konokenj.cdk-api-mcp-server 0.44.0__py3-none-any.whl → 0.46.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.exec-command.ts

@@ -3,11 +3,16 @@ import * as kms from 'aws-cdk-lib/aws-kms';
 import * as logs from 'aws-cdk-lib/aws-logs';
 import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as cdk from 'aws-cdk-lib';
-import { Duration } from 'aws-cdk-lib';
-import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 
-const app = new cdk.App();
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
+    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
+    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
+  },
+});
 const stack = new cdk.Stack(app, 'aws-ecs-integ-exec-command');
 
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
@@ -22,7 +27,7 @@ const execBucket = new s3.Bucket(stack, 'EcsExecBucket', {
   encryptionKey: kmsKey,
 });
 
-const cluster = new ecs.Cluster(stack, 'FargateCluster', {
+const cluster = new ecs.Cluster(stack, 'Ec2Cluster', {
   vpc,
   executeCommandConfiguration: {
     kmsKey,
@@ -36,32 +41,21 @@ const cluster = new ecs.Cluster(stack, 'FargateCluster', {
     logging: ecs.ExecuteCommandLogging.OVERRIDE,
   },
 });
+cluster.addCapacity('DefaultAutoScalingGroup', {
+  instanceType: new ec2.InstanceType('t2.micro'),
+});
 
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef');
+const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef');
 
 taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  healthCheck: {
-    command: ['CMD-SHELL', 'curl localhost:8000'],
-    interval: Duration.seconds(60),
-    timeout: Duration.seconds(40),
-  },
+  memoryLimitMiB: 256,
 });
 
-new ecs.FargateService(stack, 'FargateService', {
+new ecs.Ec2Service(stack, 'Ec2Service', {
   cluster,
   taskDefinition,
   enableExecuteCommand: true,
 });
 
-new integ.IntegTest(app, 'exec-command-integ-test', {
-  testCases: [stack],
-  diffAssets: true,
-  cdkCommandOptions: {
-    deploy: {
-      args: {
-        rollback: true,
-      },
-    },
-  },
-});
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.lb-awsvpc-nw.ts

@@ -3,38 +3,48 @@ import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
 import * as cdk from 'aws-cdk-lib';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 
-const app = new cdk.App();
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
+    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
+    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
+  },
+});
 const stack = new cdk.Stack(app, 'aws-ecs-integ');
 
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
 
-const cluster = new ecs.Cluster(stack, 'FargateCluster', { vpc });
+const cluster = new ecs.Cluster(stack, 'EcsCluster', { vpc });
+cluster.addCapacity('DefaultAutoScalingGroup', {
+  instanceType: new ec2.InstanceType('t2.micro'),
+});
 
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef', {
-  memoryLimitMiB: 1024,
-  cpu: 512,
+const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef', {
+  networkMode: ecs.NetworkMode.AWS_VPC,
 });
 
-taskDefinition.addContainer('web', {
+const container = taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  portMappings: [{
-    containerPort: 80,
-    protocol: ecs.Protocol.TCP,
-  }],
+  memoryLimitMiB: 256,
+  environment: {
+    SOME_VARIABLE: 'value',
+  },
 });
 
-const service = new ecs.FargateService(stack, 'Service', {
+container.addPortMappings({
+  containerPort: 80,
+  protocol: ecs.Protocol.TCP,
+});
+
+const service = new ecs.Ec2Service(stack, 'Service', {
   cluster,
   taskDefinition,
 });
 
-const scaling = service.autoScaleTaskCount({ maxCapacity: 10 });
-// Quite low to try and force it to scale
-scaling.scaleOnCpuUtilization('ReasonableCpu', { targetUtilizationPercent: 10 });
-
 const lb = new elbv2.ApplicationLoadBalancer(stack, 'LB', { vpc, internetFacing: true });
 const listener = lb.addListener('PublicListener', { port: 80, open: true });
-listener.addTargets('Fargate', {
+listener.addTargets('ECS', {
   port: 80,
   targets: [service],
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.pseudo-terminal.ts

@@ -3,25 +3,35 @@ import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 
-const app = new cdk.App();
-const stack = new cdk.Stack(app, 'integ-pseudo-terminal');
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
+    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
+    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
+  },
+});
+const stack = new cdk.Stack(app, 'aws-ecs-integ-pseudo-terminal');
 
 // Create a cluster
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
 
 const cluster = new ecs.Cluster(stack, 'EcsCluster', { vpc });
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef', {
-  cpu: 256,
-  memoryLimitMiB: 512,
+cluster.addCapacity('DefaultAutoScalingGroup', {
+  instanceType: new ec2.InstanceType('t2.micro'),
+});
+
+const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef', {
+  networkMode: ecs.NetworkMode.AWS_VPC,
 });
+
 taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  memoryLimitMiB: 512,
-  cpu: 256,
+  memoryLimitMiB: 256,
   pseudoTerminal: true,
 });
 
-new ecs.FargateService(stack, 'Service', {
+new ecs.Ec2Service(stack, 'Service', {
   cluster,
   taskDefinition,
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-elasticloadbalancingv2/README.md

@@ -746,6 +746,27 @@ const ipv6NetworkTargetGroup = new elbv2.NetworkTargetGroup(this, 'Ipv6NetworkTa
 });
 ```
 
+### Target Group level health setting for Application Load Balancers and Network Load Balancers
+
+You can set target group health setting at target group level by setting `targetGroupHealth` property.
+
+For more information, see [How Elastic Load Balancing works](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-group-attributes).
+
+```ts
+declare const vpc: ec2.Vpc;
+
+const targetGroup = new elbv2.ApplicationTargetGroup(this, 'TargetGroup', {
+  vpc,
+  port: 80,
+  targetGroupHealth: {
+    dnsMinimumHealthyTargetCount: 3,
+    dnsMinimumHealthyTargetPercentage: 70,
+    routingMinimumHealthyTargetCount: 2,
+    routingMinimumHealthyTargetPercentage: 50,
+  },
+});
+```
+
 ## Using Lambda Targets
 
 To use a Lambda Function as a target, use the integration class in the

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-elasticloadbalancingv2/integ.alb-target-group-attributes.ts

@@ -0,0 +1,45 @@
+import { ExpectedResult, IntegTest, Match } from '@aws-cdk/integ-tests-alpha';
+import { Stack, aws_ec2 as ec2, aws_elasticloadbalancingv2 as elbv2, App } from 'aws-cdk-lib';
+
+const app = new App();
+const stack = new Stack(app, 'alb-target-group-attributes');
+
+const vpc = new ec2.Vpc(stack, 'Stack');
+
+const targetGroup = new elbv2.ApplicationTargetGroup(stack, 'TargetGroup', {
+  vpc,
+  port: 80,
+  targetGroupHealth: {
+    dnsMinimumHealthyTargetCount: 3,
+    dnsMinimumHealthyTargetPercentage: 70,
+    routingMinimumHealthyTargetCount: 2,
+    routingMinimumHealthyTargetPercentage: 50,
+  },
+});
+
+const integTest = new IntegTest(app, 'alb-target-group-attributes-test', {
+  testCases: [stack],
+});
+
+integTest.assertions.awsApiCall('elbv2', 'describeTargetGroupAttributes', {
+  TargetGroupArn: targetGroup.targetGroupArn,
+}).expect(ExpectedResult.objectLike({
+  Attributes: Match.arrayWith([
+    {
+      Key: 'target_group_health.unhealthy_state_routing.minimum_healthy_targets.percentage',
+      Value: '50',
+    },
+    {
+      Key: 'target_group_health.dns_failover.minimum_healthy_targets.percentage',
+      Value: '70',
+    },
+    {
+      Key: 'target_group_health.unhealthy_state_routing.minimum_healthy_targets.count',
+      Value: '2',
+    },
+    {
+      Key: 'target_group_health.dns_failover.minimum_healthy_targets.count',
+      Value: '3',
+    },
+  ]),
+}));

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-elasticloadbalancingv2/integ.nlb-target-group-attributes.ts

@@ -0,0 +1,45 @@
+import { ExpectedResult, IntegTest, Match } from '@aws-cdk/integ-tests-alpha';
+import { Stack, aws_ec2 as ec2, aws_elasticloadbalancingv2 as elbv2, App } from 'aws-cdk-lib';
+
+const app = new App();
+const stack = new Stack(app, 'nlb-target-group-attributes');
+
+const vpc = new ec2.Vpc(stack, 'Stack');
+
+const targetGroup = new elbv2.NetworkTargetGroup(stack, 'TargetGroup', {
+  vpc,
+  port: 80,
+  targetGroupHealth: {
+    dnsMinimumHealthyTargetCount: 3,
+    dnsMinimumHealthyTargetPercentage: 70,
+    routingMinimumHealthyTargetCount: 2,
+    routingMinimumHealthyTargetPercentage: 50,
+  },
+});
+
+const integTest = new IntegTest(app, 'nlb-target-group-attributes-test', {
+  testCases: [stack],
+});
+
+integTest.assertions.awsApiCall('elbv2', 'describeTargetGroupAttributes', {
+  TargetGroupArn: targetGroup.targetGroupArn,
+}).expect(ExpectedResult.objectLike({
+  Attributes: Match.arrayWith([
+    {
+      Key: 'target_group_health.unhealthy_state_routing.minimum_healthy_targets.count',
+      Value: '2',
+    },
+    {
+      Key: 'target_group_health.unhealthy_state_routing.minimum_healthy_targets.percentage',
+      Value: '50',
+    },
+    {
+      Key: 'target_group_health.dns_failover.minimum_healthy_targets.count',
+      Value: '3',
+    },
+    {
+      Key: 'target_group_health.dns_failover.minimum_healthy_targets.percentage',
+      Value: '70',
+    },
+  ]),
+}));

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-events/README.md

@@ -356,4 +356,21 @@ const archive = new Archive(stack, 'Archive', {
 ```
 
 To enable archives or schema discovery on an event bus, customers has the choice of using either an AWS owned key or a customer managed key.
-For more information, see [KMS key options for event bus encryption](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-encryption-at-rest-key-options.html).
+For more information, see [KMS key options for event bus encryption](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-encryption-at-rest-key-options.html).
+
+## Configuring logging
+
+To configure logging for an Event Bus, leverage the LogConfig property. It allows different level of logging (NONE, INFO, TRACE, ERROR) and wether to include details or not.
+
+```ts
+import { EventBus, IncludeDetail, Level } from 'aws-cdk-lib/aws-events';
+
+const bus =  new EventBus(this, 'Bus', {
+      logConfig: {
+        includeDetail: IncludeDetail.FULL,
+        level: Level.TRACE,
+      },
+    });
+```
+
+See more [Specifying event bus log level](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-bus-logs.html#eb-event-bus-logs-level)

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-events/integ.eventbus.ts

@@ -2,21 +2,31 @@ import * as iam from 'aws-cdk-lib/aws-iam';
 import * as sqs from 'aws-cdk-lib/aws-sqs';
 import { App, Stack } from 'aws-cdk-lib';
 import { IntegTest } from '@aws-cdk/integ-tests-alpha';
-import { EventBus } from 'aws-cdk-lib/aws-events';
+import { EventBus, IncludeDetail, Level } from 'aws-cdk-lib/aws-events';
 
 const app = new App();
 const stack = new Stack(app, 'Stack');
 
 const dlq = new sqs.Queue(stack, 'DLQ');
 
+const eventBusRole = new iam.Role(stack, 'EventBusRole', {
+  assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+  description: 'Role for accessing EventBus',
+  roleName: 'EventBusAccessRole',
+});
+
 const bus = new EventBus(stack, 'Bus', {
   deadLetterQueue: dlq,
   description: 'myEventBus',
+  logConfig: {
+    includeDetail: IncludeDetail.FULL,
+    level: Level.ERROR,
+  },
 });
 
 bus.addToResourcePolicy(new iam.PolicyStatement({
   effect: iam.Effect.ALLOW,
-  principals: [new iam.AccountPrincipal(stack.account)],
+  principals: [eventBusRole],
   actions: ['events:PutEvents'],
   sid: 'Statement1',
   resources: [bus.eventBusArn],
@@ -24,7 +34,7 @@ bus.addToResourcePolicy(new iam.PolicyStatement({
 
 bus.addToResourcePolicy(new iam.PolicyStatement({
   effect: iam.Effect.ALLOW,
-  principals: [new iam.AccountPrincipal(stack.account)],
+  principals: [eventBusRole],
   actions: ['events:PutRule'],
   sid: 'Statement2',
   resources: [bus.eventBusArn],

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-route53/README.md

@@ -134,6 +134,30 @@ new route53.AaaaRecord(this, 'Alias', {
 });
 ```
 
+To add an HTTPS record:
+
+``` ts
+import * as cloudfront from 'aws-cdk-lib/aws-cloudfront';
+
+declare const myZone: route53.HostedZone;
+declare const distribution: cloudfront.CloudFrontWebDistribution;
+// Alias to CloudFront target
+new route53.HttpsRecord(this, 'HttpsRecord-CloudFrontAlias', {
+  zone: myZone,
+  target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),
+});
+// ServiceMode (priority >= 1)
+new route53.HttpsRecord(this, 'HttpsRecord-ServiceMode', {
+  zone: myZone,
+  values: [route53.HttpsRecordValue.service({ alpn: [route53.Alpn.H3, route53.Alpn.H2] })],
+});
+// AliasMode (priority = 0)
+new route53.HttpsRecord(this, 'HttpsRecord-AliasMode', {
+  zone: myZone,
+  values: [route53.HttpsRecordValue.alias('service.example.com')],
+});
+```
+
 [Geolocation routing](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-geo.html) can be enabled for continent, country or subdivision:
 
 ```ts

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-route53/integ.route53.ts

@@ -1,6 +1,6 @@
 import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import * as cdk from 'aws-cdk-lib';
-import { ARecord, CaaAmazonRecord, CnameRecord, Continent, GeoLocation, PrivateHostedZone, PublicHostedZone, RecordTarget, TxtRecord } from 'aws-cdk-lib/aws-route53';
+import { Alpn, ARecord, CaaAmazonRecord, CnameRecord, Continent, GeoLocation, HttpsRecord, HttpsRecordValue, PrivateHostedZone, PublicHostedZone, RecordTarget, SvcbRecord, SvcbRecordValue, TxtRecord } from 'aws-cdk-lib/aws-route53';
 
 const app = new cdk.App();
 
@@ -92,6 +92,56 @@ new TxtRecord(stack, 'TXT', {
   ],
 });
 
+new SvcbRecord(stack, 'SVCB-AliasMode', {
+  zone: publicZone,
+  recordName: '_8080._svcb-alias',
+  values: [SvcbRecordValue.alias('service.example.com')],
+});
+new SvcbRecord(stack, 'SVCB-ServiceMode', {
+  zone: publicZone,
+  recordName: '_8080._svcb-service',
+  values: [SvcbRecordValue.service({ alpn: [Alpn.H3, Alpn.H2] })],
+});
+new SvcbRecord(stack, 'SVCB-ServiceMode-FullParams', {
+  zone: publicZone,
+  recordName: '_8080._svcb-service-fullparams',
+  values: [SvcbRecordValue.service({
+    priority: 2,
+    targetName: 'service.example.com',
+    mandatory: ['alpn'],
+    alpn: [Alpn.H3, Alpn.H2, Alpn.HTTP1_1, Alpn.of('h3-29')],
+    noDefaultAlpn: true,
+    port: 8443,
+    ipv4hint: ['127.0.0.1'],
+    ipv6hint: ['::1'],
+  })],
+});
+
+new HttpsRecord(stack, 'HTTPS-AliasMode', {
+  zone: publicZone,
+  recordName: 'https-alias',
+  values: [HttpsRecordValue.alias('service.example.com')],
+});
+new HttpsRecord(stack, 'HTTPS-ServiceMode', {
+  zone: publicZone,
+  recordName: 'https-service',
+  values: [HttpsRecordValue.service({ alpn: [Alpn.H3, Alpn.H2] })],
+});
+new HttpsRecord(stack, 'HTTPS-ServiceMode-FullParams', {
+  zone: publicZone,
+  recordName: 'https-service-fullparams',
+  values: [HttpsRecordValue.service({
+    priority: 2,
+    targetName: 'service.example.com',
+    mandatory: ['alpn'],
+    alpn: [Alpn.H3, Alpn.H2, Alpn.HTTP1_1, Alpn.of('h3-29')],
+    noDefaultAlpn: true,
+    port: 8443,
+    ipv4hint: ['127.0.0.1'],
+    ipv6hint: ['::1'],
+  })],
+});
+
 new cdk.CfnOutput(stack, 'PrivateZoneId', { value: privateZone.hostedZoneId });
 new cdk.CfnOutput(stack, 'PublicZoneId', { value: publicZone.hostedZoneId });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-route53-targets/integ.cloudfront-alias-target.ts

@@ -3,6 +3,7 @@ import * as route53 from 'aws-cdk-lib/aws-route53';
 import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as cdk from 'aws-cdk-lib';
 import * as targets from 'aws-cdk-lib/aws-route53-targets';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 
 const app = new cdk.App();
 
@@ -31,4 +32,18 @@ new route53.ARecord(zone, 'Alias', {
   target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),
 });
 
-app.synth();
+new route53.AaaaRecord(zone, 'AaaaAlias', {
+  zone,
+  recordName: '_foo',
+  target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),
+});
+
+new route53.HttpsRecord(zone, 'HttpsAlias', {
+  zone,
+  recordName: '_foo',
+  target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),
+});
+
+new IntegTest(app, 'aws-cdk-route53-cloudfront-alias-integ-test', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/README.md

@@ -962,6 +962,18 @@ new tasks.EmrCreateCluster(this, 'SpotSpecification', {
 });
 ```
 
+You can [customize EBS root device volume](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-custom-ami-root-volume-size.html).
+
+```ts
+new tasks.EmrCreateCluster(this, 'Create Cluster', {
+  instances: {},
+  name: 'ClusterName',
+  ebsRootVolumeIops: 4000,
+  ebsRootVolumeSize: Size.gibibytes(20),
+  ebsRootVolumeThroughput: 200,
+});
+```
+
 If you want to run multiple steps in [parallel](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-concurrent-steps.html),
 you can specify the `stepConcurrencyLevel` property. The concurrency range is between 1
 and 256 inclusive, where the default concurrency of 1 means no step concurrency is allowed.
@@ -987,6 +999,47 @@ new tasks.EmrCreateCluster(this, 'Create Cluster', {
 });
 ```
 
+If you want to use [managed scaling](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-scaling.html),
+you can specify the `managedScalingPolicy` property.
+
+```ts
+new tasks.EmrCreateCluster(this, 'CreateCluster', {
+  instances: {
+    instanceFleets: [
+      {
+        instanceFleetType: tasks.EmrCreateCluster.InstanceRoleType.CORE,
+        instanceTypeConfigs: [
+          {
+            instanceType: 'm5.xlarge',
+          },
+        ],
+        targetOnDemandCapacity: 1,
+      },
+      {
+        instanceFleetType: tasks.EmrCreateCluster.InstanceRoleType.MASTER,
+        instanceTypeConfigs: [
+          {
+            instanceType: 'm5.xlarge',
+          },
+        ],
+        targetOnDemandCapacity: 1,
+      },
+    ],
+  },
+  name: 'ClusterName',
+  releaseLabel: 'emr-7.9.0',
+  managedScalingPolicy: {
+    computeLimits: {
+      unitType: tasks.EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS,
+      maximumCapacityUnits: 4,
+      minimumCapacityUnits: 1,
+      maximumOnDemandCapacityUnits: 4,
+      maximumCoreCapacityUnits: 2,
+    },
+  },
+});
+```
+
 ### Termination Protection
 
 Locks a cluster (job flow) so the EC2 instances in the cluster cannot be

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.emr-create-cluster-with-ebs.ts

@@ -0,0 +1,126 @@
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import { App, Duration, Size, Stack, Tags } from 'aws-cdk-lib';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { EmrCreateCluster } from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import { Vpc } from 'aws-cdk-lib/aws-ec2';
+
+const app = new App();
+
+const stack = new Stack(app, 'emr-create-cluster-ebs');
+const vpc = new Vpc(stack, 'Vpc', { restrictDefaultSecurityGroup: false });
+
+const releaseLabel = 'emr-7.10.0';
+const ebsRootVolumeIops = 4000;
+const ebsRootVolumeSize = 20;
+const ebsRootVolumeThroughput = 200;
+const unitType = EmrCreateCluster.ComputeLimitsUnitType.INSTANCE_FLEET_UNITS;
+const maximumCapacityUnits = 4;
+const minimumCapacityUnits = 1;
+const maximumOnDemandCapacityUnits = 4;
+const maximumCoreCapacityUnits = 2;
+
+// https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-iam-policies.html#manually-tagged-resources
+Tags.of(vpc).add('for-use-with-amazon-emr-managed-policies', 'true');
+
+const step = new EmrCreateCluster(stack, 'EmrCreateCluster', {
+  instances: {
+    instanceFleets: [
+      {
+        instanceFleetType: EmrCreateCluster.InstanceRoleType.CORE,
+        instanceTypeConfigs: [
+          {
+            instanceType: 'm5.xlarge',
+          },
+        ],
+        targetOnDemandCapacity: 1,
+      },
+      {
+        instanceFleetType: EmrCreateCluster.InstanceRoleType.MASTER,
+        instanceTypeConfigs: [
+          {
+            instanceType: 'm5.xlarge',
+          },
+        ],
+        targetOnDemandCapacity: 1,
+      },
+    ],
+    ec2SubnetId: vpc.publicSubnets[0].subnetId,
+  },
+  name: 'Cluster',
+  releaseLabel,
+  integrationPattern: sfn.IntegrationPattern.RUN_JOB,
+  ebsRootVolumeIops,
+  ebsRootVolumeSize: Size.gibibytes(ebsRootVolumeSize),
+  ebsRootVolumeThroughput,
+  managedScalingPolicy: {
+    computeLimits: {
+      unitType,
+      maximumCapacityUnits,
+      minimumCapacityUnits,
+      maximumOnDemandCapacityUnits,
+      maximumCoreCapacityUnits,
+    },
+  },
+});
+
+const sm = new sfn.StateMachine(stack, 'SM', {
+  definition: step,
+});
+
+const integTest = new IntegTest(app, 'emr-create-cluster-ebs-integ', {
+  testCases: [stack],
+});
+
+const start = integTest.assertions.awsApiCall('StepFunctions', 'startExecution', {
+  stateMachineArn: sm.stateMachineArn,
+});
+
+const describeExecution = integTest.assertions.awsApiCall('StepFunctions', 'describeExecution', {
+  executionArn: start.getAttString('executionArn'),
+});
+start.next(describeExecution);
+
+const waitForExecution = describeExecution.expect(ExpectedResult.objectLike({
+  status: 'SUCCEEDED',
+})).waitForAssertions({
+  interval: Duration.seconds(30),
+  totalTimeout: Duration.minutes(5),
+});
+
+const getClusterId = integTest.assertions.awsApiCall('StepFunctions', 'describeExecution', {
+  executionArn: start.getAttString('executionArn'),
+});
+waitForExecution.next(getClusterId);
+
+const clusterId = getClusterId.getAttString('output.ClusterId');
+
+const describeCluster = integTest.assertions.awsApiCall('Emr', 'describeCluster', {
+  ClusterId: clusterId,
+});
+getClusterId.next(describeCluster);
+
+describeCluster.expect(ExpectedResult.objectLike({
+  Cluster: {
+    ReleaseLabel: releaseLabel,
+    EbsRootVolumeIops: ebsRootVolumeIops,
+    EbsRootVolumeSize: ebsRootVolumeSize,
+    EbsRootVolumeThroughput: ebsRootVolumeThroughput,
+  },
+}));
+
+const getManagedScalingPolicy = integTest.assertions.awsApiCall('Emr', 'getManagedScalingPolicy', {
+  ClusterId: clusterId,
+});
+describeCluster.next(getManagedScalingPolicy);
+
+getManagedScalingPolicy.expect(ExpectedResult.objectLike({
+  ManagedScalingPolicy: {
+    ComputeLimits: {
+      UnitType: unitType,
+      MaximumCapacityUnits: maximumCapacityUnits,
+      MinimumCapacityUnits: minimumCapacityUnits,
+      MaximumOnDemandCapacityUnits: maximumOnDemandCapacityUnits,
+      MaximumCoreCapacityUnits: maximumCoreCapacityUnits,
+    },
+  },
+}));