com.amazonaws.services.eks.AmazonEKSClient Maven / Gradle / Ivy
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.eks;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.client.builder.AdvancedConfig;
import com.amazonaws.services.eks.AmazonEKSClientBuilder;
import com.amazonaws.services.eks.waiters.AmazonEKSWaiters;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.eks.model.*;
import com.amazonaws.services.eks.model.transform.*;
/**
* Client for accessing Amazon EKS. All service calls made using this client are blocking, and will not return until the
* service call completes.
*
*
* Amazon Elastic Kubernetes Service (Amazon EKS) is a managed service that makes it easy for you to run Kubernetes on
* Amazon Web Services without needing to setup or maintain your own Kubernetes control plane. Kubernetes is an
* open-source system for automating the deployment, scaling, and management of containerized applications.
*
*
* Amazon EKS runs up-to-date versions of the open-source Kubernetes software, so you can use all the existing plugins
* and tooling from the Kubernetes community. Applications running on Amazon EKS are fully compatible with applications
* running on any standard Kubernetes environment, whether running in on-premises data centers or public clouds. This
* means that you can easily migrate any standard Kubernetes application to Amazon EKS without any code modification
* required.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonEKSClient extends AmazonWebServiceClient implements AmazonEKS {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonEKS.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "eks";
private volatile AmazonEKSWaiters waiters;
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
private static final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.1")
.withSupportsCbor(false)
.withSupportsIon(false)
.withContentTypeOverride("application/json")
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidRequestException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.InvalidRequestExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceNotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.ResourceNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ClientException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.ClientExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceLimitExceededException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.ResourceLimitExceededExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidParameterException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.InvalidParameterExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceInUseException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.ResourceInUseExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("NotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.NotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("AccessDeniedException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.AccessDeniedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("UnsupportedAvailabilityZoneException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.UnsupportedAvailabilityZoneExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ServerException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.ServerExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourcePropagationDelayException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.ResourcePropagationDelayExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ServiceUnavailableException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.ServiceUnavailableExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("BadRequestException").withExceptionUnmarshaller(
com.amazonaws.services.eks.model.transform.BadRequestExceptionUnmarshaller.getInstance()))
.withBaseServiceExceptionClass(com.amazonaws.services.eks.model.AmazonEKSException.class));
public static AmazonEKSClientBuilder builder() {
return AmazonEKSClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on Amazon EKS using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonEKSClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on Amazon EKS using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonEKSClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
setEndpoint("eks.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/eks/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/eks/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Associates an access policy and its scope to an access entry. For more information about associating access
* policies, see Associating and
* disassociating access policies to and from access entries in the Amazon EKS User Guide.
*
*
* @param associateAccessPolicyRequest
* @return Result of the AssociateAccessPolicy operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonEKS.AssociateAccessPolicy
* @see AWS API
* Documentation
*/
@Override
public AssociateAccessPolicyResult associateAccessPolicy(AssociateAccessPolicyRequest request) {
request = beforeClientExecution(request);
return executeAssociateAccessPolicy(request);
}
@SdkInternalApi
final AssociateAccessPolicyResult executeAssociateAccessPolicy(AssociateAccessPolicyRequest associateAccessPolicyRequest) {
ExecutionContext executionContext = createExecutionContext(associateAccessPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AssociateAccessPolicyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(associateAccessPolicyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AssociateAccessPolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new AssociateAccessPolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Associates an encryption configuration to an existing cluster.
*
*
* Use this API to enable encryption on existing clusters that don't already have encryption enabled. This allows
* you to implement a defense-in-depth security strategy without migrating applications to new Amazon EKS clusters.
*
*
* @param associateEncryptionConfigRequest
* @return Result of the AssociateEncryptionConfig operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.AssociateEncryptionConfig
* @see AWS
* API Documentation
*/
@Override
public AssociateEncryptionConfigResult associateEncryptionConfig(AssociateEncryptionConfigRequest request) {
request = beforeClientExecution(request);
return executeAssociateEncryptionConfig(request);
}
@SdkInternalApi
final AssociateEncryptionConfigResult executeAssociateEncryptionConfig(AssociateEncryptionConfigRequest associateEncryptionConfigRequest) {
ExecutionContext executionContext = createExecutionContext(associateEncryptionConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AssociateEncryptionConfigRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(associateEncryptionConfigRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AssociateEncryptionConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new AssociateEncryptionConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Associates an identity provider configuration to a cluster.
*
*
* If you want to authenticate identities using an identity provider, you can create an identity provider
* configuration and associate it to your cluster. After configuring authentication to your cluster you can create
* Kubernetes Role and ClusterRole objects, assign permissions to them, and then bind them
* to the identities using Kubernetes RoleBinding and ClusterRoleBinding objects. For more
* information see Using RBAC
* Authorization in the Kubernetes documentation.
*
*
* @param associateIdentityProviderConfigRequest
* @return Result of the AssociateIdentityProviderConfig operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.AssociateIdentityProviderConfig
* @see AWS API Documentation
*/
@Override
public AssociateIdentityProviderConfigResult associateIdentityProviderConfig(AssociateIdentityProviderConfigRequest request) {
request = beforeClientExecution(request);
return executeAssociateIdentityProviderConfig(request);
}
@SdkInternalApi
final AssociateIdentityProviderConfigResult executeAssociateIdentityProviderConfig(
AssociateIdentityProviderConfigRequest associateIdentityProviderConfigRequest) {
ExecutionContext executionContext = createExecutionContext(associateIdentityProviderConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AssociateIdentityProviderConfigRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(associateIdentityProviderConfigRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AssociateIdentityProviderConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new AssociateIdentityProviderConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an access entry.
*
*
* An access entry allows an IAM principal to access your cluster. Access entries can replace the need to maintain
* entries in the aws-auth ConfigMap for authentication. You have the following options
* for authorizing an IAM principal to access Kubernetes objects on your cluster: Kubernetes role-based access
* control (RBAC), Amazon EKS, or both. Kubernetes RBAC authorization requires you to create and manage Kubernetes
* Role, ClusterRole, RoleBinding, and ClusterRoleBinding
* objects, in addition to managing access entries. If you use Amazon EKS authorization exclusively, you don't need
* to create and manage Kubernetes Role, ClusterRole, RoleBinding, and
* ClusterRoleBinding objects.
*
*
* For more information about access entries, see Access entries in the Amazon
* EKS User Guide.
*
*
* @param createAccessEntryRequest
* @return Result of the CreateAccessEntry operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ResourceLimitExceededException
* You have encountered a service limit on the specified resource.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonEKS.CreateAccessEntry
* @see AWS API
* Documentation
*/
@Override
public CreateAccessEntryResult createAccessEntry(CreateAccessEntryRequest request) {
request = beforeClientExecution(request);
return executeCreateAccessEntry(request);
}
@SdkInternalApi
final CreateAccessEntryResult executeCreateAccessEntry(CreateAccessEntryRequest createAccessEntryRequest) {
ExecutionContext executionContext = createExecutionContext(createAccessEntryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateAccessEntryRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createAccessEntryRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateAccessEntry");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateAccessEntryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an Amazon EKS add-on.
*
*
* Amazon EKS add-ons help to automate the provisioning and lifecycle management of common operational software for
* Amazon EKS clusters. For more information, see Amazon EKS add-ons in the Amazon
* EKS User Guide.
*
*
* @param createAddonRequest
* @return Result of the CreateAddon operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @sample AmazonEKS.CreateAddon
* @see AWS API
* Documentation
*/
@Override
public CreateAddonResult createAddon(CreateAddonRequest request) {
request = beforeClientExecution(request);
return executeCreateAddon(request);
}
@SdkInternalApi
final CreateAddonResult executeCreateAddon(CreateAddonRequest createAddonRequest) {
ExecutionContext executionContext = createExecutionContext(createAddonRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateAddonRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createAddonRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateAddon");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateAddonResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an Amazon EKS control plane.
*
*
* The Amazon EKS control plane consists of control plane instances that run the Kubernetes software, such as
* etcd and the API server. The control plane runs in an account managed by Amazon Web Services, and
* the Kubernetes API is exposed by the Amazon EKS API server endpoint. Each Amazon EKS cluster control plane is
* single tenant and unique. It runs on its own set of Amazon EC2 instances.
*
*
* The cluster control plane is provisioned across multiple Availability Zones and fronted by an Elastic Load
* Balancing Network Load Balancer. Amazon EKS also provisions elastic network interfaces in your VPC subnets to
* provide connectivity from the control plane instances to the nodes (for example, to support
* kubectl exec, logs, and proxy data flows).
*
*
* Amazon EKS nodes run in your Amazon Web Services account and connect to your cluster's control plane over the
* Kubernetes API server endpoint and a certificate file that is created for your cluster.
*
*
* You can use the endpointPublicAccess and endpointPrivateAccess parameters to enable or
* disable public and private access to your cluster's Kubernetes API server endpoint. By default, public access is
* enabled, and private access is disabled. For more information, see Amazon EKS Cluster Endpoint Access
* Control in the Amazon EKS User Guide .
*
*
* You can use the logging parameter to enable or disable exporting the Kubernetes control plane logs
* for your cluster to CloudWatch Logs. By default, cluster control plane logs aren't exported to CloudWatch Logs.
* For more information, see Amazon EKS Cluster Control Plane
* Logs in the Amazon EKS User Guide .
*
*
*
* CloudWatch Logs ingestion, archive storage, and data scanning rates apply to exported control plane logs. For
* more information, see CloudWatch Pricing.
*
*
*
* In most cases, it takes several minutes to create a cluster. After you create an Amazon EKS cluster, you must
* configure your Kubernetes tooling to communicate with the API server and launch nodes into your cluster. For more
* information, see Allowing users to
* access your cluster and Launching Amazon EKS nodes in the
* Amazon EKS User Guide.
*
*
* @param createClusterRequest
* @return Result of the CreateCluster operation returned by the service.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceLimitExceededException
* You have encountered a service limit on the specified resource.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @throws UnsupportedAvailabilityZoneException
* At least one of your specified cluster subnets is in an Availability Zone that does not support Amazon
* EKS. The exception output specifies the supported Availability Zones for your account, from which you can
* choose subnets for your cluster.
* @sample AmazonEKS.CreateCluster
* @see AWS API
* Documentation
*/
@Override
public CreateClusterResult createCluster(CreateClusterRequest request) {
request = beforeClientExecution(request);
return executeCreateCluster(request);
}
@SdkInternalApi
final CreateClusterResult executeCreateCluster(CreateClusterRequest createClusterRequest) {
ExecutionContext executionContext = createExecutionContext(createClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateClusterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateClusterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an EKS Anywhere subscription. When a subscription is created, it is a contract agreement for the length
* of the term specified in the request. Licenses that are used to validate support are provisioned in Amazon Web
* Services License Manager and the caller account is granted access to EKS Anywhere Curated Packages.
*
*
* @param createEksAnywhereSubscriptionRequest
* @return Result of the CreateEksAnywhereSubscription operation returned by the service.
* @throws ResourceLimitExceededException
* You have encountered a service limit on the specified resource.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @sample AmazonEKS.CreateEksAnywhereSubscription
* @see AWS API Documentation
*/
@Override
public CreateEksAnywhereSubscriptionResult createEksAnywhereSubscription(CreateEksAnywhereSubscriptionRequest request) {
request = beforeClientExecution(request);
return executeCreateEksAnywhereSubscription(request);
}
@SdkInternalApi
final CreateEksAnywhereSubscriptionResult executeCreateEksAnywhereSubscription(CreateEksAnywhereSubscriptionRequest createEksAnywhereSubscriptionRequest) {
ExecutionContext executionContext = createExecutionContext(createEksAnywhereSubscriptionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateEksAnywhereSubscriptionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createEksAnywhereSubscriptionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateEksAnywhereSubscription");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateEksAnywhereSubscriptionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an Fargate profile for your Amazon EKS cluster. You must have at least one Fargate profile in a cluster
* to be able to run pods on Fargate.
*
*
* The Fargate profile allows an administrator to declare which pods run on Fargate and specify which pods run on
* which Fargate profile. This declaration is done through the profile’s selectors. Each profile can have up to five
* selectors that contain a namespace and labels. A namespace is required for every selector. The label field
* consists of multiple optional key-value pairs. Pods that match the selectors are scheduled on Fargate. If a
* to-be-scheduled pod matches any of the selectors in the Fargate profile, then that pod is run on Fargate.
*
*
* When you create a Fargate profile, you must specify a pod execution role to use with the pods that are scheduled
* with the profile. This role is added to the cluster's Kubernetes Role Based Access Control (RBAC) for
* authorization so that the kubelet that is running on the Fargate infrastructure can register with
* your Amazon EKS cluster so that it can appear in your cluster as a node. The pod execution role also provides IAM
* permissions to the Fargate infrastructure to allow read access to Amazon ECR image repositories. For more
* information, see Pod Execution
* Role in the Amazon EKS User Guide.
*
*
* Fargate profiles are immutable. However, you can create a new updated profile to replace an existing profile and
* then delete the original after the updated profile has finished creating.
*
*
* If any Fargate profiles in a cluster are in the DELETING status, you must wait for that Fargate
* profile to finish deleting before you can create any other profiles in that cluster.
*
*
* For more information, see Fargate
* profile in the Amazon EKS User Guide.
*
*
* @param createFargateProfileRequest
* @return Result of the CreateFargateProfile operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceLimitExceededException
* You have encountered a service limit on the specified resource.
* @throws UnsupportedAvailabilityZoneException
* At least one of your specified cluster subnets is in an Availability Zone that does not support Amazon
* EKS. The exception output specifies the supported Availability Zones for your account, from which you can
* choose subnets for your cluster.
* @sample AmazonEKS.CreateFargateProfile
* @see AWS API
* Documentation
*/
@Override
public CreateFargateProfileResult createFargateProfile(CreateFargateProfileRequest request) {
request = beforeClientExecution(request);
return executeCreateFargateProfile(request);
}
@SdkInternalApi
final CreateFargateProfileResult executeCreateFargateProfile(CreateFargateProfileRequest createFargateProfileRequest) {
ExecutionContext executionContext = createExecutionContext(createFargateProfileRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateFargateProfileRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createFargateProfileRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateFargateProfile");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateFargateProfileResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a managed node group for an Amazon EKS cluster.
*
*
* You can only create a node group for your cluster that is equal to the current Kubernetes version for the
* cluster. All node groups are created with the latest AMI release version for the respective minor Kubernetes
* version of the cluster, unless you deploy a custom AMI using a launch template. For more information about using
* launch templates, see Customizing managed nodes with
* launch templates.
*
*
* An Amazon EKS managed node group is an Amazon EC2 Auto Scaling group and associated Amazon EC2 instances that are
* managed by Amazon Web Services for an Amazon EKS cluster. For more information, see Managed node groups in the
* Amazon EKS User Guide.
*
*
*
* Windows AMI types are only supported for commercial Amazon Web Services Regions that support Windows on Amazon
* EKS.
*
*
*
* @param createNodegroupRequest
* @return Result of the CreateNodegroup operation returned by the service.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceLimitExceededException
* You have encountered a service limit on the specified resource.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @sample AmazonEKS.CreateNodegroup
* @see AWS API
* Documentation
*/
@Override
public CreateNodegroupResult createNodegroup(CreateNodegroupRequest request) {
request = beforeClientExecution(request);
return executeCreateNodegroup(request);
}
@SdkInternalApi
final CreateNodegroupResult executeCreateNodegroup(CreateNodegroupRequest createNodegroupRequest) {
ExecutionContext executionContext = createExecutionContext(createNodegroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateNodegroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createNodegroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateNodegroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateNodegroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an EKS Pod Identity association between a service account in an Amazon EKS cluster and an IAM role with
* EKS Pod Identity. Use EKS Pod Identity to give temporary IAM credentials to pods and the credentials are
* rotated automatically.
*
*
* Amazon EKS Pod Identity associations provide the ability to manage credentials for your applications, similar to
* the way that Amazon EC2 instance profiles provide credentials to Amazon EC2 instances.
*
*
* If a pod uses a service account that has an association, Amazon EKS sets environment variables in the containers
* of the pod. The environment variables configure the Amazon Web Services SDKs, including the Command Line
* Interface, to use the EKS Pod Identity credentials.
*
*
* Pod Identity is a simpler method than IAM roles for service accounts, as this method doesn't use OIDC
* identity providers. Additionally, you can configure a role for Pod Identity once, and reuse it across clusters.
*
*
* @param createPodIdentityAssociationRequest
* @return Result of the CreatePodIdentityAssociation operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ResourceLimitExceededException
* You have encountered a service limit on the specified resource.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonEKS.CreatePodIdentityAssociation
* @see AWS API Documentation
*/
@Override
public CreatePodIdentityAssociationResult createPodIdentityAssociation(CreatePodIdentityAssociationRequest request) {
request = beforeClientExecution(request);
return executeCreatePodIdentityAssociation(request);
}
@SdkInternalApi
final CreatePodIdentityAssociationResult executeCreatePodIdentityAssociation(CreatePodIdentityAssociationRequest createPodIdentityAssociationRequest) {
ExecutionContext executionContext = createExecutionContext(createPodIdentityAssociationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreatePodIdentityAssociationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createPodIdentityAssociationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreatePodIdentityAssociation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreatePodIdentityAssociationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an access entry.
*
*
* Deleting an access entry of a type other than Standard can cause your cluster to function
* improperly. If you delete an access entry in error, you can recreate it.
*
*
* @param deleteAccessEntryRequest
* @return Result of the DeleteAccessEntry operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.DeleteAccessEntry
* @see AWS API
* Documentation
*/
@Override
public DeleteAccessEntryResult deleteAccessEntry(DeleteAccessEntryRequest request) {
request = beforeClientExecution(request);
return executeDeleteAccessEntry(request);
}
@SdkInternalApi
final DeleteAccessEntryResult executeDeleteAccessEntry(DeleteAccessEntryRequest deleteAccessEntryRequest) {
ExecutionContext executionContext = createExecutionContext(deleteAccessEntryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteAccessEntryRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteAccessEntryRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteAccessEntry");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteAccessEntryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an Amazon EKS add-on.
*
*
* When you remove an add-on, it's deleted from the cluster. You can always manually start an add-on on the cluster
* using the Kubernetes API.
*
*
* @param deleteAddonRequest
* @return Result of the DeleteAddon operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @sample AmazonEKS.DeleteAddon
* @see AWS API
* Documentation
*/
@Override
public DeleteAddonResult deleteAddon(DeleteAddonRequest request) {
request = beforeClientExecution(request);
return executeDeleteAddon(request);
}
@SdkInternalApi
final DeleteAddonResult executeDeleteAddon(DeleteAddonRequest deleteAddonRequest) {
ExecutionContext executionContext = createExecutionContext(deleteAddonRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteAddonRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteAddonRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteAddon");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteAddonResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an Amazon EKS cluster control plane.
*
*
* If you have active services in your cluster that are associated with a load balancer, you must delete those
* services before deleting the cluster so that the load balancers are deleted properly. Otherwise, you can have
* orphaned resources in your VPC that prevent you from being able to delete the VPC. For more information, see Deleting a cluster in the
* Amazon EKS User Guide.
*
*
* If you have managed node groups or Fargate profiles attached to the cluster, you must delete them first. For more
* information, see DeleteNodgroup and DeleteFargateProfile.
*
*
* @param deleteClusterRequest
* @return Result of the DeleteCluster operation returned by the service.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @sample AmazonEKS.DeleteCluster
* @see AWS API
* Documentation
*/
@Override
public DeleteClusterResult deleteCluster(DeleteClusterRequest request) {
request = beforeClientExecution(request);
return executeDeleteCluster(request);
}
@SdkInternalApi
final DeleteClusterResult executeDeleteCluster(DeleteClusterRequest deleteClusterRequest) {
ExecutionContext executionContext = createExecutionContext(deleteClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteClusterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteClusterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an expired or inactive subscription. Deleting inactive subscriptions removes them from the Amazon Web
* Services Management Console view and from list/describe API responses. Subscriptions can only be cancelled within
* 7 days of creation and are cancelled by creating a ticket in the Amazon Web Services Support Center.
*
*
* @param deleteEksAnywhereSubscriptionRequest
* @return Result of the DeleteEksAnywhereSubscription operation returned by the service.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @sample AmazonEKS.DeleteEksAnywhereSubscription
* @see AWS API Documentation
*/
@Override
public DeleteEksAnywhereSubscriptionResult deleteEksAnywhereSubscription(DeleteEksAnywhereSubscriptionRequest request) {
request = beforeClientExecution(request);
return executeDeleteEksAnywhereSubscription(request);
}
@SdkInternalApi
final DeleteEksAnywhereSubscriptionResult executeDeleteEksAnywhereSubscription(DeleteEksAnywhereSubscriptionRequest deleteEksAnywhereSubscriptionRequest) {
ExecutionContext executionContext = createExecutionContext(deleteEksAnywhereSubscriptionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteEksAnywhereSubscriptionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteEksAnywhereSubscriptionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteEksAnywhereSubscription");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteEksAnywhereSubscriptionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an Fargate profile.
*
*
* When you delete a Fargate profile, any Pod running on Fargate that was created with the profile is
* deleted. If the Pod matches another Fargate profile, then it is scheduled on Fargate with that
* profile. If it no longer matches any Fargate profiles, then it's not scheduled on Fargate and may remain in a
* pending state.
*
*
* Only one Fargate profile in a cluster can be in the DELETING status at a time. You must wait for a
* Fargate profile to finish deleting before you can delete any other profiles in that cluster.
*
*
* @param deleteFargateProfileRequest
* @return Result of the DeleteFargateProfile operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @sample AmazonEKS.DeleteFargateProfile
* @see AWS API
* Documentation
*/
@Override
public DeleteFargateProfileResult deleteFargateProfile(DeleteFargateProfileRequest request) {
request = beforeClientExecution(request);
return executeDeleteFargateProfile(request);
}
@SdkInternalApi
final DeleteFargateProfileResult executeDeleteFargateProfile(DeleteFargateProfileRequest deleteFargateProfileRequest) {
ExecutionContext executionContext = createExecutionContext(deleteFargateProfileRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteFargateProfileRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteFargateProfileRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteFargateProfile");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteFargateProfileResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a managed node group.
*
*
* @param deleteNodegroupRequest
* @return Result of the DeleteNodegroup operation returned by the service.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @sample AmazonEKS.DeleteNodegroup
* @see AWS API
* Documentation
*/
@Override
public DeleteNodegroupResult deleteNodegroup(DeleteNodegroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteNodegroup(request);
}
@SdkInternalApi
final DeleteNodegroupResult executeDeleteNodegroup(DeleteNodegroupRequest deleteNodegroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteNodegroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteNodegroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteNodegroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteNodegroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteNodegroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a EKS Pod Identity association.
*
*
* The temporary Amazon Web Services credentials from the previous IAM role session might still be valid until the
* session expiry. If you need to immediately revoke the temporary session credentials, then go to the role in the
* IAM console.
*
*
* @param deletePodIdentityAssociationRequest
* @return Result of the DeletePodIdentityAssociation operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonEKS.DeletePodIdentityAssociation
* @see AWS API Documentation
*/
@Override
public DeletePodIdentityAssociationResult deletePodIdentityAssociation(DeletePodIdentityAssociationRequest request) {
request = beforeClientExecution(request);
return executeDeletePodIdentityAssociation(request);
}
@SdkInternalApi
final DeletePodIdentityAssociationResult executeDeletePodIdentityAssociation(DeletePodIdentityAssociationRequest deletePodIdentityAssociationRequest) {
ExecutionContext executionContext = createExecutionContext(deletePodIdentityAssociationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeletePodIdentityAssociationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deletePodIdentityAssociationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeletePodIdentityAssociation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeletePodIdentityAssociationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deregisters a connected cluster to remove it from the Amazon EKS control plane.
*
*
* A connected cluster is a Kubernetes cluster that you've connected to your control plane using the Amazon EKS Connector.
*
*
* @param deregisterClusterRequest
* @return Result of the DeregisterCluster operation returned by the service.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @throws AccessDeniedException
* You don't have permissions to perform the requested operation. The IAM
* principal making the request must have at least one IAM permissions policy attached that grants the
* required permissions. For more information, see Access management in the IAM
* User Guide.
* @sample AmazonEKS.DeregisterCluster
* @see AWS API
* Documentation
*/
@Override
public DeregisterClusterResult deregisterCluster(DeregisterClusterRequest request) {
request = beforeClientExecution(request);
return executeDeregisterCluster(request);
}
@SdkInternalApi
final DeregisterClusterResult executeDeregisterCluster(DeregisterClusterRequest deregisterClusterRequest) {
ExecutionContext executionContext = createExecutionContext(deregisterClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeregisterClusterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deregisterClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeregisterCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeregisterClusterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes an access entry.
*
*
* @param describeAccessEntryRequest
* @return Result of the DescribeAccessEntry operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.DescribeAccessEntry
* @see AWS API
* Documentation
*/
@Override
public DescribeAccessEntryResult describeAccessEntry(DescribeAccessEntryRequest request) {
request = beforeClientExecution(request);
return executeDescribeAccessEntry(request);
}
@SdkInternalApi
final DescribeAccessEntryResult executeDescribeAccessEntry(DescribeAccessEntryRequest describeAccessEntryRequest) {
ExecutionContext executionContext = createExecutionContext(describeAccessEntryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeAccessEntryRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeAccessEntryRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeAccessEntry");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeAccessEntryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes an Amazon EKS add-on.
*
*
* @param describeAddonRequest
* @return Result of the DescribeAddon operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @sample AmazonEKS.DescribeAddon
* @see AWS API
* Documentation
*/
@Override
public DescribeAddonResult describeAddon(DescribeAddonRequest request) {
request = beforeClientExecution(request);
return executeDescribeAddon(request);
}
@SdkInternalApi
final DescribeAddonResult executeDescribeAddon(DescribeAddonRequest describeAddonRequest) {
ExecutionContext executionContext = createExecutionContext(describeAddonRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeAddonRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeAddonRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeAddon");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeAddonResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns configuration options.
*
*
* @param describeAddonConfigurationRequest
* @return Result of the DescribeAddonConfiguration operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonEKS.DescribeAddonConfiguration
* @see AWS
* API Documentation
*/
@Override
public DescribeAddonConfigurationResult describeAddonConfiguration(DescribeAddonConfigurationRequest request) {
request = beforeClientExecution(request);
return executeDescribeAddonConfiguration(request);
}
@SdkInternalApi
final DescribeAddonConfigurationResult executeDescribeAddonConfiguration(DescribeAddonConfigurationRequest describeAddonConfigurationRequest) {
ExecutionContext executionContext = createExecutionContext(describeAddonConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeAddonConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeAddonConfigurationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeAddonConfiguration");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeAddonConfigurationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes the versions for an add-on.
*
*
* Information such as the Kubernetes versions that you can use the add-on with, the owner,
* publisher, and the type of the add-on are returned.
*
*
* @param describeAddonVersionsRequest
* @return Result of the DescribeAddonVersions operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonEKS.DescribeAddonVersions
* @see AWS API
* Documentation
*/
@Override
public DescribeAddonVersionsResult describeAddonVersions(DescribeAddonVersionsRequest request) {
request = beforeClientExecution(request);
return executeDescribeAddonVersions(request);
}
@SdkInternalApi
final DescribeAddonVersionsResult executeDescribeAddonVersions(DescribeAddonVersionsRequest describeAddonVersionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeAddonVersionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeAddonVersionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeAddonVersionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeAddonVersions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeAddonVersionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes an Amazon EKS cluster.
*
*
* The API server endpoint and certificate authority data returned by this operation are required for
* kubelet and kubectl to communicate with your Kubernetes API server. For more
* information, see Creating or
* updating a kubeconfig file for an Amazon EKS cluster.
*
*
*
* The API server endpoint and certificate authority data aren't available until the cluster reaches the
* ACTIVE state.
*
*
*
* @param describeClusterRequest
* @return Result of the DescribeCluster operation returned by the service.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @sample AmazonEKS.DescribeCluster
* @see AWS API
* Documentation
*/
@Override
public DescribeClusterResult describeCluster(DescribeClusterRequest request) {
request = beforeClientExecution(request);
return executeDescribeCluster(request);
}
@SdkInternalApi
final DescribeClusterResult executeDescribeCluster(DescribeClusterRequest describeClusterRequest) {
ExecutionContext executionContext = createExecutionContext(describeClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeClusterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeClusterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns descriptive information about a subscription.
*
*
* @param describeEksAnywhereSubscriptionRequest
* @return Result of the DescribeEksAnywhereSubscription operation returned by the service.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @sample AmazonEKS.DescribeEksAnywhereSubscription
* @see AWS API Documentation
*/
@Override
public DescribeEksAnywhereSubscriptionResult describeEksAnywhereSubscription(DescribeEksAnywhereSubscriptionRequest request) {
request = beforeClientExecution(request);
return executeDescribeEksAnywhereSubscription(request);
}
@SdkInternalApi
final DescribeEksAnywhereSubscriptionResult executeDescribeEksAnywhereSubscription(
DescribeEksAnywhereSubscriptionRequest describeEksAnywhereSubscriptionRequest) {
ExecutionContext executionContext = createExecutionContext(describeEksAnywhereSubscriptionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEksAnywhereSubscriptionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeEksAnywhereSubscriptionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeEksAnywhereSubscription");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeEksAnywhereSubscriptionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes an Fargate profile.
*
*
* @param describeFargateProfileRequest
* @return Result of the DescribeFargateProfile operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @sample AmazonEKS.DescribeFargateProfile
* @see AWS API
* Documentation
*/
@Override
public DescribeFargateProfileResult describeFargateProfile(DescribeFargateProfileRequest request) {
request = beforeClientExecution(request);
return executeDescribeFargateProfile(request);
}
@SdkInternalApi
final DescribeFargateProfileResult executeDescribeFargateProfile(DescribeFargateProfileRequest describeFargateProfileRequest) {
ExecutionContext executionContext = createExecutionContext(describeFargateProfileRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeFargateProfileRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeFargateProfileRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeFargateProfile");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeFargateProfileResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes an identity provider configuration.
*
*
* @param describeIdentityProviderConfigRequest
* @return Result of the DescribeIdentityProviderConfig operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @sample AmazonEKS.DescribeIdentityProviderConfig
* @see AWS API Documentation
*/
@Override
public DescribeIdentityProviderConfigResult describeIdentityProviderConfig(DescribeIdentityProviderConfigRequest request) {
request = beforeClientExecution(request);
return executeDescribeIdentityProviderConfig(request);
}
@SdkInternalApi
final DescribeIdentityProviderConfigResult executeDescribeIdentityProviderConfig(DescribeIdentityProviderConfigRequest describeIdentityProviderConfigRequest) {
ExecutionContext executionContext = createExecutionContext(describeIdentityProviderConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeIdentityProviderConfigRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeIdentityProviderConfigRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeIdentityProviderConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeIdentityProviderConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns details about an insight that you specify using its ID.
*
*
* @param describeInsightRequest
* @return Result of the DescribeInsight operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonEKS.DescribeInsight
* @see AWS API
* Documentation
*/
@Override
public DescribeInsightResult describeInsight(DescribeInsightRequest request) {
request = beforeClientExecution(request);
return executeDescribeInsight(request);
}
@SdkInternalApi
final DescribeInsightResult executeDescribeInsight(DescribeInsightRequest describeInsightRequest) {
ExecutionContext executionContext = createExecutionContext(describeInsightRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeInsightRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeInsightRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeInsight");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeInsightResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes a managed node group.
*
*
* @param describeNodegroupRequest
* @return Result of the DescribeNodegroup operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @sample AmazonEKS.DescribeNodegroup
* @see AWS API
* Documentation
*/
@Override
public DescribeNodegroupResult describeNodegroup(DescribeNodegroupRequest request) {
request = beforeClientExecution(request);
return executeDescribeNodegroup(request);
}
@SdkInternalApi
final DescribeNodegroupResult executeDescribeNodegroup(DescribeNodegroupRequest describeNodegroupRequest) {
ExecutionContext executionContext = createExecutionContext(describeNodegroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeNodegroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeNodegroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeNodegroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeNodegroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns descriptive information about an EKS Pod Identity association.
*
*
* This action requires the ID of the association. You can get the ID from the response to the
* CreatePodIdentityAssocation for newly created associations. Or, you can list the IDs for
* associations with ListPodIdentityAssociations and filter the list by namespace or service account.
*
*
* @param describePodIdentityAssociationRequest
* @return Result of the DescribePodIdentityAssociation operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonEKS.DescribePodIdentityAssociation
* @see AWS API Documentation
*/
@Override
public DescribePodIdentityAssociationResult describePodIdentityAssociation(DescribePodIdentityAssociationRequest request) {
request = beforeClientExecution(request);
return executeDescribePodIdentityAssociation(request);
}
@SdkInternalApi
final DescribePodIdentityAssociationResult executeDescribePodIdentityAssociation(DescribePodIdentityAssociationRequest describePodIdentityAssociationRequest) {
ExecutionContext executionContext = createExecutionContext(describePodIdentityAssociationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribePodIdentityAssociationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describePodIdentityAssociationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribePodIdentityAssociation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribePodIdentityAssociationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes an update to an Amazon EKS resource.
*
*
* When the status of the update is Succeeded, the update is complete. If an update fails, the status
* is Failed, and an error detail explains the reason for the failure.
*
*
* @param describeUpdateRequest
* Describes an update request.
* @return Result of the DescribeUpdate operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @sample AmazonEKS.DescribeUpdate
* @see AWS API
* Documentation
*/
@Override
public DescribeUpdateResult describeUpdate(DescribeUpdateRequest request) {
request = beforeClientExecution(request);
return executeDescribeUpdate(request);
}
@SdkInternalApi
final DescribeUpdateResult executeDescribeUpdate(DescribeUpdateRequest describeUpdateRequest) {
ExecutionContext executionContext = createExecutionContext(describeUpdateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeUpdateRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeUpdateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeUpdate");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeUpdateResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Disassociates an access policy from an access entry.
*
*
* @param disassociateAccessPolicyRequest
* @return Result of the DisassociateAccessPolicy operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.DisassociateAccessPolicy
* @see AWS
* API Documentation
*/
@Override
public DisassociateAccessPolicyResult disassociateAccessPolicy(DisassociateAccessPolicyRequest request) {
request = beforeClientExecution(request);
return executeDisassociateAccessPolicy(request);
}
@SdkInternalApi
final DisassociateAccessPolicyResult executeDisassociateAccessPolicy(DisassociateAccessPolicyRequest disassociateAccessPolicyRequest) {
ExecutionContext executionContext = createExecutionContext(disassociateAccessPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisassociateAccessPolicyRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(disassociateAccessPolicyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DisassociateAccessPolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DisassociateAccessPolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Disassociates an identity provider configuration from a cluster.
*
*
* If you disassociate an identity provider from your cluster, users included in the provider can no longer access
* the cluster. However, you can still access the cluster with IAM principals.
*
*
* @param disassociateIdentityProviderConfigRequest
* @return Result of the DisassociateIdentityProviderConfig operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.DisassociateIdentityProviderConfig
* @see AWS API Documentation
*/
@Override
public DisassociateIdentityProviderConfigResult disassociateIdentityProviderConfig(DisassociateIdentityProviderConfigRequest request) {
request = beforeClientExecution(request);
return executeDisassociateIdentityProviderConfig(request);
}
@SdkInternalApi
final DisassociateIdentityProviderConfigResult executeDisassociateIdentityProviderConfig(
DisassociateIdentityProviderConfigRequest disassociateIdentityProviderConfigRequest) {
ExecutionContext executionContext = createExecutionContext(disassociateIdentityProviderConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisassociateIdentityProviderConfigRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(disassociateIdentityProviderConfigRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DisassociateIdentityProviderConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DisassociateIdentityProviderConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the access entries for your cluster.
*
*
* @param listAccessEntriesRequest
* @return Result of the ListAccessEntries operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonEKS.ListAccessEntries
* @see AWS API
* Documentation
*/
@Override
public ListAccessEntriesResult listAccessEntries(ListAccessEntriesRequest request) {
request = beforeClientExecution(request);
return executeListAccessEntries(request);
}
@SdkInternalApi
final ListAccessEntriesResult executeListAccessEntries(ListAccessEntriesRequest listAccessEntriesRequest) {
ExecutionContext executionContext = createExecutionContext(listAccessEntriesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListAccessEntriesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listAccessEntriesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListAccessEntries");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListAccessEntriesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the available access policies.
*
*
* @param listAccessPoliciesRequest
* @return Result of the ListAccessPolicies operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @sample AmazonEKS.ListAccessPolicies
* @see AWS API
* Documentation
*/
@Override
public ListAccessPoliciesResult listAccessPolicies(ListAccessPoliciesRequest request) {
request = beforeClientExecution(request);
return executeListAccessPolicies(request);
}
@SdkInternalApi
final ListAccessPoliciesResult executeListAccessPolicies(ListAccessPoliciesRequest listAccessPoliciesRequest) {
ExecutionContext executionContext = createExecutionContext(listAccessPoliciesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListAccessPoliciesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listAccessPoliciesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListAccessPolicies");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListAccessPoliciesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the installed add-ons.
*
*
* @param listAddonsRequest
* @return Result of the ListAddons operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @sample AmazonEKS.ListAddons
* @see AWS API
* Documentation
*/
@Override
public ListAddonsResult listAddons(ListAddonsRequest request) {
request = beforeClientExecution(request);
return executeListAddons(request);
}
@SdkInternalApi
final ListAddonsResult executeListAddons(ListAddonsRequest listAddonsRequest) {
ExecutionContext executionContext = createExecutionContext(listAddonsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListAddonsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listAddonsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListAddons");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListAddonsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the access policies associated with an access entry.
*
*
* @param listAssociatedAccessPoliciesRequest
* @return Result of the ListAssociatedAccessPolicies operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.ListAssociatedAccessPolicies
* @see AWS API Documentation
*/
@Override
public ListAssociatedAccessPoliciesResult listAssociatedAccessPolicies(ListAssociatedAccessPoliciesRequest request) {
request = beforeClientExecution(request);
return executeListAssociatedAccessPolicies(request);
}
@SdkInternalApi
final ListAssociatedAccessPoliciesResult executeListAssociatedAccessPolicies(ListAssociatedAccessPoliciesRequest listAssociatedAccessPoliciesRequest) {
ExecutionContext executionContext = createExecutionContext(listAssociatedAccessPoliciesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListAssociatedAccessPoliciesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listAssociatedAccessPoliciesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListAssociatedAccessPolicies");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListAssociatedAccessPoliciesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the Amazon EKS clusters in your Amazon Web Services account in the specified Amazon Web Services Region.
*
*
* @param listClustersRequest
* @return Result of the ListClusters operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @sample AmazonEKS.ListClusters
* @see AWS API
* Documentation
*/
@Override
public ListClustersResult listClusters(ListClustersRequest request) {
request = beforeClientExecution(request);
return executeListClusters(request);
}
@SdkInternalApi
final ListClustersResult executeListClusters(ListClustersRequest listClustersRequest) {
ExecutionContext executionContext = createExecutionContext(listClustersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListClustersRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listClustersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListClusters");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListClustersResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Displays the full description of the subscription.
*
*
* @param listEksAnywhereSubscriptionsRequest
* @return Result of the ListEksAnywhereSubscriptions operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @sample AmazonEKS.ListEksAnywhereSubscriptions
* @see AWS API Documentation
*/
@Override
public ListEksAnywhereSubscriptionsResult listEksAnywhereSubscriptions(ListEksAnywhereSubscriptionsRequest request) {
request = beforeClientExecution(request);
return executeListEksAnywhereSubscriptions(request);
}
@SdkInternalApi
final ListEksAnywhereSubscriptionsResult executeListEksAnywhereSubscriptions(ListEksAnywhereSubscriptionsRequest listEksAnywhereSubscriptionsRequest) {
ExecutionContext executionContext = createExecutionContext(listEksAnywhereSubscriptionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListEksAnywhereSubscriptionsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listEksAnywhereSubscriptionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListEksAnywhereSubscriptions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListEksAnywhereSubscriptionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the Fargate profiles associated with the specified cluster in your Amazon Web Services account in the
* specified Amazon Web Services Region.
*
*
* @param listFargateProfilesRequest
* @return Result of the ListFargateProfiles operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @sample AmazonEKS.ListFargateProfiles
* @see AWS API
* Documentation
*/
@Override
public ListFargateProfilesResult listFargateProfiles(ListFargateProfilesRequest request) {
request = beforeClientExecution(request);
return executeListFargateProfiles(request);
}
@SdkInternalApi
final ListFargateProfilesResult executeListFargateProfiles(ListFargateProfilesRequest listFargateProfilesRequest) {
ExecutionContext executionContext = createExecutionContext(listFargateProfilesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListFargateProfilesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listFargateProfilesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListFargateProfiles");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListFargateProfilesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the identity provider configurations for your cluster.
*
*
* @param listIdentityProviderConfigsRequest
* @return Result of the ListIdentityProviderConfigs operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @sample AmazonEKS.ListIdentityProviderConfigs
* @see AWS API Documentation
*/
@Override
public ListIdentityProviderConfigsResult listIdentityProviderConfigs(ListIdentityProviderConfigsRequest request) {
request = beforeClientExecution(request);
return executeListIdentityProviderConfigs(request);
}
@SdkInternalApi
final ListIdentityProviderConfigsResult executeListIdentityProviderConfigs(ListIdentityProviderConfigsRequest listIdentityProviderConfigsRequest) {
ExecutionContext executionContext = createExecutionContext(listIdentityProviderConfigsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListIdentityProviderConfigsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listIdentityProviderConfigsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListIdentityProviderConfigs");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListIdentityProviderConfigsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of all insights checked for against the specified cluster. You can filter which insights are
* returned by category, associated Kubernetes version, and status.
*
*
* @param listInsightsRequest
* @return Result of the ListInsights operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonEKS.ListInsights
* @see AWS API
* Documentation
*/
@Override
public ListInsightsResult listInsights(ListInsightsRequest request) {
request = beforeClientExecution(request);
return executeListInsights(request);
}
@SdkInternalApi
final ListInsightsResult executeListInsights(ListInsightsRequest listInsightsRequest) {
ExecutionContext executionContext = createExecutionContext(listInsightsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListInsightsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listInsightsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListInsights");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListInsightsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the managed node groups associated with the specified cluster in your Amazon Web Services account in the
* specified Amazon Web Services Region. Self-managed node groups aren't listed.
*
*
* @param listNodegroupsRequest
* @return Result of the ListNodegroups operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @sample AmazonEKS.ListNodegroups
* @see AWS API
* Documentation
*/
@Override
public ListNodegroupsResult listNodegroups(ListNodegroupsRequest request) {
request = beforeClientExecution(request);
return executeListNodegroups(request);
}
@SdkInternalApi
final ListNodegroupsResult executeListNodegroups(ListNodegroupsRequest listNodegroupsRequest) {
ExecutionContext executionContext = createExecutionContext(listNodegroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListNodegroupsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listNodegroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListNodegroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListNodegroupsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List the EKS Pod Identity associations in a cluster. You can filter the list by the namespace that the
* association is in or the service account that the association uses.
*
*
* @param listPodIdentityAssociationsRequest
* @return Result of the ListPodIdentityAssociations operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonEKS.ListPodIdentityAssociations
* @see AWS API Documentation
*/
@Override
public ListPodIdentityAssociationsResult listPodIdentityAssociations(ListPodIdentityAssociationsRequest request) {
request = beforeClientExecution(request);
return executeListPodIdentityAssociations(request);
}
@SdkInternalApi
final ListPodIdentityAssociationsResult executeListPodIdentityAssociations(ListPodIdentityAssociationsRequest listPodIdentityAssociationsRequest) {
ExecutionContext executionContext = createExecutionContext(listPodIdentityAssociationsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListPodIdentityAssociationsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listPodIdentityAssociationsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListPodIdentityAssociations");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListPodIdentityAssociationsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List the tags for an Amazon EKS resource.
*
*
* @param listTagsForResourceRequest
* @return Result of the ListTagsForResource operation returned by the service.
* @throws BadRequestException
* This exception is thrown if the request contains a semantic error. The precise meaning will depend on the
* API, and will be documented in the error message.
* @throws NotFoundException
* A service resource associated with the request could not be found. Clients should not retry such
* requests.
* @sample AmazonEKS.ListTagsForResource
* @see AWS API
* Documentation
*/
@Override
public ListTagsForResourceResult listTagsForResource(ListTagsForResourceRequest request) {
request = beforeClientExecution(request);
return executeListTagsForResource(request);
}
@SdkInternalApi
final ListTagsForResourceResult executeListTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest) {
ExecutionContext executionContext = createExecutionContext(listTagsForResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTagsForResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTagsForResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTagsForResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTagsForResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the updates associated with an Amazon EKS resource in your Amazon Web Services account, in the specified
* Amazon Web Services Region.
*
*
* @param listUpdatesRequest
* @return Result of the ListUpdates operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @sample AmazonEKS.ListUpdates
* @see AWS API
* Documentation
*/
@Override
public ListUpdatesResult listUpdates(ListUpdatesRequest request) {
request = beforeClientExecution(request);
return executeListUpdates(request);
}
@SdkInternalApi
final ListUpdatesResult executeListUpdates(ListUpdatesRequest listUpdatesRequest) {
ExecutionContext executionContext = createExecutionContext(listUpdatesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListUpdatesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listUpdatesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListUpdates");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListUpdatesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Connects a Kubernetes cluster to the Amazon EKS control plane.
*
*
* Any Kubernetes cluster can be connected to the Amazon EKS control plane to view current information about the
* cluster and its nodes.
*
*
* Cluster connection requires two steps. First, send a RegisterClusterRequest to add it to
* the Amazon EKS control plane.
*
*
* Second, a Manifest containing the activationID and activationCode must be applied to the
* Kubernetes cluster through it's native provider to provide visibility.
*
*
* After the manifest is updated and applied, the connected cluster is visible to the Amazon EKS control plane. If
* the manifest isn't applied within three days, the connected cluster will no longer be visible and must be
* deregistered using DeregisterCluster.
*
*
* @param registerClusterRequest
* @return Result of the RegisterCluster operation returned by the service.
* @throws ResourceLimitExceededException
* You have encountered a service limit on the specified resource.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ServiceUnavailableException
* The service is unavailable. Back off and retry the operation.
* @throws AccessDeniedException
* You don't have permissions to perform the requested operation. The IAM
* principal making the request must have at least one IAM permissions policy attached that grants the
* required permissions. For more information, see Access management in the IAM
* User Guide.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourcePropagationDelayException
* Required resources (such as service-linked roles) were created and are still propagating. Retry later.
* @sample AmazonEKS.RegisterCluster
* @see AWS API
* Documentation
*/
@Override
public RegisterClusterResult registerCluster(RegisterClusterRequest request) {
request = beforeClientExecution(request);
return executeRegisterCluster(request);
}
@SdkInternalApi
final RegisterClusterResult executeRegisterCluster(RegisterClusterRequest registerClusterRequest) {
ExecutionContext executionContext = createExecutionContext(registerClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RegisterClusterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(registerClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RegisterCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RegisterClusterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Associates the specified tags to an Amazon EKS resource with the specified resourceArn. If existing
* tags on a resource are not specified in the request parameters, they aren't changed. When a resource is deleted,
* the tags associated with that resource are also deleted. Tags that you create for Amazon EKS resources don't
* propagate to any other resources associated with the cluster. For example, if you tag a cluster with this
* operation, that tag doesn't automatically propagate to the subnets and nodes associated with the cluster.
*
*
* @param tagResourceRequest
* @return Result of the TagResource operation returned by the service.
* @throws BadRequestException
* This exception is thrown if the request contains a semantic error. The precise meaning will depend on the
* API, and will be documented in the error message.
* @throws NotFoundException
* A service resource associated with the request could not be found. Clients should not retry such
* requests.
* @sample AmazonEKS.TagResource
* @see AWS API
* Documentation
*/
@Override
public TagResourceResult tagResource(TagResourceRequest request) {
request = beforeClientExecution(request);
return executeTagResource(request);
}
@SdkInternalApi
final TagResourceResult executeTagResource(TagResourceRequest tagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(tagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(tagResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new TagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes specified tags from an Amazon EKS resource.
*
*
* @param untagResourceRequest
* @return Result of the UntagResource operation returned by the service.
* @throws BadRequestException
* This exception is thrown if the request contains a semantic error. The precise meaning will depend on the
* API, and will be documented in the error message.
* @throws NotFoundException
* A service resource associated with the request could not be found. Clients should not retry such
* requests.
* @sample AmazonEKS.UntagResource
* @see AWS API
* Documentation
*/
@Override
public UntagResourceResult untagResource(UntagResourceRequest request) {
request = beforeClientExecution(request);
return executeUntagResource(request);
}
@SdkInternalApi
final UntagResourceResult executeUntagResource(UntagResourceRequest untagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(untagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UntagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(untagResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UntagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UntagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates an access entry.
*
*
* @param updateAccessEntryRequest
* @return Result of the UpdateAccessEntry operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonEKS.UpdateAccessEntry
* @see AWS API
* Documentation
*/
@Override
public UpdateAccessEntryResult updateAccessEntry(UpdateAccessEntryRequest request) {
request = beforeClientExecution(request);
return executeUpdateAccessEntry(request);
}
@SdkInternalApi
final UpdateAccessEntryResult executeUpdateAccessEntry(UpdateAccessEntryRequest updateAccessEntryRequest) {
ExecutionContext executionContext = createExecutionContext(updateAccessEntryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateAccessEntryRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateAccessEntryRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateAccessEntry");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateAccessEntryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates an Amazon EKS add-on.
*
*
* @param updateAddonRequest
* @return Result of the UpdateAddon operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @sample AmazonEKS.UpdateAddon
* @see AWS API
* Documentation
*/
@Override
public UpdateAddonResult updateAddon(UpdateAddonRequest request) {
request = beforeClientExecution(request);
return executeUpdateAddon(request);
}
@SdkInternalApi
final UpdateAddonResult executeUpdateAddon(UpdateAddonRequest updateAddonRequest) {
ExecutionContext executionContext = createExecutionContext(updateAddonRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateAddonRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateAddonRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateAddon");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateAddonResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates an Amazon EKS cluster configuration. Your cluster continues to function during the update. The response
* output includes an update ID that you can use to track the status of your cluster update with
* DescribeUpdate"/>.
*
*
* You can use this API operation to enable or disable exporting the Kubernetes control plane logs for your cluster
* to CloudWatch Logs. By default, cluster control plane logs aren't exported to CloudWatch Logs. For more
* information, see Amazon EKS
* Cluster control plane logs in the Amazon EKS User Guide .
*
*
*
* CloudWatch Logs ingestion, archive storage, and data scanning rates apply to exported control plane logs. For
* more information, see CloudWatch Pricing.
*
*
*
* You can also use this API operation to enable or disable public and private access to your cluster's Kubernetes
* API server endpoint. By default, public access is enabled, and private access is disabled. For more information,
* see Amazon EKS cluster endpoint
* access control in the Amazon EKS User Guide .
*
*
* You can also use this API operation to choose different subnets and security groups for the cluster. You must
* specify at least two subnets that are in different Availability Zones. You can't change which VPC the subnets are
* from, the subnets must be in the same VPC as the subnets that the cluster was created with. For more information
* about the VPC requirements, see https
* ://docs.aws.amazon.com/eks/latest/userguide/network_reqs.html in the Amazon EKS User Guide .
*
*
* Cluster updates are asynchronous, and they should finish within a few minutes. During an update, the cluster
* status moves to UPDATING (this status transition is eventually consistent). When the update is
* complete (either Failed or Successful), the cluster status moves to Active
* .
*
*
* @param updateClusterConfigRequest
* @return Result of the UpdateClusterConfig operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.UpdateClusterConfig
* @see AWS API
* Documentation
*/
@Override
public UpdateClusterConfigResult updateClusterConfig(UpdateClusterConfigRequest request) {
request = beforeClientExecution(request);
return executeUpdateClusterConfig(request);
}
@SdkInternalApi
final UpdateClusterConfigResult executeUpdateClusterConfig(UpdateClusterConfigRequest updateClusterConfigRequest) {
ExecutionContext executionContext = createExecutionContext(updateClusterConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateClusterConfigRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateClusterConfigRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateClusterConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateClusterConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates an Amazon EKS cluster to the specified Kubernetes version. Your cluster continues to function during the
* update. The response output includes an update ID that you can use to track the status of your cluster update
* with the DescribeUpdate API operation.
*
*
* Cluster updates are asynchronous, and they should finish within a few minutes. During an update, the cluster
* status moves to UPDATING (this status transition is eventually consistent). When the update is
* complete (either Failed or Successful), the cluster status moves to Active
* .
*
*
* If your cluster has managed node groups attached to it, all of your node groups’ Kubernetes versions must match
* the cluster’s Kubernetes version in order to update the cluster to a new Kubernetes version.
*
*
* @param updateClusterVersionRequest
* @return Result of the UpdateClusterVersion operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.UpdateClusterVersion
* @see AWS API
* Documentation
*/
@Override
public UpdateClusterVersionResult updateClusterVersion(UpdateClusterVersionRequest request) {
request = beforeClientExecution(request);
return executeUpdateClusterVersion(request);
}
@SdkInternalApi
final UpdateClusterVersionResult executeUpdateClusterVersion(UpdateClusterVersionRequest updateClusterVersionRequest) {
ExecutionContext executionContext = createExecutionContext(updateClusterVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateClusterVersionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateClusterVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateClusterVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateClusterVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Update an EKS Anywhere Subscription. Only auto renewal and tags can be updated after subscription creation.
*
*
* @param updateEksAnywhereSubscriptionRequest
* @return Result of the UpdateEksAnywhereSubscription operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.UpdateEksAnywhereSubscription
* @see AWS API Documentation
*/
@Override
public UpdateEksAnywhereSubscriptionResult updateEksAnywhereSubscription(UpdateEksAnywhereSubscriptionRequest request) {
request = beforeClientExecution(request);
return executeUpdateEksAnywhereSubscription(request);
}
@SdkInternalApi
final UpdateEksAnywhereSubscriptionResult executeUpdateEksAnywhereSubscription(UpdateEksAnywhereSubscriptionRequest updateEksAnywhereSubscriptionRequest) {
ExecutionContext executionContext = createExecutionContext(updateEksAnywhereSubscriptionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateEksAnywhereSubscriptionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateEksAnywhereSubscriptionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateEksAnywhereSubscription");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateEksAnywhereSubscriptionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates an Amazon EKS managed node group configuration. Your node group continues to function during the update.
* The response output includes an update ID that you can use to track the status of your node group update with the
* DescribeUpdate API operation. Currently you can update the Kubernetes labels for a node group or the
* scaling configuration.
*
*
* @param updateNodegroupConfigRequest
* @return Result of the UpdateNodegroupConfig operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.UpdateNodegroupConfig
* @see AWS API
* Documentation
*/
@Override
public UpdateNodegroupConfigResult updateNodegroupConfig(UpdateNodegroupConfigRequest request) {
request = beforeClientExecution(request);
return executeUpdateNodegroupConfig(request);
}
@SdkInternalApi
final UpdateNodegroupConfigResult executeUpdateNodegroupConfig(UpdateNodegroupConfigRequest updateNodegroupConfigRequest) {
ExecutionContext executionContext = createExecutionContext(updateNodegroupConfigRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateNodegroupConfigRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateNodegroupConfigRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateNodegroupConfig");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateNodegroupConfigResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the Kubernetes version or AMI version of an Amazon EKS managed node group.
*
*
* You can update a node group using a launch template only if the node group was originally deployed with a launch
* template. If you need to update a custom AMI in a node group that was deployed with a launch template, then
* update your custom AMI, specify the new ID in a new version of the launch template, and then update the node
* group to the new version of the launch template.
*
*
* If you update without a launch template, then you can update to the latest available AMI version of a node
* group's current Kubernetes version by not specifying a Kubernetes version in the request. You can update to the
* latest AMI version of your cluster's current Kubernetes version by specifying your cluster's Kubernetes version
* in the request. For information about Linux versions, see Amazon EKS optimized Amazon
* Linux AMI versions in the Amazon EKS User Guide. For information about Windows versions, see Amazon EKS optimized
* Windows AMI versions in the Amazon EKS User Guide.
*
*
* You cannot roll back a node group to an earlier Kubernetes version or AMI version.
*
*
* When a node in a managed node group is terminated due to a scaling action or update, every Pod on
* that node is drained first. Amazon EKS attempts to drain the nodes gracefully and will fail if it is unable to do
* so. You can force the update if Amazon EKS is unable to drain the nodes as a result of a
* Pod disruption budget issue.
*
*
* @param updateNodegroupVersionRequest
* @return Result of the UpdateNodegroupVersion operation returned by the service.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClientException
* These errors are usually caused by a client action. Actions can include using an action or resource on
* behalf of an IAM
* principal that doesn't have permissions to use the action or resource or specifying an identifier
* that is not valid.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @sample AmazonEKS.UpdateNodegroupVersion
* @see AWS API
* Documentation
*/
@Override
public UpdateNodegroupVersionResult updateNodegroupVersion(UpdateNodegroupVersionRequest request) {
request = beforeClientExecution(request);
return executeUpdateNodegroupVersion(request);
}
@SdkInternalApi
final UpdateNodegroupVersionResult executeUpdateNodegroupVersion(UpdateNodegroupVersionRequest updateNodegroupVersionRequest) {
ExecutionContext executionContext = createExecutionContext(updateNodegroupVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateNodegroupVersionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateNodegroupVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateNodegroupVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateNodegroupVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a EKS Pod Identity association. Only the IAM role can be changed; an association can't be moved between
* clusters, namespaces, or service accounts. If you need to edit the namespace or service account, you need to
* delete the association and then create a new association with your desired settings.
*
*
* @param updatePodIdentityAssociationRequest
* @return Result of the UpdatePodIdentityAssociation operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server-side issue.
* @throws ResourceNotFoundException
* The specified resource could not be found. You can view your available clusters with
* ListClusters. You can view your available managed node groups with
* ListNodegroups. Amazon EKS clusters and node groups are Amazon Web Services Region specific.
* @throws InvalidRequestException
* The request is invalid given the state of the cluster. Check the state of the cluster and the associated
* operations.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonEKS.UpdatePodIdentityAssociation
* @see AWS API Documentation
*/
@Override
public UpdatePodIdentityAssociationResult updatePodIdentityAssociation(UpdatePodIdentityAssociationRequest request) {
request = beforeClientExecution(request);
return executeUpdatePodIdentityAssociation(request);
}
@SdkInternalApi
final UpdatePodIdentityAssociationResult executeUpdatePodIdentityAssociation(UpdatePodIdentityAssociationRequest updatePodIdentityAssociationRequest) {
ExecutionContext executionContext = createExecutionContext(updatePodIdentityAssociationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdatePodIdentityAssociationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updatePodIdentityAssociationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "EKS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdatePodIdentityAssociation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdatePodIdentityAssociationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
HttpResponseHandler errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@com.amazonaws.annotation.SdkInternalApi
static com.amazonaws.protocol.json.SdkJsonProtocolFactory getProtocolFactory() {
return protocolFactory;
}
@Override
public AmazonEKSWaiters waiters() {
if (waiters == null) {
synchronized (this) {
if (waiters == null) {
waiters = new AmazonEKSWaiters(this);
}
}
}
return waiters;
}
@Override
public void shutdown() {
super.shutdown();
if (waiters != null) {
waiters.shutdown();
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy