aws-cdk-lib 2.190.0__py3-none-any.whl → 2.192.0__py3-none-any.whl

aws_cdk/aws_ecs/__init__.py

@@ -19995,28 +19995,43 @@ class ClusterProps:
 
         Example::
 
-            vpc = ec2.Vpc.from_lookup(self, "Vpc",
-                is_default=True
+            # vpc: ec2.Vpc
+            
+            
+            cluster = ecs.Cluster(self, "Cluster",
+                vpc=vpc
             )
-            cluster = ecs.Cluster(self, "ECSCluster", vpc=vpc)
             
-            task_definition = ecs.TaskDefinition(self, "TD",
-                compatibility=ecs.Compatibility.FARGATE,
-                cpu="256",
-                memory_mi_b="512"
+            auto_scaling_group = autoscaling.AutoScalingGroup(self, "ASG",
+                vpc=vpc,
+                instance_type=ec2.InstanceType("t2.micro"),
+                machine_image=ecs.EcsOptimizedImage.amazon_linux2(),
+                min_capacity=0,
+                max_capacity=100
             )
             
-            task_definition.add_container("TheContainer",
-                image=ecs.ContainerImage.from_registry("foo/bar")
+            capacity_provider = ecs.AsgCapacityProvider(self, "AsgCapacityProvider",
+                auto_scaling_group=auto_scaling_group,
+                instance_warmup_period=300
             )
+            cluster.add_asg_capacity_provider(capacity_provider)
             
-            run_task = tasks.EcsRunTask(self, "Run",
-                integration_pattern=sfn.IntegrationPattern.RUN_JOB,
+            task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
+            
+            task_definition.add_container("web",
+                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
+                memory_reservation_mi_b=256
+            )
+            
+            ecs.Ec2Service(self, "EC2Service",
                 cluster=cluster,
                 task_definition=task_definition,
-                launch_target=tasks.EcsFargateLaunchTarget(),
-                cpu="1024",
-                memory_mi_b="1048"
+                min_healthy_percent=100,
+                capacity_provider_strategies=[ecs.CapacityProviderStrategy(
+                    capacity_provider=capacity_provider.capacity_provider_name,
+                    weight=1
+                )
+                ]
             )
         '''
         if isinstance(capacity, dict):
@@ -21173,26 +21188,34 @@ class ContainerDefinitionOptions:
 
         Example::
 
+            # task_definition: ecs.TaskDefinition
             # cluster: ecs.Cluster
-            # vpc: ec2.Vpc
             
-            service = ecs_patterns.ApplicationLoadBalancedFargateService(self, "Service",
+            
+            # Add a container to the task definition
+            specific_container = task_definition.add_container("Container",
+                image=ecs.ContainerImage.from_registry("/aws/aws-example-app"),
+                memory_limit_mi_b=2048
+            )
+            
+            # Add a port mapping
+            specific_container.add_port_mappings(
+                container_port=7600,
+                protocol=ecs.Protocol.TCP
+            )
+            
+            ecs.Ec2Service(self, "Service",
                 cluster=cluster,
-                vpc=vpc,
-                desired_count=1,
+                task_definition=task_definition,
                 min_healthy_percent=100,
-                task_image_options=ecsPatterns.ApplicationLoadBalancedTaskImageOptions(
-                    image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
-                    docker_labels={
-                        "application.label.one": "first_label",
-                        "application.label.two": "second_label"
-                    }
+                cloud_map_options=ecs.CloudMapOptions(
+                    # 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
                 )
             )
-            
-            service.task_definition.add_container("Sidecar",
-                image=ecs.ContainerImage.from_registry("example/metrics-sidecar")
-            )
         '''
         if isinstance(health_check, dict):
             health_check = HealthCheck(**health_check)
@@ -22674,32 +22697,24 @@ class ContainerImage(
 
     Example::
 
-        # vpc: ec2.Vpc
+        # my_file_system: efs.IFileSystem
+        # my_job_role: iam.Role
         
+        my_file_system.grant_read(my_job_role)
         
-        cluster = ecs.Cluster(self, "FargateCPCluster",
-            vpc=vpc,
-            enable_fargate_capacity_providers=True
-        )
-        
-        task_definition = ecs.FargateTaskDefinition(self, "TaskDef")
-        
-        task_definition.add_container("web",
-            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
-        )
-        
-        ecs.FargateService(self, "FargateService",
-            cluster=cluster,
-            task_definition=task_definition,
-            min_healthy_percent=100,
-            capacity_provider_strategies=[ecs.CapacityProviderStrategy(
-                capacity_provider="FARGATE_SPOT",
-                weight=2
-            ), ecs.CapacityProviderStrategy(
-                capacity_provider="FARGATE",
-                weight=1
+        job_defn = batch.EcsJobDefinition(self, "JobDefn",
+            container=batch.EcsEc2ContainerDefinition(self, "containerDefn",
+                image=ecs.ContainerImage.from_registry("public.ecr.aws/amazonlinux/amazonlinux:latest"),
+                memory=cdk.Size.mebibytes(2048),
+                cpu=256,
+                volumes=[batch.EcsVolume.efs(
+                    name="myVolume",
+                    file_system=my_file_system,
+                    container_path="/Volumes/myVolume",
+                    use_job_role=True
+                )],
+                job_role=my_job_role
             )
-            ]
         )
     '''
 
@@ -24372,18 +24387,31 @@ class Ec2ServiceProps(BaseServiceOptions):
 
         Example::
 
-            # cluster: ecs.Cluster
-            # task_definition: ecs.TaskDefinition
             # vpc: ec2.Vpc
             
-            service = ecs.Ec2Service(self, "Service", cluster=cluster, task_definition=task_definition, min_healthy_percent=100)
             
-            lb = elb.LoadBalancer(self, "LB", vpc=vpc)
-            lb.add_listener(external_port=80)
-            lb.add_target(service.load_balancer_target(
-                container_name="MyContainer",
-                container_port=80
-            ))
+            # 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,
+                min_healthy_percent=100
+            )
         '''
         if isinstance(circuit_breaker, dict):
             circuit_breaker = DeploymentCircuitBreaker(**circuit_breaker)
@@ -24927,13 +24955,14 @@ class Ec2TaskDefinitionProps(CommonTaskDefinitionProps):
 
         Example::
 
-            inference_accelerators = [{
-                "device_name": "device1",
-                "device_type": "eia2.medium"
-            }]
+            ec2_task_definition = ecs.Ec2TaskDefinition(self, "TaskDef",
+                network_mode=ecs.NetworkMode.BRIDGE
+            )
             
-            task_definition = ecs.Ec2TaskDefinition(self, "Ec2TaskDef",
-                inference_accelerators=inference_accelerators
+            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
             )
         '''
         if __debug__:
@@ -27180,21 +27209,39 @@ class FargateServiceProps(BaseServiceOptions):
 
         Example::
 
+            import aws_cdk.aws_cloudwatch as cw
+            
             # cluster: ecs.Cluster
             # task_definition: ecs.TaskDefinition
-            # vpc: ec2.Vpc
             
-            service = ecs.FargateService(self, "Service", cluster=cluster, task_definition=task_definition, min_healthy_percent=100)
+            service_name = "MyFargateService"
+            service = ecs.FargateService(self, "Service",
+                service_name=service_name,
+                cluster=cluster,
+                task_definition=task_definition,
+                min_healthy_percent=100
+            )
             
-            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
-                )
+            cpu_metric = cw.Metric(
+                metric_name="CPUUtilization",
+                namespace="AWS/ECS",
+                period=Duration.minutes(5),
+                statistic="Average",
+                dimensions_map={
+                    "ClusterName": cluster.cluster_name,
+                    # Using `service.serviceName` here will cause a circular dependency
+                    "ServiceName": service_name
+                }
+            )
+            my_alarm = cw.Alarm(self, "CPUAlarm",
+                alarm_name="cpuAlarmName",
+                metric=cpu_metric,
+                evaluation_periods=2,
+                threshold=80
+            )
+            
+            service.enable_deployment_alarms([my_alarm.alarm_name],
+                behavior=ecs.AlarmBehavior.FAIL_ON_ALARM
             )
         '''
         if isinstance(circuit_breaker, dict):
@@ -27699,14 +27746,20 @@ class FargateTaskDefinitionProps(CommonTaskDefinitionProps):
 
         Example::
 
-            fargate_task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
+            # Create a Task Definition for the Windows container to start
+            task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
                 runtime_platform=ecs.RuntimePlatform(
-                    operating_system_family=ecs.OperatingSystemFamily.LINUX,
-                    cpu_architecture=ecs.CpuArchitecture.ARM64
+                    operating_system_family=ecs.OperatingSystemFamily.WINDOWS_SERVER_2019_CORE,
+                    cpu_architecture=ecs.CpuArchitecture.X86_64
                 ),
-                memory_limit_mi_b=512,
-                cpu=256,
-                pid_mode=ecs.PidMode.TASK
+                cpu=1024,
+                memory_limit_mi_b=2048
+            )
+            
+            task_definition.add_container("windowsservercore",
+                logging=ecs.LogDriver.aws_logs(stream_prefix="win-iis-on-fargate"),
+                port_mappings=[ecs.PortMapping(container_port=80)],
+                image=ecs.ContainerImage.from_registry("mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2019")
             )
         '''
         if isinstance(runtime_platform, dict):
@@ -35281,22 +35334,29 @@ class ServiceConnectProps:
 
             # cluster: ecs.Cluster
             # task_definition: ecs.TaskDefinition
+            # container_options: ecs.ContainerDefinitionOptions
+            
+            
+            container = task_definition.add_container("MyContainer", container_options)
+            
+            container.add_port_mappings(
+                name="api",
+                container_port=8080
+            )
             
+            cluster.add_default_cloud_map_namespace(
+                name="local"
+            )
             
-            custom_service = ecs.FargateService(self, "CustomizedService",
+            service = ecs.FargateService(self, "Service",
                 cluster=cluster,
                 task_definition=task_definition,
                 min_healthy_percent=100,
                 service_connect_configuration=ecs.ServiceConnectProps(
-                    log_driver=ecs.LogDrivers.aws_logs(
-                        stream_prefix="sc-traffic"
-                    ),
                     services=[ecs.ServiceConnectService(
                         port_mapping_name="api",
-                        dns_name="customized-api",
-                        port=80,
-                        ingress_port_override=20040,
-                        discovery_name="custom"
+                        dns_name="http-api",
+                        port=80
                     )
                     ]
                 )
@@ -37234,28 +37294,21 @@ class TaskDefinition(
 
     Example::
 
-        import aws_cdk.aws_cloudwatch as cw
-        
         # cluster: ecs.Cluster
         # task_definition: ecs.TaskDefinition
+        # vpc: ec2.Vpc
         
+        service = ecs.FargateService(self, "Service", cluster=cluster, task_definition=task_definition, min_healthy_percent=100)
         
-        service = ecs.FargateService(self, "Service",
-            cluster=cluster,
-            task_definition=task_definition
-        )
-        
-        cpu_alarm_name = "MyCpuMetricAlarm"
-        my_alarm = cw.Alarm(self, "CPUAlarm",
-            alarm_name=cpu_alarm_name,
-            metric=service.metric_cpu_utilization(),
-            evaluation_periods=2,
-            threshold=80
-        )
-        
-        # Using `myAlarm.alarmName` here will cause a circular dependency
-        service.enable_deployment_alarms([cpu_alarm_name],
-            behavior=ecs.AlarmBehavior.FAIL_ON_ALARM
+        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
+            )
         )
     '''
 
@@ -39648,31 +39701,24 @@ class Cluster(
 
     Example::
 
-        import aws_cdk.aws_elasticloadbalancingv2 as elbv2
+        from aws_cdk import Tags
         
         
-        # The VPC and subnet must have associated IPv6 CIDR blocks.
-        vpc = ec2.Vpc(self, "Vpc",
-            ip_protocol=ec2.IpProtocol.DUAL_STACK
-        )
+        vpc = ec2.Vpc(self, "Vpc", max_azs=1)
         cluster = ecs.Cluster(self, "EcsCluster", vpc=vpc)
-        
-        service = ecs_patterns.ApplicationLoadBalancedFargateService(self, "myService",
-            cluster=cluster,
-            task_image_options=ecsPatterns.ApplicationLoadBalancedTaskImageOptions(
-                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
-            ),
-            min_healthy_percent=100,
-            ip_address_type=elbv2.IpAddressType.DUAL_STACK
+        task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
+            memory_limit_mi_b=512,
+            cpu=256
         )
-        
-        application_load_balanced_ec2_service = ecs_patterns.ApplicationLoadBalancedEc2Service(self, "myService",
+        task_definition.add_container("WebContainer",
+            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
+        )
+        Tags.of(task_definition).add("my-tag", "my-tag-value")
+        scheduled_fargate_task = ecs_patterns.ScheduledFargateTask(self, "ScheduledFargateTask",
             cluster=cluster,
-            task_image_options=ecsPatterns.ApplicationLoadBalancedTaskImageOptions(
-                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
-            ),
-            min_healthy_percent=100,
-            ip_address_type=elbv2.IpAddressType.DUAL_STACK
+            task_definition=task_definition,
+            schedule=appscaling.Schedule.expression("rate(1 minute)"),
+            propagate_tags=ecs.PropagatedTagSource.TASK_DEFINITION
         )
     '''
 
@@ -41663,18 +41709,31 @@ class Ec2Service(
 
     Example::
 
-        # cluster: ecs.Cluster
-        # task_definition: ecs.TaskDefinition
         # vpc: ec2.Vpc
         
-        service = ecs.Ec2Service(self, "Service", cluster=cluster, task_definition=task_definition, min_healthy_percent=100)
         
-        lb = elb.LoadBalancer(self, "LB", vpc=vpc)
-        lb.add_listener(external_port=80)
-        lb.add_target(service.load_balancer_target(
-            container_name="MyContainer",
-            container_port=80
-        ))
+        # 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,
+            min_healthy_percent=100
+        )
     '''
 
     def __init__(
@@ -41879,17 +41938,15 @@ class Ec2TaskDefinition(
 
     Example::
 
-        # secret: ecs.Secret
-        
-        
         # 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(
-                secret_token=secret,
-                url="my-splunk-url"
+            logging=ecs.LogDrivers.aws_logs(
+                stream_prefix="EventDemo",
+                mode=ecs.AwsLogDriverMode.NON_BLOCKING,
+                max_buffer_size=Size.mebibytes(25)
             )
         )
     '''
@@ -42593,21 +42650,39 @@ class FargateService(
 
     Example::
 
+        import aws_cdk.aws_cloudwatch as cw
+        
         # cluster: ecs.Cluster
         # task_definition: ecs.TaskDefinition
-        # vpc: ec2.Vpc
         
-        service = ecs.FargateService(self, "Service", cluster=cluster, task_definition=task_definition, min_healthy_percent=100)
+        service_name = "MyFargateService"
+        service = ecs.FargateService(self, "Service",
+            service_name=service_name,
+            cluster=cluster,
+            task_definition=task_definition,
+            min_healthy_percent=100
+        )
         
-        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
-            )
+        cpu_metric = cw.Metric(
+            metric_name="CPUUtilization",
+            namespace="AWS/ECS",
+            period=Duration.minutes(5),
+            statistic="Average",
+            dimensions_map={
+                "ClusterName": cluster.cluster_name,
+                # Using `service.serviceName` here will cause a circular dependency
+                "ServiceName": service_name
+            }
+        )
+        my_alarm = cw.Alarm(self, "CPUAlarm",
+            alarm_name="cpuAlarmName",
+            metric=cpu_metric,
+            evaluation_periods=2,
+            threshold=80
+        )
+        
+        service.enable_deployment_alarms([my_alarm.alarm_name],
+            behavior=ecs.AlarmBehavior.FAIL_ON_ALARM
         )
     '''