documentation, tests, and bugfixes

aws · mergify · Feb 17, 2023 · Sep 13, 2022 · Sep 14, 2022 · Sep 15, 2022
commit f262a52199410d22260659258517918ca3a9cf99
diff --git a/packages/@aws-cdk/aws-redshift/README.md b/packages/@aws-cdk/aws-redshift/README.md
@@ -331,6 +331,25 @@ const cluster = new Cluster(this, 'Cluster', {
 cluster.addToParameterGroup('enable_user_activity_logging', 'true');
 ```
 
+## Rebooting for Parameter Updates
+
+In most cases, existing clusters [must be manually rebooted](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html) to apply parameter changes. You can automate parameter related reboots by setting the cluster's `rebootForParameterChanges` property to `true` , or by using `Cluster.enableRebootForParameterChanges()`.
+
+```ts
+declare const vpc: ec2.Vpc;
+
+const cluster = new Cluster(this, 'Cluster', {
+  masterUser: {
+    masterUsername: 'admin',
+    masterPassword: cdk.SecretValue.unsafePlainText('tooshort'),
+  },
+  vpc,
+});
+
+cluster.addToParameterGroup('enable_user_activity_logging', 'true');
+cluster.enableRebootForParameterChanges()
+```
+
 ## 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.
@@ -367,4 +386,3 @@ The elastic IP address is an external IP address for accessing the cluster outsi
 ### Attach Elastic IP after Cluster creation
 
 In some cases, you might want to associate the cluster with an elastic IP address or change an elastic IP address that is associated with the cluster. To attach an elastic IP address after the cluster is created, first update the cluster so that it is not publicly accessible, then make it both publicly accessible and add an Elastic IP address in the same operation.
-
diff --git a/packages/@aws-cdk/aws-redshift/lib/cluster-parameter-change-reboot-handler/index.ts b/packages/@aws-cdk/aws-redshift/lib/cluster-parameter-change-reboot-handler/index.ts
@@ -3,38 +3,49 @@ import { Redshift } from 'aws-sdk';
 
 const redshift = new Redshift();
 
-export async function handler(event: AWSLambda.CloudFormationCustomResourceEvent) {
+export async function handler(event: AWSLambda.CloudFormationCustomResourceEvent): Promise<void> {
   if (event.RequestType !== 'Delete') {
-    return rebootClusterIfRequired(event);
+    return rebootClusterIfRequired(event.ResourceProperties?.ClusterId, event.ResourceProperties?.ParameterGroupName);
   } else {
     return;
   }
 }
 
-async function rebootClusterIfRequired(event: AWSLambda.CloudFormationCustomResourceEvent) {
-  const clusterId = event.ResourceProperties?.ClusterId;
-  const parameterGroupName = event.ResourceProperties?.ParameterGroupName;
-  const clusterDetails = await redshift.describeClusters({ ClusterIdentifier: clusterId }).promise();
-  let found = false;
-  if (clusterDetails.Clusters?.[0].ClusterParameterGroups === undefined) {
-    throw new Error(`Unable to find any Parameter Groups associated with ClusterId "${clusterId}".`);
-  }
-  for (const group of clusterDetails.Clusters?.[0].ClusterParameterGroups) {
-    if (group.ParameterGroupName === parameterGroupName) {
-      found = true;
-      if (group.ParameterApplyStatus === 'pending-reboot') {
+async function rebootClusterIfRequired(clusterId: string, parameterGroupName: string): Promise<void> {
+  return executeActionForStatus(await getApplyStatus());
+
+  // https://docs.aws.amazon.com/redshift/latest/APIReference/API_ClusterParameterStatus.html
+  async function executeActionForStatus(status: string, retryDurationMs?: number): Promise<void> {
+    await sleep(retryDurationMs ?? 0);
+    if (['pending-reboot', 'apply-deferred', 'apply-error', 'unknown-error'].includes(status)) {
+      try {
         await redshift.rebootCluster({ ClusterIdentifier: clusterId }).promise();
-      } else if (group.ParameterApplyStatus === 'applying') {
-        await sleep(60000);
-        await rebootClusterIfRequired(event);
+      } catch (err) {
+        if ((<any>err).code === 'InvalidClusterState') {
+          return await executeActionForStatus(status, 30000);
+        } else {
+          throw err;
+        }
       }
-      break;
+      return;
+    } else if (['applying', 'retry'].includes(status)) {
+      return executeActionForStatus(await getApplyStatus(), 30000);
     }
+    return;
   }
-  if (!found) {
+
+  async function getApplyStatus(): Promise<string> {
+    const clusterDetails = await redshift.describeClusters({ ClusterIdentifier: clusterId }).promise();
+    if (clusterDetails.Clusters?.[0].ClusterParameterGroups === undefined) {
+      throw new Error(`Unable to find any Parameter Groups associated with ClusterId "${clusterId}".`);
+    }
+    for (const group of clusterDetails.Clusters?.[0].ClusterParameterGroups) {
+      if (group.ParameterGroupName === parameterGroupName) {
+        return group.ParameterApplyStatus ?? 'retry';
+      }
+    }
     throw new Error(`Unable to find Parameter Group named "${parameterGroupName}" associated with ClusterId "${clusterId}".`);
   }
-  return;
 }
 
 function sleep(ms: number) {

diff --git a/packages/@aws-cdk/aws-redshift/lib/cluster.ts b/packages/@aws-cdk/aws-redshift/lib/cluster.ts
@@ -5,7 +5,7 @@ import * as kms from '@aws-cdk/aws-kms';
 import * as lambda from '@aws-cdk/aws-lambda';
 import * as s3 from '@aws-cdk/aws-s3';
 import * as secretsmanager from '@aws-cdk/aws-secretsmanager';
-import { Duration, IResource, RemovalPolicy, Resource, SecretValue, Token, CustomResource, Stack, ArnFormat } from '@aws-cdk/core';
+import { ArnFormat, CustomResource, Duration, IResource, Lazy, RemovalPolicy, Resource, SecretValue, Stack, Token } from '@aws-cdk/core';
 import * as cr from '@aws-cdk/custom-resources';
 import { Construct } from 'constructs';
 import { DatabaseSecret } from './database-secret';
@@ -693,7 +693,7 @@ export class Cluster extends ClusterBase {
         resources: ['*'],
       }));
       rebootFunction.addToRolePolicy(new iam.PolicyStatement({
-        actions: ['reshift:RebootCluster'],
+        actions: ['redshift:RebootCluster'],
         resources: [
           Stack.of(this).formatArn({
             service: 'redshift',
@@ -710,9 +710,16 @@ export class Cluster extends ClusterBase {
         resourceType: 'Custom::RedshiftClusterRebooter',
         serviceToken: provider.serviceToken,
         properties: {
-          ClusterId: this.cluster.getAtt('id'),
+          ClusterId: this.clusterName,
           ParameterGroupName: this.parameterGroup.clusterParameterGroupName,
-          ParametersString: JSON.stringify(this.parameterGroup.parameters),
+          ParametersString: Lazy.string({
+            produce: () => {
+              if (!(this.parameterGroup instanceof ClusterParameterGroup)) {
+                throw new Error('Cannot enable reboot for parameter changes when using an imported parameter group.');
+              }
+              return JSON.stringify(this.parameterGroup.parameters);
+            },
+          }),
         },
       });
       customResource.node.addDependency(this, this.parameterGroup);

diff --git a/...luster-reboot/.cache/1b88b7c3e3e0f8d3e27ded1bde51b7a80c75f3d8733872af7952c3a6d902147e.zip b/...luster-reboot/.cache/1b88b7c3e3e0f8d3e27ded1bde51b7a80c75f3d8733872af7952c3a6d902147e.zip
diff --git a/...luster-reboot/.cache/631d177ea8a37a639d61917693cce9bbdb8e53862bc1ead871c88a235f8ef139.zip b/...luster-reboot/.cache/631d177ea8a37a639d61917693cce9bbdb8e53862bc1ead871c88a235f8ef139.zip
diff --git a/...luster-reboot/.cache/8183b462910b51c368ad6760d3019ff95dbf73d5be0dc2b7dc5db48f25f8245f.zip b/...luster-reboot/.cache/8183b462910b51c368ad6760d3019ff95dbf73d5be0dc2b7dc5db48f25f8245f.zip
diff --git a/packages/@aws-cdk/aws-redshift/test/cdk-integ.out.cluster-reboot/assertion-results.json b/packages/@aws-cdk/aws-redshift/test/cdk-integ.out.cluster-reboot/assertion-results.json
@@ -0,0 +1,6 @@
+{
+  "aws-cdk-redshift-cluster-reboot-integ": {
+    "ExportsOutputRefClusterEB0386A796A0E3FE": "clustereb0386a7-dzxalxbye79k",
+    "ExportsOutputRefParameterGroup5E32DECBB33EA140": "aws-cdk-redshift-cluster-reboot-integ-parametergroup5e32decb-kuykp4syd337"
+  }
+}
diff --git a/...er-reboot/asset.1b88b7c3e3e0f8d3e27ded1bde51b7a80c75f3d8733872af7952c3a6d902147e/index.ts b/...er-reboot/asset.1b88b7c3e3e0f8d3e27ded1bde51b7a80c75f3d8733872af7952c3a6d902147e/index.ts
@@ -0,0 +1,53 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { Redshift } from 'aws-sdk';
+
+const redshift = new Redshift();
+
+export async function handler(event: AWSLambda.CloudFormationCustomResourceEvent): Promise<void> {
+  if (event.RequestType !== 'Delete') {
+    return rebootClusterIfRequired(event.ResourceProperties?.ClusterId, event.ResourceProperties?.ParameterGroupName);
+  } else {
+    return;
+  }
+}
+
+async function rebootClusterIfRequired(clusterId: string, parameterGroupName: string): Promise<void> {
+  return executeActionForStatus(await getApplyStatus());
+
+  // https://docs.aws.amazon.com/redshift/latest/APIReference/API_ClusterParameterStatus.html
+  async function executeActionForStatus(status: string, retryDurationMs?: number): Promise<void> {
+    await sleep(retryDurationMs ?? 0);
+    if (['pending-reboot', 'apply-deferred', 'apply-error', 'unknown-error'].includes(status)) {
+      try {
+        await redshift.rebootCluster({ ClusterIdentifier: clusterId }).promise();
+      } catch (err) {
+        if ((<any>err).code === 'InvalidClusterState') {
+          return await executeActionForStatus(status, 30000);
+        } else {
+          throw err;
+        }
+      }
+      return;
+    } else if (['applying', 'retry'].includes(status)) {
+      return executeActionForStatus(await getApplyStatus(), 30000);
+    }
+    return;
+  }
+
+  async function getApplyStatus(): Promise<string> {
+    const clusterDetails = await redshift.describeClusters({ ClusterIdentifier: clusterId }).promise();
+    if (clusterDetails.Clusters?.[0].ClusterParameterGroups === undefined) {
+      throw new Error(`Unable to find any Parameter Groups associated with ClusterId "${clusterId}".`);
+    }
+    for (const group of clusterDetails.Clusters?.[0].ClusterParameterGroups) {
+      if (group.ParameterGroupName === parameterGroupName) {
+        return group.ParameterApplyStatus ?? 'retry';
+      }
+    }
+    throw new Error(`Unable to find Parameter Group named "${parameterGroupName}" associated with ClusterId "${clusterId}".`);
+  }
+}
+
+function sleep(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
diff --git a/...er-reboot/asset.631d177ea8a37a639d61917693cce9bbdb8e53862bc1ead871c88a235f8ef139/index.ts b/...er-reboot/asset.631d177ea8a37a639d61917693cce9bbdb8e53862bc1ead871c88a235f8ef139/index.ts
@@ -0,0 +1,53 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { Redshift } from 'aws-sdk';
+
+const redshift = new Redshift();
+
+export async function handler(event: AWSLambda.CloudFormationCustomResourceEvent): Promise<void> {
+  if (event.RequestType !== 'Delete') {
+    return rebootClusterIfRequired(event.ResourceProperties?.ClusterId, event.ResourceProperties?.ParameterGroupName);
+  } else {
+    return;
+  }
+}
+
+async function rebootClusterIfRequired(clusterId: string, parameterGroupName: string): Promise<void> {
+  return executeActionForStatus(await getApplyStatus());
+
+  // https://docs.aws.amazon.com/redshift/latest/APIReference/API_ClusterParameterStatus.html
+  async function executeActionForStatus(status: string, retryDurationMs?: number): Promise<void> {
+    await sleep(retryDurationMs ?? 0);
+    if (['pending-reboot', 'apply-deferred', 'apply-error', 'unknown-error'].includes(status)) {
+      try {
+        await redshift.rebootCluster({ ClusterIdentifier: clusterId }).promise();
+      } catch (err) {
+        if ((<any>err).code === 'InvalidClusterState') {
+          return await executeActionForStatus(status, 30000);
+        } else {
+          throw err;
+        }
+      }
+      return;
+    } else if (['applying', 'retry'].includes(status)) {
+      return executeActionForStatus(await getApplyStatus(), 30000);
+    }
+    return;
+  }
+
+  async function getApplyStatus(): Promise<string> {
+    const clusterDetails = await redshift.describeClusters({ ClusterIdentifier: clusterId }).promise();
+    if (clusterDetails.Clusters?.[0].ClusterParameterGroups === undefined) {
+      throw new Error(`Unable to find any Parameter Groups associated with ClusterId "${clusterId}".`);
+    }
+    for (const group of clusterDetails.Clusters?.[0].ClusterParameterGroups) {
+      if (group.ParameterGroupName === parameterGroupName) {
+        return group.ParameterApplyStatus ?? 'retry';
+      }
+    }
+    throw new Error(`Unable to find Parameter Group named "${parameterGroupName}" associated with ClusterId "${clusterId}".`);
+  }
+}
+
+function sleep(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
diff --git a/...er-reboot/asset.8183b462910b51c368ad6760d3019ff95dbf73d5be0dc2b7dc5db48f25f8245f/index.ts b/...er-reboot/asset.8183b462910b51c368ad6760d3019ff95dbf73d5be0dc2b7dc5db48f25f8245f/index.ts
@@ -0,0 +1,54 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { Redshift } from 'aws-sdk';
+
+const redshift = new Redshift();
+
+export async function handler(event: AWSLambda.CloudFormationCustomResourceEvent): Promise<void> {
+  if (event.RequestType !== 'Delete') {
+    return rebootClusterIfRequired(event.ResourceProperties?.ClusterId, event.ResourceProperties?.ParameterGroupName);
+  } else {
+    return;
+  }
+}
+
+async function rebootClusterIfRequired(clusterId: string, parameterGroupName: string) {
+  return executeActionForStatus(await getApplyStatus());
+
+  // https://docs.aws.amazon.com/redshift/latest/APIReference/API_ClusterParameterStatus.html
+  async function executeActionForStatus(status: string): Promise<void> {
+    if (['pending-reboot', 'apply-deferred', 'apply-error', 'unknown-error'].includes(status)) {
+      try {
+        await redshift.rebootCluster({ ClusterIdentifier: clusterId }).promise();
+      } catch (err) {
+        if ((<any>err).code === 'InvalidClusterState') {
+          await sleep(60000);
+          return await executeActionForStatus(await getApplyStatus());
+        } else {
+          throw err;
+        }
+      }
+      return;
+    } else if (['applying', 'retry'].includes(status)) {
+      await sleep(60000);
+      return executeActionForStatus(await getApplyStatus());
+    }
+    return;
+  }
+
+  async function getApplyStatus(): Promise<string> {
+    const clusterDetails = await redshift.describeClusters({ ClusterIdentifier: clusterId }).promise();
+    if (clusterDetails.Clusters?.[0].ClusterParameterGroups === undefined) {
+      throw new Error(`Unable to find any Parameter Groups associated with ClusterId "${clusterId}".`);
+    }
+    for (const group of clusterDetails.Clusters?.[0].ClusterParameterGroups) {
+      if (group.ParameterGroupName === parameterGroupName) {
+        return group.ParameterApplyStatus ?? 'retry';
+      }
+    }
+    throw new Error(`Unable to find Parameter Group named "${parameterGroupName}" associated with ClusterId "${clusterId}".`);
+  }
+}
+
+function sleep(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
diff --git a/...ws-redshift/test/cdk-integ.out.cluster-reboot/aws-cdk-redshift-cluster-create.assets.json b/...ws-redshift/test/cdk-integ.out.cluster-reboot/aws-cdk-redshift-cluster-create.assets.json
@@ -0,0 +1,45 @@
+{
+  "version": "21.0.0",
+  "files": {
+    "631d177ea8a37a639d61917693cce9bbdb8e53862bc1ead871c88a235f8ef139": {
+      "source": {
+        "path": "asset.631d177ea8a37a639d61917693cce9bbdb8e53862bc1ead871c88a235f8ef139",
+        "packaging": "zip"
+      },
+      "destinations": {
+        "current_account-current_region": {
+          "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}",
+          "objectKey": "631d177ea8a37a639d61917693cce9bbdb8e53862bc1ead871c88a235f8ef139.zip",
+          "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}"
+        }
+      }
+    },
+    "3b263c2ad043fd069ef446753788c36e595c82b51a70478e58258c8ef7471671": {
+      "source": {
+        "path": "asset.3b263c2ad043fd069ef446753788c36e595c82b51a70478e58258c8ef7471671",
+        "packaging": "zip"
+      },
+      "destinations": {
+        "current_account-current_region": {
+          "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}",
+          "objectKey": "3b263c2ad043fd069ef446753788c36e595c82b51a70478e58258c8ef7471671.zip",
+          "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}"
+        }
+      }
+    },
+    "42ff6c40ab2191a9f141b53cff77b4d1a253b7af577e2d0c9a196cdc4316ee2f": {
+      "source": {
+        "path": "aws-cdk-redshift-cluster-create.template.json",
+        "packaging": "file"
+      },
+      "destinations": {
+        "current_account-current_region": {
+          "bucketName": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}",
+          "objectKey": "42ff6c40ab2191a9f141b53cff77b4d1a253b7af577e2d0c9a196cdc4316ee2f.json",
+          "assumeRoleArn": "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-hnb659fds-file-publishing-role-${AWS::AccountId}-${AWS::Region}"
+        }
+      }
+    }
+  },
+  "dockerImages": {}
+}