Ecsfargate autoscaling

Tutorial: Usar AWS ECS Fargate + Auto Scaling desde Arch Linux

Este tutorial muestra cómo desplegar contenedores en AWS usando ECS Fargate con Auto Scaling desde un sistema Arch Linux usando herramientas CLI.

Está pensado para usuarios avanzados que prefieren trabajar desde terminal.

1. Qué vamos a construir

Arquitectura final:

Internet
   │
Application Load Balancer
   │
ECS Service
   │
Fargate Tasks (contenedores)
   │
Auto Scaling

Todo se administrará desde Arch Linux usando CLI.

2. Instalar herramientas en Arch Linux

Actualizar el sistema:

sudo pacman -Syu

Instalar herramientas necesarias:

sudo pacman -S docker aws-cli jq git

Opcional pero recomendado:

sudo pacman -S terraform

Activar Docker:

sudo systemctl enable --now docker

Agregar usuario al grupo docker:

sudo usermod -aG docker $USER

Cerrar sesión y volver a entrar.

3. Configurar AWS CLI

Configurar credenciales:

aws configure

Te pedirá:

AWS Access Key
AWS Secret Key
Region
Output format

Probar conexión:

aws sts get-caller-identity

4. Crear aplicación de ejemplo

Crear carpeta del proyecto:

mkdir ecs-demo
cd ecs-demo

Crear archivo:

app.py

from http.server import BaseHTTPRequestHandler, HTTPServer

class handler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.end_headers()
        self.wfile.write(b"Hello from ECS Fargate")

HTTPServer(("",3000),handler).serve_forever()

5. Crear Dockerfile

Crear archivo:

Dockerfile

Contenido:

FROM python:3.11-slim

WORKDIR /app
COPY app.py .

CMD ["python","app.py"]

Construir imagen:

docker build -t ecs-demo .

6. Crear repositorio ECR

Crear repositorio:

aws ecr create-repository \
--repository-name ecs-demo

Guardar la URL que devuelve.

Login en Docker:

aws ecr get-login-password \
| docker login \
--username AWS \
--password-stdin ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com

7. Subir imagen a ECR

Taggear imagen:

docker tag ecs-demo:latest \
ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/ecs-demo:latest

Subir imagen:

docker push \
ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/ecs-demo:latest

8. Crear cluster ECS

Desde CLI:

aws ecs create-cluster \
--cluster-name ecs-demo-cluster

Verificar:

aws ecs list-clusters

9. Crear Task Definition

Crear archivo:

task-definition.json

Contenido:

{
  "family": "ecs-demo",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "512",
  "memory": "1024",
  "containerDefinitions": [
    {
      "name": "ecs-demo",
      "image": "ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/ecs-demo:latest",
      "portMappings": [
        {
          "containerPort": 3000,
          "protocol": "tcp"
        }
      ],
      "essential": true
    }
  ]
}

Registrar task:

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

10. Crear red (VPC y subnets)

Fargate requiere networking.

Puedes usar la default VPC:

aws ec2 describe-vpcs

Listar subnets:

aws ec2 describe-subnets

Guardar:

subnet IDs
security group

11. Crear servicio ECS

Ejemplo:

aws ecs create-service \
--cluster ecs-demo-cluster \
--service-name ecs-demo-service \
--task-definition ecs-demo \
--desired-count 2 \
--launch-type FARGATE \
--network-configuration "awsvpcConfiguration={
subnets=[subnet-123,subnet-456],
securityGroups=[sg-123],
assignPublicIp=ENABLED}"

Esto lanzará 2 contenedores Fargate.

12. Configurar Auto Scaling

Registrar el servicio para escalado:

aws application-autoscaling register-scalable-target \
--service-namespace ecs \
--resource-id service/ecs-demo-cluster/ecs-demo-service \
--scalable-dimension ecs:service:DesiredCount \
--min-capacity 2 \
--max-capacity 10

Crear política de scaling:

aws application-autoscaling put-scaling-policy \
--service-namespace ecs \
--resource-id service/ecs-demo-cluster/ecs-demo-service \
--scalable-dimension ecs:service:DesiredCount \
--policy-name cpu-scaling \
--policy-type TargetTrackingScaling \
--target-tracking-scaling-policy-configuration '{
  "TargetValue":70.0,
  "PredefinedMetricSpecification":{
    "PredefinedMetricType":"ECSServiceAverageCPUUtilization"
  },
  "ScaleInCooldown":60,
  "ScaleOutCooldown":60
}'

13. Qué pasa cuando corre

Escenario:

CPU baja → 2 contenedores
CPU media → 5 contenedores
CPU alta → 10 contenedores

Todo se escala automáticamente.

14. Ver contenedores activos

Listar servicios:

aws ecs list-services \
--cluster ecs-demo-cluster

Ver tasks:

aws ecs list-tasks \
--cluster ecs-demo-cluster

15. Debug desde Arch Linux

Ver logs:

aws logs tail /ecs/ecs-demo --follow

Ver métricas:

aws cloudwatch get-metric-statistics

Conclusión

Desde Arch Linux puedes manejar toda la infraestructura de contenedores usando solo CLI:

Docker
 → ECR
 → ECS
 → Fargate
 → Auto Scaling

Esto permite crear sistemas que escalan automáticamente sin administrar servidores.

Este enfoque es común para:

  • APIs
  • microservicios
  • workers
  • pipelines de datos
  • agentes de inteligencia artificial escalables