@gemeentenijmegen/webapp 1.1.12 → 1.1.14

package/node_modules/@aws-solutions-constructs/core/lib/opensearch-helper.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOpenSearch = buildOpenSearch;
+exports.buildOpenSearchCWAlarms = buildOpenSearchCWAlarms;
+exports.CheckOpenSearchProps = CheckOpenSearchProps;
+/*
+ *  The functions found here in the core library are for internal use and can be changed
+ *  or removed outside of a major release. We recommend against calling them directly from client code.
+ */
+const opensearch = require("aws-cdk-lib/aws-opensearchservice");
+const opensearch_defaults_1 = require("./opensearch-defaults");
+const vpc_helper_1 = require("./vpc-helper");
+const utils_1 = require("./utils");
+const iam = require("aws-cdk-lib/aws-iam");
+const cdk = require("aws-cdk-lib");
+const cloudwatch = require("aws-cdk-lib/aws-cloudwatch");
+const MAXIMUM_AZS_IN_OPENSEARCH_DOMAIN = 3;
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildOpenSearch(scope, props) {
+    let subnetIds;
+    const constructDrivenProps = {};
+    // Setup the IAM Role & policy for the OpenSearch Service to configure Cognito User pool and Identity pool
+    const cognitoDashboardConfigureRole = createDashboardCognitoRole(scope, props.userpool, props.identitypool, props.openSearchDomainName);
+    if (props.vpc) {
+        subnetIds = (0, vpc_helper_1.retrievePrivateSubnetIds)(props.vpc);
+        if (subnetIds.length > MAXIMUM_AZS_IN_OPENSEARCH_DOMAIN) {
+            subnetIds = subnetIds.slice(0, MAXIMUM_AZS_IN_OPENSEARCH_DOMAIN);
+        }
+        constructDrivenProps.vpcOptions = {
+            subnetIds,
+            securityGroupIds: props.securityGroupIds
+        };
+        // If the client did not submit a ClusterConfig, then we will create one
+        if (!props.clientDomainProps?.clusterConfig) {
+            constructDrivenProps.clusterConfig = createClusterConfiguration(subnetIds.length);
+        }
+    }
+    else { // No VPC
+        // If the client did not submit a ClusterConfig, then we will create one based on the Region
+        if (!props.clientDomainProps?.clusterConfig) {
+            constructDrivenProps.clusterConfig = createClusterConfiguration(cdk.Stack.of(scope).availabilityZones.length);
+        }
+    }
+    const defaultCfnDomainProps = (0, opensearch_defaults_1.DefaultOpenSearchCfnDomainProps)(props.openSearchDomainName, cognitoDashboardConfigureRole, props);
+    const finalCfnDomainProps = (0, utils_1.consolidateProps)(defaultCfnDomainProps, props.clientDomainProps, constructDrivenProps);
+    // tlsSecurityPolicy is set in DefaultOpenSearchCfnDomainProps() - it is the
+    // default behavior, but Sonarqube cannot follow the program flow to confirm this.
+    // This is confirmed by the 'Check that TLS 1.2 is the default' test in aws-lambda-opensearch
+    const opensearchDomain = new opensearch.CfnDomain(scope, `OpenSearchDomain`, finalCfnDomainProps); // NOSONAR
+    opensearchDomain.node.addDependency(cognitoDashboardConfigureRole);
+    (0, utils_1.addCfnSuppressRules)(opensearchDomain, [
+        {
+            id: "W28",
+            reason: `The OpenSearch Service domain is passed dynamically as as parameter and explicitly specified to ensure that IAM policies are configured to lockdown access to this specific OpenSearch Service instance only`,
+        },
+        {
+            id: "W90",
+            reason: `This is not a rule for the general case, just for specific use cases/industries`,
+        },
+    ]);
+    (0, utils_1.addCfnGuardSuppressRules)(opensearchDomain, ["CFN_NO_EXPLICIT_RESOURCE_NAMES"]);
+    return { domain: opensearchDomain, role: cognitoDashboardConfigureRole };
+}
+/**
+ * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.
+ */
+function buildOpenSearchCWAlarms(scope) {
+    const alarms = new Array();
+    // ClusterStatus.red maximum is >= 1 for 1 minute, 1 consecutive time
+    alarms.push(new cloudwatch.Alarm(scope, 'StatusRedAlarm', {
+        metric: new cloudwatch.Metric({
+            namespace: 'AWS/ES',
+            metricName: 'ClusterStatus.red',
+            statistic: 'Maximum',
+            period: cdk.Duration.seconds(60),
+        }),
+        threshold: 1,
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'At least one primary shard and its replicas are not allocated to a node. '
+    }));
+    // ClusterStatus.yellow maximum is >= 1 for 1 minute, 1 consecutive time
+    alarms.push(new cloudwatch.Alarm(scope, 'StatusYellowAlarm', {
+        metric: new cloudwatch.Metric({
+            namespace: 'AWS/ES',
+            metricName: 'ClusterStatus.yellow',
+            statistic: 'Maximum',
+            period: cdk.Duration.seconds(60),
+        }),
+        threshold: 1,
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'At least one replica shard is not allocated to a node.'
+    }));
+    // FreeStorageSpace minimum is <= 20480 for 1 minute, 1 consecutive time
+    alarms.push(new cloudwatch.Alarm(scope, 'FreeStorageSpaceTooLowAlarm', {
+        metric: new cloudwatch.Metric({
+            namespace: 'AWS/ES',
+            metricName: 'FreeStorageSpace',
+            statistic: 'Minimum',
+            period: cdk.Duration.seconds(60),
+        }),
+        threshold: 20000,
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'A node in your cluster is down to 20 GiB of free storage space.'
+    }));
+    // ClusterIndexWritesBlocked is >= 1 for 5 minutes, 1 consecutive time
+    alarms.push(new cloudwatch.Alarm(scope, 'IndexWritesBlockedTooHighAlarm', {
+        metric: new cloudwatch.Metric({
+            namespace: 'AWS/ES',
+            metricName: 'ClusterIndexWritesBlocked',
+            statistic: 'Maximum',
+            period: cdk.Duration.seconds(300),
+        }),
+        threshold: 1,
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'Your cluster is blocking write requests.'
+    }));
+    // AutomatedSnapshotFailure maximum is >= 1 for 1 minute, 1 consecutive time
+    alarms.push(new cloudwatch.Alarm(scope, 'AutomatedSnapshotFailureTooHighAlarm', {
+        metric: new cloudwatch.Metric({
+            namespace: 'AWS/ES',
+            metricName: 'AutomatedSnapshotFailure',
+            statistic: 'Maximum',
+            period: cdk.Duration.seconds(60),
+        }),
+        threshold: 1,
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'An automated snapshot failed. This failure is often the result of a red cluster health status.'
+    }));
+    // CPUUtilization maximum is >= 80% for 15 minutes, 3 consecutive times
+    alarms.push(new cloudwatch.Alarm(scope, 'CPUUtilizationTooHighAlarm', {
+        metric: new cloudwatch.Metric({
+            namespace: 'AWS/ES',
+            metricName: 'CPUUtilization',
+            statistic: 'Average',
+            period: cdk.Duration.seconds(900),
+        }),
+        threshold: 80,
+        evaluationPeriods: 3,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: '100% CPU utilization is not uncommon, but sustained high usage is problematic. Consider using larger instance types or adding instances.'
+    }));
+    // JVMMemoryPressure maximum is >= 80% for 5 minutes, 3 consecutive times
+    alarms.push(new cloudwatch.Alarm(scope, 'JVMMemoryPressureTooHighAlarm', {
+        metric: new cloudwatch.Metric({
+            namespace: 'AWS/ES',
+            metricName: 'JVMMemoryPressure',
+            statistic: 'Average',
+            period: cdk.Duration.seconds(900),
+        }),
+        threshold: 80,
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'Average JVM memory pressure over last 15 minutes too high. Consider scaling vertically.'
+    }));
+    // MasterCPUUtilization maximum is >= 50% for 15 minutes, 3 consecutive times
+    alarms.push(new cloudwatch.Alarm(scope, 'MasterCPUUtilizationTooHighAlarm', {
+        metric: new cloudwatch.Metric({
+            namespace: 'AWS/ES',
+            metricName: 'MasterCPUUtilization',
+            statistic: 'Average',
+            period: cdk.Duration.seconds(900),
+        }),
+        threshold: 50,
+        evaluationPeriods: 3,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'Average CPU utilization over last 45 minutes too high. Consider using larger instance types for your dedicated master nodes.'
+    }));
+    // MasterJVMMemoryPressure maximum is >= 80% for 15 minutes, 1 consecutive time
+    alarms.push(new cloudwatch.Alarm(scope, 'MasterJVMMemoryPressureTooHighAlarm', {
+        metric: new cloudwatch.Metric({
+            namespace: 'AWS/ES',
+            metricName: 'MasterJVMMemoryPressure',
+            statistic: 'Average',
+            period: cdk.Duration.seconds(900),
+        }),
+        threshold: 50,
+        evaluationPeriods: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        alarmDescription: 'Average JVM memory pressure over last 15 minutes too high. Consider scaling vertically.'
+    }));
+    return alarms;
+}
+function createClusterConfiguration(numberOfAzs) {
+    return {
+        dedicatedMasterEnabled: true,
+        dedicatedMasterCount: 3,
+        zoneAwarenessEnabled: true,
+        zoneAwarenessConfig: {
+            availabilityZoneCount: numberOfAzs
+        },
+        instanceCount: numberOfAzs,
+    };
+}
+function createDashboardCognitoRole(scope, userPool, identitypool, domainName) {
+    // Setup the IAM Role & policy for the OpenSearch Service to configure Cognito User pool and Identity pool
+    const cognitoDashboardConfigureRole = new iam.Role(scope, "CognitoDashboardConfigureRole", {
+        assumedBy: new iam.ServicePrincipal("es.amazonaws.com"),
+    });
+    const cognitoDashboardConfigureRolePolicy = new iam.Policy(scope, "CognitoDashboardConfigureRolePolicy", {
+        statements: [
+            new iam.PolicyStatement({
+                actions: [
+                    "cognito-idp:DescribeUserPool",
+                    "cognito-idp:CreateUserPoolClient",
+                    "cognito-idp:DeleteUserPoolClient",
+                    "cognito-idp:DescribeUserPoolClient",
+                    "cognito-idp:AdminInitiateAuth",
+                    "cognito-idp:AdminUserGlobalSignOut",
+                    "cognito-idp:ListUserPoolClients",
+                    "cognito-identity:DescribeIdentityPool",
+                    "cognito-identity:UpdateIdentityPool",
+                    "cognito-identity:SetIdentityPoolRoles",
+                    "cognito-identity:GetIdentityPoolRoles",
+                    "es:UpdateDomainConfig",
+                ],
+                resources: [
+                    userPool.userPoolArn,
+                    `arn:${cdk.Aws.PARTITION}:cognito-identity:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:identitypool/${identitypool.ref}`,
+                    `arn:${cdk.Aws.PARTITION}:es:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:domain/${domainName}`,
+                ],
+            }),
+            new iam.PolicyStatement({
+                actions: ["iam:PassRole"],
+                conditions: {
+                    StringLike: {
+                        "iam:PassedToService": "cognito-identity.amazonaws.com",
+                    },
+                },
+                resources: [cognitoDashboardConfigureRole.roleArn],
+            }),
+        ],
+    });
+    cognitoDashboardConfigureRolePolicy.attachToRole(cognitoDashboardConfigureRole);
+    return cognitoDashboardConfigureRole;
+}
+function CheckOpenSearchProps(propsObject) {
+    let errorMessages = '';
+    let errorFound = false;
+    if (propsObject.openSearchDomainProps?.vpcOptions) {
+        errorMessages += "Error - Define VPC using construct parameters not the OpenSearch Service props\n";
+        errorFound = true;
+    }
+    if (errorFound) {
+        throw new Error(errorMessages);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"opensearch-helper.js","sourceRoot":"","sources":["opensearch-helper.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\n/*\n *  The functions found here in the core library are for internal use and can be changed\n *  or removed outside of a major release. We recommend against calling them directly from client code.\n */\n\nimport * as opensearch from 'aws-cdk-lib/aws-opensearchservice';\nimport { DefaultOpenSearchCfnDomainProps } from './opensearch-defaults';\nimport { retrievePrivateSubnetIds } from './vpc-helper';\nimport { consolidateProps, addCfnSuppressRules, addCfnGuardSuppressRules } from './utils';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as cdk from 'aws-cdk-lib';\nimport * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\nimport * as cognito from 'aws-cdk-lib/aws-cognito';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\n// Note: To ensure CDKv2 compatibility, keep the import statement for Construct separate\nimport { Construct } from 'constructs';\n\nconst MAXIMUM_AZS_IN_OPENSEARCH_DOMAIN = 3;\n\nexport interface BuildOpenSearchProps {\n  readonly identitypool: cognito.CfnIdentityPool;\n  readonly userpool: cognito.UserPool;\n  readonly cognitoAuthorizedRoleARN: string;\n  readonly serviceRoleARN?: string;\n  readonly vpc?: ec2.IVpc;\n  readonly openSearchDomainName: string;\n  readonly clientDomainProps?: opensearch.CfnDomainProps,\n  readonly securityGroupIds?: string[]\n}\n\nexport interface BuildOpenSearchResponse {\n  readonly domain: opensearch.CfnDomain,\n  readonly role: iam.Role\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildOpenSearch(scope: Construct, props: BuildOpenSearchProps): BuildOpenSearchResponse {\n  let subnetIds: string[];\n  const constructDrivenProps: any = {};\n\n  // Setup the IAM Role & policy for the OpenSearch Service to configure Cognito User pool and Identity pool\n  const cognitoDashboardConfigureRole = createDashboardCognitoRole(scope, props.userpool, props.identitypool, props.openSearchDomainName);\n\n  if (props.vpc) {\n    subnetIds = retrievePrivateSubnetIds(props.vpc);\n\n    if (subnetIds.length > MAXIMUM_AZS_IN_OPENSEARCH_DOMAIN) {\n      subnetIds = subnetIds.slice(0, MAXIMUM_AZS_IN_OPENSEARCH_DOMAIN);\n    }\n\n    constructDrivenProps.vpcOptions = {\n      subnetIds,\n      securityGroupIds: props.securityGroupIds\n    };\n\n    // If the client did not submit a ClusterConfig, then we will create one\n    if (!props.clientDomainProps?.clusterConfig) {\n      constructDrivenProps.clusterConfig = createClusterConfiguration(subnetIds.length);\n    }\n  } else { // No VPC\n    // If the client did not submit a ClusterConfig, then we will create one based on the Region\n    if (!props.clientDomainProps?.clusterConfig) {\n      constructDrivenProps.clusterConfig = createClusterConfiguration(cdk.Stack.of(scope).availabilityZones.length);\n    }\n  }\n\n  const defaultCfnDomainProps = DefaultOpenSearchCfnDomainProps(props.openSearchDomainName, cognitoDashboardConfigureRole, props);\n  const finalCfnDomainProps = consolidateProps(defaultCfnDomainProps, props.clientDomainProps, constructDrivenProps);\n\n  // tlsSecurityPolicy is set in DefaultOpenSearchCfnDomainProps() - it is the\n  // default behavior, but Sonarqube cannot follow the program flow to confirm this.\n  // This is confirmed by the 'Check that TLS 1.2 is the default' test in aws-lambda-opensearch\n  const opensearchDomain = new opensearch.CfnDomain(scope, `OpenSearchDomain`, finalCfnDomainProps); // NOSONAR\n  opensearchDomain.node.addDependency(cognitoDashboardConfigureRole);\n\n  addCfnSuppressRules(opensearchDomain, [\n    {\n      id: \"W28\",\n      reason: `The OpenSearch Service domain is passed dynamically as as parameter and explicitly specified to ensure that IAM policies are configured to lockdown access to this specific OpenSearch Service instance only`,\n    },\n    {\n      id: \"W90\",\n      reason: `This is not a rule for the general case, just for specific use cases/industries`,\n    },\n  ]);\n\n  addCfnGuardSuppressRules(opensearchDomain, [\"CFN_NO_EXPLICIT_RESOURCE_NAMES\"]);\n\n  return  { domain: opensearchDomain, role: cognitoDashboardConfigureRole };\n}\n\n/**\n * @internal This is an internal core function and should not be called directly by Solutions Constructs clients.\n */\nexport function buildOpenSearchCWAlarms(scope: Construct): cloudwatch.Alarm[] {\n  const alarms: cloudwatch.Alarm[] = new Array();\n\n  // ClusterStatus.red maximum is >= 1 for 1 minute, 1 consecutive time\n  alarms.push(new cloudwatch.Alarm(scope, 'StatusRedAlarm', {\n    metric: new cloudwatch.Metric({\n      namespace: 'AWS/ES',\n      metricName: 'ClusterStatus.red',\n      statistic: 'Maximum',\n      period: cdk.Duration.seconds(60),\n    }),\n    threshold: 1,\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'At least one primary shard and its replicas are not allocated to a node. '\n  }));\n\n  // ClusterStatus.yellow maximum is >= 1 for 1 minute, 1 consecutive time\n  alarms.push(new cloudwatch.Alarm(scope, 'StatusYellowAlarm', {\n    metric: new cloudwatch.Metric({\n      namespace: 'AWS/ES',\n      metricName: 'ClusterStatus.yellow',\n      statistic: 'Maximum',\n      period: cdk.Duration.seconds(60),\n    }),\n    threshold: 1,\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'At least one replica shard is not allocated to a node.'\n  }));\n\n  // FreeStorageSpace minimum is <= 20480 for 1 minute, 1 consecutive time\n  alarms.push(new cloudwatch.Alarm(scope, 'FreeStorageSpaceTooLowAlarm', {\n    metric: new cloudwatch.Metric({\n      namespace: 'AWS/ES',\n      metricName: 'FreeStorageSpace',\n      statistic: 'Minimum',\n      period: cdk.Duration.seconds(60),\n    }),\n    threshold: 20000,\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'A node in your cluster is down to 20 GiB of free storage space.'\n  }));\n\n  // ClusterIndexWritesBlocked is >= 1 for 5 minutes, 1 consecutive time\n  alarms.push(new cloudwatch.Alarm(scope, 'IndexWritesBlockedTooHighAlarm', {\n    metric: new cloudwatch.Metric({\n      namespace: 'AWS/ES',\n      metricName: 'ClusterIndexWritesBlocked',\n      statistic: 'Maximum',\n      period: cdk.Duration.seconds(300),\n    }),\n    threshold: 1,\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'Your cluster is blocking write requests.'\n  }));\n\n  // AutomatedSnapshotFailure maximum is >= 1 for 1 minute, 1 consecutive time\n  alarms.push(new cloudwatch.Alarm(scope, 'AutomatedSnapshotFailureTooHighAlarm', {\n    metric: new cloudwatch.Metric({\n      namespace: 'AWS/ES',\n      metricName: 'AutomatedSnapshotFailure',\n      statistic: 'Maximum',\n      period: cdk.Duration.seconds(60),\n    }),\n    threshold: 1,\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'An automated snapshot failed. This failure is often the result of a red cluster health status.'\n  }));\n\n  // CPUUtilization maximum is >= 80% for 15 minutes, 3 consecutive times\n  alarms.push(new cloudwatch.Alarm(scope, 'CPUUtilizationTooHighAlarm', {\n    metric: new cloudwatch.Metric({\n      namespace: 'AWS/ES',\n      metricName: 'CPUUtilization',\n      statistic: 'Average',\n      period: cdk.Duration.seconds(900),\n    }),\n    threshold: 80,\n    evaluationPeriods: 3,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: '100% CPU utilization is not uncommon, but sustained high usage is problematic. Consider using larger instance types or adding instances.'\n  }));\n\n  // JVMMemoryPressure maximum is >= 80% for 5 minutes, 3 consecutive times\n  alarms.push(new cloudwatch.Alarm(scope, 'JVMMemoryPressureTooHighAlarm', {\n    metric: new cloudwatch.Metric({\n      namespace: 'AWS/ES',\n      metricName: 'JVMMemoryPressure',\n      statistic: 'Average',\n      period: cdk.Duration.seconds(900),\n    }),\n    threshold: 80,\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'Average JVM memory pressure over last 15 minutes too high. Consider scaling vertically.'\n  }));\n\n  // MasterCPUUtilization maximum is >= 50% for 15 minutes, 3 consecutive times\n  alarms.push(new cloudwatch.Alarm(scope, 'MasterCPUUtilizationTooHighAlarm', {\n    metric: new cloudwatch.Metric({\n      namespace: 'AWS/ES',\n      metricName: 'MasterCPUUtilization',\n      statistic: 'Average',\n      period: cdk.Duration.seconds(900),\n    }),\n    threshold: 50,\n    evaluationPeriods: 3,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'Average CPU utilization over last 45 minutes too high. Consider using larger instance types for your dedicated master nodes.'\n  }));\n\n  // MasterJVMMemoryPressure maximum is >= 80% for 15 minutes, 1 consecutive time\n  alarms.push(new cloudwatch.Alarm(scope, 'MasterJVMMemoryPressureTooHighAlarm', {\n    metric: new cloudwatch.Metric({\n      namespace: 'AWS/ES',\n      metricName: 'MasterJVMMemoryPressure',\n      statistic: 'Average',\n      period: cdk.Duration.seconds(900),\n    }),\n    threshold: 50,\n    evaluationPeriods: 1,\n    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,\n    alarmDescription: 'Average JVM memory pressure over last 15 minutes too high. Consider scaling vertically.'\n  }));\n\n  return alarms;\n}\n\nfunction createClusterConfiguration(numberOfAzs?: number): opensearch.CfnDomain.ClusterConfigProperty {\n  return {\n    dedicatedMasterEnabled: true,\n    dedicatedMasterCount: 3,\n    zoneAwarenessEnabled: true,\n    zoneAwarenessConfig: {\n      availabilityZoneCount: numberOfAzs\n    },\n    instanceCount: numberOfAzs,\n  };\n}\n\nfunction createDashboardCognitoRole(\n  scope: Construct,\n  userPool: cognito.UserPool,\n  identitypool: cognito.CfnIdentityPool,\n  domainName: string\n): iam.Role {\n  // Setup the IAM Role & policy for the OpenSearch Service to configure Cognito User pool and Identity pool\n  const cognitoDashboardConfigureRole = new iam.Role(\n    scope,\n    \"CognitoDashboardConfigureRole\",\n    {\n      assumedBy: new iam.ServicePrincipal(\"es.amazonaws.com\"),\n    }\n  );\n\n  const cognitoDashboardConfigureRolePolicy = new iam.Policy(\n    scope,\n    \"CognitoDashboardConfigureRolePolicy\",\n    {\n      statements: [\n        new iam.PolicyStatement({\n          actions: [\n            \"cognito-idp:DescribeUserPool\",\n            \"cognito-idp:CreateUserPoolClient\",\n            \"cognito-idp:DeleteUserPoolClient\",\n            \"cognito-idp:DescribeUserPoolClient\",\n            \"cognito-idp:AdminInitiateAuth\",\n            \"cognito-idp:AdminUserGlobalSignOut\",\n            \"cognito-idp:ListUserPoolClients\",\n            \"cognito-identity:DescribeIdentityPool\",\n            \"cognito-identity:UpdateIdentityPool\",\n            \"cognito-identity:SetIdentityPoolRoles\",\n            \"cognito-identity:GetIdentityPoolRoles\",\n            \"es:UpdateDomainConfig\",\n          ],\n          resources: [\n            userPool.userPoolArn,\n            `arn:${cdk.Aws.PARTITION}:cognito-identity:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:identitypool/${identitypool.ref}`,\n            `arn:${cdk.Aws.PARTITION}:es:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:domain/${domainName}`,\n          ],\n        }),\n        new iam.PolicyStatement({\n          actions: [\"iam:PassRole\"],\n          conditions: {\n            StringLike: {\n              \"iam:PassedToService\": \"cognito-identity.amazonaws.com\",\n            },\n          },\n          resources: [cognitoDashboardConfigureRole.roleArn],\n        }),\n      ],\n    }\n  );\n\n  cognitoDashboardConfigureRolePolicy.attachToRole(cognitoDashboardConfigureRole);\n  return cognitoDashboardConfigureRole;\n}\n\nexport interface OpenSearchProps {\n  readonly openSearchDomainProps?: opensearch.CfnDomainProps;\n}\n\nexport function CheckOpenSearchProps(propsObject: OpenSearchProps | any) {\n  let errorMessages = '';\n  let errorFound = false;\n\n  if (propsObject.openSearchDomainProps?.vpcOptions) {\n    errorMessages += \"Error - Define VPC using construct parameters not the OpenSearch Service props\\n\";\n    errorFound = true;\n  }\n\n  if (errorFound) {\n    throw new Error(errorMessages);\n  }\n}\n"]}

package/node_modules/@aws-solutions-constructs/core/lib/polly-helper.d.ts

@@ -0,0 +1,50 @@
+/**
+ *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import { Construct } from 'constructs';
+import * as kms from 'aws-cdk-lib/aws-kms';
+import * as sns from 'aws-cdk-lib/aws-sns';
+export interface PollyProps {
+    readonly asyncJobs?: boolean;
+    readonly existingBucketObj?: s3.IBucket;
+    readonly bucketProps?: s3.BucketProps;
+    readonly loggingBucketProps?: s3.BucketProps;
+    readonly logS3AccessLogs?: boolean;
+    readonly bucketEnvironmentVariableName?: string;
+    readonly existingTopicObj?: sns.Topic;
+    readonly existingTopicEncryptionKey?: kms.Key;
+    readonly topicProps?: sns.TopicProps;
+    readonly enableTopicEncryptionWithCustomerManagedKey?: boolean;
+    readonly topicEncryptionKey?: kms.Key;
+    readonly topicEncryptionKeyProps?: kms.KeyProps;
+    readonly topicEnvironmentVariableName?: string;
+}
+export interface PollyBucketDetails {
+    readonly bucket?: s3.Bucket;
+    readonly bucketInterface: s3.IBucket;
+    readonly loggingBucket?: s3.Bucket;
+}
+export interface EnvironmentVariableDefinition {
+    readonly defaultName: string;
+    readonly clientNameOverride?: string;
+    readonly value: string;
+}
+export interface PollyConfiguration {
+    readonly destinationBucket?: PollyBucketDetails;
+    readonly snsNotificationTopic?: sns.Topic;
+    readonly notificationTopicEncryptionKey?: kms.Key;
+    readonly lambdaIamActionsRequired: string[];
+    readonly environmentVariables: EnvironmentVariableDefinition[];
+}
+export declare function ConfigurePollySupport(scope: Construct, id: string, props: PollyProps): PollyConfiguration;
+export declare function CheckPollyProps(props: PollyProps): void;

package/node_modules/@aws-solutions-constructs/core/lib/polly-helper.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+ *  with the License. A copy of the License is located at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+ *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurePollySupport = ConfigurePollySupport;
+exports.CheckPollyProps = CheckPollyProps;
+const s3_bucket_helper_1 = require("./s3-bucket-helper");
+const sns_helper_1 = require("./sns-helper");
+const utils_1 = require("./utils");
+const syncPermissions = [
+    'polly:SynthesizeSpeech'
+];
+const asyncPermissions = [
+    'polly:StartSpeechSynthesisTask',
+    'polly:GetSpeechSynthesisTask',
+    'polly:ListSpeechSynthesisTasks'
+];
+function ConfigurePollySupport(scope, id, props) {
+    let configuration = {
+        lambdaIamActionsRequired: [...syncPermissions],
+        environmentVariables: [],
+    };
+    if (props.asyncJobs) {
+        // Setup SNS notification topic
+        const buildTopicResponse = (0, sns_helper_1.buildTopic)(scope, id, {
+            existingTopicObj: props.existingTopicObj,
+            existingTopicEncryptionKey: props.existingTopicEncryptionKey,
+            topicProps: props.topicProps,
+            enableEncryptionWithCustomerManagedKey: props.enableTopicEncryptionWithCustomerManagedKey,
+            encryptionKey: props.topicEncryptionKey,
+            encryptionKeyProps: props.topicEncryptionKeyProps
+        });
+        configuration = (0, utils_1.overrideProps)(configuration, {
+            snsNotificationTopic: buildTopicResponse.topic,
+        });
+        if (buildTopicResponse.key) {
+            configuration = (0, utils_1.overrideProps)(configuration, { notificationTopicEncryptionKey: buildTopicResponse.key });
+        }
+        // Setup S3 Bucket for audio output
+        if (props.existingBucketObj) {
+            configuration = (0, utils_1.overrideProps)(configuration, {
+                destinationBucket: {
+                    bucketInterface: props.existingBucketObj
+                }
+            }, false);
+        }
+        else {
+            const buildBucketResponse = (0, s3_bucket_helper_1.buildS3Bucket)(scope, {
+                bucketProps: props.bucketProps,
+                loggingBucketProps: props.loggingBucketProps,
+                logS3AccessLogs: props.logS3AccessLogs
+            }, `${id}-output-bucket`);
+            configuration = (0, utils_1.overrideProps)(configuration, {
+                destinationBucket: {
+                    bucket: buildBucketResponse.bucket,
+                    loggingBucket: buildBucketResponse.loggingBucket,
+                    bucketInterface: buildBucketResponse.bucket,
+                }
+            }, false);
+        }
+        // Add async permissions
+        asyncPermissions.forEach((permission) => {
+            configuration.lambdaIamActionsRequired.push(permission);
+        });
+        // Build environment variables
+        configuration.environmentVariables.push({
+            defaultName: 'OUTPUT_BUCKET_NAME',
+            clientNameOverride: props.bucketEnvironmentVariableName,
+            value: configuration.destinationBucket.bucketInterface.bucketName
+        });
+        configuration.environmentVariables.push({
+            defaultName: 'SNS_TOPIC_ARN',
+            clientNameOverride: props.topicEnvironmentVariableName,
+            value: configuration.snsNotificationTopic.topicArn
+        });
+    }
+    return configuration;
+}
+function CheckPollyProps(props) {
+    let errorMessages = '';
+    let errorFound = false;
+    if (props.asyncJobs) {
+        // Check for conflicting bucket props
+        if (props.existingBucketObj && props.bucketProps) {
+            errorMessages += 'Error - Either provide bucketProps or existingBucketObj, but not both.\n';
+            errorFound = true;
+        }
+        // Check for conflicting topic props
+        if (props.existingTopicObj && props.topicProps) {
+            errorMessages += 'Error - Either provide topicProps or existingTopicObj, but not both.\n';
+            errorFound = true;
+        }
+        // Check SNS encryption props
+        if (props.topicProps?.masterKey && props.topicEncryptionKey) {
+            errorMessages += 'Error - Either provide topicProps.masterKey or topicEncryptionKey, but not both.\n';
+            errorFound = true;
+        }
+        if (props.topicProps?.masterKey && props.topicEncryptionKeyProps) {
+            errorMessages += 'Error - Either provide topicProps.masterKey or topicEncryptionKeyProps, but not both.\n';
+            errorFound = true;
+        }
+        if (props.topicEncryptionKey && props.topicEncryptionKeyProps) {
+            errorMessages += 'Error - Either provide topicEncryptionKey or topicEncryptionKeyProps, but not both.\n';
+            errorFound = true;
+        }
+    }
+    // If asyncJobs is false or undefined, no bucket or topic props should be provided
+    if (!props.asyncJobs) {
+        if (props.existingBucketObj || props.bucketProps ||
+            props.loggingBucketProps || props.logS3AccessLogs !== undefined ||
+            props.bucketEnvironmentVariableName) {
+            errorMessages += 'Error - Bucket properties can only be provided when asyncJobs is true.\n';
+            errorFound = true;
+        }
+        if (props.existingTopicObj || props.topicProps ||
+            props.existingTopicEncryptionKey || props.topicEncryptionKey ||
+            props.topicEncryptionKeyProps ||
+            props.enableTopicEncryptionWithCustomerManagedKey !== undefined ||
+            props.topicEnvironmentVariableName) {
+            errorMessages += 'Error - Topic properties can only be provided when asyncJobs is true.\n';
+            errorFound = true;
+        }
+    }
+    if (errorFound) {
+        throw new Error(errorMessages);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"polly-helper.js","sourceRoot":"","sources":["polly-helper.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n *  with the License. A copy of the License is located at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES\n *  OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions\n *  and limitations under the License.\n */\n\n/*\n *  The functions found here in the core library are for internal use and can be changed\n *  or removed outside of a major release. We recommend against calling them directly from client code.\n */\n\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport { Construct } from 'constructs';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport { buildS3Bucket } from './s3-bucket-helper';\nimport { buildTopic } from './sns-helper';\nimport { overrideProps } from './utils';\nimport * as sns from 'aws-cdk-lib/aws-sns';\n\nexport interface PollyProps {\n  readonly asyncJobs?: boolean;\n  readonly existingBucketObj?: s3.IBucket;\n  readonly bucketProps?: s3.BucketProps;\n  readonly loggingBucketProps?: s3.BucketProps;\n  readonly logS3AccessLogs?: boolean;\n  readonly bucketEnvironmentVariableName?: string;\n  readonly existingTopicObj?: sns.Topic;\n  readonly existingTopicEncryptionKey?: kms.Key;\n  readonly topicProps?: sns.TopicProps;\n  readonly enableTopicEncryptionWithCustomerManagedKey?: boolean;\n  readonly topicEncryptionKey?: kms.Key;\n  readonly topicEncryptionKeyProps?: kms.KeyProps;\n  readonly topicEnvironmentVariableName?: string;\n}\n\nexport interface PollyBucketDetails {\n  readonly bucket?: s3.Bucket,\n  readonly bucketInterface: s3.IBucket,\n  readonly loggingBucket?: s3.Bucket\n}\n\nexport interface EnvironmentVariableDefinition {\n  readonly defaultName: string;\n  readonly clientNameOverride?: string;\n  readonly value: string;\n}\n\nexport interface PollyConfiguration {\n  readonly destinationBucket?: PollyBucketDetails,\n  readonly snsNotificationTopic?: sns.Topic,\n  readonly notificationTopicEncryptionKey?: kms.Key,\n  readonly lambdaIamActionsRequired: string[],\n  readonly environmentVariables: EnvironmentVariableDefinition[],\n}\n\nconst syncPermissions = [\n  'polly:SynthesizeSpeech'\n];\n\nconst asyncPermissions = [\n  'polly:StartSpeechSynthesisTask',\n  'polly:GetSpeechSynthesisTask',\n  'polly:ListSpeechSynthesisTasks'\n];\n\nexport function ConfigurePollySupport(scope: Construct, id: string, props: PollyProps): PollyConfiguration {\n\n  let configuration: PollyConfiguration = {\n    lambdaIamActionsRequired: [...syncPermissions],\n    environmentVariables: [],\n  };\n\n  if (props.asyncJobs) {\n    // Setup SNS notification topic\n    const buildTopicResponse = buildTopic(scope, id, {\n      existingTopicObj: props.existingTopicObj,\n      existingTopicEncryptionKey: props.existingTopicEncryptionKey,\n      topicProps: props.topicProps,\n      enableEncryptionWithCustomerManagedKey: props.enableTopicEncryptionWithCustomerManagedKey,\n      encryptionKey: props.topicEncryptionKey,\n      encryptionKeyProps: props.topicEncryptionKeyProps\n    });\n\n    configuration = overrideProps(configuration, {\n      snsNotificationTopic: buildTopicResponse.topic,\n    });\n\n    if (buildTopicResponse.key) {\n      configuration = overrideProps(configuration, { notificationTopicEncryptionKey: buildTopicResponse.key });\n    }\n\n    // Setup S3 Bucket for audio output\n    if (props.existingBucketObj) {\n      configuration = overrideProps(configuration, {\n        destinationBucket: {\n          bucketInterface: props.existingBucketObj\n        }\n      }, false);\n    } else {\n      const buildBucketResponse = buildS3Bucket(scope, {\n        bucketProps: props.bucketProps,\n        loggingBucketProps: props.loggingBucketProps,\n        logS3AccessLogs: props.logS3AccessLogs\n      }, `${id}-output-bucket`);\n\n      configuration = overrideProps(configuration, {\n        destinationBucket: {\n          bucket: buildBucketResponse.bucket,\n          loggingBucket: buildBucketResponse.loggingBucket,\n          bucketInterface: buildBucketResponse.bucket,\n        }\n      }, false);\n    }\n\n    // Add async permissions\n    asyncPermissions.forEach((permission) => {\n      configuration.lambdaIamActionsRequired.push(permission);\n    });\n\n    // Build environment variables\n    configuration.environmentVariables.push({\n      defaultName: 'OUTPUT_BUCKET_NAME',\n      clientNameOverride: props.bucketEnvironmentVariableName,\n      value: configuration.destinationBucket!.bucketInterface.bucketName\n    });\n\n    configuration.environmentVariables.push({\n      defaultName: 'SNS_TOPIC_ARN',\n      clientNameOverride: props.topicEnvironmentVariableName,\n      value: configuration.snsNotificationTopic!.topicArn\n    });\n  }\n\n  return configuration;\n}\n\nexport function CheckPollyProps(props: PollyProps): void {\n  let errorMessages = '';\n  let errorFound = false;\n\n  if (props.asyncJobs) {\n    // Check for conflicting bucket props\n    if (props.existingBucketObj && props.bucketProps) {\n      errorMessages += 'Error - Either provide bucketProps or existingBucketObj, but not both.\\n';\n      errorFound = true;\n    }\n\n    // Check for conflicting topic props\n    if (props.existingTopicObj && props.topicProps) {\n      errorMessages += 'Error - Either provide topicProps or existingTopicObj, but not both.\\n';\n      errorFound = true;\n    }\n\n    // Check SNS encryption props\n    if (props.topicProps?.masterKey && props.topicEncryptionKey) {\n      errorMessages += 'Error - Either provide topicProps.masterKey or topicEncryptionKey, but not both.\\n';\n      errorFound = true;\n    }\n\n    if (props.topicProps?.masterKey && props.topicEncryptionKeyProps) {\n      errorMessages += 'Error - Either provide topicProps.masterKey or topicEncryptionKeyProps, but not both.\\n';\n      errorFound = true;\n    }\n\n    if (props.topicEncryptionKey && props.topicEncryptionKeyProps) {\n      errorMessages += 'Error - Either provide topicEncryptionKey or topicEncryptionKeyProps, but not both.\\n';\n      errorFound = true;\n    }\n  }\n\n  // If asyncJobs is false or undefined, no bucket or topic props should be provided\n  if (!props.asyncJobs) {\n    if (props.existingBucketObj || props.bucketProps ||\n      props.loggingBucketProps || props.logS3AccessLogs !== undefined ||\n      props.bucketEnvironmentVariableName) {\n      errorMessages += 'Error - Bucket properties can only be provided when asyncJobs is true.\\n';\n      errorFound = true;\n    }\n\n    if (props.existingTopicObj || props.topicProps ||\n      props.existingTopicEncryptionKey || props.topicEncryptionKey ||\n      props.topicEncryptionKeyProps ||\n      props.enableTopicEncryptionWithCustomerManagedKey !== undefined ||\n      props.topicEnvironmentVariableName) {\n      errorMessages += 'Error - Topic properties can only be provided when asyncJobs is true.\\n';\n      errorFound = true;\n    }\n  }\n\n  if (errorFound) {\n    throw new Error(errorMessages);\n  }\n}\n"]}