konokenj.cdk-api-mcp-server 0.39.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

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

@@ -18,6 +18,7 @@
 - [WebSocket API](#websocket-api)
   - [Manage Connections Permission](#manage-connections-permission)
   - [Managing access to WebSocket APIs](#managing-access-to-websocket-apis)
+  - [Usage Plan and API Keys](#usage-plan-and-api-keys)
 
 ## Introduction
 
@@ -589,3 +590,146 @@ new apigwv2.HttpStage(this, 'Stage', {
   detailedMetricsEnabled: true,
 });
 ```
+## Usage Plan and API Keys
+
+A usage plan specifies who can access one or more deployed WebSocket API stages, and the rate at which they can be accessed. The plan uses API keys to
+identify API clients and meters access to the associated API stages for each key. Usage plans also allow configuring throttling limits and quota limits that are
+enforced on individual client API keys.
+
+The following example shows how to create and associate a usage plan and an API key for WebSocket APIs:
+
+```ts
+const apiKey = new apigwv2.ApiKey(this, "ApiKey");
+
+const usagePlan = new apigwv2.UsagePlan(this, "UsagePlan", {
+  usagePlanName: "WebSocketUsagePlan",
+  throttle: {
+    rateLimit: 10,
+    burstLimit: 2
+  }
+});
+
+usagePlan.addApiKey(apiKey);
+```
+
+To associate a plan to a given WebSocketAPI stage:
+
+```ts
+const api = new apigwv2.WebSocketApi(this, 'my-api');
+const stage = new apigwv2.WebSocketStage(this, 'my-stage', {
+  webSocketApi: api,
+  stageName: 'dev',
+});
+
+const usagePlan = new apigwv2.UsagePlan(this, 'my-usage-plan', {
+  usagePlanName: 'Basic',
+});
+
+usagePlan.addApiStage({
+  api: api,
+  stage: stage,
+});
+```
+Existing usage plans can be imported into a CDK app using its id.
+
+```ts
+const usagePlan: apigwv2.IUsagePlan = apigwv2.UsagePlan.fromUsagePlanId(this, 'imported-usage-plan', '<usage-plan-id>');
+```
+
+The name and value of the API Key can be specified at creation; if not provided, a name and a value will be automatically generated by API Gateway.
+
+```ts
+// Auto-generated name and value
+const autoKey = new apigwv2.ApiKey(this, 'AutoKey');                                                                                                            
+                                                                                                                                                                     
+// Explicit name and value                                                                                                                                           
+const explicitKey = new apigwv2.ApiKey(this, 'ExplicitKey', {                                                                                                   
+  apiKeyName: 'MyWebSocketApiKey',                                                                                                                                   
+  value: 'MyApiKeyThatIsAtLeast20Characters',                                                                                                                        
+});         
+```
+
+Existing API keys can also be imported into a CDK app using its id.
+
+```ts
+const importedKey = apigwv2.ApiKey.fromApiKeyId(this, 'imported-key', '<api-key-id>');
+```
+
+The "grant" methods can be used to give prepackaged sets of permissions to other resources. The
+following code provides read permission to an API key.
+
+```ts
+import * as iam from 'aws-cdk-lib/aws-iam';
+
+const user = new iam.User(this, 'User');
+const apiKey = new apigwv2.ApiKey(this, 'ApiKey', {
+  customerId: 'test-customer',
+});
+apiKey.grantRead(user);
+```
+
+### Adding an API Key to an imported WebSocketApi
+
+API Keys for WebSocket APIs are associated through Usage Plans, not directly to stages. When you import a WebSocketApi, you need to create a Usage Plan that references the
+imported stage and then associate the API key with that Usage Plan.
+
+```ts
+declare const webSocketApi: apigwv2.IWebSocketApi;
+                                                                                                                                                                                   
+const importedStage = apigwv2.WebSocketStage.fromWebSocketStageAttributes(this, 'imported-stage', {                                                                           
+  stageName: 'myStage',                                                                                                                                                            
+  api: webSocketApi,                                                                                                                                                               
+});                                                                                                                                                                                
+                                                                                                                                                                                   
+const apiKey = new apigwv2.ApiKey(this, 'MyApiKey');                                                                                                                          
+                                                                                                                                                                                   
+const usagePlan = new apigwv2.UsagePlan(this, 'MyUsagePlan', {                                                                                                                
+  apiStages: [{ api: webSocketApi, stage: importedStage }],                                                                                                                        
+});                                                                                                                                                                                
+                                                                                                                                                                                   
+usagePlan.addApiKey(apiKey);
+```
+
+### Multiple API Keys
+
+It is possible to specify multiple API keys for a given Usage Plan, by calling `usagePlan.addApiKey()`.
+
+When using multiple API keys, you may need to ensure that the CloudFormation logical ids of the API keys remain consistent across deployments. You can set the logical id as part of the `addApiKey()` method
+
+```ts
+declare const usagePlan: apigwv2.UsagePlan;
+declare const apiKey: apigwv2.ApiKey;
+
+usagePlan.addApiKey(apiKey, {
+ overrideLogicalId: 'MyCustomLogicalId',
+});
+```
+
+### Rate Limited API Key
+
+In scenarios where you need to create a single api key and configure rate limiting for it, you can use `RateLimitedApiKey`.
+This construct lets you specify rate limiting properties which should be applied only to the api key being created.
+The API key created has the specified rate limits, such as quota and throttles, applied.
+
+The following example shows how to use a rate limited api key :
+
+```ts
+declare const api: apigwv2.WebSocketApi;
+declare const stage: apigwv2.WebSocketStage;
+
+const key = new apigwv2.RateLimitedApiKey(this, 'rate-limited-api-key', {
+  customerId: 'test-customer',
+  apiStages: [{
+    api: api,
+    stage: stage
+  }],
+  quota: {
+    limit: 10000,
+    period: apigwv2.Period.MONTH
+  },
+  throttle: {
+    rateLimit: 100,
+    burstLimit: 200
+  }
+});            
+```

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/integ.usage-plan.ts

@@ -0,0 +1,80 @@
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as cdk from 'aws-cdk-lib';
+import { WebSocketApi, WebSocketStage, UsagePlan, ApiKey, RateLimitedApiKey, Period } from 'aws-cdk-lib/aws-apigatewayv2';
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2-websocket-usage-plan');
+
+const webSocketApi = new WebSocketApi(stack, 'WebSocketApi');
+
+const webSocketStage = new WebSocketStage(stack, 'WebSocketStage', {
+  webSocketApi,
+  stageName: 'dev',
+});
+
+const apiKey = new ApiKey(stack, 'ApiKey', {
+  apiKeyName: 'my-api-key',
+  value: 'MyApiKeyThatIsAtLeast20Characters',
+  description: 'Basic api-key',
+  customerId: 'my-customer',
+  enabled: true,
+  generateDistinctId: true,
+});
+
+const usagePlan = new UsagePlan(stack, 'UsagePlan', {
+  apiStages: [{
+    api: webSocketApi,
+    stage: webSocketStage,
+  }],
+  description: 'Basic usage plan',
+  quota: {
+    limit: 10000,
+    offset: 1,
+    period: Period.MONTH,
+  },
+  throttle: {
+    rateLimit: 100,
+    burstLimit: 200,
+  },
+  usagePlanName: 'WebSocketUsagePlan',
+});
+
+const webSocketStage2 = new WebSocketStage(stack, 'WebSocketStage2', {
+  webSocketApi,
+  stageName: 'dev2',
+});
+
+usagePlan.addApiKey(apiKey);
+usagePlan.addApiStage({ api: webSocketApi, stage: webSocketStage2 });
+
+const webSocketStage3 = new WebSocketStage(stack, 'WebSocketStage3', {
+  webSocketApi,
+  stageName: 'dev3',
+});
+
+new RateLimitedApiKey(stack, 'RateLimitedApiKey', {
+  apiKeyName: 'my-rate-limited-api-key',
+  value: 'MyRateLimitedApiKeyThatIsAtLeast20Characters',
+  description: 'Basic rate-limited-api-key',
+  customerId: 'my-customer',
+  enabled: true,
+  generateDistinctId: true,
+  apiStages: [{
+    api: webSocketApi,
+    stage: webSocketStage3,
+  }],
+  quota: {
+    limit: 10000,
+    offset: 1,
+    period: Period.MONTH,
+  },
+  throttle: {
+    rateLimit: 100,
+    burstLimit: 200,
+  },
+});
+
+new integ.IntegTest(app, 'WebSocketUsagePlanInteg', {
+  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-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-codedeploy/integ.deployment-config.ts

@@ -2,17 +2,28 @@ 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();
-const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-ecs-config');
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-lambda-config');
 
-new codedeploy.EcsDeploymentConfig(stack, 'LinearConfig', {
+new codedeploy.LambdaDeploymentConfig(stack, 'LinearConfig', {
   trafficRouting: codedeploy.TrafficRouting.timeBasedLinear({
     interval: cdk.Duration.minutes(1),
     percentage: 5,
   }),
 });
 
-new integ.IntegTest(app, 'EcsDeploymentConfigTest', {
+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', {
   testCases: [stack],
 });