sst 3.4.25 → 3.4.27

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.
Files changed (5) hide show
  1. package/dist/aws/task.d.ts +41 -10
  2. package/dist/aws/task.js +24 -4
  3. package/package.json +6 -6
  4. package/dist/aws/types/aws-sdk-client-ecs.d.ts +0 -1564
  5. package/dist/aws/types/aws-sdk-client-ecs.js +0 -1
package/dist/aws/types/aws-sdk-client-ecs.d.ts DELETED
@@ -1,1564 +0,0 @@
1
- export interface DescribeTasksRequest {
2
- /**
3
- * <p>The short name or full Amazon Resource Name (ARN) of the cluster that hosts the task or tasks to
4
- * describe. If you do not specify a cluster, the default cluster is assumed. This parameter is required. If you do not specify a
5
- * value, the <code>default</code> cluster is used.</p>
6
- * @public
7
- */
8
- cluster?: string | undefined;
9
- /**
10
- * <p>A list of up to 100 task IDs or full ARN entries.</p>
11
- * @public
12
- */
13
- tasks: string[] | undefined;
14
- /**
15
- * <p>Specifies whether you want to see the resource tags for the task. If <code>TAGS</code>
16
- * is specified, the tags are included in the response. If this field is omitted, tags
17
- * aren't included in the response.</p>
18
- * @public
19
- */
20
- include?: TaskField[] | undefined;
21
- }
22
- export interface DescribeTasksResponse {
23
- /**
24
- * <p>The list of tasks.</p>
25
- * @public
26
- */
27
- tasks?: Task[] | undefined;
28
- /**
29
- * <p>Any failures associated with the call.</p>
30
- * @public
31
- */
32
- failures?: Failure[] | undefined;
33
- }
34
- export interface RunTaskRequest {
35
- /**
36
- * <p>The capacity provider strategy to use for the task.</p>
37
- * <p>If a <code>capacityProviderStrategy</code> is specified, the <code>launchType</code>
38
- * parameter must be omitted. If no <code>capacityProviderStrategy</code> or
39
- * <code>launchType</code> is specified, the
40
- * <code>defaultCapacityProviderStrategy</code> for the cluster is used.</p>
41
- * <p>When you use cluster auto scaling, you must specify
42
- * <code>capacityProviderStrategy</code> and not <code>launchType</code>. </p>
43
- * <p>A capacity provider strategy can contain a maximum of 20 capacity providers.</p>
44
- * @public
45
- */
46
- capacityProviderStrategy?: CapacityProviderStrategyItem[] | undefined;
47
- /**
48
- * <p>The short name or full Amazon Resource Name (ARN) of the cluster to run your task on.
49
- * If you do not specify a cluster, the default cluster is assumed.</p>
50
- * @public
51
- */
52
- cluster?: string | undefined;
53
- /**
54
- * <p>The number of instantiations of the specified task to place on your cluster. You can
55
- * specify up to 10 tasks for each call.</p>
56
- * @public
57
- */
58
- count?: number | undefined;
59
- /**
60
- * <p>Specifies whether to use Amazon ECS managed tags for the task. For more information, see
61
- * <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html">Tagging Your Amazon ECS
62
- * Resources</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
63
- * @public
64
- */
65
- enableECSManagedTags?: boolean | undefined;
66
- /**
67
- * <p>Determines whether to use the execute command functionality for the containers in this
68
- * task. If <code>true</code>, this enables execute command functionality on all containers
69
- * in the task.</p>
70
- * <p>If <code>true</code>, then the task definition must have a task role, or you must
71
- * provide one as an override.</p>
72
- * @public
73
- */
74
- enableExecuteCommand?: boolean | undefined;
75
- /**
76
- * <p>The name of the task group to associate with the task. The default value is the family
77
- * name of the task definition (for example, <code>family:my-family-name</code>).</p>
78
- * @public
79
- */
80
- group?: string | undefined;
81
- /**
82
- * <p>The infrastructure to run your standalone task on. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html">Amazon ECS
83
- * launch types</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
84
- * <p>The <code>FARGATE</code> launch type runs your tasks on Fargate On-Demand
85
- * infrastructure.</p>
86
- * <note>
87
- * <p>Fargate Spot infrastructure is available for use but a capacity provider
88
- * strategy must be used. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-capacity-providers.html">Fargate capacity providers</a> in the
89
- * <i>Amazon ECS Developer Guide</i>.</p>
90
- * </note>
91
- * <p>The <code>EC2</code> launch type runs your tasks on Amazon EC2 instances registered to your
92
- * cluster.</p>
93
- * <p>The <code>EXTERNAL</code> launch type runs your tasks on your on-premises server or
94
- * virtual machine (VM) capacity registered to your cluster.</p>
95
- * <p>A task can use either a launch type or a capacity provider strategy. If a
96
- * <code>launchType</code> is specified, the <code>capacityProviderStrategy</code>
97
- * parameter must be omitted.</p>
98
- * <p>When you use cluster auto scaling, you must specify
99
- * <code>capacityProviderStrategy</code> and not <code>launchType</code>. </p>
100
- * @public
101
- */
102
- launchType?: LaunchType | undefined;
103
- /**
104
- * <p>The network configuration for the task. This parameter is required for task
105
- * definitions that use the <code>awsvpc</code> network mode to receive their own elastic
106
- * network interface, and it isn't supported for other network modes. For more information,
107
- * see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task networking</a>
108
- * in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
109
- * @public
110
- */
111
- networkConfiguration?: NetworkConfiguration | undefined;
112
- /**
113
- * <p>A list of container overrides in JSON format that specify the name of a container in
114
- * the specified task definition and the overrides it should receive. You can override the
115
- * default command for a container (that's specified in the task definition or Docker
116
- * image) with a <code>command</code> override. You can also override existing environment
117
- * variables (that are specified in the task definition or Docker image) on a container or
118
- * add new environment variables to it with an <code>environment</code> override.</p>
119
- * <p>A total of 8192 characters are allowed for overrides. This limit includes the JSON
120
- * formatting characters of the override structure.</p>
121
- * @public
122
- */
123
- overrides?: TaskOverride | undefined;
124
- /**
125
- * <p>An array of placement constraint objects to use for the task. You can specify up to 10
126
- * constraints for each task (including constraints in the task definition and those
127
- * specified at runtime).</p>
128
- * @public
129
- */
130
- placementConstraints?: PlacementConstraint[] | undefined;
131
- /**
132
- * <p>The placement strategy objects to use for the task. You can specify a maximum of 5
133
- * strategy rules for each task.</p>
134
- * @public
135
- */
136
- placementStrategy?: PlacementStrategy[] | undefined;
137
- /**
138
- * <p>The platform version the task uses. A platform version is only specified for tasks
139
- * hosted on Fargate. If one isn't specified, the <code>LATEST</code>
140
- * platform version is used. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html">Fargate platform
141
- * versions</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
142
- * @public
143
- */
144
- platformVersion?: string | undefined;
145
- /**
146
- * <p>Specifies whether to propagate the tags from the task definition to the task. If no
147
- * value is specified, the tags aren't propagated. Tags can only be propagated to the task
148
- * during task creation. To add tags to a task after task creation, use the<a href="https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TagResource.html">TagResource</a> API action.</p>
149
- * <note>
150
- * <p>An error will be received if you specify the <code>SERVICE</code> option when
151
- * running a task.</p>
152
- * </note>
153
- * @public
154
- */
155
- propagateTags?: PropagateTags | undefined;
156
- /**
157
- * <p>This parameter is only used by Amazon ECS. It is not intended for use by customers.</p>
158
- * @public
159
- */
160
- referenceId?: string | undefined;
161
- /**
162
- * <p>An optional tag specified when a task is started. For example, if you automatically
163
- * trigger a task to run a batch process job, you could apply a unique identifier for that
164
- * job to your task with the <code>startedBy</code> parameter. You can then identify which
165
- * tasks belong to that job by filtering the results of a <a href="https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ListTasks.html">ListTasks</a> call with
166
- * the <code>startedBy</code> value. Up to 128 letters (uppercase and lowercase), numbers,
167
- * hyphens (-), forward slash (/), and underscores (_) are allowed.</p>
168
- * <p>If a task is started by an Amazon ECS service, then the <code>startedBy</code> parameter
169
- * contains the deployment ID of the service that starts it.</p>
170
- * @public
171
- */
172
- startedBy?: string | undefined;
173
- /**
174
- * <p>The metadata that you apply to the task to help you categorize and organize them. Each
175
- * tag consists of a key and an optional value, both of which you define.</p>
176
- * <p>The following basic restrictions apply to tags:</p>
177
- * <ul>
178
- * <li>
179
- * <p>Maximum number of tags per resource - 50</p>
180
- * </li>
181
- * <li>
182
- * <p>For each resource, each tag key must be unique, and each tag key can have only
183
- * one value.</p>
184
- * </li>
185
- * <li>
186
- * <p>Maximum key length - 128 Unicode characters in UTF-8</p>
187
- * </li>
188
- * <li>
189
- * <p>Maximum value length - 256 Unicode characters in UTF-8</p>
190
- * </li>
191
- * <li>
192
- * <p>If your tagging schema is used across multiple services and resources,
193
- * remember that other services may have restrictions on allowed characters.
194
- * Generally allowed characters are: letters, numbers, and spaces representable in
195
- * UTF-8, and the following characters: + - = . _ : / @.</p>
196
- * </li>
197
- * <li>
198
- * <p>Tag keys and values are case-sensitive.</p>
199
- * </li>
200
- * <li>
201
- * <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
202
- * combination of such as a prefix for either keys or values as it is reserved for
203
- * Amazon Web Services use. You cannot edit or delete tag keys or values with this prefix. Tags with
204
- * this prefix do not count against your tags per resource limit.</p>
205
- * </li>
206
- * </ul>
207
- * @public
208
- */
209
- tags?: Tag[] | undefined;
210
- /**
211
- * <p>The <code>family</code> and <code>revision</code> (<code>family:revision</code>) or
212
- * full ARN of the task definition to run. If a <code>revision</code> isn't specified,
213
- * the latest <code>ACTIVE</code> revision is used.</p>
214
- * <p>The full ARN value must match the value that you specified as the
215
- * <code>Resource</code> of the principal's permissions policy.</p>
216
- * <p>When you specify a task definition, you must either specify a specific revision, or
217
- * all revisions in the ARN.</p>
218
- * <p>To specify a specific revision, include the revision number in the ARN. For example,
219
- * to specify revision 2, use
220
- * <code>arn:aws:ecs:us-east-1:111122223333:task-definition/TaskFamilyName:2</code>.</p>
221
- * <p>To specify all revisions, use the wildcard (*) in the ARN. For example, to specify
222
- * all revisions, use
223
- * <code>arn:aws:ecs:us-east-1:111122223333:task-definition/TaskFamilyName:*</code>.</p>
224
- * <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies-resources">Policy Resources for Amazon ECS</a> in the Amazon Elastic Container Service Developer Guide.</p>
225
- * @public
226
- */
227
- taskDefinition: string | undefined;
228
- /**
229
- * <p>An identifier that you provide to ensure the idempotency of the request. It must be
230
- * unique and is case sensitive. Up to 64 characters are allowed. The valid characters are
231
- * characters in the range of 33-126, inclusive. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/APIReference/ECS_Idempotency.html">Ensuring idempotency</a>.</p>
232
- * @public
233
- */
234
- clientToken?: string | undefined;
235
- /**
236
- * <p>The details of the volume that was <code>configuredAtLaunch</code>. You can configure
237
- * the size, volumeType, IOPS, throughput, snapshot and encryption in in <a href="https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TaskManagedEBSVolumeConfiguration.html">TaskManagedEBSVolumeConfiguration</a>. The <code>name</code> of the volume must
238
- * match the <code>name</code> from the task definition.</p>
239
- * @public
240
- */
241
- volumeConfigurations?: TaskVolumeConfiguration[] | undefined;
242
- }
243
- export interface RunTaskResponse {
244
- /**
245
- * <p>A full description of the tasks that were run. The tasks that were successfully placed
246
- * on your cluster are described here.</p>
247
- * @public
248
- */
249
- tasks?: Task[] | undefined;
250
- /**
251
- * <p>Any failures associated with the call.</p>
252
- * <p>For information about how to address failures, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html#service-event-messages-list">Service event messages</a> and <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/api_failures_messages.html">API failure
253
- * reasons</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
254
- * @public
255
- */
256
- failures?: Failure[] | undefined;
257
- }
258
- export interface StopTaskRequest {
259
- /**
260
- * <p>The short name or full Amazon Resource Name (ARN) of the cluster that hosts the task to stop.
261
- * If you do not specify a cluster, the default cluster is assumed.</p>
262
- * @public
263
- */
264
- cluster?: string | undefined;
265
- /**
266
- * <p>The task ID of the task to stop.</p>
267
- * @public
268
- */
269
- task: string | undefined;
270
- /**
271
- * <p>An optional message specified when a task is stopped. For example, if you're using a
272
- * custom scheduler, you can use this parameter to specify the reason for stopping the task
273
- * here, and the message appears in subsequent <a href="https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html">DescribeTasks</a>>
274
- * API operations on this task.</p>
275
- * @public
276
- */
277
- reason?: string | undefined;
278
- }
279
- export interface StopTaskResponse {
280
- /**
281
- * <p>The task that was stopped.</p>
282
- * @public
283
- */
284
- task?: Task | undefined;
285
- }
286
- export declare const TaskField: {
287
- readonly TAGS: "TAGS";
288
- };
289
- export type TaskField = (typeof TaskField)[keyof typeof TaskField];
290
- export interface Task {
291
- /**
292
- * <p>The Elastic Network Adapter that's associated with the task if the task uses the
293
- * <code>awsvpc</code> network mode.</p>
294
- * @public
295
- */
296
- attachments?: Attachment[] | undefined;
297
- /**
298
- * <p>The attributes of the task</p>
299
- * @public
300
- */
301
- attributes?: Attribute[] | undefined;
302
- /**
303
- * <p>The Availability Zone for the task.</p>
304
- * @public
305
- */
306
- availabilityZone?: string | undefined;
307
- /**
308
- * <p>The capacity provider that's associated with the task.</p>
309
- * @public
310
- */
311
- capacityProviderName?: string | undefined;
312
- /**
313
- * <p>The ARN of the cluster that hosts the task.</p>
314
- * @public
315
- */
316
- clusterArn?: string | undefined;
317
- /**
318
- * <p>The connectivity status of a task.</p>
319
- * @public
320
- */
321
- connectivity?: Connectivity | undefined;
322
- /**
323
- * <p>The Unix timestamp for the time when the task last went into <code>CONNECTED</code>
324
- * status.</p>
325
- * @public
326
- */
327
- connectivityAt?: Date | undefined;
328
- /**
329
- * <p>The ARN of the container instances that host the task.</p>
330
- * @public
331
- */
332
- containerInstanceArn?: string | undefined;
333
- /**
334
- * <p>The containers that's associated with the task.</p>
335
- * @public
336
- */
337
- containers?: Container[] | undefined;
338
- /**
339
- * <p>The number of CPU units used by the task as expressed in a task definition. It can be
340
- * expressed as an integer using CPU units (for example, <code>1024</code>). It can also be
341
- * expressed as a string using vCPUs (for example, <code>1 vCPU</code> or <code>1
342
- * vcpu</code>). String values are converted to an integer that indicates the CPU units
343
- * when the task definition is registered.</p>
344
- * <p>If you use the EC2 launch type, this field is optional. Supported values
345
- * are between <code>128</code> CPU units (<code>0.125</code> vCPUs) and <code>10240</code>
346
- * CPU units (<code>10</code> vCPUs).</p>
347
- * <p>If you use the Fargate launch type, this field is required. You must use
348
- * one of the following values. These values determine the range of supported values for
349
- * the <code>memory</code> parameter:</p>
350
- * <p>The CPU units cannot be less than 1 vCPU when you use Windows containers on
351
- * Fargate.</p>
352
- * <ul>
353
- * <li>
354
- * <p>256 (.25 vCPU) - Available <code>memory</code> values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB)</p>
355
- * </li>
356
- * <li>
357
- * <p>512 (.5 vCPU) - Available <code>memory</code> values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB)</p>
358
- * </li>
359
- * <li>
360
- * <p>1024 (1 vCPU) - Available <code>memory</code> values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)</p>
361
- * </li>
362
- * <li>
363
- * <p>2048 (2 vCPU) - Available <code>memory</code> values: 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)</p>
364
- * </li>
365
- * <li>
366
- * <p>4096 (4 vCPU) - Available <code>memory</code> values: 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB)</p>
367
- * </li>
368
- * <li>
369
- * <p>8192 (8 vCPU) - Available <code>memory</code> values: 16 GB and 60 GB in 4 GB increments</p>
370
- * <p>This option requires Linux platform <code>1.4.0</code> or
371
- * later.</p>
372
- * </li>
373
- * <li>
374
- * <p>16384 (16vCPU) - Available <code>memory</code> values: 32GB and 120 GB in 8 GB increments</p>
375
- * <p>This option requires Linux platform <code>1.4.0</code> or
376
- * later.</p>
377
- * </li>
378
- * </ul>
379
- * @public
380
- */
381
- cpu?: string | undefined;
382
- /**
383
- * <p>The Unix timestamp for the time when the task was created. More specifically, it's for
384
- * the time when the task entered the <code>PENDING</code> state.</p>
385
- * @public
386
- */
387
- createdAt?: Date | undefined;
388
- /**
389
- * <p>The desired status of the task. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html">Task
390
- * Lifecycle</a>.</p>
391
- * @public
392
- */
393
- desiredStatus?: string | undefined;
394
- /**
395
- * <p>Determines whether execute command functionality is turned on for this task. If
396
- * <code>true</code>, execute command functionality is turned on all the containers in
397
- * the task.</p>
398
- * @public
399
- */
400
- enableExecuteCommand?: boolean | undefined;
401
- /**
402
- * <p>The Unix timestamp for the time when the task execution stopped.</p>
403
- * @public
404
- */
405
- executionStoppedAt?: Date | undefined;
406
- /**
407
- * <p>The name of the task group that's associated with the task.</p>
408
- * @public
409
- */
410
- group?: string | undefined;
411
- /**
412
- * <p>The health status for the task. It's determined by the health of the essential
413
- * containers in the task. If all essential containers in the task are reporting as
414
- * <code>HEALTHY</code>, the task status also reports as <code>HEALTHY</code>. If any
415
- * essential containers in the task are reporting as <code>UNHEALTHY</code> or
416
- * <code>UNKNOWN</code>, the task status also reports as <code>UNHEALTHY</code> or
417
- * <code>UNKNOWN</code>.</p>
418
- * <note>
419
- * <p>The Amazon ECS container agent doesn't monitor or report on Docker health checks that
420
- * are embedded in a container image and not specified in the container definition. For
421
- * example, this includes those specified in a parent image or from the image's
422
- * Dockerfile. Health check parameters that are specified in a container definition
423
- * override any Docker health checks that are found in the container image.</p>
424
- * </note>
425
- * @public
426
- */
427
- healthStatus?: HealthStatus | undefined;
428
- /**
429
- * <p>The Elastic Inference accelerator that's associated with the task.</p>
430
- * @public
431
- */
432
- inferenceAccelerators?: InferenceAccelerator[] | undefined;
433
- /**
434
- * <p>The last known status for the task. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html">Task
435
- * Lifecycle</a>.</p>
436
- * @public
437
- */
438
- lastStatus?: string | undefined;
439
- /**
440
- * <p>The infrastructure where your task runs on. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html">Amazon ECS
441
- * launch types</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
442
- * @public
443
- */
444
- launchType?: LaunchType | undefined;
445
- /**
446
- * <p>The amount of memory (in MiB) that the task uses as expressed in a task definition. It
447
- * can be expressed as an integer using MiB (for example, <code>1024</code>). If it's
448
- * expressed as a string using GB (for example, <code>1GB</code> or <code>1 GB</code>),
449
- * it's converted to an integer indicating the MiB when the task definition is
450
- * registered.</p>
451
- * <p>If you use the EC2 launch type, this field is optional.</p>
452
- * <p>If you use the Fargate launch type, this field is required. You must use
453
- * one of the following values. The value that you choose determines the range of supported
454
- * values for the <code>cpu</code> parameter.</p>
455
- * <ul>
456
- * <li>
457
- * <p>512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available <code>cpu</code> values: 256 (.25 vCPU)</p>
458
- * </li>
459
- * <li>
460
- * <p>1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available <code>cpu</code> values: 512 (.5 vCPU)</p>
461
- * </li>
462
- * <li>
463
- * <p>2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available <code>cpu</code> values: 1024 (1 vCPU)</p>
464
- * </li>
465
- * <li>
466
- * <p>Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 2048 (2 vCPU)</p>
467
- * </li>
468
- * <li>
469
- * <p>Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available <code>cpu</code> values: 4096 (4 vCPU)</p>
470
- * </li>
471
- * <li>
472
- * <p>Between 16 GB and 60 GB in 4 GB increments - Available <code>cpu</code> values: 8192 (8 vCPU)</p>
473
- * <p>This option requires Linux platform <code>1.4.0</code> or
474
- * later.</p>
475
- * </li>
476
- * <li>
477
- * <p>Between 32GB and 120 GB in 8 GB increments - Available <code>cpu</code> values: 16384 (16 vCPU)</p>
478
- * <p>This option requires Linux platform <code>1.4.0</code> or
479
- * later.</p>
480
- * </li>
481
- * </ul>
482
- * @public
483
- */
484
- memory?: string | undefined;
485
- /**
486
- * <p>One or more container overrides.</p>
487
- * @public
488
- */
489
- overrides?: TaskOverride | undefined;
490
- /**
491
- * <p>The platform version where your task runs on. A platform version is only specified for
492
- * tasks that use the Fargate launch type. If you didn't specify one, the
493
- * <code>LATEST</code> platform version is used. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html">Fargate Platform Versions</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
494
- * @public
495
- */
496
- platformVersion?: string | undefined;
497
- /**
498
- * <p>The operating system that your tasks are running on. A platform family is specified
499
- * only for tasks that use the Fargate launch type. </p>
500
- * <p> All tasks that run as part of this service must use the same
501
- * <code>platformFamily</code> value as the service (for example,
502
- * <code>LINUX.</code>).</p>
503
- * @public
504
- */
505
- platformFamily?: string | undefined;
506
- /**
507
- * <p>The Unix timestamp for the time when the container image pull began.</p>
508
- * @public
509
- */
510
- pullStartedAt?: Date | undefined;
511
- /**
512
- * <p>The Unix timestamp for the time when the container image pull completed.</p>
513
- * @public
514
- */
515
- pullStoppedAt?: Date | undefined;
516
- /**
517
- * <p>The Unix timestamp for the time when the task started. More specifically, it's for the
518
- * time when the task transitioned from the <code>PENDING</code> state to the
519
- * <code>RUNNING</code> state.</p>
520
- * @public
521
- */
522
- startedAt?: Date | undefined;
523
- /**
524
- * <p>The tag specified when a task is started. If an Amazon ECS service started the task, the
525
- * <code>startedBy</code> parameter contains the deployment ID of that service.</p>
526
- * @public
527
- */
528
- startedBy?: string | undefined;
529
- /**
530
- * <p>The stop code indicating why a task was stopped. The <code>stoppedReason</code> might
531
- * contain additional details. </p>
532
- * <p>For more information about stop code, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/stopped-task-error-codes.html">Stopped tasks
533
- * error codes</a> in the <i>Amazon ECS Developer Guide</i>.</p>
534
- * @public
535
- */
536
- stopCode?: TaskStopCode | undefined;
537
- /**
538
- * <p>The Unix timestamp for the time when the task was stopped. More specifically, it's for
539
- * the time when the task transitioned from the <code>RUNNING</code> state to the
540
- * <code>STOPPED</code> state.</p>
541
- * @public
542
- */
543
- stoppedAt?: Date | undefined;
544
- /**
545
- * <p>The reason that the task was stopped.</p>
546
- * @public
547
- */
548
- stoppedReason?: string | undefined;
549
- /**
550
- * <p>The Unix timestamp for the time when the task stops. More specifically, it's for the
551
- * time when the task transitions from the <code>RUNNING</code> state to
552
- * <code>STOPPING</code>.</p>
553
- * @public
554
- */
555
- stoppingAt?: Date | undefined;
556
- /**
557
- * <p>The metadata that you apply to the task to help you categorize and organize the task.
558
- * Each tag consists of a key and an optional value. You define both the key and
559
- * value.</p>
560
- * <p>The following basic restrictions apply to tags:</p>
561
- * <ul>
562
- * <li>
563
- * <p>Maximum number of tags per resource - 50</p>
564
- * </li>
565
- * <li>
566
- * <p>For each resource, each tag key must be unique, and each tag key can have only
567
- * one value.</p>
568
- * </li>
569
- * <li>
570
- * <p>Maximum key length - 128 Unicode characters in UTF-8</p>
571
- * </li>
572
- * <li>
573
- * <p>Maximum value length - 256 Unicode characters in UTF-8</p>
574
- * </li>
575
- * <li>
576
- * <p>If your tagging schema is used across multiple services and resources,
577
- * remember that other services may have restrictions on allowed characters.
578
- * Generally allowed characters are: letters, numbers, and spaces representable in
579
- * UTF-8, and the following characters: + - = . _ : / @.</p>
580
- * </li>
581
- * <li>
582
- * <p>Tag keys and values are case-sensitive.</p>
583
- * </li>
584
- * <li>
585
- * <p>Do not use <code>aws:</code>, <code>AWS:</code>, or any upper or lowercase
586
- * combination of such as a prefix for either keys or values as it is reserved for
587
- * Amazon Web Services use. You cannot edit or delete tag keys or values with this prefix. Tags with
588
- * this prefix do not count against your tags per resource limit.</p>
589
- * </li>
590
- * </ul>
591
- * @public
592
- */
593
- tags?: Tag[] | undefined;
594
- /**
595
- * <p>The Amazon Resource Name (ARN) of the task.</p>
596
- * @public
597
- */
598
- taskArn?: string | undefined;
599
- /**
600
- * <p>The ARN of the task definition that creates the task.</p>
601
- * @public
602
- */
603
- taskDefinitionArn?: string | undefined;
604
- /**
605
- * <p>The version counter for the task. Every time a task experiences a change that starts a
606
- * CloudWatch event, the version counter is incremented. If you replicate your Amazon ECS task state
607
- * with CloudWatch Events, you can compare the version of a task reported by the Amazon ECS API
608
- * actions with the version reported in CloudWatch Events for the task (inside the
609
- * <code>detail</code> object) to verify that the version in your event stream is
610
- * current.</p>
611
- * @public
612
- */
613
- version?: number | undefined;
614
- /**
615
- * <p>The ephemeral storage settings for the task.</p>
616
- * @public
617
- */
618
- ephemeralStorage?: EphemeralStorage | undefined;
619
- /**
620
- * <p>The Fargate ephemeral storage settings for the task.</p>
621
- * @public
622
- */
623
- fargateEphemeralStorage?: TaskEphemeralStorage | undefined;
624
- }
625
- export interface Failure {
626
- /**
627
- * <p>The Amazon Resource Name (ARN) of the failed resource.</p>
628
- * @public
629
- */
630
- arn?: string | undefined;
631
- /**
632
- * <p>The reason for the failure.</p>
633
- * @public
634
- */
635
- reason?: string | undefined;
636
- /**
637
- * <p>The details of the failure.</p>
638
- * @public
639
- */
640
- detail?: string | undefined;
641
- }
642
- export interface CapacityProviderStrategyItem {
643
- /**
644
- * <p>The short name of the capacity provider.</p>
645
- * @public
646
- */
647
- capacityProvider: string | undefined;
648
- /**
649
- * <p>The <i>weight</i> value designates the relative percentage of the total
650
- * number of tasks launched that should use the specified capacity provider. The
651
- * <code>weight</code> value is taken into consideration after the <code>base</code>
652
- * value, if defined, is satisfied.</p>
653
- * <p>If no <code>weight</code> value is specified, the default value of <code>0</code> is
654
- * used. When multiple capacity providers are specified within a capacity provider
655
- * strategy, at least one of the capacity providers must have a weight value greater than
656
- * zero and any capacity providers with a weight of <code>0</code> can't be used to place
657
- * tasks. If you specify multiple capacity providers in a strategy that all have a weight
658
- * of <code>0</code>, any <code>RunTask</code> or <code>CreateService</code> actions using
659
- * the capacity provider strategy will fail.</p>
660
- * <p>An example scenario for using weights is defining a strategy that contains two
661
- * capacity providers and both have a weight of <code>1</code>, then when the
662
- * <code>base</code> is satisfied, the tasks will be split evenly across the two
663
- * capacity providers. Using that same logic, if you specify a weight of <code>1</code> for
664
- * <i>capacityProviderA</i> and a weight of <code>4</code> for
665
- * <i>capacityProviderB</i>, then for every one task that's run using
666
- * <i>capacityProviderA</i>, four tasks would use
667
- * <i>capacityProviderB</i>.</p>
668
- * @public
669
- */
670
- weight?: number | undefined;
671
- /**
672
- * <p>The <i>base</i> value designates how many tasks, at a minimum, to run on
673
- * the specified capacity provider. Only one capacity provider in a capacity provider
674
- * strategy can have a <i>base</i> defined. If no value is specified, the
675
- * default value of <code>0</code> is used.</p>
676
- * @public
677
- */
678
- base?: number | undefined;
679
- }
680
- export declare const LaunchType: {
681
- readonly EC2: "EC2";
682
- readonly EXTERNAL: "EXTERNAL";
683
- readonly FARGATE: "FARGATE";
684
- };
685
- export type LaunchType = (typeof LaunchType)[keyof typeof LaunchType];
686
- export declare const HealthStatus: {
687
- readonly HEALTHY: "HEALTHY";
688
- readonly UNHEALTHY: "UNHEALTHY";
689
- readonly UNKNOWN: "UNKNOWN";
690
- };
691
- export type HealthStatus = (typeof HealthStatus)[keyof typeof HealthStatus];
692
- export interface NetworkConfiguration {
693
- /**
694
- * <p>The VPC subnets and security groups that are associated with a task.</p>
695
- * <note>
696
- * <p>All specified subnets and security groups must be from the same VPC.</p>
697
- * </note>
698
- * @public
699
- */
700
- awsvpcConfiguration?: AwsVpcConfiguration | undefined;
701
- }
702
- export interface AwsVpcConfiguration {
703
- /**
704
- * <p>The IDs of the subnets associated with the task or service. There's a limit of 16
705
- * subnets that can be specified per <code>awsvpcConfiguration</code>.</p>
706
- * <note>
707
- * <p>All specified subnets must be from the same VPC.</p>
708
- * </note>
709
- * @public
710
- */
711
- subnets: string[] | undefined;
712
- /**
713
- * <p>The IDs of the security groups associated with the task or service. If you don't
714
- * specify a security group, the default security group for the VPC is used. There's a
715
- * limit of 5 security groups that can be specified per
716
- * <code>awsvpcConfiguration</code>.</p>
717
- * <note>
718
- * <p>All specified security groups must be from the same VPC.</p>
719
- * </note>
720
- * @public
721
- */
722
- securityGroups?: string[] | undefined;
723
- /**
724
- * <p>Whether the task's elastic network interface receives a public IP address. The default
725
- * value is <code>ENABLED</code>.</p>
726
- * @public
727
- */
728
- assignPublicIp?: AssignPublicIp | undefined;
729
- }
730
- export declare const AssignPublicIp: {
731
- readonly DISABLED: "DISABLED";
732
- readonly ENABLED: "ENABLED";
733
- };
734
- export type AssignPublicIp = (typeof AssignPublicIp)[keyof typeof AssignPublicIp];
735
- export interface InferenceAccelerator {
736
- /**
737
- * <p>The Elastic Inference accelerator device name. The <code>deviceName</code> must also
738
- * be referenced in a container definition as a <a href="https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ResourceRequirement.html">ResourceRequirement</a>.</p>
739
- * @public
740
- */
741
- deviceName: string | undefined;
742
- /**
743
- * <p>The Elastic Inference accelerator type to use.</p>
744
- * @public
745
- */
746
- deviceType: string | undefined;
747
- }
748
- export interface TaskOverride {
749
- /**
750
- * <p>One or more container overrides that are sent to a task.</p>
751
- * @public
752
- */
753
- containerOverrides?: ContainerOverride[] | undefined;
754
- /**
755
- * <p>The CPU override for the task.</p>
756
- * @public
757
- */
758
- cpu?: string | undefined;
759
- /**
760
- * <p>The Elastic Inference accelerator override for the task.</p>
761
- * @public
762
- */
763
- inferenceAcceleratorOverrides?: InferenceAcceleratorOverride[] | undefined;
764
- /**
765
- * <p>The Amazon Resource Name (ARN) of the task execution role override for the task. For more information,
766
- * see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html">Amazon ECS task
767
- * execution IAM role</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
768
- * @public
769
- */
770
- executionRoleArn?: string | undefined;
771
- /**
772
- * <p>The memory override for the task.</p>
773
- * @public
774
- */
775
- memory?: string | undefined;
776
- /**
777
- * <p>The Amazon Resource Name (ARN) of the role that containers in this task can assume. All containers in
778
- * this task are granted the permissions that are specified in this role. For more
779
- * information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM Role for Tasks</a>
780
- * in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
781
- * @public
782
- */
783
- taskRoleArn?: string | undefined;
784
- /**
785
- * <p>The ephemeral storage setting override for the task.</p>
786
- * <note>
787
- * <p>This parameter is only supported for tasks hosted on Fargate that
788
- * use the following platform versions:</p>
789
- * <ul>
790
- * <li>
791
- * <p>Linux platform version <code>1.4.0</code> or later.</p>
792
- * </li>
793
- * <li>
794
- * <p>Windows platform version <code>1.0.0</code> or later.</p>
795
- * </li>
796
- * </ul>
797
- * </note>
798
- * @public
799
- */
800
- ephemeralStorage?: EphemeralStorage | undefined;
801
- }
802
- export declare const TaskStopCode: {
803
- readonly ESSENTIAL_CONTAINER_EXITED: "EssentialContainerExited";
804
- readonly SERVICE_SCHEDULER_INITIATED: "ServiceSchedulerInitiated";
805
- readonly SPOT_INTERRUPTION: "SpotInterruption";
806
- readonly TASK_FAILED_TO_START: "TaskFailedToStart";
807
- readonly TERMINATION_NOTICE: "TerminationNotice";
808
- readonly USER_INITIATED: "UserInitiated";
809
- };
810
- export type TaskStopCode = (typeof TaskStopCode)[keyof typeof TaskStopCode];
811
- export interface PlacementConstraint {
812
- /**
813
- * <p>The type of constraint. Use <code>distinctInstance</code> to ensure that each task in
814
- * a particular group is running on a different container instance. Use
815
- * <code>memberOf</code> to restrict the selection to a group of valid
816
- * candidates.</p>
817
- * @public
818
- */
819
- type?: PlacementConstraintType | undefined;
820
- /**
821
- * <p>A cluster query language expression to apply to the constraint. The expression can
822
- * have a maximum length of 2000 characters. You can't specify an expression if the
823
- * constraint type is <code>distinctInstance</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html">Cluster query language</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
824
- * @public
825
- */
826
- expression?: string | undefined;
827
- }
828
- export declare const PropagateTags: {
829
- readonly NONE: "NONE";
830
- readonly SERVICE: "SERVICE";
831
- readonly TASK_DEFINITION: "TASK_DEFINITION";
832
- };
833
- export type PropagateTags = (typeof PropagateTags)[keyof typeof PropagateTags];
834
- export interface TaskVolumeConfiguration {
835
- /**
836
- * <p>The name of the volume. This value must match the volume name from the
837
- * <code>Volume</code> object in the task definition.</p>
838
- * @public
839
- */
840
- name: string | undefined;
841
- /**
842
- * <p>The configuration for the Amazon EBS volume that Amazon ECS creates and manages on your behalf.
843
- * These settings are used to create each Amazon EBS volume, with one volume created for each
844
- * task. The Amazon EBS volumes are visible in your account in the Amazon EC2 console once they are
845
- * created.</p>
846
- * @public
847
- */
848
- managedEBSVolume?: TaskManagedEBSVolumeConfiguration | undefined;
849
- }
850
- export interface Attachment {
851
- /**
852
- * <p>The unique identifier for the attachment.</p>
853
- * @public
854
- */
855
- id?: string | undefined;
856
- /**
857
- * <p>The type of the attachment, such as <code>ElasticNetworkInterface</code>,
858
- * <code>Service Connect</code>, and <code>AmazonElasticBlockStorage</code>.</p>
859
- * @public
860
- */
861
- type?: string | undefined;
862
- /**
863
- * <p> The status of the attachment. Valid values are <code>PRECREATED</code>,
864
- * <code>CREATED</code>, <code>ATTACHING</code>, <code>ATTACHED</code>,
865
- * <code>DETACHING</code>, <code>DETACHED</code>, <code>DELETED</code>, and
866
- * <code>FAILED</code>.</p>
867
- * @public
868
- */
869
- status?: string | undefined;
870
- /**
871
- * <p>Details of the attachment.</p>
872
- * <p>For elastic network interfaces, this includes the network interface ID, the MAC
873
- * address, the subnet ID, and the private IPv4 address.</p>
874
- * <p>For Service Connect services, this includes <code>portName</code>,
875
- * <code>clientAliases</code>, <code>discoveryName</code>, and
876
- * <code>ingressPortOverride</code>.</p>
877
- * <p>For Elastic Block Storage, this includes <code>roleArn</code>,
878
- * <code>deleteOnTermination</code>, <code>volumeName</code>, <code>volumeId</code>,
879
- * and <code>statusReason</code> (only when the attachment fails to create or
880
- * attach).</p>
881
- * @public
882
- */
883
- details?: KeyValuePair[] | undefined;
884
- }
885
- export interface Attribute {
886
- /**
887
- * <p>The name of the attribute. The <code>name</code> must contain between 1 and 128
888
- * characters. The name may contain letters (uppercase and lowercase), numbers, hyphens
889
- * (-), underscores (_), forward slashes (/), back slashes (\), or periods (.).</p>
890
- * @public
891
- */
892
- name: string | undefined;
893
- /**
894
- * <p>The value of the attribute. The <code>value</code> must contain between 1 and 128
895
- * characters. It can contain letters (uppercase and lowercase), numbers, hyphens (-),
896
- * underscores (_), periods (.), at signs (@), forward slashes (/), back slashes (\),
897
- * colons (:), or spaces. The value can't start or end with a space.</p>
898
- * @public
899
- */
900
- value?: string | undefined;
901
- /**
902
- * <p>The type of the target to attach the attribute with. This parameter is required if you
903
- * use the short form ID for a resource instead of the full ARN.</p>
904
- * @public
905
- */
906
- targetType?: TargetType | undefined;
907
- /**
908
- * <p>The ID of the target. You can specify the short form ID for a resource or the full
909
- * Amazon Resource Name (ARN).</p>
910
- * @public
911
- */
912
- targetId?: string | undefined;
913
- }
914
- export declare const Connectivity: {
915
- readonly CONNECTED: "CONNECTED";
916
- readonly DISCONNECTED: "DISCONNECTED";
917
- };
918
- export type Connectivity = (typeof Connectivity)[keyof typeof Connectivity];
919
- export interface Container {
920
- /**
921
- * <p>The Amazon Resource Name (ARN) of the container.</p>
922
- * @public
923
- */
924
- containerArn?: string | undefined;
925
- /**
926
- * <p>The ARN of the task.</p>
927
- * @public
928
- */
929
- taskArn?: string | undefined;
930
- /**
931
- * <p>The name of the container.</p>
932
- * @public
933
- */
934
- name?: string | undefined;
935
- /**
936
- * <p>The image used for the container.</p>
937
- * @public
938
- */
939
- image?: string | undefined;
940
- /**
941
- * <p>The container image manifest digest.</p>
942
- * @public
943
- */
944
- imageDigest?: string | undefined;
945
- /**
946
- * <p>The ID of the Docker container.</p>
947
- * @public
948
- */
949
- runtimeId?: string | undefined;
950
- /**
951
- * <p>The last known status of the container.</p>
952
- * @public
953
- */
954
- lastStatus?: string | undefined;
955
- /**
956
- * <p>The exit code returned from the container.</p>
957
- * @public
958
- */
959
- exitCode?: number | undefined;
960
- /**
961
- * <p>A short (255 max characters) human-readable string to provide additional details about
962
- * a running or stopped container.</p>
963
- * @public
964
- */
965
- reason?: string | undefined;
966
- /**
967
- * <p>The network bindings associated with the container.</p>
968
- * @public
969
- */
970
- networkBindings?: NetworkBinding[] | undefined;
971
- /**
972
- * <p>The network interfaces associated with the container.</p>
973
- * @public
974
- */
975
- networkInterfaces?: NetworkInterface[] | undefined;
976
- /**
977
- * <p>The health status of the container. If health checks aren't configured for this
978
- * container in its task definition, then it reports the health status as
979
- * <code>UNKNOWN</code>.</p>
980
- * @public
981
- */
982
- healthStatus?: HealthStatus | undefined;
983
- /**
984
- * <p>The details of any Amazon ECS managed agents associated with the container.</p>
985
- * @public
986
- */
987
- managedAgents?: ManagedAgent[] | undefined;
988
- /**
989
- * <p>The number of CPU units set for the container. The value is <code>0</code> if no value
990
- * was specified in the container definition when the task definition was
991
- * registered.</p>
992
- * @public
993
- */
994
- cpu?: string | undefined;
995
- /**
996
- * <p>The hard limit (in MiB) of memory set for the container.</p>
997
- * @public
998
- */
999
- memory?: string | undefined;
1000
- /**
1001
- * <p>The soft limit (in MiB) of memory set for the container.</p>
1002
- * @public
1003
- */
1004
- memoryReservation?: string | undefined;
1005
- /**
1006
- * <p>The IDs of each GPU assigned to the container.</p>
1007
- * @public
1008
- */
1009
- gpuIds?: string[] | undefined;
1010
- }
1011
- export interface ContainerOverride {
1012
- /**
1013
- * <p>The name of the container that receives the override. This parameter is required if
1014
- * any override is specified.</p>
1015
- * @public
1016
- */
1017
- name?: string | undefined;
1018
- /**
1019
- * <p>The command to send to the container that overrides the default command from the
1020
- * Docker image or the task definition. You must also specify a container name.</p>
1021
- * @public
1022
- */
1023
- command?: string[] | undefined;
1024
- /**
1025
- * <p>The environment variables to send to the container. You can add new environment
1026
- * variables, which are added to the container at launch, or you can override the existing
1027
- * environment variables from the Docker image or the task definition. You must also
1028
- * specify a container name.</p>
1029
- * @public
1030
- */
1031
- environment?: KeyValuePair[] | undefined;
1032
- /**
1033
- * <p>A list of files containing the environment variables to pass to a container, instead
1034
- * of the value from the container definition.</p>
1035
- * @public
1036
- */
1037
- environmentFiles?: EnvironmentFile[] | undefined;
1038
- /**
1039
- * <p>The number of <code>cpu</code> units reserved for the container, instead of the
1040
- * default value from the task definition. You must also specify a container name.</p>
1041
- * @public
1042
- */
1043
- cpu?: number | undefined;
1044
- /**
1045
- * <p>The hard limit (in MiB) of memory to present to the container, instead of the default
1046
- * value from the task definition. If your container attempts to exceed the memory
1047
- * specified here, the container is killed. You must also specify a container name.</p>
1048
- * @public
1049
- */
1050
- memory?: number | undefined;
1051
- /**
1052
- * <p>The soft limit (in MiB) of memory to reserve for the container, instead of the default
1053
- * value from the task definition. You must also specify a container name.</p>
1054
- * @public
1055
- */
1056
- memoryReservation?: number | undefined;
1057
- /**
1058
- * <p>The type and amount of a resource to assign to a container, instead of the default
1059
- * value from the task definition. The only supported resource is a GPU.</p>
1060
- * @public
1061
- */
1062
- resourceRequirements?: ResourceRequirement[] | undefined;
1063
- }
1064
- export interface TaskEphemeralStorage {
1065
- /**
1066
- * <p>The total amount, in GiB, of the ephemeral storage to set for the task. The minimum
1067
- * supported value is <code>20</code> GiB and the maximum supported value is
1068
- * <code>200</code> GiB.</p>
1069
- * @public
1070
- */
1071
- sizeInGiB?: number | undefined;
1072
- /**
1073
- * <p>Specify an Key Management Service key ID to encrypt the ephemeral storage for the
1074
- * task.</p>
1075
- * @public
1076
- */
1077
- kmsKeyId?: string | undefined;
1078
- }
1079
- export interface InferenceAcceleratorOverride {
1080
- /**
1081
- * <p>The Elastic Inference accelerator device name to override for the task. This parameter
1082
- * must match a <code>deviceName</code> specified in the task definition.</p>
1083
- * @public
1084
- */
1085
- deviceName?: string | undefined;
1086
- /**
1087
- * <p>The Elastic Inference accelerator type to use.</p>
1088
- * @public
1089
- */
1090
- deviceType?: string | undefined;
1091
- }
1092
- export interface EphemeralStorage {
1093
- /**
1094
- * <p>The total amount, in GiB, of ephemeral storage to set for the task. The minimum
1095
- * supported value is <code>21</code> GiB and the maximum supported value is
1096
- * <code>200</code> GiB.</p>
1097
- * @public
1098
- */
1099
- sizeInGiB: number | undefined;
1100
- }
1101
- export interface TaskManagedEBSVolumeConfiguration {
1102
- /**
1103
- * <p>Indicates whether the volume should be encrypted. If no value is specified, encryption
1104
- * is turned on by default. This parameter maps 1:1 with the <code>Encrypted</code>
1105
- * parameter of the <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html">CreateVolume API</a> in
1106
- * the <i>Amazon EC2 API Reference</i>.</p>
1107
- * @public
1108
- */
1109
- encrypted?: boolean | undefined;
1110
- /**
1111
- * <p>The Amazon Resource Name (ARN) identifier of the Amazon Web Services Key Management Service key to use for Amazon EBS encryption. When
1112
- * encryption is turned on and no Amazon Web Services Key Management Service key is specified, the default Amazon Web Services managed key
1113
- * for Amazon EBS volumes is used. This parameter maps 1:1 with the <code>KmsKeyId</code>
1114
- * parameter of the <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html">CreateVolume API</a> in
1115
- * the <i>Amazon EC2 API Reference</i>.</p>
1116
- * <important>
1117
- * <p>Amazon Web Services authenticates the Amazon Web Services Key Management Service key asynchronously. Therefore, if you specify an
1118
- * ID, alias, or ARN that is invalid, the action can appear to complete, but
1119
- * eventually fails.</p>
1120
- * </important>
1121
- * @public
1122
- */
1123
- kmsKeyId?: string | undefined;
1124
- /**
1125
- * <p>The volume type. This parameter maps 1:1 with the <code>VolumeType</code> parameter of
1126
- * the <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html">CreateVolume API</a> in the <i>Amazon EC2 API Reference</i>. For more
1127
- * information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html">Amazon EBS volume types</a> in
1128
- * the <i>Amazon EC2 User Guide</i>.</p>
1129
- * <p>The following are the supported volume types.</p>
1130
- * <ul>
1131
- * <li>
1132
- * <p>General Purpose SSD: <code>gp2</code>|<code>gp3</code>
1133
- * </p>
1134
- * </li>
1135
- * <li>
1136
- * <p>Provisioned IOPS SSD: <code>io1</code>|<code>io2</code>
1137
- * </p>
1138
- * </li>
1139
- * <li>
1140
- * <p>Throughput Optimized HDD: <code>st1</code>
1141
- * </p>
1142
- * </li>
1143
- * <li>
1144
- * <p>Cold HDD: <code>sc1</code>
1145
- * </p>
1146
- * </li>
1147
- * <li>
1148
- * <p>Magnetic: <code>standard</code>
1149
- * </p>
1150
- * <note>
1151
- * <p>The magnetic volume type is not supported on Fargate.</p>
1152
- * </note>
1153
- * </li>
1154
- * </ul>
1155
- * @public
1156
- */
1157
- volumeType?: string | undefined;
1158
- /**
1159
- * <p>The size of the volume in GiB. You must specify either a volume size or a snapshot ID.
1160
- * If you specify a snapshot ID, the snapshot size is used for the volume size by default.
1161
- * You can optionally specify a volume size greater than or equal to the snapshot size.
1162
- * This parameter maps 1:1 with the <code>Size</code> parameter of the <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html">CreateVolume API</a> in the <i>Amazon EC2 API Reference</i>.</p>
1163
- * <p>The following are the supported volume size values for each volume type.</p>
1164
- * <ul>
1165
- * <li>
1166
- * <p>
1167
- * <code>gp2</code> and <code>gp3</code>: 1-16,384</p>
1168
- * </li>
1169
- * <li>
1170
- * <p>
1171
- * <code>io1</code> and <code>io2</code>: 4-16,384</p>
1172
- * </li>
1173
- * <li>
1174
- * <p>
1175
- * <code>st1</code> and <code>sc1</code>: 125-16,384</p>
1176
- * </li>
1177
- * <li>
1178
- * <p>
1179
- * <code>standard</code>: 1-1,024</p>
1180
- * </li>
1181
- * </ul>
1182
- * @public
1183
- */
1184
- sizeInGiB?: number | undefined;
1185
- /**
1186
- * <p>The snapshot that Amazon ECS uses to create the volume. You must specify either a snapshot
1187
- * ID or a volume size. This parameter maps 1:1 with the <code>SnapshotId</code> parameter
1188
- * of the <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html">CreateVolume API</a> in
1189
- * the <i>Amazon EC2 API Reference</i>.</p>
1190
- * @public
1191
- */
1192
- snapshotId?: string | undefined;
1193
- /**
1194
- * <p>The number of I/O operations per second (IOPS). For <code>gp3</code>,
1195
- * <code>io1</code>, and <code>io2</code> volumes, this represents the number of IOPS that
1196
- * are provisioned for the volume. For <code>gp2</code> volumes, this represents the
1197
- * baseline performance of the volume and the rate at which the volume accumulates I/O
1198
- * credits for bursting.</p>
1199
- * <p>The following are the supported values for each volume type.</p>
1200
- * <ul>
1201
- * <li>
1202
- * <p>
1203
- * <code>gp3</code>: 3,000 - 16,000 IOPS</p>
1204
- * </li>
1205
- * <li>
1206
- * <p>
1207
- * <code>io1</code>: 100 - 64,000 IOPS</p>
1208
- * </li>
1209
- * <li>
1210
- * <p>
1211
- * <code>io2</code>: 100 - 256,000 IOPS</p>
1212
- * </li>
1213
- * </ul>
1214
- * <p>This parameter is required for <code>io1</code> and <code>io2</code> volume types. The
1215
- * default for <code>gp3</code> volumes is <code>3,000 IOPS</code>. This parameter is not
1216
- * supported for <code>st1</code>, <code>sc1</code>, or <code>standard</code> volume
1217
- * types.</p>
1218
- * <p>This parameter maps 1:1 with the <code>Iops</code> parameter of the <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html">CreateVolume API</a> in the <i>Amazon EC2 API Reference</i>.</p>
1219
- * @public
1220
- */
1221
- iops?: number | undefined;
1222
- /**
1223
- * <p>The throughput to provision for a volume, in MiB/s, with a maximum of 1,000 MiB/s.
1224
- * This parameter maps 1:1 with the <code>Throughput</code> parameter of the <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html">CreateVolume API</a> in the <i>Amazon EC2 API Reference</i>.</p>
1225
- * <important>
1226
- * <p>This parameter is only supported for the <code>gp3</code> volume type.</p>
1227
- * </important>
1228
- * @public
1229
- */
1230
- throughput?: number | undefined;
1231
- /**
1232
- * <p>The tags to apply to the volume. Amazon ECS applies service-managed tags by default. This
1233
- * parameter maps 1:1 with the <code>TagSpecifications.N</code> parameter of the <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html">CreateVolume API</a> in the <i>Amazon EC2 API Reference</i>.</p>
1234
- * @public
1235
- */
1236
- tagSpecifications?: EBSTagSpecification[] | undefined;
1237
- /**
1238
- * <p>The ARN of the IAM role to associate with this volume. This is the Amazon ECS
1239
- * infrastructure IAM role that is used to manage your Amazon Web Services infrastructure. We recommend
1240
- * using the Amazon ECS-managed <code>AmazonECSInfrastructureRolePolicyForVolumes</code> IAM
1241
- * policy with this role. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/infrastructure_IAM_role.html">Amazon ECS
1242
- * infrastructure IAM role</a> in the <i>Amazon ECS Developer
1243
- * Guide</i>.</p>
1244
- * @public
1245
- */
1246
- roleArn: string | undefined;
1247
- /**
1248
- * <p>The termination policy for the volume when the task exits. This provides a way to
1249
- * control whether Amazon ECS terminates the Amazon EBS volume when the task stops.</p>
1250
- * @public
1251
- */
1252
- terminationPolicy?: TaskManagedEBSVolumeTerminationPolicy | undefined;
1253
- /**
1254
- * <p>The Linux filesystem type for the volume. For volumes created from a snapshot, you
1255
- * must specify the same filesystem type that the volume was using when the snapshot was
1256
- * created. If there is a filesystem type mismatch, the task will fail to start.</p>
1257
- * <p>The available filesystem types are
1258
- <code>ext3</code>, <code>ext4</code>, and
1259
- * <code>xfs</code>. If no value is specified, the <code>xfs</code> filesystem type is
1260
- * used by default.</p>
1261
- * @public
1262
- */
1263
- filesystemType?: TaskFilesystemType | undefined;
1264
- }
1265
- export interface PlacementStrategy {
1266
- /**
1267
- * <p>The type of placement strategy. The <code>random</code> placement strategy randomly
1268
- * places tasks on available candidates. The <code>spread</code> placement strategy spreads
1269
- * placement across available candidates evenly based on the <code>field</code> parameter.
1270
- * The <code>binpack</code> strategy places tasks on available candidates that have the
1271
- * least available amount of the resource that's specified with the <code>field</code>
1272
- * parameter. For example, if you binpack on memory, a task is placed on the instance with
1273
- * the least amount of remaining memory but still enough to run the task.</p>
1274
- * @public
1275
- */
1276
- type?: PlacementStrategyType | undefined;
1277
- /**
1278
- * <p>The field to apply the placement strategy against. For the <code>spread</code>
1279
- * placement strategy, valid values are <code>instanceId</code> (or <code>host</code>,
1280
- * which has the same effect), or any platform or custom attribute that's applied to a
1281
- * container instance, such as <code>attribute:ecs.availability-zone</code>. For the
1282
- * <code>binpack</code> placement strategy, valid values are <code>cpu</code> and
1283
- * <code>memory</code>. For the <code>random</code> placement strategy, this field is
1284
- * not used.</p>
1285
- * @public
1286
- */
1287
- field?: string | undefined;
1288
- }
1289
- export declare const PlacementStrategyType: {
1290
- readonly BINPACK: "binpack";
1291
- readonly RANDOM: "random";
1292
- readonly SPREAD: "spread";
1293
- };
1294
- /**
1295
- * @public
1296
- */
1297
- export type PlacementStrategyType = (typeof PlacementStrategyType)[keyof typeof PlacementStrategyType];
1298
- export declare const PlacementConstraintType: {
1299
- readonly DISTINCT_INSTANCE: "distinctInstance";
1300
- readonly MEMBER_OF: "memberOf";
1301
- };
1302
- export type PlacementConstraintType = (typeof PlacementConstraintType)[keyof typeof PlacementConstraintType];
1303
- export interface KeyValuePair {
1304
- /**
1305
- * <p>The name of the key-value pair. For environment variables, this is the name of the
1306
- * environment variable.</p>
1307
- * @public
1308
- */
1309
- name?: string | undefined;
1310
- /**
1311
- * <p>The value of the key-value pair. For environment variables, this is the value of the
1312
- * environment variable.</p>
1313
- * @public
1314
- */
1315
- value?: string | undefined;
1316
- }
1317
- export declare const TargetType: {
1318
- readonly CONTAINER_INSTANCE: "container-instance";
1319
- };
1320
- export type TargetType = (typeof TargetType)[keyof typeof TargetType];
1321
- export interface NetworkBinding {
1322
- /**
1323
- * <p>The IP address that the container is bound to on the container instance.</p>
1324
- * @public
1325
- */
1326
- bindIP?: string | undefined;
1327
- /**
1328
- * <p>The port number on the container that's used with the network binding.</p>
1329
- * @public
1330
- */
1331
- containerPort?: number | undefined;
1332
- /**
1333
- * <p>The port number on the host that's used with the network binding.</p>
1334
- * @public
1335
- */
1336
- hostPort?: number | undefined;
1337
- /**
1338
- * <p>The protocol used for the network binding.</p>
1339
- * @public
1340
- */
1341
- protocol?: TransportProtocol | undefined;
1342
- /**
1343
- * <p>The port number range on the container that's bound to the dynamically mapped host
1344
- * port range.</p>
1345
- * <p>The following rules apply when you specify a <code>containerPortRange</code>:</p>
1346
- * <ul>
1347
- * <li>
1348
- * <p>You must use either the <code>bridge</code> network mode or the <code>awsvpc</code>
1349
- * network mode.</p>
1350
- * </li>
1351
- * <li>
1352
- * <p>This parameter is available for both the EC2 and Fargate launch types.</p>
1353
- * </li>
1354
- * <li>
1355
- * <p>This parameter is available for both the Linux and Windows operating systems.</p>
1356
- * </li>
1357
- * <li>
1358
- * <p>The container instance must have at least version 1.67.0 of the container agent
1359
- * and at least version 1.67.0-1 of the <code>ecs-init</code> package </p>
1360
- * </li>
1361
- * <li>
1362
- * <p>You can specify a maximum of 100 port ranges per container.</p>
1363
- * </li>
1364
- * <li>
1365
- * <p>You do not specify a <code>hostPortRange</code>. The value of the <code>hostPortRange</code> is set
1366
- * as follows:</p>
1367
- * <ul>
1368
- * <li>
1369
- * <p>For containers in a task with the <code>awsvpc</code> network mode,
1370
- * the <code>hostPortRange</code> is set to the same value as the
1371
- * <code>containerPortRange</code>. This is a static mapping
1372
- * strategy.</p>
1373
- * </li>
1374
- * <li>
1375
- * <p>For containers in a task with the <code>bridge</code> network mode, the Amazon ECS agent finds open host ports from the default ephemeral range and passes it to docker to bind them to the container ports.</p>
1376
- * </li>
1377
- * </ul>
1378
- * </li>
1379
- * <li>
1380
- * <p>The <code>containerPortRange</code> valid values are between 1 and
1381
- * 65535.</p>
1382
- * </li>
1383
- * <li>
1384
- * <p>A port can only be included in one port mapping per container.</p>
1385
- * </li>
1386
- * <li>
1387
- * <p>You cannot specify overlapping port ranges.</p>
1388
- * </li>
1389
- * <li>
1390
- * <p>The first port in the range must be less than last port in the range.</p>
1391
- * </li>
1392
- * <li>
1393
- * <p>Docker recommends that you turn off the docker-proxy in the Docker daemon config file when you have a large number of ports.</p>
1394
- * <p>For more information, see <a href="https://github.com/moby/moby/issues/11185"> Issue #11185</a> on the Github website.</p>
1395
- * <p>For information about how to turn off the docker-proxy in the Docker daemon config file, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#bootstrap_docker_daemon">Docker daemon</a> in the <i>Amazon ECS Developer Guide</i>.</p>
1396
- * </li>
1397
- * </ul>
1398
- * <p>You can call <a href="https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html">
1399
- * <code>DescribeTasks</code>
1400
- * </a> to view the <code>hostPortRange</code> which
1401
- * are the host ports that are bound to the container ports.</p>
1402
- * @public
1403
- */
1404
- containerPortRange?: string | undefined;
1405
- /**
1406
- * <p>The port number range on the host that's used with the network binding. This is
1407
- * assigned is assigned by Docker and delivered by the Amazon ECS agent.</p>
1408
- * @public
1409
- */
1410
- hostPortRange?: string | undefined;
1411
- }
1412
- export interface NetworkInterface {
1413
- /**
1414
- * <p>The attachment ID for the network interface.</p>
1415
- * @public
1416
- */
1417
- attachmentId?: string | undefined;
1418
- /**
1419
- * <p>The private IPv4 address for the network interface.</p>
1420
- * @public
1421
- */
1422
- privateIpv4Address?: string | undefined;
1423
- /**
1424
- * <p>The private IPv6 address for the network interface.</p>
1425
- * @public
1426
- */
1427
- ipv6Address?: string | undefined;
1428
- }
1429
- export interface ManagedAgent {
1430
- /**
1431
- * <p>The Unix timestamp for the time when the managed agent was last started.</p>
1432
- * @public
1433
- */
1434
- lastStartedAt?: Date | undefined;
1435
- /**
1436
- * <p>The name of the managed agent. When the execute command feature is turned on, the
1437
- * managed agent name is <code>ExecuteCommandAgent</code>.</p>
1438
- * @public
1439
- */
1440
- name?: ManagedAgentName | undefined;
1441
- /**
1442
- * <p>The reason for why the managed agent is in the state it is in.</p>
1443
- * @public
1444
- */
1445
- reason?: string | undefined;
1446
- /**
1447
- * <p>The last known status of the managed agent.</p>
1448
- * @public
1449
- */
1450
- lastStatus?: string | undefined;
1451
- }
1452
- export declare const ManagedAgentName: {
1453
- readonly ExecuteCommandAgent: "ExecuteCommandAgent";
1454
- };
1455
- export type ManagedAgentName = (typeof ManagedAgentName)[keyof typeof ManagedAgentName];
1456
- export interface EnvironmentFile {
1457
- /**
1458
- * <p>The Amazon Resource Name (ARN) of the Amazon S3 object containing the environment
1459
- * variable file.</p>
1460
- * @public
1461
- */
1462
- value: string | undefined;
1463
- /**
1464
- * <p>The file type to use. Environment files are objects in Amazon S3. The only supported value
1465
- * is <code>s3</code>.</p>
1466
- * @public
1467
- */
1468
- type: EnvironmentFileType | undefined;
1469
- }
1470
- export declare const EnvironmentFileType: {
1471
- readonly S3: "s3";
1472
- };
1473
- export type EnvironmentFileType = (typeof EnvironmentFileType)[keyof typeof EnvironmentFileType];
1474
- export interface ResourceRequirement {
1475
- /**
1476
- * <p>The value for the specified resource type.</p>
1477
- * <p>When the type is <code>GPU</code>, the value is the number of physical
1478
- * <code>GPUs</code> the Amazon ECS container agent reserves for the container. The number
1479
- * of GPUs that's reserved for all containers in a task can't exceed the number of
1480
- * available GPUs on the container instance that the task is launched on.</p>
1481
- * <p>When the type is <code>InferenceAccelerator</code>, the <code>value</code> matches the
1482
- * <code>deviceName</code> for an <a href="https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_InferenceAccelerator.html">InferenceAccelerator</a> specified in a task definition.</p>
1483
- * @public
1484
- */
1485
- value: string | undefined;
1486
- /**
1487
- * <p>The type of resource to assign to a container. </p>
1488
- * @public
1489
- */
1490
- type: ResourceType | undefined;
1491
- }
1492
- export declare const ResourceType: {
1493
- readonly GPU: "GPU";
1494
- readonly INFERENCE_ACCELERATOR: "InferenceAccelerator";
1495
- };
1496
- export type ResourceType = (typeof ResourceType)[keyof typeof ResourceType];
1497
- export declare const EBSResourceType: {
1498
- readonly VOLUME: "volume";
1499
- };
1500
- export type EBSResourceType = (typeof EBSResourceType)[keyof typeof EBSResourceType];
1501
- export interface EBSTagSpecification {
1502
- /**
1503
- * <p>The type of volume resource.</p>
1504
- * @public
1505
- */
1506
- resourceType: EBSResourceType | undefined;
1507
- /**
1508
- * <p>The tags applied to this Amazon EBS volume. <code>AmazonECSCreated</code> and
1509
- * <code>AmazonECSManaged</code> are reserved tags that can't be used.</p>
1510
- * @public
1511
- */
1512
- tags?: Tag[] | undefined;
1513
- /**
1514
- * <p>Determines whether to propagate the tags from the task definition to
1515
- the Amazon EBS
1516
- * volume. Tags can only propagate to a <code>SERVICE</code> specified in
1517
- *
1518
- <code>ServiceVolumeConfiguration</code>. If no value is specified, the tags aren't
1519
- *
1520
- propagated.</p>
1521
- * @public
1522
- */
1523
- propagateTags?: PropagateTags | undefined;
1524
- }
1525
- export interface TaskManagedEBSVolumeTerminationPolicy {
1526
- /**
1527
- * <p>Indicates whether the volume should be deleted on when the task stops. If a value of
1528
- * <code>true</code> is specified,
1529
- Amazon ECS deletes the Amazon EBS volume on your behalf when
1530
- * the task goes into the <code>STOPPED</code> state. If no value is specified, the
1531
- *
1532
- default value is <code>true</code> is used. When set to <code>false</code>, Amazon ECS
1533
- * leaves the volume in your
1534
- account.</p>
1535
- * @public
1536
- */
1537
- deleteOnTermination: boolean | undefined;
1538
- }
1539
- export declare const TaskFilesystemType: {
1540
- readonly EXT3: "ext3";
1541
- readonly EXT4: "ext4";
1542
- readonly NTFS: "ntfs";
1543
- readonly XFS: "xfs";
1544
- };
1545
- export type TaskFilesystemType = (typeof TaskFilesystemType)[keyof typeof TaskFilesystemType];
1546
- export declare const TransportProtocol: {
1547
- readonly TCP: "tcp";
1548
- readonly UDP: "udp";
1549
- };
1550
- export type TransportProtocol = (typeof TransportProtocol)[keyof typeof TransportProtocol];
1551
- export interface Tag {
1552
- /**
1553
- * <p>One part of a key-value pair that make up a tag. A <code>key</code> is a general label
1554
- * that acts like a category for more specific tag values.</p>
1555
- * @public
1556
- */
1557
- key?: string | undefined;
1558
- /**
1559
- * <p>The optional part of a key-value pair that make up a tag. A <code>value</code> acts as
1560
- * a descriptor within a tag category (key).</p>
1561
- * @public
1562
- */
1563
- value?: string | undefined;
1564
- }