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

cdk_api_mcp_server/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Kenji Kono <konoken@amazon.co.jp>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.47.0"
+__version__ = "0.48.0"

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

@@ -1059,7 +1059,7 @@ The properties passed to the level 2 constructs `AutoScalingGroup` and `Instance
 `aws-ec2` module abstract what is passed into the `CfnOption` properties `resourceSignal` and
 `autoScalingCreationPolicy`, but when using level 1 constructs you can specify these yourself.
 
-The CfnWaitCondition resource from the `aws-cloudformation` module suppports the `resourceSignal`.
+The CfnWaitCondition resource from the `aws-cloudformation` module supports the `resourceSignal`.
 The format of the timeout is `PT#H#M#S`. In the example below AWS Cloudformation will wait for
 3 success signals to occur within 15 minutes before the status of the resource will be set to
 `CREATE_COMPLETE`.

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

@@ -577,6 +577,82 @@ const fleet = new codebuild.Fleet(this, 'MyFleet', {
 });
 ```
 
+### Custom instance types
+You can use [specific EC2 instance
+types](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment-reserved-capacity.instance-types)
+for your fleet by setting the `computeType` to `CUSTOM_INSTANCE_TYPE`.  This
+allows you to specify the `instanceType` in `computeConfiguration`. Only certain
+EC2 instance types are supported; see the linked documentation for details.
+
+```ts
+import { Size } from 'aws-cdk-lib';
+
+const fleet = new codebuild.Fleet(this, 'MyFleet', {
+  baseCapacity: 1,
+  computeType: codebuild.FleetComputeType.CUSTOM_INSTANCE_TYPE,
+  environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+  computeConfiguration: {
+    instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+    // By default, 64 GiB of disk space is included. Any value optionally
+    // specified here is _incremental_ on top of the included disk space.
+    disk: Size.gibibytes(10),
+  },
+});
+```
+
+### Fleet overflow behavior
+
+When your builds exceed the capacity of your fleet, you can specify how CodeBuild should handle the overflow builds by setting the `overflowBehavior` property:
+
+```ts
+const fleet = new codebuild.Fleet(this, 'Fleet', {
+  computeType: codebuild.FleetComputeType.MEDIUM,
+  environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+  baseCapacity: 1,
+  overflowBehavior: codebuild.FleetOverflowBehavior.ON_DEMAND,
+});
+```
+
+The available overflow behaviors are:
+
+- `QUEUE` (default): Overflow builds wait for existing fleet instances to become available
+- `ON_DEMAND`: Overflow builds run on CodeBuild on-demand instances
+
+Note: If you set overflow behavior to `ON_DEMAND` for a VPC-connected fleet, ensure your VPC settings allow access to public AWS services.
+
+### VPCs
+The same considerations that apply to [Project
+VPCs](#definition-of-vpc-configuration-in-codebuild-project) also apply to Fleet
+VPCs.  When using a Fleet in a CodeBuild Project, it is an error to configure a
+VPC on the Project. Configure a VPC on the fleet instead.
+
+```ts
+declare const loadBalancer: elbv2.ApplicationLoadBalancer;
+
+const vpc = new ec2.Vpc(this, 'MyVPC');
+const fleet = new codebuild.Fleet(this, 'MyProject', {
+  computeType: codebuild.FleetComputeType.MEDIUM,
+  environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+  baseCapacity: 1,
+  vpc,
+});
+
+fleet.connections.allowTo(loadBalancer, ec2.Port.tcp(443));
+
+const project = new codebuild.Project(this, 'MyProject', {
+  environment: {
+    fleet,
+  },
+  buildSpec: codebuild.BuildSpec.fromObject({
+    // ...
+  }),
+  // Trying to configure a project-level VPC is an error, because this project
+  // runs on the Fleet created above.
+  // vpc,
+});
+```
+>>>>>>> 39ec36ec6a (feat(codebuild): add custom instance type and VPC to Fleets)
+
 ## Logs
 
 CodeBuild lets you specify an S3 Bucket, CloudWatch Log Group or both to receive logs from your projects.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-attribute-based-compute.ts

@@ -1,17 +1,55 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as codebuild from 'aws-cdk-lib/aws-codebuild';
 import { Construct } from 'constructs';
 
-const configurations: codebuild.ComputeConfiguration[] = [
+type StackConfiguration = {
+  computeConfiguration: codebuild.ComputeConfiguration;
+  vpcProps?: ec2.VpcProps;
+  subnetSelection?: ec2.SubnetSelection;
+  securityGroupProps?: Array<Omit<ec2.SecurityGroupProps, 'vpc'>>;
+}
+const configurations: Array<StackConfiguration> = [
+  {
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+    },
+  },
   {
-    machineType: codebuild.MachineType.GENERAL,
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+      vCpu: 2,
+      memory: cdk.Size.gibibytes(4),
+      disk: cdk.Size.gibibytes(10),
+    },
   },
   {
-    machineType: codebuild.MachineType.GENERAL,
-    vCpu: 2,
-    memory: cdk.Size.gibibytes(4),
-    disk: cdk.Size.gibibytes(10),
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+    },
+    vpcProps: {
+      maxAzs: 1,
+      restrictDefaultSecurityGroup: false,
+    },
+  },
+  {
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+    },
+    vpcProps: {
+      maxAzs: 1,
+      // Incredibly, if you pass a SubnetSelection that produces more than 1
+      // subnet, you currently get this error:
+      // > Resource handler returned message: "Invalid vpc config: the maximum number of subnets is 1
+      // This seems like a terrible limitation from the CodeBuild team.
+      // maxAzs: 2,
+    },
+    subnetSelection: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+    securityGroupProps: [
+      { allowAllOutbound: true },
+      { allowAllIpv6Outbound: true },
+    ],
   },
 ];
 
@@ -19,14 +57,27 @@ class FleetStack extends cdk.Stack {
   public readonly fleet: codebuild.Fleet;
   public readonly project: codebuild.Project;
 
-  constructor(scope: Construct, id: string, computeConfiguration: codebuild.ComputeConfiguration) {
+  constructor(scope: Construct, id: string, { computeConfiguration, vpcProps, subnetSelection, securityGroupProps }: StackConfiguration) {
     super(scope, id);
 
+    let vpc: ec2.Vpc | undefined;
+    let securityGroups: Array<ec2.SecurityGroup> | undefined;
+    if (vpcProps) {
+      vpc = new ec2.Vpc(this, 'Vpc', vpcProps);
+      const refinedVpc = vpc;
+      securityGroups = securityGroupProps?.map((props, i) =>
+        new ec2.SecurityGroup(this, `SecurityGroup${i}`, { ...props, vpc: refinedVpc }),
+      );
+    }
+
     this.fleet = new codebuild.Fleet(this, 'MyFleet', {
       baseCapacity: 1,
       computeType: codebuild.FleetComputeType.ATTRIBUTE_BASED,
       computeConfiguration,
       environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+      vpc,
+      securityGroups,
+      subnetSelection,
     });
 
     this.project = new codebuild.Project(this, 'MyProject', {
@@ -38,6 +89,7 @@ class FleetStack extends cdk.Stack {
       }),
       environment: {
         buildImage: codebuild.LinuxBuildImage.STANDARD_7_0,
+        fleet: this.fleet,
       },
     });
   }

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-custom-instance-type.ts

@@ -0,0 +1,130 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as cdk from 'aws-cdk-lib';
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import { Construct } from 'constructs';
+
+type StackConfiguration = {
+  computeConfiguration: codebuild.ComputeConfiguration;
+  vpcProps?: ec2.VpcProps;
+  subnetSelection?: ec2.SubnetSelection;
+  securityGroupProps?: Array<Omit<ec2.SecurityGroupProps, 'vpc'>>;
+}
+const configurations: Array<StackConfiguration> = [
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+    },
+  },
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+      disk: cdk.Size.gibibytes(10),
+    },
+  },
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+    },
+    vpcProps: {
+      maxAzs: 1,
+      restrictDefaultSecurityGroup: false,
+    },
+  },
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+    },
+    vpcProps: {
+      maxAzs: 1,
+      // Incredibly, if you pass a SubnetSelection that produces more than 1
+      // subnet, you currently get this error:
+      // > Resource handler returned message: "Invalid vpc config: the maximum number of subnets is 1
+      // This seems like a terrible limitation from the CodeBuild team.
+      // maxAzs: 2,
+    },
+    subnetSelection: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+    securityGroupProps: [
+      { allowAllOutbound: true },
+      { allowAllIpv6Outbound: true },
+    ],
+  },
+];
+
+class FleetStack extends cdk.Stack {
+  public readonly fleet: codebuild.Fleet;
+  public readonly project: codebuild.Project;
+
+  constructor(scope: Construct, id: string, { computeConfiguration, vpcProps, subnetSelection, securityGroupProps }: StackConfiguration) {
+    super(scope, id);
+
+    let vpc: ec2.Vpc | undefined;
+    let securityGroups: Array<ec2.SecurityGroup> | undefined;
+    if (vpcProps) {
+      vpc = new ec2.Vpc(this, 'Vpc', vpcProps);
+      const refinedVpc = vpc;
+      securityGroups = securityGroupProps?.map((props, i) =>
+        new ec2.SecurityGroup(this, `SecurityGroup${i}`, { ...props, vpc: refinedVpc }),
+      );
+    }
+
+    this.fleet = new codebuild.Fleet(this, 'MyFleet', {
+      baseCapacity: 1,
+      computeType: codebuild.FleetComputeType.CUSTOM_INSTANCE_TYPE,
+      computeConfiguration,
+      environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+      vpc,
+      securityGroups,
+      subnetSelection,
+    });
+
+    this.project = new codebuild.Project(this, 'MyProject', {
+      buildSpec: codebuild.BuildSpec.fromObject({
+        version: '0.2',
+        phases: {
+          build: { commands: ['echo "Nothing to do!"'] },
+        },
+      }),
+      environment: {
+        buildImage: codebuild.LinuxBuildImage.STANDARD_7_0,
+        fleet: this.fleet,
+      },
+    });
+  }
+}
+
+const app = new cdk.App();
+const stacks = configurations.map(
+  (config, index) => new FleetStack(
+    app,
+    `CustomInstanceTypeComputeFleetIntegStack${index}`,
+    config,
+  ),
+);
+
+const test = new integ.IntegTest(app, 'CustomInstanceTypeComputeFleetIntegTest', {
+  testCases: stacks,
+});
+
+const listFleets = test.assertions.awsApiCall('Codebuild', 'listFleets');
+for (const { fleet, project } of stacks) {
+  listFleets.expect(integ.ExpectedResult.objectLike({
+    fleets: integ.Match.arrayWith([fleet.fleetArn]),
+  }));
+
+  const startBuild = test.assertions.awsApiCall('Codebuild', 'startBuild', { projectName: project.projectName });
+
+  // Describe the build and wait for the status to be successful
+  test.assertions.awsApiCall('CodeBuild', 'batchGetBuilds', {
+    ids: [startBuild.getAttString('build.id')],
+  }).assertAtPath(
+    'builds.0.buildStatus',
+    integ.ExpectedResult.stringLikeRegexp('SUCCEEDED'),
+  ).waitForAssertions({
+    // After a custom instance type fleet is created, there can still be high
+    // latency on creating actual instances. Needs a long timeout, builds are
+    // pending until instances are initialized.
+    totalTimeout: cdk.Duration.minutes(10),
+    interval: cdk.Duration.seconds(30),
+  });
+}

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-overflow-behavior.ts

@@ -0,0 +1,61 @@
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import { Construct } from 'constructs';
+
+class FleetStack extends cdk.Stack {
+  public readonly fleet: codebuild.Fleet;
+  public readonly project: codebuild.Project;
+
+  constructor(scope: Construct, id: string) {
+    super(scope, id);
+
+    this.fleet = new codebuild.Fleet(this, 'MyFleet', {
+      baseCapacity: 1,
+      computeType: codebuild.FleetComputeType.SMALL,
+      environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+      overflowBehavior: codebuild.FleetOverflowBehavior.ON_DEMAND,
+    });
+
+    this.project = new codebuild.Project(this, 'MyProject', {
+      buildSpec: codebuild.BuildSpec.fromObject({
+        version: '0.2',
+        phases: {
+          build: { commands: ['echo "Nothing to do!"'] },
+        },
+      }),
+      environment: {
+        fleet: this.fleet,
+        buildImage: codebuild.LinuxBuildImage.STANDARD_7_0,
+      },
+    });
+  }
+}
+
+const app = new cdk.App();
+const stack= new FleetStack(
+  app,
+  'OverflowBehaviorFleetStack',
+);
+
+const test = new integ.IntegTest(app, 'OverflowBehaviorFleetInteg', {
+  testCases: [stack],
+});
+
+const listFleets = test.assertions.awsApiCall('Codebuild', 'listFleets');
+listFleets.expect(integ.ExpectedResult.objectLike({
+  fleets: integ.Match.arrayWith([stack.fleet.fleetArn]),
+}));
+
+const startBuild = test.assertions.awsApiCall('Codebuild', 'startBuild', { projectName: stack.project.projectName });
+
+// Describe the build and wait for the status to be successful
+test.assertions.awsApiCall('CodeBuild', 'batchGetBuilds', {
+  ids: [startBuild.getAttString('build.id')],
+}).assertAtPath(
+  'builds.0.buildStatus',
+  integ.ExpectedResult.stringLikeRegexp('SUCCEEDED'),
+).waitForAssertions({
+  totalTimeout: cdk.Duration.minutes(5),
+  interval: cdk.Duration.seconds(30),
+});

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

@@ -1659,6 +1659,107 @@ new ecs.Ec2Service(this, 'EC2Service', {
 });
 ```
 
+### Managed Instances Capacity Providers
+
+Managed Instances Capacity Providers allow you to use AWS-managed EC2 instances for your ECS tasks while providing more control over instance selection than standard Fargate. AWS handles the instance lifecycle, patching, and maintenance while you can specify detailed instance requirements.
+
+To create a Managed Instances Capacity Provider, you need to specify the required EC2 instance profile, and networking configuration. You can also define detailed instance requirements to control which types of instances are used for your workloads.
+
+```ts
+declare const vpc: ec2.Vpc;
+declare const infrastructureRole: iam.Role;
+declare const instanceProfile: iam.InstanceProfile;
+
+const cluster = new ecs.Cluster(this, 'Cluster', { vpc });
+
+// Create a Managed Instances Capacity Provider
+const miCapacityProvider = new ecs.ManagedInstancesCapacityProvider(this, 'MICapacityProvider', {
+  infrastructureRole,
+  ec2InstanceProfile: instanceProfile,
+  subnets: vpc.privateSubnets,
+  securityGroups: [new ec2.SecurityGroup(this, 'MISecurityGroup', { vpc })],
+  instanceRequirements: {
+    vCpuCountMin: 1,
+    memoryMin: Size.gibibytes(2),
+    cpuManufacturers: [ec2.CpuManufacturer.INTEL],
+    acceleratorManufacturers: [ec2.AcceleratorManufacturer.NVIDIA],
+  },
+  propagateTags: ecs.PropagateManagedInstancesTags.CAPACITY_PROVIDER,
+});
+
+// Add the capacity provider to the cluster
+cluster.addManagedInstancesCapacityProvider(miCapacityProvider);
+
+const taskDefinition = new ecs.Ec2TaskDefinition(this, 'TaskDef');
+
+taskDefinition.addContainer('web', {
+  image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+  memoryReservationMiB: 256,
+});
+
+new ecs.Ec2Service(this, 'EC2Service', {
+  cluster,
+  taskDefinition,
+  minHealthyPercent: 100,
+  capacityProviderStrategies: [
+    {
+      capacityProvider: miCapacityProvider.capacityProviderName,
+      weight: 1,
+    },
+  ],
+});
+```
+
+You can specify detailed instance requirements to control which types of instances are used:
+
+```ts
+declare const infrastructureRole: iam.Role;
+declare const instanceProfile: iam.InstanceProfile;
+declare const vpc: ec2.Vpc;
+
+const miCapacityProvider = new ecs.ManagedInstancesCapacityProvider(this, 'MICapacityProvider', {
+  infrastructureRole,
+  ec2InstanceProfile: instanceProfile,
+  subnets: vpc.privateSubnets,
+  instanceRequirements: {
+    // Required: CPU and memory constraints
+    vCpuCountMin: 2,
+    vCpuCountMax: 8,
+    memoryMin: Size.gibibytes(4),
+    memoryMax: Size.gibibytes(32),
+    
+    // CPU preferences
+    cpuManufacturers: [ec2.CpuManufacturer.INTEL, ec2.CpuManufacturer.AMD],
+    instanceGenerations: [ec2.InstanceGeneration.CURRENT],
+    
+    // Instance type filtering
+    allowedInstanceTypes: ['m5.*', 'c5.*'],
+    
+    // Performance characteristics
+    burstablePerformance: ec2.BurstablePerformance.EXCLUDED,
+    bareMetal: ec2.BareMetal.EXCLUDED,
+    
+    // Accelerator requirements (for ML/AI workloads)
+    acceleratorTypes: [ec2.AcceleratorType.GPU],
+    acceleratorManufacturers: [ec2.AcceleratorManufacturer.NVIDIA],
+    acceleratorNames: [ec2.AcceleratorName.T4, ec2.AcceleratorName.V100],
+    acceleratorCountMin: 1,
+    
+    // Storage requirements
+    localStorage: ec2.LocalStorage.REQUIRED,
+    localStorageTypes: [ec2.LocalStorageType.SSD],
+    totalLocalStorageGBMin: 100,
+    
+    // Network requirements
+    networkInterfaceCountMin: 2,
+    networkBandwidthGbpsMin: 10,
+    
+    // Cost optimization
+    onDemandMaxPricePercentageOverLowestPrice: 10,
+  },
+});
+```
+
 ### Cluster Default Provider Strategy
 
 A capacity provider strategy determines whether ECS tasks are launched on EC2 instances or Fargate/Fargate Spot. It can be specified at the cluster, service, or task level, and consists of one or more capacity providers. You can specify an optional base and weight value for finer control of how tasks are launched. The `base` specifies a minimum number of tasks on one capacity provider, and the `weight`s of each capacity provider determine how tasks are distributed after `base` is satisfied.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.managedinstances-capacity-provider.ts

@@ -0,0 +1,112 @@
+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('AdministratorAccess'),
+  ],
+});
+
+const instanceRole = new iam.Role(stack, 'InstanceRole', {
+  roleName: 'AmazonECSInstanceRoleForOmakase',
+  assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
+  managedPolicies: [
+    iam.ManagedPolicy.fromAwsManagedPolicyName('AdministratorAccess'),
+  ],
+});
+
+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],
+  },
+});
+
+// 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],
+  regions: ['us-west-2'],
+});
+
+app.synth();

{konokenj_cdk_api_mcp_server-0.47.0.dist-info → konokenj_cdk_api_mcp_server-0.48.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konokenj.cdk-api-mcp-server
-Version: 0.47.0
+Version: 0.48.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.217.0-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.218.0-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
 <!-- DEP-VERSIONS-END -->
 
 ---

{konokenj_cdk_api_mcp_server-0.47.0.dist-info → konokenj_cdk_api_mcp_server-0.48.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cdk_api_mcp_server/__about__.py,sha256=8L-6OWVPIF0futVdaVrf07B6gKzkYZILssN41hDhlOE,129
+cdk_api_mcp_server/__about__.py,sha256=srzMbr0otzQq5BX_rtov_llD8WR7FdcIlipzD5IkGlQ,129
 cdk_api_mcp_server/__init__.py,sha256=yJA6yIEhJviC-qNlB-nC6UR1JblQci_d84i-viHZkc0,187
 cdk_api_mcp_server/models.py,sha256=cMS1Hi29M41YjuBxqqrzNrNvyG3MgnUBb1SqYpMCJ30,692
 cdk_api_mcp_server/resources.py,sha256=R7LVwn29I4BJzU5XAwKbX8j6uy-3ZxcB1b0HzZ_Z2PI,6689
@@ -44,7 +44,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/cfnspec/README.md,sha25
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/custom-resource-handlers/README.md,sha256=QctOoyGt6AqVWeFhRwpkCSxHZ1XFWj_nCKlkJHDFock,965
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/example-construct-library/README.md,sha256=vnVXyvtN9ICph68sw2y6gkdD_gmas0PiUa9TkwNckWQ,4501
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/integ-tests-alpha/README.md,sha256=VifKLrR404_yLVT0E3ai8f3R5K0h22VNwQplpSUSZqc,17489
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/README.md/README.md,sha256=5tNXSQdAoxRB2CXlKDpTlt-07OG3yIFqEEMnofQTGxE,76232
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/README.md/README.md,sha256=3UAoxAPV0YhySOFVSCnsNgur2YHYqBqJL4LGiWBQ7Tw,76231
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/assertions/MIGRATING.md,sha256=SYGX8QNB1Pm_rVYDBp4QRWkqwnxOb3CHzeFglUy_53k,3347
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/assertions/README.md,sha256=3yo3D05n5explTIgnuF-vkk01MTYeAYe7_3rcsD2baE,18299
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/assets/README.md,sha256=kL56RlfxBa5LwV0cRseybeKIRKHhEXPjUo0HWPZqdO8,53
@@ -325,7 +325,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch-actio
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch-actions/integ.lambda-alarm-action.ts,sha256=onNZET1IofzJ-_LmnlREFQ3O7MkISTW2OrLrCkJ2qBA,4614
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch-actions/integ.lambda-alarm-multiple-stepscalingpolicy.ts,sha256=gPLnWcaoTAAlmDYKyHsZz_55lpEDjG92xTNdjEc3IPk,2722
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch-actions/integ.ssm-incident-alarm-action.ts,sha256=X5iWnwQcAbLQnDkrxd5_rKL-jfw4s60kEQMVFLnCTRk,1895
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/README.md,sha256=pKI0s8e1zzvjz4LvKZga20AJxS6kpUEpsysTAP3N9ls,34404
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/README.md,sha256=D5zH4G72KjcgUBoxvyeMv5IiibETqfsjFqbsTu5N2ao,37188
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.asset-build-spec.ts,sha256=APwn0Tzph1El4XowRux9zXXlZO3eXJMFbp3bbovs-AM,1850
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.aws-deep-learning-container-build-image.ts,sha256=hSyb2cy-zu1rEkNiPybncQaV-Gh63REI95WBpuXeL-Y,488
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.breakpoint.ts,sha256=ezkSR2Ne1erXri4XV_kMwS4-DUhR5m3EMG1nxzbKZs4,838
@@ -344,7 +344,9 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-buildspec-artifacts.ts,sha256=3Fx_jwCa5HW0Dsat2B5hMXrZw_CVldbITSTZRbSGRjo,693
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-docker-server.ts,sha256=n-TtyWQmaxiI-dWyWe6nZgCDtdn_gvqZAigIT_ugFPI,1301
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-file-system-location.ts,sha256=t1I6uabPbfoaQ7lzP2EJIbvB3_5vkTrr_oQRh69_HQk,1060
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-attribute-based-compute.ts,sha256=ttHvMAKsoo0zEF4f82x6cSyI_2QA0se6zrXoN64A2WY,2303
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-attribute-based-compute.ts,sha256=dAC9hW95FKgQl9sc_I4YK7UzIYcEZUrDblmlqd-bVJo,3930
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-custom-instance-type.ts,sha256=tobSWcbc6bd9De3brfmqAqV5_muT3FlOJPee378ff5g,4248
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-overflow-behavior.ts,sha256=XqE1fRey0AoXWUOIKSlBo_9uumqzL_hUayqXo21uU0c,1895
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet.ts,sha256=kCXeV4i_mq2JFzvTDox6rv10no6LOZ-bb_Gk6aSa7A4,1913
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-linux-arm-lambda-image.lit.ts,sha256=f8fQCveGRs6yCEF0Shkww6BxGs1_iOb8QGl5nZg-138,1282
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-linux-arm.ts,sha256=cB-WiW6Vy4hK5vNbozAHUTX2UduHf2L2Yghm-bNF4uM,1318
@@ -583,7 +585,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecr-assets/integ
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecr-assets/integ.assets-tarball.ts,sha256=pSbNMWSorKT7lUTXxnzkxpcRumKPYWUmcbqRSwwWOgI,937
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecr-assets/integ.nested-stacks-docker.ts,sha256=4hDobse34oIG2r0mjbYXzsEXXLEqv077jUh3pjoYmcc,981
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/CONTRIBUTING.md,sha256=TlNwpeYemLdYq4jdo24v7nwDIj3RmZ7u2j_LCQiQR74,2634
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/README.md,sha256=3x7qZzMSZhlUITrPhNTscpSQbBQV34cDMADTqmOA7uc,75808
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/README.md,sha256=g4z6674_NsRjkJoBj0eGXlWp03nQyapkjdJkiJ0GUUw,79348
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.add-docker-label.ts,sha256=avHktilCBVPuVelquVaY2ylRkSLraWn7vUIIIFPsbyI,1375
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.add-environment-variable.ts,sha256=sIdwJl7LYh5wlv_EDLPSGCavC2OF6W8IBwZ_hMOnCfw,1143
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.app-mesh-proxy-config.ts,sha256=vWr45An7W7lgW9Ws_yPFhapf9DXyJP-D0fhTNg5fZC0,1717
@@ -625,6 +627,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.gravit
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.graviton.ts,sha256=SfImqll0RwSnvXxB_UIb8pQbdN_OxFfUVsq69lI4k2o,840
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.lb-awsvpc-nw.ts,sha256=Rwqi34a5qRjNqLnbh6bNgb46CVDnGD7WGWGWm321w24,1623
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.lb-bridge-nw.ts,sha256=sxV4f9fRvG2aTwDI0rUfipuE8yQFZy0CWUTd3H0OdUc,1632
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.managedinstances-capacity-provider.ts,sha256=oGNex2Yj_aHaaRp9rUfWerjJv7O91Ls4ChkJXqmjgpE,3561
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.nlb-awsvpc-nw.ts,sha256=vXdMwV8Ythm3Qa4cHX_mg0WjRESCMYe0GgA3tX_uqTk,1474
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.placement-constraint-default-empty.ts,sha256=mMQZyejxLzLlENEuiDk7GKa1syiPkpb6xb6DEtYH62s,1490
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.placement-strategies.ts,sha256=W797uZbgznmaIVRYBaguJ3cM9OxXi70utWvE3g-nPiM,1424
@@ -1414,8 +1417,8 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/integ.pipe
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/region-info/README.md,sha256=vewWkV3ds9o9iyyYaJBNTkaKJ2XA6K2yF17tAxUnujg,2718
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/triggers/README.md,sha256=hYIx7DbG_7p4LYLUfxDwgIQjw9UNdz1GLrqDe8_Dbko,4132
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/triggers/integ.triggers.ts,sha256=4OHplMoBOgHGkktAzoU-TuNmJQS5wGAUvBfj5bGSe_Y,2807
-konokenj_cdk_api_mcp_server-0.47.0.dist-info/METADATA,sha256=XOyf695Rswja2-w_gzNMI_s7OkNACCDiH7uzU4TFmo8,2646
-konokenj_cdk_api_mcp_server-0.47.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-konokenj_cdk_api_mcp_server-0.47.0.dist-info/entry_points.txt,sha256=bVDhMdyCC1WNMPOMbmB82jvWII2CIrwTZDygdCf0cYQ,79
-konokenj_cdk_api_mcp_server-0.47.0.dist-info/licenses/LICENSE.txt,sha256=5OIAASeg1HM22mVZ1enz9bgZ7TlsGfWXnj02P9OgFyk,1098
-konokenj_cdk_api_mcp_server-0.47.0.dist-info/RECORD,,
+konokenj_cdk_api_mcp_server-0.48.0.dist-info/METADATA,sha256=DlxK8jwG-lfIznfwyArD_Rgn_I07ZrlH_ftIRTLM1y8,2646
+konokenj_cdk_api_mcp_server-0.48.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+konokenj_cdk_api_mcp_server-0.48.0.dist-info/entry_points.txt,sha256=bVDhMdyCC1WNMPOMbmB82jvWII2CIrwTZDygdCf0cYQ,79
+konokenj_cdk_api_mcp_server-0.48.0.dist-info/licenses/LICENSE.txt,sha256=5OIAASeg1HM22mVZ1enz9bgZ7TlsGfWXnj02P9OgFyk,1098
+konokenj_cdk_api_mcp_server-0.48.0.dist-info/RECORD,,