GuíaAvanzado
Guía de Terraform e IaC
Toma el stack de Andes Cargo que en la Guía de Servicios Core de AWS se creó a mano, comando por comando, y le enseña a dejar de crear infraestructura a mano para empezar a declararla. La guía cubre HCL en profundidad (`resource`, `data`, `variable`, `output`, `locals`, `module`), el ciclo `init`/`plan`/`apply`/`destroy` y la idempotencia que lo sostiene, y dedica el módulo de mayor peso al `state` de Terraform: qué es, por qué es la fuente de verdad, cómo se detecta el drift, cómo se importa infraestructura que ya existe (el mismo problema real de Andes Cargo, creada a mano en la guía anterior) y por qué un state mal resguardado es uno de los riesgos de seguridad menos enseñados de la disciplina. Construye dos módulos reutilizables (`s3-bucket`, `iam-role`) y los usa para declarar los mismos cuatro recursos canónicos de Andes Cargo — el bucket, los dos roles IAM y la función Lambda con su tabla DynamoDB — probando que un solo `terraform apply` recrea lo que antes exigía un checklist manual, y que un solo `terraform destroy` lo limpia todo. El capstone corre el mismo código con OpenTofu, el fork open source de Terraform, y dedica una lección al incidente real de marzo de 2026 donde un agente de IA corrió un `terraform destroy` contra infraestructura de producción sin que nadie revisara el `plan` con atención — instalando la regla de que ningún `apply` ni `destroy` corre sin leer el plan completo primero. Todo corre $0 contra el mismo laboratorio LocalStack de la guía anterior.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Explicar por qué la infraestructura declarativa gana sobre una secuencia de comandos imperativos (reproducibilidad, historial en Git, revisión en PR, un `destroy` que limpia todo)
- Escribir HCL con criterio: anatomía de `resource`/`data`/`provider`, el grafo de dependencias implícitas y explícitas, `fmt` y `validate`
- Ejecutar el ciclo `init`/`plan`/`apply`/`destroy` y demostrar la idempotencia de Terraform (un segundo `apply` sin cambios no hace nada)
- Parametrizar una configuración con `variable`, archivos `.tfvars`, `locals` y `output`, respetando el orden real de precedencia
- Explicar qué es `terraform.tfstate`, por qué es la fuente de verdad, y detectar drift comparando el state contra la realidad
- Importar infraestructura preexistente con `terraform import` y escribir el HCL que coincide con lo importado
- Identificar el riesgo de seguridad de un state mal resguardado (secretos y ARNs en texto plano) y aplicar las mitigaciones básicas
- Construir módulos reutilizables de Terraform (`source`, inputs/outputs) para no repetir la misma definición de bucket o de rol
- Declarar con Terraform los mismos servicios ya conocidos (S3, IAM, Lambda, DynamoDB) que en la guía anterior se crearon a mano con AWS CLI
- Leer un `terraform plan` como el artefacto de revisión antes de aplicar, y reconocer el radio de explosión de un `apply`/`destroy` mal revisado
- Ejecutar el mismo código HCL con OpenTofu y explicar por qué existe el fork
Antes de empezar
Qué necesitas traer
Es para ti si...
- Devs que ya completaron la Guía de Servicios Core de AWS y quieren dejar de crear infraestructura a mano con la CLI
- Equipos que gestionan infraestructura por comandos sueltos y necesitan reproducibilidad, revisión en PR e historial en Git
- Devs de Data Engineering que necesitan la pieza de Terraform para completar su stack de ingeniería de software (junto con git, tests y CI/CD, cubiertos en otras guías)
- Cualquiera que quiera entender el `state` de Terraform a fondo antes de tocarlo en un entorno de producción real
Requisitos y materiales
- Guía de Servicios Core de AWS completada (IAM, S3, Lambda con un trigger de S3, DynamoDB) con el laboratorio LocalStack ya levantado
- Terminal y shell básicos (variables de entorno, redirección, lectura de JSON en la terminal)
- Cuenta gratuita de LocalStack con auth token, sin necesidad de tarjeta
- Docker instalado y funcionando localmente
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- 1. Introducción a la guía: de comandos a código
- 2. El problema de la infraestructura imperativa
- 3. Qué es infraestructura como código
- 4. Terraform y sus alternativas: por qué Terraform, qué es OpenTofu
- 5. Manos a la obra: instalando Terraform y un arranque limpio
- 6. Manos a la obra: conectando Terraform a LocalStack
- 7. Manos a la obra: tu primer recurso, de punta a punta
- 8. Proyecto: arrancando el repositorio Terraform de Andes Cargo
- 1. Introducción: leer y escribir HCL con criterio
- 2. Anatomía de un bloque HCL
- 3. `resource` vs. `data`: crear vs. leer
- 4. El grafo de dependencias: implícitas y explícitas
- 5. El ciclo `plan` → `apply` → `destroy`, a fondo
- 6. Manos a la obra: `fmt` y `validate`
- 7. Manos a la obra: probando la idempotencia
- 8. Proyecto: el primer recurso declarado de Andes Cargo
- 1. Introducción: de valores fijos a configuración parametrizada
- 2. Variables de entrada y tipos
- 3. Archivos `.tfvars` y precedencia
- 4. `locals` para valores calculados
- 5. `output` e interpolación de strings
- 6. El provider `random`, con semilla fija
- 7. Manos a la obra: parametrizando el bucket de Andes Cargo
- 8. Proyecto: un stack configurable para Andes Cargo
- 1. Introducción: lo que Terraform recuerda entre corridas
- 2. Qué es `terraform.tfstate`
- 3. Por qué el state es la fuente de verdad
- 4. Manos a la obra: detectando drift
- 5. Manos a la obra: importando infraestructura existente
- 6. Backends: local (el que usa esta guía) vs. remoto
- 7. El riesgo de seguridad del state
- 8. Proyecto: el state de Andes Cargo bajo control
- 1. Introducción: dejar de copiar y pegar HCL
- 2. Qué es un módulo de Terraform
- 3. Anatomía de un módulo hijo
- 4. Llamar a un módulo: `source` e inputs
- 5. `for_each` y `count` para recursos repetidos
- 6. Manos a la obra: el módulo `s3-bucket`
- 7. Manos a la obra: el módulo `iam-role`
- 8. Proyecto: la biblioteca de módulos de Andes Cargo
- 1. Introducción: el modelo de acceso y almacenamiento, ahora en código
- 2. Repaso: el modelo de identidad y almacenamiento de Andes Cargo
- 3. Políticas IAM como dato declarativo
- 4. Manos a la obra: declarando `LambdaManifestProcessorRole`
- 5. Manos a la obra: declarando `AppServerRole`
- 6. Versionado y política de bucket como recursos separados
- 7. Manos a la obra: declarando `andes-cargo-shipment-docs`
- 8. Proyecto: identidad y almacenamiento de Andes Cargo como código
- 1. Introducción: cómputo y datos, ahora en código
- 2. Repaso: procesamiento y datos de Andes Cargo
- 3. Empaquetar código Lambda con `archive_file`
- 4. Manos a la obra: declarando la función Lambda
- 5. Manos a la obra: declarando la tabla `Shipments`
- 6. Cableando el trigger de S3
- 7. Manos a la obra: aplicando el pipeline completo
- 8. Proyecto: el pipeline de Andes Cargo como código
- 1. Introducción al capstone
- 2. Repaso de arquitectura: el stack completo como código
- 3. Recrear todo desde cero, de punta a punta
- 4. `plan` como revisión de PR, y guardrails de `apply`
- 5. Radio de explosión: el caso del `destroy` de Claude Code
- 6. Manos a la obra: el mismo código con OpenTofu
- 7. Lo que Andes Cargo todavía necesita
- 8. Proyecto final: la infraestructura de Andes Cargo como entregable
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp del Club, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Sí. Al terminar todas las lecciones se emite automáticamente, con un código verificable que puedes compartir en LinkedIn.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!