@liflig/cdk 2.18.4 → 2.18.6

package/lib/bastion-host.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BastionHost = void 0;
+const constructs = require("constructs");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+const iam = require("aws-cdk-lib/aws-iam");
+const cdk = require("aws-cdk-lib");
+/**
+ * This creates a EC2 bastion host that can be used to connect
+ * to database instances and other internal resources.
+ *
+ * The instance is supposed to have no open ingress ports, and users
+ * are supposed to connect only through SSM Session Manager.
+ *
+ * The resources that the bastion host should be allowed to access
+ * must have the bastion host security group as allowed ingress.
+ *
+ * For more internal details, see
+ * https://confluence.capraconsulting.no/x/q8UBC
+ */
+class BastionHost extends constructs.Construct {
+    constructor(scope, id, props) {
+        var _a, _b;
+        super(scope, id);
+        const region = cdk.Stack.of(this).region;
+        this.securityGroup =
+            (_a = props.securityGroup) !== null && _a !== void 0 ? _a : new ec2.SecurityGroup(this, "SecurityGroup", {
+                vpc: props.vpc,
+            });
+        const instance = new ec2.Instance(this, "Instance", {
+            vpc: props.vpc,
+            vpcSubnets: (_b = props.subnetSelection) !== null && _b !== void 0 ? _b : {
+                subnetType: ec2.SubnetType.PUBLIC,
+            },
+            securityGroup: this.securityGroup,
+            instanceName: "Bastion",
+            instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.NANO),
+            machineImage: ec2.MachineImage.latestAmazonLinux({
+                generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2,
+            }),
+        });
+        instance.addUserData(`yum install -y https://amazon-ssm-${region}.s3.amazonaws.com/latest/linux_amd64/amazon-ssm-agent.rpm socat postgresql mariadb`);
+        // SSM support.
+        instance.addToRolePolicy(
+        // This mimics the AmazonEC2RoleforSSM policy
+        // while granting least privileges needed.
+        //
+        // The default AmazonEC2RoleforSSM policy gives read/write access
+        // to all objects in S3, all parameters in Parameter Store, amoung
+        // more. We primarily use the SSM agent for limited remote control,
+        // and the policy here covers that as the primary use case.
+        //
+        // See https://www.cflee.com/posts/aws-ssm-iam-policy-caveats/
+        // See also https://docs.aws.amazon.com/systems-manager/latest/userguide/setup-instance-profile.html
+        new iam.PolicyStatement({
+            actions: [
+                // https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-setting-up-messageAPIs.html
+                // https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awssystemsmanager.html
+                "ssm:ListInstanceAssociations",
+                "ssm:UpdateInstanceInformation",
+                "ssm:GetDocument",
+                "ssm:PutInventory",
+                "ssm:UpdateInstanceAssociationStatus",
+                // https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-setting-up-messageAPIs.html
+                "ssmmessages:CreateControlChannel",
+                "ssmmessages:CreateDataChannel",
+                "ssmmessages:OpenControlChannel",
+                "ssmmessages:OpenDataChannel",
+                // https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmessagedeliveryservice.html
+                "ec2messages:AcknowledgeMessage",
+                "ec2messages:DeleteMessage",
+                "ec2messages:FailMessage",
+                "ec2messages:GetEndpoint",
+                "ec2messages:GetMessages",
+                "ec2messages:SendReply",
+            ],
+            // Seems this is needed for the given actions.
+            resources: ["*"],
+        }));
+        new cdk.CfnOutput(this, "BastionInstanceId", {
+            value: instance.instanceId,
+        });
+    }
+}
+exports.BastionHost = BastionHost;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bastion-host.js","sourceRoot":"","sources":["../src/bastion-host.ts"],"names":[],"mappings":";;;AAAA,yCAAwC;AACxC,2CAA0C;AAC1C,2CAA0C;AAC1C,mCAAkC;AAwBlC;;;;;;;;;;;;GAYG;AACH,MAAa,WAAY,SAAQ,UAAU,CAAC,SAAS;IAGnD,YAAY,KAA2B,EAAE,EAAU,EAAE,KAAY;;QAC/D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;QAEhB,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,CAAA;QAExC,IAAI,CAAC,aAAa;YAChB,MAAA,KAAK,CAAC,aAAa,mCACnB,IAAI,GAAG,CAAC,aAAa,CAAC,IAAI,EAAE,eAAe,EAAE;gBAC3C,GAAG,EAAE,KAAK,CAAC,GAAG;aACf,CAAC,CAAA;QAEJ,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE;YAClD,GAAG,EAAE,KAAK,CAAC,GAAG;YACd,UAAU,EAAE,MAAA,KAAK,CAAC,eAAe,mCAAI;gBACnC,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,MAAM;aAClC;YACD,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,YAAY,EAAE,SAAS;YACvB,YAAY,EAAE,GAAG,CAAC,YAAY,CAAC,EAAE,CAC/B,GAAG,CAAC,aAAa,CAAC,EAAE,EACpB,GAAG,CAAC,YAAY,CAAC,IAAI,CACtB;YACD,YAAY,EAAE,GAAG,CAAC,YAAY,CAAC,iBAAiB,CAAC;gBAC/C,UAAU,EAAE,GAAG,CAAC,qBAAqB,CAAC,cAAc;aACrD,CAAC;SACH,CAAC,CAAA;QAEF,QAAQ,CAAC,WAAW,CAClB,qCAAqC,MAAM,oFAAoF,CAChI,CAAA;QAED,eAAe;QACf,QAAQ,CAAC,eAAe;QACtB,6CAA6C;QAC7C,0CAA0C;QAC1C,EAAE;QACF,iEAAiE;QACjE,kEAAkE;QAClE,mEAAmE;QACnE,2DAA2D;QAC3D,EAAE;QACF,8DAA8D;QAC9D,oGAAoG;QACpG,IAAI,GAAG,CAAC,eAAe,CAAC;YACtB,OAAO,EAAE;gBACP,2GAA2G;gBAC3G,+EAA+E;gBAC/E,8BAA8B;gBAC9B,+BAA+B;gBAC/B,iBAAiB;gBACjB,kBAAkB;gBAClB,qCAAqC;gBACrC,2GAA2G;gBAC3G,kCAAkC;gBAClC,+BAA+B;gBAC/B,gCAAgC;gBAChC,6BAA6B;gBAC7B,0FAA0F;gBAC1F,gCAAgC;gBAChC,2BAA2B;gBAC3B,yBAAyB;gBACzB,yBAAyB;gBACzB,yBAAyB;gBACzB,uBAAuB;aACxB;YACD,8CAA8C;YAC9C,SAAS,EAAE,CAAC,GAAG,CAAC;SACjB,CAAC,CACH,CAAA;QAED,IAAI,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,mBAAmB,EAAE;YAC3C,KAAK,EAAE,QAAQ,CAAC,UAAU;SAC3B,CAAC,CAAA;IACJ,CAAC;CACF;AA7ED,kCA6EC","sourcesContent":["import * as constructs from \"constructs\"\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as cdk from \"aws-cdk-lib\"\n\ninterface Props {\n  vpc: ec2.IVpc\n  /**\n   * The security group used for the EC2 instance.\n   *\n   * @default - a security group will be created\n   */\n  securityGroup?: ec2.ISecurityGroup\n  /**\n   * The subnets to place the bastion host.\n   *\n   * Note that if placed inside private subnet, the VPC must have\n   * VPC endpoints to access relevant AWS services for Systems Manager\n   * to work in order to be able to connect to the instance.\n   *\n   * See https://aws.amazon.com/premiumsupport/knowledge-center/ec2-systems-manager-vpc-endpoints/\n   *\n   * @default - public subnets\n   */\n  subnetSelection?: ec2.SubnetSelection\n}\n\n/**\n * This creates a EC2 bastion host that can be used to connect\n * to database instances and other internal resources.\n *\n * The instance is supposed to have no open ingress ports, and users\n * are supposed to connect only through SSM Session Manager.\n *\n * The resources that the bastion host should be allowed to access\n * must have the bastion host security group as allowed ingress.\n *\n * For more internal details, see\n * https://confluence.capraconsulting.no/x/q8UBC\n */\nexport class BastionHost extends constructs.Construct {\n  public readonly securityGroup: ec2.ISecurityGroup\n\n  constructor(scope: constructs.Construct, id: string, props: Props) {\n    super(scope, id)\n\n    const region = cdk.Stack.of(this).region\n\n    this.securityGroup =\n      props.securityGroup ??\n      new ec2.SecurityGroup(this, \"SecurityGroup\", {\n        vpc: props.vpc,\n      })\n\n    const instance = new ec2.Instance(this, \"Instance\", {\n      vpc: props.vpc,\n      vpcSubnets: props.subnetSelection ?? {\n        subnetType: ec2.SubnetType.PUBLIC,\n      },\n      securityGroup: this.securityGroup,\n      instanceName: \"Bastion\",\n      instanceType: ec2.InstanceType.of(\n        ec2.InstanceClass.T3,\n        ec2.InstanceSize.NANO,\n      ),\n      machineImage: ec2.MachineImage.latestAmazonLinux({\n        generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2,\n      }),\n    })\n\n    instance.addUserData(\n      `yum install -y https://amazon-ssm-${region}.s3.amazonaws.com/latest/linux_amd64/amazon-ssm-agent.rpm socat postgresql mariadb`,\n    )\n\n    // SSM support.\n    instance.addToRolePolicy(\n      // This mimics the AmazonEC2RoleforSSM policy\n      // while granting least privileges needed.\n      //\n      // The default AmazonEC2RoleforSSM policy gives read/write access\n      // to all objects in S3, all parameters in Parameter Store, amoung\n      // more. We primarily use the SSM agent for limited remote control,\n      // and the policy here covers that as the primary use case.\n      //\n      // See https://www.cflee.com/posts/aws-ssm-iam-policy-caveats/\n      // See also https://docs.aws.amazon.com/systems-manager/latest/userguide/setup-instance-profile.html\n      new iam.PolicyStatement({\n        actions: [\n          // https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-setting-up-messageAPIs.html\n          // https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awssystemsmanager.html\n          \"ssm:ListInstanceAssociations\",\n          \"ssm:UpdateInstanceInformation\",\n          \"ssm:GetDocument\",\n          \"ssm:PutInventory\",\n          \"ssm:UpdateInstanceAssociationStatus\",\n          // https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-setting-up-messageAPIs.html\n          \"ssmmessages:CreateControlChannel\",\n          \"ssmmessages:CreateDataChannel\",\n          \"ssmmessages:OpenControlChannel\",\n          \"ssmmessages:OpenDataChannel\",\n          // https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmessagedeliveryservice.html\n          \"ec2messages:AcknowledgeMessage\",\n          \"ec2messages:DeleteMessage\",\n          \"ec2messages:FailMessage\",\n          \"ec2messages:GetEndpoint\",\n          \"ec2messages:GetMessages\",\n          \"ec2messages:SendReply\",\n        ],\n        // Seems this is needed for the given actions.\n        resources: [\"*\"],\n      }),\n    )\n\n    new cdk.CfnOutput(this, \"BastionInstanceId\", {\n      value: instance.instanceId,\n    })\n  }\n}\n"]}

package/lib/bin/cdk-create-snapshots.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin/fetch-pipeline-variables.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/build-artifacts/index.d.ts

@@ -0,0 +1,68 @@
+import * as constructs from "constructs";
+import * as ecr from "aws-cdk-lib/aws-ecr";
+interface Props {
+    /**
+     * The name to use for the S3 Bucket. Should include both account and region
+     * so that it will not conflict with other accounts/regions.
+     *
+     * @default - no bucket will be created
+     */
+    bucketName?: string;
+    /**
+     * The name to use for the ECR Repository.
+     */
+    ecrRepositoryName: string;
+    /**
+     * The lifecycle rules to apply to images stored in the ECR repository.
+     *
+     * @default - Expire images after 180 days
+     */
+    ecrRepositoryLifecycleRules?: ecr.LifecycleRule[];
+    /**
+     * Reference to the IAM Role that will be granted permission to
+     * assume the CI role. This role must have permission to assume
+     * the CI role.
+     *
+     * @default - use Liflig Jenkins role
+     */
+    externalRoleArn?: string;
+    /**
+     * The name of the role that will be created that will be assumed
+     * from the CI system.
+     *
+     * @default - no role will be created
+     */
+    ciRoleName?: string;
+    /**
+     * The AWS Accounts that will be granted permission to read from
+     * the artifact repos.
+     */
+    targetAccountIds: string[];
+    /**
+     * Flag if Griid is bootstrapped and the account this construct is
+     * deployed to is the build account. Will attach policies and
+     * reference existing artifacts and roles.
+     *
+     * @default false
+     */
+    griid?: boolean;
+}
+/**
+ * Build artifacts.
+ *
+ * This holds a S3 Bucket, a ECR Repository and roles to be used
+ * from CI system for uploading.
+ *
+ * TODO: How can we cleanup stuff that goes into this S3 Bucket and
+ *  ECR Repository? Can we ever reliably cleanup? We probably need
+ *  some strategy for how we put stuff here to be able to do it.
+ *
+ * @experimental
+ */
+export declare class BuildArtifacts extends constructs.Construct {
+    readonly bucketName: string | undefined;
+    readonly ecrRepositoryArn: string;
+    readonly ecrRepositoryName: string;
+    constructor(scope: constructs.Construct, id: string, props: Props);
+}
+export {};

package/lib/build-artifacts/index.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildArtifacts = void 0;
+const constructs = require("constructs");
+const ecr = require("aws-cdk-lib/aws-ecr");
+const iam = require("aws-cdk-lib/aws-iam");
+const s3 = require("aws-cdk-lib/aws-s3");
+const cdk = require("aws-cdk-lib");
+const griid_1 = require("../griid");
+/**
+ * Build artifacts.
+ *
+ * This holds a S3 Bucket, a ECR Repository and roles to be used
+ * from CI system for uploading.
+ *
+ * TODO: How can we cleanup stuff that goes into this S3 Bucket and
+ *  ECR Repository? Can we ever reliably cleanup? We probably need
+ *  some strategy for how we put stuff here to be able to do it.
+ *
+ * @experimental
+ */
+class BuildArtifacts extends constructs.Construct {
+    constructor(scope, id, props) {
+        var _a;
+        super(scope, id);
+        this.bucketName = props.bucketName;
+        this.ecrRepositoryName = props.ecrRepositoryName;
+        this.ecrRepositoryArn = cdk.Arn.format({
+            service: "ecr",
+            resource: "repository",
+            resourceName: this.ecrRepositoryName,
+        }, cdk.Stack.of(this));
+        const externalRoleArn = (_a = props.externalRoleArn) !== null && _a !== void 0 ? _a : "arn:aws:iam::923402097046:role/buildtools-jenkins-RoleJenkinsSlave-JQGYHR5WE6C5";
+        const ecrRepositoryName = props.ecrRepositoryName;
+        let bucket = undefined;
+        if (props.bucketName) {
+            bucket = new s3.Bucket(this, "S3Bucket", {
+                bucketName: props.bucketName,
+                encryption: s3.BucketEncryption.S3_MANAGED,
+                eventBridgeEnabled: true,
+                blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
+                versioned: true,
+                lifecycleRules: [
+                    {
+                        noncurrentVersionExpiration: cdk.Duration.days(10),
+                    },
+                ],
+            });
+        }
+        const ciRole = props.ciRoleName
+            ? new iam.Role(this, "CiRole", {
+                roleName: props.ciRoleName,
+                assumedBy: new iam.ArnPrincipal(externalRoleArn),
+            })
+            : undefined;
+        const griidCiRole = props.griid
+            ? (0, griid_1.getGriidCiRole)(this)
+            : undefined;
+        if (bucket && ciRole) {
+            bucket.grantReadWrite(ciRole);
+        }
+        if (bucket && griidCiRole) {
+            bucket.grantReadWrite(griidCiRole);
+        }
+        const ecrRepo = new ecr.Repository(this, "EcrRepository", {
+            repositoryName: ecrRepositoryName,
+            lifecycleRules: props.ecrRepositoryLifecycleRules || [
+                {
+                    maxImageAge: cdk.Duration.days(180),
+                    tagStatus: ecr.TagStatus.ANY,
+                },
+            ],
+        });
+        if (ciRole) {
+            ecrRepo.grantPullPush(ciRole);
+        }
+        if (griidCiRole) {
+            ecrRepo.grantPullPush(griidCiRole);
+        }
+        // Allow a target to read from the repos. As any specific roles need
+        // to exist before we can grant access, we delegate that responsibility
+        // to the target account.
+        for (const targetAccountId of props.targetAccountIds) {
+            if (bucket) {
+                bucket.grantRead(new iam.AccountPrincipal(targetAccountId));
+            }
+            ecrRepo.grantPull(new iam.AccountPrincipal(targetAccountId));
+        }
+        // Grant permissions to write pipeline variables.
+        if (ciRole || griidCiRole) {
+            const account = cdk.Stack.of(this).account;
+            const region = cdk.Stack.of(this).region;
+            const statement = new iam.PolicyStatement({
+                actions: ["ssm:PutParameter"],
+                resources: [
+                    `arn:aws:ssm:${region}:${account}:parameter/liflig-cdk/*/pipeline-variables/*`,
+                ],
+            });
+            ciRole === null || ciRole === void 0 ? void 0 : ciRole.grantPrincipal.addToPrincipalPolicy(statement);
+            griidCiRole === null || griidCiRole === void 0 ? void 0 : griidCiRole.grantPrincipal.addToPrincipalPolicy(statement);
+        }
+        new cdk.CfnOutput(this, "EcrRepoUri", {
+            value: ecrRepo.repositoryUri,
+        });
+        if (bucket) {
+            new cdk.CfnOutput(this, "BucketName", {
+                value: bucket.bucketName,
+            });
+        }
+        if (ciRole) {
+            new cdk.CfnOutput(this, "CiRoleArn", {
+                value: ciRole.roleArn,
+            });
+        }
+    }
+}
+exports.BuildArtifacts = BuildArtifacts;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/build-artifacts/index.ts"],"names":[],"mappings":";;;AAAA,yCAAwC;AACxC,2CAA0C;AAC1C,2CAA0C;AAC1C,yCAAwC;AACxC,mCAAkC;AAClC,oCAAyC;AAkDzC;;;;;;;;;;;GAWG;AACH,MAAa,cAAe,SAAQ,UAAU,CAAC,SAAS;IAKtD,YAAY,KAA2B,EAAE,EAAU,EAAE,KAAY;;QAC/D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;QAEhB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAA;QAClC,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,iBAAiB,CAAA;QAChD,IAAI,CAAC,gBAAgB,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,CACpC;YACE,OAAO,EAAE,KAAK;YACd,QAAQ,EAAE,YAAY;YACtB,YAAY,EAAE,IAAI,CAAC,iBAAiB;SACrC,EACD,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CACnB,CAAA;QAED,MAAM,eAAe,GACnB,MAAA,KAAK,CAAC,eAAe,mCACrB,iFAAiF,CAAA;QAEnF,MAAM,iBAAiB,GAAG,KAAK,CAAC,iBAAiB,CAAA;QAEjD,IAAI,MAAM,GAA0B,SAAS,CAAA;QAE7C,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YACrB,MAAM,GAAG,IAAI,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE;gBACvC,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,UAAU,EAAE,EAAE,CAAC,gBAAgB,CAAC,UAAU;gBAC1C,kBAAkB,EAAE,IAAI;gBACxB,iBAAiB,EAAE,EAAE,CAAC,iBAAiB,CAAC,SAAS;gBACjD,SAAS,EAAE,IAAI;gBACf,cAAc,EAAE;oBACd;wBACE,2BAA2B,EAAE,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;qBACnD;iBACF;aACF,CAAC,CAAA;QACJ,CAAC;QAED,MAAM,MAAM,GAAyB,KAAK,CAAC,UAAU;YACnD,CAAC,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE;gBAC3B,QAAQ,EAAE,KAAK,CAAC,UAAU;gBAC1B,SAAS,EAAE,IAAI,GAAG,CAAC,YAAY,CAAC,eAAe,CAAC;aACjD,CAAC;YACJ,CAAC,CAAC,SAAS,CAAA;QAEb,MAAM,WAAW,GAA0B,KAAK,CAAC,KAAK;YACpD,CAAC,CAAC,IAAA,sBAAc,EAAC,IAAI,CAAC;YACtB,CAAC,CAAC,SAAS,CAAA;QAEb,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;YACrB,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;QAC/B,CAAC;QAED,IAAI,MAAM,IAAI,WAAW,EAAE,CAAC;YAC1B,MAAM,CAAC,cAAc,CAAC,WAAW,CAAC,CAAA;QACpC,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,eAAe,EAAE;YACxD,cAAc,EAAE,iBAAiB;YACjC,cAAc,EAAE,KAAK,CAAC,2BAA2B,IAAI;gBACnD;oBACE,WAAW,EAAE,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC;oBACnC,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,GAAG;iBAC7B;aACF;SACF,CAAC,CAAA;QAEF,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAAA;QAC/B,CAAC;QAED,IAAI,WAAW,EAAE,CAAC;YAChB,OAAO,CAAC,aAAa,CAAC,WAAW,CAAC,CAAA;QACpC,CAAC;QAED,oEAAoE;QACpE,uEAAuE;QACvE,yBAAyB;QACzB,KAAK,MAAM,eAAe,IAAI,KAAK,CAAC,gBAAgB,EAAE,CAAC;YACrD,IAAI,MAAM,EAAE,CAAC;gBACX,MAAM,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC,CAAA;YAC7D,CAAC;YACD,OAAO,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC,CAAA;QAC9D,CAAC;QAED,iDAAiD;QACjD,IAAI,MAAM,IAAI,WAAW,EAAE,CAAC;YAC1B,MAAM,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAA;YAC1C,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,CAAA;YACxC,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,eAAe,CAAC;gBACxC,OAAO,EAAE,CAAC,kBAAkB,CAAC;gBAC7B,SAAS,EAAE;oBACT,eAAe,MAAM,IAAI,OAAO,8CAA8C;iBAC/E;aACF,CAAC,CAAA;YAEF,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,cAAc,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAA;YACtD,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAE,cAAc,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAA;QAC7D,CAAC;QAED,IAAI,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE;YACpC,KAAK,EAAE,OAAO,CAAC,aAAa;SAC7B,CAAC,CAAA;QAEF,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE;gBACpC,KAAK,EAAE,MAAM,CAAC,UAAU;aACzB,CAAC,CAAA;QACJ,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE;gBACnC,KAAK,EAAE,MAAM,CAAC,OAAO;aACtB,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;CACF;AAxHD,wCAwHC","sourcesContent":["import * as constructs from \"constructs\"\nimport * as ecr from \"aws-cdk-lib/aws-ecr\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as s3 from \"aws-cdk-lib/aws-s3\"\nimport * as cdk from \"aws-cdk-lib\"\nimport { getGriidCiRole } from \"../griid\"\n\ninterface Props {\n  /**\n   * The name to use for the S3 Bucket. Should include both account and region\n   * so that it will not conflict with other accounts/regions.\n   *\n   * @default - no bucket will be created\n   */\n  bucketName?: string\n  /**\n   * The name to use for the ECR Repository.\n   */\n  ecrRepositoryName: string\n  /**\n   * The lifecycle rules to apply to images stored in the ECR repository.\n   *\n   * @default - Expire images after 180 days\n   */\n  ecrRepositoryLifecycleRules?: ecr.LifecycleRule[]\n  /**\n   * Reference to the IAM Role that will be granted permission to\n   * assume the CI role. This role must have permission to assume\n   * the CI role.\n   *\n   * @default - use Liflig Jenkins role\n   */\n  externalRoleArn?: string\n  /**\n   * The name of the role that will be created that will be assumed\n   * from the CI system.\n   *\n   * @default - no role will be created\n   */\n  ciRoleName?: string\n  /**\n   * The AWS Accounts that will be granted permission to read from\n   * the artifact repos.\n   */\n  targetAccountIds: string[]\n  /**\n   * Flag if Griid is bootstrapped and the account this construct is\n   * deployed to is the build account. Will attach policies and\n   * reference existing artifacts and roles.\n   *\n   * @default false\n   */\n  griid?: boolean\n}\n\n/**\n * Build artifacts.\n *\n * This holds a S3 Bucket, a ECR Repository and roles to be used\n * from CI system for uploading.\n *\n * TODO: How can we cleanup stuff that goes into this S3 Bucket and\n *  ECR Repository? Can we ever reliably cleanup? We probably need\n *  some strategy for how we put stuff here to be able to do it.\n *\n * @experimental\n */\nexport class BuildArtifacts extends constructs.Construct {\n  readonly bucketName: string | undefined\n  readonly ecrRepositoryArn: string\n  readonly ecrRepositoryName: string\n\n  constructor(scope: constructs.Construct, id: string, props: Props) {\n    super(scope, id)\n\n    this.bucketName = props.bucketName\n    this.ecrRepositoryName = props.ecrRepositoryName\n    this.ecrRepositoryArn = cdk.Arn.format(\n      {\n        service: \"ecr\",\n        resource: \"repository\",\n        resourceName: this.ecrRepositoryName,\n      },\n      cdk.Stack.of(this),\n    )\n\n    const externalRoleArn =\n      props.externalRoleArn ??\n      \"arn:aws:iam::923402097046:role/buildtools-jenkins-RoleJenkinsSlave-JQGYHR5WE6C5\"\n\n    const ecrRepositoryName = props.ecrRepositoryName\n\n    let bucket: s3.Bucket | undefined = undefined\n\n    if (props.bucketName) {\n      bucket = new s3.Bucket(this, \"S3Bucket\", {\n        bucketName: props.bucketName,\n        encryption: s3.BucketEncryption.S3_MANAGED,\n        eventBridgeEnabled: true,\n        blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,\n        versioned: true,\n        lifecycleRules: [\n          {\n            noncurrentVersionExpiration: cdk.Duration.days(10),\n          },\n        ],\n      })\n    }\n\n    const ciRole: iam.Role | undefined = props.ciRoleName\n      ? new iam.Role(this, \"CiRole\", {\n          roleName: props.ciRoleName,\n          assumedBy: new iam.ArnPrincipal(externalRoleArn),\n        })\n      : undefined\n\n    const griidCiRole: iam.IRole | undefined = props.griid\n      ? getGriidCiRole(this)\n      : undefined\n\n    if (bucket && ciRole) {\n      bucket.grantReadWrite(ciRole)\n    }\n\n    if (bucket && griidCiRole) {\n      bucket.grantReadWrite(griidCiRole)\n    }\n\n    const ecrRepo = new ecr.Repository(this, \"EcrRepository\", {\n      repositoryName: ecrRepositoryName,\n      lifecycleRules: props.ecrRepositoryLifecycleRules || [\n        {\n          maxImageAge: cdk.Duration.days(180),\n          tagStatus: ecr.TagStatus.ANY,\n        },\n      ],\n    })\n\n    if (ciRole) {\n      ecrRepo.grantPullPush(ciRole)\n    }\n\n    if (griidCiRole) {\n      ecrRepo.grantPullPush(griidCiRole)\n    }\n\n    // Allow a target to read from the repos. As any specific roles need\n    // to exist before we can grant access, we delegate that responsibility\n    // to the target account.\n    for (const targetAccountId of props.targetAccountIds) {\n      if (bucket) {\n        bucket.grantRead(new iam.AccountPrincipal(targetAccountId))\n      }\n      ecrRepo.grantPull(new iam.AccountPrincipal(targetAccountId))\n    }\n\n    // Grant permissions to write pipeline variables.\n    if (ciRole || griidCiRole) {\n      const account = cdk.Stack.of(this).account\n      const region = cdk.Stack.of(this).region\n      const statement = new iam.PolicyStatement({\n        actions: [\"ssm:PutParameter\"],\n        resources: [\n          `arn:aws:ssm:${region}:${account}:parameter/liflig-cdk/*/pipeline-variables/*`,\n        ],\n      })\n\n      ciRole?.grantPrincipal.addToPrincipalPolicy(statement)\n      griidCiRole?.grantPrincipal.addToPrincipalPolicy(statement)\n    }\n\n    new cdk.CfnOutput(this, \"EcrRepoUri\", {\n      value: ecrRepo.repositoryUri,\n    })\n\n    if (bucket) {\n      new cdk.CfnOutput(this, \"BucketName\", {\n        value: bucket.bucketName,\n      })\n    }\n\n    if (ciRole) {\n      new cdk.CfnOutput(this, \"CiRoleArn\", {\n        value: ciRole.roleArn,\n      })\n    }\n  }\n}\n"]}

package/lib/cdk-deploy/cdk-deploy.d.ts

@@ -0,0 +1,63 @@
+import * as constructs from "constructs";
+import * as cdk from "aws-cdk-lib";
+interface Props extends cdk.StackProps {
+    /**
+     * The role that will be granted permission to assume the deploy
+     * role. This role must have permission to assume the deploy role.
+     */
+    callerRoleArn: string;
+    /**
+     * The name that will be used for the deploy role. This is the role
+     * that the caller will assume in order to have permission to invoke
+     * the Lambda Functions.
+     */
+    roleName: string;
+    /**
+     * The bucket used for storing artifacts. This is used to grant
+     * permission to the role to read artifact. If the bucket is in
+     * another account, it must have a policy which allows the target
+     * account to use IAM permissions from target account.
+     */
+    artifactsBucketName: string;
+    startDeployFunctionName: string;
+    statusFunctionName: string;
+    /**
+     * This is the stack name used with `cdk bootstrap` and can e
+     * found in cdk.json as "toolkitStackName".
+     */
+    cdkToolkitStackName: string;
+    /**
+     * We pass the CDK context values as they contain feature flags
+     * used by the CDK CLI.
+     */
+    cdkContext: Record<string, string | string[]>;
+    /**
+     * The secret containing username and password (or access token)
+     * for a valid docker user. This is used to access private
+     * repositories or to handle docker hub's pull rate limiting.
+     */
+    dockerCredentialsSecretName?: string;
+}
+/**
+ * This construct is responsible for the privileges and logic of
+ * automatically deploying stack resources in an account.
+ * Its resources are used from a deployment pipeline.
+ *
+ * The deployment is performed by invoking the "start deploy"
+ * lambda with details of what should be deployed. As this is
+ * responsible for deploying infrastructure, the principal invoking
+ * might be able to cause privilege escalation. The principal invoking
+ * should be assumed to have full administrator access.
+ *
+ * The process deploying the infrastructure is locked down so this
+ * is only possibly by deployment through CloudFormation, and as
+ * such removes a lot of possible escalation paths (e.g. no role
+ * can be created by direct API call).
+ *
+ * The "status" lambda can be used to poll for completion, and will
+ * also return logs from the job upon completion.
+ */
+export declare class CdkDeploy extends constructs.Construct {
+    constructor(scope: constructs.Construct, id: string, props: Props);
+}
+export {};

package/lib/cdk-deploy/cdk-deploy.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdkDeploy = void 0;
+const constructs = require("constructs");
+const codebuild = require("aws-cdk-lib/aws-codebuild");
+const iam = require("aws-cdk-lib/aws-iam");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const s3 = require("aws-cdk-lib/aws-s3");
+const cdk = require("aws-cdk-lib");
+const secretsmanager = require("aws-cdk-lib/aws-secretsmanager");
+const start_deploy_handler_1 = require("./start-deploy-handler");
+const status_handler_1 = require("./status-handler");
+/**
+ * This construct is responsible for the privileges and logic of
+ * automatically deploying stack resources in an account.
+ * Its resources are used from a deployment pipeline.
+ *
+ * The deployment is performed by invoking the "start deploy"
+ * lambda with details of what should be deployed. As this is
+ * responsible for deploying infrastructure, the principal invoking
+ * might be able to cause privilege escalation. The principal invoking
+ * should be assumed to have full administrator access.
+ *
+ * The process deploying the infrastructure is locked down so this
+ * is only possibly by deployment through CloudFormation, and as
+ * such removes a lot of possible escalation paths (e.g. no role
+ * can be created by direct API call).
+ *
+ * The "status" lambda can be used to poll for completion, and will
+ * also return logs from the job upon completion.
+ */
+class CdkDeploy extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const account = cdk.Stack.of(this).account;
+        const region = cdk.Stack.of(this).region;
+        const artifactsBucket = s3.Bucket.fromBucketName(this, "ArtifactsBucket", props.artifactsBucketName);
+        const roleToBeAssumed = new iam.Role(this, "Role", {
+            roleName: props.roleName,
+            assumedBy: new iam.ArnPrincipal(props.callerRoleArn),
+        });
+        // Bucked used for input to CodeBuild.
+        // We let CloudFormation manage the bucket name.
+        const codebuildBucket = new s3.Bucket(this, "CodebuildSourceBucket", {
+            encryption: s3.BucketEncryption.S3_MANAGED,
+            blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
+            lifecycleRules: [
+                {
+                    expiration: cdk.Duration.days(5),
+                },
+            ],
+        });
+        // The role used for CloudFormation deployment.
+        const cloudFormationRole = new iam.Role(this, "CloudFormationRole", {
+            assumedBy: new iam.ServicePrincipal("cloudformation.amazonaws.com"),
+            managedPolicies: [
+                // TODO: Can we restrict this a bit more? E.g. look into how Griid has
+                //  limited what the individual stack deployments have permissions to do.
+                iam.ManagedPolicy.fromAwsManagedPolicyName("AdministratorAccess"),
+            ],
+        });
+        // Replace CodeBuild with ECS task?
+        // See https://aws.amazon.com/blogs/devops/using-aws-codebuild-to-execute-administrative-tasks/
+        const codebuildProject = new codebuild.Project(this, "CodebuildProject", {
+            environment: {
+                buildImage: props.dockerCredentialsSecretName == null
+                    ? codebuild.LinuxBuildImage.fromDockerRegistry("node:16")
+                    : codebuild.LinuxBuildImage.fromDockerRegistry("node:16", {
+                        secretsManagerCredentials: secretsmanager.Secret.fromSecretNameV2(this, "dockerCredentialsSecretName", props.dockerCredentialsSecretName),
+                    }),
+            },
+            buildSpec: codebuild.BuildSpec.fromObject({
+                version: "0.2",
+                env: {
+                    variables: {
+                        CDK_DEPLOY_ROLE_ARN: cloudFormationRole.roleArn,
+                        CDK_TOOLKIT_STACK_NAME: props.cdkToolkitStackName,
+                    },
+                },
+                phases: {
+                    build: {
+                        commands: [
+                            "npm install -g aws-cdk",
+                            'cdk --app "$CODEBUILD_SRC_DIR_CLOUDASSEMBLY" --role-arn "$CDK_DEPLOY_ROLE_ARN" --toolkit-stack-name "$CDK_TOOLKIT_STACK_NAME" --require-approval never deploy --exclusively $(cat stack-names.txt)',
+                        ],
+                    },
+                },
+            }),
+            timeout: cdk.Duration.hours(4),
+        });
+        // Grant access to CloudFormation.
+        codebuildProject.addToRolePolicy(new iam.PolicyStatement({
+            actions: [
+                // For diff.
+                "cloudformation:DescribeStacks",
+                "cloudformation:GetTemplate",
+                // For deploy.
+                "cloudformation:CreateChangeSet",
+                "cloudformation:DeleteStack",
+                "cloudformation:DescribeChangeSet",
+                "cloudformation:ExecuteChangeSet",
+                "cloudformation:DescribeStackEvents",
+                "cloudformation:DeleteChangeSet",
+            ],
+            resources: ["*"],
+        }));
+        // Grant access to the CDK Toolkit bucket.
+        codebuildProject.addToRolePolicy(new iam.PolicyStatement({
+            actions: [
+                "s3:GetObject*",
+                "s3:GetBucket*",
+                "s3:List*",
+                "s3:PutObject*",
+                "s3:Abort*",
+                "s3:DeleteObject*",
+            ],
+            resources: [
+                `arn:aws:s3:::${props.cdkToolkitStackName.toLowerCase()}-stagingbucket-*`,
+            ],
+        }));
+        artifactsBucket.grantRead(codebuildProject);
+        cloudFormationRole.grantPassRole(codebuildProject.role);
+        codebuildBucket.grantReadWrite(codebuildProject);
+        const startDeployFn = new lambda.Function(this, "StartDeployFunction", {
+            code: new lambda.InlineCode(`exports.handler = ${start_deploy_handler_1.startDeployHandler.toString()};`),
+            runtime: lambda.Runtime.NODEJS_16_X,
+            handler: "index.handler",
+            functionName: props.startDeployFunctionName,
+            environment: {
+                PROJECT_NAME: codebuildProject.projectName,
+                BUCKET_NAME: codebuildBucket.bucketName,
+                CDK_CONTEXT: JSON.stringify(props.cdkContext),
+            },
+            timeout: cdk.Duration.seconds(30),
+        });
+        startDeployFn.grantInvoke(roleToBeAssumed);
+        codebuildBucket.grantReadWrite(startDeployFn);
+        startDeployFn.addToRolePolicy(new iam.PolicyStatement({
+            actions: ["codebuild:StartBuild", "codebuild:BatchGetBuilds"],
+            resources: [codebuildProject.projectArn],
+        }));
+        const statusFn = new lambda.Function(this, "StatusFunction", {
+            code: new lambda.InlineCode(`exports.handler = ${status_handler_1.statusHandler.toString()};`),
+            runtime: lambda.Runtime.NODEJS_16_X,
+            handler: "index.handler",
+            functionName: props.statusFunctionName,
+            environment: {
+                PROJECT_NAME: codebuildProject.projectName,
+            },
+            timeout: cdk.Duration.seconds(30),
+        });
+        statusFn.grantInvoke(roleToBeAssumed);
+        statusFn.addToRolePolicy(new iam.PolicyStatement({
+            actions: ["codebuild:BatchGetBuilds"],
+            resources: [codebuildProject.projectArn],
+        }));
+        statusFn.addToRolePolicy(new iam.PolicyStatement({
+            actions: ["logs:GetLogEvents"],
+            resources: [
+                `arn:aws:logs:${region}:${account}:log-group:/aws/codebuild/${codebuildProject.projectName}:log-stream:*`,
+            ],
+        }));
+        new cdk.CfnOutput(this, "RoleToBeAssumedArn", {
+            value: roleToBeAssumed.roleArn,
+        });
+        new cdk.CfnOutput(this, "StatusFunctionArn", {
+            value: statusFn.functionArn,
+        });
+        new cdk.CfnOutput(this, "StartDeployFunctionArn", {
+            value: startDeployFn.functionArn,
+        });
+    }
+}
+exports.CdkDeploy = CdkDeploy;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-deploy.js","sourceRoot":"","sources":["../../src/cdk-deploy/cdk-deploy.ts"],"names":[],"mappings":"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","sourcesContent":["import * as constructs from \"constructs\"\nimport * as codebuild from \"aws-cdk-lib/aws-codebuild\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport * as s3 from \"aws-cdk-lib/aws-s3\"\nimport * as cdk from \"aws-cdk-lib\"\nimport * as secretsmanager from \"aws-cdk-lib/aws-secretsmanager\"\nimport { startDeployHandler } from \"./start-deploy-handler\"\nimport { statusHandler } from \"./status-handler\"\n\ninterface Props extends cdk.StackProps {\n  /**\n   * The role that will be granted permission to assume the deploy\n   * role. This role must have permission to assume the deploy role.\n   */\n  callerRoleArn: string\n  /**\n   * The name that will be used for the deploy role. This is the role\n   * that the caller will assume in order to have permission to invoke\n   * the Lambda Functions.\n   */\n  roleName: string\n  /**\n   * The bucket used for storing artifacts. This is used to grant\n   * permission to the role to read artifact. If the bucket is in\n   * another account, it must have a policy which allows the target\n   * account to use IAM permissions from target account.\n   */\n  artifactsBucketName: string\n  startDeployFunctionName: string\n  statusFunctionName: string\n  /**\n   * This is the stack name used with `cdk bootstrap` and can e\n   * found in cdk.json as \"toolkitStackName\".\n   */\n  cdkToolkitStackName: string\n  /**\n   * We pass the CDK context values as they contain feature flags\n   * used by the CDK CLI.\n   */\n  cdkContext: Record<string, string | string[]>\n  /**\n   * The secret containing username and password (or access token)\n   * for a valid docker user. This is used to access private\n   * repositories or to handle docker hub's pull rate limiting.\n   */\n  dockerCredentialsSecretName?: string\n}\n\n/**\n * This construct is responsible for the privileges and logic of\n * automatically deploying stack resources in an account.\n * Its resources are used from a deployment pipeline.\n *\n * The deployment is performed by invoking the \"start deploy\"\n * lambda with details of what should be deployed. As this is\n * responsible for deploying infrastructure, the principal invoking\n * might be able to cause privilege escalation. The principal invoking\n * should be assumed to have full administrator access.\n *\n * The process deploying the infrastructure is locked down so this\n * is only possibly by deployment through CloudFormation, and as\n * such removes a lot of possible escalation paths (e.g. no role\n * can be created by direct API call).\n *\n * The \"status\" lambda can be used to poll for completion, and will\n * also return logs from the job upon completion.\n */\nexport class CdkDeploy extends constructs.Construct {\n  constructor(scope: constructs.Construct, id: string, props: Props) {\n    super(scope, id)\n\n    const account = cdk.Stack.of(this).account\n    const region = cdk.Stack.of(this).region\n\n    const artifactsBucket = s3.Bucket.fromBucketName(\n      this,\n      \"ArtifactsBucket\",\n      props.artifactsBucketName,\n    )\n\n    const roleToBeAssumed = new iam.Role(this, \"Role\", {\n      roleName: props.roleName,\n      assumedBy: new iam.ArnPrincipal(props.callerRoleArn),\n    })\n\n    // Bucked used for input to CodeBuild.\n    // We let CloudFormation manage the bucket name.\n    const codebuildBucket = new s3.Bucket(this, \"CodebuildSourceBucket\", {\n      encryption: s3.BucketEncryption.S3_MANAGED,\n      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,\n      lifecycleRules: [\n        {\n          expiration: cdk.Duration.days(5),\n        },\n      ],\n    })\n\n    // The role used for CloudFormation deployment.\n    const cloudFormationRole = new iam.Role(this, \"CloudFormationRole\", {\n      assumedBy: new iam.ServicePrincipal(\"cloudformation.amazonaws.com\"),\n      managedPolicies: [\n        // TODO: Can we restrict this a bit more? E.g. look into how Griid has\n        //  limited what the individual stack deployments have permissions to do.\n        iam.ManagedPolicy.fromAwsManagedPolicyName(\"AdministratorAccess\"),\n      ],\n    })\n\n    // Replace CodeBuild with ECS task?\n    // See https://aws.amazon.com/blogs/devops/using-aws-codebuild-to-execute-administrative-tasks/\n    const codebuildProject = new codebuild.Project(this, \"CodebuildProject\", {\n      environment: {\n        buildImage:\n          props.dockerCredentialsSecretName == null\n            ? codebuild.LinuxBuildImage.fromDockerRegistry(\"node:16\")\n            : codebuild.LinuxBuildImage.fromDockerRegistry(\"node:16\", {\n                secretsManagerCredentials:\n                  secretsmanager.Secret.fromSecretNameV2(\n                    this,\n                    \"dockerCredentialsSecretName\",\n                    props.dockerCredentialsSecretName,\n                  ),\n              }),\n      },\n      buildSpec: codebuild.BuildSpec.fromObject({\n        version: \"0.2\",\n        env: {\n          variables: {\n            CDK_DEPLOY_ROLE_ARN: cloudFormationRole.roleArn,\n            CDK_TOOLKIT_STACK_NAME: props.cdkToolkitStackName,\n          },\n        },\n        phases: {\n          build: {\n            commands: [\n              \"npm install -g aws-cdk\",\n              'cdk --app \"$CODEBUILD_SRC_DIR_CLOUDASSEMBLY\" --role-arn \"$CDK_DEPLOY_ROLE_ARN\" --toolkit-stack-name \"$CDK_TOOLKIT_STACK_NAME\" --require-approval never deploy --exclusively $(cat stack-names.txt)',\n            ],\n          },\n        },\n      }),\n      timeout: cdk.Duration.hours(4),\n    })\n\n    // Grant access to CloudFormation.\n    codebuildProject.addToRolePolicy(\n      new iam.PolicyStatement({\n        actions: [\n          // For diff.\n          \"cloudformation:DescribeStacks\",\n          \"cloudformation:GetTemplate\",\n          // For deploy.\n          \"cloudformation:CreateChangeSet\",\n          \"cloudformation:DeleteStack\",\n          \"cloudformation:DescribeChangeSet\",\n          \"cloudformation:ExecuteChangeSet\",\n          \"cloudformation:DescribeStackEvents\",\n          \"cloudformation:DeleteChangeSet\",\n        ],\n        resources: [\"*\"],\n      }),\n    )\n\n    // Grant access to the CDK Toolkit bucket.\n    codebuildProject.addToRolePolicy(\n      new iam.PolicyStatement({\n        actions: [\n          \"s3:GetObject*\",\n          \"s3:GetBucket*\",\n          \"s3:List*\",\n          \"s3:PutObject*\",\n          \"s3:Abort*\",\n          \"s3:DeleteObject*\",\n        ],\n        resources: [\n          `arn:aws:s3:::${props.cdkToolkitStackName.toLowerCase()}-stagingbucket-*`,\n        ],\n      }),\n    )\n\n    artifactsBucket.grantRead(codebuildProject)\n\n    cloudFormationRole.grantPassRole(codebuildProject.role!)\n\n    codebuildBucket.grantReadWrite(codebuildProject)\n\n    const startDeployFn = new lambda.Function(this, \"StartDeployFunction\", {\n      code: new lambda.InlineCode(\n        `exports.handler = ${startDeployHandler.toString()};`,\n      ),\n      runtime: lambda.Runtime.NODEJS_16_X,\n      handler: \"index.handler\",\n      functionName: props.startDeployFunctionName,\n      environment: {\n        PROJECT_NAME: codebuildProject.projectName,\n        BUCKET_NAME: codebuildBucket.bucketName,\n        CDK_CONTEXT: JSON.stringify(props.cdkContext),\n      },\n      timeout: cdk.Duration.seconds(30),\n    })\n\n    startDeployFn.grantInvoke(roleToBeAssumed)\n    codebuildBucket.grantReadWrite(startDeployFn)\n\n    startDeployFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        actions: [\"codebuild:StartBuild\", \"codebuild:BatchGetBuilds\"],\n        resources: [codebuildProject.projectArn],\n      }),\n    )\n\n    const statusFn = new lambda.Function(this, \"StatusFunction\", {\n      code: new lambda.InlineCode(\n        `exports.handler = ${statusHandler.toString()};`,\n      ),\n      runtime: lambda.Runtime.NODEJS_16_X,\n      handler: \"index.handler\",\n      functionName: props.statusFunctionName,\n      environment: {\n        PROJECT_NAME: codebuildProject.projectName,\n      },\n      timeout: cdk.Duration.seconds(30),\n    })\n\n    statusFn.grantInvoke(roleToBeAssumed)\n\n    statusFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        actions: [\"codebuild:BatchGetBuilds\"],\n        resources: [codebuildProject.projectArn],\n      }),\n    )\n\n    statusFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        actions: [\"logs:GetLogEvents\"],\n        resources: [\n          `arn:aws:logs:${region}:${account}:log-group:/aws/codebuild/${codebuildProject.projectName}:log-stream:*`,\n        ],\n      }),\n    )\n\n    new cdk.CfnOutput(this, \"RoleToBeAssumedArn\", {\n      value: roleToBeAssumed.roleArn,\n    })\n    new cdk.CfnOutput(this, \"StatusFunctionArn\", {\n      value: statusFn.functionArn,\n    })\n    new cdk.CfnOutput(this, \"StartDeployFunctionArn\", {\n      value: startDeployFn.functionArn,\n    })\n  }\n}\n"]}

package/lib/cdk-deploy/index.d.ts

@@ -0,0 +1 @@
+export { CdkDeploy } from "./cdk-deploy";

package/lib/cdk-deploy/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdkDeploy = void 0;
+var cdk_deploy_1 = require("./cdk-deploy");
+Object.defineProperty(exports, "CdkDeploy", { enumerable: true, get: function () { return cdk_deploy_1.CdkDeploy; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2RrLWRlcGxveS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwyQ0FBd0M7QUFBL0IsdUdBQUEsU0FBUyxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgQ2RrRGVwbG95IH0gZnJvbSBcIi4vY2RrLWRlcGxveVwiXG4iXX0=

package/lib/cdk-deploy/start-deploy-handler.d.ts

@@ -0,0 +1,8 @@
+import { Handler } from "aws-lambda";
+interface StartDeployExpectedInput {
+    bucketName: string;
+    bucketKey: string;
+    stackNames: string[];
+}
+export declare const startDeployHandler: Handler<Partial<StartDeployExpectedInput>>;
+export {};