@restatedev/restate-cdk 0.7.0 → 0.8.1

package/README.md

@@ -10,23 +10,27 @@ AWS. This library helps you when deploying Restate services to AWS Lambda as wel
 deployments on your own infrastructure. For more information on CDK, please
 see [Getting started with the AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html).
 
+## Installation
+
+Inside an existing CDK project, add the library from [npm](https://www.npmjs.com/package/@restatedev/restate-cdk):
+
+```shell
+npm i @restatedev/restate-cdk
+```
+
 ## Available constructs
 
-- [`LambdaServiceRegistry`](./lib/restate-constructs/lambda-service-registry.ts) - A collection of Lambda-deployed
-  Restate services, this construct automatically registers the latest function version as a new deployment revision in a
-  Restate instance
 - [`SingleNodeRestateDeployment`](./lib/restate-constructs/single-node-restate-deployment.ts) - Deploys a self-hosted
-  Restate instance on EC2; note this is a single-node deployment targeted at development and testing
-- [`RestateCloudEnvironment`](./lib/restate-constructs/restate-cloud-environment.ts) - A Restate Cloud instance
+  Restate server running on Amazon EC2; this provides a basic single-node deployment targeted at development and testing
+- [`ServiceDeployer`](./lib/restate-constructs/service-deployer.ts) - facilitates registration of Lambda-based service
+  handlers with a Restate environment, such as a self-hosted EC2 environment
 
 For a more detailed overview, please see
-the [Restate CDK documentation](https://docs.restate.dev/services/deployment/cdk).
+the [Restate CDK documentation](https://docs.restate.dev/deploy/lambda/cdk).
 
 ### Examples
 
-You can use the following examples as references for your own CDK projects:
+You can use the following templates to bootstrap your own CDK projects:
 
-- [hello-world-lambda-cdk](https://github.com/restatedev/examples/tree/main/kotlin/hello-world-lambda-cdk) - Kotlin
-  service deployed to AWS Lambda
-- [Restate Holiday](https://github.com/restatedev/restate-holiday) - a more complex example of a fictional reservation
-  service demonstrating the Saga orchestration pattern
+- [typescript-lambda-cdk](https://github.com/restatedev/examples/tree/main/templates/typescript-lambda-cdk)
+- [kotlin-gradle-lambda-cdk](https://github.com/restatedev/examples/tree/main/templates/kotlin-gradle-lambda-cdk)

package/dist/deployments-common.d.ts

@@ -0,0 +1,4 @@
+export declare enum TracingMode {
+    DISABLED = "DISABLED",
+    AWS_XRAY = "AWS_XRAY"
+}

package/dist/deployments-common.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TracingMode = void 0;
+var TracingMode;
+(function (TracingMode) {
+    TracingMode["DISABLED"] = "DISABLED";
+    TracingMode["AWS_XRAY"] = "AWS_XRAY";
+})(TracingMode || (exports.TracingMode = TracingMode = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwbG95bWVudHMtY29tbW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vbGliL3Jlc3RhdGUtY29uc3RydWN0cy9kZXBsb3ltZW50cy1jb21tb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsSUFBWSxXQUdYO0FBSEQsV0FBWSxXQUFXO0lBQ3JCLG9DQUFxQixDQUFBO0lBQ3JCLG9DQUFxQixDQUFBO0FBQ3ZCLENBQUMsRUFIVyxXQUFXLDJCQUFYLFdBQVcsUUFHdEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBUcmFjaW5nTW9kZSB7XG4gIERJU0FCTEVEID0gXCJESVNBQkxFRFwiLFxuICBBV1NfWFJBWSA9IFwiQVdTX1hSQVlcIixcbn1cbiJdfQ==

package/dist/fargate-restate-deployment.d.ts

@@ -0,0 +1,77 @@
+import { Construct } from "constructs";
+import * as cdk from "aws-cdk-lib";
+import * as logs from "aws-cdk-lib/aws-logs";
+import * as ec2 from "aws-cdk-lib/aws-ec2";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as efs from "aws-cdk-lib/aws-efs";
+import * as elb2 from "aws-cdk-lib/aws-elasticloadbalancingv2";
+import * as r53 from "aws-cdk-lib/aws-route53";
+import { IRestateEnvironment } from "./restate-environment";
+import { TracingMode } from "./deployments-common";
+export interface RestateFargateProps {
+    /** The VPC in which to launch the Restate host. */
+    vpc?: ec2.IVpc;
+    /** Log group for Restate service logs. */
+    logGroup?: logs.LogGroup;
+    /** Tracing mode for Restate services. Defaults to {@link TracingMode.DISABLED}. */
+    tracing?: TracingMode;
+    /** Prefix for resources created by this construct that require unique names. */
+    prefix?: string;
+    /** ECS cluster name. */
+    clusterName?: string;
+    /** Restate Docker image name. Defaults to `latest`. */
+    restateImage?: string;
+    /** Restate Docker image tag. Defaults to `latest`. */
+    restateTag?: string;
+    /** Amazon Distro for Open Telemetry Docker image tag. Defaults to `latest`. */
+    adotTag?: string;
+    /**
+     * Environment for Restate container. Use it to configure logging and other process-level settings.
+     */
+    environment?: Record<string, string>;
+    /**
+     * Restate container extra arguments.
+     */
+    command?: string[];
+    /**
+     * The full name for the public endpoint.
+     */
+    dnsName: string;
+    /**
+     * DNS zone in which to create the public endpoint.
+     */
+    hostedZone: r53.IHostedZone;
+    /**
+     * Removal policy for long-lived resources (storage, logs). Default: `cdk.RemovalPolicy.DESTROY`.
+     */
+    removalPolicy?: cdk.RemovalPolicy;
+    /**
+     * Load balancer configuration.
+     */
+    loadBalancer?: {
+        /** @see BaseLoadBalancerProps.internetFacing */
+        internetFacing?: boolean;
+        /**
+         * If you set this to false, you can customize the access to the pair of ALB listeners via
+         * {@link FargateRestateDeployment.ingressListener} and {@link FargateRestateDeployment.adminListener}.
+         *
+         * @see BaseApplicationListenerProps.open */
+        open?: boolean;
+    };
+}
+/**
+ * Creates a Restate service deployment running as a Fargate task and backed by EFS.
+ *
+ * Please note that this construct is still experimental! Use with caution.
+ */
+export declare class FargateRestateDeployment extends Construct implements IRestateEnvironment {
+    readonly invokerRole: iam.IRole;
+    readonly vpc: ec2.IVpc;
+    readonly ingressUrl: string;
+    readonly adminUrl: string;
+    readonly securityGroup: ec2.SecurityGroup;
+    readonly dataStore: efs.FileSystem;
+    readonly ingressListener: elb2.ApplicationListener;
+    readonly adminListener: elb2.ApplicationListener;
+    constructor(scope: Construct, id: string, props: RestateFargateProps);
+}

package/dist/fargate-restate-deployment.js

@@ -0,0 +1,239 @@
+"use strict";
+/*
+ * Copyright (c) 2023 - Restate Software, Inc., Restate GmbH
+ *
+ * This file is part of the Restate SDK for Node.js/TypeScript,
+ * which is released under the MIT license.
+ *
+ * You can find a copy of the license in file LICENSE in the root
+ * directory of this repository or package, or at
+ * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FargateRestateDeployment = void 0;
+const constructs_1 = require("constructs");
+const cdk = __importStar(require("aws-cdk-lib"));
+const acm = __importStar(require("aws-cdk-lib/aws-certificatemanager"));
+const logs = __importStar(require("aws-cdk-lib/aws-logs"));
+const ec2 = __importStar(require("aws-cdk-lib/aws-ec2"));
+const iam = __importStar(require("aws-cdk-lib/aws-iam"));
+const ecs = __importStar(require("aws-cdk-lib/aws-ecs"));
+const efs = __importStar(require("aws-cdk-lib/aws-efs"));
+const elb2 = __importStar(require("aws-cdk-lib/aws-elasticloadbalancingv2"));
+const r53 = __importStar(require("aws-cdk-lib/aws-route53"));
+const targets = __importStar(require("aws-cdk-lib/aws-route53-targets"));
+const PUBLIC_INGRESS_PORT = 443;
+const PUBLIC_ADMIN_PORT = 9070;
+const RESTATE_INGRESS_PORT = 8080;
+const RESTATE_ADMIN_PORT = 9070;
+const RESTATE_IMAGE_DEFAULT = "docker.io/restatedev/restate";
+const RESTATE_DOCKER_DEFAULT_TAG = "latest";
+const ADOT_DOCKER_DEFAULT_TAG = "latest";
+/**
+ * Creates a Restate service deployment running as a Fargate task and backed by EFS.
+ *
+ * Please note that this construct is still experimental! Use with caution.
+ */
+class FargateRestateDeployment extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.vpc = props.vpc ?? ec2.Vpc.fromLookup(this, "Vpc", { isDefault: true });
+        const restateImage = props.restateImage ?? RESTATE_IMAGE_DEFAULT;
+        const restateTag = props.restateTag ?? RESTATE_DOCKER_DEFAULT_TAG;
+        const adotTag = props.adotTag ?? ADOT_DOCKER_DEFAULT_TAG; // TODO: add X-Ray support like we have for EC2
+        const fs = new efs.FileSystem(this, "DataStore", {
+            vpc: this.vpc,
+            lifecyclePolicy: efs.LifecyclePolicy.AFTER_30_DAYS,
+            performanceMode: efs.PerformanceMode.GENERAL_PURPOSE,
+            throughputMode: efs.ThroughputMode.BURSTING,
+            removalPolicy: props.removalPolicy ?? cdk.RemovalPolicy.DESTROY,
+        });
+        fs.addToResourcePolicy(new iam.PolicyStatement({
+            sid: "AllowEfsMount",
+            actions: ["elasticfilesystem:ClientMount"],
+            // Restricting to the ECS execution role does not work; probably doesn't matter - EFS access is secured by a security group
+            principals: [new iam.AnyPrincipal()],
+            conditions: {
+                Bool: {
+                    "elasticfilesystem:AccessedViaMountTarget": "true",
+                },
+            },
+        }));
+        this.dataStore = fs;
+        const cluster = new ecs.Cluster(this, "Cluster", {
+            vpc: this.vpc,
+            clusterName: props.clusterName,
+        });
+        const restateTask = new ecs.FargateTaskDefinition(this, "RestateTask", {
+            cpu: 4096,
+            memoryLimitMiB: 8192,
+            runtimePlatform: {
+                cpuArchitecture: ecs.CpuArchitecture.ARM64,
+                operatingSystemFamily: ecs.OperatingSystemFamily.LINUX,
+            },
+            volumes: [
+                {
+                    name: "restateStore",
+                    efsVolumeConfiguration: {
+                        fileSystemId: fs.fileSystemId,
+                        authorizationConfig: {},
+                    },
+                },
+            ],
+        });
+        // TODO: Start an ADOT container and hook it up to Restate and AWS X-Ray or another OTel sink
+        // if (props.tracing === TracingMode.AWS_XRAY) {
+        //   restateTask.taskRole.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName("AWSXrayWriteOnlyAccess"));
+        // }
+        new iam.Policy(this, "TaskPolicy", {
+            statements: [
+                new iam.PolicyStatement({
+                    sid: "AllowAssumeAnyRole",
+                    actions: ["sts:AssumeRole"],
+                    resources: ["*"], // we don't know upfront what invoker roles we may be asked to assume at runtime
+                }),
+            ],
+        }).attachToRole(restateTask.taskRole);
+        const invokerRole = new iam.Role(this, "InvokerRole", {
+            assumedBy: new iam.ArnPrincipal(restateTask.taskRole.roleArn),
+            description: "Assumed by Restate deployment to invoke Lambda-based services",
+        });
+        invokerRole.grantAssumeRole(restateTask.taskRole);
+        this.invokerRole = invokerRole;
+        const logGroup = props.logGroup ??
+            new logs.LogGroup(this, "Logs", {
+                logGroupName: `/restate/${id}`,
+                retention: logs.RetentionDays.ONE_MONTH,
+                removalPolicy: props.removalPolicy ?? cdk.RemovalPolicy.DESTROY,
+            });
+        const restate = restateTask.addContainer("Restate", {
+            containerName: "restate-runtime",
+            image: ecs.ContainerImage.fromRegistry(`${restateImage}:${restateTag}`),
+            portMappings: [{ containerPort: RESTATE_INGRESS_PORT }, { containerPort: RESTATE_ADMIN_PORT }],
+            logging: ecs.LogDriver.awsLogs({
+                logGroup,
+                streamPrefix: "restate",
+            }),
+            environment: {
+                RESTATE_OBSERVABILITY__LOG__FORMAT: "Json",
+                // RUST_LOG: "warn,restate=info",
+            },
+            command: props.command,
+            startTimeout: cdk.Duration.seconds(20),
+            stopTimeout: cdk.Duration.seconds(20),
+        });
+        restate.addMountPoints({
+            containerPath: "/target",
+            readOnly: false,
+            sourceVolume: "restateStore",
+        });
+        const restateSecurityGroup = new ec2.SecurityGroup(this, "SecurityGroup", {
+            vpc: this.vpc,
+            allowAllOutbound: true,
+        });
+        this.securityGroup = restateSecurityGroup;
+        const restateFargateService = new ecs.FargateService(this, "Service", {
+            cluster,
+            taskDefinition: restateTask,
+            assignPublicIp: true,
+            circuitBreaker: {
+                enable: true,
+                rollback: true,
+            },
+            minHealthyPercent: 0, // allow scale down to zero during deployments (required for at-most-1 max setting)
+            maxHealthyPercent: 100, // don't start more than one copy
+            securityGroups: [restateSecurityGroup],
+        });
+        fs.connections.allowDefaultPortFrom(restateSecurityGroup);
+        fs.connections.allowDefaultPortTo(restateSecurityGroup);
+        fs.grantRootAccess(restateFargateService.taskDefinition.taskRole.grantPrincipal);
+        const alb = new elb2.ApplicationLoadBalancer(this, "Alb", {
+            vpc: this.vpc,
+            internetFacing: props.loadBalancer?.internetFacing,
+        });
+        const publicApiCertificate = new acm.Certificate(this, "Certificate", {
+            domainName: props.dnsName,
+            validation: acm.CertificateValidation.fromDns(props.hostedZone),
+        });
+        const ingressListener = alb.addListener("IngressListener", {
+            port: PUBLIC_INGRESS_PORT,
+            protocol: elb2.ApplicationProtocol.HTTPS,
+            certificates: [publicApiCertificate],
+            open: props.loadBalancer?.open,
+        });
+        ingressListener.addTargets("FargateIngressTarget", {
+            targets: [
+                restateFargateService.loadBalancerTarget({
+                    containerName: restate.containerName,
+                    containerPort: RESTATE_INGRESS_PORT,
+                }),
+            ],
+            protocol: elb2.ApplicationProtocol.HTTP,
+            healthCheck: {
+                path: "/grpc.health.v1.Health/Check",
+                interval: cdk.Duration.seconds(5),
+                healthyThresholdCount: 3,
+                unhealthyThresholdCount: 3,
+                timeout: cdk.Duration.seconds(2),
+            },
+            deregistrationDelay: cdk.Duration.seconds(5),
+        });
+        this.ingressListener = ingressListener;
+        const adminListener = alb.addListener("AdminListener", {
+            port: PUBLIC_ADMIN_PORT,
+            protocol: elb2.ApplicationProtocol.HTTPS,
+            certificates: [publicApiCertificate],
+        });
+        adminListener.addTargets("FargateAdminTarget", {
+            targets: [
+                restateFargateService.loadBalancerTarget({
+                    containerName: restate.containerName,
+                    containerPort: RESTATE_ADMIN_PORT,
+                }),
+            ],
+            protocol: elb2.ApplicationProtocol.HTTP,
+            healthCheck: {
+                path: "/health",
+                interval: cdk.Duration.seconds(5),
+                healthyThresholdCount: 3,
+                unhealthyThresholdCount: 3,
+                timeout: cdk.Duration.seconds(2),
+            },
+            deregistrationDelay: cdk.Duration.seconds(5),
+        });
+        this.adminListener = adminListener;
+        new r53.ARecord(this, "AlbAlias", {
+            zone: props.hostedZone,
+            recordName: props.dnsName.split(".")[0],
+            target: r53.RecordTarget.fromAlias(new targets.LoadBalancerTarget(alb)),
+            // other ARecord configuration...
+        });
+        this.ingressUrl = `https://${props.dnsName}${PUBLIC_INGRESS_PORT == 443 ? "" : `:${PUBLIC_INGRESS_PORT}`}`;
+        this.adminUrl = `https://${props.dnsName}:${PUBLIC_ADMIN_PORT}`;
+    }
+}
+exports.FargateRestateDeployment = FargateRestateDeployment;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fargate-restate-deployment.js","sourceRoot":"","sources":["../lib/restate-constructs/fargate-restate-deployment.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2023 - Restate Software, Inc., Restate GmbH\n *\n * This file is part of the Restate SDK for Node.js/TypeScript,\n * which is released under the MIT license.\n *\n * You can find a copy of the license in file LICENSE in the root\n * directory of this repository or package, or at\n * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE\n */\n\nimport { Construct } from \"constructs\";\nimport * as cdk from \"aws-cdk-lib\";\nimport * as acm from \"aws-cdk-lib/aws-certificatemanager\";\nimport * as logs from \"aws-cdk-lib/aws-logs\";\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\";\nimport * as iam from \"aws-cdk-lib/aws-iam\";\nimport * as ecs from \"aws-cdk-lib/aws-ecs\";\nimport * as efs from \"aws-cdk-lib/aws-efs\";\nimport * as elb2 from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport * as r53 from \"aws-cdk-lib/aws-route53\";\nimport * as targets from \"aws-cdk-lib/aws-route53-targets\";\nimport { IRestateEnvironment } from \"./restate-environment\";\nimport { TracingMode } from \"./deployments-common\";\n\nconst PUBLIC_INGRESS_PORT = 443;\nconst PUBLIC_ADMIN_PORT = 9070;\nconst RESTATE_INGRESS_PORT = 8080;\nconst RESTATE_ADMIN_PORT = 9070;\nconst RESTATE_IMAGE_DEFAULT = \"docker.io/restatedev/restate\";\nconst RESTATE_DOCKER_DEFAULT_TAG = \"latest\";\nconst ADOT_DOCKER_DEFAULT_TAG = \"latest\";\n\nexport interface RestateFargateProps {\n  /** The VPC in which to launch the Restate host. */\n  vpc?: ec2.IVpc;\n\n  /** Log group for Restate service logs. */\n  logGroup?: logs.LogGroup;\n\n  /** Tracing mode for Restate services. Defaults to {@link TracingMode.DISABLED}. */\n  tracing?: TracingMode;\n\n  /** Prefix for resources created by this construct that require unique names. */\n  prefix?: string;\n\n  /** ECS cluster name. */\n  clusterName?: string;\n\n  /** Restate Docker image name. Defaults to `latest`. */\n  restateImage?: string;\n\n  /** Restate Docker image tag. Defaults to `latest`. */\n  restateTag?: string;\n\n  /** Amazon Distro for Open Telemetry Docker image tag. Defaults to `latest`. */\n  adotTag?: string;\n\n  /**\n   * Environment for Restate container. Use it to configure logging and other process-level settings.\n   */\n  environment?: Record<string, string>;\n\n  /**\n   * Restate container extra arguments.\n   */\n  command?: string[];\n\n  /**\n   * The full name for the public endpoint.\n   */\n  dnsName: string;\n\n  /**\n   * DNS zone in which to create the public endpoint.\n   */\n  hostedZone: r53.IHostedZone;\n\n  /**\n   * Removal policy for long-lived resources (storage, logs). Default: `cdk.RemovalPolicy.DESTROY`.\n   */\n  removalPolicy?: cdk.RemovalPolicy;\n\n  /**\n   * Load balancer configuration.\n   */\n  loadBalancer?: {\n    /** @see BaseLoadBalancerProps.internetFacing */\n    internetFacing?: boolean;\n\n    /**\n     * If you set this to false, you can customize the access to the pair of ALB listeners via\n     * {@link FargateRestateDeployment.ingressListener} and {@link FargateRestateDeployment.adminListener}.\n     *\n     * @see BaseApplicationListenerProps.open */\n    open?: boolean;\n  };\n}\n\n/**\n * Creates a Restate service deployment running as a Fargate task and backed by EFS.\n *\n * Please note that this construct is still experimental! Use with caution.\n */\nexport class FargateRestateDeployment extends Construct implements IRestateEnvironment {\n  readonly invokerRole: iam.IRole;\n  readonly vpc: ec2.IVpc;\n\n  readonly ingressUrl: string;\n  readonly adminUrl: string;\n  readonly securityGroup: ec2.SecurityGroup;\n  readonly dataStore: efs.FileSystem;\n  readonly ingressListener: elb2.ApplicationListener;\n  readonly adminListener: elb2.ApplicationListener;\n\n  constructor(scope: Construct, id: string, props: RestateFargateProps) {\n    super(scope, id);\n\n    this.vpc = props.vpc ?? ec2.Vpc.fromLookup(this, \"Vpc\", { isDefault: true });\n\n    const restateImage = props.restateImage ?? RESTATE_IMAGE_DEFAULT;\n    const restateTag = props.restateTag ?? RESTATE_DOCKER_DEFAULT_TAG;\n    const adotTag = props.adotTag ?? ADOT_DOCKER_DEFAULT_TAG; // TODO: add X-Ray support like we have for EC2\n\n    const fs = new efs.FileSystem(this, \"DataStore\", {\n      vpc: this.vpc,\n      lifecyclePolicy: efs.LifecyclePolicy.AFTER_30_DAYS,\n      performanceMode: efs.PerformanceMode.GENERAL_PURPOSE,\n      throughputMode: efs.ThroughputMode.BURSTING,\n      removalPolicy: props.removalPolicy ?? cdk.RemovalPolicy.DESTROY,\n    });\n    fs.addToResourcePolicy(\n      new iam.PolicyStatement({\n        sid: \"AllowEfsMount\",\n        actions: [\"elasticfilesystem:ClientMount\"],\n        // Restricting to the ECS execution role does not work; probably doesn't matter - EFS access is secured by a security group\n        principals: [new iam.AnyPrincipal()],\n        conditions: {\n          Bool: {\n            \"elasticfilesystem:AccessedViaMountTarget\": \"true\",\n          },\n        },\n      }),\n    );\n    this.dataStore = fs;\n\n    const cluster = new ecs.Cluster(this, \"Cluster\", {\n      vpc: this.vpc,\n      clusterName: props.clusterName,\n    });\n\n    const restateTask = new ecs.FargateTaskDefinition(this, \"RestateTask\", {\n      cpu: 4096,\n      memoryLimitMiB: 8192,\n      runtimePlatform: {\n        cpuArchitecture: ecs.CpuArchitecture.ARM64,\n        operatingSystemFamily: ecs.OperatingSystemFamily.LINUX,\n      },\n      volumes: [\n        {\n          name: \"restateStore\",\n          efsVolumeConfiguration: {\n            fileSystemId: fs.fileSystemId,\n            authorizationConfig: {},\n          },\n        },\n      ],\n    });\n\n    // TODO: Start an ADOT container and hook it up to Restate and AWS X-Ray or another OTel sink\n    // if (props.tracing === TracingMode.AWS_XRAY) {\n    //   restateTask.taskRole.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName(\"AWSXrayWriteOnlyAccess\"));\n    // }\n\n    new iam.Policy(this, \"TaskPolicy\", {\n      statements: [\n        new iam.PolicyStatement({\n          sid: \"AllowAssumeAnyRole\",\n          actions: [\"sts:AssumeRole\"],\n          resources: [\"*\"], // we don't know upfront what invoker roles we may be asked to assume at runtime\n        }),\n      ],\n    }).attachToRole(restateTask.taskRole);\n\n    const invokerRole = new iam.Role(this, \"InvokerRole\", {\n      assumedBy: new iam.ArnPrincipal(restateTask.taskRole.roleArn),\n      description: \"Assumed by Restate deployment to invoke Lambda-based services\",\n    });\n    invokerRole.grantAssumeRole(restateTask.taskRole);\n    this.invokerRole = invokerRole;\n\n    const logGroup =\n      props.logGroup ??\n      new logs.LogGroup(this, \"Logs\", {\n        logGroupName: `/restate/${id}`,\n        retention: logs.RetentionDays.ONE_MONTH,\n        removalPolicy: props.removalPolicy ?? cdk.RemovalPolicy.DESTROY,\n      });\n\n    const restate = restateTask.addContainer(\"Restate\", {\n      containerName: \"restate-runtime\",\n      image: ecs.ContainerImage.fromRegistry(`${restateImage}:${restateTag}`),\n      portMappings: [{ containerPort: RESTATE_INGRESS_PORT }, { containerPort: RESTATE_ADMIN_PORT }],\n      logging: ecs.LogDriver.awsLogs({\n        logGroup,\n        streamPrefix: \"restate\",\n      }),\n      environment: {\n        RESTATE_OBSERVABILITY__LOG__FORMAT: \"Json\",\n        // RUST_LOG: \"warn,restate=info\",\n      },\n      command: props.command,\n      startTimeout: cdk.Duration.seconds(20),\n      stopTimeout: cdk.Duration.seconds(20),\n    });\n    restate.addMountPoints({\n      containerPath: \"/target\",\n      readOnly: false,\n      sourceVolume: \"restateStore\",\n    });\n\n    const restateSecurityGroup = new ec2.SecurityGroup(this, \"SecurityGroup\", {\n      vpc: this.vpc,\n      allowAllOutbound: true,\n    });\n    this.securityGroup = restateSecurityGroup;\n\n    const restateFargateService = new ecs.FargateService(this, \"Service\", {\n      cluster,\n      taskDefinition: restateTask,\n      assignPublicIp: true,\n      circuitBreaker: {\n        enable: true,\n        rollback: true,\n      },\n      minHealthyPercent: 0, // allow scale down to zero during deployments (required for at-most-1 max setting)\n      maxHealthyPercent: 100, // don't start more than one copy\n      securityGroups: [restateSecurityGroup],\n    });\n\n    fs.connections.allowDefaultPortFrom(restateSecurityGroup);\n    fs.connections.allowDefaultPortTo(restateSecurityGroup);\n    fs.grantRootAccess(restateFargateService.taskDefinition.taskRole.grantPrincipal);\n\n    const alb = new elb2.ApplicationLoadBalancer(this, \"Alb\", {\n      vpc: this.vpc,\n      internetFacing: props.loadBalancer?.internetFacing,\n    });\n\n    const publicApiCertificate = new acm.Certificate(this, \"Certificate\", {\n      domainName: props.dnsName,\n      validation: acm.CertificateValidation.fromDns(props.hostedZone),\n    });\n\n    const ingressListener = alb.addListener(\"IngressListener\", {\n      port: PUBLIC_INGRESS_PORT,\n      protocol: elb2.ApplicationProtocol.HTTPS,\n      certificates: [publicApiCertificate],\n      open: props.loadBalancer?.open,\n    });\n    ingressListener.addTargets(\"FargateIngressTarget\", {\n      targets: [\n        restateFargateService.loadBalancerTarget({\n          containerName: restate.containerName,\n          containerPort: RESTATE_INGRESS_PORT,\n        }),\n      ],\n      protocol: elb2.ApplicationProtocol.HTTP,\n      healthCheck: {\n        path: \"/grpc.health.v1.Health/Check\",\n        interval: cdk.Duration.seconds(5),\n        healthyThresholdCount: 3,\n        unhealthyThresholdCount: 3,\n        timeout: cdk.Duration.seconds(2),\n      },\n      deregistrationDelay: cdk.Duration.seconds(5),\n    });\n    this.ingressListener = ingressListener;\n\n    const adminListener = alb.addListener(\"AdminListener\", {\n      port: PUBLIC_ADMIN_PORT,\n      protocol: elb2.ApplicationProtocol.HTTPS,\n      certificates: [publicApiCertificate],\n    });\n    adminListener.addTargets(\"FargateAdminTarget\", {\n      targets: [\n        restateFargateService.loadBalancerTarget({\n          containerName: restate.containerName,\n          containerPort: RESTATE_ADMIN_PORT,\n        }),\n      ],\n      protocol: elb2.ApplicationProtocol.HTTP,\n      healthCheck: {\n        path: \"/health\",\n        interval: cdk.Duration.seconds(5),\n        healthyThresholdCount: 3,\n        unhealthyThresholdCount: 3,\n        timeout: cdk.Duration.seconds(2),\n      },\n      deregistrationDelay: cdk.Duration.seconds(5),\n    });\n    this.adminListener = adminListener;\n\n    new r53.ARecord(this, \"AlbAlias\", {\n      zone: props.hostedZone,\n      recordName: props.dnsName.split(\".\")[0],\n      target: r53.RecordTarget.fromAlias(new targets.LoadBalancerTarget(alb)),\n      // other ARecord configuration...\n    });\n\n    this.ingressUrl = `https://${props.dnsName}${PUBLIC_INGRESS_PORT == 443 ? \"\" : `:${PUBLIC_INGRESS_PORT}`}`;\n    this.adminUrl = `https://${props.dnsName}:${PUBLIC_ADMIN_PORT}`;\n  }\n}\n"]}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./lambda-service-registry";
-export * from "./registration-provider";
-export * from "./restate-cloud-environment";
+export * from "./service-deployer";
 export * from "./restate-environment";
+export * from "./deployments-common";
 export * from "./single-node-restate-deployment";
+export * from "./fargate-restate-deployment";

package/dist/index.js

@@ -24,9 +24,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./lambda-service-registry"), exports);
-__exportStar(require("./registration-provider"), exports);
-__exportStar(require("./restate-cloud-environment"), exports);
+__exportStar(require("./service-deployer"), exports);
 __exportStar(require("./restate-environment"), exports);
+__exportStar(require("./deployments-common"), exports);
 __exportStar(require("./single-node-restate-deployment"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvcmVzdGF0ZS1jb25zdHJ1Y3RzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7Ozs7O0dBU0c7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCw0REFBMEM7QUFDMUMsMERBQXdDO0FBQ3hDLDhEQUE0QztBQUM1Qyx3REFBc0M7QUFDdEMsbUVBQWlEIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAyMyAtIFJlc3RhdGUgU29mdHdhcmUsIEluYy4sIFJlc3RhdGUgR21iSFxuICpcbiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBSZXN0YXRlIFNESyBmb3IgTm9kZS5qcy9UeXBlU2NyaXB0LFxuICogd2hpY2ggaXMgcmVsZWFzZWQgdW5kZXIgdGhlIE1JVCBsaWNlbnNlLlxuICpcbiAqIFlvdSBjYW4gZmluZCBhIGNvcHkgb2YgdGhlIGxpY2Vuc2UgaW4gZmlsZSBMSUNFTlNFIGluIHRoZSByb290XG4gKiBkaXJlY3Rvcnkgb2YgdGhpcyByZXBvc2l0b3J5IG9yIHBhY2thZ2UsIG9yIGF0XG4gKiBodHRwczovL2dpdGh1Yi5jb20vcmVzdGF0ZWRldi9zZGstdHlwZXNjcmlwdC9ibG9iL21haW4vTElDRU5TRVxuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL2xhbWJkYS1zZXJ2aWNlLXJlZ2lzdHJ5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yZWdpc3RyYXRpb24tcHJvdmlkZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Jlc3RhdGUtY2xvdWQtZW52aXJvbm1lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Jlc3RhdGUtZW52aXJvbm1lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NpbmdsZS1ub2RlLXJlc3RhdGUtZGVwbG95bWVudFwiOyJdfQ==
+__exportStar(require("./fargate-restate-deployment"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvcmVzdGF0ZS1jb25zdHJ1Y3RzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7Ozs7O0dBU0c7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCxxREFBbUM7QUFDbkMsd0RBQXNDO0FBQ3RDLHVEQUFxQztBQUNyQyxtRUFBaUQ7QUFDakQsK0RBQTZDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAyMyAtIFJlc3RhdGUgU29mdHdhcmUsIEluYy4sIFJlc3RhdGUgR21iSFxuICpcbiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBSZXN0YXRlIFNESyBmb3IgTm9kZS5qcy9UeXBlU2NyaXB0LFxuICogd2hpY2ggaXMgcmVsZWFzZWQgdW5kZXIgdGhlIE1JVCBsaWNlbnNlLlxuICpcbiAqIFlvdSBjYW4gZmluZCBhIGNvcHkgb2YgdGhlIGxpY2Vuc2UgaW4gZmlsZSBMSUNFTlNFIGluIHRoZSByb290XG4gKiBkaXJlY3Rvcnkgb2YgdGhpcyByZXBvc2l0b3J5IG9yIHBhY2thZ2UsIG9yIGF0XG4gKiBodHRwczovL2dpdGh1Yi5jb20vcmVzdGF0ZWRldi9zZGstdHlwZXNjcmlwdC9ibG9iL21haW4vTElDRU5TRVxuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL3NlcnZpY2UtZGVwbG95ZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Jlc3RhdGUtZW52aXJvbm1lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlcGxveW1lbnRzLWNvbW1vblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2luZ2xlLW5vZGUtcmVzdGF0ZS1kZXBsb3ltZW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9mYXJnYXRlLXJlc3RhdGUtZGVwbG95bWVudFwiO1xuIl19

package/dist/register-service-handler/index.d.ts

@@ -8,9 +8,12 @@ export interface RegistrationProperties {
     invokeRoleArn?: string;
     removalPolicy?: cdk.RemovalPolicy;
     authTokenSecretArn?: string;
+    configurationVersion?: string;
+    private?: "true" | "false";
+    insecure?: "true" | "false";
 }
 /**
  * Custom Resource event handler for Restate service registration. This handler backs the custom resources created by
- * {@link LambdaServiceRegistry} to facilitate Lambda service handler discovery.
+ * {@link ServiceDeployer} to facilitate Lambda service handler discovery.
  */
 export declare const handler: Handler<CloudFormationCustomResourceEvent, void>;