Container Service on AWS

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as awsx from "@pulumi/awsx";

const config = new pulumi.Config();
const containerPort = config.getNumber("containerPort") || 80;
const cpu = config.getNumber("cpu") || 512;
const memory = config.getNumber("memory") || 128;

// An ECS cluster to deploy into
const cluster = new aws.ecs.Cluster("cluster", {});

// An ALB to serve the container endpoint to the internet
const loadbalancer = new awsx.lb.ApplicationLoadBalancer("loadbalancer", {});

// An ECR repository to store the application's container image
const repo = new awsx.ecr.Repository("repo", {
    forceDelete: true,
});

// Build and publish the application's container image from ./app to the ECR repository
const image = new awsx.ecr.Image("image", {
    repositoryUrl: repo.url,
    context: "./app",
    platform: "linux/amd64",
});

// Deploy an ECS Service on Fargate to host the application container
const service = new awsx.ecs.FargateService("service", {
    cluster: cluster.arn,
    assignPublicIp: true,
    taskDefinitionArgs: {
        container: {
            name: "app",
            image: image.imageUri,
            cpu: cpu,
            memory: memory,
            essential: true,
            portMappings: [{
                containerPort: containerPort,
                targetGroup: loadbalancer.defaultTargetGroup,
            }],
        },
    },
});

// The URL at which the container's HTTP endpoint will be available
export const url = pulumi.interpolate`http://${loadbalancer.loadBalancer.dnsName}`;

// The name of the ECS cluster
export const clusterName = cluster.name;

from pulumi import Config, Output, export
import pulumi_aws as aws
import pulumi_awsx as awsx

config = Config()
container_port = config.get_int("containerPort", 80)
cpu = config.get_int("cpu", 512)
memory = config.get_int("memory", 128)

# An ECS cluster to deploy into
cluster = aws.ecs.Cluster("cluster")

# An ALB to serve the container endpoint to the internet
loadbalancer = awsx.lb.ApplicationLoadBalancer("loadbalancer")

# An ECR repository to store the application's container image
repo = awsx.ecr.Repository("repo", force_delete=True)

# Build and publish the application's container image from ./app to the ECR repository
image = awsx.ecr.Image(
    "image", repository_url=repo.url, context="./app", platform="linux/amd64"
)

# Deploy an ECS Service on Fargate to host the application container
service = awsx.ecs.FargateService(
    "service",
    cluster=cluster.arn,
    assign_public_ip=True,
    task_definition_args={
        "container": {
            "name": "app",
            "image": image.image_uri,
            "cpu": cpu,
            "memory": memory,
            "essential": True,
            "port_mappings": [
                {
                    "container_port": container_port,
                    "target_group": loadbalancer.default_target_group,
                }
            ],
        },
    },
)

# The URL at which the container's HTTP endpoint will be available
export("url", Output.concat("http://", loadbalancer.load_balancer.dns_name))

# The name of the ECS cluster
export("clusterName", cluster.name)

package main

import (
  "github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ecs"
  "github.com/pulumi/pulumi-awsx/sdk/v3/go/awsx/ecr"
  ecrx "github.com/pulumi/pulumi-awsx/sdk/v3/go/awsx/ecr"
  ecsx "github.com/pulumi/pulumi-awsx/sdk/v3/go/awsx/ecs"
  lbx "github.com/pulumi/pulumi-awsx/sdk/v3/go/awsx/lb"
  "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
  "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
  pulumi.Run(func(ctx *pulumi.Context) error {
    cfg := config.New(ctx, "")
    containerPort := 80
    if param := cfg.GetInt("containerPort"); param != 0 {
      containerPort = param
    }
    cpu := 512
    if param := cfg.GetInt("cpu"); param != 0 {
      cpu = param
    }
    memory := 128
    if param := cfg.GetInt("memory"); param != 0 {
      memory = param
    }

    // An ECS cluster to deploy into
    cluster, err := ecs.NewCluster(ctx, "cluster", nil)
    if err != nil {
      return err
    }

    // An ALB to serve the container endpoint to the internet
    loadbalancer, err := lbx.NewApplicationLoadBalancer(ctx, "loadbalancer", nil)
    if err != nil {
      return err
    }

    // An ECR repository to store the application's container image
    repo, err := ecrx.NewRepository(ctx, "repo", &ecrx.RepositoryArgs{
      ForceDelete: pulumi.Bool(true),
    })
    if err != nil {
      return err
    }

    // Build and publish the application's container image from ./app to the ECR repository
    image, err := ecrx.NewImage(ctx, "image", &ecr.ImageArgs{
      RepositoryUrl: repo.Url,
      Context:       pulumi.String("./app"),
      Platform:      pulumi.String("linux/amd64"),
    })
    if err != nil {
      return err
    }

    // Deploy an ECS Service on Fargate to host the application container
    _, err = ecsx.NewFargateService(ctx, "service", &ecsx.FargateServiceArgs{
      Cluster:        cluster.Arn,
      AssignPublicIp: pulumi.Bool(true),
      TaskDefinitionArgs: &ecsx.FargateServiceTaskDefinitionArgs{
        Container: &ecsx.TaskDefinitionContainerDefinitionArgs{
          Name:      pulumi.String("app"),
          Image:     image.ImageUri,
          Cpu:       pulumi.Int(cpu),
          Memory:    pulumi.Int(memory),
          Essential: pulumi.Bool(true),
          PortMappings: ecsx.TaskDefinitionPortMappingArray{
            &ecsx.TaskDefinitionPortMappingArgs{
              ContainerPort: pulumi.Int(containerPort),
              TargetGroup:   loadbalancer.DefaultTargetGroup,
            },
          },
        },
      },
    })
    if err != nil {
      return err
    }

    // The URL at which the container's HTTP endpoint will be available
    ctx.Export("url", pulumi.Sprintf("http://%s", loadbalancer.LoadBalancer.DnsName()))

    // The name of the ECS cluster
    ctx.Export("clusterName", cluster.Name)
    return nil
  })
}

using System.Collections.Generic;
using Pulumi;
using Aws = Pulumi.Aws;
using Awsx = Pulumi.Awsx;

return await Deployment.RunAsync(() =>
{
    var config = new Config();
    var containerPort = config.GetInt32("containerPort") ?? 80;
    var cpu = config.GetInt32("cpu") ?? 512;
    var memory = config.GetInt32("memory") ?? 128;
    var cluster = new Aws.Ecs.Cluster("cluster");

    var loadbalancer = new Awsx.Lb.ApplicationLoadBalancer("loadbalancer");

    var repo = new Awsx.Ecr.Repository("repo", new()
    {
        ForceDelete = true,
    });

    var image = new Awsx.Ecr.Image("image", new()
    {
        RepositoryUrl = repo.Url,
        Context = "./app",
        Platform = "linux/amd64",
    });

    var service = new Awsx.Ecs.FargateService("service", new()
    {
        Cluster = cluster.Arn,
        AssignPublicIp = true,
        TaskDefinitionArgs = new Awsx.Ecs.Inputs.FargateServiceTaskDefinitionArgs
        {
            Container = new Awsx.Ecs.Inputs.TaskDefinitionContainerDefinitionArgs
            {
                Name = "app",
                Image = image.ImageUri,
                Cpu = cpu,
                Memory = memory,
                Essential = true,
                PortMappings = new[]
                {
                    new Awsx.Ecs.Inputs.TaskDefinitionPortMappingArgs
                    {
                        ContainerPort = containerPort,
                        TargetGroup = loadbalancer.DefaultTargetGroup,
                    },
                },
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["url"] = loadbalancer.LoadBalancer.Apply(loadBalancer => Output.Format($"http://{loadBalancer.DnsName}")),
        ["clusterName"] = cluster.Name,
    };
});

name: my-project
description: A Pulumi YAML program to deploy a containerized service on AWS
runtime: yaml
config:
  containerPort:
    default: 80
  cpu:
    default: 512
  memory:
    default: 128

resources:

  # An ECS cluster to deploy into
  cluster:
    type: aws:ecs:Cluster

  # An ALB to serve the container endpoint to the internet
  loadbalancer:
    type: awsx:lb:ApplicationLoadBalancer

  # An ECR repository to store the application's container image
  repo:
    type: awsx:ecr:Repository
    properties:
      forceDelete: true

  # Build and publish the application's container image from ./app to the ECR repository
  image:
    type: awsx:ecr:Image
    properties:
      repositoryUrl: ${repo.url}
      context: ./app
      platform: linux/amd64

  # Deploy an ECS Service on Fargate to host the application container
  service:
    type: awsx:ecs:FargateService
    properties:
      cluster: ${cluster.arn}
      assignPublicIp: true
      taskDefinitionArgs:
        container:
          name: app
          image: ${image.imageUri}
          cpu: ${cpu}
          memory: ${memory}
          essential: true
          portMappings:
          - containerPort: ${containerPort}
            targetGroup: ${loadbalancer.defaultTargetGroup}

outputs:

  # The URL at which the container's HTTP endpoint will be available
  url: http://${loadbalancer.loadBalancer.dnsName}

  # The name of the ECS cluster
  clusterName: ${cluster.name}

terraform {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
    awsx = {
      source = "pulumi/awsx"
    }
  }
}

variable "container_port" {
  description = "The port to expose on the container"
  type        = number
  default     = 80
}

variable "cpu" {
  description = "The amount of CPU to allocate for the container"
  type        = number
  default     = 512
}

variable "memory" {
  description = "The amount of memory to allocate for the container"
  type        = number
  default     = 128
}

# An ECS cluster to deploy into
resource "aws_ecs_cluster" "cluster" {}

# An ALB to serve the container endpoint to the internet
resource "awsx_lb_application_load_balancer" "loadbalancer" {}

# An ECR repository to store the application's container image
resource "awsx_ecr_repository" "repo" {
  force_delete = true
}

# Build and publish the application's container image from ./app to the ECR repository
resource "awsx_ecr_image" "image" {
  repository_url = awsx_ecr_repository.repo.url
  context        = "./app"
  platform       = "linux/amd64"
}

# Deploy an ECS Service on Fargate to host the application container
resource "awsx_ecs_fargate_service" "service" {
  cluster          = aws_ecs_cluster.cluster.arn
  assign_public_ip = true

  task_definition_args = {
    container = {
      name      = "app"
      image     = awsx_ecr_image.image.image_uri
      cpu       = var.cpu
      memory    = var.memory
      essential = true
      port_mappings = [{
        container_port = var.container_port
        target_group   = awsx_lb_application_load_balancer.loadbalancer.default_target_group
      }]
    }
  }
}

# The URL at which the container's HTTP endpoint will be available
output "url" {
  value = "http://${awsx_lb_application_load_balancer.loadbalancer.load_balancer.dns_name}"
}

# The name of the ECS cluster
output "cluster_name" {
  value = aws_ecs_cluster.cluster.name
}