com.amazonaws.services.ecs.AmazonECSAsync Maven / Gradle / Ivy
/*
* Copyright 2013-2018 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.ecs;
import javax.annotation.Generated;
import com.amazonaws.services.ecs.model.*;
/**
* Interface for accessing Amazon ECS asynchronously. Each asynchronous method will return a Java Future object
* representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
* notification when an asynchronous operation completes.
*
* Note: Do not directly implement this interface, new methods are added to it regularly. Extend from
* {@link com.amazonaws.services.ecs.AbstractAmazonECSAsync} instead.
*
*
*
* Amazon Elastic Container Service (Amazon ECS) is a highly scalable, fast, container management service that makes it
* easy to run, stop, and manage Docker containers on a cluster. You can host your cluster on a serverless
* infrastructure that is managed by Amazon ECS by launching your services or tasks using the Fargate launch type. For
* more control, you can host your tasks on a cluster of Amazon Elastic Compute Cloud (Amazon EC2) instances that you
* manage by using the EC2 launch type. For more information about launch types, see Amazon ECS Launch Types.
*
*
* Amazon ECS lets you launch and stop container-based applications with simple API calls, allows you to get the state
* of your cluster from a centralized service, and gives you access to many familiar Amazon EC2 features.
*
*
* You can use Amazon ECS to schedule the placement of containers across your cluster based on your resource needs,
* isolation policies, and availability requirements. Amazon ECS eliminates the need for you to operate your own cluster
* management and configuration management systems or worry about scaling your management infrastructure.
*
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public interface AmazonECSAsync extends AmazonECS {
/**
*
* Creates a new Amazon ECS cluster. By default, your account receives a default cluster when you
* launch your first container instance. However, you can create your own cluster with a unique name with the
* CreateCluster action.
*
*
*
* When you call the CreateCluster API operation, Amazon ECS attempts to create the service-linked role for
* your account so that required resources in other AWS services can be managed on your behalf. However, if the IAM
* user that makes the call does not have permissions to create the service-linked role, it is not created. For more
* information, see Using
* Service-Linked Roles for Amazon ECS in the Amazon Elastic Container Service Developer Guide.
*
*
*
* @param createClusterRequest
* @return A Java Future containing the result of the CreateCluster operation returned by the service.
* @sample AmazonECSAsync.CreateCluster
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createClusterAsync(CreateClusterRequest createClusterRequest);
/**
*
* Creates a new Amazon ECS cluster. By default, your account receives a default cluster when you
* launch your first container instance. However, you can create your own cluster with a unique name with the
* CreateCluster action.
*
*
*
* When you call the CreateCluster API operation, Amazon ECS attempts to create the service-linked role for
* your account so that required resources in other AWS services can be managed on your behalf. However, if the IAM
* user that makes the call does not have permissions to create the service-linked role, it is not created. For more
* information, see Using
* Service-Linked Roles for Amazon ECS in the Amazon Elastic Container Service Developer Guide.
*
*
*
* @param createClusterRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateCluster operation returned by the service.
* @sample AmazonECSAsyncHandler.CreateCluster
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createClusterAsync(CreateClusterRequest createClusterRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the CreateCluster operation.
*
* @see #createClusterAsync(CreateClusterRequest)
*/
java.util.concurrent.Future createClusterAsync();
/**
* Simplified method form for invoking the CreateCluster operation with an AsyncHandler.
*
* @see #createClusterAsync(CreateClusterRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future createClusterAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Runs and maintains a desired number of tasks from a specified task definition. If the number of tasks running in
* a service drops below desiredCount, Amazon ECS spawns another copy of the task in the specified
* cluster. To update an existing service, see UpdateService.
*
*
* In addition to maintaining the desired count of tasks in your service, you can optionally run your service behind
* a load balancer. The load balancer distributes traffic across the tasks that are associated with the service. For
* more information, see Service Load
* Balancing in the Amazon Elastic Container Service Developer Guide.
*
*
* You can optionally specify a deployment configuration for your service. During a deployment, the service
* scheduler uses the minimumHealthyPercent and maximumPercent parameters to determine the
* deployment strategy. The deployment is triggered by changing the task definition or the desired count of a
* service with an UpdateService operation.
*
*
* The minimumHealthyPercent represents a lower limit on the number of your service's tasks that must
* remain in the RUNNING state during a deployment, as a percentage of the desiredCount
* (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster
* capacity. For example, if your service has a desiredCount of four tasks and a
* minimumHealthyPercent of 50%, the scheduler can stop two existing tasks to free up cluster capacity
* before starting two new tasks. Tasks for services that do not use a load balancer are considered healthy
* if they are in the RUNNING state. Tasks for services that do use a load balancer are
* considered healthy if they are in the RUNNING state and the container instance they are hosted on is
* reported as healthy by the load balancer. The default value for a replica service for
* minimumHealthyPercent is 50% in the console and 100% for the AWS CLI, the AWS SDKs, and the APIs.
* The default value for a daemon service for minimumHealthyPercent is 0% for the AWS CLI, the AWS
* SDKs, and the APIs and 50% for the console.
*
*
* The maximumPercent parameter represents an upper limit on the number of your service's tasks that
* are allowed in the RUNNING or PENDING state during a deployment, as a percentage of the
* desiredCount (rounded down to the nearest integer). This parameter enables you to define the
* deployment batch size. For example, if your replica service has a desiredCount of four tasks and a
* maximumPercent value of 200%, the scheduler can start four new tasks before stopping the four older
* tasks (provided that the cluster resources required to do this are available). The default value for a replica
* service for maximumPercent is 200%. If you are using a daemon service type, the
* maximumPercent should remain at 100%, which is the default value.
*
*
* When the service scheduler launches new tasks, it determines task placement in your cluster using the following
* logic:
*
*
* -
*
* Determine which of the container instances in your cluster can support your service's task definition (for
* example, they have the required CPU, memory, ports, and container instance attributes).
*
*
* -
*
* By default, the service scheduler attempts to balance tasks across Availability Zones in this manner (although
* you can choose a different placement strategy) with the placementStrategy parameter):
*
*
* -
*
* Sort the valid container instances, giving priority to instances that have the fewest number of running tasks for
* this service in their respective Availability Zone. For example, if zone A has one running service task and zones
* B and C each have zero, valid container instances in either zone B or C are considered optimal for placement.
*
*
* -
*
* Place the new service task on a valid container instance in an optimal Availability Zone (based on the previous
* steps), favoring container instances with the fewest number of running tasks for this service.
*
*
*
*
*
*
* @param createServiceRequest
* @return A Java Future containing the result of the CreateService operation returned by the service.
* @sample AmazonECSAsync.CreateService
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createServiceAsync(CreateServiceRequest createServiceRequest);
/**
*
* Runs and maintains a desired number of tasks from a specified task definition. If the number of tasks running in
* a service drops below desiredCount, Amazon ECS spawns another copy of the task in the specified
* cluster. To update an existing service, see UpdateService.
*
*
* In addition to maintaining the desired count of tasks in your service, you can optionally run your service behind
* a load balancer. The load balancer distributes traffic across the tasks that are associated with the service. For
* more information, see Service Load
* Balancing in the Amazon Elastic Container Service Developer Guide.
*
*
* You can optionally specify a deployment configuration for your service. During a deployment, the service
* scheduler uses the minimumHealthyPercent and maximumPercent parameters to determine the
* deployment strategy. The deployment is triggered by changing the task definition or the desired count of a
* service with an UpdateService operation.
*
*
* The minimumHealthyPercent represents a lower limit on the number of your service's tasks that must
* remain in the RUNNING state during a deployment, as a percentage of the desiredCount
* (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster
* capacity. For example, if your service has a desiredCount of four tasks and a
* minimumHealthyPercent of 50%, the scheduler can stop two existing tasks to free up cluster capacity
* before starting two new tasks. Tasks for services that do not use a load balancer are considered healthy
* if they are in the RUNNING state. Tasks for services that do use a load balancer are
* considered healthy if they are in the RUNNING state and the container instance they are hosted on is
* reported as healthy by the load balancer. The default value for a replica service for
* minimumHealthyPercent is 50% in the console and 100% for the AWS CLI, the AWS SDKs, and the APIs.
* The default value for a daemon service for minimumHealthyPercent is 0% for the AWS CLI, the AWS
* SDKs, and the APIs and 50% for the console.
*
*
* The maximumPercent parameter represents an upper limit on the number of your service's tasks that
* are allowed in the RUNNING or PENDING state during a deployment, as a percentage of the
* desiredCount (rounded down to the nearest integer). This parameter enables you to define the
* deployment batch size. For example, if your replica service has a desiredCount of four tasks and a
* maximumPercent value of 200%, the scheduler can start four new tasks before stopping the four older
* tasks (provided that the cluster resources required to do this are available). The default value for a replica
* service for maximumPercent is 200%. If you are using a daemon service type, the
* maximumPercent should remain at 100%, which is the default value.
*
*
* When the service scheduler launches new tasks, it determines task placement in your cluster using the following
* logic:
*
*
* -
*
* Determine which of the container instances in your cluster can support your service's task definition (for
* example, they have the required CPU, memory, ports, and container instance attributes).
*
*
* -
*
* By default, the service scheduler attempts to balance tasks across Availability Zones in this manner (although
* you can choose a different placement strategy) with the placementStrategy parameter):
*
*
* -
*
* Sort the valid container instances, giving priority to instances that have the fewest number of running tasks for
* this service in their respective Availability Zone. For example, if zone A has one running service task and zones
* B and C each have zero, valid container instances in either zone B or C are considered optimal for placement.
*
*
* -
*
* Place the new service task on a valid container instance in an optimal Availability Zone (based on the previous
* steps), favoring container instances with the fewest number of running tasks for this service.
*
*
*
*
*
*
* @param createServiceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateService operation returned by the service.
* @sample AmazonECSAsyncHandler.CreateService
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createServiceAsync(CreateServiceRequest createServiceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Modifies the ARN and resource ID format of a resource for a specified IAM user, IAM role, or the root user for an
* account. You can specify whether the new ARN and resource ID format are disabled for new resources that are
* created.
*
*
* @param deleteAccountSettingRequest
* @return A Java Future containing the result of the DeleteAccountSetting operation returned by the service.
* @sample AmazonECSAsync.DeleteAccountSetting
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteAccountSettingAsync(DeleteAccountSettingRequest deleteAccountSettingRequest);
/**
*
* Modifies the ARN and resource ID format of a resource for a specified IAM user, IAM role, or the root user for an
* account. You can specify whether the new ARN and resource ID format are disabled for new resources that are
* created.
*
*
* @param deleteAccountSettingRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteAccountSetting operation returned by the service.
* @sample AmazonECSAsyncHandler.DeleteAccountSetting
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteAccountSettingAsync(DeleteAccountSettingRequest deleteAccountSettingRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes one or more custom attributes from an Amazon ECS resource.
*
*
* @param deleteAttributesRequest
* @return A Java Future containing the result of the DeleteAttributes operation returned by the service.
* @sample AmazonECSAsync.DeleteAttributes
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteAttributesAsync(DeleteAttributesRequest deleteAttributesRequest);
/**
*
* Deletes one or more custom attributes from an Amazon ECS resource.
*
*
* @param deleteAttributesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteAttributes operation returned by the service.
* @sample AmazonECSAsyncHandler.DeleteAttributes
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteAttributesAsync(DeleteAttributesRequest deleteAttributesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes the specified cluster. You must deregister all container instances from this cluster before you may
* delete it. You can list the container instances in a cluster with ListContainerInstances and deregister
* them with DeregisterContainerInstance.
*
*
* @param deleteClusterRequest
* @return A Java Future containing the result of the DeleteCluster operation returned by the service.
* @sample AmazonECSAsync.DeleteCluster
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteClusterAsync(DeleteClusterRequest deleteClusterRequest);
/**
*
* Deletes the specified cluster. You must deregister all container instances from this cluster before you may
* delete it. You can list the container instances in a cluster with ListContainerInstances and deregister
* them with DeregisterContainerInstance.
*
*
* @param deleteClusterRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteCluster operation returned by the service.
* @sample AmazonECSAsyncHandler.DeleteCluster
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteClusterAsync(DeleteClusterRequest deleteClusterRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes a specified service within a cluster. You can delete a service if you have no running tasks in it and the
* desired task count is zero. If the service is actively maintaining tasks, you cannot delete it, and you must
* update the service to a desired task count of zero. For more information, see UpdateService.
*
*
*
* When you delete a service, if there are still running tasks that require cleanup, the service status moves from
* ACTIVE to DRAINING, and the service is no longer visible in the console or in the
* ListServices API operation. After the tasks have stopped, then the service status moves from
* DRAINING to INACTIVE. Services in the DRAINING or INACTIVE
* status can still be viewed with the DescribeServices API operation. However, in the future,
* INACTIVE services may be cleaned up and purged from Amazon ECS record keeping, and
* DescribeServices calls on those services return a ServiceNotFoundException error.
*
*
*
* If you attempt to create a new service with the same name as an existing service in either ACTIVE or
* DRAINING status, you receive an error.
*
*
*
* @param deleteServiceRequest
* @return A Java Future containing the result of the DeleteService operation returned by the service.
* @sample AmazonECSAsync.DeleteService
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteServiceAsync(DeleteServiceRequest deleteServiceRequest);
/**
*
* Deletes a specified service within a cluster. You can delete a service if you have no running tasks in it and the
* desired task count is zero. If the service is actively maintaining tasks, you cannot delete it, and you must
* update the service to a desired task count of zero. For more information, see UpdateService.
*
*
*
* When you delete a service, if there are still running tasks that require cleanup, the service status moves from
* ACTIVE to DRAINING, and the service is no longer visible in the console or in the
* ListServices API operation. After the tasks have stopped, then the service status moves from
* DRAINING to INACTIVE. Services in the DRAINING or INACTIVE
* status can still be viewed with the DescribeServices API operation. However, in the future,
* INACTIVE services may be cleaned up and purged from Amazon ECS record keeping, and
* DescribeServices calls on those services return a ServiceNotFoundException error.
*
*
*
* If you attempt to create a new service with the same name as an existing service in either ACTIVE or
* DRAINING status, you receive an error.
*
*
*
* @param deleteServiceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteService operation returned by the service.
* @sample AmazonECSAsyncHandler.DeleteService
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteServiceAsync(DeleteServiceRequest deleteServiceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deregisters an Amazon ECS container instance from the specified cluster. This instance is no longer available to
* run tasks.
*
*
* If you intend to use the container instance for some other purpose after deregistration, you should stop all of
* the tasks running on the container instance before deregistration. That prevents any orphaned tasks from
* consuming resources.
*
*
* Deregistering a container instance removes the instance from a cluster, but it does not terminate the EC2
* instance. If you are finished using the instance, be sure to terminate it in the Amazon EC2 console to stop
* billing.
*
*
*
* If you terminate a running container instance, Amazon ECS automatically deregisters the instance from your
* cluster (stopped container instances or instances with disconnected agents are not automatically deregistered
* when terminated).
*
*
*
* @param deregisterContainerInstanceRequest
* @return A Java Future containing the result of the DeregisterContainerInstance operation returned by the service.
* @sample AmazonECSAsync.DeregisterContainerInstance
* @see AWS API Documentation
*/
java.util.concurrent.Future deregisterContainerInstanceAsync(
DeregisterContainerInstanceRequest deregisterContainerInstanceRequest);
/**
*
* Deregisters an Amazon ECS container instance from the specified cluster. This instance is no longer available to
* run tasks.
*
*
* If you intend to use the container instance for some other purpose after deregistration, you should stop all of
* the tasks running on the container instance before deregistration. That prevents any orphaned tasks from
* consuming resources.
*
*
* Deregistering a container instance removes the instance from a cluster, but it does not terminate the EC2
* instance. If you are finished using the instance, be sure to terminate it in the Amazon EC2 console to stop
* billing.
*
*
*
* If you terminate a running container instance, Amazon ECS automatically deregisters the instance from your
* cluster (stopped container instances or instances with disconnected agents are not automatically deregistered
* when terminated).
*
*
*
* @param deregisterContainerInstanceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeregisterContainerInstance operation returned by the service.
* @sample AmazonECSAsyncHandler.DeregisterContainerInstance
* @see AWS API Documentation
*/
java.util.concurrent.Future deregisterContainerInstanceAsync(
DeregisterContainerInstanceRequest deregisterContainerInstanceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deregisters the specified task definition by family and revision. Upon deregistration, the task definition is
* marked as INACTIVE. Existing tasks and services that reference an INACTIVE task
* definition continue to run without disruption. Existing services that reference an INACTIVE task
* definition can still scale up or down by modifying the service's desired count.
*
*
* You cannot use an INACTIVE task definition to run new tasks or create new services, and you cannot
* update an existing service to reference an INACTIVE task definition (although there may be up to a
* 10-minute window following deregistration where these restrictions have not yet taken effect).
*
*
*
* At this time, INACTIVE task definitions remain discoverable in your account indefinitely. However,
* this behavior is subject to change in the future, so you should not rely on INACTIVE task
* definitions persisting beyond the lifecycle of any associated tasks and services.
*
*
*
* @param deregisterTaskDefinitionRequest
* @return A Java Future containing the result of the DeregisterTaskDefinition operation returned by the service.
* @sample AmazonECSAsync.DeregisterTaskDefinition
* @see AWS
* API Documentation
*/
java.util.concurrent.Future deregisterTaskDefinitionAsync(DeregisterTaskDefinitionRequest deregisterTaskDefinitionRequest);
/**
*
* Deregisters the specified task definition by family and revision. Upon deregistration, the task definition is
* marked as INACTIVE. Existing tasks and services that reference an INACTIVE task
* definition continue to run without disruption. Existing services that reference an INACTIVE task
* definition can still scale up or down by modifying the service's desired count.
*
*
* You cannot use an INACTIVE task definition to run new tasks or create new services, and you cannot
* update an existing service to reference an INACTIVE task definition (although there may be up to a
* 10-minute window following deregistration where these restrictions have not yet taken effect).
*
*
*
* At this time, INACTIVE task definitions remain discoverable in your account indefinitely. However,
* this behavior is subject to change in the future, so you should not rely on INACTIVE task
* definitions persisting beyond the lifecycle of any associated tasks and services.
*
*
*
* @param deregisterTaskDefinitionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeregisterTaskDefinition operation returned by the service.
* @sample AmazonECSAsyncHandler.DeregisterTaskDefinition
* @see AWS
* API Documentation
*/
java.util.concurrent.Future deregisterTaskDefinitionAsync(DeregisterTaskDefinitionRequest deregisterTaskDefinitionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Describes one or more of your clusters.
*
*
* @param describeClustersRequest
* @return A Java Future containing the result of the DescribeClusters operation returned by the service.
* @sample AmazonECSAsync.DescribeClusters
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeClustersAsync(DescribeClustersRequest describeClustersRequest);
/**
*
* Describes one or more of your clusters.
*
*
* @param describeClustersRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeClusters operation returned by the service.
* @sample AmazonECSAsyncHandler.DescribeClusters
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeClustersAsync(DescribeClustersRequest describeClustersRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the DescribeClusters operation.
*
* @see #describeClustersAsync(DescribeClustersRequest)
*/
java.util.concurrent.Future describeClustersAsync();
/**
* Simplified method form for invoking the DescribeClusters operation with an AsyncHandler.
*
* @see #describeClustersAsync(DescribeClustersRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future describeClustersAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Describes Amazon Elastic Container Service container instances. Returns metadata about registered and remaining
* resources on each container instance requested.
*
*
* @param describeContainerInstancesRequest
* @return A Java Future containing the result of the DescribeContainerInstances operation returned by the service.
* @sample AmazonECSAsync.DescribeContainerInstances
* @see AWS
* API Documentation
*/
java.util.concurrent.Future describeContainerInstancesAsync(
DescribeContainerInstancesRequest describeContainerInstancesRequest);
/**
*
* Describes Amazon Elastic Container Service container instances. Returns metadata about registered and remaining
* resources on each container instance requested.
*
*
* @param describeContainerInstancesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeContainerInstances operation returned by the service.
* @sample AmazonECSAsyncHandler.DescribeContainerInstances
* @see AWS
* API Documentation
*/
java.util.concurrent.Future describeContainerInstancesAsync(
DescribeContainerInstancesRequest describeContainerInstancesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Describes the specified services running in your cluster.
*
*
* @param describeServicesRequest
* @return A Java Future containing the result of the DescribeServices operation returned by the service.
* @sample AmazonECSAsync.DescribeServices
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeServicesAsync(DescribeServicesRequest describeServicesRequest);
/**
*
* Describes the specified services running in your cluster.
*
*
* @param describeServicesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeServices operation returned by the service.
* @sample AmazonECSAsyncHandler.DescribeServices
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeServicesAsync(DescribeServicesRequest describeServicesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Describes a task definition. You can specify a family and revision to find information
* about a specific task definition, or you can simply specify the family to find the latest ACTIVE
* revision in that family.
*
*
*
* You can only describe INACTIVE task definitions while an active task or service references them.
*
*
*
* @param describeTaskDefinitionRequest
* @return A Java Future containing the result of the DescribeTaskDefinition operation returned by the service.
* @sample AmazonECSAsync.DescribeTaskDefinition
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeTaskDefinitionAsync(DescribeTaskDefinitionRequest describeTaskDefinitionRequest);
/**
*
* Describes a task definition. You can specify a family and revision to find information
* about a specific task definition, or you can simply specify the family to find the latest ACTIVE
* revision in that family.
*
*
*
* You can only describe INACTIVE task definitions while an active task or service references them.
*
*
*
* @param describeTaskDefinitionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeTaskDefinition operation returned by the service.
* @sample AmazonECSAsyncHandler.DescribeTaskDefinition
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeTaskDefinitionAsync(DescribeTaskDefinitionRequest describeTaskDefinitionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Describes a specified task or tasks.
*
*
* @param describeTasksRequest
* @return A Java Future containing the result of the DescribeTasks operation returned by the service.
* @sample AmazonECSAsync.DescribeTasks
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeTasksAsync(DescribeTasksRequest describeTasksRequest);
/**
*
* Describes a specified task or tasks.
*
*
* @param describeTasksRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DescribeTasks operation returned by the service.
* @sample AmazonECSAsyncHandler.DescribeTasks
* @see AWS API
* Documentation
*/
java.util.concurrent.Future describeTasksAsync(DescribeTasksRequest describeTasksRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Returns an endpoint for the Amazon ECS agent to poll for updates.
*
*
* @param discoverPollEndpointRequest
* @return A Java Future containing the result of the DiscoverPollEndpoint operation returned by the service.
* @sample AmazonECSAsync.DiscoverPollEndpoint
* @see AWS API
* Documentation
*/
java.util.concurrent.Future discoverPollEndpointAsync(DiscoverPollEndpointRequest discoverPollEndpointRequest);
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Returns an endpoint for the Amazon ECS agent to poll for updates.
*
*
* @param discoverPollEndpointRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DiscoverPollEndpoint operation returned by the service.
* @sample AmazonECSAsyncHandler.DiscoverPollEndpoint
* @see AWS API
* Documentation
*/
java.util.concurrent.Future discoverPollEndpointAsync(DiscoverPollEndpointRequest discoverPollEndpointRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the DiscoverPollEndpoint operation.
*
* @see #discoverPollEndpointAsync(DiscoverPollEndpointRequest)
*/
java.util.concurrent.Future discoverPollEndpointAsync();
/**
* Simplified method form for invoking the DiscoverPollEndpoint operation with an AsyncHandler.
*
* @see #discoverPollEndpointAsync(DiscoverPollEndpointRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future discoverPollEndpointAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Lists the account settings for an Amazon ECS resource for a specified principal.
*
*
* @param listAccountSettingsRequest
* @return A Java Future containing the result of the ListAccountSettings operation returned by the service.
* @sample AmazonECSAsync.ListAccountSettings
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listAccountSettingsAsync(ListAccountSettingsRequest listAccountSettingsRequest);
/**
*
* Lists the account settings for an Amazon ECS resource for a specified principal.
*
*
* @param listAccountSettingsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListAccountSettings operation returned by the service.
* @sample AmazonECSAsyncHandler.ListAccountSettings
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listAccountSettingsAsync(ListAccountSettingsRequest listAccountSettingsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Lists the attributes for Amazon ECS resources within a specified target type and cluster. When you specify a
* target type and cluster, ListAttributes returns a list of attribute objects, one for each attribute
* on each resource. You can filter the list of results to a single attribute name to only return results that have
* that name. You can also filter the results by attribute name and value, for example, to see which container
* instances in a cluster are running a Linux AMI (ecs.os-type=linux).
*
*
* @param listAttributesRequest
* @return A Java Future containing the result of the ListAttributes operation returned by the service.
* @sample AmazonECSAsync.ListAttributes
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listAttributesAsync(ListAttributesRequest listAttributesRequest);
/**
*
* Lists the attributes for Amazon ECS resources within a specified target type and cluster. When you specify a
* target type and cluster, ListAttributes returns a list of attribute objects, one for each attribute
* on each resource. You can filter the list of results to a single attribute name to only return results that have
* that name. You can also filter the results by attribute name and value, for example, to see which container
* instances in a cluster are running a Linux AMI (ecs.os-type=linux).
*
*
* @param listAttributesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListAttributes operation returned by the service.
* @sample AmazonECSAsyncHandler.ListAttributes
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listAttributesAsync(ListAttributesRequest listAttributesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a list of existing clusters.
*
*
* @param listClustersRequest
* @return A Java Future containing the result of the ListClusters operation returned by the service.
* @sample AmazonECSAsync.ListClusters
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listClustersAsync(ListClustersRequest listClustersRequest);
/**
*
* Returns a list of existing clusters.
*
*
* @param listClustersRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListClusters operation returned by the service.
* @sample AmazonECSAsyncHandler.ListClusters
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listClustersAsync(ListClustersRequest listClustersRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ListClusters operation.
*
* @see #listClustersAsync(ListClustersRequest)
*/
java.util.concurrent.Future listClustersAsync();
/**
* Simplified method form for invoking the ListClusters operation with an AsyncHandler.
*
* @see #listClustersAsync(ListClustersRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future listClustersAsync(com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a list of container instances in a specified cluster. You can filter the results of a
* ListContainerInstances operation with cluster query language statements inside the
* filter parameter. For more information, see Cluster Query
* Language in the Amazon Elastic Container Service Developer Guide.
*
*
* @param listContainerInstancesRequest
* @return A Java Future containing the result of the ListContainerInstances operation returned by the service.
* @sample AmazonECSAsync.ListContainerInstances
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listContainerInstancesAsync(ListContainerInstancesRequest listContainerInstancesRequest);
/**
*
* Returns a list of container instances in a specified cluster. You can filter the results of a
* ListContainerInstances operation with cluster query language statements inside the
* filter parameter. For more information, see Cluster Query
* Language in the Amazon Elastic Container Service Developer Guide.
*
*
* @param listContainerInstancesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListContainerInstances operation returned by the service.
* @sample AmazonECSAsyncHandler.ListContainerInstances
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listContainerInstancesAsync(ListContainerInstancesRequest listContainerInstancesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ListContainerInstances operation.
*
* @see #listContainerInstancesAsync(ListContainerInstancesRequest)
*/
java.util.concurrent.Future listContainerInstancesAsync();
/**
* Simplified method form for invoking the ListContainerInstances operation with an AsyncHandler.
*
* @see #listContainerInstancesAsync(ListContainerInstancesRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future listContainerInstancesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Lists the services that are running in a specified cluster.
*
*
* @param listServicesRequest
* @return A Java Future containing the result of the ListServices operation returned by the service.
* @sample AmazonECSAsync.ListServices
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listServicesAsync(ListServicesRequest listServicesRequest);
/**
*
* Lists the services that are running in a specified cluster.
*
*
* @param listServicesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListServices operation returned by the service.
* @sample AmazonECSAsyncHandler.ListServices
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listServicesAsync(ListServicesRequest listServicesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ListServices operation.
*
* @see #listServicesAsync(ListServicesRequest)
*/
java.util.concurrent.Future listServicesAsync();
/**
* Simplified method form for invoking the ListServices operation with an AsyncHandler.
*
* @see #listServicesAsync(ListServicesRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future listServicesAsync(com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* List the tags for an Amazon ECS resource.
*
*
* @param listTagsForResourceRequest
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* @sample AmazonECSAsync.ListTagsForResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest listTagsForResourceRequest);
/**
*
* List the tags for an Amazon ECS resource.
*
*
* @param listTagsForResourceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* @sample AmazonECSAsyncHandler.ListTagsForResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest listTagsForResourceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a list of task definition families that are registered to your account (which may include task definition
* families that no longer have any ACTIVE task definition revisions).
*
*
* You can filter out task definition families that do not contain any ACTIVE task definition revisions
* by setting the status parameter to ACTIVE. You can also filter the results with the
* familyPrefix parameter.
*
*
* @param listTaskDefinitionFamiliesRequest
* @return A Java Future containing the result of the ListTaskDefinitionFamilies operation returned by the service.
* @sample AmazonECSAsync.ListTaskDefinitionFamilies
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listTaskDefinitionFamiliesAsync(
ListTaskDefinitionFamiliesRequest listTaskDefinitionFamiliesRequest);
/**
*
* Returns a list of task definition families that are registered to your account (which may include task definition
* families that no longer have any ACTIVE task definition revisions).
*
*
* You can filter out task definition families that do not contain any ACTIVE task definition revisions
* by setting the status parameter to ACTIVE. You can also filter the results with the
* familyPrefix parameter.
*
*
* @param listTaskDefinitionFamiliesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListTaskDefinitionFamilies operation returned by the service.
* @sample AmazonECSAsyncHandler.ListTaskDefinitionFamilies
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listTaskDefinitionFamiliesAsync(
ListTaskDefinitionFamiliesRequest listTaskDefinitionFamiliesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ListTaskDefinitionFamilies operation.
*
* @see #listTaskDefinitionFamiliesAsync(ListTaskDefinitionFamiliesRequest)
*/
java.util.concurrent.Future listTaskDefinitionFamiliesAsync();
/**
* Simplified method form for invoking the ListTaskDefinitionFamilies operation with an AsyncHandler.
*
* @see #listTaskDefinitionFamiliesAsync(ListTaskDefinitionFamiliesRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future listTaskDefinitionFamiliesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a list of task definitions that are registered to your account. You can filter the results by family name
* with the familyPrefix parameter or by status with the status parameter.
*
*
* @param listTaskDefinitionsRequest
* @return A Java Future containing the result of the ListTaskDefinitions operation returned by the service.
* @sample AmazonECSAsync.ListTaskDefinitions
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listTaskDefinitionsAsync(ListTaskDefinitionsRequest listTaskDefinitionsRequest);
/**
*
* Returns a list of task definitions that are registered to your account. You can filter the results by family name
* with the familyPrefix parameter or by status with the status parameter.
*
*
* @param listTaskDefinitionsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListTaskDefinitions operation returned by the service.
* @sample AmazonECSAsyncHandler.ListTaskDefinitions
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listTaskDefinitionsAsync(ListTaskDefinitionsRequest listTaskDefinitionsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ListTaskDefinitions operation.
*
* @see #listTaskDefinitionsAsync(ListTaskDefinitionsRequest)
*/
java.util.concurrent.Future listTaskDefinitionsAsync();
/**
* Simplified method form for invoking the ListTaskDefinitions operation with an AsyncHandler.
*
* @see #listTaskDefinitionsAsync(ListTaskDefinitionsRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future listTaskDefinitionsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a list of tasks for a specified cluster. You can filter the results by family name, by a particular
* container instance, or by the desired status of the task with the family,
* containerInstance, and desiredStatus parameters.
*
*
* Recently stopped tasks might appear in the returned results. Currently, stopped tasks appear in the returned
* results for at least one hour.
*
*
* @param listTasksRequest
* @return A Java Future containing the result of the ListTasks operation returned by the service.
* @sample AmazonECSAsync.ListTasks
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listTasksAsync(ListTasksRequest listTasksRequest);
/**
*
* Returns a list of tasks for a specified cluster. You can filter the results by family name, by a particular
* container instance, or by the desired status of the task with the family,
* containerInstance, and desiredStatus parameters.
*
*
* Recently stopped tasks might appear in the returned results. Currently, stopped tasks appear in the returned
* results for at least one hour.
*
*
* @param listTasksRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListTasks operation returned by the service.
* @sample AmazonECSAsyncHandler.ListTasks
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listTasksAsync(ListTasksRequest listTasksRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ListTasks operation.
*
* @see #listTasksAsync(ListTasksRequest)
*/
java.util.concurrent.Future listTasksAsync();
/**
* Simplified method form for invoking the ListTasks operation with an AsyncHandler.
*
* @see #listTasksAsync(ListTasksRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future listTasksAsync(com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Modifies the ARN and resource ID format of a resource for a specified IAM user, IAM role, or the root user for an
* account. You can specify whether the new ARN and resource ID format are enabled for new resources that are
* created. Enabling this setting is required to use new Amazon ECS features such as resource tagging.
*
*
* @param putAccountSettingRequest
* @return A Java Future containing the result of the PutAccountSetting operation returned by the service.
* @sample AmazonECSAsync.PutAccountSetting
* @see AWS API
* Documentation
*/
java.util.concurrent.Future putAccountSettingAsync(PutAccountSettingRequest putAccountSettingRequest);
/**
*
* Modifies the ARN and resource ID format of a resource for a specified IAM user, IAM role, or the root user for an
* account. You can specify whether the new ARN and resource ID format are enabled for new resources that are
* created. Enabling this setting is required to use new Amazon ECS features such as resource tagging.
*
*
* @param putAccountSettingRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutAccountSetting operation returned by the service.
* @sample AmazonECSAsyncHandler.PutAccountSetting
* @see AWS API
* Documentation
*/
java.util.concurrent.Future putAccountSettingAsync(PutAccountSettingRequest putAccountSettingRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Create or update an attribute on an Amazon ECS resource. If the attribute does not exist, it is created. If the
* attribute exists, its value is replaced with the specified value. To delete an attribute, use
* DeleteAttributes. For more information, see Attributes in the Amazon Elastic Container Service Developer Guide.
*
*
* @param putAttributesRequest
* @return A Java Future containing the result of the PutAttributes operation returned by the service.
* @sample AmazonECSAsync.PutAttributes
* @see AWS API
* Documentation
*/
java.util.concurrent.Future putAttributesAsync(PutAttributesRequest putAttributesRequest);
/**
*
* Create or update an attribute on an Amazon ECS resource. If the attribute does not exist, it is created. If the
* attribute exists, its value is replaced with the specified value. To delete an attribute, use
* DeleteAttributes. For more information, see Attributes in the Amazon Elastic Container Service Developer Guide.
*
*
* @param putAttributesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PutAttributes operation returned by the service.
* @sample AmazonECSAsyncHandler.PutAttributes
* @see AWS API
* Documentation
*/
java.util.concurrent.Future putAttributesAsync(PutAttributesRequest putAttributesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Registers an EC2 instance into the specified cluster. This instance becomes available to place containers on.
*
*
* @param registerContainerInstanceRequest
* @return A Java Future containing the result of the RegisterContainerInstance operation returned by the service.
* @sample AmazonECSAsync.RegisterContainerInstance
* @see AWS
* API Documentation
*/
java.util.concurrent.Future registerContainerInstanceAsync(
RegisterContainerInstanceRequest registerContainerInstanceRequest);
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Registers an EC2 instance into the specified cluster. This instance becomes available to place containers on.
*
*
* @param registerContainerInstanceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the RegisterContainerInstance operation returned by the service.
* @sample AmazonECSAsyncHandler.RegisterContainerInstance
* @see AWS
* API Documentation
*/
java.util.concurrent.Future registerContainerInstanceAsync(
RegisterContainerInstanceRequest registerContainerInstanceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Registers a new task definition from the supplied family and containerDefinitions.
* Optionally, you can add data volumes to your containers with the volumes parameter. For more
* information about task definition parameters and defaults, see Amazon ECS Task
* Definitions in the Amazon Elastic Container Service Developer Guide.
*
*
* You can specify an IAM role for your task with the taskRoleArn parameter. When you specify an IAM
* role for a task, its containers can then use the latest versions of the AWS CLI or SDKs to make API requests to
* the AWS services that are specified in the IAM policy associated with the role. For more information, see IAM Roles for Tasks in
* the Amazon Elastic Container Service Developer Guide.
*
*
* You can specify a Docker networking mode for the containers in your task definition with the
* networkMode parameter. The available network modes correspond to those described in Network settings in the Docker run
* reference. If you specify the awsvpc network mode, the task is allocated an elastic network
* interface, and you must specify a NetworkConfiguration when you create a service or run a task with the
* task definition. For more information, see Task Networking in the
* Amazon Elastic Container Service Developer Guide.
*
*
* @param registerTaskDefinitionRequest
* @return A Java Future containing the result of the RegisterTaskDefinition operation returned by the service.
* @sample AmazonECSAsync.RegisterTaskDefinition
* @see AWS API
* Documentation
*/
java.util.concurrent.Future registerTaskDefinitionAsync(RegisterTaskDefinitionRequest registerTaskDefinitionRequest);
/**
*
* Registers a new task definition from the supplied family and containerDefinitions.
* Optionally, you can add data volumes to your containers with the volumes parameter. For more
* information about task definition parameters and defaults, see Amazon ECS Task
* Definitions in the Amazon Elastic Container Service Developer Guide.
*
*
* You can specify an IAM role for your task with the taskRoleArn parameter. When you specify an IAM
* role for a task, its containers can then use the latest versions of the AWS CLI or SDKs to make API requests to
* the AWS services that are specified in the IAM policy associated with the role. For more information, see IAM Roles for Tasks in
* the Amazon Elastic Container Service Developer Guide.
*
*
* You can specify a Docker networking mode for the containers in your task definition with the
* networkMode parameter. The available network modes correspond to those described in Network settings in the Docker run
* reference. If you specify the awsvpc network mode, the task is allocated an elastic network
* interface, and you must specify a NetworkConfiguration when you create a service or run a task with the
* task definition. For more information, see Task Networking in the
* Amazon Elastic Container Service Developer Guide.
*
*
* @param registerTaskDefinitionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the RegisterTaskDefinition operation returned by the service.
* @sample AmazonECSAsyncHandler.RegisterTaskDefinition
* @see AWS API
* Documentation
*/
java.util.concurrent.Future registerTaskDefinitionAsync(RegisterTaskDefinitionRequest registerTaskDefinitionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Starts a new task using the specified task definition.
*
*
* You can allow Amazon ECS to place tasks for you, or you can customize how Amazon ECS places tasks using placement
* constraints and placement strategies. For more information, see Scheduling Tasks in
* the Amazon Elastic Container Service Developer Guide.
*
*
* Alternatively, you can use StartTask to use your own scheduler or place tasks manually on specific
* container instances.
*
*
* The Amazon ECS API follows an eventual consistency model, due to the distributed nature of the system supporting
* the API. This means that the result of an API command you run that affects your Amazon ECS resources might not be
* immediately visible to all subsequent commands you run. Keep this in mind when you carry out an API command that
* immediately follows a previous API command.
*
*
* To manage eventual consistency, you can do the following:
*
*
* -
*
* Confirm the state of the resource before you run a command to modify it. Run the DescribeTasks command using an
* exponential backoff algorithm to ensure that you allow enough time for the previous command to propagate through
* the system. To do this, run the DescribeTasks command repeatedly, starting with a couple of seconds of wait time
* and increasing gradually up to five minutes of wait time.
*
*
* -
*
* Add wait time between subsequent commands, even if the DescribeTasks command returns an accurate response. Apply
* an exponential backoff algorithm starting with a couple of seconds of wait time, and increase gradually up to
* about five minutes of wait time.
*
*
*
*
* @param runTaskRequest
* @return A Java Future containing the result of the RunTask operation returned by the service.
* @sample AmazonECSAsync.RunTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future runTaskAsync(RunTaskRequest runTaskRequest);
/**
*
* Starts a new task using the specified task definition.
*
*
* You can allow Amazon ECS to place tasks for you, or you can customize how Amazon ECS places tasks using placement
* constraints and placement strategies. For more information, see Scheduling Tasks in
* the Amazon Elastic Container Service Developer Guide.
*
*
* Alternatively, you can use StartTask to use your own scheduler or place tasks manually on specific
* container instances.
*
*
* The Amazon ECS API follows an eventual consistency model, due to the distributed nature of the system supporting
* the API. This means that the result of an API command you run that affects your Amazon ECS resources might not be
* immediately visible to all subsequent commands you run. Keep this in mind when you carry out an API command that
* immediately follows a previous API command.
*
*
* To manage eventual consistency, you can do the following:
*
*
* -
*
* Confirm the state of the resource before you run a command to modify it. Run the DescribeTasks command using an
* exponential backoff algorithm to ensure that you allow enough time for the previous command to propagate through
* the system. To do this, run the DescribeTasks command repeatedly, starting with a couple of seconds of wait time
* and increasing gradually up to five minutes of wait time.
*
*
* -
*
* Add wait time between subsequent commands, even if the DescribeTasks command returns an accurate response. Apply
* an exponential backoff algorithm starting with a couple of seconds of wait time, and increase gradually up to
* about five minutes of wait time.
*
*
*
*
* @param runTaskRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the RunTask operation returned by the service.
* @sample AmazonECSAsyncHandler.RunTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future runTaskAsync(RunTaskRequest runTaskRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Starts a new task from the specified task definition on the specified container instance or instances.
*
*
* Alternatively, you can use RunTask to place tasks for you. For more information, see Scheduling Tasks in
* the Amazon Elastic Container Service Developer Guide.
*
*
* @param startTaskRequest
* @return A Java Future containing the result of the StartTask operation returned by the service.
* @sample AmazonECSAsync.StartTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future startTaskAsync(StartTaskRequest startTaskRequest);
/**
*
* Starts a new task from the specified task definition on the specified container instance or instances.
*
*
* Alternatively, you can use RunTask to place tasks for you. For more information, see Scheduling Tasks in
* the Amazon Elastic Container Service Developer Guide.
*
*
* @param startTaskRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the StartTask operation returned by the service.
* @sample AmazonECSAsyncHandler.StartTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future startTaskAsync(StartTaskRequest startTaskRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Stops a running task. Any tags associated with the task will be deleted.
*
*
* When StopTask is called on a task, the equivalent of docker stop is issued to the containers
* running in the task. This results in a SIGTERM and a default 30-second timeout, after which
* SIGKILL is sent and the containers are forcibly stopped. If the container handles the
* SIGTERM gracefully and exits within 30 seconds from receiving it, no SIGKILL is sent.
*
*
*
* The default 30-second timeout can be configured on the Amazon ECS container agent with the
* ECS_CONTAINER_STOP_TIMEOUT variable. For more information, see Amazon ECS Container
* Agent Configuration in the Amazon Elastic Container Service Developer Guide.
*
*
*
* @param stopTaskRequest
* @return A Java Future containing the result of the StopTask operation returned by the service.
* @sample AmazonECSAsync.StopTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future stopTaskAsync(StopTaskRequest stopTaskRequest);
/**
*
* Stops a running task. Any tags associated with the task will be deleted.
*
*
* When StopTask is called on a task, the equivalent of docker stop is issued to the containers
* running in the task. This results in a SIGTERM and a default 30-second timeout, after which
* SIGKILL is sent and the containers are forcibly stopped. If the container handles the
* SIGTERM gracefully and exits within 30 seconds from receiving it, no SIGKILL is sent.
*
*
*
* The default 30-second timeout can be configured on the Amazon ECS container agent with the
* ECS_CONTAINER_STOP_TIMEOUT variable. For more information, see Amazon ECS Container
* Agent Configuration in the Amazon Elastic Container Service Developer Guide.
*
*
*
* @param stopTaskRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the StopTask operation returned by the service.
* @sample AmazonECSAsyncHandler.StopTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future stopTaskAsync(StopTaskRequest stopTaskRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Sent to acknowledge that a container changed states.
*
*
* @param submitContainerStateChangeRequest
* @return A Java Future containing the result of the SubmitContainerStateChange operation returned by the service.
* @sample AmazonECSAsync.SubmitContainerStateChange
* @see AWS
* API Documentation
*/
java.util.concurrent.Future submitContainerStateChangeAsync(
SubmitContainerStateChangeRequest submitContainerStateChangeRequest);
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Sent to acknowledge that a container changed states.
*
*
* @param submitContainerStateChangeRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the SubmitContainerStateChange operation returned by the service.
* @sample AmazonECSAsyncHandler.SubmitContainerStateChange
* @see AWS
* API Documentation
*/
java.util.concurrent.Future submitContainerStateChangeAsync(
SubmitContainerStateChangeRequest submitContainerStateChangeRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the SubmitContainerStateChange operation.
*
* @see #submitContainerStateChangeAsync(SubmitContainerStateChangeRequest)
*/
java.util.concurrent.Future submitContainerStateChangeAsync();
/**
* Simplified method form for invoking the SubmitContainerStateChange operation with an AsyncHandler.
*
* @see #submitContainerStateChangeAsync(SubmitContainerStateChangeRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future submitContainerStateChangeAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Sent to acknowledge that a task changed states.
*
*
* @param submitTaskStateChangeRequest
* @return A Java Future containing the result of the SubmitTaskStateChange operation returned by the service.
* @sample AmazonECSAsync.SubmitTaskStateChange
* @see AWS API
* Documentation
*/
java.util.concurrent.Future submitTaskStateChangeAsync(SubmitTaskStateChangeRequest submitTaskStateChangeRequest);
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Sent to acknowledge that a task changed states.
*
*
* @param submitTaskStateChangeRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the SubmitTaskStateChange operation returned by the service.
* @sample AmazonECSAsyncHandler.SubmitTaskStateChange
* @see AWS API
* Documentation
*/
java.util.concurrent.Future submitTaskStateChangeAsync(SubmitTaskStateChangeRequest submitTaskStateChangeRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Associates the specified tags to a resource with the specified resourceArn. If existing tags on a
* resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags
* associated with that resource are deleted as well.
*
*
* @param tagResourceRequest
* @return A Java Future containing the result of the TagResource operation returned by the service.
* @sample AmazonECSAsync.TagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future tagResourceAsync(TagResourceRequest tagResourceRequest);
/**
*
* Associates the specified tags to a resource with the specified resourceArn. If existing tags on a
* resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags
* associated with that resource are deleted as well.
*
*
* @param tagResourceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the TagResource operation returned by the service.
* @sample AmazonECSAsyncHandler.TagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future tagResourceAsync(TagResourceRequest tagResourceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes specified tags from a resource.
*
*
* @param untagResourceRequest
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* @sample AmazonECSAsync.UntagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future untagResourceAsync(UntagResourceRequest untagResourceRequest);
/**
*
* Deletes specified tags from a resource.
*
*
* @param untagResourceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* @sample AmazonECSAsyncHandler.UntagResource
* @see AWS API
* Documentation
*/
java.util.concurrent.Future untagResourceAsync(UntagResourceRequest untagResourceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Updates the Amazon ECS container agent on a specified container instance. Updating the Amazon ECS container agent
* does not interrupt running tasks or services on the container instance. The process for updating the agent
* differs depending on whether your container instance was launched with the Amazon ECS-optimized AMI or another
* operating system.
*
*
* UpdateContainerAgent requires the Amazon ECS-optimized AMI or Amazon Linux with the
* ecs-init service installed and running. For help updating the Amazon ECS container agent on other
* operating systems, see Manually Updating the Amazon ECS Container Agent in the Amazon Elastic Container Service Developer
* Guide.
*
*
* @param updateContainerAgentRequest
* @return A Java Future containing the result of the UpdateContainerAgent operation returned by the service.
* @sample AmazonECSAsync.UpdateContainerAgent
* @see AWS API
* Documentation
*/
java.util.concurrent.Future updateContainerAgentAsync(UpdateContainerAgentRequest updateContainerAgentRequest);
/**
*
* Updates the Amazon ECS container agent on a specified container instance. Updating the Amazon ECS container agent
* does not interrupt running tasks or services on the container instance. The process for updating the agent
* differs depending on whether your container instance was launched with the Amazon ECS-optimized AMI or another
* operating system.
*
*
* UpdateContainerAgent requires the Amazon ECS-optimized AMI or Amazon Linux with the
* ecs-init service installed and running. For help updating the Amazon ECS container agent on other
* operating systems, see Manually Updating the Amazon ECS Container Agent in the Amazon Elastic Container Service Developer
* Guide.
*
*
* @param updateContainerAgentRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UpdateContainerAgent operation returned by the service.
* @sample AmazonECSAsyncHandler.UpdateContainerAgent
* @see AWS API
* Documentation
*/
java.util.concurrent.Future updateContainerAgentAsync(UpdateContainerAgentRequest updateContainerAgentRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Modifies the status of an Amazon ECS container instance.
*
*
* You can change the status of a container instance to DRAINING to manually remove an instance from a
* cluster, for example to perform system updates, update the Docker daemon, or scale down the cluster size.
*
*
* When you set a container instance to DRAINING, Amazon ECS prevents new tasks from being scheduled
* for placement on the container instance and replacement service tasks are started on other container instances in
* the cluster if the resources are available. Service tasks on the container instance that are in the
* PENDING state are stopped immediately.
*
*
* Service tasks on the container instance that are in the RUNNING state are stopped and replaced
* according to the service's deployment configuration parameters, minimumHealthyPercent and
* maximumPercent. You can change the deployment configuration of your service using
* UpdateService.
*
*
* -
*
* If minimumHealthyPercent is below 100%, the scheduler can ignore desiredCount
* temporarily during task replacement. For example, desiredCount is four tasks, a minimum of 50%
* allows the scheduler to stop two existing tasks before starting two new tasks. If the minimum is 100%, the
* service scheduler can't remove existing tasks until the replacement tasks are considered healthy. Tasks for
* services that do not use a load balancer are considered healthy if they are in the RUNNING state.
* Tasks for services that use a load balancer are considered healthy if they are in the RUNNING state
* and the container instance they are hosted on is reported as healthy by the load balancer.
*
*
* -
*
* The maximumPercent parameter represents an upper limit on the number of running tasks during task
* replacement, which enables you to define the replacement batch size. For example, if desiredCount of
* four tasks, a maximum of 200% starts four new tasks before stopping the four tasks to be drained (provided that
* the cluster resources required to do this are available). If the maximum is 100%, then replacement tasks can't
* start until the draining tasks have stopped.
*
*
*
*
* Any PENDING or RUNNING tasks that do not belong to a service are not affected. You must
* wait for them to finish or stop them manually.
*
*
* A container instance has completed draining when it has no more RUNNING tasks. You can verify this
* using ListTasks.
*
*
* When you set a container instance to ACTIVE, the Amazon ECS scheduler can begin scheduling tasks on
* the instance again.
*
*
* @param updateContainerInstancesStateRequest
* @return A Java Future containing the result of the UpdateContainerInstancesState operation returned by the
* service.
* @sample AmazonECSAsync.UpdateContainerInstancesState
* @see AWS API Documentation
*/
java.util.concurrent.Future updateContainerInstancesStateAsync(
UpdateContainerInstancesStateRequest updateContainerInstancesStateRequest);
/**
*
* Modifies the status of an Amazon ECS container instance.
*
*
* You can change the status of a container instance to DRAINING to manually remove an instance from a
* cluster, for example to perform system updates, update the Docker daemon, or scale down the cluster size.
*
*
* When you set a container instance to DRAINING, Amazon ECS prevents new tasks from being scheduled
* for placement on the container instance and replacement service tasks are started on other container instances in
* the cluster if the resources are available. Service tasks on the container instance that are in the
* PENDING state are stopped immediately.
*
*
* Service tasks on the container instance that are in the RUNNING state are stopped and replaced
* according to the service's deployment configuration parameters, minimumHealthyPercent and
* maximumPercent. You can change the deployment configuration of your service using
* UpdateService.
*
*
* -
*
* If minimumHealthyPercent is below 100%, the scheduler can ignore desiredCount
* temporarily during task replacement. For example, desiredCount is four tasks, a minimum of 50%
* allows the scheduler to stop two existing tasks before starting two new tasks. If the minimum is 100%, the
* service scheduler can't remove existing tasks until the replacement tasks are considered healthy. Tasks for
* services that do not use a load balancer are considered healthy if they are in the RUNNING state.
* Tasks for services that use a load balancer are considered healthy if they are in the RUNNING state
* and the container instance they are hosted on is reported as healthy by the load balancer.
*
*
* -
*
* The maximumPercent parameter represents an upper limit on the number of running tasks during task
* replacement, which enables you to define the replacement batch size. For example, if desiredCount of
* four tasks, a maximum of 200% starts four new tasks before stopping the four tasks to be drained (provided that
* the cluster resources required to do this are available). If the maximum is 100%, then replacement tasks can't
* start until the draining tasks have stopped.
*
*
*
*
* Any PENDING or RUNNING tasks that do not belong to a service are not affected. You must
* wait for them to finish or stop them manually.
*
*
* A container instance has completed draining when it has no more RUNNING tasks. You can verify this
* using ListTasks.
*
*
* When you set a container instance to ACTIVE, the Amazon ECS scheduler can begin scheduling tasks on
* the instance again.
*
*
* @param updateContainerInstancesStateRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UpdateContainerInstancesState operation returned by the
* service.
* @sample AmazonECSAsyncHandler.UpdateContainerInstancesState
* @see AWS API Documentation
*/
java.util.concurrent.Future updateContainerInstancesStateAsync(
UpdateContainerInstancesStateRequest updateContainerInstancesStateRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Modifies the desired count, deployment configuration, network configuration, or task definition used in a
* service.
*
*
* You can add to or subtract from the number of instantiations of a task definition in a service by specifying the
* cluster that the service is running in and a new desiredCount parameter.
*
*
* If you have updated the Docker image of your application, you can create a new task definition with that image
* and deploy it to your service. The service scheduler uses the minimum healthy percent and maximum percent
* parameters (in the service's deployment configuration) to determine the deployment strategy.
*
*
*
* If your updated Docker image uses the same tag as what is in the existing task definition for your service (for
* example, my_image:latest), you do not need to create a new revision of your task definition. You can
* update the service using the forceNewDeployment option. The new tasks launched by the deployment
* pull the current image/tag combination from your repository when they start.
*
*
*
* You can also update the deployment configuration of a service. When a deployment is triggered by updating the
* task definition of a service, the service scheduler uses the deployment configuration parameters,
* minimumHealthyPercent and maximumPercent, to determine the deployment strategy.
*
*
* -
*
* If minimumHealthyPercent is below 100%, the scheduler can ignore desiredCount
* temporarily during a deployment. For example, if desiredCount is four tasks, a minimum of 50% allows
* the scheduler to stop two existing tasks before starting two new tasks. Tasks for services that do not use a load
* balancer are considered healthy if they are in the RUNNING state. Tasks for services that use a load
* balancer are considered healthy if they are in the RUNNING state and the container instance they are
* hosted on is reported as healthy by the load balancer.
*
*
* -
*
* The maximumPercent parameter represents an upper limit on the number of running tasks during a
* deployment, which enables you to define the deployment batch size. For example, if desiredCount is
* four tasks, a maximum of 200% starts four new tasks before stopping the four older tasks (provided that the
* cluster resources required to do this are available).
*
*
*
*
* When UpdateService stops a task during a deployment, the equivalent of docker stop is issued
* to the containers running in the task. This results in a SIGTERM and a 30-second timeout, after
* which SIGKILL is sent and the containers are forcibly stopped. If the container handles the
* SIGTERM gracefully and exits within 30 seconds from receiving it, no SIGKILL is sent.
*
*
* When the service scheduler launches new tasks, it determines task placement in your cluster with the following
* logic:
*
*
* -
*
* Determine which of the container instances in your cluster can support your service's task definition (for
* example, they have the required CPU, memory, ports, and container instance attributes).
*
*
* -
*
* By default, the service scheduler attempts to balance tasks across Availability Zones in this manner (although
* you can choose a different placement strategy):
*
*
* -
*
* Sort the valid container instances by the fewest number of running tasks for this service in the same
* Availability Zone as the instance. For example, if zone A has one running service task and zones B and C each
* have zero, valid container instances in either zone B or C are considered optimal for placement.
*
*
* -
*
* Place the new service task on a valid container instance in an optimal Availability Zone (based on the previous
* steps), favoring container instances with the fewest number of running tasks for this service.
*
*
*
*
*
*
* When the service scheduler stops running tasks, it attempts to maintain balance across the Availability Zones in
* your cluster using the following logic:
*
*
* -
*
* Sort the container instances by the largest number of running tasks for this service in the same Availability
* Zone as the instance. For example, if zone A has one running service task and zones B and C each have two,
* container instances in either zone B or C are considered optimal for termination.
*
*
* -
*
* Stop the task on a container instance in an optimal Availability Zone (based on the previous steps), favoring
* container instances with the largest number of running tasks for this service.
*
*
*
*
* @param updateServiceRequest
* @return A Java Future containing the result of the UpdateService operation returned by the service.
* @sample AmazonECSAsync.UpdateService
* @see AWS API
* Documentation
*/
java.util.concurrent.Future updateServiceAsync(UpdateServiceRequest updateServiceRequest);
/**
*
* Modifies the desired count, deployment configuration, network configuration, or task definition used in a
* service.
*
*
* You can add to or subtract from the number of instantiations of a task definition in a service by specifying the
* cluster that the service is running in and a new desiredCount parameter.
*
*
* If you have updated the Docker image of your application, you can create a new task definition with that image
* and deploy it to your service. The service scheduler uses the minimum healthy percent and maximum percent
* parameters (in the service's deployment configuration) to determine the deployment strategy.
*
*
*
* If your updated Docker image uses the same tag as what is in the existing task definition for your service (for
* example, my_image:latest), you do not need to create a new revision of your task definition. You can
* update the service using the forceNewDeployment option. The new tasks launched by the deployment
* pull the current image/tag combination from your repository when they start.
*
*
*
* You can also update the deployment configuration of a service. When a deployment is triggered by updating the
* task definition of a service, the service scheduler uses the deployment configuration parameters,
* minimumHealthyPercent and maximumPercent, to determine the deployment strategy.
*
*
* -
*
* If minimumHealthyPercent is below 100%, the scheduler can ignore desiredCount
* temporarily during a deployment. For example, if desiredCount is four tasks, a minimum of 50% allows
* the scheduler to stop two existing tasks before starting two new tasks. Tasks for services that do not use a load
* balancer are considered healthy if they are in the RUNNING state. Tasks for services that use a load
* balancer are considered healthy if they are in the RUNNING state and the container instance they are
* hosted on is reported as healthy by the load balancer.
*
*
* -
*
* The maximumPercent parameter represents an upper limit on the number of running tasks during a
* deployment, which enables you to define the deployment batch size. For example, if desiredCount is
* four tasks, a maximum of 200% starts four new tasks before stopping the four older tasks (provided that the
* cluster resources required to do this are available).
*
*
*
*
* When UpdateService stops a task during a deployment, the equivalent of docker stop is issued
* to the containers running in the task. This results in a SIGTERM and a 30-second timeout, after
* which SIGKILL is sent and the containers are forcibly stopped. If the container handles the
* SIGTERM gracefully and exits within 30 seconds from receiving it, no SIGKILL is sent.
*
*
* When the service scheduler launches new tasks, it determines task placement in your cluster with the following
* logic:
*
*
* -
*
* Determine which of the container instances in your cluster can support your service's task definition (for
* example, they have the required CPU, memory, ports, and container instance attributes).
*
*
* -
*
* By default, the service scheduler attempts to balance tasks across Availability Zones in this manner (although
* you can choose a different placement strategy):
*
*
* -
*
* Sort the valid container instances by the fewest number of running tasks for this service in the same
* Availability Zone as the instance. For example, if zone A has one running service task and zones B and C each
* have zero, valid container instances in either zone B or C are considered optimal for placement.
*
*
* -
*
* Place the new service task on a valid container instance in an optimal Availability Zone (based on the previous
* steps), favoring container instances with the fewest number of running tasks for this service.
*
*
*
*
*
*
* When the service scheduler stops running tasks, it attempts to maintain balance across the Availability Zones in
* your cluster using the following logic:
*
*
* -
*
* Sort the container instances by the largest number of running tasks for this service in the same Availability
* Zone as the instance. For example, if zone A has one running service task and zones B and C each have two,
* container instances in either zone B or C are considered optimal for termination.
*
*
* -
*
* Stop the task on a container instance in an optimal Availability Zone (based on the previous steps), favoring
* container instances with the largest number of running tasks for this service.
*
*
*
*
* @param updateServiceRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UpdateService operation returned by the service.
* @sample AmazonECSAsyncHandler.UpdateService
* @see AWS API
* Documentation
*/
java.util.concurrent.Future updateServiceAsync(UpdateServiceRequest updateServiceRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
}