konokenj.cdk-api-mcp-server 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

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

@@ -0,0 +1,140 @@
+import * as codepipeline from 'aws-cdk-lib/aws-codepipeline';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import * as targets from 'aws-cdk-lib/aws-elasticloadbalancingv2-targets';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as s3deployment from 'aws-cdk-lib/aws-s3-deployment';
+import * as cdk from 'aws-cdk-lib';
+import * as cpactions from 'aws-cdk-lib/aws-codepipeline-actions';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as path from 'path';
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'aws-cdk-codepipeline-ec2-deploy');
+
+const vpc = new ec2.Vpc(stack, 'VPC', {
+  maxAzs: 2,
+  natGateways: 0,
+  restrictDefaultSecurityGroup: false,
+});
+
+const instances = Object.fromEntries(Object.entries({ NoLB: [0, 1], LB: [0, 1] }).map(([tagValue, indexs]) => {
+  const innerInstances = indexs.map((index) => {
+    const userData = ec2.UserData.forLinux();
+    userData.addCommands('dnf install httpd -y', 'mkdir -p /var/www/html', 'touch /var/www/html/index.html', 'systemctl start httpd');
+    const instance = new ec2.Instance(stack, `Instance-${tagValue}-${index}`, {
+      vpc,
+      vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC },
+      availabilityZone: vpc.publicSubnets[index].availabilityZone,
+      machineImage: ec2.MachineImage.latestAmazonLinux2023({ cpuType: ec2.AmazonLinuxCpuType.ARM_64 }),
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE4_GRAVITON, ec2.InstanceSize.MICRO),
+      ssmSessionPermissions: true,
+      userData,
+    });
+    instance.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
+    instance.connections.allowFromAnyIpv4(ec2.Port.HTTP);
+    cdk.Tags.of(instance).add('EC2-Target', tagValue);
+    return instance;
+  });
+  return [tagValue, innerInstances];
+}));
+
+const alb = new elbv2.ApplicationLoadBalancer(stack, 'ALB', { vpc, internetFacing: true });
+const albTg = new elbv2.ApplicationTargetGroup(stack, 'ALB-TG', {
+  vpc,
+  protocol: elbv2.ApplicationProtocol.HTTP,
+  deregistrationDelay: cdk.Duration.seconds(0),
+});
+alb.addListener('HTTP', {
+  protocol: elbv2.ApplicationProtocol.HTTP,
+  defaultTargetGroups: [albTg],
+});
+alb.connections.allowToAnyIpv4(ec2.Port.HTTP);
+albTg.addTarget(...instances.LB.map((instance) => new targets.InstanceTarget(instance)));
+
+const bucket = new s3.Bucket(stack, 'ArtifactBucket', {
+  versioned: true,
+  autoDeleteObjects: true,
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+});
+instances.LB.forEach((instance) => bucket.grantRead(instance));
+instances.NoLB.forEach((instance) => bucket.grantRead(instance));
+const deployment = new s3deployment.BucketDeployment(stack, 'ArtifactDeployment', {
+  destinationBucket: bucket,
+  sources: [s3deployment.Source.asset(path.join(__dirname, 'ec2-deploy-artifacts', 'inline'))],
+  extract: false,
+});
+
+const sourceArtifact = new codepipeline.Artifact('SourceArtifact');
+const sourceAction = new cpactions.S3SourceAction({
+  actionName: 'Source',
+  output: sourceArtifact,
+  bucket,
+  bucketKey: cdk.Fn.select(0, deployment.objectKeys),
+});
+
+const pipeline = new codepipeline.Pipeline(stack, 'MyPipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+  artifactBucket: bucket,
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [sourceAction],
+    },
+    {
+      stageName: 'Deploy',
+      actions: [
+        new cpactions.Ec2DeployAction({
+          actionName: 'EC2-NoLB',
+          input: sourceArtifact,
+          instanceType: cpactions.Ec2InstanceType.EC2,
+          instanceTagKey: 'EC2-Target',
+          instanceTagValue: 'NoLB',
+          deploySpecifications: cpactions.Ec2DeploySpecifications.inline({
+            targetDirectory: '/var/www/html/NoLB',
+            preScript: 'scripts/pre-deploy.sh',
+            postScript: 'scripts/post-deploy.sh',
+          }),
+          maxBatch: cpactions.Ec2MaxInstances.targets(2),
+        }),
+        new cpactions.Ec2DeployAction({
+          actionName: 'EC2-LB',
+          input: sourceArtifact,
+          instanceType: cpactions.Ec2InstanceType.EC2,
+          instanceTagKey: 'EC2-Target',
+          instanceTagValue: 'LB',
+          deploySpecifications: cpactions.Ec2DeploySpecifications.inline({
+            targetDirectory: '/var/www/html/LB',
+            preScript: 'scripts/pre-deploy.sh',
+            postScript: 'scripts/post-deploy.sh',
+          }),
+          targetGroups: [albTg],
+          maxBatch: cpactions.Ec2MaxInstances.targets(1),
+        }),
+      ],
+    },
+  ],
+});
+
+const integ = new IntegTest(app, 'ec2-deploy-action-integ', {
+  testCases: [stack],
+});
+
+const pipelineExecutionId = integ.assertions
+  .awsApiCall('codepipeline', 'StartPipelineExecution', { name: pipeline.pipelineName })
+  .getAttString('pipelineExecutionId');
+const waitPipelieneSuccess = integ.assertions
+  .awsApiCall('codepipeline', 'GetPipelineExecution', { pipelineName: pipeline.pipelineName, pipelineExecutionId })
+  .waitForAssertions({ interval: cdk.Duration.seconds(30) })
+  .expect(ExpectedResult.objectLike({ pipelineExecution: { status: 'Succeeded' } }));
+waitPipelieneSuccess.next(
+  integ.assertions
+    .httpApiCall(`http://${alb.loadBalancerDnsName}/LB/index.html`)
+    .expect(ExpectedResult.objectLike({ status: 200 })),
+);
+instances.NoLB.forEach((instance) => waitPipelieneSuccess.next(
+  integ.assertions
+    .httpApiCall(`http://${instance.instancePublicDnsName}/NoLB/index.html`)
+    .expect(ExpectedResult.objectLike({ status: 200 })),
+));

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

@@ -882,7 +882,10 @@ If the security group ID is known and configuration details are unknown, use met
 const sg = ec2.SecurityGroup.fromLookupById(this, 'SecurityGroupLookup', 'sg-1234');
 ```
 
-The result of `SecurityGroup.fromLookupByName` and `SecurityGroup.fromLookupById` operations will be written to a file called `cdk.context.json`. You must commit this file to source control so that the lookup values are available in non-privileged environments such as CI build steps, and to ensure your template builds are repeatable.
+The result of `SecurityGroup.fromLookupByName` and `SecurityGroup.fromLookupById` operations will be
+written to a file called `cdk.context.json`. 
+You must commit this file to source control so that the lookup values are available in non-privileged
+environments such as CI build steps, and to ensure your template builds are repeatable.
 
 ### Cross Stack Connections
 
@@ -969,6 +972,13 @@ examples of images you might want to use:
 > `cdk.context.json`, or use the `cdk context` command. For more information, see
 > [Runtime Context](https://docs.aws.amazon.com/cdk/latest/guide/context.html) in the CDK
 > developer guide.
+> 
+> To customize the cache key, use the `additionalCacheKey` parameter.
+> This allows you to have multiple lookups with the same parameters
+> cache their values separately. This can be useful if you want to
+> scope the context variable to a construct (ie, using `additionalCacheKey: this.node.path`),
+> so that if the value in the cache needs to be updated, it does not need to be updated
+> for all constructs at the same time.
 >
 > `MachineImage.genericLinux()`, `MachineImage.genericWindows()` will use `CfnMapping` in
 > an agnostic stack.
@@ -1361,6 +1371,31 @@ new ec2.Instance(this, 'LatestAl2023', {
   // context cache is turned on by default
   machineImage: new ec2.AmazonLinux2023ImageSsmParameter(),
 });
+
+// or
+new ec2.Instance(this, 'LatestAl2023', {
+  vpc,
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
+  machineImage: ec2.MachineImage.latestAmazonLinux2023({
+    cachedInContext: true,
+    // creates a distinct context variable for this image, instead of resolving to the same
+    // value anywhere this lookup is done in your app
+    additionalCacheKey: this.node.path,
+  }),
+});
+
+// or
+new ec2.Instance(this, 'LatestAl2023', {
+  vpc,
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
+  // context cache is turned on by default
+  machineImage: new ec2.AmazonLinux2023ImageSsmParameter({
+    // creates a distinct context variable for this image, instead of resolving to the same
+    // value anywhere this lookup is done in your app
+    additionalCacheKey: this.node.path,
+  }),
+});
+
 ```
 
 #### Kernel Versions
@@ -1843,6 +1878,25 @@ new ec2.Volume(this, 'Volume', {
 });
 ```
 
+#### Volume initialization rate
+
+When creating an EBS volume from a snapshot, you can specify the [volume initialization rate](https://docs.aws.amazon.com/ebs/latest/userguide/initalize-volume.html#volume-initialization-rate) at which the snapshot blocks are downloaded from Amazon S3 to the volume.
+Specifying a volume initialization rate ensures that the volume is initialized at a predictable and consistent rate after creation.
+
+```ts
+new ec2.Volume(this, 'Volume', {
+  availabilityZone: 'us-east-1a',
+  size: Size.gibibytes(500),
+  snapshotId: 'snap-1234567890abcdef0',
+  volumeInitializationRate: Size.mebibytes(250),
+});
+```
+
+The `volumeInitializationRate` must be:
+
+* Between 100 and 300 MiB/s
+* Only specified when creating a volume from a snapshot
+
 ### Configuring Instance Metadata Service (IMDS)
 
 #### Toggling IMDSv1

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ec2/integ.machine-image-cached.ts

@@ -0,0 +1,53 @@
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import {
+  Stack,
+  StackProps,
+  App,
+  aws_ec2 as ec2,
+} from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { EC2_RESTRICT_DEFAULT_SECURITY_GROUP } from 'aws-cdk-lib/cx-api';
+
+// we associate this stack with an explicit environment since this is required by the
+// environmental context provider used with `cachedInContext`. CDK_INTEG_XXX are set
+// when producing the .expected file and CDK_DEFAULT_XXX is passed in through from
+// the CLI in actual deployment.
+const env = {
+  account: process.env.CDK_INTEG_ACCOUNT || process.env.CDK_DEFAULT_ACCOUNT,
+  region: process.env.CDK_INTEG_REGION || process.env.CDK_DEFAULT_REGION,
+};
+
+export class TestCase extends Stack {
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+    this.node.setContext(EC2_RESTRICT_DEFAULT_SECURITY_GROUP, false);
+    const vpc = new ec2.Vpc(this, 'Vpc');
+
+    const instanceType = ec2.InstanceType.of(ec2.InstanceClass.T2, ec2.InstanceSize.NANO);
+
+    new ec2.Instance(this, 'al2023Cached', {
+      instanceType,
+      machineImage: ec2.MachineImage.latestAmazonLinux2023({
+        cachedInContext: true,
+      }),
+      vpc,
+    });
+
+    new ec2.Instance(this, 'al2023CachedScope', {
+      instanceType,
+      machineImage: ec2.MachineImage.latestAmazonLinux2023({
+        cachedInContext: true,
+        additionalCacheKey: 'extraKey',
+      }),
+      vpc,
+    });
+  }
+}
+
+const app = new App();
+const stack = new TestCase(app, 'cdk-ec2-machine-image-cached', { env });
+new IntegTest(app, 'integ-ec2-machine-image-cached', {
+  testCases: [stack],
+  enableLookups: true,
+});
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ec2/integ.volume-initialization-rate.ts

@@ -0,0 +1,21 @@
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'volume-initialization-rate-stack');
+
+const snapshotId = process.env.SNAPSHOT_ID ?? 'snap-123456789abcdef0';
+
+new ec2.Volume(stack, 'Volume', {
+  availabilityZone: 'us-east-1a',
+  size: cdk.Size.gibibytes(1),
+  volumeType: ec2.EbsDeviceVolumeType.GP3,
+  volumeInitializationRate: cdk.Size.mebibytes(100),
+  snapshotId,
+});
+
+new integ.IntegTest(app, 'volume-initialization-rate-integ', {
+  testCases: [stack],
+});

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

@@ -169,6 +169,22 @@ const autoScalingGroup = new autoscaling.AutoScalingGroup(this, 'ASG', {
 });
 ```
 
+To customize the cache key, use the `additionalCacheKey` parameter.
+This allows you to have multiple lookups with the same parameters
+cache their values separately. This can be useful if you want to
+scope the context variable to a construct (ie, using `additionalCacheKey: this.node.path`),
+so that if the value in the cache needs to be updated, it does not need to be updated
+for all constructs at the same time.
+
+```ts
+declare const vpc: ec2.Vpc;
+const autoScalingGroup = new autoscaling.AutoScalingGroup(this, 'ASG', {
+  machineImage: ecs.EcsOptimizedImage.amazonLinux({ cachedInContext: true, additionalCacheKey: this.node.path }),
+  vpc,
+  instanceType: new ec2.InstanceType('t2.micro'),
+});
+```
+
 To use `LaunchTemplate` with `AsgCapacityProvider`, make sure to specify the `userData` in the `LaunchTemplate`:
 
 ```ts

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.availability-zone-rebalancing.ts

@@ -3,30 +3,20 @@ import * as cdk from 'aws-cdk-lib';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 
-const app = new cdk.App({
-  postCliContext: {
-    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
-    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
-  },
-});
+const app = new cdk.App();
 const stack = new cdk.Stack(app, 'aws-ecs-integ-availability-zone-rebalancing');
 
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
 
-const cluster = new ecs.Cluster(stack, 'EcsCluster', { vpc });
-
-cluster.addCapacity('DefaultAutoScalingGroup', {
-  instanceType: new ec2.InstanceType('t2.micro'),
-});
+const cluster = new ecs.Cluster(stack, 'Cluster', { vpc });
 
-const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef');
+const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef');
 
 taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  memoryLimitMiB: 256,
 });
 
-new ecs.Ec2Service(stack, 'FrontendService', {
+new ecs.FargateService(stack, 'FargateService', {
   cluster,
   taskDefinition,
   availabilityZoneRebalancing: ecs.AvailabilityZoneRebalancing.ENABLED,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.enable-execute-command.ts

@@ -1,53 +1,30 @@
-
-import * as autoscaling from 'aws-cdk-lib/aws-autoscaling';
-import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as kms from 'aws-cdk-lib/aws-kms';
+import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as cdk from 'aws-cdk-lib';
+import { Duration } from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 
 const app = new cdk.App({
   postCliContext: {
-    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
     '@aws-cdk/aws-ecs:reduceEc2FargateCloudWatchPermissions': true,
-    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
-    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
-    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
   },
 });
 const stack = new cdk.Stack(app, 'aws-ecs-integ-enable-execute-command');
 
-const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2 });
-
-const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef');
-
-taskDefinition.addContainer('web', {
-  image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  memoryReservationMiB: 256,
-  portMappings: [
-    {
-      containerPort: 80,
-      hostPort: 8080,
-      protocol: ecs.Protocol.TCP,
-    },
-  ],
-});
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
 
-const execBucket = new s3.Bucket(stack, 'EcsExecBucket');
+const kmsKey = new kms.Key(stack, 'KmsKey');
 
-const cp = new ecs.AsgCapacityProvider(stack, 'EC2CapacityProvider', {
-  autoScalingGroup: new autoscaling.AutoScalingGroup(stack, 'ASG', {
-    vpc,
-    instanceType: new ec2.InstanceType('t2.micro'),
-    machineImage: ecs.EcsOptimizedImage.amazonLinux2(),
-  }),
-  // This is to allow cdk destroy to work; otherwise deletion will hang bc ASG cannot be deleted
-  enableManagedTerminationProtection: false,
+const execBucket = new s3.Bucket(stack, 'EcsExecBucket', {
+  encryptionKey: kmsKey,
 });
 
-const cluster = new ecs.Cluster(stack, 'EC2CPCluster', {
+const cluster = new ecs.Cluster(stack, 'FargateCluster', {
   vpc,
   executeCommandConfiguration: {
+    kmsKey,
     logConfiguration: {
       s3Bucket: execBucket,
       s3EncryptionEnabled: true,
@@ -56,9 +33,19 @@ const cluster = new ecs.Cluster(stack, 'EC2CPCluster', {
     logging: ecs.ExecuteCommandLogging.OVERRIDE,
   },
 });
-cluster.addAsgCapacityProvider(cp);
 
-new ecs.Ec2Service(stack, 'EC2Service', {
+const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef');
+
+taskDefinition.addContainer('web', {
+  image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+  healthCheck: {
+    command: ['CMD-SHELL', 'curl localhost:8000'],
+    interval: Duration.seconds(60),
+    timeout: Duration.seconds(40),
+  },
+});
+
+new ecs.FargateService(stack, 'FargateService', {
   cluster,
   taskDefinition,
   enableExecuteCommand: true,
@@ -66,5 +53,12 @@ new ecs.Ec2Service(stack, 'EC2Service', {
 
 new integ.IntegTest(app, 'enable-execute-command-test', {
   testCases: [stack],
+  diffAssets: true,
+  cdkCommandOptions: {
+    deploy: {
+      args: {
+        rollback: true,
+      },
+    },
+  },
 });
-app.synth();

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

@@ -3,16 +3,11 @@ import * as kms from 'aws-cdk-lib/aws-kms';
 import * as logs from 'aws-cdk-lib/aws-logs';
 import * as s3 from 'aws-cdk-lib/aws-s3';
 import * as cdk from 'aws-cdk-lib';
+import { Duration } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 
-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,
-  },
-});
+const app = new cdk.App();
 const stack = new cdk.Stack(app, 'aws-ecs-integ-exec-command');
 
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
@@ -27,7 +22,7 @@ const execBucket = new s3.Bucket(stack, 'EcsExecBucket', {
   encryptionKey: kmsKey,
 });
 
-const cluster = new ecs.Cluster(stack, 'Ec2Cluster', {
+const cluster = new ecs.Cluster(stack, 'FargateCluster', {
   vpc,
   executeCommandConfiguration: {
     kmsKey,
@@ -41,21 +36,32 @@ const cluster = new ecs.Cluster(stack, 'Ec2Cluster', {
     logging: ecs.ExecuteCommandLogging.OVERRIDE,
   },
 });
-cluster.addCapacity('DefaultAutoScalingGroup', {
-  instanceType: new ec2.InstanceType('t2.micro'),
-});
 
-const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef');
+const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef');
 
 taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  memoryLimitMiB: 256,
+  healthCheck: {
+    command: ['CMD-SHELL', 'curl localhost:8000'],
+    interval: Duration.seconds(60),
+    timeout: Duration.seconds(40),
+  },
 });
 
-new ecs.Ec2Service(stack, 'Ec2Service', {
+new ecs.FargateService(stack, 'FargateService', {
   cluster,
   taskDefinition,
   enableExecuteCommand: true,
 });
 
-app.synth();
+new integ.IntegTest(app, 'exec-command-integ-test', {
+  testCases: [stack],
+  diffAssets: true,
+  cdkCommandOptions: {
+    deploy: {
+      args: {
+        rollback: true,
+      },
+    },
+  },
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.lb-awsvpc-nw.ts

@@ -3,48 +3,38 @@ import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
 import * as cdk from 'aws-cdk-lib';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 
-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,
-  },
-});
+const app = new cdk.App();
 const stack = new cdk.Stack(app, 'aws-ecs-integ');
 
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
 
-const cluster = new ecs.Cluster(stack, 'EcsCluster', { vpc });
-cluster.addCapacity('DefaultAutoScalingGroup', {
-  instanceType: new ec2.InstanceType('t2.micro'),
-});
+const cluster = new ecs.Cluster(stack, 'FargateCluster', { vpc });
 
-const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef', {
-  networkMode: ecs.NetworkMode.AWS_VPC,
+const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef', {
+  memoryLimitMiB: 1024,
+  cpu: 512,
 });
 
-const container = taskDefinition.addContainer('web', {
+taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  memoryLimitMiB: 256,
-  environment: {
-    SOME_VARIABLE: 'value',
-  },
+  portMappings: [{
+    containerPort: 80,
+    protocol: ecs.Protocol.TCP,
+  }],
 });
 
-container.addPortMappings({
-  containerPort: 80,
-  protocol: ecs.Protocol.TCP,
-});
-
-const service = new ecs.Ec2Service(stack, 'Service', {
+const service = new ecs.FargateService(stack, 'Service', {
   cluster,
   taskDefinition,
 });
 
+const scaling = service.autoScaleTaskCount({ maxCapacity: 10 });
+// Quite low to try and force it to scale
+scaling.scaleOnCpuUtilization('ReasonableCpu', { targetUtilizationPercent: 10 });
+
 const lb = new elbv2.ApplicationLoadBalancer(stack, 'LB', { vpc, internetFacing: true });
 const listener = lb.addListener('PublicListener', { port: 80, open: true });
-listener.addTargets('ECS', {
+listener.addTargets('Fargate', {
   port: 80,
   targets: [service],
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.pseudo-terminal.ts

@@ -3,35 +3,25 @@ import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 
-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,
-  },
-});
-const stack = new cdk.Stack(app, 'aws-ecs-integ-pseudo-terminal');
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'integ-pseudo-terminal');
 
 // Create a cluster
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
 
 const cluster = new ecs.Cluster(stack, 'EcsCluster', { vpc });
-cluster.addCapacity('DefaultAutoScalingGroup', {
-  instanceType: new ec2.InstanceType('t2.micro'),
-});
-
-const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef', {
-  networkMode: ecs.NetworkMode.AWS_VPC,
+const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef', {
+  cpu: 256,
+  memoryLimitMiB: 512,
 });
-
 taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  memoryLimitMiB: 256,
+  memoryLimitMiB: 512,
+  cpu: 256,
   pseudoTerminal: true,
 });
 
-new ecs.Ec2Service(stack, 'Service', {
+new ecs.FargateService(stack, 'Service', {
   cluster,
   taskDefinition,
 });

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

@@ -1106,6 +1106,12 @@ new eks.Cluster(this, 'Cluster', {
 });
 ```
 
+### Self-Managed Add-ons
+
+Amazon EKS automatically installs self-managed add-ons such as the Amazon VPC CNI plugin for Kubernetes, kube-proxy, and CoreDNS for every cluster. You can change the default configuration of the add-ons and update them when desired. If you wish to create a cluster without the default add-ons, set `bootstrapSelfManagedAddons` as `false`. When this is set to false, make sure to install the necessary alternatives which provide functionality that enables pod and service operations for your EKS cluster.
+
+> Changing the value of `bootstrapSelfManagedAddons` after the EKS cluster creation will result in a replacement of the cluster.
+
 ## Permissions and Security
 
 Amazon EKS provides several mechanism of securing the cluster and granting permissions to specific IAM users and roles.