Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException

type AccessDeniedException struct {
	Message *string
}

    You do not have authorization to perform the requested action.

    func (*AccessDeniedException) Error

    func (e *AccessDeniedException) Error() string

    func (*AccessDeniedException) ErrorCode

    func (e *AccessDeniedException) ErrorCode() string

    func (*AccessDeniedException) ErrorFault

    func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault

    func (*AccessDeniedException) ErrorMessage

    func (e *AccessDeniedException) ErrorMessage() string

    type AgentUpdateStatus

    type AgentUpdateStatus string
    const (
    	AgentUpdateStatusPending  AgentUpdateStatus = "PENDING"
    	AgentUpdateStatusStaging  AgentUpdateStatus = "STAGING"
    	AgentUpdateStatusStaged   AgentUpdateStatus = "STAGED"
    	AgentUpdateStatusUpdating AgentUpdateStatus = "UPDATING"
    	AgentUpdateStatusUpdated  AgentUpdateStatus = "UPDATED"
    	AgentUpdateStatusFailed   AgentUpdateStatus = "FAILED"
    )

      Enum values for AgentUpdateStatus

      func (AgentUpdateStatus) Values

        Values returns all known values for AgentUpdateStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

        type AssignPublicIp

        type AssignPublicIp string
        const (
        	AssignPublicIpEnabled  AssignPublicIp = "ENABLED"
        	AssignPublicIpDisabled AssignPublicIp = "DISABLED"
        )

          Enum values for AssignPublicIp

          func (AssignPublicIp) Values

          func (AssignPublicIp) Values() []AssignPublicIp

            Values returns all known values for AssignPublicIp. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

            type Attachment

            type Attachment struct {
            
            	// Details of the attachment. For elastic network interfaces, this includes the
            	// network interface ID, the MAC address, the subnet ID, and the private IPv4
            	// address.
            	Details []KeyValuePair
            
            	// The unique identifier for the attachment.
            	Id *string
            
            	// The status of the attachment. Valid values are PRECREATED, CREATED, ATTACHING,
            	// ATTACHED, DETACHING, DETACHED, and DELETED.
            	Status *string
            
            	// The type of the attachment, such as ElasticNetworkInterface.
            	Type *string
            }

              An object representing a container instance or task attachment.

              type AttachmentStateChange

              type AttachmentStateChange struct {
              
              	// The Amazon Resource Name (ARN) of the attachment.
              	//
              	// This member is required.
              	AttachmentArn *string
              
              	// The status of the attachment.
              	//
              	// This member is required.
              	Status *string
              }

                An object representing a change in state for a task attachment.

                type Attribute

                type Attribute struct {
                
                	// The name of the attribute. The name must contain between 1 and 128 characters
                	// and name may contain letters (uppercase and lowercase), numbers, hyphens,
                	// underscores, forward slashes, back slashes, or periods.
                	//
                	// This member is required.
                	Name *string
                
                	// The ID of the target. You can specify the short form ID for a resource or the
                	// full Amazon Resource Name (ARN).
                	TargetId *string
                
                	// The type of the target with which to attach the attribute. This parameter is
                	// required if you use the short form ID for a resource instead of the full ARN.
                	TargetType TargetType
                
                	// The value of the attribute. The value must contain between 1 and 128 characters
                	// and may contain letters (uppercase and lowercase), numbers, hyphens,
                	// underscores, periods, at signs (@), forward slashes, back slashes, colons, or
                	// spaces. The value cannot contain any leading or trailing whitespace.
                	Value *string
                }

                  An attribute is a name-value pair associated with an Amazon ECS object. Attributes enable you to extend the Amazon ECS data model by adding custom metadata to your resources. For more information, see Attributes (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html#attributes) in the Amazon Elastic Container Service Developer Guide.

                  type AttributeLimitExceededException

                  type AttributeLimitExceededException struct {
                  	Message *string
                  }

                    You can apply up to 10 custom attributes per resource. You can view the attributes of a resource with ListAttributes. You can remove existing attributes on a resource with DeleteAttributes.

                    func (*AttributeLimitExceededException) Error

                    func (*AttributeLimitExceededException) ErrorCode

                    func (e *AttributeLimitExceededException) ErrorCode() string

                    func (*AttributeLimitExceededException) ErrorFault

                    func (*AttributeLimitExceededException) ErrorMessage

                    func (e *AttributeLimitExceededException) ErrorMessage() string

                    type AutoScalingGroupProvider

                    type AutoScalingGroupProvider struct {
                    
                    	// The Amazon Resource Name (ARN) that identifies the Auto Scaling group.
                    	//
                    	// This member is required.
                    	AutoScalingGroupArn *string
                    
                    	// The managed scaling settings for the Auto Scaling group capacity provider.
                    	ManagedScaling *ManagedScaling
                    
                    	// The managed termination protection setting to use for the Auto Scaling group
                    	// capacity provider. This determines whether the Auto Scaling group has managed
                    	// termination protection. When using managed termination protection, managed
                    	// scaling must also be used otherwise managed termination protection will not
                    	// work. When managed termination protection is enabled, Amazon ECS prevents the
                    	// Amazon EC2 instances in an Auto Scaling group that contain tasks from being
                    	// terminated during a scale-in action. The Auto Scaling group and each instance in
                    	// the Auto Scaling group must have instance protection from scale-in actions
                    	// enabled as well. For more information, see Instance Protection
                    	// (https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html#instance-protection)
                    	// in the AWS Auto Scaling User Guide. When managed termination protection is
                    	// disabled, your Amazon EC2 instances are not protected from termination when the
                    	// Auto Scaling group scales in.
                    	ManagedTerminationProtection ManagedTerminationProtection
                    }

                      The details of the Auto Scaling group for the capacity provider.

                      type AutoScalingGroupProviderUpdate

                      type AutoScalingGroupProviderUpdate struct {
                      
                      	// The managed scaling settings for the Auto Scaling group capacity provider. When
                      	// managed scaling is enabled, Amazon ECS manages the scale-in and scale-out
                      	// actions of the Auto Scaling group. Amazon ECS manages a target tracking scaling
                      	// policy using an Amazon ECS-managed CloudWatch metric with the specified
                      	// targetCapacity value as the target value for the metric. For more information,
                      	// see Using Managed Scaling
                      	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/asg-capacity-providers.html#asg-capacity-providers-managed-scaling)
                      	// in the Amazon Elastic Container Service Developer Guide. If managed scaling is
                      	// disabled, the user must manage the scaling of the Auto Scaling group.
                      	ManagedScaling *ManagedScaling
                      
                      	// The managed termination protection setting to use for the Auto Scaling group
                      	// capacity provider. This determines whether the Auto Scaling group has managed
                      	// termination protection. When using managed termination protection, managed
                      	// scaling must also be used otherwise managed termination protection will not
                      	// work. When managed termination protection is enabled, Amazon ECS prevents the
                      	// Amazon EC2 instances in an Auto Scaling group that contain tasks from being
                      	// terminated during a scale-in action. The Auto Scaling group and each instance in
                      	// the Auto Scaling group must have instance protection from scale-in actions
                      	// enabled as well. For more information, see Instance Protection
                      	// (https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html#instance-protection)
                      	// in the AWS Auto Scaling User Guide. When managed termination protection is
                      	// disabled, your Amazon EC2 instances are not protected from termination when the
                      	// Auto Scaling group scales in.
                      	ManagedTerminationProtection ManagedTerminationProtection
                      }

                        The details of the Auto Scaling group capacity provider to update.

                        type AwsVpcConfiguration

                        type AwsVpcConfiguration struct {
                        
                        	// The IDs of the subnets associated with the task or service. There is a limit of
                        	// 16 subnets that can be specified per AwsVpcConfiguration. All specified subnets
                        	// must be from the same VPC.
                        	//
                        	// This member is required.
                        	Subnets []string
                        
                        	// Whether the task's elastic network interface receives a public IP address. The
                        	// default value is DISABLED.
                        	AssignPublicIp AssignPublicIp
                        
                        	// The IDs of the security groups associated with the task or service. If you do
                        	// not specify a security group, the default security group for the VPC is used.
                        	// There is a limit of 5 security groups that can be specified per
                        	// AwsVpcConfiguration. All specified security groups must be from the same VPC.
                        	SecurityGroups []string
                        }

                          An object representing the networking details for a task or service.

                          type BlockedException

                          type BlockedException struct {
                          	Message *string
                          }

                            Your AWS account has been blocked. For more information, contact AWS Support (http://aws.amazon.com/contact-us/).

                            func (*BlockedException) Error

                            func (e *BlockedException) Error() string

                            func (*BlockedException) ErrorCode

                            func (e *BlockedException) ErrorCode() string

                            func (*BlockedException) ErrorFault

                            func (e *BlockedException) ErrorFault() smithy.ErrorFault

                            func (*BlockedException) ErrorMessage

                            func (e *BlockedException) ErrorMessage() string

                            type CapacityProvider

                            type CapacityProvider struct {
                            
                            	// The Auto Scaling group settings for the capacity provider.
                            	AutoScalingGroupProvider *AutoScalingGroupProvider
                            
                            	// The Amazon Resource Name (ARN) that identifies the capacity provider.
                            	CapacityProviderArn *string
                            
                            	// The name of the capacity provider.
                            	Name *string
                            
                            	// The current status of the capacity provider. Only capacity providers in an
                            	// ACTIVE state can be used in a cluster. When a capacity provider is successfully
                            	// deleted, it will have an INACTIVE status.
                            	Status CapacityProviderStatus
                            
                            	// The metadata that you apply to the capacity provider to help you categorize and
                            	// organize it. Each tag consists of a key and an optional value, both of which you
                            	// define. The following basic restrictions apply to tags:
                            	//
                            	// * Maximum number of
                            	// tags per resource - 50
                            	//
                            	// * For each resource, each tag key must be unique, and
                            	// each tag key can have only one value.
                            	//
                            	// * Maximum key length - 128 Unicode
                            	// characters in UTF-8
                            	//
                            	// * Maximum value length - 256 Unicode characters in UTF-8
                            	//
                            	// *
                            	// If your tagging schema is used across multiple services and resources, remember
                            	// that other services may have restrictions on allowed characters. Generally
                            	// allowed characters are: letters, numbers, and spaces representable in UTF-8, and
                            	// the following characters: + - = . _ : / @.
                            	//
                            	// * Tag keys and values are
                            	// case-sensitive.
                            	//
                            	// * Do not use aws:, AWS:, or any upper or lowercase combination
                            	// of such as a prefix for either keys or values as it is reserved for AWS use. You
                            	// cannot edit or delete tag keys or values with this prefix. Tags with this prefix
                            	// do not count against your tags per resource limit.
                            	Tags []Tag
                            
                            	// The update status of the capacity provider. The following are the possible
                            	// states that will be returned. DELETE_IN_PROGRESS The capacity provider is in the
                            	// process of being deleted. DELETE_COMPLETE The capacity provider has been
                            	// successfully deleted and will have an INACTIVE status. DELETE_FAILED The
                            	// capacity provider was unable to be deleted. The update status reason will
                            	// provide further details about why the delete failed.
                            	UpdateStatus CapacityProviderUpdateStatus
                            
                            	// The update status reason. This provides further details about the update status
                            	// for the capacity provider.
                            	UpdateStatusReason *string
                            }

                              The details of a capacity provider.

                              type CapacityProviderField

                              type CapacityProviderField string
                              const (
                              	CapacityProviderFieldTags CapacityProviderField = "TAGS"
                              )

                                Enum values for CapacityProviderField

                                func (CapacityProviderField) Values

                                  Values returns all known values for CapacityProviderField. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                  type CapacityProviderStatus

                                  type CapacityProviderStatus string
                                  const (
                                  	CapacityProviderStatusActive   CapacityProviderStatus = "ACTIVE"
                                  	CapacityProviderStatusInactive CapacityProviderStatus = "INACTIVE"
                                  )

                                    Enum values for CapacityProviderStatus

                                    func (CapacityProviderStatus) Values

                                      Values returns all known values for CapacityProviderStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                      type CapacityProviderStrategyItem

                                      type CapacityProviderStrategyItem struct {
                                      
                                      	// The short name of the capacity provider.
                                      	//
                                      	// This member is required.
                                      	CapacityProvider *string
                                      
                                      	// The base value designates how many tasks, at a minimum, to run on the specified
                                      	// capacity provider. Only one capacity provider in a capacity provider strategy
                                      	// can have a base defined.
                                      	Base int32
                                      
                                      	// The weight value designates the relative percentage of the total number of tasks
                                      	// launched that should use the specified capacity provider. For example, if you
                                      	// have a strategy that contains two capacity providers and both have a weight of
                                      	// 1, then when the base is satisfied, the tasks will be split evenly across the
                                      	// two capacity providers. Using that same logic, if you specify a weight of 1 for
                                      	// capacityProviderA and a weight of 4 for capacityProviderB, then for every one
                                      	// task that is run using capacityProviderA, four tasks would use
                                      	// capacityProviderB.
                                      	Weight int32
                                      }

                                        The details of a capacity provider strategy.

                                        type CapacityProviderUpdateStatus

                                        type CapacityProviderUpdateStatus string
                                        const (
                                        	CapacityProviderUpdateStatusDeleteInProgress CapacityProviderUpdateStatus = "DELETE_IN_PROGRESS"
                                        	CapacityProviderUpdateStatusDeleteComplete   CapacityProviderUpdateStatus = "DELETE_COMPLETE"
                                        	CapacityProviderUpdateStatusDeleteFailed     CapacityProviderUpdateStatus = "DELETE_FAILED"
                                        	CapacityProviderUpdateStatusUpdateInProgress CapacityProviderUpdateStatus = "UPDATE_IN_PROGRESS"
                                        	CapacityProviderUpdateStatusUpdateComplete   CapacityProviderUpdateStatus = "UPDATE_COMPLETE"
                                        	CapacityProviderUpdateStatusUpdateFailed     CapacityProviderUpdateStatus = "UPDATE_FAILED"
                                        )

                                          Enum values for CapacityProviderUpdateStatus

                                          func (CapacityProviderUpdateStatus) Values

                                            Values returns all known values for CapacityProviderUpdateStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                            type ClientException

                                            type ClientException struct {
                                            	Message *string
                                            }

                                              These errors are usually caused by a client action, such as using an action or resource on behalf of a user that doesn't have permissions to use the action or resource, or specifying an identifier that is not valid.

                                              func (*ClientException) Error

                                              func (e *ClientException) Error() string

                                              func (*ClientException) ErrorCode

                                              func (e *ClientException) ErrorCode() string

                                              func (*ClientException) ErrorFault

                                              func (e *ClientException) ErrorFault() smithy.ErrorFault

                                              func (*ClientException) ErrorMessage

                                              func (e *ClientException) ErrorMessage() string

                                              type Cluster

                                              type Cluster struct {
                                              
                                              	// The number of services that are running on the cluster in an ACTIVE state. You
                                              	// can view these services with ListServices.
                                              	ActiveServicesCount int32
                                              
                                              	// The resources attached to a cluster. When using a capacity provider with a
                                              	// cluster, the Auto Scaling plan that is created will be returned as a cluster
                                              	// attachment.
                                              	Attachments []Attachment
                                              
                                              	// The status of the capacity providers associated with the cluster. The following
                                              	// are the states that will be returned: UPDATE_IN_PROGRESS The available capacity
                                              	// providers for the cluster are updating. This occurs when the Auto Scaling plan
                                              	// is provisioning or deprovisioning. UPDATE_COMPLETE The capacity providers have
                                              	// successfully updated. UPDATE_FAILED The capacity provider updates failed.
                                              	AttachmentsStatus *string
                                              
                                              	// The capacity providers associated with the cluster.
                                              	CapacityProviders []string
                                              
                                              	// The Amazon Resource Name (ARN) that identifies the cluster. The ARN contains the
                                              	// arn:aws:ecs namespace, followed by the Region of the cluster, the AWS account ID
                                              	// of the cluster owner, the cluster namespace, and then the cluster name. For
                                              	// example, arn:aws:ecs:region:012345678910:cluster/test.
                                              	ClusterArn *string
                                              
                                              	// A user-generated string that you use to identify your cluster.
                                              	ClusterName *string
                                              
                                              	// The default capacity provider strategy for the cluster. When services or tasks
                                              	// are run in the cluster with no launch type or capacity provider strategy
                                              	// specified, the default capacity provider strategy is used.
                                              	DefaultCapacityProviderStrategy []CapacityProviderStrategyItem
                                              
                                              	// The number of tasks in the cluster that are in the PENDING state.
                                              	PendingTasksCount int32
                                              
                                              	// The number of container instances registered into the cluster. This includes
                                              	// container instances in both ACTIVE and DRAINING status.
                                              	RegisteredContainerInstancesCount int32
                                              
                                              	// The number of tasks in the cluster that are in the RUNNING state.
                                              	RunningTasksCount int32
                                              
                                              	// The settings for the cluster. This parameter indicates whether CloudWatch
                                              	// Container Insights is enabled or disabled for a cluster.
                                              	Settings []ClusterSetting
                                              
                                              	// Additional information about your clusters that are separated by launch type,
                                              	// including:
                                              	//
                                              	// * runningEC2TasksCount
                                              	//
                                              	// * RunningFargateTasksCount
                                              	//
                                              	// *
                                              	// pendingEC2TasksCount
                                              	//
                                              	// * pendingFargateTasksCount
                                              	//
                                              	// * activeEC2ServiceCount
                                              	//
                                              	// *
                                              	// activeFargateServiceCount
                                              	//
                                              	// * drainingEC2ServiceCount
                                              	//
                                              	// *
                                              	// drainingFargateServiceCount
                                              	Statistics []KeyValuePair
                                              
                                              	// The status of the cluster. The following are the possible states that will be
                                              	// returned. ACTIVE The cluster is ready to accept tasks and if applicable you can
                                              	// register container instances with the cluster. PROVISIONING The cluster has
                                              	// capacity providers associated with it and the resources needed for the capacity
                                              	// provider are being created. DEPROVISIONING The cluster has capacity providers
                                              	// associated with it and the resources needed for the capacity provider are being
                                              	// deleted. FAILED The cluster has capacity providers associated with it and the
                                              	// resources needed for the capacity provider have failed to create. INACTIVE The
                                              	// cluster has been deleted. Clusters with an INACTIVE status may remain
                                              	// discoverable in your account for a period of time. However, this behavior is
                                              	// subject to change in the future, so you should not rely on INACTIVE clusters
                                              	// persisting.
                                              	Status *string
                                              
                                              	// The metadata that you apply to the cluster to help you categorize and organize
                                              	// them. Each tag consists of a key and an optional value, both of which you
                                              	// define. The following basic restrictions apply to tags:
                                              	//
                                              	// * Maximum number of
                                              	// tags per resource - 50
                                              	//
                                              	// * For each resource, each tag key must be unique, and
                                              	// each tag key can have only one value.
                                              	//
                                              	// * Maximum key length - 128 Unicode
                                              	// characters in UTF-8
                                              	//
                                              	// * Maximum value length - 256 Unicode characters in UTF-8
                                              	//
                                              	// *
                                              	// If your tagging schema is used across multiple services and resources, remember
                                              	// that other services may have restrictions on allowed characters. Generally
                                              	// allowed characters are: letters, numbers, and spaces representable in UTF-8, and
                                              	// the following characters: + - = . _ : / @.
                                              	//
                                              	// * Tag keys and values are
                                              	// case-sensitive.
                                              	//
                                              	// * Do not use aws:, AWS:, or any upper or lowercase combination
                                              	// of such as a prefix for either keys or values as it is reserved for AWS use. You
                                              	// cannot edit or delete tag keys or values with this prefix. Tags with this prefix
                                              	// do not count against your tags per resource limit.
                                              	Tags []Tag
                                              }

                                                A regional grouping of one or more container instances on which you can run task requests. Each account receives a default cluster the first time you use the Amazon ECS service, but you may also create other clusters. Clusters may contain more than one instance type simultaneously.

                                                type ClusterContainsContainerInstancesException

                                                type ClusterContainsContainerInstancesException struct {
                                                	Message *string
                                                }

                                                  You cannot delete a cluster that has registered container instances. First, deregister the container instances before you can delete the cluster. For more information, see DeregisterContainerInstance.

                                                  func (*ClusterContainsContainerInstancesException) Error

                                                  func (*ClusterContainsContainerInstancesException) ErrorCode

                                                  func (*ClusterContainsContainerInstancesException) ErrorFault

                                                  func (*ClusterContainsContainerInstancesException) ErrorMessage

                                                  type ClusterContainsServicesException

                                                  type ClusterContainsServicesException struct {
                                                  	Message *string
                                                  }

                                                    You cannot delete a cluster that contains services. First, update the service to reduce its desired task count to 0 and then delete the service. For more information, see UpdateService and DeleteService.

                                                    func (*ClusterContainsServicesException) Error

                                                    func (*ClusterContainsServicesException) ErrorCode

                                                    func (*ClusterContainsServicesException) ErrorFault

                                                    func (*ClusterContainsServicesException) ErrorMessage

                                                    func (e *ClusterContainsServicesException) ErrorMessage() string

                                                    type ClusterContainsTasksException

                                                    type ClusterContainsTasksException struct {
                                                    	Message *string
                                                    }

                                                      You cannot delete a cluster that has active tasks.

                                                      func (*ClusterContainsTasksException) Error

                                                      func (*ClusterContainsTasksException) ErrorCode

                                                      func (e *ClusterContainsTasksException) ErrorCode() string

                                                      func (*ClusterContainsTasksException) ErrorFault

                                                      func (*ClusterContainsTasksException) ErrorMessage

                                                      func (e *ClusterContainsTasksException) ErrorMessage() string

                                                      type ClusterField

                                                      type ClusterField string
                                                      const (
                                                      	ClusterFieldAttachments ClusterField = "ATTACHMENTS"
                                                      	ClusterFieldSettings    ClusterField = "SETTINGS"
                                                      	ClusterFieldStatistics  ClusterField = "STATISTICS"
                                                      	ClusterFieldTags        ClusterField = "TAGS"
                                                      )

                                                        Enum values for ClusterField

                                                        func (ClusterField) Values

                                                        func (ClusterField) Values() []ClusterField

                                                          Values returns all known values for ClusterField. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                          type ClusterNotFoundException

                                                          type ClusterNotFoundException struct {
                                                          	Message *string
                                                          }

                                                            The specified cluster could not be found. You can view your available clusters with ListClusters. Amazon ECS clusters are Region-specific.

                                                            func (*ClusterNotFoundException) Error

                                                            func (e *ClusterNotFoundException) Error() string

                                                            func (*ClusterNotFoundException) ErrorCode

                                                            func (e *ClusterNotFoundException) ErrorCode() string

                                                            func (*ClusterNotFoundException) ErrorFault

                                                            func (e *ClusterNotFoundException) ErrorFault() smithy.ErrorFault

                                                            func (*ClusterNotFoundException) ErrorMessage

                                                            func (e *ClusterNotFoundException) ErrorMessage() string

                                                            type ClusterSetting

                                                            type ClusterSetting struct {
                                                            
                                                            	// The name of the cluster setting. The only supported value is containerInsights.
                                                            	Name ClusterSettingName
                                                            
                                                            	// The value to set for the cluster setting. The supported values are enabled and
                                                            	// disabled. If enabled is specified, CloudWatch Container Insights will be enabled
                                                            	// for the cluster, otherwise it will be disabled unless the containerInsights
                                                            	// account setting is enabled. If a cluster value is specified, it will override
                                                            	// the containerInsights value set with PutAccountSetting or
                                                            	// PutAccountSettingDefault.
                                                            	Value *string
                                                            }

                                                              The settings to use when creating a cluster. This parameter is used to enable CloudWatch Container Insights for a cluster.

                                                              type ClusterSettingName

                                                              type ClusterSettingName string
                                                              const (
                                                              	ClusterSettingNameContainerInsights ClusterSettingName = "containerInsights"
                                                              )

                                                                Enum values for ClusterSettingName

                                                                func (ClusterSettingName) Values

                                                                  Values returns all known values for ClusterSettingName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                  type Compatibility

                                                                  type Compatibility string
                                                                  const (
                                                                  	CompatibilityEc2     Compatibility = "EC2"
                                                                  	CompatibilityFargate Compatibility = "FARGATE"
                                                                  )

                                                                    Enum values for Compatibility

                                                                    func (Compatibility) Values

                                                                    func (Compatibility) Values() []Compatibility

                                                                      Values returns all known values for Compatibility. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                      type Connectivity

                                                                      type Connectivity string
                                                                      const (
                                                                      	ConnectivityConnected    Connectivity = "CONNECTED"
                                                                      	ConnectivityDisconnected Connectivity = "DISCONNECTED"
                                                                      )

                                                                        Enum values for Connectivity

                                                                        func (Connectivity) Values

                                                                        func (Connectivity) Values() []Connectivity

                                                                          Values returns all known values for Connectivity. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                          type Container

                                                                          type Container struct {
                                                                          
                                                                          	// The Amazon Resource Name (ARN) of the container.
                                                                          	ContainerArn *string
                                                                          
                                                                          	// The number of CPU units set for the container. The value will be 0 if no value
                                                                          	// was specified in the container definition when the task definition was
                                                                          	// registered.
                                                                          	Cpu *string
                                                                          
                                                                          	// The exit code returned from the container.
                                                                          	ExitCode *int32
                                                                          
                                                                          	// The IDs of each GPU assigned to the container.
                                                                          	GpuIds []string
                                                                          
                                                                          	// The health status of the container. If health checks are not configured for this
                                                                          	// container in its task definition, then it reports the health status as UNKNOWN.
                                                                          	HealthStatus HealthStatus
                                                                          
                                                                          	// The image used for the container.
                                                                          	Image *string
                                                                          
                                                                          	// The container image manifest digest. The imageDigest is only returned if the
                                                                          	// container is using an image hosted in Amazon ECR, otherwise it is omitted.
                                                                          	ImageDigest *string
                                                                          
                                                                          	// The last known status of the container.
                                                                          	LastStatus *string
                                                                          
                                                                          	// The hard limit (in MiB) of memory set for the container.
                                                                          	Memory *string
                                                                          
                                                                          	// The soft limit (in MiB) of memory set for the container.
                                                                          	MemoryReservation *string
                                                                          
                                                                          	// The name of the container.
                                                                          	Name *string
                                                                          
                                                                          	// The network bindings associated with the container.
                                                                          	NetworkBindings []NetworkBinding
                                                                          
                                                                          	// The network interfaces associated with the container.
                                                                          	NetworkInterfaces []NetworkInterface
                                                                          
                                                                          	// A short (255 max characters) human-readable string to provide additional details
                                                                          	// about a running or stopped container.
                                                                          	Reason *string
                                                                          
                                                                          	// The ID of the Docker container.
                                                                          	RuntimeId *string
                                                                          
                                                                          	// The ARN of the task.
                                                                          	TaskArn *string
                                                                          }

                                                                            A Docker container that is part of a task.

                                                                            type ContainerCondition

                                                                            type ContainerCondition string
                                                                            const (
                                                                            	ContainerConditionStart    ContainerCondition = "START"
                                                                            	ContainerConditionComplete ContainerCondition = "COMPLETE"
                                                                            	ContainerConditionSuccess  ContainerCondition = "SUCCESS"
                                                                            	ContainerConditionHealthy  ContainerCondition = "HEALTHY"
                                                                            )

                                                                              Enum values for ContainerCondition

                                                                              func (ContainerCondition) Values

                                                                                Values returns all known values for ContainerCondition. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                type ContainerDefinition

                                                                                type ContainerDefinition struct {
                                                                                
                                                                                	// The command that is passed to the container. This parameter maps to Cmd in the
                                                                                	// Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// COMMAND parameter to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). For more
                                                                                	// information, see https://docs.docker.com/engine/reference/builder/#cmd
                                                                                	// (https://docs.docker.com/engine/reference/builder/#cmd). If there are multiple
                                                                                	// arguments, each argument should be a separated string in the array.
                                                                                	Command []string
                                                                                
                                                                                	// The number of cpu units reserved for the container. This parameter maps to
                                                                                	// CpuShares in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --cpu-shares option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). This
                                                                                	// field is optional for tasks using the Fargate launch type, and the only
                                                                                	// requirement is that the total amount of CPU reserved for all containers within a
                                                                                	// task be lower than the task-level cpu value. You can determine the number of CPU
                                                                                	// units that are available per EC2 instance type by multiplying the vCPUs listed
                                                                                	// for that instance type on the Amazon EC2 Instances
                                                                                	// (http://aws.amazon.com/ec2/instance-types/) detail page by 1,024. Linux
                                                                                	// containers share unallocated CPU units with other containers on the container
                                                                                	// instance with the same ratio as their allocated amount. For example, if you run
                                                                                	// a single-container task on a single-core instance type with 512 CPU units
                                                                                	// specified for that container, and that is the only task running on the container
                                                                                	// instance, that container could use the full 1,024 CPU unit share at any given
                                                                                	// time. However, if you launched another copy of the same task on that container
                                                                                	// instance, each task would be guaranteed a minimum of 512 CPU units when needed,
                                                                                	// and each container could float to higher CPU usage if the other container was
                                                                                	// not using it, but if both tasks were 100% active all of the time, they would be
                                                                                	// limited to 512 CPU units. On Linux container instances, the Docker daemon on the
                                                                                	// container instance uses the CPU value to calculate the relative CPU share ratios
                                                                                	// for running containers. For more information, see CPU share constraint
                                                                                	// (https://docs.docker.com/engine/reference/run/#cpu-share-constraint) in the
                                                                                	// Docker documentation. The minimum valid CPU share value that the Linux kernel
                                                                                	// allows is 2. However, the CPU parameter is not required, and you can use CPU
                                                                                	// values below 2 in your container definitions. For CPU values below 2 (including
                                                                                	// null), the behavior varies based on your Amazon ECS container agent version:
                                                                                	//
                                                                                	// *
                                                                                	// Agent versions less than or equal to 1.1.0: Null and zero CPU values are passed
                                                                                	// to Docker as 0, which Docker then converts to 1,024 CPU shares. CPU values of 1
                                                                                	// are passed to Docker as 1, which the Linux kernel converts to two CPU shares.
                                                                                	//
                                                                                	// *
                                                                                	// Agent versions greater than or equal to 1.2.0: Null, zero, and CPU values of 1
                                                                                	// are passed to Docker as 2.
                                                                                	//
                                                                                	// On Windows container instances, the CPU limit is
                                                                                	// enforced as an absolute limit, or a quota. Windows containers only have access
                                                                                	// to the specified amount of CPU that is described in the task definition. A null
                                                                                	// or zero CPU value is passed to Docker as 0, which Windows interprets as 1% of
                                                                                	// one CPU.
                                                                                	Cpu int32
                                                                                
                                                                                	// The dependencies defined for container startup and shutdown. A container can
                                                                                	// contain multiple dependencies. When a dependency is defined for container
                                                                                	// startup, for container shutdown it is reversed. For tasks using the EC2 launch
                                                                                	// type, the container instances require at least version 1.26.0 of the container
                                                                                	// agent to enable container dependencies. However, we recommend using the latest
                                                                                	// container agent version. For information about checking your agent version and
                                                                                	// updating to the latest version, see Updating the Amazon ECS Container Agent
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide. If you are using an
                                                                                	// Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of
                                                                                	// the ecs-init package. If your container instances are launched from version
                                                                                	// 20190301 or later, then they contain the required versions of the container
                                                                                	// agent and ecs-init. For more information, see Amazon ECS-optimized Linux AMI
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide. For tasks using the
                                                                                	// Fargate launch type, the task or service requires platform version 1.3.0 or
                                                                                	// later.
                                                                                	DependsOn []ContainerDependency
                                                                                
                                                                                	// When this parameter is true, networking is disabled within the container. This
                                                                                	// parameter maps to NetworkDisabled in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/). This
                                                                                	// parameter is not supported for Windows containers or tasks that use the awsvpc
                                                                                	// network mode.
                                                                                	DisableNetworking *bool
                                                                                
                                                                                	// A list of DNS search domains that are presented to the container. This parameter
                                                                                	// maps to DnsSearch in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --dns-search option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). This
                                                                                	// parameter is not supported for Windows containers or tasks that use the awsvpc
                                                                                	// network mode.
                                                                                	DnsSearchDomains []string
                                                                                
                                                                                	// A list of DNS servers that are presented to the container. This parameter maps
                                                                                	// to Dns in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --dns
                                                                                	// option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). This
                                                                                	// parameter is not supported for Windows containers or tasks that use the awsvpc
                                                                                	// network mode.
                                                                                	DnsServers []string
                                                                                
                                                                                	// A key/value map of labels to add to the container. This parameter maps to Labels
                                                                                	// in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --label option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). This
                                                                                	// parameter requires version 1.18 of the Docker Remote API or greater on your
                                                                                	// container instance. To check the Docker Remote API version on your container
                                                                                	// instance, log in to your container instance and run the following command: sudo
                                                                                	// docker version --format '{{.Server.APIVersion}}'
                                                                                	DockerLabels map[string]string
                                                                                
                                                                                	// A list of strings to provide custom labels for SELinux and AppArmor multi-level
                                                                                	// security systems. This field is not valid for containers in tasks using the
                                                                                	// Fargate launch type. With Windows containers, this parameter can be used to
                                                                                	// reference a credential spec file when configuring a container for Active
                                                                                	// Directory authentication. For more information, see Using gMSAs for Windows
                                                                                	// Containers
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide. This parameter maps to
                                                                                	// SecurityOpt in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --security-opt option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). The
                                                                                	// Amazon ECS container agent running on a container instance must register with
                                                                                	// the ECS_SELINUX_CAPABLE=true or ECS_APPARMOR_CAPABLE=true environment variables
                                                                                	// before containers placed on that instance can use these security options. For
                                                                                	// more information, see Amazon ECS Container Agent Configuration
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide. For more information
                                                                                	// about valid values, see Docker Run Security Configuration
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). Valid
                                                                                	// values: "no-new-privileges" | "apparmor:PROFILE" | "label:value" |
                                                                                	// "credentialspec:CredentialSpecFilePath"
                                                                                	DockerSecurityOptions []string
                                                                                
                                                                                	// Early versions of the Amazon ECS container agent do not properly handle
                                                                                	// entryPoint parameters. If you have problems using entryPoint, update your
                                                                                	// container agent or enter your commands and arguments as command array items
                                                                                	// instead. The entry point that is passed to the container. This parameter maps to
                                                                                	// Entrypoint in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --entrypoint option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). For more
                                                                                	// information, see https://docs.docker.com/engine/reference/builder/#entrypoint
                                                                                	// (https://docs.docker.com/engine/reference/builder/#entrypoint).
                                                                                	EntryPoint []string
                                                                                
                                                                                	// The environment variables to pass to a container. This parameter maps to Env in
                                                                                	// the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --env
                                                                                	// option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). We do
                                                                                	// not recommend using plaintext environment variables for sensitive information,
                                                                                	// such as credential data.
                                                                                	Environment []KeyValuePair
                                                                                
                                                                                	// A list of files containing the environment variables to pass to a container.
                                                                                	// This parameter maps to the --env-file option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). You can
                                                                                	// specify up to ten environment files. The file must have a .env file extension.
                                                                                	// Each line in an environment file should contain an environment variable in
                                                                                	// VARIABLE=VALUE format. Lines beginning with # are treated as comments and are
                                                                                	// ignored. For more information on the environment variable file syntax, see
                                                                                	// Declare default environment variables in file
                                                                                	// (https://docs.docker.com/compose/env-file/). If there are environment variables
                                                                                	// specified using the environment parameter in a container definition, they take
                                                                                	// precedence over the variables contained within an environment file. If multiple
                                                                                	// environment files are specified that contain the same variable, they are
                                                                                	// processed from the top down. It is recommended to use unique variable names. For
                                                                                	// more information, see Specifying Environment Variables
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/taskdef-envfiles.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide. This field is not valid
                                                                                	// for containers in tasks using the Fargate launch type.
                                                                                	EnvironmentFiles []EnvironmentFile
                                                                                
                                                                                	// If the essential parameter of a container is marked as true, and that container
                                                                                	// fails or stops for any reason, all other containers that are part of the task
                                                                                	// are stopped. If the essential parameter of a container is marked as false, then
                                                                                	// its failure does not affect the rest of the containers in a task. If this
                                                                                	// parameter is omitted, a container is assumed to be essential. All tasks must
                                                                                	// have at least one essential container. If you have an application that is
                                                                                	// composed of multiple containers, you should group containers that are used for a
                                                                                	// common purpose into components, and separate the different components into
                                                                                	// multiple task definitions. For more information, see Application Architecture
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide.
                                                                                	Essential *bool
                                                                                
                                                                                	// A list of hostnames and IP address mappings to append to the /etc/hosts file on
                                                                                	// the container. This parameter maps to ExtraHosts in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --add-host option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). This
                                                                                	// parameter is not supported for Windows containers or tasks that use the awsvpc
                                                                                	// network mode.
                                                                                	ExtraHosts []HostEntry
                                                                                
                                                                                	// The FireLens configuration for the container. This is used to specify and
                                                                                	// configure a log router for container logs. For more information, see Custom Log
                                                                                	// Routing
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide.
                                                                                	FirelensConfiguration *FirelensConfiguration
                                                                                
                                                                                	// The container health check command and associated configuration parameters for
                                                                                	// the container. This parameter maps to HealthCheck in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// HEALTHCHECK parameter of docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration).
                                                                                	HealthCheck *HealthCheck
                                                                                
                                                                                	// The hostname to use for your container. This parameter maps to Hostname in the
                                                                                	// Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --hostname option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). The
                                                                                	// hostname parameter is not supported if you are using the awsvpc network mode.
                                                                                	Hostname *string
                                                                                
                                                                                	// The image used to start a container. This string is passed directly to the
                                                                                	// Docker daemon. Images in the Docker Hub registry are available by default. Other
                                                                                	// repositories are specified with either  repository-url/image:tag  or
                                                                                	// repository-url/image@digest . Up to 255 letters (uppercase and lowercase),
                                                                                	// numbers, hyphens, underscores, colons, periods, forward slashes, and number
                                                                                	// signs are allowed. This parameter maps to Image in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the IMAGE
                                                                                	// parameter of docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration).
                                                                                	//
                                                                                	// * When
                                                                                	// a new task starts, the Amazon ECS container agent pulls the latest version of
                                                                                	// the specified image and tag for the container to use. However, subsequent
                                                                                	// updates to a repository image are not propagated to already running tasks.
                                                                                	//
                                                                                	// *
                                                                                	// Images in Amazon ECR repositories can be specified by either using the full
                                                                                	// registry/repository:tag or registry/repository@digest. For example,
                                                                                	// 012345678910.dkr.ecr..amazonaws.com/:latest or
                                                                                	// 012345678910.dkr.ecr..amazonaws.com/@sha256:94afd1f2e64d908bc90dbca0035a5b567EXAMPLE.
                                                                                	//
                                                                                	// *
                                                                                	// Images in official repositories on Docker Hub use a single name (for example,
                                                                                	// ubuntu or mongo).
                                                                                	//
                                                                                	// * Images in other repositories on Docker Hub are qualified
                                                                                	// with an organization name (for example, amazon/amazon-ecs-agent).
                                                                                	//
                                                                                	// * Images in
                                                                                	// other online repositories are qualified further by a domain name (for example,
                                                                                	// quay.io/assemblyline/ubuntu).
                                                                                	Image *string
                                                                                
                                                                                	// When this parameter is true, this allows you to deploy containerized
                                                                                	// applications that require stdin or a tty to be allocated. This parameter maps to
                                                                                	// OpenStdin in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --interactive option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration).
                                                                                	Interactive *bool
                                                                                
                                                                                	// The links parameter allows containers to communicate with each other without the
                                                                                	// need for port mappings. This parameter is only supported if the network mode of
                                                                                	// a task definition is bridge. The name:internalName construct is analogous to
                                                                                	// name:alias in Docker links. Up to 255 letters (uppercase and lowercase),
                                                                                	// numbers, and hyphens are allowed. For more information about linking Docker
                                                                                	// containers, go to Legacy container links
                                                                                	// (https://docs.docker.com/network/links/) in the Docker documentation. This
                                                                                	// parameter maps to Links in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --link
                                                                                	// option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). This
                                                                                	// parameter is not supported for Windows containers or tasks that use the awsvpc
                                                                                	// network mode. Containers that are collocated on a single container instance may
                                                                                	// be able to communicate with each other without requiring links or host port
                                                                                	// mappings. Network isolation is achieved on the container instance using security
                                                                                	// groups and VPC settings.
                                                                                	Links []string
                                                                                
                                                                                	// Linux-specific modifications that are applied to the container, such as Linux
                                                                                	// kernel capabilities. For more information see KernelCapabilities. This parameter
                                                                                	// is not supported for Windows containers.
                                                                                	LinuxParameters *LinuxParameters
                                                                                
                                                                                	// The log configuration specification for the container. This parameter maps to
                                                                                	// LogConfig in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --log-driver option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). By
                                                                                	// default, containers use the same logging driver that the Docker daemon uses.
                                                                                	// However the container may use a different logging driver than the Docker daemon
                                                                                	// by specifying a log driver with this parameter in the container definition. To
                                                                                	// use a different logging driver for a container, the log system must be
                                                                                	// configured properly on the container instance (or on a different log server for
                                                                                	// remote logging options). For more information on the options for different
                                                                                	// supported log drivers, see Configure logging drivers
                                                                                	// (https://docs.docker.com/engine/admin/logging/overview/) in the Docker
                                                                                	// documentation. Amazon ECS currently supports a subset of the logging drivers
                                                                                	// available to the Docker daemon (shown in the LogConfiguration data type).
                                                                                	// Additional log drivers may be available in future releases of the Amazon ECS
                                                                                	// container agent. This parameter requires version 1.18 of the Docker Remote API
                                                                                	// or greater on your container instance. To check the Docker Remote API version on
                                                                                	// your container instance, log in to your container instance and run the following
                                                                                	// command: sudo docker version --format '{{.Server.APIVersion}}' The Amazon ECS
                                                                                	// container agent running on a container instance must register the logging
                                                                                	// drivers available on that instance with the ECS_AVAILABLE_LOGGING_DRIVERS
                                                                                	// environment variable before containers placed on that instance can use these log
                                                                                	// configuration options. For more information, see Amazon ECS Container Agent
                                                                                	// Configuration
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide.
                                                                                	LogConfiguration *LogConfiguration
                                                                                
                                                                                	// The amount (in MiB) of memory to present to the container. If your container
                                                                                	// attempts to exceed the memory specified here, the container is killed. The total
                                                                                	// amount of memory reserved for all containers within a task must be lower than
                                                                                	// the task memory value, if one is specified. This parameter maps to Memory in the
                                                                                	// Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --memory option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). If using
                                                                                	// the Fargate launch type, this parameter is optional. If using the EC2 launch
                                                                                	// type, you must specify either a task-level memory value or a container-level
                                                                                	// memory value. If you specify both a container-level memory and memoryReservation
                                                                                	// value, memory must be greater than memoryReservation. If you specify
                                                                                	// memoryReservation, then that value is subtracted from the available memory
                                                                                	// resources for the container instance on which the container is placed.
                                                                                	// Otherwise, the value of memory is used. The Docker daemon reserves a minimum of
                                                                                	// 4 MiB of memory for a container, so you should not specify fewer than 4 MiB of
                                                                                	// memory for your containers.
                                                                                	Memory *int32
                                                                                
                                                                                	// The soft limit (in MiB) of memory to reserve for the container. When system
                                                                                	// memory is under heavy contention, Docker attempts to keep the container memory
                                                                                	// to this soft limit. However, your container can consume more memory when it
                                                                                	// needs to, up to either the hard limit specified with the memory parameter (if
                                                                                	// applicable), or all of the available memory on the container instance, whichever
                                                                                	// comes first. This parameter maps to MemoryReservation in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --memory-reservation option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). If a
                                                                                	// task-level memory value is not specified, you must specify a non-zero integer
                                                                                	// for one or both of memory or memoryReservation in a container definition. If you
                                                                                	// specify both, memory must be greater than memoryReservation. If you specify
                                                                                	// memoryReservation, then that value is subtracted from the available memory
                                                                                	// resources for the container instance on which the container is placed.
                                                                                	// Otherwise, the value of memory is used. For example, if your container normally
                                                                                	// uses 128 MiB of memory, but occasionally bursts to 256 MiB of memory for short
                                                                                	// periods of time, you can set a memoryReservation of 128 MiB, and a memory hard
                                                                                	// limit of 300 MiB. This configuration would allow the container to only reserve
                                                                                	// 128 MiB of memory from the remaining resources on the container instance, but
                                                                                	// also allow the container to consume more memory resources when needed. The
                                                                                	// Docker daemon reserves a minimum of 4 MiB of memory for a container, so you
                                                                                	// should not specify fewer than 4 MiB of memory for your containers.
                                                                                	MemoryReservation *int32
                                                                                
                                                                                	// The mount points for data volumes in your container. This parameter maps to
                                                                                	// Volumes in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --volume option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). Windows
                                                                                	// containers can mount whole directories on the same drive as $env:ProgramData.
                                                                                	// Windows containers cannot mount directories on a different drive, and mount
                                                                                	// point cannot be across drives.
                                                                                	MountPoints []MountPoint
                                                                                
                                                                                	// The name of a container. If you are linking multiple containers together in a
                                                                                	// task definition, the name of one container can be entered in the links of
                                                                                	// another container to connect the containers. Up to 255 letters (uppercase and
                                                                                	// lowercase), numbers, and hyphens are allowed. This parameter maps to name in the
                                                                                	// Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --name
                                                                                	// option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration).
                                                                                	Name *string
                                                                                
                                                                                	// The list of port mappings for the container. Port mappings allow containers to
                                                                                	// access ports on the host container instance to send or receive traffic. For task
                                                                                	// definitions that use the awsvpc network mode, you should only specify the
                                                                                	// containerPort. The hostPort can be left blank or it must be the same value as
                                                                                	// the containerPort. Port mappings on Windows use the NetNAT gateway address
                                                                                	// rather than localhost. There is no loopback for port mappings on Windows, so you
                                                                                	// cannot access a container's mapped port from the host itself. This parameter
                                                                                	// maps to PortBindings in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --publish option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). If the
                                                                                	// network mode of a task definition is set to none, then you can't specify port
                                                                                	// mappings. If the network mode of a task definition is set to host, then host
                                                                                	// ports must either be undefined or they must match the container port in the port
                                                                                	// mapping. After a task reaches the RUNNING status, manual and automatic host and
                                                                                	// container port assignments are visible in the Network Bindings section of a
                                                                                	// container description for a selected task in the Amazon ECS console. The
                                                                                	// assignments are also visible in the networkBindings section DescribeTasks
                                                                                	// responses.
                                                                                	PortMappings []PortMapping
                                                                                
                                                                                	// When this parameter is true, the container is given elevated privileges on the
                                                                                	// host container instance (similar to the root user). This parameter maps to
                                                                                	// Privileged in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --privileged option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). This
                                                                                	// parameter is not supported for Windows containers or tasks using the Fargate
                                                                                	// launch type.
                                                                                	Privileged *bool
                                                                                
                                                                                	// When this parameter is true, a TTY is allocated. This parameter maps to Tty in
                                                                                	// the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --tty
                                                                                	// option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration).
                                                                                	PseudoTerminal *bool
                                                                                
                                                                                	// When this parameter is true, the container is given read-only access to its root
                                                                                	// file system. This parameter maps to ReadonlyRootfs in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --read-only option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). This
                                                                                	// parameter is not supported for Windows containers or tasks that use the awsvpc
                                                                                	// network mode.
                                                                                	ReadonlyRootFilesystem *bool
                                                                                
                                                                                	// The private repository authentication credentials to use.
                                                                                	RepositoryCredentials *RepositoryCredentials
                                                                                
                                                                                	// The type and amount of a resource to assign to a container. The only supported
                                                                                	// resource is a GPU.
                                                                                	ResourceRequirements []ResourceRequirement
                                                                                
                                                                                	// The secrets to pass to the container. For more information, see Specifying
                                                                                	// Sensitive Data
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide.
                                                                                	Secrets []Secret
                                                                                
                                                                                	// Time duration (in seconds) to wait before giving up on resolving dependencies
                                                                                	// for a container. For example, you specify two containers in a task definition
                                                                                	// with containerA having a dependency on containerB reaching a COMPLETE, SUCCESS,
                                                                                	// or HEALTHY status. If a startTimeout value is specified for containerB and it
                                                                                	// does not reach the desired status within that time then containerA will give up
                                                                                	// and not start. This results in the task transitioning to a STOPPED state. When
                                                                                	// the ECS_CONTAINER_START_TIMEOUT container agent configuration variable is used,
                                                                                	// it is enforced indendently from this start timeout value. For tasks using the
                                                                                	// Fargate launch type, this parameter requires that the task or service uses
                                                                                	// platform version 1.3.0 or later. For tasks using the EC2 launch type, your
                                                                                	// container instances require at least version 1.26.0 of the container agent to
                                                                                	// enable a container start timeout value. However, we recommend using the latest
                                                                                	// container agent version. For information about checking your agent version and
                                                                                	// updating to the latest version, see Updating the Amazon ECS Container Agent
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide. If you are using an
                                                                                	// Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of
                                                                                	// the ecs-init package. If your container instances are launched from version
                                                                                	// 20190301 or later, then they contain the required versions of the container
                                                                                	// agent and ecs-init. For more information, see Amazon ECS-optimized Linux AMI
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide.
                                                                                	StartTimeout *int32
                                                                                
                                                                                	// Time duration (in seconds) to wait before the container is forcefully killed if
                                                                                	// it doesn't exit normally on its own. For tasks using the Fargate launch type,
                                                                                	// the task or service requires platform version 1.3.0 or later. The max stop
                                                                                	// timeout value is 120 seconds and if the parameter is not specified, the default
                                                                                	// value of 30 seconds is used. For tasks using the EC2 launch type, if the
                                                                                	// stopTimeout parameter is not specified, the value set for the Amazon ECS
                                                                                	// container agent configuration variable ECS_CONTAINER_STOP_TIMEOUT is used by
                                                                                	// default. If neither the stopTimeout parameter or the ECS_CONTAINER_STOP_TIMEOUT
                                                                                	// agent configuration variable are set, then the default values of 30 seconds for
                                                                                	// Linux containers and 30 seconds on Windows containers are used. Your container
                                                                                	// instances require at least version 1.26.0 of the container agent to enable a
                                                                                	// container stop timeout value. However, we recommend using the latest container
                                                                                	// agent version. For information about checking your agent version and updating to
                                                                                	// the latest version, see Updating the Amazon ECS Container Agent
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide. If you are using an
                                                                                	// Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of
                                                                                	// the ecs-init package. If your container instances are launched from version
                                                                                	// 20190301 or later, then they contain the required versions of the container
                                                                                	// agent and ecs-init. For more information, see Amazon ECS-optimized Linux AMI
                                                                                	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)
                                                                                	// in the Amazon Elastic Container Service Developer Guide.
                                                                                	StopTimeout *int32
                                                                                
                                                                                	// A list of namespaced kernel parameters to set in the container. This parameter
                                                                                	// maps to Sysctls in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --sysctl option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). It is
                                                                                	// not recommended that you specify network-related systemControls parameters for
                                                                                	// multiple containers in a single task that also uses either the awsvpc or host
                                                                                	// network modes. For tasks that use the awsvpc network mode, the container that is
                                                                                	// started last determines which systemControls parameters take effect. For tasks
                                                                                	// that use the host network mode, it changes the container instance's namespaced
                                                                                	// kernel parameters as well as the containers.
                                                                                	SystemControls []SystemControl
                                                                                
                                                                                	// A list of ulimits to set in the container. If a ulimit value is specified in a
                                                                                	// task definition, it will override the default values set by Docker. This
                                                                                	// parameter maps to Ulimits in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --ulimit option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). Valid
                                                                                	// naming values are displayed in the Ulimit data type. This parameter requires
                                                                                	// version 1.18 of the Docker Remote API or greater on your container instance. To
                                                                                	// check the Docker Remote API version on your container instance, log in to your
                                                                                	// container instance and run the following command: sudo docker version --format
                                                                                	// '{{.Server.APIVersion}}' This parameter is not supported for Windows containers
                                                                                	// or tasks that use the awsvpc network mode.
                                                                                	Ulimits []Ulimit
                                                                                
                                                                                	// The user to use inside the container. This parameter maps to User in the Create
                                                                                	// a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --user
                                                                                	// option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). When
                                                                                	// running tasks using the host network mode, you should not run containers using
                                                                                	// the root user (UID 0). It is considered best practice to use a non-root user.
                                                                                	// You can specify the user using the following formats. If specifying a UID or
                                                                                	// GID, you must specify it as a positive integer.
                                                                                	//
                                                                                	// * user
                                                                                	//
                                                                                	// * user:group
                                                                                	//
                                                                                	// * uid
                                                                                	//
                                                                                	// *
                                                                                	// uid:gid
                                                                                	//
                                                                                	// * user:gid
                                                                                	//
                                                                                	// * uid:group
                                                                                	//
                                                                                	// This parameter is not supported for Windows
                                                                                	// containers or tasks that use the awsvpc network mode.
                                                                                	User *string
                                                                                
                                                                                	// Data volumes to mount from another container. This parameter maps to VolumesFrom
                                                                                	// in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --volumes-from option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration).
                                                                                	VolumesFrom []VolumeFrom
                                                                                
                                                                                	// The working directory in which to run commands inside the container. This
                                                                                	// parameter maps to WorkingDir in the Create a container
                                                                                	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                	// --workdir option to docker run
                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration).
                                                                                	WorkingDirectory *string
                                                                                }

                                                                                  Container definitions are used in task definitions to describe the different containers that are launched as part of a task.

                                                                                  type ContainerDependency

                                                                                  type ContainerDependency struct {
                                                                                  
                                                                                  	// The dependency condition of the container. The following are the available
                                                                                  	// conditions and their behavior:
                                                                                  	//
                                                                                  	// * START - This condition emulates the behavior
                                                                                  	// of links and volumes today. It validates that a dependent container is started
                                                                                  	// before permitting other containers to start.
                                                                                  	//
                                                                                  	// * COMPLETE - This condition
                                                                                  	// validates that a dependent container runs to completion (exits) before
                                                                                  	// permitting other containers to start. This can be useful for nonessential
                                                                                  	// containers that run a script and then exit. This condition cannot be set on an
                                                                                  	// essential container.
                                                                                  	//
                                                                                  	// * SUCCESS - This condition is the same as COMPLETE, but it
                                                                                  	// also requires that the container exits with a zero status. This condition cannot
                                                                                  	// be set on an essential container.
                                                                                  	//
                                                                                  	// * HEALTHY - This condition validates that the
                                                                                  	// dependent container passes its Docker health check before permitting other
                                                                                  	// containers to start. This requires that the dependent container has health
                                                                                  	// checks configured. This condition is confirmed only at task startup.
                                                                                  	//
                                                                                  	// This member is required.
                                                                                  	Condition ContainerCondition
                                                                                  
                                                                                  	// The name of a container.
                                                                                  	//
                                                                                  	// This member is required.
                                                                                  	ContainerName *string
                                                                                  }

                                                                                    The dependencies defined for container startup and shutdown. A container can contain multiple dependencies. When a dependency is defined for container startup, for container shutdown it is reversed. Your Amazon ECS container instances require at least version 1.26.0 of the container agent to enable container dependencies. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see Updating the Amazon ECS Container Agent (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the Amazon Elastic Container Service Developer Guide. If you are using an Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the ecs-init package. If your container instances are launched from version 20190301 or later, then they contain the required versions of the container agent and ecs-init. For more information, see Amazon ECS-optimized Linux AMI (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the Amazon Elastic Container Service Developer Guide. For tasks using the Fargate launch type, this parameter requires that the task or service uses platform version 1.3.0 or later.

                                                                                    type ContainerInstance

                                                                                    type ContainerInstance struct {
                                                                                    
                                                                                    	// This parameter returns true if the agent is connected to Amazon ECS. Registered
                                                                                    	// instances with an agent that may be unhealthy or stopped return false. Only
                                                                                    	// instances connected to an agent can accept placement requests.
                                                                                    	AgentConnected bool
                                                                                    
                                                                                    	// The status of the most recent agent update. If an update has never been
                                                                                    	// requested, this value is NULL.
                                                                                    	AgentUpdateStatus AgentUpdateStatus
                                                                                    
                                                                                    	// The resources attached to a container instance, such as elastic network
                                                                                    	// interfaces.
                                                                                    	Attachments []Attachment
                                                                                    
                                                                                    	// The attributes set for the container instance, either by the Amazon ECS
                                                                                    	// container agent at instance registration or manually with the PutAttributes
                                                                                    	// operation.
                                                                                    	Attributes []Attribute
                                                                                    
                                                                                    	// The capacity provider associated with the container instance.
                                                                                    	CapacityProviderName *string
                                                                                    
                                                                                    	// The Amazon Resource Name (ARN) of the container instance. The ARN contains the
                                                                                    	// arn:aws:ecs namespace, followed by the Region of the container instance, the AWS
                                                                                    	// account ID of the container instance owner, the container-instance namespace,
                                                                                    	// and then the container instance ID. For example,
                                                                                    	// arn:aws:ecs:region:aws_account_id:container-instance/container_instance_ID.
                                                                                    	ContainerInstanceArn *string
                                                                                    
                                                                                    	// The EC2 instance ID of the container instance.
                                                                                    	Ec2InstanceId *string
                                                                                    
                                                                                    	// The number of tasks on the container instance that are in the PENDING status.
                                                                                    	PendingTasksCount int32
                                                                                    
                                                                                    	// The Unix timestamp for when the container instance was registered.
                                                                                    	RegisteredAt *time.Time
                                                                                    
                                                                                    	// For CPU and memory resource types, this parameter describes the amount of each
                                                                                    	// resource that was available on the container instance when the container agent
                                                                                    	// registered it with Amazon ECS. This value represents the total amount of CPU and
                                                                                    	// memory that can be allocated on this container instance to tasks. For port
                                                                                    	// resource types, this parameter describes the ports that were reserved by the
                                                                                    	// Amazon ECS container agent when it registered the container instance with Amazon
                                                                                    	// ECS.
                                                                                    	RegisteredResources []Resource
                                                                                    
                                                                                    	// For CPU and memory resource types, this parameter describes the remaining CPU
                                                                                    	// and memory that has not already been allocated to tasks and is therefore
                                                                                    	// available for new tasks. For port resource types, this parameter describes the
                                                                                    	// ports that were reserved by the Amazon ECS container agent (at instance
                                                                                    	// registration time) and any task containers that have reserved port mappings on
                                                                                    	// the host (with the host or bridge network mode). Any port that is not specified
                                                                                    	// here is available for new tasks.
                                                                                    	RemainingResources []Resource
                                                                                    
                                                                                    	// The number of tasks on the container instance that are in the RUNNING status.
                                                                                    	RunningTasksCount int32
                                                                                    
                                                                                    	// The status of the container instance. The valid values are REGISTERING,
                                                                                    	// REGISTRATION_FAILED, ACTIVE, INACTIVE, DEREGISTERING, or DRAINING. If your
                                                                                    	// account has opted in to the awsvpcTrunking account setting, then any newly
                                                                                    	// registered container instance will transition to a REGISTERING status while the
                                                                                    	// trunk elastic network interface is provisioned for the instance. If the
                                                                                    	// registration fails, the instance will transition to a REGISTRATION_FAILED
                                                                                    	// status. You can describe the container instance and see the reason for failure
                                                                                    	// in the statusReason parameter. Once the container instance is terminated, the
                                                                                    	// instance transitions to a DEREGISTERING status while the trunk elastic network
                                                                                    	// interface is deprovisioned. The instance then transitions to an INACTIVE status.
                                                                                    	// The ACTIVE status indicates that the container instance can accept tasks. The
                                                                                    	// DRAINING indicates that new tasks are not placed on the container instance and
                                                                                    	// any service tasks running on the container instance are removed if possible. For
                                                                                    	// more information, see Container Instance Draining
                                                                                    	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-draining.html)
                                                                                    	// in the Amazon Elastic Container Service Developer Guide.
                                                                                    	Status *string
                                                                                    
                                                                                    	// The reason that the container instance reached its current status.
                                                                                    	StatusReason *string
                                                                                    
                                                                                    	// The metadata that you apply to the container instance to help you categorize and
                                                                                    	// organize them. Each tag consists of a key and an optional value, both of which
                                                                                    	// you define. The following basic restrictions apply to tags:
                                                                                    	//
                                                                                    	// * Maximum number of
                                                                                    	// tags per resource - 50
                                                                                    	//
                                                                                    	// * For each resource, each tag key must be unique, and
                                                                                    	// each tag key can have only one value.
                                                                                    	//
                                                                                    	// * Maximum key length - 128 Unicode
                                                                                    	// characters in UTF-8
                                                                                    	//
                                                                                    	// * Maximum value length - 256 Unicode characters in UTF-8
                                                                                    	//
                                                                                    	// *
                                                                                    	// If your tagging schema is used across multiple services and resources, remember
                                                                                    	// that other services may have restrictions on allowed characters. Generally
                                                                                    	// allowed characters are: letters, numbers, and spaces representable in UTF-8, and
                                                                                    	// the following characters: + - = . _ : / @.
                                                                                    	//
                                                                                    	// * Tag keys and values are
                                                                                    	// case-sensitive.
                                                                                    	//
                                                                                    	// * Do not use aws:, AWS:, or any upper or lowercase combination
                                                                                    	// of such as a prefix for either keys or values as it is reserved for AWS use. You
                                                                                    	// cannot edit or delete tag keys or values with this prefix. Tags with this prefix
                                                                                    	// do not count against your tags per resource limit.
                                                                                    	Tags []Tag
                                                                                    
                                                                                    	// The version counter for the container instance. Every time a container instance
                                                                                    	// experiences a change that triggers a CloudWatch event, the version counter is
                                                                                    	// incremented. If you are replicating your Amazon ECS container instance state
                                                                                    	// with CloudWatch Events, you can compare the version of a container instance
                                                                                    	// reported by the Amazon ECS APIs with the version reported in CloudWatch Events
                                                                                    	// for the container instance (inside the detail object) to verify that the version
                                                                                    	// in your event stream is current.
                                                                                    	Version int64
                                                                                    
                                                                                    	// The version information for the Amazon ECS container agent and Docker daemon
                                                                                    	// running on the container instance.
                                                                                    	VersionInfo *VersionInfo
                                                                                    }

                                                                                      An EC2 instance that is running the Amazon ECS agent and has been registered with a cluster.

                                                                                      type ContainerInstanceField

                                                                                      type ContainerInstanceField string
                                                                                      const (
                                                                                      	ContainerInstanceFieldTags ContainerInstanceField = "TAGS"
                                                                                      )

                                                                                        Enum values for ContainerInstanceField

                                                                                        func (ContainerInstanceField) Values

                                                                                          Values returns all known values for ContainerInstanceField. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                          type ContainerInstanceStatus

                                                                                          type ContainerInstanceStatus string
                                                                                          const (
                                                                                          	ContainerInstanceStatusActive             ContainerInstanceStatus = "ACTIVE"
                                                                                          	ContainerInstanceStatusDraining           ContainerInstanceStatus = "DRAINING"
                                                                                          	ContainerInstanceStatusRegistering        ContainerInstanceStatus = "REGISTERING"
                                                                                          	ContainerInstanceStatusDeregistering      ContainerInstanceStatus = "DEREGISTERING"
                                                                                          	ContainerInstanceStatusRegistrationFailed ContainerInstanceStatus = "REGISTRATION_FAILED"
                                                                                          )

                                                                                            Enum values for ContainerInstanceStatus

                                                                                            func (ContainerInstanceStatus) Values

                                                                                              Values returns all known values for ContainerInstanceStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                              type ContainerOverride

                                                                                              type ContainerOverride struct {
                                                                                              
                                                                                              	// The command to send to the container that overrides the default command from the
                                                                                              	// Docker image or the task definition. You must also specify a container name.
                                                                                              	Command []string
                                                                                              
                                                                                              	// The number of cpu units reserved for the container, instead of the default value
                                                                                              	// from the task definition. You must also specify a container name.
                                                                                              	Cpu *int32
                                                                                              
                                                                                              	// The environment variables to send to the container. You can add new environment
                                                                                              	// variables, which are added to the container at launch, or you can override the
                                                                                              	// existing environment variables from the Docker image or the task definition. You
                                                                                              	// must also specify a container name.
                                                                                              	Environment []KeyValuePair
                                                                                              
                                                                                              	// A list of files containing the environment variables to pass to a container,
                                                                                              	// instead of the value from the container definition.
                                                                                              	EnvironmentFiles []EnvironmentFile
                                                                                              
                                                                                              	// The hard limit (in MiB) of memory to present to the container, instead of the
                                                                                              	// default value from the task definition. If your container attempts to exceed the
                                                                                              	// memory specified here, the container is killed. You must also specify a
                                                                                              	// container name.
                                                                                              	Memory *int32
                                                                                              
                                                                                              	// The soft limit (in MiB) of memory to reserve for the container, instead of the
                                                                                              	// default value from the task definition. You must also specify a container name.
                                                                                              	MemoryReservation *int32
                                                                                              
                                                                                              	// The name of the container that receives the override. This parameter is required
                                                                                              	// if any override is specified.
                                                                                              	Name *string
                                                                                              
                                                                                              	// The type and amount of a resource to assign to a container, instead of the
                                                                                              	// default value from the task definition. The only supported resource is a GPU.
                                                                                              	ResourceRequirements []ResourceRequirement
                                                                                              }

                                                                                                The overrides that should be sent to a container. An empty container override can be passed in. An example of an empty container override would be {"containerOverrides": [ ] }. If a non-empty container override is specified, the name parameter must be included.

                                                                                                type ContainerStateChange

                                                                                                type ContainerStateChange struct {
                                                                                                
                                                                                                	// The name of the container.
                                                                                                	ContainerName *string
                                                                                                
                                                                                                	// The exit code for the container, if the state change is a result of the
                                                                                                	// container exiting.
                                                                                                	ExitCode *int32
                                                                                                
                                                                                                	// The container image SHA 256 digest.
                                                                                                	ImageDigest *string
                                                                                                
                                                                                                	// Any network bindings associated with the container.
                                                                                                	NetworkBindings []NetworkBinding
                                                                                                
                                                                                                	// The reason for the state change.
                                                                                                	Reason *string
                                                                                                
                                                                                                	// The ID of the Docker container.
                                                                                                	RuntimeId *string
                                                                                                
                                                                                                	// The status of the container.
                                                                                                	Status *string
                                                                                                }

                                                                                                  An object representing a change in state for a container.

                                                                                                  type Deployment

                                                                                                  type Deployment struct {
                                                                                                  
                                                                                                  	// The capacity provider strategy that the deployment is using.
                                                                                                  	CapacityProviderStrategy []CapacityProviderStrategyItem
                                                                                                  
                                                                                                  	// The Unix timestamp for when the service deployment was created.
                                                                                                  	CreatedAt *time.Time
                                                                                                  
                                                                                                  	// The most recent desired count of tasks that was specified for the service to
                                                                                                  	// deploy or maintain.
                                                                                                  	DesiredCount int32
                                                                                                  
                                                                                                  	// The number of consecutively failed tasks in the deployment. A task is considered
                                                                                                  	// a failure if the service scheduler can't launch the task, the task doesn't
                                                                                                  	// transition to a RUNNING state, or if it fails any of its defined health checks
                                                                                                  	// and is stopped. Once a service deployment has one or more successfully running
                                                                                                  	// tasks, the failed task count resets to zero and stops being evaluated.
                                                                                                  	FailedTasks int32
                                                                                                  
                                                                                                  	// The ID of the deployment.
                                                                                                  	Id *string
                                                                                                  
                                                                                                  	// The launch type the tasks in the service are using. For more information, see
                                                                                                  	// Amazon ECS Launch Types
                                                                                                  	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
                                                                                                  	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                  	LaunchType LaunchType
                                                                                                  
                                                                                                  	// The VPC subnet and security group configuration for tasks that receive their own
                                                                                                  	// elastic network interface by using the awsvpc networking mode.
                                                                                                  	NetworkConfiguration *NetworkConfiguration
                                                                                                  
                                                                                                  	// The number of tasks in the deployment that are in the PENDING status.
                                                                                                  	PendingCount int32
                                                                                                  
                                                                                                  	// The platform version on which your tasks in the service are running. A platform
                                                                                                  	// version is only specified for tasks using the Fargate launch type. If one is not
                                                                                                  	// specified, the LATEST platform version is used by default. For more information,
                                                                                                  	// see AWS Fargate Platform Versions
                                                                                                  	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
                                                                                                  	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                  	PlatformVersion *string
                                                                                                  
                                                                                                  	// The rolloutState of a service is only returned for services that use the rolling
                                                                                                  	// update (ECS) deployment type that are not behind a Classic Load Balancer. The
                                                                                                  	// rollout state of the deployment. When a service deployment is started, it begins
                                                                                                  	// in an IN_PROGRESS state. When the service reaches a steady state, the deployment
                                                                                                  	// will transition to a COMPLETED state. If the service fails to reach a steady
                                                                                                  	// state and circuit breaker is enabled, the deployment will transition to a FAILED
                                                                                                  	// state. A deployment in FAILED state will launch no new tasks. For more
                                                                                                  	// information, see DeploymentCircuitBreaker.
                                                                                                  	RolloutState DeploymentRolloutState
                                                                                                  
                                                                                                  	// A description of the rollout state of a deployment.
                                                                                                  	RolloutStateReason *string
                                                                                                  
                                                                                                  	// The number of tasks in the deployment that are in the RUNNING status.
                                                                                                  	RunningCount int32
                                                                                                  
                                                                                                  	// The status of the deployment. The following describes each state: PRIMARY The
                                                                                                  	// most recent deployment of a service. ACTIVE A service deployment that still has
                                                                                                  	// running tasks, but are in the process of being replaced with a new PRIMARY
                                                                                                  	// deployment. INACTIVE A deployment that has been completely replaced.
                                                                                                  	Status *string
                                                                                                  
                                                                                                  	// The most recent task definition that was specified for the tasks in the service
                                                                                                  	// to use.
                                                                                                  	TaskDefinition *string
                                                                                                  
                                                                                                  	// The Unix timestamp for when the service deployment was last updated.
                                                                                                  	UpdatedAt *time.Time
                                                                                                  }

                                                                                                    The details of an Amazon ECS service deployment. This is used only when a service uses the ECS deployment controller type.

                                                                                                    type DeploymentCircuitBreaker

                                                                                                    type DeploymentCircuitBreaker struct {
                                                                                                    
                                                                                                    	// Whether to enable the deployment circuit breaker logic for the service.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	Enable bool
                                                                                                    
                                                                                                    	// Whether to enable Amazon ECS to roll back the service if a service deployment
                                                                                                    	// fails. If rollback is enabled, when a service deployment fails, the service is
                                                                                                    	// rolled back to the last deployment that completed successfully.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	Rollback bool
                                                                                                    }

                                                                                                      The deployment circuit breaker can only be used for services using the rolling update (ECS) deployment type that are not behind a Classic Load Balancer. The deployment circuit breaker determines whether a service deployment will fail if the service can't reach a steady state. If enabled, a service deployment will transition to a failed state and stop launching new tasks. You can also enable Amazon ECS to roll back your service to the last completed deployment after a failure. For more information, see Rolling update (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                      type DeploymentConfiguration

                                                                                                      type DeploymentConfiguration struct {
                                                                                                      
                                                                                                      	// The deployment circuit breaker can only be used for services using the rolling
                                                                                                      	// update (ECS) deployment type. The deployment circuit breaker determines whether
                                                                                                      	// a service deployment will fail if the service can't reach a steady state. If
                                                                                                      	// deployment circuit breaker is enabled, a service deployment will transition to a
                                                                                                      	// failed state and stop launching new tasks. If rollback is enabled, when a
                                                                                                      	// service deployment fails, the service is rolled back to the last deployment that
                                                                                                      	// completed successfully.
                                                                                                      	DeploymentCircuitBreaker *DeploymentCircuitBreaker
                                                                                                      
                                                                                                      	// If a service is using the rolling update (ECS) deployment type, the maximum
                                                                                                      	// percent parameter represents an upper limit on the number of tasks in a service
                                                                                                      	// that are allowed in the RUNNING or PENDING state during a deployment, as a
                                                                                                      	// percentage of the desired number of tasks (rounded down to the nearest integer),
                                                                                                      	// and while any container instances are in the DRAINING state if the service
                                                                                                      	// contains tasks using the EC2 launch type. This parameter enables you to define
                                                                                                      	// the deployment batch size. For example, if your service has a desired number of
                                                                                                      	// four tasks and a maximum percent value of 200%, the scheduler may start four new
                                                                                                      	// tasks before stopping the four older tasks (provided that the cluster resources
                                                                                                      	// required to do this are available). The default value for maximum percent is
                                                                                                      	// 200%. If a service is using the blue/green (CODE_DEPLOY) or EXTERNAL deployment
                                                                                                      	// types and tasks that use the EC2 launch type, the maximum percent value is set
                                                                                                      	// to the default value and is used to define the upper limit on the number of the
                                                                                                      	// tasks in the service that remain in the RUNNING state while the container
                                                                                                      	// instances are in the DRAINING state. If the tasks in the service use the Fargate
                                                                                                      	// launch type, the maximum percent value is not used, although it is returned when
                                                                                                      	// describing your service.
                                                                                                      	MaximumPercent *int32
                                                                                                      
                                                                                                      	// If a service is using the rolling update (ECS) deployment type, the minimum
                                                                                                      	// healthy percent represents a lower limit on the number of tasks in a service
                                                                                                      	// that must remain in the RUNNING state during a deployment, as a percentage of
                                                                                                      	// the desired number of tasks (rounded up to the nearest integer), and while any
                                                                                                      	// container instances are in the DRAINING state if the service contains tasks
                                                                                                      	// using the EC2 launch type. This parameter enables you to deploy without using
                                                                                                      	// additional cluster capacity. For example, if your service has a desired number
                                                                                                      	// of four tasks and a minimum healthy percent of 50%, the scheduler may stop two
                                                                                                      	// existing tasks to free up cluster capacity before starting two new tasks. Tasks
                                                                                                      	// for services that do not use a load balancer are considered healthy if they are
                                                                                                      	// in the RUNNING state; tasks for services that do use a load balancer are
                                                                                                      	// considered healthy if they are in the RUNNING state and they are reported as
                                                                                                      	// healthy by the load balancer. The default value for minimum healthy percent is
                                                                                                      	// 100%. If a service is using the blue/green (CODE_DEPLOY) or EXTERNAL deployment
                                                                                                      	// types and tasks that use the EC2 launch type, the minimum healthy percent value
                                                                                                      	// is set to the default value and is used to define the lower limit on the number
                                                                                                      	// of the tasks in the service that remain in the RUNNING state while the container
                                                                                                      	// instances are in the DRAINING state. If the tasks in the service use the Fargate
                                                                                                      	// launch type, the minimum healthy percent value is not used, although it is
                                                                                                      	// returned when describing your service.
                                                                                                      	MinimumHealthyPercent *int32
                                                                                                      }

                                                                                                        Optional deployment parameters that control how many tasks run during a deployment and the ordering of stopping and starting tasks.

                                                                                                        type DeploymentController

                                                                                                        type DeploymentController struct {
                                                                                                        
                                                                                                        	// The deployment controller type to use. There are three deployment controller
                                                                                                        	// types available: ECS The rolling update (ECS) deployment type involves replacing
                                                                                                        	// the current running version of the container with the latest version. The number
                                                                                                        	// of containers Amazon ECS adds or removes from the service during a rolling
                                                                                                        	// update is controlled by adjusting the minimum and maximum number of healthy
                                                                                                        	// tasks allowed during a service deployment, as specified in the
                                                                                                        	// DeploymentConfiguration. CODE_DEPLOY The blue/green (CODE_DEPLOY) deployment
                                                                                                        	// type uses the blue/green deployment model powered by AWS CodeDeploy, which
                                                                                                        	// allows you to verify a new deployment of a service before sending production
                                                                                                        	// traffic to it. EXTERNAL The external (EXTERNAL) deployment type enables you to
                                                                                                        	// use any third-party deployment controller for full control over the deployment
                                                                                                        	// process for an Amazon ECS service.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Type DeploymentControllerType
                                                                                                        }

                                                                                                          The deployment controller to use for the service. For more information, see Amazon ECS Deployment Types (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                          type DeploymentControllerType

                                                                                                          type DeploymentControllerType string
                                                                                                          const (
                                                                                                          	DeploymentControllerTypeEcs        DeploymentControllerType = "ECS"
                                                                                                          	DeploymentControllerTypeCodeDeploy DeploymentControllerType = "CODE_DEPLOY"
                                                                                                          	DeploymentControllerTypeExternal   DeploymentControllerType = "EXTERNAL"
                                                                                                          )

                                                                                                            Enum values for DeploymentControllerType

                                                                                                            func (DeploymentControllerType) Values

                                                                                                              Values returns all known values for DeploymentControllerType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                              type DeploymentRolloutState

                                                                                                              type DeploymentRolloutState string
                                                                                                              const (
                                                                                                              	DeploymentRolloutStateCompleted  DeploymentRolloutState = "COMPLETED"
                                                                                                              	DeploymentRolloutStateFailed     DeploymentRolloutState = "FAILED"
                                                                                                              	DeploymentRolloutStateInProgress DeploymentRolloutState = "IN_PROGRESS"
                                                                                                              )

                                                                                                                Enum values for DeploymentRolloutState

                                                                                                                func (DeploymentRolloutState) Values

                                                                                                                  Values returns all known values for DeploymentRolloutState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                  type DesiredStatus

                                                                                                                  type DesiredStatus string
                                                                                                                  const (
                                                                                                                  	DesiredStatusRunning DesiredStatus = "RUNNING"
                                                                                                                  	DesiredStatusPending DesiredStatus = "PENDING"
                                                                                                                  	DesiredStatusStopped DesiredStatus = "STOPPED"
                                                                                                                  )

                                                                                                                    Enum values for DesiredStatus

                                                                                                                    func (DesiredStatus) Values

                                                                                                                    func (DesiredStatus) Values() []DesiredStatus

                                                                                                                      Values returns all known values for DesiredStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                      type Device

                                                                                                                      type Device struct {
                                                                                                                      
                                                                                                                      	// The path for the device on the host container instance.
                                                                                                                      	//
                                                                                                                      	// This member is required.
                                                                                                                      	HostPath *string
                                                                                                                      
                                                                                                                      	// The path inside the container at which to expose the host device.
                                                                                                                      	ContainerPath *string
                                                                                                                      
                                                                                                                      	// The explicit permissions to provide to the container for the device. By default,
                                                                                                                      	// the container has permissions for read, write, and mknod for the device.
                                                                                                                      	Permissions []DeviceCgroupPermission
                                                                                                                      }

                                                                                                                        An object representing a container instance host device.

                                                                                                                        type DeviceCgroupPermission

                                                                                                                        type DeviceCgroupPermission string
                                                                                                                        const (
                                                                                                                        	DeviceCgroupPermissionRead  DeviceCgroupPermission = "read"
                                                                                                                        	DeviceCgroupPermissionWrite DeviceCgroupPermission = "write"
                                                                                                                        	DeviceCgroupPermissionMknod DeviceCgroupPermission = "mknod"
                                                                                                                        )

                                                                                                                          Enum values for DeviceCgroupPermission

                                                                                                                          func (DeviceCgroupPermission) Values

                                                                                                                            Values returns all known values for DeviceCgroupPermission. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                            type DockerVolumeConfiguration

                                                                                                                            type DockerVolumeConfiguration struct {
                                                                                                                            
                                                                                                                            	// If this value is true, the Docker volume is created if it does not already
                                                                                                                            	// exist. This field is only used if the scope is shared.
                                                                                                                            	Autoprovision *bool
                                                                                                                            
                                                                                                                            	// The Docker volume driver to use. The driver value must match the driver name
                                                                                                                            	// provided by Docker because it is used for task placement. If the driver was
                                                                                                                            	// installed using the Docker plugin CLI, use docker plugin ls to retrieve the
                                                                                                                            	// driver name from your container instance. If the driver was installed using
                                                                                                                            	// another method, use Docker plugin discovery to retrieve the driver name. For
                                                                                                                            	// more information, see Docker plugin discovery
                                                                                                                            	// (https://docs.docker.com/engine/extend/plugin_api/#plugin-discovery). This
                                                                                                                            	// parameter maps to Driver in the Create a volume
                                                                                                                            	// (https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of
                                                                                                                            	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                                                            	// xxdriver option to docker volume create
                                                                                                                            	// (https://docs.docker.com/engine/reference/commandline/volume_create/).
                                                                                                                            	Driver *string
                                                                                                                            
                                                                                                                            	// A map of Docker driver-specific options passed through. This parameter maps to
                                                                                                                            	// DriverOpts in the Create a volume
                                                                                                                            	// (https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of
                                                                                                                            	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the xxopt
                                                                                                                            	// option to docker volume create
                                                                                                                            	// (https://docs.docker.com/engine/reference/commandline/volume_create/).
                                                                                                                            	DriverOpts map[string]string
                                                                                                                            
                                                                                                                            	// Custom metadata to add to your Docker volume. This parameter maps to Labels in
                                                                                                                            	// the Create a volume
                                                                                                                            	// (https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of
                                                                                                                            	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                                                            	// xxlabel option to docker volume create
                                                                                                                            	// (https://docs.docker.com/engine/reference/commandline/volume_create/).
                                                                                                                            	Labels map[string]string
                                                                                                                            
                                                                                                                            	// The scope for the Docker volume that determines its lifecycle. Docker volumes
                                                                                                                            	// that are scoped to a task are automatically provisioned when the task starts and
                                                                                                                            	// destroyed when the task stops. Docker volumes that are scoped as shared persist
                                                                                                                            	// after the task stops.
                                                                                                                            	Scope Scope
                                                                                                                            }

                                                                                                                              This parameter is specified when you are using Docker volumes. Docker volumes are only supported when you are using the EC2 launch type. Windows containers only support the use of the local driver. To use bind mounts, specify a host instead.

                                                                                                                              type EFSAuthorizationConfig

                                                                                                                              type EFSAuthorizationConfig struct {
                                                                                                                              
                                                                                                                              	// The Amazon EFS access point ID to use. If an access point is specified, the root
                                                                                                                              	// directory value specified in the EFSVolumeConfiguration must either be omitted
                                                                                                                              	// or set to / which will enforce the path set on the EFS access point. If an
                                                                                                                              	// access point is used, transit encryption must be enabled in the
                                                                                                                              	// EFSVolumeConfiguration. For more information, see Working with Amazon EFS Access
                                                                                                                              	// Points (https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html) in the
                                                                                                                              	// Amazon Elastic File System User Guide.
                                                                                                                              	AccessPointId *string
                                                                                                                              
                                                                                                                              	// Whether or not to use the Amazon ECS task IAM role defined in a task definition
                                                                                                                              	// when mounting the Amazon EFS file system. If enabled, transit encryption must be
                                                                                                                              	// enabled in the EFSVolumeConfiguration. If this parameter is omitted, the default
                                                                                                                              	// value of DISABLED is used. For more information, see Using Amazon EFS Access
                                                                                                                              	// Points
                                                                                                                              	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints)
                                                                                                                              	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                              	Iam EFSAuthorizationConfigIAM
                                                                                                                              }

                                                                                                                                The authorization configuration details for the Amazon EFS file system.

                                                                                                                                type EFSAuthorizationConfigIAM

                                                                                                                                type EFSAuthorizationConfigIAM string
                                                                                                                                const (
                                                                                                                                	EFSAuthorizationConfigIAMEnabled  EFSAuthorizationConfigIAM = "ENABLED"
                                                                                                                                	EFSAuthorizationConfigIAMDisabled EFSAuthorizationConfigIAM = "DISABLED"
                                                                                                                                )

                                                                                                                                  Enum values for EFSAuthorizationConfigIAM

                                                                                                                                  func (EFSAuthorizationConfigIAM) Values

                                                                                                                                    Values returns all known values for EFSAuthorizationConfigIAM. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                    type EFSTransitEncryption

                                                                                                                                    type EFSTransitEncryption string
                                                                                                                                    const (
                                                                                                                                    	EFSTransitEncryptionEnabled  EFSTransitEncryption = "ENABLED"
                                                                                                                                    	EFSTransitEncryptionDisabled EFSTransitEncryption = "DISABLED"
                                                                                                                                    )

                                                                                                                                      Enum values for EFSTransitEncryption

                                                                                                                                      func (EFSTransitEncryption) Values

                                                                                                                                        Values returns all known values for EFSTransitEncryption. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                        type EFSVolumeConfiguration

                                                                                                                                        type EFSVolumeConfiguration struct {
                                                                                                                                        
                                                                                                                                        	// The Amazon EFS file system ID to use.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	FileSystemId *string
                                                                                                                                        
                                                                                                                                        	// The authorization configuration details for the Amazon EFS file system.
                                                                                                                                        	AuthorizationConfig *EFSAuthorizationConfig
                                                                                                                                        
                                                                                                                                        	// The directory within the Amazon EFS file system to mount as the root directory
                                                                                                                                        	// inside the host. If this parameter is omitted, the root of the Amazon EFS volume
                                                                                                                                        	// will be used. Specifying / will have the same effect as omitting this parameter.
                                                                                                                                        	// If an EFS access point is specified in the authorizationConfig, the root
                                                                                                                                        	// directory parameter must either be omitted or set to / which will enforce the
                                                                                                                                        	// path set on the EFS access point.
                                                                                                                                        	RootDirectory *string
                                                                                                                                        
                                                                                                                                        	// Whether or not to enable encryption for Amazon EFS data in transit between the
                                                                                                                                        	// Amazon ECS host and the Amazon EFS server. Transit encryption must be enabled if
                                                                                                                                        	// Amazon EFS IAM authorization is used. If this parameter is omitted, the default
                                                                                                                                        	// value of DISABLED is used. For more information, see Encrypting Data in Transit
                                                                                                                                        	// (https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html) in the
                                                                                                                                        	// Amazon Elastic File System User Guide.
                                                                                                                                        	TransitEncryption EFSTransitEncryption
                                                                                                                                        
                                                                                                                                        	// The port to use when sending encrypted data between the Amazon ECS host and the
                                                                                                                                        	// Amazon EFS server. If you do not specify a transit encryption port, it will use
                                                                                                                                        	// the port selection strategy that the Amazon EFS mount helper uses. For more
                                                                                                                                        	// information, see EFS Mount Helper
                                                                                                                                        	// (https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html) in the Amazon
                                                                                                                                        	// Elastic File System User Guide.
                                                                                                                                        	TransitEncryptionPort *int32
                                                                                                                                        }

                                                                                                                                          This parameter is specified when you are using an Amazon Elastic File System file system for task storage. For more information, see Amazon EFS Volumes (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                                                          type EnvironmentFile

                                                                                                                                          type EnvironmentFile struct {
                                                                                                                                          
                                                                                                                                          	// The file type to use. The only supported value is s3.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Type EnvironmentFileType
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) of the Amazon S3 object containing the
                                                                                                                                          	// environment variable file.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Value *string
                                                                                                                                          }

                                                                                                                                            A list of files containing the environment variables to pass to a container. You can specify up to ten environment files. The file must have a .env file extension. Each line in an environment file should contain an environment variable in VARIABLE=VALUE format. Lines beginning with # are treated as comments and are ignored. For more information on the environment variable file syntax, see Declare default environment variables in file (https://docs.docker.com/compose/env-file/). If there are environment variables specified using the environment parameter in a container definition, they take precedence over the variables contained within an environment file. If multiple environment files are specified that contain the same variable, they are processed from the top down. It is recommended to use unique variable names. For more information, see Specifying Environment Variables (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/taskdef-envfiles.html) in the Amazon Elastic Container Service Developer Guide. This field is not valid for containers in tasks using the Fargate launch type.

                                                                                                                                            type EnvironmentFileType

                                                                                                                                            type EnvironmentFileType string
                                                                                                                                            const (
                                                                                                                                            	EnvironmentFileTypeS3 EnvironmentFileType = "s3"
                                                                                                                                            )

                                                                                                                                              Enum values for EnvironmentFileType

                                                                                                                                              func (EnvironmentFileType) Values

                                                                                                                                                Values returns all known values for EnvironmentFileType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                type FSxWindowsFileServerAuthorizationConfig

                                                                                                                                                type FSxWindowsFileServerAuthorizationConfig struct {
                                                                                                                                                
                                                                                                                                                	// The authorization credential option to use. The authorization credential options
                                                                                                                                                	// can be provided using either the Amazon Resource Name (ARN) of an AWS Secrets
                                                                                                                                                	// Manager secret or AWS Systems Manager Parameter Store parameter. The ARNs refer
                                                                                                                                                	// to the stored credentials.
                                                                                                                                                	//
                                                                                                                                                	// This member is required.
                                                                                                                                                	CredentialsParameter *string
                                                                                                                                                
                                                                                                                                                	// A fully qualified domain name hosted by an AWS Directory Service
                                                                                                                                                	// (https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)
                                                                                                                                                	// Managed Microsoft AD (Active Directory) or self-hosted AD on Amazon EC2.
                                                                                                                                                	//
                                                                                                                                                	// This member is required.
                                                                                                                                                	Domain *string
                                                                                                                                                }

                                                                                                                                                  The authorization configuration details for Amazon FSx for Windows File Server file system. See FSxWindowsFileServerVolumeConfiguration (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_FSxWindowsFileServerVolumeConfiguration.html) in the Amazon Elastic Container Service API Reference. For more information and the input format, see Amazon FSx for Windows File Server Volumes (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/wfsx-volumes.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                                                                  type FSxWindowsFileServerVolumeConfiguration

                                                                                                                                                  type FSxWindowsFileServerVolumeConfiguration struct {
                                                                                                                                                  
                                                                                                                                                  	// The authorization configuration details for the Amazon FSx for Windows File
                                                                                                                                                  	// Server file system.
                                                                                                                                                  	//
                                                                                                                                                  	// This member is required.
                                                                                                                                                  	AuthorizationConfig *FSxWindowsFileServerAuthorizationConfig
                                                                                                                                                  
                                                                                                                                                  	// The Amazon FSx for Windows File Server file system ID to use.
                                                                                                                                                  	//
                                                                                                                                                  	// This member is required.
                                                                                                                                                  	FileSystemId *string
                                                                                                                                                  
                                                                                                                                                  	// The directory within the Amazon FSx for Windows File Server file system to mount
                                                                                                                                                  	// as the root directory inside the host.
                                                                                                                                                  	//
                                                                                                                                                  	// This member is required.
                                                                                                                                                  	RootDirectory *string
                                                                                                                                                  }

                                                                                                                                                    This parameter is specified when you are using Amazon FSx for Windows File Server (https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) file system for task storage. For more information and the input format, see Amazon FSx for Windows File Server Volumes (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/wfsx-volumes.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                                                                    type Failure

                                                                                                                                                    type Failure struct {
                                                                                                                                                    
                                                                                                                                                    	// The Amazon Resource Name (ARN) of the failed resource.
                                                                                                                                                    	Arn *string
                                                                                                                                                    
                                                                                                                                                    	// The details of the failure.
                                                                                                                                                    	Detail *string
                                                                                                                                                    
                                                                                                                                                    	// The reason for the failure.
                                                                                                                                                    	Reason *string
                                                                                                                                                    }

                                                                                                                                                      A failed resource. For a list of common causes, see API failure reasons (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/api_failures_messages.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                                                                      type FirelensConfiguration

                                                                                                                                                      type FirelensConfiguration struct {
                                                                                                                                                      
                                                                                                                                                      	// The log router to use. The valid values are fluentd or fluentbit.
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	Type FirelensConfigurationType
                                                                                                                                                      
                                                                                                                                                      	// The options to use when configuring the log router. This field is optional and
                                                                                                                                                      	// can be used to specify a custom configuration file or to add additional
                                                                                                                                                      	// metadata, such as the task, task definition, cluster, and container instance
                                                                                                                                                      	// details to the log event. If specified, the syntax to use is
                                                                                                                                                      	// "options":{"enable-ecs-log-metadata":"true|false","config-file-type:"s3|file","config-file-value":"arn:aws:s3:::mybucket/fluent.conf|filepath"}.
                                                                                                                                                      	// For more information, see Creating a Task Definition that Uses a FireLens
                                                                                                                                                      	// Configuration
                                                                                                                                                      	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html#firelens-taskdef)
                                                                                                                                                      	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                      	Options map[string]string
                                                                                                                                                      }

                                                                                                                                                        The FireLens configuration for the container. This is used to specify and configure a log router for container logs. For more information, see Custom Log Routing (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                                                                        type FirelensConfigurationType

                                                                                                                                                        type FirelensConfigurationType string
                                                                                                                                                        const (
                                                                                                                                                        	FirelensConfigurationTypeFluentd   FirelensConfigurationType = "fluentd"
                                                                                                                                                        	FirelensConfigurationTypeFluentbit FirelensConfigurationType = "fluentbit"
                                                                                                                                                        )

                                                                                                                                                          Enum values for FirelensConfigurationType

                                                                                                                                                          func (FirelensConfigurationType) Values

                                                                                                                                                            Values returns all known values for FirelensConfigurationType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                            type HealthCheck

                                                                                                                                                            type HealthCheck struct {
                                                                                                                                                            
                                                                                                                                                            	// A string array representing the command that the container runs to determine if
                                                                                                                                                            	// it is healthy. The string array must start with CMD to execute the command
                                                                                                                                                            	// arguments directly, or CMD-SHELL to run the command with the container's default
                                                                                                                                                            	// shell. For example: [ "CMD-SHELL", "curl -f http://localhost/ || exit 1" ] An
                                                                                                                                                            	// exit code of 0 indicates success, and non-zero exit code indicates failure. For
                                                                                                                                                            	// more information, see HealthCheck in the Create a container
                                                                                                                                                            	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                                                                                            	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/).
                                                                                                                                                            	//
                                                                                                                                                            	// This member is required.
                                                                                                                                                            	Command []string
                                                                                                                                                            
                                                                                                                                                            	// The time period in seconds between each health check execution. You may specify
                                                                                                                                                            	// between 5 and 300 seconds. The default value is 30 seconds.
                                                                                                                                                            	Interval *int32
                                                                                                                                                            
                                                                                                                                                            	// The number of times to retry a failed health check before the container is
                                                                                                                                                            	// considered unhealthy. You may specify between 1 and 10 retries. The default
                                                                                                                                                            	// value is 3.
                                                                                                                                                            	Retries *int32
                                                                                                                                                            
                                                                                                                                                            	// The optional grace period within which to provide containers time to bootstrap
                                                                                                                                                            	// before failed health checks count towards the maximum number of retries. You may
                                                                                                                                                            	// specify between 0 and 300 seconds. The startPeriod is disabled by default. If a
                                                                                                                                                            	// health check succeeds within the startPeriod, then the container is considered
                                                                                                                                                            	// healthy and any subsequent failures count toward the maximum number of retries.
                                                                                                                                                            	StartPeriod *int32
                                                                                                                                                            
                                                                                                                                                            	// The time period in seconds to wait for a health check to succeed before it is
                                                                                                                                                            	// considered a failure. You may specify between 2 and 60 seconds. The default
                                                                                                                                                            	// value is 5.
                                                                                                                                                            	Timeout *int32
                                                                                                                                                            }

                                                                                                                                                              An object representing a container health check. Health check parameters that are specified in a container definition override any Docker health checks that exist in the container image (such as those specified in a parent image or from the image's Dockerfile). You can view the health status of both individual containers and a task with the DescribeTasks API operation or when viewing the task details in the console. The following describes the possible healthStatus values for a container:

                                                                                                                                                              * HEALTHY-The container health check has passed successfully.

                                                                                                                                                              * UNHEALTHY-The container health check has failed.

                                                                                                                                                              * UNKNOWN-The container health check is being evaluated or there is no container health check defined.

                                                                                                                                                              The following describes the possible healthStatus values for a task. The container health check status of nonessential containers do not have an effect on the health status of a task.

                                                                                                                                                              * HEALTHY-All essential containers within the task have passed their health checks.

                                                                                                                                                              * UNHEALTHY-One or more essential containers have failed their health check.

                                                                                                                                                              * UNKNOWN-The essential containers within the task are still having their health checks evaluated or there are no container health checks defined.

                                                                                                                                                              If a task is run manually, and not as part of a service, the task will continue its lifecycle regardless of its health status. For tasks that are part of a service, if the task reports as unhealthy then the task will be stopped and the service scheduler will replace it. The following are notes about container health check support:

                                                                                                                                                              * Container health checks require version 1.17.0 or greater of the Amazon ECS container agent. For more information, see Updating the Amazon ECS Container Agent (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html).

                                                                                                                                                              * Container health checks are supported for Fargate tasks if you are using platform version 1.1.0 or greater. For more information, see AWS Fargate Platform Versions (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html).

                                                                                                                                                              * Container health checks are not supported for tasks that are part of a service that is configured to use a Classic Load Balancer.

                                                                                                                                                              type HealthStatus

                                                                                                                                                              type HealthStatus string
                                                                                                                                                              const (
                                                                                                                                                              	HealthStatusHealthy   HealthStatus = "HEALTHY"
                                                                                                                                                              	HealthStatusUnhealthy HealthStatus = "UNHEALTHY"
                                                                                                                                                              	HealthStatusUnknown   HealthStatus = "UNKNOWN"
                                                                                                                                                              )

                                                                                                                                                                Enum values for HealthStatus

                                                                                                                                                                func (HealthStatus) Values

                                                                                                                                                                func (HealthStatus) Values() []HealthStatus

                                                                                                                                                                  Values returns all known values for HealthStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                  type HostEntry

                                                                                                                                                                  type HostEntry struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The hostname to use in the /etc/hosts entry.
                                                                                                                                                                  	//
                                                                                                                                                                  	// This member is required.
                                                                                                                                                                  	Hostname *string
                                                                                                                                                                  
                                                                                                                                                                  	// The IP address to use in the /etc/hosts entry.
                                                                                                                                                                  	//
                                                                                                                                                                  	// This member is required.
                                                                                                                                                                  	IpAddress *string
                                                                                                                                                                  }

                                                                                                                                                                    Hostnames and IP address entries that are added to the /etc/hosts file of a container via the extraHosts parameter of its ContainerDefinition.

                                                                                                                                                                    type HostVolumeProperties

                                                                                                                                                                    type HostVolumeProperties struct {
                                                                                                                                                                    
                                                                                                                                                                    	// When the host parameter is used, specify a sourcePath to declare the path on the
                                                                                                                                                                    	// host container instance that is presented to the container. If this parameter is
                                                                                                                                                                    	// empty, then the Docker daemon has assigned a host path for you. If the host
                                                                                                                                                                    	// parameter contains a sourcePath file location, then the data volume persists at
                                                                                                                                                                    	// the specified location on the host container instance until you delete it
                                                                                                                                                                    	// manually. If the sourcePath value does not exist on the host container instance,
                                                                                                                                                                    	// the Docker daemon creates it. If the location does exist, the contents of the
                                                                                                                                                                    	// source path folder are exported. If you are using the Fargate launch type, the
                                                                                                                                                                    	// sourcePath parameter is not supported.
                                                                                                                                                                    	SourcePath *string
                                                                                                                                                                    }

                                                                                                                                                                      Details on a container instance bind mount host volume.

                                                                                                                                                                      type InferenceAccelerator

                                                                                                                                                                      type InferenceAccelerator struct {
                                                                                                                                                                      
                                                                                                                                                                      	// The Elastic Inference accelerator device name. The deviceName must also be
                                                                                                                                                                      	// referenced in a container definition as a ResourceRequirement.
                                                                                                                                                                      	//
                                                                                                                                                                      	// This member is required.
                                                                                                                                                                      	DeviceName *string
                                                                                                                                                                      
                                                                                                                                                                      	// The Elastic Inference accelerator type to use.
                                                                                                                                                                      	//
                                                                                                                                                                      	// This member is required.
                                                                                                                                                                      	DeviceType *string
                                                                                                                                                                      }

                                                                                                                                                                        Details on a Elastic Inference accelerator. For more information, see Working with Amazon Elastic Inference on Amazon ECS (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-eia.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                                                                                        type InferenceAcceleratorOverride

                                                                                                                                                                        type InferenceAcceleratorOverride struct {
                                                                                                                                                                        
                                                                                                                                                                        	// The Elastic Inference accelerator device name to override for the task. This
                                                                                                                                                                        	// parameter must match a deviceName specified in the task definition.
                                                                                                                                                                        	DeviceName *string
                                                                                                                                                                        
                                                                                                                                                                        	// The Elastic Inference accelerator type to use.
                                                                                                                                                                        	DeviceType *string
                                                                                                                                                                        }

                                                                                                                                                                          Details on an Elastic Inference accelerator task override. This parameter is used to override the Elastic Inference accelerator specified in the task definition. For more information, see Working with Amazon Elastic Inference on Amazon ECS (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-eia.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                                                                                          type InvalidParameterException

                                                                                                                                                                          type InvalidParameterException struct {
                                                                                                                                                                          	Message *string
                                                                                                                                                                          }

                                                                                                                                                                            The specified parameter is invalid. Review the available parameters for the API request.

                                                                                                                                                                            func (*InvalidParameterException) Error

                                                                                                                                                                            func (e *InvalidParameterException) Error() string

                                                                                                                                                                            func (*InvalidParameterException) ErrorCode

                                                                                                                                                                            func (e *InvalidParameterException) ErrorCode() string

                                                                                                                                                                            func (*InvalidParameterException) ErrorFault

                                                                                                                                                                            func (*InvalidParameterException) ErrorMessage

                                                                                                                                                                            func (e *InvalidParameterException) ErrorMessage() string

                                                                                                                                                                            type IpcMode

                                                                                                                                                                            type IpcMode string
                                                                                                                                                                            const (
                                                                                                                                                                            	IpcModeHost IpcMode = "host"
                                                                                                                                                                            	IpcModeTask IpcMode = "task"
                                                                                                                                                                            	IpcModeNone IpcMode = "none"
                                                                                                                                                                            )

                                                                                                                                                                              Enum values for IpcMode

                                                                                                                                                                              func (IpcMode) Values

                                                                                                                                                                              func (IpcMode) Values() []IpcMode

                                                                                                                                                                                Values returns all known values for IpcMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                type KernelCapabilities

                                                                                                                                                                                type KernelCapabilities struct {
                                                                                                                                                                                
                                                                                                                                                                                	// The Linux capabilities for the container that have been added to the default
                                                                                                                                                                                	// configuration provided by Docker. This parameter maps to CapAdd in the Create a
                                                                                                                                                                                	// container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
                                                                                                                                                                                	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and
                                                                                                                                                                                	// the --cap-add option to docker run
                                                                                                                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). Tasks
                                                                                                                                                                                	// launched on AWS Fargate only support adding the SYS_PTRACE kernel capability.
                                                                                                                                                                                	// Valid values: "ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" |
                                                                                                                                                                                	// "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK"
                                                                                                                                                                                	// | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" |
                                                                                                                                                                                	// "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" |
                                                                                                                                                                                	// "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" |
                                                                                                                                                                                	// "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" |
                                                                                                                                                                                	// "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" |
                                                                                                                                                                                	// "SYSLOG" | "WAKE_ALARM"
                                                                                                                                                                                	Add []string
                                                                                                                                                                                
                                                                                                                                                                                	// The Linux capabilities for the container that have been removed from the default
                                                                                                                                                                                	// configuration provided by Docker. This parameter maps to CapDrop in the Create a
                                                                                                                                                                                	// container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
                                                                                                                                                                                	// section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and
                                                                                                                                                                                	// the --cap-drop option to docker run
                                                                                                                                                                                	// (https://docs.docker.com/engine/reference/run/#security-configuration). Valid
                                                                                                                                                                                	// values: "ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" | "CHOWN" |
                                                                                                                                                                                	// "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK" |
                                                                                                                                                                                	// "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" |
                                                                                                                                                                                	// "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" |
                                                                                                                                                                                	// "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" |
                                                                                                                                                                                	// "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" |
                                                                                                                                                                                	// "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" |
                                                                                                                                                                                	// "SYSLOG" | "WAKE_ALARM"
                                                                                                                                                                                	Drop []string
                                                                                                                                                                                }

                                                                                                                                                                                  The Linux capabilities for the container that are added to or dropped from the default configuration provided by Docker. For more information on the default capabilities and the non-default available capabilities, see Runtime privilege and Linux capabilities (https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) in the Docker run reference. For more detailed information on these Linux capabilities, see the capabilities(7) (http://man7.org/linux/man-pages/man7/capabilities.7.html) Linux manual page.

                                                                                                                                                                                  type KeyValuePair

                                                                                                                                                                                  type KeyValuePair struct {
                                                                                                                                                                                  
                                                                                                                                                                                  	// The name of the key-value pair. For environment variables, this is the name of
                                                                                                                                                                                  	// the environment variable.
                                                                                                                                                                                  	Name *string
                                                                                                                                                                                  
                                                                                                                                                                                  	// The value of the key-value pair. For environment variables, this is the value of
                                                                                                                                                                                  	// the environment variable.
                                                                                                                                                                                  	Value *string
                                                                                                                                                                                  }

                                                                                                                                                                                    A key-value pair object.

                                                                                                                                                                                    type LaunchType

                                                                                                                                                                                    type LaunchType string
                                                                                                                                                                                    const (
                                                                                                                                                                                    	LaunchTypeEc2     LaunchType = "EC2"
                                                                                                                                                                                    	LaunchTypeFargate LaunchType = "FARGATE"
                                                                                                                                                                                    )

                                                                                                                                                                                      Enum values for LaunchType

                                                                                                                                                                                      func (LaunchType) Values

                                                                                                                                                                                      func (LaunchType) Values() []LaunchType

                                                                                                                                                                                        Values returns all known values for LaunchType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                        type LimitExceededException

                                                                                                                                                                                        type LimitExceededException struct {
                                                                                                                                                                                        	Message *string
                                                                                                                                                                                        }

                                                                                                                                                                                          The limit for the resource has been exceeded.

                                                                                                                                                                                          func (*LimitExceededException) Error

                                                                                                                                                                                          func (e *LimitExceededException) Error() string

                                                                                                                                                                                          func (*LimitExceededException) ErrorCode

                                                                                                                                                                                          func (e *LimitExceededException) ErrorCode() string

                                                                                                                                                                                          func (*LimitExceededException) ErrorFault

                                                                                                                                                                                          func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                          func (*LimitExceededException) ErrorMessage

                                                                                                                                                                                          func (e *LimitExceededException) ErrorMessage() string

                                                                                                                                                                                          type LinuxParameters

                                                                                                                                                                                          type LinuxParameters struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The Linux capabilities for the container that are added to or dropped from the
                                                                                                                                                                                          	// default configuration provided by Docker. For tasks that use the Fargate launch
                                                                                                                                                                                          	// type, capabilities is supported for all platform versions but the add parameter
                                                                                                                                                                                          	// is only supported if using platform version 1.4.0 or later.
                                                                                                                                                                                          	Capabilities *KernelCapabilities
                                                                                                                                                                                          
                                                                                                                                                                                          	// Any host devices to expose to the container. This parameter maps to Devices in
                                                                                                                                                                                          	// the Create a container
                                                                                                                                                                                          	// (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
                                                                                                                                                                                          	// the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the
                                                                                                                                                                                          	// --device option to docker run
                                                                                                                                                                                          	// (https://docs.docker.com/engine/reference/run/#security-configuration). If you
                                                                                                                                                                                          	// are using tasks that use the Fargate launch type, the devices parameter is not
                                                                                                                                                                                          	// supported.
                                                                                                                                                                                          	Devices []Device
                                                                                                                                                                                          
                                                                                                                                                                                          	// Run an init process inside the container that forwards signals and reaps
                                                                                                                                                                                          	// processes. This parameter maps to the --init option to docker run
                                                                                                                                                                                          	// (https://docs.docker.com/engine/reference/run/#security-configuration). This
                                                                                                                                                                                          	// parameter requires version 1.25 of the Docker Remote API or greater on your
                                                                                                                                                                                          	// container instance. To check the Docker Remote API version on your container
                                                                                                                                                                                          	// instance, log in to your container instance and run the following command: sudo
                                                                                                                                                                                          	// docker version --format '{{.Server.APIVersion}}'
                                                                                                                                                                                          	InitProcessEnabled *bool
                                                                                                                                                                                          
                                                                                                                                                                                          	// The total amount of swap memory (in MiB) a container can use. This parameter
                                                                                                                                                                                          	// will be translated to the --memory-swap option to docker run
                                                                                                                                                                                          	// (https://docs.docker.com/engine/reference/run/#security-configuration) where the
                                                                                                                                                                                          	// value would be the sum of the container memory plus the maxSwap value. If a
                                                                                                                                                                                          	// maxSwap value of 0 is specified, the container will not use swap. Accepted
                                                                                                                                                                                          	// values are 0 or any positive integer. If the maxSwap parameter is omitted, the
                                                                                                                                                                                          	// container will use the swap configuration for the container instance it is
                                                                                                                                                                                          	// running on. A maxSwap value must be set for the swappiness parameter to be used.
                                                                                                                                                                                          	// If you are using tasks that use the Fargate launch type, the maxSwap parameter
                                                                                                                                                                                          	// is not supported.
                                                                                                                                                                                          	MaxSwap *int32
                                                                                                                                                                                          
                                                                                                                                                                                          	// The value for the size (in MiB) of the /dev/shm volume. This parameter maps to
                                                                                                                                                                                          	// the --shm-size option to docker run
                                                                                                                                                                                          	// (https://docs.docker.com/engine/reference/run/#security-configuration). If you
                                                                                                                                                                                          	// are using tasks that use the Fargate launch type, the sharedMemorySize parameter
                                                                                                                                                                                          	// is not supported.
                                                                                                                                                                                          	SharedMemorySize *int32
                                                                                                                                                                                          
                                                                                                                                                                                          	// This allows you to tune a container's memory swappiness behavior. A swappiness
                                                                                                                                                                                          	// value of 0 will cause swapping to not happen unless absolutely necessary. A
                                                                                                                                                                                          	// swappiness value of 100 will cause pages to be swapped very aggressively.
                                                                                                                                                                                          	// Accepted values are whole numbers between 0 and 100. If the swappiness parameter
                                                                                                                                                                                          	// is not specified, a default value of 60 is used. If a value is not specified for
                                                                                                                                                                                          	// maxSwap then this parameter is ignored. This parameter maps to the
                                                                                                                                                                                          	// --memory-swappiness option to docker run
                                                                                                                                                                                          	// (https://docs.docker.com/engine/reference/run/#security-configuration). If you
                                                                                                                                                                                          	// are using tasks that use the Fargate launch type, the swappiness parameter is
                                                                                                                                                                                          	// not supported.
                                                                                                                                                                                          	Swappiness *int32
                                                                                                                                                                                          
                                                                                                                                                                                          	// The container path, mount options, and size (in MiB) of the tmpfs mount. This
                                                                                                                                                                                          	// parameter maps to the --tmpfs option to docker run
                                                                                                                                                                                          	// (https://docs.docker.com/engine/reference/run/#security-configuration). If you
                                                                                                                                                                                          	// are using tasks that use the Fargate launch type, the tmpfs parameter is not
                                                                                                                                                                                          	// supported.
                                                                                                                                                                                          	Tmpfs []Tmpfs
                                                                                                                                                                                          }

                                                                                                                                                                                            Linux-specific options that are applied to the container, such as Linux KernelCapabilities.

                                                                                                                                                                                            type LoadBalancer

                                                                                                                                                                                            type LoadBalancer struct {
                                                                                                                                                                                            
                                                                                                                                                                                            	// The name of the container (as it appears in a container definition) to associate
                                                                                                                                                                                            	// with the load balancer.
                                                                                                                                                                                            	ContainerName *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The port on the container to associate with the load balancer. This port must
                                                                                                                                                                                            	// correspond to a containerPort in the task definition the tasks in the service
                                                                                                                                                                                            	// are using. For tasks that use the EC2 launch type, the container instance they
                                                                                                                                                                                            	// are launched on must allow ingress traffic on the hostPort of the port mapping.
                                                                                                                                                                                            	ContainerPort *int32
                                                                                                                                                                                            
                                                                                                                                                                                            	// The name of the load balancer to associate with the Amazon ECS service or task
                                                                                                                                                                                            	// set. A load balancer name is only specified when using a Classic Load Balancer.
                                                                                                                                                                                            	// If you are using an Application Load Balancer or a Network Load Balancer the
                                                                                                                                                                                            	// load balancer name parameter should be omitted.
                                                                                                                                                                                            	LoadBalancerName *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The full Amazon Resource Name (ARN) of the Elastic Load Balancing target group
                                                                                                                                                                                            	// or groups associated with a service or task set. A target group ARN is only
                                                                                                                                                                                            	// specified when using an Application Load Balancer or Network Load Balancer. If
                                                                                                                                                                                            	// you are using a Classic Load Balancer the target group ARN should be omitted.
                                                                                                                                                                                            	// For services using the ECS deployment controller, you can specify one or
                                                                                                                                                                                            	// multiple target groups. For more information, see Registering Multiple Target
                                                                                                                                                                                            	// Groups with a Service
                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html)
                                                                                                                                                                                            	// in the Amazon Elastic Container Service Developer Guide. For services using the
                                                                                                                                                                                            	// CODE_DEPLOY deployment controller, you are required to define two target groups
                                                                                                                                                                                            	// for the load balancer. For more information, see Blue/Green Deployment with
                                                                                                                                                                                            	// CodeDeploy
                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-bluegreen.html)
                                                                                                                                                                                            	// in the Amazon Elastic Container Service Developer Guide. If your service's task
                                                                                                                                                                                            	// definition uses the awsvpc network mode (which is required for the Fargate
                                                                                                                                                                                            	// launch type), you must choose ip as the target type, not instance, when creating
                                                                                                                                                                                            	// your target groups because tasks that use the awsvpc network mode are associated
                                                                                                                                                                                            	// with an elastic network interface, not an Amazon EC2 instance.
                                                                                                                                                                                            	TargetGroupArn *string
                                                                                                                                                                                            }

                                                                                                                                                                                              The load balancer configuration to use with a service or task set. For specific notes and restrictions regarding the use of load balancers with services and task sets, see the CreateService and CreateTaskSet actions.

                                                                                                                                                                                              type LogConfiguration

                                                                                                                                                                                              type LogConfiguration struct {
                                                                                                                                                                                              
                                                                                                                                                                                              	// The log driver to use for the container. For tasks on AWS Fargate, the supported
                                                                                                                                                                                              	// log drivers are awslogs, splunk, and awsfirelens. For tasks hosted on Amazon EC2
                                                                                                                                                                                              	// instances, the supported log drivers are awslogs, fluentd, gelf, json-file,
                                                                                                                                                                                              	// journald, logentries,syslog, splunk, and awsfirelens. For more information about
                                                                                                                                                                                              	// using the awslogs log driver, see Using the awslogs log driver
                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html)
                                                                                                                                                                                              	// in the Amazon Elastic Container Service Developer Guide. For more information
                                                                                                                                                                                              	// about using the awsfirelens log driver, see Custom log routing
                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html)
                                                                                                                                                                                              	// in the Amazon Elastic Container Service Developer Guide. If you have a custom
                                                                                                                                                                                              	// driver that is not listed, you can fork the Amazon ECS container agent project
                                                                                                                                                                                              	// that is available on GitHub (https://github.com/aws/amazon-ecs-agent) and
                                                                                                                                                                                              	// customize it to work with that driver. We encourage you to submit pull requests
                                                                                                                                                                                              	// for changes that you would like to have included. However, we do not currently
                                                                                                                                                                                              	// provide support for running modified copies of this software.
                                                                                                                                                                                              	//
                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                              	LogDriver LogDriver
                                                                                                                                                                                              
                                                                                                                                                                                              	// The configuration options to send to the log driver. This parameter requires
                                                                                                                                                                                              	// version 1.19 of the Docker Remote API or greater on your container instance. To
                                                                                                                                                                                              	// check the Docker Remote API version on your container instance, log in to your
                                                                                                                                                                                              	// container instance and run the following command: sudo docker version --format
                                                                                                                                                                                              	// '{{.Server.APIVersion}}'
                                                                                                                                                                                              	Options map[string]string
                                                                                                                                                                                              
                                                                                                                                                                                              	// The secrets to pass to the log configuration. For more information, see
                                                                                                                                                                                              	// Specifying Sensitive Data
                                                                                                                                                                                              	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html)
                                                                                                                                                                                              	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                              	SecretOptions []Secret
                                                                                                                                                                                              }

                                                                                                                                                                                                The log configuration for the container. This parameter maps to LogConfig in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --log-driver option to docker run (https://docs.docker.com/engine/reference/commandline/run/). By default, containers use the same logging driver that the Docker daemon uses; however the container may use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition. For more information on the options for different supported log drivers, see Configure logging drivers (https://docs.docker.com/engine/admin/logging/overview/) in the Docker documentation. The following should be noted when specifying a log configuration for your containers:

                                                                                                                                                                                                * Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon (shown in the valid values below). Additional log drivers may be available in future releases of the Amazon ECS container agent.

                                                                                                                                                                                                * This parameter requires version 1.18 of the Docker Remote API or greater on your container instance.

                                                                                                                                                                                                * For tasks hosted on Amazon EC2 instances, the Amazon ECS container agent must register the available logging drivers with the ECS_AVAILABLE_LOGGING_DRIVERS environment variable before containers placed on that instance can use these log configuration options. For more information, see Amazon ECS container agent configuration (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                                                                                                                * For tasks on AWS Fargate, because you do not have access to the underlying infrastructure your tasks are hosted on, any additional software needed will have to be installed outside of the task. For example, the Fluentd output aggregators or a remote host running Logstash to send Gelf logs to.

                                                                                                                                                                                                type LogDriver

                                                                                                                                                                                                type LogDriver string
                                                                                                                                                                                                const (
                                                                                                                                                                                                	LogDriverJsonFile    LogDriver = "json-file"
                                                                                                                                                                                                	LogDriverSyslog      LogDriver = "syslog"
                                                                                                                                                                                                	LogDriverJournald    LogDriver = "journald"
                                                                                                                                                                                                	LogDriverGelf        LogDriver = "gelf"
                                                                                                                                                                                                	LogDriverFluentd     LogDriver = "fluentd"
                                                                                                                                                                                                	LogDriverAwslogs     LogDriver = "awslogs"
                                                                                                                                                                                                	LogDriverSplunk      LogDriver = "splunk"
                                                                                                                                                                                                	LogDriverAwsfirelens LogDriver = "awsfirelens"
                                                                                                                                                                                                )

                                                                                                                                                                                                  Enum values for LogDriver

                                                                                                                                                                                                  func (LogDriver) Values

                                                                                                                                                                                                  func (LogDriver) Values() []LogDriver

                                                                                                                                                                                                    Values returns all known values for LogDriver. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                    type ManagedScaling

                                                                                                                                                                                                    type ManagedScaling struct {
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The period of time, in seconds, after a newly launched Amazon EC2 instance can
                                                                                                                                                                                                    	// contribute to CloudWatch metrics for Auto Scaling group. If this parameter is
                                                                                                                                                                                                    	// omitted, the default value of 300 seconds is used.
                                                                                                                                                                                                    	InstanceWarmupPeriod *int32
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The maximum number of container instances that Amazon ECS will scale in or scale
                                                                                                                                                                                                    	// out at one time. If this parameter is omitted, the default value of 10000 is
                                                                                                                                                                                                    	// used.
                                                                                                                                                                                                    	MaximumScalingStepSize *int32
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The minimum number of container instances that Amazon ECS will scale in or scale
                                                                                                                                                                                                    	// out at one time. If this parameter is omitted, the default value of 1 is used.
                                                                                                                                                                                                    	MinimumScalingStepSize *int32
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// Whether or not to enable managed scaling for the capacity provider.
                                                                                                                                                                                                    	Status ManagedScalingStatus
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The target capacity value for the capacity provider. The specified value must be
                                                                                                                                                                                                    	// greater than 0 and less than or equal to 100. A value of 100 will result in the
                                                                                                                                                                                                    	// Amazon EC2 instances in your Auto Scaling group being completely utilized.
                                                                                                                                                                                                    	TargetCapacity *int32
                                                                                                                                                                                                    }

                                                                                                                                                                                                      The managed scaling settings for the Auto Scaling group capacity provider. When managed scaling is enabled, Amazon ECS manages the scale-in and scale-out actions of the Auto Scaling group. Amazon ECS manages a target tracking scaling policy using an Amazon ECS-managed CloudWatch metric with the specified targetCapacity value as the target value for the metric. For more information, see Using Managed Scaling (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/asg-capacity-providers.html#asg-capacity-providers-managed-scaling) in the Amazon Elastic Container Service Developer Guide. If managed scaling is disabled, the user must manage the scaling of the Auto Scaling group.

                                                                                                                                                                                                      type ManagedScalingStatus

                                                                                                                                                                                                      type ManagedScalingStatus string
                                                                                                                                                                                                      const (
                                                                                                                                                                                                      	ManagedScalingStatusEnabled  ManagedScalingStatus = "ENABLED"
                                                                                                                                                                                                      	ManagedScalingStatusDisabled ManagedScalingStatus = "DISABLED"
                                                                                                                                                                                                      )

                                                                                                                                                                                                        Enum values for ManagedScalingStatus

                                                                                                                                                                                                        func (ManagedScalingStatus) Values

                                                                                                                                                                                                          Values returns all known values for ManagedScalingStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                          type ManagedTerminationProtection

                                                                                                                                                                                                          type ManagedTerminationProtection string
                                                                                                                                                                                                          const (
                                                                                                                                                                                                          	ManagedTerminationProtectionEnabled  ManagedTerminationProtection = "ENABLED"
                                                                                                                                                                                                          	ManagedTerminationProtectionDisabled ManagedTerminationProtection = "DISABLED"
                                                                                                                                                                                                          )

                                                                                                                                                                                                            Enum values for ManagedTerminationProtection

                                                                                                                                                                                                            func (ManagedTerminationProtection) Values

                                                                                                                                                                                                              Values returns all known values for ManagedTerminationProtection. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                              type MissingVersionException

                                                                                                                                                                                                              type MissingVersionException struct {
                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                              }

                                                                                                                                                                                                                Amazon ECS is unable to determine the current version of the Amazon ECS container agent on the container instance and does not have enough information to proceed with an update. This could be because the agent running on the container instance is an older or custom version that does not use our version information.

                                                                                                                                                                                                                func (*MissingVersionException) Error

                                                                                                                                                                                                                func (e *MissingVersionException) Error() string

                                                                                                                                                                                                                func (*MissingVersionException) ErrorCode

                                                                                                                                                                                                                func (e *MissingVersionException) ErrorCode() string

                                                                                                                                                                                                                func (*MissingVersionException) ErrorFault

                                                                                                                                                                                                                func (e *MissingVersionException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                func (*MissingVersionException) ErrorMessage

                                                                                                                                                                                                                func (e *MissingVersionException) ErrorMessage() string

                                                                                                                                                                                                                type MountPoint

                                                                                                                                                                                                                type MountPoint struct {
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// The path on the container to mount the host volume at.
                                                                                                                                                                                                                	ContainerPath *string
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// If this value is true, the container has read-only access to the volume. If this
                                                                                                                                                                                                                	// value is false, then the container can write to the volume. The default value is
                                                                                                                                                                                                                	// false.
                                                                                                                                                                                                                	ReadOnly *bool
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// The name of the volume to mount. Must be a volume name referenced in the name
                                                                                                                                                                                                                	// parameter of task definition volume.
                                                                                                                                                                                                                	SourceVolume *string
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  Details on a volume mount point that is used in a container definition.

                                                                                                                                                                                                                  type NetworkBinding

                                                                                                                                                                                                                  type NetworkBinding struct {
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The IP address that the container is bound to on the container instance.
                                                                                                                                                                                                                  	BindIP *string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The port number on the container that is used with the network binding.
                                                                                                                                                                                                                  	ContainerPort *int32
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The port number on the host that is used with the network binding.
                                                                                                                                                                                                                  	HostPort *int32
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The protocol used for the network binding.
                                                                                                                                                                                                                  	Protocol TransportProtocol
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    Details on the network bindings between a container and its host container instance. After a task reaches the RUNNING status, manual and automatic host and container port assignments are visible in the networkBindings section of DescribeTasks API responses.

                                                                                                                                                                                                                    type NetworkConfiguration

                                                                                                                                                                                                                    type NetworkConfiguration struct {
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The VPC subnets and security groups associated with a task. All specified
                                                                                                                                                                                                                    	// subnets and security groups must be from the same VPC.
                                                                                                                                                                                                                    	AwsvpcConfiguration *AwsVpcConfiguration
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      An object representing the network configuration for a task or service.

                                                                                                                                                                                                                      type NetworkInterface

                                                                                                                                                                                                                      type NetworkInterface struct {
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The attachment ID for the network interface.
                                                                                                                                                                                                                      	AttachmentId *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The private IPv6 address for the network interface.
                                                                                                                                                                                                                      	Ipv6Address *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The private IPv4 address for the network interface.
                                                                                                                                                                                                                      	PrivateIpv4Address *string
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        An object representing the elastic network interface for tasks that use the awsvpc network mode.

                                                                                                                                                                                                                        type NetworkMode

                                                                                                                                                                                                                        type NetworkMode string
                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                        	NetworkModeBridge NetworkMode = "bridge"
                                                                                                                                                                                                                        	NetworkModeHost   NetworkMode = "host"
                                                                                                                                                                                                                        	NetworkModeAwsvpc NetworkMode = "awsvpc"
                                                                                                                                                                                                                        	NetworkModeNone   NetworkMode = "none"
                                                                                                                                                                                                                        )

                                                                                                                                                                                                                          Enum values for NetworkMode

                                                                                                                                                                                                                          func (NetworkMode) Values

                                                                                                                                                                                                                          func (NetworkMode) Values() []NetworkMode

                                                                                                                                                                                                                            Values returns all known values for NetworkMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                            type NoUpdateAvailableException

                                                                                                                                                                                                                            type NoUpdateAvailableException struct {
                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              There is no update available for this Amazon ECS container agent. This could be because the agent is already running the latest version, or it is so old that there is no update path to the current version.

                                                                                                                                                                                                                              func (*NoUpdateAvailableException) Error

                                                                                                                                                                                                                              func (*NoUpdateAvailableException) ErrorCode

                                                                                                                                                                                                                              func (e *NoUpdateAvailableException) ErrorCode() string

                                                                                                                                                                                                                              func (*NoUpdateAvailableException) ErrorFault

                                                                                                                                                                                                                              func (*NoUpdateAvailableException) ErrorMessage

                                                                                                                                                                                                                              func (e *NoUpdateAvailableException) ErrorMessage() string

                                                                                                                                                                                                                              type PidMode

                                                                                                                                                                                                                              type PidMode string
                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                              	PidModeHost PidMode = "host"
                                                                                                                                                                                                                              	PidModeTask PidMode = "task"
                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                Enum values for PidMode

                                                                                                                                                                                                                                func (PidMode) Values

                                                                                                                                                                                                                                func (PidMode) Values() []PidMode

                                                                                                                                                                                                                                  Values returns all known values for PidMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                  type PlacementConstraint

                                                                                                                                                                                                                                  type PlacementConstraint struct {
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// A cluster query language expression to apply to the constraint. You cannot
                                                                                                                                                                                                                                  	// specify an expression if the constraint type is distinctInstance. For more
                                                                                                                                                                                                                                  	// information, see Cluster Query Language
                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html)
                                                                                                                                                                                                                                  	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                  	Expression *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The type of constraint. Use distinctInstance to ensure that each task in a
                                                                                                                                                                                                                                  	// particular group is running on a different container instance. Use memberOf to
                                                                                                                                                                                                                                  	// restrict the selection to a group of valid candidates.
                                                                                                                                                                                                                                  	Type PlacementConstraintType
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    An object representing a constraint on task placement. For more information, see Task Placement Constraints (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html) in the Amazon Elastic Container Service Developer Guide. If you are using the Fargate launch type, task placement constraints are not supported.

                                                                                                                                                                                                                                    type PlacementConstraintType

                                                                                                                                                                                                                                    type PlacementConstraintType string
                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                    	PlacementConstraintTypeDistinctInstance PlacementConstraintType = "distinctInstance"
                                                                                                                                                                                                                                    	PlacementConstraintTypeMemberOf         PlacementConstraintType = "memberOf"
                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                      Enum values for PlacementConstraintType

                                                                                                                                                                                                                                      func (PlacementConstraintType) Values

                                                                                                                                                                                                                                        Values returns all known values for PlacementConstraintType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                        type PlacementStrategy

                                                                                                                                                                                                                                        type PlacementStrategy struct {
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The field to apply the placement strategy against. For the spread placement
                                                                                                                                                                                                                                        	// strategy, valid values are instanceId (or host, which has the same effect), or
                                                                                                                                                                                                                                        	// any platform or custom attribute that is applied to a container instance, such
                                                                                                                                                                                                                                        	// as attribute:ecs.availability-zone. For the binpack placement strategy, valid
                                                                                                                                                                                                                                        	// values are cpu and memory. For the random placement strategy, this field is not
                                                                                                                                                                                                                                        	// used.
                                                                                                                                                                                                                                        	Field *string
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The type of placement strategy. The random placement strategy randomly places
                                                                                                                                                                                                                                        	// tasks on available candidates. The spread placement strategy spreads placement
                                                                                                                                                                                                                                        	// across available candidates evenly based on the field parameter. The binpack
                                                                                                                                                                                                                                        	// strategy places tasks on available candidates that have the least available
                                                                                                                                                                                                                                        	// amount of the resource that is specified with the field parameter. For example,
                                                                                                                                                                                                                                        	// if you binpack on memory, a task is placed on the instance with the least amount
                                                                                                                                                                                                                                        	// of remaining memory (but still enough to run the task).
                                                                                                                                                                                                                                        	Type PlacementStrategyType
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          The task placement strategy for a task or service. For more information, see Task Placement Strategies (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-strategies.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                                                                                                                                                          type PlacementStrategyType

                                                                                                                                                                                                                                          type PlacementStrategyType string
                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                          	PlacementStrategyTypeRandom  PlacementStrategyType = "random"
                                                                                                                                                                                                                                          	PlacementStrategyTypeSpread  PlacementStrategyType = "spread"
                                                                                                                                                                                                                                          	PlacementStrategyTypeBinpack PlacementStrategyType = "binpack"
                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                            Enum values for PlacementStrategyType

                                                                                                                                                                                                                                            func (PlacementStrategyType) Values

                                                                                                                                                                                                                                              Values returns all known values for PlacementStrategyType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                              type PlatformDevice

                                                                                                                                                                                                                                              type PlatformDevice struct {
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The ID for the GPU(s) on the container instance. The available GPU IDs can also
                                                                                                                                                                                                                                              	// be obtained on the container instance in the
                                                                                                                                                                                                                                              	// /var/lib/ecs/gpu/nvidia_gpu_info.json file.
                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                              	Id *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The type of device that is available on the container instance. The only
                                                                                                                                                                                                                                              	// supported value is GPU.
                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                              	Type PlatformDeviceType
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                The devices that are available on the container instance. The only supported device type is a GPU.

                                                                                                                                                                                                                                                type PlatformDeviceType

                                                                                                                                                                                                                                                type PlatformDeviceType string
                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                	PlatformDeviceTypeGpu PlatformDeviceType = "GPU"
                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                  Enum values for PlatformDeviceType

                                                                                                                                                                                                                                                  func (PlatformDeviceType) Values

                                                                                                                                                                                                                                                    Values returns all known values for PlatformDeviceType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                    type PlatformTaskDefinitionIncompatibilityException

                                                                                                                                                                                                                                                    type PlatformTaskDefinitionIncompatibilityException struct {
                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      The specified platform version does not satisfy the task definition's required capabilities.

                                                                                                                                                                                                                                                      func (*PlatformTaskDefinitionIncompatibilityException) Error

                                                                                                                                                                                                                                                      func (*PlatformTaskDefinitionIncompatibilityException) ErrorCode

                                                                                                                                                                                                                                                      func (*PlatformTaskDefinitionIncompatibilityException) ErrorFault

                                                                                                                                                                                                                                                      func (*PlatformTaskDefinitionIncompatibilityException) ErrorMessage

                                                                                                                                                                                                                                                      type PlatformUnknownException

                                                                                                                                                                                                                                                      type PlatformUnknownException struct {
                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        The specified platform version does not exist.

                                                                                                                                                                                                                                                        func (*PlatformUnknownException) Error

                                                                                                                                                                                                                                                        func (e *PlatformUnknownException) Error() string

                                                                                                                                                                                                                                                        func (*PlatformUnknownException) ErrorCode

                                                                                                                                                                                                                                                        func (e *PlatformUnknownException) ErrorCode() string

                                                                                                                                                                                                                                                        func (*PlatformUnknownException) ErrorFault

                                                                                                                                                                                                                                                        func (e *PlatformUnknownException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                        func (*PlatformUnknownException) ErrorMessage

                                                                                                                                                                                                                                                        func (e *PlatformUnknownException) ErrorMessage() string

                                                                                                                                                                                                                                                        type PortMapping

                                                                                                                                                                                                                                                        type PortMapping struct {
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The port number on the container that is bound to the user-specified or
                                                                                                                                                                                                                                                        	// automatically assigned host port. If you are using containers in a task with the
                                                                                                                                                                                                                                                        	// awsvpc or host network mode, exposed ports should be specified using
                                                                                                                                                                                                                                                        	// containerPort. If you are using containers in a task with the bridge network
                                                                                                                                                                                                                                                        	// mode and you specify a container port and not a host port, your container
                                                                                                                                                                                                                                                        	// automatically receives a host port in the ephemeral port range. For more
                                                                                                                                                                                                                                                        	// information, see hostPort. Port mappings that are automatically assigned in this
                                                                                                                                                                                                                                                        	// way do not count toward the 100 reserved ports limit of a container instance.
                                                                                                                                                                                                                                                        	ContainerPort *int32
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The port number on the container instance to reserve for your container. If you
                                                                                                                                                                                                                                                        	// are using containers in a task with the awsvpc or host network mode, the
                                                                                                                                                                                                                                                        	// hostPort can either be left blank or set to the same value as the containerPort.
                                                                                                                                                                                                                                                        	// If you are using containers in a task with the bridge network mode, you can
                                                                                                                                                                                                                                                        	// specify a non-reserved host port for your container port mapping, or you can
                                                                                                                                                                                                                                                        	// omit the hostPort (or set it to 0) while specifying a containerPort and your
                                                                                                                                                                                                                                                        	// container automatically receives a port in the ephemeral port range for your
                                                                                                                                                                                                                                                        	// container instance operating system and Docker version. The default ephemeral
                                                                                                                                                                                                                                                        	// port range for Docker version 1.6.0 and later is listed on the instance under
                                                                                                                                                                                                                                                        	// /proc/sys/net/ipv4/ip_local_port_range. If this kernel parameter is unavailable,
                                                                                                                                                                                                                                                        	// the default ephemeral port range from 49153 through 65535 is used. Do not
                                                                                                                                                                                                                                                        	// attempt to specify a host port in the ephemeral port range as these are reserved
                                                                                                                                                                                                                                                        	// for automatic assignment. In general, ports below 32768 are outside of the
                                                                                                                                                                                                                                                        	// ephemeral port range. The default ephemeral port range from 49153 through 65535
                                                                                                                                                                                                                                                        	// is always used for Docker versions before 1.6.0. The default reserved ports are
                                                                                                                                                                                                                                                        	// 22 for SSH, the Docker ports 2375 and 2376, and the Amazon ECS container agent
                                                                                                                                                                                                                                                        	// ports 51678-51680. Any host port that was previously specified in a running task
                                                                                                                                                                                                                                                        	// is also reserved while the task is running (after a task stops, the host port is
                                                                                                                                                                                                                                                        	// released). The current reserved ports are displayed in the remainingResources of
                                                                                                                                                                                                                                                        	// DescribeContainerInstances output. A container instance can have up to 100
                                                                                                                                                                                                                                                        	// reserved ports at a time, including the default reserved ports. Automatically
                                                                                                                                                                                                                                                        	// assigned ports don't count toward the 100 reserved ports limit.
                                                                                                                                                                                                                                                        	HostPort *int32
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The protocol used for the port mapping. Valid values are tcp and udp. The
                                                                                                                                                                                                                                                        	// default is tcp.
                                                                                                                                                                                                                                                        	Protocol TransportProtocol
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          Port mappings allow containers to access ports on the host container instance to send or receive traffic. Port mappings are specified as part of the container definition. If you are using containers in a task with the awsvpc or host network mode, exposed ports should be specified using containerPort. The hostPort can be left blank or it must be the same value as the containerPort. After a task reaches the RUNNING status, manual and automatic host and container port assignments are visible in the networkBindings section of DescribeTasks API responses.

                                                                                                                                                                                                                                                          type PropagateTags

                                                                                                                                                                                                                                                          type PropagateTags string
                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                          	PropagateTagsTaskDefinition PropagateTags = "TASK_DEFINITION"
                                                                                                                                                                                                                                                          	PropagateTagsService        PropagateTags = "SERVICE"
                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                            Enum values for PropagateTags

                                                                                                                                                                                                                                                            func (PropagateTags) Values

                                                                                                                                                                                                                                                            func (PropagateTags) Values() []PropagateTags

                                                                                                                                                                                                                                                              Values returns all known values for PropagateTags. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                              type ProxyConfiguration

                                                                                                                                                                                                                                                              type ProxyConfiguration struct {
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The name of the container that will serve as the App Mesh proxy.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                              	ContainerName *string
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The set of network configuration parameters to provide the Container Network
                                                                                                                                                                                                                                                              	// Interface (CNI) plugin, specified as key-value pairs.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// * IgnoredUID - (Required)
                                                                                                                                                                                                                                                              	// The user ID (UID) of the proxy container as defined by the user parameter in a
                                                                                                                                                                                                                                                              	// container definition. This is used to ensure the proxy ignores its own traffic.
                                                                                                                                                                                                                                                              	// If IgnoredGID is specified, this field can be empty.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// * IgnoredGID - (Required)
                                                                                                                                                                                                                                                              	// The group ID (GID) of the proxy container as defined by the user parameter in a
                                                                                                                                                                                                                                                              	// container definition. This is used to ensure the proxy ignores its own traffic.
                                                                                                                                                                                                                                                              	// If IgnoredUID is specified, this field can be empty.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// * AppPorts - (Required)
                                                                                                                                                                                                                                                              	// The list of ports that the application uses. Network traffic to these ports is
                                                                                                                                                                                                                                                              	// forwarded to the ProxyIngressPort and ProxyEgressPort.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// * ProxyIngressPort -
                                                                                                                                                                                                                                                              	// (Required) Specifies the port that incoming traffic to the AppPorts is directed
                                                                                                                                                                                                                                                              	// to.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// * ProxyEgressPort - (Required) Specifies the port that outgoing traffic
                                                                                                                                                                                                                                                              	// from the AppPorts is directed to.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// * EgressIgnoredPorts - (Required) The egress
                                                                                                                                                                                                                                                              	// traffic going to the specified ports is ignored and not redirected to the
                                                                                                                                                                                                                                                              	// ProxyEgressPort. It can be an empty list.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// * EgressIgnoredIPs - (Required) The
                                                                                                                                                                                                                                                              	// egress traffic going to the specified IP addresses is ignored and not redirected
                                                                                                                                                                                                                                                              	// to the ProxyEgressPort. It can be an empty list.
                                                                                                                                                                                                                                                              	Properties []KeyValuePair
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The proxy type. The only supported value is APPMESH.
                                                                                                                                                                                                                                                              	Type ProxyConfigurationType
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                The configuration details for the App Mesh proxy. For tasks using the EC2 launch type, the container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the ecs-init package to enable a proxy configuration. If your container instances are launched from the Amazon ECS-optimized AMI version 20190301 or later, then they contain the required versions of the container agent and ecs-init. For more information, see Amazon ECS-optimized Linux AMI (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)

                                                                                                                                                                                                                                                                type ProxyConfigurationType

                                                                                                                                                                                                                                                                type ProxyConfigurationType string
                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                	ProxyConfigurationTypeAppmesh ProxyConfigurationType = "APPMESH"
                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                  Enum values for ProxyConfigurationType

                                                                                                                                                                                                                                                                  func (ProxyConfigurationType) Values

                                                                                                                                                                                                                                                                    Values returns all known values for ProxyConfigurationType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                    type RepositoryCredentials

                                                                                                                                                                                                                                                                    type RepositoryCredentials struct {
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the secret containing the private repository
                                                                                                                                                                                                                                                                    	// credentials. When you are using the Amazon ECS API, AWS CLI, or AWS SDK, if the
                                                                                                                                                                                                                                                                    	// secret exists in the same Region as the task that you are launching then you can
                                                                                                                                                                                                                                                                    	// use either the full ARN or the name of the secret. When you are using the AWS
                                                                                                                                                                                                                                                                    	// Management Console, you must specify the full ARN of the secret.
                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                    	CredentialsParameter *string
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      The repository credentials for private registry authentication.

                                                                                                                                                                                                                                                                      type Resource

                                                                                                                                                                                                                                                                      type Resource struct {
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// When the doubleValue type is set, the value of the resource must be a double
                                                                                                                                                                                                                                                                      	// precision floating-point type.
                                                                                                                                                                                                                                                                      	DoubleValue float64
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// When the integerValue type is set, the value of the resource must be an integer.
                                                                                                                                                                                                                                                                      	IntegerValue int32
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// When the longValue type is set, the value of the resource must be an extended
                                                                                                                                                                                                                                                                      	// precision floating-point type.
                                                                                                                                                                                                                                                                      	LongValue int64
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// The name of the resource, such as CPU, MEMORY, PORTS, PORTS_UDP, or a
                                                                                                                                                                                                                                                                      	// user-defined resource.
                                                                                                                                                                                                                                                                      	Name *string
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// When the stringSetValue type is set, the value of the resource must be a string
                                                                                                                                                                                                                                                                      	// type.
                                                                                                                                                                                                                                                                      	StringSetValue []string
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// The type of the resource, such as INTEGER, DOUBLE, LONG, or STRINGSET.
                                                                                                                                                                                                                                                                      	Type *string
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        Describes the resources available for a container instance.

                                                                                                                                                                                                                                                                        type ResourceInUseException

                                                                                                                                                                                                                                                                        type ResourceInUseException struct {
                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                          The specified resource is in-use and cannot be removed.

                                                                                                                                                                                                                                                                          func (*ResourceInUseException) Error

                                                                                                                                                                                                                                                                          func (e *ResourceInUseException) Error() string

                                                                                                                                                                                                                                                                          func (*ResourceInUseException) ErrorCode

                                                                                                                                                                                                                                                                          func (e *ResourceInUseException) ErrorCode() string

                                                                                                                                                                                                                                                                          func (*ResourceInUseException) ErrorFault

                                                                                                                                                                                                                                                                          func (e *ResourceInUseException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                          func (*ResourceInUseException) ErrorMessage

                                                                                                                                                                                                                                                                          func (e *ResourceInUseException) ErrorMessage() string

                                                                                                                                                                                                                                                                          type ResourceNotFoundException

                                                                                                                                                                                                                                                                          type ResourceNotFoundException struct {
                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            The specified resource could not be found.

                                                                                                                                                                                                                                                                            func (*ResourceNotFoundException) Error

                                                                                                                                                                                                                                                                            func (e *ResourceNotFoundException) Error() string

                                                                                                                                                                                                                                                                            func (*ResourceNotFoundException) ErrorCode

                                                                                                                                                                                                                                                                            func (e *ResourceNotFoundException) ErrorCode() string

                                                                                                                                                                                                                                                                            func (*ResourceNotFoundException) ErrorFault

                                                                                                                                                                                                                                                                            func (*ResourceNotFoundException) ErrorMessage

                                                                                                                                                                                                                                                                            func (e *ResourceNotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                                                            type ResourceRequirement

                                                                                                                                                                                                                                                                            type ResourceRequirement struct {
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// The type of resource to assign to a container. The supported values are GPU or
                                                                                                                                                                                                                                                                            	// InferenceAccelerator.
                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                            	Type ResourceType
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// The value for the specified resource type. If the GPU type is used, the value is
                                                                                                                                                                                                                                                                            	// the number of physical GPUs the Amazon ECS container agent will reserve for the
                                                                                                                                                                                                                                                                            	// container. The number of GPUs reserved for all containers in a task should not
                                                                                                                                                                                                                                                                            	// exceed the number of available GPUs on the container instance the task is
                                                                                                                                                                                                                                                                            	// launched on. If the InferenceAccelerator type is used, the value should match
                                                                                                                                                                                                                                                                            	// the deviceName for an InferenceAccelerator specified in a task definition.
                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                            	Value *string
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              The type and amount of a resource to assign to a container. The supported resource types are GPUs and Elastic Inference accelerators. For more information, see Working with GPUs on Amazon ECS (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-gpu.html) or Working with Amazon Elastic Inference on Amazon ECS (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-eia.html) in the Amazon Elastic Container Service Developer Guide

                                                                                                                                                                                                                                                                              type ResourceType

                                                                                                                                                                                                                                                                              type ResourceType string
                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                              	ResourceTypeGpu                  ResourceType = "GPU"
                                                                                                                                                                                                                                                                              	ResourceTypeInferenceAccelerator ResourceType = "InferenceAccelerator"
                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                Enum values for ResourceType

                                                                                                                                                                                                                                                                                func (ResourceType) Values

                                                                                                                                                                                                                                                                                func (ResourceType) Values() []ResourceType

                                                                                                                                                                                                                                                                                  Values returns all known values for ResourceType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                  type Scale

                                                                                                                                                                                                                                                                                  type Scale struct {
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The unit of measure for the scale value.
                                                                                                                                                                                                                                                                                  	Unit ScaleUnit
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The value, specified as a percent total of a service's desiredCount, to scale
                                                                                                                                                                                                                                                                                  	// the task set. Accepted values are numbers between 0 and 100.
                                                                                                                                                                                                                                                                                  	Value float64
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    A floating-point percentage of the desired number of tasks to place and keep running in the task set.

                                                                                                                                                                                                                                                                                    type ScaleUnit

                                                                                                                                                                                                                                                                                    type ScaleUnit string
                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                    	ScaleUnitPercent ScaleUnit = "PERCENT"
                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                      Enum values for ScaleUnit

                                                                                                                                                                                                                                                                                      func (ScaleUnit) Values

                                                                                                                                                                                                                                                                                      func (ScaleUnit) Values() []ScaleUnit

                                                                                                                                                                                                                                                                                        Values returns all known values for ScaleUnit. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                        type SchedulingStrategy

                                                                                                                                                                                                                                                                                        type SchedulingStrategy string
                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                        	SchedulingStrategyReplica SchedulingStrategy = "REPLICA"
                                                                                                                                                                                                                                                                                        	SchedulingStrategyDaemon  SchedulingStrategy = "DAEMON"
                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                          Enum values for SchedulingStrategy

                                                                                                                                                                                                                                                                                          func (SchedulingStrategy) Values

                                                                                                                                                                                                                                                                                            Values returns all known values for SchedulingStrategy. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                            type Scope

                                                                                                                                                                                                                                                                                            type Scope string
                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                            	ScopeTask   Scope = "task"
                                                                                                                                                                                                                                                                                            	ScopeShared Scope = "shared"
                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                              Enum values for Scope

                                                                                                                                                                                                                                                                                              func (Scope) Values

                                                                                                                                                                                                                                                                                              func (Scope) Values() []Scope

                                                                                                                                                                                                                                                                                                Values returns all known values for Scope. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                type Secret

                                                                                                                                                                                                                                                                                                type Secret struct {
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// The name of the secret.
                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// The secret to expose to the container. The supported values are either the full
                                                                                                                                                                                                                                                                                                	// ARN of the AWS Secrets Manager secret or the full ARN of the parameter in the
                                                                                                                                                                                                                                                                                                	// AWS Systems Manager Parameter Store. If the AWS Systems Manager Parameter Store
                                                                                                                                                                                                                                                                                                	// parameter exists in the same Region as the task you are launching, then you can
                                                                                                                                                                                                                                                                                                	// use either the full ARN or name of the parameter. If the parameter exists in a
                                                                                                                                                                                                                                                                                                	// different Region, then the full ARN must be specified.
                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                	ValueFrom *string
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  An object representing the secret to expose to your container. Secrets can be exposed to a container in the following ways:

                                                                                                                                                                                                                                                                                                  * To inject sensitive data into your containers as environment variables, use the secrets container definition parameter.

                                                                                                                                                                                                                                                                                                  * To reference sensitive information in the log configuration of a container, use the secretOptions container definition parameter.

                                                                                                                                                                                                                                                                                                  For more information, see Specifying Sensitive Data (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the Amazon Elastic Container Service Developer Guide.

                                                                                                                                                                                                                                                                                                  type ServerException

                                                                                                                                                                                                                                                                                                  type ServerException struct {
                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    These errors are usually caused by a server issue.

                                                                                                                                                                                                                                                                                                    func (*ServerException) Error

                                                                                                                                                                                                                                                                                                    func (e *ServerException) Error() string

                                                                                                                                                                                                                                                                                                    func (*ServerException) ErrorCode

                                                                                                                                                                                                                                                                                                    func (e *ServerException) ErrorCode() string

                                                                                                                                                                                                                                                                                                    func (*ServerException) ErrorFault

                                                                                                                                                                                                                                                                                                    func (e *ServerException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                    func (*ServerException) ErrorMessage

                                                                                                                                                                                                                                                                                                    func (e *ServerException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                    type Service

                                                                                                                                                                                                                                                                                                    type Service struct {
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The capacity provider strategy associated with the service.
                                                                                                                                                                                                                                                                                                    	CapacityProviderStrategy []CapacityProviderStrategyItem
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the cluster that hosts the service.
                                                                                                                                                                                                                                                                                                    	ClusterArn *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The Unix timestamp for when the service was created.
                                                                                                                                                                                                                                                                                                    	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The principal that created the service.
                                                                                                                                                                                                                                                                                                    	CreatedBy *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// Optional deployment parameters that control how many tasks run during the
                                                                                                                                                                                                                                                                                                    	// deployment and the ordering of stopping and starting tasks.
                                                                                                                                                                                                                                                                                                    	DeploymentConfiguration *DeploymentConfiguration
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The deployment controller type the service is using. When using the
                                                                                                                                                                                                                                                                                                    	// DescribeServices API, this field is omitted if the service is using the ECS
                                                                                                                                                                                                                                                                                                    	// deployment controller type.
                                                                                                                                                                                                                                                                                                    	DeploymentController *DeploymentController
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The current state of deployments for the service.
                                                                                                                                                                                                                                                                                                    	Deployments []Deployment
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The desired number of instantiations of the task definition to keep running on
                                                                                                                                                                                                                                                                                                    	// the service. This value is specified when the service is created with
                                                                                                                                                                                                                                                                                                    	// CreateService, and it can be modified with UpdateService.
                                                                                                                                                                                                                                                                                                    	DesiredCount int32
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// Specifies whether to enable Amazon ECS managed tags for the tasks in the
                                                                                                                                                                                                                                                                                                    	// service. For more information, see Tagging Your Amazon ECS Resources
                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html)
                                                                                                                                                                                                                                                                                                    	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                    	EnableECSManagedTags bool
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The event stream for your service. A maximum of 100 of the latest events are
                                                                                                                                                                                                                                                                                                    	// displayed.
                                                                                                                                                                                                                                                                                                    	Events []ServiceEvent
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The period of time, in seconds, that the Amazon ECS service scheduler ignores
                                                                                                                                                                                                                                                                                                    	// unhealthy Elastic Load Balancing target health checks after a task has first
                                                                                                                                                                                                                                                                                                    	// started.
                                                                                                                                                                                                                                                                                                    	HealthCheckGracePeriodSeconds *int32
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The launch type on which your service is running. If no value is specified, it
                                                                                                                                                                                                                                                                                                    	// will default to EC2. Valid values include EC2 and FARGATE. For more information,
                                                                                                                                                                                                                                                                                                    	// see Amazon ECS Launch Types
                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
                                                                                                                                                                                                                                                                                                    	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                    	LaunchType LaunchType
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// A list of Elastic Load Balancing load balancer objects, containing the load
                                                                                                                                                                                                                                                                                                    	// balancer name, the container name (as it appears in a container definition), and
                                                                                                                                                                                                                                                                                                    	// the container port to access from the load balancer.
                                                                                                                                                                                                                                                                                                    	LoadBalancers []LoadBalancer
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The VPC subnet and security group configuration for tasks that receive their own
                                                                                                                                                                                                                                                                                                    	// elastic network interface by using the awsvpc networking mode.
                                                                                                                                                                                                                                                                                                    	NetworkConfiguration *NetworkConfiguration
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The number of tasks in the cluster that are in the PENDING state.
                                                                                                                                                                                                                                                                                                    	PendingCount int32
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The placement constraints for the tasks in the service.
                                                                                                                                                                                                                                                                                                    	PlacementConstraints []PlacementConstraint
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The placement strategy that determines how tasks for the service are placed.
                                                                                                                                                                                                                                                                                                    	PlacementStrategy []PlacementStrategy
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The platform version on which to run your service. A platform version is only
                                                                                                                                                                                                                                                                                                    	// specified for tasks using the Fargate launch type. If one is not specified, the
                                                                                                                                                                                                                                                                                                    	// LATEST platform version is used by default. For more information, see AWS
                                                                                                                                                                                                                                                                                                    	// Fargate Platform Versions
                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
                                                                                                                                                                                                                                                                                                    	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                    	PlatformVersion *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// Specifies whether to propagate the tags from the task definition or the service
                                                                                                                                                                                                                                                                                                    	// to the task. If no value is specified, the tags are not propagated.
                                                                                                                                                                                                                                                                                                    	PropagateTags PropagateTags
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The ARN of the IAM role associated with the service that allows the Amazon ECS
                                                                                                                                                                                                                                                                                                    	// container agent to register container instances with an Elastic Load Balancing
                                                                                                                                                                                                                                                                                                    	// load balancer.
                                                                                                                                                                                                                                                                                                    	RoleArn *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The number of tasks in the cluster that are in the RUNNING state.
                                                                                                                                                                                                                                                                                                    	RunningCount int32
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The scheduling strategy to use for the service. For more information, see
                                                                                                                                                                                                                                                                                                    	// Services
                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html).
                                                                                                                                                                                                                                                                                                    	// There are two service scheduler strategies available:
                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                    	// * REPLICA-The replica
                                                                                                                                                                                                                                                                                                    	// scheduling strategy places and maintains the desired number of tasks across your
                                                                                                                                                                                                                                                                                                    	// cluster. By default, the service scheduler spreads tasks across Availability
                                                                                                                                                                                                                                                                                                    	// Zones. You can use task placement strategies and constraints to customize task
                                                                                                                                                                                                                                                                                                    	// placement decisions.
                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                    	// * DAEMON-The daemon scheduling strategy deploys exactly
                                                                                                                                                                                                                                                                                                    	// one task on each active container instance that meets all of the task placement
                                                                                                                                                                                                                                                                                                    	// constraints that you specify in your cluster. The service scheduler also
                                                                                                                                                                                                                                                                                                    	// evaluates the task placement constraints for running tasks and will stop tasks
                                                                                                                                                                                                                                                                                                    	// that do not meet the placement constraints. Fargate tasks do not support the
                                                                                                                                                                                                                                                                                                    	// DAEMON scheduling strategy.
                                                                                                                                                                                                                                                                                                    	SchedulingStrategy SchedulingStrategy
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The ARN that identifies the service. The ARN contains the arn:aws:ecs namespace,
                                                                                                                                                                                                                                                                                                    	// followed by the Region of the service, the AWS account ID of the service owner,
                                                                                                                                                                                                                                                                                                    	// the service namespace, and then the service name. For example,
                                                                                                                                                                                                                                                                                                    	// arn:aws:ecs:region:012345678910:service/my-service.
                                                                                                                                                                                                                                                                                                    	ServiceArn *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The name of your service. Up to 255 letters (uppercase and lowercase), numbers,
                                                                                                                                                                                                                                                                                                    	// and hyphens are allowed. Service names must be unique within a cluster, but you
                                                                                                                                                                                                                                                                                                    	// can have similarly named services in multiple clusters within a Region or across
                                                                                                                                                                                                                                                                                                    	// multiple Regions.
                                                                                                                                                                                                                                                                                                    	ServiceName *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The details of the service discovery registries to assign to this service. For
                                                                                                                                                                                                                                                                                                    	// more information, see Service Discovery
                                                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html).
                                                                                                                                                                                                                                                                                                    	ServiceRegistries []ServiceRegistry
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The status of the service. The valid values are ACTIVE, DRAINING, or INACTIVE.
                                                                                                                                                                                                                                                                                                    	Status *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The metadata that you apply to the service to help you categorize and organize
                                                                                                                                                                                                                                                                                                    	// them. Each tag consists of a key and an optional value, both of which you
                                                                                                                                                                                                                                                                                                    	// define. The following basic restrictions apply to tags:
                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                    	// * Maximum number of
                                                                                                                                                                                                                                                                                                    	// tags per resource - 50
                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                    	// * For each resource, each tag key must be unique, and
                                                                                                                                                                                                                                                                                                    	// each tag key can have only one value.
                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                    	// * Maximum key length - 128 Unicode
                                                                                                                                                                                                                                                                                                    	// characters in UTF-8
                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                    	// * Maximum value length - 256 Unicode characters in UTF-8
                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                    	// *
                                                                                                                                                                                                                                                                                                    	// If your tagging schema is used across multiple services and resources, remember
                                                                                                                                                                                                                                                                                                    	// that other services may have restrictions on allowed characters. Generally
                                                                                                                                                                                                                                                                                                    	// allowed characters are: letters, numbers, and spaces representable in UTF-8, and
                                                                                                                                                                                                                                                                                                    	// the following characters: + - = . _ : / @.
                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                    	// * Tag keys and values are
                                                                                                                                                                                                                                                                                                    	// case-sensitive.
                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                    	// * Do not use aws:, AWS:, or any upper or lowercase combination
                                                                                                                                                                                                                                                                                                    	// of such as a prefix for either keys or values as it is reserved for AWS use. You
                                                                                                                                                                                                                                                                                                    	// cannot edit or delete tag keys or values with this prefix. Tags with this prefix
                                                                                                                                                                                                                                                                                                    	// do not count against your tags per resource limit.
                                                                                                                                                                                                                                                                                                    	Tags []Tag
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The task definition to use for tasks in the service. This value is specified
                                                                                                                                                                                                                                                                                                    	// when the service is created with CreateService, and it can be modified with
                                                                                                                                                                                                                                                                                                    	// UpdateService.
                                                                                                                                                                                                                                                                                                    	TaskDefinition *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// Information about a set of Amazon ECS tasks in either an AWS CodeDeploy or an
                                                                                                                                                                                                                                                                                                    	// EXTERNAL deployment. An Amazon ECS task set includes details such as the desired
                                                                                                                                                                                                                                                                                                    	// number of tasks, how many tasks are running, and whether the task set serves
                                                                                                                                                                                                                                                                                                    	// production traffic.
                                                                                                                                                                                                                                                                                                    	TaskSets []TaskSet
                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                      Details on a service within a cluster

                                                                                                                                                                                                                                                                                                      type ServiceEvent

                                                                                                                                                                                                                                                                                                      type ServiceEvent struct {
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// The Unix timestamp for when the event was triggered.
                                                                                                                                                                                                                                                                                                      	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// The ID string of the event.
                                                                                                                                                                                                                                                                                                      	Id *string
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// The event message.
                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        Details on an event associated with a service.

                                                                                                                                                                                                                                                                                                        type ServiceField

                                                                                                                                                                                                                                                                                                        type ServiceField string
                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                        	ServiceFieldTags ServiceField = "TAGS"
                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                          Enum values for ServiceField

                                                                                                                                                                                                                                                                                                          func (ServiceField) Values

                                                                                                                                                                                                                                                                                                          func (ServiceField) Values() []ServiceField

                                                                                                                                                                                                                                                                                                            Values returns all known values for ServiceField. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                            type ServiceNotActiveException

                                                                                                                                                                                                                                                                                                            type ServiceNotActiveException struct {
                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                              The specified service is not active. You can't update a service that is inactive. If you have previously deleted a service, you can re-create it with CreateService.

                                                                                                                                                                                                                                                                                                              func (*ServiceNotActiveException) Error

                                                                                                                                                                                                                                                                                                              func (e *ServiceNotActiveException) Error() string

                                                                                                                                                                                                                                                                                                              func (*ServiceNotActiveException) ErrorCode

                                                                                                                                                                                                                                                                                                              func (e *ServiceNotActiveException) ErrorCode() string

                                                                                                                                                                                                                                                                                                              func (*ServiceNotActiveException) ErrorFault

                                                                                                                                                                                                                                                                                                              func (*ServiceNotActiveException) ErrorMessage

                                                                                                                                                                                                                                                                                                              func (e *ServiceNotActiveException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                              type ServiceNotFoundException

                                                                                                                                                                                                                                                                                                              type ServiceNotFoundException struct {
                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                The specified service could not be found. You can view your available services with ListServices. Amazon ECS services are cluster-specific and Region-specific.

                                                                                                                                                                                                                                                                                                                func (*ServiceNotFoundException) Error

                                                                                                                                                                                                                                                                                                                func (e *ServiceNotFoundException) Error() string

                                                                                                                                                                                                                                                                                                                func (*ServiceNotFoundException) ErrorCode

                                                                                                                                                                                                                                                                                                                func (e *ServiceNotFoundException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                func (*ServiceNotFoundException) ErrorFault

                                                                                                                                                                                                                                                                                                                func (e *ServiceNotFoundException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                func (*ServiceNotFoundException) ErrorMessage

                                                                                                                                                                                                                                                                                                                func (e *ServiceNotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                type ServiceRegistry

                                                                                                                                                                                                                                                                                                                type ServiceRegistry struct {
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// The container name value, already specified in the task definition, to be used
                                                                                                                                                                                                                                                                                                                	// for your service discovery service. If the task definition that your service
                                                                                                                                                                                                                                                                                                                	// task specifies uses the bridge or host network mode, you must specify a
                                                                                                                                                                                                                                                                                                                	// containerName and containerPort combination from the task definition. If the
                                                                                                                                                                                                                                                                                                                	// task definition that your service task specifies uses the awsvpc network mode
                                                                                                                                                                                                                                                                                                                	// and a type SRV DNS record is used, you must specify either a containerName and
                                                                                                                                                                                                                                                                                                                	// containerPort combination or a port value, but not both.
                                                                                                                                                                                                                                                                                                                	ContainerName *string
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// The port value, already specified in the task definition, to be used for your
                                                                                                                                                                                                                                                                                                                	// service discovery service. If the task definition your service task specifies
                                                                                                                                                                                                                                                                                                                	// uses the bridge or host network mode, you must specify a containerName and
                                                                                                                                                                                                                                                                                                                	// containerPort combination from the task definition. If the task definition your
                                                                                                                                                                                                                                                                                                                	// service task specifies uses the awsvpc network mode and a type SRV DNS record is
                                                                                                                                                                                                                                                                                                                	// used, you must specify either a containerName and containerPort combination or a
                                                                                                                                                                                                                                                                                                                	// port value, but not both.
                                                                                                                                                                                                                                                                                                                	ContainerPort *int32
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// The port value used if your service discovery service specified an SRV record.
                                                                                                                                                                                                                                                                                                                	// This field may be used if both the awsvpc network mode and SRV records are used.
                                                                                                                                                                                                                                                                                                                	Port *int32
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	// The Amazon Resource Name (ARN) of the service registry. The currently supported
                                                                                                                                                                                                                                                                                                                	// service registry is AWS Cloud Map. For more information, see CreateService
                                                                                                                                                                                                                                                                                                                	// (https://docs.aws.amazon.com/cloud-map/latest/api/API_CreateService.html).
                                                                                                                                                                                                                                                                                                                	RegistryArn *string
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                  Details of the service registry.

                                                                                                                                                                                                                                                                                                                  type Setting

                                                                                                                                                                                                                                                                                                                  type Setting struct {
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The Amazon ECS resource name.
                                                                                                                                                                                                                                                                                                                  	Name SettingName
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The ARN of the principal, which can be an IAM user, IAM role, or the root user.
                                                                                                                                                                                                                                                                                                                  	// If this field is omitted, the authenticated user is assumed.
                                                                                                                                                                                                                                                                                                                  	PrincipalArn *string
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// Whether the account setting is enabled or disabled for the specified resource.
                                                                                                                                                                                                                                                                                                                  	Value *string
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                    The current account setting for a resource.

                                                                                                                                                                                                                                                                                                                    type SettingName

                                                                                                                                                                                                                                                                                                                    type SettingName string
                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                    	SettingNameServiceLongArnFormat           SettingName = "serviceLongArnFormat"
                                                                                                                                                                                                                                                                                                                    	SettingNameTaskLongArnFormat              SettingName = "taskLongArnFormat"
                                                                                                                                                                                                                                                                                                                    	SettingNameContainerInstanceLongArnFormat SettingName = "containerInstanceLongArnFormat"
                                                                                                                                                                                                                                                                                                                    	SettingNameAwsvpcTrunking                 SettingName = "awsvpcTrunking"
                                                                                                                                                                                                                                                                                                                    	SettingNameContainerInsights              SettingName = "containerInsights"
                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                      Enum values for SettingName

                                                                                                                                                                                                                                                                                                                      func (SettingName) Values

                                                                                                                                                                                                                                                                                                                      func (SettingName) Values() []SettingName

                                                                                                                                                                                                                                                                                                                        Values returns all known values for SettingName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                        type SortOrder

                                                                                                                                                                                                                                                                                                                        type SortOrder string
                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                        	SortOrderAsc  SortOrder = "ASC"
                                                                                                                                                                                                                                                                                                                        	SortOrderDesc SortOrder = "DESC"
                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                          Enum values for SortOrder

                                                                                                                                                                                                                                                                                                                          func (SortOrder) Values

                                                                                                                                                                                                                                                                                                                          func (SortOrder) Values() []SortOrder

                                                                                                                                                                                                                                                                                                                            Values returns all known values for SortOrder. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                            type StabilityStatus

                                                                                                                                                                                                                                                                                                                            type StabilityStatus string
                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                            	StabilityStatusSteadyState StabilityStatus = "STEADY_STATE"
                                                                                                                                                                                                                                                                                                                            	StabilityStatusStabilizing StabilityStatus = "STABILIZING"
                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                              Enum values for StabilityStatus

                                                                                                                                                                                                                                                                                                                              func (StabilityStatus) Values

                                                                                                                                                                                                                                                                                                                              func (StabilityStatus) Values() []StabilityStatus

                                                                                                                                                                                                                                                                                                                                Values returns all known values for StabilityStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                type SystemControl

                                                                                                                                                                                                                                                                                                                                type SystemControl struct {
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The namespaced kernel parameter for which to set a value.
                                                                                                                                                                                                                                                                                                                                	Namespace *string
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The value for the namespaced kernel parameter specified in namespace.
                                                                                                                                                                                                                                                                                                                                	Value *string
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  A list of namespaced kernel parameters to set in the container. This parameter maps to Sysctls in the Create a container (https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the Docker Remote API (https://docs.docker.com/engine/api/v1.35/) and the --sysctl option to docker run (https://docs.docker.com/engine/reference/run/#security-configuration). It is not recommended that you specify network-related systemControls parameters for multiple containers in a single task that also uses either the awsvpc or host network mode for the following reasons:

                                                                                                                                                                                                                                                                                                                                  * For tasks that use the awsvpc network mode, if you set systemControls for any container, it applies to all containers in the task. If you set different systemControls for multiple containers in a single task, the container that is started last determines which systemControls take effect.

                                                                                                                                                                                                                                                                                                                                  * For tasks that use the host network mode, the systemControls parameter applies to the container instance's kernel parameter as well as that of all containers of any tasks running on that container instance.

                                                                                                                                                                                                                                                                                                                                  type Tag

                                                                                                                                                                                                                                                                                                                                  type Tag struct {
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// One part of a key-value pair that make up a tag. A key is a general label that
                                                                                                                                                                                                                                                                                                                                  	// acts like a category for more specific tag values.
                                                                                                                                                                                                                                                                                                                                  	Key *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The optional part of a key-value pair that make up a tag. A value acts as a
                                                                                                                                                                                                                                                                                                                                  	// descriptor within a tag category (key).
                                                                                                                                                                                                                                                                                                                                  	Value *string
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    The metadata that you apply to a resource to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. The following basic restrictions apply to tags:

                                                                                                                                                                                                                                                                                                                                    * Maximum number of tags per resource - 50

                                                                                                                                                                                                                                                                                                                                    * For each resource, each tag key must be unique, and each tag key can have only one value.

                                                                                                                                                                                                                                                                                                                                    * Maximum key length - 128 Unicode characters in UTF-8

                                                                                                                                                                                                                                                                                                                                    * Maximum value length - 256 Unicode characters in UTF-8

                                                                                                                                                                                                                                                                                                                                    * If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.

                                                                                                                                                                                                                                                                                                                                    * Tag keys and values are case-sensitive.

                                                                                                                                                                                                                                                                                                                                    * Do not use aws:, AWS:, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

                                                                                                                                                                                                                                                                                                                                    type TargetNotFoundException

                                                                                                                                                                                                                                                                                                                                    type TargetNotFoundException struct {
                                                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      The specified target could not be found. You can view your available container instances with ListContainerInstances. Amazon ECS container instances are cluster-specific and Region-specific.

                                                                                                                                                                                                                                                                                                                                      func (*TargetNotFoundException) Error

                                                                                                                                                                                                                                                                                                                                      func (e *TargetNotFoundException) Error() string

                                                                                                                                                                                                                                                                                                                                      func (*TargetNotFoundException) ErrorCode

                                                                                                                                                                                                                                                                                                                                      func (e *TargetNotFoundException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                      func (*TargetNotFoundException) ErrorFault

                                                                                                                                                                                                                                                                                                                                      func (e *TargetNotFoundException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                      func (*TargetNotFoundException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                      func (e *TargetNotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                      type TargetType

                                                                                                                                                                                                                                                                                                                                      type TargetType string
                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                      	TargetTypeContainerInstance TargetType = "container-instance"
                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                        Enum values for TargetType

                                                                                                                                                                                                                                                                                                                                        func (TargetType) Values

                                                                                                                                                                                                                                                                                                                                        func (TargetType) Values() []TargetType

                                                                                                                                                                                                                                                                                                                                          Values returns all known values for TargetType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                          type Task

                                                                                                                                                                                                                                                                                                                                          type Task struct {
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Elastic Network Adapter associated with the task if the task uses the awsvpc
                                                                                                                                                                                                                                                                                                                                          	// network mode.
                                                                                                                                                                                                                                                                                                                                          	Attachments []Attachment
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The attributes of the task
                                                                                                                                                                                                                                                                                                                                          	Attributes []Attribute
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The availability zone of the task.
                                                                                                                                                                                                                                                                                                                                          	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The capacity provider associated with the task.
                                                                                                                                                                                                                                                                                                                                          	CapacityProviderName *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The ARN of the cluster that hosts the task.
                                                                                                                                                                                                                                                                                                                                          	ClusterArn *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The connectivity status of a task.
                                                                                                                                                                                                                                                                                                                                          	Connectivity Connectivity
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Unix timestamp for when the task last went into CONNECTED status.
                                                                                                                                                                                                                                                                                                                                          	ConnectivityAt *time.Time
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The ARN of the container instances that host the task.
                                                                                                                                                                                                                                                                                                                                          	ContainerInstanceArn *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The containers associated with the task.
                                                                                                                                                                                                                                                                                                                                          	Containers []Container
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The number of CPU units used by the task as expressed in a task definition. It
                                                                                                                                                                                                                                                                                                                                          	// can be expressed as an integer using CPU units, for example 1024. It can also be
                                                                                                                                                                                                                                                                                                                                          	// expressed as a string using vCPUs, for example 1 vCPU or 1 vcpu. String values
                                                                                                                                                                                                                                                                                                                                          	// are converted to an integer indicating the CPU units when the task definition is
                                                                                                                                                                                                                                                                                                                                          	// registered. If you are using the EC2 launch type, this field is optional.
                                                                                                                                                                                                                                                                                                                                          	// Supported values are between 128 CPU units (0.125 vCPUs) and 10240 CPU units (10
                                                                                                                                                                                                                                                                                                                                          	// vCPUs). If you are using the Fargate launch type, this field is required and you
                                                                                                                                                                                                                                                                                                                                          	// must use one of the following values, which determines your range of supported
                                                                                                                                                                                                                                                                                                                                          	// values for the memory parameter:
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * 256 (.25 vCPU) - Available memory values:
                                                                                                                                                                                                                                                                                                                                          	// 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB)
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * 512 (.5 vCPU) - Available memory
                                                                                                                                                                                                                                                                                                                                          	// values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB)
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * 1024 (1 vCPU) -
                                                                                                                                                                                                                                                                                                                                          	// Available memory values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB),
                                                                                                                                                                                                                                                                                                                                          	// 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * 2048 (2 vCPU) - Available memory
                                                                                                                                                                                                                                                                                                                                          	// values: Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// *
                                                                                                                                                                                                                                                                                                                                          	// 4096 (4 vCPU) - Available memory values: Between 8192 (8 GB) and 30720 (30 GB)
                                                                                                                                                                                                                                                                                                                                          	// in increments of 1024 (1 GB)
                                                                                                                                                                                                                                                                                                                                          	Cpu *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Unix timestamp for when the task was created (the task entered the PENDING
                                                                                                                                                                                                                                                                                                                                          	// state).
                                                                                                                                                                                                                                                                                                                                          	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The desired status of the task. For more information, see Task Lifecycle
                                                                                                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html).
                                                                                                                                                                                                                                                                                                                                          	DesiredStatus *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Unix timestamp for when the task execution stopped.
                                                                                                                                                                                                                                                                                                                                          	ExecutionStoppedAt *time.Time
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The name of the task group associated with the task.
                                                                                                                                                                                                                                                                                                                                          	Group *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The health status for the task, which is determined by the health of the
                                                                                                                                                                                                                                                                                                                                          	// essential containers in the task. If all essential containers in the task are
                                                                                                                                                                                                                                                                                                                                          	// reporting as HEALTHY, then the task status also reports as HEALTHY. If any
                                                                                                                                                                                                                                                                                                                                          	// essential containers in the task are reporting as UNHEALTHY or UNKNOWN, then the
                                                                                                                                                                                                                                                                                                                                          	// task status also reports as UNHEALTHY or UNKNOWN, accordingly. The Amazon ECS
                                                                                                                                                                                                                                                                                                                                          	// container agent does not monitor or report on Docker health checks that are
                                                                                                                                                                                                                                                                                                                                          	// embedded in a container image (such as those specified in a parent image or from
                                                                                                                                                                                                                                                                                                                                          	// the image's Dockerfile) and not specified in the container definition. Health
                                                                                                                                                                                                                                                                                                                                          	// check parameters that are specified in a container definition override any
                                                                                                                                                                                                                                                                                                                                          	// Docker health checks that exist in the container image.
                                                                                                                                                                                                                                                                                                                                          	HealthStatus HealthStatus
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Elastic Inference accelerator associated with the task.
                                                                                                                                                                                                                                                                                                                                          	InferenceAccelerators []InferenceAccelerator
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The last known status of the task. For more information, see Task Lifecycle
                                                                                                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html).
                                                                                                                                                                                                                                                                                                                                          	LastStatus *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The launch type on which your task is running. For more information, see Amazon
                                                                                                                                                                                                                                                                                                                                          	// ECS Launch Types
                                                                                                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
                                                                                                                                                                                                                                                                                                                                          	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                          	LaunchType LaunchType
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The amount of memory (in MiB) used by the task as expressed in a task
                                                                                                                                                                                                                                                                                                                                          	// definition. It can be expressed as an integer using MiB, for example 1024. It
                                                                                                                                                                                                                                                                                                                                          	// can also be expressed as a string using GB, for example 1GB or 1 GB. String
                                                                                                                                                                                                                                                                                                                                          	// values are converted to an integer indicating the MiB when the task definition
                                                                                                                                                                                                                                                                                                                                          	// is registered. If you are using the EC2 launch type, this field is optional. If
                                                                                                                                                                                                                                                                                                                                          	// you are using the Fargate launch type, this field is required and you must use
                                                                                                                                                                                                                                                                                                                                          	// one of the following values, which determines your range of supported values for
                                                                                                                                                                                                                                                                                                                                          	// the cpu parameter:
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu
                                                                                                                                                                                                                                                                                                                                          	// values: 256 (.25 vCPU)
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) -
                                                                                                                                                                                                                                                                                                                                          	// Available cpu values: 512 (.5 vCPU)
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * 2048 (2 GB), 3072 (3 GB), 4096 (4 GB),
                                                                                                                                                                                                                                                                                                                                          	// 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024
                                                                                                                                                                                                                                                                                                                                          	// (1 vCPU)
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) -
                                                                                                                                                                                                                                                                                                                                          	// Available cpu values: 2048 (2 vCPU)
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * Between 8192 (8 GB) and 30720 (30 GB) in
                                                                                                                                                                                                                                                                                                                                          	// increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU)
                                                                                                                                                                                                                                                                                                                                          	Memory *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// One or more container overrides.
                                                                                                                                                                                                                                                                                                                                          	Overrides *TaskOverride
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The platform version on which your task is running. A platform version is only
                                                                                                                                                                                                                                                                                                                                          	// specified for tasks using the Fargate launch type. If one is not specified, the
                                                                                                                                                                                                                                                                                                                                          	// LATEST platform version is used by default. For more information, see AWS
                                                                                                                                                                                                                                                                                                                                          	// Fargate Platform Versions
                                                                                                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
                                                                                                                                                                                                                                                                                                                                          	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                          	PlatformVersion *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Unix timestamp for when the container image pull began.
                                                                                                                                                                                                                                                                                                                                          	PullStartedAt *time.Time
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Unix timestamp for when the container image pull completed.
                                                                                                                                                                                                                                                                                                                                          	PullStoppedAt *time.Time
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Unix timestamp for when the task started (the task transitioned from the
                                                                                                                                                                                                                                                                                                                                          	// PENDING state to the RUNNING state).
                                                                                                                                                                                                                                                                                                                                          	StartedAt *time.Time
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The tag specified when a task is started. If the task is started by an Amazon
                                                                                                                                                                                                                                                                                                                                          	// ECS service, then the startedBy parameter contains the deployment ID of the
                                                                                                                                                                                                                                                                                                                                          	// service that starts it.
                                                                                                                                                                                                                                                                                                                                          	StartedBy *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The stop code indicating why a task was stopped. The stoppedReason may contain
                                                                                                                                                                                                                                                                                                                                          	// additional details.
                                                                                                                                                                                                                                                                                                                                          	StopCode TaskStopCode
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Unix timestamp for when the task was stopped (the task transitioned from the
                                                                                                                                                                                                                                                                                                                                          	// RUNNING state to the STOPPED state).
                                                                                                                                                                                                                                                                                                                                          	StoppedAt *time.Time
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The reason that the task was stopped.
                                                                                                                                                                                                                                                                                                                                          	StoppedReason *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Unix timestamp for when the task stops (transitions from the RUNNING state
                                                                                                                                                                                                                                                                                                                                          	// to STOPPED).
                                                                                                                                                                                                                                                                                                                                          	StoppingAt *time.Time
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The metadata that you apply to the task to help you categorize and organize
                                                                                                                                                                                                                                                                                                                                          	// them. Each tag consists of a key and an optional value, both of which you
                                                                                                                                                                                                                                                                                                                                          	// define. The following basic restrictions apply to tags:
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * Maximum number of
                                                                                                                                                                                                                                                                                                                                          	// tags per resource - 50
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * For each resource, each tag key must be unique, and
                                                                                                                                                                                                                                                                                                                                          	// each tag key can have only one value.
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * Maximum key length - 128 Unicode
                                                                                                                                                                                                                                                                                                                                          	// characters in UTF-8
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * Maximum value length - 256 Unicode characters in UTF-8
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// *
                                                                                                                                                                                                                                                                                                                                          	// If your tagging schema is used across multiple services and resources, remember
                                                                                                                                                                                                                                                                                                                                          	// that other services may have restrictions on allowed characters. Generally
                                                                                                                                                                                                                                                                                                                                          	// allowed characters are: letters, numbers, and spaces representable in UTF-8, and
                                                                                                                                                                                                                                                                                                                                          	// the following characters: + - = . _ : / @.
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * Tag keys and values are
                                                                                                                                                                                                                                                                                                                                          	// case-sensitive.
                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                          	// * Do not use aws:, AWS:, or any upper or lowercase combination
                                                                                                                                                                                                                                                                                                                                          	// of such as a prefix for either keys or values as it is reserved for AWS use. You
                                                                                                                                                                                                                                                                                                                                          	// cannot edit or delete tag keys or values with this prefix. Tags with this prefix
                                                                                                                                                                                                                                                                                                                                          	// do not count against your tags per resource limit.
                                                                                                                                                                                                                                                                                                                                          	Tags []Tag
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the task.
                                                                                                                                                                                                                                                                                                                                          	TaskArn *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The ARN of the task definition that creates the task.
                                                                                                                                                                                                                                                                                                                                          	TaskDefinitionArn *string
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// The version counter for the task. Every time a task experiences a change that
                                                                                                                                                                                                                                                                                                                                          	// triggers a CloudWatch event, the version counter is incremented. If you are
                                                                                                                                                                                                                                                                                                                                          	// replicating your Amazon ECS task state with CloudWatch Events, you can compare
                                                                                                                                                                                                                                                                                                                                          	// the version of a task reported by the Amazon ECS API actions with the version
                                                                                                                                                                                                                                                                                                                                          	// reported in CloudWatch Events for the task (inside the detail object) to verify
                                                                                                                                                                                                                                                                                                                                          	// that the version in your event stream is current.
                                                                                                                                                                                                                                                                                                                                          	Version int64
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            Details on a task in a cluster.

                                                                                                                                                                                                                                                                                                                                            type TaskDefinition

                                                                                                                                                                                                                                                                                                                                            type TaskDefinition struct {
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The launch type to use with your task. For more information, see Amazon ECS
                                                                                                                                                                                                                                                                                                                                            	// Launch Types
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
                                                                                                                                                                                                                                                                                                                                            	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                            	Compatibilities []Compatibility
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// A list of container definitions in JSON format that describe the different
                                                                                                                                                                                                                                                                                                                                            	// containers that make up your task. For more information about container
                                                                                                                                                                                                                                                                                                                                            	// definition parameters and defaults, see Amazon ECS Task Definitions
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html)
                                                                                                                                                                                                                                                                                                                                            	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                            	ContainerDefinitions []ContainerDefinition
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The number of cpu units used by the task. If you are using the EC2 launch type,
                                                                                                                                                                                                                                                                                                                                            	// this field is optional and any value can be used. If you are using the Fargate
                                                                                                                                                                                                                                                                                                                                            	// launch type, this field is required and you must use one of the following
                                                                                                                                                                                                                                                                                                                                            	// values, which determines your range of valid values for the memory parameter:
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// *
                                                                                                                                                                                                                                                                                                                                            	// 256 (.25 vCPU) - Available memory values: 512 (0.5 GB), 1024 (1 GB), 2048 (2
                                                                                                                                                                                                                                                                                                                                            	// GB)
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// * 512 (.5 vCPU) - Available memory values: 1024 (1 GB), 2048 (2 GB), 3072
                                                                                                                                                                                                                                                                                                                                            	// (3 GB), 4096 (4 GB)
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// * 1024 (1 vCPU) - Available memory values: 2048 (2 GB),
                                                                                                                                                                                                                                                                                                                                            	// 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// *
                                                                                                                                                                                                                                                                                                                                            	// 2048 (2 vCPU) - Available memory values: Between 4096 (4 GB) and 16384 (16 GB)
                                                                                                                                                                                                                                                                                                                                            	// in increments of 1024 (1 GB)
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// * 4096 (4 vCPU) - Available memory values: Between
                                                                                                                                                                                                                                                                                                                                            	// 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB)
                                                                                                                                                                                                                                                                                                                                            	Cpu *string
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) of the task execution role that grants the Amazon
                                                                                                                                                                                                                                                                                                                                            	// ECS container agent permission to make AWS API calls on your behalf. The task
                                                                                                                                                                                                                                                                                                                                            	// execution IAM role is required depending on the requirements of your task. For
                                                                                                                                                                                                                                                                                                                                            	// more information, see Amazon ECS task execution IAM role
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html)
                                                                                                                                                                                                                                                                                                                                            	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                            	ExecutionRoleArn *string
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The name of a family that this task definition is registered to. Up to 255
                                                                                                                                                                                                                                                                                                                                            	// letters (uppercase and lowercase), numbers, hyphens, and underscores are
                                                                                                                                                                                                                                                                                                                                            	// allowed. A family groups multiple versions of a task definition. Amazon ECS
                                                                                                                                                                                                                                                                                                                                            	// gives the first task definition that you registered to a family a revision
                                                                                                                                                                                                                                                                                                                                            	// number of 1. Amazon ECS gives sequential revision numbers to each task
                                                                                                                                                                                                                                                                                                                                            	// definition that you add.
                                                                                                                                                                                                                                                                                                                                            	Family *string
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The Elastic Inference accelerator associated with the task.
                                                                                                                                                                                                                                                                                                                                            	InferenceAccelerators []InferenceAccelerator
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The IPC resource namespace to use for the containers in the task. The valid
                                                                                                                                                                                                                                                                                                                                            	// values are host, task, or none. If host is specified, then all containers within
                                                                                                                                                                                                                                                                                                                                            	// the tasks that specified the host IPC mode on the same container instance share
                                                                                                                                                                                                                                                                                                                                            	// the same IPC resources with the host Amazon EC2 instance. If task is specified,
                                                                                                                                                                                                                                                                                                                                            	// all containers within the specified task share the same IPC resources. If none
                                                                                                                                                                                                                                                                                                                                            	// is specified, then IPC resources within the containers of a task are private and
                                                                                                                                                                                                                                                                                                                                            	// not shared with other containers in a task or on the container instance. If no
                                                                                                                                                                                                                                                                                                                                            	// value is specified, then the IPC resource namespace sharing depends on the
                                                                                                                                                                                                                                                                                                                                            	// Docker daemon setting on the container instance. For more information, see IPC
                                                                                                                                                                                                                                                                                                                                            	// settings (https://docs.docker.com/engine/reference/run/#ipc-settings---ipc) in
                                                                                                                                                                                                                                                                                                                                            	// the Docker run reference. If the host IPC mode is used, be aware that there is a
                                                                                                                                                                                                                                                                                                                                            	// heightened risk of undesired IPC namespace expose. For more information, see
                                                                                                                                                                                                                                                                                                                                            	// Docker security (https://docs.docker.com/engine/security/security/). If you are
                                                                                                                                                                                                                                                                                                                                            	// setting namespaced kernel parameters using systemControls for the containers in
                                                                                                                                                                                                                                                                                                                                            	// the task, the following will apply to your IPC resource namespace. For more
                                                                                                                                                                                                                                                                                                                                            	// information, see System Controls
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html)
                                                                                                                                                                                                                                                                                                                                            	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// * For tasks that use
                                                                                                                                                                                                                                                                                                                                            	// the host IPC mode, IPC namespace related systemControls are not supported.
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// *
                                                                                                                                                                                                                                                                                                                                            	// For tasks that use the task IPC mode, IPC namespace related systemControls will
                                                                                                                                                                                                                                                                                                                                            	// apply to all containers within a task.
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// This parameter is not supported for
                                                                                                                                                                                                                                                                                                                                            	// Windows containers or tasks using the Fargate launch type.
                                                                                                                                                                                                                                                                                                                                            	IpcMode IpcMode
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The amount (in MiB) of memory used by the task. If using the EC2 launch type,
                                                                                                                                                                                                                                                                                                                                            	// you must specify either a task-level memory value or a container-level memory
                                                                                                                                                                                                                                                                                                                                            	// value. This field is optional and any value can be used. If a task-level memory
                                                                                                                                                                                                                                                                                                                                            	// value is specified then the container-level memory value is optional. For more
                                                                                                                                                                                                                                                                                                                                            	// information regarding container-level memory and memory reservation, see
                                                                                                                                                                                                                                                                                                                                            	// ContainerDefinition
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html).
                                                                                                                                                                                                                                                                                                                                            	// If using the Fargate launch type, this field is required and you must use one of
                                                                                                                                                                                                                                                                                                                                            	// the following values, which determines your range of valid values for the cpu
                                                                                                                                                                                                                                                                                                                                            	// parameter:
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// * 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256
                                                                                                                                                                                                                                                                                                                                            	// (.25 vCPU)
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// * 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu
                                                                                                                                                                                                                                                                                                                                            	// values: 512 (.5 vCPU)
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// * 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB),
                                                                                                                                                                                                                                                                                                                                            	// 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU)
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// *
                                                                                                                                                                                                                                                                                                                                            	// Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available
                                                                                                                                                                                                                                                                                                                                            	// cpu values: 2048 (2 vCPU)
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// * Between 8192 (8 GB) and 30720 (30 GB) in increments
                                                                                                                                                                                                                                                                                                                                            	// of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU)
                                                                                                                                                                                                                                                                                                                                            	Memory *string
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The Docker networking mode to use for the containers in the task. The valid
                                                                                                                                                                                                                                                                                                                                            	// values are none, bridge, awsvpc, and host. If no network mode is specified, the
                                                                                                                                                                                                                                                                                                                                            	// default is bridge. For Amazon ECS tasks on Fargate, the awsvpc network mode is
                                                                                                                                                                                                                                                                                                                                            	// required. For Amazon ECS tasks on Amazon EC2 instances, any network mode can be
                                                                                                                                                                                                                                                                                                                                            	// used. If the network mode is set to none, you cannot specify port mappings in
                                                                                                                                                                                                                                                                                                                                            	// your container definitions, and the tasks containers do not have external
                                                                                                                                                                                                                                                                                                                                            	// connectivity. The host and awsvpc network modes offer the highest networking
                                                                                                                                                                                                                                                                                                                                            	// performance for containers because they use the EC2 network stack instead of the
                                                                                                                                                                                                                                                                                                                                            	// virtualized network stack provided by the bridge mode. With the host and awsvpc
                                                                                                                                                                                                                                                                                                                                            	// network modes, exposed container ports are mapped directly to the corresponding
                                                                                                                                                                                                                                                                                                                                            	// host port (for the host network mode) or the attached elastic network interface
                                                                                                                                                                                                                                                                                                                                            	// port (for the awsvpc network mode), so you cannot take advantage of dynamic host
                                                                                                                                                                                                                                                                                                                                            	// port mappings. When using the host network mode, you should not run containers
                                                                                                                                                                                                                                                                                                                                            	// using the root user (UID 0). It is considered best practice to use a non-root
                                                                                                                                                                                                                                                                                                                                            	// user. If the network mode is awsvpc, the task is allocated an elastic network
                                                                                                                                                                                                                                                                                                                                            	// interface, and you must specify a NetworkConfiguration value when you create a
                                                                                                                                                                                                                                                                                                                                            	// service or run a task with the task definition. For more information, see Task
                                                                                                                                                                                                                                                                                                                                            	// Networking
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html)
                                                                                                                                                                                                                                                                                                                                            	// in the Amazon Elastic Container Service Developer Guide. Currently, only Amazon
                                                                                                                                                                                                                                                                                                                                            	// ECS-optimized AMIs, other Amazon Linux variants with the ecs-init package, or
                                                                                                                                                                                                                                                                                                                                            	// AWS Fargate infrastructure support the awsvpc network mode. If the network mode
                                                                                                                                                                                                                                                                                                                                            	// is host, you cannot run multiple instantiations of the same task on a single
                                                                                                                                                                                                                                                                                                                                            	// container instance when port mappings are used. Docker for Windows uses
                                                                                                                                                                                                                                                                                                                                            	// different network modes than Docker for Linux. When you register a task
                                                                                                                                                                                                                                                                                                                                            	// definition with Windows containers, you must not specify a network mode. If you
                                                                                                                                                                                                                                                                                                                                            	// use the console to register a task definition with Windows containers, you must
                                                                                                                                                                                                                                                                                                                                            	// choose the  network mode object. For more information, see Network settings
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.docker.com/engine/reference/run/#network-settings) in the Docker
                                                                                                                                                                                                                                                                                                                                            	// run reference.
                                                                                                                                                                                                                                                                                                                                            	NetworkMode NetworkMode
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The process namespace to use for the containers in the task. The valid values
                                                                                                                                                                                                                                                                                                                                            	// are host or task. If host is specified, then all containers within the tasks
                                                                                                                                                                                                                                                                                                                                            	// that specified the host PID mode on the same container instance share the same
                                                                                                                                                                                                                                                                                                                                            	// process namespace with the host Amazon EC2 instance. If task is specified, all
                                                                                                                                                                                                                                                                                                                                            	// containers within the specified task share the same process namespace. If no
                                                                                                                                                                                                                                                                                                                                            	// value is specified, the default is a private namespace. For more information,
                                                                                                                                                                                                                                                                                                                                            	// see PID settings
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.docker.com/engine/reference/run/#pid-settings---pid) in the Docker
                                                                                                                                                                                                                                                                                                                                            	// run reference. If the host PID mode is used, be aware that there is a heightened
                                                                                                                                                                                                                                                                                                                                            	// risk of undesired process namespace expose. For more information, see Docker
                                                                                                                                                                                                                                                                                                                                            	// security (https://docs.docker.com/engine/security/security/). This parameter is
                                                                                                                                                                                                                                                                                                                                            	// not supported for Windows containers or tasks using the Fargate launch type.
                                                                                                                                                                                                                                                                                                                                            	PidMode PidMode
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// An array of placement constraint objects to use for tasks. This field is not
                                                                                                                                                                                                                                                                                                                                            	// valid if you are using the Fargate launch type for your task.
                                                                                                                                                                                                                                                                                                                                            	PlacementConstraints []TaskDefinitionPlacementConstraint
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The configuration details for the App Mesh proxy. Your Amazon ECS container
                                                                                                                                                                                                                                                                                                                                            	// instances require at least version 1.26.0 of the container agent and at least
                                                                                                                                                                                                                                                                                                                                            	// version 1.26.0-1 of the ecs-init package to enable a proxy configuration. If
                                                                                                                                                                                                                                                                                                                                            	// your container instances are launched from the Amazon ECS-optimized AMI version
                                                                                                                                                                                                                                                                                                                                            	// 20190301 or later, then they contain the required versions of the container
                                                                                                                                                                                                                                                                                                                                            	// agent and ecs-init. For more information, see Amazon ECS-optimized Linux AMI
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)
                                                                                                                                                                                                                                                                                                                                            	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                            	ProxyConfiguration *ProxyConfiguration
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The container instance attributes required by your task. This field is not valid
                                                                                                                                                                                                                                                                                                                                            	// if you are using the Fargate launch type for your task.
                                                                                                                                                                                                                                                                                                                                            	RequiresAttributes []Attribute
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The launch type the task requires. If no value is specified, it will default to
                                                                                                                                                                                                                                                                                                                                            	// EC2. Valid values include EC2 and FARGATE.
                                                                                                                                                                                                                                                                                                                                            	RequiresCompatibilities []Compatibility
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The revision of the task in a particular family. The revision is a version
                                                                                                                                                                                                                                                                                                                                            	// number of a task definition in a family. When you register a task definition for
                                                                                                                                                                                                                                                                                                                                            	// the first time, the revision is 1. Each time that you register a new revision of
                                                                                                                                                                                                                                                                                                                                            	// a task definition in the same family, the revision value always increases by
                                                                                                                                                                                                                                                                                                                                            	// one, even if you have deregistered previous revisions in this family.
                                                                                                                                                                                                                                                                                                                                            	Revision int32
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The status of the task definition.
                                                                                                                                                                                                                                                                                                                                            	Status TaskDefinitionStatus
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The full Amazon Resource Name (ARN) of the task definition.
                                                                                                                                                                                                                                                                                                                                            	TaskDefinitionArn *string
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The short name or full Amazon Resource Name (ARN) of the AWS Identity and Access
                                                                                                                                                                                                                                                                                                                                            	// Management (IAM) role that grants containers in the task permission to call AWS
                                                                                                                                                                                                                                                                                                                                            	// APIs on your behalf. For more information, see Amazon ECS Task Role
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)
                                                                                                                                                                                                                                                                                                                                            	// in the Amazon Elastic Container Service Developer Guide. IAM roles for tasks on
                                                                                                                                                                                                                                                                                                                                            	// Windows require that the -EnableTaskIAMRole option is set when you launch the
                                                                                                                                                                                                                                                                                                                                            	// Amazon ECS-optimized Windows AMI. Your containers must also run some
                                                                                                                                                                                                                                                                                                                                            	// configuration code in order to take advantage of the feature. For more
                                                                                                                                                                                                                                                                                                                                            	// information, see Windows IAM Roles for Tasks
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows_task_IAM_roles.html)
                                                                                                                                                                                                                                                                                                                                            	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                            	TaskRoleArn *string
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The list of volume definitions for the task. If your tasks are using the Fargate
                                                                                                                                                                                                                                                                                                                                            	// launch type, the host and sourcePath parameters are not supported. For more
                                                                                                                                                                                                                                                                                                                                            	// information about volume definition parameters and defaults, see Amazon ECS Task
                                                                                                                                                                                                                                                                                                                                            	// Definitions
                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html)
                                                                                                                                                                                                                                                                                                                                            	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                            	Volumes []Volume
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                              The details of a task definition which describes the container and volume definitions of an Amazon Elastic Container Service task. You can specify which Docker images to use, the required resources, and other configurations related to launching the task definition through an Amazon ECS service or task.

                                                                                                                                                                                                                                                                                                                                              type TaskDefinitionFamilyStatus

                                                                                                                                                                                                                                                                                                                                              type TaskDefinitionFamilyStatus string
                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                              	TaskDefinitionFamilyStatusActive   TaskDefinitionFamilyStatus = "ACTIVE"
                                                                                                                                                                                                                                                                                                                                              	TaskDefinitionFamilyStatusInactive TaskDefinitionFamilyStatus = "INACTIVE"
                                                                                                                                                                                                                                                                                                                                              	TaskDefinitionFamilyStatusAll      TaskDefinitionFamilyStatus = "ALL"
                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                Enum values for TaskDefinitionFamilyStatus

                                                                                                                                                                                                                                                                                                                                                func (TaskDefinitionFamilyStatus) Values

                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for TaskDefinitionFamilyStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                  type TaskDefinitionField

                                                                                                                                                                                                                                                                                                                                                  type TaskDefinitionField string
                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                  	TaskDefinitionFieldTags TaskDefinitionField = "TAGS"
                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                    Enum values for TaskDefinitionField

                                                                                                                                                                                                                                                                                                                                                    func (TaskDefinitionField) Values

                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for TaskDefinitionField. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                      type TaskDefinitionPlacementConstraint

                                                                                                                                                                                                                                                                                                                                                      type TaskDefinitionPlacementConstraint struct {
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// A cluster query language expression to apply to the constraint. For more
                                                                                                                                                                                                                                                                                                                                                      	// information, see Cluster Query Language
                                                                                                                                                                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html)
                                                                                                                                                                                                                                                                                                                                                      	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                                      	Expression *string
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// The type of constraint. The MemberOf constraint restricts selection to be from a
                                                                                                                                                                                                                                                                                                                                                      	// group of valid candidates.
                                                                                                                                                                                                                                                                                                                                                      	Type TaskDefinitionPlacementConstraintType
                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                        An object representing a constraint on task placement in the task definition. For more information, see Task Placement Constraints (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html) in the Amazon Elastic Container Service Developer Guide. If you are using the Fargate launch type, task placement constraints are not supported.

                                                                                                                                                                                                                                                                                                                                                        type TaskDefinitionPlacementConstraintType

                                                                                                                                                                                                                                                                                                                                                        type TaskDefinitionPlacementConstraintType string
                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                        	TaskDefinitionPlacementConstraintTypeMemberOf TaskDefinitionPlacementConstraintType = "memberOf"
                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                          Enum values for TaskDefinitionPlacementConstraintType

                                                                                                                                                                                                                                                                                                                                                          func (TaskDefinitionPlacementConstraintType) Values

                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for TaskDefinitionPlacementConstraintType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                            type TaskDefinitionStatus

                                                                                                                                                                                                                                                                                                                                                            type TaskDefinitionStatus string
                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                            	TaskDefinitionStatusActive   TaskDefinitionStatus = "ACTIVE"
                                                                                                                                                                                                                                                                                                                                                            	TaskDefinitionStatusInactive TaskDefinitionStatus = "INACTIVE"
                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                              Enum values for TaskDefinitionStatus

                                                                                                                                                                                                                                                                                                                                                              func (TaskDefinitionStatus) Values

                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for TaskDefinitionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                type TaskField

                                                                                                                                                                                                                                                                                                                                                                type TaskField string
                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                	TaskFieldTags TaskField = "TAGS"
                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                  Enum values for TaskField

                                                                                                                                                                                                                                                                                                                                                                  func (TaskField) Values

                                                                                                                                                                                                                                                                                                                                                                  func (TaskField) Values() []TaskField

                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for TaskField. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                    type TaskOverride

                                                                                                                                                                                                                                                                                                                                                                    type TaskOverride struct {
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// One or more container overrides sent to a task.
                                                                                                                                                                                                                                                                                                                                                                    	ContainerOverrides []ContainerOverride
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The cpu override for the task.
                                                                                                                                                                                                                                                                                                                                                                    	Cpu *string
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the task execution IAM role override for the
                                                                                                                                                                                                                                                                                                                                                                    	// task.
                                                                                                                                                                                                                                                                                                                                                                    	ExecutionRoleArn *string
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The Elastic Inference accelerator override for the task.
                                                                                                                                                                                                                                                                                                                                                                    	InferenceAcceleratorOverrides []InferenceAcceleratorOverride
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The memory override for the task.
                                                                                                                                                                                                                                                                                                                                                                    	Memory *string
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the IAM role that containers in this task can
                                                                                                                                                                                                                                                                                                                                                                    	// assume. All containers in this task are granted the permissions that are
                                                                                                                                                                                                                                                                                                                                                                    	// specified in this role.
                                                                                                                                                                                                                                                                                                                                                                    	TaskRoleArn *string
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      The overrides associated with a task.

                                                                                                                                                                                                                                                                                                                                                                      type TaskSet

                                                                                                                                                                                                                                                                                                                                                                      type TaskSet struct {
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The capacity provider strategy associated with the task set.
                                                                                                                                                                                                                                                                                                                                                                      	CapacityProviderStrategy []CapacityProviderStrategyItem
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) of the cluster that the service that hosts the
                                                                                                                                                                                                                                                                                                                                                                      	// task set exists in.
                                                                                                                                                                                                                                                                                                                                                                      	ClusterArn *string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The computed desired count for the task set. This is calculated by multiplying
                                                                                                                                                                                                                                                                                                                                                                      	// the service's desiredCount by the task set's scale percentage. The result is
                                                                                                                                                                                                                                                                                                                                                                      	// always rounded up. For example, if the computed desired count is 1.2, it rounds
                                                                                                                                                                                                                                                                                                                                                                      	// up to 2 tasks.
                                                                                                                                                                                                                                                                                                                                                                      	ComputedDesiredCount int32
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The Unix timestamp for when the task set was created.
                                                                                                                                                                                                                                                                                                                                                                      	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The external ID associated with the task set. If a task set is created by an AWS
                                                                                                                                                                                                                                                                                                                                                                      	// CodeDeploy deployment, the externalId parameter contains the AWS CodeDeploy
                                                                                                                                                                                                                                                                                                                                                                      	// deployment ID. If a task set is created for an external deployment and is
                                                                                                                                                                                                                                                                                                                                                                      	// associated with a service discovery registry, the externalId parameter contains
                                                                                                                                                                                                                                                                                                                                                                      	// the ECS_TASK_SET_EXTERNAL_ID AWS Cloud Map attribute.
                                                                                                                                                                                                                                                                                                                                                                      	ExternalId *string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The ID of the task set.
                                                                                                                                                                                                                                                                                                                                                                      	Id *string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The launch type the tasks in the task set are using. For more information, see
                                                                                                                                                                                                                                                                                                                                                                      	// Amazon ECS Launch Types
                                                                                                                                                                                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
                                                                                                                                                                                                                                                                                                                                                                      	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                                                      	LaunchType LaunchType
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// Details on a load balancer that is used with a task set.
                                                                                                                                                                                                                                                                                                                                                                      	LoadBalancers []LoadBalancer
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The network configuration for the task set.
                                                                                                                                                                                                                                                                                                                                                                      	NetworkConfiguration *NetworkConfiguration
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The number of tasks in the task set that are in the PENDING status during a
                                                                                                                                                                                                                                                                                                                                                                      	// deployment. A task in the PENDING state is preparing to enter the RUNNING state.
                                                                                                                                                                                                                                                                                                                                                                      	// A task set enters the PENDING status when it launches for the first time or when
                                                                                                                                                                                                                                                                                                                                                                      	// it is restarted after being in the STOPPED state.
                                                                                                                                                                                                                                                                                                                                                                      	PendingCount int32
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The platform version on which the tasks in the task set are running. A platform
                                                                                                                                                                                                                                                                                                                                                                      	// version is only specified for tasks using the Fargate launch type. If one is not
                                                                                                                                                                                                                                                                                                                                                                      	// specified, the LATEST platform version is used by default. For more information,
                                                                                                                                                                                                                                                                                                                                                                      	// see AWS Fargate Platform Versions
                                                                                                                                                                                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
                                                                                                                                                                                                                                                                                                                                                                      	// in the Amazon Elastic Container Service Developer Guide.
                                                                                                                                                                                                                                                                                                                                                                      	PlatformVersion *string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The number of tasks in the task set that are in the RUNNING status during a
                                                                                                                                                                                                                                                                                                                                                                      	// deployment. A task in the RUNNING state is running and ready for use.
                                                                                                                                                                                                                                                                                                                                                                      	RunningCount int32
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// A floating-point percentage of the desired number of tasks to place and keep
                                                                                                                                                                                                                                                                                                                                                                      	// running in the task set.
                                                                                                                                                                                                                                                                                                                                                                      	Scale *Scale
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) of the service the task set exists in.
                                                                                                                                                                                                                                                                                                                                                                      	ServiceArn *string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The details of the service discovery registries to assign to this task set. For
                                                                                                                                                                                                                                                                                                                                                                      	// more information, see Service Discovery
                                                                                                                                                                                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html).
                                                                                                                                                                                                                                                                                                                                                                      	ServiceRegistries []ServiceRegistry
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The stability status, which indicates whether the task set has reached a steady
                                                                                                                                                                                                                                                                                                                                                                      	// state. If the following conditions are met, the task set will be in
                                                                                                                                                                                                                                                                                                                                                                      	// STEADY_STATE:
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// * The task runningCount is equal to the computedDesiredCount.
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// *
                                                                                                                                                                                                                                                                                                                                                                      	// The pendingCount is 0.
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// * There are no tasks running on container instances in
                                                                                                                                                                                                                                                                                                                                                                      	// the DRAINING status.
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// * All tasks are reporting a healthy status from the load
                                                                                                                                                                                                                                                                                                                                                                      	// balancers, service discovery, and container health checks.
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// If any of those
                                                                                                                                                                                                                                                                                                                                                                      	// conditions are not met, the stability status returns STABILIZING.
                                                                                                                                                                                                                                                                                                                                                                      	StabilityStatus StabilityStatus
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The Unix timestamp for when the task set stability status was retrieved.
                                                                                                                                                                                                                                                                                                                                                                      	StabilityStatusAt *time.Time
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The tag specified when a task set is started. If the task set is created by an
                                                                                                                                                                                                                                                                                                                                                                      	// AWS CodeDeploy deployment, the startedBy parameter is CODE_DEPLOY. For a task
                                                                                                                                                                                                                                                                                                                                                                      	// set created for an external deployment, the startedBy field isn't used.
                                                                                                                                                                                                                                                                                                                                                                      	StartedBy *string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The status of the task set. The following describes each state: PRIMARY The task
                                                                                                                                                                                                                                                                                                                                                                      	// set is serving production traffic. ACTIVE The task set is not serving production
                                                                                                                                                                                                                                                                                                                                                                      	// traffic. DRAINING The tasks in the task set are being stopped and their
                                                                                                                                                                                                                                                                                                                                                                      	// corresponding targets are being deregistered from their target group.
                                                                                                                                                                                                                                                                                                                                                                      	Status *string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The metadata that you apply to the task set to help you categorize and organize
                                                                                                                                                                                                                                                                                                                                                                      	// them. Each tag consists of a key and an optional value, both of which you
                                                                                                                                                                                                                                                                                                                                                                      	// define. The following basic restrictions apply to tags:
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// * Maximum number of
                                                                                                                                                                                                                                                                                                                                                                      	// tags per resource - 50
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// * For each resource, each tag key must be unique, and
                                                                                                                                                                                                                                                                                                                                                                      	// each tag key can have only one value.
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// * Maximum key length - 128 Unicode
                                                                                                                                                                                                                                                                                                                                                                      	// characters in UTF-8
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// * Maximum value length - 256 Unicode characters in UTF-8
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// *
                                                                                                                                                                                                                                                                                                                                                                      	// If your tagging schema is used across multiple services and resources, remember
                                                                                                                                                                                                                                                                                                                                                                      	// that other services may have restrictions on allowed characters. Generally
                                                                                                                                                                                                                                                                                                                                                                      	// allowed characters are: letters, numbers, and spaces representable in UTF-8, and
                                                                                                                                                                                                                                                                                                                                                                      	// the following characters: + - = . _ : / @.
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// * Tag keys and values are
                                                                                                                                                                                                                                                                                                                                                                      	// case-sensitive.
                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                      	// * Do not use aws:, AWS:, or any upper or lowercase combination
                                                                                                                                                                                                                                                                                                                                                                      	// of such as a prefix for either keys or values as it is reserved for AWS use. You
                                                                                                                                                                                                                                                                                                                                                                      	// cannot edit or delete tag keys or values with this prefix. Tags with this prefix
                                                                                                                                                                                                                                                                                                                                                                      	// do not count against your tags per resource limit.
                                                                                                                                                                                                                                                                                                                                                                      	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The task definition the task set is using.
                                                                                                                                                                                                                                                                                                                                                                      	TaskDefinition *string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) of the task set.
                                                                                                                                                                                                                                                                                                                                                                      	TaskSetArn *string
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The Unix timestamp for when the task set was last updated.
                                                                                                                                                                                                                                                                                                                                                                      	UpdatedAt *time.Time
                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                        Information about a set of Amazon ECS tasks in either an AWS CodeDeploy or an EXTERNAL deployment. An Amazon ECS task set includes details such as the desired number of tasks, how many tasks are running, and whether the task set serves production traffic.

                                                                                                                                                                                                                                                                                                                                                                        type TaskSetField

                                                                                                                                                                                                                                                                                                                                                                        type TaskSetField string
                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                        	TaskSetFieldTags TaskSetField = "TAGS"
                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                          Enum values for TaskSetField

                                                                                                                                                                                                                                                                                                                                                                          func (TaskSetField) Values

                                                                                                                                                                                                                                                                                                                                                                          func (TaskSetField) Values() []TaskSetField

                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for TaskSetField. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                            type TaskSetNotFoundException

                                                                                                                                                                                                                                                                                                                                                                            type TaskSetNotFoundException struct {
                                                                                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              The specified task set could not be found. You can view your available task sets with DescribeTaskSets. Task sets are specific to each cluster, service and Region.

                                                                                                                                                                                                                                                                                                                                                                              func (*TaskSetNotFoundException) Error

                                                                                                                                                                                                                                                                                                                                                                              func (e *TaskSetNotFoundException) Error() string

                                                                                                                                                                                                                                                                                                                                                                              func (*TaskSetNotFoundException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                              func (e *TaskSetNotFoundException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                              func (*TaskSetNotFoundException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                              func (e *TaskSetNotFoundException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                                                              func (*TaskSetNotFoundException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                              func (e *TaskSetNotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                              type TaskStopCode

                                                                                                                                                                                                                                                                                                                                                                              type TaskStopCode string
                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                              	TaskStopCodeTaskFailedToStart        TaskStopCode = "TaskFailedToStart"
                                                                                                                                                                                                                                                                                                                                                                              	TaskStopCodeEssentialContainerExited TaskStopCode = "EssentialContainerExited"
                                                                                                                                                                                                                                                                                                                                                                              	TaskStopCodeUserInitiated            TaskStopCode = "UserInitiated"
                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                Enum values for TaskStopCode

                                                                                                                                                                                                                                                                                                                                                                                func (TaskStopCode) Values

                                                                                                                                                                                                                                                                                                                                                                                func (TaskStopCode) Values() []TaskStopCode

                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for TaskStopCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                  type Tmpfs

                                                                                                                                                                                                                                                                                                                                                                                  type Tmpfs struct {
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The absolute file path where the tmpfs volume is to be mounted.
                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                  	ContainerPath *string
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The maximum size (in MiB) of the tmpfs volume.
                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                  	Size int32
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The list of tmpfs volume mount options. Valid values: "defaults" | "ro" | "rw" |
                                                                                                                                                                                                                                                                                                                                                                                  	// "suid" | "nosuid" | "dev" | "nodev" | "exec" | "noexec" | "sync" | "async" |
                                                                                                                                                                                                                                                                                                                                                                                  	// "dirsync" | "remount" | "mand" | "nomand" | "atime" | "noatime" | "diratime" |
                                                                                                                                                                                                                                                                                                                                                                                  	// "nodiratime" | "bind" | "rbind" | "unbindable" | "runbindable" | "private" |
                                                                                                                                                                                                                                                                                                                                                                                  	// "rprivate" | "shared" | "rshared" | "slave" | "rslave" | "relatime" |
                                                                                                                                                                                                                                                                                                                                                                                  	// "norelatime" | "strictatime" | "nostrictatime" | "mode" | "uid" | "gid" |
                                                                                                                                                                                                                                                                                                                                                                                  	// "nr_inodes" | "nr_blocks" | "mpol"
                                                                                                                                                                                                                                                                                                                                                                                  	MountOptions []string
                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                    The container path, mount options, and size of the tmpfs mount.

                                                                                                                                                                                                                                                                                                                                                                                    type TransportProtocol

                                                                                                                                                                                                                                                                                                                                                                                    type TransportProtocol string
                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                    	TransportProtocolTcp TransportProtocol = "tcp"
                                                                                                                                                                                                                                                                                                                                                                                    	TransportProtocolUdp TransportProtocol = "udp"
                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                      Enum values for TransportProtocol

                                                                                                                                                                                                                                                                                                                                                                                      func (TransportProtocol) Values

                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for TransportProtocol. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                        type Ulimit

                                                                                                                                                                                                                                                                                                                                                                                        type Ulimit struct {
                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                        	// The hard limit for the ulimit type.
                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                        	HardLimit int32
                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                        	// The type of the ulimit.
                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                        	Name UlimitName
                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                        	// The soft limit for the ulimit type.
                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                        	SoftLimit int32
                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                          The ulimit settings to pass to the container.

                                                                                                                                                                                                                                                                                                                                                                                          type UlimitName

                                                                                                                                                                                                                                                                                                                                                                                          type UlimitName string
                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameCore       UlimitName = "core"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameCpu        UlimitName = "cpu"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameData       UlimitName = "data"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameFsize      UlimitName = "fsize"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameLocks      UlimitName = "locks"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameMemlock    UlimitName = "memlock"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameMsgqueue   UlimitName = "msgqueue"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameNice       UlimitName = "nice"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameNofile     UlimitName = "nofile"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameNproc      UlimitName = "nproc"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameRss        UlimitName = "rss"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameRtprio     UlimitName = "rtprio"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameRttime     UlimitName = "rttime"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameSigpending UlimitName = "sigpending"
                                                                                                                                                                                                                                                                                                                                                                                          	UlimitNameStack      UlimitName = "stack"
                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                            Enum values for UlimitName

                                                                                                                                                                                                                                                                                                                                                                                            func (UlimitName) Values

                                                                                                                                                                                                                                                                                                                                                                                            func (UlimitName) Values() []UlimitName

                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for UlimitName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                              type UnsupportedFeatureException

                                                                                                                                                                                                                                                                                                                                                                                              type UnsupportedFeatureException struct {
                                                                                                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                The specified task is not supported in this Region.

                                                                                                                                                                                                                                                                                                                                                                                                func (*UnsupportedFeatureException) Error

                                                                                                                                                                                                                                                                                                                                                                                                func (*UnsupportedFeatureException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                func (e *UnsupportedFeatureException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                func (*UnsupportedFeatureException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                func (*UnsupportedFeatureException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                func (e *UnsupportedFeatureException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                type UpdateInProgressException

                                                                                                                                                                                                                                                                                                                                                                                                type UpdateInProgressException struct {
                                                                                                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                  There is already a current Amazon ECS container agent update in progress on the specified container instance. If the container agent becomes disconnected while it is in a transitional stage, such as PENDING or STAGING, the update process can get stuck in that state. However, when the agent reconnects, it resumes where it stopped previously.

                                                                                                                                                                                                                                                                                                                                                                                                  func (*UpdateInProgressException) Error

                                                                                                                                                                                                                                                                                                                                                                                                  func (e *UpdateInProgressException) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                  func (*UpdateInProgressException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                  func (e *UpdateInProgressException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                  func (*UpdateInProgressException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                  func (*UpdateInProgressException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                  func (e *UpdateInProgressException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                  type VersionInfo

                                                                                                                                                                                                                                                                                                                                                                                                  type VersionInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	// The Git commit hash for the Amazon ECS container agent build on the
                                                                                                                                                                                                                                                                                                                                                                                                  	// amazon-ecs-agent  (https://github.com/aws/amazon-ecs-agent/commits/master)
                                                                                                                                                                                                                                                                                                                                                                                                  	// GitHub repository.
                                                                                                                                                                                                                                                                                                                                                                                                  	AgentHash *string
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	// The version number of the Amazon ECS container agent.
                                                                                                                                                                                                                                                                                                                                                                                                  	AgentVersion *string
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	// The Docker version running on the container instance.
                                                                                                                                                                                                                                                                                                                                                                                                  	DockerVersion *string
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    The Docker and Amazon ECS container agent version information about a container instance.

                                                                                                                                                                                                                                                                                                                                                                                                    type Volume

                                                                                                                                                                                                                                                                                                                                                                                                    type Volume struct {
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// This parameter is specified when you are using Docker volumes. Docker volumes
                                                                                                                                                                                                                                                                                                                                                                                                    	// are only supported when you are using the EC2 launch type. Windows containers
                                                                                                                                                                                                                                                                                                                                                                                                    	// only support the use of the local driver. To use bind mounts, specify the host
                                                                                                                                                                                                                                                                                                                                                                                                    	// parameter instead.
                                                                                                                                                                                                                                                                                                                                                                                                    	DockerVolumeConfiguration *DockerVolumeConfiguration
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// This parameter is specified when you are using an Amazon Elastic File System
                                                                                                                                                                                                                                                                                                                                                                                                    	// file system for task storage.
                                                                                                                                                                                                                                                                                                                                                                                                    	EfsVolumeConfiguration *EFSVolumeConfiguration
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// This parameter is specified when you are using Amazon FSx for Windows File
                                                                                                                                                                                                                                                                                                                                                                                                    	// Server file system for task storage.
                                                                                                                                                                                                                                                                                                                                                                                                    	FsxWindowsFileServerVolumeConfiguration *FSxWindowsFileServerVolumeConfiguration
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// This parameter is specified when you are using bind mount host volumes. The
                                                                                                                                                                                                                                                                                                                                                                                                    	// contents of the host parameter determine whether your bind mount host volume
                                                                                                                                                                                                                                                                                                                                                                                                    	// persists on the host container instance and where it is stored. If the host
                                                                                                                                                                                                                                                                                                                                                                                                    	// parameter is empty, then the Docker daemon assigns a host path for your data
                                                                                                                                                                                                                                                                                                                                                                                                    	// volume. However, the data is not guaranteed to persist after the containers
                                                                                                                                                                                                                                                                                                                                                                                                    	// associated with it stop running. Windows containers can mount whole directories
                                                                                                                                                                                                                                                                                                                                                                                                    	// on the same drive as $env:ProgramData. Windows containers cannot mount
                                                                                                                                                                                                                                                                                                                                                                                                    	// directories on a different drive, and mount point cannot be across drives. For
                                                                                                                                                                                                                                                                                                                                                                                                    	// example, you can mount C:\my\path:C:\my\path and D:\:D:\, but not
                                                                                                                                                                                                                                                                                                                                                                                                    	// D:\my\path:C:\my\path or D:\:C:\my\path.
                                                                                                                                                                                                                                                                                                                                                                                                    	Host *HostVolumeProperties
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the volume. Up to 255 letters (uppercase and lowercase), numbers,
                                                                                                                                                                                                                                                                                                                                                                                                    	// and hyphens are allowed. This name is referenced in the sourceVolume parameter
                                                                                                                                                                                                                                                                                                                                                                                                    	// of container definition mountPoints.
                                                                                                                                                                                                                                                                                                                                                                                                    	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      A data volume used in a task definition. For tasks that use the Amazon Elastic File System (Amazon EFS), specify an efsVolumeConfiguration. For Windows tasks that use Amazon FSx for Windows File Server file system, specify a fsxWindowsFileServerVolumeConfiguration. For tasks that use a Docker volume, specify a DockerVolumeConfiguration. For tasks that use a bind mount host volume, specify a host and optional sourcePath. For more information, see Using Data Volumes in Tasks (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html).

                                                                                                                                                                                                                                                                                                                                                                                                      type VolumeFrom

                                                                                                                                                                                                                                                                                                                                                                                                      type VolumeFrom struct {
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// If this value is true, the container has read-only access to the volume. If this
                                                                                                                                                                                                                                                                                                                                                                                                      	// value is false, then the container can write to the volume. The default value is
                                                                                                                                                                                                                                                                                                                                                                                                      	// false.
                                                                                                                                                                                                                                                                                                                                                                                                      	ReadOnly *bool
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of another container within the same task definition from which to
                                                                                                                                                                                                                                                                                                                                                                                                      	// mount volumes.
                                                                                                                                                                                                                                                                                                                                                                                                      	SourceContainer *string
                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                        Details on a data volume from another container in the same task definition.