konokenj.cdk-api-mcp-server 0.28.0__py3-none-any.whl → 0.30.0__py3-none-any.whl

cdk_api_mcp_server/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Kenji Kono <konoken@amazon.co.jp>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.28.0"
+__version__ = "0.30.0"

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-amplify-alpha/README.md

@@ -238,6 +238,68 @@ const amplifyApp = new amplify.App(this, 'App', {
 });
 ```
 
+If the app uses a monorepo structure, define which appRoot from the build spec the custom response headers should apply to by using the `appRoot` property:
+
+```ts
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+
+const amplifyApp = new amplify.App(this, 'App', {
+  sourceCodeProvider: new amplify.GitHubSourceCodeProvider({
+    owner: '<user>',
+    repository: '<repo>',
+    oauthToken: SecretValue.secretsManager('my-github-token'),
+  }),
+  buildSpec: codebuild.BuildSpec.fromObjectToYaml({
+    version: '1.0',
+    applications: [
+      {
+        appRoot: 'frontend',
+        frontend: {
+          phases: {
+            preBuild: {
+              commands: ['npm install'],
+            },
+            build: {
+              commands: ['npm run build'],
+            },
+          },
+        },
+      },
+      {
+        appRoot: 'backend',
+        backend: {
+          phases: {
+            preBuild: {
+              commands: ['npm install'],
+            },
+            build: {
+              commands: ['npm run build'],
+            },
+          },
+        },
+      },
+    ],
+  }),
+  customResponseHeaders: [
+    {
+      appRoot: 'frontend',
+      pattern: '*.json',
+      headers: {
+        'custom-header-name-1': 'custom-header-value-1',
+        'custom-header-name-2': 'custom-header-value-2',
+      },
+    },
+    {
+      appRoot: 'backend',
+      pattern: '/path/*',
+      headers: {
+        'custom-header-name-1': 'custom-header-value-2',
+      },
+    },
+  ],
+});
+```
+
 ## Configure server side rendering when hosting app
 
 Setting the `platform` field on the Amplify `App` construct can be used to control whether the app will host only static assets or server side rendered assets in addition to static. By default, the value is set to `WEB` (static only), however, server side rendering can be turned on by setting to `WEB_COMPUTE` as follows:
@@ -268,6 +330,15 @@ const amplifyApp = new amplify.App(this, 'MyApp', {
 });
 ```
 
+It is also possible to override the compute role for a specific branch by setting `computeRole` in `Branch`:
+
+```ts
+declare const computeRole: iam.Role;
+declare const amplifyApp: amplify.App
+
+const branch = amplifyApp.addBranch("dev", { computeRole });
+```
+
 ## Cache Config
 
 Amplify uses Amazon CloudFront to manage the caching configuration for your hosted applications. A cache configuration is applied to each app to optimize for the best performance.

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/integ-tests-alpha/README.md

@@ -18,7 +18,7 @@
 
 ## Overview
 
-This library is meant to be used in combination with the [integ-runner](https://github.com/aws/aws-cdk/tree/main/packages/%40aws-cdk/integ-runner) CLI
+This library is meant to be used in combination with the [integ-runner](https://github.com/aws/aws-cdk-cli/tree/main/packages/%40aws-cdk/integ-runner) CLI
 to enable users to write and execute integration tests for AWS CDK Constructs.
 
 An integration test should be defined as a CDK application, and

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2/integ.api-dualstack.ts

@@ -4,13 +4,14 @@ import * as cdk from 'aws-cdk-lib';
 import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
 
 const app = new cdk.App();
-const stack = new cdk.Stack(app, 'DualStackWebsocketApiStack');
+const stack = new cdk.Stack(app, 'DualStackHttpApiStack');
 
-new apigw.WebSocketApi(stack, 'WebSocketApi', {
+new apigw.HttpApi(stack, 'HttpApi', {
+  routeSelectionExpression: true,
   ipAddressType: apigw.IpAddressType.DUAL_STACK,
 });
 
-new IntegTest(app, 'DualStackWebsocketApiInteg', {
+new IntegTest(app, 'DualStackHttpApiInteg', {
   testCases: [stack],
 });
 

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

@@ -6,9 +6,11 @@ import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
 const app = new cdk.App();
 const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2');
 
-new apigw.WebSocketApi(stack, 'WebSocketApi');
+new apigw.HttpApi(stack, 'HttpApi', {
+  routeSelectionExpression: true,
+});
 
-new IntegTest(app, 'web-socket-api', {
+new IntegTest(app, 'http-api', {
   testCases: [stack],
 });
 

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

@@ -1,20 +1,33 @@
 #!/usr/bin/env node
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 import * as cdk from 'aws-cdk-lib';
-import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigw from 'aws-cdk-lib/aws-apigateway';
+import * as logs from 'aws-cdk-lib/aws-logs';
 
 const app = new cdk.App();
-const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2-websocket-stage');
+const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2-http-stage');
 
-const webSocketApi = new apigw.WebSocketApi(stack, 'WebSocketApi');
-new apigw.WebSocketStage(stack, 'WebSocketStage', {
-  webSocketApi,
-  stageName: 'dev',
+const testLogGroup = new logs.LogGroup(stack, 'MyLogGroup');
+
+const httpApi = new apigwv2.HttpApi(stack, 'HttpApi', { createDefaultStage: false });
+new apigwv2.HttpStage(stack, 'HttpStageWithProperties', {
+  httpApi,
   throttle: {
     rateLimit: 1000,
     burstLimit: 1000,
   },
   detailedMetricsEnabled: true,
   description: 'My Stage',
+  accessLogSettings: {
+    destination: new apigwv2.LogGroupLogDestination(testLogGroup),
+    format: apigw.AccessLogFormat.custom(JSON.stringify({
+      extendedRequestId: apigw.AccessLogField.contextExtendedRequestId(),
+      requestTime: apigw.AccessLogField.contextRequestTime(),
+    })),
+  },
 });
 
-app.synth();
+new IntegTest(app, 'aws-cdk-aws-apigatewayv2-http-stage-test', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigatewayv2-authorizers/integ.iam.ts

@@ -1,53 +1,46 @@
 import * as apigatewayv2 from 'aws-cdk-lib/aws-apigatewayv2';
-import { WebSocketLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
 import * as iam from 'aws-cdk-lib/aws-iam';
-import { Code, Function, Runtime } from 'aws-cdk-lib/aws-lambda';
 import * as cdk from 'aws-cdk-lib';
-import { Stack } from 'aws-cdk-lib';
-import * as integ from '@aws-cdk/integ-tests-alpha';
-import { WebSocketIamAuthorizer } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
+import { HttpIamAuthorizer } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
 
-const app = new cdk.App({
-  postCliContext: {
-    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
-  },
-});
+class ExampleComIntegration extends apigatewayv2.HttpRouteIntegration {
+  public bind(): apigatewayv2.HttpRouteIntegrationConfig {
+    return {
+      type: apigatewayv2.HttpIntegrationType.HTTP_PROXY,
+      payloadFormatVersion: apigatewayv2.PayloadFormatVersion.VERSION_1_0,
+      method: apigatewayv2.HttpMethod.GET,
+      uri: 'https://www.example.com/',
+    };
+  }
+}
+
+const app = new cdk.App();
 const stack = new cdk.Stack(app, 'IntegApiGatewayV2Iam');
 const user = new iam.User(stack, 'User');
 const userAccessKey = new iam.AccessKey(stack, 'UserAccess', {
   user,
 });
 
-const handler = new Function(stack, 'auth-function', {
-  runtime: Runtime.NODEJS_18_X,
-  code: Code.fromInline('exports.handler = () => {return true}'),
-  handler: 'index.handler',
+const httpApi = new apigatewayv2.HttpApi(stack, 'HttpApi', {
+  defaultAuthorizer: new HttpIamAuthorizer(),
 });
 
-const webSocketApi = new apigatewayv2.WebSocketApi(stack, 'WebSocketApi', {
-  connectRouteOptions: {
-    integration: new WebSocketLambdaIntegration('WebSocketLambdaIntegration', handler),
-    authorizer: new WebSocketIamAuthorizer(),
-  },
+const [fooRoute] = httpApi.addRoutes({
+  integration: new ExampleComIntegration('examplecom'),
+  path: '/foo',
 });
 
-const arn = Stack.of(stack).formatArn({
-  service: 'execute-api',
-  resource: webSocketApi.apiId,
+fooRoute.grantInvoke(user);
+
+const [booksRoute] = httpApi.addRoutes({
+  integration: new ExampleComIntegration('examplecom'),
+  path: '/books/{book}',
 });
 
-user.attachInlinePolicy(new iam.Policy(stack, 'AllowInvoke', {
-  statements: [
-    new iam.PolicyStatement({
-      actions: ['execute-api:Invoke'],
-      effect: iam.Effect.ALLOW,
-      resources: [arn],
-    }),
-  ],
-}));
+booksRoute.grantInvoke(user);
 
-new integ.IntegTest(app, 'ApiGatewayV2WebSocketIamTest', {
-  testCases: [stack],
+new cdk.CfnOutput(stack, 'API', {
+  value: httpApi.url!,
 });
 
 new cdk.CfnOutput(stack, 'TESTACCESSKEYID', {
@@ -62,4 +55,15 @@ new cdk.CfnOutput(stack, 'TESTREGION', {
   value: stack.region,
 });
 
-app.synth();
+/*
+ * Stack verification steps:
+ * * Get cURL version 7.75.0 or later so you can use the --aws-sigv4 option
+ * * Curl <url>/foo without sigv4 and expect a 403
+ * * Curl <url>/books/something without sigv4 and expect a 403
+ * * Curl <url>/foo with sigv4 from the authorized user and expect 200
+ * * Curl <url>/books/something with sigv4 from the authorized user and expect 200
+ *
+ * Reference:
+ * * Using cURL 7.75.0 or later via the official docker image: docker run --rm curlimages/curl -s -o/dev/null -w"%{http_code}" <url>
+ * * Args to enable sigv4 with authorized credentials: --user "$TESTACCESSKEYID:$TESTSECRETACCESSKEY" --aws-sigv4 "aws:amz:$TESTREGION:execute-api"
+ */

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

@@ -1,72 +1,85 @@
-import { HttpMethod, PassthroughBehavior, WebSocketApi, WebSocketStage } from 'aws-cdk-lib/aws-apigatewayv2';
+import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';
 import * as sqs from 'aws-cdk-lib/aws-sqs';
-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';
-
-/*
- * Stack verification steps:
- * 1. Verify manually that the integration has type "AWS"
- */
+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';
 
 const app = new App();
-const stack = new Stack(app, 'integ-aws-websocket-sqs-integration');
+const stack = new Stack(app, 'sqs-integration');
 
-const sqsMessageQueue = new sqs.Queue(stack, 'MessageSQSQueue', {
-  fifo: true,
-  queueName: 'MessageSQSQueue.fifo',
-});
+const queue = new sqs.Queue(stack, '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 httpApi = new apigwv2.HttpApi(stack, 'Api');
+httpApi.addRoutes({
+  path: '/default',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('defaultIntegration', {
+    queue,
+  }),
 });
-
-// Optionally, create a WebSocket stage
-new WebSocketStage(stack, 'DevStage', {
-  webSocketApi: webSocketApi,
-  stageName: 'dev',
-  autoDeploy: true,
+httpApi.addRoutes({
+  path: '/send-message',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('sendMessageIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_SEND_MESSAGE,
+  }),
 });
-
-// IAM Role for API Gateway
-const webSocketApiRole = new iam.Role(stack, 'webSocketApiRole', {
-  assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com'),
+httpApi.addRoutes({
+  path: '/receive-message',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('receiveMessageIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_RECEIVE_MESSAGE,
+  }),
 });
-
-webSocketApiRole.addToPolicy(
-  new iam.PolicyStatement({
-    actions: ['sqs:SendMessage'],
-    effect: iam.Effect.ALLOW,
-    resources: [sqsMessageQueue.queueArn],
+httpApi.addRoutes({
+  path: '/delete-message',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('deleteMessageIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_DELETE_MESSAGE,
   }),
-);
-
-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\'',
-    },
+});
+httpApi.addRoutes({
+  path: '/purge-queue',
+  methods: [apigwv2.HttpMethod.POST],
+  integration: new HttpSqsIntegration('purgeQueueIntegration', {
+    queue,
+    subtype: apigwv2.HttpIntegrationSubtype.SQS_PURGE_QUEUE,
   }),
 });
 
-new IntegTest(app, 'apigatewayv2-aws-integration-sqs-integ-test', {
+const integTest = new integ.IntegTest(app, 'SqsIntegrationIntegTest', {
   testCases: [stack],
-  cdkCommandOptions: {
-    deploy: {
-      args: {
-        rollback: 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' }));
+
+const sendMessageAssertion = integTest.assertions.httpApiCall(
+  `${httpApi.apiEndpoint}/send-message`, {
+    body: JSON.stringify({ MessageBody: 'Hello World!' }),
+    method: 'POST',
+  },
+);
+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' }));
+
+const purgeQueueAssertion = integTest.assertions.httpApiCall(
+  `${httpApi.apiEndpoint}/purge-queue`, {
+    method: 'POST',
+  },
+);
+purgeQueueAssertion.expect(integ.ExpectedResult.objectLike({ status: 200, statusText: 'OK' }));

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

@@ -84,6 +84,7 @@ plan.addSelection('Selection', {
 To add rules to a plan, use `addRule()`:
 
 ```ts
+import { TimeZone } from 'aws-cdk-lib';
 declare const plan: backup.BackupPlan;
 plan.addRule(new backup.BackupPlanRule({
   completionWindow: Duration.hours(2),
@@ -93,6 +94,7 @@ plan.addRule(new backup.BackupPlanRule({
     hour: '3',
     minute: '30',
   }),
+  scheduleExpressionTimezone: TimeZone.ETC_UTC,
   moveToColdStorageAfter: Duration.days(30),
 }));
 ```

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

@@ -1,6 +1,7 @@
 import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
 import * as efs from 'aws-cdk-lib/aws-efs';
-import { App, Duration, RemovalPolicy, Stack, StackProps, CfnParameter } from 'aws-cdk-lib';
+import * as events from 'aws-cdk-lib/aws-events';
+import { App, Duration, RemovalPolicy, Stack, StackProps, CfnParameter, TimeZone } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import * as backup from 'aws-cdk-lib/aws-backup';
 
@@ -61,6 +62,16 @@ class TestStack extends Stack {
         stage: 'prod',
       },
     }));
+
+    plan.addRule(new backup.BackupPlanRule({
+      backupVault: vault,
+      scheduleExpression: events.Schedule.cron({
+        day: '15',
+        hour: '3',
+        minute: '30',
+      }),
+      scheduleExpressionTimezone: TimeZone.ETC_UTC,
+    }));
   }
 }
 

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

@@ -1252,7 +1252,24 @@ When using a CloudFront PublicKey, only the `comment` field can be updated after
 Resource handler returned message: "Invalid request provided: AWS::CloudFront::PublicKey"
 ```
 
-To update the `encodedKey`, you must change the logical ID of the public key resource in your template. This causes CloudFormation to create a new `cloudfront.PublicKey` resource and delete the old one during the next deployment.
+To update the `encodedKey`, you must change the ID of the public key resource in your template. This causes CloudFormation to create a new `cloudfront.PublicKey` resource and delete the old one during the next deployment.
+
+Example:
+
+```ts
+// Step 1: Original deployment
+const originalKey = new cloudfront.PublicKey(this, 'MyPublicKeyV1', {
+  encodedKey: '...', // contents of original public_key.pem file
+});
+```
+
+Regenerate a new key and change the construct id in the code:
+```ts
+// Step 2: In a subsequent deployment, create a new key with a different ID
+const updatedKey = new cloudfront.PublicKey(this, 'MyPublicKeyV2', {
+  encodedKey: '...', // contents of new public_key.pem file
+});
+```
 
 
 See:

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

@@ -959,3 +959,35 @@ const dashboard = new cw.Dashboard(this, 'Dash', {
 ```
 
 You can add a variable after object instantiation with the method `dashboard.addVariable()`.
+
+### Cross-Account Visibility
+
+Both Log and Metric Widget objects support cross-account visibility by allowing you to specify the AWS Account ID that the data (logs or metrics) originates from.
+
+**Prerequisites:**
+1. The monitoring account must be set up as a monitoring account
+2. The source account must grant permissions to the monitoring account
+3. Appropriate IAM roles and policies must be configured
+
+For detailed setup instructions, see [Cross-Account Cross-Region CloudWatch Console](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html).
+
+
+To use this feature, you can set the `accountId` property on `LogQueryWidget`, `GraphWidget`, `AlarmWidget`, `SingleValueWidget`, and `GaugeWidget` constructs:
+
+```ts
+declare const dashboard: cloudwatch.Dashboard;
+
+dashboard.addWidgets(new cloudwatch.GraphWidget({
+  // ...
+  accountId: '123456789012',
+}));
+
+dashboard.addWidgets(new cloudwatch.LogQueryWidget({
+  logGroupNames: ['my-log-group'],
+  // ...
+  accountId: '123456789012',
+  queryLines: [
+    'fields @message',
+  ],
+}));
+```

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch/integ.alarm-and-dashboard.ts

@@ -92,6 +92,7 @@ dashboard.addWidgets(new cloudwatch.LogQueryWidget({
   logGroupNames: ['my-log-group'],
   queryString: `fields @message
                 | filter @message like /Error/`,
+  accountId: '123456789012',
 }));
 dashboard.addWidgets(new cloudwatch.SingleValueWidget({
   title: 'Sent message size',

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch/integ.math-alarm-and-dashboard.ts

@@ -51,6 +51,7 @@ const dashboard = new cloudwatch.Dashboard(stack, 'Dash', {
 dashboard.addWidgets(new cloudwatch.AlarmWidget({
   title: 'Total messages in queue',
   alarm,
+  accountId: '123456789012',
 }));
 
 dashboard.addWidgets(new cloudwatch.GraphWidget({
@@ -58,18 +59,21 @@ dashboard.addWidgets(new cloudwatch.GraphWidget({
   left: [sumExpression],
   right: [metricA, metricB],
   leftAnnotations: [alarm.toAnnotation()],
+  accountId: '123456789012',
 }));
 
 dashboard.addWidgets(new cloudwatch.GraphWidget({
   title: 'Percentage of messages in each queue as pie chart',
   left: [metricA, metricB],
   view: cloudwatch.GraphWidgetView.PIE,
+  accountId: '123456789012',
   setPeriodToTimeRange: true,
 }));
 
 dashboard.addWidgets(new cloudwatch.SingleValueWidget({
   title: 'Current total messages in queue',
   metrics: [sumExpression],
+  accountId: '123456789012',
 }));
 
 new IntegTest(app, 'cdk-integ-math-alarm-and-dashboard', {

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codedeploy/integ.deployment-config.ts

@@ -2,28 +2,17 @@ import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as codedeploy from 'aws-cdk-lib/aws-codedeploy';
 
-const app = new cdk.App({
-  postCliContext: {
-    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
-  },
-});
-const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-lambda-config');
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-ecs-config');
 
-new codedeploy.LambdaDeploymentConfig(stack, 'LinearConfig', {
+new codedeploy.EcsDeploymentConfig(stack, 'LinearConfig', {
   trafficRouting: codedeploy.TrafficRouting.timeBasedLinear({
     interval: cdk.Duration.minutes(1),
     percentage: 5,
   }),
 });
 
-new codedeploy.CustomLambdaDeploymentConfig(stack, 'CustomConfig', {
-  interval: cdk.Duration.minutes(1),
-  percentage: 5,
-  type: cdk.aws_codedeploy.CustomLambdaDeploymentConfigType.LINEAR,
-  deploymentConfigName: 'hello',
-});
-
-new integ.IntegTest(app, 'LambdaDeploymentConfigTest', {
+new integ.IntegTest(app, 'EcsDeploymentConfigTest', {
   testCases: [stack],
 });