1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package types 4 5import ( 6 "time" 7) 8 9// An object representing a container instance or task attachment. 10type Attachment struct { 11 12 // Details of the attachment. For elastic network interfaces, this includes the 13 // network interface ID, the MAC address, the subnet ID, and the private IPv4 14 // address. 15 Details []KeyValuePair 16 17 // The unique identifier for the attachment. 18 Id *string 19 20 // The status of the attachment. Valid values are PRECREATED, CREATED, ATTACHING, 21 // ATTACHED, DETACHING, DETACHED, and DELETED. 22 Status *string 23 24 // The type of the attachment, such as ElasticNetworkInterface. 25 Type *string 26} 27 28// An object representing a change in state for a task attachment. 29type AttachmentStateChange struct { 30 31 // The Amazon Resource Name (ARN) of the attachment. 32 // 33 // This member is required. 34 AttachmentArn *string 35 36 // The status of the attachment. 37 // 38 // This member is required. 39 Status *string 40} 41 42// An attribute is a name-value pair associated with an Amazon ECS object. 43// Attributes enable you to extend the Amazon ECS data model by adding custom 44// metadata to your resources. For more information, see Attributes 45// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html#attributes) 46// in the Amazon Elastic Container Service Developer Guide. 47type Attribute struct { 48 49 // The name of the attribute. The name must contain between 1 and 128 characters 50 // and name may contain letters (uppercase and lowercase), numbers, hyphens, 51 // underscores, forward slashes, back slashes, or periods. 52 // 53 // This member is required. 54 Name *string 55 56 // The ID of the target. You can specify the short form ID for a resource or the 57 // full Amazon Resource Name (ARN). 58 TargetId *string 59 60 // The type of the target with which to attach the attribute. This parameter is 61 // required if you use the short form ID for a resource instead of the full ARN. 62 TargetType TargetType 63 64 // The value of the attribute. The value must contain between 1 and 128 characters 65 // and may contain letters (uppercase and lowercase), numbers, hyphens, 66 // underscores, periods, at signs (@), forward slashes, back slashes, colons, or 67 // spaces. The value cannot contain any leading or trailing whitespace. 68 Value *string 69} 70 71// The details of the Auto Scaling group for the capacity provider. 72type AutoScalingGroupProvider struct { 73 74 // The Amazon Resource Name (ARN) that identifies the Auto Scaling group. 75 // 76 // This member is required. 77 AutoScalingGroupArn *string 78 79 // The managed scaling settings for the Auto Scaling group capacity provider. 80 ManagedScaling *ManagedScaling 81 82 // The managed termination protection setting to use for the Auto Scaling group 83 // capacity provider. This determines whether the Auto Scaling group has managed 84 // termination protection. When using managed termination protection, managed 85 // scaling must also be used otherwise managed termination protection will not 86 // work. When managed termination protection is enabled, Amazon ECS prevents the 87 // Amazon EC2 instances in an Auto Scaling group that contain tasks from being 88 // terminated during a scale-in action. The Auto Scaling group and each instance in 89 // the Auto Scaling group must have instance protection from scale-in actions 90 // enabled as well. For more information, see Instance Protection 91 // (https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html#instance-protection) 92 // in the AWS Auto Scaling User Guide. When managed termination protection is 93 // disabled, your Amazon EC2 instances are not protected from termination when the 94 // Auto Scaling group scales in. 95 ManagedTerminationProtection ManagedTerminationProtection 96} 97 98// The details of the Auto Scaling group capacity provider to update. 99type AutoScalingGroupProviderUpdate struct { 100 101 // The managed scaling settings for the Auto Scaling group capacity provider. When 102 // managed scaling is enabled, Amazon ECS manages the scale-in and scale-out 103 // actions of the Auto Scaling group. Amazon ECS manages a target tracking scaling 104 // policy using an Amazon ECS-managed CloudWatch metric with the specified 105 // targetCapacity value as the target value for the metric. For more information, 106 // see Using Managed Scaling 107 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/asg-capacity-providers.html#asg-capacity-providers-managed-scaling) 108 // in the Amazon Elastic Container Service Developer Guide. If managed scaling is 109 // disabled, the user must manage the scaling of the Auto Scaling group. 110 ManagedScaling *ManagedScaling 111 112 // The managed termination protection setting to use for the Auto Scaling group 113 // capacity provider. This determines whether the Auto Scaling group has managed 114 // termination protection. When using managed termination protection, managed 115 // scaling must also be used otherwise managed termination protection will not 116 // work. When managed termination protection is enabled, Amazon ECS prevents the 117 // Amazon EC2 instances in an Auto Scaling group that contain tasks from being 118 // terminated during a scale-in action. The Auto Scaling group and each instance in 119 // the Auto Scaling group must have instance protection from scale-in actions 120 // enabled as well. For more information, see Instance Protection 121 // (https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html#instance-protection) 122 // in the AWS Auto Scaling User Guide. When managed termination protection is 123 // disabled, your Amazon EC2 instances are not protected from termination when the 124 // Auto Scaling group scales in. 125 ManagedTerminationProtection ManagedTerminationProtection 126} 127 128// An object representing the networking details for a task or service. 129type AwsVpcConfiguration struct { 130 131 // The IDs of the subnets associated with the task or service. There is a limit of 132 // 16 subnets that can be specified per AwsVpcConfiguration. All specified subnets 133 // must be from the same VPC. 134 // 135 // This member is required. 136 Subnets []string 137 138 // Whether the task's elastic network interface receives a public IP address. The 139 // default value is DISABLED. 140 AssignPublicIp AssignPublicIp 141 142 // The IDs of the security groups associated with the task or service. If you do 143 // not specify a security group, the default security group for the VPC is used. 144 // There is a limit of 5 security groups that can be specified per 145 // AwsVpcConfiguration. All specified security groups must be from the same VPC. 146 SecurityGroups []string 147} 148 149// The details of a capacity provider. 150type CapacityProvider struct { 151 152 // The Auto Scaling group settings for the capacity provider. 153 AutoScalingGroupProvider *AutoScalingGroupProvider 154 155 // The Amazon Resource Name (ARN) that identifies the capacity provider. 156 CapacityProviderArn *string 157 158 // The name of the capacity provider. 159 Name *string 160 161 // The current status of the capacity provider. Only capacity providers in an 162 // ACTIVE state can be used in a cluster. When a capacity provider is successfully 163 // deleted, it will have an INACTIVE status. 164 Status CapacityProviderStatus 165 166 // The metadata that you apply to the capacity provider to help you categorize and 167 // organize it. Each tag consists of a key and an optional value, both of which you 168 // define. The following basic restrictions apply to tags: 169 // 170 // * Maximum number of 171 // tags per resource - 50 172 // 173 // * For each resource, each tag key must be unique, and 174 // each tag key can have only one value. 175 // 176 // * Maximum key length - 128 Unicode 177 // characters in UTF-8 178 // 179 // * Maximum value length - 256 Unicode characters in UTF-8 180 // 181 // * 182 // If your tagging schema is used across multiple services and resources, remember 183 // that other services may have restrictions on allowed characters. Generally 184 // allowed characters are: letters, numbers, and spaces representable in UTF-8, and 185 // the following characters: + - = . _ : / @. 186 // 187 // * Tag keys and values are 188 // case-sensitive. 189 // 190 // * Do not use aws:, AWS:, or any upper or lowercase combination 191 // of such as a prefix for either keys or values as it is reserved for AWS use. You 192 // cannot edit or delete tag keys or values with this prefix. Tags with this prefix 193 // do not count against your tags per resource limit. 194 Tags []Tag 195 196 // The update status of the capacity provider. The following are the possible 197 // states that will be returned. DELETE_IN_PROGRESS The capacity provider is in the 198 // process of being deleted. DELETE_COMPLETE The capacity provider has been 199 // successfully deleted and will have an INACTIVE status. DELETE_FAILED The 200 // capacity provider was unable to be deleted. The update status reason will 201 // provide further details about why the delete failed. 202 UpdateStatus CapacityProviderUpdateStatus 203 204 // The update status reason. This provides further details about the update status 205 // for the capacity provider. 206 UpdateStatusReason *string 207} 208 209// The details of a capacity provider strategy. 210type CapacityProviderStrategyItem struct { 211 212 // The short name of the capacity provider. 213 // 214 // This member is required. 215 CapacityProvider *string 216 217 // The base value designates how many tasks, at a minimum, to run on the specified 218 // capacity provider. Only one capacity provider in a capacity provider strategy 219 // can have a base defined. 220 Base int32 221 222 // The weight value designates the relative percentage of the total number of tasks 223 // launched that should use the specified capacity provider. For example, if you 224 // have a strategy that contains two capacity providers and both have a weight of 225 // 1, then when the base is satisfied, the tasks will be split evenly across the 226 // two capacity providers. Using that same logic, if you specify a weight of 1 for 227 // capacityProviderA and a weight of 4 for capacityProviderB, then for every one 228 // task that is run using capacityProviderA, four tasks would use 229 // capacityProviderB. 230 Weight int32 231} 232 233// A regional grouping of one or more container instances on which you can run task 234// requests. Each account receives a default cluster the first time you use the 235// Amazon ECS service, but you may also create other clusters. Clusters may contain 236// more than one instance type simultaneously. 237type Cluster struct { 238 239 // The number of services that are running on the cluster in an ACTIVE state. You 240 // can view these services with ListServices. 241 ActiveServicesCount int32 242 243 // The resources attached to a cluster. When using a capacity provider with a 244 // cluster, the Auto Scaling plan that is created will be returned as a cluster 245 // attachment. 246 Attachments []Attachment 247 248 // The status of the capacity providers associated with the cluster. The following 249 // are the states that will be returned: UPDATE_IN_PROGRESS The available capacity 250 // providers for the cluster are updating. This occurs when the Auto Scaling plan 251 // is provisioning or deprovisioning. UPDATE_COMPLETE The capacity providers have 252 // successfully updated. UPDATE_FAILED The capacity provider updates failed. 253 AttachmentsStatus *string 254 255 // The capacity providers associated with the cluster. 256 CapacityProviders []string 257 258 // The Amazon Resource Name (ARN) that identifies the cluster. The ARN contains the 259 // arn:aws:ecs namespace, followed by the Region of the cluster, the AWS account ID 260 // of the cluster owner, the cluster namespace, and then the cluster name. For 261 // example, arn:aws:ecs:region:012345678910:cluster/test. 262 ClusterArn *string 263 264 // A user-generated string that you use to identify your cluster. 265 ClusterName *string 266 267 // The default capacity provider strategy for the cluster. When services or tasks 268 // are run in the cluster with no launch type or capacity provider strategy 269 // specified, the default capacity provider strategy is used. 270 DefaultCapacityProviderStrategy []CapacityProviderStrategyItem 271 272 // The number of tasks in the cluster that are in the PENDING state. 273 PendingTasksCount int32 274 275 // The number of container instances registered into the cluster. This includes 276 // container instances in both ACTIVE and DRAINING status. 277 RegisteredContainerInstancesCount int32 278 279 // The number of tasks in the cluster that are in the RUNNING state. 280 RunningTasksCount int32 281 282 // The settings for the cluster. This parameter indicates whether CloudWatch 283 // Container Insights is enabled or disabled for a cluster. 284 Settings []ClusterSetting 285 286 // Additional information about your clusters that are separated by launch type, 287 // including: 288 // 289 // * runningEC2TasksCount 290 // 291 // * RunningFargateTasksCount 292 // 293 // * 294 // pendingEC2TasksCount 295 // 296 // * pendingFargateTasksCount 297 // 298 // * activeEC2ServiceCount 299 // 300 // * 301 // activeFargateServiceCount 302 // 303 // * drainingEC2ServiceCount 304 // 305 // * 306 // drainingFargateServiceCount 307 Statistics []KeyValuePair 308 309 // The status of the cluster. The following are the possible states that will be 310 // returned. ACTIVE The cluster is ready to accept tasks and if applicable you can 311 // register container instances with the cluster. PROVISIONING The cluster has 312 // capacity providers associated with it and the resources needed for the capacity 313 // provider are being created. DEPROVISIONING The cluster has capacity providers 314 // associated with it and the resources needed for the capacity provider are being 315 // deleted. FAILED The cluster has capacity providers associated with it and the 316 // resources needed for the capacity provider have failed to create. INACTIVE The 317 // cluster has been deleted. Clusters with an INACTIVE status may remain 318 // discoverable in your account for a period of time. However, this behavior is 319 // subject to change in the future, so you should not rely on INACTIVE clusters 320 // persisting. 321 Status *string 322 323 // The metadata that you apply to the cluster to help you categorize and organize 324 // them. Each tag consists of a key and an optional value, both of which you 325 // define. The following basic restrictions apply to tags: 326 // 327 // * Maximum number of 328 // tags per resource - 50 329 // 330 // * For each resource, each tag key must be unique, and 331 // each tag key can have only one value. 332 // 333 // * Maximum key length - 128 Unicode 334 // characters in UTF-8 335 // 336 // * Maximum value length - 256 Unicode characters in UTF-8 337 // 338 // * 339 // If your tagging schema is used across multiple services and resources, remember 340 // that other services may have restrictions on allowed characters. Generally 341 // allowed characters are: letters, numbers, and spaces representable in UTF-8, and 342 // the following characters: + - = . _ : / @. 343 // 344 // * Tag keys and values are 345 // case-sensitive. 346 // 347 // * Do not use aws:, AWS:, or any upper or lowercase combination 348 // of such as a prefix for either keys or values as it is reserved for AWS use. You 349 // cannot edit or delete tag keys or values with this prefix. Tags with this prefix 350 // do not count against your tags per resource limit. 351 Tags []Tag 352} 353 354// The settings to use when creating a cluster. This parameter is used to enable 355// CloudWatch Container Insights for a cluster. 356type ClusterSetting struct { 357 358 // The name of the cluster setting. The only supported value is containerInsights. 359 Name ClusterSettingName 360 361 // The value to set for the cluster setting. The supported values are enabled and 362 // disabled. If enabled is specified, CloudWatch Container Insights will be enabled 363 // for the cluster, otherwise it will be disabled unless the containerInsights 364 // account setting is enabled. If a cluster value is specified, it will override 365 // the containerInsights value set with PutAccountSetting or 366 // PutAccountSettingDefault. 367 Value *string 368} 369 370// A Docker container that is part of a task. 371type Container struct { 372 373 // The Amazon Resource Name (ARN) of the container. 374 ContainerArn *string 375 376 // The number of CPU units set for the container. The value will be 0 if no value 377 // was specified in the container definition when the task definition was 378 // registered. 379 Cpu *string 380 381 // The exit code returned from the container. 382 ExitCode *int32 383 384 // The IDs of each GPU assigned to the container. 385 GpuIds []string 386 387 // The health status of the container. If health checks are not configured for this 388 // container in its task definition, then it reports the health status as UNKNOWN. 389 HealthStatus HealthStatus 390 391 // The image used for the container. 392 Image *string 393 394 // The container image manifest digest. The imageDigest is only returned if the 395 // container is using an image hosted in Amazon ECR, otherwise it is omitted. 396 ImageDigest *string 397 398 // The last known status of the container. 399 LastStatus *string 400 401 // The hard limit (in MiB) of memory set for the container. 402 Memory *string 403 404 // The soft limit (in MiB) of memory set for the container. 405 MemoryReservation *string 406 407 // The name of the container. 408 Name *string 409 410 // The network bindings associated with the container. 411 NetworkBindings []NetworkBinding 412 413 // The network interfaces associated with the container. 414 NetworkInterfaces []NetworkInterface 415 416 // A short (255 max characters) human-readable string to provide additional details 417 // about a running or stopped container. 418 Reason *string 419 420 // The ID of the Docker container. 421 RuntimeId *string 422 423 // The ARN of the task. 424 TaskArn *string 425} 426 427// Container definitions are used in task definitions to describe the different 428// containers that are launched as part of a task. 429type ContainerDefinition struct { 430 431 // The command that is passed to the container. This parameter maps to Cmd in the 432 // Create a container 433 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 434 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 435 // COMMAND parameter to docker run 436 // (https://docs.docker.com/engine/reference/run/#security-configuration). For more 437 // information, see https://docs.docker.com/engine/reference/builder/#cmd 438 // (https://docs.docker.com/engine/reference/builder/#cmd). If there are multiple 439 // arguments, each argument should be a separated string in the array. 440 Command []string 441 442 // The number of cpu units reserved for the container. This parameter maps to 443 // CpuShares in the Create a container 444 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 445 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 446 // --cpu-shares option to docker run 447 // (https://docs.docker.com/engine/reference/run/#security-configuration). This 448 // field is optional for tasks using the Fargate launch type, and the only 449 // requirement is that the total amount of CPU reserved for all containers within a 450 // task be lower than the task-level cpu value. You can determine the number of CPU 451 // units that are available per EC2 instance type by multiplying the vCPUs listed 452 // for that instance type on the Amazon EC2 Instances 453 // (http://aws.amazon.com/ec2/instance-types/) detail page by 1,024. Linux 454 // containers share unallocated CPU units with other containers on the container 455 // instance with the same ratio as their allocated amount. For example, if you run 456 // a single-container task on a single-core instance type with 512 CPU units 457 // specified for that container, and that is the only task running on the container 458 // instance, that container could use the full 1,024 CPU unit share at any given 459 // time. However, if you launched another copy of the same task on that container 460 // instance, each task would be guaranteed a minimum of 512 CPU units when needed, 461 // and each container could float to higher CPU usage if the other container was 462 // not using it, but if both tasks were 100% active all of the time, they would be 463 // limited to 512 CPU units. On Linux container instances, the Docker daemon on the 464 // container instance uses the CPU value to calculate the relative CPU share ratios 465 // for running containers. For more information, see CPU share constraint 466 // (https://docs.docker.com/engine/reference/run/#cpu-share-constraint) in the 467 // Docker documentation. The minimum valid CPU share value that the Linux kernel 468 // allows is 2. However, the CPU parameter is not required, and you can use CPU 469 // values below 2 in your container definitions. For CPU values below 2 (including 470 // null), the behavior varies based on your Amazon ECS container agent version: 471 // 472 // * 473 // Agent versions less than or equal to 1.1.0: Null and zero CPU values are passed 474 // to Docker as 0, which Docker then converts to 1,024 CPU shares. CPU values of 1 475 // are passed to Docker as 1, which the Linux kernel converts to two CPU shares. 476 // 477 // * 478 // Agent versions greater than or equal to 1.2.0: Null, zero, and CPU values of 1 479 // are passed to Docker as 2. 480 // 481 // On Windows container instances, the CPU limit is 482 // enforced as an absolute limit, or a quota. Windows containers only have access 483 // to the specified amount of CPU that is described in the task definition. A null 484 // or zero CPU value is passed to Docker as 0, which Windows interprets as 1% of 485 // one CPU. 486 Cpu int32 487 488 // The dependencies defined for container startup and shutdown. A container can 489 // contain multiple dependencies. When a dependency is defined for container 490 // startup, for container shutdown it is reversed. For tasks using the EC2 launch 491 // type, the container instances require at least version 1.26.0 of the container 492 // agent to enable container dependencies. However, we recommend using the latest 493 // container agent version. For information about checking your agent version and 494 // updating to the latest version, see Updating the Amazon ECS Container Agent 495 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) 496 // in the Amazon Elastic Container Service Developer Guide. If you are using an 497 // Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of 498 // the ecs-init package. If your container instances are launched from version 499 // 20190301 or later, then they contain the required versions of the container 500 // agent and ecs-init. For more information, see Amazon ECS-optimized Linux AMI 501 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) 502 // in the Amazon Elastic Container Service Developer Guide. For tasks using the 503 // Fargate launch type, the task or service requires platform version 1.3.0 or 504 // later. 505 DependsOn []ContainerDependency 506 507 // When this parameter is true, networking is disabled within the container. This 508 // parameter maps to NetworkDisabled in the Create a container 509 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 510 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/). This 511 // parameter is not supported for Windows containers or tasks that use the awsvpc 512 // network mode. 513 DisableNetworking *bool 514 515 // A list of DNS search domains that are presented to the container. This parameter 516 // maps to DnsSearch in the Create a container 517 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 518 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 519 // --dns-search option to docker run 520 // (https://docs.docker.com/engine/reference/run/#security-configuration). This 521 // parameter is not supported for Windows containers or tasks that use the awsvpc 522 // network mode. 523 DnsSearchDomains []string 524 525 // A list of DNS servers that are presented to the container. This parameter maps 526 // to Dns in the Create a container 527 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 528 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --dns 529 // option to docker run 530 // (https://docs.docker.com/engine/reference/run/#security-configuration). This 531 // parameter is not supported for Windows containers or tasks that use the awsvpc 532 // network mode. 533 DnsServers []string 534 535 // A key/value map of labels to add to the container. This parameter maps to Labels 536 // in the Create a container 537 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 538 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 539 // --label option to docker run 540 // (https://docs.docker.com/engine/reference/run/#security-configuration). This 541 // parameter requires version 1.18 of the Docker Remote API or greater on your 542 // container instance. To check the Docker Remote API version on your container 543 // instance, log in to your container instance and run the following command: sudo 544 // docker version --format '{{.Server.APIVersion}}' 545 DockerLabels map[string]string 546 547 // A list of strings to provide custom labels for SELinux and AppArmor multi-level 548 // security systems. This field is not valid for containers in tasks using the 549 // Fargate launch type. With Windows containers, this parameter can be used to 550 // reference a credential spec file when configuring a container for Active 551 // Directory authentication. For more information, see Using gMSAs for Windows 552 // Containers 553 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html) 554 // in the Amazon Elastic Container Service Developer Guide. This parameter maps to 555 // SecurityOpt in the Create a container 556 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 557 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 558 // --security-opt option to docker run 559 // (https://docs.docker.com/engine/reference/run/#security-configuration). The 560 // Amazon ECS container agent running on a container instance must register with 561 // the ECS_SELINUX_CAPABLE=true or ECS_APPARMOR_CAPABLE=true environment variables 562 // before containers placed on that instance can use these security options. For 563 // more information, see Amazon ECS Container Agent Configuration 564 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) 565 // in the Amazon Elastic Container Service Developer Guide. For more information 566 // about valid values, see Docker Run Security Configuration 567 // (https://docs.docker.com/engine/reference/run/#security-configuration). Valid 568 // values: "no-new-privileges" | "apparmor:PROFILE" | "label:value" | 569 // "credentialspec:CredentialSpecFilePath" 570 DockerSecurityOptions []string 571 572 // Early versions of the Amazon ECS container agent do not properly handle 573 // entryPoint parameters. If you have problems using entryPoint, update your 574 // container agent or enter your commands and arguments as command array items 575 // instead. The entry point that is passed to the container. This parameter maps to 576 // Entrypoint in the Create a container 577 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 578 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 579 // --entrypoint option to docker run 580 // (https://docs.docker.com/engine/reference/run/#security-configuration). For more 581 // information, see https://docs.docker.com/engine/reference/builder/#entrypoint 582 // (https://docs.docker.com/engine/reference/builder/#entrypoint). 583 EntryPoint []string 584 585 // The environment variables to pass to a container. This parameter maps to Env in 586 // the Create a container 587 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 588 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --env 589 // option to docker run 590 // (https://docs.docker.com/engine/reference/run/#security-configuration). We do 591 // not recommend using plaintext environment variables for sensitive information, 592 // such as credential data. 593 Environment []KeyValuePair 594 595 // A list of files containing the environment variables to pass to a container. 596 // This parameter maps to the --env-file option to docker run 597 // (https://docs.docker.com/engine/reference/run/#security-configuration). You can 598 // specify up to ten environment files. The file must have a .env file extension. 599 // Each line in an environment file should contain an environment variable in 600 // VARIABLE=VALUE format. Lines beginning with # are treated as comments and are 601 // ignored. For more information on the environment variable file syntax, see 602 // Declare default environment variables in file 603 // (https://docs.docker.com/compose/env-file/). If there are environment variables 604 // specified using the environment parameter in a container definition, they take 605 // precedence over the variables contained within an environment file. If multiple 606 // environment files are specified that contain the same variable, they are 607 // processed from the top down. It is recommended to use unique variable names. For 608 // more information, see Specifying Environment Variables 609 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/taskdef-envfiles.html) 610 // in the Amazon Elastic Container Service Developer Guide. This field is not valid 611 // for containers in tasks using the Fargate launch type. 612 EnvironmentFiles []EnvironmentFile 613 614 // If the essential parameter of a container is marked as true, and that container 615 // fails or stops for any reason, all other containers that are part of the task 616 // are stopped. If the essential parameter of a container is marked as false, then 617 // its failure does not affect the rest of the containers in a task. If this 618 // parameter is omitted, a container is assumed to be essential. All tasks must 619 // have at least one essential container. If you have an application that is 620 // composed of multiple containers, you should group containers that are used for a 621 // common purpose into components, and separate the different components into 622 // multiple task definitions. For more information, see Application Architecture 623 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html) 624 // in the Amazon Elastic Container Service Developer Guide. 625 Essential *bool 626 627 // A list of hostnames and IP address mappings to append to the /etc/hosts file on 628 // the container. This parameter maps to ExtraHosts in the Create a container 629 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 630 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 631 // --add-host option to docker run 632 // (https://docs.docker.com/engine/reference/run/#security-configuration). This 633 // parameter is not supported for Windows containers or tasks that use the awsvpc 634 // network mode. 635 ExtraHosts []HostEntry 636 637 // The FireLens configuration for the container. This is used to specify and 638 // configure a log router for container logs. For more information, see Custom Log 639 // Routing 640 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) 641 // in the Amazon Elastic Container Service Developer Guide. 642 FirelensConfiguration *FirelensConfiguration 643 644 // The container health check command and associated configuration parameters for 645 // the container. This parameter maps to HealthCheck in the Create a container 646 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 647 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 648 // HEALTHCHECK parameter of docker run 649 // (https://docs.docker.com/engine/reference/run/#security-configuration). 650 HealthCheck *HealthCheck 651 652 // The hostname to use for your container. This parameter maps to Hostname in the 653 // Create a container 654 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 655 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 656 // --hostname option to docker run 657 // (https://docs.docker.com/engine/reference/run/#security-configuration). The 658 // hostname parameter is not supported if you are using the awsvpc network mode. 659 Hostname *string 660 661 // The image used to start a container. This string is passed directly to the 662 // Docker daemon. Images in the Docker Hub registry are available by default. Other 663 // repositories are specified with either repository-url/image:tag or 664 // repository-url/image@digest . Up to 255 letters (uppercase and lowercase), 665 // numbers, hyphens, underscores, colons, periods, forward slashes, and number 666 // signs are allowed. This parameter maps to Image in the Create a container 667 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 668 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the IMAGE 669 // parameter of docker run 670 // (https://docs.docker.com/engine/reference/run/#security-configuration). 671 // 672 // * When 673 // a new task starts, the Amazon ECS container agent pulls the latest version of 674 // the specified image and tag for the container to use. However, subsequent 675 // updates to a repository image are not propagated to already running tasks. 676 // 677 // * 678 // Images in Amazon ECR repositories can be specified by either using the full 679 // registry/repository:tag or registry/repository@digest. For example, 680 // 012345678910.dkr.ecr..amazonaws.com/:latest or 681 // 012345678910.dkr.ecr..amazonaws.com/@sha256:94afd1f2e64d908bc90dbca0035a5b567EXAMPLE. 682 // 683 // * 684 // Images in official repositories on Docker Hub use a single name (for example, 685 // ubuntu or mongo). 686 // 687 // * Images in other repositories on Docker Hub are qualified 688 // with an organization name (for example, amazon/amazon-ecs-agent). 689 // 690 // * Images in 691 // other online repositories are qualified further by a domain name (for example, 692 // quay.io/assemblyline/ubuntu). 693 Image *string 694 695 // When this parameter is true, this allows you to deploy containerized 696 // applications that require stdin or a tty to be allocated. This parameter maps to 697 // OpenStdin in the Create a container 698 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 699 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 700 // --interactive option to docker run 701 // (https://docs.docker.com/engine/reference/run/#security-configuration). 702 Interactive *bool 703 704 // The links parameter allows containers to communicate with each other without the 705 // need for port mappings. This parameter is only supported if the network mode of 706 // a task definition is bridge. The name:internalName construct is analogous to 707 // name:alias in Docker links. Up to 255 letters (uppercase and lowercase), 708 // numbers, and hyphens are allowed. For more information about linking Docker 709 // containers, go to Legacy container links 710 // (https://docs.docker.com/network/links/) in the Docker documentation. This 711 // parameter maps to Links in the Create a container 712 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 713 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --link 714 // option to docker run 715 // (https://docs.docker.com/engine/reference/run/#security-configuration). This 716 // parameter is not supported for Windows containers or tasks that use the awsvpc 717 // network mode. Containers that are collocated on a single container instance may 718 // be able to communicate with each other without requiring links or host port 719 // mappings. Network isolation is achieved on the container instance using security 720 // groups and VPC settings. 721 Links []string 722 723 // Linux-specific modifications that are applied to the container, such as Linux 724 // kernel capabilities. For more information see KernelCapabilities. This parameter 725 // is not supported for Windows containers. 726 LinuxParameters *LinuxParameters 727 728 // The log configuration specification for the container. This parameter maps to 729 // LogConfig in the Create a container 730 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 731 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 732 // --log-driver option to docker run 733 // (https://docs.docker.com/engine/reference/run/#security-configuration). By 734 // default, containers use the same logging driver that the Docker daemon uses. 735 // However the container may use a different logging driver than the Docker daemon 736 // by specifying a log driver with this parameter in the container definition. To 737 // use a different logging driver for a container, the log system must be 738 // configured properly on the container instance (or on a different log server for 739 // remote logging options). For more information on the options for different 740 // supported log drivers, see Configure logging drivers 741 // (https://docs.docker.com/engine/admin/logging/overview/) in the Docker 742 // documentation. Amazon ECS currently supports a subset of the logging drivers 743 // available to the Docker daemon (shown in the LogConfiguration data type). 744 // Additional log drivers may be available in future releases of the Amazon ECS 745 // container agent. This parameter requires version 1.18 of the Docker Remote API 746 // or greater on your container instance. To check the Docker Remote API version on 747 // your container instance, log in to your container instance and run the following 748 // command: sudo docker version --format '{{.Server.APIVersion}}' The Amazon ECS 749 // container agent running on a container instance must register the logging 750 // drivers available on that instance with the ECS_AVAILABLE_LOGGING_DRIVERS 751 // environment variable before containers placed on that instance can use these log 752 // configuration options. For more information, see Amazon ECS Container Agent 753 // Configuration 754 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) 755 // in the Amazon Elastic Container Service Developer Guide. 756 LogConfiguration *LogConfiguration 757 758 // The amount (in MiB) of memory to present to the container. If your container 759 // attempts to exceed the memory specified here, the container is killed. The total 760 // amount of memory reserved for all containers within a task must be lower than 761 // the task memory value, if one is specified. This parameter maps to Memory in the 762 // Create a container 763 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 764 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 765 // --memory option to docker run 766 // (https://docs.docker.com/engine/reference/run/#security-configuration). If using 767 // the Fargate launch type, this parameter is optional. If using the EC2 launch 768 // type, you must specify either a task-level memory value or a container-level 769 // memory value. If you specify both a container-level memory and memoryReservation 770 // value, memory must be greater than memoryReservation. If you specify 771 // memoryReservation, then that value is subtracted from the available memory 772 // resources for the container instance on which the container is placed. 773 // Otherwise, the value of memory is used. The Docker daemon reserves a minimum of 774 // 4 MiB of memory for a container, so you should not specify fewer than 4 MiB of 775 // memory for your containers. 776 Memory *int32 777 778 // The soft limit (in MiB) of memory to reserve for the container. When system 779 // memory is under heavy contention, Docker attempts to keep the container memory 780 // to this soft limit. However, your container can consume more memory when it 781 // needs to, up to either the hard limit specified with the memory parameter (if 782 // applicable), or all of the available memory on the container instance, whichever 783 // comes first. This parameter maps to MemoryReservation in the Create a container 784 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 785 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 786 // --memory-reservation option to docker run 787 // (https://docs.docker.com/engine/reference/run/#security-configuration). If a 788 // task-level memory value is not specified, you must specify a non-zero integer 789 // for one or both of memory or memoryReservation in a container definition. If you 790 // specify both, memory must be greater than memoryReservation. If you specify 791 // memoryReservation, then that value is subtracted from the available memory 792 // resources for the container instance on which the container is placed. 793 // Otherwise, the value of memory is used. For example, if your container normally 794 // uses 128 MiB of memory, but occasionally bursts to 256 MiB of memory for short 795 // periods of time, you can set a memoryReservation of 128 MiB, and a memory hard 796 // limit of 300 MiB. This configuration would allow the container to only reserve 797 // 128 MiB of memory from the remaining resources on the container instance, but 798 // also allow the container to consume more memory resources when needed. The 799 // Docker daemon reserves a minimum of 4 MiB of memory for a container, so you 800 // should not specify fewer than 4 MiB of memory for your containers. 801 MemoryReservation *int32 802 803 // The mount points for data volumes in your container. This parameter maps to 804 // Volumes in the Create a container 805 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 806 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 807 // --volume option to docker run 808 // (https://docs.docker.com/engine/reference/run/#security-configuration). Windows 809 // containers can mount whole directories on the same drive as $env:ProgramData. 810 // Windows containers cannot mount directories on a different drive, and mount 811 // point cannot be across drives. 812 MountPoints []MountPoint 813 814 // The name of a container. If you are linking multiple containers together in a 815 // task definition, the name of one container can be entered in the links of 816 // another container to connect the containers. Up to 255 letters (uppercase and 817 // lowercase), numbers, and hyphens are allowed. This parameter maps to name in the 818 // Create a container 819 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 820 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --name 821 // option to docker run 822 // (https://docs.docker.com/engine/reference/run/#security-configuration). 823 Name *string 824 825 // The list of port mappings for the container. Port mappings allow containers to 826 // access ports on the host container instance to send or receive traffic. For task 827 // definitions that use the awsvpc network mode, you should only specify the 828 // containerPort. The hostPort can be left blank or it must be the same value as 829 // the containerPort. Port mappings on Windows use the NetNAT gateway address 830 // rather than localhost. There is no loopback for port mappings on Windows, so you 831 // cannot access a container's mapped port from the host itself. This parameter 832 // maps to PortBindings in the Create a container 833 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 834 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 835 // --publish option to docker run 836 // (https://docs.docker.com/engine/reference/run/#security-configuration). If the 837 // network mode of a task definition is set to none, then you can't specify port 838 // mappings. If the network mode of a task definition is set to host, then host 839 // ports must either be undefined or they must match the container port in the port 840 // mapping. After a task reaches the RUNNING status, manual and automatic host and 841 // container port assignments are visible in the Network Bindings section of a 842 // container description for a selected task in the Amazon ECS console. The 843 // assignments are also visible in the networkBindings section DescribeTasks 844 // responses. 845 PortMappings []PortMapping 846 847 // When this parameter is true, the container is given elevated privileges on the 848 // host container instance (similar to the root user). This parameter maps to 849 // Privileged in the Create a container 850 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 851 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 852 // --privileged option to docker run 853 // (https://docs.docker.com/engine/reference/run/#security-configuration). This 854 // parameter is not supported for Windows containers or tasks using the Fargate 855 // launch type. 856 Privileged *bool 857 858 // When this parameter is true, a TTY is allocated. This parameter maps to Tty in 859 // the Create a container 860 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 861 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --tty 862 // option to docker run 863 // (https://docs.docker.com/engine/reference/run/#security-configuration). 864 PseudoTerminal *bool 865 866 // When this parameter is true, the container is given read-only access to its root 867 // file system. This parameter maps to ReadonlyRootfs in the Create a container 868 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 869 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 870 // --read-only option to docker run 871 // (https://docs.docker.com/engine/reference/run/#security-configuration). This 872 // parameter is not supported for Windows containers or tasks that use the awsvpc 873 // network mode. 874 ReadonlyRootFilesystem *bool 875 876 // The private repository authentication credentials to use. 877 RepositoryCredentials *RepositoryCredentials 878 879 // The type and amount of a resource to assign to a container. The only supported 880 // resource is a GPU. 881 ResourceRequirements []ResourceRequirement 882 883 // The secrets to pass to the container. For more information, see Specifying 884 // Sensitive Data 885 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) 886 // in the Amazon Elastic Container Service Developer Guide. 887 Secrets []Secret 888 889 // Time duration (in seconds) to wait before giving up on resolving dependencies 890 // for a container. For example, you specify two containers in a task definition 891 // with containerA having a dependency on containerB reaching a COMPLETE, SUCCESS, 892 // or HEALTHY status. If a startTimeout value is specified for containerB and it 893 // does not reach the desired status within that time then containerA will give up 894 // and not start. This results in the task transitioning to a STOPPED state. When 895 // the ECS_CONTAINER_START_TIMEOUT container agent configuration variable is used, 896 // it is enforced indendently from this start timeout value. For tasks using the 897 // Fargate launch type, this parameter requires that the task or service uses 898 // platform version 1.3.0 or later. For tasks using the EC2 launch type, your 899 // container instances require at least version 1.26.0 of the container agent to 900 // enable a container start timeout value. However, we recommend using the latest 901 // container agent version. For information about checking your agent version and 902 // updating to the latest version, see Updating the Amazon ECS Container Agent 903 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) 904 // in the Amazon Elastic Container Service Developer Guide. If you are using an 905 // Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of 906 // the ecs-init package. If your container instances are launched from version 907 // 20190301 or later, then they contain the required versions of the container 908 // agent and ecs-init. For more information, see Amazon ECS-optimized Linux AMI 909 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) 910 // in the Amazon Elastic Container Service Developer Guide. 911 StartTimeout *int32 912 913 // Time duration (in seconds) to wait before the container is forcefully killed if 914 // it doesn't exit normally on its own. For tasks using the Fargate launch type, 915 // the task or service requires platform version 1.3.0 or later. The max stop 916 // timeout value is 120 seconds and if the parameter is not specified, the default 917 // value of 30 seconds is used. For tasks using the EC2 launch type, if the 918 // stopTimeout parameter is not specified, the value set for the Amazon ECS 919 // container agent configuration variable ECS_CONTAINER_STOP_TIMEOUT is used by 920 // default. If neither the stopTimeout parameter or the ECS_CONTAINER_STOP_TIMEOUT 921 // agent configuration variable are set, then the default values of 30 seconds for 922 // Linux containers and 30 seconds on Windows containers are used. Your container 923 // instances require at least version 1.26.0 of the container agent to enable a 924 // container stop timeout value. However, we recommend using the latest container 925 // agent version. For information about checking your agent version and updating to 926 // the latest version, see Updating the Amazon ECS Container Agent 927 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) 928 // in the Amazon Elastic Container Service Developer Guide. If you are using an 929 // Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of 930 // the ecs-init package. If your container instances are launched from version 931 // 20190301 or later, then they contain the required versions of the container 932 // agent and ecs-init. For more information, see Amazon ECS-optimized Linux AMI 933 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) 934 // in the Amazon Elastic Container Service Developer Guide. 935 StopTimeout *int32 936 937 // A list of namespaced kernel parameters to set in the container. This parameter 938 // maps to Sysctls in the Create a container 939 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 940 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 941 // --sysctl option to docker run 942 // (https://docs.docker.com/engine/reference/run/#security-configuration). It is 943 // not recommended that you specify network-related systemControls parameters for 944 // multiple containers in a single task that also uses either the awsvpc or host 945 // network modes. For tasks that use the awsvpc network mode, the container that is 946 // started last determines which systemControls parameters take effect. For tasks 947 // that use the host network mode, it changes the container instance's namespaced 948 // kernel parameters as well as the containers. 949 SystemControls []SystemControl 950 951 // A list of ulimits to set in the container. If a ulimit value is specified in a 952 // task definition, it will override the default values set by Docker. This 953 // parameter maps to Ulimits in the Create a container 954 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 955 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 956 // --ulimit option to docker run 957 // (https://docs.docker.com/engine/reference/run/#security-configuration). Valid 958 // naming values are displayed in the Ulimit data type. This parameter requires 959 // version 1.18 of the Docker Remote API or greater on your container instance. To 960 // check the Docker Remote API version on your container instance, log in to your 961 // container instance and run the following command: sudo docker version --format 962 // '{{.Server.APIVersion}}' This parameter is not supported for Windows containers 963 // or tasks that use the awsvpc network mode. 964 Ulimits []Ulimit 965 966 // The user to use inside the container. This parameter maps to User in the Create 967 // a container 968 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 969 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --user 970 // option to docker run 971 // (https://docs.docker.com/engine/reference/run/#security-configuration). When 972 // running tasks using the host network mode, you should not run containers using 973 // the root user (UID 0). It is considered best practice to use a non-root user. 974 // You can specify the user using the following formats. If specifying a UID or 975 // GID, you must specify it as a positive integer. 976 // 977 // * user 978 // 979 // * user:group 980 // 981 // * uid 982 // 983 // * 984 // uid:gid 985 // 986 // * user:gid 987 // 988 // * uid:group 989 // 990 // This parameter is not supported for Windows 991 // containers or tasks that use the awsvpc network mode. 992 User *string 993 994 // Data volumes to mount from another container. This parameter maps to VolumesFrom 995 // in the Create a container 996 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 997 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 998 // --volumes-from option to docker run 999 // (https://docs.docker.com/engine/reference/run/#security-configuration). 1000 VolumesFrom []VolumeFrom 1001 1002 // The working directory in which to run commands inside the container. This 1003 // parameter maps to WorkingDir in the Create a container 1004 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 1005 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 1006 // --workdir option to docker run 1007 // (https://docs.docker.com/engine/reference/run/#security-configuration). 1008 WorkingDirectory *string 1009} 1010 1011// The dependencies defined for container startup and shutdown. A container can 1012// contain multiple dependencies. When a dependency is defined for container 1013// startup, for container shutdown it is reversed. Your Amazon ECS container 1014// instances require at least version 1.26.0 of the container agent to enable 1015// container dependencies. However, we recommend using the latest container agent 1016// version. For information about checking your agent version and updating to the 1017// latest version, see Updating the Amazon ECS Container Agent 1018// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) 1019// in the Amazon Elastic Container Service Developer Guide. If you are using an 1020// Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of 1021// the ecs-init package. If your container instances are launched from version 1022// 20190301 or later, then they contain the required versions of the container 1023// agent and ecs-init. For more information, see Amazon ECS-optimized Linux AMI 1024// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) 1025// in the Amazon Elastic Container Service Developer Guide. For tasks using the 1026// Fargate launch type, this parameter requires that the task or service uses 1027// platform version 1.3.0 or later. 1028type ContainerDependency struct { 1029 1030 // The dependency condition of the container. The following are the available 1031 // conditions and their behavior: 1032 // 1033 // * START - This condition emulates the behavior 1034 // of links and volumes today. It validates that a dependent container is started 1035 // before permitting other containers to start. 1036 // 1037 // * COMPLETE - This condition 1038 // validates that a dependent container runs to completion (exits) before 1039 // permitting other containers to start. This can be useful for nonessential 1040 // containers that run a script and then exit. This condition cannot be set on an 1041 // essential container. 1042 // 1043 // * SUCCESS - This condition is the same as COMPLETE, but it 1044 // also requires that the container exits with a zero status. This condition cannot 1045 // be set on an essential container. 1046 // 1047 // * HEALTHY - This condition validates that the 1048 // dependent container passes its Docker health check before permitting other 1049 // containers to start. This requires that the dependent container has health 1050 // checks configured. This condition is confirmed only at task startup. 1051 // 1052 // This member is required. 1053 Condition ContainerCondition 1054 1055 // The name of a container. 1056 // 1057 // This member is required. 1058 ContainerName *string 1059} 1060 1061// An EC2 instance that is running the Amazon ECS agent and has been registered 1062// with a cluster. 1063type ContainerInstance struct { 1064 1065 // This parameter returns true if the agent is connected to Amazon ECS. Registered 1066 // instances with an agent that may be unhealthy or stopped return false. Only 1067 // instances connected to an agent can accept placement requests. 1068 AgentConnected bool 1069 1070 // The status of the most recent agent update. If an update has never been 1071 // requested, this value is NULL. 1072 AgentUpdateStatus AgentUpdateStatus 1073 1074 // The resources attached to a container instance, such as elastic network 1075 // interfaces. 1076 Attachments []Attachment 1077 1078 // The attributes set for the container instance, either by the Amazon ECS 1079 // container agent at instance registration or manually with the PutAttributes 1080 // operation. 1081 Attributes []Attribute 1082 1083 // The capacity provider associated with the container instance. 1084 CapacityProviderName *string 1085 1086 // The Amazon Resource Name (ARN) of the container instance. The ARN contains the 1087 // arn:aws:ecs namespace, followed by the Region of the container instance, the AWS 1088 // account ID of the container instance owner, the container-instance namespace, 1089 // and then the container instance ID. For example, 1090 // arn:aws:ecs:region:aws_account_id:container-instance/container_instance_ID. 1091 ContainerInstanceArn *string 1092 1093 // The EC2 instance ID of the container instance. 1094 Ec2InstanceId *string 1095 1096 // The number of tasks on the container instance that are in the PENDING status. 1097 PendingTasksCount int32 1098 1099 // The Unix timestamp for when the container instance was registered. 1100 RegisteredAt *time.Time 1101 1102 // For CPU and memory resource types, this parameter describes the amount of each 1103 // resource that was available on the container instance when the container agent 1104 // registered it with Amazon ECS. This value represents the total amount of CPU and 1105 // memory that can be allocated on this container instance to tasks. For port 1106 // resource types, this parameter describes the ports that were reserved by the 1107 // Amazon ECS container agent when it registered the container instance with Amazon 1108 // ECS. 1109 RegisteredResources []Resource 1110 1111 // For CPU and memory resource types, this parameter describes the remaining CPU 1112 // and memory that has not already been allocated to tasks and is therefore 1113 // available for new tasks. For port resource types, this parameter describes the 1114 // ports that were reserved by the Amazon ECS container agent (at instance 1115 // registration time) and any task containers that have reserved port mappings on 1116 // the host (with the host or bridge network mode). Any port that is not specified 1117 // here is available for new tasks. 1118 RemainingResources []Resource 1119 1120 // The number of tasks on the container instance that are in the RUNNING status. 1121 RunningTasksCount int32 1122 1123 // The status of the container instance. The valid values are REGISTERING, 1124 // REGISTRATION_FAILED, ACTIVE, INACTIVE, DEREGISTERING, or DRAINING. If your 1125 // account has opted in to the awsvpcTrunking account setting, then any newly 1126 // registered container instance will transition to a REGISTERING status while the 1127 // trunk elastic network interface is provisioned for the instance. If the 1128 // registration fails, the instance will transition to a REGISTRATION_FAILED 1129 // status. You can describe the container instance and see the reason for failure 1130 // in the statusReason parameter. Once the container instance is terminated, the 1131 // instance transitions to a DEREGISTERING status while the trunk elastic network 1132 // interface is deprovisioned. The instance then transitions to an INACTIVE status. 1133 // The ACTIVE status indicates that the container instance can accept tasks. The 1134 // DRAINING indicates that new tasks are not placed on the container instance and 1135 // any service tasks running on the container instance are removed if possible. For 1136 // more information, see Container Instance Draining 1137 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-draining.html) 1138 // in the Amazon Elastic Container Service Developer Guide. 1139 Status *string 1140 1141 // The reason that the container instance reached its current status. 1142 StatusReason *string 1143 1144 // The metadata that you apply to the container instance to help you categorize and 1145 // organize them. Each tag consists of a key and an optional value, both of which 1146 // you define. The following basic restrictions apply to tags: 1147 // 1148 // * Maximum number of 1149 // tags per resource - 50 1150 // 1151 // * For each resource, each tag key must be unique, and 1152 // each tag key can have only one value. 1153 // 1154 // * Maximum key length - 128 Unicode 1155 // characters in UTF-8 1156 // 1157 // * Maximum value length - 256 Unicode characters in UTF-8 1158 // 1159 // * 1160 // If your tagging schema is used across multiple services and resources, remember 1161 // that other services may have restrictions on allowed characters. Generally 1162 // allowed characters are: letters, numbers, and spaces representable in UTF-8, and 1163 // the following characters: + - = . _ : / @. 1164 // 1165 // * Tag keys and values are 1166 // case-sensitive. 1167 // 1168 // * Do not use aws:, AWS:, or any upper or lowercase combination 1169 // of such as a prefix for either keys or values as it is reserved for AWS use. You 1170 // cannot edit or delete tag keys or values with this prefix. Tags with this prefix 1171 // do not count against your tags per resource limit. 1172 Tags []Tag 1173 1174 // The version counter for the container instance. Every time a container instance 1175 // experiences a change that triggers a CloudWatch event, the version counter is 1176 // incremented. If you are replicating your Amazon ECS container instance state 1177 // with CloudWatch Events, you can compare the version of a container instance 1178 // reported by the Amazon ECS APIs with the version reported in CloudWatch Events 1179 // for the container instance (inside the detail object) to verify that the version 1180 // in your event stream is current. 1181 Version int64 1182 1183 // The version information for the Amazon ECS container agent and Docker daemon 1184 // running on the container instance. 1185 VersionInfo *VersionInfo 1186} 1187 1188// The overrides that should be sent to a container. An empty container override 1189// can be passed in. An example of an empty container override would be 1190// {"containerOverrides": [ ] }. If a non-empty container override is specified, 1191// the name parameter must be included. 1192type ContainerOverride struct { 1193 1194 // The command to send to the container that overrides the default command from the 1195 // Docker image or the task definition. You must also specify a container name. 1196 Command []string 1197 1198 // The number of cpu units reserved for the container, instead of the default value 1199 // from the task definition. You must also specify a container name. 1200 Cpu *int32 1201 1202 // The environment variables to send to the container. You can add new environment 1203 // variables, which are added to the container at launch, or you can override the 1204 // existing environment variables from the Docker image or the task definition. You 1205 // must also specify a container name. 1206 Environment []KeyValuePair 1207 1208 // A list of files containing the environment variables to pass to a container, 1209 // instead of the value from the container definition. 1210 EnvironmentFiles []EnvironmentFile 1211 1212 // The hard limit (in MiB) of memory to present to the container, instead of the 1213 // default value from the task definition. If your container attempts to exceed the 1214 // memory specified here, the container is killed. You must also specify a 1215 // container name. 1216 Memory *int32 1217 1218 // The soft limit (in MiB) of memory to reserve for the container, instead of the 1219 // default value from the task definition. You must also specify a container name. 1220 MemoryReservation *int32 1221 1222 // The name of the container that receives the override. This parameter is required 1223 // if any override is specified. 1224 Name *string 1225 1226 // The type and amount of a resource to assign to a container, instead of the 1227 // default value from the task definition. The only supported resource is a GPU. 1228 ResourceRequirements []ResourceRequirement 1229} 1230 1231// An object representing a change in state for a container. 1232type ContainerStateChange struct { 1233 1234 // The name of the container. 1235 ContainerName *string 1236 1237 // The exit code for the container, if the state change is a result of the 1238 // container exiting. 1239 ExitCode *int32 1240 1241 // The container image SHA 256 digest. 1242 ImageDigest *string 1243 1244 // Any network bindings associated with the container. 1245 NetworkBindings []NetworkBinding 1246 1247 // The reason for the state change. 1248 Reason *string 1249 1250 // The ID of the Docker container. 1251 RuntimeId *string 1252 1253 // The status of the container. 1254 Status *string 1255} 1256 1257// The details of an Amazon ECS service deployment. This is used only when a 1258// service uses the ECS deployment controller type. 1259type Deployment struct { 1260 1261 // The capacity provider strategy that the deployment is using. 1262 CapacityProviderStrategy []CapacityProviderStrategyItem 1263 1264 // The Unix timestamp for when the service deployment was created. 1265 CreatedAt *time.Time 1266 1267 // The most recent desired count of tasks that was specified for the service to 1268 // deploy or maintain. 1269 DesiredCount int32 1270 1271 // The number of consecutively failed tasks in the deployment. A task is considered 1272 // a failure if the service scheduler can't launch the task, the task doesn't 1273 // transition to a RUNNING state, or if it fails any of its defined health checks 1274 // and is stopped. Once a service deployment has one or more successfully running 1275 // tasks, the failed task count resets to zero and stops being evaluated. 1276 FailedTasks int32 1277 1278 // The ID of the deployment. 1279 Id *string 1280 1281 // The launch type the tasks in the service are using. For more information, see 1282 // Amazon ECS Launch Types 1283 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) 1284 // in the Amazon Elastic Container Service Developer Guide. 1285 LaunchType LaunchType 1286 1287 // The VPC subnet and security group configuration for tasks that receive their own 1288 // elastic network interface by using the awsvpc networking mode. 1289 NetworkConfiguration *NetworkConfiguration 1290 1291 // The number of tasks in the deployment that are in the PENDING status. 1292 PendingCount int32 1293 1294 // The platform version on which your tasks in the service are running. A platform 1295 // version is only specified for tasks using the Fargate launch type. If one is not 1296 // specified, the LATEST platform version is used by default. For more information, 1297 // see AWS Fargate Platform Versions 1298 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html) 1299 // in the Amazon Elastic Container Service Developer Guide. 1300 PlatformVersion *string 1301 1302 // The rolloutState of a service is only returned for services that use the rolling 1303 // update (ECS) deployment type that are not behind a Classic Load Balancer. The 1304 // rollout state of the deployment. When a service deployment is started, it begins 1305 // in an IN_PROGRESS state. When the service reaches a steady state, the deployment 1306 // will transition to a COMPLETED state. If the service fails to reach a steady 1307 // state and circuit breaker is enabled, the deployment will transition to a FAILED 1308 // state. A deployment in FAILED state will launch no new tasks. For more 1309 // information, see DeploymentCircuitBreaker. 1310 RolloutState DeploymentRolloutState 1311 1312 // A description of the rollout state of a deployment. 1313 RolloutStateReason *string 1314 1315 // The number of tasks in the deployment that are in the RUNNING status. 1316 RunningCount int32 1317 1318 // The status of the deployment. The following describes each state: PRIMARY The 1319 // most recent deployment of a service. ACTIVE A service deployment that still has 1320 // running tasks, but are in the process of being replaced with a new PRIMARY 1321 // deployment. INACTIVE A deployment that has been completely replaced. 1322 Status *string 1323 1324 // The most recent task definition that was specified for the tasks in the service 1325 // to use. 1326 TaskDefinition *string 1327 1328 // The Unix timestamp for when the service deployment was last updated. 1329 UpdatedAt *time.Time 1330} 1331 1332// The deployment circuit breaker can only be used for services using the rolling 1333// update (ECS) deployment type that are not behind a Classic Load Balancer. The 1334// deployment circuit breaker determines whether a service deployment will fail if 1335// the service can't reach a steady state. If enabled, a service deployment will 1336// transition to a failed state and stop launching new tasks. You can also enable 1337// Amazon ECS to roll back your service to the last completed deployment after a 1338// failure. For more information, see Rolling update 1339// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) 1340// in the Amazon Elastic Container Service Developer Guide. 1341type DeploymentCircuitBreaker struct { 1342 1343 // Whether to enable the deployment circuit breaker logic for the service. 1344 // 1345 // This member is required. 1346 Enable bool 1347 1348 // Whether to enable Amazon ECS to roll back the service if a service deployment 1349 // fails. If rollback is enabled, when a service deployment fails, the service is 1350 // rolled back to the last deployment that completed successfully. 1351 // 1352 // This member is required. 1353 Rollback bool 1354} 1355 1356// Optional deployment parameters that control how many tasks run during a 1357// deployment and the ordering of stopping and starting tasks. 1358type DeploymentConfiguration struct { 1359 1360 // The deployment circuit breaker can only be used for services using the rolling 1361 // update (ECS) deployment type. The deployment circuit breaker determines whether 1362 // a service deployment will fail if the service can't reach a steady state. If 1363 // deployment circuit breaker is enabled, a service deployment will transition to a 1364 // failed state and stop launching new tasks. If rollback is enabled, when a 1365 // service deployment fails, the service is rolled back to the last deployment that 1366 // completed successfully. 1367 DeploymentCircuitBreaker *DeploymentCircuitBreaker 1368 1369 // If a service is using the rolling update (ECS) deployment type, the maximum 1370 // percent parameter represents an upper limit on the number of tasks in a service 1371 // that are allowed in the RUNNING or PENDING state during a deployment, as a 1372 // percentage of the desired number of tasks (rounded down to the nearest integer), 1373 // and while any container instances are in the DRAINING state if the service 1374 // contains tasks using the EC2 launch type. This parameter enables you to define 1375 // the deployment batch size. For example, if your service has a desired number of 1376 // four tasks and a maximum percent value of 200%, the scheduler may start four new 1377 // tasks before stopping the four older tasks (provided that the cluster resources 1378 // required to do this are available). The default value for maximum percent is 1379 // 200%. If a service is using the blue/green (CODE_DEPLOY) or EXTERNAL deployment 1380 // types and tasks that use the EC2 launch type, the maximum percent value is set 1381 // to the default value and is used to define the upper limit on the number of the 1382 // tasks in the service that remain in the RUNNING state while the container 1383 // instances are in the DRAINING state. If the tasks in the service use the Fargate 1384 // launch type, the maximum percent value is not used, although it is returned when 1385 // describing your service. 1386 MaximumPercent *int32 1387 1388 // If a service is using the rolling update (ECS) deployment type, the minimum 1389 // healthy percent represents a lower limit on the number of tasks in a service 1390 // that must remain in the RUNNING state during a deployment, as a percentage of 1391 // the desired number of tasks (rounded up to the nearest integer), and while any 1392 // container instances are in the DRAINING state if the service contains tasks 1393 // using the EC2 launch type. This parameter enables you to deploy without using 1394 // additional cluster capacity. For example, if your service has a desired number 1395 // of four tasks and a minimum healthy percent of 50%, the scheduler may stop two 1396 // existing tasks to free up cluster capacity before starting two new tasks. Tasks 1397 // for services that do not use a load balancer are considered healthy if they are 1398 // in the RUNNING state; tasks for services that do use a load balancer are 1399 // considered healthy if they are in the RUNNING state and they are reported as 1400 // healthy by the load balancer. The default value for minimum healthy percent is 1401 // 100%. If a service is using the blue/green (CODE_DEPLOY) or EXTERNAL deployment 1402 // types and tasks that use the EC2 launch type, the minimum healthy percent value 1403 // is set to the default value and is used to define the lower limit on the number 1404 // of the tasks in the service that remain in the RUNNING state while the container 1405 // instances are in the DRAINING state. If the tasks in the service use the Fargate 1406 // launch type, the minimum healthy percent value is not used, although it is 1407 // returned when describing your service. 1408 MinimumHealthyPercent *int32 1409} 1410 1411// The deployment controller to use for the service. For more information, see 1412// Amazon ECS Deployment Types 1413// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html) 1414// in the Amazon Elastic Container Service Developer Guide. 1415type DeploymentController struct { 1416 1417 // The deployment controller type to use. There are three deployment controller 1418 // types available: ECS The rolling update (ECS) deployment type involves replacing 1419 // the current running version of the container with the latest version. The number 1420 // of containers Amazon ECS adds or removes from the service during a rolling 1421 // update is controlled by adjusting the minimum and maximum number of healthy 1422 // tasks allowed during a service deployment, as specified in the 1423 // DeploymentConfiguration. CODE_DEPLOY The blue/green (CODE_DEPLOY) deployment 1424 // type uses the blue/green deployment model powered by AWS CodeDeploy, which 1425 // allows you to verify a new deployment of a service before sending production 1426 // traffic to it. EXTERNAL The external (EXTERNAL) deployment type enables you to 1427 // use any third-party deployment controller for full control over the deployment 1428 // process for an Amazon ECS service. 1429 // 1430 // This member is required. 1431 Type DeploymentControllerType 1432} 1433 1434// An object representing a container instance host device. 1435type Device struct { 1436 1437 // The path for the device on the host container instance. 1438 // 1439 // This member is required. 1440 HostPath *string 1441 1442 // The path inside the container at which to expose the host device. 1443 ContainerPath *string 1444 1445 // The explicit permissions to provide to the container for the device. By default, 1446 // the container has permissions for read, write, and mknod for the device. 1447 Permissions []DeviceCgroupPermission 1448} 1449 1450// This parameter is specified when you are using Docker volumes. Docker volumes 1451// are only supported when you are using the EC2 launch type. Windows containers 1452// only support the use of the local driver. To use bind mounts, specify a host 1453// instead. 1454type DockerVolumeConfiguration struct { 1455 1456 // If this value is true, the Docker volume is created if it does not already 1457 // exist. This field is only used if the scope is shared. 1458 Autoprovision *bool 1459 1460 // The Docker volume driver to use. The driver value must match the driver name 1461 // provided by Docker because it is used for task placement. If the driver was 1462 // installed using the Docker plugin CLI, use docker plugin ls to retrieve the 1463 // driver name from your container instance. If the driver was installed using 1464 // another method, use Docker plugin discovery to retrieve the driver name. For 1465 // more information, see Docker plugin discovery 1466 // (https://docs.docker.com/engine/extend/plugin_api/#plugin-discovery). This 1467 // parameter maps to Driver in the Create a volume 1468 // (https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of 1469 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 1470 // xxdriver option to docker volume create 1471 // (https://docs.docker.com/engine/reference/commandline/volume_create/). 1472 Driver *string 1473 1474 // A map of Docker driver-specific options passed through. This parameter maps to 1475 // DriverOpts in the Create a volume 1476 // (https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of 1477 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the xxopt 1478 // option to docker volume create 1479 // (https://docs.docker.com/engine/reference/commandline/volume_create/). 1480 DriverOpts map[string]string 1481 1482 // Custom metadata to add to your Docker volume. This parameter maps to Labels in 1483 // the Create a volume 1484 // (https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of 1485 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 1486 // xxlabel option to docker volume create 1487 // (https://docs.docker.com/engine/reference/commandline/volume_create/). 1488 Labels map[string]string 1489 1490 // The scope for the Docker volume that determines its lifecycle. Docker volumes 1491 // that are scoped to a task are automatically provisioned when the task starts and 1492 // destroyed when the task stops. Docker volumes that are scoped as shared persist 1493 // after the task stops. 1494 Scope Scope 1495} 1496 1497// The authorization configuration details for the Amazon EFS file system. 1498type EFSAuthorizationConfig struct { 1499 1500 // The Amazon EFS access point ID to use. If an access point is specified, the root 1501 // directory value specified in the EFSVolumeConfiguration must either be omitted 1502 // or set to / which will enforce the path set on the EFS access point. If an 1503 // access point is used, transit encryption must be enabled in the 1504 // EFSVolumeConfiguration. For more information, see Working with Amazon EFS Access 1505 // Points (https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html) in the 1506 // Amazon Elastic File System User Guide. 1507 AccessPointId *string 1508 1509 // Whether or not to use the Amazon ECS task IAM role defined in a task definition 1510 // when mounting the Amazon EFS file system. If enabled, transit encryption must be 1511 // enabled in the EFSVolumeConfiguration. If this parameter is omitted, the default 1512 // value of DISABLED is used. For more information, see Using Amazon EFS Access 1513 // Points 1514 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints) 1515 // in the Amazon Elastic Container Service Developer Guide. 1516 Iam EFSAuthorizationConfigIAM 1517} 1518 1519// This parameter is specified when you are using an Amazon Elastic File System 1520// file system for task storage. For more information, see Amazon EFS Volumes 1521// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html) 1522// in the Amazon Elastic Container Service Developer Guide. 1523type EFSVolumeConfiguration struct { 1524 1525 // The Amazon EFS file system ID to use. 1526 // 1527 // This member is required. 1528 FileSystemId *string 1529 1530 // The authorization configuration details for the Amazon EFS file system. 1531 AuthorizationConfig *EFSAuthorizationConfig 1532 1533 // The directory within the Amazon EFS file system to mount as the root directory 1534 // inside the host. If this parameter is omitted, the root of the Amazon EFS volume 1535 // will be used. Specifying / will have the same effect as omitting this parameter. 1536 // If an EFS access point is specified in the authorizationConfig, the root 1537 // directory parameter must either be omitted or set to / which will enforce the 1538 // path set on the EFS access point. 1539 RootDirectory *string 1540 1541 // Whether or not to enable encryption for Amazon EFS data in transit between the 1542 // Amazon ECS host and the Amazon EFS server. Transit encryption must be enabled if 1543 // Amazon EFS IAM authorization is used. If this parameter is omitted, the default 1544 // value of DISABLED is used. For more information, see Encrypting Data in Transit 1545 // (https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html) in the 1546 // Amazon Elastic File System User Guide. 1547 TransitEncryption EFSTransitEncryption 1548 1549 // The port to use when sending encrypted data between the Amazon ECS host and the 1550 // Amazon EFS server. If you do not specify a transit encryption port, it will use 1551 // the port selection strategy that the Amazon EFS mount helper uses. For more 1552 // information, see EFS Mount Helper 1553 // (https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html) in the Amazon 1554 // Elastic File System User Guide. 1555 TransitEncryptionPort *int32 1556} 1557 1558// A list of files containing the environment variables to pass to a container. You 1559// can specify up to ten environment files. The file must have a .env file 1560// extension. Each line in an environment file should contain an environment 1561// variable in VARIABLE=VALUE format. Lines beginning with # are treated as 1562// comments and are ignored. For more information on the environment variable file 1563// syntax, see Declare default environment variables in file 1564// (https://docs.docker.com/compose/env-file/). If there are environment variables 1565// specified using the environment parameter in a container definition, they take 1566// precedence over the variables contained within an environment file. If multiple 1567// environment files are specified that contain the same variable, they are 1568// processed from the top down. It is recommended to use unique variable names. For 1569// more information, see Specifying Environment Variables 1570// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/taskdef-envfiles.html) 1571// in the Amazon Elastic Container Service Developer Guide. This field is not valid 1572// for containers in tasks using the Fargate launch type. 1573type EnvironmentFile struct { 1574 1575 // The file type to use. The only supported value is s3. 1576 // 1577 // This member is required. 1578 Type EnvironmentFileType 1579 1580 // The Amazon Resource Name (ARN) of the Amazon S3 object containing the 1581 // environment variable file. 1582 // 1583 // This member is required. 1584 Value *string 1585} 1586 1587// A failed resource. For a list of common causes, see API failure reasons 1588// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/api_failures_messages.html) 1589// in the Amazon Elastic Container Service Developer Guide. 1590type Failure struct { 1591 1592 // The Amazon Resource Name (ARN) of the failed resource. 1593 Arn *string 1594 1595 // The details of the failure. 1596 Detail *string 1597 1598 // The reason for the failure. 1599 Reason *string 1600} 1601 1602// The FireLens configuration for the container. This is used to specify and 1603// configure a log router for container logs. For more information, see Custom Log 1604// Routing 1605// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) 1606// in the Amazon Elastic Container Service Developer Guide. 1607type FirelensConfiguration struct { 1608 1609 // The log router to use. The valid values are fluentd or fluentbit. 1610 // 1611 // This member is required. 1612 Type FirelensConfigurationType 1613 1614 // The options to use when configuring the log router. This field is optional and 1615 // can be used to specify a custom configuration file or to add additional 1616 // metadata, such as the task, task definition, cluster, and container instance 1617 // details to the log event. If specified, the syntax to use is 1618 // "options":{"enable-ecs-log-metadata":"true|false","config-file-type:"s3|file","config-file-value":"arn:aws:s3:::mybucket/fluent.conf|filepath"}. 1619 // For more information, see Creating a Task Definition that Uses a FireLens 1620 // Configuration 1621 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html#firelens-taskdef) 1622 // in the Amazon Elastic Container Service Developer Guide. 1623 Options map[string]string 1624} 1625 1626// The authorization configuration details for Amazon FSx for Windows File Server 1627// file system. See FSxWindowsFileServerVolumeConfiguration 1628// (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_FSxWindowsFileServerVolumeConfiguration.html) 1629// in the Amazon Elastic Container Service API Reference. For more information and 1630// the input format, see Amazon FSx for Windows File Server Volumes 1631// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/wfsx-volumes.html) 1632// in the Amazon Elastic Container Service Developer Guide. 1633type FSxWindowsFileServerAuthorizationConfig struct { 1634 1635 // The authorization credential option to use. The authorization credential options 1636 // can be provided using either the Amazon Resource Name (ARN) of an AWS Secrets 1637 // Manager secret or AWS Systems Manager Parameter Store parameter. The ARNs refer 1638 // to the stored credentials. 1639 // 1640 // This member is required. 1641 CredentialsParameter *string 1642 1643 // A fully qualified domain name hosted by an AWS Directory Service 1644 // (https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html) 1645 // Managed Microsoft AD (Active Directory) or self-hosted AD on Amazon EC2. 1646 // 1647 // This member is required. 1648 Domain *string 1649} 1650 1651// This parameter is specified when you are using Amazon FSx for Windows File 1652// Server (https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) file 1653// system for task storage. For more information and the input format, see Amazon 1654// FSx for Windows File Server Volumes 1655// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/wfsx-volumes.html) 1656// in the Amazon Elastic Container Service Developer Guide. 1657type FSxWindowsFileServerVolumeConfiguration struct { 1658 1659 // The authorization configuration details for the Amazon FSx for Windows File 1660 // Server file system. 1661 // 1662 // This member is required. 1663 AuthorizationConfig *FSxWindowsFileServerAuthorizationConfig 1664 1665 // The Amazon FSx for Windows File Server file system ID to use. 1666 // 1667 // This member is required. 1668 FileSystemId *string 1669 1670 // The directory within the Amazon FSx for Windows File Server file system to mount 1671 // as the root directory inside the host. 1672 // 1673 // This member is required. 1674 RootDirectory *string 1675} 1676 1677// An object representing a container health check. Health check parameters that 1678// are specified in a container definition override any Docker health checks that 1679// exist in the container image (such as those specified in a parent image or from 1680// the image's Dockerfile). You can view the health status of both individual 1681// containers and a task with the DescribeTasks API operation or when viewing the 1682// task details in the console. The following describes the possible healthStatus 1683// values for a container: 1684// 1685// * HEALTHY-The container health check has passed 1686// successfully. 1687// 1688// * UNHEALTHY-The container health check has failed. 1689// 1690// * UNKNOWN-The 1691// container health check is being evaluated or there is no container health check 1692// defined. 1693// 1694// The following describes the possible healthStatus values for a task. 1695// The container health check status of nonessential containers do not have an 1696// effect on the health status of a task. 1697// 1698// * HEALTHY-All essential containers 1699// within the task have passed their health checks. 1700// 1701// * UNHEALTHY-One or more 1702// essential containers have failed their health check. 1703// 1704// * UNKNOWN-The essential 1705// containers within the task are still having their health checks evaluated or 1706// there are no container health checks defined. 1707// 1708// If a task is run manually, and 1709// not as part of a service, the task will continue its lifecycle regardless of its 1710// health status. For tasks that are part of a service, if the task reports as 1711// unhealthy then the task will be stopped and the service scheduler will replace 1712// it. The following are notes about container health check support: 1713// 1714// * Container 1715// health checks require version 1.17.0 or greater of the Amazon ECS container 1716// agent. For more information, see Updating the Amazon ECS Container Agent 1717// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html). 1718// 1719// * 1720// Container health checks are supported for Fargate tasks if you are using 1721// platform version 1.1.0 or greater. For more information, see AWS Fargate 1722// Platform Versions 1723// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html). 1724// 1725// * 1726// Container health checks are not supported for tasks that are part of a service 1727// that is configured to use a Classic Load Balancer. 1728type HealthCheck struct { 1729 1730 // A string array representing the command that the container runs to determine if 1731 // it is healthy. The string array must start with CMD to execute the command 1732 // arguments directly, or CMD-SHELL to run the command with the container's default 1733 // shell. For example: [ "CMD-SHELL", "curl -f http://localhost/ || exit 1" ] An 1734 // exit code of 0 indicates success, and non-zero exit code indicates failure. For 1735 // more information, see HealthCheck in the Create a container 1736 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 1737 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/). 1738 // 1739 // This member is required. 1740 Command []string 1741 1742 // The time period in seconds between each health check execution. You may specify 1743 // between 5 and 300 seconds. The default value is 30 seconds. 1744 Interval *int32 1745 1746 // The number of times to retry a failed health check before the container is 1747 // considered unhealthy. You may specify between 1 and 10 retries. The default 1748 // value is 3. 1749 Retries *int32 1750 1751 // The optional grace period within which to provide containers time to bootstrap 1752 // before failed health checks count towards the maximum number of retries. You may 1753 // specify between 0 and 300 seconds. The startPeriod is disabled by default. If a 1754 // health check succeeds within the startPeriod, then the container is considered 1755 // healthy and any subsequent failures count toward the maximum number of retries. 1756 StartPeriod *int32 1757 1758 // The time period in seconds to wait for a health check to succeed before it is 1759 // considered a failure. You may specify between 2 and 60 seconds. The default 1760 // value is 5. 1761 Timeout *int32 1762} 1763 1764// Hostnames and IP address entries that are added to the /etc/hosts file of a 1765// container via the extraHosts parameter of its ContainerDefinition. 1766type HostEntry struct { 1767 1768 // The hostname to use in the /etc/hosts entry. 1769 // 1770 // This member is required. 1771 Hostname *string 1772 1773 // The IP address to use in the /etc/hosts entry. 1774 // 1775 // This member is required. 1776 IpAddress *string 1777} 1778 1779// Details on a container instance bind mount host volume. 1780type HostVolumeProperties struct { 1781 1782 // When the host parameter is used, specify a sourcePath to declare the path on the 1783 // host container instance that is presented to the container. If this parameter is 1784 // empty, then the Docker daemon has assigned a host path for you. If the host 1785 // parameter contains a sourcePath file location, then the data volume persists at 1786 // the specified location on the host container instance until you delete it 1787 // manually. If the sourcePath value does not exist on the host container instance, 1788 // the Docker daemon creates it. If the location does exist, the contents of the 1789 // source path folder are exported. If you are using the Fargate launch type, the 1790 // sourcePath parameter is not supported. 1791 SourcePath *string 1792} 1793 1794// Details on a Elastic Inference accelerator. For more information, see Working 1795// with Amazon Elastic Inference on Amazon ECS 1796// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-eia.html) in 1797// the Amazon Elastic Container Service Developer Guide. 1798type InferenceAccelerator struct { 1799 1800 // The Elastic Inference accelerator device name. The deviceName must also be 1801 // referenced in a container definition as a ResourceRequirement. 1802 // 1803 // This member is required. 1804 DeviceName *string 1805 1806 // The Elastic Inference accelerator type to use. 1807 // 1808 // This member is required. 1809 DeviceType *string 1810} 1811 1812// Details on an Elastic Inference accelerator task override. This parameter is 1813// used to override the Elastic Inference accelerator specified in the task 1814// definition. For more information, see Working with Amazon Elastic Inference on 1815// Amazon ECS 1816// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-eia.html) in 1817// the Amazon Elastic Container Service Developer Guide. 1818type InferenceAcceleratorOverride struct { 1819 1820 // The Elastic Inference accelerator device name to override for the task. This 1821 // parameter must match a deviceName specified in the task definition. 1822 DeviceName *string 1823 1824 // The Elastic Inference accelerator type to use. 1825 DeviceType *string 1826} 1827 1828// The Linux capabilities for the container that are added to or dropped from the 1829// default configuration provided by Docker. For more information on the default 1830// capabilities and the non-default available capabilities, see Runtime privilege 1831// and Linux capabilities 1832// (https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) 1833// in the Docker run reference. For more detailed information on these Linux 1834// capabilities, see the capabilities(7) 1835// (http://man7.org/linux/man-pages/man7/capabilities.7.html) Linux manual page. 1836type KernelCapabilities struct { 1837 1838 // The Linux capabilities for the container that have been added to the default 1839 // configuration provided by Docker. This parameter maps to CapAdd in the Create a 1840 // container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) 1841 // section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and 1842 // the --cap-add option to docker run 1843 // (https://docs.docker.com/engine/reference/run/#security-configuration). Tasks 1844 // launched on AWS Fargate only support adding the SYS_PTRACE kernel capability. 1845 // Valid values: "ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" | 1846 // "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK" 1847 // | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" | 1848 // "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" | 1849 // "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" | 1850 // "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" | 1851 // "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" | 1852 // "SYSLOG" | "WAKE_ALARM" 1853 Add []string 1854 1855 // The Linux capabilities for the container that have been removed from the default 1856 // configuration provided by Docker. This parameter maps to CapDrop in the Create a 1857 // container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) 1858 // section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and 1859 // the --cap-drop option to docker run 1860 // (https://docs.docker.com/engine/reference/run/#security-configuration). Valid 1861 // values: "ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" | "CHOWN" | 1862 // "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK" | 1863 // "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" | 1864 // "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" | 1865 // "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" | 1866 // "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" | 1867 // "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" | 1868 // "SYSLOG" | "WAKE_ALARM" 1869 Drop []string 1870} 1871 1872// A key-value pair object. 1873type KeyValuePair struct { 1874 1875 // The name of the key-value pair. For environment variables, this is the name of 1876 // the environment variable. 1877 Name *string 1878 1879 // The value of the key-value pair. For environment variables, this is the value of 1880 // the environment variable. 1881 Value *string 1882} 1883 1884// Linux-specific options that are applied to the container, such as Linux 1885// KernelCapabilities. 1886type LinuxParameters struct { 1887 1888 // The Linux capabilities for the container that are added to or dropped from the 1889 // default configuration provided by Docker. For tasks that use the Fargate launch 1890 // type, capabilities is supported for all platform versions but the add parameter 1891 // is only supported if using platform version 1.4.0 or later. 1892 Capabilities *KernelCapabilities 1893 1894 // Any host devices to expose to the container. This parameter maps to Devices in 1895 // the Create a container 1896 // (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 1897 // the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 1898 // --device option to docker run 1899 // (https://docs.docker.com/engine/reference/run/#security-configuration). If you 1900 // are using tasks that use the Fargate launch type, the devices parameter is not 1901 // supported. 1902 Devices []Device 1903 1904 // Run an init process inside the container that forwards signals and reaps 1905 // processes. This parameter maps to the --init option to docker run 1906 // (https://docs.docker.com/engine/reference/run/#security-configuration). This 1907 // parameter requires version 1.25 of the Docker Remote API or greater on your 1908 // container instance. To check the Docker Remote API version on your container 1909 // instance, log in to your container instance and run the following command: sudo 1910 // docker version --format '{{.Server.APIVersion}}' 1911 InitProcessEnabled *bool 1912 1913 // The total amount of swap memory (in MiB) a container can use. This parameter 1914 // will be translated to the --memory-swap option to docker run 1915 // (https://docs.docker.com/engine/reference/run/#security-configuration) where the 1916 // value would be the sum of the container memory plus the maxSwap value. If a 1917 // maxSwap value of 0 is specified, the container will not use swap. Accepted 1918 // values are 0 or any positive integer. If the maxSwap parameter is omitted, the 1919 // container will use the swap configuration for the container instance it is 1920 // running on. A maxSwap value must be set for the swappiness parameter to be used. 1921 // If you are using tasks that use the Fargate launch type, the maxSwap parameter 1922 // is not supported. 1923 MaxSwap *int32 1924 1925 // The value for the size (in MiB) of the /dev/shm volume. This parameter maps to 1926 // the --shm-size option to docker run 1927 // (https://docs.docker.com/engine/reference/run/#security-configuration). If you 1928 // are using tasks that use the Fargate launch type, the sharedMemorySize parameter 1929 // is not supported. 1930 SharedMemorySize *int32 1931 1932 // This allows you to tune a container's memory swappiness behavior. A swappiness 1933 // value of 0 will cause swapping to not happen unless absolutely necessary. A 1934 // swappiness value of 100 will cause pages to be swapped very aggressively. 1935 // Accepted values are whole numbers between 0 and 100. If the swappiness parameter 1936 // is not specified, a default value of 60 is used. If a value is not specified for 1937 // maxSwap then this parameter is ignored. This parameter maps to the 1938 // --memory-swappiness option to docker run 1939 // (https://docs.docker.com/engine/reference/run/#security-configuration). If you 1940 // are using tasks that use the Fargate launch type, the swappiness parameter is 1941 // not supported. 1942 Swappiness *int32 1943 1944 // The container path, mount options, and size (in MiB) of the tmpfs mount. This 1945 // parameter maps to the --tmpfs option to docker run 1946 // (https://docs.docker.com/engine/reference/run/#security-configuration). If you 1947 // are using tasks that use the Fargate launch type, the tmpfs parameter is not 1948 // supported. 1949 Tmpfs []Tmpfs 1950} 1951 1952// The load balancer configuration to use with a service or task set. For specific 1953// notes and restrictions regarding the use of load balancers with services and 1954// task sets, see the CreateService and CreateTaskSet actions. 1955type LoadBalancer struct { 1956 1957 // The name of the container (as it appears in a container definition) to associate 1958 // with the load balancer. 1959 ContainerName *string 1960 1961 // The port on the container to associate with the load balancer. This port must 1962 // correspond to a containerPort in the task definition the tasks in the service 1963 // are using. For tasks that use the EC2 launch type, the container instance they 1964 // are launched on must allow ingress traffic on the hostPort of the port mapping. 1965 ContainerPort *int32 1966 1967 // The name of the load balancer to associate with the Amazon ECS service or task 1968 // set. A load balancer name is only specified when using a Classic Load Balancer. 1969 // If you are using an Application Load Balancer or a Network Load Balancer the 1970 // load balancer name parameter should be omitted. 1971 LoadBalancerName *string 1972 1973 // The full Amazon Resource Name (ARN) of the Elastic Load Balancing target group 1974 // or groups associated with a service or task set. A target group ARN is only 1975 // specified when using an Application Load Balancer or Network Load Balancer. If 1976 // you are using a Classic Load Balancer the target group ARN should be omitted. 1977 // For services using the ECS deployment controller, you can specify one or 1978 // multiple target groups. For more information, see Registering Multiple Target 1979 // Groups with a Service 1980 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html) 1981 // in the Amazon Elastic Container Service Developer Guide. For services using the 1982 // CODE_DEPLOY deployment controller, you are required to define two target groups 1983 // for the load balancer. For more information, see Blue/Green Deployment with 1984 // CodeDeploy 1985 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-bluegreen.html) 1986 // in the Amazon Elastic Container Service Developer Guide. If your service's task 1987 // definition uses the awsvpc network mode (which is required for the Fargate 1988 // launch type), you must choose ip as the target type, not instance, when creating 1989 // your target groups because tasks that use the awsvpc network mode are associated 1990 // with an elastic network interface, not an Amazon EC2 instance. 1991 TargetGroupArn *string 1992} 1993 1994// The log configuration for the container. This parameter maps to LogConfig in the 1995// Create a container 1996// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 1997// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 1998// --log-driver option to docker run 1999// (https://docs.docker.com/engine/reference/commandline/run/). By default, 2000// containers use the same logging driver that the Docker daemon uses; however the 2001// container may use a different logging driver than the Docker daemon by 2002// specifying a log driver configuration in the container definition. For more 2003// information on the options for different supported log drivers, see Configure 2004// logging drivers (https://docs.docker.com/engine/admin/logging/overview/) in the 2005// Docker documentation. The following should be noted when specifying a log 2006// configuration for your containers: 2007// 2008// * Amazon ECS currently supports a subset of 2009// the logging drivers available to the Docker daemon (shown in the valid values 2010// below). Additional log drivers may be available in future releases of the Amazon 2011// ECS container agent. 2012// 2013// * This parameter requires version 1.18 of the Docker 2014// Remote API or greater on your container instance. 2015// 2016// * For tasks hosted on Amazon 2017// EC2 instances, the Amazon ECS container agent must register the available 2018// logging drivers with the ECS_AVAILABLE_LOGGING_DRIVERS environment variable 2019// before containers placed on that instance can use these log configuration 2020// options. For more information, see Amazon ECS container agent configuration 2021// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) 2022// in the Amazon Elastic Container Service Developer Guide. 2023// 2024// * For tasks on AWS 2025// Fargate, because you do not have access to the underlying infrastructure your 2026// tasks are hosted on, any additional software needed will have to be installed 2027// outside of the task. For example, the Fluentd output aggregators or a remote 2028// host running Logstash to send Gelf logs to. 2029type LogConfiguration struct { 2030 2031 // The log driver to use for the container. For tasks on AWS Fargate, the supported 2032 // log drivers are awslogs, splunk, and awsfirelens. For tasks hosted on Amazon EC2 2033 // instances, the supported log drivers are awslogs, fluentd, gelf, json-file, 2034 // journald, logentries,syslog, splunk, and awsfirelens. For more information about 2035 // using the awslogs log driver, see Using the awslogs log driver 2036 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html) 2037 // in the Amazon Elastic Container Service Developer Guide. For more information 2038 // about using the awsfirelens log driver, see Custom log routing 2039 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) 2040 // in the Amazon Elastic Container Service Developer Guide. If you have a custom 2041 // driver that is not listed, you can fork the Amazon ECS container agent project 2042 // that is available on GitHub (https://github.com/aws/amazon-ecs-agent) and 2043 // customize it to work with that driver. We encourage you to submit pull requests 2044 // for changes that you would like to have included. However, we do not currently 2045 // provide support for running modified copies of this software. 2046 // 2047 // This member is required. 2048 LogDriver LogDriver 2049 2050 // The configuration options to send to the log driver. This parameter requires 2051 // version 1.19 of the Docker Remote API or greater on your container instance. To 2052 // check the Docker Remote API version on your container instance, log in to your 2053 // container instance and run the following command: sudo docker version --format 2054 // '{{.Server.APIVersion}}' 2055 Options map[string]string 2056 2057 // The secrets to pass to the log configuration. For more information, see 2058 // Specifying Sensitive Data 2059 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) 2060 // in the Amazon Elastic Container Service Developer Guide. 2061 SecretOptions []Secret 2062} 2063 2064// The managed scaling settings for the Auto Scaling group capacity provider. When 2065// managed scaling is enabled, Amazon ECS manages the scale-in and scale-out 2066// actions of the Auto Scaling group. Amazon ECS manages a target tracking scaling 2067// policy using an Amazon ECS-managed CloudWatch metric with the specified 2068// targetCapacity value as the target value for the metric. For more information, 2069// see Using Managed Scaling 2070// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/asg-capacity-providers.html#asg-capacity-providers-managed-scaling) 2071// in the Amazon Elastic Container Service Developer Guide. If managed scaling is 2072// disabled, the user must manage the scaling of the Auto Scaling group. 2073type ManagedScaling struct { 2074 2075 // The period of time, in seconds, after a newly launched Amazon EC2 instance can 2076 // contribute to CloudWatch metrics for Auto Scaling group. If this parameter is 2077 // omitted, the default value of 300 seconds is used. 2078 InstanceWarmupPeriod *int32 2079 2080 // The maximum number of container instances that Amazon ECS will scale in or scale 2081 // out at one time. If this parameter is omitted, the default value of 10000 is 2082 // used. 2083 MaximumScalingStepSize *int32 2084 2085 // The minimum number of container instances that Amazon ECS will scale in or scale 2086 // out at one time. If this parameter is omitted, the default value of 1 is used. 2087 MinimumScalingStepSize *int32 2088 2089 // Whether or not to enable managed scaling for the capacity provider. 2090 Status ManagedScalingStatus 2091 2092 // The target capacity value for the capacity provider. The specified value must be 2093 // greater than 0 and less than or equal to 100. A value of 100 will result in the 2094 // Amazon EC2 instances in your Auto Scaling group being completely utilized. 2095 TargetCapacity *int32 2096} 2097 2098// Details on a volume mount point that is used in a container definition. 2099type MountPoint struct { 2100 2101 // The path on the container to mount the host volume at. 2102 ContainerPath *string 2103 2104 // If this value is true, the container has read-only access to the volume. If this 2105 // value is false, then the container can write to the volume. The default value is 2106 // false. 2107 ReadOnly *bool 2108 2109 // The name of the volume to mount. Must be a volume name referenced in the name 2110 // parameter of task definition volume. 2111 SourceVolume *string 2112} 2113 2114// Details on the network bindings between a container and its host container 2115// instance. After a task reaches the RUNNING status, manual and automatic host and 2116// container port assignments are visible in the networkBindings section of 2117// DescribeTasks API responses. 2118type NetworkBinding struct { 2119 2120 // The IP address that the container is bound to on the container instance. 2121 BindIP *string 2122 2123 // The port number on the container that is used with the network binding. 2124 ContainerPort *int32 2125 2126 // The port number on the host that is used with the network binding. 2127 HostPort *int32 2128 2129 // The protocol used for the network binding. 2130 Protocol TransportProtocol 2131} 2132 2133// An object representing the network configuration for a task or service. 2134type NetworkConfiguration struct { 2135 2136 // The VPC subnets and security groups associated with a task. All specified 2137 // subnets and security groups must be from the same VPC. 2138 AwsvpcConfiguration *AwsVpcConfiguration 2139} 2140 2141// An object representing the elastic network interface for tasks that use the 2142// awsvpc network mode. 2143type NetworkInterface struct { 2144 2145 // The attachment ID for the network interface. 2146 AttachmentId *string 2147 2148 // The private IPv6 address for the network interface. 2149 Ipv6Address *string 2150 2151 // The private IPv4 address for the network interface. 2152 PrivateIpv4Address *string 2153} 2154 2155// An object representing a constraint on task placement. For more information, see 2156// Task Placement Constraints 2157// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html) 2158// in the Amazon Elastic Container Service Developer Guide. If you are using the 2159// Fargate launch type, task placement constraints are not supported. 2160type PlacementConstraint struct { 2161 2162 // A cluster query language expression to apply to the constraint. You cannot 2163 // specify an expression if the constraint type is distinctInstance. For more 2164 // information, see Cluster Query Language 2165 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html) 2166 // in the Amazon Elastic Container Service Developer Guide. 2167 Expression *string 2168 2169 // The type of constraint. Use distinctInstance to ensure that each task in a 2170 // particular group is running on a different container instance. Use memberOf to 2171 // restrict the selection to a group of valid candidates. 2172 Type PlacementConstraintType 2173} 2174 2175// The task placement strategy for a task or service. For more information, see 2176// Task Placement Strategies 2177// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-strategies.html) 2178// in the Amazon Elastic Container Service Developer Guide. 2179type PlacementStrategy struct { 2180 2181 // The field to apply the placement strategy against. For the spread placement 2182 // strategy, valid values are instanceId (or host, which has the same effect), or 2183 // any platform or custom attribute that is applied to a container instance, such 2184 // as attribute:ecs.availability-zone. For the binpack placement strategy, valid 2185 // values are cpu and memory. For the random placement strategy, this field is not 2186 // used. 2187 Field *string 2188 2189 // The type of placement strategy. The random placement strategy randomly places 2190 // tasks on available candidates. The spread placement strategy spreads placement 2191 // across available candidates evenly based on the field parameter. The binpack 2192 // strategy places tasks on available candidates that have the least available 2193 // amount of the resource that is specified with the field parameter. For example, 2194 // if you binpack on memory, a task is placed on the instance with the least amount 2195 // of remaining memory (but still enough to run the task). 2196 Type PlacementStrategyType 2197} 2198 2199// The devices that are available on the container instance. The only supported 2200// device type is a GPU. 2201type PlatformDevice struct { 2202 2203 // The ID for the GPU(s) on the container instance. The available GPU IDs can also 2204 // be obtained on the container instance in the 2205 // /var/lib/ecs/gpu/nvidia_gpu_info.json file. 2206 // 2207 // This member is required. 2208 Id *string 2209 2210 // The type of device that is available on the container instance. The only 2211 // supported value is GPU. 2212 // 2213 // This member is required. 2214 Type PlatformDeviceType 2215} 2216 2217// Port mappings allow containers to access ports on the host container instance to 2218// send or receive traffic. Port mappings are specified as part of the container 2219// definition. If you are using containers in a task with the awsvpc or host 2220// network mode, exposed ports should be specified using containerPort. The 2221// hostPort can be left blank or it must be the same value as the containerPort. 2222// After a task reaches the RUNNING status, manual and automatic host and container 2223// port assignments are visible in the networkBindings section of DescribeTasks API 2224// responses. 2225type PortMapping struct { 2226 2227 // The port number on the container that is bound to the user-specified or 2228 // automatically assigned host port. If you are using containers in a task with the 2229 // awsvpc or host network mode, exposed ports should be specified using 2230 // containerPort. If you are using containers in a task with the bridge network 2231 // mode and you specify a container port and not a host port, your container 2232 // automatically receives a host port in the ephemeral port range. For more 2233 // information, see hostPort. Port mappings that are automatically assigned in this 2234 // way do not count toward the 100 reserved ports limit of a container instance. 2235 ContainerPort *int32 2236 2237 // The port number on the container instance to reserve for your container. If you 2238 // are using containers in a task with the awsvpc or host network mode, the 2239 // hostPort can either be left blank or set to the same value as the containerPort. 2240 // If you are using containers in a task with the bridge network mode, you can 2241 // specify a non-reserved host port for your container port mapping, or you can 2242 // omit the hostPort (or set it to 0) while specifying a containerPort and your 2243 // container automatically receives a port in the ephemeral port range for your 2244 // container instance operating system and Docker version. The default ephemeral 2245 // port range for Docker version 1.6.0 and later is listed on the instance under 2246 // /proc/sys/net/ipv4/ip_local_port_range. If this kernel parameter is unavailable, 2247 // the default ephemeral port range from 49153 through 65535 is used. Do not 2248 // attempt to specify a host port in the ephemeral port range as these are reserved 2249 // for automatic assignment. In general, ports below 32768 are outside of the 2250 // ephemeral port range. The default ephemeral port range from 49153 through 65535 2251 // is always used for Docker versions before 1.6.0. The default reserved ports are 2252 // 22 for SSH, the Docker ports 2375 and 2376, and the Amazon ECS container agent 2253 // ports 51678-51680. Any host port that was previously specified in a running task 2254 // is also reserved while the task is running (after a task stops, the host port is 2255 // released). The current reserved ports are displayed in the remainingResources of 2256 // DescribeContainerInstances output. A container instance can have up to 100 2257 // reserved ports at a time, including the default reserved ports. Automatically 2258 // assigned ports don't count toward the 100 reserved ports limit. 2259 HostPort *int32 2260 2261 // The protocol used for the port mapping. Valid values are tcp and udp. The 2262 // default is tcp. 2263 Protocol TransportProtocol 2264} 2265 2266// The configuration details for the App Mesh proxy. For tasks using the EC2 launch 2267// type, the container instances require at least version 1.26.0 of the container 2268// agent and at least version 1.26.0-1 of the ecs-init package to enable a proxy 2269// configuration. If your container instances are launched from the Amazon 2270// ECS-optimized AMI version 20190301 or later, then they contain the required 2271// versions of the container agent and ecs-init. For more information, see Amazon 2272// ECS-optimized Linux AMI 2273// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) 2274type ProxyConfiguration struct { 2275 2276 // The name of the container that will serve as the App Mesh proxy. 2277 // 2278 // This member is required. 2279 ContainerName *string 2280 2281 // The set of network configuration parameters to provide the Container Network 2282 // Interface (CNI) plugin, specified as key-value pairs. 2283 // 2284 // * IgnoredUID - (Required) 2285 // The user ID (UID) of the proxy container as defined by the user parameter in a 2286 // container definition. This is used to ensure the proxy ignores its own traffic. 2287 // If IgnoredGID is specified, this field can be empty. 2288 // 2289 // * IgnoredGID - (Required) 2290 // The group ID (GID) of the proxy container as defined by the user parameter in a 2291 // container definition. This is used to ensure the proxy ignores its own traffic. 2292 // If IgnoredUID is specified, this field can be empty. 2293 // 2294 // * AppPorts - (Required) 2295 // The list of ports that the application uses. Network traffic to these ports is 2296 // forwarded to the ProxyIngressPort and ProxyEgressPort. 2297 // 2298 // * ProxyIngressPort - 2299 // (Required) Specifies the port that incoming traffic to the AppPorts is directed 2300 // to. 2301 // 2302 // * ProxyEgressPort - (Required) Specifies the port that outgoing traffic 2303 // from the AppPorts is directed to. 2304 // 2305 // * EgressIgnoredPorts - (Required) The egress 2306 // traffic going to the specified ports is ignored and not redirected to the 2307 // ProxyEgressPort. It can be an empty list. 2308 // 2309 // * EgressIgnoredIPs - (Required) The 2310 // egress traffic going to the specified IP addresses is ignored and not redirected 2311 // to the ProxyEgressPort. It can be an empty list. 2312 Properties []KeyValuePair 2313 2314 // The proxy type. The only supported value is APPMESH. 2315 Type ProxyConfigurationType 2316} 2317 2318// The repository credentials for private registry authentication. 2319type RepositoryCredentials struct { 2320 2321 // The Amazon Resource Name (ARN) of the secret containing the private repository 2322 // credentials. When you are using the Amazon ECS API, AWS CLI, or AWS SDK, if the 2323 // secret exists in the same Region as the task that you are launching then you can 2324 // use either the full ARN or the name of the secret. When you are using the AWS 2325 // Management Console, you must specify the full ARN of the secret. 2326 // 2327 // This member is required. 2328 CredentialsParameter *string 2329} 2330 2331// Describes the resources available for a container instance. 2332type Resource struct { 2333 2334 // When the doubleValue type is set, the value of the resource must be a double 2335 // precision floating-point type. 2336 DoubleValue float64 2337 2338 // When the integerValue type is set, the value of the resource must be an integer. 2339 IntegerValue int32 2340 2341 // When the longValue type is set, the value of the resource must be an extended 2342 // precision floating-point type. 2343 LongValue int64 2344 2345 // The name of the resource, such as CPU, MEMORY, PORTS, PORTS_UDP, or a 2346 // user-defined resource. 2347 Name *string 2348 2349 // When the stringSetValue type is set, the value of the resource must be a string 2350 // type. 2351 StringSetValue []string 2352 2353 // The type of the resource, such as INTEGER, DOUBLE, LONG, or STRINGSET. 2354 Type *string 2355} 2356 2357// The type and amount of a resource to assign to a container. The supported 2358// resource types are GPUs and Elastic Inference accelerators. For more 2359// information, see Working with GPUs on Amazon ECS 2360// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-gpu.html) or 2361// Working with Amazon Elastic Inference on Amazon ECS 2362// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-eia.html) in 2363// the Amazon Elastic Container Service Developer Guide 2364type ResourceRequirement struct { 2365 2366 // The type of resource to assign to a container. The supported values are GPU or 2367 // InferenceAccelerator. 2368 // 2369 // This member is required. 2370 Type ResourceType 2371 2372 // The value for the specified resource type. If the GPU type is used, the value is 2373 // the number of physical GPUs the Amazon ECS container agent will reserve for the 2374 // container. The number of GPUs reserved for all containers in a task should not 2375 // exceed the number of available GPUs on the container instance the task is 2376 // launched on. If the InferenceAccelerator type is used, the value should match 2377 // the deviceName for an InferenceAccelerator specified in a task definition. 2378 // 2379 // This member is required. 2380 Value *string 2381} 2382 2383// A floating-point percentage of the desired number of tasks to place and keep 2384// running in the task set. 2385type Scale struct { 2386 2387 // The unit of measure for the scale value. 2388 Unit ScaleUnit 2389 2390 // The value, specified as a percent total of a service's desiredCount, to scale 2391 // the task set. Accepted values are numbers between 0 and 100. 2392 Value float64 2393} 2394 2395// An object representing the secret to expose to your container. Secrets can be 2396// exposed to a container in the following ways: 2397// 2398// * To inject sensitive data into 2399// your containers as environment variables, use the secrets container definition 2400// parameter. 2401// 2402// * To reference sensitive information in the log configuration of a 2403// container, use the secretOptions container definition parameter. 2404// 2405// For more 2406// information, see Specifying Sensitive Data 2407// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) 2408// in the Amazon Elastic Container Service Developer Guide. 2409type Secret struct { 2410 2411 // The name of the secret. 2412 // 2413 // This member is required. 2414 Name *string 2415 2416 // The secret to expose to the container. The supported values are either the full 2417 // ARN of the AWS Secrets Manager secret or the full ARN of the parameter in the 2418 // AWS Systems Manager Parameter Store. If the AWS Systems Manager Parameter Store 2419 // parameter exists in the same Region as the task you are launching, then you can 2420 // use either the full ARN or name of the parameter. If the parameter exists in a 2421 // different Region, then the full ARN must be specified. 2422 // 2423 // This member is required. 2424 ValueFrom *string 2425} 2426 2427// Details on a service within a cluster 2428type Service struct { 2429 2430 // The capacity provider strategy associated with the service. 2431 CapacityProviderStrategy []CapacityProviderStrategyItem 2432 2433 // The Amazon Resource Name (ARN) of the cluster that hosts the service. 2434 ClusterArn *string 2435 2436 // The Unix timestamp for when the service was created. 2437 CreatedAt *time.Time 2438 2439 // The principal that created the service. 2440 CreatedBy *string 2441 2442 // Optional deployment parameters that control how many tasks run during the 2443 // deployment and the ordering of stopping and starting tasks. 2444 DeploymentConfiguration *DeploymentConfiguration 2445 2446 // The deployment controller type the service is using. When using the 2447 // DescribeServices API, this field is omitted if the service is using the ECS 2448 // deployment controller type. 2449 DeploymentController *DeploymentController 2450 2451 // The current state of deployments for the service. 2452 Deployments []Deployment 2453 2454 // The desired number of instantiations of the task definition to keep running on 2455 // the service. This value is specified when the service is created with 2456 // CreateService, and it can be modified with UpdateService. 2457 DesiredCount int32 2458 2459 // Specifies whether to enable Amazon ECS managed tags for the tasks in the 2460 // service. For more information, see Tagging Your Amazon ECS Resources 2461 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html) 2462 // in the Amazon Elastic Container Service Developer Guide. 2463 EnableECSManagedTags bool 2464 2465 // The event stream for your service. A maximum of 100 of the latest events are 2466 // displayed. 2467 Events []ServiceEvent 2468 2469 // The period of time, in seconds, that the Amazon ECS service scheduler ignores 2470 // unhealthy Elastic Load Balancing target health checks after a task has first 2471 // started. 2472 HealthCheckGracePeriodSeconds *int32 2473 2474 // The launch type on which your service is running. If no value is specified, it 2475 // will default to EC2. Valid values include EC2 and FARGATE. For more information, 2476 // see Amazon ECS Launch Types 2477 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) 2478 // in the Amazon Elastic Container Service Developer Guide. 2479 LaunchType LaunchType 2480 2481 // A list of Elastic Load Balancing load balancer objects, containing the load 2482 // balancer name, the container name (as it appears in a container definition), and 2483 // the container port to access from the load balancer. 2484 LoadBalancers []LoadBalancer 2485 2486 // The VPC subnet and security group configuration for tasks that receive their own 2487 // elastic network interface by using the awsvpc networking mode. 2488 NetworkConfiguration *NetworkConfiguration 2489 2490 // The number of tasks in the cluster that are in the PENDING state. 2491 PendingCount int32 2492 2493 // The placement constraints for the tasks in the service. 2494 PlacementConstraints []PlacementConstraint 2495 2496 // The placement strategy that determines how tasks for the service are placed. 2497 PlacementStrategy []PlacementStrategy 2498 2499 // The platform version on which to run your service. A platform version is only 2500 // specified for tasks using the Fargate launch type. If one is not specified, the 2501 // LATEST platform version is used by default. For more information, see AWS 2502 // Fargate Platform Versions 2503 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html) 2504 // in the Amazon Elastic Container Service Developer Guide. 2505 PlatformVersion *string 2506 2507 // Specifies whether to propagate the tags from the task definition or the service 2508 // to the task. If no value is specified, the tags are not propagated. 2509 PropagateTags PropagateTags 2510 2511 // The ARN of the IAM role associated with the service that allows the Amazon ECS 2512 // container agent to register container instances with an Elastic Load Balancing 2513 // load balancer. 2514 RoleArn *string 2515 2516 // The number of tasks in the cluster that are in the RUNNING state. 2517 RunningCount int32 2518 2519 // The scheduling strategy to use for the service. For more information, see 2520 // Services 2521 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html). 2522 // There are two service scheduler strategies available: 2523 // 2524 // * REPLICA-The replica 2525 // scheduling strategy places and maintains the desired number of tasks across your 2526 // cluster. By default, the service scheduler spreads tasks across Availability 2527 // Zones. You can use task placement strategies and constraints to customize task 2528 // placement decisions. 2529 // 2530 // * DAEMON-The daemon scheduling strategy deploys exactly 2531 // one task on each active container instance that meets all of the task placement 2532 // constraints that you specify in your cluster. The service scheduler also 2533 // evaluates the task placement constraints for running tasks and will stop tasks 2534 // that do not meet the placement constraints. Fargate tasks do not support the 2535 // DAEMON scheduling strategy. 2536 SchedulingStrategy SchedulingStrategy 2537 2538 // The ARN that identifies the service. The ARN contains the arn:aws:ecs namespace, 2539 // followed by the Region of the service, the AWS account ID of the service owner, 2540 // the service namespace, and then the service name. For example, 2541 // arn:aws:ecs:region:012345678910:service/my-service. 2542 ServiceArn *string 2543 2544 // The name of your service. Up to 255 letters (uppercase and lowercase), numbers, 2545 // and hyphens are allowed. Service names must be unique within a cluster, but you 2546 // can have similarly named services in multiple clusters within a Region or across 2547 // multiple Regions. 2548 ServiceName *string 2549 2550 // The details of the service discovery registries to assign to this service. For 2551 // more information, see Service Discovery 2552 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html). 2553 ServiceRegistries []ServiceRegistry 2554 2555 // The status of the service. The valid values are ACTIVE, DRAINING, or INACTIVE. 2556 Status *string 2557 2558 // The metadata that you apply to the service to help you categorize and organize 2559 // them. Each tag consists of a key and an optional value, both of which you 2560 // define. The following basic restrictions apply to tags: 2561 // 2562 // * Maximum number of 2563 // tags per resource - 50 2564 // 2565 // * For each resource, each tag key must be unique, and 2566 // each tag key can have only one value. 2567 // 2568 // * Maximum key length - 128 Unicode 2569 // characters in UTF-8 2570 // 2571 // * Maximum value length - 256 Unicode characters in UTF-8 2572 // 2573 // * 2574 // If your tagging schema is used across multiple services and resources, remember 2575 // that other services may have restrictions on allowed characters. Generally 2576 // allowed characters are: letters, numbers, and spaces representable in UTF-8, and 2577 // the following characters: + - = . _ : / @. 2578 // 2579 // * Tag keys and values are 2580 // case-sensitive. 2581 // 2582 // * Do not use aws:, AWS:, or any upper or lowercase combination 2583 // of such as a prefix for either keys or values as it is reserved for AWS use. You 2584 // cannot edit or delete tag keys or values with this prefix. Tags with this prefix 2585 // do not count against your tags per resource limit. 2586 Tags []Tag 2587 2588 // The task definition to use for tasks in the service. This value is specified 2589 // when the service is created with CreateService, and it can be modified with 2590 // UpdateService. 2591 TaskDefinition *string 2592 2593 // Information about a set of Amazon ECS tasks in either an AWS CodeDeploy or an 2594 // EXTERNAL deployment. An Amazon ECS task set includes details such as the desired 2595 // number of tasks, how many tasks are running, and whether the task set serves 2596 // production traffic. 2597 TaskSets []TaskSet 2598} 2599 2600// Details on an event associated with a service. 2601type ServiceEvent struct { 2602 2603 // The Unix timestamp for when the event was triggered. 2604 CreatedAt *time.Time 2605 2606 // The ID string of the event. 2607 Id *string 2608 2609 // The event message. 2610 Message *string 2611} 2612 2613// Details of the service registry. 2614type ServiceRegistry struct { 2615 2616 // The container name value, already specified in the task definition, to be used 2617 // for your service discovery service. If the task definition that your service 2618 // task specifies uses the bridge or host network mode, you must specify a 2619 // containerName and containerPort combination from the task definition. If the 2620 // task definition that your service task specifies uses the awsvpc network mode 2621 // and a type SRV DNS record is used, you must specify either a containerName and 2622 // containerPort combination or a port value, but not both. 2623 ContainerName *string 2624 2625 // The port value, already specified in the task definition, to be used for your 2626 // service discovery service. If the task definition your service task specifies 2627 // uses the bridge or host network mode, you must specify a containerName and 2628 // containerPort combination from the task definition. If the task definition your 2629 // service task specifies uses the awsvpc network mode and a type SRV DNS record is 2630 // used, you must specify either a containerName and containerPort combination or a 2631 // port value, but not both. 2632 ContainerPort *int32 2633 2634 // The port value used if your service discovery service specified an SRV record. 2635 // This field may be used if both the awsvpc network mode and SRV records are used. 2636 Port *int32 2637 2638 // The Amazon Resource Name (ARN) of the service registry. The currently supported 2639 // service registry is AWS Cloud Map. For more information, see CreateService 2640 // (https://docs.aws.amazon.com/cloud-map/latest/api/API_CreateService.html). 2641 RegistryArn *string 2642} 2643 2644// The current account setting for a resource. 2645type Setting struct { 2646 2647 // The Amazon ECS resource name. 2648 Name SettingName 2649 2650 // The ARN of the principal, which can be an IAM user, IAM role, or the root user. 2651 // If this field is omitted, the authenticated user is assumed. 2652 PrincipalArn *string 2653 2654 // Whether the account setting is enabled or disabled for the specified resource. 2655 Value *string 2656} 2657 2658// A list of namespaced kernel parameters to set in the container. This parameter 2659// maps to Sysctls in the Create a container 2660// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of 2661// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the 2662// --sysctl option to docker run 2663// (https://docs.docker.com/engine/reference/run/#security-configuration). It is 2664// not recommended that you specify network-related systemControls parameters for 2665// multiple containers in a single task that also uses either the awsvpc or host 2666// network mode for the following reasons: 2667// 2668// * For tasks that use the awsvpc network 2669// mode, if you set systemControls for any container, it applies to all containers 2670// in the task. If you set different systemControls for multiple containers in a 2671// single task, the container that is started last determines which systemControls 2672// take effect. 2673// 2674// * For tasks that use the host network mode, the systemControls 2675// parameter applies to the container instance's kernel parameter as well as that 2676// of all containers of any tasks running on that container instance. 2677type SystemControl struct { 2678 2679 // The namespaced kernel parameter for which to set a value. 2680 Namespace *string 2681 2682 // The value for the namespaced kernel parameter specified in namespace. 2683 Value *string 2684} 2685 2686// The metadata that you apply to a resource to help you categorize and organize 2687// them. Each tag consists of a key and an optional value, both of which you 2688// define. The following basic restrictions apply to tags: 2689// 2690// * Maximum number of 2691// tags per resource - 50 2692// 2693// * For each resource, each tag key must be unique, and 2694// each tag key can have only one value. 2695// 2696// * Maximum key length - 128 Unicode 2697// characters in UTF-8 2698// 2699// * Maximum value length - 256 Unicode characters in UTF-8 2700// 2701// * 2702// If your tagging schema is used across multiple services and resources, remember 2703// that other services may have restrictions on allowed characters. Generally 2704// allowed characters are: letters, numbers, and spaces representable in UTF-8, and 2705// the following characters: + - = . _ : / @. 2706// 2707// * Tag keys and values are 2708// case-sensitive. 2709// 2710// * Do not use aws:, AWS:, or any upper or lowercase combination 2711// of such as a prefix for either keys or values as it is reserved for AWS use. You 2712// cannot edit or delete tag keys or values with this prefix. Tags with this prefix 2713// do not count against your tags per resource limit. 2714type Tag struct { 2715 2716 // One part of a key-value pair that make up a tag. A key is a general label that 2717 // acts like a category for more specific tag values. 2718 Key *string 2719 2720 // The optional part of a key-value pair that make up a tag. A value acts as a 2721 // descriptor within a tag category (key). 2722 Value *string 2723} 2724 2725// Details on a task in a cluster. 2726type Task struct { 2727 2728 // The Elastic Network Adapter associated with the task if the task uses the awsvpc 2729 // network mode. 2730 Attachments []Attachment 2731 2732 // The attributes of the task 2733 Attributes []Attribute 2734 2735 // The availability zone of the task. 2736 AvailabilityZone *string 2737 2738 // The capacity provider associated with the task. 2739 CapacityProviderName *string 2740 2741 // The ARN of the cluster that hosts the task. 2742 ClusterArn *string 2743 2744 // The connectivity status of a task. 2745 Connectivity Connectivity 2746 2747 // The Unix timestamp for when the task last went into CONNECTED status. 2748 ConnectivityAt *time.Time 2749 2750 // The ARN of the container instances that host the task. 2751 ContainerInstanceArn *string 2752 2753 // The containers associated with the task. 2754 Containers []Container 2755 2756 // The number of CPU units used by the task as expressed in a task definition. It 2757 // can be expressed as an integer using CPU units, for example 1024. It can also be 2758 // expressed as a string using vCPUs, for example 1 vCPU or 1 vcpu. String values 2759 // are converted to an integer indicating the CPU units when the task definition is 2760 // registered. If you are using the EC2 launch type, this field is optional. 2761 // Supported values are between 128 CPU units (0.125 vCPUs) and 10240 CPU units (10 2762 // vCPUs). If you are using the Fargate launch type, this field is required and you 2763 // must use one of the following values, which determines your range of supported 2764 // values for the memory parameter: 2765 // 2766 // * 256 (.25 vCPU) - Available memory values: 2767 // 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) 2768 // 2769 // * 512 (.5 vCPU) - Available memory 2770 // values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) 2771 // 2772 // * 1024 (1 vCPU) - 2773 // Available memory values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 2774 // 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) 2775 // 2776 // * 2048 (2 vCPU) - Available memory 2777 // values: Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) 2778 // 2779 // * 2780 // 4096 (4 vCPU) - Available memory values: Between 8192 (8 GB) and 30720 (30 GB) 2781 // in increments of 1024 (1 GB) 2782 Cpu *string 2783 2784 // The Unix timestamp for when the task was created (the task entered the PENDING 2785 // state). 2786 CreatedAt *time.Time 2787 2788 // The desired status of the task. For more information, see Task Lifecycle 2789 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html). 2790 DesiredStatus *string 2791 2792 // The Unix timestamp for when the task execution stopped. 2793 ExecutionStoppedAt *time.Time 2794 2795 // The name of the task group associated with the task. 2796 Group *string 2797 2798 // The health status for the task, which is determined by the health of the 2799 // essential containers in the task. If all essential containers in the task are 2800 // reporting as HEALTHY, then the task status also reports as HEALTHY. If any 2801 // essential containers in the task are reporting as UNHEALTHY or UNKNOWN, then the 2802 // task status also reports as UNHEALTHY or UNKNOWN, accordingly. The Amazon ECS 2803 // container agent does not monitor or report on Docker health checks that are 2804 // embedded in a container image (such as those specified in a parent image or from 2805 // the image's Dockerfile) and not specified in the container definition. Health 2806 // check parameters that are specified in a container definition override any 2807 // Docker health checks that exist in the container image. 2808 HealthStatus HealthStatus 2809 2810 // The Elastic Inference accelerator associated with the task. 2811 InferenceAccelerators []InferenceAccelerator 2812 2813 // The last known status of the task. For more information, see Task Lifecycle 2814 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html). 2815 LastStatus *string 2816 2817 // The launch type on which your task is running. For more information, see Amazon 2818 // ECS Launch Types 2819 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) 2820 // in the Amazon Elastic Container Service Developer Guide. 2821 LaunchType LaunchType 2822 2823 // The amount of memory (in MiB) used by the task as expressed in a task 2824 // definition. It can be expressed as an integer using MiB, for example 1024. It 2825 // can also be expressed as a string using GB, for example 1GB or 1 GB. String 2826 // values are converted to an integer indicating the MiB when the task definition 2827 // is registered. If you are using the EC2 launch type, this field is optional. If 2828 // you are using the Fargate launch type, this field is required and you must use 2829 // one of the following values, which determines your range of supported values for 2830 // the cpu parameter: 2831 // 2832 // * 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu 2833 // values: 256 (.25 vCPU) 2834 // 2835 // * 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - 2836 // Available cpu values: 512 (.5 vCPU) 2837 // 2838 // * 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 2839 // 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 2840 // (1 vCPU) 2841 // 2842 // * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - 2843 // Available cpu values: 2048 (2 vCPU) 2844 // 2845 // * Between 8192 (8 GB) and 30720 (30 GB) in 2846 // increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU) 2847 Memory *string 2848 2849 // One or more container overrides. 2850 Overrides *TaskOverride 2851 2852 // The platform version on which your task is running. A platform version is only 2853 // specified for tasks using the Fargate launch type. If one is not specified, the 2854 // LATEST platform version is used by default. For more information, see AWS 2855 // Fargate Platform Versions 2856 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html) 2857 // in the Amazon Elastic Container Service Developer Guide. 2858 PlatformVersion *string 2859 2860 // The Unix timestamp for when the container image pull began. 2861 PullStartedAt *time.Time 2862 2863 // The Unix timestamp for when the container image pull completed. 2864 PullStoppedAt *time.Time 2865 2866 // The Unix timestamp for when the task started (the task transitioned from the 2867 // PENDING state to the RUNNING state). 2868 StartedAt *time.Time 2869 2870 // The tag specified when a task is started. If the task is started by an Amazon 2871 // ECS service, then the startedBy parameter contains the deployment ID of the 2872 // service that starts it. 2873 StartedBy *string 2874 2875 // The stop code indicating why a task was stopped. The stoppedReason may contain 2876 // additional details. 2877 StopCode TaskStopCode 2878 2879 // The Unix timestamp for when the task was stopped (the task transitioned from the 2880 // RUNNING state to the STOPPED state). 2881 StoppedAt *time.Time 2882 2883 // The reason that the task was stopped. 2884 StoppedReason *string 2885 2886 // The Unix timestamp for when the task stops (transitions from the RUNNING state 2887 // to STOPPED). 2888 StoppingAt *time.Time 2889 2890 // The metadata that you apply to the task to help you categorize and organize 2891 // them. Each tag consists of a key and an optional value, both of which you 2892 // define. The following basic restrictions apply to tags: 2893 // 2894 // * Maximum number of 2895 // tags per resource - 50 2896 // 2897 // * For each resource, each tag key must be unique, and 2898 // each tag key can have only one value. 2899 // 2900 // * Maximum key length - 128 Unicode 2901 // characters in UTF-8 2902 // 2903 // * Maximum value length - 256 Unicode characters in UTF-8 2904 // 2905 // * 2906 // If your tagging schema is used across multiple services and resources, remember 2907 // that other services may have restrictions on allowed characters. Generally 2908 // allowed characters are: letters, numbers, and spaces representable in UTF-8, and 2909 // the following characters: + - = . _ : / @. 2910 // 2911 // * Tag keys and values are 2912 // case-sensitive. 2913 // 2914 // * Do not use aws:, AWS:, or any upper or lowercase combination 2915 // of such as a prefix for either keys or values as it is reserved for AWS use. You 2916 // cannot edit or delete tag keys or values with this prefix. Tags with this prefix 2917 // do not count against your tags per resource limit. 2918 Tags []Tag 2919 2920 // The Amazon Resource Name (ARN) of the task. 2921 TaskArn *string 2922 2923 // The ARN of the task definition that creates the task. 2924 TaskDefinitionArn *string 2925 2926 // The version counter for the task. Every time a task experiences a change that 2927 // triggers a CloudWatch event, the version counter is incremented. If you are 2928 // replicating your Amazon ECS task state with CloudWatch Events, you can compare 2929 // the version of a task reported by the Amazon ECS API actions with the version 2930 // reported in CloudWatch Events for the task (inside the detail object) to verify 2931 // that the version in your event stream is current. 2932 Version int64 2933} 2934 2935// The details of a task definition which describes the container and volume 2936// definitions of an Amazon Elastic Container Service task. You can specify which 2937// Docker images to use, the required resources, and other configurations related 2938// to launching the task definition through an Amazon ECS service or task. 2939type TaskDefinition struct { 2940 2941 // The launch type to use with your task. For more information, see Amazon ECS 2942 // Launch Types 2943 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) 2944 // in the Amazon Elastic Container Service Developer Guide. 2945 Compatibilities []Compatibility 2946 2947 // A list of container definitions in JSON format that describe the different 2948 // containers that make up your task. For more information about container 2949 // definition parameters and defaults, see Amazon ECS Task Definitions 2950 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html) 2951 // in the Amazon Elastic Container Service Developer Guide. 2952 ContainerDefinitions []ContainerDefinition 2953 2954 // The number of cpu units used by the task. If you are using the EC2 launch type, 2955 // this field is optional and any value can be used. If you are using the Fargate 2956 // launch type, this field is required and you must use one of the following 2957 // values, which determines your range of valid values for the memory parameter: 2958 // 2959 // * 2960 // 256 (.25 vCPU) - Available memory values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 2961 // GB) 2962 // 2963 // * 512 (.5 vCPU) - Available memory values: 1024 (1 GB), 2048 (2 GB), 3072 2964 // (3 GB), 4096 (4 GB) 2965 // 2966 // * 1024 (1 vCPU) - Available memory values: 2048 (2 GB), 2967 // 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) 2968 // 2969 // * 2970 // 2048 (2 vCPU) - Available memory values: Between 4096 (4 GB) and 16384 (16 GB) 2971 // in increments of 1024 (1 GB) 2972 // 2973 // * 4096 (4 vCPU) - Available memory values: Between 2974 // 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) 2975 Cpu *string 2976 2977 // The Amazon Resource Name (ARN) of the task execution role that grants the Amazon 2978 // ECS container agent permission to make AWS API calls on your behalf. The task 2979 // execution IAM role is required depending on the requirements of your task. For 2980 // more information, see Amazon ECS task execution IAM role 2981 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) 2982 // in the Amazon Elastic Container Service Developer Guide. 2983 ExecutionRoleArn *string 2984 2985 // The name of a family that this task definition is registered to. Up to 255 2986 // letters (uppercase and lowercase), numbers, hyphens, and underscores are 2987 // allowed. A family groups multiple versions of a task definition. Amazon ECS 2988 // gives the first task definition that you registered to a family a revision 2989 // number of 1. Amazon ECS gives sequential revision numbers to each task 2990 // definition that you add. 2991 Family *string 2992 2993 // The Elastic Inference accelerator associated with the task. 2994 InferenceAccelerators []InferenceAccelerator 2995 2996 // The IPC resource namespace to use for the containers in the task. The valid 2997 // values are host, task, or none. If host is specified, then all containers within 2998 // the tasks that specified the host IPC mode on the same container instance share 2999 // the same IPC resources with the host Amazon EC2 instance. If task is specified, 3000 // all containers within the specified task share the same IPC resources. If none 3001 // is specified, then IPC resources within the containers of a task are private and 3002 // not shared with other containers in a task or on the container instance. If no 3003 // value is specified, then the IPC resource namespace sharing depends on the 3004 // Docker daemon setting on the container instance. For more information, see IPC 3005 // settings (https://docs.docker.com/engine/reference/run/#ipc-settings---ipc) in 3006 // the Docker run reference. If the host IPC mode is used, be aware that there is a 3007 // heightened risk of undesired IPC namespace expose. For more information, see 3008 // Docker security (https://docs.docker.com/engine/security/security/). If you are 3009 // setting namespaced kernel parameters using systemControls for the containers in 3010 // the task, the following will apply to your IPC resource namespace. For more 3011 // information, see System Controls 3012 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html) 3013 // in the Amazon Elastic Container Service Developer Guide. 3014 // 3015 // * For tasks that use 3016 // the host IPC mode, IPC namespace related systemControls are not supported. 3017 // 3018 // * 3019 // For tasks that use the task IPC mode, IPC namespace related systemControls will 3020 // apply to all containers within a task. 3021 // 3022 // This parameter is not supported for 3023 // Windows containers or tasks using the Fargate launch type. 3024 IpcMode IpcMode 3025 3026 // The amount (in MiB) of memory used by the task. If using the EC2 launch type, 3027 // you must specify either a task-level memory value or a container-level memory 3028 // value. This field is optional and any value can be used. If a task-level memory 3029 // value is specified then the container-level memory value is optional. For more 3030 // information regarding container-level memory and memory reservation, see 3031 // ContainerDefinition 3032 // (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html). 3033 // If using the Fargate launch type, this field is required and you must use one of 3034 // the following values, which determines your range of valid values for the cpu 3035 // parameter: 3036 // 3037 // * 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 3038 // (.25 vCPU) 3039 // 3040 // * 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu 3041 // values: 512 (.5 vCPU) 3042 // 3043 // * 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 3044 // 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU) 3045 // 3046 // * 3047 // Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available 3048 // cpu values: 2048 (2 vCPU) 3049 // 3050 // * Between 8192 (8 GB) and 30720 (30 GB) in increments 3051 // of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU) 3052 Memory *string 3053 3054 // The Docker networking mode to use for the containers in the task. The valid 3055 // values are none, bridge, awsvpc, and host. If no network mode is specified, the 3056 // default is bridge. For Amazon ECS tasks on Fargate, the awsvpc network mode is 3057 // required. For Amazon ECS tasks on Amazon EC2 instances, any network mode can be 3058 // used. If the network mode is set to none, you cannot specify port mappings in 3059 // your container definitions, and the tasks containers do not have external 3060 // connectivity. The host and awsvpc network modes offer the highest networking 3061 // performance for containers because they use the EC2 network stack instead of the 3062 // virtualized network stack provided by the bridge mode. With the host and awsvpc 3063 // network modes, exposed container ports are mapped directly to the corresponding 3064 // host port (for the host network mode) or the attached elastic network interface 3065 // port (for the awsvpc network mode), so you cannot take advantage of dynamic host 3066 // port mappings. When using the host network mode, you should not run containers 3067 // using the root user (UID 0). It is considered best practice to use a non-root 3068 // user. If the network mode is awsvpc, the task is allocated an elastic network 3069 // interface, and you must specify a NetworkConfiguration value when you create a 3070 // service or run a task with the task definition. For more information, see Task 3071 // Networking 3072 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) 3073 // in the Amazon Elastic Container Service Developer Guide. Currently, only Amazon 3074 // ECS-optimized AMIs, other Amazon Linux variants with the ecs-init package, or 3075 // AWS Fargate infrastructure support the awsvpc network mode. If the network mode 3076 // is host, you cannot run multiple instantiations of the same task on a single 3077 // container instance when port mappings are used. Docker for Windows uses 3078 // different network modes than Docker for Linux. When you register a task 3079 // definition with Windows containers, you must not specify a network mode. If you 3080 // use the console to register a task definition with Windows containers, you must 3081 // choose the network mode object. For more information, see Network settings 3082 // (https://docs.docker.com/engine/reference/run/#network-settings) in the Docker 3083 // run reference. 3084 NetworkMode NetworkMode 3085 3086 // The process namespace to use for the containers in the task. The valid values 3087 // are host or task. If host is specified, then all containers within the tasks 3088 // that specified the host PID mode on the same container instance share the same 3089 // process namespace with the host Amazon EC2 instance. If task is specified, all 3090 // containers within the specified task share the same process namespace. If no 3091 // value is specified, the default is a private namespace. For more information, 3092 // see PID settings 3093 // (https://docs.docker.com/engine/reference/run/#pid-settings---pid) in the Docker 3094 // run reference. If the host PID mode is used, be aware that there is a heightened 3095 // risk of undesired process namespace expose. For more information, see Docker 3096 // security (https://docs.docker.com/engine/security/security/). This parameter is 3097 // not supported for Windows containers or tasks using the Fargate launch type. 3098 PidMode PidMode 3099 3100 // An array of placement constraint objects to use for tasks. This field is not 3101 // valid if you are using the Fargate launch type for your task. 3102 PlacementConstraints []TaskDefinitionPlacementConstraint 3103 3104 // The configuration details for the App Mesh proxy. Your Amazon ECS container 3105 // instances require at least version 1.26.0 of the container agent and at least 3106 // version 1.26.0-1 of the ecs-init package to enable a proxy configuration. If 3107 // your container instances are launched from the Amazon ECS-optimized AMI version 3108 // 20190301 or later, then they contain the required versions of the container 3109 // agent and ecs-init. For more information, see Amazon ECS-optimized Linux AMI 3110 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) 3111 // in the Amazon Elastic Container Service Developer Guide. 3112 ProxyConfiguration *ProxyConfiguration 3113 3114 // The container instance attributes required by your task. This field is not valid 3115 // if you are using the Fargate launch type for your task. 3116 RequiresAttributes []Attribute 3117 3118 // The launch type the task requires. If no value is specified, it will default to 3119 // EC2. Valid values include EC2 and FARGATE. 3120 RequiresCompatibilities []Compatibility 3121 3122 // The revision of the task in a particular family. The revision is a version 3123 // number of a task definition in a family. When you register a task definition for 3124 // the first time, the revision is 1. Each time that you register a new revision of 3125 // a task definition in the same family, the revision value always increases by 3126 // one, even if you have deregistered previous revisions in this family. 3127 Revision int32 3128 3129 // The status of the task definition. 3130 Status TaskDefinitionStatus 3131 3132 // The full Amazon Resource Name (ARN) of the task definition. 3133 TaskDefinitionArn *string 3134 3135 // The short name or full Amazon Resource Name (ARN) of the AWS Identity and Access 3136 // Management (IAM) role that grants containers in the task permission to call AWS 3137 // APIs on your behalf. For more information, see Amazon ECS Task Role 3138 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) 3139 // in the Amazon Elastic Container Service Developer Guide. IAM roles for tasks on 3140 // Windows require that the -EnableTaskIAMRole option is set when you launch the 3141 // Amazon ECS-optimized Windows AMI. Your containers must also run some 3142 // configuration code in order to take advantage of the feature. For more 3143 // information, see Windows IAM Roles for Tasks 3144 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows_task_IAM_roles.html) 3145 // in the Amazon Elastic Container Service Developer Guide. 3146 TaskRoleArn *string 3147 3148 // The list of volume definitions for the task. If your tasks are using the Fargate 3149 // launch type, the host and sourcePath parameters are not supported. For more 3150 // information about volume definition parameters and defaults, see Amazon ECS Task 3151 // Definitions 3152 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html) 3153 // in the Amazon Elastic Container Service Developer Guide. 3154 Volumes []Volume 3155} 3156 3157// An object representing a constraint on task placement in the task definition. 3158// For more information, see Task Placement Constraints 3159// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html) 3160// in the Amazon Elastic Container Service Developer Guide. If you are using the 3161// Fargate launch type, task placement constraints are not supported. 3162type TaskDefinitionPlacementConstraint struct { 3163 3164 // A cluster query language expression to apply to the constraint. For more 3165 // information, see Cluster Query Language 3166 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html) 3167 // in the Amazon Elastic Container Service Developer Guide. 3168 Expression *string 3169 3170 // The type of constraint. The MemberOf constraint restricts selection to be from a 3171 // group of valid candidates. 3172 Type TaskDefinitionPlacementConstraintType 3173} 3174 3175// The overrides associated with a task. 3176type TaskOverride struct { 3177 3178 // One or more container overrides sent to a task. 3179 ContainerOverrides []ContainerOverride 3180 3181 // The cpu override for the task. 3182 Cpu *string 3183 3184 // The Amazon Resource Name (ARN) of the task execution IAM role override for the 3185 // task. 3186 ExecutionRoleArn *string 3187 3188 // The Elastic Inference accelerator override for the task. 3189 InferenceAcceleratorOverrides []InferenceAcceleratorOverride 3190 3191 // The memory override for the task. 3192 Memory *string 3193 3194 // The Amazon Resource Name (ARN) of the IAM role that containers in this task can 3195 // assume. All containers in this task are granted the permissions that are 3196 // specified in this role. 3197 TaskRoleArn *string 3198} 3199 3200// Information about a set of Amazon ECS tasks in either an AWS CodeDeploy or an 3201// EXTERNAL deployment. An Amazon ECS task set includes details such as the desired 3202// number of tasks, how many tasks are running, and whether the task set serves 3203// production traffic. 3204type TaskSet struct { 3205 3206 // The capacity provider strategy associated with the task set. 3207 CapacityProviderStrategy []CapacityProviderStrategyItem 3208 3209 // The Amazon Resource Name (ARN) of the cluster that the service that hosts the 3210 // task set exists in. 3211 ClusterArn *string 3212 3213 // The computed desired count for the task set. This is calculated by multiplying 3214 // the service's desiredCount by the task set's scale percentage. The result is 3215 // always rounded up. For example, if the computed desired count is 1.2, it rounds 3216 // up to 2 tasks. 3217 ComputedDesiredCount int32 3218 3219 // The Unix timestamp for when the task set was created. 3220 CreatedAt *time.Time 3221 3222 // The external ID associated with the task set. If a task set is created by an AWS 3223 // CodeDeploy deployment, the externalId parameter contains the AWS CodeDeploy 3224 // deployment ID. If a task set is created for an external deployment and is 3225 // associated with a service discovery registry, the externalId parameter contains 3226 // the ECS_TASK_SET_EXTERNAL_ID AWS Cloud Map attribute. 3227 ExternalId *string 3228 3229 // The ID of the task set. 3230 Id *string 3231 3232 // The launch type the tasks in the task set are using. For more information, see 3233 // Amazon ECS Launch Types 3234 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) 3235 // in the Amazon Elastic Container Service Developer Guide. 3236 LaunchType LaunchType 3237 3238 // Details on a load balancer that is used with a task set. 3239 LoadBalancers []LoadBalancer 3240 3241 // The network configuration for the task set. 3242 NetworkConfiguration *NetworkConfiguration 3243 3244 // The number of tasks in the task set that are in the PENDING status during a 3245 // deployment. A task in the PENDING state is preparing to enter the RUNNING state. 3246 // A task set enters the PENDING status when it launches for the first time or when 3247 // it is restarted after being in the STOPPED state. 3248 PendingCount int32 3249 3250 // The platform version on which the tasks in the task set are running. A platform 3251 // version is only specified for tasks using the Fargate launch type. If one is not 3252 // specified, the LATEST platform version is used by default. For more information, 3253 // see AWS Fargate Platform Versions 3254 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html) 3255 // in the Amazon Elastic Container Service Developer Guide. 3256 PlatformVersion *string 3257 3258 // The number of tasks in the task set that are in the RUNNING status during a 3259 // deployment. A task in the RUNNING state is running and ready for use. 3260 RunningCount int32 3261 3262 // A floating-point percentage of the desired number of tasks to place and keep 3263 // running in the task set. 3264 Scale *Scale 3265 3266 // The Amazon Resource Name (ARN) of the service the task set exists in. 3267 ServiceArn *string 3268 3269 // The details of the service discovery registries to assign to this task set. For 3270 // more information, see Service Discovery 3271 // (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html). 3272 ServiceRegistries []ServiceRegistry 3273 3274 // The stability status, which indicates whether the task set has reached a steady 3275 // state. If the following conditions are met, the task set will be in 3276 // STEADY_STATE: 3277 // 3278 // * The task runningCount is equal to the computedDesiredCount. 3279 // 3280 // * 3281 // The pendingCount is 0. 3282 // 3283 // * There are no tasks running on container instances in 3284 // the DRAINING status. 3285 // 3286 // * All tasks are reporting a healthy status from the load 3287 // balancers, service discovery, and container health checks. 3288 // 3289 // If any of those 3290 // conditions are not met, the stability status returns STABILIZING. 3291 StabilityStatus StabilityStatus 3292 3293 // The Unix timestamp for when the task set stability status was retrieved. 3294 StabilityStatusAt *time.Time 3295 3296 // The tag specified when a task set is started. If the task set is created by an 3297 // AWS CodeDeploy deployment, the startedBy parameter is CODE_DEPLOY. For a task 3298 // set created for an external deployment, the startedBy field isn't used. 3299 StartedBy *string 3300 3301 // The status of the task set. The following describes each state: PRIMARY The task 3302 // set is serving production traffic. ACTIVE The task set is not serving production 3303 // traffic. DRAINING The tasks in the task set are being stopped and their 3304 // corresponding targets are being deregistered from their target group. 3305 Status *string 3306 3307 // The metadata that you apply to the task set to help you categorize and organize 3308 // them. Each tag consists of a key and an optional value, both of which you 3309 // define. The following basic restrictions apply to tags: 3310 // 3311 // * Maximum number of 3312 // tags per resource - 50 3313 // 3314 // * For each resource, each tag key must be unique, and 3315 // each tag key can have only one value. 3316 // 3317 // * Maximum key length - 128 Unicode 3318 // characters in UTF-8 3319 // 3320 // * Maximum value length - 256 Unicode characters in UTF-8 3321 // 3322 // * 3323 // If your tagging schema is used across multiple services and resources, remember 3324 // that other services may have restrictions on allowed characters. Generally 3325 // allowed characters are: letters, numbers, and spaces representable in UTF-8, and 3326 // the following characters: + - = . _ : / @. 3327 // 3328 // * Tag keys and values are 3329 // case-sensitive. 3330 // 3331 // * Do not use aws:, AWS:, or any upper or lowercase combination 3332 // of such as a prefix for either keys or values as it is reserved for AWS use. You 3333 // cannot edit or delete tag keys or values with this prefix. Tags with this prefix 3334 // do not count against your tags per resource limit. 3335 Tags []Tag 3336 3337 // The task definition the task set is using. 3338 TaskDefinition *string 3339 3340 // The Amazon Resource Name (ARN) of the task set. 3341 TaskSetArn *string 3342 3343 // The Unix timestamp for when the task set was last updated. 3344 UpdatedAt *time.Time 3345} 3346 3347// The container path, mount options, and size of the tmpfs mount. 3348type Tmpfs struct { 3349 3350 // The absolute file path where the tmpfs volume is to be mounted. 3351 // 3352 // This member is required. 3353 ContainerPath *string 3354 3355 // The maximum size (in MiB) of the tmpfs volume. 3356 // 3357 // This member is required. 3358 Size int32 3359 3360 // The list of tmpfs volume mount options. Valid values: "defaults" | "ro" | "rw" | 3361 // "suid" | "nosuid" | "dev" | "nodev" | "exec" | "noexec" | "sync" | "async" | 3362 // "dirsync" | "remount" | "mand" | "nomand" | "atime" | "noatime" | "diratime" | 3363 // "nodiratime" | "bind" | "rbind" | "unbindable" | "runbindable" | "private" | 3364 // "rprivate" | "shared" | "rshared" | "slave" | "rslave" | "relatime" | 3365 // "norelatime" | "strictatime" | "nostrictatime" | "mode" | "uid" | "gid" | 3366 // "nr_inodes" | "nr_blocks" | "mpol" 3367 MountOptions []string 3368} 3369 3370// The ulimit settings to pass to the container. 3371type Ulimit struct { 3372 3373 // The hard limit for the ulimit type. 3374 // 3375 // This member is required. 3376 HardLimit int32 3377 3378 // The type of the ulimit. 3379 // 3380 // This member is required. 3381 Name UlimitName 3382 3383 // The soft limit for the ulimit type. 3384 // 3385 // This member is required. 3386 SoftLimit int32 3387} 3388 3389// The Docker and Amazon ECS container agent version information about a container 3390// instance. 3391type VersionInfo struct { 3392 3393 // The Git commit hash for the Amazon ECS container agent build on the 3394 // amazon-ecs-agent (https://github.com/aws/amazon-ecs-agent/commits/master) 3395 // GitHub repository. 3396 AgentHash *string 3397 3398 // The version number of the Amazon ECS container agent. 3399 AgentVersion *string 3400 3401 // The Docker version running on the container instance. 3402 DockerVersion *string 3403} 3404 3405// A data volume used in a task definition. For tasks that use the Amazon Elastic 3406// File System (Amazon EFS), specify an efsVolumeConfiguration. For Windows tasks 3407// that use Amazon FSx for Windows File Server file system, specify a 3408// fsxWindowsFileServerVolumeConfiguration. For tasks that use a Docker volume, 3409// specify a DockerVolumeConfiguration. For tasks that use a bind mount host 3410// volume, specify a host and optional sourcePath. For more information, see Using 3411// Data Volumes in Tasks 3412// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html). 3413type Volume struct { 3414 3415 // This parameter is specified when you are using Docker volumes. Docker volumes 3416 // are only supported when you are using the EC2 launch type. Windows containers 3417 // only support the use of the local driver. To use bind mounts, specify the host 3418 // parameter instead. 3419 DockerVolumeConfiguration *DockerVolumeConfiguration 3420 3421 // This parameter is specified when you are using an Amazon Elastic File System 3422 // file system for task storage. 3423 EfsVolumeConfiguration *EFSVolumeConfiguration 3424 3425 // This parameter is specified when you are using Amazon FSx for Windows File 3426 // Server file system for task storage. 3427 FsxWindowsFileServerVolumeConfiguration *FSxWindowsFileServerVolumeConfiguration 3428 3429 // This parameter is specified when you are using bind mount host volumes. The 3430 // contents of the host parameter determine whether your bind mount host volume 3431 // persists on the host container instance and where it is stored. If the host 3432 // parameter is empty, then the Docker daemon assigns a host path for your data 3433 // volume. However, the data is not guaranteed to persist after the containers 3434 // associated with it stop running. Windows containers can mount whole directories 3435 // on the same drive as $env:ProgramData. Windows containers cannot mount 3436 // directories on a different drive, and mount point cannot be across drives. For 3437 // example, you can mount C:\my\path:C:\my\path and D:\:D:\, but not 3438 // D:\my\path:C:\my\path or D:\:C:\my\path. 3439 Host *HostVolumeProperties 3440 3441 // The name of the volume. Up to 255 letters (uppercase and lowercase), numbers, 3442 // and hyphens are allowed. This name is referenced in the sourceVolume parameter 3443 // of container definition mountPoints. 3444 Name *string 3445} 3446 3447// Details on a data volume from another container in the same task definition. 3448type VolumeFrom struct { 3449 3450 // If this value is true, the container has read-only access to the volume. If this 3451 // value is false, then the container can write to the volume. The default value is 3452 // false. 3453 ReadOnly *bool 3454 3455 // The name of another container within the same task definition from which to 3456 // mount volumes. 3457 SourceContainer *string 3458} 3459