tessl/npm-pulumi--aws

A Pulumi package for creating and managing Amazon Web Services (AWS) cloud resources with infrastructure-as-code.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

ECS - Elastic Container Service

Name: tessl/npm-pulumi--aws
Author: tessl

Amazon ECS is a fully managed container orchestration service for Docker containers.

Common Tasks

Create a Fargate service with load balancer

const cluster = new aws.ecs.Cluster("app");

const taskDef = new aws.ecs.TaskDefinition("task", {
    family: "app",
    containerDefinitions: JSON.stringify([{
        name: "app",
        image: "nginx:latest",
        memory: 512,
        portMappings: [{ containerPort: 80 }],
    }]),
    requiresCompatibilities: ["FARGATE"],
    networkMode: "awsvpc",
    cpu: "256",
    memory: "512",
    executionRoleArn: role.arn,
});

const service = new aws.ecs.Service("service", {
    cluster: cluster.id,
    taskDefinition: taskDef.arn,
    desiredCount: 2,
    launchType: "FARGATE",
    networkConfiguration: {
        subnets: [subnet1.id, subnet2.id],
        securityGroups: [sg.id],
    },
    loadBalancers: [{
        targetGroupArn: tg.arn,
        containerName: "app",
        containerPort: 80,
    }],
});

Run a one-time task

const task = new aws.ecs.TaskDefinition("batch-task", {
    family: "batch",
    containerDefinitions: JSON.stringify([{
        name: "worker",
        image: "my-app:latest",
        memory: 1024,
    }]),
    requiresCompatibilities: ["FARGATE"],
    networkMode: "awsvpc",
    cpu: "512",
    memory: "1024",
});

Core Resources

Cluster

ECS clusters for running tasks and services.

class Cluster extends pulumi.CustomResource {
    constructor(name: string, args?: ClusterArgs, opts?: pulumi.CustomResourceOptions);

    readonly arn: pulumi.Output<string>;
    readonly id: pulumi.Output<string>;
}

interface ClusterArgs {
    name?: pulumi.Input<string>;
    settings?: pulumi.Input<pulumi.Input<ClusterSetting>[]>;
    tags?: pulumi.Input<{[key: string]: pulumi.Input<string>}>;
}

interface ClusterSetting {
    name: pulumi.Input<string>;
    value: pulumi.Input<string>;
}

Usage Example:

const cluster = new aws.ecs.Cluster("app-cluster", {
    name: "production-cluster",
    settings: [{
        name: "containerInsights",
        value: "enabled",
    }],
    tags: { Environment: "production" },
});

TaskDefinition

Define container configurations.

class TaskDefinition extends pulumi.CustomResource {
    constructor(name: string, args: TaskDefinitionArgs, opts?: pulumi.CustomResourceOptions);

    readonly arn: pulumi.Output<string>;
    readonly family: pulumi.Output<string>;
    readonly revision: pulumi.Output<number>;
}

interface TaskDefinitionArgs {
    family: pulumi.Input<string>;
    containerDefinitions: pulumi.Input<string>;
    taskRoleArn?: pulumi.Input<string>;
    executionRoleArn?: pulumi.Input<string>;
    networkMode?: pulumi.Input<"bridge" | "host" | "awsvpc" | "none">;
    requiresCompatibilities?: pulumi.Input<pulumi.Input<"EC2" | "FARGATE">[]>;
    cpu?: pulumi.Input<string>;
    memory?: pulumi.Input<string>;
}

Usage Example:

const taskDef = new aws.ecs.TaskDefinition("app-task", {
    family: "app",
    containerDefinitions: JSON.stringify([{
        name: "app",
        image: "nginx:latest",
        memory: 512,
        cpu: 256,
        essential: true,
        portMappings: [{
            containerPort: 80,
            protocol: "tcp"
        }],
        environment: [
            { name: "ENV", value: "production" },
        ],
        logConfiguration: {
            logDriver: "awslogs",
            options: {
                "awslogs-group": "/ecs/app",
                "awslogs-region": "us-west-2",
                "awslogs-stream-prefix": "ecs",
            },
        },
    }]),
    requiresCompatibilities: ["FARGATE"],
    networkMode: "awsvpc",
    cpu: "256",
    memory: "512",
    executionRoleArn: executionRole.arn,
    taskRoleArn: taskRole.arn,
});

Service

Run and maintain tasks.

class Service extends pulumi.CustomResource {
    constructor(name: string, args: ServiceArgs, opts?: pulumi.CustomResourceOptions);
}

interface ServiceArgs {
    cluster?: pulumi.Input<string>;
    taskDefinition: pulumi.Input<string>;
    desiredCount?: pulumi.Input<number>;
    launchType?: pulumi.Input<"EC2" | "FARGATE">;
    networkConfiguration?: pulumi.Input<ServiceNetworkConfiguration>;
    loadBalancers?: pulumi.Input<pulumi.Input<ServiceLoadBalancer>[]>;
}

interface ServiceNetworkConfiguration {
    assignPublicIp?: pulumi.Input<boolean>;
    securityGroups?: pulumi.Input<pulumi.Input<string>[]>;
    subnets: pulumi.Input<pulumi.Input<string>[]>;
}

interface ServiceLoadBalancer {
    targetGroupArn: pulumi.Input<string>;
    containerName: pulumi.Input<string>;
    containerPort: pulumi.Input<number>;
}

Usage Example:

const service = new aws.ecs.Service("app-service", {
    cluster: cluster.id,
    taskDefinition: taskDef.arn,
    desiredCount: 3,
    launchType: "FARGATE",
    networkConfiguration: {
        subnets: [subnet1.id, subnet2.id],
        securityGroups: [sg.id],
        assignPublicIp: true,
    },
    loadBalancers: [{
        targetGroupArn: tg.arn,
        containerName: "app",
        containerPort: 80,
    }],
});

Usage Example

const cluster = new aws.ecs.Cluster("app-cluster");

const taskDef = new aws.ecs.TaskDefinition("app-task", {
    family: "app",
    containerDefinitions: JSON.stringify([{
        name: "app",
        image: "nginx:latest",
        memory: 512,
        cpu: 256,
        essential: true,
        portMappings: [{ containerPort: 80 }],
    }]),
    requiresCompatibilities: ["FARGATE"],
    networkMode: "awsvpc",
    cpu: "256",
    memory: "512",
    executionRoleArn: executionRole.arn,
});

const service = new aws.ecs.Service("app-service", {
    cluster: cluster.id,
    taskDefinition: taskDef.arn,
    desiredCount: 2,
    launchType: "FARGATE",
    networkConfiguration: {
        subnets: [subnet1.id, subnet2.id],
        securityGroups: [sg.id],
        assignPublicIp: true,
    },
});

export const clusterArn = cluster.arn;