v1alpha1

type AWSVPCConfiguration ¶

type AWSVPCConfiguration struct {
	SecurityGroups []*string `json:"securityGroups,omitempty"`
	Subnets        []*string `json:"subnets,omitempty"`
}

An object representing the networking details for a task or service. For example awsvpcConfiguration={subnets=["subnet-12344321"],securityGroups=["sg-12344321"]}

func (in *AWSVPCConfiguration) DeepCopy() *AWSVPCConfiguration

func (in *AWSVPCConfiguration) DeepCopyInto(out *AWSVPCConfiguration)

type AgentUpdateStatus ¶

type AgentUpdateStatus string

const (
	AgentUpdateStatus_PENDING  AgentUpdateStatus = "PENDING"
	AgentUpdateStatus_STAGING  AgentUpdateStatus = "STAGING"
	AgentUpdateStatus_STAGED   AgentUpdateStatus = "STAGED"
	AgentUpdateStatus_UPDATING AgentUpdateStatus = "UPDATING"
	AgentUpdateStatus_UPDATED  AgentUpdateStatus = "UPDATED"
	AgentUpdateStatus_FAILED   AgentUpdateStatus = "FAILED"
)

type ApplicationProtocol ¶

type ApplicationProtocol string

const (
	ApplicationProtocol_http  ApplicationProtocol = "http"
	ApplicationProtocol_http2 ApplicationProtocol = "http2"
	ApplicationProtocol_grpc  ApplicationProtocol = "grpc"
)

type AssignPublicIP ¶

type AssignPublicIP string

const (
	AssignPublicIP_ENABLED  AssignPublicIP = "ENABLED"
	AssignPublicIP_DISABLED AssignPublicIP = "DISABLED"
)

type Attachment ¶

type Attachment struct {
	Details []*KeyValuePair `json:"details,omitempty"`
	ID      *string         `json:"id,omitempty"`
	Status  *string         `json:"status,omitempty"`
	Type    *string         `json:"type,omitempty"`
}

An object representing a container instance or task attachment.

func (in *Attachment) DeepCopy() *Attachment

func (in *Attachment) DeepCopyInto(out *Attachment)

type AttachmentStateChange ¶

type AttachmentStateChange struct {
	AttachmentARN *string `json:"attachmentARN,omitempty"`
	Status        *string `json:"status,omitempty"`
}

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

func (in *AttachmentStateChange) DeepCopy() *AttachmentStateChange

func (in *AttachmentStateChange) DeepCopyInto(out *AttachmentStateChange)

type Attribute ¶

type Attribute struct {
	Name     *string `json:"name,omitempty"`
	TargetID *string `json:"targetID,omitempty"`
	Value    *string `json:"value,omitempty"`
}

An attribute is a name-value pair that's associated with an Amazon ECS object. Use attributes 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.

func (in *Attribute) DeepCopy() *Attribute

func (in *Attribute) DeepCopyInto(out *Attribute)

type AutoScalingGroupProvider ¶

type AutoScalingGroupProvider struct {
	AutoScalingGroupARN *string `json:"autoScalingGroupARN,omitempty"`
}

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

func (in *AutoScalingGroupProvider) DeepCopy() *AutoScalingGroupProvider

func (in *AutoScalingGroupProvider) DeepCopyInto(out *AutoScalingGroupProvider)

type CPUArchitecture ¶

type CPUArchitecture string

const (
	CPUArchitecture_X86_64 CPUArchitecture = "X86_64"
	CPUArchitecture_ARM64  CPUArchitecture = "ARM64"
)

type CapacityProvider ¶

type CapacityProvider struct {
	CapacityProviderARN *string `json:"capacityProviderARN,omitempty"`
	Name                *string `json:"name,omitempty"`
	Tags                []*Tag  `json:"tags,omitempty"`
	UpdateStatusReason  *string `json:"updateStatusReason,omitempty"`
}

The details for a capacity provider.

func (in *CapacityProvider) DeepCopy() *CapacityProvider

func (in *CapacityProvider) DeepCopyInto(out *CapacityProvider)

type CapacityProviderField ¶

type CapacityProviderField string

const (
	CapacityProviderField_TAGS CapacityProviderField = "TAGS"
)

type CapacityProviderStatus ¶

type CapacityProviderStatus string

const (
	CapacityProviderStatus_ACTIVE   CapacityProviderStatus = "ACTIVE"
	CapacityProviderStatus_INACTIVE CapacityProviderStatus = "INACTIVE"
)

type CapacityProviderStrategyItem ¶

type CapacityProviderStrategyItem struct {
	Base             *int64  `json:"base,omitempty"`
	CapacityProvider *string `json:"capacityProvider,omitempty"`
	Weight           *int64  `json:"weight,omitempty"`
}

The details of a capacity provider strategy. A capacity provider strategy can be set when using the RunTask or CreateCluster APIs or as the default capacity provider strategy for a cluster with the CreateCluster API.

Only capacity providers that are already associated with a cluster and have an ACTIVE or UPDATING status can be used in a capacity provider strategy. The PutClusterCapacityProviders API is used to associate a capacity provider with a cluster.

If specifying a capacity provider that uses an Auto Scaling group, the capacity provider must already be created. New Auto Scaling group capacity providers can be created with the CreateCapacityProvider API operation.

To use a Fargate capacity provider, specify either the FARGATE or FARGATE_SPOT capacity providers. The Fargate capacity providers are available to all accounts and only need to be associated with a cluster to be used in a capacity provider strategy.

A capacity provider strategy may contain a maximum of 6 capacity providers.

func (in *CapacityProviderStrategyItem) DeepCopy() *CapacityProviderStrategyItem

func (in *CapacityProviderStrategyItem) DeepCopyInto(out *CapacityProviderStrategyItem)

type CapacityProviderUpdateStatus ¶

type CapacityProviderUpdateStatus string

const (
	CapacityProviderUpdateStatus_DELETE_IN_PROGRESS CapacityProviderUpdateStatus = "DELETE_IN_PROGRESS"
	CapacityProviderUpdateStatus_DELETE_COMPLETE    CapacityProviderUpdateStatus = "DELETE_COMPLETE"
	CapacityProviderUpdateStatus_DELETE_FAILED      CapacityProviderUpdateStatus = "DELETE_FAILED"
	CapacityProviderUpdateStatus_UPDATE_IN_PROGRESS CapacityProviderUpdateStatus = "UPDATE_IN_PROGRESS"
	CapacityProviderUpdateStatus_UPDATE_COMPLETE    CapacityProviderUpdateStatus = "UPDATE_COMPLETE"
	CapacityProviderUpdateStatus_UPDATE_FAILED      CapacityProviderUpdateStatus = "UPDATE_FAILED"
)

type Cluster ¶

type Cluster struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              ClusterSpec   `json:"spec,omitempty"`
	Status            ClusterStatus `json:"status,omitempty"`
}

Cluster is the Schema for the Clusters API +kubebuilder:object:root=true +kubebuilder:subresource:status +kubebuilder:printcolumn:name="ACTIVESERVICES",type=integer,priority=0,JSONPath=`.status.activeServicesCount` +kubebuilder:printcolumn:name="CLUSTER",type=string,priority=0,JSONPath=`.spec.name` +kubebuilder:printcolumn:name="PENDINGTASKS",type=integer,priority=0,JSONPath=`.status.pendingTasksCount` +kubebuilder:printcolumn:name="RUNNINGTASKS",type=integer,priority=0,JSONPath=`.status.runningTasksCount` +kubebuilder:printcolumn:name="STATUS",type=string,priority=0,JSONPath=`.status.status`

func (in *Cluster) DeepCopy() *Cluster

func (in *Cluster) DeepCopyInto(out *Cluster)

func (in *Cluster) DeepCopyObject() runtime.Object

type ClusterConfiguration ¶

type ClusterConfiguration struct {
	// The details of the execute command configuration.
	ExecuteCommandConfiguration *ExecuteCommandConfiguration `json:"executeCommandConfiguration,omitempty"`
}

The execute command configuration for the cluster.

func (in *ClusterConfiguration) DeepCopy() *ClusterConfiguration

func (in *ClusterConfiguration) DeepCopyInto(out *ClusterConfiguration)

type ClusterField ¶

type ClusterField string

const (
	ClusterField_ATTACHMENTS    ClusterField = "ATTACHMENTS"
	ClusterField_CONFIGURATIONS ClusterField = "CONFIGURATIONS"
	ClusterField_SETTINGS       ClusterField = "SETTINGS"
	ClusterField_STATISTICS     ClusterField = "STATISTICS"
	ClusterField_TAGS           ClusterField = "TAGS"
)

type ClusterList ¶

type ClusterList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Cluster `json:"items"`
}

ClusterList contains a list of Cluster +kubebuilder:object:root=true

func (in *ClusterList) DeepCopy() *ClusterList

func (in *ClusterList) DeepCopyInto(out *ClusterList)

func (in *ClusterList) DeepCopyObject() runtime.Object

type ClusterServiceConnectDefaults ¶

type ClusterServiceConnectDefaults struct {
	Namespace *string `json:"namespace,omitempty"`
}

Use this parameter to set a default Service Connect namespace. After you set a default Service Connect namespace, any new services with Service Connect turned on that are created in the cluster are added as client services in the namespace. This setting only applies to new services that set the enabled parameter to true in the ServiceConnectConfiguration. You can set the namespace of each service individually in the ServiceConnectConfiguration to override this default parameter.

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the Amazon Elastic Container Service Developer Guide.

func (in *ClusterServiceConnectDefaults) DeepCopy() *ClusterServiceConnectDefaults

func (in *ClusterServiceConnectDefaults) DeepCopyInto(out *ClusterServiceConnectDefaults)

type ClusterServiceConnectDefaultsRequest ¶

type ClusterServiceConnectDefaultsRequest struct {
	Namespace *string `json:"namespace,omitempty"`
}

Use this parameter to set a default Service Connect namespace. After you set a default Service Connect namespace, any new services with Service Connect turned on that are created in the cluster are added as client services in the namespace. This setting only applies to new services that set the enabled parameter to true in the ServiceConnectConfiguration. You can set the namespace of each service individually in the ServiceConnectConfiguration to override this default parameter.

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the Amazon Elastic Container Service Developer Guide.

func (in *ClusterServiceConnectDefaultsRequest) DeepCopy() *ClusterServiceConnectDefaultsRequest

func (in *ClusterServiceConnectDefaultsRequest) DeepCopyInto(out *ClusterServiceConnectDefaultsRequest)

type ClusterSetting ¶

type ClusterSetting struct {
	Name  *string `json:"name,omitempty"`
	Value *string `json:"value,omitempty"`
}

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

func (in *ClusterSetting) DeepCopy() *ClusterSetting

func (in *ClusterSetting) DeepCopyInto(out *ClusterSetting)

type ClusterSettingName ¶

type ClusterSettingName string

const (
	ClusterSettingName_containerInsights ClusterSettingName = "containerInsights"
)

type ClusterSpec ¶

type ClusterSpec struct {

	// The short name of one or more capacity providers to associate with the cluster.
	// A capacity provider must be associated with a cluster before it can be included
	// as part of the default capacity provider strategy of the cluster or used
	// in a capacity provider strategy when calling the CreateService (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html)
	// or RunTask (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html)
	// actions.
	//
	// If specifying a capacity provider that uses an Auto Scaling group, the capacity
	// provider must be created but not associated with another cluster. New Auto
	// Scaling group capacity providers can be created with the CreateCapacityProvider
	// (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateCapacityProvider.html)
	// API operation.
	//
	// To use a Fargate capacity provider, specify either the FARGATE or FARGATE_SPOT
	// capacity providers. The Fargate capacity providers are available to all accounts
	// and only need to be associated with a cluster to be used.
	//
	// The PutCapacityProvider (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutCapacityProvider.html)
	// API operation is used to update the list of available capacity providers
	// for a cluster after the cluster is created.
	CapacityProviders []*string `json:"capacityProviders,omitempty"`
	// The execute command configuration for the cluster.
	Configuration *ClusterConfiguration `json:"configuration,omitempty"`
	// The capacity provider strategy to set as the default for the cluster. After
	// a default capacity provider strategy is set for a cluster, when you call
	// the CreateService (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html)
	// or RunTask (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html)
	// APIs with no capacity provider strategy or launch type specified, the default
	// capacity provider strategy for the cluster is used.
	//
	// If a default capacity provider strategy isn't defined for a cluster when
	// it was created, it can be defined later with the PutClusterCapacityProviders
	// API operation.
	DefaultCapacityProviderStrategy []*CapacityProviderStrategyItem `json:"defaultCapacityProviderStrategy,omitempty"`
	// The name of your cluster. If you don't specify a name for your cluster, you
	// create a cluster that's named default. Up to 255 letters (uppercase and lowercase),
	// numbers, underscores, and hyphens are allowed.
	Name *string `json:"name,omitempty"`
	// Use this parameter to set a default Service Connect namespace. After you
	// set a default Service Connect namespace, any new services with Service Connect
	// turned on that are created in the cluster are added as client services in
	// the namespace. This setting only applies to new services that set the enabled
	// parameter to true in the ServiceConnectConfiguration. You can set the namespace
	// of each service individually in the ServiceConnectConfiguration to override
	// this default parameter.
	//
	// Tasks that run in a namespace can use short names to connect to services
	// in the namespace. Tasks can connect to services across all of the clusters
	// in the namespace. Tasks connect through a managed proxy container that collects
	// logs and metrics for increased visibility. Only the tasks that Amazon ECS
	// services create are supported with Service Connect. For more information,
	// see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	ServiceConnectDefaults *ClusterServiceConnectDefaultsRequest `json:"serviceConnectDefaults,omitempty"`
	// The setting to use when creating a cluster. This parameter is used to turn
	// on CloudWatch Container Insights for a cluster. If this value is specified,
	// it overrides the containerInsights value set with PutAccountSetting or PutAccountSettingDefault.
	Settings []*ClusterSetting `json:"settings,omitempty"`
	// 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. You define both.
	//
	// 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 Amazon Web
	//     Services 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 `json:"tags,omitempty"`
}

ClusterSpec defines the desired state of Cluster.

A regional grouping of one or more container instances where 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.

func (in *ClusterSpec) DeepCopy() *ClusterSpec

func (in *ClusterSpec) DeepCopyInto(out *ClusterSpec)

type ClusterStatus ¶

type ClusterStatus struct {
	// All CRs managed by ACK have a common `Status.ACKResourceMetadata` member
	// that is used to contain resource sync state, account ownership,
	// constructed ARN for the resource
	// +kubebuilder:validation:Optional
	ACKResourceMetadata *ackv1alpha1.ResourceMetadata `json:"ackResourceMetadata"`
	// All CRS managed by ACK have a common `Status.Conditions` member that
	// contains a collection of `ackv1alpha1.Condition` objects that describe
	// the various terminal states of the CR and its backend AWS service API
	// resource
	// +kubebuilder:validation:Optional
	Conditions []*ackv1alpha1.Condition `json:"conditions"`
	// The number of services that are running on the cluster in an ACTIVE state.
	// You can view these services with ListServices.
	// +kubebuilder:validation:Optional
	ActiveServicesCount *int64 `json:"activeServicesCount,omitempty"`
	// The resources attached to a cluster. When using a capacity provider with
	// a cluster, the capacity provider and associated resources are returned as
	// cluster attachments.
	// +kubebuilder:validation:Optional
	Attachments []*Attachment `json:"attachments,omitempty"`
	// The status of the capacity providers associated with the cluster. The following
	// are the states that are returned.
	//
	// UPDATE_IN_PROGRESS
	//
	// The available capacity providers for the cluster are updating.
	//
	// UPDATE_COMPLETE
	//
	// The capacity providers have successfully updated.
	//
	// UPDATE_FAILED
	//
	// The capacity provider updates failed.
	// +kubebuilder:validation:Optional
	AttachmentsStatus *string `json:"attachmentsStatus,omitempty"`
	// The number of tasks in the cluster that are in the PENDING state.
	// +kubebuilder:validation:Optional
	PendingTasksCount *int64 `json:"pendingTasksCount,omitempty"`
	// The number of container instances registered into the cluster. This includes
	// container instances in both ACTIVE and DRAINING status.
	// +kubebuilder:validation:Optional
	RegisteredContainerInstancesCount *int64 `json:"registeredContainerInstancesCount,omitempty"`
	// The number of tasks in the cluster that are in the RUNNING state.
	// +kubebuilder:validation:Optional
	RunningTasksCount *int64 `json:"runningTasksCount,omitempty"`
	// Additional information about your clusters that are separated by launch type.
	// They include the following:
	//
	//    * runningEC2TasksCount
	//
	//    * RunningFargateTasksCount
	//
	//    * pendingEC2TasksCount
	//
	//    * pendingFargateTasksCount
	//
	//    * activeEC2ServiceCount
	//
	//    * activeFargateServiceCount
	//
	//    * drainingEC2ServiceCount
	//
	//    * drainingFargateServiceCount
	// +kubebuilder:validation:Optional
	Statistics []*KeyValuePair `json:"statistics,omitempty"`
	// The status of the cluster. The following are the possible states that are
	// 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 that are associated with it and the resources
	// needed for the capacity provider are being created.
	//
	// DEPROVISIONING
	//
	// The cluster has capacity providers that are associated with it and the resources
	// needed for the capacity provider are being deleted.
	//
	// FAILED
	//
	// The cluster has capacity providers that are 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. We don't recommend that you rely on INACTIVE
	// clusters persisting.
	// +kubebuilder:validation:Optional
	Status *string `json:"status,omitempty"`
}

ClusterStatus defines the observed state of Cluster

func (in *ClusterStatus) DeepCopy() *ClusterStatus

func (in *ClusterStatus) DeepCopyInto(out *ClusterStatus)

type Cluster_SDK ¶

type Cluster_SDK struct {
	ActiveServicesCount *int64        `json:"activeServicesCount,omitempty"`
	Attachments         []*Attachment `json:"attachments,omitempty"`
	AttachmentsStatus   *string       `json:"attachmentsStatus,omitempty"`
	CapacityProviders   []*string     `json:"capacityProviders,omitempty"`
	ClusterARN          *string       `json:"clusterARN,omitempty"`
	ClusterName         *string       `json:"clusterName,omitempty"`
	// The execute command configuration for the cluster.
	Configuration                     *ClusterConfiguration           `json:"configuration,omitempty"`
	DefaultCapacityProviderStrategy   []*CapacityProviderStrategyItem `json:"defaultCapacityProviderStrategy,omitempty"`
	PendingTasksCount                 *int64                          `json:"pendingTasksCount,omitempty"`
	RegisteredContainerInstancesCount *int64                          `json:"registeredContainerInstancesCount,omitempty"`
	RunningTasksCount                 *int64                          `json:"runningTasksCount,omitempty"`
	// Use this parameter to set a default Service Connect namespace. After you
	// set a default Service Connect namespace, any new services with Service Connect
	// turned on that are created in the cluster are added as client services in
	// the namespace. This setting only applies to new services that set the enabled
	// parameter to true in the ServiceConnectConfiguration. You can set the namespace
	// of each service individually in the ServiceConnectConfiguration to override
	// this default parameter.
	//
	// Tasks that run in a namespace can use short names to connect to services
	// in the namespace. Tasks can connect to services across all of the clusters
	// in the namespace. Tasks connect through a managed proxy container that collects
	// logs and metrics for increased visibility. Only the tasks that Amazon ECS
	// services create are supported with Service Connect. For more information,
	// see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	ServiceConnectDefaults *ClusterServiceConnectDefaults `json:"serviceConnectDefaults,omitempty"`
	Settings               []*ClusterSetting              `json:"settings,omitempty"`
	Statistics             []*KeyValuePair                `json:"statistics,omitempty"`
	Status                 *string                        `json:"status,omitempty"`
	Tags                   []*Tag                         `json:"tags,omitempty"`
}

A regional grouping of one or more container instances where 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.

func (in *Cluster_SDK) DeepCopy() *Cluster_SDK

func (in *Cluster_SDK) DeepCopyInto(out *Cluster_SDK)

type Compatibility ¶

type Compatibility string

const (
	Compatibility_EC2      Compatibility = "EC2"
	Compatibility_FARGATE  Compatibility = "FARGATE"
	Compatibility_EXTERNAL Compatibility = "EXTERNAL"
)

type Connectivity ¶

type Connectivity string

const (
	Connectivity_CONNECTED    Connectivity = "CONNECTED"
	Connectivity_DISCONNECTED Connectivity = "DISCONNECTED"
)

type Container ¶

type Container struct {
	ContainerARN      *string `json:"containerARN,omitempty"`
	CPU               *string `json:"cpu,omitempty"`
	Image             *string `json:"image,omitempty"`
	ImageDigest       *string `json:"imageDigest,omitempty"`
	LastStatus        *string `json:"lastStatus,omitempty"`
	Memory            *string `json:"memory,omitempty"`
	MemoryReservation *string `json:"memoryReservation,omitempty"`
	Name              *string `json:"name,omitempty"`
	Reason            *string `json:"reason,omitempty"`
	RuntimeID         *string `json:"runtimeID,omitempty"`
	TaskARN           *string `json:"taskARN,omitempty"`
}

A Docker container that's part of a task.

func (in *Container) DeepCopy() *Container

func (in *Container) DeepCopyInto(out *Container)

type ContainerCondition ¶

type ContainerCondition string

const (
	ContainerCondition_START    ContainerCondition = "START"
	ContainerCondition_COMPLETE ContainerCondition = "COMPLETE"
	ContainerCondition_SUCCESS  ContainerCondition = "SUCCESS"
	ContainerCondition_HEALTHY  ContainerCondition = "HEALTHY"
)

type ContainerDefinition ¶

type ContainerDefinition struct {
	Command               []*string `json:"command,omitempty"`
	CPU                   *int64    `json:"cpu,omitempty"`
	CredentialSpecs       []*string `json:"credentialSpecs,omitempty"`
	DNSSearchDomains      []*string `json:"dnsSearchDomains,omitempty"`
	DNSServers            []*string `json:"dnsServers,omitempty"`
	DockerSecurityOptions []*string `json:"dockerSecurityOptions,omitempty"`
	EntryPoint            []*string `json:"entryPoint,omitempty"`
	Hostname              *string   `json:"hostname,omitempty"`
	Image                 *string   `json:"image,omitempty"`
	Links                 []*string `json:"links,omitempty"`
	Name                  *string   `json:"name,omitempty"`
	User                  *string   `json:"user,omitempty"`
	WorkingDirectory      *string   `json:"workingDirectory,omitempty"`
}

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

func (in *ContainerDefinition) DeepCopy() *ContainerDefinition

func (in *ContainerDefinition) DeepCopyInto(out *ContainerDefinition)

type ContainerDependency ¶

type ContainerDependency struct {
	ContainerName *string `json:"containerName,omitempty"`
}

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 use 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're 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 that use the Fargate launch type, the task or service requires the following platforms:

• Linux platform version 1.3.0 or later.

• Windows platform version 1.0.0 or later.

For more information about how to create a container dependency, see Container dependency (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/example_task_definitions.html#example_task_definition-containerdependency) in the Amazon Elastic Container Service Developer Guide.

func (in *ContainerDependency) DeepCopy() *ContainerDependency

func (in *ContainerDependency) DeepCopyInto(out *ContainerDependency)

type ContainerInstance ¶

type ContainerInstance struct {
	AgentConnected       *bool         `json:"agentConnected,omitempty"`
	Attachments          []*Attachment `json:"attachments,omitempty"`
	CapacityProviderName *string       `json:"capacityProviderName,omitempty"`
	ContainerInstanceARN *string       `json:"containerInstanceARN,omitempty"`
	EC2InstanceID        *string       `json:"ec2InstanceID,omitempty"`
	PendingTasksCount    *int64        `json:"pendingTasksCount,omitempty"`
	RunningTasksCount    *int64        `json:"runningTasksCount,omitempty"`
	Status               *string       `json:"status,omitempty"`
	StatusReason         *string       `json:"statusReason,omitempty"`
	Tags                 []*Tag        `json:"tags,omitempty"`
}

An Amazon EC2 or External instance that's running the Amazon ECS agent and has been registered with a cluster.

func (in *ContainerInstance) DeepCopy() *ContainerInstance

func (in *ContainerInstance) DeepCopyInto(out *ContainerInstance)

type ContainerInstanceField ¶

type ContainerInstanceField string

const (
	ContainerInstanceField_TAGS                      ContainerInstanceField = "TAGS"
	ContainerInstanceField_CONTAINER_INSTANCE_HEALTH ContainerInstanceField = "CONTAINER_INSTANCE_HEALTH"
)

type ContainerInstanceStatus ¶

type ContainerInstanceStatus string

const (
	ContainerInstanceStatus_ACTIVE              ContainerInstanceStatus = "ACTIVE"
	ContainerInstanceStatus_DRAINING            ContainerInstanceStatus = "DRAINING"
	ContainerInstanceStatus_REGISTERING         ContainerInstanceStatus = "REGISTERING"
	ContainerInstanceStatus_DEREGISTERING       ContainerInstanceStatus = "DEREGISTERING"
	ContainerInstanceStatus_REGISTRATION_FAILED ContainerInstanceStatus = "REGISTRATION_FAILED"
)

type ContainerOverride ¶

type ContainerOverride struct {
	Command []*string `json:"command,omitempty"`
	Name    *string   `json:"name,omitempty"`
}

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

You can use Secrets Manager or Amazon Web Services Systems Manager Parameter Store to store the sensitive data. For more information, see Retrieve secrets through environment variables (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/secrets-envvar.html) in the Amazon ECS Developer Guide.

func (in *ContainerOverride) DeepCopy() *ContainerOverride

func (in *ContainerOverride) DeepCopyInto(out *ContainerOverride)

type ContainerStateChange ¶

type ContainerStateChange struct {
	ContainerName *string `json:"containerName,omitempty"`
	ImageDigest   *string `json:"imageDigest,omitempty"`
	Reason        *string `json:"reason,omitempty"`
	RuntimeID     *string `json:"runtimeID,omitempty"`
	Status        *string `json:"status,omitempty"`
}

An object that represents a change in state for a container.

func (in *ContainerStateChange) DeepCopy() *ContainerStateChange

func (in *ContainerStateChange) DeepCopyInto(out *ContainerStateChange)

type Deployment ¶

type Deployment struct {
	CapacityProviderStrategy []*CapacityProviderStrategyItem `json:"capacityProviderStrategy,omitempty"`
	DesiredCount             *int64                          `json:"desiredCount,omitempty"`
	FailedTasks              *int64                          `json:"failedTasks,omitempty"`
	ID                       *string                         `json:"id,omitempty"`
	PendingCount             *int64                          `json:"pendingCount,omitempty"`
	PlatformFamily           *string                         `json:"platformFamily,omitempty"`
	PlatformVersion          *string                         `json:"platformVersion,omitempty"`
	RolloutStateReason       *string                         `json:"rolloutStateReason,omitempty"`
	RunningCount             *int64                          `json:"runningCount,omitempty"`
	Status                   *string                         `json:"status,omitempty"`
	TaskDefinition           *string                         `json:"taskDefinition,omitempty"`
}

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

func (in *Deployment) DeepCopy() *Deployment

func (in *Deployment) DeepCopyInto(out *Deployment)

type DeploymentAlarms ¶

type DeploymentAlarms struct {
	AlarmNames []*string `json:"alarmNames,omitempty"`
	Enable     *bool     `json:"enable,omitempty"`
	Rollback   *bool     `json:"rollback,omitempty"`
}

One of the methods which provide a way for you to quickly identify when a deployment has failed, and then to optionally roll back the failure to the last working deployment.

When the alarms are generated, Amazon ECS sets the service deployment to failed. Set the rollback parameter to have Amazon ECS to roll back your service to the last completed deployment after a failure.

You can only use the DeploymentAlarms method to detect failures when the DeploymentController is set to ECS (rolling update).

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 .

func (in *DeploymentAlarms) DeepCopy() *DeploymentAlarms

func (in *DeploymentAlarms) DeepCopyInto(out *DeploymentAlarms)

type DeploymentCircuitBreaker ¶

type DeploymentCircuitBreaker struct {
	Enable   *bool `json:"enable,omitempty"`
	Rollback *bool `json:"rollback,omitempty"`
}

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 it is turned on, a service deployment will transition to a failed state and stop launching new tasks. You can also configure 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.

For more information about API failure reasons, see API failure reasons (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/api_failures_messages.html) in the Amazon Elastic Container Service Developer Guide.

func (in *DeploymentCircuitBreaker) DeepCopy() *DeploymentCircuitBreaker

func (in *DeploymentCircuitBreaker) DeepCopyInto(out *DeploymentCircuitBreaker)

type DeploymentControllerType ¶

type DeploymentControllerType string

const (
	DeploymentControllerType_ECS         DeploymentControllerType = "ECS"
	DeploymentControllerType_CODE_DEPLOY DeploymentControllerType = "CODE_DEPLOY"
	DeploymentControllerType_EXTERNAL    DeploymentControllerType = "EXTERNAL"
)

type DeploymentRolloutState ¶

type DeploymentRolloutState string

const (
	DeploymentRolloutState_COMPLETED   DeploymentRolloutState = "COMPLETED"
	DeploymentRolloutState_FAILED      DeploymentRolloutState = "FAILED"
	DeploymentRolloutState_IN_PROGRESS DeploymentRolloutState = "IN_PROGRESS"
)

type DesiredStatus ¶

type DesiredStatus string

const (
	DesiredStatus_RUNNING DesiredStatus = "RUNNING"
	DesiredStatus_PENDING DesiredStatus = "PENDING"
	DesiredStatus_STOPPED DesiredStatus = "STOPPED"
)

type Device ¶

type Device struct {
	ContainerPath *string `json:"containerPath,omitempty"`
	HostPath      *string `json:"hostPath,omitempty"`
}

An object representing a container instance host device.

func (in *Device) DeepCopy() *Device

func (in *Device) DeepCopyInto(out *Device)

type DeviceCgroupPermission ¶

type DeviceCgroupPermission string

const (
	DeviceCgroupPermission_read  DeviceCgroupPermission = "read"
	DeviceCgroupPermission_write DeviceCgroupPermission = "write"
	DeviceCgroupPermission_mknod DeviceCgroupPermission = "mknod"
)

type DockerVolumeConfiguration ¶

type DockerVolumeConfiguration struct {
	Driver *string `json:"driver,omitempty"`
}

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

func (in *DockerVolumeConfiguration) DeepCopy() *DockerVolumeConfiguration

func (in *DockerVolumeConfiguration) DeepCopyInto(out *DockerVolumeConfiguration)

type EBSResourceType ¶

type EBSResourceType string

const (
	EBSResourceType_volume EBSResourceType = "volume"
)

type EBSTagSpecification ¶

type EBSTagSpecification struct {
	Tags []*Tag `json:"tags,omitempty"`
}

The tag specifications of an Amazon EBS volume.

func (in *EBSTagSpecification) DeepCopy() *EBSTagSpecification

func (in *EBSTagSpecification) DeepCopyInto(out *EBSTagSpecification)

type EFSAuthorizationConfig ¶

type EFSAuthorizationConfig struct {
	AccessPointID *string `json:"accessPointID,omitempty"`
}

The authorization configuration details for the Amazon EFS file system.

func (in *EFSAuthorizationConfig) DeepCopy() *EFSAuthorizationConfig

func (in *EFSAuthorizationConfig) DeepCopyInto(out *EFSAuthorizationConfig)

type EFSAuthorizationConfigIAM ¶

type EFSAuthorizationConfigIAM string

const (
	EFSAuthorizationConfigIAM_ENABLED  EFSAuthorizationConfigIAM = "ENABLED"
	EFSAuthorizationConfigIAM_DISABLED EFSAuthorizationConfigIAM = "DISABLED"
)

type EFSTransitEncryption ¶

type EFSTransitEncryption string

const (
	EFSTransitEncryption_ENABLED  EFSTransitEncryption = "ENABLED"
	EFSTransitEncryption_DISABLED EFSTransitEncryption = "DISABLED"
)

type EFSVolumeConfiguration ¶

type EFSVolumeConfiguration struct {
	FileSystemID  *string `json:"fileSystemID,omitempty"`
	RootDirectory *string `json:"rootDirectory,omitempty"`
}

This parameter is specified when you're 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.

func (in *EFSVolumeConfiguration) DeepCopy() *EFSVolumeConfiguration

func (in *EFSVolumeConfiguration) DeepCopyInto(out *EFSVolumeConfiguration)

type EnvironmentFile ¶

type EnvironmentFile struct {
	Value *string `json:"value,omitempty"`
}

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.

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're processed from the top down. We recommend that you 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.

You must use the following platforms for the Fargate launch type:

• Linux platform version 1.4.0 or later.

• Windows platform version 1.0.0 or later.

Consider the following when using the Fargate launch type:

• The file is handled like a native Docker env-file.

• There is no support for shell escape handling.

• The container entry point interperts the VARIABLE values.

func (in *EnvironmentFile) DeepCopy() *EnvironmentFile

func (in *EnvironmentFile) DeepCopyInto(out *EnvironmentFile)

type EnvironmentFileType ¶

type EnvironmentFileType string

const (
	EnvironmentFileType_s3 EnvironmentFileType = "s3"
)

type EphemeralStorage ¶

type EphemeralStorage struct {
	SizeInGiB *int64 `json:"sizeInGiB,omitempty"`
}

The amount of ephemeral storage to allocate for the task. This parameter is used to expand the total amount of ephemeral storage available, beyond the default amount, for tasks hosted on Fargate. For more information, see Using data volumes in tasks (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html) in the Amazon ECS Developer Guide;.

For tasks using the Fargate launch type, the task requires the following platforms:

• Linux platform version 1.4.0 or later.

• Windows platform version 1.0.0 or later.

func (in *EphemeralStorage) DeepCopy() *EphemeralStorage

func (in *EphemeralStorage) DeepCopyInto(out *EphemeralStorage)

type ExecuteCommandConfiguration ¶

type ExecuteCommandConfiguration struct {
	KMSKeyID *string `json:"kmsKeyID,omitempty"`
	// The log configuration for the results of the execute command actions. The
	// logs can be sent to CloudWatch Logs or an Amazon S3 bucket.
	LogConfiguration *ExecuteCommandLogConfiguration `json:"logConfiguration,omitempty"`
	Logging          *string                         `json:"logging,omitempty"`
}

The details of the execute command configuration.

func (in *ExecuteCommandConfiguration) DeepCopy() *ExecuteCommandConfiguration

func (in *ExecuteCommandConfiguration) DeepCopyInto(out *ExecuteCommandConfiguration)

type ExecuteCommandLogConfiguration ¶

type ExecuteCommandLogConfiguration struct {
	CloudWatchEncryptionEnabled *bool   `json:"cloudWatchEncryptionEnabled,omitempty"`
	CloudWatchLogGroupName      *string `json:"cloudWatchLogGroupName,omitempty"`
	S3BucketName                *string `json:"s3BucketName,omitempty"`
	S3EncryptionEnabled         *bool   `json:"s3EncryptionEnabled,omitempty"`
	S3KeyPrefix                 *string `json:"s3KeyPrefix,omitempty"`
}

The log configuration for the results of the execute command actions. The logs can be sent to CloudWatch Logs or an Amazon S3 bucket.

func (in *ExecuteCommandLogConfiguration) DeepCopy() *ExecuteCommandLogConfiguration

func (in *ExecuteCommandLogConfiguration) DeepCopyInto(out *ExecuteCommandLogConfiguration)

type ExecuteCommandLogging ¶

type ExecuteCommandLogging string

const (
	ExecuteCommandLogging_NONE     ExecuteCommandLogging = "NONE"
	ExecuteCommandLogging_DEFAULT  ExecuteCommandLogging = "DEFAULT"
	ExecuteCommandLogging_OVERRIDE ExecuteCommandLogging = "OVERRIDE"
)

type FSxWindowsFileServerAuthorizationConfig ¶

type FSxWindowsFileServerAuthorizationConfig struct {
	CredentialsParameter *string `json:"credentialsParameter,omitempty"`
	Domain               *string `json:"domain,omitempty"`
}

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 ECS 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.

func (in *FSxWindowsFileServerAuthorizationConfig) DeepCopy() *FSxWindowsFileServerAuthorizationConfig

func (in *FSxWindowsFileServerAuthorizationConfig) DeepCopyInto(out *FSxWindowsFileServerAuthorizationConfig)

type FSxWindowsFileServerVolumeConfiguration ¶

type FSxWindowsFileServerVolumeConfiguration struct {
	FileSystemID  *string `json:"fileSystemID,omitempty"`
	RootDirectory *string `json:"rootDirectory,omitempty"`
}

This parameter is specified when you're 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.

func (in *FSxWindowsFileServerVolumeConfiguration) DeepCopy() *FSxWindowsFileServerVolumeConfiguration

func (in *FSxWindowsFileServerVolumeConfiguration) DeepCopyInto(out *FSxWindowsFileServerVolumeConfiguration)

type Failure ¶

type Failure struct {
	ARN    *string `json:"arn,omitempty"`
	Detail *string `json:"detail,omitempty"`
	Reason *string `json:"reason,omitempty"`
}

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.

func (in *Failure) DeepCopy() *Failure

func (in *Failure) DeepCopyInto(out *Failure)

type FirelensConfigurationType ¶

type FirelensConfigurationType string

const (
	FirelensConfigurationType_fluentd   FirelensConfigurationType = "fluentd"
	FirelensConfigurationType_fluentbit FirelensConfigurationType = "fluentbit"
)

type HealthCheck ¶

type HealthCheck struct {
	Command []*string `json:"command,omitempty"`
}

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). This configuration maps to the HEALTHCHECK parameter of docker run (https://docs.docker.com/engine/reference/run/).

The Amazon ECS container agent only monitors and reports on the health checks specified in the task definition. Amazon ECS does not monitor Docker health checks that are embedded in a container image 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.

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 health check is designed to make sure that your containers survive agent restarts, upgrades, or temporary unavailability.

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, there's no container health check defined, or Amazon ECS doesn't have the health status of the container.

The following describes the possible healthStatus values based on the container health checker status of essential containers in the task with the following priority order (high to low):

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

• UNKNOWN-Any essential container running within the task is in an UNKNOWN state and no other essential containers have an UNHEALTHY state.

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

Consider the following task health example with 2 containers.

• If Container1 is UNHEALTHY and Container2 is UNKNOWN, the task health is UNHEALTHY.

• If Container1 is UNHEALTHY and Container2 is HEALTHY, the task health is UNHEALTHY.

• If Container1 is HEALTHY and Container2 is UNKNOWN, the task health is UNKNOWN.

• If Container1 is HEALTHY and Container2 is HEALTHY, the task health is HEALTHY.

Consider the following task health example with 3 containers.

• If Container1 is UNHEALTHY and Container2 is UNKNOWN, and Container3 is UNKNOWN, the task health is UNHEALTHY.

• If Container1 is UNHEALTHY and Container2 is UNKNOWN, and Container3 is HEALTHY, the task health is UNHEALTHY.

• If Container1 is UNHEALTHY and Container2 is HEALTHY, and Container3 is HEALTHY, the task health is UNHEALTHY.

• If Container1 is HEALTHY and Container2 is UNKNOWN, and Container3 is HEALTHY, the task health is UNKNOWN.

• If Container1 is HEALTHY and Container2 is UNKNOWN, and Container3 is UNKNOWN, the task health is UNKNOWN.

• If Container1 is HEALTHY and Container2 is HEALTHY, and Container3 is HEALTHY, the task health is HEALTHY.

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:

• When the Amazon ECS agent cannot connect to the Amazon ECS service, the service reports the container as UNHEALTHY.

• The health check statuses are the "last heard from" response from the Amazon ECS agent. There are no assumptions made about the status of the container health checks.

• 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're using platform version 1.1.0 or greater. For more information, see Fargate platform versions (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html).

• Container health checks aren't supported for tasks that are part of a service that's configured to use a Classic Load Balancer.

func (in *HealthCheck) DeepCopy() *HealthCheck

func (in *HealthCheck) DeepCopyInto(out *HealthCheck)

type HealthStatus ¶

type HealthStatus string

const (
	HealthStatus_HEALTHY   HealthStatus = "HEALTHY"
	HealthStatus_UNHEALTHY HealthStatus = "UNHEALTHY"
	HealthStatus_UNKNOWN   HealthStatus = "UNKNOWN"
)

type HostEntry ¶

type HostEntry struct {
	Hostname  *string `json:"hostname,omitempty"`
	IPAddress *string `json:"ipAddress,omitempty"`
}

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

func (in *HostEntry) DeepCopy() *HostEntry

func (in *HostEntry) DeepCopyInto(out *HostEntry)

type HostVolumeProperties ¶

type HostVolumeProperties struct {
	SourcePath *string `json:"sourcePath,omitempty"`
}

Details on a container instance bind mount host volume.

func (in *HostVolumeProperties) DeepCopy() *HostVolumeProperties

func (in *HostVolumeProperties) DeepCopyInto(out *HostVolumeProperties)

type IPCMode ¶

type IPCMode string

const (
	IPCMode_host IPCMode = "host"
	IPCMode_task IPCMode = "task"
	IPCMode_none IPCMode = "none"
)

type InferenceAccelerator ¶

type InferenceAccelerator struct {
	DeviceName *string `json:"deviceName,omitempty"`
	DeviceType *string `json:"deviceType,omitempty"`
}

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

func (in *InferenceAccelerator) DeepCopy() *InferenceAccelerator

func (in *InferenceAccelerator) DeepCopyInto(out *InferenceAccelerator)

type InferenceAcceleratorOverride ¶

type InferenceAcceleratorOverride struct {
	DeviceName *string `json:"deviceName,omitempty"`
	DeviceType *string `json:"deviceType,omitempty"`
}

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-inference.html) in the Amazon Elastic Container Service Developer Guide.

func (in *InferenceAcceleratorOverride) DeepCopy() *InferenceAcceleratorOverride

func (in *InferenceAcceleratorOverride) DeepCopyInto(out *InferenceAcceleratorOverride)

type InstanceHealthCheckState ¶

type InstanceHealthCheckState string

const (
	InstanceHealthCheckState_OK                InstanceHealthCheckState = "OK"
	InstanceHealthCheckState_IMPAIRED          InstanceHealthCheckState = "IMPAIRED"
	InstanceHealthCheckState_INSUFFICIENT_DATA InstanceHealthCheckState = "INSUFFICIENT_DATA"
	InstanceHealthCheckState_INITIALIZING      InstanceHealthCheckState = "INITIALIZING"
)

type InstanceHealthCheckType ¶

type InstanceHealthCheckType string

const (
	InstanceHealthCheckType_CONTAINER_RUNTIME InstanceHealthCheckType = "CONTAINER_RUNTIME"
)

type KernelCapabilities ¶

type KernelCapabilities struct {
	Add  []*string `json:"add,omitempty"`
	Drop []*string `json:"drop,omitempty"`
}

The Linux capabilities for the container that are added to or dropped from the default configuration provided by Docker. For more information about 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 about these Linux capabilities, see the capabilities(7) (http://man7.org/linux/man-pages/man7/capabilities.7.html) Linux manual page.

func (in *KernelCapabilities) DeepCopy() *KernelCapabilities

func (in *KernelCapabilities) DeepCopyInto(out *KernelCapabilities)

type KeyValuePair ¶

type KeyValuePair struct {
	Name  *string `json:"name,omitempty"`
	Value *string `json:"value,omitempty"`
}

A key-value pair object.

func (in *KeyValuePair) DeepCopy() *KeyValuePair

func (in *KeyValuePair) DeepCopyInto(out *KeyValuePair)

type LaunchType ¶

type LaunchType string

const (
	LaunchType_EC2      LaunchType = "EC2"
	LaunchType_FARGATE  LaunchType = "FARGATE"
	LaunchType_EXTERNAL LaunchType = "EXTERNAL"
)

type LoadBalancer ¶

type LoadBalancer struct {
	ContainerName    *string `json:"containerName,omitempty"`
	LoadBalancerName *string `json:"loadBalancerName,omitempty"`
	TargetGroupARN   *string `json:"targetGroupARN,omitempty"`
}

The load balancer configuration to use with a service or task set.

When you add, update, or remove a load balancer configuration, Amazon ECS starts a new deployment with the updated Elastic Load Balancing configuration. This causes tasks to register to and deregister from load balancers.

We recommend that you verify this on a test environment before you update the Elastic Load Balancing configuration.

A service-linked role is required for services that use multiple target groups. For more information, see Using service-linked roles (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html) in the Amazon Elastic Container Service Developer Guide.

func (in *LoadBalancer) DeepCopy() *LoadBalancer

func (in *LoadBalancer) DeepCopyInto(out *LoadBalancer)

type LogDriver ¶

type LogDriver string

const (
	LogDriver_json_file   LogDriver = "json-file"
	LogDriver_syslog      LogDriver = "syslog"
	LogDriver_journald    LogDriver = "journald"
	LogDriver_gelf        LogDriver = "gelf"
	LogDriver_fluentd     LogDriver = "fluentd"
	LogDriver_awslogs     LogDriver = "awslogs"
	LogDriver_splunk      LogDriver = "splunk"
	LogDriver_awsfirelens LogDriver = "awsfirelens"
)

type ManagedAgent ¶

type ManagedAgent struct {
	LastStatus *string `json:"lastStatus,omitempty"`
	Reason     *string `json:"reason,omitempty"`
}

Details about the managed agent status for the container.

func (in *ManagedAgent) DeepCopy() *ManagedAgent

func (in *ManagedAgent) DeepCopyInto(out *ManagedAgent)

type ManagedAgentName ¶

type ManagedAgentName string

const (
	ManagedAgentName_ExecuteCommandAgent ManagedAgentName = "ExecuteCommandAgent"
)

type ManagedAgentStateChange ¶

type ManagedAgentStateChange struct {
	ContainerName *string `json:"containerName,omitempty"`
	Reason        *string `json:"reason,omitempty"`
	Status        *string `json:"status,omitempty"`
}

An object representing a change in state for a managed agent.

func (in *ManagedAgentStateChange) DeepCopy() *ManagedAgentStateChange

func (in *ManagedAgentStateChange) DeepCopyInto(out *ManagedAgentStateChange)

type ManagedDraining ¶

type ManagedDraining string

const (
	ManagedDraining_ENABLED  ManagedDraining = "ENABLED"
	ManagedDraining_DISABLED ManagedDraining = "DISABLED"
)

type ManagedScalingStatus ¶

type ManagedScalingStatus string

const (
	ManagedScalingStatus_ENABLED  ManagedScalingStatus = "ENABLED"
	ManagedScalingStatus_DISABLED ManagedScalingStatus = "DISABLED"
)

type ManagedTerminationProtection ¶

type ManagedTerminationProtection string

const (
	ManagedTerminationProtection_ENABLED  ManagedTerminationProtection = "ENABLED"
	ManagedTerminationProtection_DISABLED ManagedTerminationProtection = "DISABLED"
)

type MountPoint ¶

type MountPoint struct {
	ContainerPath *string `json:"containerPath,omitempty"`
	SourceVolume  *string `json:"sourceVolume,omitempty"`
}

The details for a volume mount point that's used in a container definition.

func (in *MountPoint) DeepCopy() *MountPoint

func (in *MountPoint) DeepCopyInto(out *MountPoint)

type NetworkBinding ¶

type NetworkBinding struct {
	BindIP             *string `json:"bindIP,omitempty"`
	ContainerPortRange *string `json:"containerPortRange,omitempty"`
	HostPortRange      *string `json:"hostPortRange,omitempty"`
}

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.

func (in *NetworkBinding) DeepCopy() *NetworkBinding

func (in *NetworkBinding) DeepCopyInto(out *NetworkBinding)

type NetworkInterface ¶

type NetworkInterface struct {
	AttachmentID       *string `json:"attachmentID,omitempty"`
	IPv6Address        *string `json:"ipv6Address,omitempty"`
	PrivateIPv4Address *string `json:"privateIPv4Address,omitempty"`
}

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

func (in *NetworkInterface) DeepCopy() *NetworkInterface

func (in *NetworkInterface) DeepCopyInto(out *NetworkInterface)

type NetworkMode ¶

type NetworkMode string

const (
	NetworkMode_bridge NetworkMode = "bridge"
	NetworkMode_host   NetworkMode = "host"
	NetworkMode_awsvpc NetworkMode = "awsvpc"
	NetworkMode_none   NetworkMode = "none"
)

type OSFamily ¶

type OSFamily string

const (
	OSFamily_WINDOWS_SERVER_2019_FULL OSFamily = "WINDOWS_SERVER_2019_FULL"
	OSFamily_WINDOWS_SERVER_2019_CORE OSFamily = "WINDOWS_SERVER_2019_CORE"
	OSFamily_WINDOWS_SERVER_2016_FULL OSFamily = "WINDOWS_SERVER_2016_FULL"
	OSFamily_WINDOWS_SERVER_2004_CORE OSFamily = "WINDOWS_SERVER_2004_CORE"
	OSFamily_WINDOWS_SERVER_2022_CORE OSFamily = "WINDOWS_SERVER_2022_CORE"
	OSFamily_WINDOWS_SERVER_2022_FULL OSFamily = "WINDOWS_SERVER_2022_FULL"
	OSFamily_WINDOWS_SERVER_20H2_CORE OSFamily = "WINDOWS_SERVER_20H2_CORE"
	OSFamily_LINUX                    OSFamily = "LINUX"
)

type PIDMode ¶

type PIDMode string

const (
	PIDMode_host PIDMode = "host"
	PIDMode_task PIDMode = "task"
)

type PlacementConstraint ¶

type PlacementConstraint struct {
	Expression *string `json:"expression,omitempty"`
}

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're using the Fargate launch type, task placement constraints aren't supported.

func (in *PlacementConstraint) DeepCopy() *PlacementConstraint

func (in *PlacementConstraint) DeepCopyInto(out *PlacementConstraint)

type PlacementConstraintType ¶

type PlacementConstraintType string

const (
	PlacementConstraintType_distinctInstance PlacementConstraintType = "distinctInstance"
	PlacementConstraintType_memberOf         PlacementConstraintType = "memberOf"
)

type PlacementStrategy ¶

type PlacementStrategy struct {
	Field *string `json:"field,omitempty"`
}

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.

func (in *PlacementStrategy) DeepCopy() *PlacementStrategy

func (in *PlacementStrategy) DeepCopyInto(out *PlacementStrategy)

type PlacementStrategyType ¶

type PlacementStrategyType string

const (
	PlacementStrategyType_random  PlacementStrategyType = "random"
	PlacementStrategyType_spread  PlacementStrategyType = "spread"
	PlacementStrategyType_binpack PlacementStrategyType = "binpack"
)

type PlatformDevice ¶

type PlatformDevice struct {
	ID *string `json:"id,omitempty"`
}

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

func (in *PlatformDevice) DeepCopy() *PlatformDevice

func (in *PlatformDevice) DeepCopyInto(out *PlatformDevice)

type PlatformDeviceType ¶

type PlatformDeviceType string

const (
	PlatformDeviceType_GPU PlatformDeviceType = "GPU"
)

type PortMapping ¶

type PortMapping struct {
	ContainerPortRange *string `json:"containerPortRange,omitempty"`
	Name               *string `json:"name,omitempty"`
}

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 use containers in a task with the awsvpc or host network mode, specify the exposed ports using containerPort. The hostPort can be left blank or it must be the same value as the containerPort.

Most fields of this parameter (containerPort, hostPort, protocol) 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/commandline/run/). If the network mode of a task definition is set to host, host ports must either be undefined or match the container port in the port mapping.

You can't expose the same container port for multiple protocols. If you attempt this, an error is returned.

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.

func (in *PortMapping) DeepCopy() *PortMapping

func (in *PortMapping) DeepCopyInto(out *PortMapping)

type PropagateTags ¶

type PropagateTags string

const (
	PropagateTags_TASK_DEFINITION PropagateTags = "TASK_DEFINITION"
	PropagateTags_SERVICE         PropagateTags = "SERVICE"
	PropagateTags_NONE            PropagateTags = "NONE"
)

type ProtectedTask ¶

type ProtectedTask struct {
	ProtectionEnabled *bool   `json:"protectionEnabled,omitempty"`
	TaskARN           *string `json:"taskARN,omitempty"`
}

An object representing the protection status details for a task. You can set the protection status with the UpdateTaskProtection API and get the status of tasks with the GetTaskProtection API.

func (in *ProtectedTask) DeepCopy() *ProtectedTask

func (in *ProtectedTask) DeepCopyInto(out *ProtectedTask)

type ProxyConfiguration ¶

type ProxyConfiguration struct {
	ContainerName *string `json:"containerName,omitempty"`
}

The configuration details for the App Mesh proxy.

For tasks that use 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 use 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)

func (in *ProxyConfiguration) DeepCopy() *ProxyConfiguration

func (in *ProxyConfiguration) DeepCopyInto(out *ProxyConfiguration)

type ProxyConfigurationType ¶

type ProxyConfigurationType string

const (
	ProxyConfigurationType_APPMESH ProxyConfigurationType = "APPMESH"
)

type RepositoryCredentials ¶

type RepositoryCredentials struct {
	CredentialsParameter *string `json:"credentialsParameter,omitempty"`
}

The repository credentials for private registry authentication.

func (in *RepositoryCredentials) DeepCopy() *RepositoryCredentials

func (in *RepositoryCredentials) DeepCopyInto(out *RepositoryCredentials)

type Resource ¶

type Resource struct {
	IntegerValue   *int64    `json:"integerValue,omitempty"`
	Name           *string   `json:"name,omitempty"`
	StringSetValue []*string `json:"stringSetValue,omitempty"`
	Type           *string   `json:"type_,omitempty"`
}

Describes the resources available for a container instance.

func (in *Resource) DeepCopy() *Resource

func (in *Resource) DeepCopyInto(out *Resource)

type ResourceRequirement ¶

type ResourceRequirement struct {
	Value *string `json:"value,omitempty"`
}

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-inference.html) in the Amazon Elastic Container Service Developer Guide

func (in *ResourceRequirement) DeepCopy() *ResourceRequirement

func (in *ResourceRequirement) DeepCopyInto(out *ResourceRequirement)

type ResourceType ¶

type ResourceType string

const (
	ResourceType_GPU                  ResourceType = "GPU"
	ResourceType_InferenceAccelerator ResourceType = "InferenceAccelerator"
)

type ScaleUnit ¶

type ScaleUnit string

const (
	ScaleUnit_PERCENT ScaleUnit = "PERCENT"
)

type SchedulingStrategy ¶

type SchedulingStrategy string

const (
	SchedulingStrategy_REPLICA SchedulingStrategy = "REPLICA"
	SchedulingStrategy_DAEMON  SchedulingStrategy = "DAEMON"
)

type Scope ¶

type Scope string

const (
	Scope_task   Scope = "task"
	Scope_shared Scope = "shared"
)

type Secret ¶

type Secret struct {
	Name      *string `json:"name,omitempty"`
	ValueFrom *string `json:"valueFrom,omitempty"`
}

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.

func (in *Secret) DeepCopy() *Secret

func (in *Secret) DeepCopyInto(out *Secret)

type Service ¶

type Service struct {
	CapacityProviderStrategy []*CapacityProviderStrategyItem `json:"capacityProviderStrategy,omitempty"`
	ClusterARN               *string                         `json:"clusterARN,omitempty"`
	CreatedBy                *string                         `json:"createdBy,omitempty"`
	DesiredCount             *int64                          `json:"desiredCount,omitempty"`
	EnableECSManagedTags     *bool                           `json:"enableECSManagedTags,omitempty"`
	EnableExecuteCommand     *bool                           `json:"enableExecuteCommand,omitempty"`
	PendingCount             *int64                          `json:"pendingCount,omitempty"`
	PlatformFamily           *string                         `json:"platformFamily,omitempty"`
	PlatformVersion          *string                         `json:"platformVersion,omitempty"`
	RoleARN                  *string                         `json:"roleARN,omitempty"`
	RunningCount             *int64                          `json:"runningCount,omitempty"`
	ServiceARN               *string                         `json:"serviceARN,omitempty"`
	ServiceName              *string                         `json:"serviceName,omitempty"`
	Status                   *string                         `json:"status,omitempty"`
	Tags                     []*Tag                          `json:"tags,omitempty"`
	TaskDefinition           *string                         `json:"taskDefinition,omitempty"`
}

Details on a service within a cluster.

func (in *Service) DeepCopy() *Service

func (in *Service) DeepCopyInto(out *Service)

type ServiceConnecTTLSCertificateAuthority ¶

type ServiceConnecTTLSCertificateAuthority struct {
	AWSPcaAuthorityARN *string `json:"awsPcaAuthorityARN,omitempty"`
}

An object that represents the Amazon Web Services Private Certificate Authority certificate.

func (in *ServiceConnecTTLSCertificateAuthority) DeepCopy() *ServiceConnecTTLSCertificateAuthority

func (in *ServiceConnecTTLSCertificateAuthority) DeepCopyInto(out *ServiceConnecTTLSCertificateAuthority)

type ServiceConnecTTLSConfiguration ¶

type ServiceConnecTTLSConfiguration struct {
	KMSKey  *string `json:"kmsKey,omitempty"`
	RoleARN *string `json:"roleARN,omitempty"`
}

An object that represents the configuration for Service Connect TLS.

func (in *ServiceConnecTTLSConfiguration) DeepCopy() *ServiceConnecTTLSConfiguration

func (in *ServiceConnecTTLSConfiguration) DeepCopyInto(out *ServiceConnecTTLSConfiguration)

type ServiceConnectClientAlias ¶

type ServiceConnectClientAlias struct {
	DNSName *string `json:"dnsName,omitempty"`
}

Each alias ("endpoint") is a fully-qualified name and port number that other tasks ("clients") can use to connect to this service.

Each name and port mapping must be unique within the namespace.

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the Amazon Elastic Container Service Developer Guide.

func (in *ServiceConnectClientAlias) DeepCopy() *ServiceConnectClientAlias

func (in *ServiceConnectClientAlias) DeepCopyInto(out *ServiceConnectClientAlias)

type ServiceConnectConfiguration ¶

type ServiceConnectConfiguration struct {
	Enabled   *bool   `json:"enabled,omitempty"`
	Namespace *string `json:"namespace,omitempty"`
}

The Service Connect configuration of your Amazon ECS service. The configuration for this service to discover and connect to services, and be discovered by, and connected from, other services within a namespace.

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the Amazon Elastic Container Service Developer Guide.

func (in *ServiceConnectConfiguration) DeepCopy() *ServiceConnectConfiguration

func (in *ServiceConnectConfiguration) DeepCopyInto(out *ServiceConnectConfiguration)

type ServiceConnectService ¶

type ServiceConnectService struct {
	DiscoveryName *string `json:"discoveryName,omitempty"`
	PortName      *string `json:"portName,omitempty"`
}

The Service Connect service object configuration. For more information, see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the Amazon Elastic Container Service Developer Guide.

func (in *ServiceConnectService) DeepCopy() *ServiceConnectService

func (in *ServiceConnectService) DeepCopyInto(out *ServiceConnectService)

type ServiceConnectServiceResource ¶

type ServiceConnectServiceResource struct {
	DiscoveryARN  *string `json:"discoveryARN,omitempty"`
	DiscoveryName *string `json:"discoveryName,omitempty"`
}

The Service Connect resource. Each configuration maps a discovery name to a Cloud Map service name. The data is stored in Cloud Map as part of the Service Connect configuration for each discovery name of this Amazon ECS service.

A task can resolve the dnsName for each of the clientAliases of a service. However a task can't resolve the discovery names. If you want to connect to a service, refer to the ServiceConnectConfiguration of that service for the list of clientAliases that you can use.

func (in *ServiceConnectServiceResource) DeepCopy() *ServiceConnectServiceResource

func (in *ServiceConnectServiceResource) DeepCopyInto(out *ServiceConnectServiceResource)

type ServiceEvent ¶

type ServiceEvent struct {
	ID      *string `json:"id,omitempty"`
	Message *string `json:"message,omitempty"`
}

The details for an event that's associated with a service.

func (in *ServiceEvent) DeepCopy() *ServiceEvent

func (in *ServiceEvent) DeepCopyInto(out *ServiceEvent)

type ServiceField ¶

type ServiceField string

const (
	ServiceField_TAGS ServiceField = "TAGS"
)

type ServiceRegistry ¶

type ServiceRegistry struct {
	ContainerName *string `json:"containerName,omitempty"`
	RegistryARN   *string `json:"registryARN,omitempty"`
}

The details for the service registry.

Each service may be associated with one service registry. Multiple service registries for each service are not supported.

When you add, update, or remove the service registries configuration, Amazon ECS starts a new deployment. New tasks are registered and deregistered to the updated service registry configuration.

func (in *ServiceRegistry) DeepCopy() *ServiceRegistry

func (in *ServiceRegistry) DeepCopyInto(out *ServiceRegistry)

type Session ¶

type Session struct {
	SessionID *string `json:"sessionID,omitempty"`
	StreamURL *string `json:"streamURL,omitempty"`
}

The details for the execute command session.

func (in *Session) DeepCopy() *Session

func (in *Session) DeepCopyInto(out *Session)

type Setting ¶

type Setting struct {
	PrincipalARN *string `json:"principalARN,omitempty"`
	Value        *string `json:"value,omitempty"`
}

The current account setting for a resource.

func (in *Setting) DeepCopy() *Setting

func (in *Setting) DeepCopyInto(out *Setting)

type SettingName ¶

type SettingName string

const (
	SettingName_serviceLongArnFormat            SettingName = "serviceLongArnFormat"
	SettingName_taskLongArnFormat               SettingName = "taskLongArnFormat"
	SettingName_containerInstanceLongArnFormat  SettingName = "containerInstanceLongArnFormat"
	SettingName_awsvpcTrunking                  SettingName = "awsvpcTrunking"
	SettingName_containerInsights               SettingName = "containerInsights"
	SettingName_fargateFIPSMode                 SettingName = "fargateFIPSMode"
	SettingName_tagResourceAuthorization        SettingName = "tagResourceAuthorization"
	SettingName_fargateTaskRetirementWaitPeriod SettingName = "fargateTaskRetirementWaitPeriod"
	SettingName_guardDutyActivate               SettingName = "guardDutyActivate"
)

type SettingType ¶

type SettingType string

const (
	SettingType_user        SettingType = "user"
	SettingType_aws_managed SettingType = "aws_managed"
)

type SortOrder ¶

type SortOrder string

const (
	SortOrder_ASC  SortOrder = "ASC"
	SortOrder_DESC SortOrder = "DESC"
)

type StabilityStatus ¶

type StabilityStatus string

const (
	StabilityStatus_STEADY_STATE StabilityStatus = "STEADY_STATE"
	StabilityStatus_STABILIZING  StabilityStatus = "STABILIZING"
)

type SystemControl ¶

type SystemControl struct {
	Namespace *string `json:"namespace,omitempty"`
	Value     *string `json:"value,omitempty"`
}

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). For example, you can configure net.ipv4.tcp_keepalive_time setting to maintain longer lived connections.

We don't recommend that you specify network-related systemControls parameters for multiple containers in a single task that also uses either the awsvpc or host network mode. Doing this has the following disadvantages:

• For tasks that use the awsvpc network mode including Fargate, 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's started last determines which systemControls take effect.

• For tasks that use the host network mode, the network namespace systemControls aren't supported.

If you're setting an IPC resource namespace to use for the containers in the task, the following conditions apply to your system controls. For more information, see IPC mode (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_ipcmode).

• For tasks that use the host IPC mode, IPC namespace systemControls aren't supported.

• For tasks that use the task IPC mode, IPC namespace systemControls values apply to all containers within a task.

This parameter is not supported for Windows containers.

This parameter is only supported for tasks that are hosted on Fargate if the tasks are using platform version 1.4.0 or later (Linux). This isn't supported for Windows containers on Fargate.

func (in *SystemControl) DeepCopy() *SystemControl

func (in *SystemControl) DeepCopyInto(out *SystemControl)

type Tag ¶

type Tag struct {
	Key   *string `json:"key,omitempty"`
	Value *string `json:"value,omitempty"`
}

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. You define them.

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 Amazon Web Services 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.

func (in *Tag) DeepCopy() *Tag

func (in *Tag) DeepCopyInto(out *Tag)

type TargetType ¶

type TargetType string

const (
	TargetType_container_instance TargetType = "container-instance"
)

type Task ¶

type Task struct {
	Attachments          []*Attachment `json:"attachments,omitempty"`
	AvailabilityZone     *string       `json:"availabilityZone,omitempty"`
	CapacityProviderName *string       `json:"capacityProviderName,omitempty"`
	ClusterARN           *string       `json:"clusterARN,omitempty"`
	ContainerInstanceARN *string       `json:"containerInstanceARN,omitempty"`
	CPU                  *string       `json:"cpu,omitempty"`
	DesiredStatus        *string       `json:"desiredStatus,omitempty"`
	EnableExecuteCommand *bool         `json:"enableExecuteCommand,omitempty"`
	Group                *string       `json:"group,omitempty"`
	LastStatus           *string       `json:"lastStatus,omitempty"`
	Memory               *string       `json:"memory,omitempty"`
	PlatformFamily       *string       `json:"platformFamily,omitempty"`
	PlatformVersion      *string       `json:"platformVersion,omitempty"`
	StartedBy            *string       `json:"startedBy,omitempty"`
	StoppedReason        *string       `json:"stoppedReason,omitempty"`
	Tags                 []*Tag        `json:"tags,omitempty"`
	TaskARN              *string       `json:"taskARN,omitempty"`
	TaskDefinitionARN    *string       `json:"taskDefinitionARN,omitempty"`
}

Details on a task in a cluster.

func (in *Task) DeepCopy() *Task

func (in *Task) DeepCopyInto(out *Task)

type TaskDefinition ¶

type TaskDefinition struct {
	CPU               *string `json:"cpu,omitempty"`
	ExecutionRoleARN  *string `json:"executionRoleARN,omitempty"`
	Family            *string `json:"family,omitempty"`
	Memory            *string `json:"memory,omitempty"`
	RegisteredBy      *string `json:"registeredBy,omitempty"`
	Revision          *int64  `json:"revision,omitempty"`
	TaskDefinitionARN *string `json:"taskDefinitionARN,omitempty"`
	TaskRoleARN       *string `json:"taskRoleARN,omitempty"`
}

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.

func (in *TaskDefinition) DeepCopy() *TaskDefinition

func (in *TaskDefinition) DeepCopyInto(out *TaskDefinition)

type TaskDefinitionFamilyStatus ¶

type TaskDefinitionFamilyStatus string

const (
	TaskDefinitionFamilyStatus_ACTIVE   TaskDefinitionFamilyStatus = "ACTIVE"
	TaskDefinitionFamilyStatus_INACTIVE TaskDefinitionFamilyStatus = "INACTIVE"
	TaskDefinitionFamilyStatus_ALL      TaskDefinitionFamilyStatus = "ALL"
)

type TaskDefinitionField ¶

type TaskDefinitionField string

const (
	TaskDefinitionField_TAGS TaskDefinitionField = "TAGS"
)

type TaskDefinitionPlacementConstraint ¶

type TaskDefinitionPlacementConstraint struct {
	Expression *string `json:"expression,omitempty"`
}

The 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.

Task placement constraints aren't supported for tasks run on Fargate.

func (in *TaskDefinitionPlacementConstraint) DeepCopy() *TaskDefinitionPlacementConstraint

func (in *TaskDefinitionPlacementConstraint) DeepCopyInto(out *TaskDefinitionPlacementConstraint)

type TaskDefinitionPlacementConstraintType ¶

type TaskDefinitionPlacementConstraintType string

const (
	TaskDefinitionPlacementConstraintType_memberOf TaskDefinitionPlacementConstraintType = "memberOf"
)

type TaskDefinitionStatus ¶

type TaskDefinitionStatus string

const (
	TaskDefinitionStatus_ACTIVE             TaskDefinitionStatus = "ACTIVE"
	TaskDefinitionStatus_INACTIVE           TaskDefinitionStatus = "INACTIVE"
	TaskDefinitionStatus_DELETE_IN_PROGRESS TaskDefinitionStatus = "DELETE_IN_PROGRESS"
)

type TaskField ¶

type TaskField string

const (
	TaskField_TAGS TaskField = "TAGS"
)

type TaskFilesystemType ¶

type TaskFilesystemType string

const (
	TaskFilesystemType_ext3 TaskFilesystemType = "ext3"
	TaskFilesystemType_ext4 TaskFilesystemType = "ext4"
	TaskFilesystemType_xfs  TaskFilesystemType = "xfs"
)

type TaskOverride ¶

type TaskOverride struct {
	CPU              *string `json:"cpu,omitempty"`
	ExecutionRoleARN *string `json:"executionRoleARN,omitempty"`
	Memory           *string `json:"memory,omitempty"`
	TaskRoleARN      *string `json:"taskRoleARN,omitempty"`
}

The overrides that are associated with a task.

func (in *TaskOverride) DeepCopy() *TaskOverride

func (in *TaskOverride) DeepCopyInto(out *TaskOverride)

type TaskSet ¶

type TaskSet struct {
	CapacityProviderStrategy []*CapacityProviderStrategyItem `json:"capacityProviderStrategy,omitempty"`
	ClusterARN               *string                         `json:"clusterARN,omitempty"`
	ComputedDesiredCount     *int64                          `json:"computedDesiredCount,omitempty"`
	ExternalID               *string                         `json:"externalID,omitempty"`
	ID                       *string                         `json:"id,omitempty"`
	PendingCount             *int64                          `json:"pendingCount,omitempty"`
	PlatformFamily           *string                         `json:"platformFamily,omitempty"`
	PlatformVersion          *string                         `json:"platformVersion,omitempty"`
	RunningCount             *int64                          `json:"runningCount,omitempty"`
	ServiceARN               *string                         `json:"serviceARN,omitempty"`
	StartedBy                *string                         `json:"startedBy,omitempty"`
	Status                   *string                         `json:"status,omitempty"`
	Tags                     []*Tag                          `json:"tags,omitempty"`
	TaskDefinition           *string                         `json:"taskDefinition,omitempty"`
	TaskSetARN               *string                         `json:"taskSetARN,omitempty"`
}

Information about a set of Amazon ECS tasks in either an 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.

func (in *TaskSet) DeepCopy() *TaskSet

func (in *TaskSet) DeepCopyInto(out *TaskSet)

type TaskSetField ¶

type TaskSetField string

const (
	TaskSetField_TAGS TaskSetField = "TAGS"
)

type TaskStopCode ¶

type TaskStopCode string

const (
	TaskStopCode_TaskFailedToStart         TaskStopCode = "TaskFailedToStart"
	TaskStopCode_EssentialContainerExited  TaskStopCode = "EssentialContainerExited"
	TaskStopCode_UserInitiated             TaskStopCode = "UserInitiated"
	TaskStopCode_ServiceSchedulerInitiated TaskStopCode = "ServiceSchedulerInitiated"
	TaskStopCode_SpotInterruption          TaskStopCode = "SpotInterruption"
	TaskStopCode_TerminationNotice         TaskStopCode = "TerminationNotice"
)

type Tmpfs ¶

type Tmpfs struct {
	ContainerPath *string   `json:"containerPath,omitempty"`
	MountOptions  []*string `json:"mountOptions,omitempty"`
	Size          *int64    `json:"size,omitempty"`
}

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

func (in *Tmpfs) DeepCopy() *Tmpfs

func (in *Tmpfs) DeepCopyInto(out *Tmpfs)

type TransportProtocol ¶

type TransportProtocol string

const (
	TransportProtocol_tcp TransportProtocol = "tcp"
	TransportProtocol_udp TransportProtocol = "udp"
)

type Ulimit ¶

type Ulimit struct {
	HardLimit *int64 `json:"hardLimit,omitempty"`
	SoftLimit *int64 `json:"softLimit,omitempty"`
}

The ulimit settings to pass to the container.

Amazon ECS tasks hosted on Fargate use the default resource limit values set by the operating system with the exception of the nofile resource limit parameter which Fargate overrides. The nofile resource limit sets a restriction on the number of open files that a container can use. The default nofile soft limit is 1024 and the default hard limit is 65535.

You can specify the ulimit settings for a container in a task definition.

func (in *Ulimit) DeepCopy() *Ulimit

func (in *Ulimit) DeepCopyInto(out *Ulimit)

type UlimitName ¶

type UlimitName string

const (
	UlimitName_core       UlimitName = "core"
	UlimitName_cpu        UlimitName = "cpu"
	UlimitName_data       UlimitName = "data"
	UlimitName_fsize      UlimitName = "fsize"
	UlimitName_locks      UlimitName = "locks"
	UlimitName_memlock    UlimitName = "memlock"
	UlimitName_msgqueue   UlimitName = "msgqueue"
	UlimitName_nice       UlimitName = "nice"
	UlimitName_nofile     UlimitName = "nofile"
	UlimitName_nproc      UlimitName = "nproc"
	UlimitName_rss        UlimitName = "rss"
	UlimitName_rtprio     UlimitName = "rtprio"
	UlimitName_rttime     UlimitName = "rttime"
	UlimitName_sigpending UlimitName = "sigpending"
	UlimitName_stack      UlimitName = "stack"
)

type VersionInfo ¶

type VersionInfo struct {
	AgentHash     *string `json:"agentHash,omitempty"`
	AgentVersion  *string `json:"agentVersion,omitempty"`
	DockerVersion *string `json:"dockerVersion,omitempty"`
}

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

func (in *VersionInfo) DeepCopy() *VersionInfo

func (in *VersionInfo) DeepCopyInto(out *VersionInfo)

type Volume ¶

type Volume struct {
	Name *string `json:"name,omitempty"`
}

The data volume configuration for tasks launched using this task definition. Specifying a volume configuration in a task definition is optional. The volume configuration may contain multiple volumes but only one volume configured at launch is supported. Each volume defined in the volume configuration may only specify a name and one of either configuredAtLaunch, dockerVolumeConfiguration, efsVolumeConfiguration, fsxWindowsFileServerVolumeConfiguration, or host. If an empty volume configuration is specified, by default Amazon ECS uses a host volume. For more information, see Using data volumes in tasks (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html).

func (in *Volume) DeepCopy() *Volume

func (in *Volume) DeepCopyInto(out *Volume)

type VolumeFrom ¶

type VolumeFrom struct {
	SourceContainer *string `json:"sourceContainer,omitempty"`
}

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

func (in *VolumeFrom) DeepCopy() *VolumeFrom

func (in *VolumeFrom) DeepCopyInto(out *VolumeFrom)