Implementando Contenedores Serverless con AWS Fargate: Una Guía Detallada

🚀 Introducción a AWS Fargate y los Contenedores Serverless

En el mundo del cloud computing, la palabra serverless ha revolucionado la forma en que los desarrolladores piensan en la infraestructura. Tradicionalmente, serverless se asociaba principalmente con funciones (como AWS Lambda), donde el código se ejecuta en respuesta a eventos sin que el usuario gestione servidores. Sin embargo, el panorama ha evolucionado para incluir contenedores. Aquí es donde entra AWS Fargate.

AWS Fargate es un motor de cómputo serverless para contenedores que funciona con Amazon Elastic Container Service (ECS) y Amazon Elastic Kubernetes Service (EKS). Elimina la necesidad de aprovisionar y gestionar servidores, clústeres o unidades de cómputo, permitiéndote concentrarte exclusivamente en el diseño y construcción de tus aplicaciones.

¿Por qué Serverless para Contenedores? 🤔

La adopción de contenedores ha crecido exponencialmente debido a su portabilidad, consistencia y eficiencia. Sin embargo, gestionar los clústeres de contenedores subyacentes (instancias EC2, parches, escalado del clúster) puede ser complejo y demandar mucho tiempo. AWS Fargate resuelve este problema al proporcionar una experiencia serverless para contenedores, ofreciendo beneficios clave:

Operaciones simplificadas: Olvídate de la administración de la infraestructura. AWS se encarga de todo, desde el aprovisionamiento de capacidad hasta la aplicación de parches y el escalado.
Costos optimizados: Pagas solo por los recursos de cómputo y memoria que tus contenedores utilizan, sin necesidad de sobreaprovisionar capacidad.
Escalabilidad automática: Fargate escala automáticamente tus contenedores en función de la demanda, garantizando alta disponibilidad y rendimiento.
Mayor seguridad: AWS gestiona la seguridad de la infraestructura subyacente, reduciendo la superficie de ataque.

💡 Consejo: Fargate es ideal para equipos que buscan centrarse en el desarrollo de aplicaciones y reducir la carga operativa de la gestión de la infraestructura de contenedores.

📖 Conceptos Fundamentales de AWS Fargate

Antes de sumergirnos en la implementación, es crucial entender algunos conceptos clave de AWS Fargate y ECS (con el que Fargate se integra de forma nativa).

Tareas y Servicios de ECS 🎯

En el corazón de ECS y Fargate se encuentran las tareas y los servicios.

Definición de Tarea (Task Definition): Una definición de tarea es como un plano o blueprint para tu aplicación. Especifica qué imágenes de Docker usar, cuánta CPU y memoria requiere cada contenedor, los puertos de red, variables de entorno, volúmenes de datos, y más. Puedes tener múltiples contenedores dentro de una sola definición de tarea que se ejecutan juntos.

{
"family": "my-app-task",
"networkMode": "awsvpc",
"cpu": "256",
"memory": "512",
"requiresCompatibilities": ["FARGATE"],
"executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"containerDefinitions": [
{
"name": "web",
"image": "nginx:latest",
"portMappings": [
{
"containerPort": 80,
"hostPort": 80,
"protocol": "tcp"
}
],
"essential": true
}
]
}

Tarea (Task): Una tarea es una instancia en ejecución de una definición de tarea. Cuando lanzas una tarea, AWS Fargate aprovisiona los recursos de cómputo necesarios y ejecuta los contenedores especificados.
Servicio (Service): Un servicio te permite ejecutar y mantener un número deseado de tareas simultáneamente en un clúster de ECS. Los servicios se encargan de la auto-recuperación (reemplazar tareas fallidas), el escalado (añadir o quitar tareas según la demanda) y la integración con balanceadores de carga. Un servicio de Fargate garantiza que tu aplicación tenga la capacidad necesaria para manejar el tráfico.

Clústeres de ECS (sin servidores) ✨

Cuando usas Fargate, aunque sigues trabajando con el concepto de un clúster de ECS, este clúster es lógico. No necesitas aprovisionar ni gestionar las instancias EC2 que forman el clúster. Fargate se encarga de la infraestructura subyacente, lo que te libera de esa carga.

Redes con `awsvpc` 🌐

Un aspecto crucial de Fargate es el modo de red awsvpc. Cada tarea de Fargate recibe su propia interfaz de red elástica (ENI) y una dirección IP privada dentro de la VPC (Virtual Private Cloud) de tu cuenta. Esto significa que las tareas de Fargate se comportan como si fueran instancias EC2 individuales, lo que simplifica la configuración de red, la seguridad y la integración con otros servicios de AWS (como balanceadores de carga y bases de datos RDS).

🛠️ Configuración del Entorno: Requisitos Previos

Para seguir este tutorial y desplegar tu primera aplicación en Fargate, necesitarás lo siguiente:

Una cuenta de AWS activa: Si no tienes una, puedes crear una cuenta gratuita de AWS. Asegúrate de tener acceso con credenciales de administrador o un usuario IAM con los permisos necesarios para ECS, Fargate, IAM, VPC y ECR.
AWS CLI configurado: La Interfaz de Línea de Comandos de AWS debe estar instalada y configurada con tus credenciales. Puedes verificarlo ejecutando aws configure.
Docker instalado: Necesario para construir y etiquetar tus imágenes de contenedor localmente. Puedes descargarlo desde docker.com.
Conocimientos básicos de Docker y contenedores: Familiaridad con conceptos como imágenes, contenedores, Dockerfile, etc.

⚠️ Advertencia: Desplegar recursos en AWS puede generar costos. Asegúrate de revisar la estructura de precios de Fargate y otros servicios involucrados (ALB, ECR, etc.) y de limpiar los recursos una vez finalizado el tutorial para evitar cargos inesperados.

🏗️ Paso 1: Crear un Repositorio de Contenedores con Amazon ECR

Amazon Elastic Container Registry (ECR) es un servicio gestionado de registro de imágenes de Docker. Almacenaremos nuestra imagen de aplicación aquí para que Fargate pueda acceder a ella.

1.1. Crear un Repositorio ECR

Vamos a crear un repositorio llamado my-fargate-app.

aws ecr create-repository \
    --repository-name my-fargate-app \
    --image-tag-mutability MUTABLE \
    --image-scanning-configuration scanOnPush=true

La salida de este comando te dará el URI del repositorio, algo como 123456789012.dkr.ecr.us-east-1.amazonaws.com/my-fargate-app. Guarda este URI, lo necesitarás más adelante.

1.2. Autenticar Docker con ECR

Para poder subir imágenes a tu repositorio ECR, Docker necesita autenticarse. Ejecuta el siguiente comando (reemplaza us-east-1 con tu región de AWS):

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 123456789012.dkr.ecr.us-east-1.amazonaws.com

Verás un mensaje Login Succeeded si todo salió bien.

⚙️ Paso 2: Construir y Empujar una Imagen Docker

Ahora crearemos una pequeña aplicación web simple y la empaquetaremos en una imagen Docker.

2.1. Crear un `Dockerfile` y una Aplicación Simple

Crea una carpeta my-fargate-app y dentro de ella, un archivo app.py y un Dockerfile.

app.py (aplicación Flask simple):

from flask import Flask
import os

app = Flask(__name__)

@app.route('/')
def hello():
    return f"Hola desde Fargate! Versión: {os.getenv('APP_VERSION', '1.0')}"

@app.route('/health')
def health():
    return "OK"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=80)

requirements.txt:

Flask

Dockerfile:

# Usa una imagen base de Python oficial
FROM python:3.9-slim-buster

# Establece el directorio de trabajo dentro del contenedor
WORKDIR /app

# Copia los archivos de requerimientos y Python al directorio de trabajo
COPY requirements.txt .
COPY app.py .

# Instala las dependencias
RUN pip install --no-cache-dir -r requirements.txt

# Expone el puerto que la aplicación escuchará
EXPOSE 80

# Comando para ejecutar la aplicación cuando el contenedor se inicie
CMD ["python", "app.py"]

2.2. Construir y Etiquetar la Imagen Docker

Desde el directorio my-fargate-app, ejecuta:

docker build -t my-fargate-app .

Luego, etiqueta la imagen para ECR (reemplaza el URI con el tuyo):

docker tag my-fargate-app:latest 123456789012.dkr.ecr.us-east-1.amazonaws.com/my-fargate-app:latest

2.3. Empujar la Imagen a ECR

Finalmente, sube la imagen a ECR:

docker push 123456789012.dkr.ecr.us-east-1.amazonaws.com/my-fargate-app:latest

Ahora tu imagen está disponible en ECR para ser usada por Fargate.

☁️ Paso 3: Configurar Recursos de Red y IAM

Fargate requiere una VPC, subredes y grupos de seguridad. También necesitamos roles de IAM para permitir que Fargate ejecute tareas.

3.1. Crear una VPC y Subredes (Si no tienes una existente) 🌐

Para simplificar, usaremos una VPC existente o crearemos una nueva con subredes públicas. Fargate necesita al menos dos subredes en diferentes Zonas de Disponibilidad para alta disponibilidad. También necesitamos un Internet Gateway para que nuestra aplicación sea accesible.

# Crear VPC
VPC_ID=$(aws ec2 create-vpc --cidr-block 10.0.0.0/16 --query 'Vpc.VpcId' --output text)
aws ec2 create-tags --resources $VPC_ID --tags Key=Name,Value=fargate-vpc

# Crear Subredes Públicas (ajusta AZs según tu región)
SUBNET_ID_1=$(aws ec2 create-subnet --vpc-id $VPC_ID --cidr-block 10.0.0.0/24 --availability-zone us-east-1a --query 'Subnet.SubnetId' --output text)
aws ec2 create-tags --resources $SUBNET_ID_1 --tags Key=Name,Value=fargate-subnet-1

SUBNET_ID_2=$(aws ec2 create-subnet --vpc-id $VPC_ID --cidr-block 10.0.1.0/24 --availability-zone us-east-1b --query 'Subnet.SubnetId' --output text)
aws ec2 create-tags --resources $SUBNET_ID_2 --tags Key=Name,Value=fargate-subnet-2

# Habilitar auto-asignación de IP pública para subredes
aws ec2 modify-subnet-attribute --subnet-id $SUBNET_ID_1 --map-public-ip-on-launch
aws ec2 modify-subnet-attribute --subnet-id $SUBNET_ID_2 --map-public-ip-on-launch

# Crear Internet Gateway y adjuntarlo a la VPC
IGW_ID=$(aws ec2 create-internet-gateway --query 'InternetGateway.InternetGatewayId' --output text)
aws ec2 create-tags --resources $IGW_ID --tags Key=Name,Value=fargate-igw
aws ec2 attach-internet-gateway --vpc-id $VPC_ID --internet-gateway-id $IGW_ID

# Crear Tabla de Rutas y asociarla a las subredes
ROUTE_TABLE_ID=$(aws ec2 create-route-table --vpc-id $VPC_ID --query 'RouteTable.RouteTableId' --output text)
aws ec2 create-tags --resources $ROUTE_TABLE_ID --tags Key=Name,Value=fargate-route-table
aws ec2 create-route --route-table-id $ROUTE_TABLE_ID --destination-cidr-block 0.0.0.0/0 --gateway-id $IGW_ID
aws ec2 associate-route-table --subnet-id $SUBNET_ID_1 --route-table-id $ROUTE_TABLE_ID
aws ec2 associate-route-table --subnet-id $SUBNET_ID_2 --route-table-id $ROUTE_TABLE_ID

# Guarda estos IDs para uso posterior
echo "VPC_ID: $VPC_ID"
echo "SUBNET_ID_1: $SUBNET_ID_1"
echo "SUBNET_ID_2: $SUBNET_ID_2"

3.2. Crear un Grupo de Seguridad 🔒

Necesitamos un Security Group que permita el tráfico HTTP entrante al puerto 80.

SECURITY_GROUP_ID=$(aws ec2 create-security-group \
    --group-name fargate-sg \
    --description "Security group for Fargate tasks" \
    --vpc-id $VPC_ID \
    --query 'GroupId' --output text)

aws ec2 authorize-security-group-ingress \
    --group-id $SECURITY_GROUP_ID \
    --protocol tcp \
    --port 80 \
    --cidr 0.0.0.0/0

echo "SECURITY_GROUP_ID: $SECURITY_GROUP_ID"

3.3. Crear Roles de IAM para Fargate ✅

Fargate necesita dos roles de IAM:

ecsTaskExecutionRole: Permite que las tareas de ECS llamen a las APIs de AWS en tu nombre para cosas como extraer imágenes de ECR y publicar logs en CloudWatch.
ecsTaskRole (Opcional, pero recomendado): Permite que tu aplicación dentro del contenedor realice llamadas a las APIs de AWS (por ejemplo, para interactuar con S3 o DynamoDB).

Crear ecsTaskExecutionRole:

# Crear política de confianza
cat > ecs-tasks-trust-policy.json <<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "ecs-tasks.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
EOF

aws iam create-role --role-name ecsTaskExecutionRole --assume-role-policy-document file://ecs-tasks-trust-policy.json
aws iam attach-role-policy --role-name ecsTaskExecutionRole --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy

Crear ecsTaskRole (si tu aplicación necesita permisos de AWS):

aws iam create-role --role-name ecsTaskRole --assume-role-policy-document file://ecs-tasks-trust-policy.json
# Puedes adjuntar políticas adicionales aquí, por ejemplo:
# aws iam attach-role-policy --role-name ecsTaskRole --policy-arn arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess

🔥 Importante: Asegúrate de que los roles IAM se hayan propagado antes de usarlos, lo que puede tardar unos segundos.

🚀 Paso 4: Crear el Clúster y la Definición de Tarea de ECS

Con los componentes de red e IAM listos, podemos definir nuestra aplicación en ECS.

4.1. Crear un Clúster de ECS (Lógico) para Fargate

aws ecs create-cluster --cluster-name my-fargate-cluster

4.2. Registrar la Definición de Tarea

Ahora creamos el blueprint de nuestra aplicación usando la imagen de ECR que subimos.

Crea un archivo llamado task-definition.json (reemplaza los placeholders 123456789012 y us-east-1):

{
  "family": "my-fargate-app-task",
  "networkMode": "awsvpc",
  "cpu": "256",
  "memory": "512",
  "executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
  "taskRoleArn": "arn:aws:iam::123456789012:role/ecsTaskRole",
  "requiresCompatibilities": ["FARGATE"],
  "containerDefinitions": [
    {
      "name": "my-web-app",
      "image": "123456789012.dkr.ecr.us-east-1.amazonaws.com/my-fargate-app:latest",
      "portMappings": [
        {
          "containerPort": 80,
          "hostPort": 80,
          "protocol": "tcp"
        }
      ],
      "essential": true,
      "environment": [
        {
          "name": "APP_VERSION",
          "value": "1.0.0"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/my-fargate-app",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "ecs"
        }
      }
    }
  ]
}

Antes de registrar la tarea, asegúrate de que el grupo de logs de CloudWatch exista:

aws logs create-log-group --log-group-name /ecs/my-fargate-app

Ahora, registra la definición de tarea:

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

La salida mostrará la revisión de tu definición de tarea. Por ejemplo, my-fargate-app-task:1.

🌐 Paso 5: Desplegar un Servicio de Fargate con un Balanceador de Carga

Para hacer nuestra aplicación accesible públicamente y garantizar alta disponibilidad, usaremos un Application Load Balancer (ALB).

5.1. Crear un Application Load Balancer (ALB)

Crearemos un ALB, un target group y un listener.

# Crear ALB
ALB_ARN=$(aws elb create-load-balancer \
    --name my-fargate-alb \
    --subnets $SUBNET_ID_1 $SUBNET_ID_2 \
    --security-groups $SECURITY_GROUP_ID \
    --scheme internet-facing \
    --query 'LoadBalancers[0].LoadBalancerArn' --output text)

# Crear Target Group
TARGET_GROUP_ARN=$(aws elbv2 create-target-group \
    --name my-fargate-tg \
    --protocol HTTP \
    --port 80 \
    --vpc-id $VPC_ID \
    --target-type ip \
    --query 'TargetGroups[0].TargetGroupArn' --output text)

# Crear Listener
LISTENER_ARN=$(aws elbv2 create-listener \
    --load-balancer-arn $ALB_ARN \
    --protocol HTTP \
    --port 80 \
    --default-actions Type=forward,TargetGroupArn=$TARGET_GROUP_ARN \
    --query 'Listeners[0].ListenerArn' --output text)

echo "ALB_ARN: $ALB_ARN"
echo "TARGET_GROUP_ARN: $TARGET_GROUP_ARN"
echo "LISTENER_ARN: $LISTENER_ARN"

# Espera unos minutos a que el ALB se aprovisione
# Puedes obtener el DNS del ALB con:
# aws elb describe-load-balancers --names my-fargate-alb --query 'LoadBalancers[0].DNSName' --output text

ALB Provisioning

5.2. Crear el Servicio de ECS Fargate

Finalmente, crearemos el servicio de ECS Fargate que mantendrá nuestras tareas en ejecución y las registrará con el ALB.

aws ecs create-service \
    --cluster my-fargate-cluster \
    --service-name my-fargate-service \
    --task-definition my-fargate-app-task \
    --desired-count 2 \
    --launch-type FARGATE \
    --network-configuration "awsvpcConfiguration={subnets=[$SUBNET_ID_1,$SUBNET_ID_2],securityGroups=[$SECURITY_GROUP_ID],assignPublicIp=ENABLED}" \
    --load-balancers "targetGroupArn=$TARGET_GROUP_ARN,containerName=my-web-app,containerPort=80" \
    --scheduling-strategy REPLICA

Este comando crea un servicio que ejecuta 2 tareas de my-fargate-app-task en Fargate, las distribuye entre las subredes especificadas, les asigna IPs públicas (para este ejemplo simplificado, en un entorno de producción, las tareas Fargate típicamente residen en subredes privadas y solo el ALB está en la subred pública), aplica el grupo de seguridad y las registra automáticamente con el target group de nuestro ALB.

¿Por qué `assignPublicIp=ENABLED`?

En un escenario real de producción, lo más común es que las tareas de Fargate estén en **subredes privadas** y que el ALB esté en **subredes públicas**. El ALB enruta el tráfico a las tareas en las subredes privadas. Sin embargo, para este tutorial y simplificar la conectividad directa del ALB sin NAT Gateway para las tareas, habilitamos `assignPublicIp`. Para entornos de producción, se recomienda usar subredes privadas y un NAT Gateway si las tareas necesitan acceso a internet saliente.

✅ Paso 6: Verificación y Acceso a la Aplicación

Una vez que el servicio esté activo (puede tardar unos minutos en lanzar las tareas), puedes acceder a tu aplicación.

Obtener el DNS del ALB:

aws elbv2 describe-load-balancers --names my-fargate-alb --query 'LoadBalancers[0].DNSName' --output text

Copia la URL DNS que se muestra.

2. Acceder a la aplicación: Abre tu navegador y navega a la URL del ALB. Deberías ver el mensaje: "Hola desde Fargate! Versión: 1.0.0".

Monitorear las tareas: Puedes verificar el estado de tus tareas en la consola de ECS, en tu clúster my-fargate-cluster, bajo la pestaña "Tasks" o "Services".
Ver logs en CloudWatch: Los logs de tu aplicación se enviarán automáticamente a CloudWatch en el grupo de logs /ecs/my-fargate-app. Puedes verlos en la consola de CloudWatch.

Paso 1: Navegar al DNS del ALB

Paso 2: Ver mensaje de bienvenida de la app

Paso 3: Verificar estado de tareas en ECS

Paso 4: Revisar logs en CloudWatch

📈 Escalado y Actualizaciones en Fargate

Una de las mayores ventajas de Fargate es su facilidad para escalar y desplegar actualizaciones.

Escalado Automático ↔️

Puedes configurar el escalado automático para tu servicio de Fargate. ECS se integra con Application Auto Scaling para ajustar el número de tareas en función de métricas como el uso de CPU, memoria o solicitudes por objetivo del ALB.

# Ejemplo de política de escalado para CPU (ajusta según tus necesidades)
aws application-autoscaling register-scalable-target \
    --service-namespace ecs \
    --scalable-dimension ecs:service:DesiredCount \
    --resource-id service/my-fargate-cluster/my-fargate-service \
    --min-capacity 1 \
    --max-capacity 5

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

Esta configuración mantendrá el uso promedio de CPU de las tareas en un 50%, escalando hacia arriba o abajo entre 1 y 5 tareas según sea necesario.

Despliegues Continuos 🔄

Para actualizar tu aplicación, simplemente subes una nueva imagen Docker a ECR con una nueva etiqueta (o la misma latest). Luego, registras una nueva revisión de tu definición de tarea que apunte a la nueva imagen. Finalmente, actualizas tu servicio de ECS para usar la nueva revisión de la tarea.

Ejemplo de actualización:

Modifica app.py (ej. cambia la versión a 2.0.0).
Reconstruye y empuja la imagen a ECR (ej. my-fargate-app:2.0.0 o my-fargate-app:latest).
Actualiza task-definition.json para reflejar la nueva imagen o versión:

...
"image": "123456789012.dkr.ecr.us-east-1.amazonaws.com/my-fargate-app:2.0.0",
"environment": [
{
"name": "APP_VERSION",
"value": "2.0.0"
}
],
...

Registra la nueva definición de tarea:

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

Actualiza el servicio para usar la nueva revisión:

aws ecs update-service \
--cluster my-fargate-cluster \
--service-name my-fargate-service \
--task-definition my-fargate-app-task:2 \
--force-new-deployment

ECS Fargate realizará un despliegue rodante, reemplazando las tareas antiguas con las nuevas gradualmente sin tiempo de inactividad, gracias a la integración con el ALB.

Sin tiempo de inactividad Despliegues controlados

🧹 Limpieza de Recursos

Es crucial eliminar todos los recursos creados para evitar cargos continuos. Sigue estos pasos en orden:

Eliminar el servicio de ECS:

aws ecs update-service --cluster my-fargate-cluster --service-name my-fargate-service --desired-count 0
aws ecs delete-service --cluster my-fargate-cluster --service-name my-fargate-service

Espera a que el servicio esté completamente eliminado.

2. Eliminar el clúster de ECS:

aws ecs delete-cluster --cluster my-fargate-cluster

Eliminar el Listener, Target Group y ALB:

aws elbv2 delete-listener --listener-arn $LISTENER_ARN
aws elbv2 delete-target-group --target-group-arn $TARGET_GROUP_ARN
aws elbv2 delete-load-balancer --load-balancer-arn $ALB_ARN

Eliminar el grupo de seguridad:

aws ec2 delete-security-group --group-id $SECURITY_GROUP_ID

Eliminar roles de IAM:

aws iam detach-role-policy --role-name ecsTaskExecutionRole --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
aws iam delete-role --role-name ecsTaskExecutionRole
aws iam delete-role --role-name ecsTaskRole # Si lo creaste y desvinculaste políticas
rm ecs-tasks-trust-policy.json

Eliminar las imágenes de ECR y el repositorio:

aws ecr batch-delete-image --repository-name my-fargate-app --image-ids imageTag=latest # o todos los tags
aws ecr delete-repository --repository-name my-fargate-app

Eliminar el grupo de logs de CloudWatch:

aws logs delete-log-group --log-group-name /ecs/my-fargate-app

Eliminar recursos de VPC (si los creaste para este tutorial):

# Desasociar tablas de rutas
aws ec2 disassociate-route-table --association-id <ID_ASOCIACION_SUBNET_1>
aws ec2 disassociate-route-table --association-id <ID_ASOCIACION_SUBNET_2>

# Eliminar rutas
aws ec2 delete-route --route-table-id $ROUTE_TABLE_ID --destination-cidr-block 0.0.0.0/0

# Eliminar tabla de rutas
aws ec2 delete-route-table --route-table-id $ROUTE_TABLE_ID

# Desvincular y eliminar Internet Gateway
aws ec2 detach-internet-gateway --vpc-id $VPC_ID --internet-gateway-id $IGW_ID
aws ec2 delete-internet-gateway --internet-gateway-id $IGW_ID

# Eliminar subredes
aws ec2 delete-subnet --subnet-id $SUBNET_ID_1
aws ec2 delete-subnet --subnet-id $SUBNET_ID_2

# Eliminar VPC
aws ec2 delete-vpc --vpc-id $VPC_ID

⚠️ Advertencia: Ten cuidado al eliminar recursos de VPC, especialmente si estás usando una VPC existente con otros recursos. Asegúrate de eliminar solo los creados para este tutorial.

📚 Conclusión

AWS Fargate representa un paso significativo hacia la verdadera serverlessización de las aplicaciones containerizadas. Al abstraer completamente la gestión de la infraestructura subyacente, Fargate permite a los desarrolladores y equipos operativos centrarse en lo que realmente importa: construir, desplegar y escalar aplicaciones innovadoras. Hemos recorrido el camino desde la preparación del entorno y la creación de la imagen Docker hasta el despliegue de un servicio web completo y escalable en Fargate con un balanceador de carga, y finalmente la limpieza de los recursos.

La adopción de Fargate puede reducir drásticamente la sobrecarga operativa, mejorar la agilidad del desarrollo y optimizar los costos, convirtiéndolo en una herramienta invaluable para cualquier organización que busque modernizar su infraestructura de contenedores. ¡Esperamos que este tutorial te sirva como un trampolín para tus propios proyectos serverless con contenedores!

Implementando Contenedores Serverless con AWS Fargate: Una Guía Detallada

🚀 Introducción a AWS Fargate y los Contenedores Serverless

¿Por qué Serverless para Contenedores? 🤔

📖 Conceptos Fundamentales de AWS Fargate

Tareas y Servicios de ECS 🎯

Clústeres de ECS (sin servidores) ✨

Redes con `awsvpc` 🌐

🛠️ Configuración del Entorno: Requisitos Previos

🏗️ Paso 1: Crear un Repositorio de Contenedores con Amazon ECR

1.1. Crear un Repositorio ECR

1.2. Autenticar Docker con ECR

⚙️ Paso 2: Construir y Empujar una Imagen Docker

2.1. Crear un `Dockerfile` y una Aplicación Simple

2.2. Construir y Etiquetar la Imagen Docker

2.3. Empujar la Imagen a ECR

☁️ Paso 3: Configurar Recursos de Red y IAM

3.1. Crear una VPC y Subredes (Si no tienes una existente) 🌐

3.2. Crear un Grupo de Seguridad 🔒

3.3. Crear Roles de IAM para Fargate ✅

🚀 Paso 4: Crear el Clúster y la Definición de Tarea de ECS

4.1. Crear un Clúster de ECS (Lógico) para Fargate

4.2. Registrar la Definición de Tarea

🌐 Paso 5: Desplegar un Servicio de Fargate con un Balanceador de Carga

5.1. Crear un Application Load Balancer (ALB)

5.2. Crear el Servicio de ECS Fargate

✅ Paso 6: Verificación y Acceso a la Aplicación

📈 Escalado y Actualizaciones en Fargate

Escalado Automático ↔️

Despliegues Continuos 🔄

🧹 Limpieza de Recursos

📚 Conclusión

Tutoriales relacionados

Comentarios (0)

🚀 Introducción a AWS Fargate y los Contenedores Serverless

¿Por qué Serverless para Contenedores? 🤔

📖 Conceptos Fundamentales de AWS Fargate

Tareas y Servicios de ECS 🎯

Clústeres de ECS (sin servidores) ✨

Redes con awsvpc 🌐

🛠️ Configuración del Entorno: Requisitos Previos

🏗️ Paso 1: Crear un Repositorio de Contenedores con Amazon ECR

1.1. Crear un Repositorio ECR

1.2. Autenticar Docker con ECR

⚙️ Paso 2: Construir y Empujar una Imagen Docker

2.1. Crear un Dockerfile y una Aplicación Simple

2.2. Construir y Etiquetar la Imagen Docker

2.3. Empujar la Imagen a ECR

☁️ Paso 3: Configurar Recursos de Red y IAM

3.1. Crear una VPC y Subredes (Si no tienes una existente) 🌐

3.2. Crear un Grupo de Seguridad 🔒

3.3. Crear Roles de IAM para Fargate ✅

🚀 Paso 4: Crear el Clúster y la Definición de Tarea de ECS

4.1. Crear un Clúster de ECS (Lógico) para Fargate

4.2. Registrar la Definición de Tarea

🌐 Paso 5: Desplegar un Servicio de Fargate con un Balanceador de Carga

5.1. Crear un Application Load Balancer (ALB)

5.2. Crear el Servicio de ECS Fargate

✅ Paso 6: Verificación y Acceso a la Aplicación

📈 Escalado y Actualizaciones en Fargate

Escalado Automático ↔️

Despliegues Continuos 🔄

🧹 Limpieza de Recursos

📚 Conclusión

Tutoriales relacionados

Comentarios (0)

Redes con `awsvpc` 🌐

2.1. Crear un `Dockerfile` y una Aplicación Simple