feat(redshift-alpha): directly add parameters to a parameter group or indirectly through a cluster

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

@@ -277,6 +277,27 @@ cluster.addRotationMultiUser('MultiUserRotation', {
 });
 ```
 
+## Adding Parameters
+
+You can add a parameter to a parameter group with`ClusterParameterGroup.addParameter()`.
+
+```ts
+const params = new ClusterParameterGroup(stack, 'Params', {
+  description: 'desc',
+  parameters: {
+    require_ssl: 'true',
+  },
+});
+
+params.addParameter('enable_user_activity_logging', 'true');
+```
+
+Additionally, you can add a parameter to the cluster's associated parameter group with `Cluster.addToParameterGroup()`. If the cluster does not have an associated parameter group, a new parameter group is created.
+
+```ts fixture=cluster
+cluster.addToParameterGroup('enable_user_activity_logging', 'true');
+```
+
 ## Elastic IP
 
 If you configure your cluster to be publicly accessible, you can optionally select an *elastic IP address* to use for the external IP address. An elastic IP address is a static IP address that is associated with your AWS account. You can use an elastic IP address to connect to your cluster from outside the VPC. An elastic IP address gives you the ability to change your underlying configuration without affecting the IP address that clients use to connect to your cluster. This approach can be helpful for situations such as recovery after a failure.

packages/@aws-cdk/aws-redshift/lib/cluster.ts

@@ -7,7 +7,7 @@ import { Duration, IResource, RemovalPolicy, Resource, SecretValue, Token } from
 import { Construct } from 'constructs';
 import { DatabaseSecret } from './database-secret';
 import { Endpoint } from './endpoint';
-import { IClusterParameterGroup } from './parameter-group';
+import { ClusterParameterGroup, IClusterParameterGroup } from './parameter-group';
 import { CfnCluster } from './redshift.generated';
 import { ClusterSubnetGroup, IClusterSubnetGroup } from './subnet-group';
 
@@ -350,6 +350,7 @@ export interface ClusterProps {
  * A new or imported clustered database.
  */
 abstract class ClusterBase extends Resource implements ICluster {
+
   /**
    * Name of the cluster
    */
@@ -374,6 +375,7 @@ abstract class ClusterBase extends Resource implements ICluster {
       targetType: secretsmanager.AttachmentTargetType.REDSHIFT_CLUSTER,
     };
   }
+
 }
 
 /**
@@ -395,7 +397,6 @@ export class Cluster extends ClusterBase {
       public readonly instanceIdentifiers: string[] = [];
       public readonly clusterEndpoint = new Endpoint(attrs.clusterEndpointAddress, attrs.clusterEndpointPort);
     }
-
     return new Import(scope, id);
   }
 
@@ -432,13 +433,24 @@ export class Cluster extends ClusterBase {
    */
   private readonly vpcSubnets?: ec2.SubnetSelection;
 
+  /**
+   * The underlying CfnCluster
+   */
+  private readonly cluster: CfnCluster;
+
+  /**
+   * The cluster's parameter group
+   */
+  protected parameterGroup?: IClusterParameterGroup;
+
   constructor(scope: Construct, id: string, props: ClusterProps) {
     super(scope, id);
 
     this.vpc = props.vpc;
     this.vpcSubnets = props.vpcSubnets ?? {
       subnetType: ec2.SubnetType.PRIVATE_WITH_NAT,
     };
+    this.parameterGroup = props.parameterGroup;
 
     const removalPolicy = props.removalPolicy ?? RemovalPolicy.RETAIN;
 
@@ -482,7 +494,7 @@ export class Cluster extends ClusterBase {
       };
     }
 
-    const cluster = new CfnCluster(this, 'Resource', {
+    this.cluster = new CfnCluster(this, 'Resource', {
       // Basic
       allowVersionUpgrade: true,
       automatedSnapshotRetentionPeriod: 1,
@@ -511,15 +523,15 @@ export class Cluster extends ClusterBase {
       elasticIp: props.elasticIp,
     });
 
-    cluster.applyRemovalPolicy(removalPolicy, {
+    this.cluster.applyRemovalPolicy(removalPolicy, {
       applyToUpdateReplacePolicy: true,
     });
 
-    this.clusterName = cluster.ref;
+    this.clusterName = this.cluster.ref;
 
     // create a number token that represents the port of the cluster
-    const portAttribute = Token.asNumber(cluster.attrEndpointPort);
-    this.clusterEndpoint = new Endpoint(cluster.attrEndpointAddress, portAttribute);
+    const portAttribute = Token.asNumber(this.cluster.attrEndpointPort);
+    this.clusterEndpoint = new Endpoint(this.cluster.attrEndpointAddress, portAttribute);
 
     if (secret) {
       this.secret = secret.attach(this);
@@ -592,4 +604,26 @@ export class Cluster extends ClusterBase {
       return nodeCount;
     }
   }
+
+  /**
+   * Adds a parameter to the Clusters' parameter group
+   *
+   * @param name the parameter name
+   * @param value the parameter name
+   */
+  public addToParameterGroup(name: string, value: string): void {
+    if (!this.parameterGroup) {
+      const param: { [name: string]: string } = {};
+      param[name] = value;
+      this.parameterGroup = new ClusterParameterGroup(this, 'ParameterGroup', {
+        description: `Parameter Group for the ${this.cluster.clusterIdentifier ?? this.clusterName} Redshift cluster`,
+        parameters: param,
+      });
+      this.cluster.clusterParameterGroupName = this.parameterGroup.clusterParameterGroupName;
+    } else if (this.parameterGroup instanceof ClusterParameterGroup) {
+      this.parameterGroup.addParameter(name, value);
+    } else {
+      throw new Error('Cannot add a parameter to an imported parameter group.');
+    }
+  }
 }

packages/@aws-cdk/aws-redshift/lib/parameter-group.ts

@@ -18,6 +18,7 @@ export interface IClusterParameterGroup extends IResource {
  * A new cluster or instance parameter group
  */
 abstract class ClusterParameterGroupBase extends Resource implements IClusterParameterGroup {
+
   /**
    * The name of the parameter group
    */
@@ -62,17 +63,46 @@ export class ClusterParameterGroup extends ClusterParameterGroupBase {
    */
   public readonly clusterParameterGroupName: string;
 
+  /**
+   * The parameters in the parameter group
+  */
+  readonly parameters: { [name: string]: string };
+
+  /**
+   * The underlying CfnClusterParameterGroup
+  */
+  private readonly resource: CfnClusterParameterGroup;
+
   constructor(scope: Construct, id: string, props: ClusterParameterGroupProps) {
     super(scope, id);
-
-    const resource = new CfnClusterParameterGroup(this, 'Resource', {
+    this.parameters = props.parameters;
+    this.resource = new CfnClusterParameterGroup(this, 'Resource', {
       description: props.description || 'Cluster parameter group for family redshift-1.0',
       parameterGroupFamily: 'redshift-1.0',
-      parameters: Object.entries(props.parameters).map(([name, value]) => {
-        return { parameterName: name, parameterValue: value };
-      }),
+      parameters: this.parseParameters(),
     });
 
-    this.clusterParameterGroupName = resource.ref;
+    this.clusterParameterGroupName = this.resource.ref;
+  }
+  private parseParameters(): any {
+    return Object.entries(this.parameters).map(([name, value]) => {
+      return { parameterName: name, parameterValue: value };
+    });
+  }
+
+  /**
+   * Adds a parameter to the parameter group
+   *
+   * @param name the parameter name
+   * @param value the parameter name
+   */
+  public addParameter(name: string, value: string): void {
+    const existingValue = Object.entries(this.parameters).find(([key, _]) => key === name)?.[1];
+    if (existingValue === undefined) {
+      this.parameters[name] = value;
+      this.resource.parameters = this.parseParameters();
+    } else if (existingValue !== value) {
+      throw new Error(`The parameter group already contains the parameter "${name}", but with a different value (Given: ${value}, Existing: ${existingValue}).`);
+    }
   }
 }

packages/@aws-cdk/aws-redshift/test/cluster.test.ts

@@ -253,27 +253,76 @@ test('create an encrypted cluster with custom KMS key', () => {
     },
   });
 });
+describe('parameter group', () => {
+  test('cluster instantiated with parameter group', () => {
+    // WHEN
+    const group = new ClusterParameterGroup(stack, 'Params', {
+      description: 'bye',
+      parameters: {
+        param: 'value',
+      },
+    });
+
+    new Cluster(stack, 'Redshift', {
+      masterUser: {
+        masterUsername: 'admin',
+      },
+      vpc,
+      parameterGroup: group,
+    });
+
+    // THEN
+    Template.fromStack(stack).hasResourceProperties('AWS::Redshift::Cluster', {
+      ClusterParameterGroupName: { Ref: 'ParamsA8366201' },
+    });
 
-test('cluster with parameter group', () => {
-  // WHEN
-  const group = new ClusterParameterGroup(stack, 'Params', {
-    description: 'bye',
-    parameters: {
-      param: 'value',
-    },
   });
 
-  new Cluster(stack, 'Redshift', {
-    masterUser: {
-      masterUsername: 'admin',
-    },
-    vpc,
-    parameterGroup: group,
+  test('adding to cluster parameter group on cluster not instantiated with parameter group', () => {
+
+    // WHEN
+    const cluster = new Cluster(stack, 'Redshift', {
+      clusterName: 'foobar',
+      masterUser: {
+        masterUsername: 'admin',
+      },
+      vpc,
+    });
+
+    cluster.addToParameterGroup('foo', 'bar');
+
+    const template = Template.fromStack(stack);
+    template.hasResourceProperties('AWS::Redshift::Cluster', {
+      ClusterParameterGroupName: { Ref: Match.anyValue() },
+    });
+
+    template.hasResourceProperties('AWS::Redshift::ClusterParameterGroup', {
+      Description: 'Parameter Group for the foobar Redshift cluster',
+      ParameterGroupFamily: 'redshift-1.0',
+      Parameters: [
+        {
+          ParameterName: 'foo',
+          ParameterValue: 'bar',
+        },
+      ],
+    });
   });
 
-  // THEN
-  Template.fromStack(stack).hasResourceProperties('AWS::Redshift::Cluster', {
-    ClusterParameterGroupName: { Ref: 'ParamsA8366201' },
+  test('Adding a parameter to an IClusterParameterGroup', () => {
+    // GIVEN
+    const cluster = new Cluster(stack, 'Redshift', {
+      clusterName: 'foobar',
+      parameterGroup: ClusterParameterGroup.fromClusterParameterGroupName(stack, 'Params', 'foo'),
+      masterUser: {
+        masterUsername: 'admin',
+      },
+      vpc,
+    });
+
+    // WHEN
+    expect(() => cluster.addToParameterGroup('param', 'value2'))
+      // THEN
+      .toThrowError('Cannot add a parameter to an imported parameter group');
   });
 
 });
@@ -372,7 +421,7 @@ test('throws validation error when trying to set encryptionKey without enabling
 
   // THEN
   expect(() => {
-    new Cluster(stack, 'Redshift', props );
+    new Cluster(stack, 'Redshift', props);
   }).toThrowError();
 
 });