konokenj.cdk-api-mcp-server 0.43.0__py3-none-any.whl → 0.45.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.43.0"
+__version__ = "0.45.0"

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

@@ -150,7 +150,7 @@ new iot.AccountAuditConfiguration(this, 'AuditConfiguration', {
   checkConfiguration: {
     deviceCertificateAgeCheck: true,
     // The default value is 365 days
-    // Valid values range from 30 days (minimum) to 3652 days (10 years, maximum)
+    // Valid values range from 30 days (minimum) to 3650 days (10 years, maximum)
     deviceCertificateAgeCheckDuration: Duration.days(365),
   },
 });

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

@@ -524,6 +524,14 @@ const arn = api.arnForExecuteApiV2('$connect', 'dev');
 
 For a detailed explanation of this function, including usage and examples, please refer to the [Generating ARN for Execute API](#generating-arn-for-execute-api) section under HTTP API.
 
+To disable schema validation, set `disableSchemaValidation` to true.
+
+```ts
+new apigwv2.WebSocketApi(this, 'api', {
+  disableSchemaValidation: true,
+});
+```
+
 You can configure IP address type for the API endpoint using `ipAddressType` property.
 Valid values are `IPV4` (default) and `DUAL_STACK`.
 

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

@@ -8,6 +8,10 @@ const stack = new cdk.Stack(app, 'aws-cdk-aws-apigatewayv2');
 
 new apigw.WebSocketApi(stack, 'WebSocketApi');
 
+new apigw.WebSocketApi(stack, 'WebSocketApiWithProps', {
+  disableSchemaValidation: true,
+});
+
 new IntegTest(app, 'web-socket-api', {
   testCases: [stack],
 });

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

@@ -532,6 +532,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-cloudfront-origins/README.md

@@ -577,6 +577,7 @@ const origin = new origins.LoadBalancerV2Origin(loadBalancer, {
   connectionAttempts: 3,
   connectionTimeout: Duration.seconds(5),
   readTimeout: Duration.seconds(45),
+  responseCompletionTimeout: Duration.seconds(120),
   keepaliveTimeout: Duration.seconds(45),
   protocolPolicy: cloudfront.OriginProtocolPolicy.MATCH_VIEWER,
 });
@@ -596,6 +597,22 @@ new cloudfront.Distribution(this, 'myDist', {
 });
 ```
 
+The origin can be customized with timeout settings to handle different response scenarios:
+
+```ts
+new cloudfront.Distribution(this, 'Distribution', {
+  defaultBehavior: {
+    origin: new origins.HttpOrigin('api.example.com', {
+      readTimeout: Duration.seconds(60),
+      responseCompletionTimeout: Duration.seconds(120),
+      keepaliveTimeout: Duration.seconds(45),
+    }),
+  },
+});
+```
+
+The `responseCompletionTimeout` property specifies the time that a request from CloudFront to the origin can stay open and wait for a response. If the complete response isn't received from the origin by this time, CloudFront ends the connection. Valid values are 1-3600 seconds, and if set, the value must be equal to or greater than the `readTimeout` value.
+
 See the documentation of `aws-cdk-lib/aws-cloudfront` for more information.
 
 ## VPC origins
@@ -801,6 +818,25 @@ new cloudfront.Distribution(this, 'Distribution', {
 });
 ```
 
+You can also configure timeout settings for Lambda Function URL origins:
+
+```ts
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+
+declare const fn: lambda.Function;
+const fnUrl = fn.addFunctionUrl({ authType: lambda.FunctionUrlAuthType.NONE });
+
+new cloudfront.Distribution(this, 'Distribution', {
+  defaultBehavior: {
+    origin: new origins.FunctionUrlOrigin(fnUrl, {
+      readTimeout: Duration.seconds(30),
+      responseCompletionTimeout: Duration.seconds(90),
+      keepaliveTimeout: Duration.seconds(45),
+    }),
+  },
+});
+```
+
 ### Lambda Function URL with Origin Access Control (OAC)
 You can configure the Lambda Function URL with Origin Access Control (OAC) for enhanced security. When using OAC with Signing SIGV4_ALWAYS, it is recommended to set the Lambda Function URL authType to AWS_IAM to ensure proper authorization.
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.origin-response-completion-timeout.ts

@@ -0,0 +1,50 @@
+import * as cloudfront from 'aws-cdk-lib/aws-cloudfront';
+import * as origins from 'aws-cdk-lib/aws-cloudfront-origins';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'integ-cloudfront-response-completion-timeout');
+
+const httpOrigin = new origins.HttpOrigin('example.com', {
+  responseCompletionTimeout: cdk.Duration.seconds(120),
+  readTimeout: cdk.Duration.seconds(60),
+});
+
+const fn = new lambda.Function(stack, 'Function', {
+  runtime: lambda.Runtime.NODEJS_18_X,
+  handler: 'index.handler',
+  code: lambda.Code.fromInline('exports.handler = async () => ({ statusCode: 200, body: "Hello from Lambda!" });'),
+});
+
+const fnUrl = fn.addFunctionUrl({
+  authType: lambda.FunctionUrlAuthType.NONE,
+});
+
+const functionUrlOrigin = new origins.FunctionUrlOrigin(fnUrl, {
+  responseCompletionTimeout: cdk.Duration.seconds(90),
+  readTimeout: cdk.Duration.seconds(30),
+});
+
+const httpOriginNoReadTimeout = new origins.HttpOrigin('api.example.com', {
+  responseCompletionTimeout: cdk.Duration.seconds(300),
+});
+
+new cloudfront.Distribution(stack, 'Distribution', {
+  defaultBehavior: {
+    origin: httpOrigin,
+  },
+  additionalBehaviors: {
+    '/api/*': {
+      origin: functionUrlOrigin,
+    },
+    '/files/*': {
+      origin: httpOriginNoReadTimeout,
+    },
+  },
+});
+
+new IntegTest(app, 'CloudFrontResponseCompletionTimeoutTest', {
+  testCases: [stack],
+});

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

@@ -376,6 +376,7 @@ can use the `environment` property to customize the build environment:
   details on how to define build images.
 * `certificate` defines the location of a PEM encoded certificate to import.
 * `computeType` defines the instance type used for the build.
+* `dockerServer` defines the docker server used for the build.
 * `privileged` can be set to `true` to allow privileged access.
 * `environmentVariables` can be set at this level (and also at the project
   level).

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-docker-server.ts

@@ -0,0 +1,44 @@
+import { App, Stack } from 'aws-cdk-lib';
+import { Project, BuildSpec, DockerServerComputeType, Source, ComputeType } from 'aws-cdk-lib/aws-codebuild';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+
+const app = new App();
+const stack = new Stack(app, 'codebuild-project-docker-server');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { restrictDefaultSecurityGroup: false });
+const sg = new ec2.SecurityGroup(stack, 'SecurityGroup', { vpc });
+
+const project = new Project(stack, 'MyProject', {
+  source: Source.gitHub({
+    owner: 'dockersamples',
+    repo: 'helloworld-demo-python',
+  }),
+  buildSpec: BuildSpec.fromObject({
+    version: '0.2',
+    phases: {
+      build: {
+        commands: [
+          'cd sample',
+          'docker buildx build .',
+        ],
+      },
+    },
+  }),
+  environment: {
+    computeType: ComputeType.SMALL,
+    dockerServer: {
+      computeType: DockerServerComputeType.SMALL,
+      securityGroups: [sg],
+    },
+  },
+});
+
+const integ = new IntegTest(app, 'codebuild-project-docker-server-integ', {
+  testCases: [stack],
+});
+
+// Execute the `startBuild` API to confirm that the build can be done correctly.
+integ.assertions.awsApiCall('CodeBuild', 'startBuild', {
+  projectName: project.projectName,
+}).waitForAssertions();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codepipeline-actions/integ.pipeline-elastic-beanstalk-deploy.ts

@@ -2,11 +2,13 @@ import * as path from 'path';
 import * as codepipeline from 'aws-cdk-lib/aws-codepipeline';
 import * as elasticbeanstalk from 'aws-cdk-lib/aws-elasticbeanstalk';
 import * as iam from 'aws-cdk-lib/aws-iam';
+import { IManagedPolicy, ManagedPolicyReference } from 'aws-cdk-lib/aws-iam';
 import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as deploy from 'aws-cdk-lib/aws-s3-deployment';
-import { App, Fn, RemovalPolicy, Stack } from 'aws-cdk-lib';
+import { App, Fn, RemovalPolicy, Stack, UnscopedValidationError } from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as cpactions from 'aws-cdk-lib/aws-codepipeline-actions';
+import { Node } from 'constructs';
 
 /**
  * To validate that the deployment actually succeeds, perform the following actions:
@@ -43,16 +45,26 @@ const artifact = new deploy.BucketDeployment(stack, 'DeployApp', {
   extract: false,
 });
 
+function makePolicy(arn: string): IManagedPolicy {
+  return {
+    managedPolicyArn: arn,
+    get managedPolicyRef(): ManagedPolicyReference {
+      return {
+        policyArn: this.managedPolicyArn,
+      };
+    },
+    get node(): Node {
+      throw new UnscopedValidationError('The result of fromAwsManagedPolicyName can not be used in this API');
+    },
+  };
+}
+
 const serviceRole = new iam.Role(stack, 'service-role', {
   roleName: 'codepipeline-elasticbeanstalk-action-test-serivce-role',
   assumedBy: new iam.ServicePrincipal('elasticbeanstalk.amazonaws.com'),
   managedPolicies: [
-    {
-      managedPolicyArn: 'arn:aws:iam::aws:policy/service-role/AWSElasticBeanstalkEnhancedHealth',
-    },
-    {
-      managedPolicyArn: 'arn:aws:iam::aws:policy/AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy',
-    },
+    makePolicy('arn:aws:iam::aws:policy/service-role/AWSElasticBeanstalkEnhancedHealth'),
+    makePolicy('arn:aws:iam::aws:policy/AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy'),
   ],
 });
 
@@ -60,15 +72,9 @@ const instanceProfileRole = new iam.Role(stack, 'instance-profile-role', {
   roleName: 'codepipeline-elasticbeanstalk-action-test-instance-profile-role',
   assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
   managedPolicies: [
-    {
-      managedPolicyArn: 'arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier',
-    },
-    {
-      managedPolicyArn: 'arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker',
-    },
-    {
-      managedPolicyArn: 'arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier',
-    },
+    makePolicy('arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier'),
+    makePolicy('arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker'),
+    makePolicy('arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier'),
   ],
 });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecr-assets/README.md

@@ -163,6 +163,10 @@ This will instruct the toolkit to add the tarball as a file asset. During deploy
 from `local-image.tar`, push it to an Amazon ECR repository and wire the name of the repository as CloudFormation parameters
 to your stack.
 
+Similar to `DockerImageAsset`, you can set the `CDK_DOCKER` environment variable to provide a custom Docker executable 
+command or path. This may be needed when building in environments where the standard docker cannot be executed or when 
+using alternative container runtimes like Finch.
+
 ## Publishing images to ECR repositories
 
 `DockerImageAsset` is designed for seamless build & consumption of image assets by CDK code deployed to multiple environments

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

@@ -1591,6 +1591,8 @@ it in the constructor. Then add the Capacity Provider to the cluster. Finally,
 you can refer to the Provider by its name in your service's or task's Capacity
 Provider strategy.
 
+> **Note**: Cross-stack capacity provider registration is not supported. The ECS cluster and its capacity providers must be created in the same stack to avoid circular dependency issues.
+
 By default, Auto Scaling Group Capacity Providers will manage the scale-in and
 scale-out behavior of the auto scaling group based on the load your tasks put on
 the cluster, this is called [Managed Scaling](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/asg-capacity-providers.html#asg-capacity-providers-managed-scaling). If you'd

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

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

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

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

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

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

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

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

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

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