cdk-nextjs 0.0.0

package/lib/nextjs-build/symlink-full-route-cache.mjs

@@ -0,0 +1,23 @@
+// src/nextjs-build/symlink-full-route-cache.ts
+import { mkdirSync, readdirSync, rmSync, symlinkSync } from "node:fs";
+import { extname, join } from "node:path";
+function createSymlinks(srcPath, destPath2) {
+  mkdirSync(destPath2, { recursive: true });
+  const entries = readdirSync(srcPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = join(srcPath, entry.name);
+    if (entry.isDirectory()) {
+      createSymlinks(entryPath, join(destPath2, entry.name));
+    } else if (entry.isFile()) {
+      const ext = extname(entryPath).slice(1);
+      if (["html", "rsc", "meta"].includes(ext)) {
+        const symlink = entryPath;
+        const target = join(destPath2, entry.name);
+        rmSync(symlink);
+        symlinkSync(target, symlink, "file");
+      }
+    }
+  }
+}
+var [sourcePath, destPath] = process.argv.slice(2);
+createSymlinks(sourcePath, destPath);

package/lib/nextjs-compute/nextjs-compute-base-props.d.ts

@@ -0,0 +1,8 @@
+import { IVpc } from "aws-cdk-lib/aws-ec2";
+import { AccessPoint } from "aws-cdk-lib/aws-efs";
+export interface NextjsComputeBaseProps {
+    readonly accessPoint: AccessPoint;
+    readonly containerMountPathForEfs: string;
+    readonly healthCheckPath: string;
+    readonly vpc: IVpc;
+}

package/lib/nextjs-compute/nextjs-compute-base-props.js

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

package/lib/nextjs-compute/nextjs-containers.d.ts

@@ -0,0 +1,43 @@
+import { DockerImageAsset } from "aws-cdk-lib/aws-ecr-assets";
+import { Cluster } from "aws-cdk-lib/aws-ecs";
+import { ApplicationLoadBalancedFargateService, ApplicationLoadBalancedFargateServiceProps } from "aws-cdk-lib/aws-ecs-patterns";
+import { FileSystem } from "aws-cdk-lib/aws-efs";
+import { Construct } from "constructs";
+import { NextjsComputeBaseProps } from "./nextjs-compute-base-props";
+import { NextjsType } from "../common";
+import { OptionalApplicationLoadBalancedTaskImageOptions } from "../generated-structs/OptionalApplicationLoadBalancedTaskImageOptions";
+import { OptionalClusterProps } from "../generated-structs/OptionalClusterProps";
+export interface NextjsContainersOverrides {
+    readonly ecsClusterProps?: OptionalClusterProps;
+    readonly albFargateServiceProps?: ApplicationLoadBalancedFargateServiceProps;
+    readonly taskImageOptions?: OptionalApplicationLoadBalancedTaskImageOptions;
+}
+export interface NextjsContainersProps extends NextjsComputeBaseProps {
+    readonly dockerImageAsset: DockerImageAsset;
+    readonly fileSystem: FileSystem;
+    readonly nextjsType: NextjsType;
+    readonly overrides?: NextjsContainersOverrides;
+    readonly relativeEntrypointPath: string;
+}
+/**
+ * Next.js load balanced via Application Load Balancer with containers via AWS
+ * Fargate.
+ */
+export declare class NextjsContainers extends Construct {
+    albFargateService: ApplicationLoadBalancedFargateService;
+    ecsCluster: Cluster;
+    url: string;
+    private props;
+    constructor(scope: Construct, id: string, props: NextjsContainersProps);
+    private createEcsCluster;
+    private createAlbFargateSevice;
+    /**
+     * Configure health checks for containers at ALB and ECS level. This ensures
+     * unhealthy containers are removed. Both of these health checks can be
+     * overwritten by user by accessing `albFargateService` property, so no need
+     * for `overrides`.
+     */
+    private configureHealthCheck;
+    private attachFileSystem;
+    private getUrl;
+}

package/lib/nextjs-compute/nextjs-containers.js

@@ -0,0 +1,149 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsContainers = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_ecs_1 = require("aws-cdk-lib/aws-ecs");
+const aws_ecs_patterns_1 = require("aws-cdk-lib/aws-ecs-patterns");
+const aws_elasticloadbalancingv2_1 = require("aws-cdk-lib/aws-elasticloadbalancingv2");
+const constructs_1 = require("constructs");
+/**
+ * Next.js load balanced via Application Load Balancer with containers via AWS
+ * Fargate.
+ */
+class NextjsContainers extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.ecsCluster = this.createEcsCluster();
+        this.albFargateService = this.createAlbFargateSevice();
+        this.configureHealthCheck();
+        this.attachFileSystem();
+        this.url = this.getUrl();
+    }
+    createEcsCluster() {
+        const cluster = new aws_ecs_1.Cluster(this, "EcsCluster", {
+            enableFargateCapacityProviders: true,
+            containerInsights: true,
+            vpc: this.props.vpc,
+            ...this.props.overrides?.ecsClusterProps,
+        });
+        return cluster;
+    }
+    createAlbFargateSevice() {
+        let cpuArchitecture = undefined;
+        if (process.arch === "x64") {
+            cpuArchitecture = aws_ecs_1.CpuArchitecture.X86_64;
+        }
+        else if (process.arch === "arm64") {
+            cpuArchitecture = aws_ecs_1.CpuArchitecture.ARM64;
+        }
+        const albFargateService = new aws_ecs_patterns_1.ApplicationLoadBalancedFargateService(this, "AlbFargateService", {
+            circuitBreaker: { rollback: true, enable: true },
+            cluster: this.ecsCluster,
+            cpu: 1024,
+            healthCheckGracePeriod: aws_cdk_lib_1.Duration.seconds(10),
+            maxHealthyPercent: 200,
+            memoryLimitMiB: 2048,
+            minHealthyPercent: 100, // maintain service availability during deployment
+            /*
+              This protocol version is for the target group (Fargate), not the ALB
+              Listener. From docs, "Application Load Balancers provide native support
+              for HTTP/2 with HTTPS listeners". See https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html
+              Next.js default server does not support HTTP/2 as it's recommended
+              to proxy your Next.js server which we're doing with ALB.
+              Also note, CloudFront only supports HTTP/1.1 origins.
+              https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/RequestAndResponseBehaviorCustomOrigin.html#RequestCustomHTTPVersion
+            */
+            protocolVersion: aws_elasticloadbalancingv2_1.ApplicationProtocolVersion.HTTP1,
+            runtimePlatform: {
+                cpuArchitecture,
+            },
+            taskImageOptions: {
+                command: ["node", this.props.relativeEntrypointPath],
+                containerName: "nextjs",
+                containerPort: 3000,
+                image: aws_ecs_1.ContainerImage.fromDockerImageAsset(this.props.dockerImageAsset),
+                logDriver: aws_ecs_1.LogDrivers.awsLogs({
+                    streamPrefix: "nextjs",
+                    mode: aws_ecs_1.AwsLogDriverMode.NON_BLOCKING,
+                }),
+                ...this.props.overrides?.taskImageOptions,
+            },
+            ...this.props.overrides?.albFargateServiceProps,
+        });
+        // required or health checks fail
+        albFargateService.taskDefinition.defaultContainer?.addEnvironment("HOSTNAME", "0.0.0.0");
+        // security best practice to enforce readonly for root filesystem
+        // hopefully https://github.com/aws/aws-cdk/issues/23935 will result in
+        // easier way to set this property
+        const cfnTaskDef = albFargateService.taskDefinition.node
+            .defaultChild;
+        cfnTaskDef.addPropertyOverride("ContainerDefinitions.0.ReadonlyRootFilesystem", true);
+        // speed up deployments by shortening deregistration delay
+        // https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/load-balancer-connection-draining.html
+        // TODO: document that this should be increased if long lived connections are expected
+        albFargateService.targetGroup.setAttribute("deregistration_delay.timeout_seconds", "30");
+        // best practice to enable cross zone load balancing
+        // @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/disable-cross-zone.html
+        albFargateService.loadBalancer.setAttribute("load_balancing.cross_zone.enabled", "true");
+        return albFargateService;
+    }
+    /**
+     * Configure health checks for containers at ALB and ECS level. This ensures
+     * unhealthy containers are removed. Both of these health checks can be
+     * overwritten by user by accessing `albFargateService` property, so no need
+     * for `overrides`.
+     */
+    configureHealthCheck() {
+        // speed up deployments by shortening health checks
+        // see https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/load-balancer-healthcheck.html
+        this.albFargateService.targetGroup.configureHealthCheck({
+            path: this.props.healthCheckPath,
+            healthyThresholdCount: 2,
+            interval: aws_cdk_lib_1.Duration.seconds(10), // too frequent? but enables faster rollback...
+            timeout: aws_cdk_lib_1.Duration.seconds(5), // must be less than interval
+        });
+        const healthCheck = {
+            command: [
+                "CMD-SHELL",
+                // curl isn't available in alpine linux
+                `wget --quiet --tries=1 --spider http://localhost:3000${this.props.healthCheckPath} || exit 1`,
+            ],
+        };
+        const defaultContainer = this.albFargateService.taskDefinition.defaultContainer;
+        if (defaultContainer) {
+            // @ts-expect-error must use internal "props" attribute b/c no other way to add health check
+            defaultContainer.props.healthCheck = healthCheck;
+        }
+    }
+    attachFileSystem() {
+        const container = this.albFargateService.taskDefinition.defaultContainer;
+        const volumeName = "cdk-nextjs-volume";
+        this.albFargateService.taskDefinition.addVolume({
+            name: volumeName,
+            efsVolumeConfiguration: {
+                fileSystemId: this.props.fileSystem.fileSystemId,
+                transitEncryption: "ENABLED",
+                authorizationConfig: {
+                    accessPointId: this.props.accessPoint.accessPointId,
+                    iam: "ENABLED",
+                },
+            },
+        });
+        container?.addMountPoints({
+            sourceVolume: volumeName,
+            containerPath: this.props.containerMountPathForEfs,
+            readOnly: false,
+        });
+    }
+    getUrl() {
+        const protocol = this.albFargateService.certificate ? "https" : "http";
+        return `${protocol}://${this.albFargateService.loadBalancer.loadBalancerDnsName}`;
+    }
+}
+exports.NextjsContainers = NextjsContainers;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsContainers[_a] = { fqn: "cdk-nextjs.NextjsContainers", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-containers.js","sourceRoot":"","sources":["../../src/nextjs-compute/nextjs-containers.ts"],"names":[],"mappings":";;;;;AAAA,6CAAuC;AAEvC,iDAQ6B;AAC7B,mEAGsC;AAEtC,uFAAoF;AACpF,2CAAuC;AAoBvC;;;GAGG;AACH,MAAa,gBAAiB,SAAQ,sBAAS;IAO7C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA4B;QACpE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC1C,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACvD,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;IAC3B,CAAC;IAEO,gBAAgB;QACtB,MAAM,OAAO,GAAG,IAAI,iBAAO,CAAC,IAAI,EAAE,YAAY,EAAE;YAC9C,8BAA8B,EAAE,IAAI;YACpC,iBAAiB,EAAE,IAAI;YACvB,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG;YACnB,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,eAAe;SACzC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC;IACjB,CAAC;IACO,sBAAsB;QAC5B,IAAI,eAAe,GAAgC,SAAS,CAAC;QAC7D,IAAI,OAAO,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;YAC3B,eAAe,GAAG,yBAAe,CAAC,MAAM,CAAC;QAC3C,CAAC;aAAM,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACpC,eAAe,GAAG,yBAAe,CAAC,KAAK,CAAC;QAC1C,CAAC;QACD,MAAM,iBAAiB,GAAG,IAAI,wDAAqC,CACjE,IAAI,EACJ,mBAAmB,EACnB;YACE,cAAc,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;YAChD,OAAO,EAAE,IAAI,CAAC,UAAU;YACxB,GAAG,EAAE,IAAI;YACT,sBAAsB,EAAE,sBAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5C,iBAAiB,EAAE,GAAG;YACtB,cAAc,EAAE,IAAI;YACpB,iBAAiB,EAAE,GAAG,EAAE,kDAAkD;YAC1E;;;;;;;;cAQE;YACF,eAAe,EAAE,uDAA0B,CAAC,KAAK;YACjD,eAAe,EAAE;gBACf,eAAe;aAChB;YACD,gBAAgB,EAAE;gBAChB,OAAO,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC;gBACpD,aAAa,EAAE,QAAQ;gBACvB,aAAa,EAAE,IAAI;gBACnB,KAAK,EAAE,wBAAc,CAAC,oBAAoB,CACxC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAC5B;gBACD,SAAS,EAAE,oBAAU,CAAC,OAAO,CAAC;oBAC5B,YAAY,EAAE,QAAQ;oBACtB,IAAI,EAAE,0BAAgB,CAAC,YAAY;iBACpC,CAAC;gBACF,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,gBAAgB;aAC1C;YACD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,sBAAsB;SAChD,CACF,CAAC;QACF,iCAAiC;QACjC,iBAAiB,CAAC,cAAc,CAAC,gBAAgB,EAAE,cAAc,CAC/D,UAAU,EACV,SAAS,CACV,CAAC;QACF,iEAAiE;QACjE,uEAAuE;QACvE,kCAAkC;QAClC,MAAM,UAAU,GAAG,iBAAiB,CAAC,cAAc,CAAC,IAAI;aACrD,YAAiC,CAAC;QACrC,UAAU,CAAC,mBAAmB,CAC5B,+CAA+C,EAC/C,IAAI,CACL,CAAC;QACF,0DAA0D;QAC1D,yGAAyG;QACzG,sFAAsF;QACtF,iBAAiB,CAAC,WAAW,CAAC,YAAY,CACxC,sCAAsC,EACtC,IAAI,CACL,CAAC;QACF,oDAAoD;QACpD,mGAAmG;QACnG,iBAAiB,CAAC,YAAY,CAAC,YAAY,CACzC,mCAAmC,EACnC,MAAM,CACP,CAAC;QACF,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IACD;;;;;OAKG;IACK,oBAAoB;QAC1B,mDAAmD;QACnD,qGAAqG;QACrG,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,oBAAoB,CAAC;YACtD,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,eAAe;YAChC,qBAAqB,EAAE,CAAC;YACxB,QAAQ,EAAE,sBAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,+CAA+C;YAC/E,OAAO,EAAE,sBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,6BAA6B;SAC5D,CAAC,CAAC;QACH,MAAM,WAAW,GAAgB;YAC/B,OAAO,EAAE;gBACP,WAAW;gBACX,uCAAuC;gBACvC,wDAAwD,IAAI,CAAC,KAAK,CAAC,eAAe,YAAY;aAC/F;SACF,CAAC;QACF,MAAM,gBAAgB,GACpB,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,gBAAgB,CAAC;QACzD,IAAI,gBAAgB,EAAE,CAAC;YACrB,4FAA4F;YAC5F,gBAAgB,CAAC,KAAK,CAAC,WAAW,GAAG,WAAW,CAAC;QACnD,CAAC;IACH,CAAC;IACO,gBAAgB;QACtB,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,gBAAgB,CAAC;QACzE,MAAM,UAAU,GAAG,mBAAmB,CAAC;QACvC,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,SAAS,CAAC;YAC9C,IAAI,EAAE,UAAU;YAChB,sBAAsB,EAAE;gBACtB,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,YAAY;gBAChD,iBAAiB,EAAE,SAAS;gBAC5B,mBAAmB,EAAE;oBACnB,aAAa,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,aAAa;oBACnD,GAAG,EAAE,SAAS;iBACf;aACF;SACF,CAAC,CAAC;QACH,SAAS,EAAE,cAAc,CAAC;YACxB,YAAY,EAAE,UAAU;YACxB,aAAa,EAAE,IAAI,CAAC,KAAK,CAAC,wBAAwB;YAClD,QAAQ,EAAE,KAAK;SAChB,CAAC,CAAC;IACL,CAAC;IACO,MAAM;QACZ,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;QACvE,OAAO,GAAG,QAAQ,MAAM,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,mBAAmB,EAAE,CAAC;IACpF,CAAC;;AA1JH,4CA2JC","sourcesContent":["import { Duration } from \"aws-cdk-lib\";\nimport { DockerImageAsset } from \"aws-cdk-lib/aws-ecr-assets\";\nimport {\n  AwsLogDriverMode,\n  CfnTaskDefinition,\n  Cluster,\n  ContainerImage,\n  CpuArchitecture,\n  HealthCheck,\n  LogDrivers,\n} from \"aws-cdk-lib/aws-ecs\";\nimport {\n  ApplicationLoadBalancedFargateService,\n  ApplicationLoadBalancedFargateServiceProps,\n} from \"aws-cdk-lib/aws-ecs-patterns\";\nimport { FileSystem } from \"aws-cdk-lib/aws-efs\";\nimport { ApplicationProtocolVersion } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { Construct } from \"constructs\";\nimport { NextjsComputeBaseProps } from \"./nextjs-compute-base-props\";\nimport { NextjsType } from \"../common\";\nimport { OptionalApplicationLoadBalancedTaskImageOptions } from \"../generated-structs/OptionalApplicationLoadBalancedTaskImageOptions\";\nimport { OptionalClusterProps } from \"../generated-structs/OptionalClusterProps\";\n\nexport interface NextjsContainersOverrides {\n  readonly ecsClusterProps?: OptionalClusterProps;\n  readonly albFargateServiceProps?: ApplicationLoadBalancedFargateServiceProps;\n  readonly taskImageOptions?: OptionalApplicationLoadBalancedTaskImageOptions;\n}\n\nexport interface NextjsContainersProps extends NextjsComputeBaseProps {\n  readonly dockerImageAsset: DockerImageAsset;\n  readonly fileSystem: FileSystem;\n  readonly nextjsType: NextjsType;\n  readonly overrides?: NextjsContainersOverrides;\n  readonly relativeEntrypointPath: string;\n}\n\n/**\n * Next.js load balanced via Application Load Balancer with containers via AWS\n * Fargate.\n */\nexport class NextjsContainers extends Construct {\n  albFargateService: ApplicationLoadBalancedFargateService;\n  ecsCluster: Cluster;\n  url: string;\n\n  private props: NextjsContainersProps;\n\n  constructor(scope: Construct, id: string, props: NextjsContainersProps) {\n    super(scope, id);\n    this.props = props;\n    this.ecsCluster = this.createEcsCluster();\n    this.albFargateService = this.createAlbFargateSevice();\n    this.configureHealthCheck();\n    this.attachFileSystem();\n    this.url = this.getUrl();\n  }\n\n  private createEcsCluster(): Cluster {\n    const cluster = new Cluster(this, \"EcsCluster\", {\n      enableFargateCapacityProviders: true,\n      containerInsights: true,\n      vpc: this.props.vpc,\n      ...this.props.overrides?.ecsClusterProps,\n    });\n    return cluster;\n  }\n  private createAlbFargateSevice(): ApplicationLoadBalancedFargateService {\n    let cpuArchitecture: CpuArchitecture | undefined = undefined;\n    if (process.arch === \"x64\") {\n      cpuArchitecture = CpuArchitecture.X86_64;\n    } else if (process.arch === \"arm64\") {\n      cpuArchitecture = CpuArchitecture.ARM64;\n    }\n    const albFargateService = new ApplicationLoadBalancedFargateService(\n      this,\n      \"AlbFargateService\",\n      {\n        circuitBreaker: { rollback: true, enable: true },\n        cluster: this.ecsCluster,\n        cpu: 1024,\n        healthCheckGracePeriod: Duration.seconds(10),\n        maxHealthyPercent: 200,\n        memoryLimitMiB: 2048,\n        minHealthyPercent: 100, // maintain service availability during deployment\n        /*\n          This protocol version is for the target group (Fargate), not the ALB\n          Listener. From docs, \"Application Load Balancers provide native support\n          for HTTP/2 with HTTPS listeners\". See https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html\n          Next.js default server does not support HTTP/2 as it's recommended\n          to proxy your Next.js server which we're doing with ALB.\n          Also note, CloudFront only supports HTTP/1.1 origins.\n          https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/RequestAndResponseBehaviorCustomOrigin.html#RequestCustomHTTPVersion\n        */\n        protocolVersion: ApplicationProtocolVersion.HTTP1,\n        runtimePlatform: {\n          cpuArchitecture,\n        },\n        taskImageOptions: {\n          command: [\"node\", this.props.relativeEntrypointPath],\n          containerName: \"nextjs\",\n          containerPort: 3000,\n          image: ContainerImage.fromDockerImageAsset(\n            this.props.dockerImageAsset,\n          ),\n          logDriver: LogDrivers.awsLogs({\n            streamPrefix: \"nextjs\",\n            mode: AwsLogDriverMode.NON_BLOCKING,\n          }),\n          ...this.props.overrides?.taskImageOptions,\n        },\n        ...this.props.overrides?.albFargateServiceProps,\n      },\n    );\n    // required or health checks fail\n    albFargateService.taskDefinition.defaultContainer?.addEnvironment(\n      \"HOSTNAME\",\n      \"0.0.0.0\",\n    );\n    // security best practice to enforce readonly for root filesystem\n    // hopefully https://github.com/aws/aws-cdk/issues/23935 will result in\n    // easier way to set this property\n    const cfnTaskDef = albFargateService.taskDefinition.node\n      .defaultChild as CfnTaskDefinition;\n    cfnTaskDef.addPropertyOverride(\n      \"ContainerDefinitions.0.ReadonlyRootFilesystem\",\n      true, // TODO: figure why symlink not being created between full route cache\n    );\n    // speed up deployments by shortening deregistration delay\n    // https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/load-balancer-connection-draining.html\n    // TODO: document that this should be increased if long lived connections are expected\n    albFargateService.targetGroup.setAttribute(\n      \"deregistration_delay.timeout_seconds\",\n      \"30\",\n    );\n    // best practice to enable cross zone load balancing\n    // @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/disable-cross-zone.html\n    albFargateService.loadBalancer.setAttribute(\n      \"load_balancing.cross_zone.enabled\",\n      \"true\",\n    );\n    return albFargateService;\n  }\n  /**\n   * Configure health checks for containers at ALB and ECS level. This ensures\n   * unhealthy containers are removed. Both of these health checks can be\n   * overwritten by user by accessing `albFargateService` property, so no need\n   * for `overrides`.\n   */\n  private configureHealthCheck() {\n    // speed up deployments by shortening health checks\n    // see https://docs.aws.amazon.com/AmazonECS/latest/bestpracticesguide/load-balancer-healthcheck.html\n    this.albFargateService.targetGroup.configureHealthCheck({\n      path: this.props.healthCheckPath,\n      healthyThresholdCount: 2,\n      interval: Duration.seconds(10), // too frequent? but enables faster rollback...\n      timeout: Duration.seconds(5), // must be less than interval\n    });\n    const healthCheck: HealthCheck = {\n      command: [\n        \"CMD-SHELL\",\n        // curl isn't available in alpine linux\n        `wget --quiet --tries=1 --spider http://localhost:3000${this.props.healthCheckPath} || exit 1`,\n      ],\n    };\n    const defaultContainer =\n      this.albFargateService.taskDefinition.defaultContainer;\n    if (defaultContainer) {\n      // @ts-expect-error must use internal \"props\" attribute b/c no other way to add health check\n      defaultContainer.props.healthCheck = healthCheck;\n    }\n  }\n  private attachFileSystem() {\n    const container = this.albFargateService.taskDefinition.defaultContainer;\n    const volumeName = \"cdk-nextjs-volume\";\n    this.albFargateService.taskDefinition.addVolume({\n      name: volumeName,\n      efsVolumeConfiguration: {\n        fileSystemId: this.props.fileSystem.fileSystemId,\n        transitEncryption: \"ENABLED\",\n        authorizationConfig: {\n          accessPointId: this.props.accessPoint.accessPointId,\n          iam: \"ENABLED\",\n        },\n      },\n    });\n    container?.addMountPoints({\n      sourceVolume: volumeName,\n      containerPath: this.props.containerMountPathForEfs,\n      readOnly: false,\n    });\n  }\n  private getUrl(): string {\n    const protocol = this.albFargateService.certificate ? \"https\" : \"http\";\n    return `${protocol}://${this.albFargateService.loadBalancer.loadBalancerDnsName}`;\n  }\n}\n"]}

package/lib/nextjs-compute/nextjs-functions.d.ts

@@ -0,0 +1,23 @@
+import { DockerImageCode, DockerImageFunction, FunctionUrl } from "aws-cdk-lib/aws-lambda";
+import { Construct } from "constructs";
+import { NextjsComputeBaseProps } from "./nextjs-compute-base-props";
+import { OptionalDockerImageFunctionProps } from "../generated-structs/OptionalDockerImageFunctionProps";
+import { OptionalFunctionUrlProps } from "../generated-structs/OptionalFunctionUrlProps";
+export interface NextjsFunctionsOverrides {
+    readonly dockerImageFunctionProps?: OptionalDockerImageFunctionProps;
+    readonly functionUrlProps?: OptionalFunctionUrlProps;
+}
+export interface NextjsFunctionsProps extends NextjsComputeBaseProps {
+    readonly dockerImageCode: DockerImageCode;
+    readonly overrides?: NextjsFunctionsOverrides;
+}
+/**
+ * Run Next.js in functions on AWS with AWS Lambda.
+ */
+export declare class NextjsFunctions extends Construct {
+    function: DockerImageFunction;
+    functionUrl: FunctionUrl;
+    private props;
+    constructor(scope: Construct, id: string, props: NextjsFunctionsProps);
+    private createFunction;
+}

package/lib/nextjs-compute/nextjs-functions.js

@@ -0,0 +1,57 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsFunctions = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const constructs_1 = require("constructs");
+/**
+ * Run Next.js in functions on AWS with AWS Lambda.
+ */
+class NextjsFunctions extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.function = this.createFunction();
+        this.functionUrl = this.function.addFunctionUrl({
+            authType: aws_lambda_1.FunctionUrlAuthType.AWS_IAM,
+            invokeMode: aws_lambda_1.InvokeMode.RESPONSE_STREAM,
+            ...this.props.overrides?.functionUrlProps,
+        });
+        if (!this.function.role) {
+            throw new Error("Function role is undefined");
+        }
+    }
+    createFunction() {
+        let architecture = undefined;
+        if (process.arch === "x64") {
+            architecture = aws_lambda_1.Architecture.X86_64;
+        }
+        else if (process.arch === "arm64") {
+            architecture = aws_lambda_1.Architecture.ARM_64;
+        }
+        const fn = new aws_lambda_1.DockerImageFunction(this, "Functions", {
+            architecture,
+            code: this.props.dockerImageCode,
+            filesystem: aws_lambda_1.FileSystem.fromEfsAccessPoint(this.props.accessPoint, this.props.containerMountPathForEfs),
+            memorySize: 2048,
+            timeout: aws_cdk_lib_1.Duration.seconds(30),
+            vpc: this.props.vpc,
+            ...this.props.overrides?.dockerImageFunctionProps,
+            environment: {
+                AWS_LWA_ENABLE_COMPRESSION: "true",
+                AWS_LWA_INVOKE_MODE: "response_stream",
+                AWS_LWA_READINESS_CHECK_PATH: this.props.healthCheckPath,
+                AWS_LWA_READINESS_CHECK_PORT: "3000",
+                READINESS_CHECK_PATH: `http://127.0.0.1:3000${this.props.healthCheckPath}`,
+                ...this.props.overrides?.dockerImageFunctionProps?.environment,
+            },
+        });
+        return fn;
+    }
+}
+exports.NextjsFunctions = NextjsFunctions;
+_a = JSII_RTTI_SYMBOL_1;
+NextjsFunctions[_a] = { fqn: "cdk-nextjs.NextjsFunctions", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/nextjs-distribution.d.ts

@@ -0,0 +1,120 @@
+import { ICertificate } from "aws-cdk-lib/aws-certificatemanager";
+import { AddBehaviorOptions, CachePolicyProps, Distribution, ResponseHeadersPolicyProps } from "aws-cdk-lib/aws-cloudfront";
+import { HttpOriginProps } from "aws-cdk-lib/aws-cloudfront-origins";
+import { IBucket } from "aws-cdk-lib/aws-s3";
+import { Construct } from "constructs";
+import { NextjsType } from "./common";
+import { OptionalDistributionProps } from "./generated-structs/OptionalDistributionProps";
+import { OptionalFunctionProps } from "./generated-structs/OptionalFunctionProps";
+import { OptionalS3OriginProps } from "./generated-structs/OptionalS3OriginProps";
+import { PublicDirEntry } from "./nextjs-build/nextjs-build";
+export interface NextjsDistributionOverrides {
+    readonly edgeFunctionProps?: OptionalFunctionProps;
+    readonly distributionProps?: OptionalDistributionProps;
+    readonly imageBehaviorOptions?: AddBehaviorOptions;
+    readonly imageCachePolicyProps?: CachePolicyProps;
+    readonly imageResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;
+    readonly dynamicBehaviorOptions?: AddBehaviorOptions;
+    readonly dynamicCachePolicyProps?: CachePolicyProps;
+    readonly dynamicResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;
+    readonly dynamicHttpOriginProps?: HttpOriginProps;
+    readonly staticBehaviorOptions?: AddBehaviorOptions;
+    readonly staticResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;
+    readonly s3OriginProps?: OptionalS3OriginProps;
+}
+export interface NextjsDistributionProps {
+    /**
+     * Bucket containing static assets.
+     * Must be provided if you want to serve static files.
+     */
+    readonly assetsBucket: IBucket;
+    readonly basePath?: string;
+    /**
+     * Optional but only applicable for `NextjsType.GLOBAL_CONTAINERS`
+     */
+    readonly certificate?: ICertificate;
+    readonly distribution?: Distribution;
+    /**
+     * Dynamic (Next.js server) URL to add behavior to distribution
+     */
+    readonly dynamicUrl: string;
+    /**
+     * Required if `NextjsType.GLOBAL_FUNCTIONS`
+     */
+    readonly functionArn?: string;
+    readonly nextjsType: NextjsType;
+    /**
+     * Override props for every construct.
+     */
+    readonly overrides?: NextjsDistributionOverrides;
+    /**
+     * Path to directory of Next.js app's public directory. Used to add static
+     * behaviors to distribution.
+     */
+    readonly publicDirEntries: PublicDirEntry[];
+}
+export declare class NextjsDistribution extends Construct {
+    distribution: Distribution;
+    private props;
+    /**
+     * Common security headers applied by default to all origins
+     * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-response-headers-policies.html#managed-response-headers-policies-security
+     */
+    private commonSecurityHeadersBehavior;
+    private staticOrigin;
+    private dynamicOrigin;
+    private dynamicOriginResponsePolicy;
+    private dynamicCloudFrontFunctionAssociations;
+    private edgeLambdas?;
+    private isFunctionCompute;
+    private staticBehaviorOptions;
+    private dynamicBehaviorOptions;
+    private imageBehaviorOptions;
+    /**
+     * Given stack id: "arn:aws:cloudformation:us-east-1:905418358903:stack/lh-stickb-idp/4bf74be0-e880-11ee-aea9-0affc6185b25",
+     * returns "4bf74be0"
+     */
+    private uniqueStackIdPart;
+    constructor(scope: Construct, id: string, props: NextjsDistributionProps);
+    private createStaticOrigin;
+    private createDynamicOrigin;
+    /**
+     * Lambda Function URLs "expect the `Host` header to contain the origin domain
+     * name, not the domain name of the CloudFront distribution."
+     * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-except-host-header
+     */
+    private createDynamicOriginRequestPolicy;
+    /**
+     * Ensures Next.js `request.url` will be correct domain instead of URL of
+     * compute option (App Runner, Fargate, or Lambda)
+     * @see https://open-next.js.org/advanced/workaround#workaround-set-x-forwarded-host-header-aws-specific
+     */
+    private createDynamicCloudFrontFunctionAssociations;
+    /**
+     * Required to sign requests so that we can use IAM_AUTH for Lambda Function URL
+     * to prevent public access. Once CloudFront Lambda OAC is released, we can
+     * use infra configuration for this instead of custom code.
+     */
+    private createEdgeLambdas;
+    private createStaticBehaviorOptions;
+    private createDynamicBehaviorOptions;
+    private createImageBehaviorOptions;
+    /**
+     * Creates or uses user specified CloudFront Distribution
+     */
+    private getDistribution;
+    private addDynamicBehaviors;
+    private addStaticBehaviors;
+    /**
+     * Optionally prepends base path to given path pattern.
+     */
+    private getPathPattern;
+    /**
+     * Add Origin Access Control (OAC) to CloudFront Distribution which is preferred
+     * way to secure access from Distribution to S3. Remove legacy OAI.
+     *
+     * When CDK releases L2 support for this, please remove this code.
+     * @see https://github.com/aws/aws-cdk/issues/21771#issuecomment-1567647338
+     */
+    private addS3OacAndRemoveOai;
+}