Interface VpcLatticeAsyncClient

All Superinterfaces:
AutoCloseable, AwsClient, SdkAutoCloseable, SdkClient
@Generated("software.amazon.awssdk:codegen") @ThreadSafe public interface VpcLatticeAsyncClient extends AwsClient
Service client for accessing Amazon VPC Lattice asynchronously. This can be created using the static builder() method.The asynchronous client performs non-blocking I/O when configured with any SdkAsyncHttpClient supported in the SDK. However, full non-blocking is not guaranteed as the async client may perform blocking calls in some cases such as credentials retrieval and endpoint discovery as part of the async API call.

Amazon VPC Lattice is a fully managed application networking service that you use to connect, secure, and monitor all of your services across multiple accounts and virtual private clouds (VPCs). Amazon VPC Lattice interconnects your microservices and legacy services within a logical boundary, so that you can discover and manage them more efficiently. For more information, see the Amazon VPC Lattice User Guide

  • Field Details

  • Method Details

    • batchUpdateRule

      default CompletableFuture<BatchUpdateRuleResponse> batchUpdateRule(BatchUpdateRuleRequest batchUpdateRuleRequest)

      Updates the listener rules in a batch. You can use this operation to change the priority of listener rules. This can be useful when bulk updating or swapping rule priority.

      Required permissions: vpc-lattice:UpdateRule

      For more information, see How Amazon VPC Lattice works with IAM in the Amazon VPC Lattice User Guide.

      Parameters:
      batchUpdateRuleRequest -
      Returns:
      A Java Future containing the result of the BatchUpdateRule operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • batchUpdateRule

      default CompletableFuture<BatchUpdateRuleResponse> batchUpdateRule(Consumer<BatchUpdateRuleRequest.Builder> batchUpdateRuleRequest)

      Updates the listener rules in a batch. You can use this operation to change the priority of listener rules. This can be useful when bulk updating or swapping rule priority.

      Required permissions: vpc-lattice:UpdateRule

      For more information, see How Amazon VPC Lattice works with IAM in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the BatchUpdateRuleRequest.Builder avoiding the need to create one manually via BatchUpdateRuleRequest.builder()

      Parameters:
      batchUpdateRuleRequest - A Consumer that will call methods on BatchUpdateRuleRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the BatchUpdateRule operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createAccessLogSubscription

      default CompletableFuture<CreateAccessLogSubscriptionResponse> createAccessLogSubscription(CreateAccessLogSubscriptionRequest createAccessLogSubscriptionRequest)

      Enables access logs to be sent to Amazon CloudWatch, Amazon S3, and Amazon Kinesis Data Firehose. The service network owner can use the access logs to audit the services in the network. The service network owner can only see access logs from clients and services that are associated with their service network. Access log entries represent traffic originated from VPCs associated with that network. For more information, see Access logs in the Amazon VPC Lattice User Guide.

      Parameters:
      createAccessLogSubscriptionRequest -
      Returns:
      A Java Future containing the result of the CreateAccessLogSubscription operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createAccessLogSubscription

      default CompletableFuture<CreateAccessLogSubscriptionResponse> createAccessLogSubscription(Consumer<CreateAccessLogSubscriptionRequest.Builder> createAccessLogSubscriptionRequest)

      Enables access logs to be sent to Amazon CloudWatch, Amazon S3, and Amazon Kinesis Data Firehose. The service network owner can use the access logs to audit the services in the network. The service network owner can only see access logs from clients and services that are associated with their service network. Access log entries represent traffic originated from VPCs associated with that network. For more information, see Access logs in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the CreateAccessLogSubscriptionRequest.Builder avoiding the need to create one manually via CreateAccessLogSubscriptionRequest.builder()

      Parameters:
      createAccessLogSubscriptionRequest - A Consumer that will call methods on CreateAccessLogSubscriptionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateAccessLogSubscription operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createListener

      default CompletableFuture<CreateListenerResponse> createListener(CreateListenerRequest createListenerRequest)

      Creates a listener for a service. Before you start using your Amazon VPC Lattice service, you must add one or more listeners. A listener is a process that checks for connection requests to your services. For more information, see Listeners in the Amazon VPC Lattice User Guide.

      Parameters:
      createListenerRequest -
      Returns:
      A Java Future containing the result of the CreateListener operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createListener

      default CompletableFuture<CreateListenerResponse> createListener(Consumer<CreateListenerRequest.Builder> createListenerRequest)

      Creates a listener for a service. Before you start using your Amazon VPC Lattice service, you must add one or more listeners. A listener is a process that checks for connection requests to your services. For more information, see Listeners in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the CreateListenerRequest.Builder avoiding the need to create one manually via CreateListenerRequest.builder()

      Parameters:
      createListenerRequest - A Consumer that will call methods on CreateListenerRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateListener operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createRule

      default CompletableFuture<CreateRuleResponse> createRule(CreateRuleRequest createRuleRequest)

      Creates a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. For more information, see Listener rules in the Amazon VPC Lattice User Guide.

      Parameters:
      createRuleRequest -
      Returns:
      A Java Future containing the result of the CreateRule operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createRule

      default CompletableFuture<CreateRuleResponse> createRule(Consumer<CreateRuleRequest.Builder> createRuleRequest)

      Creates a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. For more information, see Listener rules in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the CreateRuleRequest.Builder avoiding the need to create one manually via CreateRuleRequest.builder()

      Parameters:
      createRuleRequest - A Consumer that will call methods on CreateRuleRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateRule operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createService

      default CompletableFuture<CreateServiceResponse> createService(CreateServiceRequest createServiceRequest)

      Creates a service. A service is any software application that can run on instances containers, or serverless functions within an account or virtual private cloud (VPC).

      For more information, see Services in the Amazon VPC Lattice User Guide.

      Parameters:
      createServiceRequest -
      Returns:
      A Java Future containing the result of the CreateService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createService

      default CompletableFuture<CreateServiceResponse> createService(Consumer<CreateServiceRequest.Builder> createServiceRequest)

      Creates a service. A service is any software application that can run on instances containers, or serverless functions within an account or virtual private cloud (VPC).

      For more information, see Services in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the CreateServiceRequest.Builder avoiding the need to create one manually via CreateServiceRequest.builder()

      Parameters:
      createServiceRequest - A Consumer that will call methods on CreateServiceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createServiceNetwork

      default CompletableFuture<CreateServiceNetworkResponse> createServiceNetwork(CreateServiceNetworkRequest createServiceNetworkRequest)

      Creates a service network. A service network is a logical boundary for a collection of services. You can associate services and VPCs with a service network.

      For more information, see Service networks in the Amazon VPC Lattice User Guide.

      Parameters:
      createServiceNetworkRequest -
      Returns:
      A Java Future containing the result of the CreateServiceNetwork operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createServiceNetwork

      default CompletableFuture<CreateServiceNetworkResponse> createServiceNetwork(Consumer<CreateServiceNetworkRequest.Builder> createServiceNetworkRequest)

      Creates a service network. A service network is a logical boundary for a collection of services. You can associate services and VPCs with a service network.

      For more information, see Service networks in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the CreateServiceNetworkRequest.Builder avoiding the need to create one manually via CreateServiceNetworkRequest.builder()

      Parameters:
      createServiceNetworkRequest - A Consumer that will call methods on CreateServiceNetworkRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateServiceNetwork operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createServiceNetworkServiceAssociation

      default CompletableFuture<CreateServiceNetworkServiceAssociationResponse> createServiceNetworkServiceAssociation(CreateServiceNetworkServiceAssociationRequest createServiceNetworkServiceAssociationRequest)

      Associates a service with a service network. For more information, see Manage service associations in the Amazon VPC Lattice User Guide.

      You can't use this operation if the service and service network are already associated or if there is a disassociation or deletion in progress. If the association fails, you can retry the operation by deleting the association and recreating it.

      You cannot associate a service and service network that are shared with a caller. The caller must own either the service or the service network.

      As a result of this operation, the association is created in the service network account and the association owner account.

      Parameters:
      createServiceNetworkServiceAssociationRequest -
      Returns:
      A Java Future containing the result of the CreateServiceNetworkServiceAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createServiceNetworkServiceAssociation

      default CompletableFuture<CreateServiceNetworkServiceAssociationResponse> createServiceNetworkServiceAssociation(Consumer<CreateServiceNetworkServiceAssociationRequest.Builder> createServiceNetworkServiceAssociationRequest)

      Associates a service with a service network. For more information, see Manage service associations in the Amazon VPC Lattice User Guide.

      You can't use this operation if the service and service network are already associated or if there is a disassociation or deletion in progress. If the association fails, you can retry the operation by deleting the association and recreating it.

      You cannot associate a service and service network that are shared with a caller. The caller must own either the service or the service network.

      As a result of this operation, the association is created in the service network account and the association owner account.


      This is a convenience which creates an instance of the CreateServiceNetworkServiceAssociationRequest.Builder avoiding the need to create one manually via CreateServiceNetworkServiceAssociationRequest.builder()

      Parameters:
      createServiceNetworkServiceAssociationRequest - A Consumer that will call methods on CreateServiceNetworkServiceAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateServiceNetworkServiceAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createServiceNetworkVpcAssociation

      default CompletableFuture<CreateServiceNetworkVpcAssociationResponse> createServiceNetworkVpcAssociation(CreateServiceNetworkVpcAssociationRequest createServiceNetworkVpcAssociationRequest)

      Associates a VPC with a service network. When you associate a VPC with the service network, it enables all the resources within that VPC to be clients and communicate with other services in the service network. For more information, see Manage VPC associations in the Amazon VPC Lattice User Guide.

      You can't use this operation if there is a disassociation in progress. If the association fails, retry by deleting the association and recreating it.

      As a result of this operation, the association gets created in the service network account and the VPC owner account.

      If you add a security group to the service network and VPC association, the association must continue to always have at least one security group. You can add or edit security groups at any time. However, to remove all security groups, you must first delete the association and recreate it without security groups.

      Parameters:
      createServiceNetworkVpcAssociationRequest -
      Returns:
      A Java Future containing the result of the CreateServiceNetworkVpcAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createServiceNetworkVpcAssociation

      default CompletableFuture<CreateServiceNetworkVpcAssociationResponse> createServiceNetworkVpcAssociation(Consumer<CreateServiceNetworkVpcAssociationRequest.Builder> createServiceNetworkVpcAssociationRequest)

      Associates a VPC with a service network. When you associate a VPC with the service network, it enables all the resources within that VPC to be clients and communicate with other services in the service network. For more information, see Manage VPC associations in the Amazon VPC Lattice User Guide.

      You can't use this operation if there is a disassociation in progress. If the association fails, retry by deleting the association and recreating it.

      As a result of this operation, the association gets created in the service network account and the VPC owner account.

      If you add a security group to the service network and VPC association, the association must continue to always have at least one security group. You can add or edit security groups at any time. However, to remove all security groups, you must first delete the association and recreate it without security groups.


      This is a convenience which creates an instance of the CreateServiceNetworkVpcAssociationRequest.Builder avoiding the need to create one manually via CreateServiceNetworkVpcAssociationRequest.builder()

      Parameters:
      createServiceNetworkVpcAssociationRequest - A Consumer that will call methods on CreateServiceNetworkVpcAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateServiceNetworkVpcAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createTargetGroup

      default CompletableFuture<CreateTargetGroupResponse> createTargetGroup(CreateTargetGroupRequest createTargetGroupRequest)

      Creates a target group. A target group is a collection of targets, or compute resources, that run your application or service. A target group can only be used by a single service.

      For more information, see Target groups in the Amazon VPC Lattice User Guide.

      Parameters:
      createTargetGroupRequest -
      Returns:
      A Java Future containing the result of the CreateTargetGroup operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • createTargetGroup

      default CompletableFuture<CreateTargetGroupResponse> createTargetGroup(Consumer<CreateTargetGroupRequest.Builder> createTargetGroupRequest)

      Creates a target group. A target group is a collection of targets, or compute resources, that run your application or service. A target group can only be used by a single service.

      For more information, see Target groups in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the CreateTargetGroupRequest.Builder avoiding the need to create one manually via CreateTargetGroupRequest.builder()

      Parameters:
      createTargetGroupRequest - A Consumer that will call methods on CreateTargetGroupRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the CreateTargetGroup operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteAccessLogSubscription

      default CompletableFuture<DeleteAccessLogSubscriptionResponse> deleteAccessLogSubscription(DeleteAccessLogSubscriptionRequest deleteAccessLogSubscriptionRequest)

      Deletes the specified access log subscription.

      Parameters:
      deleteAccessLogSubscriptionRequest -
      Returns:
      A Java Future containing the result of the DeleteAccessLogSubscription operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteAccessLogSubscription

      default CompletableFuture<DeleteAccessLogSubscriptionResponse> deleteAccessLogSubscription(Consumer<DeleteAccessLogSubscriptionRequest.Builder> deleteAccessLogSubscriptionRequest)

      Deletes the specified access log subscription.


      This is a convenience which creates an instance of the DeleteAccessLogSubscriptionRequest.Builder avoiding the need to create one manually via DeleteAccessLogSubscriptionRequest.builder()

      Parameters:
      deleteAccessLogSubscriptionRequest - A Consumer that will call methods on DeleteAccessLogSubscriptionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteAccessLogSubscription operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteAuthPolicy

      default CompletableFuture<DeleteAuthPolicyResponse> deleteAuthPolicy(DeleteAuthPolicyRequest deleteAuthPolicyRequest)

      Deletes the specified auth policy. If an auth is set to AWS_IAM and the auth policy is deleted, all requests are denied. If you are trying to remove the auth policy completely, you must set the auth type to NONE. If auth is enabled on the resource, but no auth policy is set, all requests are denied.

      Parameters:
      deleteAuthPolicyRequest -
      Returns:
      A Java Future containing the result of the DeleteAuthPolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteAuthPolicy

      default CompletableFuture<DeleteAuthPolicyResponse> deleteAuthPolicy(Consumer<DeleteAuthPolicyRequest.Builder> deleteAuthPolicyRequest)

      Deletes the specified auth policy. If an auth is set to AWS_IAM and the auth policy is deleted, all requests are denied. If you are trying to remove the auth policy completely, you must set the auth type to NONE. If auth is enabled on the resource, but no auth policy is set, all requests are denied.


      This is a convenience which creates an instance of the DeleteAuthPolicyRequest.Builder avoiding the need to create one manually via DeleteAuthPolicyRequest.builder()

      Parameters:
      deleteAuthPolicyRequest - A Consumer that will call methods on DeleteAuthPolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteAuthPolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteListener

      default CompletableFuture<DeleteListenerResponse> deleteListener(DeleteListenerRequest deleteListenerRequest)

      Deletes the specified listener.

      Parameters:
      deleteListenerRequest -
      Returns:
      A Java Future containing the result of the DeleteListener operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteListener

      default CompletableFuture<DeleteListenerResponse> deleteListener(Consumer<DeleteListenerRequest.Builder> deleteListenerRequest)

      Deletes the specified listener.


      This is a convenience which creates an instance of the DeleteListenerRequest.Builder avoiding the need to create one manually via DeleteListenerRequest.builder()

      Parameters:
      deleteListenerRequest - A Consumer that will call methods on DeleteListenerRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteListener operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteResourcePolicy

      default CompletableFuture<DeleteResourcePolicyResponse> deleteResourcePolicy(DeleteResourcePolicyRequest deleteResourcePolicyRequest)

      Deletes the specified resource policy.

      Parameters:
      deleteResourcePolicyRequest -
      Returns:
      A Java Future containing the result of the DeleteResourcePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteResourcePolicy

      default CompletableFuture<DeleteResourcePolicyResponse> deleteResourcePolicy(Consumer<DeleteResourcePolicyRequest.Builder> deleteResourcePolicyRequest)

      Deletes the specified resource policy.


      This is a convenience which creates an instance of the DeleteResourcePolicyRequest.Builder avoiding the need to create one manually via DeleteResourcePolicyRequest.builder()

      Parameters:
      deleteResourcePolicyRequest - A Consumer that will call methods on DeleteResourcePolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteResourcePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteRule

      default CompletableFuture<DeleteRuleResponse> deleteRule(DeleteRuleRequest deleteRuleRequest)

      Deletes a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. You can delete additional listener rules, but you cannot delete the default rule.

      For more information, see Listener rules in the Amazon VPC Lattice User Guide.

      Parameters:
      deleteRuleRequest -
      Returns:
      A Java Future containing the result of the DeleteRule operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteRule

      default CompletableFuture<DeleteRuleResponse> deleteRule(Consumer<DeleteRuleRequest.Builder> deleteRuleRequest)

      Deletes a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. You can delete additional listener rules, but you cannot delete the default rule.

      For more information, see Listener rules in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the DeleteRuleRequest.Builder avoiding the need to create one manually via DeleteRuleRequest.builder()

      Parameters:
      deleteRuleRequest - A Consumer that will call methods on DeleteRuleRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteRule operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteService

      default CompletableFuture<DeleteServiceResponse> deleteService(DeleteServiceRequest deleteServiceRequest)

      Deletes a service. A service can't be deleted if it's associated with a service network. If you delete a service, all resources related to the service, such as the resource policy, auth policy, listeners, listener rules, and access log subscriptions, are also deleted. For more information, see Delete a service in the Amazon VPC Lattice User Guide.

      Parameters:
      deleteServiceRequest -
      Returns:
      A Java Future containing the result of the DeleteService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteService

      default CompletableFuture<DeleteServiceResponse> deleteService(Consumer<DeleteServiceRequest.Builder> deleteServiceRequest)

      Deletes a service. A service can't be deleted if it's associated with a service network. If you delete a service, all resources related to the service, such as the resource policy, auth policy, listeners, listener rules, and access log subscriptions, are also deleted. For more information, see Delete a service in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the DeleteServiceRequest.Builder avoiding the need to create one manually via DeleteServiceRequest.builder()

      Parameters:
      deleteServiceRequest - A Consumer that will call methods on DeleteServiceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteServiceNetwork

      default CompletableFuture<DeleteServiceNetworkResponse> deleteServiceNetwork(DeleteServiceNetworkRequest deleteServiceNetworkRequest)

      Deletes a service network. You can only delete the service network if there is no service or VPC associated with it. If you delete a service network, all resources related to the service network, such as the resource policy, auth policy, and access log subscriptions, are also deleted. For more information, see Delete a service network in the Amazon VPC Lattice User Guide.

      Parameters:
      deleteServiceNetworkRequest -
      Returns:
      A Java Future containing the result of the DeleteServiceNetwork operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteServiceNetwork

      default CompletableFuture<DeleteServiceNetworkResponse> deleteServiceNetwork(Consumer<DeleteServiceNetworkRequest.Builder> deleteServiceNetworkRequest)

      Deletes a service network. You can only delete the service network if there is no service or VPC associated with it. If you delete a service network, all resources related to the service network, such as the resource policy, auth policy, and access log subscriptions, are also deleted. For more information, see Delete a service network in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the DeleteServiceNetworkRequest.Builder avoiding the need to create one manually via DeleteServiceNetworkRequest.builder()

      Parameters:
      deleteServiceNetworkRequest - A Consumer that will call methods on DeleteServiceNetworkRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteServiceNetwork operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteServiceNetworkServiceAssociation

      default CompletableFuture<DeleteServiceNetworkServiceAssociationResponse> deleteServiceNetworkServiceAssociation(DeleteServiceNetworkServiceAssociationRequest deleteServiceNetworkServiceAssociationRequest)

      Deletes the association between a specified service and the specific service network. This operation fails if an association is still in progress.

      Parameters:
      deleteServiceNetworkServiceAssociationRequest -
      Returns:
      A Java Future containing the result of the DeleteServiceNetworkServiceAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteServiceNetworkServiceAssociation

      default CompletableFuture<DeleteServiceNetworkServiceAssociationResponse> deleteServiceNetworkServiceAssociation(Consumer<DeleteServiceNetworkServiceAssociationRequest.Builder> deleteServiceNetworkServiceAssociationRequest)

      Deletes the association between a specified service and the specific service network. This operation fails if an association is still in progress.


      This is a convenience which creates an instance of the DeleteServiceNetworkServiceAssociationRequest.Builder avoiding the need to create one manually via DeleteServiceNetworkServiceAssociationRequest.builder()

      Parameters:
      deleteServiceNetworkServiceAssociationRequest - A Consumer that will call methods on DeleteServiceNetworkServiceAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteServiceNetworkServiceAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteServiceNetworkVpcAssociation

      default CompletableFuture<DeleteServiceNetworkVpcAssociationResponse> deleteServiceNetworkVpcAssociation(DeleteServiceNetworkVpcAssociationRequest deleteServiceNetworkVpcAssociationRequest)

      Disassociates the VPC from the service network. You can't disassociate the VPC if there is a create or update association in progress.

      Parameters:
      deleteServiceNetworkVpcAssociationRequest -
      Returns:
      A Java Future containing the result of the DeleteServiceNetworkVpcAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteServiceNetworkVpcAssociation

      default CompletableFuture<DeleteServiceNetworkVpcAssociationResponse> deleteServiceNetworkVpcAssociation(Consumer<DeleteServiceNetworkVpcAssociationRequest.Builder> deleteServiceNetworkVpcAssociationRequest)

      Disassociates the VPC from the service network. You can't disassociate the VPC if there is a create or update association in progress.


      This is a convenience which creates an instance of the DeleteServiceNetworkVpcAssociationRequest.Builder avoiding the need to create one manually via DeleteServiceNetworkVpcAssociationRequest.builder()

      Parameters:
      deleteServiceNetworkVpcAssociationRequest - A Consumer that will call methods on DeleteServiceNetworkVpcAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteServiceNetworkVpcAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteTargetGroup

      default CompletableFuture<DeleteTargetGroupResponse> deleteTargetGroup(DeleteTargetGroupRequest deleteTargetGroupRequest)

      Deletes a target group. You can't delete a target group if it is used in a listener rule or if the target group creation is in progress.

      Parameters:
      deleteTargetGroupRequest -
      Returns:
      A Java Future containing the result of the DeleteTargetGroup operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deleteTargetGroup

      default CompletableFuture<DeleteTargetGroupResponse> deleteTargetGroup(Consumer<DeleteTargetGroupRequest.Builder> deleteTargetGroupRequest)

      Deletes a target group. You can't delete a target group if it is used in a listener rule or if the target group creation is in progress.


      This is a convenience which creates an instance of the DeleteTargetGroupRequest.Builder avoiding the need to create one manually via DeleteTargetGroupRequest.builder()

      Parameters:
      deleteTargetGroupRequest - A Consumer that will call methods on DeleteTargetGroupRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeleteTargetGroup operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deregisterTargets

      default CompletableFuture<DeregisterTargetsResponse> deregisterTargets(DeregisterTargetsRequest deregisterTargetsRequest)

      Deregisters the specified targets from the specified target group.

      Parameters:
      deregisterTargetsRequest -
      Returns:
      A Java Future containing the result of the DeregisterTargets operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • deregisterTargets

      default CompletableFuture<DeregisterTargetsResponse> deregisterTargets(Consumer<DeregisterTargetsRequest.Builder> deregisterTargetsRequest)

      Deregisters the specified targets from the specified target group.


      This is a convenience which creates an instance of the DeregisterTargetsRequest.Builder avoiding the need to create one manually via DeregisterTargetsRequest.builder()

      Parameters:
      deregisterTargetsRequest - A Consumer that will call methods on DeregisterTargetsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the DeregisterTargets operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getAccessLogSubscription

      default CompletableFuture<GetAccessLogSubscriptionResponse> getAccessLogSubscription(GetAccessLogSubscriptionRequest getAccessLogSubscriptionRequest)

      Retrieves information about the specified access log subscription.

      Parameters:
      getAccessLogSubscriptionRequest -
      Returns:
      A Java Future containing the result of the GetAccessLogSubscription operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getAccessLogSubscription

      default CompletableFuture<GetAccessLogSubscriptionResponse> getAccessLogSubscription(Consumer<GetAccessLogSubscriptionRequest.Builder> getAccessLogSubscriptionRequest)

      Retrieves information about the specified access log subscription.


      This is a convenience which creates an instance of the GetAccessLogSubscriptionRequest.Builder avoiding the need to create one manually via GetAccessLogSubscriptionRequest.builder()

      Parameters:
      getAccessLogSubscriptionRequest - A Consumer that will call methods on GetAccessLogSubscriptionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetAccessLogSubscription operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getAuthPolicy

      default CompletableFuture<GetAuthPolicyResponse> getAuthPolicy(GetAuthPolicyRequest getAuthPolicyRequest)

      Retrieves information about the auth policy for the specified service or service network.

      Parameters:
      getAuthPolicyRequest -
      Returns:
      A Java Future containing the result of the GetAuthPolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getAuthPolicy

      default CompletableFuture<GetAuthPolicyResponse> getAuthPolicy(Consumer<GetAuthPolicyRequest.Builder> getAuthPolicyRequest)

      Retrieves information about the auth policy for the specified service or service network.


      This is a convenience which creates an instance of the GetAuthPolicyRequest.Builder avoiding the need to create one manually via GetAuthPolicyRequest.builder()

      Parameters:
      getAuthPolicyRequest - A Consumer that will call methods on GetAuthPolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetAuthPolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getListener

      default CompletableFuture<GetListenerResponse> getListener(GetListenerRequest getListenerRequest)

      Retrieves information about the specified listener for the specified service.

      Parameters:
      getListenerRequest -
      Returns:
      A Java Future containing the result of the GetListener operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getListener

      default CompletableFuture<GetListenerResponse> getListener(Consumer<GetListenerRequest.Builder> getListenerRequest)

      Retrieves information about the specified listener for the specified service.


      This is a convenience which creates an instance of the GetListenerRequest.Builder avoiding the need to create one manually via GetListenerRequest.builder()

      Parameters:
      getListenerRequest - A Consumer that will call methods on GetListenerRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetListener operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getResourcePolicy

      default CompletableFuture<GetResourcePolicyResponse> getResourcePolicy(GetResourcePolicyRequest getResourcePolicyRequest)

      Retrieves information about the resource policy. The resource policy is an IAM policy created on behalf of the resource owner when they share a resource.

      Parameters:
      getResourcePolicyRequest -
      Returns:
      A Java Future containing the result of the GetResourcePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getResourcePolicy

      default CompletableFuture<GetResourcePolicyResponse> getResourcePolicy(Consumer<GetResourcePolicyRequest.Builder> getResourcePolicyRequest)

      Retrieves information about the resource policy. The resource policy is an IAM policy created on behalf of the resource owner when they share a resource.


      This is a convenience which creates an instance of the GetResourcePolicyRequest.Builder avoiding the need to create one manually via GetResourcePolicyRequest.builder()

      Parameters:
      getResourcePolicyRequest - A Consumer that will call methods on GetResourcePolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetResourcePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getRule

      default CompletableFuture<GetRuleResponse> getRule(GetRuleRequest getRuleRequest)

      Retrieves information about listener rules. You can also retrieve information about the default listener rule. For more information, see Listener rules in the Amazon VPC Lattice User Guide.

      Parameters:
      getRuleRequest -
      Returns:
      A Java Future containing the result of the GetRule operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getRule

      default CompletableFuture<GetRuleResponse> getRule(Consumer<GetRuleRequest.Builder> getRuleRequest)

      Retrieves information about listener rules. You can also retrieve information about the default listener rule. For more information, see Listener rules in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the GetRuleRequest.Builder avoiding the need to create one manually via GetRuleRequest.builder()

      Parameters:
      getRuleRequest - A Consumer that will call methods on GetRuleRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetRule operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getService

      default CompletableFuture<GetServiceResponse> getService(GetServiceRequest getServiceRequest)

      Retrieves information about the specified service.

      Parameters:
      getServiceRequest -
      Returns:
      A Java Future containing the result of the GetService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getService

      default CompletableFuture<GetServiceResponse> getService(Consumer<GetServiceRequest.Builder> getServiceRequest)

      Retrieves information about the specified service.


      This is a convenience which creates an instance of the GetServiceRequest.Builder avoiding the need to create one manually via GetServiceRequest.builder()

      Parameters:
      getServiceRequest - A Consumer that will call methods on GetServiceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getServiceNetwork

      default CompletableFuture<GetServiceNetworkResponse> getServiceNetwork(GetServiceNetworkRequest getServiceNetworkRequest)

      Retrieves information about the specified service network.

      Parameters:
      getServiceNetworkRequest -
      Returns:
      A Java Future containing the result of the GetServiceNetwork operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getServiceNetwork

      default CompletableFuture<GetServiceNetworkResponse> getServiceNetwork(Consumer<GetServiceNetworkRequest.Builder> getServiceNetworkRequest)

      Retrieves information about the specified service network.


      This is a convenience which creates an instance of the GetServiceNetworkRequest.Builder avoiding the need to create one manually via GetServiceNetworkRequest.builder()

      Parameters:
      getServiceNetworkRequest - A Consumer that will call methods on GetServiceNetworkRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetServiceNetwork operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getServiceNetworkServiceAssociation

      default CompletableFuture<GetServiceNetworkServiceAssociationResponse> getServiceNetworkServiceAssociation(GetServiceNetworkServiceAssociationRequest getServiceNetworkServiceAssociationRequest)

      Retrieves information about the specified association between a service network and a service.

      Parameters:
      getServiceNetworkServiceAssociationRequest -
      Returns:
      A Java Future containing the result of the GetServiceNetworkServiceAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getServiceNetworkServiceAssociation

      default CompletableFuture<GetServiceNetworkServiceAssociationResponse> getServiceNetworkServiceAssociation(Consumer<GetServiceNetworkServiceAssociationRequest.Builder> getServiceNetworkServiceAssociationRequest)

      Retrieves information about the specified association between a service network and a service.


      This is a convenience which creates an instance of the GetServiceNetworkServiceAssociationRequest.Builder avoiding the need to create one manually via GetServiceNetworkServiceAssociationRequest.builder()

      Parameters:
      getServiceNetworkServiceAssociationRequest - A Consumer that will call methods on GetServiceNetworkServiceAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetServiceNetworkServiceAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getServiceNetworkVpcAssociation

      default CompletableFuture<GetServiceNetworkVpcAssociationResponse> getServiceNetworkVpcAssociation(GetServiceNetworkVpcAssociationRequest getServiceNetworkVpcAssociationRequest)

      Retrieves information about the association between a service network and a VPC.

      Parameters:
      getServiceNetworkVpcAssociationRequest -
      Returns:
      A Java Future containing the result of the GetServiceNetworkVpcAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getServiceNetworkVpcAssociation

      default CompletableFuture<GetServiceNetworkVpcAssociationResponse> getServiceNetworkVpcAssociation(Consumer<GetServiceNetworkVpcAssociationRequest.Builder> getServiceNetworkVpcAssociationRequest)

      Retrieves information about the association between a service network and a VPC.


      This is a convenience which creates an instance of the GetServiceNetworkVpcAssociationRequest.Builder avoiding the need to create one manually via GetServiceNetworkVpcAssociationRequest.builder()

      Parameters:
      getServiceNetworkVpcAssociationRequest - A Consumer that will call methods on GetServiceNetworkVpcAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetServiceNetworkVpcAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTargetGroup

      default CompletableFuture<GetTargetGroupResponse> getTargetGroup(GetTargetGroupRequest getTargetGroupRequest)

      Retrieves information about the specified target group.

      Parameters:
      getTargetGroupRequest -
      Returns:
      A Java Future containing the result of the GetTargetGroup operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • getTargetGroup

      default CompletableFuture<GetTargetGroupResponse> getTargetGroup(Consumer<GetTargetGroupRequest.Builder> getTargetGroupRequest)

      Retrieves information about the specified target group.


      This is a convenience which creates an instance of the GetTargetGroupRequest.Builder avoiding the need to create one manually via GetTargetGroupRequest.builder()

      Parameters:
      getTargetGroupRequest - A Consumer that will call methods on GetTargetGroupRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the GetTargetGroup operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listAccessLogSubscriptions

      default CompletableFuture<ListAccessLogSubscriptionsResponse> listAccessLogSubscriptions(ListAccessLogSubscriptionsRequest listAccessLogSubscriptionsRequest)

      Lists all access log subscriptions for the specified service network or service.

      Parameters:
      listAccessLogSubscriptionsRequest -
      Returns:
      A Java Future containing the result of the ListAccessLogSubscriptions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listAccessLogSubscriptions

      default CompletableFuture<ListAccessLogSubscriptionsResponse> listAccessLogSubscriptions(Consumer<ListAccessLogSubscriptionsRequest.Builder> listAccessLogSubscriptionsRequest)

      Lists all access log subscriptions for the specified service network or service.


      This is a convenience which creates an instance of the ListAccessLogSubscriptionsRequest.Builder avoiding the need to create one manually via ListAccessLogSubscriptionsRequest.builder()

      Parameters:
      listAccessLogSubscriptionsRequest - A Consumer that will call methods on ListAccessLogSubscriptionsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListAccessLogSubscriptions operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listAccessLogSubscriptionsPaginator

      default ListAccessLogSubscriptionsPublisher listAccessLogSubscriptionsPaginator(ListAccessLogSubscriptionsRequest listAccessLogSubscriptionsRequest)

      This is a variant of listAccessLogSubscriptions(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListAccessLogSubscriptionsPublisher publisher = client.listAccessLogSubscriptionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListAccessLogSubscriptionsPublisher publisher = client.listAccessLogSubscriptionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listAccessLogSubscriptions(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsRequest) operation.

      Parameters:
      listAccessLogSubscriptionsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listAccessLogSubscriptionsPaginator

      default ListAccessLogSubscriptionsPublisher listAccessLogSubscriptionsPaginator(Consumer<ListAccessLogSubscriptionsRequest.Builder> listAccessLogSubscriptionsRequest)

      This is a variant of listAccessLogSubscriptions(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListAccessLogSubscriptionsPublisher publisher = client.listAccessLogSubscriptionsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListAccessLogSubscriptionsPublisher publisher = client.listAccessLogSubscriptionsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listAccessLogSubscriptions(software.amazon.awssdk.services.vpclattice.model.ListAccessLogSubscriptionsRequest) operation.


      This is a convenience which creates an instance of the ListAccessLogSubscriptionsRequest.Builder avoiding the need to create one manually via ListAccessLogSubscriptionsRequest.builder()

      Parameters:
      listAccessLogSubscriptionsRequest - A Consumer that will call methods on ListAccessLogSubscriptionsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listListeners

      default CompletableFuture<ListListenersResponse> listListeners(ListListenersRequest listListenersRequest)

      Lists the listeners for the specified service.

      Parameters:
      listListenersRequest -
      Returns:
      A Java Future containing the result of the ListListeners operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listListeners

      default CompletableFuture<ListListenersResponse> listListeners(Consumer<ListListenersRequest.Builder> listListenersRequest)

      Lists the listeners for the specified service.


      This is a convenience which creates an instance of the ListListenersRequest.Builder avoiding the need to create one manually via ListListenersRequest.builder()

      Parameters:
      listListenersRequest - A Consumer that will call methods on ListListenersRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListListeners operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listListenersPaginator

      default ListListenersPublisher listListenersPaginator(ListListenersRequest listListenersRequest)

      This is a variant of listListeners(software.amazon.awssdk.services.vpclattice.model.ListListenersRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListListenersPublisher publisher = client.listListenersPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListListenersPublisher publisher = client.listListenersPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListListenersResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListListenersResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listListeners(software.amazon.awssdk.services.vpclattice.model.ListListenersRequest) operation.

      Parameters:
      listListenersRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listListenersPaginator

      default ListListenersPublisher listListenersPaginator(Consumer<ListListenersRequest.Builder> listListenersRequest)

      This is a variant of listListeners(software.amazon.awssdk.services.vpclattice.model.ListListenersRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListListenersPublisher publisher = client.listListenersPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListListenersPublisher publisher = client.listListenersPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListListenersResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListListenersResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listListeners(software.amazon.awssdk.services.vpclattice.model.ListListenersRequest) operation.


      This is a convenience which creates an instance of the ListListenersRequest.Builder avoiding the need to create one manually via ListListenersRequest.builder()

      Parameters:
      listListenersRequest - A Consumer that will call methods on ListListenersRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listRules

      default CompletableFuture<ListRulesResponse> listRules(ListRulesRequest listRulesRequest)

      Lists the rules for the listener.

      Parameters:
      listRulesRequest -
      Returns:
      A Java Future containing the result of the ListRules operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listRules

      default CompletableFuture<ListRulesResponse> listRules(Consumer<ListRulesRequest.Builder> listRulesRequest)

      Lists the rules for the listener.


      This is a convenience which creates an instance of the ListRulesRequest.Builder avoiding the need to create one manually via ListRulesRequest.builder()

      Parameters:
      listRulesRequest - A Consumer that will call methods on ListRulesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListRules operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listRulesPaginator

      default ListRulesPublisher listRulesPaginator(ListRulesRequest listRulesRequest)

      This is a variant of listRules(software.amazon.awssdk.services.vpclattice.model.ListRulesRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListRulesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListRulesResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listRules(software.amazon.awssdk.services.vpclattice.model.ListRulesRequest) operation.

      Parameters:
      listRulesRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listRulesPaginator

      default ListRulesPublisher listRulesPaginator(Consumer<ListRulesRequest.Builder> listRulesRequest)

      This is a variant of listRules(software.amazon.awssdk.services.vpclattice.model.ListRulesRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListRulesPublisher publisher = client.listRulesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListRulesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListRulesResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listRules(software.amazon.awssdk.services.vpclattice.model.ListRulesRequest) operation.


      This is a convenience which creates an instance of the ListRulesRequest.Builder avoiding the need to create one manually via ListRulesRequest.builder()

      Parameters:
      listRulesRequest - A Consumer that will call methods on ListRulesRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworkServiceAssociations

      default CompletableFuture<ListServiceNetworkServiceAssociationsResponse> listServiceNetworkServiceAssociations(ListServiceNetworkServiceAssociationsRequest listServiceNetworkServiceAssociationsRequest)

      Lists the associations between the service network and the service. You can filter the list either by service or service network. You must provide either the service network identifier or the service identifier.

      Every association in Amazon VPC Lattice is given a unique Amazon Resource Name (ARN), such as when a service network is associated with a VPC or when a service is associated with a service network. If the association is for a resource that is shared with another account, the association includes the local account ID as the prefix in the ARN for each account the resource is shared with.

      Parameters:
      listServiceNetworkServiceAssociationsRequest -
      Returns:
      A Java Future containing the result of the ListServiceNetworkServiceAssociations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworkServiceAssociations

      default CompletableFuture<ListServiceNetworkServiceAssociationsResponse> listServiceNetworkServiceAssociations(Consumer<ListServiceNetworkServiceAssociationsRequest.Builder> listServiceNetworkServiceAssociationsRequest)

      Lists the associations between the service network and the service. You can filter the list either by service or service network. You must provide either the service network identifier or the service identifier.

      Every association in Amazon VPC Lattice is given a unique Amazon Resource Name (ARN), such as when a service network is associated with a VPC or when a service is associated with a service network. If the association is for a resource that is shared with another account, the association includes the local account ID as the prefix in the ARN for each account the resource is shared with.


      This is a convenience which creates an instance of the ListServiceNetworkServiceAssociationsRequest.Builder avoiding the need to create one manually via ListServiceNetworkServiceAssociationsRequest.builder()

      Parameters:
      listServiceNetworkServiceAssociationsRequest - A Consumer that will call methods on ListServiceNetworkServiceAssociationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListServiceNetworkServiceAssociations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworkServiceAssociationsPaginator

      default ListServiceNetworkServiceAssociationsPublisher listServiceNetworkServiceAssociationsPaginator(ListServiceNetworkServiceAssociationsRequest listServiceNetworkServiceAssociationsRequest)

      This is a variant of listServiceNetworkServiceAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkServiceAssociationsPublisher publisher = client.listServiceNetworkServiceAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkServiceAssociationsPublisher publisher = client.listServiceNetworkServiceAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listServiceNetworkServiceAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsRequest) operation.

      Parameters:
      listServiceNetworkServiceAssociationsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworkServiceAssociationsPaginator

      default ListServiceNetworkServiceAssociationsPublisher listServiceNetworkServiceAssociationsPaginator(Consumer<ListServiceNetworkServiceAssociationsRequest.Builder> listServiceNetworkServiceAssociationsRequest)

      This is a variant of listServiceNetworkServiceAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkServiceAssociationsPublisher publisher = client.listServiceNetworkServiceAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkServiceAssociationsPublisher publisher = client.listServiceNetworkServiceAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listServiceNetworkServiceAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkServiceAssociationsRequest) operation.


      This is a convenience which creates an instance of the ListServiceNetworkServiceAssociationsRequest.Builder avoiding the need to create one manually via ListServiceNetworkServiceAssociationsRequest.builder()

      Parameters:
      listServiceNetworkServiceAssociationsRequest - A Consumer that will call methods on ListServiceNetworkServiceAssociationsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworkVpcAssociations

      default CompletableFuture<ListServiceNetworkVpcAssociationsResponse> listServiceNetworkVpcAssociations(ListServiceNetworkVpcAssociationsRequest listServiceNetworkVpcAssociationsRequest)

      Lists the service network and VPC associations. You can filter the list either by VPC or service network. You must provide either the service network identifier or the VPC identifier.

      Parameters:
      listServiceNetworkVpcAssociationsRequest -
      Returns:
      A Java Future containing the result of the ListServiceNetworkVpcAssociations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworkVpcAssociations

      default CompletableFuture<ListServiceNetworkVpcAssociationsResponse> listServiceNetworkVpcAssociations(Consumer<ListServiceNetworkVpcAssociationsRequest.Builder> listServiceNetworkVpcAssociationsRequest)

      Lists the service network and VPC associations. You can filter the list either by VPC or service network. You must provide either the service network identifier or the VPC identifier.


      This is a convenience which creates an instance of the ListServiceNetworkVpcAssociationsRequest.Builder avoiding the need to create one manually via ListServiceNetworkVpcAssociationsRequest.builder()

      Parameters:
      listServiceNetworkVpcAssociationsRequest - A Consumer that will call methods on ListServiceNetworkVpcAssociationsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListServiceNetworkVpcAssociations operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworkVpcAssociationsPaginator

      default ListServiceNetworkVpcAssociationsPublisher listServiceNetworkVpcAssociationsPaginator(ListServiceNetworkVpcAssociationsRequest listServiceNetworkVpcAssociationsRequest)

      This is a variant of listServiceNetworkVpcAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkVpcAssociationsPublisher publisher = client.listServiceNetworkVpcAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkVpcAssociationsPublisher publisher = client.listServiceNetworkVpcAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listServiceNetworkVpcAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsRequest) operation.

      Parameters:
      listServiceNetworkVpcAssociationsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworkVpcAssociationsPaginator

      default ListServiceNetworkVpcAssociationsPublisher listServiceNetworkVpcAssociationsPaginator(Consumer<ListServiceNetworkVpcAssociationsRequest.Builder> listServiceNetworkVpcAssociationsRequest)

      This is a variant of listServiceNetworkVpcAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkVpcAssociationsPublisher publisher = client.listServiceNetworkVpcAssociationsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworkVpcAssociationsPublisher publisher = client.listServiceNetworkVpcAssociationsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listServiceNetworkVpcAssociations(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworkVpcAssociationsRequest) operation.


      This is a convenience which creates an instance of the ListServiceNetworkVpcAssociationsRequest.Builder avoiding the need to create one manually via ListServiceNetworkVpcAssociationsRequest.builder()

      Parameters:
      listServiceNetworkVpcAssociationsRequest - A Consumer that will call methods on ListServiceNetworkVpcAssociationsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworks

      default CompletableFuture<ListServiceNetworksResponse> listServiceNetworks(ListServiceNetworksRequest listServiceNetworksRequest)

      Lists the service networks owned by the caller account or shared with the caller account. Also includes the account ID in the ARN to show which account owns the service network.

      Parameters:
      listServiceNetworksRequest -
      Returns:
      A Java Future containing the result of the ListServiceNetworks operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworks

      default CompletableFuture<ListServiceNetworksResponse> listServiceNetworks(Consumer<ListServiceNetworksRequest.Builder> listServiceNetworksRequest)

      Lists the service networks owned by the caller account or shared with the caller account. Also includes the account ID in the ARN to show which account owns the service network.


      This is a convenience which creates an instance of the ListServiceNetworksRequest.Builder avoiding the need to create one manually via ListServiceNetworksRequest.builder()

      Parameters:
      listServiceNetworksRequest - A Consumer that will call methods on ListServiceNetworksRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListServiceNetworks operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworksPaginator

      default ListServiceNetworksPublisher listServiceNetworksPaginator(ListServiceNetworksRequest listServiceNetworksRequest)

      This is a variant of listServiceNetworks(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworksPublisher publisher = client.listServiceNetworksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworksPublisher publisher = client.listServiceNetworksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listServiceNetworks(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksRequest) operation.

      Parameters:
      listServiceNetworksRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServiceNetworksPaginator

      default ListServiceNetworksPublisher listServiceNetworksPaginator(Consumer<ListServiceNetworksRequest.Builder> listServiceNetworksRequest)

      This is a variant of listServiceNetworks(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworksPublisher publisher = client.listServiceNetworksPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServiceNetworksPublisher publisher = client.listServiceNetworksPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listServiceNetworks(software.amazon.awssdk.services.vpclattice.model.ListServiceNetworksRequest) operation.


      This is a convenience which creates an instance of the ListServiceNetworksRequest.Builder avoiding the need to create one manually via ListServiceNetworksRequest.builder()

      Parameters:
      listServiceNetworksRequest - A Consumer that will call methods on ListServiceNetworksRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServices

      default CompletableFuture<ListServicesResponse> listServices(ListServicesRequest listServicesRequest)

      Lists the services owned by the caller account or shared with the caller account.

      Parameters:
      listServicesRequest -
      Returns:
      A Java Future containing the result of the ListServices operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServices

      default CompletableFuture<ListServicesResponse> listServices(Consumer<ListServicesRequest.Builder> listServicesRequest)

      Lists the services owned by the caller account or shared with the caller account.


      This is a convenience which creates an instance of the ListServicesRequest.Builder avoiding the need to create one manually via ListServicesRequest.builder()

      Parameters:
      listServicesRequest - A Consumer that will call methods on ListServicesRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListServices operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServicesPaginator

      default ListServicesPublisher listServicesPaginator(ListServicesRequest listServicesRequest)

      This is a variant of listServices(software.amazon.awssdk.services.vpclattice.model.ListServicesRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServicesPublisher publisher = client.listServicesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServicesPublisher publisher = client.listServicesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServicesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServicesResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listServices(software.amazon.awssdk.services.vpclattice.model.ListServicesRequest) operation.

      Parameters:
      listServicesRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listServicesPaginator

      default ListServicesPublisher listServicesPaginator(Consumer<ListServicesRequest.Builder> listServicesRequest)

      This is a variant of listServices(software.amazon.awssdk.services.vpclattice.model.ListServicesRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServicesPublisher publisher = client.listServicesPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListServicesPublisher publisher = client.listServicesPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListServicesResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListServicesResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listServices(software.amazon.awssdk.services.vpclattice.model.ListServicesRequest) operation.


      This is a convenience which creates an instance of the ListServicesRequest.Builder avoiding the need to create one manually via ListServicesRequest.builder()

      Parameters:
      listServicesRequest - A Consumer that will call methods on ListServicesRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTagsForResource

      default CompletableFuture<ListTagsForResourceResponse> listTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest)

      Lists the tags for the specified resource.

      Parameters:
      listTagsForResourceRequest -
      Returns:
      A Java Future containing the result of the ListTagsForResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTagsForResource

      default CompletableFuture<ListTagsForResourceResponse> listTagsForResource(Consumer<ListTagsForResourceRequest.Builder> listTagsForResourceRequest)

      Lists the tags for the specified resource.


      This is a convenience which creates an instance of the ListTagsForResourceRequest.Builder avoiding the need to create one manually via ListTagsForResourceRequest.builder()

      Parameters:
      listTagsForResourceRequest - A Consumer that will call methods on ListTagsForResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTagsForResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTargetGroups

      default CompletableFuture<ListTargetGroupsResponse> listTargetGroups(ListTargetGroupsRequest listTargetGroupsRequest)

      Lists your target groups. You can narrow your search by using the filters below in your request.

      Parameters:
      listTargetGroupsRequest -
      Returns:
      A Java Future containing the result of the ListTargetGroups operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTargetGroups

      default CompletableFuture<ListTargetGroupsResponse> listTargetGroups(Consumer<ListTargetGroupsRequest.Builder> listTargetGroupsRequest)

      Lists your target groups. You can narrow your search by using the filters below in your request.


      This is a convenience which creates an instance of the ListTargetGroupsRequest.Builder avoiding the need to create one manually via ListTargetGroupsRequest.builder()

      Parameters:
      listTargetGroupsRequest - A Consumer that will call methods on ListTargetGroupsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTargetGroups operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTargetGroupsPaginator

      default ListTargetGroupsPublisher listTargetGroupsPaginator(ListTargetGroupsRequest listTargetGroupsRequest)

      This is a variant of listTargetGroups(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetGroupsPublisher publisher = client.listTargetGroupsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetGroupsPublisher publisher = client.listTargetGroupsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listTargetGroups(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsRequest) operation.

      Parameters:
      listTargetGroupsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTargetGroupsPaginator

      default ListTargetGroupsPublisher listTargetGroupsPaginator(Consumer<ListTargetGroupsRequest.Builder> listTargetGroupsRequest)

      This is a variant of listTargetGroups(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetGroupsPublisher publisher = client.listTargetGroupsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetGroupsPublisher publisher = client.listTargetGroupsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listTargetGroups(software.amazon.awssdk.services.vpclattice.model.ListTargetGroupsRequest) operation.


      This is a convenience which creates an instance of the ListTargetGroupsRequest.Builder avoiding the need to create one manually via ListTargetGroupsRequest.builder()

      Parameters:
      listTargetGroupsRequest - A Consumer that will call methods on ListTargetGroupsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTargets

      default CompletableFuture<ListTargetsResponse> listTargets(ListTargetsRequest listTargetsRequest)

      Lists the targets for the target group. By default, all targets are included. You can use this API to check the health status of targets. You can also filter the results by target.

      Parameters:
      listTargetsRequest -
      Returns:
      A Java Future containing the result of the ListTargets operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTargets

      default CompletableFuture<ListTargetsResponse> listTargets(Consumer<ListTargetsRequest.Builder> listTargetsRequest)

      Lists the targets for the target group. By default, all targets are included. You can use this API to check the health status of targets. You can also filter the results by target.


      This is a convenience which creates an instance of the ListTargetsRequest.Builder avoiding the need to create one manually via ListTargetsRequest.builder()

      Parameters:
      listTargetsRequest - A Consumer that will call methods on ListTargetsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the ListTargets operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTargetsPaginator

      default ListTargetsPublisher listTargetsPaginator(ListTargetsRequest listTargetsRequest)

      This is a variant of listTargets(software.amazon.awssdk.services.vpclattice.model.ListTargetsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetsPublisher publisher = client.listTargetsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetsPublisher publisher = client.listTargetsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListTargetsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListTargetsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listTargets(software.amazon.awssdk.services.vpclattice.model.ListTargetsRequest) operation.

      Parameters:
      listTargetsRequest -
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • listTargetsPaginator

      default ListTargetsPublisher listTargetsPaginator(Consumer<ListTargetsRequest.Builder> listTargetsRequest)

      This is a variant of listTargets(software.amazon.awssdk.services.vpclattice.model.ListTargetsRequest) operation. The return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will internally handle making service calls for you.

      When the operation is called, an instance of this class is returned. At this point, no service calls are made yet and so there is no guarantee that the request is valid. If there are errors in your request, you will see the failures only after you start streaming the data. The subscribe method should be called as a request to start streaming data. For more info, see Publisher.subscribe(org.reactivestreams.Subscriber). Each call to the subscribe method will result in a new Subscription i.e., a new contract to stream data from the starting request.

      The following are few ways to use the response class:

      1) Using the subscribe helper method 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetsPublisher publisher = client.listTargetsPaginator(request);
 CompletableFuture<Void> future = publisher.subscribe(res -> { // Do something with the response });
 future.get();
      2) Using a custom subscriber 
       
 software.amazon.awssdk.services.vpclattice.paginators.ListTargetsPublisher publisher = client.listTargetsPaginator(request);
 publisher.subscribe(new Subscriber<software.amazon.awssdk.services.vpclattice.model.ListTargetsResponse>() {
 
 public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
 
 
 public void onNext(software.amazon.awssdk.services.vpclattice.model.ListTargetsResponse response) { //... };
 });
      As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.

      Please notice that the configuration of maxResults won't limit the number of results you get with the paginator. It only limits the number of results in each page.

      Note: If you prefer to have control on service calls, use the listTargets(software.amazon.awssdk.services.vpclattice.model.ListTargetsRequest) operation.


      This is a convenience which creates an instance of the ListTargetsRequest.Builder avoiding the need to create one manually via ListTargetsRequest.builder()

      Parameters:
      listTargetsRequest - A Consumer that will call methods on ListTargetsRequest.Builder to create a request.
      Returns:
      A custom publisher that can be subscribed to request a stream of response pages.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putAuthPolicy

      default CompletableFuture<PutAuthPolicyResponse> putAuthPolicy(PutAuthPolicyRequest putAuthPolicyRequest)

      Creates or updates the auth policy. The policy string in JSON must not contain newlines or blank lines.

      For more information, see Auth policies in the Amazon VPC Lattice User Guide.

      Parameters:
      putAuthPolicyRequest -
      Returns:
      A Java Future containing the result of the PutAuthPolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putAuthPolicy

      default CompletableFuture<PutAuthPolicyResponse> putAuthPolicy(Consumer<PutAuthPolicyRequest.Builder> putAuthPolicyRequest)

      Creates or updates the auth policy. The policy string in JSON must not contain newlines or blank lines.

      For more information, see Auth policies in the Amazon VPC Lattice User Guide.


      This is a convenience which creates an instance of the PutAuthPolicyRequest.Builder avoiding the need to create one manually via PutAuthPolicyRequest.builder()

      Parameters:
      putAuthPolicyRequest - A Consumer that will call methods on PutAuthPolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the PutAuthPolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putResourcePolicy

      default CompletableFuture<PutResourcePolicyResponse> putResourcePolicy(PutResourcePolicyRequest putResourcePolicyRequest)

      Attaches a resource-based permission policy to a service or service network. The policy must contain the same actions and condition statements as the Amazon Web Services Resource Access Manager permission for sharing services and service networks.

      Parameters:
      putResourcePolicyRequest -
      Returns:
      A Java Future containing the result of the PutResourcePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • putResourcePolicy

      default CompletableFuture<PutResourcePolicyResponse> putResourcePolicy(Consumer<PutResourcePolicyRequest.Builder> putResourcePolicyRequest)

      Attaches a resource-based permission policy to a service or service network. The policy must contain the same actions and condition statements as the Amazon Web Services Resource Access Manager permission for sharing services and service networks.


      This is a convenience which creates an instance of the PutResourcePolicyRequest.Builder avoiding the need to create one manually via PutResourcePolicyRequest.builder()

      Parameters:
      putResourcePolicyRequest - A Consumer that will call methods on PutResourcePolicyRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the PutResourcePolicy operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • registerTargets

      default CompletableFuture<RegisterTargetsResponse> registerTargets(RegisterTargetsRequest registerTargetsRequest)

      Registers the targets with the target group. If it's a Lambda target, you can only have one target in a target group.

      Parameters:
      registerTargetsRequest -
      Returns:
      A Java Future containing the result of the RegisterTargets operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • registerTargets

      default CompletableFuture<RegisterTargetsResponse> registerTargets(Consumer<RegisterTargetsRequest.Builder> registerTargetsRequest)

      Registers the targets with the target group. If it's a Lambda target, you can only have one target in a target group.


      This is a convenience which creates an instance of the RegisterTargetsRequest.Builder avoiding the need to create one manually via RegisterTargetsRequest.builder()

      Parameters:
      registerTargetsRequest - A Consumer that will call methods on RegisterTargetsRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the RegisterTargets operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • ServiceQuotaExceededException The request would cause a service quota to be exceeded.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • tagResource

      default CompletableFuture<TagResourceResponse> tagResource(TagResourceRequest tagResourceRequest)

      Adds the specified tags to the specified resource.

      Parameters:
      tagResourceRequest -
      Returns:
      A Java Future containing the result of the TagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • tagResource

      default CompletableFuture<TagResourceResponse> tagResource(Consumer<TagResourceRequest.Builder> tagResourceRequest)

      Adds the specified tags to the specified resource.


      This is a convenience which creates an instance of the TagResourceRequest.Builder avoiding the need to create one manually via TagResourceRequest.builder()

      Parameters:
      tagResourceRequest - A Consumer that will call methods on TagResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the TagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • untagResource

      default CompletableFuture<UntagResourceResponse> untagResource(UntagResourceRequest untagResourceRequest)

      Removes the specified tags from the specified resource.

      Parameters:
      untagResourceRequest -
      Returns:
      A Java Future containing the result of the UntagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • untagResource

      default CompletableFuture<UntagResourceResponse> untagResource(Consumer<UntagResourceRequest.Builder> untagResourceRequest)

      Removes the specified tags from the specified resource.


      This is a convenience which creates an instance of the UntagResourceRequest.Builder avoiding the need to create one manually via UntagResourceRequest.builder()

      Parameters:
      untagResourceRequest - A Consumer that will call methods on UntagResourceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UntagResource operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ResourceNotFoundException The request references a resource that does not exist.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateAccessLogSubscription

      default CompletableFuture<UpdateAccessLogSubscriptionResponse> updateAccessLogSubscription(UpdateAccessLogSubscriptionRequest updateAccessLogSubscriptionRequest)

      Updates the specified access log subscription.

      Parameters:
      updateAccessLogSubscriptionRequest -
      Returns:
      A Java Future containing the result of the UpdateAccessLogSubscription operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateAccessLogSubscription

      default CompletableFuture<UpdateAccessLogSubscriptionResponse> updateAccessLogSubscription(Consumer<UpdateAccessLogSubscriptionRequest.Builder> updateAccessLogSubscriptionRequest)

      Updates the specified access log subscription.


      This is a convenience which creates an instance of the UpdateAccessLogSubscriptionRequest.Builder avoiding the need to create one manually via UpdateAccessLogSubscriptionRequest.builder()

      Parameters:
      updateAccessLogSubscriptionRequest - A Consumer that will call methods on UpdateAccessLogSubscriptionRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateAccessLogSubscription operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateListener

      default CompletableFuture<UpdateListenerResponse> updateListener(UpdateListenerRequest updateListenerRequest)

      Updates the specified listener for the specified service.

      Parameters:
      updateListenerRequest -
      Returns:
      A Java Future containing the result of the UpdateListener operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateListener

      default CompletableFuture<UpdateListenerResponse> updateListener(Consumer<UpdateListenerRequest.Builder> updateListenerRequest)

      Updates the specified listener for the specified service.


      This is a convenience which creates an instance of the UpdateListenerRequest.Builder avoiding the need to create one manually via UpdateListenerRequest.builder()

      Parameters:
      updateListenerRequest - A Consumer that will call methods on UpdateListenerRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateListener operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateRule

      default CompletableFuture<UpdateRuleResponse> updateRule(UpdateRuleRequest updateRuleRequest)

      Updates a rule for the listener. You can't modify a default listener rule. To modify a default listener rule, use UpdateListener.

      Parameters:
      updateRuleRequest -
      Returns:
      A Java Future containing the result of the UpdateRule operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateRule

      default CompletableFuture<UpdateRuleResponse> updateRule(Consumer<UpdateRuleRequest.Builder> updateRuleRequest)

      Updates a rule for the listener. You can't modify a default listener rule. To modify a default listener rule, use UpdateListener.


      This is a convenience which creates an instance of the UpdateRuleRequest.Builder avoiding the need to create one manually via UpdateRuleRequest.builder()

      Parameters:
      updateRuleRequest - A Consumer that will call methods on UpdateRuleRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateRule operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateService

      default CompletableFuture<UpdateServiceResponse> updateService(UpdateServiceRequest updateServiceRequest)

      Updates the specified service.

      Parameters:
      updateServiceRequest -
      Returns:
      A Java Future containing the result of the UpdateService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateService

      default CompletableFuture<UpdateServiceResponse> updateService(Consumer<UpdateServiceRequest.Builder> updateServiceRequest)

      Updates the specified service.


      This is a convenience which creates an instance of the UpdateServiceRequest.Builder avoiding the need to create one manually via UpdateServiceRequest.builder()

      Parameters:
      updateServiceRequest - A Consumer that will call methods on UpdateServiceRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateService operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateServiceNetwork

      default CompletableFuture<UpdateServiceNetworkResponse> updateServiceNetwork(UpdateServiceNetworkRequest updateServiceNetworkRequest)

      Updates the specified service network.

      Parameters:
      updateServiceNetworkRequest -
      Returns:
      A Java Future containing the result of the UpdateServiceNetwork operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateServiceNetwork

      default CompletableFuture<UpdateServiceNetworkResponse> updateServiceNetwork(Consumer<UpdateServiceNetworkRequest.Builder> updateServiceNetworkRequest)

      Updates the specified service network.


      This is a convenience which creates an instance of the UpdateServiceNetworkRequest.Builder avoiding the need to create one manually via UpdateServiceNetworkRequest.builder()

      Parameters:
      updateServiceNetworkRequest - A Consumer that will call methods on UpdateServiceNetworkRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateServiceNetwork operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateServiceNetworkVpcAssociation

      default CompletableFuture<UpdateServiceNetworkVpcAssociationResponse> updateServiceNetworkVpcAssociation(UpdateServiceNetworkVpcAssociationRequest updateServiceNetworkVpcAssociationRequest)

      Updates the service network and VPC association. If you add a security group to the service network and VPC association, the association must continue to always have at least one security group. You can add or edit security groups at any time. However, to remove all security groups, you must first delete the association and recreate it without security groups.

      Parameters:
      updateServiceNetworkVpcAssociationRequest -
      Returns:
      A Java Future containing the result of the UpdateServiceNetworkVpcAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateServiceNetworkVpcAssociation

      default CompletableFuture<UpdateServiceNetworkVpcAssociationResponse> updateServiceNetworkVpcAssociation(Consumer<UpdateServiceNetworkVpcAssociationRequest.Builder> updateServiceNetworkVpcAssociationRequest)

      Updates the service network and VPC association. If you add a security group to the service network and VPC association, the association must continue to always have at least one security group. You can add or edit security groups at any time. However, to remove all security groups, you must first delete the association and recreate it without security groups.


      This is a convenience which creates an instance of the UpdateServiceNetworkVpcAssociationRequest.Builder avoiding the need to create one manually via UpdateServiceNetworkVpcAssociationRequest.builder()

      Parameters:
      updateServiceNetworkVpcAssociationRequest - A Consumer that will call methods on UpdateServiceNetworkVpcAssociationRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateServiceNetworkVpcAssociation operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateTargetGroup

      default CompletableFuture<UpdateTargetGroupResponse> updateTargetGroup(UpdateTargetGroupRequest updateTargetGroupRequest)

      Updates the specified target group.

      Parameters:
      updateTargetGroupRequest -
      Returns:
      A Java Future containing the result of the UpdateTargetGroup operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • updateTargetGroup

      default CompletableFuture<UpdateTargetGroupResponse> updateTargetGroup(Consumer<UpdateTargetGroupRequest.Builder> updateTargetGroupRequest)

      Updates the specified target group.


      This is a convenience which creates an instance of the UpdateTargetGroupRequest.Builder avoiding the need to create one manually via UpdateTargetGroupRequest.builder()

      Parameters:
      updateTargetGroupRequest - A Consumer that will call methods on UpdateTargetGroupRequest.Builder to create a request.
      Returns:
      A Java Future containing the result of the UpdateTargetGroup operation returned by the service.
      The CompletableFuture returned by this method can be completed exceptionally with the following exceptions. The exception returned is wrapped with CompletionException, so you need to invoke Throwable.getCause() to retrieve the underlying exception.
      • ValidationException The input does not satisfy the constraints specified by an Amazon Web Services service.
      • AccessDeniedException The user does not have sufficient access to perform this action.
      • ThrottlingException The limit on the number of requests per second was exceeded.
      • ResourceNotFoundException The request references a resource that does not exist.
      • ConflictException The request conflicts with the current state of the resource. Updating or deleting a resource can cause an inconsistent state.
      • InternalServerException An unexpected error occurred while processing the request.
      • SdkException Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for catch all scenarios.
      • SdkClientException If any client side error occurs such as an IO related failure, failure to get credentials, etc.
      • VpcLatticeException Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
      See Also:

    • serviceClientConfiguration

      default VpcLatticeServiceClientConfiguration serviceClientConfiguration()
      Description copied from interface: SdkClient
      The SDK service client configuration exposes client settings to the user, e.g., ClientOverrideConfiguration
      Specified by:
      serviceClientConfiguration in interface AwsClient
      Specified by:
      serviceClientConfiguration in interface SdkClient
      Returns:
      SdkServiceClientConfiguration

    • create

      static VpcLatticeAsyncClient create()
      Create a VpcLatticeAsyncClient with the region loaded from the DefaultAwsRegionProviderChain and credentials loaded from the DefaultCredentialsProvider.

    • builder

      static VpcLatticeAsyncClientBuilder builder()
      Create a builder that can be used to configure and create a VpcLatticeAsyncClient.