-
Notifications
You must be signed in to change notification settings - Fork 623
/
api_types.go
4242 lines (3653 loc) · 192 KB
/
api_types.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
package ecs
import (
"fmt"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/internal/awsutil"
)
var _ aws.Config
var _ = awsutil.Prettify
// An object representing a container instance or task attachment.
type Attachment struct {
_ struct{} `type:"structure"`
// Details of the attachment. For elastic network interfaces, this includes
// the network interface ID, the MAC address, the subnet ID, and the private
// IPv4 address.
Details []KeyValuePair `locationName:"details" type:"list"`
// The unique identifier for the attachment.
Id *string `locationName:"id" type:"string"`
// The status of the attachment. Valid values are PRECREATED, CREATED, ATTACHING,
// ATTACHED, DETACHING, DETACHED, and DELETED.
Status *string `locationName:"status" type:"string"`
// The type of the attachment, such as ElasticNetworkInterface.
Type *string `locationName:"type" type:"string"`
}
// String returns the string representation
func (s Attachment) String() string {
return awsutil.Prettify(s)
}
// An object representing a change in state for a task attachment.
type AttachmentStateChange struct {
_ struct{} `type:"structure"`
// The Amazon Resource Name (ARN) of the attachment.
//
// AttachmentArn is a required field
AttachmentArn *string `locationName:"attachmentArn" type:"string" required:"true"`
// The status of the attachment.
//
// Status is a required field
Status *string `locationName:"status" type:"string" required:"true"`
}
// String returns the string representation
func (s AttachmentStateChange) String() string {
return awsutil.Prettify(s)
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *AttachmentStateChange) Validate() error {
invalidParams := aws.ErrInvalidParams{Context: "AttachmentStateChange"}
if s.AttachmentArn == nil {
invalidParams.Add(aws.NewErrParamRequired("AttachmentArn"))
}
if s.Status == nil {
invalidParams.Add(aws.NewErrParamRequired("Status"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// An attribute is a name-value pair associated with an Amazon ECS object. Attributes
// enable you to extend the Amazon ECS data model by adding custom metadata
// to your resources. For more information, see Attributes (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html#attributes)
// in the Amazon Elastic Container Service Developer Guide.
type Attribute struct {
_ struct{} `type:"structure"`
// The name of the attribute. Up to 128 letters (uppercase and lowercase), numbers,
// hyphens, underscores, and periods are allowed.
//
// Name is a required field
Name *string `locationName:"name" type:"string" required:"true"`
// The ID of the target. You can specify the short form ID for a resource or
// the full Amazon Resource Name (ARN).
TargetId *string `locationName:"targetId" type:"string"`
// The type of the target with which to attach the attribute. This parameter
// is required if you use the short form ID for a resource instead of the full
// ARN.
TargetType TargetType `locationName:"targetType" type:"string" enum:"true"`
// The value of the attribute. Up to 128 letters (uppercase and lowercase),
// numbers, hyphens, underscores, periods, at signs (@), forward slashes, colons,
// and spaces are allowed.
Value *string `locationName:"value" type:"string"`
}
// String returns the string representation
func (s Attribute) String() string {
return awsutil.Prettify(s)
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *Attribute) Validate() error {
invalidParams := aws.ErrInvalidParams{Context: "Attribute"}
if s.Name == nil {
invalidParams.Add(aws.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// The details of the Auto Scaling group for the capacity provider.
type AutoScalingGroupProvider struct {
_ struct{} `type:"structure"`
// The Amazon Resource Name (ARN) that identifies the Auto Scaling group.
//
// AutoScalingGroupArn is a required field
AutoScalingGroupArn *string `locationName:"autoScalingGroupArn" type:"string" required:"true"`
// The managed scaling settings for the Auto Scaling group capacity provider.
ManagedScaling *ManagedScaling `locationName:"managedScaling" type:"structure"`
// The managed termination protection setting to use for the Auto Scaling group
// capacity provider. This determines whether the Auto Scaling group has managed
// termination protection.
//
// When using managed termination protection, managed scaling must also be used
// otherwise managed termination protection will not work.
//
// When managed termination protection is enabled, Amazon ECS prevents the Amazon
// EC2 instances in an Auto Scaling group that contain tasks from being terminated
// during a scale-in action. The Auto Scaling group and each instance in the
// Auto Scaling group must have instance protection from scale-in actions enabled
// as well. For more information, see Instance Protection (https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html#instance-protection)
// in the AWS Auto Scaling User Guide.
//
// When managed termination protection is disabled, your Amazon EC2 instances
// are not protected from termination when the Auto Scaling group scales in.
ManagedTerminationProtection ManagedTerminationProtection `locationName:"managedTerminationProtection" type:"string" enum:"true"`
}
// String returns the string representation
func (s AutoScalingGroupProvider) String() string {
return awsutil.Prettify(s)
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *AutoScalingGroupProvider) Validate() error {
invalidParams := aws.ErrInvalidParams{Context: "AutoScalingGroupProvider"}
if s.AutoScalingGroupArn == nil {
invalidParams.Add(aws.NewErrParamRequired("AutoScalingGroupArn"))
}
if s.ManagedScaling != nil {
if err := s.ManagedScaling.Validate(); err != nil {
invalidParams.AddNested("ManagedScaling", err.(aws.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// An object representing the networking details for a task or service.
type AwsVpcConfiguration struct {
_ struct{} `type:"structure"`
// Whether the task's elastic network interface receives a public IP address.
// The default value is DISABLED.
AssignPublicIp AssignPublicIp `locationName:"assignPublicIp" type:"string" enum:"true"`
// The security groups associated with the task or service. If you do not specify
// a security group, the default security group for the VPC is used. There is
// a limit of 5 security groups that can be specified per AwsVpcConfiguration.
//
// All specified security groups must be from the same VPC.
SecurityGroups []string `locationName:"securityGroups" type:"list"`
// The subnets associated with the task or service. There is a limit of 16 subnets
// that can be specified per AwsVpcConfiguration.
//
// All specified subnets must be from the same VPC.
//
// Subnets is a required field
Subnets []string `locationName:"subnets" type:"list" required:"true"`
}
// String returns the string representation
func (s AwsVpcConfiguration) String() string {
return awsutil.Prettify(s)
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *AwsVpcConfiguration) Validate() error {
invalidParams := aws.ErrInvalidParams{Context: "AwsVpcConfiguration"}
if s.Subnets == nil {
invalidParams.Add(aws.NewErrParamRequired("Subnets"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// The details of a capacity provider.
type CapacityProvider struct {
_ struct{} `type:"structure"`
// The Auto Scaling group settings for the capacity provider.
AutoScalingGroupProvider *AutoScalingGroupProvider `locationName:"autoScalingGroupProvider" type:"structure"`
// The Amazon Resource Name (ARN) that identifies the capacity provider.
CapacityProviderArn *string `locationName:"capacityProviderArn" type:"string"`
// The name of the capacity provider.
Name *string `locationName:"name" type:"string"`
// The current status of the capacity provider. Only capacity providers in an
// ACTIVE state can be used in a cluster.
Status CapacityProviderStatus `locationName:"status" type:"string" enum:"true"`
// The metadata that you apply to the capacity provider to help you categorize
// and organize it. Each tag consists of a key and an optional value, both of
// which you define.
//
// The following basic restrictions apply to tags:
//
// * Maximum number of tags per resource - 50
//
// * For each resource, each tag key must be unique, and each tag key can
// have only one value.
//
// * Maximum key length - 128 Unicode characters in UTF-8
//
// * Maximum value length - 256 Unicode characters in UTF-8
//
// * If your tagging schema is used across multiple services and resources,
// remember that other services may have restrictions on allowed characters.
// Generally allowed characters are: letters, numbers, and spaces representable
// in UTF-8, and the following characters: + - = . _ : / @.
//
// * Tag keys and values are case-sensitive.
//
// * Do not use aws:, AWS:, or any upper or lowercase combination of such
// as a prefix for either keys or values as it is reserved for AWS use. You
// cannot edit or delete tag keys or values with this prefix. Tags with this
// prefix do not count against your tags per resource limit.
Tags []Tag `locationName:"tags" type:"list"`
}
// String returns the string representation
func (s CapacityProvider) String() string {
return awsutil.Prettify(s)
}
// The details of a capacity provider strategy.
type CapacityProviderStrategyItem struct {
_ struct{} `type:"structure"`
// The base value designates how many tasks, at a minimum, to run on the specified
// capacity provider. Only one capacity provider in a capacity provider strategy
// can have a base defined.
Base *int64 `locationName:"base" type:"integer"`
// The short name of the capacity provider.
//
// CapacityProvider is a required field
CapacityProvider *string `locationName:"capacityProvider" type:"string" required:"true"`
// The weight value designates the relative percentage of the total number of
// tasks launched that should use the specified capacity provider.
//
// For example, if you have a strategy that contains two capacity providers
// and both have a weight of 1, then when the base is satisfied, the tasks will
// be split evenly across the two capacity providers. Using that same logic,
// if you specify a weight of 1 for capacityProviderA and a weight of 4 for
// capacityProviderB, then for every one task that is run using capacityProviderA,
// four tasks would use capacityProviderB.
Weight *int64 `locationName:"weight" type:"integer"`
}
// String returns the string representation
func (s CapacityProviderStrategyItem) String() string {
return awsutil.Prettify(s)
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CapacityProviderStrategyItem) Validate() error {
invalidParams := aws.ErrInvalidParams{Context: "CapacityProviderStrategyItem"}
if s.CapacityProvider == nil {
invalidParams.Add(aws.NewErrParamRequired("CapacityProvider"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// A regional grouping of one or more container instances on which you can run
// task requests. Each account receives a default cluster the first time you
// use the Amazon ECS service, but you may also create other clusters. Clusters
// may contain more than one instance type simultaneously.
type Cluster struct {
_ struct{} `type:"structure"`
// The number of services that are running on the cluster in an ACTIVE state.
// You can view these services with ListServices.
ActiveServicesCount *int64 `locationName:"activeServicesCount" type:"integer"`
// The resources attached to a cluster. When using a capacity provider with
// a cluster, the Auto Scaling plan that is created will be returned as a cluster
// attachment.
Attachments []Attachment `locationName:"attachments" type:"list"`
// The status of the capacity providers associated with the cluster. The following
// are the states that will be returned:
//
// UPDATE_IN_PROGRESS
//
// The available capacity providers for the cluster are updating. This occurs
// when the Auto Scaling plan is provisioning or deprovisioning.
//
// UPDATE_COMPLETE
//
// The capacity providers have successfully updated.
//
// UPDATE_FAILED
//
// The capacity provider updates failed.
AttachmentsStatus *string `locationName:"attachmentsStatus" type:"string"`
// The capacity providers associated with the cluster.
CapacityProviders []string `locationName:"capacityProviders" type:"list"`
// The Amazon Resource Name (ARN) that identifies the cluster. The ARN contains
// the arn:aws:ecs namespace, followed by the Region of the cluster, the AWS
// account ID of the cluster owner, the cluster namespace, and then the cluster
// name. For example, arn:aws:ecs:region:012345678910:cluster/test.
ClusterArn *string `locationName:"clusterArn" type:"string"`
// A user-generated string that you use to identify your cluster.
ClusterName *string `locationName:"clusterName" type:"string"`
// The default capacity provider strategy for the cluster. When services or
// tasks are run in the cluster with no launch type or capacity provider strategy
// specified, the default capacity provider strategy is used.
DefaultCapacityProviderStrategy []CapacityProviderStrategyItem `locationName:"defaultCapacityProviderStrategy" type:"list"`
// The number of tasks in the cluster that are in the PENDING state.
PendingTasksCount *int64 `locationName:"pendingTasksCount" type:"integer"`
// The number of container instances registered into the cluster. This includes
// container instances in both ACTIVE and DRAINING status.
RegisteredContainerInstancesCount *int64 `locationName:"registeredContainerInstancesCount" type:"integer"`
// The number of tasks in the cluster that are in the RUNNING state.
RunningTasksCount *int64 `locationName:"runningTasksCount" type:"integer"`
// The settings for the cluster. This parameter indicates whether CloudWatch
// Container Insights is enabled or disabled for a cluster.
Settings []ClusterSetting `locationName:"settings" type:"list"`
// Additional information about your clusters that are separated by launch type,
// including:
//
// * runningEC2TasksCount
//
// * RunningFargateTasksCount
//
// * pendingEC2TasksCount
//
// * pendingFargateTasksCount
//
// * activeEC2ServiceCount
//
// * activeFargateServiceCount
//
// * drainingEC2ServiceCount
//
// * drainingFargateServiceCount
Statistics []KeyValuePair `locationName:"statistics" type:"list"`
// The status of the cluster. The following are the possible states that will
// be returned.
//
// ACTIVE
//
// The cluster is ready to accept tasks and if applicable you can register container
// instances with the cluster.
//
// PROVISIONING
//
// The cluster has capacity providers associated with it and the resources needed
// for the capacity provider are being created.
//
// DEPROVISIONING
//
// The cluster has capacity providers associated with it and the resources needed
// for the capacity provider are being deleted.
//
// FAILED
//
// The cluster has capacity providers associated with it and the resources needed
// for the capacity provider have failed to create.
//
// INACTIVE
//
// The cluster has been deleted. Clusters with an INACTIVE status may remain
// discoverable in your account for a period of time. However, this behavior
// is subject to change in the future, so you should not rely on INACTIVE clusters
// persisting.
Status *string `locationName:"status" type:"string"`
// The metadata that you apply to the cluster to help you categorize and organize
// them. Each tag consists of a key and an optional value, both of which you
// define.
//
// The following basic restrictions apply to tags:
//
// * Maximum number of tags per resource - 50
//
// * For each resource, each tag key must be unique, and each tag key can
// have only one value.
//
// * Maximum key length - 128 Unicode characters in UTF-8
//
// * Maximum value length - 256 Unicode characters in UTF-8
//
// * If your tagging schema is used across multiple services and resources,
// remember that other services may have restrictions on allowed characters.
// Generally allowed characters are: letters, numbers, and spaces representable
// in UTF-8, and the following characters: + - = . _ : / @.
//
// * Tag keys and values are case-sensitive.
//
// * Do not use aws:, AWS:, or any upper or lowercase combination of such
// as a prefix for either keys or values as it is reserved for AWS use. You
// cannot edit or delete tag keys or values with this prefix. Tags with this
// prefix do not count against your tags per resource limit.
Tags []Tag `locationName:"tags" type:"list"`
}
// String returns the string representation
func (s Cluster) String() string {
return awsutil.Prettify(s)
}
// The settings to use when creating a cluster. This parameter is used to enable
// CloudWatch Container Insights for a cluster.
type ClusterSetting struct {
_ struct{} `type:"structure"`
// The name of the cluster setting. The only supported value is containerInsights.
Name ClusterSettingName `locationName:"name" type:"string" enum:"true"`
// The value to set for the cluster setting. The supported values are enabled
// and disabled. If enabled is specified, CloudWatch Container Insights will
// be enabled for the cluster, otherwise it will be disabled unless the containerInsights
// account setting is enabled. If a cluster value is specified, it will override
// the containerInsights value set with PutAccountSetting or PutAccountSettingDefault.
Value *string `locationName:"value" type:"string"`
}
// String returns the string representation
func (s ClusterSetting) String() string {
return awsutil.Prettify(s)
}
// A Docker container that is part of a task.
type Container struct {
_ struct{} `type:"structure"`
// The Amazon Resource Name (ARN) of the container.
ContainerArn *string `locationName:"containerArn" type:"string"`
// The number of CPU units set for the container. The value will be 0 if no
// value was specified in the container definition when the task definition
// was registered.
Cpu *string `locationName:"cpu" type:"string"`
// The exit code returned from the container.
ExitCode *int64 `locationName:"exitCode" type:"integer"`
// The IDs of each GPU assigned to the container.
GpuIds []string `locationName:"gpuIds" type:"list"`
// The health status of the container. If health checks are not configured for
// this container in its task definition, then it reports the health status
// as UNKNOWN.
HealthStatus HealthStatus `locationName:"healthStatus" type:"string" enum:"true"`
// The image used for the container.
Image *string `locationName:"image" type:"string"`
// The container image manifest digest.
//
// The imageDigest is only returned if the container is using an image hosted
// in Amazon ECR, otherwise it is omitted.
ImageDigest *string `locationName:"imageDigest" type:"string"`
// The last known status of the container.
LastStatus *string `locationName:"lastStatus" type:"string"`
// The hard limit (in MiB) of memory set for the container.
Memory *string `locationName:"memory" type:"string"`
// The soft limit (in MiB) of memory set for the container.
MemoryReservation *string `locationName:"memoryReservation" type:"string"`
// The name of the container.
Name *string `locationName:"name" type:"string"`
// The network bindings associated with the container.
NetworkBindings []NetworkBinding `locationName:"networkBindings" type:"list"`
// The network interfaces associated with the container.
NetworkInterfaces []NetworkInterface `locationName:"networkInterfaces" type:"list"`
// A short (255 max characters) human-readable string to provide additional
// details about a running or stopped container.
Reason *string `locationName:"reason" type:"string"`
// The ID of the Docker container.
RuntimeId *string `locationName:"runtimeId" type:"string"`
// The ARN of the task.
TaskArn *string `locationName:"taskArn" type:"string"`
}
// String returns the string representation
func (s Container) String() string {
return awsutil.Prettify(s)
}
// Container definitions are used in task definitions to describe the different
// containers that are launched as part of a task.
type ContainerDefinition struct {
_ struct{} `type:"structure"`
// The command that is passed to the container. This parameter maps to Cmd in
// the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the COMMAND parameter to docker run (https://docs.docker.com/engine/reference/run/).
// For more information, see https://docs.docker.com/engine/reference/builder/#cmd
// (https://docs.docker.com/engine/reference/builder/#cmd). If there are multiple
// arguments, each argument should be a separated string in the array.
Command []string `locationName:"command" type:"list"`
// The number of cpu units reserved for the container. This parameter maps to
// CpuShares in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --cpu-shares option to docker run (https://docs.docker.com/engine/reference/run/).
//
// This field is optional for tasks using the Fargate launch type, and the only
// requirement is that the total amount of CPU reserved for all containers within
// a task be lower than the task-level cpu value.
//
// You can determine the number of CPU units that are available per EC2 instance
// type by multiplying the vCPUs listed for that instance type on the Amazon
// EC2 Instances (http://aws.amazon.com/ec2/instance-types/) detail page by
// 1,024.
//
// Linux containers share unallocated CPU units with other containers on the
// container instance with the same ratio as their allocated amount. For example,
// if you run a single-container task on a single-core instance type with 512
// CPU units specified for that container, and that is the only task running
// on the container instance, that container could use the full 1,024 CPU unit
// share at any given time. However, if you launched another copy of the same
// task on that container instance, each task would be guaranteed a minimum
// of 512 CPU units when needed, and each container could float to higher CPU
// usage if the other container was not using it, but if both tasks were 100%
// active all of the time, they would be limited to 512 CPU units.
//
// On Linux container instances, the Docker daemon on the container instance
// uses the CPU value to calculate the relative CPU share ratios for running
// containers. For more information, see CPU share constraint (https://docs.docker.com/engine/reference/run/#cpu-share-constraint)
// in the Docker documentation. The minimum valid CPU share value that the Linux
// kernel allows is 2. However, the CPU parameter is not required, and you can
// use CPU values below 2 in your container definitions. For CPU values below
// 2 (including null), the behavior varies based on your Amazon ECS container
// agent version:
//
// * Agent versions less than or equal to 1.1.0: Null and zero CPU values
// are passed to Docker as 0, which Docker then converts to 1,024 CPU shares.
// CPU values of 1 are passed to Docker as 1, which the Linux kernel converts
// to two CPU shares.
//
// * Agent versions greater than or equal to 1.2.0: Null, zero, and CPU values
// of 1 are passed to Docker as 2.
//
// On Windows container instances, the CPU limit is enforced as an absolute
// limit, or a quota. Windows containers only have access to the specified amount
// of CPU that is described in the task definition.
Cpu *int64 `locationName:"cpu" type:"integer"`
// The dependencies defined for container startup and shutdown. A container
// can contain multiple dependencies. When a dependency is defined for container
// startup, for container shutdown it is reversed.
//
// For tasks using the EC2 launch type, the container instances require at least
// version 1.26.0 of the container agent to enable container dependencies. However,
// we recommend using the latest container agent version. For information about
// checking your agent version and updating to the latest version, see Updating
// the Amazon ECS Container Agent (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html)
// in the Amazon Elastic Container Service Developer Guide. If you are using
// an Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1
// of the ecs-init package. If your container instances are launched from version
// 20190301 or later, then they contain the required versions of the container
// agent and ecs-init. For more information, see Amazon ECS-optimized Linux
// AMI (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)
// in the Amazon Elastic Container Service Developer Guide.
//
// For tasks using the Fargate launch type, the task or service requires platform
// version 1.3.0 or later.
DependsOn []ContainerDependency `locationName:"dependsOn" type:"list"`
// When this parameter is true, networking is disabled within the container.
// This parameter maps to NetworkDisabled in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/).
//
// This parameter is not supported for Windows containers.
DisableNetworking *bool `locationName:"disableNetworking" type:"boolean"`
// A list of DNS search domains that are presented to the container. This parameter
// maps to DnsSearch in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --dns-search option to docker run (https://docs.docker.com/engine/reference/run/).
//
// This parameter is not supported for Windows containers.
DnsSearchDomains []string `locationName:"dnsSearchDomains" type:"list"`
// A list of DNS servers that are presented to the container. This parameter
// maps to Dns in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --dns option to docker run (https://docs.docker.com/engine/reference/run/).
//
// This parameter is not supported for Windows containers.
DnsServers []string `locationName:"dnsServers" type:"list"`
// A key/value map of labels to add to the container. This parameter maps to
// Labels in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --label option to docker run (https://docs.docker.com/engine/reference/run/).
// This parameter requires version 1.18 of the Docker Remote API or greater
// on your container instance. To check the Docker Remote API version on your
// container instance, log in to your container instance and run the following
// command: sudo docker version --format '{{.Server.APIVersion}}'
DockerLabels map[string]string `locationName:"dockerLabels" type:"map"`
// A list of strings to provide custom labels for SELinux and AppArmor multi-level
// security systems. This field is not valid for containers in tasks using the
// Fargate launch type.
//
// With Windows containers, this parameter can be used to reference a credential
// spec file when configuring a container for Active Directory authentication.
// For more information, see Using gMSAs for Windows Containers (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html)
// in the Amazon Elastic Container Service Developer Guide.
//
// This parameter maps to SecurityOpt in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --security-opt option to docker run (https://docs.docker.com/engine/reference/run/).
//
// The Amazon ECS container agent running on a container instance must register
// with the ECS_SELINUX_CAPABLE=true or ECS_APPARMOR_CAPABLE=true environment
// variables before containers placed on that instance can use these security
// options. For more information, see Amazon ECS Container Agent Configuration
// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
// in the Amazon Elastic Container Service Developer Guide.
DockerSecurityOptions []string `locationName:"dockerSecurityOptions" type:"list"`
//
// Early versions of the Amazon ECS container agent do not properly handle entryPoint
// parameters. If you have problems using entryPoint, update your container
// agent or enter your commands and arguments as command array items instead.
//
// The entry point that is passed to the container. This parameter maps to Entrypoint
// in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --entrypoint option to docker run (https://docs.docker.com/engine/reference/run/).
// For more information, see https://docs.docker.com/engine/reference/builder/#entrypoint
// (https://docs.docker.com/engine/reference/builder/#entrypoint).
EntryPoint []string `locationName:"entryPoint" type:"list"`
// The environment variables to pass to a container. This parameter maps to
// Env in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --env option to docker run (https://docs.docker.com/engine/reference/run/).
//
// We do not recommend using plaintext environment variables for sensitive information,
// such as credential data.
Environment []KeyValuePair `locationName:"environment" type:"list"`
// If the essential parameter of a container is marked as true, and that container
// fails or stops for any reason, all other containers that are part of the
// task are stopped. If the essential parameter of a container is marked as
// false, then its failure does not affect the rest of the containers in a task.
// If this parameter is omitted, a container is assumed to be essential.
//
// All tasks must have at least one essential container. If you have an application
// that is composed of multiple containers, you should group containers that
// are used for a common purpose into components, and separate the different
// components into multiple task definitions. For more information, see Application
// Architecture (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html)
// in the Amazon Elastic Container Service Developer Guide.
Essential *bool `locationName:"essential" type:"boolean"`
// A list of hostnames and IP address mappings to append to the /etc/hosts file
// on the container. This parameter maps to ExtraHosts in the Create a container
// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section
// of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and
// the --add-host option to docker run (https://docs.docker.com/engine/reference/run/).
//
// This parameter is not supported for Windows containers or tasks that use
// the awsvpc network mode.
ExtraHosts []HostEntry `locationName:"extraHosts" type:"list"`
// The FireLens configuration for the container. This is used to specify and
// configure a log router for container logs. For more information, see Custom
// Log Routing (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html)
// in the Amazon Elastic Container Service Developer Guide.
FirelensConfiguration *FirelensConfiguration `locationName:"firelensConfiguration" type:"structure"`
// The container health check command and associated configuration parameters
// for the container. This parameter maps to HealthCheck in the Create a container
// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section
// of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and
// the HEALTHCHECK parameter of docker run (https://docs.docker.com/engine/reference/run/).
HealthCheck *HealthCheck `locationName:"healthCheck" type:"structure"`
// The hostname to use for your container. This parameter maps to Hostname in
// the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --hostname option to docker run (https://docs.docker.com/engine/reference/run/).
//
// The hostname parameter is not supported if you are using the awsvpc network
// mode.
Hostname *string `locationName:"hostname" type:"string"`
// The image used to start a container. This string is passed directly to the
// Docker daemon. Images in the Docker Hub registry are available by default.
// Other repositories are specified with either repository-url/image:tag or
// repository-url/image@digest . Up to 255 letters (uppercase and lowercase),
// numbers, hyphens, underscores, colons, periods, forward slashes, and number
// signs are allowed. This parameter maps to Image in the Create a container
// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section
// of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and
// the IMAGE parameter of docker run (https://docs.docker.com/engine/reference/run/).
//
// * When a new task starts, the Amazon ECS container agent pulls the latest
// version of the specified image and tag for the container to use. However,
// subsequent updates to a repository image are not propagated to already
// running tasks.
//
// * Images in Amazon ECR repositories can be specified by either using the
// full registry/repository:tag or registry/repository@digest. For example,
// 012345678910.dkr.ecr.<region-name>.amazonaws.com/<repository-name>:latest
// or 012345678910.dkr.ecr.<region-name>.amazonaws.com/<repository-name>@sha256:94afd1f2e64d908bc90dbca0035a5b567EXAMPLE.
//
// * Images in official repositories on Docker Hub use a single name (for
// example, ubuntu or mongo).
//
// * Images in other repositories on Docker Hub are qualified with an organization
// name (for example, amazon/amazon-ecs-agent).
//
// * Images in other online repositories are qualified further by a domain
// name (for example, quay.io/assemblyline/ubuntu).
Image *string `locationName:"image" type:"string"`
// When this parameter is true, this allows you to deploy containerized applications
// that require stdin or a tty to be allocated. This parameter maps to OpenStdin
// in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --interactive option to docker run (https://docs.docker.com/engine/reference/run/).
Interactive *bool `locationName:"interactive" type:"boolean"`
// The links parameter allows containers to communicate with each other without
// the need for port mappings. This parameter is only supported if the network
// mode of a task definition is bridge. The name:internalName construct is analogous
// to name:alias in Docker links. Up to 255 letters (uppercase and lowercase),
// numbers, and hyphens are allowed. For more information about linking Docker
// containers, go to Legacy container links (https://docs.docker.com/network/links/)
// in the Docker documentation. This parameter maps to Links in the Create a
// container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --link option to docker run (https://docs.docker.com/engine/reference/run/).
//
// This parameter is not supported for Windows containers.
//
// Containers that are collocated on a single container instance may be able
// to communicate with each other without requiring links or host port mappings.
// Network isolation is achieved on the container instance using security groups
// and VPC settings.
Links []string `locationName:"links" type:"list"`
// Linux-specific modifications that are applied to the container, such as Linux
// kernel capabilities. For more information see KernelCapabilities.
//
// This parameter is not supported for Windows containers.
LinuxParameters *LinuxParameters `locationName:"linuxParameters" type:"structure"`
// The log configuration specification for the container.
//
// This parameter maps to LogConfig in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --log-driver option to docker run (https://docs.docker.com/engine/reference/run/).
// By default, containers use the same logging driver that the Docker daemon
// uses. However the container may use a different logging driver than the Docker
// daemon by specifying a log driver with this parameter in the container definition.
// To use a different logging driver for a container, the log system must be
// configured properly on the container instance (or on a different log server
// for remote logging options). For more information on the options for different
// supported log drivers, see Configure logging drivers (https://docs.docker.com/engine/admin/logging/overview/)
// in the Docker documentation.
//
// Amazon ECS currently supports a subset of the logging drivers available to
// the Docker daemon (shown in the LogConfiguration data type). Additional log
// drivers may be available in future releases of the Amazon ECS container agent.
//
// This parameter requires version 1.18 of the Docker Remote API or greater
// on your container instance. To check the Docker Remote API version on your
// container instance, log in to your container instance and run the following
// command: sudo docker version --format '{{.Server.APIVersion}}'
//
// The Amazon ECS container agent running on a container instance must register
// the logging drivers available on that instance with the ECS_AVAILABLE_LOGGING_DRIVERS
// environment variable before containers placed on that instance can use these
// log configuration options. For more information, see Amazon ECS Container
// Agent Configuration (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
// in the Amazon Elastic Container Service Developer Guide.
LogConfiguration *LogConfiguration `locationName:"logConfiguration" type:"structure"`
// The amount (in MiB) of memory to present to the container. If your container
// attempts to exceed the memory specified here, the container is killed. The
// total amount of memory reserved for all containers within a task must be
// lower than the task memory value, if one is specified. This parameter maps
// to Memory in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --memory option to docker run (https://docs.docker.com/engine/reference/run/).
//
// If using the Fargate launch type, this parameter is optional.
//
// If using the EC2 launch type, you must specify either a task-level memory
// value or a container-level memory value. If you specify both a container-level
// memory and memoryReservation value, memory must be greater than memoryReservation.
// If you specify memoryReservation, then that value is subtracted from the
// available memory resources for the container instance on which the container
// is placed. Otherwise, the value of memory is used.
//
// The Docker daemon reserves a minimum of 4 MiB of memory for a container,
// so you should not specify fewer than 4 MiB of memory for your containers.
Memory *int64 `locationName:"memory" type:"integer"`
// The soft limit (in MiB) of memory to reserve for the container. When system
// memory is under heavy contention, Docker attempts to keep the container memory
// to this soft limit. However, your container can consume more memory when
// it needs to, up to either the hard limit specified with the memory parameter
// (if applicable), or all of the available memory on the container instance,
// whichever comes first. This parameter maps to MemoryReservation in the Create
// a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --memory-reservation option to docker run (https://docs.docker.com/engine/reference/run/).
//
// If a task-level memory value is not specified, you must specify a non-zero
// integer for one or both of memory or memoryReservation in a container definition.
// If you specify both, memory must be greater than memoryReservation. If you
// specify memoryReservation, then that value is subtracted from the available
// memory resources for the container instance on which the container is placed.
// Otherwise, the value of memory is used.
//
// For example, if your container normally uses 128 MiB of memory, but occasionally
// bursts to 256 MiB of memory for short periods of time, you can set a memoryReservation
// of 128 MiB, and a memory hard limit of 300 MiB. This configuration would
// allow the container to only reserve 128 MiB of memory from the remaining
// resources on the container instance, but also allow the container to consume
// more memory resources when needed.
//
// The Docker daemon reserves a minimum of 4 MiB of memory for a container,
// so you should not specify fewer than 4 MiB of memory for your containers.
MemoryReservation *int64 `locationName:"memoryReservation" type:"integer"`
// The mount points for data volumes in your container.
//
// This parameter maps to Volumes in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --volume option to docker run (https://docs.docker.com/engine/reference/run/).
//
// Windows containers can mount whole directories on the same drive as $env:ProgramData.
// Windows containers cannot mount directories on a different drive, and mount
// point cannot be across drives.
MountPoints []MountPoint `locationName:"mountPoints" type:"list"`
// The name of a container. If you are linking multiple containers together
// in a task definition, the name of one container can be entered in the links
// of another container to connect the containers. Up to 255 letters (uppercase
// and lowercase), numbers, and hyphens are allowed. This parameter maps to
// name in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --name option to docker run (https://docs.docker.com/engine/reference/run/).
Name *string `locationName:"name" type:"string"`
// The list of port mappings for the container. Port mappings allow containers
// to access ports on the host container instance to send or receive traffic.
//
// For task definitions that use the awsvpc network mode, you should only specify
// the containerPort. The hostPort can be left blank or it must be the same
// value as the containerPort.
//
// Port mappings on Windows use the NetNAT gateway address rather than localhost.
// There is no loopback for port mappings on Windows, so you cannot access a
// container's mapped port from the host itself.
//
// This parameter maps to PortBindings in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --publish option to docker run (https://docs.docker.com/engine/reference/run/).
// If the network mode of a task definition is set to none, then you can't specify
// port mappings. If the network mode of a task definition is set to host, then
// host ports must either be undefined or they must match the container port
// in the port mapping.
//
// After a task reaches the RUNNING status, manual and automatic host and container
// port assignments are visible in the Network Bindings section of a container
// description for a selected task in the Amazon ECS console. The assignments
// are also visible in the networkBindings section DescribeTasks responses.
PortMappings []PortMapping `locationName:"portMappings" type:"list"`
// When this parameter is true, the container is given elevated privileges on
// the host container instance (similar to the root user). This parameter maps
// to Privileged in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --privileged option to docker run (https://docs.docker.com/engine/reference/run/).
//
// This parameter is not supported for Windows containers or tasks using the
// Fargate launch type.
Privileged *bool `locationName:"privileged" type:"boolean"`
// When this parameter is true, a TTY is allocated. This parameter maps to Tty
// in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/)
// and the --tty option to docker run (https://docs.docker.com/engine/reference/run/).
PseudoTerminal *bool `locationName:"pseudoTerminal" type:"boolean"`
// When this parameter is true, the container is given read-only access to its
// root file system. This parameter maps to ReadonlyRootfs in the Create a container
// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section
// of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and
// the --read-only option to docker run (https://docs.docker.com/engine/reference/run/).
//
// This parameter is not supported for Windows containers.
ReadonlyRootFilesystem *bool `locationName:"readonlyRootFilesystem" type:"boolean"`
// The private repository authentication credentials to use.
RepositoryCredentials *RepositoryCredentials `locationName:"repositoryCredentials" type:"structure"`
// The type and amount of a resource to assign to a container. The only supported
// resource is a GPU.
ResourceRequirements []ResourceRequirement `locationName:"resourceRequirements" type:"list"`
// The secrets to pass to the container. For more information, see Specifying
// Sensitive Data (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html)
// in the Amazon Elastic Container Service Developer Guide.
Secrets []Secret `locationName:"secrets" type:"list"`
// Time duration (in seconds) to wait before giving up on resolving dependencies
// for a container. For example, you specify two containers in a task definition
// with containerA having a dependency on containerB reaching a COMPLETE, SUCCESS,
// or HEALTHY status. If a startTimeout value is specified for containerB and
// it does not reach the desired status within that time then containerA will
// give up and not start. This results in the task transitioning to a STOPPED
// state.
//
// For tasks using the Fargate launch type, this parameter requires that the
// task or service uses platform version 1.3.0 or later. If this parameter is
// not specified, the default value of 3 minutes is used.
//
// For tasks using the EC2 launch type, if the startTimeout parameter is not
// specified, the value set for the Amazon ECS container agent configuration
// variable ECS_CONTAINER_START_TIMEOUT is used by default. If neither the startTimeout
// parameter or the ECS_CONTAINER_START_TIMEOUT agent configuration variable
// are set, then the default values of 3 minutes for Linux containers and 8