konokenj.cdk-api-mcp-server 0.45.0__py3-none-any.whl → 0.47.0__py3-none-any.whl

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

@@ -1,62 +1,240 @@
-import * as path from 'path';
 import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
-import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
 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';
-import { STANDARD_NODEJS_RUNTIME } from '../../../config';
 
-const app = new cdk.App({
-  postCliContext: {
-    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+/**
+ * Follow these instructions to manually test running a CodeDeploy deployment with the resources provisioned in this stack:
+ *
+ * 1. Deploy the stack:
+```
+$ cdk deploy --app 'node integ.deployment-group.js' aws-cdk-codedeploy-ecs-dg
+```
+ *
+ * 2. Create a file called `appspec.json` with the following contents, replacing the placeholders with output values from the deployed stack:
+```
+{
+  "version": 0.0,
+  "Resources": [
+    {
+      "TargetService": {
+        "Type": "AWS::ECS::Service",
+        "Properties": {
+          "TaskDefinition": "<PLACEHOLDER - NEW TASK DEFINITION>",
+          "LoadBalancerInfo": {
+            "ContainerName": "Container",
+            "ContainerPort": 80
+          },
+          "PlatformVersion": "LATEST",
+          "NetworkConfiguration": {
+            "awsvpcConfiguration": {
+              "subnets": [
+                "<PLACEHOLDER - SUBNET 1 ID>",
+                "<PLACEHOLDER - SUBNET 2 ID>",
+              ],
+              "securityGroups": [
+                "<PLACEHOLDER - SECURITY GROUP ID>"
+              ],
+              "assignPublicIp": "DISABLED"
+            }
+          }
+        }
+      }
+    }
+  ]
+}
+```
+ *
+ * 3. Start the deployment:
+```
+$ appspec=$(jq -R -s '.' < appspec.json | sed 's/\\n//g')
+$ aws deploy create-deployment \
+   --application-name <PLACEHOLDER - CODEDEPLOY APPLICATION NAME> \
+   --deployment-group-name <PLACEHOLDER - CODEDEPLOY DEPLOYMENT GROUP NAME> \
+   --description "AWS CDK integ test" \
+   --revision revisionType=AppSpecContent,appSpecContent={content="$appspec"}
+```
+ *
+ * 4. Wait for the deployment to complete successfully, providing the deployment ID from the previous step:
+```
+$ aws deploy wait deployment-successful --deployment-id <PLACEHOLDER - DEPLOYMENT ID>
+```
+ *
+ * 5. Destroy the stack:
+```
+$ cdk destroy --app 'node integ.deployment-group.js' aws-cdk-codedeploy-ecs-dg
+```
+ */
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-ecs-dg');
+
+// Network infrastructure
+const vpc = new ec2.Vpc(stack, 'VPC', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+
+// ECS service
+const cluster = new ecs.Cluster(stack, 'EcsCluster', {
+  vpc,
+});
+const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef');
+taskDefinition.addContainer('Container', {
+  image: ecs.ContainerImage.fromRegistry('public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest'),
+  portMappings: [{ containerPort: 80 }],
+});
+const service = new ecs.FargateService(stack, 'FargateService', {
+  cluster,
+  taskDefinition,
+  deploymentController: {
+    type: ecs.DeploymentControllerType.CODE_DEPLOY,
   },
 });
-const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-lambda');
 
-const handler = new lambda.Function(stack, 'Handler', {
-  code: lambda.Code.fromAsset(path.join(__dirname, 'handler')),
-  handler: 'index.handler',
-  runtime: STANDARD_NODEJS_RUNTIME,
+// A second task definition for testing a CodeDeploy deployment of the ECS service to a new task definition
+const taskDefinition2 = new ecs.FargateTaskDefinition(stack, 'TaskDef2');
+taskDefinition2.addContainer('Container', {
+  image: ecs.ContainerImage.fromRegistry('public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest'),
+  portMappings: [{ containerPort: 80 }],
 });
-const version = handler.currentVersion;
-const blueGreenAlias = new lambda.Alias(stack, 'Alias', {
-  aliasName: 'alias',
-  version,
+service.node.addDependency(taskDefinition2);
+
+// Load balancer
+const loadBalancer = new elbv2.ApplicationLoadBalancer(stack, 'ServiceLB', {
+  vpc,
+  internetFacing: false,
 });
 
-const preHook = new lambda.Function(stack, 'PreHook', {
-  code: lambda.Code.fromAsset(path.join(__dirname, 'preHook')),
-  handler: 'index.handler',
-  runtime: STANDARD_NODEJS_RUNTIME,
+// Listeners
+const prodListener = loadBalancer.addListener('ProdListener', {
+  port: 80, // port for production traffic
+  protocol: elbv2.ApplicationProtocol.HTTP,
 });
-const postHook = new lambda.Function(stack, 'PostHook', {
-  code: lambda.Code.fromAsset(path.join(__dirname, 'postHook')),
-  handler: 'index.handler',
-  runtime: STANDARD_NODEJS_RUNTIME,
+const testListener = loadBalancer.addListener('TestListener', {
+  port: 9002, // port for testing
+  protocol: elbv2.ApplicationProtocol.HTTP,
 });
 
-new codedeploy.LambdaDeploymentGroup(stack, 'BlueGreenDeployment', {
-  alias: blueGreenAlias,
-  deploymentConfig: codedeploy.LambdaDeploymentConfig.LINEAR_10PERCENT_EVERY_1MINUTE,
-  alarms: [
-    new cloudwatch.Alarm(stack, 'BlueGreenErrors', {
-      comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
-      threshold: 1,
-      evaluationPeriods: 1,
-      metric: blueGreenAlias.metricErrors(),
+// Target groups
+const blueTG = prodListener.addTargets('BlueTG', {
+  port: 80,
+  protocol: elbv2.ApplicationProtocol.HTTP,
+  targets: [
+    service.loadBalancerTarget({
+      containerName: 'Container',
+      containerPort: 80,
     }),
   ],
-  preHook,
-  postHook,
+  deregistrationDelay: cdk.Duration.seconds(30),
+  healthCheck: {
+    interval: cdk.Duration.seconds(5),
+    healthyHttpCodes: '200',
+    healthyThresholdCount: 2,
+    unhealthyThresholdCount: 3,
+    timeout: cdk.Duration.seconds(4),
+  },
 });
 
-const secondAlias = new lambda.Alias(stack, 'SecondAlias', {
-  aliasName: 'secondAlias',
-  version,
+const greenTG = new elbv2.ApplicationTargetGroup(stack, 'GreenTG', {
+  vpc,
+  port: 80,
+  protocol: elbv2.ApplicationProtocol.HTTP,
+  targetType: elbv2.TargetType.IP,
+  deregistrationDelay: cdk.Duration.seconds(30),
+  healthCheck: {
+    interval: cdk.Duration.seconds(5),
+    healthyHttpCodes: '200',
+    healthyThresholdCount: 2,
+    unhealthyThresholdCount: 3,
+    timeout: cdk.Duration.seconds(4),
+  },
+});
+
+testListener.addTargetGroups('GreenTGTest', {
+  targetGroups: [greenTG],
 });
 
-new codedeploy.LambdaDeploymentGroup(stack, 'SecondDeployment', {
-  alias: secondAlias,
-  deploymentConfig: codedeploy.LambdaDeploymentConfig.CANARY_10PERCENT_5MINUTES,
+prodListener.node.addDependency(greenTG);
+testListener.node.addDependency(blueTG);
+service.node.addDependency(testListener);
+service.node.addDependency(greenTG);
+
+// Alarms: monitor 500s and unhealthy hosts on target groups
+const blueUnhealthyHosts = new cloudwatch.Alarm(stack, 'BlueUnhealthyHosts', {
+  alarmName: stack.stackName + '-Unhealthy-Hosts-Blue',
+  metric: blueTG.metricUnhealthyHostCount(),
+  threshold: 1,
+  evaluationPeriods: 2,
+});
+
+const blueApiFailure = new cloudwatch.Alarm(stack, 'Blue5xx', {
+  alarmName: stack.stackName + '-Http-500-Blue',
+  metric: blueTG.metricHttpCodeTarget(
+    elbv2.HttpCodeTarget.TARGET_5XX_COUNT,
+    { period: cdk.Duration.minutes(1) },
+  ),
+  threshold: 1,
+  evaluationPeriods: 1,
+});
+
+const greenUnhealthyHosts = new cloudwatch.Alarm(stack, 'GreenUnhealthyHosts', {
+  alarmName: stack.stackName + '-Unhealthy-Hosts-Green',
+  metric: greenTG.metricUnhealthyHostCount(),
+  threshold: 1,
+  evaluationPeriods: 2,
+});
+
+const greenApiFailure = new cloudwatch.Alarm(stack, 'Green5xx', {
+  alarmName: stack.stackName + '-Http-500-Green',
+  metric: greenTG.metricHttpCodeTarget(
+    elbv2.HttpCodeTarget.TARGET_5XX_COUNT,
+    { period: cdk.Duration.minutes(1) },
+  ),
+  threshold: 1,
+  evaluationPeriods: 1,
+});
+
+// Deployment group
+const deploymentConfig = new codedeploy.EcsDeploymentConfig(stack, 'CanaryConfig', {
+  trafficRouting: codedeploy.TrafficRouting.timeBasedCanary({
+    interval: cdk.Duration.minutes(1),
+    percentage: 20,
+  }),
+});
+
+const dg = new codedeploy.EcsDeploymentGroup(stack, 'BlueGreenDG', {
+  alarms: [
+    blueUnhealthyHosts,
+    blueApiFailure,
+    greenUnhealthyHosts,
+    greenApiFailure,
+  ],
+  service,
+  blueGreenDeploymentConfig: {
+    blueTargetGroup: blueTG,
+    greenTargetGroup: greenTG,
+    listener: prodListener,
+    testListener,
+    terminationWaitTime: cdk.Duration.minutes(1),
+  },
+  deploymentConfig,
+  autoRollback: {
+    stoppedDeployment: true,
+  },
+  ignoreAlarmConfiguration: true,
+});
+
+// Outputs to use for manual testing
+new cdk.CfnOutput(stack, 'NewTaskDefinition', { value: taskDefinition2.taskDefinitionArn });
+new cdk.CfnOutput(stack, 'Subnet1Id', { value: vpc.privateSubnets[0].subnetId });
+new cdk.CfnOutput(stack, 'Subnet2Id', { value: vpc.privateSubnets[1].subnetId });
+new cdk.CfnOutput(stack, 'SecurityGroupId', { value: service.connections.securityGroups[0].securityGroupId });
+new cdk.CfnOutput(stack, 'CodeDeployApplicationName', { value: dg.application.applicationName });
+new cdk.CfnOutput(stack, 'CodeDeployDeploymentGroupName', { value: dg.deploymentGroupName });
+
+new integ.IntegTest(app, 'EcsDeploymentGroupTest', {
+  testCases: [stack],
 });
 
 app.synth();

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

@@ -28,6 +28,28 @@ By default, the master password will be generated and stored in AWS Secrets Mana
 
 Your cluster will be empty by default.
 
+## Serverless Clusters
+
+DocumentDB supports serverless clusters that automatically scale capacity based on your application's needs.
+To create a serverless cluster, specify the `serverlessV2ScalingConfiguration` instead of `instanceType`:
+
+```ts
+declare const vpc: ec2.Vpc;
+const cluster = new docdb.DatabaseCluster(this, 'Database', {
+  masterUser: {
+    username: 'myuser',
+  },
+  vpc,
+  serverlessV2ScalingConfiguration: {
+    minCapacity: 0.5,
+    maxCapacity: 2,
+  },
+  engineVersion: '5.0.0', // Serverless requires engine version 5.0.0 or higher
+});
+```
+
+**Note**: DocumentDB serverless requires engine version 5.0.0 or higher and is not compatible with all features. See the [AWS documentation](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-serverless-limitations.html) for limitations.
+
 ## Connecting
 
 To control who can access the cluster, use the `.connections` attribute. DocumentDB databases have a default port, so
@@ -278,3 +300,5 @@ const cluster = new docdb.DatabaseCluster(this, 'Database', {
 ```
 
 **Note**: `StorageType.IOPT1` is supported starting with engine version 5.0.0.
+
+**Note**: For serverless clusters, storage type is managed automatically and cannot be specified.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/integ.cluster-serverless.ts

@@ -0,0 +1,34 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as cdk from 'aws-cdk-lib';
+import * as constructs from 'constructs';
+import { DatabaseCluster } from 'aws-cdk-lib/aws-docdb';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+class TestStack extends cdk.Stack {
+  constructor(scope: constructs.Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    const vpc = new ec2.Vpc(this, 'VPC', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+
+    new DatabaseCluster(this, 'Database', {
+      masterUser: {
+        username: 'docdb',
+      },
+      vpc,
+      serverlessV2ScalingConfiguration: {
+        minCapacity: 0.5,
+        maxCapacity: 2,
+      },
+      engineVersion: '5.0.0',
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+  }
+}
+
+const app = new cdk.App();
+
+const stack = new TestStack(app, 'aws-cdk-docdb-cluster-serverless');
+
+new IntegTest(app, 'aws-cdk-docdb-cluster-serverless-integ', {
+  testCases: [stack],
+});

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

@@ -3,20 +3,30 @@ 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();
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+    '@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy': false,
+  },
+});
 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, 'Cluster', { vpc });
+const cluster = new ecs.Cluster(stack, 'EcsCluster', { vpc });
+
+cluster.addCapacity('DefaultAutoScalingGroup', {
+  instanceType: new ec2.InstanceType('t2.micro'),
+});
 
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef');
+const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef');
 
 taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+  memoryLimitMiB: 256,
 });
 
-new ecs.FargateService(stack, 'FargateService', {
+new ecs.Ec2Service(stack, 'FrontendService', {
   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,30 +1,53 @@
-import * as ec2 from 'aws-cdk-lib/aws-ec2';
-import * as kms from 'aws-cdk-lib/aws-kms';
+
+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 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, restrictDefaultSecurityGroup: false });
+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 kmsKey = new kms.Key(stack, 'KmsKey');
+const execBucket = new s3.Bucket(stack, 'EcsExecBucket');
 
-const execBucket = new s3.Bucket(stack, 'EcsExecBucket', {
-  encryptionKey: 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 cluster = new ecs.Cluster(stack, 'FargateCluster', {
+const cluster = new ecs.Cluster(stack, 'EC2CPCluster', {
   vpc,
   executeCommandConfiguration: {
-    kmsKey,
     logConfiguration: {
       s3Bucket: execBucket,
       s3EncryptionEnabled: true,
@@ -33,19 +56,9 @@ const cluster = new ecs.Cluster(stack, 'FargateCluster', {
     logging: ecs.ExecuteCommandLogging.OVERRIDE,
   },
 });
+cluster.addAsgCapacityProvider(cp);
 
-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', {
+new ecs.Ec2Service(stack, 'EC2Service', {
   cluster,
   taskDefinition,
   enableExecuteCommand: true,
@@ -53,12 +66,5 @@ new ecs.FargateService(stack, 'FargateService', {
 
 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,11 +3,16 @@ 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();
+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-exec-command');
 
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
@@ -22,7 +27,7 @@ const execBucket = new s3.Bucket(stack, 'EcsExecBucket', {
   encryptionKey: kmsKey,
 });
 
-const cluster = new ecs.Cluster(stack, 'FargateCluster', {
+const cluster = new ecs.Cluster(stack, 'Ec2Cluster', {
   vpc,
   executeCommandConfiguration: {
     kmsKey,
@@ -36,32 +41,21 @@ const cluster = new ecs.Cluster(stack, 'FargateCluster', {
     logging: ecs.ExecuteCommandLogging.OVERRIDE,
   },
 });
+cluster.addCapacity('DefaultAutoScalingGroup', {
+  instanceType: new ec2.InstanceType('t2.micro'),
+});
 
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef');
+const taskDefinition = new ecs.Ec2TaskDefinition(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),
-  },
+  memoryLimitMiB: 256,
 });
 
-new ecs.FargateService(stack, 'FargateService', {
+new ecs.Ec2Service(stack, 'Ec2Service', {
   cluster,
   taskDefinition,
   enableExecuteCommand: true,
 });
 
-new integ.IntegTest(app, 'exec-command-integ-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.lb-awsvpc-nw.ts

@@ -3,38 +3,48 @@ 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();
+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');
 
 const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
 
-const cluster = new ecs.Cluster(stack, 'FargateCluster', { vpc });
+const cluster = new ecs.Cluster(stack, 'EcsCluster', { vpc });
+cluster.addCapacity('DefaultAutoScalingGroup', {
+  instanceType: new ec2.InstanceType('t2.micro'),
+});
 
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef', {
-  memoryLimitMiB: 1024,
-  cpu: 512,
+const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef', {
+  networkMode: ecs.NetworkMode.AWS_VPC,
 });
 
-taskDefinition.addContainer('web', {
+const container = taskDefinition.addContainer('web', {
   image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
-  portMappings: [{
-    containerPort: 80,
-    protocol: ecs.Protocol.TCP,
-  }],
+  memoryLimitMiB: 256,
+  environment: {
+    SOME_VARIABLE: 'value',
+  },
 });
 
-const service = new ecs.FargateService(stack, 'Service', {
+container.addPortMappings({
+  containerPort: 80,
+  protocol: ecs.Protocol.TCP,
+});
+
+const service = new ecs.Ec2Service(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('Fargate', {
+listener.addTargets('ECS', {
   port: 80,
   targets: [service],
 });

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

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