Convert existing CDK App into CDK Pipeline - aws-cdk

Question

Is it possible to wrap an existing CDK App into a pipeline, to have the option of creating a pipeline for the application but also doing the regular cdk deploy -all if just wanting to deploy the app locally?
Our current main app looks something like this (over simplified, but just to give idea):
const app = describeApp()
const coreStack = new CoreStack(app, 'CoreStack')
const domainConfig = new DomainConfig(app, 'DomainConfig')
...
What I would then like to do, is add something at the bottom along the lines of:
if (process.env.CREATE_PIPELINE) {
const pipelineApp = new App();
new PipelineStack(pipelineApp, 'PipelineStack', app);
}
With a PipelineStack class that effectively adds the main app as a stage to a pipeline, eg:
export class PipelineStack extends Stack {
constructor(scope: Construct, id: string, app: App, props?: StackProps) {
super(scope, id, props);
const repo = codeCommit.Repository.fromRepositoryName(this, 'Repo', 'XXX')
const pipeline = new CodePipeline(this, 'Pipeline', {
pipelineName: 'Pipeline',
synth: new CodeBuildStep('SynthStep', {
input: CodePipelineSource.codeCommit(repo, 'YYY'),
installCommands: [
'npm install -g yarn',
'cd app',
'yarn install',
'yarn global add aws-cdk'
],
commands: [
'yarn build',
'cdk synth'
]
}
)
});
pipeline.addStage(app)
}
}
This currently complains about my stage not having a stageName, but if I add the hack:
// #ts-ignore
app.stageName = 'DeployApp'
I then get errors around Error: Pipeline stack which uses cross-environment actions must have an explicitly set region.
I feel like there must be a more straightforward way of doing this, but without re-writing my main app class to ONLY allow me to deploy via this new pipeline?

Answer 1

Yes. The important point here is that "local" and "pipeline" deploys have different construct hierarchies:
local: App > (CoreStack, DomainConfig)
pipeline: App > PipelineStack > Stage > (CoreStack, DomainConfig)
Because the stacks' parent is different in each case, it's useful to wrap your app's stacks in a reusable construct. The MyService example in the docs also uses this pattern.
// AppStacks.ts
export class AppStacks extends Construct {
constructor(scope: cdk.App | cdk.Stage, id: string, props: AppStacksProps) {
super(scope, id);
const coreStack = new CoreStack(this, 'CoreStack', props)
const domainConfig = new DomainConfig(this, 'DomainConfig', props)
}
}
For *local* (cdk deploy) deploys, your stacks, wrapped in AppStacks, are children of the App:
// app.ts
const app = new App();
new AppStacks(app, 'Stacks', props);
For *pipeline* deploys, your stacks are children of a Stage, and the Stage is added to the Pipeline.
// DeployStage.ts
export class DeployStage extends cdk.Stage {
constructor(scope: Construct, id: string, props: DeployStageProps) {
super(scope, id, { ...props, env: props.config.env });
new AppStacks(this, 'Stacks', props);
}
}
// app-pipeline.ts
const app = new App();
new PipelineStack(app, 'Pipeline', props); // add the stage: pipeline.addStage(new DeployStage...)
I prefer to put my pipeline app setup in a separate file. But you could also have one "app" file with conditional logic, as in the OP.