Namespace Amazon.CDK.AppDelivery
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:
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:
┏━━━━━━━━━━━━━━━━┓ ┏━━━━━━━━━━━━━━━━┓ ┏━━━━━━━━━━━━━━━━━┓ ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Source ┃ ┃ Build ┃ ┃ Self-Update ┃ ┃ Deploy ┃
┃ ┃ ┃ ┃ ┃ ┃ ┃ ┃
┃ ┌────────────┐ ┃ ┃ ┌────────────┐ ┃ ┃ ┌─────────────┐ ┃ ┃ ┌─────────────┐ ┌─────────────┐ ┃
┃ │ GitHub ┣━╋━━╋━▶ CodeBuild ┣━╋━━╋━▶Deploy Stack ┣━╋━━╋━▶Deploy Stack ┣━▶Deploy Stack │ ┃
┃ │ │ ┃ ┃ │ │ ┃ ┃ │PipelineStack│ ┃ ┃ │ServiceStackA│ │ServiceStackB│ ┃
┃ └────────────┘ ┃ ┃ └────────────┘ ┃ ┃ └─────────────┘ ┃ ┃ └─────────────┘ └─────────────┘ ┃
┗━━━━━━━━━━━━━━━━┛ ┗━━━━━━━━━━━━━━━━┛ ┗━━━━━━━━━━━━━━━━━┛ ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
index.ts
using Amazon.CDK.AWS.CodeBuild;
using Amazon.CDK.AWS.CodePipeline;
using Amazon.CDK.AWS.CodePipeline.Actions;
using Amazon.CDK;
using Amazon.CDK.AppDelivery;
using Amazon.CDK.AWS.IAM;
class MyServiceStackA : Stack
{
}
class MyServiceStackB : Stack
{
}
var app = new App();
// We define a stack that contains the CodePipeline
var pipelineStack = new Stack(app, "PipelineStack");
var 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
var sourceOutput = new Artifact();
var source = new GitHubSourceAction(new GitHubSourceActionProps {
ActionName = "GitHub",
Output = sourceOutput,
Owner = "myName",
Repo = "myRepo",
OauthToken = SecretValue.UnsafePlainText("secret")
});
pipeline.AddStage(new StageOptions {
StageName = "source",
Actions = new [] { source }
});
var project = new PipelineProject(pipelineStack, "CodeBuild", new PipelineProjectProps { });
var synthesizedApp = new Artifact();
var buildAction = new CodeBuildAction(new CodeBuildActionProps {
ActionName = "CodeBuild",
Project = project,
Input = sourceOutput,
Outputs = new [] { synthesizedApp }
});
pipeline.AddStage(new StageOptions {
StageName = "build",
Actions = new [] { buildAction }
});
// Optionally, self-update the pipeline stack
var selfUpdateStage = pipeline.AddStage(new StageOptions { StageName = "SelfUpdate" });
selfUpdateStage.AddAction(new PipelineDeployStackAction(new PipelineDeployStackActionProps {
Stack = pipelineStack,
Input = synthesizedApp,
AdminPermissions = true
}));
// Now add our service stacks
var deployStage = pipeline.AddStage(new StageOptions { StageName = "Deploy" });
var serviceStackA = new MyServiceStackA(app, "ServiceStackA", new StackProps { });
// Add actions to deploy the stacks in the deploy stage:
var 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.
var myResourceArn = "arn:partition:service:region:account-id:resource-id";
deployServiceAAction.AddToDeploymentRolePolicy(new PolicyStatement(new PolicyStatementProps {
Actions = new [] { "service:SomeAction" },
Resources = new [] { myResourceArn }
}));
var serviceStackB = new MyServiceStackB(app, "ServiceStackB", new StackProps { });
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>
.
Classes
PipelineDeployStackAction | (deprecated) A class to deploy a stack that is part of a CDK App, using CodePipeline. |
PipelineDeployStackActionProps |
Interfaces
IPipelineDeployStackActionProps |