Entendiendo el Autoscaling usando AWS ECS

package main

import (
    "crypto/sha256"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
    })

    http.HandleFunc("/heavy", func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        // Simular carga CPU durante ~500ms
        for time.Since(start) < 500*time.Millisecond {
            data := fmt.Sprintf("work-%d", time.Now().UnixNano())
            sha256.Sum256([]byte(data))
        }
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(map[string]string{
            "status":   "ok",
            "duration": time.Since(start).String(),
        })
    })

    fmt.Println("Server running on :8080")
    http.ListenAndServe(":8080", nil)
}

FROM golang:1.24-alpine AS builder
WORKDIR /app
COPY main.go .
RUN go build -o server main.go

FROM alpine:3.19
COPY --from=builder /app/server /server
EXPOSE 8080
CMD ["/server"]

docker build -t autoscaling-demo .
docker tag autoscaling-demo:latest <tu-usuario>/autoscaling-demo:latest
docker push <tu-usuario>/autoscaling-demo:latest

aws ecs create-cluster --cluster-name autoscaling-demo --capacity-providers FARGATE

{
  "family": "autoscaling-demo",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512",
  "executionRoleArn": "arn:aws:iam::<ACCOUNT_ID>:role/ecsTaskExecutionRole",
  "containerDefinitions": [
    {
      "name": "api",
      "image": "<tu-usuario>/autoscaling-demo:latest",
      "portMappings": [
        {
          "containerPort": 8080,
          "protocol": "tcp"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/autoscaling-demo",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "api"
        }
      }
    }
  ]
}

aws ecs register-task-definition --cli-input-json file://task-definition.json

# Crear servicio ECS con ALB (simplificado)
aws ecs create-service \
  --cluster autoscaling-demo \
  --service-name api-service \
  --task-definition autoscaling-demo \
  --desired-count 1 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[subnet-xxx],securityGroups=[sg-xxx],assignPublicIp=ENABLED}" \
  --load-balancers "targetGroupArn=arn:aws:elasticloadbalancing:...,containerName=api,containerPort=8080"

# Registrar target escalable
aws application-autoscaling register-scalable-target \
  --service-namespace ecs \
  --resource-id service/autoscaling-demo/api-service \
  --scalable-dimension ecs:service:DesiredCount \
  --min-capacity 1 \
  --max-capacity 10

# Crear política de target tracking
aws application-autoscaling put-scaling-policy \
  --service-namespace ecs \
  --resource-id service/autoscaling-demo/api-service \
  --scalable-dimension ecs:service:DesiredCount \
  --policy-name cpu-target-tracking \
  --policy-type TargetTrackingScaling \
  --target-tracking-scaling-policy-configuration '{
    "TargetValue": 60.0,
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ECSServiceAverageCPUUtilization"
    },
    "ScaleOutCooldown": 60,
    "ScaleInCooldown": 120
  }'

echo "GET https://tu-alb-url.amazonaws.com/heavy" | vegeta attack -duration=5m -rate=50/s | vegeta report