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_changessudesired_count: il numero di task lo decide l'autoscaling. Senza questa riga, ogniterraform applylo 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.