Interface Summary
Interface Description

PipelineDeployStackActionProps

Interface Summary
Interface	Description
PipelineDeployStackActionProps

Class Summary
Class	Description
PipelineDeployStackAction	(experimental) A class to deploy a stack that is part of a CDK App, using CodePipeline.
PipelineDeployStackAction.Builder	(experimental) A fluent builder for `PipelineDeployStackAction`.
PipelineDeployStackActionProps.Builder	A builder for `PipelineDeployStackActionProps`
PipelineDeployStackActionProps.Jsii$Proxy	An implementation for `PipelineDeployStackActionProps`

Package software.amazon.awscdk.appdelivery Description

Continuous Integration / Continuous Delivery for CDK Applications

---

This API may emit warnings. Backward compatibility is not guaranteed.

This library includes a CodePipeline composite Action for deploying AWS CDK Applications.

This module is part of the AWS Cloud Development Kit project.

Replacement recommended

This library has been deprecated. We recommend you use the @aws-cdk/pipelines module instead.

Limitations

The construct library in it's current form has the following limitations:

It can only deploy stacks that are hosted in the same AWS account and region as the CodePipeline is.
Stacks that make use of Assets cannot be deployed successfully.

Getting Started

In order to add the PipelineDeployStackAction to your CodePipeline, you need to have a CodePipeline artifact that contains the result of invoking cdk synth -o <dir> on your CDK App. You can for example achieve this using a CodeBuild project.

The example below defines a CDK App that contains 3 stacks:

CodePipelineStack manages the CodePipeline resources, and self-updates before deploying any other stack
ServiceStackA and ServiceStackB are service infrastructure stacks, and need to be deployed in this order

   ┏━━━━━━━━━━━━━━━━┓  ┏━━━━━━━━━━━━━━━━┓  ┏━━━━━━━━━━━━━━━━━┓  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
   ┃     Source     ┃  ┃     Build      ┃  ┃  Self-Update    ┃  ┃             Deploy              ┃
   ┃                ┃  ┃                ┃  ┃                 ┃  ┃                                 ┃
   ┃ ┌────────────┐ ┃  ┃ ┌────────────┐ ┃  ┃ ┌─────────────┐ ┃  ┃ ┌─────────────┐ ┌─────────────┐ ┃
   ┃ │   GitHub   ┣━╋━━╋━▶ CodeBuild  ┣━╋━━╋━▶Deploy Stack ┣━╋━━╋━▶Deploy Stack ┣━▶Deploy Stack │ ┃
   ┃ │            │ ┃  ┃ │            │ ┃  ┃ │PipelineStack│ ┃  ┃ │ServiceStackA│ │ServiceStackB│ ┃
   ┃ └────────────┘ ┃  ┃ └────────────┘ ┃  ┃ └─────────────┘ ┃  ┃ └─────────────┘ └─────────────┘ ┃
   ┗━━━━━━━━━━━━━━━━┛  ┗━━━━━━━━━━━━━━━━┛  ┗━━━━━━━━━━━━━━━━━┛  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

`index.ts`

 // Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
 import software.amazon.awscdk.services.codebuild.*;
 import software.amazon.awscdk.services.codepipeline.*;
 import software.amazon.awscdk.services.codepipeline.actions.*;
 import software.amazon.awscdk.core.*;
 import software.amazon.awscdk.appdelivery.*;
 
 App app = new App();
 
 // We define a stack that contains the CodePipeline
 Stack pipelineStack = new Stack(app, "PipelineStack");
 Pipeline pipeline = new Pipeline(pipelineStack, "CodePipeline", new PipelineProps()
         // Mutating a CodePipeline can cause the currently propagating state to be
         // "lost". Ensure we re-run the latest change through the pipeline after it's
         // been mutated so we're sure the latest state is fully deployed through.
         .restartExecutionOnUpdate(true));
 
 // Configure the CodePipeline source - where your CDK App's source code is hosted
 Artifact sourceOutput = new Artifact();
 GitHubSourceAction source = new GitHubSourceAction(new GitHubSourceActionProps()
         .actionName("GitHub")
         .output(sourceOutput));
 pipeline.addStage(new StageOptions()
         .stageName("source")
         .actions(asList(source)));
 
 PipelineProject project = new PipelineProject(pipelineStack, "CodeBuild", new PipelineProjectProps());
 Artifact synthesizedApp = new Artifact();
 CodeBuildAction buildAction = new CodeBuildAction(new CodeBuildActionProps()
         .actionName("CodeBuild")
         .project(project)
         .input(sourceOutput)
         .outputs(asList(synthesizedApp)));
 pipeline.addStage(new StageOptions()
         .stageName("build")
         .actions(asList(buildAction)));
 
 // Optionally, self-update the pipeline stack
 IStage selfUpdateStage = pipeline.addStage(new StageOptions().stageName("SelfUpdate"));
 selfUpdateStage.addAction(new PipelineDeployStackAction(new PipelineDeployStackActionProps()
         .stack(pipelineStack)
         .input(synthesizedApp)
         .adminPermissions(true)));
 
 // Now add our service stacks
 IStage deployStage = pipeline.addStage(new StageOptions().stageName("Deploy"));
 Object serviceStackA = MyServiceStackA.Builder.create(app, "ServiceStackA").build();
 // Add actions to deploy the stacks in the deploy stage:
 PipelineDeployStackAction deployServiceAAction = new PipelineDeployStackAction(new PipelineDeployStackActionProps()
         .stack(serviceStackA)
         .input(synthesizedApp)
         // See the note below for details about this option.
         .adminPermissions(false));
 deployStage.addAction(deployServiceAAction);
 // Add the necessary permissions for you service deploy action. This role is
 // is passed to CloudFormation and needs the permissions necessary to deploy
 // stack. Alternatively you can enable [Administrator](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html#jf_administrator) permissions above,
 // users should understand the privileged nature of this role.
 deployServiceAAction.addToRolePolicy(PolicyStatement.Builder.create()
         .actions(asList("service:SomeAction"))
         .resources(asList(myResource.getMyResourceArn()))
         .build());
 
 Object serviceStackB = MyServiceStackB.Builder.create(app, "ServiceStackB").build();
 deployStage.addAction(new PipelineDeployStackAction(new PipelineDeployStackActionProps()
         .stack(serviceStackB)
         .input(synthesizedApp)
         .createChangeSetRunOrder(998)
         .adminPermissions(true)));

`buildspec.yml`

The repository can contain a file at the root level named buildspec.yml, or you can in-line the buildspec. Note that buildspec.yaml is not compatible.

For example, a TypeScript or Javascript CDK App can add the following buildspec.yml at the root of the repository:

 version: 0.2
 phases:
   install:
     commands:
       # Installs the npm dependencies as defined by the `package.json` file
       # present in the root directory of the package
       # (`cdk init app --language=typescript` would have created one for you)
       - npm install
   build:
     commands:
       # Builds the CDK App so it can be synthesized
       - npm run build
       # Synthesizes the CDK App and puts the resulting artifacts into `dist`
       - npm run cdk synth -- -o dist
 artifacts:
   # The output artifact is all the files in the `dist` directory
   base-directory: dist
   files: '** /*'

The PipelineDeployStackAction expects it's input to contain the result of synthesizing a CDK App using the cdk synth -o <directory>.