konokenj.cdk-api-mcp-server 0.26.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-apigateway/integ.model-schema-additional-items.ts

@@ -0,0 +1,72 @@
+import * as cdk from 'aws-cdk-lib';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as apigateway from 'aws-cdk-lib/aws-apigateway';
+
+class TestStack extends cdk.Stack {
+  constructor(scope: cdk.App, id: string) {
+    super(scope, id);
+
+    const api = new apigateway.RestApi(this, 'model-schema-api', {
+      restApiName: 'Model Schema Test API',
+    });
+
+    // Create a minimal schema that uses additionalItems
+    const schema: apigateway.JsonSchema = {
+      type: apigateway.JsonSchemaType.OBJECT,
+      required: ['tags'],
+      properties: {
+        tags: {
+          type: apigateway.JsonSchemaType.ARRAY,
+          items: [
+            { type: apigateway.JsonSchemaType.STRING, enum: ['primary'] },
+            { type: apigateway.JsonSchemaType.STRING, enum: ['secondary'] },
+          ],
+          additionalItems: {
+            type: apigateway.JsonSchemaType.STRING,
+            pattern: '^[a-z0-9-]+$',
+          },
+          minItems: 1,
+          maxItems: 5,
+        },
+      },
+    };
+
+    // Create the model using our schema
+    const model = api.addModel('TagsModel', {
+      contentType: 'application/json',
+      modelName: 'Tags',
+      schema: schema,
+    });
+
+    // Add a validator that requires the request body to match our model
+    const validator = api.addRequestValidator('TagsValidator', {
+      requestValidatorName: 'TagsValidator',
+      validateRequestBody: true,
+    });
+
+    // Add a POST method that uses the model and validator
+    api.root.addMethod('POST', new apigateway.MockIntegration({
+      integrationResponses: [{
+        statusCode: '200',
+      }],
+      requestTemplates: {
+        'application/json': '{ "statusCode": 200 }',
+      },
+    }), {
+      requestValidator: validator,
+      requestModels: {
+        'application/json': model,
+      },
+      methodResponses: [{
+        statusCode: '200',
+      }],
+    });
+  }
+}
+
+const app = new cdk.App();
+const stack = new TestStack(app, 'model-schema-additional-items-test');
+new IntegTest(app, 'ModelSchemaAdditionalItemsTest', {
+  testCases: [stack],
+});
+app.synth();

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

@@ -1247,6 +1247,14 @@ new cloudfront.KeyGroup(this, 'MyKeyGroup', {
 });
 ```
 
+When using a CloudFront PublicKey, only the `comment` field can be updated after creation. Fields such as `encodedKey` and `publicKeyName` are immutable, as outlined in the [API Reference](https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdatePublicKey.html). Attempting to modify these fields will result in an error:
+```
+Resource handler returned message: "Invalid request provided: AWS::CloudFront::PublicKey"
+```
+
+To update the `encodedKey`, you must change the logical ID of the public key resource in your template. This causes CloudFormation to create a new `cloudfront.PublicKey` resource and delete the old one during the next deployment.
+
+
 See:
 
 - <https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/PrivateContent.html>

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront/integ.distribution-basic.ts

@@ -18,7 +18,7 @@ const role2 = new iam.Role(stack, 'Role2', {
   assumedBy: new iam.AccountRootPrincipal(),
 });
 distribution.grantCreateInvalidation(role1);
-distribution.grant(role2, 'cloudfront:ListInvalidations');
+distribution.grant(role2, 'cloudfront:ListInvalidations', 'cloudfront:ListDistributions');
 
 new IntegTest(stack, 'distribution-basic-test', {
   testCases: [stack],

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codedeploy/integ.deployment-config.ts

@@ -2,17 +2,28 @@ import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as codedeploy from 'aws-cdk-lib/aws-codedeploy';
 
-const app = new cdk.App();
-const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-ecs-config');
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-lambda-config');
 
-new codedeploy.EcsDeploymentConfig(stack, 'LinearConfig', {
+new codedeploy.LambdaDeploymentConfig(stack, 'LinearConfig', {
   trafficRouting: codedeploy.TrafficRouting.timeBasedLinear({
     interval: cdk.Duration.minutes(1),
     percentage: 5,
   }),
 });
 
-new integ.IntegTest(app, 'EcsDeploymentConfigTest', {
+new codedeploy.CustomLambdaDeploymentConfig(stack, 'CustomConfig', {
+  interval: cdk.Duration.minutes(1),
+  percentage: 5,
+  type: cdk.aws_codedeploy.CustomLambdaDeploymentConfigType.LINEAR,
+  deploymentConfigName: 'hello',
+});
+
+new integ.IntegTest(app, 'LambdaDeploymentConfigTest', {
   testCases: [stack],
 });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codedeploy/integ.deployment-group.ts

@@ -1,240 +1,62 @@
+import * as path from 'path';
 import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
-import * as ec2 from 'aws-cdk-lib/aws-ec2';
-import * as ecs from 'aws-cdk-lib/aws-ecs';
-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 integ from '@aws-cdk/integ-tests-alpha';
 import * as codedeploy from 'aws-cdk-lib/aws-codedeploy';
+import { STANDARD_NODEJS_RUNTIME } from '../../../config';
 
-/**
- * Follow these instructions to manually test running a CodeDeploy deployment with the resources provisioned in this stack:
- *
- * 1. Deploy the stack:
-```
-$ cdk deploy --app 'node integ.deployment-group.js' aws-cdk-codedeploy-ecs-dg
-```
- *
- * 2. Create a file called `appspec.json` with the following contents, replacing the placeholders with output values from the deployed stack:
-```
-{
-  "version": 0.0,
-  "Resources": [
-    {
-      "TargetService": {
-        "Type": "AWS::ECS::Service",
-        "Properties": {
-          "TaskDefinition": "<PLACEHOLDER - NEW TASK DEFINITION>",
-          "LoadBalancerInfo": {
-            "ContainerName": "Container",
-            "ContainerPort": 80
-          },
-          "PlatformVersion": "LATEST",
-          "NetworkConfiguration": {
-            "awsvpcConfiguration": {
-              "subnets": [
-                "<PLACEHOLDER - SUBNET 1 ID>",
-                "<PLACEHOLDER - SUBNET 2 ID>",
-              ],
-              "securityGroups": [
-                "<PLACEHOLDER - SECURITY GROUP ID>"
-              ],
-              "assignPublicIp": "DISABLED"
-            }
-          }
-        }
-      }
-    }
-  ]
-}
-```
- *
- * 3. Start the deployment:
-```
-$ appspec=$(jq -R -s '.' < appspec.json | sed 's/\\n//g')
-$ aws deploy create-deployment \
-   --application-name <PLACEHOLDER - CODEDEPLOY APPLICATION NAME> \
-   --deployment-group-name <PLACEHOLDER - CODEDEPLOY DEPLOYMENT GROUP NAME> \
-   --description "AWS CDK integ test" \
-   --revision revisionType=AppSpecContent,appSpecContent={content="$appspec"}
-```
- *
- * 4. Wait for the deployment to complete successfully, providing the deployment ID from the previous step:
-```
-$ aws deploy wait deployment-successful --deployment-id <PLACEHOLDER - DEPLOYMENT ID>
-```
- *
- * 5. Destroy the stack:
-```
-$ cdk destroy --app 'node integ.deployment-group.js' aws-cdk-codedeploy-ecs-dg
-```
- */
-
-const app = new cdk.App();
-const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-ecs-dg');
-
-// Network infrastructure
-const vpc = new ec2.Vpc(stack, 'VPC', { maxAzs: 2, restrictDefaultSecurityGroup: false });
-
-// ECS service
-const cluster = new ecs.Cluster(stack, 'EcsCluster', {
-  vpc,
-});
-const taskDefinition = new ecs.FargateTaskDefinition(stack, 'TaskDef');
-taskDefinition.addContainer('Container', {
-  image: ecs.ContainerImage.fromRegistry('public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest'),
-  portMappings: [{ containerPort: 80 }],
-});
-const service = new ecs.FargateService(stack, 'FargateService', {
-  cluster,
-  taskDefinition,
-  deploymentController: {
-    type: ecs.DeploymentControllerType.CODE_DEPLOY,
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
   },
 });
+const stack = new cdk.Stack(app, 'aws-cdk-codedeploy-lambda');
 
-// A second task definition for testing a CodeDeploy deployment of the ECS service to a new task definition
-const taskDefinition2 = new ecs.FargateTaskDefinition(stack, 'TaskDef2');
-taskDefinition2.addContainer('Container', {
-  image: ecs.ContainerImage.fromRegistry('public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest'),
-  portMappings: [{ containerPort: 80 }],
+const handler = new lambda.Function(stack, 'Handler', {
+  code: lambda.Code.fromAsset(path.join(__dirname, 'handler')),
+  handler: 'index.handler',
+  runtime: STANDARD_NODEJS_RUNTIME,
 });
-service.node.addDependency(taskDefinition2);
-
-// Load balancer
-const loadBalancer = new elbv2.ApplicationLoadBalancer(stack, 'ServiceLB', {
-  vpc,
-  internetFacing: false,
+const version = handler.currentVersion;
+const blueGreenAlias = new lambda.Alias(stack, 'Alias', {
+  aliasName: 'alias',
+  version,
 });
 
-// Listeners
-const prodListener = loadBalancer.addListener('ProdListener', {
-  port: 80, // port for production traffic
-  protocol: elbv2.ApplicationProtocol.HTTP,
+const preHook = new lambda.Function(stack, 'PreHook', {
+  code: lambda.Code.fromAsset(path.join(__dirname, 'preHook')),
+  handler: 'index.handler',
+  runtime: STANDARD_NODEJS_RUNTIME,
 });
-const testListener = loadBalancer.addListener('TestListener', {
-  port: 9002, // port for testing
-  protocol: elbv2.ApplicationProtocol.HTTP,
+const postHook = new lambda.Function(stack, 'PostHook', {
+  code: lambda.Code.fromAsset(path.join(__dirname, 'postHook')),
+  handler: 'index.handler',
+  runtime: STANDARD_NODEJS_RUNTIME,
 });
 
-// Target groups
-const blueTG = prodListener.addTargets('BlueTG', {
-  port: 80,
-  protocol: elbv2.ApplicationProtocol.HTTP,
-  targets: [
-    service.loadBalancerTarget({
-      containerName: 'Container',
-      containerPort: 80,
+new codedeploy.LambdaDeploymentGroup(stack, 'BlueGreenDeployment', {
+  alias: blueGreenAlias,
+  deploymentConfig: codedeploy.LambdaDeploymentConfig.LINEAR_10PERCENT_EVERY_1MINUTE,
+  alarms: [
+    new cloudwatch.Alarm(stack, 'BlueGreenErrors', {
+      comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+      threshold: 1,
+      evaluationPeriods: 1,
+      metric: blueGreenAlias.metricErrors(),
     }),
   ],
-  deregistrationDelay: cdk.Duration.seconds(30),
-  healthCheck: {
-    interval: cdk.Duration.seconds(5),
-    healthyHttpCodes: '200',
-    healthyThresholdCount: 2,
-    unhealthyThresholdCount: 3,
-    timeout: cdk.Duration.seconds(4),
-  },
+  preHook,
+  postHook,
 });
 
-const greenTG = new elbv2.ApplicationTargetGroup(stack, 'GreenTG', {
-  vpc,
-  port: 80,
-  protocol: elbv2.ApplicationProtocol.HTTP,
-  targetType: elbv2.TargetType.IP,
-  deregistrationDelay: cdk.Duration.seconds(30),
-  healthCheck: {
-    interval: cdk.Duration.seconds(5),
-    healthyHttpCodes: '200',
-    healthyThresholdCount: 2,
-    unhealthyThresholdCount: 3,
-    timeout: cdk.Duration.seconds(4),
-  },
-});
-
-testListener.addTargetGroups('GreenTGTest', {
-  targetGroups: [greenTG],
+const secondAlias = new lambda.Alias(stack, 'SecondAlias', {
+  aliasName: 'secondAlias',
+  version,
 });
 
-prodListener.node.addDependency(greenTG);
-testListener.node.addDependency(blueTG);
-service.node.addDependency(testListener);
-service.node.addDependency(greenTG);
-
-// Alarms: monitor 500s and unhealthy hosts on target groups
-const blueUnhealthyHosts = new cloudwatch.Alarm(stack, 'BlueUnhealthyHosts', {
-  alarmName: stack.stackName + '-Unhealthy-Hosts-Blue',
-  metric: blueTG.metricUnhealthyHostCount(),
-  threshold: 1,
-  evaluationPeriods: 2,
-});
-
-const blueApiFailure = new cloudwatch.Alarm(stack, 'Blue5xx', {
-  alarmName: stack.stackName + '-Http-500-Blue',
-  metric: blueTG.metricHttpCodeTarget(
-    elbv2.HttpCodeTarget.TARGET_5XX_COUNT,
-    { period: cdk.Duration.minutes(1) },
-  ),
-  threshold: 1,
-  evaluationPeriods: 1,
-});
-
-const greenUnhealthyHosts = new cloudwatch.Alarm(stack, 'GreenUnhealthyHosts', {
-  alarmName: stack.stackName + '-Unhealthy-Hosts-Green',
-  metric: greenTG.metricUnhealthyHostCount(),
-  threshold: 1,
-  evaluationPeriods: 2,
-});
-
-const greenApiFailure = new cloudwatch.Alarm(stack, 'Green5xx', {
-  alarmName: stack.stackName + '-Http-500-Green',
-  metric: greenTG.metricHttpCodeTarget(
-    elbv2.HttpCodeTarget.TARGET_5XX_COUNT,
-    { period: cdk.Duration.minutes(1) },
-  ),
-  threshold: 1,
-  evaluationPeriods: 1,
-});
-
-// Deployment group
-const deploymentConfig = new codedeploy.EcsDeploymentConfig(stack, 'CanaryConfig', {
-  trafficRouting: codedeploy.TrafficRouting.timeBasedCanary({
-    interval: cdk.Duration.minutes(1),
-    percentage: 20,
-  }),
-});
-
-const dg = new codedeploy.EcsDeploymentGroup(stack, 'BlueGreenDG', {
-  alarms: [
-    blueUnhealthyHosts,
-    blueApiFailure,
-    greenUnhealthyHosts,
-    greenApiFailure,
-  ],
-  service,
-  blueGreenDeploymentConfig: {
-    blueTargetGroup: blueTG,
-    greenTargetGroup: greenTG,
-    listener: prodListener,
-    testListener,
-    terminationWaitTime: cdk.Duration.minutes(1),
-  },
-  deploymentConfig,
-  autoRollback: {
-    stoppedDeployment: true,
-  },
-  ignoreAlarmConfiguration: true,
-});
-
-// Outputs to use for manual testing
-new cdk.CfnOutput(stack, 'NewTaskDefinition', { value: taskDefinition2.taskDefinitionArn });
-new cdk.CfnOutput(stack, 'Subnet1Id', { value: vpc.privateSubnets[0].subnetId });
-new cdk.CfnOutput(stack, 'Subnet2Id', { value: vpc.privateSubnets[1].subnetId });
-new cdk.CfnOutput(stack, 'SecurityGroupId', { value: service.connections.securityGroups[0].securityGroupId });
-new cdk.CfnOutput(stack, 'CodeDeployApplicationName', { value: dg.application.applicationName });
-new cdk.CfnOutput(stack, 'CodeDeployDeploymentGroupName', { value: dg.deploymentGroupName });
-
-new integ.IntegTest(app, 'EcsDeploymentGroupTest', {
-  testCases: [stack],
+new codedeploy.LambdaDeploymentGroup(stack, 'SecondDeployment', {
+  alias: secondAlias,
+  deploymentConfig: codedeploy.LambdaDeploymentConfig.CANARY_10PERCENT_5MINUTES,
 });
 
 app.synth();

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

@@ -927,6 +927,40 @@ Here's an example:
 
 [example ECS pipeline for an application in a separate source code repository](test/integ.pipeline-ecs-separate-source.lit.ts)
 
+### Amazon EC2
+
+To deploy application code to Amazon EC2 Linux instances or Linux SSM-managed nodes:
+
+> **Note**
+> This action is only supported for V2 type pipelines.
+
+```ts
+const sourceOutput = new codepipeline.Artifact();
+
+const pipeline = new codepipeline.Pipeline(this, 'MyPipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+});
+const deployAction = new codepipeline_actions.Ec2DeployAction({
+  actionName: 'Ec2Deploy',
+  input: sourceOutput,
+  instanceType: codepipeline_actions.Ec2InstanceType.EC2,
+  instanceTagKey: 'Name',
+  instanceTagValue: 'MyInstance',
+  deploySpecifications: codepipeline_actions.Ec2DeploySpecifications.inline({
+    targetDirectory: '/home/ec2-user/deploy',
+    preScript: 'scripts/pre-deploy.sh',
+    postScript: 'scripts/post-deploy.sh',
+  }),
+});
+const deployStage = pipeline.addStage({
+  stageName: 'Deploy',
+  actions: [deployAction],
+});
+```
+
+To learn more about using the EC2 deploy action in your pipeline, visit [tutorial](https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials-ec2-deploy.html) and [documentation](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-EC2Deploy.html).
+
+
 ### AWS S3 Deployment
 
 To use an S3 Bucket as a deployment target in CodePipeline:

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codepipeline-actions/integ.pipeline-ec2-deploy-ssm-managed.ts

@@ -0,0 +1,140 @@
+import * as codepipeline from 'aws-cdk-lib/aws-codepipeline';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import * as targets from 'aws-cdk-lib/aws-elasticloadbalancingv2-targets';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as s3deployment from 'aws-cdk-lib/aws-s3-deployment';
+import * as cdk from 'aws-cdk-lib';
+import * as cpactions from 'aws-cdk-lib/aws-codepipeline-actions';
+import { ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';
+import * as path from 'path';
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'aws-cdk-codepipeline-ec2-deploy-ssm-managed-node');
+
+const vpc = new ec2.Vpc(stack, 'VPC', {
+  maxAzs: 2,
+  natGateways: 0,
+  restrictDefaultSecurityGroup: false,
+});
+
+const instances = Object.fromEntries(Object.entries({ NoLB: [0, 1], LB: [0, 1] }).map(([tagValue, indexs]) => {
+  const innerInstances = indexs.map((index) => {
+    const userData = ec2.UserData.forLinux();
+    userData.addCommands('dnf install httpd -y', 'mkdir -p /var/www/html', 'touch /var/www/html/index.html', 'systemctl start httpd');
+    const instance = new ec2.Instance(stack, `Instance-${tagValue}-${index}`, {
+      vpc,
+      vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC },
+      availabilityZone: vpc.publicSubnets[index].availabilityZone,
+      machineImage: ec2.MachineImage.latestAmazonLinux2023({ cpuType: ec2.AmazonLinuxCpuType.ARM_64 }),
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE4_GRAVITON, ec2.InstanceSize.MICRO),
+      ssmSessionPermissions: true,
+      userData,
+    });
+    instance.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
+    instance.connections.allowFromAnyIpv4(ec2.Port.HTTP);
+    cdk.Tags.of(instance).add('EC2-Target', tagValue);
+    return instance;
+  });
+  return [tagValue, innerInstances];
+}));
+
+const alb = new elbv2.ApplicationLoadBalancer(stack, 'ALB', { vpc, internetFacing: true });
+const albTg = new elbv2.ApplicationTargetGroup(stack, 'ALB-TG', {
+  vpc,
+  protocol: elbv2.ApplicationProtocol.HTTP,
+  deregistrationDelay: cdk.Duration.seconds(0),
+});
+alb.addListener('HTTP', {
+  protocol: elbv2.ApplicationProtocol.HTTP,
+  defaultTargetGroups: [albTg],
+});
+alb.connections.allowToAnyIpv4(ec2.Port.HTTP);
+albTg.addTarget(...instances.LB.map((instance) => new targets.InstanceTarget(instance)));
+
+const bucket = new s3.Bucket(stack, 'ArtifactBucket', {
+  versioned: true,
+  autoDeleteObjects: true,
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+});
+instances.LB.forEach((instance) => bucket.grantRead(instance));
+instances.NoLB.forEach((instance) => bucket.grantRead(instance));
+const deployment = new s3deployment.BucketDeployment(stack, 'ArtifactDeployment', {
+  destinationBucket: bucket,
+  sources: [s3deployment.Source.asset(path.join(__dirname, 'ec2-deploy-artifacts', 'inline'))],
+  extract: false,
+});
+
+const sourceArtifact = new codepipeline.Artifact('SourceArtifact');
+const sourceAction = new cpactions.S3SourceAction({
+  actionName: 'Source',
+  output: sourceArtifact,
+  bucket,
+  bucketKey: cdk.Fn.select(0, deployment.objectKeys),
+});
+
+const pipeline = new codepipeline.Pipeline(stack, 'MyPipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+  artifactBucket: bucket,
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [sourceAction],
+    },
+    {
+      stageName: 'Deploy',
+      actions: [
+        new cpactions.Ec2DeployAction({
+          actionName: 'EC2-NoLB',
+          input: sourceArtifact,
+          instanceType: cpactions.Ec2InstanceType.SSM_MANAGED_NODE,
+          instanceTagKey: 'EC2-Target',
+          instanceTagValue: 'NoLB',
+          deploySpecifications: cpactions.Ec2DeploySpecifications.inline({
+            targetDirectory: '/var/www/html/NoLB',
+            preScript: 'scripts/pre-deploy.sh',
+            postScript: 'scripts/post-deploy.sh',
+          }),
+          maxBatch: cpactions.Ec2MaxInstances.targets(2),
+        }),
+        new cpactions.Ec2DeployAction({
+          actionName: 'EC2-LB',
+          input: sourceArtifact,
+          instanceType: cpactions.Ec2InstanceType.SSM_MANAGED_NODE,
+          instanceTagKey: 'EC2-Target',
+          instanceTagValue: 'LB',
+          deploySpecifications: cpactions.Ec2DeploySpecifications.inline({
+            targetDirectory: '/var/www/html/LB',
+            preScript: 'scripts/pre-deploy.sh',
+            postScript: 'scripts/post-deploy.sh',
+          }),
+          targetGroups: [albTg],
+          maxBatch: cpactions.Ec2MaxInstances.targets(1),
+        }),
+      ],
+    },
+  ],
+});
+
+const integ = new IntegTest(app, 'ec2-deploy-action-ssm-managed-node-integ', {
+  testCases: [stack],
+});
+
+const pipelineExecutionId = integ.assertions
+  .awsApiCall('codepipeline', 'StartPipelineExecution', { name: pipeline.pipelineName })
+  .getAttString('pipelineExecutionId');
+const waitPipelieneSuccess = integ.assertions
+  .awsApiCall('codepipeline', 'GetPipelineExecution', { pipelineName: pipeline.pipelineName, pipelineExecutionId })
+  .waitForAssertions({ interval: cdk.Duration.seconds(30) })
+  .expect(ExpectedResult.objectLike({ pipelineExecution: { status: 'Succeeded' } }));
+waitPipelieneSuccess.next(
+  integ.assertions
+    .httpApiCall(`http://${alb.loadBalancerDnsName}/LB/index.html`)
+    .expect(ExpectedResult.objectLike({ status: 200 })),
+);
+instances.NoLB.forEach((instance) => waitPipelieneSuccess.next(
+  integ.assertions
+    .httpApiCall(`http://${instance.instancePublicDnsName}/NoLB/index.html`)
+    .expect(ExpectedResult.objectLike({ status: 200 })),
+));