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-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,21 +119,45 @@ const problemPercentage = new cloudwatch.MathExpression({
 });
 ```
 
-### Search Expressions
+### Metric ID Usage in Math Expressions
 
-Math expressions also support search expressions. For example, the following
-search expression returns all CPUUtilization metrics that it finds, with the
-graph showing the Average statistic with an aggregation period of 5 minutes:
+When metrics have custom IDs, you can reference them directly in math expressions.
 
 ```ts
-const cpuUtilization = new cloudwatch.MathExpression({
-  expression: "SEARCH('{AWS/EC2,InstanceId} MetricName=\"CPUUtilization\"', 'Average', 300)",
+declare const fn: lambda.Function;
 
-  // Specifying '' as the label suppresses the default behavior
-  // of using the expression as metric label. This is especially appropriate
-  // when using expressions that return multiple time series (like SEARCH()
-  // or METRICS()), to show the labels of the retrieved metrics only.
-  label: '',
+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
+
+Search expressions allow you to dynamically discover and display metrics that match specific criteria, making them ideal for monitoring dynamic infrastructure where the exact metrics aren't known in advance. A single search expression can return up to 500 time series.
+
+
+#### Using SearchExpression Class
+
+Following is an example of a search expression that returns all CPUUtilization metrics with the graph showing the Average statistic with an aggregation period of 5 minutes:
+
+```ts
+const cpuUtilization = new cloudwatch.SearchExpression({
+  expression: "SEARCH('{AWS/EC2,InstanceId} MetricName=\"CPUUtilization\"', 'Average', 900)",
+  label: 'EC2 CPU Utilization',
+  color: '#ff7f0e',
 });
 ```
 
@@ -108,6 +165,15 @@ Cross-account and cross-region search expressions are also supported. Use
 the `searchAccount` and `searchRegion` properties to specify the account
 and/or region to evaluate the search expression against.
 
+```ts
+const crossAccountSearch = new cloudwatch.SearchExpression({
+  expression: "SEARCH('{AWS/Lambda,FunctionName} MetricName=\"Invocations\"', 'Sum', 300)",
+  searchAccount: '123456789012',
+  searchRegion: 'us-west-2',
+  label: 'Production Lambda Invocations',
+});
+```
+
 ### Aggregation
 
 To graph or alarm on metrics you must aggregate them first, using a function
@@ -413,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
@@ -534,6 +600,19 @@ dashboard.addWidgets(new cloudwatch.GraphWidget({
 }));
 ```
 
+The `displayLabelsOnChart` property can be set to `true` to show labels on the chart. Note that this only has an effect when the `view` property is set to `cloudwatch.GraphWidgetView.PIE`.
+
+```ts
+declare const dashboard: cloudwatch.Dashboard;
+
+dashboard.addWidgets(new cloudwatch.GraphWidget({
+  // ...
+
+  view: cloudwatch.GraphWidgetView.PIE,
+  displayLabelsOnChart: true,
+}));
+```
+
 The `start` and `end` properties can be used to specify the time range for each graph widget independently from those of the dashboard.
 The parameters can be specified at `GraphWidget`, `GaugeWidget`, and `SingleValueWidget`.
 
@@ -790,6 +869,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.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-cloudwatch/integ.dashboard-with-graphwidget-with-labels-visible.ts

@@ -0,0 +1,92 @@
+import { App, Stack, StackProps } from 'aws-cdk-lib';
+import {
+  Dashboard,
+  GraphWidget,
+  GraphWidgetProps,
+  GraphWidgetView,
+  Metric,
+  Shading,
+  Stats,
+  VerticalShading,
+} from 'aws-cdk-lib/aws-cloudwatch';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+class DashboardWithGraphWidgetWithLabelsVisibleIntegrationTest extends Stack {
+  constructor(scope: App, id: string, props?: StackProps) {
+    super(scope, id, props);
+    const dashboard = new Dashboard(this, 'Dash');
+    const metrics = [
+      new Metric({
+        namespace: 'CDK/Test',
+        metricName: 'Metric',
+        label: 'Metric left 1 - p99',
+        statistic: Stats.p(99),
+      }),
+
+      new Metric({
+        namespace: 'CDK/Test',
+        metricName: 'Metric',
+        label: 'Metric left 2 - TC_10P_90P',
+        statistic: Stats.tc(10, 90),
+      }),
+
+      new Metric({
+        namespace: 'CDK/Test',
+        metricName: 'Metric',
+        label: 'Metric left 3 - TS(5%:95%)',
+        statistic: 'TS(5%:95%)',
+      }),
+    ];
+
+    const widgetProps: GraphWidgetProps = {
+      title: 'My fancy graph',
+      left: metrics,
+      right: [],
+      view: GraphWidgetView.PIE,
+      leftAnnotations: [
+        {
+          value: 10,
+          label: 'Left annotation',
+          color: '#00ff00',
+          fill: Shading.ABOVE,
+          visible: true,
+        },
+      ],
+      rightAnnotations: [
+        {
+          value: 20,
+          label: 'Right annotation',
+          color: '#e30d0d',
+          fill: Shading.BELOW,
+          visible: false,
+        },
+      ],
+      verticalAnnotations: [
+        {
+          date: '2023-08-20T00:00:00.000Z',
+          label: 'Vertical annotation',
+          color: '#2556f6',
+          fill: VerticalShading.AFTER,
+          visible: true,
+        },
+      ],
+    };
+
+    dashboard.addWidgets(
+      new GraphWidget({
+        ...widgetProps,
+        displayLabelsOnChart: true,
+      }),
+      new GraphWidget({
+        ...widgetProps,
+        displayLabelsOnChart: false,
+      }),
+      new GraphWidget(widgetProps),
+    );
+  }
+}
+
+const app = new App();
+new IntegTest(app, 'cdk-integ-dashboard-with-graph-widget-with-annotations', {
+  testCases: [new DashboardWithGraphWidgetWithLabelsVisibleIntegrationTest(app, 'DashboardWithGraphWidgetWithLabelsVisibleIntegrationTest')],
+});

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-cloudwatch/integ.search-expression.ts

@@ -0,0 +1,51 @@
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as cdk from 'aws-cdk-lib';
+import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
+
+class SearchExpressionStack extends cdk.Stack {
+  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    const minimalSearchExpression = new cloudwatch.SearchExpression({
+      expression: "SEARCH('{AWS/EC2,InstanceId} CPUUtilization', 'Average', 300)",
+    });
+
+    const customSearchExpression = new cloudwatch.SearchExpression({
+      expression: "SEARCH('{AWS/Lambda,FunctionName} Duration', 'Average', 300)",
+      label: 'Custom Lambda Duration',
+      color: '#e377c2',
+      period: cdk.Duration.minutes(10),
+      searchAccount: '123456789012',
+      searchRegion: 'us-west-2',
+    });
+
+    const crossAccountRegionSearchExpression = new cloudwatch.SearchExpression({
+      expression: "SEARCH('{AWS/S3,BucketName} BucketSizeBytes', 'Average', 86400)",
+      label: 'Cross-Account Cross-Region S3',
+      color: '#9467bd',
+      period: cdk.Duration.hours(1),
+      searchAccount: '123456789012',
+      searchRegion: 'ap-southeast-1',
+    });
+
+    const dashboard = new cloudwatch.Dashboard(this, 'SearchExpressionDashboard', {
+      dashboardName: 'SearchExpressionTestDashboard',
+    });
+
+    const searchExpressionWidget = new cloudwatch.GraphWidget({
+      title: 'Minimal vs Custom Properties',
+      width: 24,
+      height: 6,
+      left: [minimalSearchExpression],
+      right: [customSearchExpression, crossAccountRegionSearchExpression],
+    });
+
+    dashboard.addWidgets(searchExpressionWidget);
+  }
+}
+
+const app = new cdk.App();
+
+new IntegTest(app, 'SearchExpressionIntegTest', {
+  testCases: [new SearchExpressionStack(app, 'SearchExpressionStack')],
+});

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
 
@@ -312,6 +376,7 @@ can use the `environment` property to customize the build environment:
   details on how to define build images.
 * `certificate` defines the location of a PEM encoded certificate to import.
 * `computeType` defines the instance type used for the build.
+* `dockerServer` defines the docker server used for the build.
 * `privileged` can be set to `true` to allow privileged access.
 * `environmentVariables` can be set at this level (and also at the project
   level).
@@ -512,6 +577,81 @@ 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,
+});
+```
+
 ## 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-docker-server.ts

@@ -0,0 +1,44 @@
+import { App, Stack } from 'aws-cdk-lib';
+import { Project, BuildSpec, DockerServerComputeType, Source, ComputeType } from 'aws-cdk-lib/aws-codebuild';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+
+const app = new App();
+const stack = new Stack(app, 'codebuild-project-docker-server');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { restrictDefaultSecurityGroup: false });
+const sg = new ec2.SecurityGroup(stack, 'SecurityGroup', { vpc });
+
+const project = new Project(stack, 'MyProject', {
+  source: Source.gitHub({
+    owner: 'dockersamples',
+    repo: 'helloworld-demo-python',
+  }),
+  buildSpec: BuildSpec.fromObject({
+    version: '0.2',
+    phases: {
+      build: {
+        commands: [
+          'cd sample',
+          'docker buildx build .',
+        ],
+      },
+    },
+  }),
+  environment: {
+    computeType: ComputeType.SMALL,
+    dockerServer: {
+      computeType: DockerServerComputeType.SMALL,
+      securityGroups: [sg],
+    },
+  },
+});
+
+const integ = new IntegTest(app, 'codebuild-project-docker-server-integ', {
+  testCases: [stack],
+});
+
+// Execute the `startBuild` API to confirm that the build can be done correctly.
+integ.assertions.awsApiCall('CodeBuild', 'startBuild', {
+  projectName: project.projectName,
+}).waitForAssertions();