AWS Review
English

Appearance

On this page

Ejercicio: Despliegue de Aplicación en Amazon ECS con Auto Scaling y Load Balancer ​

Objetivo: Implementar una aplicación web simple en contenedor usando Amazon ECS, con configuración de auto scaling y balanceo de carga.

  1. Primero, crear una aplicación simple en Node.js para contenerizar:

Estructura:

app/
├── Dockerfile
├── package.json
├── server.js
└── public/
    └── index.html

server.js:

javascript
const express = require('express');
const os = require('os');
const app = express();
const port = process.env.PORT || 3000;

app.use(express.static('public'));

app.get('/api/info', (req, res) => {
    res.json({
        hostname: os.hostname(),
        platform: os.platform(),
        uptime: os.uptime(),
        memory: {
            total: os.totalmem(),
            free: os.freemem()
        },
        timestamp: new Date().toISOString()
    });
});

app.listen(port, () => {
    console.log(`Server running on port ${port}`);
});

package.json:

json
{
  "name": "ecs-demo-app",
  "version": "1.0.0",
  "main": "server.js",
  "dependencies": {
    "express": "^4.17.1"
  }
}

public/index.html:

html
<!DOCTYPE html>
<html>
<head>
    <title>ECS Demo App</title>
    <script src="https://cdn.tailwindcss.com"></script>
</head>
<body class="bg-gray-100">
    <div class="container mx-auto px-4 py-8">
        <div class="bg-white rounded-lg shadow-lg p-6">
            <h1 class="text-2xl font-bold mb-4">Container Information</h1>
            <div id="info" class="grid grid-cols-2 gap-4">
                Loading...
            </div>
        </div>
    </div>
    <script>
        function updateInfo() {
            fetch('/api/info')
                .then(res => res.json())
                .then(data => {
                    const info = document.getElementById('info');
                    info.innerHTML = `
                        <div>
                            <p class="font-semibold">Hostname:</p>
                            <p>${data.hostname}</p>
                        </div>
                        <div>
                            <p class="font-semibold">Platform:</p>
                            <p>${data.platform}</p>
                        </div>
                        <div>
                            <p class="font-semibold">Uptime:</p>
                            <p>${Math.floor(data.uptime / 60)} minutes</p>
                        </div>
                        <div>
                            <p class="font-semibold">Memory Usage:</p>
                            <p>${Math.floor((data.memory.total - data.memory.free) / 1024 / 1024)} MB / ${Math.floor(data.memory.total / 1024 / 1024)} MB</p>
                        </div>
                        <div>
                            <p class="font-semibold">Last Update:</p>
                            <p>${new Date(data.timestamp).toLocaleString()}</p>
                        </div>
                    `;
                });
        }
        setInterval(updateInfo, 5000);
        updateInfo();
    </script>
</body>
</html>

Dockerfile:

dockerfile
FROM node:16-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]
  1. Pasos en la Consola AWS:

a) Crear Repositorio ECR:

plaintext
1. Ir a Amazon ECR
2. Crear repositorio
   - Nombre: ecs-demo-app
   - Visibilidad: privada
3. Anotar URI del repositorio

b) Subir imagen al ECR:

bash
# Autenticar Docker con ECR
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin [AWS_ACCOUNT_ID].dkr.ecr.us-east-1.amazonaws.com

# Construir imagen
docker build -t ecs-demo-app .

# Etiquetar imagen
docker tag ecs-demo-app:latest [AWS_ACCOUNT_ID].dkr.ecr.us-east-1.amazonaws.com/ecs-demo-app:latest

# Subir imagen
docker push [AWS_ACCOUNT_ID].dkr.ecr.us-east-1.amazonaws.com/ecs-demo-app:latest

c) Crear Cluster ECS:

plaintext
1. Ir a Amazon ECS
2. Crear Cluster
   - Nombre: demo-cluster
   - VPC: Crear nueva
   - Subnets: Seleccionar múltiples zonas
   - Infraestructura: AWS Fargate

d) Crear Task Definition:

plaintext
1. Crear Task Definition
   - Tipo: Fargate
   - Nombre: demo-app
   - Task Role: Create new
   - Task execution role: Create new
   - Task memory: 0.5GB
   - Task CPU: 0.25 vCPU
   - Container:
     * Nombre: demo-app
     * Imagen: [URI del repositorio ECR]
     * Port mappings: 3000

e) Crear Application Load Balancer:

plaintext
1. Ir a EC2 > Load Balancers
2. Crear Application Load Balancer
   - Nombre: demo-alb
   - Scheme: internet-facing
   - IP address type: ipv4
   - VPC: Seleccionar VPC del cluster
   - Subnets: Seleccionar múltiples zonas
   - Security Group: Crear nuevo
     * Inbound rules: HTTP 80 desde anywhere
3. Crear Target Group
   - Target type: IP
   - Protocol: HTTP
   - Port: 3000
   - Health check path: /api/info

f) Crear Service ECS:

plaintext
1. En el cluster, crear Service
   - Launch type: Fargate
   - Task Definition: demo-app
   - Service name: demo-service
   - Number of tasks: 2
   - Minimum healthy percent: 100
   - Maximum percent: 200
2. Configurar networking
   - VPC: Seleccionar VPC del cluster
   - Subnets: Seleccionar múltiples zonas
   - Security groups: Crear nuevo
     * Inbound rules: HTTP 3000 desde ALB
3. Configurar load balancing
   - Application Load Balancer
   - Target group: Seleccionar el creado anteriormente

g) Configurar Auto Scaling:

plaintext
1. En el servicio, configurar Auto Scaling
   - Minimum number of tasks: 2
   - Maximum number of tasks: 6
   - Scaling policies:
     * Target tracking
     * ECS service average CPU utilization: 70%
     * Scale-in cooldown: 300
     * Scale-out cooldown: 60
  1. Pruebas y Verificación:

a) Verificar Despliegue:

plaintext
1. Acceder a la URL del ALB
2. Verificar que la aplicación responde
3. Comprobar que muestra información de diferentes contenedores

b) Pruebas de Auto Scaling:

plaintext
1. Usar Apache Bench para generar carga:
   ab -n 10000 -c 100 http://[ALB-DNS]/api/info
2. Monitorear en CloudWatch:
   - CPU Utilization
   - Number of tasks
  1. Limpieza:
plaintext
1. Eliminar Service ECS
2. Eliminar Load Balancer
3. Eliminar Target Group
4. Eliminar Task Definition
5. Eliminar Cluster
6. Eliminar repositorio ECR

Este ejercicio proporciona experiencia en:

  • Contenerización de aplicaciones
  • Uso de Amazon ECR
  • Configuración de ECS con Fargate
  • Implementación de balanceo de carga
  • Configuración de auto scaling
  • Monitoreo y pruebas de carga

Los estudiantes pueden expandir el ejercicio:

  • Agregando más métricas a la aplicación
  • Implementando logging con CloudWatch
  • Configurando alertas
  • Implementando CI/CD con AWS CodePipeline