aws_sdk_ecs

Module types

Source
Expand description

Data structures used by operation inputs/outputs.

Modules§

  • builders
    Builders
  • error
    Error types that Amazon EC2 Container Service can respond with.

Structs§

  • Attachment

    An object representing a container instance or task attachment.

  • AttachmentStateChange

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

  • Attribute

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

  • AutoScalingGroupProvider

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

  • AutoScalingGroupProviderUpdate

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

  • AwsVpcConfiguration

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

  • CapacityProvider

    The details for a capacity provider.

  • CapacityProviderStrategyItem

    The details of a capacity provider strategy. A capacity provider strategy can be set when using the RunTaskor 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 CreateClusterCapacityProvider 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.

    With FARGATE_SPOT, you can run interruption tolerant tasks at a rate that's discounted compared to the FARGATE price. FARGATE_SPOT runs tasks on spare compute capacity. When Amazon Web Services needs the capacity back, your tasks are interrupted with a two-minute warning. FARGATE_SPOT supports Linux tasks with the X86_64 architecture on platform version 1.3.0 or later. FARGATE_SPOT supports Linux tasks with the ARM64 architecture on platform version 1.4.0 or later.

    A capacity provider strategy can contain a maximum of 20 capacity providers.

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

  • ClusterConfiguration

    The execute command and managed storage configuration for the cluster.

  • ClusterServiceConnectDefaults

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

  • ClusterServiceConnectDefaultsRequest

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

  • ClusterSetting

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

    Container Insights with enhanced observability provides all the Container Insights metrics, plus additional task and container metrics. This version supports enhanced observability for Amazon ECS clusters using the Amazon EC2 and Fargate launch types. After you configure Container Insights with enhanced observability on Amazon ECS, Container Insights auto-collects detailed infrastructure telemetry from the cluster level down to the container level in your environment and displays these critical performance data in curated dashboards removing the heavy lifting in observability set-up.

    For more information, see Monitor Amazon ECS containers using Container Insights with enhanced observability in the Amazon Elastic Container Service Developer Guide.

  • Container

    A Docker container that's part of a task.

  • ContainerDefinition

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

  • ContainerDependency

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

  • ContainerImage

    The details about the container image a service revision uses.

    To ensure that all tasks in a service use the same container image, Amazon ECS resolves container image names and any image tags specified in the task definition to container image digests.

    After the container image digest has been established, Amazon ECS uses the digest to start any other desired tasks, and for any future service and service revision updates. This leads to all tasks in a service always running identical container images, resulting in version consistency for your software. For more information, see Container image resolution in the Amazon ECS Developer Guide.

  • ContainerInstance

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

  • ContainerInstanceHealthStatus

    An object representing the health status of the container instance.

  • ContainerOverride

    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 in the Amazon ECS Developer Guide.

  • ContainerRestartPolicy

    You can enable a restart policy for each container defined in your task definition, to overcome transient failures faster and maintain task availability. When you enable a restart policy for a container, Amazon ECS can restart the container if it exits, without needing to replace the task. For more information, see Restart individual containers in Amazon ECS tasks with container restart policies in the Amazon Elastic Container Service Developer Guide.

  • ContainerStateChange

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

  • CreatedAt

    The optional filter to narrow the ListServiceDeployment results.

    If you do not specify a value, service deployments that were created before the current time are included in the result.

  • Deployment

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

  • DeploymentAlarms

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

  • DeploymentCircuitBreaker

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

    For more information about API failure reasons, see API failure reasons in the Amazon Elastic Container Service Developer Guide.

  • DeploymentConfiguration

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

  • DeploymentController

    The deployment controller to use for the service.

  • DeploymentEphemeralStorage

    The amount of ephemeral storage to allocate for the deployment.

  • Device

    An object representing a container instance host device.

  • DockerVolumeConfiguration

    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.

  • EbsTagSpecification

    The tag specifications of an Amazon EBS volume.

  • EfsAuthorizationConfig

    The authorization configuration details for the Amazon EFS file system.

  • EfsVolumeConfiguration

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

  • EnvironmentFile

    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 Use a file to pass environment variables to a container in the Amazon Elastic Container Service Developer Guide.

    Environment variable files are objects in Amazon S3 and all Amazon S3 security considerations apply.

    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.

  • EphemeralStorage

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

  • ExecuteCommandConfiguration

    The details of the execute command configuration.

  • ExecuteCommandLogConfiguration

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

  • FSxWindowsFileServerAuthorizationConfig

    The authorization configuration details for Amazon FSx for Windows File Server file system. See FSxWindowsFileServerVolumeConfiguration in the Amazon ECS API Reference.

    For more information and the input format, see Amazon FSx for Windows File Server Volumes in the Amazon Elastic Container Service Developer Guide.

  • FSxWindowsFileServerVolumeConfiguration

    This parameter is specified when you're using Amazon FSx for Windows File Server file system for task storage.

    For more information and the input format, see Amazon FSx for Windows File Server volumes in the Amazon Elastic Container Service Developer Guide.

  • Failure

    A failed resource. For a list of common causes, see API failure reasons in the Amazon Elastic Container Service Developer Guide.

  • FirelensConfiguration

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

  • HealthCheck

    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.

    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.

    Amazon ECS performs health checks on containers with the default that launched the container instance or the task.

    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:

    • If the Amazon ECS container agent becomes disconnected from the Amazon ECS service, this won't cause a container to transition to an UNHEALTHY status. This is by design, to ensure that containers remain running during agent restarts or temporary unavailability. The health check status is the "last heard from" response from the Amazon ECS agent, so if the container was considered HEALTHY prior to the disconnect, that status will remain until the agent reconnects and another health check occurs. 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.

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

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

  • HostEntry

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

  • HostVolumeProperties

    Details on a container instance bind mount host volume.

  • InferenceAccelerator

    Details on an Elastic Inference accelerator. For more information, see Working with Amazon Elastic Inference on Amazon ECS in the Amazon Elastic Container Service Developer Guide.

  • InferenceAcceleratorOverride

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

  • InstanceHealthCheckResult

    An object representing the result of a container instance health status check.

  • KernelCapabilities

    The Linux capabilities to add or remove from the default Docker configuration for a container defined in the task definition. For more detailed information about these Linux capabilities, see the capabilities(7) Linux manual page.

  • KeyValuePair

    A key-value pair object.

  • LinuxParameters

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

  • LoadBalancer

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

  • LogConfiguration

    The log configuration for the container. This parameter maps to LogConfig in the docker container create command and the --log-driver option to docker run.

    By default, containers use the same logging driver that the Docker daemon uses. However, the container might use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition.

    Understand the following when specifying a log configuration for your containers.

    • Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon. Additional log drivers may be available in future releases of the Amazon ECS container agent.

      For tasks on 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,syslog, splunk, and awsfirelens.

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

    • For tasks that are 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 in the Amazon Elastic Container Service Developer Guide.

    • For tasks that are on Fargate, because you don't have access to the underlying infrastructure your tasks are hosted on, any additional software needed must be installed outside of the task. For example, the Fluentd output aggregators or a remote host running Logstash to send Gelf logs to.

  • ManagedAgent

    Details about the managed agent status for the container.

  • ManagedAgentStateChange

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

  • ManagedScaling

    The managed scaling settings for the Auto Scaling group capacity provider.

    When managed scaling is turned on, 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 in the Amazon Elastic Container Service Developer Guide.

    If managed scaling is off, the user must manage the scaling of the Auto Scaling group.

  • ManagedStorageConfiguration

    The managed storage configuration for the cluster.

  • MountPoint

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

  • NetworkBinding

    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.

  • NetworkConfiguration

    The network configuration for a task or service.

  • NetworkInterface

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

  • PlacementConstraint

    An object representing a constraint on task placement. For more information, see Task placement constraints in the Amazon Elastic Container Service Developer Guide.

    If you're using the Fargate launch type, task placement constraints aren't supported.

  • PlacementStrategy

    The task placement strategy for a task or service. For more information, see Task placement strategies in the Amazon Elastic Container Service Developer Guide.

  • PlatformDevice

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

  • PortMapping

    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 docker container create command and the --publish option to docker 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.

  • ProtectedTask

    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.

  • ProxyConfiguration

    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

  • RepositoryCredentials

    The repository credentials for private registry authentication.

  • Resource

    Describes the resources available for a container instance.

  • ResourceRequirement

    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 or Working with Amazon Elastic Inference on Amazon ECS in the Amazon Elastic Container Service Developer Guide

  • Rollback

    Information about the service deployment rollback.

  • RuntimePlatform

    Information about the platform for the Amazon ECS service or task.

    For more information about RuntimePlatform, see RuntimePlatform in the Amazon Elastic Container Service Developer Guide.

  • Scale

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

  • Secret

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

  • Service

    Details on a service within a cluster.

  • ServiceConnectClientAlias

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

  • ServiceConnectConfiguration

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

  • ServiceConnectService

    The Service Connect service object configuration. For more information, see Service Connect in the Amazon Elastic Container Service Developer Guide.

  • ServiceConnectServiceResource

    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.

  • ServiceConnectTlsCertificateAuthority

    The certificate root authority that secures your service.

  • ServiceConnectTlsConfiguration

    The key that encrypts and decrypts your resources for Service Connect TLS.

  • ServiceDeployment

    Information about the service deployment.

    Service deployments provide a comprehensive view of your deployments. For information about service deployments, see View service history using Amazon ECS service deployments in the Amazon Elastic Container Service Developer Guide .

  • ServiceDeploymentAlarms

    The CloudWatch alarms used to determine a service deployment failed.

    Amazon ECS considers the service deployment as failed when any of the alarms move to the ALARM state. For more information, see How CloudWatch alarms detect Amazon ECS deployment failures in the Amazon ECS Developer Guide.

  • ServiceDeploymentBrief

    The service deployment properties that are retured when you call ListServiceDeployments.

    This provides a high-level overview of the service deployment.

  • ServiceDeploymentCircuitBreaker

    Information about the circuit breaker used to determine when a service deployment has failed.

    The deployment circuit breaker is the rolling update mechanism that determines if the tasks reach a steady state. The deployment circuit breaker has an option that will automatically roll back a failed deployment to the last cpompleted service revision. For more information, see How the Amazon ECS deployment circuit breaker detects failures in the Amazon ECS Developer Guide.

  • ServiceEvent

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

  • ServiceManagedEbsVolumeConfiguration

    The configuration for the Amazon EBS volume that Amazon ECS creates and manages on your behalf. These settings are used to create each Amazon EBS volume, with one volume created for each task in the service. For information about the supported launch types and operating systems, see Supported operating systems and launch types in the Amazon Elastic Container Service Developer Guide.

    Many of these parameters map 1:1 with the Amazon EBS CreateVolume API request parameters.

  • ServiceRegistry

    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.

  • ServiceRevision

    Information about the service revision.

    A service revision contains a record of the workload configuration Amazon ECS is attempting to deploy. Whenever you create or deploy a service, Amazon ECS automatically creates and captures the configuration that you're trying to deploy in the service revision. For information about service revisions, see Amazon ECS service revisions in the Amazon Elastic Container Service Developer Guide .

  • ServiceRevisionSummary

    The information about the number of requested, pending, and running tasks for a service revision.

  • ServiceVolumeConfiguration

    The configuration for a volume specified in the task definition as a volume that is configured at launch time. Currently, the only supported volume type is an Amazon EBS volume.

  • Session

    The details for the execute command session.

  • Setting

    The current account setting for a resource.

  • SystemControl

    A list of namespaced kernel parameters to set in the container. This parameter maps to Sysctls in the docker container create command and the --sysctl option to docker run. 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.

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

  • Tag

    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.

  • Task

    Details on a task in a cluster.

  • TaskDefinition

    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.

  • TaskDefinitionPlacementConstraint

    The constraint on task placement in the task definition. For more information, see Task placement constraints in the Amazon Elastic Container Service Developer Guide.

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

  • TaskEphemeralStorage

    The amount of ephemeral storage to allocate for the task.

  • TaskManagedEbsVolumeConfiguration

    The configuration for the Amazon EBS volume that Amazon ECS creates and manages on your behalf. These settings are used to create each Amazon EBS volume, with one volume created for each task.

  • TaskManagedEbsVolumeTerminationPolicy

    The termination policy for the Amazon EBS volume when the task exits. For more information, see Amazon ECS volume termination policy.

  • TaskOverride

    The overrides that are associated with a task.

  • TaskSet

    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.

  • TaskVolumeConfiguration

    Configuration settings for the task volume that was configuredAtLaunch that weren't set during RegisterTaskDef.

  • TimeoutConfiguration

    An object that represents the timeout configurations for Service Connect.

    If idleTimeout is set to a time that is less than perRequestTimeout, the connection will close when the idleTimeout is reached and not the perRequestTimeout.

  • Tmpfs

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

  • Ulimit

    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 65535 and the default hard limit is 65535.

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

  • VersionInfo

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

  • Volume

    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.

  • VolumeFrom

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

  • VpcLatticeConfiguration

    The VPC Lattice configuration for your service that holds the information for the target group(s) Amazon ECS tasks will be registered to.

Enums§

  • AgentUpdateStatus
    When writing a match expression against AgentUpdateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ApplicationProtocol
    When writing a match expression against ApplicationProtocol, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • AssignPublicIp
    When writing a match expression against AssignPublicIp, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • AvailabilityZoneRebalancing
    When writing a match expression against AvailabilityZoneRebalancing, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • CapacityProviderField
    When writing a match expression against CapacityProviderField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • CapacityProviderStatus
    When writing a match expression against CapacityProviderStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • CapacityProviderUpdateStatus
    When writing a match expression against CapacityProviderUpdateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ClusterField
    When writing a match expression against ClusterField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ClusterSettingName
    When writing a match expression against ClusterSettingName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • Compatibility
    When writing a match expression against Compatibility, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • Connectivity
    When writing a match expression against Connectivity, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ContainerCondition
    When writing a match expression against ContainerCondition, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ContainerInstanceField
    When writing a match expression against ContainerInstanceField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ContainerInstanceStatus
    When writing a match expression against ContainerInstanceStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • CpuArchitecture
    When writing a match expression against CpuArchitecture, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • DeploymentControllerType
    When writing a match expression against DeploymentControllerType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • DeploymentRolloutState
    When writing a match expression against DeploymentRolloutState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • DesiredStatus
    When writing a match expression against DesiredStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • DeviceCgroupPermission
    When writing a match expression against DeviceCgroupPermission, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • EbsResourceType
    When writing a match expression against EbsResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • EfsAuthorizationConfigIam
    When writing a match expression against EfsAuthorizationConfigIam, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • EfsTransitEncryption
    When writing a match expression against EfsTransitEncryption, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • EnvironmentFileType
    When writing a match expression against EnvironmentFileType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ExecuteCommandLogging
    When writing a match expression against ExecuteCommandLogging, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • FirelensConfigurationType
    When writing a match expression against FirelensConfigurationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • HealthStatus
    When writing a match expression against HealthStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • InstanceHealthCheckState
    When writing a match expression against InstanceHealthCheckState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • InstanceHealthCheckType
    When writing a match expression against InstanceHealthCheckType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • IpcMode
    When writing a match expression against IpcMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • LaunchType
    When writing a match expression against LaunchType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • LogDriver
    When writing a match expression against LogDriver, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ManagedAgentName
    When writing a match expression against ManagedAgentName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ManagedDraining
    When writing a match expression against ManagedDraining, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ManagedScalingStatus
    When writing a match expression against ManagedScalingStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ManagedTerminationProtection
    When writing a match expression against ManagedTerminationProtection, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • NetworkMode
    When writing a match expression against NetworkMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • OsFamily
    When writing a match expression against OsFamily, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • PidMode
    When writing a match expression against PidMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • PlacementConstraintType
    When writing a match expression against PlacementConstraintType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • PlacementStrategyType
    When writing a match expression against PlacementStrategyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • PlatformDeviceType
    When writing a match expression against PlatformDeviceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • PropagateTags
    When writing a match expression against PropagateTags, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ProxyConfigurationType
    When writing a match expression against ProxyConfigurationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ResourceType
    When writing a match expression against ResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ScaleUnit
    When writing a match expression against ScaleUnit, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • SchedulingStrategy
    When writing a match expression against SchedulingStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • Scope
    When writing a match expression against Scope, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ServiceDeploymentRollbackMonitorsStatus
    When writing a match expression against ServiceDeploymentRollbackMonitorsStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ServiceDeploymentStatus
    When writing a match expression against ServiceDeploymentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • ServiceField
    When writing a match expression against ServiceField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • SettingName
    When writing a match expression against SettingName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • SettingType
    When writing a match expression against SettingType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • SortOrder
    When writing a match expression against SortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • StabilityStatus
    When writing a match expression against StabilityStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TargetType
    When writing a match expression against TargetType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TaskDefinitionFamilyStatus
    When writing a match expression against TaskDefinitionFamilyStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TaskDefinitionField
    When writing a match expression against TaskDefinitionField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TaskDefinitionPlacementConstraintType
    When writing a match expression against TaskDefinitionPlacementConstraintType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TaskDefinitionStatus
    When writing a match expression against TaskDefinitionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TaskField
    When writing a match expression against TaskField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TaskFilesystemType
    When writing a match expression against TaskFilesystemType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TaskSetField
    When writing a match expression against TaskSetField, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TaskStopCode
    When writing a match expression against TaskStopCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TransportProtocol
    When writing a match expression against TransportProtocol, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • UlimitName
    When writing a match expression against UlimitName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • VersionConsistency
    When writing a match expression against VersionConsistency, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.