dcl-ops-lib 8.3.3 → 9.1.0

package/fargateHelpers.d.ts

@@ -0,0 +1,220 @@
+import * as aws from "@pulumi/aws";
+import * as pulumi from "@pulumi/pulumi";
+/**
+ * Team type used by all Fargate-related functions for ownership tagging
+ */
+export type Team = "dapps" | "platform" | "data" | "marketing" | "infra";
+/**
+ * Prometheus metrics configuration
+ */
+export type MetricsConfig = {
+    /**
+     * Port where metrics are exposed
+     */
+    port: number | string;
+    /**
+     * Path to the metrics endpoint (default: "/metrics")
+     */
+    path?: string;
+    /**
+     * Job name for Prometheus (default: task/service name)
+     */
+    jobName?: string;
+};
+/**
+ * Default CPU units for Fargate tasks (256 = 0.25 vCPU)
+ */
+export declare const DEFAULT_CPU = 256;
+/**
+ * Default memory in MB for Fargate tasks
+ */
+export declare const DEFAULT_MEMORY = 512;
+/**
+ * Default CloudWatch log retention in days
+ */
+export declare const DEFAULT_LOG_RETENTION_DAYS = 60;
+/**
+ * Default desired count for ECS services
+ */
+export declare const DEFAULT_DESIRED_COUNT = 1;
+/**
+ * Creates standard resource tags for Fargate resources
+ *
+ * @param serviceName The name of the service/task
+ * @param team Team that owns this resource
+ * @param additionalTags Optional additional tags to merge
+ * @returns Record of tags
+ */
+export declare function createResourceTags(serviceName: string, team: Team, additionalTags?: Record<string, string>): Record<string, string>;
+/**
+ * Creates a CloudWatch Log Group with consistent settings
+ *
+ * @param name The name for the log group (will be stack-scoped)
+ * @param team Team that owns this resource
+ * @param retentionInDays Log retention in days (default: 60)
+ * @returns The created CloudWatch Log Group
+ */
+export declare function createLogGroup(name: string, team: Team, retentionInDays?: number): aws.cloudwatch.LogGroup;
+/**
+ * Creates a security group for a Fargate task/service with standard tags
+ *
+ * @param name Resource name for the security group
+ * @param vpcId The VPC ID where the security group will be created
+ * @param serviceName The name of the service (for tagging)
+ * @param team Team that owns this resource
+ * @returns The created EC2 Security Group
+ */
+export declare function createTaskSecurityGroup(name: string, vpcId: pulumi.Input<string>, serviceName: string, team: Team): aws.ec2.SecurityGroup;
+/**
+ * Configures docker labels for Prometheus metrics discovery
+ *
+ * @param taskName The name of the task/service
+ * @param metrics Metrics configuration
+ * @returns Docker labels, port mappings, and the parsed metrics port
+ */
+export declare function configurePrometheusMetrics(taskName: string, metrics: MetricsConfig): {
+    dockerLabels: Record<string, string>;
+    portMappings: aws.ecs.PortMapping[];
+    metricsPort: number;
+};
+/**
+ * Creates security group rules to allow Prometheus metrics scraping
+ *
+ * @param resourcePrefix Prefix for resource names
+ * @param securityGroup The security group to add rules to
+ * @param vpcCidrBlock The VPC CIDR block for ingress rules
+ * @param metricsPort The port where metrics are exposed
+ * @param taskName The name of the task/service
+ */
+export declare function setupPrometheusSecurityRules(resourcePrefix: string, securityGroup: aws.ec2.SecurityGroup, vpcCidrBlock: string, metricsPort: number, taskName: string): void;
+/**
+ * Options for building a container definition
+ */
+export type ContainerDefinitionOptions = {
+    /**
+     * Container name
+     */
+    name: string;
+    /**
+     * Docker image to run
+     */
+    image: string | Promise<string> | pulumi.OutputInstance<string>;
+    /**
+     * CPU units for this container
+     */
+    cpu: number;
+    /**
+     * Memory reservation in MB
+     */
+    memory: number;
+    /**
+     * Environment variables
+     */
+    environment?: {
+        name: string;
+        value: pulumi.Input<string>;
+    }[];
+    /**
+     * Secrets from SSM/Secrets Manager
+     */
+    secrets?: aws.ecs.Secret[];
+    /**
+     * Override command
+     */
+    command?: string[];
+    /**
+     * Override entry point
+     */
+    entryPoint?: string[];
+    /**
+     * Port mappings
+     */
+    portMappings?: aws.ecs.PortMapping[];
+    /**
+     * Docker labels (e.g., for Prometheus)
+     */
+    dockerLabels?: Record<string, string>;
+    /**
+     * Mount points for volumes
+     */
+    mountPoints?: aws.ecs.MountPoint[];
+    /**
+     * Repository credentials for private registries
+     */
+    repositoryCredentials?: aws.ecs.RepositoryCredentials;
+    /**
+     * Log configuration
+     */
+    logConfiguration: aws.ecs.LogConfiguration;
+    /**
+     * Whether this container is essential (default: true)
+     */
+    essential?: boolean;
+    /**
+     * Container health check
+     */
+    healthCheck?: aws.ecs.HealthCheck;
+};
+/**
+ * Builds a container definition object for ECS task definitions
+ *
+ * @param options Container definition options
+ * @returns Container definition object
+ */
+export declare function buildContainerDefinition(options: ContainerDefinitionOptions): aws.ecs.ContainerDefinition;
+/**
+ * Options for creating a Fargate task definition
+ */
+export type FargateTaskDefinitionOptions = {
+    /**
+     * Name for the task definition
+     */
+    name: string;
+    /**
+     * Execution role ARN (optional for some use cases)
+     */
+    executionRoleArn?: pulumi.Input<string>;
+    /**
+     * Task role ARN (optional for some use cases)
+     */
+    taskRoleArn?: pulumi.Input<string>;
+    /**
+     * JSON-stringified container definitions
+     */
+    containerDefinitions: pulumi.Input<string>;
+    /**
+     * Team that owns this resource
+     */
+    team: Team;
+    /**
+     * CPU units for the task
+     */
+    cpu: pulumi.Input<number>;
+    /**
+     * Memory in MB for the task
+     */
+    memory: pulumi.Input<number>;
+    /**
+     * Ephemeral storage in GB (20-200)
+     */
+    ephemeralStorageInGB?: number;
+    /**
+     * Runtime platform configuration (e.g., for ARM64)
+     */
+    runtimePlatform?: aws.types.input.ecs.TaskDefinitionRuntimePlatform;
+    /**
+     * Volumes to attach
+     */
+    volumes?: pulumi.Input<aws.types.input.ecs.TaskDefinitionVolume[]>;
+    /**
+     * Resources to depend on
+     */
+    dependsOn?: pulumi.Resource[];
+};
+/**
+ * Creates a Fargate task definition with standard settings
+ *
+ * @param options Task definition options
+ * @returns The created ECS Task Definition
+ */
+export declare function createFargateTaskDefinition(options: FargateTaskDefinitionOptions): aws.ecs.TaskDefinition;

package/fargateHelpers.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFargateTaskDefinition = exports.buildContainerDefinition = exports.setupPrometheusSecurityRules = exports.configurePrometheusMetrics = exports.createTaskSecurityGroup = exports.createLogGroup = exports.createResourceTags = exports.DEFAULT_DESIRED_COUNT = exports.DEFAULT_LOG_RETENTION_DAYS = exports.DEFAULT_MEMORY = exports.DEFAULT_CPU = void 0;
+const aws = require("@pulumi/aws");
+const pulumi = require("@pulumi/pulumi");
+const stack_1 = require("./stack");
+const prometheus_1 = require("./prometheus");
+// ============================================================================
+// Default Constants
+// ============================================================================
+/**
+ * Default CPU units for Fargate tasks (256 = 0.25 vCPU)
+ */
+exports.DEFAULT_CPU = 256;
+/**
+ * Default memory in MB for Fargate tasks
+ */
+exports.DEFAULT_MEMORY = 512;
+/**
+ * Default CloudWatch log retention in days
+ */
+exports.DEFAULT_LOG_RETENTION_DAYS = 60;
+/**
+ * Default desired count for ECS services
+ */
+exports.DEFAULT_DESIRED_COUNT = 1;
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Creates standard resource tags for Fargate resources
+ *
+ * @param serviceName The name of the service/task
+ * @param team Team that owns this resource
+ * @param additionalTags Optional additional tags to merge
+ * @returns Record of tags
+ */
+function createResourceTags(serviceName, team, additionalTags) {
+    return {
+        ServiceName: serviceName,
+        Team: team,
+        ...additionalTags,
+    };
+}
+exports.createResourceTags = createResourceTags;
+/**
+ * Creates a CloudWatch Log Group with consistent settings
+ *
+ * @param name The name for the log group (will be stack-scoped)
+ * @param team Team that owns this resource
+ * @param retentionInDays Log retention in days (default: 60)
+ * @returns The created CloudWatch Log Group
+ */
+function createLogGroup(name, team, retentionInDays = 60) {
+    return new aws.cloudwatch.LogGroup((0, stack_1.getStackScopedName)(name), {
+        name: (0, stack_1.getStackScopedName)(name),
+        retentionInDays,
+        tags: { ServiceName: name, Team: team },
+    });
+}
+exports.createLogGroup = createLogGroup;
+/**
+ * Creates a security group for a Fargate task/service with standard tags
+ *
+ * @param name Resource name for the security group
+ * @param vpcId The VPC ID where the security group will be created
+ * @param serviceName The name of the service (for tagging)
+ * @param team Team that owns this resource
+ * @returns The created EC2 Security Group
+ */
+function createTaskSecurityGroup(name, vpcId, serviceName, team) {
+    return new aws.ec2.SecurityGroup(name, {
+        vpcId,
+        tags: { ServiceName: serviceName, Team: team },
+    });
+}
+exports.createTaskSecurityGroup = createTaskSecurityGroup;
+/**
+ * Configures docker labels for Prometheus metrics discovery
+ *
+ * @param taskName The name of the task/service
+ * @param metrics Metrics configuration
+ * @returns Docker labels, port mappings, and the parsed metrics port
+ */
+function configurePrometheusMetrics(taskName, metrics) {
+    const metricsPort = typeof metrics.port === "string" ? parseInt(metrics.port) : metrics.port;
+    const dockerLabels = {
+        ECS_PROMETHEUS_EXPORTER_PORT: "" + metricsPort,
+        ECS_PROMETHEUS_METRICS_PATH: metrics.path || "/metrics",
+        ECS_PROMETHEUS_JOB_NAME: metrics.jobName || taskName,
+    };
+    const portMappings = [
+        {
+            containerPort: metricsPort,
+            hostPort: metricsPort,
+            protocol: "tcp",
+        },
+    ];
+    return { dockerLabels, portMappings, metricsPort };
+}
+exports.configurePrometheusMetrics = configurePrometheusMetrics;
+/**
+ * Creates security group rules to allow Prometheus metrics scraping
+ *
+ * @param resourcePrefix Prefix for resource names
+ * @param securityGroup The security group to add rules to
+ * @param vpcCidrBlock The VPC CIDR block for ingress rules
+ * @param metricsPort The port where metrics are exposed
+ * @param taskName The name of the task/service
+ */
+function setupPrometheusSecurityRules(resourcePrefix, securityGroup, vpcCidrBlock, metricsPort, taskName) {
+    // Create security group rule for metrics access from VPC
+    new aws.ec2.SecurityGroupRule(`${resourcePrefix}-metrics-${metricsPort}`, {
+        type: "ingress",
+        fromPort: metricsPort,
+        toPort: metricsPort,
+        protocol: "tcp",
+        cidrBlocks: [vpcCidrBlock],
+        securityGroupId: securityGroup.id,
+    });
+    // Enable Prometheus to access the metrics port
+    (0, prometheus_1.makeSecurityGroupAccessibleByPrometheus)(securityGroup, metricsPort, metricsPort, taskName);
+}
+exports.setupPrometheusSecurityRules = setupPrometheusSecurityRules;
+/**
+ * Builds a container definition object for ECS task definitions
+ *
+ * @param options Container definition options
+ * @returns Container definition object
+ */
+function buildContainerDefinition(options) {
+    const { name, image, cpu, memory, environment = [], secrets = [], command, entryPoint, portMappings = [], dockerLabels = {}, mountPoints = [], repositoryCredentials, logConfiguration, essential = true, healthCheck, } = options;
+    return {
+        name,
+        image,
+        essential,
+        environment,
+        secrets,
+        command,
+        entryPoint,
+        cpu,
+        memoryReservation: memory,
+        portMappings,
+        dockerLabels,
+        mountPoints,
+        repositoryCredentials,
+        logConfiguration,
+        healthCheck,
+    };
+}
+exports.buildContainerDefinition = buildContainerDefinition;
+/**
+ * Creates a Fargate task definition with standard settings
+ *
+ * @param options Task definition options
+ * @returns The created ECS Task Definition
+ */
+function createFargateTaskDefinition(options) {
+    const { name, executionRoleArn, taskRoleArn, containerDefinitions, team, cpu, memory, ephemeralStorageInGB, runtimePlatform, volumes, dependsOn = [], } = options;
+    return new aws.ecs.TaskDefinition(`${(0, stack_1.getStackScopedName)(name)}-taskdefinition`, {
+        executionRoleArn,
+        taskRoleArn,
+        tags: createResourceTags(name, team),
+        containerDefinitions,
+        ephemeralStorage: ephemeralStorageInGB
+            ? { sizeInGib: ephemeralStorageInGB }
+            : undefined,
+        cpu: pulumi.output(cpu).apply((c) => c.toString()),
+        memory: pulumi.output(memory).apply((m) => m.toString()),
+        runtimePlatform,
+        requiresCompatibilities: ["FARGATE"],
+        networkMode: "awsvpc",
+        volumes,
+        family: (0, stack_1.getStackScopedName)(name),
+    }, { dependsOn });
+}
+exports.createFargateTaskDefinition = createFargateTaskDefinition;
+//# sourceMappingURL=fargateHelpers.js.map

package/getAmi.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAmi = void 0;
 const aws = require("@pulumi/aws");
@@ -15,22 +6,20 @@ const aws = require("@pulumi/aws");
  * @param amiId the ID of the AMI in the Amazon Marketplace
  * @param args.owners the owner of the AMI. Defaults to Amazon owned AMIs
  */
-function getAmi(amiId, args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const owners = args && args.owners ? args.owners : ["137112412989"];
-        const ami = yield aws.ec2.getAmi({
-            filters: [
-                {
-                    name: "name",
-                    values: [amiId],
-                },
-            ],
-            mostRecent: true,
-            includeDeprecated: true,
-            owners,
-        }, { async: true });
-        return ami.id;
-    });
+async function getAmi(amiId, args) {
+    const owners = args && args.owners ? args.owners : ["137112412989"];
+    const ami = await aws.ec2.getAmi({
+        filters: [
+            {
+                name: "name",
+                values: [amiId],
+            },
+        ],
+        mostRecent: true,
+        includeDeprecated: true,
+        owners,
+    }, { async: true });
+    return ami.id;
 }
 exports.getAmi = getAmi;
 //# sourceMappingURL=getAmi.js.map

package/getImageRegistryAndCredentials.js

@@ -1,22 +1,13 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getImageRegistryAndCredentials = void 0;
 const aws = require("@pulumi/aws");
 function getImageRegistryAndCredentials(repo) {
-    return repo.registryId.apply((registryId) => __awaiter(this, void 0, void 0, function* () {
+    return repo.registryId.apply(async (registryId) => {
         if (!registryId) {
             throw new Error("Expected registry ID to be defined during push");
         }
-        const credentials = yield aws.ecr.getCredentials({ registryId: registryId });
+        const credentials = await aws.ecr.getCredentials({ registryId: registryId });
         const decodedCredentials = Buffer.from(credentials.authorizationToken, "base64").toString();
         const [username, password] = decodedCredentials.split(":");
         if (!password || !username) {
@@ -27,7 +18,7 @@ function getImageRegistryAndCredentials(repo) {
             username: username,
             password: password,
         };
-    }));
+    });
 }
 exports.getImageRegistryAndCredentials = getImageRegistryAndCredentials;
 //# sourceMappingURL=getImageRegistryAndCredentials.js.map

package/index.d.ts

@@ -0,0 +1,32 @@
+export * from "./acceptAlb";
+export * from "./acceptBastion";
+export * from "./acceptDb";
+export * from "./accessTheInternet";
+export * from "./alb";
+export * from "./buildStatic";
+export * from "./certificate";
+export * from "./cloudflare";
+export * from "./cloudwatchLogs";
+export * from "./createBucketWithUser";
+export * from "./createFargateTask";
+export * from "./createImageFromContext";
+export * from "./createScheduledFargateTask";
+export * from "./createSQSTriggeredFargateTask";
+export * from "./domain";
+export * from "./exposePublicService";
+export * from "./getAmi";
+export * from "./getDomainAndSubdomain";
+export * from "./getImageRegistryAndCredentials";
+export * from "./lambda";
+export * from "./network";
+export * from "./prometheus";
+export * from "./scheduledTaskBase";
+export * from "./secrets";
+export * from "./slack";
+export * from "./stack";
+export * from "./StaticWebsite";
+export * from "./supra";
+export * from "./utils";
+export * from "./values";
+export * from "./vpc";
+export { default as withCache } from "./withCache";

package/index.js

@@ -0,0 +1,52 @@
+"use strict";
+// Re-export all modules for convenient imports from "dcl-ops-lib"
+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 __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 });
+exports.withCache = void 0;
+__exportStar(require("./acceptAlb"), exports);
+__exportStar(require("./acceptBastion"), exports);
+__exportStar(require("./acceptDb"), exports);
+__exportStar(require("./accessTheInternet"), exports);
+__exportStar(require("./alb"), exports);
+__exportStar(require("./buildStatic"), exports);
+__exportStar(require("./certificate"), exports);
+__exportStar(require("./cloudflare"), exports);
+__exportStar(require("./cloudwatchLogs"), exports);
+__exportStar(require("./createBucketWithUser"), exports);
+__exportStar(require("./createFargateTask"), exports);
+__exportStar(require("./createImageFromContext"), exports);
+__exportStar(require("./createScheduledFargateTask"), exports);
+__exportStar(require("./createSQSTriggeredFargateTask"), exports);
+__exportStar(require("./domain"), exports);
+__exportStar(require("./exposePublicService"), exports);
+__exportStar(require("./getAmi"), exports);
+__exportStar(require("./getDomainAndSubdomain"), exports);
+__exportStar(require("./getImageRegistryAndCredentials"), exports);
+__exportStar(require("./lambda"), exports);
+__exportStar(require("./network"), exports);
+__exportStar(require("./prometheus"), exports);
+__exportStar(require("./scheduledTaskBase"), exports);
+__exportStar(require("./secrets"), exports);
+__exportStar(require("./slack"), exports);
+__exportStar(require("./stack"), exports);
+__exportStar(require("./StaticWebsite"), exports);
+__exportStar(require("./supra"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./values"), exports);
+__exportStar(require("./vpc"), exports);
+var withCache_1 = require("./withCache");
+Object.defineProperty(exports, "withCache", { enumerable: true, get: function () { return withCache_1.default; } });
+//# sourceMappingURL=index.js.map