@cdklabs/multi-az-observability 0.0.0-alpha.0

package/lib/azmapper/AvailabilityZoneMapper.js

@@ -0,0 +1,200 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvailabilityZoneMapper = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const fs = require("fs");
+const path = require("path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const constructs_1 = require("constructs");
+/**
+ * A construct that allows you to map AZ names to ids and back
+ */
+class AvailabilityZoneMapper extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        /*
+        let currentNode: Construct | undefined = this.node.scope;
+    
+        while (currentNode !== undefined && !(currentNode instanceof Stack)) {
+          currentNode = currentNode.node.scope;
+        }
+    
+        if (currentNode !== undefined) {
+          (currentNode as Stack).addTransform('AWS::LanguageExtensions');
+        }
+        */
+        let xrayManagedPolicy = new aws_iam_1.ManagedPolicy(this, 'XrayManagedPolicy', {
+            path: '/azmapper/',
+            statements: [
+                new aws_iam_1.PolicyStatement({
+                    actions: [
+                        'xray:PutTraceSegments',
+                        'xray:PutTelemetryRecords',
+                        'xray:GetSamplingRules',
+                        'xray:GetSamplingTargets',
+                        'xray:GetSamplingStatisticSummaries',
+                    ],
+                    effect: aws_iam_1.Effect.ALLOW,
+                    resources: ['*'],
+                }),
+            ],
+        });
+        let ec2ManagedPolicy = new aws_iam_1.ManagedPolicy(this, 'EC2ManagedPolicy', {
+            path: '/azmapper/',
+            statements: [
+                new aws_iam_1.PolicyStatement({
+                    actions: ['ec2:DescribeAvailabilityZones'],
+                    effect: aws_iam_1.Effect.ALLOW,
+                    resources: ['*'],
+                }),
+            ],
+        });
+        let executionRole = new aws_iam_1.Role(this, 'executionRole', {
+            assumedBy: new aws_iam_1.ServicePrincipal('lambda.amazonaws.com'),
+            path: '/azmapper/',
+            managedPolicies: [xrayManagedPolicy, ec2ManagedPolicy],
+        });
+        const file = fs.readFileSync(path.resolve(__dirname, './../azmapper/src/index.py'), 'utf-8');
+        this.function = new aws_lambda_1.Function(this, 'AvailabilityZoneMapperFunction', {
+            runtime: aws_lambda_1.Runtime.PYTHON_3_12,
+            code: aws_lambda_1.Code.fromInline(file),
+            handler: 'index.handler',
+            role: executionRole,
+            architecture: aws_lambda_1.Architecture.ARM_64,
+            tracing: aws_lambda_1.Tracing.ACTIVE,
+            timeout: aws_cdk_lib_1.Duration.seconds(20),
+            memorySize: 512,
+            environment: {
+                REGION: aws_cdk_lib_1.Fn.ref('AWS::Region'),
+                PARTITION: aws_cdk_lib_1.Fn.ref('AWS::Partition'),
+            },
+        });
+        this.logGroup = new aws_logs_1.LogGroup(this, 'LogGroup', {
+            logGroupName: `/aws/lambda/${this.function.functionName}`,
+            retention: aws_logs_1.RetentionDays.ONE_DAY,
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+        });
+        new aws_iam_1.ManagedPolicy(this, 'CloudWatchManagedPolicy', {
+            path: '/azmapper/',
+            statements: [
+                new aws_iam_1.PolicyStatement({
+                    actions: ['cloudwatch:PutMetricData'],
+                    effect: aws_iam_1.Effect.ALLOW,
+                    resources: ['*'],
+                }),
+                new aws_iam_1.PolicyStatement({
+                    actions: ['logs:CreateLogStream', 'logs:PutLogEvents'],
+                    effect: aws_iam_1.Effect.ALLOW,
+                    resources: [
+                        aws_cdk_lib_1.Fn.sub('arn:${AWS::Partition}:logs:${AWS::Region}:${AWS::AccountId}:log-group:') +
+                            this.logGroup.logGroupName +
+                            ':*',
+                    ],
+                }),
+            ],
+            roles: [executionRole],
+        });
+        this.mapper = new aws_cdk_lib_1.CustomResource(this, 'AvailabilityZoneMapper', {
+            serviceToken: this.function.functionArn,
+            properties: props?.availabilityZoneNames !== undefined
+                ? { AvailabilityZones: props.availabilityZoneNames }
+                : {},
+        });
+    }
+    /**
+     * Gets the Availability Zone Id for the given Availability Zone Name in this account
+     * @param availabilityZoneName
+     * @returns
+     */
+    availabilityZoneId(availabilityZoneName) {
+        return this.mapper.getAttString(availabilityZoneName);
+    }
+    /**
+     * Gets the Availability Zone Name for the given Availability Zone Id in this account
+     * @param availabilityZoneId
+     * @returns
+     */
+    availabilityZoneName(availabilityZoneId) {
+        return this.mapper.getAttString(availabilityZoneId);
+    }
+    /**
+     * Gets the prefix for the region used with Availability Zone Ids, for example
+     * in us-east-1, this returns "use1"
+     * @returns
+     */
+    regionPrefixForAvailabilityZoneIds() {
+        return this.mapper.getAttString(aws_cdk_lib_1.Fn.ref('AWS::Region'));
+    }
+    /**
+     * Returns an array for Availability Zone Ids for the supplied Availability Zone names,
+     * they are returned in the same order the names were provided
+     * @param availabilityZoneNames
+     * @returns
+     */
+    availabilityZoneIdsAsArray(availabilityZoneNames) {
+        let ids = [];
+        for (let i = 0; i < availabilityZoneNames.length; i++) {
+            ids.push(this.availabilityZoneId(availabilityZoneNames[i]));
+        }
+        return ids;
+    }
+    /**
+     * Returns a comma delimited list of Availability Zone Ids for the supplied
+     * Availability Zone names. You can use this string with Fn.Select(x, Fn.Split(",", azs)) to
+     * get a specific Availability Zone Id
+     * @param availabilityZoneNames
+     * @returns
+     */
+    availabilityZoneIdsAsCommaDelimitedList(availabilityZoneNames) {
+        let ids = [];
+        for (let i = 0; i < availabilityZoneNames.length; i++) {
+            ids.push(this.availabilityZoneId(availabilityZoneNames[i]));
+        }
+        return ids.join(',');
+    }
+    /**
+     * Returns a comma delimited list of Availability Zone Ids for the supplied
+     * Availability Zone names. You can use this string with Fn.Select(x, Fn.Split(",", azs)) to
+     * get a specific Availability Zone Id
+     * @returns
+     */
+    allAvailabilityZoneIdsAsCommaDelimitedList() {
+        return this.mapper.getAttString('AllAvailabilityZoneIds');
+    }
+    /**
+     * Returns a reference that can be cast to a string array with all of the
+     * Availability Zone Ids
+     * @returns
+     */
+    allAvailabilityZoneIdsAsArray() {
+        return this.mapper.getAtt('AllAvailabilityZoneIdsArray');
+    }
+    /**
+     * Given a letter like "f" or "a", returns the Availability Zone Id for that
+     * Availability Zone name in this account
+     * @param letter
+     * @returns
+     */
+    availabilityZoneIdFromAvailabilityZoneLetter(letter) {
+        return this.mapper.getAttString(letter);
+    }
+    /**
+     * Gets all of the Availability Zone names in this Region as a comma delimited
+     * list. You can use this string with Fn.Select(x, Fn.Split(",", azs)) to
+     * get a specific Availability Zone Name
+     * @returns
+     */
+    allAvailabilityZoneNamesAsCommaDelimitedList() {
+        return this.mapper.getAttString('AllAvailabilityZoneNames');
+    }
+}
+exports.AvailabilityZoneMapper = AvailabilityZoneMapper;
+_a = JSII_RTTI_SYMBOL_1;
+AvailabilityZoneMapper[_a] = { fqn: "@cdklabs/multi-az-observability.AvailabilityZoneMapper", version: "0.0.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AvailabilityZoneMapper.js","sourceRoot":"","sources":["../../src/azmapper/AvailabilityZoneMapper.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport {\n  CustomResource,\n  Duration,\n  Fn,\n  Reference,\n  RemovalPolicy,\n} from 'aws-cdk-lib';\nimport {\n  Effect,\n  IManagedPolicy,\n  IRole,\n  ManagedPolicy,\n  PolicyStatement,\n  Role,\n  ServicePrincipal,\n} from 'aws-cdk-lib/aws-iam';\nimport {\n  Architecture,\n  Code,\n  Function,\n  IFunction,\n  Runtime,\n  Tracing,\n} from 'aws-cdk-lib/aws-lambda';\nimport { ILogGroup, LogGroup, RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\nimport { IAvailabilityZoneMapper } from './IAvailabilityZoneMapper';\nimport { AvailabilityZoneMapperProps } from './props/AvailabilityZoneMapperProps';\n\n/**\n * A construct that allows you to map AZ names to ids and back\n */\nexport class AvailabilityZoneMapper\n  extends Construct\n  implements IAvailabilityZoneMapper {\n  /**\n   * The function that does the mapping\n   */\n  function: IFunction;\n\n  /**\n   * The log group for the function's logs\n   */\n  logGroup: ILogGroup;\n\n  /**\n   * The custom resource that can be referenced to use\n   * Fn::GetAtt functions on to retrieve availability zone\n   * names and ids\n   */\n  mapper: CustomResource;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props?: AvailabilityZoneMapperProps,\n  ) {\n    super(scope, id);\n\n    /*\n    let currentNode: Construct | undefined = this.node.scope;\n\n    while (currentNode !== undefined && !(currentNode instanceof Stack)) {\n      currentNode = currentNode.node.scope;\n    }\n\n    if (currentNode !== undefined) {\n      (currentNode as Stack).addTransform('AWS::LanguageExtensions');\n    }\n    */\n\n    let xrayManagedPolicy: IManagedPolicy = new ManagedPolicy(\n      this,\n      'XrayManagedPolicy',\n      {\n        path: '/azmapper/',\n        statements: [\n          new PolicyStatement({\n            actions: [\n              'xray:PutTraceSegments',\n              'xray:PutTelemetryRecords',\n              'xray:GetSamplingRules',\n              'xray:GetSamplingTargets',\n              'xray:GetSamplingStatisticSummaries',\n            ],\n            effect: Effect.ALLOW,\n            resources: ['*'],\n          }),\n        ],\n      },\n    );\n\n    let ec2ManagedPolicy: IManagedPolicy = new ManagedPolicy(\n      this,\n      'EC2ManagedPolicy',\n      {\n        path: '/azmapper/',\n        statements: [\n          new PolicyStatement({\n            actions: ['ec2:DescribeAvailabilityZones'],\n            effect: Effect.ALLOW,\n            resources: ['*'],\n          }),\n        ],\n      },\n    );\n\n    let executionRole: IRole = new Role(this, 'executionRole', {\n      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n      path: '/azmapper/',\n      managedPolicies: [xrayManagedPolicy, ec2ManagedPolicy],\n    });\n\n    const file: string = fs.readFileSync(\n      path.resolve(__dirname, './../azmapper/src/index.py'),\n      'utf-8',\n    );\n\n    this.function = new Function(this, 'AvailabilityZoneMapperFunction', {\n      runtime: Runtime.PYTHON_3_12,\n      code: Code.fromInline(file),\n      handler: 'index.handler',\n      role: executionRole,\n      architecture: Architecture.ARM_64,\n      tracing: Tracing.ACTIVE,\n      timeout: Duration.seconds(20),\n      memorySize: 512,\n      environment: {\n        REGION: Fn.ref('AWS::Region'),\n        PARTITION: Fn.ref('AWS::Partition'),\n      },\n    });\n\n    this.logGroup = new LogGroup(this, 'LogGroup', {\n      logGroupName: `/aws/lambda/${this.function.functionName}`,\n      retention: RetentionDays.ONE_DAY,\n      removalPolicy: RemovalPolicy.DESTROY,\n    });\n\n    new ManagedPolicy(this, 'CloudWatchManagedPolicy', {\n      path: '/azmapper/',\n      statements: [\n        new PolicyStatement({\n          actions: ['cloudwatch:PutMetricData'],\n          effect: Effect.ALLOW,\n          resources: ['*'],\n        }),\n        new PolicyStatement({\n          actions: ['logs:CreateLogStream', 'logs:PutLogEvents'],\n          effect: Effect.ALLOW,\n          resources: [\n            Fn.sub(\n              'arn:${AWS::Partition}:logs:${AWS::Region}:${AWS::AccountId}:log-group:',\n            ) +\n              this.logGroup.logGroupName +\n              ':*',\n          ],\n        }),\n      ],\n      roles: [executionRole],\n    });\n\n    this.mapper = new CustomResource(this, 'AvailabilityZoneMapper', {\n      serviceToken: this.function.functionArn,\n      properties:\n        props?.availabilityZoneNames !== undefined\n          ? { AvailabilityZones: props.availabilityZoneNames }\n          : {},\n    });\n  }\n\n  /**\n   * Gets the Availability Zone Id for the given Availability Zone Name in this account\n   * @param availabilityZoneName\n   * @returns\n   */\n  availabilityZoneId(availabilityZoneName: string): string {\n    return this.mapper.getAttString(availabilityZoneName);\n  }\n\n  /**\n   * Gets the Availability Zone Name for the given Availability Zone Id in this account\n   * @param availabilityZoneId\n   * @returns\n   */\n  availabilityZoneName(availabilityZoneId: string): string {\n    return this.mapper.getAttString(availabilityZoneId);\n  }\n\n  /**\n   * Gets the prefix for the region used with Availability Zone Ids, for example\n   * in us-east-1, this returns \"use1\"\n   * @returns\n   */\n  regionPrefixForAvailabilityZoneIds(): string {\n    return this.mapper.getAttString(Fn.ref('AWS::Region'));\n  }\n\n  /**\n   * Returns an array for Availability Zone Ids for the supplied Availability Zone names,\n   * they are returned in the same order the names were provided\n   * @param availabilityZoneNames\n   * @returns\n   */\n  availabilityZoneIdsAsArray(availabilityZoneNames: string[]): string[] {\n    let ids: string[] = [];\n\n    for (let i = 0; i < availabilityZoneNames.length; i++) {\n      ids.push(this.availabilityZoneId(availabilityZoneNames[i]));\n    }\n\n    return ids;\n  }\n\n  /**\n   * Returns a comma delimited list of Availability Zone Ids for the supplied\n   * Availability Zone names. You can use this string with Fn.Select(x, Fn.Split(\",\", azs)) to\n   * get a specific Availability Zone Id\n   * @param availabilityZoneNames\n   * @returns\n   */\n  availabilityZoneIdsAsCommaDelimitedList(\n    availabilityZoneNames: string[],\n  ): string {\n    let ids: string[] = [];\n\n    for (let i = 0; i < availabilityZoneNames.length; i++) {\n      ids.push(this.availabilityZoneId(availabilityZoneNames[i]));\n    }\n\n    return ids.join(',');\n  }\n\n  /**\n   * Returns a comma delimited list of Availability Zone Ids for the supplied\n   * Availability Zone names. You can use this string with Fn.Select(x, Fn.Split(\",\", azs)) to\n   * get a specific Availability Zone Id\n   * @returns\n   */\n  allAvailabilityZoneIdsAsCommaDelimitedList(): string {\n    return this.mapper.getAttString('AllAvailabilityZoneIds');\n  }\n\n  /**\n   * Returns a reference that can be cast to a string array with all of the\n   * Availability Zone Ids\n   * @returns\n   */\n  allAvailabilityZoneIdsAsArray(): Reference {\n    return this.mapper.getAtt('AllAvailabilityZoneIdsArray');\n  }\n\n  /**\n   * Given a letter like \"f\" or \"a\", returns the Availability Zone Id for that\n   * Availability Zone name in this account\n   * @param letter\n   * @returns\n   */\n  availabilityZoneIdFromAvailabilityZoneLetter(letter: string): string {\n    return this.mapper.getAttString(letter);\n  }\n\n  /**\n   * Gets all of the Availability Zone names in this Region as a comma delimited\n   * list. You can use this string with Fn.Select(x, Fn.Split(\",\", azs)) to\n   * get a specific Availability Zone Name\n   * @returns\n   */\n  allAvailabilityZoneNamesAsCommaDelimitedList(): string {\n    return this.mapper.getAttString('AllAvailabilityZoneNames');\n  }\n}\n"]}

package/lib/azmapper/IAvailabilityZoneMapper.d.ts

@@ -0,0 +1,86 @@
+import { CustomResource, Reference } from 'aws-cdk-lib';
+import { IFunction } from 'aws-cdk-lib/aws-lambda';
+import { ILogGroup } from 'aws-cdk-lib/aws-logs';
+import { IConstruct } from 'constructs';
+/**
+ * A wrapper for the Availability Zone mapper construct
+ * that allows you to translate Availability Zone names
+ * to Availability Zone Ids and vice a versa using the
+ * mapping in the AWS account where this is deployed.
+ */
+export interface IAvailabilityZoneMapper extends IConstruct {
+    /**
+     * The function that does the mapping
+     */
+    function: IFunction;
+    /**
+     * The log group for the function's logs
+     */
+    logGroup: ILogGroup;
+    /**
+     * The custom resource that can be referenced to use
+     * Fn::GetAtt functions on to retrieve availability zone
+     * names and ids
+     */
+    mapper: CustomResource;
+    /**
+     * Gets the Availability Zone Id for the given Availability Zone Name in this account
+     * @param availabilityZoneName
+     * @returns
+     */
+    availabilityZoneId(availabilityZoneName: string): string;
+    /**
+     * Gets the Availability Zone Name for the given Availability Zone Id in this account
+     * @param availabilityZoneId
+     * @returns
+     */
+    availabilityZoneName(availabilityZoneId: string): string;
+    /**
+     * Gets the prefix for the region used with Availability Zone Ids, for example
+     * in us-east-1, this returns "use1"
+     * @returns
+     */
+    regionPrefixForAvailabilityZoneIds(): string;
+    /**
+     * Returns an array for Availability Zone Ids for the supplied Availability Zone names,
+     * they are returned in the same order the names were provided
+     * @param availabilityZoneNames
+     * @returns
+     */
+    availabilityZoneIdsAsArray(availabilityZoneNames: string[]): string[];
+    /**
+     * Returns a comma delimited list of Availability Zone Ids for the supplied
+     * Availability Zone names. You can use this string with Fn.Select(x, Fn.Split(",", azs)) to
+     * get a specific Availability Zone Id
+     * @param availabilityZoneNames
+     * @returns
+     */
+    availabilityZoneIdsAsCommaDelimitedList(availabilityZoneNames: string[]): string;
+    /**
+     * Returns a comma delimited list of Availability Zone Ids for the supplied
+     * Availability Zone names. You can use this string with Fn.Select(x, Fn.Split(",", azs)) to
+     * get a specific Availability Zone Id
+     * @returns
+     */
+    allAvailabilityZoneIdsAsCommaDelimitedList(): string;
+    /**
+     * Returns a reference that can be cast to a string array with all of the
+     * Availability Zone Ids
+     * @returns
+     */
+    allAvailabilityZoneIdsAsArray(): Reference;
+    /**
+     * Given a letter like "f" or "a", returns the Availability Zone Id for that
+     * Availability Zone name in this account
+     * @param letter
+     * @returns
+     */
+    availabilityZoneIdFromAvailabilityZoneLetter(letter: string): string;
+    /**
+     * Gets all of the Availability Zone names in this Region as a comma delimited
+     * list. You can use this string with Fn.Select(x, Fn.Split(",", azs)) to
+     * get a specific Availability Zone Name
+     * @returns
+     */
+    allAvailabilityZoneNamesAsCommaDelimitedList(): string;
+}

package/lib/azmapper/IAvailabilityZoneMapper.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azmapper/props/AvailabilityZoneMapperProps.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Properties for the AZ mapper
+ */
+export interface AvailabilityZoneMapperProps {
+    /**
+     * The currently in use Availability Zone names which
+     * constrains the list of AZ IDs that are returned
+     *
+     * @default - No names are provided and the mapper returns
+     * all AZs in the region in its lists
+     */
+    readonly availabilityZoneNames?: string[];
+}

package/lib/azmapper/props/AvailabilityZoneMapperProps.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQXZhaWxhYmlsaXR5Wm9uZU1hcHBlclByb3BzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F6bWFwcGVyL3Byb3BzL0F2YWlsYWJpbGl0eVpvbmVNYXBwZXJQcm9wcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IEFtYXpvbi5jb20sIEluYy4gb3IgaXRzIGFmZmlsaWF0ZXMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuLyoqXG4gKiBQcm9wZXJ0aWVzIGZvciB0aGUgQVogbWFwcGVyXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQXZhaWxhYmlsaXR5Wm9uZU1hcHBlclByb3BzIHtcbiAgLyoqXG4gICAqIFRoZSBjdXJyZW50bHkgaW4gdXNlIEF2YWlsYWJpbGl0eSBab25lIG5hbWVzIHdoaWNoXG4gICAqIGNvbnN0cmFpbnMgdGhlIGxpc3Qgb2YgQVogSURzIHRoYXQgYXJlIHJldHVybmVkXG4gICAqXG4gICAqIEBkZWZhdWx0IC0gTm8gbmFtZXMgYXJlIHByb3ZpZGVkIGFuZCB0aGUgbWFwcGVyIHJldHVybnNcbiAgICogYWxsIEFacyBpbiB0aGUgcmVnaW9uIGluIGl0cyBsaXN0c1xuICAgKi9cbiAgcmVhZG9ubHkgYXZhaWxhYmlsaXR5Wm9uZU5hbWVzPzogc3RyaW5nW107XG59XG4iXX0=

package/lib/azmapper/src/index.py

@@ -0,0 +1,107 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+import urllib3
+import json
+import os
+import boto3
+
+SUCCESS = "SUCCESS"
+FAILED = "FAILED"
+http = urllib3.PoolManager()
+region = os.environ.get("AWS_REGION")
+ec2 = boto3.client('ec2', region_name = region)
+
+def handler(event, context):
+  try:
+    print(event)
+    if event['RequestType'] == 'Delete':
+      sendResponse(event, context, SUCCESS, {})
+      return
+  
+    zone_names=[]
+    if 'ResourceProperties' in event and 'AvailabilityZones' in event['ResourceProperties'] and event['ResourceProperties']['AvailabilityZones'] != '':   
+      zone_names = event['ResourceProperties']['AvailabilityZones']
+      
+    in_use_azs = ec2.describe_availability_zones(Filters=[ { 'Name': 'zone-type', 'Values': [ 'availability-zone'] } ], ZoneNames = zone_names)
+    all_azs = ec2.describe_availability_zones(Filters=[ { 'Name': 'zone-type', 'Values': [ 'availability-zone'] } ])
+  
+    az_map = {}
+
+    biggest_letter = sorted([x["ZoneName"][-1] for x in all_azs["AvailabilityZones"]], reverse=True)[0]
+    biggest_number = int(sorted([x["ZoneId"][-1] for x in all_azs["AvailabilityZones"]], reverse=True)[0])
+
+    for code in range(ord('a'), ord(biggest_letter) + 1):
+      az_map[chr(code)] = ""
+
+    for num in range(1, biggest_number + 1):
+      az_map["az" + str(num)] = ""
+  
+    # Supply the region and get its shorthand
+    az_map[region] = all_azs["AvailabilityZones"][0]["ZoneId"].split("-")[0]
+  
+    # Get the in use availability zone Ids as comma delimited list
+    az_map["InUseAvailabilityZoneIds"] = ",".join(x["ZoneId"] for x in in_use_azs["AvailabilityZones"])
+  
+    # Get the in use availability zone Ids as an array
+    az_map["InUseAvailabilityZoneIdsArray"] = [x["ZoneId"] for x in in_use_azs["AvailabilityZones"]]
+  
+    # Get the in use availability zone names as comma delimited list
+    az_map["InUseAvailabilityZoneNames"] = ",".join(x["ZoneName"] for x in in_use_azs["AvailabilityZones"])
+  
+    # Get the in use availability zone names as an array
+    az_map["InUseAvailabilityZoneNames"] = ",".join(x["ZoneName"] for x in in_use_azs["AvailabilityZones"])
+  
+    # Make a comma delimited list of name to id joined with a colon
+    az_map["InUseAvailabilityZoneNameToIdMap"] = ",".join(x["ZoneName"] + ":" + x["ZoneId"] for x in in_use_azs["AvailabilityZones"])
+    
+    # Make a comma delimited list of name to id joined with a colon for all AZs
+    az_map["AllAvailabilityZoneNameToIdMap"] = ",".join(x["ZoneName"] + ":" + x["ZoneId"] for x in all_azs["AvailabilityZones"])
+    
+    # All availability zones in the region
+    az_map["AllAvailabilityZoneIds"] = ",".join(x["ZoneId"] for x in all_azs["AvailabilityZones"])
+    az_map["AllAvailabilityZoneIdsArray"] = [x["ZoneId"] for x in all_azs["AvailabilityZones"]]
+    az_map["AllAvailabilityZoneNames"] = ",".join(x["ZoneName"] for x in all_azs["AvailabilityZones"])
+    az_map["AllAvailabilityZoneNamesArray"] = [x["ZoneName"] for x in all_azs["AvailabilityZones"]]
+    
+    # Allow lookups for individual AZ names to Ids
+    for item in all_azs['AvailabilityZones']:
+      az_map[item['ZoneName']] = item['ZoneId']
+      az_map[item['ZoneId']] = item['ZoneName']
+      az_id = item['ZoneId'].split('-')[1].lower()
+      az_map[az_id] = item['ZoneName']
+      az_letter = item['ZoneName'][-1]
+      az_map[az_letter] = item['ZoneId']
+  
+    print(json.dumps(az_map))
+  
+    sendResponse(event, context, SUCCESS, az_map)
+  except Exception as e:
+    print(e)
+    sendResponse(event, context, FAILED, str(e))  
+  return
+
+def sendResponse(event, context, responseStatus, responseData, physicalResourceId=None, noEcho=False, reason=None):
+  responseUrl = event['ResponseURL']
+  print(responseUrl)
+  responseBody = {
+    'Status' : responseStatus,
+    'Reason' : reason or "See the details in CloudWatch Log Stream: {}".format(context.log_stream_name),
+    'PhysicalResourceId' : physicalResourceId or context.log_stream_name,
+    'StackId' : event['StackId'],
+    'RequestId' : event['RequestId'],
+    'LogicalResourceId' : event['LogicalResourceId'],
+    'NoEcho' : noEcho,
+    'Data' : responseData
+  }
+  json_responseBody = json.dumps(responseBody, default=str)
+  print("Response body:")
+  print(json_responseBody)
+  headers = {
+    'content-type' : '',
+    'content-length' : str(len(json_responseBody))
+  }
+  try:
+    response = http.request('PUT', responseUrl, headers=headers, body=json_responseBody)
+    print("Status code:", response.status)
+  except Exception as e:
+    print("send(...) failed executing http.request(..):", e)

package/lib/canaries/CanaryFunction.d.ts

@@ -0,0 +1,16 @@
+import { IFunction } from 'aws-cdk-lib/aws-lambda';
+import { ILogGroup } from 'aws-cdk-lib/aws-logs';
+import { Construct } from 'constructs';
+import { ICanaryFunction } from './ICanaryFunction';
+import { CanaryFunctionProps } from './props/CanaryFunctionProps';
+export declare class CanaryFunction extends Construct implements ICanaryFunction {
+    /**
+     * The canary function
+     */
+    function: IFunction;
+    /**
+     * The log group where the canarty logs will be sent
+     */
+    logGroup: ILogGroup;
+    constructor(scope: Construct, id: string, props: CanaryFunctionProps);
+}

package/lib/canaries/CanaryFunction.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanaryFunction = void 0;
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const path = require("path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const constructs_1 = require("constructs");
+class CanaryFunction extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        let xrayManagedPolicy = new aws_iam_1.ManagedPolicy(this, 'xrayManagedPolicy', {
+            path: '/canary/',
+            statements: [
+                new aws_iam_1.PolicyStatement({
+                    actions: [
+                        'xray:PutTraceSegments',
+                        'xray:PutTelemetryRecords',
+                        'xray:GetSamplingRules',
+                        'xray:GetSamplingTargets',
+                        'xray:GetSamplingStatisticSummaries',
+                    ],
+                    effect: aws_iam_1.Effect.ALLOW,
+                    resources: ['*'],
+                }),
+            ],
+        });
+        let ec2ManagedPolicy = new aws_iam_1.ManagedPolicy(this, 'ec2ManagedPolicy', {
+            path: '/canary/',
+            statements: [
+                new aws_iam_1.PolicyStatement({
+                    actions: [
+                        'ec2:CreateNetworkInterface',
+                        'ec2:DescribeNetworkInterfaces',
+                        'ec2:DeleteNetworkInterface',
+                    ],
+                    effect: aws_iam_1.Effect.ALLOW,
+                    resources: ['*'],
+                }),
+            ],
+        });
+        let executionRole = new aws_iam_1.Role(this, 'executionRole', {
+            assumedBy: new aws_iam_1.ServicePrincipal('lambda.amazonaws.com'),
+            path: '/canary/',
+            managedPolicies: [xrayManagedPolicy, ec2ManagedPolicy],
+        });
+        /*
+        let code: AssetCode = Code.fromAsset(path.join(__dirname, "src/"), {
+          bundling: {
+            //image: new Runtime('python3.12:latest-arm64', RuntimeFamily.PYTHON).bundlingImage,
+            image: Runtime.PYTHON_3_12.bundlingImage,
+            command: [
+              'bash', '-c',
+              'pip install --no-cache -r requirements.txt -t /asset-output && cp --archive --update . /asset-output',
+            ],
+            platform: 'linux/arm64',
+          },
+        });
+        */
+        let monitoringLayer = new aws_lambda_1.LayerVersion(this, 'MonitoringLayer', {
+            code: aws_lambda_1.Code.fromAsset(path.join(__dirname, '../monitoring/src/monitoring-layer.zip')),
+            compatibleArchitectures: [aws_lambda_1.Architecture.ARM_64],
+            compatibleRuntimes: [aws_lambda_1.Runtime.PYTHON_3_12],
+        });
+        if (props.vpc !== undefined && props.vpc != null) {
+            let sg = new aws_ec2_1.SecurityGroup(this, 'canarySecurityGroup', {
+                description: 'Allow canary to communicate with load balancer',
+                vpc: props.vpc,
+                allowAllOutbound: true,
+            });
+            this.function = new aws_lambda_1.Function(this, 'canary', {
+                runtime: aws_lambda_1.Runtime.PYTHON_3_12,
+                code: aws_lambda_1.Code.fromAsset(path.join(__dirname, 'src/canary.zip')),
+                handler: 'index.handler',
+                role: executionRole,
+                architecture: aws_lambda_1.Architecture.ARM_64,
+                tracing: aws_lambda_1.Tracing.ACTIVE,
+                timeout: aws_cdk_lib_1.Duration.seconds(240),
+                memorySize: 512,
+                layers: [monitoringLayer],
+                environment: {
+                    REGION: aws_cdk_lib_1.Fn.ref('AWS::Region'),
+                    PARTITION: aws_cdk_lib_1.Fn.ref('AWS::Partition'),
+                    TIMEOUT: props.httpTimeout !== undefined
+                        ? props.httpTimeout.toSeconds().toString()
+                        : '2',
+                    IGNORE_SSL_ERRORS: (props.ignoreTlsErrors !== undefined && props.ignoreTlsErrors == true)
+                        .toString()
+                        .toLowerCase(),
+                },
+                vpc: props.vpc,
+                securityGroups: [sg],
+                vpcSubnets: props.subnetSelection,
+            });
+        }
+        else {
+            this.function = new aws_lambda_1.Function(this, 'canary', {
+                runtime: aws_lambda_1.Runtime.PYTHON_3_12,
+                code: aws_lambda_1.Code.fromAsset(path.join(__dirname, 'src/canary.zip')),
+                handler: 'index.handler',
+                role: executionRole,
+                architecture: aws_lambda_1.Architecture.ARM_64,
+                tracing: aws_lambda_1.Tracing.ACTIVE,
+                timeout: aws_cdk_lib_1.Duration.seconds(240),
+                memorySize: 512,
+                layers: [monitoringLayer],
+                environment: {
+                    REGION: aws_cdk_lib_1.Fn.ref('AWS::Region'),
+                    PARTITION: aws_cdk_lib_1.Fn.ref('AWS::Partition'),
+                    TIMEOUT: props.httpTimeout !== undefined
+                        ? props.httpTimeout.toSeconds().toString()
+                        : '2',
+                    IGNORE_SSL_ERRORS: (props.ignoreTlsErrors !== undefined && props.ignoreTlsErrors == true)
+                        .toString()
+                        .toLowerCase(),
+                },
+            });
+        }
+        this.function.addPermission('invokePermission', {
+            action: 'lambda:InvokeFunction',
+            principal: new aws_iam_1.ServicePrincipal('events.amazonaws.com'),
+            sourceArn: aws_cdk_lib_1.Fn.sub('arn:${AWS::Partition}:events:${AWS::Region}:${AWS::AccountId}:rule/*'),
+        });
+        this.logGroup = new aws_logs_1.LogGroup(this, 'logGroup', {
+            logGroupName: `/aws/lambda/${this.function.functionName}`,
+            retention: aws_logs_1.RetentionDays.ONE_WEEK,
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+        });
+        new aws_iam_1.ManagedPolicy(this, 'cwManagedPolicy', {
+            path: '/canary/',
+            statements: [
+                new aws_iam_1.PolicyStatement({
+                    actions: ['cloudwatch:PutMetricData'],
+                    effect: aws_iam_1.Effect.ALLOW,
+                    resources: ['*'],
+                }),
+                new aws_iam_1.PolicyStatement({
+                    actions: ['logs:CreateLogStream', 'logs:PutLogEvents'],
+                    effect: aws_iam_1.Effect.ALLOW,
+                    resources: [this.logGroup.logGroupArn],
+                }),
+            ],
+            roles: [executionRole],
+        });
+    }
+}
+exports.CanaryFunction = CanaryFunction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CanaryFunction.js","sourceRoot":"","sources":["../../src/canaries/CanaryFunction.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\nimport * as path from 'path';\nimport { Duration, Fn, RemovalPolicy } from 'aws-cdk-lib';\nimport { ISecurityGroup, SecurityGroup } from 'aws-cdk-lib/aws-ec2';\nimport {\n  Effect,\n  IManagedPolicy,\n  IRole,\n  ManagedPolicy,\n  PolicyStatement,\n  Role,\n  ServicePrincipal,\n} from 'aws-cdk-lib/aws-iam';\nimport {\n  Architecture,\n  Code,\n  Function,\n  IFunction,\n  ILayerVersion,\n  LayerVersion,\n  Runtime,\n  Tracing,\n} from 'aws-cdk-lib/aws-lambda';\nimport { ILogGroup, LogGroup, RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\nimport { ICanaryFunction } from './ICanaryFunction';\nimport { CanaryFunctionProps } from './props/CanaryFunctionProps';\n\nexport class CanaryFunction extends Construct implements ICanaryFunction {\n  /**\n   * The canary function\n   */\n  function: IFunction;\n\n  /**\n   * The log group where the canarty logs will be sent\n   */\n  logGroup: ILogGroup;\n\n  constructor(scope: Construct, id: string, props: CanaryFunctionProps) {\n    super(scope, id);\n\n    let xrayManagedPolicy: IManagedPolicy = new ManagedPolicy(\n      this,\n      'xrayManagedPolicy',\n      {\n        path: '/canary/',\n        statements: [\n          new PolicyStatement({\n            actions: [\n              'xray:PutTraceSegments',\n              'xray:PutTelemetryRecords',\n              'xray:GetSamplingRules',\n              'xray:GetSamplingTargets',\n              'xray:GetSamplingStatisticSummaries',\n            ],\n            effect: Effect.ALLOW,\n            resources: ['*'],\n          }),\n        ],\n      },\n    );\n    let ec2ManagedPolicy = new ManagedPolicy(this, 'ec2ManagedPolicy', {\n      path: '/canary/',\n      statements: [\n        new PolicyStatement({\n          actions: [\n            'ec2:CreateNetworkInterface',\n            'ec2:DescribeNetworkInterfaces',\n            'ec2:DeleteNetworkInterface',\n          ],\n          effect: Effect.ALLOW,\n          resources: ['*'],\n        }),\n      ],\n    });\n\n    let executionRole: IRole = new Role(this, 'executionRole', {\n      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n      path: '/canary/',\n      managedPolicies: [xrayManagedPolicy, ec2ManagedPolicy],\n    });\n\n    /*\n    let code: AssetCode = Code.fromAsset(path.join(__dirname, \"src/\"), {\n      bundling: {\n        //image: new Runtime('python3.12:latest-arm64', RuntimeFamily.PYTHON).bundlingImage,\n        image: Runtime.PYTHON_3_12.bundlingImage,\n        command: [\n          'bash', '-c',\n          'pip install --no-cache -r requirements.txt -t /asset-output && cp --archive --update . /asset-output',\n        ],\n        platform: 'linux/arm64',\n      },\n    });\n    */\n    let monitoringLayer: ILayerVersion = new LayerVersion(\n      this,\n      'MonitoringLayer',\n      {\n        code: Code.fromAsset(\n          path.join(__dirname, '../monitoring/src/monitoring-layer.zip'),\n        ),\n        compatibleArchitectures: [Architecture.ARM_64],\n        compatibleRuntimes: [Runtime.PYTHON_3_12],\n      },\n    );\n\n    if (props.vpc !== undefined && props.vpc != null) {\n      let sg: ISecurityGroup = new SecurityGroup(this, 'canarySecurityGroup', {\n        description: 'Allow canary to communicate with load balancer',\n        vpc: props.vpc,\n        allowAllOutbound: true,\n      });\n\n      this.function = new Function(this, 'canary', {\n        runtime: Runtime.PYTHON_3_12,\n        code: Code.fromAsset(path.join(__dirname, 'src/canary.zip')),\n        handler: 'index.handler',\n        role: executionRole,\n        architecture: Architecture.ARM_64,\n        tracing: Tracing.ACTIVE,\n        timeout: Duration.seconds(240),\n        memorySize: 512,\n        layers: [monitoringLayer],\n        environment: {\n          REGION: Fn.ref('AWS::Region'),\n          PARTITION: Fn.ref('AWS::Partition'),\n          TIMEOUT:\n            props.httpTimeout !== undefined\n              ? props.httpTimeout.toSeconds().toString()\n              : '2',\n          IGNORE_SSL_ERRORS: (\n            props.ignoreTlsErrors !== undefined && props.ignoreTlsErrors == true\n          )\n            .toString()\n            .toLowerCase(),\n        },\n        vpc: props.vpc,\n        securityGroups: [sg],\n        vpcSubnets: props.subnetSelection,\n      });\n    } else {\n      this.function = new Function(this, 'canary', {\n        runtime: Runtime.PYTHON_3_12,\n        code: Code.fromAsset(path.join(__dirname, 'src/canary.zip')),\n        handler: 'index.handler',\n        role: executionRole,\n        architecture: Architecture.ARM_64,\n        tracing: Tracing.ACTIVE,\n        timeout: Duration.seconds(240),\n        memorySize: 512,\n        layers: [monitoringLayer],\n        environment: {\n          REGION: Fn.ref('AWS::Region'),\n          PARTITION: Fn.ref('AWS::Partition'),\n          TIMEOUT:\n            props.httpTimeout !== undefined\n              ? props.httpTimeout.toSeconds().toString()\n              : '2',\n          IGNORE_SSL_ERRORS: (\n            props.ignoreTlsErrors !== undefined && props.ignoreTlsErrors == true\n          )\n            .toString()\n            .toLowerCase(),\n        },\n      });\n    }\n\n    this.function.addPermission('invokePermission', {\n      action: 'lambda:InvokeFunction',\n      principal: new ServicePrincipal('events.amazonaws.com'),\n      sourceArn: Fn.sub(\n        'arn:${AWS::Partition}:events:${AWS::Region}:${AWS::AccountId}:rule/*',\n      ),\n    });\n\n    this.logGroup = new LogGroup(this, 'logGroup', {\n      logGroupName: `/aws/lambda/${this.function.functionName}`,\n      retention: RetentionDays.ONE_WEEK,\n      removalPolicy: RemovalPolicy.DESTROY,\n    });\n\n    new ManagedPolicy(this, 'cwManagedPolicy', {\n      path: '/canary/',\n      statements: [\n        new PolicyStatement({\n          actions: ['cloudwatch:PutMetricData'],\n          effect: Effect.ALLOW,\n          resources: ['*'],\n        }),\n        new PolicyStatement({\n          actions: ['logs:CreateLogStream', 'logs:PutLogEvents'],\n          effect: Effect.ALLOW,\n          resources: [this.logGroup.logGroupArn],\n        }),\n      ],\n      roles: [executionRole],\n    });\n  }\n}\n"]}