Metadata-Version: 2.1
Name: aws-cdk.aws-ecs
Version: 1.106.0
Summary: The CDK Construct Library for AWS::ECS
Home-page: https://github.com/aws/aws-cdk
Author: Amazon Web Services
License: Apache-2.0
Project-URL: Source, https://github.com/aws/aws-cdk.git
Description: # Amazon ECS Construct Library
        
        <!--BEGIN STABILITY BANNER-->---
        
        
        ![cfn-resources: Stable](https://img.shields.io/badge/cfn--resources-stable-success.svg?style=for-the-badge)
        
        ![cdk-constructs: Stable](https://img.shields.io/badge/cdk--constructs-stable-success.svg?style=for-the-badge)
        
        ---
        <!--END STABILITY BANNER-->
        
        This package contains constructs for working with **Amazon Elastic Container
        Service** (Amazon ECS).
        
        Amazon Elastic Container Service (Amazon ECS) is a fully managed container orchestration service.
        
        For further information on Amazon ECS,
        see the [Amazon ECS documentation](https://docs.aws.amazon.com/ecs)
        
        The following example creates an Amazon ECS cluster, adds capacity to it, and
        runs a service on it:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_ecs as ecs
        
        # Create an ECS cluster
        cluster = ecs.Cluster(self, "Cluster",
            vpc=vpc
        )
        
        # Add capacity to it
        cluster.add_capacity("DefaultAutoScalingGroupCapacity",
            instance_type=ec2.InstanceType("t2.xlarge"),
            desired_capacity=3
        )
        
        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
        
        task_definition.add_container("DefaultContainer",
            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
            memory_limit_mi_b=512
        )
        
        # Instantiate an Amazon ECS Service
        ecs_service = ecs.Ec2Service(self, "Service",
            cluster=cluster,
            task_definition=task_definition
        )
        ```
        
        For a set of constructs defining common ECS architectural patterns, see the `@aws-cdk/aws-ecs-patterns` package.
        
        ## Launch Types: AWS Fargate vs Amazon EC2
        
        There are two sets of constructs in this library; one to run tasks on Amazon EC2 and
        one to run tasks on AWS Fargate.
        
        * Use the `Ec2TaskDefinition` and `Ec2Service` constructs to run tasks on Amazon EC2 instances running in your account.
        * Use the `FargateTaskDefinition` and `FargateService` constructs to run tasks on
          instances that are managed for you by AWS.
        
        Here are the main differences:
        
        * **Amazon EC2**: instances are under your control. Complete control of task to host
          allocation. Required to specify at least a memory reservation or limit for
          every container. Can use Host, Bridge and AwsVpc networking modes. Can attach
          Classic Load Balancer. Can share volumes between container and host.
        * **AWS Fargate**: tasks run on AWS-managed instances, AWS manages task to host
          allocation for you. Requires specification of memory and cpu sizes at the
          taskdefinition level. Only supports AwsVpc networking modes and
          Application/Network Load Balancers. Only the AWS log driver is supported.
          Many host features are not supported such as adding kernel capabilities
          and mounting host devices/volumes inside the container.
        
        For more information on Amazon EC2 vs AWS Fargate and networking see the AWS Documentation:
        [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html) and
        [Task Networking](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html).
        
        ## Clusters
        
        A `Cluster` defines the infrastructure to run your
        tasks on. You can run many tasks on a single cluster.
        
        The following code creates a cluster that can run AWS Fargate tasks:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        cluster = ecs.Cluster(self, "Cluster",
            vpc=vpc
        )
        ```
        
        To use tasks with Amazon EC2 launch-type, you have to add capacity to
        the cluster in order for tasks to be scheduled on your instances.  Typically,
        you add an AutoScalingGroup with instances running the latest
        Amazon ECS-optimized AMI to the cluster. There is a method to build and add such an
        AutoScalingGroup automatically, or you can supply a customized AutoScalingGroup
        that you construct yourself. It's possible to add multiple AutoScalingGroups
        with various instance types.
        
        The following example creates an Amazon ECS cluster and adds capacity to it:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        cluster = ecs.Cluster(self, "Cluster",
            vpc=vpc
        )
        
        # Either add default capacity
        cluster.add_capacity("DefaultAutoScalingGroupCapacity",
            instance_type=ec2.InstanceType("t2.xlarge"),
            desired_capacity=3
        )
        
        # Or add customized capacity. Be sure to start the Amazon ECS-optimized AMI.
        auto_scaling_group = autoscaling.AutoScalingGroup(self, "ASG",
            vpc=vpc,
            instance_type=ec2.InstanceType("t2.xlarge"),
            machine_image=EcsOptimizedImage.amazon_linux(),
            # Or use Amazon ECS-Optimized Amazon Linux 2 AMI
            # machineImage: EcsOptimizedImage.amazonLinux2(),
            desired_capacity=3
        )
        
        cluster.add_auto_scaling_group(auto_scaling_group)
        ```
        
        If you omit the property `vpc`, the construct will create a new VPC with two AZs.
        
        ### Bottlerocket
        
        [Bottlerocket](https://aws.amazon.com/bottlerocket/) is a Linux-based open source operating system that is
        purpose-built by AWS for running containers. You can launch Amazon ECS container instances with the Bottlerocket AMI.
        
        > **NOTICE**: The Bottlerocket AMI is in developer preview release for Amazon ECS and is subject to change.
        
        The following example will create a capacity with self-managed Amazon EC2 capacity of 2 `c5.large` Linux instances running with `Bottlerocket` AMI.
        
        Note that you must specify either a `machineImage` or `machineImageType`, at least one, not both.
        
        The following example adds Bottlerocket capacity to the cluster:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        cluster.add_capacity("bottlerocket-asg",
            min_capacity=2,
            instance_type=ec2.InstanceType("c5.large"),
            machine_image_type=ecs.MachineImageType.BOTTLEROCKET
        )
        ```
        
        ### ARM64 (Graviton) Instances
        
        To launch instances with ARM64 hardware, you can use the Amazon ECS-optimized
        Amazon Linux 2 (arm64) AMI. Based on Amazon Linux 2, this AMI is recommended
        for use when launching your EC2 instances that are powered by Arm-based AWS
        Graviton Processors.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        cluster.add_capacity("graviton-cluster",
            min_capacity=2,
            instance_type=ec2.InstanceType("c6g.large"),
            machine_image=ecs.EcsOptimizedImage.amazon_linux2(ecs.AmiHardwareType.ARM)
        )
        ```
        
        ### Spot Instances
        
        To add spot instances into the cluster, you must specify the `spotPrice` in the `ecs.AddCapacityOptions` and optionally enable the `spotInstanceDraining` property.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Add an AutoScalingGroup with spot instances to the existing cluster
        cluster.add_capacity("AsgSpot",
            max_capacity=2,
            min_capacity=2,
            desired_capacity=2,
            instance_type=ec2.InstanceType("c5.xlarge"),
            spot_price="0.0735",
            # Enable the Automated Spot Draining support for Amazon ECS
            spot_instance_draining=True
        )
        ```
        
        ### SNS Topic Encryption
        
        When the `ecs.AddCapacityOptions` that you provide has a non-zero `taskDrainTime` (the default) then an SNS topic and Lambda are created to ensure that the
        cluster's instances have been properly drained of tasks before terminating. The SNS Topic is sent the instance-terminating lifecycle event from the AutoScalingGroup,
        and the Lambda acts on that event. If you wish to engage [server-side encryption](https://docs.aws.amazon.com/sns/latest/dg/sns-data-encryption.html) for this SNS Topic
        then you may do so by providing a KMS key for the `topicEncryptionKey` property of `ecs.AddCapacityOptions`.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Given
        key = kms.Key(...)
        # Then, use that key to encrypt the lifecycle-event SNS Topic.
        cluster.add_capacity("ASGEncryptedSNS",
            instance_type=ec2.InstanceType("t2.xlarge"),
            desired_capacity=3,
            topic_encryption_key=key
        )
        ```
        
        ## Task definitions
        
        A task definition describes what a single copy of a **task** should look like.
        A task definition has one or more containers; typically, it has one
        main container (the *default container* is the first one that's added
        to the task definition, and it is marked *essential*) and optionally
        some supporting containers which are used to support the main container,
        doings things like upload logs or metrics to monitoring services.
        
        To run a task or service with Amazon EC2 launch type, use the `Ec2TaskDefinition`. For AWS Fargate tasks/services, use the
        `FargateTaskDefinition`. These classes provide a simplified API that only contain
        properties relevant for that specific launch type.
        
        For a `FargateTaskDefinition`, specify the task size (`memoryLimitMiB` and `cpu`):
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        fargate_task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
            memory_limit_mi_b=512,
            cpu=256
        )
        ```
        
        To add containers to a task definition, call `addContainer()`:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        container = fargate_task_definition.add_container("WebContainer",
            # Use an image from DockerHub
            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
        )
        ```
        
        For a `Ec2TaskDefinition`:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        ec2_task_definition = ecs.Ec2TaskDefinition(self, "TaskDef",
            network_mode=NetworkMode.BRIDGE
        )
        
        container = ec2_task_definition.add_container("WebContainer",
            # Use an image from DockerHub
            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
            memory_limit_mi_b=1024
        )
        ```
        
        You can specify container properties when you add them to the task definition, or with various methods, e.g.:
        
        To add a port mapping when adding a container to the task definition, specify the `portMappings` option:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        task_definition.add_container("WebContainer",
            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
            memory_limit_mi_b=1024,
            port_mappings=[{"container_port": 3000}]
        )
        ```
        
        To add port mappings directly to a container definition, call `addPortMappings()`:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        container.add_port_mappings(
            container_port=3000
        )
        ```
        
        To add data volumes to a task definition, call `addVolume()`:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        volume = {
            # Use an Elastic FileSystem
            "name": "mydatavolume",
            "efs_volume_configuration": ecs.EfsVolumeConfiguration(
                file_system_id="EFS"
            )
        }
        
        container = fargate_task_definition.add_volume("mydatavolume")
        ```
        
        To use a TaskDefinition that can be used with either Amazon EC2 or
        AWS Fargate launch types, use the `TaskDefinition` construct.
        
        When creating a task definition you have to specify what kind of
        tasks you intend to run: Amazon EC2, AWS Fargate, or both.
        The following example uses both:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        task_definition = ecs.TaskDefinition(self, "TaskDef",
            memory_mi_b="512",
            cpu="256",
            network_mode=NetworkMode.AWS_VPC,
            compatibility=ecs.Compatibility.EC2_AND_FARGATE
        )
        ```
        
        ### Images
        
        Images supply the software that runs inside the container. Images can be
        obtained from either DockerHub or from ECR repositories, or built directly from a local Dockerfile.
        
        * `ecs.ContainerImage.fromRegistry(imageName)`: use a public image.
        * `ecs.ContainerImage.fromRegistry(imageName, { credentials: mySecret })`: use a private image that requires credentials.
        * `ecs.ContainerImage.fromEcrRepository(repo, tag)`: use the given ECR repository as the image
          to start. If no tag is provided, "latest" is assumed.
        * `ecs.ContainerImage.fromAsset('./image')`: build and upload an
          image directly from a `Dockerfile` in your source directory.
        * `ecs.ContainerImage.fromDockerImageAsset(asset)`: uses an existing
          `@aws-cdk/aws-ecr-assets.DockerImageAsset` as a container image.
        * `new ecs.TagParameterContainerImage(repository)`: use the given ECR repository as the image
          but a CloudFormation parameter as the tag.
        
        ### Environment variables
        
        To pass environment variables to the container, you can use the `environment`, `environmentFiles`, and `secrets` props.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        task_definition.add_container("container",
            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
            memory_limit_mi_b=1024,
            environment={# clear text, not for sensitive data
                "STAGE": "prod"},
            environment_files=[# list of environment files hosted either on local disk or S3
                ecs.EnvironmentFile.from_asset("./demo-env-file.env"),
                ecs.EnvironmentFile.from_bucket(s3_bucket, "assets/demo-env-file.env")],
            secrets={# Retrieved from AWS Secrets Manager or AWS Systems Manager Parameter Store at container start-up.
                "SECRET": ecs.Secret.from_secrets_manager(secret),
                "DB_PASSWORD": ecs.Secret.from_secrets_manager(db_secret, "password"), # Reference a specific JSON field, (requires platform version 1.4.0 or later for Fargate tasks)
                "PARAMETER": ecs.Secret.from_ssm_parameter(parameter)}
        )
        ```
        
        The task execution role is automatically granted read permissions on the secrets/parameters. Support for environment
        files is restricted to the EC2 launch type for files hosted on S3. Further details provided in the AWS documentation
        about [specifying environment variables](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/taskdef-envfiles.html).
        
        ## Service
        
        A `Service` instantiates a `TaskDefinition` on a `Cluster` a given number of
        times, optionally associating them with a load balancer.
        If a task fails,
        Amazon ECS automatically restarts the task.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        task_definition =
        
        service = ecs.FargateService(self, "Service",
            cluster=cluster,
            task_definition=task_definition,
            desired_count=5
        )
        ```
        
        `Services` by default will create a security group if not provided.
        If you'd like to specify which security groups to use you can override the `securityGroups` property.
        
        ### Deployment circuit breaker and rollback
        
        Amazon ECS [deployment circuit breaker](https://aws.amazon.com/tw/blogs/containers/announcing-amazon-ecs-deployment-circuit-breaker/)
        automatically rolls back unhealthy service deployments without the need for manual intervention. Use `circuitBreaker` to enable
        deployment circuit breaker and optionally enable `rollback` for automatic rollback. See [Using the deployment circuit breaker](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html)
        for more details.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        service = ecs.FargateService(stack, "Service",
            cluster=cluster,
            task_definition=task_definition,
            circuit_breaker={"rollback": True}
        )
        ```
        
        ### Include an application/network load balancer
        
        `Services` are load balancing targets and can be added to a target group, which will be attached to an application/network load balancers:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_elasticloadbalancingv2 as elbv2
        
        service = ecs.FargateService(self, "Service")
        
        lb = elbv2.ApplicationLoadBalancer(self, "LB", vpc=vpc, internet_facing=True)
        listener = lb.add_listener("Listener", port=80)
        target_group1 = listener.add_targets("ECS1",
            port=80,
            targets=[service]
        )
        target_group2 = listener.add_targets("ECS2",
            port=80,
            targets=[service.load_balancer_target(
                container_name="MyContainer",
                container_port=8080
            )]
        )
        ```
        
        Note that in the example above, the default `service` only allows you to register the first essential container or the first mapped port on the container as a target and add it to a new target group. To have more control over which container and port to register as targets, you can use `service.loadBalancerTarget()` to return a load balancing target for a specific container and port.
        
        Alternatively, you can also create all load balancer targets to be registered in this service, add them to target groups, and attach target groups to listeners accordingly.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_elasticloadbalancingv2 as elbv2
        
        service = ecs.FargateService(self, "Service")
        
        lb = elbv2.ApplicationLoadBalancer(self, "LB", vpc=vpc, internet_facing=True)
        listener = lb.add_listener("Listener", port=80)
        service.register_load_balancer_targets(
            container_name="web",
            container_port=80,
            new_target_group_id="ECS",
            listener=ecs.ListenerConfig.application_listener(listener,
                protocol=elbv2.ApplicationProtocol.HTTPS
            )
        )
        ```
        
        ### Using a Load Balancer from a different Stack
        
        If you want to put your Load Balancer and the Service it is load balancing to in
        different stacks, you may not be able to use the convenience methods
        `loadBalancer.addListener()` and `listener.addTargets()`.
        
        The reason is that these methods will create resources in the same Stack as the
        object they're called on, which may lead to cyclic references between stacks.
        Instead, you will have to create an `ApplicationListener` in the service stack,
        or an empty `TargetGroup` in the load balancer stack that you attach your
        service to.
        
        See the [ecs/cross-stack-load-balancer example](https://github.com/aws-samples/aws-cdk-examples/tree/master/typescript/ecs/cross-stack-load-balancer/)
        for the alternatives.
        
        ### Include a classic load balancer
        
        `Services` can also be directly attached to a classic load balancer as targets:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_elasticloadbalancing as elb
        
        service = ecs.Ec2Service(self, "Service")
        
        lb = elb.LoadBalancer(stack, "LB", vpc=vpc)
        lb.add_listener(external_port=80)
        lb.add_target(service)
        ```
        
        Similarly, if you want to have more control over load balancer targeting:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_elasticloadbalancing as elb
        
        service = ecs.Ec2Service(self, "Service")
        
        lb = elb.LoadBalancer(stack, "LB", vpc=vpc)
        lb.add_listener(external_port=80)
        lb.add_target(service.load_balancer_target(
            container_name="MyContainer",
            container_port=80
        ))
        ```
        
        There are two higher-level constructs available which include a load balancer for you that can be found in the aws-ecs-patterns module:
        
        * `LoadBalancedFargateService`
        * `LoadBalancedEc2Service`
        
        ## Task Auto-Scaling
        
        You can configure the task count of a service to match demand. Task auto-scaling is
        configured by calling `autoScaleTaskCount()`:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        scaling = service.auto_scale_task_count(max_capacity=10)
        scaling.scale_on_cpu_utilization("CpuScaling",
            target_utilization_percent=50
        )
        
        scaling.scale_on_request_count("RequestScaling",
            requests_per_target=10000,
            target_group=target
        )
        ```
        
        Task auto-scaling is powered by *Application Auto-Scaling*.
        See that section for details.
        
        ## Integration with CloudWatch Events
        
        To start an Amazon ECS task on an Amazon EC2-backed Cluster, instantiate an
        `@aws-cdk/aws-events-targets.EcsTask` instead of an `Ec2Service`:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_events_targets as targets
        
        # Create a Task Definition for the container to start
        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
        task_definition.add_container("TheContainer",
            image=ecs.ContainerImage.from_asset(path.resolve(__dirname, "..", "eventhandler-image")),
            memory_limit_mi_b=256,
            logging=ecs.AwsLogDriver(stream_prefix="EventDemo", mode=AwsLogDriverMode.NON_BLOCKING)
        )
        
        # An Rule that describes the event trigger (in this case a scheduled run)
        rule = events.Rule(self, "Rule",
            schedule=events.Schedule.expression("rate(1 min)")
        )
        
        # Pass an environment variable to the container 'TheContainer' in the task
        rule.add_target(targets.EcsTask(
            cluster=cluster,
            task_definition=task_definition,
            task_count=1,
            container_overrides=[ContainerOverride(
                container_name="TheContainer",
                environment=[TaskEnvironmentVariable(
                    name="I_WAS_TRIGGERED",
                    value="From CloudWatch Events"
                )]
            )]
        ))
        ```
        
        ## Log Drivers
        
        Currently Supported Log Drivers:
        
        * awslogs
        * fluentd
        * gelf
        * journald
        * json-file
        * splunk
        * syslog
        * awsfirelens
        
        ### awslogs Log Driver
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Create a Task Definition for the container to start
        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
        task_definition.add_container("TheContainer",
            image=ecs.ContainerImage.from_registry("example-image"),
            memory_limit_mi_b=256,
            logging=ecs.LogDrivers.aws_logs(stream_prefix="EventDemo")
        )
        ```
        
        ### fluentd Log Driver
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Create a Task Definition for the container to start
        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
        task_definition.add_container("TheContainer",
            image=ecs.ContainerImage.from_registry("example-image"),
            memory_limit_mi_b=256,
            logging=ecs.LogDrivers.fluentd()
        )
        ```
        
        ### gelf Log Driver
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Create a Task Definition for the container to start
        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
        task_definition.add_container("TheContainer",
            image=ecs.ContainerImage.from_registry("example-image"),
            memory_limit_mi_b=256,
            logging=ecs.LogDrivers.gelf(address="my-gelf-address")
        )
        ```
        
        ### journald Log Driver
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Create a Task Definition for the container to start
        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
        task_definition.add_container("TheContainer",
            image=ecs.ContainerImage.from_registry("example-image"),
            memory_limit_mi_b=256,
            logging=ecs.LogDrivers.journald()
        )
        ```
        
        ### json-file Log Driver
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Create a Task Definition for the container to start
        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
        task_definition.add_container("TheContainer",
            image=ecs.ContainerImage.from_registry("example-image"),
            memory_limit_mi_b=256,
            logging=ecs.LogDrivers.json_file()
        )
        ```
        
        ### splunk Log Driver
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Create a Task Definition for the container to start
        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
        task_definition.add_container("TheContainer",
            image=ecs.ContainerImage.from_registry("example-image"),
            memory_limit_mi_b=256,
            logging=ecs.LogDrivers.splunk(
                token=cdk.SecretValue.secrets_manager("my-splunk-token"),
                url="my-splunk-url"
            )
        )
        ```
        
        ### syslog Log Driver
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Create a Task Definition for the container to start
        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
        task_definition.add_container("TheContainer",
            image=ecs.ContainerImage.from_registry("example-image"),
            memory_limit_mi_b=256,
            logging=ecs.LogDrivers.syslog()
        )
        ```
        
        ### firelens Log Driver
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Create a Task Definition for the container to start
        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
        task_definition.add_container("TheContainer",
            image=ecs.ContainerImage.from_registry("example-image"),
            memory_limit_mi_b=256,
            logging=ecs.LogDrivers.firelens(
                options={
                    "Name": "firehose",
                    "region": "us-west-2",
                    "delivery_stream": "my-stream"
                }
            )
        )
        ```
        
        ### Generic Log Driver
        
        A generic log driver object exists to provide a lower level abstraction of the log driver configuration.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Create a Task Definition for the container to start
        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
        task_definition.add_container("TheContainer",
            image=ecs.ContainerImage.from_registry("example-image"),
            memory_limit_mi_b=256,
            logging=ecs.GenericLogDriver(
                log_driver="fluentd",
                options={
                    "tag": "example-tag"
                }
            )
        )
        ```
        
        ## CloudMap Service Discovery
        
        To register your ECS service with a CloudMap Service Registry, you may add the
        `cloudMapOptions` property to your service:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        service = ecs.Ec2Service(stack, "Service",
            cluster=cluster,
            task_definition=task_definition,
            cloud_map_options={
                # Create A records - useful for AWSVPC network mode.
                "dns_record_type": cloudmap.DnsRecordType.A
            }
        )
        ```
        
        With `bridge` or `host` network modes, only `SRV` DNS record types are supported.
        By default, `SRV` DNS record types will target the default container and default
        port. However, you may target a different container and port on the same ECS task:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        # Add a container to the task definition
        specific_container = task_definition.add_container(...)
        
        # Add a port mapping
        specific_container.add_port_mappings(
            container_port=7600,
            protocol=ecs.Protocol.TCP
        )
        
        ecs.Ec2Service(stack, "Service",
            cluster=cluster,
            task_definition=task_definition,
            cloud_map_options={
                # Create SRV records - useful for bridge networking
                "dns_record_type": cloudmap.DnsRecordType.SRV,
                # Targets port TCP port 7600 `specificContainer`
                "container": specific_container,
                "container_port": 7600
            }
        )
        ```
        
        ### Associate With a Specific CloudMap Service
        
        You may associate an ECS service with a specific CloudMap service. To do
        this, use the service's `associateCloudMapService` method:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        cloud_map_service = cloudmap.Service(...)
        ecs_service = ecs.FargateService(...)
        
        ecs_service.associate_cloud_map_service(
            service=cloud_map_service
        )
        ```
        
        ## Capacity Providers
        
        There are two major families of Capacity Providers: [AWS
        Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/fargate-capacity-providers.html)
        (including Fargate Spot) and EC2 [Auto Scaling
        Group](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/asg-capacity-providers.html)
        Capacity Providers. Both are supported.
        
        ### Fargate Capacity Providers
        
        To enable Fargate capacity providers, you can either set
        `enableFargateCapacityProviders` to `true` when creating your cluster, or by
        invoking the `enableFargateCapacityProviders()` method after creating your
        cluster. This will add both `FARGATE` and `FARGATE_SPOT` as available capacity
        providers on your cluster.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        cluster = ecs.Cluster(stack, "FargateCPCluster",
            vpc=vpc,
            enable_fargate_capacity_providers=True
        )
        
        task_definition = ecs.FargateTaskDefinition(stack, "TaskDef")
        
        task_definition.add_container("web",
            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
        )
        
        ecs.FargateService(stack, "FargateService",
            cluster=cluster,
            task_definition=task_definition,
            capacity_provider_strategies=[{
                "capacity_provider": "FARGATE_SPOT",
                "weight": 2
            }, {
                "capacity_provider": "FARGATE",
                "weight": 1
            }
            ]
        )
        ```
        
        ### Auto Scaling Group Capacity Providers
        
        To add an Auto Scaling Group Capacity Provider, first create an EC2 Auto Scaling
        Group. Then, create an `AsgCapacityProvider` and pass the Auto Scaling Group to
        it in the constructor. Then add the Capacity Provider to the cluster. Finally,
        you can refer to the Provider by its name in your service's or task's Capacity
        Provider strategy.
        
        By default, an Auto Scaling Group Capacity Provider will manage the Auto Scaling
        Group's size for you. It will also enable managed termination protection, in
        order to prevent EC2 Auto Scaling from terminating EC2 instances that have tasks
        running on them. If you want to disable this behavior, set both
        `enableManagedScaling` to and `enableManagedTerminationProtection` to `false`.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        cluster = ecs.Cluster(stack, "Cluster",
            vpc=vpc
        )
        
        auto_scaling_group = autoscaling.AutoScalingGroup(stack, "ASG",
            vpc=vpc,
            instance_type=ec2.InstanceType("t2.micro"),
            machine_image=ecs.EcsOptimizedImage.amazon_linux2(),
            min_capacity=0,
            max_capacity=100
        )
        
        capacity_provider = ecs.AsgCapacityProvider(stack, "AsgCapacityProvider",
            auto_scaling_group=auto_scaling_group
        )
        cluster.add_asg_capacity_provider(capacity_provider)
        
        task_definition = ecs.Ec2TaskDefinition(stack, "TaskDef")
        
        task_definition.add_container("web",
            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample", memory_reservation_mi_b, 256)
        )
        
        ecs.Ec2Service(stack, "EC2Service",
            cluster=cluster,
            task_definition=task_definition,
            capacity_provider_strategies=[{
                "capacity_provider": capacity_provider.capacity_provider_name,
                "weight": 1
            }
            ]
        )
        ```
        
        ## Elastic Inference Accelerators
        
        Currently, this feature is only supported for services with EC2 launch types.
        
        To add elastic inference accelerators to your EC2 instance, first add
        `inferenceAccelerators` field to the Ec2TaskDefinition and set the `deviceName`
        and `deviceType` properties.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        inference_accelerators = [{
            "device_name": "device1",
            "device_type": "eia2.medium"
        }]
        
        task_definition = ecs.Ec2TaskDefinition(stack, "Ec2TaskDef",
            inference_accelerators=inference_accelerators
        )
        ```
        
        To enable using the inference accelerators in the containers, add `inferenceAcceleratorResources`
        field and set it to a list of device names used for the inference accelerators. Each value in the
        list should match a `DeviceName` for an `InferenceAccelerator` specified in the task definition.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        inference_accelerator_resources = ["device1"]
        
        task_definition.add_container("cont",
            image=ecs.ContainerImage.from_registry("test"),
            memory_limit_mi_b=1024,
            inference_accelerator_resources=inference_accelerator_resources
        )
        ```
        
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: JavaScript
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Typing :: Typed
Classifier: Development Status :: 5 - Production/Stable
Classifier: License :: OSI Approved
Classifier: Framework :: AWS CDK
Classifier: Framework :: AWS CDK :: 1
Requires-Python: >=3.6
Description-Content-Type: text/markdown
