introduction

The way we build, ship and run applications has been revolutionized by Containers. They are a lightweight, portable, consistent environment for your code; they help move workloads between development, testing and production (how do you use containers in the cloud), but how is container running on top of popular managed services such as AWS ECS (Fargate) and Google Cloud Run?

what are containers?

This means that your app runs the same everywhere, from your laptop to the cloud; popular container runtimes include Docker and containerd.

Benefits:

• Portability across environments
• Fast startup and scaling
• Isolation and security
• Efficient resource usage

running containers on aws ecs (fargate)

what is ecs?

A fully managed container orchestration service is Amazon Elastic Container Service (ECS) which allows you to run Docker containers on a cluster of EC2 instances or on AWS Fargate, based on the serverless compute engine for containers.

why fargate?

A Fargate provides you with containers without managing servers. You define your container specs and AWS is provisioning, scaling & patching infrastructure; Aws manages provisional, and patches of the infrastructure (e.g.

Key Features:

• No server management
• Per-second billing
• Integrated with AWS networking and IAM
• Supports autoscaling

example: deploying a container on ecs fargate with terraform

A simplified example of Terraform is below to deploy a containerized app on ECS Fargate using an easy-to-use model for deployment in the framework, called The Below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

provider "aws" {
  region = "us-east-1"
}

resource "aws_ecs_cluster" "main" {
  name = "my-fargate-cluster"
}

resource "aws_ecs_task_definition" "app" {
  family                   = "my-app"
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = "256"
  memory                   = "512"
  execution_role_arn       = aws_iam_role.ecs_task_execution.arn
  container_definitions    = jsonencode([
    {
      name      = "my-app"
      image     = "nginx:latest"
      essential = true
      portMappings = [{ containerPort = 80, hostPort = 80 }]
    }
  ])
}

resource "aws_iam_role" "ecs_task_execution" {
  name = "ecsTaskExecutionRole"
  assume_role_policy = data.aws_iam_policy_document.ecs_task_assume_role_policy.json
}

data "aws_iam_policy_document" "ecs_task_assume_role_policy" {
  statement {
    actions = ["sts:AssumeRole"]
    principals {
      type        = "Service"
      identifiers = ["ecs-tasks.amazonaws.com"]
    }
  }
}

resource "aws_iam_role_policy_attachment" "ecs_task_execution_policy" {
  role       = aws_iam_role.ecs_task_execution.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
}

resource "aws_ecs_service" "app" {
  name            = "my-app-service"
  cluster         = aws_ecs_cluster.main.id
  task_definition = aws_ecs_task_definition.app.arn
  desired_count   = 1
  launch_type     = "FARGATE"
  network_configuration {
    subnets          = ["subnet-xxxxxxxx"] # Replace with your subnet ID(s)
    assign_public_ip = true
  }
}

Note: You need to set up VPC, subnets, and security groups separately. This example assumes you have a public subnet available.

running containers on google cloud run

what is cloud run?

It is a fully managed compute platform that scales your stateless containers automatically, called Google Cloud Run, which only charges for the resources you use and doesn’t need to manage servers or clusters.

Key Features:

• Serverless: No infrastructure management
• Autoscaling to zero
• HTTP(s) endpoints out of the box
• Integrated with Google IAM and VPC

example: deploying a container on cloud run with terraform

For instance, an example of a Terraform (Terror) model to deploy s container to Cloud Run is below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

provider "google" {
  project = "my-gcp-project"
  region  = "us-central1"
}

resource "google_cloud_run_service" "default" {
  name     = "my-cloudrun-app"
  location = "us-central1"

  template {
    spec {
      containers {
        image = "gcr.io/cloudrun/hello"
        ports {
          container_port = 8080
        }
      }
    }
  }

  traffic {
    percent         = 100
    latest_revision = true
  }
}

resource "google_project_iam_member" "run_invoker" {
  project = "my-gcp-project"
  role    = "roles/run.invoker"
  member  = "allUsers"
}

Note: This example makes the service public. For private services, use IAM to restrict access.

conclusion

Both AWS ECS (Fargate) and Google Cloud Run make it easy to run containers in the cloud without managing servers; Ec Fargate is a great platform for complex workloads that need deep Aw services and event-driven apps, while Cloud runs well with Cloudrun which has been recommended for stateless web services or event driven apps. With Terraform you can automate and version-control your infrastructure for both platforms using Amazon’s service provider Trafford on top of an array of stacking systems like CCP via its Web Services as well as Tvr