%% WARNING: DO NOT EDIT, AUTO-GENERATED CODE! %% See https://github.com/aws-beam/aws-codegen for more details. %% @doc Amazon Elastic Container Service %% %% 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. -module(aws_ecs). -export([create_capacity_provider/2, create_capacity_provider/3, create_cluster/2, create_cluster/3, create_service/2, create_service/3, create_task_set/2, create_task_set/3, delete_account_setting/2, delete_account_setting/3, delete_attributes/2, delete_attributes/3, delete_capacity_provider/2, delete_capacity_provider/3, delete_cluster/2, delete_cluster/3, delete_service/2, delete_service/3, delete_task_set/2, delete_task_set/3, deregister_container_instance/2, deregister_container_instance/3, deregister_task_definition/2, deregister_task_definition/3, describe_capacity_providers/2, describe_capacity_providers/3, describe_clusters/2, describe_clusters/3, describe_container_instances/2, describe_container_instances/3, describe_services/2, describe_services/3, describe_task_definition/2, describe_task_definition/3, describe_task_sets/2, describe_task_sets/3, describe_tasks/2, describe_tasks/3, discover_poll_endpoint/2, discover_poll_endpoint/3, list_account_settings/2, list_account_settings/3, list_attributes/2, list_attributes/3, list_clusters/2, list_clusters/3, list_container_instances/2, list_container_instances/3, list_services/2, list_services/3, list_tags_for_resource/2, list_tags_for_resource/3, list_task_definition_families/2, list_task_definition_families/3, list_task_definitions/2, list_task_definitions/3, list_tasks/2, list_tasks/3, put_account_setting/2, put_account_setting/3, put_account_setting_default/2, put_account_setting_default/3, put_attributes/2, put_attributes/3, put_cluster_capacity_providers/2, put_cluster_capacity_providers/3, register_container_instance/2, register_container_instance/3, register_task_definition/2, register_task_definition/3, run_task/2, run_task/3, start_task/2, start_task/3, stop_task/2, stop_task/3, submit_attachment_state_changes/2, submit_attachment_state_changes/3, submit_container_state_change/2, submit_container_state_change/3, submit_task_state_change/2, submit_task_state_change/3, tag_resource/2, tag_resource/3, untag_resource/2, untag_resource/3, update_capacity_provider/2, update_capacity_provider/3, update_cluster_settings/2, update_cluster_settings/3, update_container_agent/2, update_container_agent/3, update_container_instances_state/2, update_container_instances_state/3, update_service/2, update_service/3, update_service_primary_task_set/2, update_service_primary_task_set/3, update_task_set/2, update_task_set/3]). -include_lib("hackney/include/hackney_lib.hrl"). %%==================================================================== %% API %%==================================================================== %% @doc Creates a new capacity provider. %% %% Capacity providers are associated with an Amazon ECS cluster and are used %% in capacity provider strategies to facilitate cluster auto scaling. %% %% Only capacity providers using an Auto Scaling group can be created. Amazon %% ECS tasks on AWS Fargate use the `FARGATE' and `FARGATE_SPOT' capacity %% providers which are already created and available to all accounts in %% Regions supported by AWS Fargate. create_capacity_provider(Client, Input) when is_map(Client), is_map(Input) -> create_capacity_provider(Client, Input, []). create_capacity_provider(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"CreateCapacityProvider">>, Input, Options). %% @doc 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 Amazon ECS 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. create_cluster(Client, Input) when is_map(Client), is_map(Input) -> create_cluster(Client, Input, []). create_cluster(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"CreateCluster">>, Input, Options). %% @doc Runs and maintains a desired number of tasks from a specified task %% definition. %% %% If the number of tasks running in a service drops below the %% `desiredCount', Amazon ECS runs another copy of the task in the specified %% cluster. To update an existing service, see the UpdateService action. %% %% In addition to maintaining the desired count of tasks in your service, you %% can optionally run your service behind one or more load balancers. The %% load balancers distribute 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. %% %% Tasks for services that do not use a load balancer are considered healthy %% if they're in the `RUNNING' state. Tasks for services that do use a load %% balancer are considered healthy if they're in the `RUNNING' state and the %% container instance that they're hosted on is reported as healthy by the %% load balancer. %% %% There are two service scheduler strategies available: %% %% You can optionally specify a deployment configuration for your %% service. The deployment is triggered by changing properties, such as the %% task definition or the desired count of a service, with an `UpdateService' %% operation. The default value for a replica service for %% `minimumHealthyPercent' is 100%. The default value for a daemon service %% for `minimumHealthyPercent' is 0%. %% %% If a service is using the `ECS' deployment controller, the minimum healthy %% percent represents a lower limit on the number of tasks in a service that %% must remain in the `RUNNING' state during a deployment, as a percentage of %% the desired number of tasks (rounded up to the nearest integer), and while %% any container instances are in the `DRAINING' state if the service %% contains tasks using the EC2 launch type. This parameter enables you to %% deploy without using additional cluster capacity. For example, if your %% service has a desired number of four tasks and a minimum healthy percent %% of 50%, the scheduler might 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're in the `RUNNING' state. %% Tasks for services that do use a load balancer are considered healthy if %% they're in the `RUNNING' state and they're reported as healthy by the load %% balancer. The default value for minimum healthy percent is 100%. %% %% If a service is using the `ECS' deployment controller, the maximum percent %% parameter represents an upper limit on the number of tasks in a service %% that are allowed in the `RUNNING' or `PENDING' state during a deployment, %% as a percentage of the desired number of tasks (rounded down to the %% nearest integer), and while any container instances are in the `DRAINING' %% state if the service contains tasks using the EC2 launch type. This %% parameter enables you to define the deployment batch size. For example, if %% your service has a desired number of four tasks and a maximum percent %% value of 200%, the scheduler may 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 maximum percent is 200%. %% %% If a service is using either the `CODE_DEPLOY' or `EXTERNAL' deployment %% controller types and tasks that use the EC2 launch type, the minimum %% healthy percent and maximum percent values are used only to define the %% lower and upper limit on the number of the tasks in the service that %% remain in the `RUNNING' state while the container instances are in the %% `DRAINING' state. If the tasks in the service use the Fargate launch type, %% the minimum healthy percent and maximum percent values aren't used, %% although they're currently visible when describing your service. %% %% When creating a service that uses the `EXTERNAL' deployment controller, %% you can specify only parameters that aren't controlled at the task set %% level. The only required parameter is the service name. You control your %% services using the `CreateTaskSet' operation. For more information, see %% Amazon ECS Deployment Types in the Amazon Elastic Container Service %% Developer Guide. %% %% When the service scheduler launches new tasks, it determines task %% placement in your cluster using the following logic: %% %% create_service(Client, Input) when is_map(Client), is_map(Input) -> create_service(Client, Input, []). create_service(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"CreateService">>, Input, Options). %% @doc Create a task set in the specified cluster and service. %% %% This is used when a service uses the `EXTERNAL' deployment controller %% type. For more information, see Amazon ECS Deployment Types in the Amazon %% Elastic Container Service Developer Guide. create_task_set(Client, Input) when is_map(Client), is_map(Input) -> create_task_set(Client, Input, []). create_task_set(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"CreateTaskSet">>, Input, Options). %% @doc Disables an account setting for a specified IAM user, IAM role, or %% the root user for an account. delete_account_setting(Client, Input) when is_map(Client), is_map(Input) -> delete_account_setting(Client, Input, []). delete_account_setting(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DeleteAccountSetting">>, Input, Options). %% @doc Deletes one or more custom attributes from an Amazon ECS resource. delete_attributes(Client, Input) when is_map(Client), is_map(Input) -> delete_attributes(Client, Input, []). delete_attributes(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DeleteAttributes">>, Input, Options). %% @doc Deletes the specified capacity provider. %% %% The `FARGATE' and `FARGATE_SPOT' capacity providers are reserved and %% cannot be deleted. You can disassociate them from a cluster using either %% the `PutClusterCapacityProviders' API or by deleting the cluster. %% %% Prior to a capacity provider being deleted, the capacity provider must be %% removed from the capacity provider strategy from all services. The %% `UpdateService' API can be used to remove a capacity provider from a %% service's capacity provider strategy. When updating a service, the %% `forceNewDeployment' option can be used to ensure that any tasks using the %% Amazon EC2 instance capacity provided by the capacity provider are %% transitioned to use the capacity from the remaining capacity providers. %% Only capacity providers that are not associated with a cluster can be %% deleted. To remove a capacity provider from a cluster, you can either use %% `PutClusterCapacityProviders' or delete the cluster. delete_capacity_provider(Client, Input) when is_map(Client), is_map(Input) -> delete_capacity_provider(Client, Input, []). delete_capacity_provider(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DeleteCapacityProvider">>, Input, Options). %% @doc Deletes the specified cluster. %% %% The cluster will transition to the `INACTIVE' state. Clusters with an %% `INACTIVE' status may remain discoverable in your account for a period of %% time. However, this behavior is subject to change in the future, so you %% should not rely on `INACTIVE' clusters persisting. %% %% 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'. delete_cluster(Client, Input) when is_map(Client), is_map(Input) -> delete_cluster(Client, Input, []). delete_cluster(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DeleteCluster">>, Input, Options). %% @doc 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 all tasks have transitioned to either `STOPPING' or %% `STOPPED' status, 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. delete_service(Client, Input) when is_map(Client), is_map(Input) -> delete_service(Client, Input, []). delete_service(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DeleteService">>, Input, Options). %% @doc Deletes a specified task set within a service. %% %% This is used when a service uses the `EXTERNAL' deployment controller %% type. For more information, see Amazon ECS Deployment Types in the Amazon %% Elastic Container Service Developer Guide. delete_task_set(Client, Input) when is_map(Client), is_map(Input) -> delete_task_set(Client, Input, []). delete_task_set(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DeleteTaskSet">>, Input, Options). %% @doc 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). deregister_container_instance(Client, Input) when is_map(Client), is_map(Input) -> deregister_container_instance(Client, Input, []). deregister_container_instance(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DeregisterContainerInstance">>, Input, Options). %% @doc 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. However, 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. deregister_task_definition(Client, Input) when is_map(Client), is_map(Input) -> deregister_task_definition(Client, Input, []). deregister_task_definition(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DeregisterTaskDefinition">>, Input, Options). %% @doc Describes one or more of your capacity providers. describe_capacity_providers(Client, Input) when is_map(Client), is_map(Input) -> describe_capacity_providers(Client, Input, []). describe_capacity_providers(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeCapacityProviders">>, Input, Options). %% @doc Describes one or more of your clusters. describe_clusters(Client, Input) when is_map(Client), is_map(Input) -> describe_clusters(Client, Input, []). describe_clusters(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeClusters">>, Input, Options). %% @doc Describes Amazon Elastic Container Service container instances. %% %% Returns metadata about registered and remaining resources on each %% container instance requested. describe_container_instances(Client, Input) when is_map(Client), is_map(Input) -> describe_container_instances(Client, Input, []). describe_container_instances(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeContainerInstances">>, Input, Options). %% @doc Describes the specified services running in your cluster. describe_services(Client, Input) when is_map(Client), is_map(Input) -> describe_services(Client, Input, []). describe_services(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeServices">>, Input, Options). %% @doc 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. describe_task_definition(Client, Input) when is_map(Client), is_map(Input) -> describe_task_definition(Client, Input, []). describe_task_definition(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeTaskDefinition">>, Input, Options). %% @doc Describes the task sets in the specified cluster and service. %% %% This is used when a service uses the `EXTERNAL' deployment controller %% type. For more information, see Amazon ECS Deployment Types in the Amazon %% Elastic Container Service Developer Guide. describe_task_sets(Client, Input) when is_map(Client), is_map(Input) -> describe_task_sets(Client, Input, []). describe_task_sets(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeTaskSets">>, Input, Options). %% @doc Describes a specified task or tasks. describe_tasks(Client, Input) when is_map(Client), is_map(Input) -> describe_tasks(Client, Input, []). describe_tasks(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DescribeTasks">>, Input, Options). %% @doc 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. discover_poll_endpoint(Client, Input) when is_map(Client), is_map(Input) -> discover_poll_endpoint(Client, Input, []). discover_poll_endpoint(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"DiscoverPollEndpoint">>, Input, Options). %% @doc Lists the account settings for a specified principal. list_account_settings(Client, Input) when is_map(Client), is_map(Input) -> list_account_settings(Client, Input, []). list_account_settings(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListAccountSettings">>, Input, Options). %% @doc 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'). list_attributes(Client, Input) when is_map(Client), is_map(Input) -> list_attributes(Client, Input, []). list_attributes(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListAttributes">>, Input, Options). %% @doc Returns a list of existing clusters. list_clusters(Client, Input) when is_map(Client), is_map(Input) -> list_clusters(Client, Input, []). list_clusters(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListClusters">>, Input, Options). %% @doc 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. list_container_instances(Client, Input) when is_map(Client), is_map(Input) -> list_container_instances(Client, Input, []). list_container_instances(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListContainerInstances">>, Input, Options). %% @doc Lists the services that are running in a specified cluster. list_services(Client, Input) when is_map(Client), is_map(Input) -> list_services(Client, Input, []). list_services(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListServices">>, Input, Options). %% @doc List the tags for an Amazon ECS resource. list_tags_for_resource(Client, Input) when is_map(Client), is_map(Input) -> list_tags_for_resource(Client, Input, []). list_tags_for_resource(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListTagsForResource">>, Input, Options). %% @doc 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. list_task_definition_families(Client, Input) when is_map(Client), is_map(Input) -> list_task_definition_families(Client, Input, []). list_task_definition_families(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListTaskDefinitionFamilies">>, Input, Options). %% @doc 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. list_task_definitions(Client, Input) when is_map(Client), is_map(Input) -> list_task_definitions(Client, Input, []). list_task_definitions(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListTaskDefinitions">>, Input, Options). %% @doc 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. list_tasks(Client, Input) when is_map(Client), is_map(Input) -> list_tasks(Client, Input, []). list_tasks(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"ListTasks">>, Input, Options). %% @doc Modifies an account setting. %% %% Account settings are set on a per-Region basis. %% %% If you change the account setting for the root user, the default settings %% for all of the IAM users and roles for which no individual account setting %% has been specified are reset. For more information, see Account Settings %% in the Amazon Elastic Container Service Developer Guide. %% %% When `serviceLongArnFormat', `taskLongArnFormat', or %% `containerInstanceLongArnFormat' are specified, the Amazon Resource Name %% (ARN) and resource ID format of the resource type for a specified IAM %% user, IAM role, or the root user for an account is affected. The opt-in %% and opt-out account setting must be set for each Amazon ECS resource %% separately. The ARN and resource ID format of a resource will be defined %% by the opt-in status of the IAM user or role that created the resource. %% You must enable this setting to use Amazon ECS features such as resource %% tagging. %% %% When `awsvpcTrunking' is specified, the elastic network interface (ENI) %% limit for any new container instances that support the feature is changed. %% If `awsvpcTrunking' is enabled, any new container instances that support %% the feature are launched have the increased ENI limits available to them. %% For more information, see Elastic Network Interface Trunking in the Amazon %% Elastic Container Service Developer Guide. %% %% When `containerInsights' is specified, the default setting indicating %% whether CloudWatch Container Insights is enabled for your clusters is %% changed. If `containerInsights' is enabled, any new clusters that are %% created will have Container Insights enabled unless you disable it during %% cluster creation. For more information, see CloudWatch Container Insights %% in the Amazon Elastic Container Service Developer Guide. put_account_setting(Client, Input) when is_map(Client), is_map(Input) -> put_account_setting(Client, Input, []). put_account_setting(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"PutAccountSetting">>, Input, Options). %% @doc Modifies an account setting for all IAM users on an account for whom %% no individual account setting has been specified. %% %% Account settings are set on a per-Region basis. put_account_setting_default(Client, Input) when is_map(Client), is_map(Input) -> put_account_setting_default(Client, Input, []). put_account_setting_default(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"PutAccountSettingDefault">>, Input, Options). %% @doc 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. put_attributes(Client, Input) when is_map(Client), is_map(Input) -> put_attributes(Client, Input, []). put_attributes(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"PutAttributes">>, Input, Options). %% @doc Modifies the available capacity providers and the default capacity %% provider strategy for a cluster. %% %% You must specify both the available capacity providers and a default %% capacity provider strategy for the cluster. If the specified cluster has %% existing capacity providers associated with it, you must specify all %% existing capacity providers in addition to any new ones you want to add. %% Any existing capacity providers associated with a cluster that are omitted %% from a `PutClusterCapacityProviders' API call will be disassociated with %% the cluster. You can only disassociate an existing capacity provider from %% a cluster if it's not being used by any existing tasks. %% %% When creating a service or running a task on a cluster, if no capacity %% provider or launch type is specified, then the cluster's default capacity %% provider strategy is used. It is recommended to define a default capacity %% provider strategy for your cluster, however you may specify an empty array %% (`[]') to bypass defining a default strategy. put_cluster_capacity_providers(Client, Input) when is_map(Client), is_map(Input) -> put_cluster_capacity_providers(Client, Input, []). put_cluster_capacity_providers(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"PutClusterCapacityProviders">>, Input, Options). %% @doc 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. register_container_instance(Client, Input) when is_map(Client), is_map(Input) -> register_container_instance(Client, Input, []). register_container_instance(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"RegisterContainerInstance">>, Input, Options). %% @doc 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. register_task_definition(Client, Input) when is_map(Client), is_map(Input) -> register_task_definition(Client, Input, []). register_task_definition(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"RegisterTaskDefinition">>, Input, Options). %% @doc 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: %% %% run_task(Client, Input) when is_map(Client), is_map(Input) -> run_task(Client, Input, []). run_task(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"RunTask">>, Input, Options). %% @doc 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. start_task(Client, Input) when is_map(Client), is_map(Input) -> start_task(Client, Input, []). start_task(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"StartTask">>, Input, Options). %% @doc 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' %% value and a default 30-second timeout, after which the `SIGKILL' value is %% sent and the containers are forcibly stopped. If the container handles the %% `SIGTERM' value gracefully and exits within 30 seconds from receiving it, %% no `SIGKILL' value 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. stop_task(Client, Input) when is_map(Client), is_map(Input) -> stop_task(Client, Input, []). stop_task(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"StopTask">>, Input, Options). %% @doc 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 an attachment changed states. submit_attachment_state_changes(Client, Input) when is_map(Client), is_map(Input) -> submit_attachment_state_changes(Client, Input, []). submit_attachment_state_changes(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"SubmitAttachmentStateChanges">>, Input, Options). %% @doc 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. submit_container_state_change(Client, Input) when is_map(Client), is_map(Input) -> submit_container_state_change(Client, Input, []). submit_container_state_change(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"SubmitContainerStateChange">>, Input, Options). %% @doc 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. submit_task_state_change(Client, Input) when is_map(Client), is_map(Input) -> submit_task_state_change(Client, Input, []). submit_task_state_change(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"SubmitTaskStateChange">>, Input, Options). %% @doc 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. tag_resource(Client, Input) when is_map(Client), is_map(Input) -> tag_resource(Client, Input, []). tag_resource(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"TagResource">>, Input, Options). %% @doc Deletes specified tags from a resource. untag_resource(Client, Input) when is_map(Client), is_map(Input) -> untag_resource(Client, Input, []). untag_resource(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UntagResource">>, Input, Options). %% @doc Modifies the parameters for a capacity provider. update_capacity_provider(Client, Input) when is_map(Client), is_map(Input) -> update_capacity_provider(Client, Input, []). update_capacity_provider(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateCapacityProvider">>, Input, Options). %% @doc Modifies the settings to use for a cluster. update_cluster_settings(Client, Input) when is_map(Client), is_map(Input) -> update_cluster_settings(Client, Input, []). update_cluster_settings(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateClusterSettings">>, Input, Options). %% @doc 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. update_container_agent(Client, Input) when is_map(Client), is_map(Input) -> update_container_agent(Client, Input, []). update_container_agent(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateContainerAgent">>, Input, Options). %% @doc Modifies the status of an Amazon ECS container instance. %% %% Once a container instance has reached an `ACTIVE' state, 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. %% %% A container instance cannot be changed to `DRAINING' until it has reached %% an `ACTIVE' status. If the instance is in any other status, an error will %% be received. %% %% 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'. %% %% 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 a container instance has been drained, you can set a container %% instance to `ACTIVE' status and once it has reached that status the Amazon %% ECS scheduler can begin scheduling tasks on the instance again. update_container_instances_state(Client, Input) when is_map(Client), is_map(Input) -> update_container_instances_state(Client, Input, []). update_container_instances_state(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateContainerInstancesState">>, Input, Options). %% @doc Updating the task placement strategies and constraints on an Amazon %% ECS service remains in preview and is a Beta Service as defined by and %% subject to the Beta Service Participation Service Terms located at %% [https://aws.amazon.com/service-terms] ("Beta Terms"). %% %% These Beta Terms apply to your participation in this preview. %% %% Modifies the parameters of a service. %% %% For services using the rolling update (`ECS') deployment controller, the %% desired count, deployment configuration, network configuration, task %% placement constraints and strategies, or task definition used can be %% updated. %% %% For services using the blue/green (`CODE_DEPLOY') deployment controller, %% only the desired count, deployment configuration, task placement %% constraints and strategies, and health check grace period can be updated %% using this API. If the network configuration, platform version, or task %% definition need to be updated, a new AWS CodeDeploy deployment should be %% created. For more information, see CreateDeployment in the AWS CodeDeploy %% API Reference. %% %% For services using an external deployment controller, you can update only %% the desired count, task placement constraints and strategies, and health %% check grace period using this API. If the launch type, load balancer, %% network configuration, platform version, or task definition need to be %% updated, you should create a new task set. For more information, see %% `CreateTaskSet'. %% %% 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. %% %% 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: %% %% When the service scheduler stops running tasks, it %% attempts to maintain balance across the Availability Zones in your cluster %% using the following logic: %% %% update_service(Client, Input) when is_map(Client), is_map(Input) -> update_service(Client, Input, []). update_service(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateService">>, Input, Options). %% @doc Modifies which task set in a service is the primary task set. %% %% Any parameters that are updated on the primary task set in a service will %% transition to the service. This is used when a service uses the `EXTERNAL' %% deployment controller type. For more information, see Amazon ECS %% Deployment Types in the Amazon Elastic Container Service Developer Guide. update_service_primary_task_set(Client, Input) when is_map(Client), is_map(Input) -> update_service_primary_task_set(Client, Input, []). update_service_primary_task_set(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateServicePrimaryTaskSet">>, Input, Options). %% @doc Modifies a task set. %% %% This is used when a service uses the `EXTERNAL' deployment controller %% type. For more information, see Amazon ECS Deployment Types in the Amazon %% Elastic Container Service Developer Guide. update_task_set(Client, Input) when is_map(Client), is_map(Input) -> update_task_set(Client, Input, []). update_task_set(Client, Input, Options) when is_map(Client), is_map(Input), is_list(Options) -> request(Client, <<"UpdateTaskSet">>, Input, Options). %%==================================================================== %% Internal functions %%==================================================================== -spec request(aws_client:aws_client(), binary(), map(), list()) -> {ok, Result, {integer(), list(), hackney:client()}} | {error, Error, {integer(), list(), hackney:client()}} | {error, term()} when Result :: map() | undefined, Error :: map(). request(Client, Action, Input0, Options) -> Client1 = Client#{service => <<"ecs">>}, Host = build_host(<<"ecs">>, Client1), URL = build_url(Host, Client1), Headers = [ {<<"Host">>, Host}, {<<"Content-Type">>, <<"application/x-amz-json-1.1">>}, {<<"X-Amz-Target">>, <<"AmazonEC2ContainerServiceV20141113.", Action/binary>>} ], Input = Input0, Payload = jsx:encode(Input), SignedHeaders = aws_request:sign_request(Client1, <<"POST">>, URL, Headers, Payload), Response = hackney:request(post, URL, SignedHeaders, Payload, Options), handle_response(Response). handle_response({ok, 200, ResponseHeaders, Client}) -> case hackney:body(Client) of {ok, <<>>} -> {ok, undefined, {200, ResponseHeaders, Client}}; {ok, Body} -> Result = jsx:decode(Body), {ok, Result, {200, ResponseHeaders, Client}} end; handle_response({ok, StatusCode, ResponseHeaders, Client}) -> {ok, Body} = hackney:body(Client), Error = jsx:decode(Body), {error, Error, {StatusCode, ResponseHeaders, Client}}; handle_response({error, Reason}) -> {error, Reason}. build_host(_EndpointPrefix, #{region := <<"local">>, endpoint := Endpoint}) -> Endpoint; build_host(_EndpointPrefix, #{region := <<"local">>}) -> <<"localhost">>; build_host(EndpointPrefix, #{region := Region, endpoint := Endpoint}) -> aws_util:binary_join([EndpointPrefix, Region, Endpoint], <<".">>). build_url(Host, Client) -> Proto = maps:get(proto, Client), Port = maps:get(port, Client), aws_util:binary_join([Proto, <<"://">>, Host, <<":">>, Port, <<"/">>], <<"">>).