feat(codedeploy): CodeDeploy deployment config constructs for Lambda and ECS

packages/@aws-cdk/aws-codedeploy/README.md

@@ -15,7 +15,7 @@ AWS CodeDeploy is a deployment service that automates application deployments to
 Amazon EC2 instances, on-premises instances, serverless Lambda functions, or
 Amazon ECS services.
 
-The CDK currently supports Amazon EC2, on-premise and AWS Lambda applications.
+The CDK currently supports Amazon EC2, on-premise, AWS Lambda, and Amazon ECS applications.
 
 ## EC2/on-premise Applications
 
@@ -143,7 +143,7 @@ const deploymentGroup = new codedeploy.ServerDeploymentGroup(this, 'DeploymentGr
 });
 ```
 
-## Deployment Configurations
+## EC2/on-premise Deployment Configurations
 
 You can also pass a Deployment Configuration when creating the Deployment Group:
 
@@ -226,41 +226,6 @@ In order to deploy a new version of this function:
 2. Re-deploy the stack (this will trigger a deployment).
 3. Monitor the CodeDeploy deployment as traffic shifts between the versions.
 
-
-### Create a custom Deployment Config
-
-CodeDeploy for Lambda comes with built-in configurations for traffic shifting.
-If you want to specify your own strategy,
-you can do so with the CustomLambdaDeploymentConfig construct,
-letting you specify precisely how fast a new function version is deployed.
-
-```ts
-const config = new codedeploy.CustomLambdaDeploymentConfig(this, 'CustomConfig', {
-  type: codedeploy.CustomLambdaDeploymentConfigType.CANARY,
-  interval: Duration.minutes(1),
-  percentage: 5,
-});
-
-declare const application: codedeploy.LambdaApplication;
-declare const alias: lambda.Alias;
-const deploymentGroup = new codedeploy.LambdaDeploymentGroup(this, 'BlueGreenDeployment', {
-  application,
-  alias,
-  deploymentConfig: config,
-});
-```
-
-You can specify a custom name for your deployment config, but if you do you will not be able to update the interval/percentage through CDK.
-
-```ts
-const config = new codedeploy.CustomLambdaDeploymentConfig(this, 'CustomConfig', {
-  type: codedeploy.CustomLambdaDeploymentConfigType.CANARY,
-  interval: Duration.minutes(1),
-  percentage: 5,
-  deploymentConfigName: 'MyDeploymentConfig',
-});
-```
-
 ### Rollbacks and Alarms
 
 CodeDeploy will roll back if the deployment fails. You can optionally trigger a rollback when one or more alarms are in a failed state:
@@ -327,3 +292,127 @@ const deploymentGroup = codedeploy.LambdaDeploymentGroup.fromLambdaDeploymentGro
   deploymentGroupName: 'MyExistingDeploymentGroup',
 });
 ```
+
+## Lambda Deployment Configurations
+
+CodeDeploy for Lambda comes with predefined configurations for traffic shifting.
+The predefined configurations are available as LambdaDeploymentConfig constants.
+
+```ts
+const config = codedeploy.LambdaDeploymentConfig.CANARY_10PERCENT_30MINUTES;
+
+declare const application: codedeploy.LambdaApplication;
+declare const alias: lambda.Alias;
+const deploymentGroup = new codedeploy.LambdaDeploymentGroup(this, 'BlueGreenDeployment', {
+  application,
+  alias,
+  deploymentConfig: config,
+});
+```
+
+If you want to specify your own strategy,
+you can do so with the LambdaDeploymentConfig construct,
+letting you specify precisely how fast a new function version is deployed.
+
+```ts
+const config = new codedeploy.LambdaDeploymentConfig(this, 'CustomConfig', {
+  trafficRoutingConfig: new codedeploy.TimeBasedCanaryTrafficRoutingConfig({
+    interval: cdk.Duration.minutes(15),
+    percentage: 5,
+  }),
+});
+
+declare const application: codedeploy.LambdaApplication;
+declare const alias: lambda.Alias;
+const deploymentGroup = new codedeploy.LambdaDeploymentGroup(this, 'BlueGreenDeployment', {
+  application,
+  alias,
+  deploymentConfig: config,
+});
+```
+
+You can specify a custom name for your deployment config, but if you do you will not be able to update the interval/percentage through CDK.
+
+```ts
+const config = new codedeploy.LambdaDeploymentConfig(this, 'CustomConfig', {
+  trafficRoutingConfig: new codedeploy.TimeBasedCanaryTrafficRoutingConfig({
+    interval: cdk.Duration.minutes(15),
+    percentage: 5,
+  }),
+  deploymentConfigName: 'MyDeploymentConfig',
+});
+```
+
+To import an already existing Deployment Config:
+
+```ts
+const deploymentConfig = codedeploy.LambdaDeploymentConfig.fromLambdaDeploymentConfigName(
+  this,
+  'ExistingDeploymentConfiguration',
+  'MyExistingDeploymentConfiguration',
+);
+```
+
+## ECS Applications
+
+To create a new CodeDeploy Application that deploys an ECS service:
+
+```ts
+const application = new codedeploy.EcsApplication(this, 'CodeDeployApplication', {
+  applicationName: 'MyApplication', // optional property
+});
+```
+
+To import an already existing Application:
+
+```ts
+const application = codedeploy.EcsApplication.fromEcsApplicationName(
+  this,
+  'ExistingCodeDeployApplication',
+  'MyExistingApplication',
+);
+```
+
+## ECS Deployment Configurations
+
+CodeDeploy for ECS comes with predefined configurations for traffic shifting.
+The predefined configurations are available as LambdaDeploymentConfig constants.
+
+```ts
+const config = codedeploy.EcsDeploymentConfig.CANARY_10PERCENT_5MINUTES;
+```
+
+If you want to specify your own strategy,
+you can do so with the EcsDeploymentConfig construct,
+letting you specify precisely how fast an ECS service is deployed.
+
+```ts
+new codedeploy.EcsDeploymentConfig(this, 'CustomConfig', {
+  trafficRoutingConfig: new codedeploy.TimeBasedCanaryTrafficRoutingConfig({
+    interval: cdk.Duration.minutes(15),
+    percentage: 5,
+  }),
+});
+```
+
+You can specify a custom name for your deployment config, but if you do you will not be able to update the interval/percentage through CDK.
+
+```ts
+const config = new codedeploy.EcsDeploymentConfig(this, 'CustomConfig', {
+  trafficRoutingConfig: new codedeploy.TimeBasedCanaryTrafficRoutingConfig({
+    interval: cdk.Duration.minutes(15),
+    percentage: 5,
+  }),
+  deploymentConfigName: 'MyDeploymentConfig',
+});
+```
+
+Or import an existing one:
+
+```ts
+const deploymentConfig = codedeploy.EcsDeploymentConfig.fromEcsDeploymentConfigName(
+  this,
+  'ExistingDeploymentConfiguration',
+  'MyExistingDeploymentConfiguration',
+);
+```

packages/@aws-cdk/aws-codedeploy/lib/ecs/deployment-config.ts

@@ -1,46 +1,128 @@
+import { ArnFormat, Resource, Stack } from '@aws-cdk/core';
 import { Construct } from 'constructs';
-import { arnForDeploymentConfig } from '../utils';
+import { CfnDeploymentConfig } from '../codedeploy.generated';
+import { TrafficRouting } from '../traffic-routing-config';
+import { arnForDeploymentConfig, validateName } from '../utils';
 
 /**
  * The Deployment Configuration of an ECS Deployment Group.
+ *
+ * If you're managing the Deployment Configuration alongside the rest of your CDK resources,
+ * use the {@link EcsDeploymentConfig} class.
+ *
+ * If you want to reference an already existing deployment configuration,
+ * or one defined in a different CDK Stack,
+ * use the {@link EcsDeploymentConfig#fromEcsDeploymentConfigName} method.
+ *
  * The default, pre-defined Configurations are available as constants on the {@link EcsDeploymentConfig} class
  * (for example, `EcsDeploymentConfig.AllAtOnce`).
- *
- * Note: CloudFormation does not currently support creating custom ECS configs outside
- * of using a custom resource. You can import custom deployment config created outside the
- * CDK or via a custom resource with {@link EcsDeploymentConfig#fromEcsDeploymentConfigName}.
  */
 export interface IEcsDeploymentConfig {
+  /**
+   * The physical, human-readable name of the Deployment Configuration.
+   * @attribute
+   */
   readonly deploymentConfigName: string;
+
+  /**
+   * The ARN of the Deployment Configuration.
+   * @attribute
+   */
   readonly deploymentConfigArn: string;
 }
 
+/**
+ * Construction properties of {@link EcsDeploymentConfig}.
+ */
+export interface EcsDeploymentConfigProps {
+  /**
+   * The physical, human-readable name of the Deployment Configuration.
+   * @default - automatically generated name
+   */
+  readonly deploymentConfigName?: string;
+
+  /**
+   * The configuration that specifies how traffic is shifted from the 'blue'
+   * target group to the 'green' target group during a deployment.
+   * @default AllAtOnce
+   */
+  readonly trafficRouting?: TrafficRouting;
+}
+
 /**
  * A custom Deployment Configuration for an ECS Deployment Group.
  *
- * Note: This class currently stands as namespaced container of the default configurations
- * until CloudFormation supports custom ECS Deployment Configs. Until then it is closed
- * (private constructor) and does not extend {@link Construct}
- *
  * @resource AWS::CodeDeploy::DeploymentConfig
  */
-export class EcsDeploymentConfig {
+export class EcsDeploymentConfig extends Resource implements IEcsDeploymentConfig {
+  /** CodeDeploy predefined deployment configuration that shifts all traffic to the updated ECS task set at once. */
   public static readonly ALL_AT_ONCE = deploymentConfig('CodeDeployDefault.ECSAllAtOnce');
+  /** CodeDeploy predefined deployment configuration that shifts 10 percent of traffic every minute until all traffic is shifted. */
+  public static readonly LINEAR_10PERCENT_EVERY_1MINUTES = deploymentConfig('CodeDeployDefault.ECSLinear10PercentEvery1Minutes');
+  /** CodeDeploy predefined deployment configuration that shifts 10 percent of traffic every three minutes until all traffic is shifted. */
+  public static readonly LINEAR_10PERCENT_EVERY_3MINUTES = deploymentConfig('CodeDeployDefault.ECSLinear10PercentEvery3Minutes');
+  /** CodeDeploy predefined deployment configuration that shifts 10 percent of traffic in the first increment. The remaining 90 percent is deployed five minutes later. */
+  public static readonly CANARY_10PERCENT_5MINUTES = deploymentConfig('CodeDeployDefault.ECSCanary10Percent5Minutes');
+  /** CodeDeploy predefined deployment configuration that shifts 10 percent of traffic in the first increment. The remaining 90 percent is deployed 15 minutes later. */
+  public static readonly CANARY_10PERCENT_15MINUTES = deploymentConfig('CodeDeployDefault.ECSCanary10Percent15Minutes');
 
   /**
    * Import a custom Deployment Configuration for an ECS Deployment Group defined outside the CDK.
    *
-   * @param _scope the parent Construct for this new Construct
-   * @param _id the logical ID of this new Construct
+   * @param scope the parent Construct for this new Construct
+   * @param id the logical ID of this new Construct
    * @param ecsDeploymentConfigName the name of the referenced custom Deployment Configuration
    * @returns a Construct representing a reference to an existing custom Deployment Configuration
    */
-  public static fromEcsDeploymentConfigName(_scope: Construct, _id: string, ecsDeploymentConfigName: string): IEcsDeploymentConfig {
-    return deploymentConfig(ecsDeploymentConfigName);
+  public static fromEcsDeploymentConfigName(scope: Construct, id: string, ecsDeploymentConfigName: string): IEcsDeploymentConfig {
+    ignore(id);
+    const arn = Stack.of(scope).formatArn({
+      service: 'codedeploy',
+      resource: 'deploymentconfig',
+      resourceName: ecsDeploymentConfigName,
+      arnFormat: ArnFormat.COLON_RESOURCE_NAME,
+    });
+    return {
+      deploymentConfigName: ecsDeploymentConfigName,
+      deploymentConfigArn: arn,
+    };
   }
 
-  private constructor() {
-    // nothing to do until CFN supports custom ECS deployment configurations
+  /**
+   * The name of the deployment config
+   * @attribute
+   */
+  public readonly deploymentConfigName: string;
+
+  /**
+   * The arn of the deployment config
+   * @attribute
+   */
+  public readonly deploymentConfigArn: string;
+
+  public constructor(scope: Construct, id: string, props?: EcsDeploymentConfigProps) {
+    super(scope, id, {
+      physicalName: props?.deploymentConfigName,
+    });
+
+    // Construct the traffic routing configuration for the deployment group
+    const routingConfig = props?.trafficRouting ?? TrafficRouting.allAtOnce();
+
+    const resource = new CfnDeploymentConfig(this, 'Resource', {
+      deploymentConfigName: this.physicalName,
+      computePlatform: 'ECS',
+      trafficRoutingConfig: routingConfig.bind(this),
+    });
+
+    this.deploymentConfigName = this.getResourceNameAttribute(resource.ref);
+    this.deploymentConfigArn = this.getResourceArnAttribute(arnForDeploymentConfig(resource.ref), {
+      service: 'codedeploy',
+      resource: 'deploymentconfig',
+      resourceName: this.physicalName,
+      arnFormat: ArnFormat.COLON_RESOURCE_NAME,
+    });
+
+    this.node.addValidation({ validate: () => validateName('Deployment config', this.physicalName) });
   }
 }
 
@@ -50,3 +132,5 @@ function deploymentConfig(name: string): IEcsDeploymentConfig {
     deploymentConfigArn: arnForDeploymentConfig(name),
   };
 }
+
+function ignore(_x: any) { return; }

packages/@aws-cdk/aws-codedeploy/lib/index.ts

@@ -1,4 +1,5 @@
 export * from './rollback-config';
+export * from './traffic-routing-config';
 export * from './ecs';
 export * from './lambda';
 export * from './server';