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

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.blue-green-deployment-strategy.ts

@@ -0,0 +1,147 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-ecs-blue-green-deployment');
+
+// Create VPC and Cluster
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+const cluster = new ecs.Cluster(stack, 'FargateCluster', {
+  vpc,
+  defaultCloudMapNamespace: {
+    name: 'bluegreendeployment.com',
+    useForServiceConnect: true,
+  },
+});
+
+// Create Blue target group for B/G deployment
+const blueTargetGroup = new elbv2.ApplicationTargetGroup(stack, 'BlueTG', {
+  vpc: cluster.vpc,
+  port: 80,
+  protocol: elbv2.ApplicationProtocol.HTTP,
+  targetType: elbv2.TargetType.IP,
+  healthCheck: {
+    path: '/',
+    healthyHttpCodes: '200',
+  },
+});
+
+// Create Green target group for B/G deployment
+const greenTargetGroup = new elbv2.ApplicationTargetGroup(stack, 'GreenTG', {
+  vpc: cluster.vpc,
+  port: 80,
+  protocol: elbv2.ApplicationProtocol.HTTP,
+  targetType: elbv2.TargetType.IP,
+  healthCheck: {
+    path: '/',
+    healthyHttpCodes: '200',
+  },
+});
+
+// Create security groups
+const lbSecurityGroup = new ec2.SecurityGroup(stack, 'LBSecurityGroup', {
+  vpc: cluster.vpc,
+  allowAllOutbound: true,
+});
+lbSecurityGroup.addIngressRule(ec2.Peer.anyIpv4(), ec2.Port.tcp(80));
+
+const ecsSecurityGroup = new ec2.SecurityGroup(stack, 'ECSSecurityGroup', {
+  vpc: cluster.vpc,
+  allowAllOutbound: true,
+});
+ecsSecurityGroup.addIngressRule(lbSecurityGroup, ec2.Port.tcp(80));
+
+// Create ALB
+const alb = new elbv2.ApplicationLoadBalancer(stack, 'ALB', {
+  vpc: cluster.vpc,
+  internetFacing: true,
+  securityGroup: lbSecurityGroup,
+  idleTimeout: cdk.Duration.seconds(60),
+});
+
+// Create ALB listener with default 404 response
+const listener = alb.addListener('ALBListenerHTTP', {
+  port: 80,
+  defaultAction: elbv2.ListenerAction.fixedResponse(404),
+});
+
+// Create Prod listener rule
+const prodListenerRule = new elbv2.ApplicationListenerRule(stack, 'ALBProductionListenerRule', {
+  listener: listener,
+  priority: 1,
+  conditions: [
+    elbv2.ListenerCondition.pathPatterns(['/*']),
+  ],
+  action: elbv2.ListenerAction.weightedForward([
+    {
+      targetGroup: blueTargetGroup,
+      weight: 100,
+    },
+    {
+      targetGroup: greenTargetGroup,
+      weight: 0,
+    },
+  ]),
+});
+
+// Create Lambda hook
+const lambdaHook = new lambda.Function(stack, 'LambdaHook', {
+  handler: 'index.handler',
+  runtime: lambda.Runtime.NODEJS_22_X,
+  code: lambda.Code.fromInline(`exports.handler = async (event, context) => {
+    console.log('Event received:', JSON.stringify(event));
+    return { hookStatus: 'SUCCEEDED' }; 
+    };`),
+});
+
+// Create task definition
+const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef', {
+  memoryLimitMiB: 512,
+  cpu: 256,
+});
+
+// Add container to task definition
+taskDefinition.addContainer('container', {
+  containerName: 'nginx',
+  image: ecs.ContainerImage.fromRegistry('public.ecr.aws/nginx/nginx:latest'),
+  portMappings: [{
+    name: 'api',
+    containerPort: 80,
+    appProtocol: ecs.AppProtocol.http,
+  }],
+});
+
+// Create Fargate service with escape hatching for B/G deployment
+const service = new ecs.FargateService(stack, 'Service', {
+  cluster,
+  taskDefinition,
+  securityGroups: [ecsSecurityGroup],
+  deploymentStrategy: ecs.DeploymentStrategy.BLUE_GREEN,
+});
+
+service.addLifecycleHook(new ecs.DeploymentLifecycleLambdaTarget(lambdaHook, 'PreScaleUp', {
+  lifecycleStages: [ecs.DeploymentLifecycleStage.PRE_SCALE_UP],
+}));
+
+const target = service.loadBalancerTarget({
+  containerName: 'nginx',
+  containerPort: 80,
+  protocol: ecs.Protocol.TCP,
+  alternateTarget: new ecs.AlternateTarget('LBAlternateOptions', {
+    alternateTargetGroup: greenTargetGroup,
+    productionListener: ecs.ListenerRuleConfiguration.applicationListenerRule(prodListenerRule),
+  }),
+});
+
+target.attachToApplicationTargetGroup(blueTargetGroup);
+
+// Create integration test
+new integ.IntegTest(app, 'aws-ecs-blue-green', {
+  testCases: [stack],
+});
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.cluster-windows-server-ami.ts

@@ -32,8 +32,8 @@ insRole.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
 const autoScalingGroup = new autoscaling.AutoScalingGroup(stack, 'ASG', {
   vpc,
   role: insRole,
-  instanceType: ec2.InstanceType.of(ec2.InstanceClass.T2, ec2.InstanceSize.LARGE),
-  machineImage: ecs.EcsOptimizedImage.windows(ecs.WindowsOptimizedVersion.SERVER_2022),
+  instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.SMALL),
+  machineImage: ecs.EcsOptimizedImage.windows(ecs.WindowsOptimizedVersion.SERVER_2025),
   minCapacity: 1,
 });
 
@@ -46,10 +46,9 @@ cluster.addAsgCapacityProvider(cp);
 
 const taskDefinition = new ecs.Ec2TaskDefinition(stack, 'TaskDef', {});
 
-taskDefinition.addContainer('fluent-bit', {
-  image: ecs.ContainerImage.fromRegistry('public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-stable'),
-  memoryLimitMiB: 2096,
-  cpu: 1024,
+taskDefinition.addContainer('main', {
+  image: ecs.ContainerImage.fromRegistry('hello-world'),
+  memoryLimitMiB: 256,
 });
 
 new ecs.Ec2Service(stack, 'EC2Service', {

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

@@ -0,0 +1,80 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as cdk from 'aws-cdk-lib';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+
+/*
+ * This integration test demonstrates how to use EBS volume initialization rate
+ * with Service Managed Volumes.
+ *
+ * To run this test with a real EBS snapshot:
+ * 1. Create an EBS volume:
+ *    aws ec2 create-volume --size 1 --volume-type gp3 --availability-zone us-east-1a
+ * 2. Create a snapshot from the volume:
+ *    aws ec2 create-snapshot --volume-id vol-xxxxxxxxx --description "Test snapshot"
+ * 3. Wait for snapshot completion:
+ *    aws ec2 wait snapshot-completed --snapshot-ids snap-xxxxxxxxx
+ * 4. Set the environment variable SNAPSHOT_ID to the snapshot ID:
+ *    export SNAPSHOT_ID=snap-xxxxxxxxx
+ */
+
+const snapShotId = process.env.SNAPSHOT_ID ?? 'snap-123456789abcdef0';
+
+class TestStack extends cdk.Stack {
+  constructor(scope: Construct, id: string) {
+    super(scope, id);
+
+    const vpc = new ec2.Vpc(this, 'Vpc', {
+      maxAzs: 1,
+      restrictDefaultSecurityGroup: false,
+    });
+
+    const cluster = new ecs.Cluster(this, 'FargateCluster', {
+      vpc,
+    });
+
+    const taskDefinition = new ecs.FargateTaskDefinition(this, 'TaskDef');
+
+    const container = taskDefinition.addContainer('web', {
+      image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+      portMappings: [{
+        containerPort: 80,
+        protocol: ecs.Protocol.TCP,
+      }],
+    });
+
+    const volume = new ecs.ServiceManagedVolume(this, 'EBSVolume', {
+      name: 'ebs1',
+      managedEBSVolume: {
+        volumeType: ec2.EbsDeviceVolumeType.GP3,
+        size: cdk.Size.gibibytes(1),
+        fileSystemType: ecs.FileSystemType.EXT4,
+        volumeInitializationRate: cdk.Size.mebibytes(200),
+        snapShotId: snapShotId,
+      },
+    });
+
+    volume.mountIn(container, {
+      containerPath: '/var/lib',
+      readOnly: false,
+    });
+
+    taskDefinition.addVolume(volume);
+
+    const service = new ecs.FargateService(this, 'FargateService', {
+      cluster,
+      taskDefinition,
+      desiredCount: 1,
+    });
+
+    service.addVolume(volume);
+  }
+}
+
+const app = new cdk.App();
+const stack = new TestStack(app, 'integ-aws-ecs-ebs-volume-initialization-rate');
+
+new integ.IntegTest(app, 'EBSVolumeInitializationRate', {
+  testCases: [stack],
+});

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.managedinstances-capacity-provider.ts

@@ -0,0 +1,114 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as cdk from 'aws-cdk-lib';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm': true,
+    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
+    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
+  },
+});
+const stack = new cdk.Stack(app, 'integ-managedinstances-capacity-provider');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+const cluster = new ecs.Cluster(stack, 'ManagedInstancesCluster', {
+  vpc,
+  enableFargateCapacityProviders: true,
+});
+
+// Create IAM roles required for FMI following Omakase specifications
+const infrastructureRole = new iam.Role(stack, 'InfrastructureRole', {
+  roleName: 'AmazonECSInfrastructureRoleForOmakase',
+  assumedBy: new iam.ServicePrincipal('ecs.amazonaws.com'),
+  managedPolicies: [
+    iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonECSInfrastructureRolePolicyForManagedInstances'),
+  ],
+});
+
+const instanceRole = new iam.Role(stack, 'InstanceRole', {
+  roleName: 'AmazonECSInstanceRoleForOmakase',
+  assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
+  managedPolicies: [
+    iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonECSInstanceRolePolicyForManagedInstances'),
+  ],
+});
+
+const instanceProfile = new iam.InstanceProfile(stack, 'InstanceProfile', {
+  instanceProfileName: 'AmazonECSInstanceRoleForOmakase',
+  role: instanceRole,
+});
+
+// Create a security group for FMI instances
+const fmiSecurityGroup = new ec2.SecurityGroup(stack, 'ManagedInstancesSecurityGroup', {
+  vpc,
+  description: 'Security group for ManagedInstances capacity provider instances',
+  allowAllOutbound: true,
+});
+
+// Create MI Capacity Provider
+const miCapacityProvider = new ecs.ManagedInstancesCapacityProvider(stack, 'ManagedInstancesCapacityProvider', {
+  infrastructureRole: infrastructureRole,
+  ec2InstanceProfile: instanceProfile,
+  subnets: vpc.privateSubnets,
+  securityGroups: [fmiSecurityGroup],
+  propagateTags: ecs.PropagateManagedInstancesTags.CAPACITY_PROVIDER,
+  instanceRequirements: {
+    vCpuCountMin: 1,
+    memoryMin: cdk.Size.gibibytes(2),
+    cpuManufacturers: [ec2.CpuManufacturer.INTEL],
+    acceleratorManufacturers: [ec2.AcceleratorManufacturer.NVIDIA],
+  },
+});
+
+// Configure security group rules using IConnectable interface
+miCapacityProvider.connections.allowFrom(ec2.Peer.ipv4(vpc.vpcCidrBlock), ec2.Port.tcp(80));
+
+// Add FMI capacity provider to cluster
+cluster.addManagedInstancesCapacityProvider(miCapacityProvider);
+cluster.addDefaultCapacityProviderStrategy([
+  {
+    capacityProvider: miCapacityProvider.capacityProviderName,
+    weight: 1,
+  },
+]);
+
+// Create a task definition compatible with Managed Instances and Fargate
+const taskDefinition = new ecs.TaskDefinition(stack, 'TaskDef', {
+  compatibility: ecs.Compatibility.FARGATE_AND_MANAGED_INSTANCES,
+  cpu: '256',
+  memoryMiB: '512',
+  networkMode: ecs.NetworkMode.AWS_VPC,
+});
+
+taskDefinition.addContainer('web', {
+  image: ecs.ContainerImage.fromRegistry('public.ecr.aws/docker/library/httpd:2.4'),
+  memoryLimitMiB: 512,
+  portMappings: [
+    {
+      containerPort: 80,
+      protocol: ecs.Protocol.TCP,
+    },
+  ],
+});
+
+// Create a service using the MI capacity provider
+new ecs.FargateService(stack, 'ManagedInstancesService', {
+  cluster,
+  taskDefinition,
+  capacityProviderStrategies: [
+    {
+      capacityProvider: miCapacityProvider.capacityProviderName,
+      weight: 1,
+    },
+  ],
+  desiredCount: 1,
+});
+
+new integ.IntegTest(app, 'ManagedInstancesCapacityProviders', {
+  testCases: [stack],
+});
+
+app.synth();