Labs · tutorial AWS

Il tuo primo servizio su ECS Fargate con Terraform

Costruisco da zero, in Terraform, un servizio container su ECS Fargate: VPC su due zone, Application Load Balancer, log su CloudWatch e autoscaling sulla CPU. Lo stesso schema che uso in produzione.

In questo lab metto in piedi un servizio container su ECS Fargate, raggiungibile da internet attraverso un Application Load Balancer, con i log su CloudWatch e il numero di container che sale e scende da solo in base alla CPU. Tutto scritto in Terraform, così si crea, si replica e si distrugge con un comando.

È lo stesso schema con cui ho portato una piattaforma SaaS da un server EC2 sempre acceso a container multi-AZ. Qui lo riduco all'essenziale, ma ogni pezzo è quello che userei in produzione.

Cosa serve

  • Un account AWS con un utente o un ruolo che possa creare VPC, ECS, ELB, IAM e CloudWatch.
  • Terraform 1.6 o successivo e la AWS CLI configurata.
  • Mezz'ora di tempo. Il costo del lab è di pochi centesimi l'ora, soprattutto per il load balancer: alla fine distruggo tutto.

Com'è fatta l'architettura

  • Una VPC con due subnet pubbliche su due Availability Zone.
  • Un ALB che riceve il traffico sulla porta 80 e lo inoltra ai container.
  • Un cluster ECS con un servizio Fargate di almeno due task, uno per zona.
  • Una policy di autoscaling che tiene la CPU media intorno al 60%.

Per tenere basso il costo del lab metto i task in subnet pubbliche con IP pubblico, protetti da un security group che accetta traffico solo dal load balancer. In produzione li sposto in subnet private, con NAT gateway o VPC endpoint: ne parlo alla fine.

Provider e variabili

terraform {
  required_version = ">= 1.6"
  required_providers {
    aws = { source = "hashicorp/aws", version = "~> 5.0" }
  }
}

provider "aws" {
  region = var.region
}

variable "region" {
  default = "eu-south-1"
}

variable "name" {
  default = "lab-fargate"
}

variable "image" {
  default = "public.ecr.aws/nginx/nginx:stable"
}

Uso la region di Milano e un'immagine nginx pubblica su ECR, così il lab funziona senza dover costruire nulla. Per la tua applicazione basta cambiare image.

La rete

Per la VPC uso il modulo della community: è il modo più rapido per avere subnet, route table e internet gateway corretti senza scrivere trenta risorse a mano.

data "aws_availability_zones" "available" {
  state = "available"
}

module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "~> 5.0"

  name           = var.name
  cidr           = "10.0.0.0/16"
  azs            = slice(data.aws_availability_zones.available.names, 0, 2)
  public_subnets = ["10.0.1.0/24", "10.0.2.0/24"]
}

Security group: chi parla con chi

Due gruppi: il load balancer accetta HTTP da internet, i task accettano traffico solo dal load balancer. È la regola che più spesso trovo sbagliata negli account che reviso: task raggiungibili direttamente da chiunque.

resource "aws_security_group" "alb" {
  name   = "${var.name}-alb"
  vpc_id = module.vpc.vpc_id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_security_group" "tasks" {
  name   = "${var.name}-tasks"
  vpc_id = module.vpc.vpc_id

  ingress {
    from_port       = 80
    to_port         = 80
    protocol        = "tcp"
    security_groups = [aws_security_group.alb.id]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

Il load balancer

Con Fargate il target group deve essere di tipo ip: ogni task ha la sua interfaccia di rete e il suo indirizzo. L'health check è quello che decide se un task riceve traffico o viene sostituito.

resource "aws_lb" "this" {
  name               = var.name
  load_balancer_type = "application"
  subnets            = module.vpc.public_subnets
  security_groups    = [aws_security_group.alb.id]
}

resource "aws_lb_target_group" "app" {
  name        = "${var.name}-app"
  port        = 80
  protocol    = "HTTP"
  target_type = "ip"
  vpc_id      = module.vpc.vpc_id

  health_check {
    path                = "/"
    healthy_threshold   = 2
    unhealthy_threshold = 3
    interval            = 15
  }
}

resource "aws_lb_listener" "http" {
  load_balancer_arn = aws_lb.this.arn
  port              = 80
  protocol          = "HTTP"

  default_action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.app.arn
  }
}

Cluster, ruolo e log

Il ruolo di esecuzione serve a ECS per scaricare l'immagine e scrivere i log. Non è il ruolo dell'applicazione: se il tuo codice deve leggere da S3 o da Secrets Manager, quello va in un task_role_arn separato, con i soli permessi necessari.

resource "aws_ecs_cluster" "this" {
  name = var.name

  setting {
    name  = "containerInsights"
    value = "enabled"
  }
}

resource "aws_cloudwatch_log_group" "app" {
  name              = "/ecs/${var.name}"
  retention_in_days = 14
}

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

resource "aws_iam_role" "execution" {
  name               = "${var.name}-execution"
  assume_role_policy = data.aws_iam_policy_document.ecs_tasks.json
}

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

Imposto sempre una retention sui log: senza, CloudWatch li conserva per sempre e dopo qualche anno è una voce della fattura che nessuno sa spiegare.

Task definition e servizio

resource "aws_ecs_task_definition" "app" {
  family                   = var.name
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = 256
  memory                   = 512
  execution_role_arn       = aws_iam_role.execution.arn

  runtime_platform {
    operating_system_family = "LINUX"
    cpu_architecture        = "ARM64"
  }

  container_definitions = jsonencode([{
    name         = "app"
    image        = var.image
    essential    = true
    portMappings = [{ containerPort = 80, protocol = "tcp" }]
    logConfiguration = {
      logDriver = "awslogs"
      options = {
        awslogs-group         = aws_cloudwatch_log_group.app.name
        awslogs-region        = var.region
        awslogs-stream-prefix = "app"
      }
    }
  }])
}

resource "aws_ecs_service" "app" {
  name            = var.name
  cluster         = aws_ecs_cluster.this.id
  task_definition = aws_ecs_task_definition.app.arn
  desired_count   = 2
  launch_type     = "FARGATE"

  network_configuration {
    subnets          = module.vpc.public_subnets
    security_groups  = [aws_security_group.tasks.id]
    assign_public_ip = true
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.app.arn
    container_name   = "app"
    container_port   = 80
  }

  deployment_circuit_breaker {
    enable   = true
    rollback = true
  }

  lifecycle {
    ignore_changes = [desired_count]
  }

  depends_on = [aws_lb_listener.http]
}

Tre scelte che faccio sempre:

  • ARM64 (Graviton): a parità di risorse costa circa il 20% in meno di x86. L'immagine deve essere multi architettura, come quella di nginx.
  • Circuit breaker con rollback: se una nuova versione non supera gli health check, ECS torna da solo alla precedente invece di lasciare il servizio a metà.
  • ignore_changes su desired_count: il numero di task lo decide l'autoscaling. Senza questa riga, ogni terraform apply lo riporterebbe a 2.

Autoscaling sulla CPU

Una policy di tipo target tracking: dico ad AWS quale CPU media voglio e lui aggiunge o toglie task per restarci vicino, tra un minimo di 2 e un massimo di 6.

resource "aws_appautoscaling_target" "app" {
  service_namespace  = "ecs"
  resource_id        = "service/${aws_ecs_cluster.this.name}/${aws_ecs_service.app.name}"
  scalable_dimension = "ecs:service:DesiredCount"
  min_capacity       = 2
  max_capacity       = 6
}

resource "aws_appautoscaling_policy" "cpu" {
  name               = "${var.name}-cpu"
  policy_type        = "TargetTrackingScaling"
  service_namespace  = aws_appautoscaling_target.app.service_namespace
  resource_id        = aws_appautoscaling_target.app.resource_id
  scalable_dimension = aws_appautoscaling_target.app.scalable_dimension

  target_tracking_scaling_policy_configuration {
    target_value       = 60
    scale_in_cooldown  = 120
    scale_out_cooldown = 60

    predefined_metric_specification {
      predefined_metric_type = "ECSServiceAverageCPUUtilization"
    }
  }
}

output "url" {
  value = "http://${aws_lb.this.dns_name}"
}

Il cooldown di uscita è più breve di quello di rientro: aggiungere capacità in fretta e toglierla con calma evita che il servizio oscilli a ogni picco.

Lanciarlo e distruggerlo

terraform init
terraform plan
terraform apply

# dopo un paio di minuti
curl "$(terraform output -raw url)"

# alla fine del lab
terraform destroy

Se la pagina di nginx risponde, il traffico sta passando dal load balancer ai task. Nella console di ECS si vedono i due task, uno per zona, e in CloudWatch i log delle richieste.

Cosa cambio per la produzione

  • HTTPS: certificato su ACM, listener sulla 443 e redirect dalla 80.
  • Subnet private per i task, con NAT gateway oppure VPC endpoint per ECR, S3 e CloudWatch. Il NAT costa: con pochi servizi gli endpoint sono spesso più economici.
  • Stato remoto di Terraform su S3 con lock, e ambienti separati per staging e produzione.
  • Immagine propria su ECR, costruita e pubblicata dalla pipeline CI/CD, che poi aggiorna il servizio.
  • Allarmi su errori 5xx del load balancer, task non sani e budget mensile.

Se hai già un'applicazione su un server EC2 sempre acceso e vuoi capire se questo schema ti farebbe risparmiare, è esattamente quello che guardo nella revisione AWS a prezzo fisso.

Fonti

  1. AWS: Amazon ECS on AWS Fargate
  2. AWS: Service auto scaling
  3. Terraform Registry: aws_ecs_service
  4. Terraform Registry: modulo terraform-aws-modules/vpc

assistenza aws

Ti serve una mano su AWS?

Costi, sicurezza, rilasci o un servizio che non regge: guardo il tuo ambiente e ti dico cosa sistemare, in che ordine e quanto costa.

Parliamone