konokenj.cdk-api-mcp-server 0.65.0__py3-none-any.whl → 0.67.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-rds/integ.option-group.ts

@@ -0,0 +1,40 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as cdk from 'aws-cdk-lib';
+import {
+  DatabaseInstanceEngine,
+  OptionGroup,
+  OracleEngineVersion,
+} from 'aws-cdk-lib/aws-rds';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+class OptionGroupTestStack extends cdk.Stack {
+  constructor(scope: cdk.App, id: string) {
+    super(scope, id);
+    const vpc = new ec2.Vpc(this, 'VPC', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+
+    const optionGroup = new OptionGroup(this, 'OptionGroup', {
+      engine: DatabaseInstanceEngine.oracleSe2({
+        version: OracleEngineVersion.VER_19,
+      }),
+      description: 'Custom Option Grouptest',
+      optionGroupName: 'custom-og-name',
+      configurations: [
+        {
+          name: 'OEM',
+          port: 1158,
+          vpc,
+        },
+      ],
+    });
+    optionGroup.optionConnections.OEM.connections.allowDefaultPortFrom(
+      ec2.Peer.ipv4('10.0.0.0/16'),
+    );
+  }
+}
+
+const app = new cdk.App();
+const stack = new OptionGroupTestStack(app, 'aws-rds-option-group');
+new IntegTest(app, 'OptionGroupTest', {
+  testCases: [stack],
+});
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-route53-targets/integ.elastic-beanstalk-environment-target.ts

@@ -10,6 +10,7 @@ import { RegionInfo } from 'aws-cdk-lib/region-info';
 import * as iam from 'aws-cdk-lib/aws-iam';
 import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as s3assets from 'aws-cdk-lib/aws-s3-assets';
+import { SOLUTION_STACK_NAME } from '../../utils/aws-elasticbeanstalk';
 
 class TestStack extends cdk.Stack {
   constructor(scope: Construct, id: string) {
@@ -77,7 +78,7 @@ class TestStack extends cdk.Stack {
 
     const eb = new elasticbeanstalk.CfnEnvironment(this, 'Environment', {
       applicationName: appName,
-      solutionStackName: '64bit Amazon Linux 2023 v6.4.3 running Node.js 20',
+      solutionStackName: SOLUTION_STACK_NAME.NODEJS_20,
       environmentName: 'MyEnvironment',
       optionSettings: optionSettingProperties,
       versionLabel: appVersion.ref,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-route53-targets/integ.elastic-beanstalk-hostedzoneid.ts

@@ -7,6 +7,7 @@ import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 import * as elasticbeanstalk from 'aws-cdk-lib/aws-elasticbeanstalk';
 import * as custom from 'aws-cdk-lib/custom-resources';
 import { RegionInfo } from '@aws-cdk/region-info';
+import { SOLUTION_STACK_NAME } from '../../utils/aws-elasticbeanstalk';
 
 const app = new App({
   postCliContext: {
@@ -63,7 +64,7 @@ const optionSettings: elasticbeanstalk.CfnEnvironment.OptionSettingProperty[] =
 
 const ebsEnv = new elasticbeanstalk.CfnEnvironment(stack, 'Environment', {
   applicationName,
-  solutionStackName: '64bit Amazon Linux 2023 v6.5.0 running Node.js 22',
+  solutionStackName: SOLUTION_STACK_NAME.NODEJS_22,
   optionSettings,
 });
 ebsEnv.addDependency(ebsApp);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-route53-targets/integ.elastic-beanstalk-token-endpoint.ts

@@ -6,6 +6,7 @@ import * as targets from 'aws-cdk-lib/aws-route53-targets';
 import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 import * as elasticbeanstalk from 'aws-cdk-lib/aws-elasticbeanstalk';
 import * as custom from 'aws-cdk-lib/custom-resources';
+import { SOLUTION_STACK_NAME } from '../../utils/aws-elasticbeanstalk';
 
 const app = new App({
   postCliContext: {
@@ -66,7 +67,7 @@ const optionSettings: elasticbeanstalk.CfnEnvironment.OptionSettingProperty[] =
 
 const ebsEnv = new elasticbeanstalk.CfnEnvironment(stack, 'Environment', {
   applicationName,
-  solutionStackName: '64bit Amazon Linux 2023 v6.5.0 running Node.js 22',
+  solutionStackName: SOLUTION_STACK_NAME.NODEJS_22,
   optionSettings,
 });
 ebsEnv.addDependency(ebsApp);

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

@@ -49,6 +49,7 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
     - [RunTask](#runtask)
       - [EC2](#ec2)
       - [Fargate](#fargate)
+      - [Capacity Provider Options](#capacity-provider-options)
       - [Override CPU and Memory Parameter](#override-cpu-and-memory-parameter)
       - [ECS enable Exec](#ecs-enable-exec)
   - [EMR](#emr)
@@ -829,6 +830,52 @@ const runTask = new tasks.EcsRunTask(this, 'RunFargate', {
 });
 ```
 
+#### Capacity Provider Options
+
+The `capacityProviderOptions` property allows you to configure the capacity provider
+strategy for both EC2 and Fargate launch targets.
+
+- When `CapacityProviderOptions.custom()` is used, you can specify a custom capacity provider strategy.
+- When `CapacityProviderOptions.default()` is used, the task uses the cluster's default capacity provider strategy.
+- If `capacityProviderOptions` is not specified, the task uses the launch type (EC2 or FARGATE) without a capacity provider strategy.
+
+```ts
+const vpc = ec2.Vpc.fromLookup(this, 'Vpc', {
+  isDefault: true,
+});
+
+const cluster = new ecs.Cluster(this, 'FargateCluster', { vpc });
+
+const taskDefinition = new ecs.TaskDefinition(this, 'TD', {
+  memoryMiB: '512',
+  cpu: '256',
+  compatibility: ecs.Compatibility.FARGATE,
+});
+
+// Use custom() option - specify custom capacity provider strategy
+const runTaskWithCustom = new tasks.EcsRunTask(this, 'RunTaskWithCustom', {
+  cluster,
+  taskDefinition,
+  launchTarget: new tasks.EcsFargateLaunchTarget({
+    platformVersion: ecs.FargatePlatformVersion.VERSION1_4,
+    capacityProviderOptions: tasks.CapacityProviderOptions.custom([
+      { capacityProvider: 'FARGATE_SPOT', weight: 2, base: 1 },
+      { capacityProvider: 'FARGATE', weight: 1 },
+    ]),
+  }),
+});
+
+// Use default() option - uses cluster's default capacity provider strategy
+const runTaskWithDefault = new tasks.EcsRunTask(this, 'RunTaskWithDefault', {
+  cluster,
+  taskDefinition,
+  launchTarget: new tasks.EcsFargateLaunchTarget({
+    platformVersion: ecs.FargatePlatformVersion.VERSION1_4,
+    capacityProviderOptions: tasks.CapacityProviderOptions.default(),
+  }),
+});
+```
+
 #### Override CPU and Memory Parameter
 
 By setting the property cpu or memoryMiB, you can override the Fargate or EC2 task instance size at runtime.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.ec2-run-task-capacity-provider.ts

@@ -0,0 +1,145 @@
+import * as path from 'path';
+import * as asg from 'aws-cdk-lib/aws-autoscaling';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as cdk from 'aws-cdk-lib';
+import { Duration } from 'aws-cdk-lib';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import { IntegTest, ExpectedResult } from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-sfn-tasks-ecs-ec2-run-task-capacity-provider');
+
+const cluster = new ecs.Cluster(stack, 'Ec2Cluster');
+
+// Create Auto Scaling Groups
+const autoScalingGroup1 = new asg.AutoScalingGroup(stack, 'AutoScalingGroup1', {
+  vpc: cluster.vpc,
+  instanceType: new ec2.InstanceType('t2.micro'),
+  machineImage: ecs.EcsOptimizedImage.amazonLinux2(),
+  minCapacity: 1,
+  maxCapacity: 2,
+  vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC },
+});
+
+const autoScalingGroup2 = new asg.AutoScalingGroup(stack, 'AutoScalingGroup2', {
+  vpc: cluster.vpc,
+  instanceType: new ec2.InstanceType('t2.micro'),
+  machineImage: ecs.EcsOptimizedImage.amazonLinux2(),
+  minCapacity: 1,
+  maxCapacity: 2,
+  vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC },
+});
+
+// Create and add Capacity Providers
+const capacityProvider1 = new ecs.AsgCapacityProvider(stack, 'CP1', {
+  autoScalingGroup: autoScalingGroup1,
+  enableManagedTerminationProtection: false,
+  enableManagedDraining: true,
+});
+
+const capacityProvider2 = new ecs.AsgCapacityProvider(stack, 'CP2', {
+  autoScalingGroup: autoScalingGroup2,
+  enableManagedTerminationProtection: false,
+  enableManagedDraining: true,
+});
+
+cluster.addAsgCapacityProvider(capacityProvider1);
+cluster.addAsgCapacityProvider(capacityProvider2);
+
+// Set default capacity provider strategy for the cluster
+cluster.addDefaultCapacityProviderStrategy([
+  { capacityProvider: capacityProvider1.capacityProviderName, weight: 1, base: 1 },
+  { capacityProvider: capacityProvider2.capacityProviderName, weight: 2 },
+]);
+
+// Build task definition
+const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef');
+const containerDefinition = taskDefinition.addContainer('Container', {
+  image: ecs.ContainerImage.fromAsset(path.resolve(__dirname, 'eventhandler-image')),
+  memoryLimitMiB: 256,
+  logging: new ecs.AwsLogDriver({ streamPrefix: 'EventDemo' }),
+});
+
+// Build state machine with different capacity provider options
+const definition = new sfn.Pass(stack, 'Start', {
+  result: sfn.Result.fromObject({ SomeKey: 'SomeValue' }),
+}).next(
+  // Task without capacity provider option - uses launch type
+  new tasks.EcsRunTask(stack, 'Ec2TaskWithNone', {
+    integrationPattern: sfn.IntegrationPattern.RUN_JOB,
+    cluster,
+    taskDefinition,
+    containerOverrides: [
+      {
+        containerDefinition,
+        environment: [
+          {
+            name: 'SOME_KEY',
+            value: sfn.JsonPath.stringAt('$.SomeKey'),
+          },
+        ],
+      },
+    ],
+    launchTarget: new tasks.EcsEc2LaunchTarget(),
+    enableExecuteCommand: true,
+    resultPath: sfn.JsonPath.DISCARD,
+  }),
+).next(
+  // Task with custom capacity provider option
+  new tasks.EcsRunTask(stack, 'Ec2TaskWithCustom', {
+    cluster,
+    taskDefinition,
+    launchTarget: new tasks.EcsEc2LaunchTarget({
+      capacityProviderOptions: tasks.CapacityProviderOptions.custom([
+        {
+          capacityProvider: capacityProvider1.capacityProviderName,
+          weight: 1,
+          base: 0,
+        },
+        {
+          capacityProvider: capacityProvider2.capacityProviderName,
+          weight: 2,
+          base: 1,
+        },
+      ]),
+    }),
+    resultPath: sfn.JsonPath.DISCARD,
+  }),
+).next(
+  // Task with default capacity provider option - uses cluster default
+  new tasks.EcsRunTask(stack, 'Ec2TaskWithDefault', {
+    cluster,
+    taskDefinition,
+    launchTarget: new tasks.EcsEc2LaunchTarget({
+      capacityProviderOptions: tasks.CapacityProviderOptions.default(),
+    }),
+    resultPath: sfn.JsonPath.DISCARD,
+  }),
+);
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definition,
+});
+
+const integ = new IntegTest(app, 'SfnTasksEcsEc2RunTaskCapacityProviderTest', {
+  testCases: [stack],
+});
+
+// Start state machine execution and verify it succeeds
+const startExecutionCall = integ.assertions.awsApiCall('StepFunctions', 'startExecution', {
+  stateMachineArn: sm.stateMachineArn,
+  input: JSON.stringify({ SomeKey: 'SomeValue' }),
+});
+
+startExecutionCall.next(
+  integ.assertions.awsApiCall('StepFunctions', 'describeExecution', {
+    executionArn: startExecutionCall.getAttString('executionArn'),
+  }).expect(ExpectedResult.objectLike({
+    status: 'SUCCEEDED',
+  })).waitForAssertions({
+    totalTimeout: Duration.minutes(15),
+    interval: Duration.seconds(10),
+  }),
+);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.ec2-run-task-ref-definition.ts

@@ -10,8 +10,6 @@ import { EC2_RESTRICT_DEFAULT_SECURITY_GROUP, STEPFUNCTIONS_TASKS_FIX_RUN_ECS_TA
 const app = new cdk.App({
   postCliContext: {
     '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
-    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
-    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
     '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
   },
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.ec2-run-task.ts

@@ -20,8 +20,6 @@ import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 const app = new cdk.App({
   postCliContext: {
     '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
-    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
-    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
     '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
   },
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.ec2-task.ts

@@ -20,8 +20,6 @@ import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 const app = new cdk.App({
   postCliContext: {
     '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
-    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
-    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
     '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
   },
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.fargate-run-task-capacity-provider.ts

@@ -0,0 +1,125 @@
+import * as path from 'path';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as cdk from 'aws-cdk-lib';
+import { Duration } from 'aws-cdk-lib';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import { IntegTest, ExpectedResult } from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-sfn-tasks-ecs-fargate-run-task-capacity-provider');
+
+const cluster = new ecs.Cluster(stack, 'FargateCluster');
+
+// Enable FARGATE and FARGATE_SPOT capacity providers
+cluster.enableFargateCapacityProviders();
+
+// Set default capacity provider strategy for the cluster
+cluster.addDefaultCapacityProviderStrategy([
+  { capacityProvider: 'FARGATE', weight: 1, base: 1 },
+  { capacityProvider: 'FARGATE_SPOT', weight: 4 },
+]);
+
+// Build task definition
+const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef', {
+  memoryLimitMiB: 512,
+  cpu: 256,
+  runtimePlatform: {
+    cpuArchitecture: ecs.CpuArchitecture.X86_64,
+    operatingSystemFamily: ecs.OperatingSystemFamily.LINUX,
+  },
+});
+const containerDefinition = taskDefinition.addContainer('TheContainer', {
+  image: ecs.ContainerImage.fromAsset(path.resolve(__dirname, 'eventhandler-image')),
+  memoryLimitMiB: 256,
+  logging: new ecs.AwsLogDriver({ streamPrefix: 'EventDemo' }),
+});
+
+// Build state machine with different capacity provider options
+const definition = new sfn.Pass(stack, 'Start', {
+  result: sfn.Result.fromObject({ SomeKey: 'SomeValue', Timeout: 900 }),
+}).next(
+  // Task without capacity provider option - uses launch type
+  new tasks.EcsRunTask(stack, 'FargateTaskWithNone', {
+    integrationPattern: sfn.IntegrationPattern.RUN_JOB,
+    cluster,
+    taskDefinition,
+    assignPublicIp: true,
+    containerOverrides: [
+      {
+        containerDefinition,
+        environment: [
+          {
+            name: 'SOME_KEY',
+            value: sfn.JsonPath.stringAt('$.SomeKey'),
+          },
+        ],
+      },
+    ],
+    launchTarget: new tasks.EcsFargateLaunchTarget({
+      platformVersion: ecs.FargatePlatformVersion.VERSION1_4,
+    }),
+    taskTimeout: sfn.Timeout.at('$.Timeout'),
+    cpu: '1024',
+    memoryMiB: '2048',
+    resultPath: sfn.JsonPath.DISCARD,
+  }),
+).next(
+  // Task with custom capacity provider option
+  new tasks.EcsRunTask(stack, 'FargateTaskWithCustom', {
+    cluster,
+    taskDefinition,
+    launchTarget: new tasks.EcsFargateLaunchTarget({
+      platformVersion: ecs.FargatePlatformVersion.VERSION1_4,
+      capacityProviderOptions: tasks.CapacityProviderOptions.custom([
+        {
+          capacityProvider: 'FARGATE',
+          weight: 1,
+          base: 0,
+        },
+        {
+          capacityProvider: 'FARGATE_SPOT',
+          weight: 2,
+          base: 1,
+        },
+      ]),
+    }),
+    resultPath: sfn.JsonPath.DISCARD,
+  }),
+).next(
+  // Task with default capacity provider option - uses cluster default
+  new tasks.EcsRunTask(stack, 'FargateTaskWithDefault', {
+    cluster,
+    taskDefinition,
+    launchTarget: new tasks.EcsFargateLaunchTarget({
+      platformVersion: ecs.FargatePlatformVersion.VERSION1_4,
+      capacityProviderOptions: tasks.CapacityProviderOptions.default(),
+    }),
+    resultPath: sfn.JsonPath.DISCARD,
+  }),
+);
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definition,
+});
+
+const integ = new IntegTest(app, 'SfnTasksEcsFargateRunTaskCapacityProviderTest', {
+  testCases: [stack],
+});
+
+// Start state machine execution and verify it succeeds
+const startExecutionCall = integ.assertions.awsApiCall('StepFunctions', 'startExecution', {
+  stateMachineArn: sm.stateMachineArn,
+  input: JSON.stringify({ SomeKey: 'SomeValue', Timeout: 900 }),
+});
+
+startExecutionCall.next(
+  integ.assertions.awsApiCall('StepFunctions', 'describeExecution', {
+    executionArn: startExecutionCall.getAttString('executionArn'),
+  }).expect(ExpectedResult.objectLike({
+    status: 'SUCCEEDED',
+  })).waitForAssertions({
+    totalTimeout: Duration.minutes(15),
+    interval: Duration.seconds(10),
+  }),
+);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/cx-api/FEATURE_FLAGS.md

@@ -84,8 +84,6 @@ Flags come in three types:
 | [@aws-cdk/aws-ec2:bastionHostUseAmazonLinux2023ByDefault](#aws-cdkaws-ec2bastionhostuseamazonlinux2023bydefault) | When enabled, the BastionHost construct will use the latest Amazon Linux 2023 AMI, instead of Amazon Linux 2. | 2.172.0 | new default |
 | [@aws-cdk/core:aspectStabilization](#aws-cdkcoreaspectstabilization) | When enabled, a stabilization loop will be run when invoking Aspects during synthesis. | 2.172.0 | config |
 | [@aws-cdk/aws-route53-targets:userPoolDomainNameMethodWithoutCustomResource](#aws-cdkaws-route53-targetsuserpooldomainnamemethodwithoutcustomresource) | When enabled, use a new method for DNS Name of user pool domain target without creating a custom resource. | 2.174.0 | fix |
-| [@aws-cdk/aws-ecs:disableEcsImdsBlocking](#aws-cdkaws-ecsdisableecsimdsblocking) | When set to true, CDK synth will throw exception if canContainersAccessInstanceRole is false. **IMPORTANT: See [details.](#aws-cdkaws-ecsdisableEcsImdsBlocking)** | 2.175.0 | temporary |
-| [@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature](#aws-cdkaws-ecsenableimdsblockingdeprecatedfeature) | When set to true along with canContainersAccessInstanceRole=false in ECS cluster, new updated commands will be added to UserData to block container accessing IMDS. **Applicable to Linux only. IMPORTANT: See [details.](#aws-cdkaws-ecsenableImdsBlockingDeprecatedFeature)** | 2.175.0 | temporary |
 | [@aws-cdk/aws-elasticloadbalancingV2:albDualstackWithoutPublicIpv4SecurityGroupRulesDefault](#aws-cdkaws-elasticloadbalancingv2albdualstackwithoutpublicipv4securitygrouprulesdefault) | When enabled, the default security group ingress rules will allow IPv6 ingress from anywhere | 2.176.0 | fix |
 | [@aws-cdk/aws-iam:oidcRejectUnauthorizedConnections](#aws-cdkaws-iamoidcrejectunauthorizedconnections) | When enabled, the default behaviour of OIDC provider will reject unauthorized connections | 2.177.0 | fix |
 | [@aws-cdk/core:enableAdditionalMetadataCollection](#aws-cdkcoreenableadditionalmetadatacollection) | When enabled, CDK will expand the scope of usage data collected to better inform CDK development and improve communication for security concerns and emerging issues. | 2.178.0 | config |
@@ -110,7 +108,7 @@ Flags come in three types:
 | [@aws-cdk/aws-ecs-patterns:uniqueTargetGroupId](#aws-cdkaws-ecs-patternsuniquetargetgroupid) | When enabled, ECS patterns will generate unique target group IDs to prevent conflicts during load balancer replacement | 2.221.0 | fix |
 | [@aws-cdk/aws-stepfunctions-tasks:httpInvokeDynamicJsonPathEndpoint](#aws-cdkaws-stepfunctions-taskshttpinvokedynamicjsonpathendpoint) | When enabled, allows using a dynamic apiEndpoint with JSONPath format in HttpInvoke tasks. | 2.221.0 | fix |
 | [@aws-cdk/aws-elasticloadbalancingv2:networkLoadBalancerWithSecurityGroupByDefault](#aws-cdkaws-elasticloadbalancingv2networkloadbalancerwithsecuritygroupbydefault) | When enabled, Network Load Balancer will be created with a security group by default. | 2.222.0 | new default |
-| [@aws-cdk/aws-route53-patterns:useDistribution](#aws-cdkaws-route53-patternsusedistribution) | Use the `Distribution` resource instead of `CloudFrontWebDistribution` | V2NEXT | new default |
+| [@aws-cdk/aws-route53-patterns:useDistribution](#aws-cdkaws-route53-patternsusedistribution) | Use the `Distribution` resource instead of `CloudFrontWebDistribution` | 2.233.0 | new default |
 
 <!-- END table -->
 
@@ -177,8 +175,6 @@ The following json shows the current recommended set of flags, as `cdk init` wou
     "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault": false,
     "@aws-cdk/aws-s3:keepNotificationInImportedBucket": false,
     "@aws-cdk/core:explicitStackTags": true,
-    "@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature": false,
-    "@aws-cdk/aws-ecs:disableEcsImdsBlocking": true,
     "@aws-cdk/aws-ecs:reduceEc2FargateCloudWatchPermissions": true,
     "@aws-cdk/aws-dynamodb:resourcePolicyPerReplica": true,
     "@aws-cdk/aws-ec2:ec2SumTImeoutEnabled": true,
@@ -1787,49 +1783,6 @@ If the flag is set to false then a custom resource will be created when using `U
 | 2.174.0 | `false` | `true` |
 
 
-### @aws-cdk/aws-ecs:disableEcsImdsBlocking
-
-*When set to true, CDK synth will throw exception if canContainersAccessInstanceRole is false. **IMPORTANT: See [details.](#aws-cdkaws-ecsdisableEcsImdsBlocking)***
-
-Flag type: Temporary flag
-
-In an ECS Cluster with `MachineImageType.AMAZON_LINUX_2`, the canContainersAccessInstanceRole=false option attempts to add commands to block containers from
-accessing IMDS. CDK cannot guarantee the correct execution of the feature in all platforms. Setting this feature flag
-to true will ensure CDK does not attempt to implement IMDS blocking. By <ins>**end of 2025**</ins>, CDK will remove the
-IMDS blocking feature. See [Github discussion](https://github.com/aws/aws-cdk/discussions/32609) for more information.
-
-It is recommended to follow ECS documentation to block IMDS for your specific platform and cluster configuration.
-
-
-| Since | Unset behaves like | Recommended value |
-| ----- | ----- | ----- |
-| (not in v1) |  |  |
-| 2.175.0 | `false` | `true` |
-
-**Compatibility with old behavior:** It is strongly recommended to set this flag to true. However, if necessary, set this flag to false to continue using the old implementation.
-
-
-### @aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature
-
-*When set to true along with canContainersAccessInstanceRole=false in ECS cluster, new updated commands will be added to UserData to block container accessing IMDS. **Applicable to Linux only. IMPORTANT: See [details.](#aws-cdkaws-ecsenableImdsBlockingDeprecatedFeature)***
-
-Flag type: Temporary flag
-
-In an ECS Cluster with `MachineImageType.AMAZON_LINUX_2`, the canContainersAccessInstanceRole=false option attempts to add commands to block containers from
-accessing IMDS. Set this flag to true in order to use new and updated commands. Please note that this
-feature alone with this feature flag will be deprecated by <ins>**end of 2025**</ins> as CDK cannot
-guarantee the correct execution of the feature in all platforms. See [Github discussion](https://github.com/aws/aws-cdk/discussions/32609) for more information.
-It is recommended to follow ECS documentation to block IMDS for your specific platform and cluster configuration.
-
-
-| Since | Unset behaves like | Recommended value |
-| ----- | ----- | ----- |
-| (not in v1) |  |  |
-| 2.175.0 | `false` | `false` |
-
-**Compatibility with old behavior:** Set this flag to false in order to continue using old and outdated commands. However, it is **not** recommended.
-
-
 ### @aws-cdk/aws-elasticloadbalancingV2:albDualstackWithoutPublicIpv4SecurityGroupRulesDefault
 
 *When enabled, the default security group ingress rules will allow IPv6 ingress from anywhere*
@@ -2353,7 +2306,7 @@ of the deprecated `CloudFrontWebDistribution` construct.
 | Since | Unset behaves like | Recommended value |
 | ----- | ----- | ----- |
 | (not in v1) |  |  |
-| V2NEXT | `false` | `true` |
+| 2.233.0 | `false` | `true` |
 
 **Compatibility with old behavior:** Define a `CloudFrontWebDistribution` explicitly
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/cx-api/README.md

@@ -528,48 +528,6 @@ _cdk.json_
 }
 ```
 
-* `@aws-cdk/aws-ecs:disableEcsImdsBlocking`
-
-When set to true, CDK synth will throw exception if canContainersAccessInstanceRole is false.
-
-In an ECS Cluster with `MachineImageType.AMAZON_LINUX_2`, the canContainersAccessInstanceRole=false option attempts to add commands to block containers from
-accessing IMDS. CDK cannot guarantee the correct execution of the feature in all platforms. Setting this feature flag
-to true will ensure CDK does not attempt to implement IMDS blocking. By <ins>**end of 2025**</ins>, CDK will remove the
-IMDS blocking feature. See [Github discussion](https://github.com/aws/aws-cdk/discussions/32609) for more information.
-
-**It is recommended to follow ECS documentation to block IMDS for your specific platform and cluster configuration.**
-
-_cdk.json_
-
-```json
-{
-  "context": {
-    "@aws-cdk/aws-ecs:disableEcsImdsBlocking": true
-  }
-}
-```
-
-* `@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature`
-
-When set to true along with canContainersAccessInstanceRole=false in ECS cluster, new updated commands will be added to UserData to block container accessing IMDS. **Applicable to Linux only.**
-
-In an ECS Cluster with `MachineImageType.AMAZON_LINUX_2`, the canContainersAccessInstanceRole=false option attempts to add commands to block containers from
-accessing IMDS. Set this flag to true in order to use new and updated commands. Please note that this
-feature alone with this feature flag will be deprecated by <ins>end of 2025</ins> as CDK cannot
-guarantee the correct execution of the feature in all platforms. See [Github discussion](https://github.com/aws/aws-cdk/discussions/32609) for more information.
-
-**It is recommended to follow ECS documentation to block IMDS for your specific platform and cluster configuration.**
-
-_cdk.json_
-
-```json
-{
-  "context": {
-    "@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature": false,
-  },
-}
-```
-
 * `@aws-cdk/aws-elasticloadbalancingV2:albDualstackWithoutPublicIpv4SecurityGroupRulesDefault`
 
 When enabled, the default security group ingress rules will allow IPv6 ingress from anywhere,

{konokenj_cdk_api_mcp_server-0.65.0.dist-info → konokenj_cdk_api_mcp_server-0.67.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konokenj.cdk-api-mcp-server
-Version: 0.65.0
+Version: 0.67.0
 Summary: An MCP server provides AWS CDK API Reference
 Project-URL: Documentation, https://github.com/konokenj/cdk-api-mcp-server#readme
 Project-URL: Issues, https://github.com/konokenj/cdk-api-mcp-server/issues
@@ -26,7 +26,7 @@ Description-Content-Type: text/markdown
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/konokenj.cdk-api-mcp-server.svg)](https://pypi.org/project/konokenj.cdk-api-mcp-server)
 
 <!-- DEP-VERSIONS-START -->
-[![aws-cdk](https://img.shields.io/badge/aws%20cdk-v2.232.1-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
+[![aws-cdk](https://img.shields.io/badge/aws%20cdk-v2.233.0-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
 <!-- DEP-VERSIONS-END -->
 
 ---