@aws-solutions-constructs/core 2.25.0 → 2.26.0

package/lib/kinesis-streams-helper.js

@@ -42,7 +42,7 @@ function buildKinesisStreamCWAlarms(scope) {
             statistic: 'Maximum',
             period: cdk.Duration.minutes(5),
         }),
-        threshold: 43200,
+        threshold: 43200000,
         evaluationPeriods: 1,
         comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
         alarmDescription: 'Consumer Record Processing Falling Behind, there is risk for data loss due to record expiration.'
@@ -63,4 +63,4 @@ function buildKinesisStreamCWAlarms(scope) {
     return alarms;
 }
 exports.buildKinesisStreamCWAlarms = buildKinesisStreamCWAlarms;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/opensearch-defaults.d.ts

@@ -0,0 +1,16 @@
+/**
+ *  Copyright 2022 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 opensearch from 'aws-cdk-lib/aws-opensearchservice';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { BuildOpenSearchProps } from './opensearch-helper';
+export declare function DefaultOpenSearchCfnDomainProps(domainName: string, cognitoConfigureRole: iam.Role, props: BuildOpenSearchProps): opensearch.CfnDomainProps;

package/lib/opensearch-defaults.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ *  Copyright 2022 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.DefaultOpenSearchCfnDomainProps = void 0;
+const iam = require("aws-cdk-lib/aws-iam");
+const cdk = require("aws-cdk-lib");
+function DefaultOpenSearchCfnDomainProps(domainName, cognitoConfigureRole, props) {
+    const roleARNs = [];
+    roleARNs.push(new iam.ArnPrincipal(props.cognitoAuthorizedRoleARN));
+    if (props.serviceRoleARN) {
+        roleARNs.push(new iam.ArnPrincipal(props.serviceRoleARN));
+    }
+    // Features supported by engine version:
+    // https://docs.aws.amazon.com/opensearch-service/latest/developerguide/features-by-version.html
+    // https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_opensearchservice.CfnDomainProps.html
+    return {
+        domainName,
+        engineVersion: 'OpenSearch_1.3',
+        encryptionAtRestOptions: {
+            enabled: true
+        },
+        nodeToNodeEncryptionOptions: {
+            enabled: true
+        },
+        snapshotOptions: {
+            automatedSnapshotStartHour: 1
+        },
+        ebsOptions: {
+            ebsEnabled: true,
+            volumeSize: 10
+        },
+        cognitoOptions: {
+            enabled: true,
+            identityPoolId: props.identitypool.ref,
+            userPoolId: props.userpool.userPoolId,
+            roleArn: cognitoConfigureRole.roleArn
+        },
+        accessPolicies: new iam.PolicyDocument({
+            statements: [
+                new iam.PolicyStatement({
+                    principals: roleARNs,
+                    actions: [
+                        'es:ESHttp*'
+                    ],
+                    resources: [
+                        `arn:aws:es:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:domain/${domainName}/*`
+                    ]
+                })
+            ]
+        })
+    };
+}
+exports.DefaultOpenSearchCfnDomainProps = DefaultOpenSearchCfnDomainProps;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/opensearch-helper.d.ts

@@ -0,0 +1,30 @@
+/**
+ *  Copyright 2022 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 opensearch from 'aws-cdk-lib/aws-opensearchservice';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
+import * as cognito from 'aws-cdk-lib/aws-cognito';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import { Construct } from 'constructs';
+export interface BuildOpenSearchProps {
+    readonly identitypool: cognito.CfnIdentityPool;
+    readonly userpool: cognito.UserPool;
+    readonly cognitoAuthorizedRoleARN: string;
+    readonly serviceRoleARN?: string;
+    readonly vpc?: ec2.IVpc;
+    readonly openSearchDomainName: string;
+    readonly clientDomainProps?: opensearch.CfnDomainProps;
+    readonly securityGroupIds?: string[];
+}
+export declare function buildOpenSearch(scope: Construct, props: BuildOpenSearchProps): [opensearch.CfnDomain, iam.Role];
+export declare function buildOpenSearchCWAlarms(scope: Construct): cloudwatch.Alarm[];

package/lib/opensearch-helper.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ *  Copyright 2022 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.buildOpenSearchCWAlarms = exports.buildOpenSearch = void 0;
+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;
+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 = 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 = opensearch_defaults_1.DefaultOpenSearchCfnDomainProps(props.openSearchDomainName, cognitoDashboardConfigureRole, props);
+    const finalCfnDomainProps = utils_1.consolidateProps(defaultCfnDomainProps, props.clientDomainProps, constructDrivenProps);
+    const opensearchDomain = new opensearch.CfnDomain(scope, `OpenSearchDomain`, finalCfnDomainProps);
+    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`,
+        },
+    ]);
+    return [opensearchDomain, cognitoDashboardConfigureRole];
+}
+exports.buildOpenSearch = buildOpenSearch;
+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;
+}
+exports.buildOpenSearchCWAlarms = buildOpenSearchCWAlarms;
+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:aws:cognito-identity:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:identitypool/${identitypool.ref}`,
+                    `arn:aws: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;
+}
+//# 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 2022 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\nimport * as opensearch from 'aws-cdk-lib/aws-opensearchservice';\nimport { DefaultOpenSearchCfnDomainProps } from './opensearch-defaults';\nimport { retrievePrivateSubnetIds } from './vpc-helper';\nimport { consolidateProps, addCfnSuppressRules } 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 function buildOpenSearch(scope: Construct, props: BuildOpenSearchProps): [opensearch.CfnDomain, iam.Role] {\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  const opensearchDomain = new opensearch.CfnDomain(scope, `OpenSearchDomain`, finalCfnDomainProps);\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  return [opensearchDomain, cognitoDashboardConfigureRole];\n}\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:aws:cognito-identity:${cdk.Aws.REGION}:${cdk.Aws.ACCOUNT_ID}:identitypool/${identitypool.ref}`,\n            `arn:aws: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"]}

package/lib/vpc-helper.d.ts

@@ -46,3 +46,4 @@ export declare enum ServiceEndpointTypes {
     EVENTS = "CLOUDWATCH_EVENTS"
 }
 export declare function AddAwsServiceEndpoint(scope: Construct, vpc: ec2.IVpc, interfaceTag: ServiceEndpointTypes): void;
+export declare function retrievePrivateSubnetIds(vpc: ec2.IVpc): string[];

package/lib/vpc-helper.js

@@ -12,7 +12,7 @@
  *  and limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddAwsServiceEndpoint = exports.ServiceEndpointTypes = exports.buildVpc = void 0;
+exports.retrievePrivateSubnetIds = exports.AddAwsServiceEndpoint = exports.ServiceEndpointTypes = exports.buildVpc = void 0;
 const ec2 = require("aws-cdk-lib/aws-ec2");
 const security_group_helper_1 = require("./security-group-helper");
 const utils_1 = require("./utils");
@@ -163,4 +163,22 @@ function AddGatewayEndpoint(vpc, service, interfaceTag) {
         service: service.endpointGatewayService,
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpc-helper.js","sourceRoot":"","sources":["vpc-helper.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 2022 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\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\";\nimport { CfnLogGroup } from \"aws-cdk-lib/aws-logs\";\nimport { Construct } from \"constructs\";\nimport { buildSecurityGroup } from \"./security-group-helper\";\nimport { consolidateProps, addCfnSuppressRules } from \"./utils\";\n\nexport interface BuildVpcProps {\n  /**\n   * Existing instance of a VPC, if this is set then the all Props are ignored\n   */\n  readonly existingVpc?: ec2.IVpc;\n  /**\n   * One of the default VPC configurations available in vpc-defaults\n   */\n  readonly defaultVpcProps: ec2.VpcProps;\n  /**\n   * User provided props to override the default props for the VPC.\n   */\n  readonly userVpcProps?: ec2.VpcProps;\n  /**\n   * Construct specified props that override both the default props\n   * and user props for the VPC.\n   */\n  readonly constructVpcProps?: ec2.VpcProps;\n}\n\nexport function buildVpc(scope: Construct, props: BuildVpcProps): ec2.IVpc {\n  if (props?.existingVpc) {\n    return props?.existingVpc;\n  }\n\n  let cumulativeProps: ec2.VpcProps = props?.defaultVpcProps;\n\n  cumulativeProps = consolidateProps(cumulativeProps, props?.userVpcProps, props?.constructVpcProps);\n\n  const vpc = new ec2.Vpc(scope, \"Vpc\", cumulativeProps);\n\n  // Add VPC FlowLogs with the default setting of trafficType:ALL and destination: CloudWatch Logs\n  const flowLog: ec2.FlowLog = vpc.addFlowLog(\"FlowLog\");\n\n  SuppressMapPublicIpWarnings(vpc);\n  SuppressEncryptedLogWarnings(flowLog);\n\n  return vpc;\n}\n\nexport enum ServiceEndpointTypes {\n  DYNAMODB = \"DDB\",\n  SNS = \"SNS\",\n  SQS = \"SQS\",\n  S3 = \"S3\",\n  STEP_FUNCTIONS = \"STEP_FUNCTIONS\",\n  SAGEMAKER_RUNTIME = \"SAGEMAKER_RUNTIME\",\n  SECRETS_MANAGER = \"SECRETS_MANAGER\",\n  SSM = \"SSM\",\n  ECR_API = \"ECR_API\",\n  ECR_DKR = \"ECR_DKR\",\n  EVENTS = \"CLOUDWATCH_EVENTS\"\n}\n\nenum EndpointTypes {\n  GATEWAY = \"Gateway\",\n  INTERFACE = \"Interface\",\n}\n\ninterface EndpointDefinition {\n  endpointName: ServiceEndpointTypes;\n  endpointType: EndpointTypes;\n  endpointGatewayService?: ec2.GatewayVpcEndpointAwsService;\n  endpointInterfaceService?: ec2.InterfaceVpcEndpointAwsService;\n}\n\nconst endpointSettings: EndpointDefinition[] = [\n  {\n    endpointName: ServiceEndpointTypes.DYNAMODB,\n    endpointType: EndpointTypes.GATEWAY,\n    endpointGatewayService: ec2.GatewayVpcEndpointAwsService.DYNAMODB,\n  },\n  {\n    endpointName: ServiceEndpointTypes.S3,\n    endpointType: EndpointTypes.GATEWAY,\n    endpointGatewayService: ec2.GatewayVpcEndpointAwsService.S3,\n  },\n  {\n    endpointName: ServiceEndpointTypes.STEP_FUNCTIONS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.STEP_FUNCTIONS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SNS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SNS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SQS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SQS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SAGEMAKER_RUNTIME,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SAGEMAKER_RUNTIME,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SECRETS_MANAGER,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SECRETS_MANAGER,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SSM,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SSM,\n  },\n  {\n    endpointName: ServiceEndpointTypes.ECR_API,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.ECR\n  },\n  {\n    endpointName: ServiceEndpointTypes.ECR_DKR,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER\n  },\n  {\n    endpointName: ServiceEndpointTypes.EVENTS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.CLOUDWATCH_EVENTS\n  }\n];\n\nexport function AddAwsServiceEndpoint(\n  scope: Construct,\n  vpc: ec2.IVpc,\n  interfaceTag: ServiceEndpointTypes\n) {\n  if (CheckIfEndpointAlreadyExists(vpc, interfaceTag)) {\n    return;\n  }\n\n  const service = endpointSettings.find(\n    (endpoint) => endpoint.endpointName === interfaceTag\n  );\n\n  if (!service) {\n    throw new Error(\"Unsupported Service sent to AddServiceEndpoint\");\n  }\n\n  if (service.endpointType === EndpointTypes.GATEWAY) {\n    AddGatewayEndpoint(vpc, service, interfaceTag);\n  }\n  if (service.endpointType === EndpointTypes.INTERFACE) {\n    AddInterfaceEndpoint(scope, vpc, service, interfaceTag);\n  }\n\n  return;\n}\n\nfunction CheckIfEndpointAlreadyExists(vpc: ec2.IVpc, interfaceTag: ServiceEndpointTypes): boolean {\n  return vpc.node.children.some((child) => child.node.id === interfaceTag);\n}\n\nfunction SuppressMapPublicIpWarnings(vpc: ec2.Vpc) {\n  // Add Cfn Nag suppression for PUBLIC subnets to suppress WARN W33: EC2 Subnet should not have MapPublicIpOnLaunch set to true\n  vpc.publicSubnets.forEach((subnet) => {\n    const cfnSubnet = subnet.node.defaultChild as ec2.CfnSubnet;\n    addCfnSuppressRules(cfnSubnet, [\n      {\n        id: 'W33',\n        reason: 'Allow Public Subnets to have MapPublicIpOnLaunch set to true'\n      }\n    ]);\n  });\n}\n\nfunction SuppressEncryptedLogWarnings(flowLog: ec2.FlowLog) {\n  // Add Cfn Nag suppression for CloudWatchLogs LogGroups data is encrypted\n  const cfnLogGroup: CfnLogGroup = flowLog.logGroup?.node.defaultChild as CfnLogGroup;\n  addCfnSuppressRules(cfnLogGroup, [\n    {\n      id: 'W84',\n      reason: 'By default CloudWatchLogs LogGroups data is encrypted using the CloudWatch server-side encryption keys (AWS Managed Keys)'\n    }\n  ]);\n}\n\nfunction AddInterfaceEndpoint(scope: Construct, vpc: ec2.IVpc, service: EndpointDefinition, interfaceTag: ServiceEndpointTypes) {\n  const endpointDefaultSecurityGroup = buildSecurityGroup(\n    scope,\n    `${scope.node.id}-${service.endpointName}`,\n    {\n      vpc,\n      allowAllOutbound: true,\n    },\n    [{ peer: ec2.Peer.ipv4(vpc.vpcCidrBlock), connection: ec2.Port.tcp(443) }],\n    []\n  );\n\n  vpc.addInterfaceEndpoint(interfaceTag, {\n    service: service.endpointInterfaceService as ec2.InterfaceVpcEndpointAwsService,\n    securityGroups: [endpointDefaultSecurityGroup],\n  });\n}\n\nfunction AddGatewayEndpoint(vpc: ec2.IVpc, service: EndpointDefinition, interfaceTag: ServiceEndpointTypes) {\n  vpc.addGatewayEndpoint(interfaceTag, {\n    service: service.endpointGatewayService as ec2.GatewayVpcEndpointAwsService,\n  });\n}"]}
+function retrievePrivateSubnetIds(vpc) {
+    let targetSubnetType;
+    if (vpc.isolatedSubnets.length) {
+        targetSubnetType = ec2.SubnetType.PRIVATE_ISOLATED;
+    }
+    else if (vpc.privateSubnets.length) {
+        targetSubnetType = ec2.SubnetType.PRIVATE_WITH_EGRESS;
+    }
+    else {
+        throw new Error('Error - No isolated or private subnets available in VPC');
+    }
+    const subnetSelector = {
+        onePerAz: true,
+        subnetType: targetSubnetType
+    };
+    return vpc.selectSubnets(subnetSelector).subnetIds;
+}
+exports.retrievePrivateSubnetIds = retrievePrivateSubnetIds;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpc-helper.js","sourceRoot":"","sources":["vpc-helper.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *  Copyright 2022 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\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\";\nimport { CfnLogGroup } from \"aws-cdk-lib/aws-logs\";\nimport { Construct } from \"constructs\";\nimport { buildSecurityGroup } from \"./security-group-helper\";\nimport { consolidateProps, addCfnSuppressRules } from \"./utils\";\n\nexport interface BuildVpcProps {\n  /**\n   * Existing instance of a VPC, if this is set then the all Props are ignored\n   */\n  readonly existingVpc?: ec2.IVpc;\n  /**\n   * One of the default VPC configurations available in vpc-defaults\n   */\n  readonly defaultVpcProps: ec2.VpcProps;\n  /**\n   * User provided props to override the default props for the VPC.\n   */\n  readonly userVpcProps?: ec2.VpcProps;\n  /**\n   * Construct specified props that override both the default props\n   * and user props for the VPC.\n   */\n  readonly constructVpcProps?: ec2.VpcProps;\n}\n\nexport function buildVpc(scope: Construct, props: BuildVpcProps): ec2.IVpc {\n  if (props?.existingVpc) {\n    return props?.existingVpc;\n  }\n\n  let cumulativeProps: ec2.VpcProps = props?.defaultVpcProps;\n\n  cumulativeProps = consolidateProps(cumulativeProps, props?.userVpcProps, props?.constructVpcProps);\n\n  const vpc = new ec2.Vpc(scope, \"Vpc\", cumulativeProps);\n\n  // Add VPC FlowLogs with the default setting of trafficType:ALL and destination: CloudWatch Logs\n  const flowLog: ec2.FlowLog = vpc.addFlowLog(\"FlowLog\");\n\n  SuppressMapPublicIpWarnings(vpc);\n  SuppressEncryptedLogWarnings(flowLog);\n\n  return vpc;\n}\n\nexport enum ServiceEndpointTypes {\n  DYNAMODB = \"DDB\",\n  SNS = \"SNS\",\n  SQS = \"SQS\",\n  S3 = \"S3\",\n  STEP_FUNCTIONS = \"STEP_FUNCTIONS\",\n  SAGEMAKER_RUNTIME = \"SAGEMAKER_RUNTIME\",\n  SECRETS_MANAGER = \"SECRETS_MANAGER\",\n  SSM = \"SSM\",\n  ECR_API = \"ECR_API\",\n  ECR_DKR = \"ECR_DKR\",\n  EVENTS = \"CLOUDWATCH_EVENTS\"\n}\n\nenum EndpointTypes {\n  GATEWAY = \"Gateway\",\n  INTERFACE = \"Interface\",\n}\n\ninterface EndpointDefinition {\n  endpointName: ServiceEndpointTypes;\n  endpointType: EndpointTypes;\n  endpointGatewayService?: ec2.GatewayVpcEndpointAwsService;\n  endpointInterfaceService?: ec2.InterfaceVpcEndpointAwsService;\n}\n\nconst endpointSettings: EndpointDefinition[] = [\n  {\n    endpointName: ServiceEndpointTypes.DYNAMODB,\n    endpointType: EndpointTypes.GATEWAY,\n    endpointGatewayService: ec2.GatewayVpcEndpointAwsService.DYNAMODB,\n  },\n  {\n    endpointName: ServiceEndpointTypes.S3,\n    endpointType: EndpointTypes.GATEWAY,\n    endpointGatewayService: ec2.GatewayVpcEndpointAwsService.S3,\n  },\n  {\n    endpointName: ServiceEndpointTypes.STEP_FUNCTIONS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.STEP_FUNCTIONS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SNS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SNS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SQS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SQS,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SAGEMAKER_RUNTIME,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SAGEMAKER_RUNTIME,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SECRETS_MANAGER,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SECRETS_MANAGER,\n  },\n  {\n    endpointName: ServiceEndpointTypes.SSM,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.SSM,\n  },\n  {\n    endpointName: ServiceEndpointTypes.ECR_API,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.ECR\n  },\n  {\n    endpointName: ServiceEndpointTypes.ECR_DKR,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER\n  },\n  {\n    endpointName: ServiceEndpointTypes.EVENTS,\n    endpointType: EndpointTypes.INTERFACE,\n    endpointInterfaceService: ec2.InterfaceVpcEndpointAwsService.CLOUDWATCH_EVENTS\n  }\n];\n\nexport function AddAwsServiceEndpoint(\n  scope: Construct,\n  vpc: ec2.IVpc,\n  interfaceTag: ServiceEndpointTypes\n) {\n  if (CheckIfEndpointAlreadyExists(vpc, interfaceTag)) {\n    return;\n  }\n\n  const service = endpointSettings.find(\n    (endpoint) => endpoint.endpointName === interfaceTag\n  );\n\n  if (!service) {\n    throw new Error(\"Unsupported Service sent to AddServiceEndpoint\");\n  }\n\n  if (service.endpointType === EndpointTypes.GATEWAY) {\n    AddGatewayEndpoint(vpc, service, interfaceTag);\n  }\n  if (service.endpointType === EndpointTypes.INTERFACE) {\n    AddInterfaceEndpoint(scope, vpc, service, interfaceTag);\n  }\n\n  return;\n}\n\nfunction CheckIfEndpointAlreadyExists(vpc: ec2.IVpc, interfaceTag: ServiceEndpointTypes): boolean {\n  return vpc.node.children.some((child) => child.node.id === interfaceTag);\n}\n\nfunction SuppressMapPublicIpWarnings(vpc: ec2.Vpc) {\n  // Add Cfn Nag suppression for PUBLIC subnets to suppress WARN W33: EC2 Subnet should not have MapPublicIpOnLaunch set to true\n  vpc.publicSubnets.forEach((subnet) => {\n    const cfnSubnet = subnet.node.defaultChild as ec2.CfnSubnet;\n    addCfnSuppressRules(cfnSubnet, [\n      {\n        id: 'W33',\n        reason: 'Allow Public Subnets to have MapPublicIpOnLaunch set to true'\n      }\n    ]);\n  });\n}\n\nfunction SuppressEncryptedLogWarnings(flowLog: ec2.FlowLog) {\n  // Add Cfn Nag suppression for CloudWatchLogs LogGroups data is encrypted\n  const cfnLogGroup: CfnLogGroup = flowLog.logGroup?.node.defaultChild as CfnLogGroup;\n  addCfnSuppressRules(cfnLogGroup, [\n    {\n      id: 'W84',\n      reason: 'By default CloudWatchLogs LogGroups data is encrypted using the CloudWatch server-side encryption keys (AWS Managed Keys)'\n    }\n  ]);\n}\n\nfunction AddInterfaceEndpoint(scope: Construct, vpc: ec2.IVpc, service: EndpointDefinition, interfaceTag: ServiceEndpointTypes) {\n  const endpointDefaultSecurityGroup = buildSecurityGroup(\n    scope,\n    `${scope.node.id}-${service.endpointName}`,\n    {\n      vpc,\n      allowAllOutbound: true,\n    },\n    [{ peer: ec2.Peer.ipv4(vpc.vpcCidrBlock), connection: ec2.Port.tcp(443) }],\n    []\n  );\n\n  vpc.addInterfaceEndpoint(interfaceTag, {\n    service: service.endpointInterfaceService as ec2.InterfaceVpcEndpointAwsService,\n    securityGroups: [endpointDefaultSecurityGroup],\n  });\n}\n\nfunction AddGatewayEndpoint(vpc: ec2.IVpc, service: EndpointDefinition, interfaceTag: ServiceEndpointTypes) {\n  vpc.addGatewayEndpoint(interfaceTag, {\n    service: service.endpointGatewayService as ec2.GatewayVpcEndpointAwsService,\n  });\n}\n\nexport function retrievePrivateSubnetIds(vpc: ec2.IVpc) {\n  let targetSubnetType;\n\n  if (vpc.isolatedSubnets.length) {\n    targetSubnetType = ec2.SubnetType.PRIVATE_ISOLATED;\n  } else if (vpc.privateSubnets.length) {\n    targetSubnetType = ec2.SubnetType.PRIVATE_WITH_EGRESS;\n  } else {\n    throw new Error('Error - No isolated or private subnets available in VPC');\n  }\n\n  const subnetSelector = {\n    onePerAz: true,\n    subnetType: targetSubnetType\n  };\n\n  return vpc.selectSubnets(subnetSelector).subnetIds;\n}"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-solutions-constructs/core",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "description": "Core CDK Construct for patterns library",
   "main": "index.js",
   "types": "index.ts",
@@ -59,11 +59,11 @@
   "devDependencies": {
     "@types/deep-diff": "^1.0.0",
     "@types/npmlog": "^4.1.2",
-    "@aws-cdk/assert": "2.37.1",
+    "@aws-cdk/assert": "2.45.0",
     "@types/prettier": "2.6.0",
     "@types/jest": "^27.4.0",
     "@types/node": "^10.3.0",
-    "aws-cdk-lib": "2.37.1",
+    "aws-cdk-lib": "2.45.0",
     "constructs": "^10.0.0"
   },
   "jest": {
@@ -86,7 +86,7 @@
     "deep-diff"
   ],
   "peerDependencies": {
-    "aws-cdk-lib": "^2.37.1",
+    "aws-cdk-lib": "^2.45.0",
     "constructs": "^10.0.0"
   }
 }