Saltar al contenido

Lección 19 de 20 · Lectura y práctica

Proyecto Práctico: Desplegar una Aplicación Web Escalable en AWS

Concepto claveEn DevOps, infraestructura como código (IaC) significa definir y gestionar recursos de infraestructura mediante archivos de configuración, en lugar de hacerlo manualmente. Terraform es una herramienta de IaC que.

Del concepto a la práctica

Taller de esta lección

El proyecto debe implementarse por capas y con una evidencia asociada a cada capa. No empieces por el balanceador: primero demuestra direccionamiento y rutas, luego seguridad, capacidad, datos y observabilidad. Para cada recurso, registra propósito, dependencia y salida que consumirá otro componente.

Ejemplo resuelto

La ruta de trabajo es red Multi-AZ, grupos de seguridad, bucket con acceso restringido y RDS en privadas, plantilla de instancia, grupo automático, balanceador y alarmas. El plan esperado debe mostrar relaciones coherentes y se protege porque puede contener secretos. El resultado real solo se afirma después de observar salidas autorizadas.

Pruébalo

  1. Dibuja el grafo de dependencias y marca recursos públicos y privados.

  2. Ejecuta formato, validación y plan antes de aplicar.

  3. Revisa cambios, unidades de alarmas y límites del escalado.

  4. Tras la comprobación, guarda outputs no sensibles y destruye el laboratorio.

Error frecuente: declarar que la aplicación es escalable porque existe un ASG, sin comprobar salud, zonas y balanceador. Corrección: verificar las tres relaciones.

Ejercicio: entrega una lista de cinco evidencias, una por capa.

Comprueba tu resultado

CIDR y zonas; reglas; límites ASG; estado privado de RDS; métrica y condición de alarma, sin afirmar pruebas no realizadas.

Cinco evidencias y coste residual

La evidencia de red enumera cuatro CIDR, AZs y asociaciones de rutas; la de seguridad muestra ALB→app80 y app→DBpuerto del motor; capacidad registra min2/desired2/max4 junto a política real; datos incluye subnet group/RDSno público/cifrado/respaldo; monitoreo registra métrica/dimensión/ventana y recepción pendiente u observada. Separar tabla de diseño y observación evita atribuir una cuenta creada al autor de esta lección.

No llames S3 «subred privada»: el bucket tiene controles de acceso, endpoints y políticas, y no se instala dentro de una subnet como EC2. RDSsí utiliza subnet group. El grafo no exige crear el ALB después del ASG ni una secuencia total; target group, listener y conexiones se ordenan por referencias.

Antes de limpieza identifica objetos con datos y snapshots/logs/volúmenes retenidos y revisa un plan de destrucción autorizado. destroy solo actúa sobre recursos administrados y puede fallar; cargos ya consumidos, copias retenidas y recursos ajenos siguen posibles. No elimines el backend que contiene estado de infraestructura todavía activa. Un presupuesto es estimación con fecha/región/unidades, no garantía Free Tier. Si no se ejecutó el laboratorio, entrega configuración, cuentas y matriz con operación pendiente, en vez de una nota que declare infraestructura inexistente destruida.

Responsabilidades de proveedor y equipo: infraestructura física abajo, datos y accesos arriba y capas intermedias según el servicio.
CursaloMapa de práctica
En la nube se comparten responsabilidades

El proveedor opera la infraestructura física y el equipo administra sus datos y accesos. La responsabilidad del sistema y la aplicación cambia según el servicio elegido. Revisa la configuración y el contrato del servicio antes de asumir que una capa está cubierta.

Ver la infografía en tamaño completo ↗

Concepto clave

En DevOps, infraestructura como código (IaC) significa definir y gestionar recursos de infraestructura mediante archivos de configuración, en lugar de hacerlo manualmente. Terraform es una herramienta de IaC que permite crear, modificar y versionar infraestructura de manera predecible y repetible. Imagina que construir una infraestructura en la nube es como armar un mueble de IKEA: en lugar de improvisar con herramientas, sigues instrucciones detalladas (el código) que garantizan el mismo resultado cada vez.

Para una aplicación web escalable en AWS, Terraform automatiza el despliegue de componentes como instancias EC2, balanceadores de carga, bases de datos RDS y grupos de autoescalado. Esto elimina la deriva de configuración (diferencias entre entornos) y acelera el tiempo de entrega. En un proyecto real, un DevOps Engineer usa Terraform para mantener la infraestructura alineada con el ciclo de desarrollo, permitiendo cambios rápidos y rollbacks seguros.

Cómo funciona en la práctica

El flujo de trabajo con Terraform sigue un ciclo: escribir código, planificar cambios, aplicarlos y destruir recursos cuando ya no son necesarios. Para desplegar una aplicación web escalable, comenzamos definiendo un proveedor (AWS) y luego recursos específicos. Por ejemplo, primero configuramos una VPC con subredes públicas y privadas, luego añadimos un balanceador de carga que distribuye tráfico a instancias EC2 en un grupo de autoescalado, y finalmente una base de datos RDS en una subred privada para aislamiento.

Paso a paso: 1) Instalar Terraform y configurar credenciales de AWS. 2) Crear archivos .tf con definiciones de recursos. 3) Ejecutar terraform init para inicializar el proyecto. 4) Ejecutar terraform plan para revisar cambios. 5) Ejecutar terraform apply para desplegar. 6) Usar terraform destroy para limpiar. Este proceso asegura que la infraestructura sea idempotente: aplicarlo múltiples veces produce el mismo estado deseado.

Código en acción

Aquí un ejemplo funcional de un archivo main.tf que define una VPC y un grupo de seguridad básico en AWS. Este es el "antes" para sentar las bases:

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  enable_dns_support = true
  enable_dns_hostnames = true
  tags = {
    Name = "web-app-vpc"
  }
}

resource "aws_security_group" "web_sg" {
  name        = "web-security-group"
  description = "Security group for web instances"
  vpc_id      = aws_vpc.main.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"]
  }
}

Después de agregar escalabilidad, podemos extenderlo con un grupo de autoescalado. Este es el "después" con mejoras:

resource "aws_launch_template" "web_lt" {
  name_prefix   = "web-template"
  image_id      = "ami-0c55b159cbfafe1f0"  # Amazon Linux 2
  instance_type = "t2.micro"
  vpc_security_group_ids = [aws_security_group.web_sg.id]
  
  user_data = base64encode(<<-EOF
    #!/bin/bash
    yum update -y
    yum install -y httpd
    systemctl start httpd
    systemctl enable httpd
    echo "

Hello from Terraform!

" > /var/www/html/index.html EOF) } resource "aws_autoscaling_group" "web_asg" { desired_capacity = 2 max_size = 5 min_size = 1 vpc_zone_identifier = [aws_subnet.public1.id, aws_subnet.public2.id] launch_template { id = aws_launch_template.web_lt.id version = "$Latest" } tag { key = "Name" value = "web-instance" propagate_at_launch = true } }

Errores comunes

  • No usar state remoto: Al trabajar en equipo, guardar el archivo de estado (terraform.tfstate) localmente causa conflictos. Solución: Usar un backend como S3 con bloqueo DynamoDB para compartir estado de forma segura.
  • Hardcodear valores: Incluir credenciales o IDs de AMI directamente en el código es inseguro y poco mantenible. Solución: Usar variables o sistemas de gestión de secretos como AWS Secrets Manager.
  • Ignorar el plan: Aplicar cambios sin revisar terraform plan puede llevar a modificaciones no deseadas. Solución: Siempre ejecutar y verificar el plan antes de apply.
  • No versionar el código: No usar control de versiones (como Git) para los archivos .tf dificulta la colaboración y el rollback. Solución: Integrar Terraform con un repositorio Git desde el inicio.
  • Sobredimensionar recursos: Definir instancias muy grandes o muchas réplicas incrementa costos innecesariamente. Solución: Empezar con configuraciones mínimas y ajustar basado en métricas de uso.

Checklist de dominio

  1. Configurar correctamente el proveedor AWS en Terraform con credenciales seguras.
  2. Definir una VPC con subredes públicas y privadas para aislamiento de red.
  3. Implementar un grupo de autoescalado que ajuste instancias EC2 basado en carga.
  4. Integrar un balanceador de carga (ALB) para distribuir tráfico a instancias web.
  5. Desplegar una base de datos RDS en subredes privadas con seguridad adecuada.
  6. Usar variables y outputs para hacer el código reutilizable entre entornos.
  7. Gestionar el estado de Terraform en un backend remoto para trabajo en equipo.

Despliega una aplicación web básica con autoescalado en AWS usando Terraform

Sigue estos pasos para crear una infraestructura escalable que sirva una página web simple. Asegúrate de tener una cuenta de AWS con credenciales configuradas localmente.

  1. Crea un directorio para el proyecto y dentro, un archivo main.tf. Define el proveedor AWS con región us-east-1.
  2. Añade recursos para una VPC con CIDR 10.0.0.0/16 y dos subredes públicas en zonas de disponibilidad diferentes (ej. us-east-1a y us-east-1b).
  3. Define un grupo de seguridad que permita tráfico HTTP (puerto 80) desde cualquier IP y todo el tráfico saliente.
  4. Crea un template de lanzamiento que use una AMI de Amazon Linux 2 (ej. ami-0c55b159cbfafe1f0) e incluya user_data para instalar Apache y servir un archivo HTML.
  5. Implementa un grupo de autoescalado con 2 instancias deseadas, mínimo 1 y máximo 5, usando el template y distribuyendo en las subredes públicas.
  6. Ejecuta terraform init, luego terraform plan para revisar, y finalmente terraform apply para desplegar.
  7. Verifica el despliegue accediendo a la IP pública de una instancia EC2 en tu navegador. Destruye los recursos con terraform destroy al finalizar.
Pistas
  • Usa aws_subnet para definir las subredes con map_public_ip_on_launch = true para que sean públicas.
  • En user_data, asegúrate de codificar en base64 el script de bash para la instalación.
  • Consulta la documentación de Terraform para AWS si necesitas sintaxis específica de recursos.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Sigue con Terraform en AWS: Infraestructura como Código para DevOps

Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.

Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.