aws-cdk-lib 2.191.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
         )
     '''
 

aws_cdk/aws_events/__init__.py

@@ -89,6 +89,22 @@ on_commit_rule.add_target(targets.SnsTopic(topic,
 ))
 ```
 
+### Role
+
+You can specify an IAM Role:
+
+```python
+# role: iam.IRole
+
+
+events.Rule(self, "MyRule",
+    schedule=events.Schedule.cron(minute="0", hour="4"),
+    role=role
+)
+```
+
+**Note**: If you're setting an event bus in another account as the target and that account granted permission to your account through an organization instead of directly by the account ID, you must specify a RoleArn with proper permissions in the Target structure, instead of here in this parameter.
+
 ### Matchers
 
 To define a pattern, use the `Match` class, which provides a number of factory methods to declare
@@ -10518,6 +10534,7 @@ class Rule(
         *,
         enabled: typing.Optional[builtins.bool] = None,
         event_bus: typing.Optional[IEventBus] = None,
+        role: typing.Optional[_IRole_235f5d8e] = None,
         schedule: typing.Optional["Schedule"] = None,
         targets: typing.Optional[typing.Sequence[IRuleTarget]] = None,
         cross_stack_scope: typing.Optional[_constructs_77d1e7e8.Construct] = None,
@@ -10530,6 +10547,7 @@ class Rule(
         :param id: -
         :param enabled: Indicates whether the rule is enabled. Default: true
         :param event_bus: The event bus to associate with this rule. Default: - The default event bus.
+        :param role: The role that is used for target invocation. Must be assumable by principal ``events.amazonaws.com``. Default: - No role associated
         :param schedule: The schedule or rate (frequency) that determines when EventBridge runs the rule. You must specify this property, the ``eventPattern`` property, or both. For more information, see Schedule Expression Syntax for Rules in the Amazon EventBridge User Guide. Default: - None.
         :param targets: Targets to invoke when this rule matches an event. Input will be the full matched event. If you wish to specify custom target input, use ``addTarget(target[, inputOptions])``. Default: - No targets.
         :param cross_stack_scope: The scope to use if the source of the rule and its target are in different Stacks (but in the same account & region). This helps dealing with cycles that often arise in these situations. Default: - none (the main scope will be used, even for cross-stack Events)
@@ -10544,6 +10562,7 @@ class Rule(
         props = RuleProps(
             enabled=enabled,
             event_bus=event_bus,
+            role=role,
             schedule=schedule,
             targets=targets,
             cross_stack_scope=cross_stack_scope,
@@ -10686,6 +10705,7 @@ class Rule(
         "rule_name": "ruleName",
         "enabled": "enabled",
         "event_bus": "eventBus",
+        "role": "role",
         "schedule": "schedule",
         "targets": "targets",
     },
@@ -10700,6 +10720,7 @@ class RuleProps(EventCommonOptions):
         rule_name: typing.Optional[builtins.str] = None,
         enabled: typing.Optional[builtins.bool] = None,
         event_bus: typing.Optional[IEventBus] = None,
+        role: typing.Optional[_IRole_235f5d8e] = None,
         schedule: typing.Optional["Schedule"] = None,
         targets: typing.Optional[typing.Sequence[IRuleTarget]] = None,
     ) -> None:
@@ -10711,6 +10732,7 @@ class RuleProps(EventCommonOptions):
         :param rule_name: A name for the rule. Default: AWS CloudFormation generates a unique physical ID.
         :param enabled: Indicates whether the rule is enabled. Default: true
         :param event_bus: The event bus to associate with this rule. Default: - The default event bus.
+        :param role: The role that is used for target invocation. Must be assumable by principal ``events.amazonaws.com``. Default: - No role associated
         :param schedule: The schedule or rate (frequency) that determines when EventBridge runs the rule. You must specify this property, the ``eventPattern`` property, or both. For more information, see Schedule Expression Syntax for Rules in the Amazon EventBridge User Guide. Default: - None.
         :param targets: Targets to invoke when this rule matches an event. Input will be the full matched event. If you wish to specify custom target input, use ``addTarget(target[, inputOptions])``. Default: - No targets.
 
@@ -10745,6 +10767,7 @@ class RuleProps(EventCommonOptions):
             check_type(argname="argument rule_name", value=rule_name, expected_type=type_hints["rule_name"])
             check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
             check_type(argname="argument event_bus", value=event_bus, expected_type=type_hints["event_bus"])
+            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
             check_type(argname="argument schedule", value=schedule, expected_type=type_hints["schedule"])
             check_type(argname="argument targets", value=targets, expected_type=type_hints["targets"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
@@ -10760,6 +10783,8 @@ class RuleProps(EventCommonOptions):
             self._values["enabled"] = enabled
         if event_bus is not None:
             self._values["event_bus"] = event_bus
+        if role is not None:
+            self._values["role"] = role
         if schedule is not None:
             self._values["schedule"] = schedule
         if targets is not None:
@@ -10827,6 +10852,17 @@ class RuleProps(EventCommonOptions):
         result = self._values.get("event_bus")
         return typing.cast(typing.Optional[IEventBus], result)
 
+    @builtins.property
+    def role(self) -> typing.Optional[_IRole_235f5d8e]:
+        '''The role that is used for target invocation.
+
+        Must be assumable by principal ``events.amazonaws.com``.
+
+        :default: - No role associated
+        '''
+        result = self._values.get("role")
+        return typing.cast(typing.Optional[_IRole_235f5d8e], result)
+
     @builtins.property
     def schedule(self) -> typing.Optional["Schedule"]:
         '''The schedule or rate (frequency) that determines when EventBridge runs the rule.
@@ -13564,6 +13600,7 @@ def _typecheckingstub__15ada85ef5f1cb4f0237eff6253e200138049f1bebbea7163294d28f9
     *,
     enabled: typing.Optional[builtins.bool] = None,
     event_bus: typing.Optional[IEventBus] = None,
+    role: typing.Optional[_IRole_235f5d8e] = None,
     schedule: typing.Optional[Schedule] = None,
     targets: typing.Optional[typing.Sequence[IRuleTarget]] = None,
     cross_stack_scope: typing.Optional[_constructs_77d1e7e8.Construct] = None,
@@ -13596,6 +13633,7 @@ def _typecheckingstub__26677a946da4037892c1c589c005b7536d8ffed632ca92c5c52a92586
     rule_name: typing.Optional[builtins.str] = None,
     enabled: typing.Optional[builtins.bool] = None,
     event_bus: typing.Optional[IEventBus] = None,
+    role: typing.Optional[_IRole_235f5d8e] = None,
     schedule: typing.Optional[Schedule] = None,
     targets: typing.Optional[typing.Sequence[IRuleTarget]] = None,
 ) -> None: