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-apigatewayv2-integrations/integ.http-proxy.ts

@@ -29,7 +29,7 @@ new CfnOutput(stack, 'Endpoint', {
 
 function lambdaProxyEndpoint(s: Stack): HttpApi {
   const handler = new lambda.Function(s, 'AlwaysSuccess', {
-    runtime: lambda.Runtime.NODEJS_18_X,
+    runtime: lambda.Runtime.NODEJS_20_X,
     handler: 'index.handler',
     code: new lambda.InlineCode('exports.handler = async function(event, context) { return { statusCode: 200, body: "success" }; };'),
   });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-integrations/integ.lambda-connect-disconnect-trigger.ts

@@ -17,7 +17,7 @@ const webSocketTableName = 'WebSocketConnections';
 
 const connectFunction = new lambda.Function(stack, 'Connect Function', {
   functionName: 'process_connect_requests',
-  runtime: lambda.Runtime.NODEJS_14_X,
+  runtime: lambda.Runtime.NODEJS_22_X,
   handler: 'index.handler',
   code: lambda.Code.fromAsset(path.join(__dirname, 'lambdas', 'connect')),
   timeout: cdk.Duration.seconds(5),
@@ -31,7 +31,7 @@ const disconnectFunction = new lambda.Function(
   'Disconnect Function',
   {
     functionName: 'process_disconnect_requests',
-    runtime: lambda.Runtime.NODEJS_14_X,
+    runtime: lambda.Runtime.NODEJS_22_X,
     handler: 'index.handler',
     code: lambda.Code.fromAsset(
       path.join(__dirname, 'lambdas', 'disconnect'),

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-integrations/integ.lambda-permission-consolidation.ts

@@ -0,0 +1,45 @@
+import { HttpApi, HttpMethod, HttpRoute, HttpRouteKey } from 'aws-cdk-lib/aws-apigatewayv2';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { App, Stack } from 'aws-cdk-lib';
+import { HttpLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
+
+const app = new App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+const stack = new Stack(app, 'integ-lambda-permission-consolidation');
+
+const httpApi = new HttpApi(stack, 'HttpApi');
+
+const lambdaHandler = new lambda.Function(stack, 'Handler', {
+  runtime: lambda.Runtime.NODEJS_18_X,
+  handler: 'index.handler',
+  code: new lambda.InlineCode('exports.handler = async function(event, context) { return { statusCode: 200, body: JSON.stringify({ message: \'Hello from \' + event.requestContext.http.path }) }; };'),
+});
+
+// Add several routes
+for (let i = 1; i <= 10; i++) {
+  new HttpRoute(stack, `Route${i}`, {
+    httpApi: httpApi,
+    integration: new HttpLambdaIntegration(`Integration${i}`, lambdaHandler, {
+      scopePermissionToRoute: false,
+    }),
+    routeKey: HttpRouteKey.with(`/path${i}`, HttpMethod.GET),
+  });
+}
+
+// Integ Test Assertions
+const integ = new IntegTest(app, 'Integ', { testCases: [stack] });
+
+// Test that routes work after consolidation
+integ.assertions.httpApiCall(httpApi.apiEndpoint + '/path1').expect(ExpectedResult.objectLike({
+  body: { message: 'Hello from /path1' },
+  status: 200,
+}));
+
+integ.assertions.httpApiCall(httpApi.apiEndpoint + '/path12').expect(ExpectedResult.objectLike({
+  body: { message: 'Hello from /path10' },
+  status: 200,
+}));

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-integrations/integ.lambda-proxy.ts

@@ -17,7 +17,7 @@ const app = new App({
 const stack = new Stack(app, 'integ-lambda-proxy');
 
 const handler = new lambda.Function(stack, 'AlwaysSuccess', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: new lambda.InlineCode('exports.handler = async function(event, context) { return { statusCode: 200, body: "success" }; };'),
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-integrations/integ.lambda.ts

@@ -19,25 +19,25 @@ const app = new App({
 const stack = new Stack(app, 'WebSocketApiInteg');
 
 const connectHandler = new lambda.Function(stack, 'ConnectHandler', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: new lambda.InlineCode('exports.handler = async function(event, context) { console.log(event); return { statusCode: 200, body: "connected" }; };'),
 });
 
 const disconnetHandler = new lambda.Function(stack, 'DisconnectHandler', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: new lambda.InlineCode('exports.handler = async function(event, context) { console.log(event); return { statusCode: 200, body: "disconnected" }; };'),
 });
 
 const defaultHandler = new lambda.Function(stack, 'DefaultHandler', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: new lambda.InlineCode('exports.handler = async function(event, context) { console.log(event); return { statusCode: 200, body: "default" }; };'),
 });
 
 const messageHandler = new lambda.Function(stack, 'MessageHandler', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: new lambda.InlineCode('exports.handler = async function(event, context) { console.log(event); return { statusCode: 200, body: "received" }; };'),
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-integrations/integ.sqs.ts

@@ -1,85 +1,72 @@
-import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
+import { HttpMethod, PassthroughBehavior, WebSocketApi, WebSocketStage } from 'aws-cdk-lib/aws-apigatewayv2';
 import * as sqs from 'aws-cdk-lib/aws-sqs';
-import { App, Stack } from 'aws-cdk-lib';
-import { HttpSqsIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
-import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { App, Stack, Aws } from 'aws-cdk-lib';
+import { WebSocketAwsIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 
-const app = new App();
-const stack = new Stack(app, 'sqs-integration');
+/*
+ * Stack verification steps:
+ * 1. Verify manually that the integration has type "AWS"
+ */
 
-const queue = new sqs.Queue(stack, 'Queue');
+const app = new App();
+const stack = new Stack(app, 'integ-aws-websocket-sqs-integration');
 
-const httpApi = new apigwv2.HttpApi(stack, 'Api');
-httpApi.addRoutes({
-  path: '/default',
-  methods: [apigwv2.HttpMethod.POST],
-  integration: new HttpSqsIntegration('defaultIntegration', {
-    queue,
-  }),
-});
-httpApi.addRoutes({
-  path: '/send-message',
-  methods: [apigwv2.HttpMethod.POST],
-  integration: new HttpSqsIntegration('sendMessageIntegration', {
-    queue,
-    subtype: apigwv2.HttpIntegrationSubtype.SQS_SEND_MESSAGE,
-  }),
-});
-httpApi.addRoutes({
-  path: '/receive-message',
-  methods: [apigwv2.HttpMethod.POST],
-  integration: new HttpSqsIntegration('receiveMessageIntegration', {
-    queue,
-    subtype: apigwv2.HttpIntegrationSubtype.SQS_RECEIVE_MESSAGE,
-  }),
-});
-httpApi.addRoutes({
-  path: '/delete-message',
-  methods: [apigwv2.HttpMethod.POST],
-  integration: new HttpSqsIntegration('deleteMessageIntegration', {
-    queue,
-    subtype: apigwv2.HttpIntegrationSubtype.SQS_DELETE_MESSAGE,
-  }),
+const sqsMessageQueue = new sqs.Queue(stack, 'MessageSQSQueue', {
+  fifo: true,
+  queueName: 'MessageSQSQueue.fifo',
 });
-httpApi.addRoutes({
-  path: '/purge-queue',
-  methods: [apigwv2.HttpMethod.POST],
-  integration: new HttpSqsIntegration('purgeQueueIntegration', {
-    queue,
-    subtype: apigwv2.HttpIntegrationSubtype.SQS_PURGE_QUEUE,
-  }),
+
+// API Gateway WebSocket API
+const webSocketApi = new WebSocketApi(stack, 'webSocketApi', {
+  description: 'Send websocket data to SQS which is then processed by a Lambda 2',
+  routeSelectionExpression: '$request.body.action',
 });
 
-const integTest = new integ.IntegTest(app, 'SqsIntegrationIntegTest', {
-  testCases: [stack],
+// Optionally, create a WebSocket stage
+new WebSocketStage(stack, 'DevStage', {
+  webSocketApi: webSocketApi,
+  stageName: 'dev',
+  autoDeploy: true,
 });
 
-const defaultAssertion = integTest.assertions.httpApiCall(
-  `${httpApi.apiEndpoint}/default`, {
-    body: JSON.stringify({ MessageBody: 'Hello World!' }),
-    method: 'POST',
-  },
-);
-defaultAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));
+// IAM Role for API Gateway
+const webSocketApiRole = new iam.Role(stack, 'webSocketApiRole', {
+  assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com'),
+});
 
-const sendMessageAssertion = integTest.assertions.httpApiCall(
-  `${httpApi.apiEndpoint}/send-message`, {
-    body: JSON.stringify({ MessageBody: 'Hello World!' }),
-    method: 'POST',
-  },
+webSocketApiRole.addToPolicy(
+  new iam.PolicyStatement({
+    actions: ['sqs:SendMessage'],
+    effect: iam.Effect.ALLOW,
+    resources: [sqsMessageQueue.queueArn],
+  }),
 );
-sendMessageAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));
 
-const receiveMessageAssertion = integTest.assertions.httpApiCall(
-  `${httpApi.apiEndpoint}/receive-message`, {
-    method: 'POST',
-  },
-);
-receiveMessageAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));
+webSocketApi.addRoute('$default', {
+  integration: new WebSocketAwsIntegration('SQSSendMessage', {
+    integrationUri: `arn:aws:apigateway:${Aws.REGION}:sqs:path/${Aws.ACCOUNT_ID}/${sqsMessageQueue.queueName}`,
+    integrationMethod: HttpMethod.POST,
+    credentialsRole: webSocketApiRole,
+    passthroughBehavior: PassthroughBehavior.NEVER,
+    templateSelectionExpression: '\\$default',
+    requestTemplates: {
+      $default: 'Action=SendMessage&MessageGroupId=$input.path(\'$.MessageGroupId\')&MessageDeduplicationId=$context.requestId&MessageAttribute.1.Name=connectionId&MessageAttribute.1.Value.StringValue=$context.connectionId&MessageAttribute.1.Value.DataType=String&MessageAttribute.2.Name=requestId&MessageAttribute.2.Value.StringValue=$context.requestId&MessageAttribute.2.Value.DataType=String&MessageBody=$input.json(\'$\')',
+    },
+    requestParameters: {
+      'integration.request.header.Content-Type': '\'application/x-www-form-urlencoded\'',
+    },
+  }),
+});
 
-const purgeQueueAssertion = integTest.assertions.httpApiCall(
-  `${httpApi.apiEndpoint}/purge-queue`, {
-    method: 'POST',
+new IntegTest(app, 'apigatewayv2-aws-integration-sqs-integ-test', {
+  testCases: [stack],
+  cdkCommandOptions: {
+    deploy: {
+      args: {
+        rollback: true,
+      },
+    },
   },
-);
-purgeQueueAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-appsync/integ.graphql-lambda-permission.ts

@@ -16,7 +16,7 @@ const app = new cdk.App({
 const stack = new cdk.Stack(app, 'aws-graphql-lambda-permissions');
 
 const authorizer = new lambda.Function(stack, 'AuthorizerFunction', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   code: lambda.Code.fromInline(`
         exports.handler = async (event) => {
           console.log("Authorization event:", JSON.stringify(event));

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-appsync/integ.js-resolver.ts

@@ -64,7 +64,7 @@ const integ = new IntegTest(app, 'JsResolverIntegTest', { testCases: [stack] });
 const invoke = new lambda.Function(stack, 'InvokeApi', {
   code: lambda.Code.fromAsset(path.join(__dirname, 'integ-assets', 'js-resolver-assertion')),
   handler: 'index.handler',
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
 });
 
 const addTestInvoke = integ.assertions.invokeFunction({

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

@@ -531,7 +531,7 @@ about allowing connections between resources backed by instances.
 ## Max Instance Lifetime
 
 To enable the max instance lifetime support, specify `maxInstanceLifetime` property
-for the `AutoscalingGroup` resource. The value must be between 7 and 365 days(inclusive).
+for the `AutoscalingGroup` resource. The value must be between 1 and 365 days(inclusive).
 To clear a previously set value, leave this property undefined.
 
 ## Instance Monitoring

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-autoscaling/integ.asg-lt.ts

@@ -129,4 +129,11 @@ new autoscaling.AutoScalingGroup(stack, 'AsgWithIMDSv2', {
   vpc,
 });
 
+new autoscaling.AutoScalingGroup(stack, 'AsgFromMigrationToLT', {
+  vpc,
+  launchTemplate: lt,
+  migrateToLaunchTemplate: true,
+  updatePolicy: autoscaling.UpdatePolicy.rollingUpdate(),
+});
+
 app.synth();

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

@@ -65,7 +65,18 @@ For stateful or otherwise non-interruption-tolerant workflows, omit `spot` or se
 
 #### Choosing Your Instance Types
 
-Batch allows you to choose the instance types or classes that will run your workload.
+Batch allows you to choose most up-to-date instance classes based on your region.
+This example configures your `ComputeEnvironment` to use only ARM64 instance:
+
+```ts
+const vpc = new ec2.Vpc(this, 'VPC');
+
+new batch.ManagedEc2EcsComputeEnvironment(this, 'myEc2ComputeEnv', {
+  vpc,
+  defaultInstanceClasses: [batch.DefaultInstanceClass.ARM64],
+});
+```
+
 This example configures your `ComputeEnvironment` to use only the `M5AD.large` instance:
 
 ```ts
@@ -91,6 +102,9 @@ new batch.ManagedEc2EcsComputeEnvironment(this, 'myEc2ComputeEnv', {
 });
 ```
 
+> [!WARNING] 
+> `useOptimalInstanceClasses` is deprecated! Use `defaultInstanceClasses` instead.
+
 Unless you explicitly specify `useOptimalInstanceClasses: false`, this compute environment will use `'optimal'` instances,
 which tells Batch to pick an instance from the C4, M4, and R4 instance families.
 *Note*: Batch does not allow specifying instance types or classes with different architectures.
@@ -532,6 +546,40 @@ const jobDefn = new batch.EcsJobDefinition(this, 'JobDefn', {
 });
 ```
 
+### Enable Execute Command (ECS Exec)
+
+You can enable [ECS Exec](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html) for interactive debugging and troubleshooting by setting `enableExecuteCommand` to `true`.
+When enabled, you'll be able to execute commands interactively in running containers.
+
+```ts
+const jobDefn = new batch.EcsJobDefinition(this, 'JobDefn', {
+  container: new batch.EcsEc2ContainerDefinition(this, 'Ec2Container', {
+    image: ecs.ContainerImage.fromRegistry('public.ecr.aws/amazonlinux/amazonlinux:latest'),
+    memory: cdk.Size.mebibytes(2048),
+    cpu: 256,
+    enableExecuteCommand: true, // Enable ECS Exec
+  }),
+});
+```
+
+The same functionality is available for Fargate containers:
+
+```ts
+const jobDefn = new batch.EcsJobDefinition(this, 'JobDefn', {
+  container: new batch.EcsFargateContainerDefinition(this, 'FargateContainer', {
+    image: ecs.ContainerImage.fromRegistry('public.ecr.aws/amazonlinux/amazonlinux:latest'),
+    memory: cdk.Size.mebibytes(2048),
+    cpu: 256,
+    enableExecuteCommand: true, // Enable ECS Exec for Fargate
+  }),
+});
+```
+
+When `enableExecuteCommand` is set to `true`:
+
+- If no `jobRole` is provided, a new IAM role will be automatically created with the required SSM permissions
+- If a `jobRole` is already provided, the necessary SSM permissions will be added to the existing role
+
 ### Secrets
 
 You can expose SecretsManager Secret ARNs or SSM Parameters to your container as environment variables.

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

@@ -0,0 +1,148 @@
+import * as batch from 'aws-cdk-lib/aws-batch';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as cdk from 'aws-cdk-lib';
+import { IntegTest, ExpectedResult } from '@aws-cdk/integ-tests-alpha';
+
+class EcsExecBatchStack extends cdk.Stack {
+  public readonly ec2ComputeEnvironment: batch.ManagedEc2EcsComputeEnvironment;
+  public readonly fargateComputeEnvironment: batch.FargateComputeEnvironment;
+  public readonly ec2JobQueue: batch.JobQueue;
+  public readonly fargateJobQueue: batch.JobQueue;
+  public readonly ec2JobDefinition: batch.EcsJobDefinition;
+  public readonly fargateJobDefinition: batch.EcsJobDefinition;
+
+  constructor(scope: cdk.App, id: string, props: cdk.StackProps = {}) {
+    super(scope, id, props);
+
+    const vpc = new ec2.Vpc(this, 'Vpc', {
+      maxAzs: 2,
+    });
+
+    this.ec2ComputeEnvironment = new batch.ManagedEc2EcsComputeEnvironment(this, 'ComputeEnv', {
+      vpc,
+      instanceTypes: [ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.LARGE)],
+      minvCpus: 0,
+      maxvCpus: 256,
+    });
+
+    this.ec2JobQueue = new batch.JobQueue(this, 'JobQueue', {
+      computeEnvironments: [
+        {
+          order: 1,
+          computeEnvironment: this.ec2ComputeEnvironment,
+        },
+      ],
+    });
+
+    this.ec2JobDefinition = new batch.EcsJobDefinition(this, 'EcsExecEc2JobDefinition', {
+      jobDefinitionName: 'EcsExecEc2TestJob',
+      container: new batch.EcsEc2ContainerDefinition(this, 'Ec2Container', {
+        image: ecs.ContainerImage.fromRegistry('public.ecr.aws/amazonlinux/amazonlinux:latest'),
+        cpu: 2,
+        memory: cdk.Size.mebibytes(2048),
+        enableExecuteCommand: true,
+        command: ['sh', '-c', 'echo "Job started with ECS Exec enabled"; sleep 300'], // Keep container running
+      }),
+    });
+
+    this.fargateJobDefinition = new batch.EcsJobDefinition(this, 'EcsExecFargateJobDefinition', {
+      container: new batch.EcsFargateContainerDefinition(this, 'FargateContainer', {
+        image: ecs.ContainerImage.fromRegistry('public.ecr.aws/amazonlinux/amazonlinux:latest'),
+        cpu: 0.25,
+        memory: cdk.Size.gibibytes(1),
+        enableExecuteCommand: true, // Enable ECS Exec
+        command: ['sh', '-c', 'echo "Fargate Job started with ECS Exec enabled"; sleep 300'], // Keep container running
+      }),
+    });
+
+    // Create Fargate compute environment
+    this.fargateComputeEnvironment = new batch.FargateComputeEnvironment(this, 'FargateComputeEnv', {
+      vpc,
+    });
+
+    this.fargateJobQueue = new batch.JobQueue(this, 'FargateJobQueue', {
+      computeEnvironments: [
+        {
+          order: 1,
+          computeEnvironment: this.fargateComputeEnvironment,
+        },
+      ],
+    });
+  }
+}
+
+const app = new cdk.App();
+const stack = new EcsExecBatchStack(app, 'EcsExecBatchStack');
+
+const integ = new IntegTest(app, 'EcsExecBatchTest', {
+  testCases: [stack],
+});
+
+// Helper function to test ECS Exec for a job
+function testEcsExecForJob(
+  jobName: string,
+  jobQueue: batch.JobQueue,
+  jobDefinition: batch.EcsJobDefinition,
+  computeEnvironment: batch.IManagedComputeEnvironment,
+) {
+  // Get cluster ARN from compute environment
+  const describeComputeEnv = integ.assertions.awsApiCall('Batch', 'describeComputeEnvironments', {
+    computeEnvironments: [computeEnvironment.computeEnvironmentArn],
+  });
+
+  const clusterArn = describeComputeEnv.getAttString('computeEnvironments.0.ecsClusterArn');
+
+  // Submit the job
+  const submitJobResult = describeComputeEnv.next(
+    integ.assertions.awsApiCall('Batch', 'submitJob', {
+      jobName,
+      jobQueue: jobQueue.jobQueueArn,
+      jobDefinition: jobDefinition.jobDefinitionArn,
+    }),
+  ).waitForAssertions();
+
+  // Get the job ID from the submit response
+  const jobId = submitJobResult.getAttString('jobId');
+
+  // Wait for job to reach RUNNING state and have a task ARN
+  const waitForJobRunning = integ.assertions.awsApiCall('Batch', 'describeJobs', {
+    jobs: [jobId],
+  }).assertAtPath('jobs.0.status', ExpectedResult.stringLikeRegexp('RUNNING'))
+    .waitForAssertions({
+      totalTimeout: cdk.Duration.minutes(10),
+      interval: cdk.Duration.seconds(30),
+    });
+
+  const taskArn = waitForJobRunning.getAttString('jobs.0.container.taskArn');
+
+  // Execute ECS command to verify ECS Exec is enabled
+  waitForJobRunning.next(
+    integ.assertions.awsApiCall('ECS', 'executeCommand', {
+      cluster: clusterArn,
+      task: taskArn,
+      container: 'default',
+      interactive: true,
+      command: '/bin/bash',
+    }).waitForAssertions({
+      totalTimeout: cdk.Duration.minutes(10),
+      interval: cdk.Duration.seconds(30),
+    }),
+  );
+}
+
+// Test EC2 job
+testEcsExecForJob(
+  'test-ecs-exec-ec2-job',
+  stack.ec2JobQueue,
+  stack.ec2JobDefinition,
+  stack.ec2ComputeEnvironment,
+);
+
+// Test Fargate job
+testEcsExecForJob(
+  'test-ecs-exec-fargate-job',
+  stack.fargateJobQueue,
+  stack.fargateJobDefinition,
+  stack.fargateComputeEnvironment,
+);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-batch/integ.managed-compute-environment-default-instance-class.ts

@@ -0,0 +1,20 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { ManagedEc2EcsComputeEnvironment, EcsMachineImageType, DefaultInstanceClass } from 'aws-cdk-lib/aws-batch';
+
+const app = new App();
+const stack = new Stack(app, 'managed-compute-environment-default-instance-class');
+const vpc = new ec2.Vpc(stack, 'vpc', { restrictDefaultSecurityGroup: false });
+
+new ManagedEc2EcsComputeEnvironment(stack, 'ECS', {
+  vpc,
+  images: [{
+    imageType: EcsMachineImageType.ECS_AL2023,
+  }],
+  defaultInstanceClasses: [DefaultInstanceClass.ARM64],
+});
+
+new integ.IntegTest(app, 'integ-managed-compute-environment-default-instance-class', {
+  testCases: [stack],
+});

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

@@ -146,6 +146,17 @@ new acm.PrivateCertificate(this, 'PrivateCertificate', {
 });
 ```
 
+## Requesting public SSL/TLS certificates exportable to use anywhere
+
+AWS Certificate Manager can issue an exportable public certificate. There is a charge at certificate issuance and again when the certificate renews. See [opting out of certificate transparency logging](https://docs.aws.amazon.com/acm/latest/userguide/acm-exportable-certificates.html) for details.
+
+```ts
+new acm.Certificate(this, 'Certificate', {
+  domainName: 'test.example.com',
+  allowExport: true,
+});
+```
+
 ## Requesting certificates without transparency logging
 
 Transparency logging can be opted out of for AWS Certificate Manager certificates. See [opting out of certificate transparency logging](https://docs.aws.amazon.com/acm/latest/userguide/acm-bestpractices.html#best-practices-transparency) for limits.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudformation/integ.core-custom-resources-node-18.ts

@@ -21,7 +21,7 @@ class TestStack extends Stack {
 
     const serviceToken = CustomResourceProvider.getOrCreate(this, resourceType, {
       codeDirectory: `${__dirname}/core-custom-resource-provider-fixture`,
-      runtime: CustomResourceProviderRuntime.NODEJS_18_X,
+      runtime: CustomResourceProviderRuntime.NODEJS_20_X,
       description: 'veni vidi vici',
     });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudformation/integ.core-custom-resources-service-timeout.ts

@@ -16,7 +16,7 @@ class TestStack extends Stack {
 
     const serviceToken = CustomResourceProvider.getOrCreate(this, resourceType, {
       codeDirectory: `${__dirname}/core-custom-resource-provider-fixture`,
-      runtime: CustomResourceProviderRuntime.NODEJS_18_X,
+      runtime: CustomResourceProviderRuntime.NODEJS_20_X,
       description: 'veni vidi vici',
     });