konokenj.cdk-api-mcp-server 0.31.0__py3-none-any.whl → 0.33.0__py3-none-any.whl

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

@@ -53,6 +53,39 @@ const metric = new cloudwatch.Metric({
 });
 ```
 
+### Metric ID
+
+Metrics can be assigned a unique identifier using the `id` property. This is
+useful when referencing metrics in math expressions:
+
+```ts
+const metric = new cloudwatch.Metric({
+  namespace: 'AWS/Lambda',
+  metricName: 'Invocations',
+  dimensionsMap: {
+    FunctionName: 'MyFunction'
+  },
+  id: 'invocations'
+});
+```
+
+The `id` must start with a lowercase letter and can only contain letters, numbers, and underscores.
+
+### Metric Visible
+Metrics can be hidden from dashboard graphs using the `visible` property:
+
+```ts
+declare const fn: lambda.Function;
+
+const metric = fn.metricErrors({
+  visible: false
+});
+```
+
+By default, all metrics are visible (`visible: true`). Setting `visible: false`
+hides the metric from dashboard visualizations while still allowing it to be
+used in math expressions given that it has an `id` set to it.
+
 ### Metric Math
 
 Math expressions are supported by instantiating the `MathExpression` class.
@@ -86,6 +119,31 @@ const problemPercentage = new cloudwatch.MathExpression({
 });
 ```
 
+### Metric ID Usage in Math Expressions
+
+When metrics have custom IDs, you can reference them directly in math expressions.
+
+```ts
+declare const fn: lambda.Function;
+
+const invocations = fn.metricInvocations({
+  id: 'lambda_invocations',
+});
+
+const errors = fn.metricErrors({
+  id: 'lambda_errors',
+});
+```
+
+When metrics have predefined IDs, they can be referenced directly in math expressions by their ID without requiring the `usingMetrics` property.
+
+```ts
+const errorRate = new cloudwatch.MathExpression({
+  expression: 'lambda_errors / lambda_invocations * 100',
+  label: 'Error Rate (%)',
+});
+```
+
 ### Search Expressions
 
 Math expressions also support search expressions. For example, the following
@@ -790,6 +848,19 @@ dashboard.addWidgets(new cloudwatch.LogQueryWidget({
 }));
 ```
 
+Log Insights QL is the default query language. You may specify an [alternate query language: OpenSearch PPL or SQL](https://aws.amazon.com/blogs/aws/new-amazon-cloudwatch-and-amazon-opensearch-service-launch-an-integrated-analytics-experience/), if desired:
+
+```ts
+declare const dashboard: cloudwatch.Dashboard;
+
+dashboard.addWidgets(new cloudwatch.LogQueryWidget({
+  logGroupNames: ['my-log-group'],
+  view: cloudwatch.LogQueryVisualizationType.TABLE,
+  queryString: "SELECT count(*) as count FROM 'my-log-group'",
+  queryLanguage: cloudwatch.LogQueryLanguage.SQL,
+}));
+```
+
 ### Custom widget
 
 A `CustomWidget` shows the result of an AWS Lambda function:

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch/integ.alarm-and-dashboard.ts

@@ -94,6 +94,18 @@ dashboard.addWidgets(new cloudwatch.LogQueryWidget({
                 | filter @message like /Error/`,
   accountId: '123456789012',
 }));
+dashboard.addWidgets(new cloudwatch.LogQueryWidget({
+  title: 'Errors in my log group - SQL',
+  logGroupNames: ['my-log-group'],
+  queryString: "SELECT count(*) as count FROM 'my-log-group'",
+  queryLanguage: cloudwatch.LogQueryLanguage.SQL,
+}));
+dashboard.addWidgets(new cloudwatch.LogQueryWidget({
+  title: 'Errors in my log group - PPL',
+  logGroupNames: ['my-log-group'],
+  queryString: 'fields `@message`\ | sort - `@timestamp`',
+  queryLanguage: cloudwatch.LogQueryLanguage.PPL,
+}));
 dashboard.addWidgets(new cloudwatch.SingleValueWidget({
   title: 'Sent message size',
   metrics: [sentMessageSizeMetric],

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch/integ.dashboard-with-metric-id-and-visible.ts

@@ -0,0 +1,70 @@
+import { App, Stack, StackProps } from 'aws-cdk-lib';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { Dashboard, Metric, GraphWidget, MathExpression } from 'aws-cdk-lib/aws-cloudwatch';
+
+class DashboardWithMetricIdAndVisibleIntegrationTest extends Stack {
+  constructor(scope: App, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    const dashboard = new Dashboard(this, 'Dash');
+
+    const lambdaInvocations = new Metric({
+      namespace: 'AWS/Lambda',
+      metricName: 'Invocations',
+      dimensionsMap: { FunctionName: 'test-function' },
+      label: 'Lambda Invocations',
+      id: 'lambda_invocations',
+      visible: true,
+    });
+
+    const lambdaErrors = new Metric({
+      namespace: 'AWS/Lambda',
+      metricName: 'Errors',
+      dimensionsMap: { FunctionName: 'test-function' },
+      label: 'Lambda Errors (Hidden for calculation)',
+      id: 'lambda_errors',
+      visible: false,
+    });
+
+    const lambdaDuration = new Metric({
+      namespace: 'AWS/Lambda',
+      metricName: 'Duration',
+      dimensionsMap: { FunctionName: 'test-function' },
+      label: 'Lambda Duration',
+      id: 'lambda_duration',
+      visible: true,
+    });
+
+    const lambdaThrottles = new Metric({
+      namespace: 'AWS/Lambda',
+      metricName: 'Throttles',
+      dimensionsMap: { FunctionName: 'test-function' },
+      label: 'Lambda Throttles (Hidden)',
+      id: 'lambda_throttles',
+      visible: false,
+    });
+
+    const errorRate = new MathExpression({
+      expression: 'lambda_errors / lambda_invocations * 100',
+      label: 'Error Rate (%)',
+    });
+
+    const widget = new GraphWidget({
+      title: 'Lambda Metrics with ID and Visible Properties',
+      left: [
+        lambdaInvocations,
+        lambdaErrors,
+        lambdaDuration,
+        lambdaThrottles,
+        errorRate,
+      ],
+    });
+
+    dashboard.addWidgets(widget);
+  }
+}
+
+const app = new App();
+new IntegTest(app, 'cdk-integ-dashboard-with-metric-id-and-visible', {
+  testCases: [new DashboardWithMetricIdAndVisibleIntegrationTest(app, 'DashboardWithMetricIdAndVisibleIntegrationTest')],
+});

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

@@ -258,9 +258,73 @@ new codebuild.Project(this, 'Project', {
 });
 ```
 
-Note that two different CodeBuild Projects using the same S3 bucket will *not*
-share their cache: each Project will get a unique file in the S3 bucket to store
-the cache in.
+If you want to [share the same cache between multiple projects](https://docs.aws.amazon.com/codebuild/latest/userguide/caching-s3.html#caching-s3-sharing), you must must do the following:
+
+- Use the same `cacheNamespace`.
+- Specify the same cache key.
+- Define identical cache paths.
+- Use the same Amazon S3 buckets and `pathPrefix` if set.
+
+```ts
+declare const sourceBucket: s3.Bucket;
+declare const myCachingBucket: s3.Bucket;
+
+new codebuild.Project(this, 'ProjectA', {
+  source: codebuild.Source.s3({
+    bucket: sourceBucket,
+    path: 'path/to/source-a.zip',
+  }),
+  // configure the same bucket and path prefix
+  cache: codebuild.Cache.bucket(myCachingBucket, {
+    prefix: 'cache',
+    // use the same cache namespace
+    cacheNamespace: 'cache-namespace',
+  }),
+  buildSpec: codebuild.BuildSpec.fromObject({
+    version: '0.2',
+    phases: {
+      build: {
+        commands: ['...'],
+      },
+    },
+    // specify the same cache key and paths
+    cache: {
+      key: 'unique-key',
+      paths: [
+        '/root/cachedir/**/*',
+      ],
+    },
+  }),
+});
+
+new codebuild.Project(this, 'ProjectB', {
+  source: codebuild.Source.s3({
+    bucket: sourceBucket,
+    path: 'path/to/source-b.zip',
+  }),
+  // configure the same bucket and path prefix
+  cache: codebuild.Cache.bucket(myCachingBucket, {
+    prefix: 'cache',
+    // use the same cache namespace
+    cacheNamespace: 'cache-namespace',
+  }),
+  buildSpec: codebuild.BuildSpec.fromObject({
+    version: '0.2',
+    phases: {
+      build: {
+        commands: ['...'],
+      },
+    },
+    // specify the same cache key and paths
+    cache: {
+      key: 'unique-key',
+      paths: [
+        '/root/cachedir/**/*',
+      ],
+    },
+  }),
+});
+```
 
 ### Local Caching
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-s3-cache.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as cdk from 'aws-cdk-lib';
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'codebuild-s3-cache-stack');
+
+const bucket = new s3.Bucket(stack, 'MyBucket', {
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+  autoDeleteObjects: true,
+});
+
+const buildSpec = codebuild.BuildSpec.fromObject({
+  version: '0.2',
+  phases: {
+    build: {
+      commands: ['echo "Hello, CodeBuild!"'],
+    },
+  },
+  cache: {
+    paths: [
+      '/root/cachedir/**/*',
+    ],
+    key: 'unique-key',
+  },
+});
+
+const projectA = new codebuild.Project(stack, 'ProjectA', {
+  source: codebuild.Source.s3({
+    bucket,
+    path: 'path/to/source-a.zip',
+  }),
+  cache: codebuild.Cache.bucket(bucket, {
+    prefix: 'cache',
+    cacheNamespace: 'cache-namespace',
+  }),
+  buildSpec,
+});
+
+const projectB = new codebuild.Project(stack, 'ProjectB', {
+  source: codebuild.Source.s3({
+    bucket,
+    path: 'path/to/source-b.zip',
+  }),
+  cache: codebuild.Cache.bucket(bucket, {
+    prefix: 'cache',
+    cacheNamespace: 'cache-namespace',
+  }),
+  buildSpec,
+});
+
+const integ = new IntegTest(app, 'codebuild-s3-cache-integ', {
+  testCases: [stack],
+});
+
+[projectA, projectB].forEach((project) => {
+  integ.assertions.awsApiCall('CodeBuild', 'batchGetProjects', {
+    names: [project.projectName],
+  }).expect(ExpectedResult.objectLike({
+    projects: [{
+      cache: {
+        type: 'S3',
+        location: `${bucket.bucketName}/cache`,
+        cacheNamespace: 'cache-namespace',
+      },
+    }],
+  }));
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecr-assets/integ.assets-docker.ts

@@ -46,6 +46,10 @@ const asset8 = new assets.DockerImageAsset(stack, 'DockerImage8', {
   cacheDisabled: true,
 });
 
+const asset9 = new assets.DockerImageAsset(stack, 'DockerImage9', {
+  directory: path.join(__dirname, 'demo-image-dockerignore'),
+});
+
 const user = new iam.User(stack, 'MyUser');
 asset.repository.grantPull(user);
 asset2.repository.grantPull(user);
@@ -55,6 +59,7 @@ asset5.repository.grantPull(user);
 asset6.repository.grantPull(user);
 asset7.repository.grantPull(user);
 asset8.repository.grantPull(user);
+asset9.repository.grantPull(user);
 
 new cdk.CfnOutput(stack, 'ImageUri', { value: asset.imageUri });
 new cdk.CfnOutput(stack, 'ImageUri2', { value: asset2.imageUri });
@@ -64,5 +69,6 @@ new cdk.CfnOutput(stack, 'ImageUri5', { value: asset5.imageUri });
 new cdk.CfnOutput(stack, 'ImageUri6', { value: asset6.imageUri });
 new cdk.CfnOutput(stack, 'ImageUri7', { value: asset7.imageUri });
 new cdk.CfnOutput(stack, 'ImageUri8', { value: asset8.imageUri });
+new cdk.CfnOutput(stack, 'ImageUri9', { value: asset9.imageUri });
 
 app.synth();

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,
 });