konokenj.cdk-api-mcp-server 0.47.0__py3-none-any.whl → 0.49.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.49.0"

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-amplify-alpha/README.md

@@ -353,6 +353,18 @@ const amplifyApp = new amplify.App(this, 'MyApp', {
 });
 ```
 
+## Build Compute Type
+
+You can specify the build compute type by setting the `buildComputeType` property.
+
+For more information, see [Configuring the build instance for an Amplify application](https://docs.aws.amazon.com/amplify/latest/userguide/custom-build-instance.html).
+
+```ts
+const amplifyApp = new amplify.App(this, 'MyApp', {
+  buildComputeType: amplify.BuildComputeType.LARGE_16GB,
+});
+```
+
 ## Deploying Assets
 
 `sourceCodeProvider` is optional; when this is not specified the Amplify app can be deployed to using `.zip` packages. The `asset` property can be used to deploy S3 assets to Amplify as part of the CDK:

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-batch/README.md

@@ -65,7 +65,18 @@ For stateful or otherwise non-interruption-tolerant workflows, omit `spot` or se
 
 #### Choosing Your Instance Types
 
-Batch allows you to choose the instance types or classes that will run your workload.
+Batch allows you to choose most up-to-date instance classes based on your region.
+This example configures your `ComputeEnvironment` to use only ARM64 instance:
+
+```ts
+const vpc = new ec2.Vpc(this, 'VPC');
+
+new batch.ManagedEc2EcsComputeEnvironment(this, 'myEc2ComputeEnv', {
+  vpc,
+  defaultInstanceClasses: [batch.DefaultInstanceClass.ARM64],
+});
+```
+
 This example configures your `ComputeEnvironment` to use only the `M5AD.large` instance:
 
 ```ts
@@ -91,6 +102,9 @@ new batch.ManagedEc2EcsComputeEnvironment(this, 'myEc2ComputeEnv', {
 });
 ```
 
+> [!WARNING] 
+> `useOptimalInstanceClasses` is deprecated! Use `defaultInstanceClasses` instead.
+
 Unless you explicitly specify `useOptimalInstanceClasses: false`, this compute environment will use `'optimal'` instances,
 which tells Batch to pick an instance from the C4, M4, and R4 instance families.
 *Note*: Batch does not allow specifying instance types or classes with different architectures.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-batch/integ.managed-compute-environment-default-instance-class.ts

@@ -0,0 +1,20 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { ManagedEc2EcsComputeEnvironment, EcsMachineImageType, DefaultInstanceClass } from 'aws-cdk-lib/aws-batch';
+
+const app = new App();
+const stack = new Stack(app, 'managed-compute-environment-default-instance-class');
+const vpc = new ec2.Vpc(stack, 'vpc', { restrictDefaultSecurityGroup: false });
+
+new ManagedEc2EcsComputeEnvironment(stack, 'ECS', {
+  vpc,
+  images: [{
+    imageType: EcsMachineImageType.ECS_AL2023,
+  }],
+  defaultInstanceClasses: [DefaultInstanceClass.ARM64],
+});
+
+new integ.IntegTest(app, 'integ-managed-compute-environment-default-instance-class', {
+  testCases: [stack],
+});

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

@@ -851,6 +851,39 @@ new cloudfront.Distribution(this, 'Distribution', {
 });
 ```
 
+### Configuring IP Address Type
+
+You can specify which IP protocol CloudFront uses when connecting to your Lambda Function URL origin. By default, CloudFront uses IPv4 only.
+
+```ts
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { OriginIpAddressType } from 'aws-cdk-lib/aws-cloudfront';
+
+declare const fn: lambda.Function;
+const fnUrl = fn.addFunctionUrl({ authType: lambda.FunctionUrlAuthType.NONE });
+
+// Uses default IPv4 only
+new cloudfront.Distribution(this, 'Distribution', {
+  defaultBehavior: { 
+    origin: new origins.FunctionUrlOrigin(fnUrl)
+  },
+});
+
+// Explicitly specify IP address type
+new cloudfront.Distribution(this, 'Distribution', {
+  defaultBehavior: { 
+    origin: new origins.FunctionUrlOrigin(fnUrl, {
+      ipAddressType: OriginIpAddressType.DUALSTACK, // Use both IPv4 and IPv6
+    })
+  },
+});
+```
+
+Supported values for `ipAddressType`:
+- `OriginIpAddressType.IPV4` - CloudFront uses IPv4 only to connect to the origin (default)
+- `OriginIpAddressType.IPV6` - CloudFront uses IPv6 only to connect to the origin  
+- `OriginIpAddressType.DUALSTACK` - CloudFront uses both IPv4 and IPv6 to connect to the origin
+
 ### Lambda Function URL with Origin Access Control (OAC)
 You can configure the Lambda Function URL with Origin Access Control (OAC) for enhanced security. When using OAC with Signing SIGV4_ALWAYS, it is recommended to set the Lambda Function URL authType to AWS_IAM to ensure proper authorization.
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.function-url-origin-ip-address-type.ts

@@ -0,0 +1,84 @@
+import * as cloudfront from 'aws-cdk-lib/aws-cloudfront';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { FunctionUrlOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';
+import { App, Stack } from 'aws-cdk-lib';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { OriginIpAddressType } from 'aws-cdk-lib/aws-cloudfront';
+
+const app = new App();
+const stack = new Stack(app, 'FunctionUrlOriginIpAddressTypeStack');
+
+// Lambda function
+const fn = new lambda.Function(stack, 'TestFunction', {
+  code: lambda.Code.fromInline('exports.handler = async () => ({ statusCode: 200, body: "Hello" });'),
+  handler: 'index.handler',
+  runtime: lambda.Runtime.NODEJS_20_X,
+});
+
+// Function URL with IAM auth
+const fnUrl = fn.addFunctionUrl({
+  authType: lambda.FunctionUrlAuthType.AWS_IAM,
+});
+
+// CloudFront distribution with IPv4 IP address type
+new cloudfront.Distribution(stack, 'DistributionWithoutIpAddressTypeProp(IPv4)', {
+  defaultBehavior: {
+    origin: FunctionUrlOrigin.withOriginAccessControl(fnUrl, {}),
+  },
+});
+
+// CloudFront distribution with IPv4 IP address type
+const distributionIPv4 = new cloudfront.Distribution(stack, 'DistributionWithIPv4', {
+  defaultBehavior: {
+    origin: FunctionUrlOrigin.withOriginAccessControl(fnUrl, {
+      ipAddressType: OriginIpAddressType.IPV4,
+    }),
+  },
+});
+
+// CloudFront distribution with IPv6 IP address type
+const distributionIPv6 = new cloudfront.Distribution(stack, 'DistributionWithIPv6', {
+  defaultBehavior: {
+    origin: FunctionUrlOrigin.withOriginAccessControl(fnUrl, {
+      ipAddressType: OriginIpAddressType.IPV6,
+    }),
+  },
+});
+
+// CloudFront distribution with dualstack IP address type
+const distributionDualstack = new cloudfront.Distribution(stack, 'DistributionWithDualstack', {
+  defaultBehavior: {
+    origin: FunctionUrlOrigin.withOriginAccessControl(fnUrl, {
+      ipAddressType: OriginIpAddressType.DUALSTACK,
+    }),
+  },
+});
+
+const integ = new IntegTest(app, 'FunctionUrlOriginIpAddressTypeTest', {
+  testCases: [stack],
+});
+
+// Assert that distributions are created with expected IP address type settings
+integ.assertions.awsApiCall('CloudFront', 'getDistribution', {
+  Id: distributionIPv4.distributionId,
+}).assertAtPath('Distribution.DistributionConfig.IsIPV4Enabled', ExpectedResult.exact(true));
+
+integ.assertions.awsApiCall('CloudFront', 'getDistribution', {
+  Id: distributionIPv4.distributionId,
+}).assertAtPath('Distribution.DistributionConfig.IsIPV6Enabled', ExpectedResult.exact(false));
+
+integ.assertions.awsApiCall('CloudFront', 'getDistribution', {
+  Id: distributionIPv6.distributionId,
+}).assertAtPath('Distribution.DistributionConfig.IsIPV4Enabled', ExpectedResult.exact(false));
+
+integ.assertions.awsApiCall('CloudFront', 'getDistribution', {
+  Id: distributionIPv6.distributionId,
+}).assertAtPath('Distribution.DistributionConfig.IsIPV6Enabled', ExpectedResult.exact(true));
+
+integ.assertions.awsApiCall('CloudFront', 'getDistribution', {
+  Id: distributionDualstack.distributionId,
+}).assertAtPath('Distribution.DistributionConfig.IsIPV4Enabled', ExpectedResult.exact(true));
+
+integ.assertions.awsApiCall('CloudFront', 'getDistribution', {
+  Id: distributionDualstack.distributionId,
+}).assertAtPath('Distribution.DistributionConfig.IsIPV6Enabled', ExpectedResult.exact(true));

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

@@ -479,7 +479,7 @@ const metric = new cloudwatch.Metric({
   namespace: 'AWS/EC2',
   metricName: 'CPUUtilization',
   statistic: 'Average',
-  period: Duration.minutes(5),
+  period: Duration.hours(1), // Alarm will use the metric's period
 });
 
 // Create an anomaly detection alarm

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch/integ.anomaly-detection-alarm.ts

@@ -5,12 +5,19 @@ import { Metric, ComparisonOperator, AnomalyDetectionAlarm, Alarm } from 'aws-cd
 const app = new App();
 const stack = new Stack(app, 'AnomalyDetectionAlarmTestStack');
 
-// Create the test metric
+// Create the test metric. Period will default to 300 seconds.
 const metric = new Metric({
   namespace: 'AWS/EC2',
   metricName: 'CPUUtilization',
   statistic: 'Average',
-  period: Duration.minutes(5),
+});
+
+// Create test metric with custom period
+const customPeriodMetric = new Metric({
+  namespace: 'AWS/EC2',
+  metricName: 'CPUUtilization',
+  statistic: 'Average',
+  period: Duration.days(1),
 });
 
 // Create an anomaly detection alarm with default operator
@@ -40,6 +47,14 @@ const descriptiveAlarm = Metric.anomalyDetectionFor({
   comparisonOperator: ComparisonOperator.GREATER_THAN_UPPER_THRESHOLD,
 });
 
+// Create an anomaly detection alarm with custom period
+const customPeriodAlarm = new AnomalyDetectionAlarm(stack, 'CustomPeriodAnomalyAlarm', {
+  metric: customPeriodMetric,
+  stdDevs: 2,
+  evaluationPeriods: 1,
+  comparisonOperator: ComparisonOperator.LESS_THAN_LOWER_OR_GREATER_THAN_UPPER_THRESHOLD,
+});
+
 // Create the integration test
 const integ = new IntegTest(app, 'AnomalyDetectionAlarmIntegTest', {
   testCases: [stack],
@@ -122,3 +137,30 @@ integ.assertions
       }),
     ]),
   }));
+
+integ.assertions
+  .awsApiCall('CloudWatch', 'describeAlarms', {
+    AlarmNames: [customPeriodAlarm.alarmName],
+  })
+  .expect(ExpectedResult.objectLike({
+    MetricAlarms: Match.arrayWith([
+      Match.objectLike({
+        ComparisonOperator: 'LessThanLowerOrGreaterThanUpperThreshold',
+        EvaluationPeriods: 1,
+        ThresholdMetricId: 'expr_1',
+        Metrics: Match.arrayWith([
+          Match.objectLike({
+            Expression: 'ANOMALY_DETECTION_BAND(m0, 2)',
+            Id: 'expr_1',
+            ReturnData: true,
+          }),
+          Match.objectLike({
+            Id: 'm0',
+            MetricStat: Match.objectLike({
+              Period: 86400, // 1 day in seconds, orignal metric period got overriden
+            }),
+          }),
+        ]),
+      }),
+    ]),
+  }));

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