@aws-sdk/client-ecs 3.229.0 → 3.232.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist-cjs/endpoint/ruleset.js +0 -9
- package/dist-cjs/protocols/Aws_json1_1.js +6 -0
- package/dist-es/endpoint/ruleset.js +0 -9
- package/dist-es/protocols/Aws_json1_1.js +6 -0
- package/dist-types/ECS.d.ts +147 -146
- package/dist-types/ECSClient.d.ts +3 -3
- package/dist-types/commands/CreateCapacityProviderCommand.d.ts +1 -1
- package/dist-types/commands/CreateClusterCommand.d.ts +3 -3
- package/dist-types/commands/CreateServiceCommand.d.ts +14 -14
- package/dist-types/commands/DeleteCapacityProviderCommand.d.ts +4 -4
- package/dist-types/commands/DeleteClusterCommand.d.ts +1 -1
- package/dist-types/commands/DeleteServiceCommand.d.ts +6 -6
- package/dist-types/commands/DeregisterContainerInstanceCommand.d.ts +5 -5
- package/dist-types/commands/DeregisterTaskDefinitionCommand.d.ts +4 -4
- package/dist-types/commands/DescribeTaskDefinitionCommand.d.ts +3 -3
- package/dist-types/commands/DescribeTasksCommand.d.ts +1 -1
- package/dist-types/commands/DiscoverPollEndpointCommand.d.ts +1 -1
- package/dist-types/commands/ExecuteCommandCommand.d.ts +3 -1
- package/dist-types/commands/ListTaskDefinitionFamiliesCommand.d.ts +1 -1
- package/dist-types/commands/ListTasksCommand.d.ts +1 -1
- package/dist-types/commands/PutAccountSettingCommand.d.ts +4 -4
- package/dist-types/commands/PutClusterCapacityProvidersCommand.d.ts +2 -2
- package/dist-types/commands/RegisterContainerInstanceCommand.d.ts +1 -1
- package/dist-types/commands/RegisterTaskDefinitionCommand.d.ts +2 -2
- package/dist-types/commands/RunTaskCommand.d.ts +9 -9
- package/dist-types/commands/StartTaskCommand.d.ts +1 -1
- package/dist-types/commands/StopTaskCommand.d.ts +4 -4
- package/dist-types/commands/SubmitAttachmentStateChangesCommand.d.ts +1 -1
- package/dist-types/commands/SubmitContainerStateChangeCommand.d.ts +1 -1
- package/dist-types/commands/SubmitTaskStateChangeCommand.d.ts +1 -1
- package/dist-types/commands/UpdateContainerAgentCommand.d.ts +7 -7
- package/dist-types/commands/UpdateContainerInstancesStateCommand.d.ts +14 -14
- package/dist-types/commands/UpdateServiceCommand.d.ts +40 -41
- package/dist-types/commands/UpdateTaskProtectionCommand.d.ts +9 -9
- package/dist-types/models/models_0.d.ts +1178 -1042
- package/dist-types/ts3.4/models/models_0.d.ts +3 -0
- package/package.json +5 -5
package/dist-types/ECS.d.ts
CHANGED
|
@@ -57,15 +57,15 @@ import { UpdateTaskSetCommandInput, UpdateTaskSetCommandOutput } from "./command
|
|
|
57
57
|
import { ECSClient } from "./ECSClient";
|
|
58
58
|
/**
|
|
59
59
|
* <fullname>Amazon Elastic Container Service</fullname>
|
|
60
|
-
*
|
|
60
|
+
* <p>Amazon Elastic Container Service (Amazon ECS) is a highly scalable, fast, container management service. It makes
|
|
61
61
|
* it easy to run, stop, and manage Docker containers. You can host your cluster on a
|
|
62
62
|
* serverless infrastructure that's managed by Amazon ECS by launching your services or tasks on
|
|
63
63
|
* Fargate. For more control, you can host your tasks on a cluster of Amazon Elastic Compute Cloud (Amazon EC2)
|
|
64
64
|
* or External (on-premises) instances that you manage.</p>
|
|
65
|
-
*
|
|
65
|
+
* <p>Amazon ECS makes it easy to launch and stop container-based applications with simple API
|
|
66
66
|
* calls. This makes it easy to get the state of your cluster from a centralized service,
|
|
67
67
|
* and gives you access to many familiar Amazon EC2 features.</p>
|
|
68
|
-
*
|
|
68
|
+
* <p>You can use Amazon ECS to schedule the placement of containers across your cluster based on
|
|
69
69
|
* your resource needs, isolation policies, and availability requirements. With Amazon ECS, you
|
|
70
70
|
* don't need to operate your own cluster management and configuration management systems.
|
|
71
71
|
* You also don't need to worry about scaling your management infrastructure.</p>
|
|
@@ -75,7 +75,7 @@ export declare class ECS extends ECSClient {
|
|
|
75
75
|
* <p>Creates a new capacity provider. Capacity providers are associated with an Amazon ECS
|
|
76
76
|
* cluster and are used in capacity provider strategies to facilitate cluster auto
|
|
77
77
|
* scaling.</p>
|
|
78
|
-
*
|
|
78
|
+
* <p>Only capacity providers that use an Auto Scaling group can be created. Amazon ECS tasks on
|
|
79
79
|
* Fargate use the <code>FARGATE</code> and <code>FARGATE_SPOT</code> capacity providers.
|
|
80
80
|
* These providers are available to all accounts in the Amazon Web Services Regions that Fargate
|
|
81
81
|
* supports.</p>
|
|
@@ -87,14 +87,14 @@ export declare class ECS extends ECSClient {
|
|
|
87
87
|
* <p>Creates a new Amazon ECS cluster. By default, your account receives a <code>default</code>
|
|
88
88
|
* cluster when you launch your first container instance. However, you can create your own
|
|
89
89
|
* cluster with a unique name with the <code>CreateCluster</code> action.</p>
|
|
90
|
-
*
|
|
91
|
-
*
|
|
90
|
+
* <note>
|
|
91
|
+
* <p>When you call the <a>CreateCluster</a> API operation, Amazon ECS attempts to
|
|
92
92
|
* create the Amazon ECS service-linked role for your account. This is so that it can manage
|
|
93
93
|
* required resources in other Amazon Web Services services on your behalf. However, if the IAM user
|
|
94
94
|
* that makes the call doesn't have permissions to create the service-linked role, it
|
|
95
95
|
* isn't created. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html">Using
|
|
96
96
|
* service-linked roles for Amazon ECS</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
97
|
-
*
|
|
97
|
+
* </note>
|
|
98
98
|
*/
|
|
99
99
|
createCluster(args: CreateClusterCommandInput, options?: __HttpHandlerOptions): Promise<CreateClusterCommandOutput>;
|
|
100
100
|
createCluster(args: CreateClusterCommandInput, cb: (err: any, data?: CreateClusterCommandOutput) => void): void;
|
|
@@ -104,26 +104,26 @@ export declare class ECS extends ECSClient {
|
|
|
104
104
|
* the number of tasks running in a service drops below the <code>desiredCount</code>,
|
|
105
105
|
* Amazon ECS runs another copy of the task in the specified cluster. To update an existing
|
|
106
106
|
* service, see the <a>UpdateService</a> action.</p>
|
|
107
|
-
*
|
|
107
|
+
* <p>In addition to maintaining the desired count of tasks in your service, you can
|
|
108
108
|
* optionally run your service behind one or more load balancers. The load balancers
|
|
109
109
|
* distribute traffic across the tasks that are associated with the service. For more
|
|
110
110
|
* information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html">Service load balancing</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
111
|
-
*
|
|
111
|
+
* <p>Tasks for services that don't use a load balancer are considered healthy if they're in
|
|
112
112
|
* the <code>RUNNING</code> state. Tasks for services that use a load balancer are
|
|
113
113
|
* considered healthy if they're in the <code>RUNNING</code> state and are reported as
|
|
114
114
|
* healthy by the load balancer.</p>
|
|
115
|
-
*
|
|
116
|
-
*
|
|
115
|
+
* <p>There are two service scheduler strategies available:</p>
|
|
116
|
+
* <ul>
|
|
117
117
|
* <li>
|
|
118
|
-
*
|
|
118
|
+
* <p>
|
|
119
119
|
* <code>REPLICA</code> - The replica scheduling strategy places and
|
|
120
120
|
* maintains your desired number of tasks across your cluster. By default, the
|
|
121
121
|
* service scheduler spreads tasks across Availability Zones. You can use task
|
|
122
122
|
* placement strategies and constraints to customize task placement decisions. For
|
|
123
123
|
* more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html">Service scheduler concepts</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
124
|
-
*
|
|
124
|
+
* </li>
|
|
125
125
|
* <li>
|
|
126
|
-
*
|
|
126
|
+
* <p>
|
|
127
127
|
* <code>DAEMON</code> - The daemon scheduling strategy deploys exactly one
|
|
128
128
|
* task on each active container instance that meets all of the task placement
|
|
129
129
|
* constraints that you specify in your cluster. The service scheduler also
|
|
@@ -131,14 +131,14 @@ export declare class ECS extends ECSClient {
|
|
|
131
131
|
* that don't meet the placement constraints. When using this strategy, you don't
|
|
132
132
|
* need to specify a desired number of tasks, a task placement strategy, or use
|
|
133
133
|
* Service Auto Scaling policies. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html">Service scheduler concepts</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
134
|
-
*
|
|
134
|
+
* </li>
|
|
135
135
|
* </ul>
|
|
136
|
-
*
|
|
136
|
+
* <p>You can optionally specify a deployment configuration for your service. The deployment
|
|
137
137
|
* is initiated by changing properties. For example, the deployment might be initiated by
|
|
138
138
|
* the task definition or by your desired count of a service. This is done with an <a>UpdateService</a> operation. The default value for a replica service for
|
|
139
139
|
* <code>minimumHealthyPercent</code> is 100%. The default value for a daemon service
|
|
140
140
|
* for <code>minimumHealthyPercent</code> is 0%.</p>
|
|
141
|
-
*
|
|
141
|
+
* <p>If a service uses the <code>ECS</code> deployment controller, the minimum healthy
|
|
142
142
|
* percent represents a lower limit on the number of tasks in a service that must remain in
|
|
143
143
|
* the <code>RUNNING</code> state during a deployment. Specifically, it represents it as a
|
|
144
144
|
* percentage of your desired number of tasks (rounded up to the nearest integer). This
|
|
@@ -152,7 +152,7 @@ export declare class ECS extends ECSClient {
|
|
|
152
152
|
* <code>RUNNING</code> state and reported as healthy by the load balancer, tasks for
|
|
153
153
|
* services that <i>do</i> use a load balancer are considered healthy . The
|
|
154
154
|
* default value for minimum healthy percent is 100%.</p>
|
|
155
|
-
*
|
|
155
|
+
* <p>If a service uses the <code>ECS</code> deployment controller, the <b>maximum percent</b> parameter represents an upper limit on the
|
|
156
156
|
* number of tasks in a service that are allowed in the <code>RUNNING</code> or
|
|
157
157
|
* <code>PENDING</code> state during a deployment. Specifically, it represents it as a
|
|
158
158
|
* percentage of the desired number of tasks (rounded down to the nearest integer). This
|
|
@@ -163,7 +163,7 @@ export declare class ECS extends ECSClient {
|
|
|
163
163
|
* start four new tasks before stopping the four older tasks (provided that the cluster
|
|
164
164
|
* resources required to do this are available). The default value for maximum percent is
|
|
165
165
|
* 200%.</p>
|
|
166
|
-
*
|
|
166
|
+
* <p>If a service uses either the <code>CODE_DEPLOY</code> or <code>EXTERNAL</code>
|
|
167
167
|
* deployment controller types and tasks that use the EC2 launch type, the
|
|
168
168
|
* <b>minimum healthy percent</b> and <b>maximum percent</b> values are used only to define the lower and upper limit
|
|
169
169
|
* on the number of the tasks in the service that remain in the <code>RUNNING</code> state.
|
|
@@ -171,10 +171,10 @@ export declare class ECS extends ECSClient {
|
|
|
171
171
|
* tasks in the service use the Fargate launch type, the minimum healthy
|
|
172
172
|
* percent and maximum percent values aren't used. This is the case even if they're
|
|
173
173
|
* currently visible when describing your service.</p>
|
|
174
|
-
*
|
|
174
|
+
* <p>When creating a service that uses the <code>EXTERNAL</code> deployment controller, you
|
|
175
175
|
* can specify only parameters that aren't controlled at the task set level. The only
|
|
176
176
|
* required parameter is the service name. You control your services using the <a>CreateTaskSet</a> operation. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon ECS deployment types</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
177
|
-
*
|
|
177
|
+
* <p>When the service scheduler launches new tasks, it determines task placement. For
|
|
178
178
|
* information about task placement and task placement strategies, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement.html">Amazon ECS
|
|
179
179
|
* task placement</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
180
180
|
*/
|
|
@@ -205,13 +205,13 @@ export declare class ECS extends ECSClient {
|
|
|
205
205
|
deleteAttributes(args: DeleteAttributesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteAttributesCommandOutput) => void): void;
|
|
206
206
|
/**
|
|
207
207
|
* <p>Deletes the specified capacity provider.</p>
|
|
208
|
-
*
|
|
209
|
-
*
|
|
208
|
+
* <note>
|
|
209
|
+
* <p>The <code>FARGATE</code> and <code>FARGATE_SPOT</code> capacity providers are
|
|
210
210
|
* reserved and can't be deleted. You can disassociate them from a cluster using either
|
|
211
211
|
* the <a>PutClusterCapacityProviders</a> API or by deleting the
|
|
212
212
|
* cluster.</p>
|
|
213
|
-
*
|
|
214
|
-
*
|
|
213
|
+
* </note>
|
|
214
|
+
* <p>Prior to a capacity provider being deleted, the capacity provider must be removed from
|
|
215
215
|
* the capacity provider strategy from all services. The <a>UpdateService</a>
|
|
216
216
|
* API can be used to remove a capacity provider from a service's capacity provider
|
|
217
217
|
* strategy. When updating a service, the <code>forceNewDeployment</code> option can be
|
|
@@ -228,7 +228,7 @@ export declare class ECS extends ECSClient {
|
|
|
228
228
|
* state. Clusters with an <code>INACTIVE</code> status might remain discoverable in your
|
|
229
229
|
* account for a period of time. However, this behavior is subject to change in the future.
|
|
230
230
|
* We don't recommend that you rely on <code>INACTIVE</code> clusters persisting.</p>
|
|
231
|
-
*
|
|
231
|
+
* <p>You must deregister all container instances from this cluster before you may delete
|
|
232
232
|
* it. You can list the container instances in a cluster with <a>ListContainerInstances</a> and deregister them with <a>DeregisterContainerInstance</a>.</p>
|
|
233
233
|
*/
|
|
234
234
|
deleteCluster(args: DeleteClusterCommandInput, options?: __HttpHandlerOptions): Promise<DeleteClusterCommandOutput>;
|
|
@@ -239,8 +239,8 @@ export declare class ECS extends ECSClient {
|
|
|
239
239
|
* running tasks in it and the desired task count is zero. If the service is actively
|
|
240
240
|
* maintaining tasks, you can't delete it, and you must update the service to a desired
|
|
241
241
|
* task count of zero. For more information, see <a>UpdateService</a>.</p>
|
|
242
|
-
*
|
|
243
|
-
*
|
|
242
|
+
* <note>
|
|
243
|
+
* <p>When you delete a service, if there are still running tasks that require cleanup,
|
|
244
244
|
* the service status moves from <code>ACTIVE</code> to <code>DRAINING</code>, and the
|
|
245
245
|
* service is no longer visible in the console or in the <a>ListServices</a>
|
|
246
246
|
* API operation. After all tasks have transitioned to either <code>STOPPING</code> or
|
|
@@ -250,12 +250,12 @@ export declare class ECS extends ECSClient {
|
|
|
250
250
|
* <code>INACTIVE</code> services may be cleaned up and purged from Amazon ECS record
|
|
251
251
|
* keeping, and <a>DescribeServices</a> calls on those services return a
|
|
252
252
|
* <code>ServiceNotFoundException</code> error.</p>
|
|
253
|
-
*
|
|
254
|
-
*
|
|
255
|
-
*
|
|
253
|
+
* </note>
|
|
254
|
+
* <important>
|
|
255
|
+
* <p>If you attempt to create a new service with the same name as an existing service
|
|
256
256
|
* in either <code>ACTIVE</code> or <code>DRAINING</code> status, you receive an
|
|
257
257
|
* error.</p>
|
|
258
|
-
*
|
|
258
|
+
* </important>
|
|
259
259
|
*/
|
|
260
260
|
deleteService(args: DeleteServiceCommandInput, options?: __HttpHandlerOptions): Promise<DeleteServiceCommandOutput>;
|
|
261
261
|
deleteService(args: DeleteServiceCommandInput, cb: (err: any, data?: DeleteServiceCommandOutput) => void): void;
|
|
@@ -270,18 +270,18 @@ export declare class ECS extends ECSClient {
|
|
|
270
270
|
/**
|
|
271
271
|
* <p>Deregisters an Amazon ECS container instance from the specified cluster. This instance is
|
|
272
272
|
* no longer available to run tasks.</p>
|
|
273
|
-
*
|
|
273
|
+
* <p>If you intend to use the container instance for some other purpose after
|
|
274
274
|
* deregistration, we recommend that you stop all of the tasks running on the container
|
|
275
275
|
* instance before deregistration. That prevents any orphaned tasks from consuming
|
|
276
276
|
* resources.</p>
|
|
277
|
-
*
|
|
277
|
+
* <p>Deregistering a container instance removes the instance from a cluster, but it doesn't
|
|
278
278
|
* terminate the EC2 instance. If you are finished using the instance, be sure to terminate
|
|
279
279
|
* it in the Amazon EC2 console to stop billing.</p>
|
|
280
|
-
*
|
|
281
|
-
*
|
|
280
|
+
* <note>
|
|
281
|
+
* <p>If you terminate a running container instance, Amazon ECS automatically deregisters the
|
|
282
282
|
* instance from your cluster (stopped container instances or instances with
|
|
283
283
|
* disconnected agents aren't automatically deregistered when terminated).</p>
|
|
284
|
-
*
|
|
284
|
+
* </note>
|
|
285
285
|
*/
|
|
286
286
|
deregisterContainerInstance(args: DeregisterContainerInstanceCommandInput, options?: __HttpHandlerOptions): Promise<DeregisterContainerInstanceCommandOutput>;
|
|
287
287
|
deregisterContainerInstance(args: DeregisterContainerInstanceCommandInput, cb: (err: any, data?: DeregisterContainerInstanceCommandOutput) => void): void;
|
|
@@ -292,16 +292,16 @@ export declare class ECS extends ECSClient {
|
|
|
292
292
|
* reference an <code>INACTIVE</code> task definition continue to run without disruption.
|
|
293
293
|
* Existing services that reference an <code>INACTIVE</code> task definition can still
|
|
294
294
|
* scale up or down by modifying the service's desired count.</p>
|
|
295
|
-
*
|
|
295
|
+
* <p>You can't use an <code>INACTIVE</code> task definition to run new tasks or create new
|
|
296
296
|
* services, and you can't update an existing service to reference an <code>INACTIVE</code>
|
|
297
297
|
* task definition. However, there may be up to a 10-minute window following deregistration
|
|
298
298
|
* where these restrictions have not yet taken effect.</p>
|
|
299
|
-
*
|
|
300
|
-
*
|
|
299
|
+
* <note>
|
|
300
|
+
* <p>At this time, <code>INACTIVE</code> task definitions remain discoverable in your
|
|
301
301
|
* account indefinitely. However, this behavior is subject to change in the future. We
|
|
302
302
|
* don't recommend that you rely on <code>INACTIVE</code> task definitions persisting
|
|
303
303
|
* beyond the lifecycle of any associated tasks and services.</p>
|
|
304
|
-
*
|
|
304
|
+
* </note>
|
|
305
305
|
*/
|
|
306
306
|
deregisterTaskDefinition(args: DeregisterTaskDefinitionCommandInput, options?: __HttpHandlerOptions): Promise<DeregisterTaskDefinitionCommandOutput>;
|
|
307
307
|
deregisterTaskDefinition(args: DeregisterTaskDefinitionCommandInput, cb: (err: any, data?: DeregisterTaskDefinitionCommandOutput) => void): void;
|
|
@@ -336,17 +336,17 @@ export declare class ECS extends ECSClient {
|
|
|
336
336
|
* <code>revision</code> to find information about a specific task definition, or you
|
|
337
337
|
* can simply specify the family to find the latest <code>ACTIVE</code> revision in that
|
|
338
338
|
* family.</p>
|
|
339
|
-
*
|
|
340
|
-
*
|
|
339
|
+
* <note>
|
|
340
|
+
* <p>You can only describe <code>INACTIVE</code> task definitions while an active task
|
|
341
341
|
* or service references them.</p>
|
|
342
|
-
*
|
|
342
|
+
* </note>
|
|
343
343
|
*/
|
|
344
344
|
describeTaskDefinition(args: DescribeTaskDefinitionCommandInput, options?: __HttpHandlerOptions): Promise<DescribeTaskDefinitionCommandOutput>;
|
|
345
345
|
describeTaskDefinition(args: DescribeTaskDefinitionCommandInput, cb: (err: any, data?: DescribeTaskDefinitionCommandOutput) => void): void;
|
|
346
346
|
describeTaskDefinition(args: DescribeTaskDefinitionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeTaskDefinitionCommandOutput) => void): void;
|
|
347
347
|
/**
|
|
348
348
|
* <p>Describes a specified task or tasks.</p>
|
|
349
|
-
*
|
|
349
|
+
* <p>Currently, stopped tasks appear in the returned results for at least one hour.</p>
|
|
350
350
|
*/
|
|
351
351
|
describeTasks(args: DescribeTasksCommandInput, options?: __HttpHandlerOptions): Promise<DescribeTasksCommandOutput>;
|
|
352
352
|
describeTasks(args: DescribeTasksCommandInput, cb: (err: any, data?: DescribeTasksCommandOutput) => void): void;
|
|
@@ -364,17 +364,19 @@ export declare class ECS extends ECSClient {
|
|
|
364
364
|
* <note>
|
|
365
365
|
* <p>This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.</p>
|
|
366
366
|
* </note>
|
|
367
|
-
*
|
|
367
|
+
* <p>Returns an endpoint for the Amazon ECS agent to poll for updates.</p>
|
|
368
368
|
*/
|
|
369
369
|
discoverPollEndpoint(args: DiscoverPollEndpointCommandInput, options?: __HttpHandlerOptions): Promise<DiscoverPollEndpointCommandOutput>;
|
|
370
370
|
discoverPollEndpoint(args: DiscoverPollEndpointCommandInput, cb: (err: any, data?: DiscoverPollEndpointCommandOutput) => void): void;
|
|
371
371
|
discoverPollEndpoint(args: DiscoverPollEndpointCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DiscoverPollEndpointCommandOutput) => void): void;
|
|
372
372
|
/**
|
|
373
373
|
* <p>Runs a command remotely on a container within a task.</p>
|
|
374
|
-
*
|
|
374
|
+
* <p>If you use a condition key in your IAM policy to refine the conditions for the policy
|
|
375
375
|
* statement, for example limit the actions to a specific cluster, you receive an
|
|
376
376
|
* <code>AccessDeniedException</code> when there is a mismatch between the condition
|
|
377
377
|
* key value and the corresponding parameter value.</p>
|
|
378
|
+
* <p>For information about required permissions and considerations, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.htm">Using Amazon ECS Exec for
|
|
379
|
+
* debugging</a> in the <i>Amazon ECS Developer Guide</i>. </p>
|
|
378
380
|
*/
|
|
379
381
|
executeCommand(args: ExecuteCommandCommandInput, options?: __HttpHandlerOptions): Promise<ExecuteCommandCommandOutput>;
|
|
380
382
|
executeCommand(args: ExecuteCommandCommandInput, cb: (err: any, data?: ExecuteCommandCommandOutput) => void): void;
|
|
@@ -444,7 +446,7 @@ export declare class ECS extends ECSClient {
|
|
|
444
446
|
* <p>Returns a list of task definition families that are registered to your account. This
|
|
445
447
|
* list includes task definition families that no longer have any <code>ACTIVE</code> task
|
|
446
448
|
* definition revisions.</p>
|
|
447
|
-
*
|
|
449
|
+
* <p>You can filter out task definition families that don't contain any <code>ACTIVE</code>
|
|
448
450
|
* task definition revisions by setting the <code>status</code> parameter to
|
|
449
451
|
* <code>ACTIVE</code>. You can also filter the results with the
|
|
450
452
|
* <code>familyPrefix</code> parameter.</p>
|
|
@@ -464,7 +466,7 @@ export declare class ECS extends ECSClient {
|
|
|
464
466
|
* <p>Returns a list of tasks. You can filter the results by cluster, task definition
|
|
465
467
|
* family, container instance, launch type, what IAM principal started the task, or by the
|
|
466
468
|
* desired status of the task.</p>
|
|
467
|
-
*
|
|
469
|
+
* <p>Recently stopped tasks might appear in the returned results. Currently, stopped tasks
|
|
468
470
|
* appear in the returned results for at least one hour.</p>
|
|
469
471
|
*/
|
|
470
472
|
listTasks(args: ListTasksCommandInput, options?: __HttpHandlerOptions): Promise<ListTasksCommandOutput>;
|
|
@@ -472,24 +474,24 @@ export declare class ECS extends ECSClient {
|
|
|
472
474
|
listTasks(args: ListTasksCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTasksCommandOutput) => void): void;
|
|
473
475
|
/**
|
|
474
476
|
* <p>Modifies an account setting. Account settings are set on a per-Region basis.</p>
|
|
475
|
-
*
|
|
477
|
+
* <p>If you change the account setting for the root user, the default settings for all of
|
|
476
478
|
* the IAM users and roles that no individual account setting was specified are reset for.
|
|
477
479
|
* For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html">Account
|
|
478
480
|
* Settings</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
479
|
-
*
|
|
481
|
+
* <p>When <code>serviceLongArnFormat</code>, <code>taskLongArnFormat</code>, or
|
|
480
482
|
* <code>containerInstanceLongArnFormat</code> are specified, the Amazon Resource Name
|
|
481
483
|
* (ARN) and resource ID format of the resource type for a specified IAM user, IAM role, or
|
|
482
484
|
* the root user for an account is affected. The opt-in and opt-out account setting must be
|
|
483
485
|
* set for each Amazon ECS resource separately. The ARN and resource ID format of a resource
|
|
484
486
|
* is defined by the opt-in status of the IAM user or role that created the resource. You
|
|
485
487
|
* must turn on this setting to use Amazon ECS features such as resource tagging.</p>
|
|
486
|
-
*
|
|
488
|
+
* <p>When <code>awsvpcTrunking</code> is specified, the elastic network interface (ENI)
|
|
487
489
|
* limit for any new container instances that support the feature is changed. If
|
|
488
490
|
* <code>awsvpcTrunking</code> is enabled, any new container instances that support the
|
|
489
491
|
* feature are launched have the increased ENI limits available to them. For more
|
|
490
492
|
* information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-eni.html">Elastic Network
|
|
491
493
|
* Interface Trunking</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
492
|
-
*
|
|
494
|
+
* <p>When <code>containerInsights</code> is specified, the default setting indicating
|
|
493
495
|
* whether CloudWatch Container Insights is enabled for your clusters is changed. If
|
|
494
496
|
* <code>containerInsights</code> is enabled, any new clusters that are created will
|
|
495
497
|
* have Container Insights enabled unless you disable it during cluster creation. For more
|
|
@@ -519,14 +521,14 @@ export declare class ECS extends ECSClient {
|
|
|
519
521
|
/**
|
|
520
522
|
* <p>Modifies the available capacity providers and the default capacity provider strategy
|
|
521
523
|
* for a cluster.</p>
|
|
522
|
-
*
|
|
524
|
+
* <p>You must specify both the available capacity providers and a default capacity provider
|
|
523
525
|
* strategy for the cluster. If the specified cluster has existing capacity providers
|
|
524
526
|
* associated with it, you must specify all existing capacity providers in addition to any
|
|
525
527
|
* new ones you want to add. Any existing capacity providers that are associated with a
|
|
526
528
|
* cluster that are omitted from a <a>PutClusterCapacityProviders</a> API call
|
|
527
529
|
* will be disassociated with the cluster. You can only disassociate an existing capacity
|
|
528
530
|
* provider from a cluster if it's not being used by any existing tasks.</p>
|
|
529
|
-
*
|
|
531
|
+
* <p>When creating a service or running a task on a cluster, if no capacity provider or
|
|
530
532
|
* launch type is specified, then the cluster's default capacity provider strategy is used.
|
|
531
533
|
* We recommend that you define a default capacity provider strategy for your cluster.
|
|
532
534
|
* However, you must specify an empty array (<code>[]</code>) to bypass defining a default
|
|
@@ -539,7 +541,7 @@ export declare class ECS extends ECSClient {
|
|
|
539
541
|
* <note>
|
|
540
542
|
* <p>This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.</p>
|
|
541
543
|
* </note>
|
|
542
|
-
*
|
|
544
|
+
* <p>Registers an EC2 instance into the specified cluster. This instance becomes available
|
|
543
545
|
* to place containers on.</p>
|
|
544
546
|
*/
|
|
545
547
|
registerContainerInstance(args: RegisterContainerInstanceCommandInput, options?: __HttpHandlerOptions): Promise<RegisterContainerInstanceCommandOutput>;
|
|
@@ -551,12 +553,12 @@ export declare class ECS extends ECSClient {
|
|
|
551
553
|
* containers with the <code>volumes</code> parameter. For more information about task
|
|
552
554
|
* definition parameters and defaults, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html">Amazon ECS Task
|
|
553
555
|
* Definitions</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
554
|
-
*
|
|
556
|
+
* <p>You can specify an IAM role for your task with the <code>taskRoleArn</code> parameter.
|
|
555
557
|
* When you specify an IAM role for a task, its containers can then use the latest versions
|
|
556
558
|
* of the CLI or SDKs to make API requests to the Amazon Web Services services that are specified in
|
|
557
559
|
* the IAM policy that's associated with the role. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM
|
|
558
560
|
* Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
559
|
-
*
|
|
561
|
+
* <p>You can specify a Docker networking mode for the containers in your task definition
|
|
560
562
|
* with the <code>networkMode</code> parameter. The available network modes correspond to
|
|
561
563
|
* those described in <a href="https://docs.docker.com/engine/reference/run/#/network-settings">Network
|
|
562
564
|
* settings</a> in the Docker run reference. If you specify the <code>awsvpc</code>
|
|
@@ -570,32 +572,32 @@ export declare class ECS extends ECSClient {
|
|
|
570
572
|
registerTaskDefinition(args: RegisterTaskDefinitionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RegisterTaskDefinitionCommandOutput) => void): void;
|
|
571
573
|
/**
|
|
572
574
|
* <p>Starts a new task using the specified task definition.</p>
|
|
573
|
-
*
|
|
575
|
+
* <p>You can allow Amazon ECS to place tasks for you, or you can customize how Amazon ECS places
|
|
574
576
|
* tasks using placement constraints and placement strategies. For more information, see
|
|
575
577
|
* <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling Tasks</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
576
|
-
*
|
|
578
|
+
* <p>Alternatively, you can use <a>StartTask</a> to use your own scheduler or
|
|
577
579
|
* place tasks manually on specific container instances.</p>
|
|
578
|
-
*
|
|
580
|
+
* <p>The Amazon ECS API follows an eventual consistency model. This is because of the
|
|
579
581
|
* distributed nature of the system supporting the API. This means that the result of an
|
|
580
582
|
* API command you run that affects your Amazon ECS resources might not be immediately visible
|
|
581
583
|
* to all subsequent commands you run. Keep this in mind when you carry out an API command
|
|
582
584
|
* that immediately follows a previous API command.</p>
|
|
583
|
-
*
|
|
584
|
-
*
|
|
585
|
+
* <p>To manage eventual consistency, you can do the following:</p>
|
|
586
|
+
* <ul>
|
|
585
587
|
* <li>
|
|
586
|
-
*
|
|
588
|
+
* <p>Confirm the state of the resource before you run a command to modify it. Run
|
|
587
589
|
* the DescribeTasks command using an exponential backoff algorithm to ensure that
|
|
588
590
|
* you allow enough time for the previous command to propagate through the system.
|
|
589
591
|
* To do this, run the DescribeTasks command repeatedly, starting with a couple of
|
|
590
592
|
* seconds of wait time and increasing gradually up to five minutes of wait
|
|
591
593
|
* time.</p>
|
|
592
|
-
*
|
|
594
|
+
* </li>
|
|
593
595
|
* <li>
|
|
594
|
-
*
|
|
596
|
+
* <p>Add wait time between subsequent commands, even if the DescribeTasks command
|
|
595
597
|
* returns an accurate response. Apply an exponential backoff algorithm starting
|
|
596
598
|
* with a couple of seconds of wait time, and increase gradually up to about five
|
|
597
599
|
* minutes of wait time.</p>
|
|
598
|
-
*
|
|
600
|
+
* </li>
|
|
599
601
|
* </ul>
|
|
600
602
|
*/
|
|
601
603
|
runTask(args: RunTaskCommandInput, options?: __HttpHandlerOptions): Promise<RunTaskCommandOutput>;
|
|
@@ -604,7 +606,7 @@ export declare class ECS extends ECSClient {
|
|
|
604
606
|
/**
|
|
605
607
|
* <p>Starts a new task from the specified task definition on the specified container
|
|
606
608
|
* instance or instances.</p>
|
|
607
|
-
*
|
|
609
|
+
* <p>Alternatively, you can use <a>RunTask</a> to place tasks for you. For more
|
|
608
610
|
* information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling Tasks</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
609
611
|
*/
|
|
610
612
|
startTask(args: StartTaskCommandInput, options?: __HttpHandlerOptions): Promise<StartTaskCommandOutput>;
|
|
@@ -612,18 +614,18 @@ export declare class ECS extends ECSClient {
|
|
|
612
614
|
startTask(args: StartTaskCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartTaskCommandOutput) => void): void;
|
|
613
615
|
/**
|
|
614
616
|
* <p>Stops a running task. Any tags associated with the task will be deleted.</p>
|
|
615
|
-
*
|
|
617
|
+
* <p>When <a>StopTask</a> is called on a task, the equivalent of <code>docker
|
|
616
618
|
* stop</code> is issued to the containers running in the task. This results in a
|
|
617
619
|
* <code>SIGTERM</code> value and a default 30-second timeout, after which the
|
|
618
620
|
* <code>SIGKILL</code> value is sent and the containers are forcibly stopped. If the
|
|
619
621
|
* container handles the <code>SIGTERM</code> value gracefully and exits within 30 seconds
|
|
620
622
|
* from receiving it, no <code>SIGKILL</code> value is sent.</p>
|
|
621
|
-
*
|
|
622
|
-
*
|
|
623
|
+
* <note>
|
|
624
|
+
* <p>The default 30-second timeout can be configured on the Amazon ECS container agent with
|
|
623
625
|
* the <code>ECS_CONTAINER_STOP_TIMEOUT</code> variable. For more information, see
|
|
624
626
|
* <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html">Amazon ECS Container Agent Configuration</a> in the
|
|
625
627
|
* <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
626
|
-
*
|
|
628
|
+
* </note>
|
|
627
629
|
*/
|
|
628
630
|
stopTask(args: StopTaskCommandInput, options?: __HttpHandlerOptions): Promise<StopTaskCommandOutput>;
|
|
629
631
|
stopTask(args: StopTaskCommandInput, cb: (err: any, data?: StopTaskCommandOutput) => void): void;
|
|
@@ -632,7 +634,7 @@ export declare class ECS extends ECSClient {
|
|
|
632
634
|
* <note>
|
|
633
635
|
* <p>This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.</p>
|
|
634
636
|
* </note>
|
|
635
|
-
*
|
|
637
|
+
* <p>Sent to acknowledge that an attachment changed states.</p>
|
|
636
638
|
*/
|
|
637
639
|
submitAttachmentStateChanges(args: SubmitAttachmentStateChangesCommandInput, options?: __HttpHandlerOptions): Promise<SubmitAttachmentStateChangesCommandOutput>;
|
|
638
640
|
submitAttachmentStateChanges(args: SubmitAttachmentStateChangesCommandInput, cb: (err: any, data?: SubmitAttachmentStateChangesCommandOutput) => void): void;
|
|
@@ -641,7 +643,7 @@ export declare class ECS extends ECSClient {
|
|
|
641
643
|
* <note>
|
|
642
644
|
* <p>This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.</p>
|
|
643
645
|
* </note>
|
|
644
|
-
*
|
|
646
|
+
* <p>Sent to acknowledge that a container changed states.</p>
|
|
645
647
|
*/
|
|
646
648
|
submitContainerStateChange(args: SubmitContainerStateChangeCommandInput, options?: __HttpHandlerOptions): Promise<SubmitContainerStateChangeCommandOutput>;
|
|
647
649
|
submitContainerStateChange(args: SubmitContainerStateChangeCommandInput, cb: (err: any, data?: SubmitContainerStateChangeCommandOutput) => void): void;
|
|
@@ -650,7 +652,7 @@ export declare class ECS extends ECSClient {
|
|
|
650
652
|
* <note>
|
|
651
653
|
* <p>This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.</p>
|
|
652
654
|
* </note>
|
|
653
|
-
*
|
|
655
|
+
* <p>Sent to acknowledge that a task changed states.</p>
|
|
654
656
|
*/
|
|
655
657
|
submitTaskStateChange(args: SubmitTaskStateChangeCommandInput, options?: __HttpHandlerOptions): Promise<SubmitTaskStateChangeCommandOutput>;
|
|
656
658
|
submitTaskStateChange(args: SubmitTaskStateChangeCommandInput, cb: (err: any, data?: SubmitTaskStateChangeCommandOutput) => void): void;
|
|
@@ -693,19 +695,19 @@ export declare class ECS extends ECSClient {
|
|
|
693
695
|
* Amazon ECS container agent doesn't interrupt running tasks or services on the container
|
|
694
696
|
* instance. The process for updating the agent differs depending on whether your container
|
|
695
697
|
* instance was launched with the Amazon ECS-optimized AMI or another operating system.</p>
|
|
696
|
-
*
|
|
697
|
-
*
|
|
698
|
+
* <note>
|
|
699
|
+
* <p>The <code>UpdateContainerAgent</code> API isn't supported for container instances
|
|
698
700
|
* using the Amazon ECS-optimized Amazon Linux 2 (arm64) AMI. To update the container agent,
|
|
699
701
|
* you can update the <code>ecs-init</code> package. This updates the agent. For more
|
|
700
702
|
* information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/agent-update-ecs-ami.html">Updating the
|
|
701
703
|
* Amazon ECS container agent</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
702
|
-
*
|
|
703
|
-
*
|
|
704
|
-
*
|
|
704
|
+
* </note>
|
|
705
|
+
* <note>
|
|
706
|
+
* <p>Agent updates with the <code>UpdateContainerAgent</code> API operation do not
|
|
705
707
|
* apply to Windows container instances. We recommend that you launch new container
|
|
706
708
|
* instances to update the agent version in your Windows clusters.</p>
|
|
707
|
-
*
|
|
708
|
-
*
|
|
709
|
+
* </note>
|
|
710
|
+
* <p>The <code>UpdateContainerAgent</code> API requires an Amazon ECS-optimized AMI or Amazon
|
|
709
711
|
* Linux AMI with the <code>ecs-init</code> service installed and running. For help
|
|
710
712
|
* updating the Amazon ECS container agent on other operating systems, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html#manually_update_agent">Manually updating the Amazon ECS container agent</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
711
713
|
*/
|
|
@@ -714,27 +716,27 @@ export declare class ECS extends ECSClient {
|
|
|
714
716
|
updateContainerAgent(args: UpdateContainerAgentCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateContainerAgentCommandOutput) => void): void;
|
|
715
717
|
/**
|
|
716
718
|
* <p>Modifies the status of an Amazon ECS container instance.</p>
|
|
717
|
-
*
|
|
719
|
+
* <p>Once a container instance has reached an <code>ACTIVE</code> state, you can change the
|
|
718
720
|
* status of a container instance to <code>DRAINING</code> to manually remove an instance
|
|
719
721
|
* from a cluster, for example to perform system updates, update the Docker daemon, or
|
|
720
722
|
* scale down the cluster size.</p>
|
|
721
|
-
*
|
|
722
|
-
*
|
|
723
|
+
* <important>
|
|
724
|
+
* <p>A container instance can't be changed to <code>DRAINING</code> until it has
|
|
723
725
|
* reached an <code>ACTIVE</code> status. If the instance is in any other status, an
|
|
724
726
|
* error will be received.</p>
|
|
725
|
-
*
|
|
726
|
-
*
|
|
727
|
+
* </important>
|
|
728
|
+
* <p>When you set a container instance to <code>DRAINING</code>, Amazon ECS prevents new tasks
|
|
727
729
|
* from being scheduled for placement on the container instance and replacement service
|
|
728
730
|
* tasks are started on other container instances in the cluster if the resources are
|
|
729
731
|
* available. Service tasks on the container instance that are in the <code>PENDING</code>
|
|
730
732
|
* state are stopped immediately.</p>
|
|
731
|
-
*
|
|
733
|
+
* <p>Service tasks on the container instance that are in the <code>RUNNING</code> state are
|
|
732
734
|
* stopped and replaced according to the service's deployment configuration parameters,
|
|
733
735
|
* <code>minimumHealthyPercent</code> and <code>maximumPercent</code>. You can change
|
|
734
736
|
* the deployment configuration of your service using <a>UpdateService</a>.</p>
|
|
735
|
-
*
|
|
737
|
+
* <ul>
|
|
736
738
|
* <li>
|
|
737
|
-
*
|
|
739
|
+
* <p>If <code>minimumHealthyPercent</code> is below 100%, the scheduler can ignore
|
|
738
740
|
* <code>desiredCount</code> temporarily during task replacement. For example,
|
|
739
741
|
* <code>desiredCount</code> is four tasks, a minimum of 50% allows the
|
|
740
742
|
* scheduler to stop two existing tasks before starting two new tasks. If the
|
|
@@ -744,22 +746,22 @@ export declare class ECS extends ECSClient {
|
|
|
744
746
|
* state. Tasks for services that use a load balancer are considered healthy if
|
|
745
747
|
* they're in the <code>RUNNING</code> state and are reported as healthy by the
|
|
746
748
|
* load balancer.</p>
|
|
747
|
-
*
|
|
749
|
+
* </li>
|
|
748
750
|
* <li>
|
|
749
|
-
*
|
|
751
|
+
* <p>The <code>maximumPercent</code> parameter represents an upper limit on the
|
|
750
752
|
* number of running tasks during task replacement. You can use this to define the
|
|
751
753
|
* replacement batch size. For example, if <code>desiredCount</code> is four tasks,
|
|
752
754
|
* a maximum of 200% starts four new tasks before stopping the four tasks to be
|
|
753
755
|
* drained, provided that the cluster resources required to do this are available.
|
|
754
756
|
* If the maximum is 100%, then replacement tasks can't start until the draining
|
|
755
757
|
* tasks have stopped.</p>
|
|
756
|
-
*
|
|
758
|
+
* </li>
|
|
757
759
|
* </ul>
|
|
758
|
-
*
|
|
760
|
+
* <p>Any <code>PENDING</code> or <code>RUNNING</code> tasks that do not belong to a service
|
|
759
761
|
* aren't affected. You must wait for them to finish or stop them manually.</p>
|
|
760
|
-
*
|
|
762
|
+
* <p>A container instance has completed draining when it has no more <code>RUNNING</code>
|
|
761
763
|
* tasks. You can verify this using <a>ListTasks</a>.</p>
|
|
762
|
-
*
|
|
764
|
+
* <p>When a container instance has been drained, you can set a container instance to
|
|
763
765
|
* <code>ACTIVE</code> status and once it has reached that status the Amazon ECS scheduler
|
|
764
766
|
* can begin scheduling tasks on the instance again.</p>
|
|
765
767
|
*/
|
|
@@ -768,44 +770,44 @@ export declare class ECS extends ECSClient {
|
|
|
768
770
|
updateContainerInstancesState(args: UpdateContainerInstancesStateCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateContainerInstancesStateCommandOutput) => void): void;
|
|
769
771
|
/**
|
|
770
772
|
* <p>Modifies the parameters of a service.</p>
|
|
771
|
-
*
|
|
773
|
+
* <p>For services using the rolling update (<code>ECS</code>) you can update the desired
|
|
772
774
|
* count, deployment configuration, network configuration, load balancers, service
|
|
773
775
|
* registries, enable ECS managed tags option, propagate tags option, task placement
|
|
774
776
|
* constraints and strategies, and task definition. When you update any of these
|
|
775
777
|
* parameters, Amazon ECS starts new tasks with the new configuration. </p>
|
|
776
|
-
*
|
|
778
|
+
* <p>For services using the blue/green (<code>CODE_DEPLOY</code>) deployment controller,
|
|
777
779
|
* only the desired count, deployment configuration, health check grace period, task
|
|
778
780
|
* placement constraints and strategies, enable ECS managed tags option, and propagate tags
|
|
779
781
|
* can be updated using this API. If the network configuration, platform version, task
|
|
780
782
|
* definition, or load balancer need to be updated, create a new CodeDeploy deployment. For more
|
|
781
783
|
* information, see <a href="https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_CreateDeployment.html">CreateDeployment</a> in the <i>CodeDeploy API Reference</i>.</p>
|
|
782
|
-
*
|
|
784
|
+
* <p>For services using an external deployment controller, you can update only the desired
|
|
783
785
|
* count, task placement constraints and strategies, health check grace period, enable ECS
|
|
784
786
|
* managed tags option, and propagate tags option, using this API. If the launch type, load
|
|
785
787
|
* balancer, network configuration, platform version, or task definition need to be
|
|
786
788
|
* updated, create a new task set For more information, see <a>CreateTaskSet</a>.</p>
|
|
787
|
-
*
|
|
789
|
+
* <p>You can add to or subtract from the number of instantiations of a task definition in a
|
|
788
790
|
* service by specifying the cluster that the service is running in and a new
|
|
789
791
|
* <code>desiredCount</code> parameter.</p>
|
|
790
|
-
*
|
|
792
|
+
* <p>If you have updated the Docker image of your application, you can create a new task
|
|
791
793
|
* definition with that image and deploy it to your service. The service scheduler uses the
|
|
792
794
|
* minimum healthy percent and maximum percent parameters (in the service's deployment
|
|
793
795
|
* configuration) to determine the deployment strategy.</p>
|
|
794
|
-
*
|
|
795
|
-
*
|
|
796
|
+
* <note>
|
|
797
|
+
* <p>If your updated Docker image uses the same tag as what is in the existing task
|
|
796
798
|
* definition for your service (for example, <code>my_image:latest</code>), you don't
|
|
797
799
|
* need to create a new revision of your task definition. You can update the service
|
|
798
800
|
* using the <code>forceNewDeployment</code> option. The new tasks launched by the
|
|
799
801
|
* deployment pull the current image/tag combination from your repository when they
|
|
800
802
|
* start.</p>
|
|
801
|
-
*
|
|
802
|
-
*
|
|
803
|
+
* </note>
|
|
804
|
+
* <p>You can also update the deployment configuration of a service. When a deployment is
|
|
803
805
|
* triggered by updating the task definition of a service, the service scheduler uses the
|
|
804
806
|
* deployment configuration parameters, <code>minimumHealthyPercent</code> and
|
|
805
807
|
* <code>maximumPercent</code>, to determine the deployment strategy.</p>
|
|
806
|
-
*
|
|
808
|
+
* <ul>
|
|
807
809
|
* <li>
|
|
808
|
-
*
|
|
810
|
+
* <p>If <code>minimumHealthyPercent</code> is below 100%, the scheduler can ignore
|
|
809
811
|
* <code>desiredCount</code> temporarily during a deployment. For example, if
|
|
810
812
|
* <code>desiredCount</code> is four tasks, a minimum of 50% allows the
|
|
811
813
|
* scheduler to stop two existing tasks before starting two new tasks. Tasks for
|
|
@@ -813,84 +815,83 @@ export declare class ECS extends ECSClient {
|
|
|
813
815
|
* <code>RUNNING</code> state. Tasks for services that use a load balancer are
|
|
814
816
|
* considered healthy if they're in the <code>RUNNING</code> state and are reported
|
|
815
817
|
* as healthy by the load balancer.</p>
|
|
816
|
-
*
|
|
818
|
+
* </li>
|
|
817
819
|
* <li>
|
|
818
|
-
*
|
|
820
|
+
* <p>The <code>maximumPercent</code> parameter represents an upper limit on the
|
|
819
821
|
* number of running tasks during a deployment. You can use it to define the
|
|
820
822
|
* deployment batch size. For example, if <code>desiredCount</code> is four tasks,
|
|
821
823
|
* a maximum of 200% starts four new tasks before stopping the four older tasks
|
|
822
824
|
* (provided that the cluster resources required to do this are available).</p>
|
|
823
|
-
*
|
|
825
|
+
* </li>
|
|
824
826
|
* </ul>
|
|
825
|
-
*
|
|
827
|
+
* <p>When <a>UpdateService</a> stops a task during a deployment, the equivalent
|
|
826
828
|
* of <code>docker stop</code> is issued to the containers running in the task. This
|
|
827
829
|
* results in a <code>SIGTERM</code> and a 30-second timeout. After this,
|
|
828
830
|
* <code>SIGKILL</code> is sent and the containers are forcibly stopped. If the
|
|
829
831
|
* container handles the <code>SIGTERM</code> gracefully and exits within 30 seconds from
|
|
830
832
|
* receiving it, no <code>SIGKILL</code> is sent.</p>
|
|
831
|
-
*
|
|
833
|
+
* <p>When the service scheduler launches new tasks, it determines task placement in your
|
|
832
834
|
* cluster with the following logic.</p>
|
|
833
|
-
*
|
|
835
|
+
* <ul>
|
|
834
836
|
* <li>
|
|
835
|
-
*
|
|
837
|
+
* <p>Determine which of the container instances in your cluster can support your
|
|
836
838
|
* service's task definition. For example, they have the required CPU, memory,
|
|
837
839
|
* ports, and container instance attributes.</p>
|
|
838
|
-
*
|
|
840
|
+
* </li>
|
|
839
841
|
* <li>
|
|
840
|
-
*
|
|
842
|
+
* <p>By default, the service scheduler attempts to balance tasks across
|
|
841
843
|
* Availability Zones in this manner even though you can choose a different
|
|
842
844
|
* placement strategy.</p>
|
|
843
|
-
*
|
|
845
|
+
* <ul>
|
|
844
846
|
* <li>
|
|
845
|
-
*
|
|
847
|
+
* <p>Sort the valid container instances by the fewest number of running
|
|
846
848
|
* tasks for this service in the same Availability Zone as the instance.
|
|
847
849
|
* For example, if zone A has one running service task and zones B and C
|
|
848
850
|
* each have zero, valid container instances in either zone B or C are
|
|
849
851
|
* considered optimal for placement.</p>
|
|
850
|
-
*
|
|
852
|
+
* </li>
|
|
851
853
|
* <li>
|
|
852
|
-
*
|
|
854
|
+
* <p>Place the new service task on a valid container instance in an optimal
|
|
853
855
|
* Availability Zone (based on the previous steps), favoring container
|
|
854
856
|
* instances with the fewest number of running tasks for this
|
|
855
857
|
* service.</p>
|
|
856
|
-
*
|
|
858
|
+
* </li>
|
|
857
859
|
* </ul>
|
|
858
|
-
*
|
|
860
|
+
* </li>
|
|
859
861
|
* </ul>
|
|
860
|
-
*
|
|
861
|
-
* <p>When the service scheduler stops running tasks, it attempts to maintain balance across
|
|
862
|
+
* <p>When the service scheduler stops running tasks, it attempts to maintain balance across
|
|
862
863
|
* the Availability Zones in your cluster using the following logic: </p>
|
|
863
|
-
*
|
|
864
|
+
* <ul>
|
|
864
865
|
* <li>
|
|
865
|
-
*
|
|
866
|
+
* <p>Sort the container instances by the largest number of running tasks for this
|
|
866
867
|
* service in the same Availability Zone as the instance. For example, if zone A
|
|
867
868
|
* has one running service task and zones B and C each have two, container
|
|
868
869
|
* instances in either zone B or C are considered optimal for termination.</p>
|
|
869
|
-
*
|
|
870
|
+
* </li>
|
|
870
871
|
* <li>
|
|
871
|
-
*
|
|
872
|
+
* <p>Stop the task on a container instance in an optimal Availability Zone (based
|
|
872
873
|
* on the previous steps), favoring container instances with the largest number of
|
|
873
874
|
* running tasks for this service.</p>
|
|
874
|
-
*
|
|
875
|
+
* </li>
|
|
875
876
|
* </ul>
|
|
876
|
-
*
|
|
877
|
-
*
|
|
877
|
+
* <note>
|
|
878
|
+
* <p>You must have a service-linked role when you update any of the following service
|
|
878
879
|
* properties. If you specified a custom IAM role when you created the service, Amazon ECS
|
|
879
880
|
* automatically replaces the <a href="https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_Service.html#ECS-Type-Service-roleArn">roleARN</a> associated with the service with the ARN of your
|
|
880
881
|
* service-linked role. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html">Service-linked roles</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
|
|
881
|
-
*
|
|
882
|
+
* <ul>
|
|
882
883
|
* <li>
|
|
883
|
-
*
|
|
884
|
+
* <p>
|
|
884
885
|
* <code>loadBalancers,</code>
|
|
885
886
|
* </p>
|
|
886
|
-
*
|
|
887
|
+
* </li>
|
|
887
888
|
* <li>
|
|
888
|
-
*
|
|
889
|
+
* <p>
|
|
889
890
|
* <code>serviceRegistries</code>
|
|
890
891
|
* </p>
|
|
891
|
-
*
|
|
892
|
+
* </li>
|
|
892
893
|
* </ul>
|
|
893
|
-
*
|
|
894
|
+
* </note>
|
|
894
895
|
*/
|
|
895
896
|
updateService(args: UpdateServiceCommandInput, options?: __HttpHandlerOptions): Promise<UpdateServiceCommandOutput>;
|
|
896
897
|
updateService(args: UpdateServiceCommandInput, cb: (err: any, data?: UpdateServiceCommandOutput) => void): void;
|
|
@@ -910,29 +911,29 @@ export declare class ECS extends ECSClient {
|
|
|
910
911
|
* <code>true</code> to protect your task from termination during scale-in events from
|
|
911
912
|
* <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-auto-scaling.html">Service
|
|
912
913
|
* Autoscaling</a> or <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">deployments</a>.</p>
|
|
913
|
-
*
|
|
914
|
+
* <p>Task-protection, by default, expires after 2 hours at which point Amazon ECS unsets the
|
|
914
915
|
* <code>protectionEnabled</code> property making the task eligible for termination by
|
|
915
916
|
* a subsequent scale-in event.</p>
|
|
916
|
-
*
|
|
917
|
+
* <p>You can specify a custom expiration period for task protection from 1 minute to up to
|
|
917
918
|
* 2,880 minutes (48 hours). To specify the custom expiration period, set the
|
|
918
919
|
* <code>expiresInMinutes</code> property. The <code>expiresInMinutes</code> property
|
|
919
920
|
* is always reset when you invoke this operation for a task that already has
|
|
920
921
|
* <code>protectionEnabled</code> set to <code>true</code>. You can keep extending the
|
|
921
922
|
* protection expiration period of a task by invoking this operation repeatedly.</p>
|
|
922
|
-
*
|
|
923
|
+
* <p>To learn more about Amazon ECS task protection, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-scale-in-protection.html">Task scale-in
|
|
923
924
|
* protection</a> in the <i>
|
|
924
925
|
* <i>Amazon Elastic Container Service Developer Guide</i>
|
|
925
926
|
* </i>.</p>
|
|
926
|
-
*
|
|
927
|
-
*
|
|
927
|
+
* <note>
|
|
928
|
+
* <p>This operation is only supported for tasks belonging to an Amazon ECS service. Invoking
|
|
928
929
|
* this operation for a standalone task will result in an <code>TASK_NOT_VALID</code>
|
|
929
930
|
* failure. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/api_failures_messages.html">API failure
|
|
930
931
|
* reasons</a>.</p>
|
|
931
|
-
*
|
|
932
|
-
*
|
|
933
|
-
*
|
|
932
|
+
* </note>
|
|
933
|
+
* <important>
|
|
934
|
+
* <p>If you prefer to set task protection from within the container, we recommend using
|
|
934
935
|
* the <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-scale-in-protection-endpoint.html">Task scale-in protection endpoint</a>.</p>
|
|
935
|
-
*
|
|
936
|
+
* </important>
|
|
936
937
|
*/
|
|
937
938
|
updateTaskProtection(args: UpdateTaskProtectionCommandInput, options?: __HttpHandlerOptions): Promise<UpdateTaskProtectionCommandOutput>;
|
|
938
939
|
updateTaskProtection(args: UpdateTaskProtectionCommandInput, cb: (err: any, data?: UpdateTaskProtectionCommandOutput) => void): void;
|