konokenj.cdk-api-mcp-server 0.31.0__py3-none-any.whl → 0.57.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-sns-subscriptions/integ.sns-sqs.ts

@@ -3,50 +3,31 @@ import * as sqs from 'aws-cdk-lib/aws-sqs';
 import * as cdk from 'aws-cdk-lib';
 import { IntegTest, ExpectedResult } from '@aws-cdk/integ-tests-alpha';
 import * as subs from 'aws-cdk-lib/aws-sns-subscriptions';
-class SnsToSqsStack extends cdk.Stack {
-  topic: sns.Topic;
-  queue: sqs.Queue;
-  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
-    super(scope, id, props);
-    this.topic = new sns.Topic(this, 'MyTopic');
-    const queueStack = new cdk.Stack(app, 'QueueStack');
-    this.queue = new sqs.Queue(queueStack, 'MyQueue');
-    this.topic.addSubscription(new subs.SqsSubscription(this.queue, {
-      filterPolicyWithMessageBody: {
-        background: sns.Policy.policy({
-          color: sns.Filter.filter(sns.SubscriptionFilter.stringFilter({
-            allowlist: ['red', 'green'],
-            denylist: ['white', 'orange'],
-          })),
-        }),
-        price: sns.Filter.filter(sns.SubscriptionFilter.numericFilter({
-          allowlist: [100, 200],
-          between: { start: 300, stop: 350 },
-          greaterThan: 500,
-          lessThan: 1000,
-          betweenStrict: { start: 2000, stop: 3000 },
-        })),
-      },
-    }));
-  }
-}
-// Beginning of the test suite
+
 const app = new cdk.App();
-const stack = new SnsToSqsStack(app, 'SnsToSqsStack');
+
+const stack = new cdk.Stack(app, 'SnsToSqsStack');
+
+const topic = new sns.Topic(stack, 'MyTopic');
+
+const queue = new sqs.Queue(stack, 'MyQueue');
+
+topic.addSubscription(new subs.SqsSubscription(queue, { rawMessageDelivery: true }));
+
 const integTest = new IntegTest(app, 'SNS Subscriptions', {
-  testCases: [
-    stack,
-  ],
+  testCases: [stack],
 });
+
+const message = JSON.stringify({ color: 'green', price: 200 });
+
 integTest.assertions.awsApiCall('SNS', 'publish', {
-  Message: '{ background: { color: \'green\' }, price: 200 }',
-  TopicArn: stack.topic.topicArn,
+  Message: message,
+  TopicArn: topic.topicArn,
 });
-const message = integTest.assertions.awsApiCall('SQS', 'receiveMessage', {
-  QueueUrl: stack.queue.queueUrl,
+
+integTest.assertions.awsApiCall('SQS', 'receiveMessage', {
+  QueueUrl: queue.queueUrl,
   WaitTimeSeconds: 20,
-});
-message.expect(ExpectedResult.objectLike({
-  Messages: [{ Body: '{color: "green", price: 200}' }],
+}).expect(ExpectedResult.objectLike({
+  Messages: [{ Body: message }],
 }));
-app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.distributed-map-parallel.ts

@@ -0,0 +1,82 @@
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as cdk from 'aws-cdk-lib/core';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+
+const CSV_KEY = 'my-key.csv';
+
+class DistributedMapParallelStack extends cdk.Stack {
+  readonly bucket: s3.Bucket;
+  readonly stateMachine: sfn.StateMachine;
+
+  constructor(scope: cdk.App, id: string) {
+    super(scope, id);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      autoDeleteObjects: true,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+
+    const parallel = new sfn.Parallel(this, 'Parallel');
+
+    const distributedMap = new sfn.DistributedMap(this, 'DistributedMap', {
+      itemReader: new sfn.S3CsvItemReader({
+        bucket: this.bucket,
+        key: CSV_KEY,
+        csvHeaders: sfn.CsvHeaders.useFirstRow(),
+      }),
+    }).itemProcessor(new sfn.Pass(this, 'Pass'));
+
+    this.stateMachine = new sfn.StateMachine(this, 'StateMachine', {
+      definitionBody: sfn.ChainDefinitionBody.fromChainable(parallel.branch(distributedMap)),
+    });
+  }
+}
+
+function setupAssertions(testCaseStack: DistributedMapParallelStack, assertions: integ.IDeployAssert) {
+  const waitForStateMachineActive = assertions
+    .awsApiCall('StepFunctions', 'describeStateMachine', {
+      stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+    })
+    .expect(integ.ExpectedResult.objectLike({ status: 'ACTIVE' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(5),
+    });
+
+  // Upload the input to the DistributedMap
+  const uploadInput = assertions.awsApiCall('S3', 'putObject', {
+    Bucket: testCaseStack.bucket.bucketName,
+    Key: CSV_KEY,
+    Body: 'a,b,c\n1,2,3\n4,5,6',
+  });
+
+  // Start an execution
+  const startExecution = assertions.awsApiCall('StepFunctions', 'startExecution', {
+    stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+  });
+
+  const executionArn = startExecution.getAttString('executionArn');
+
+  const expectSucceededExecution = assertions
+    .awsApiCall('StepFunctions', 'describeExecution', { executionArn: executionArn })
+    .expect(integ.ExpectedResult.objectLike({ status: 'SUCCEEDED' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(1),
+    });
+
+  waitForStateMachineActive
+    .next(uploadInput)
+    .next(startExecution)
+    .next(expectSucceededExecution);
+}
+
+const app = new cdk.App();
+const parallelStack = new DistributedMapParallelStack(app, 'DistributedMapParallelStack');
+
+const testCase = new integ.IntegTest(app, 'DistributedMapParallel', {
+  testCases: [parallelStack],
+});
+
+setupAssertions(parallelStack, testCase.assertions);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.distributed-map-redrive.ts

@@ -0,0 +1,130 @@
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as cdk from 'aws-cdk-lib/core';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as aws_stepfunction_tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const CSV_KEY = 'my-key.csv';
+const SUCCESS_MARKER_KEY = 'pass-flag.txt';
+
+interface DistributedMapRedriveStackProps extends cdk.StackProps {
+  readonly mapRunLabel?: string;
+}
+
+class DistributedMapRedriveStack extends cdk.Stack {
+  readonly bucket: s3.Bucket;
+  readonly stateMachine: sfn.StateMachine;
+
+  constructor(scope: cdk.App, id: string, props?: DistributedMapRedriveStackProps) {
+    super(scope, id, props);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      autoDeleteObjects: true,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+
+    const distributedMap = new sfn.DistributedMap(this, 'DistributedMap', {
+      label: props?.mapRunLabel,
+      itemReader: new sfn.S3CsvItemReader({
+        bucket: this.bucket,
+        key: CSV_KEY,
+        csvHeaders: sfn.CsvHeaders.useFirstRow(),
+      }),
+    });
+
+    // Existence of the success marker object determines if the distributed map succeeds or fails
+    const getSuccessMarker = new aws_stepfunction_tasks.CallAwsService(this, 'GetData', {
+      action: 'getObject',
+      iamResources: [this.bucket.arnForObjects('*')],
+      parameters: {
+        Bucket: this.bucket.bucketName,
+        Key: SUCCESS_MARKER_KEY,
+      },
+      service: 's3',
+    });
+
+    distributedMap.itemProcessor(getSuccessMarker);
+
+    this.stateMachine = new sfn.StateMachine(this, 'StateMachine', {
+      definitionBody: sfn.ChainDefinitionBody.fromChainable(distributedMap),
+    });
+  }
+}
+
+function setupAssertions(testCaseStack: DistributedMapRedriveStack, assertions: integ.IDeployAssert) {
+  const waitForStateMachineActive = assertions
+    .awsApiCall('StepFunctions', 'describeStateMachine', {
+      stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+    })
+    .expect(integ.ExpectedResult.objectLike({ status: 'ACTIVE' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(5),
+    });
+
+  // Upload the input to the DistributedMap
+  const uploadInput = assertions.awsApiCall('S3', 'putObject', {
+    Bucket: testCaseStack.bucket.bucketName,
+    Key: CSV_KEY,
+    Body: 'a,b,c\n1,2,3\n4,5,6',
+  });
+
+  // Start an execution
+  const startExecution = assertions.awsApiCall('StepFunctions', 'startExecution', {
+    stateMachineArn: testCaseStack.stateMachine.stateMachineArn,
+  });
+
+  const executionArn = startExecution.getAttString('executionArn');
+
+  // describe the results of the execution
+  const expectFailedExecution = assertions
+    .awsApiCall('StepFunctions', 'describeExecution', {
+      executionArn: executionArn,
+    })
+    .expect(integ.ExpectedResult.objectLike({ status: 'FAILED' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(1),
+    });
+
+  // Upload the success marker, so that the next execution succeeds
+  const uploadSucceedMarker = assertions.awsApiCall('S3', 'putObject', {
+    Bucket: testCaseStack.bucket.bucketName,
+    Key: SUCCESS_MARKER_KEY,
+    Body: '',
+  });
+
+  const redriveExecution = assertions.awsApiCall('StepFunctions', 'redriveExecution', {
+    executionArn: executionArn,
+  });
+
+  const expectRedrivenExecution = assertions
+    .awsApiCall('StepFunctions', 'describeExecution', { executionArn: executionArn })
+    .expect(integ.ExpectedResult.objectLike({ status: 'SUCCEEDED' }))
+    .waitForAssertions({
+      interval: cdk.Duration.seconds(10),
+      totalTimeout: cdk.Duration.minutes(1),
+    });
+
+  waitForStateMachineActive
+    .next(uploadInput)
+    .next(startExecution)
+    .next(expectFailedExecution)
+    .next(uploadSucceedMarker)
+    .next(redriveExecution)
+    .next(expectRedrivenExecution);
+}
+
+const app = new cdk.App();
+
+const unlabeledDistributedMapStack = new DistributedMapRedriveStack(app, 'UnlabeledDistributedMapRedrive');
+const labeledDistributedMapStack = new DistributedMapRedriveStack(app, 'LabeledDistributedMapRedrive', {
+  mapRunLabel: 'myLabel',
+});
+
+const testCase = new integ.IntegTest(app, 'DistributedMap', {
+  testCases: [unlabeledDistributedMapStack, labeledDistributedMapStack],
+});
+
+setupAssertions(labeledDistributedMapStack, testCase.assertions);
+setupAssertions(unlabeledDistributedMapStack, testCase.assertions);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.map-with-catch.ts

@@ -13,6 +13,7 @@ class DistributedMapStack extends cdk.Stack {
     super(scope, id, props);
 
     this.bucket = new s3.Bucket(this, 'Bucket', {
+      autoDeleteObjects: true,
       removalPolicy: cdk.RemovalPolicy.DESTROY,
     });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions/integ.sm-jsonpath-with-distributed-map-jsonata.ts

@@ -0,0 +1,105 @@
+import * as cdk from 'aws-cdk-lib/core';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import { STEPFUNCTIONS_USE_DISTRIBUTED_MAP_RESULT_WRITER_V2 } from 'aws-cdk-lib/cx-api';
+
+const CSV_KEY = 'my-key.csv';
+const RESULT_BUCKET_PREFIX = 'my-prefix';
+
+class DistributedMapStack extends cdk.Stack {
+  readonly stateMachine: sfn.StateMachine;
+  readonly bucket: s3.Bucket;
+
+  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      autoDeleteObjects: true,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+
+    const distributedMap = sfn.DistributedMap.jsonata(this, 'DistributedMap', {
+      itemReader: new sfn.S3CsvItemReader({
+        bucket: this.bucket,
+        key: CSV_KEY,
+        csvHeaders: sfn.CsvHeaders.useFirstRow(),
+      }),
+      resultWriterV2: new sfn.ResultWriterV2({
+        bucket: this.bucket,
+        prefix: RESULT_BUCKET_PREFIX,
+      }),
+    });
+
+    distributedMap.itemProcessor(sfn.Pass.jsonata(this, 'Pass'), {
+      mode: sfn.ProcessorMode.DISTRIBUTED,
+      executionType: sfn.ProcessorType.STANDARD,
+    });
+
+    this.stateMachine = new sfn.StateMachine(this, 'StateMachine', {
+      definition: distributedMap,
+    });
+  }
+}
+
+const app = new cdk.App({
+  context: {
+    [STEPFUNCTIONS_USE_DISTRIBUTED_MAP_RESULT_WRITER_V2]: true,
+  },
+});
+const stack = new DistributedMapStack(app, 'sm-jsonpath-with-distributed-map-jsonata');
+
+const testCase = new IntegTest(app, 'integ-sm-jsonpath-with-distributed-map-jsonata', {
+  testCases: [stack],
+});
+
+testCase.assertions
+  .awsApiCall('StepFunctions', 'describeStateMachine', {
+    stateMachineArn: stack.stateMachine.stateMachineArn,
+  })
+  .expect(ExpectedResult.objectLike({ status: 'ACTIVE' }))
+  .waitForAssertions({
+    interval: cdk.Duration.seconds(10),
+    totalTimeout: cdk.Duration.minutes(5),
+  });
+
+// Put an object in the bucket
+const putObject = testCase.assertions.awsApiCall('S3', 'putObject', {
+  Bucket: stack.bucket.bucketName,
+  Key: CSV_KEY,
+  Body: 'a,b,c\n1,2,3\n4,5,6',
+});
+
+// Start an execution
+const start = testCase.assertions.awsApiCall('StepFunctions', 'startExecution', {
+  stateMachineArn: stack.stateMachine.stateMachineArn,
+});
+putObject.next(start);
+
+// describe the results of the execution
+const describe = testCase.assertions.awsApiCall('StepFunctions', 'describeExecution', {
+  executionArn: start.getAttString('executionArn'),
+});
+start.next(describe);
+
+// assert the results
+const describeExecution = describe.expect(ExpectedResult.objectLike({
+  status: 'SUCCEEDED',
+})).waitForAssertions({
+  interval: cdk.Duration.seconds(10),
+  totalTimeout: cdk.Duration.minutes(5),
+});
+
+const s3ApiCall = testCase.assertions.awsApiCall('S3', 'listObjectsV2', {
+  Bucket: stack.bucket.bucketName,
+  MaxKeys: 2,
+  Prefix: RESULT_BUCKET_PREFIX,
+}).expect(ExpectedResult.objectLike({
+  KeyCount: 2,
+}));
+s3ApiCall.provider.addToRolePolicy({
+  Effect: 'Allow',
+  Action: ['s3:GetObject', 's3:ListBucket'],
+  Resource: ['*'],
+});
+describeExecution.next(s3ApiCall);

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

@@ -34,6 +34,8 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
     - [SubmitJob](#submitjob)
   - [Bedrock](#bedrock)
     - [InvokeModel](#invokemodel)
+    - [Using Input Path for S3 URI](#using-input-path-for-s3-uri)
+    - [Using Input Path](#using-input-path)
     - [createModelCustomizationJob](#createmodelcustomizationjob)
   - [CodeBuild](#codebuild)
     - [StartBuild](#startbuild)
@@ -47,6 +49,7 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
     - [RunTask](#runtask)
       - [EC2](#ec2)
       - [Fargate](#fargate)
+      - [Override CPU and Memory Parameter](#override-cpu-and-memory-parameter)
       - [ECS enable Exec](#ecs-enable-exec)
   - [EMR](#emr)
     - [Create Cluster](#create-cluster)
@@ -64,15 +67,18 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
     - [Call](#call)
   - [EventBridge](#eventbridge)
     - [Put Events](#put-events)
+  - [EventBridge Scheduler](#eventbridge-scheduler)
+    - [Create Scheduler](#create-scheduler)
   - [Glue](#glue)
     - [StartJobRun](#startjobrun)
     - [StartCrawlerRun](#startcrawlerrun)
   - [Glue DataBrew](#glue-databrew)
     - [Start Job Run](#start-job-run-1)
+  - [Invoke HTTP API](#invoke-http-api)
   - [Lambda](#lambda)
     - [Invoke](#invoke)
   - [MediaConvert](#mediaconvert)
-    - [Create Job](#create-job)
+    - [CreateJob](#createjob)
   - [SageMaker](#sagemaker)
     - [Create Training Job](#create-training-job)
     - [Create Transform Job](#create-transform-job)
@@ -135,6 +141,17 @@ The `EvaluateExpression` supports a `runtime` prop to specify the Lambda
 runtime to use to evaluate the expression. Currently, only runtimes
 of the Node.js family are supported.
 
+The `EvaluateExpression` also supports an `architecture` prop to specify the Lambda
+architecture. This can be useful when migrating to ARM64 or when running integration
+tests on ARM64 systems.
+
+```ts
+const convertToSecondsArm64 = new tasks.EvaluateExpression(this, 'Convert to seconds', {
+  expression: '$.waitMilliseconds / 1000',
+  architecture: lambda.Architecture.ARM_64,
+});
+```
+
 ## API Gateway
 
 Step Functions supports [API Gateway](https://docs.aws.amazon.com/step-functions/latest/dg/connect-api-gateway.html) through the service integration pattern.
@@ -956,6 +973,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.
@@ -981,6 +1010,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
@@ -1315,12 +1385,12 @@ The following code snippet includes a Task state that uses eks:call to list the
 
 ```ts
 import * as eks from 'aws-cdk-lib/aws-eks';
-import { KubectlV32Layer } from '@aws-cdk/lambda-layer-kubectl-v32';
+import { KubectlV34Layer } from '@aws-cdk/lambda-layer-kubectl-v34';
 
 const myEksCluster = new eks.Cluster(this, 'my sample cluster', {
-  version: eks.KubernetesVersion.V1_32,
+  version: eks.KubernetesVersion.V1_34,
   clusterName: 'myEksCluster',
-  kubectlLayer: new KubectlV32Layer(this, 'kubectl'),
+  kubectlLayer: new KubectlV34Layer(this, 'kubectl'),
 });
 
 new tasks.EksCall(this, 'Call a EKS Endpoint', {
@@ -1523,7 +1593,7 @@ const connection = new events.Connection(this, 'Connection', {
 
 new tasks.HttpInvoke(this, 'Invoke HTTP API', {
   apiRoot: 'https://api.example.com',
-  apiEndpoint: sfn.TaskInput.fromText('path/to/resource'),
+  apiEndpoint: sfn.TaskInput.fromText(sfn.JsonPath.format('resource/{}/details', sfn.JsonPath.stringAt('$.resourceId'))),
   body: sfn.TaskInput.fromObject({ foo: 'bar' }),
   connection,
   headers: sfn.TaskInput.fromObject({ 'Content-Type': 'application/json' }),

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.call-aws-service-cross-region-lambda.ts

@@ -10,7 +10,7 @@ class TestStack extends cdk.Stack {
     super(scope, id, props);
     // Create a target Lambda function that returns JSON response
     const targetLambda = new lambda.Function(this, 'TargetLambda', {
-      runtime: lambda.Runtime.NODEJS_18_X,
+      runtime: lambda.Runtime.NODEJS_20_X,
       handler: 'index.handler',
       code: lambda.Code.fromInline(`
         exports.handler = async (event) => {

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,
+    },
+  },
+}));