La Infraestructura como Código (Infrastructure as Code, IaC) es la práctica de definir y gestionar la infraestructura —servidores, redes, bases de datos, balanceadores, reglas de seguridad— mediante ficheros de código versionados, en lugar de configurarla a mano por consolas web o comandos sueltos. Igual que el código de tu aplicación vive en un repositorio, la descripción de tu infraestructura también, con todo lo que eso aporta: control de versiones, revisión por pares, reproducibilidad exacta y automatización en pipelines. Importa porque elimina la configuración a mano (lenta, propensa a errores y no documentada), evita la "deriva de configuración" (que el entorno real se desvíe de lo esperado) y permite crear, replicar o destruir entornos completos en minutos de forma fiable. Esta lección cierra el módulo enseñándote los conceptos y las herramientas clave, con Terraform como ejemplo principal.
Contenido
- El problema que resuelve IaC.
- Declarativo frente a imperativo.
- Comparativa de herramientas: Terraform, CloudFormation y Ansible.
- Idempotencia: el concepto central.
- Ejemplo práctico con Terraform.
- IaC en pipelines de CI/CD.
- Errores comunes y consejos.
- Ejercicios y soluciones.
- El problema que resuelve IaC
La gestión manual de infraestructura (hacer clic en la consola del proveedor) tiene problemas graves: no es reproducible (montar el mismo entorno dos veces da resultados distintos), no queda documentada (nadie sabe por qué existe esa regla de firewall), no es revisable (no hay forma de revisar un cambio antes de aplicarlo) y produce deriva de configuración (drift): el entorno real diverge poco a poco de lo previsto. IaC convierte la infraestructura en código: una fuente de verdad única, versionada en Git, revisable mediante pull requests y aplicable de forma automática y repetible.
- Declarativo frente a imperativo
Hay dos enfoques para describir infraestructura:
| Aspecto | Imperativo | Declarativo |
|---|---|---|
| Qué describes | Cómo llegar al estado (paso a paso) | Qué estado quieres (el resultado) |
| Analogía | Una receta de cocina | Una foto del plato terminado |
| La herramienta calcula | Nada, ejecutas órdenes | La diferencia entre estado actual y deseado |
| Ejemplo de herramienta | Scripts, Ansible (en parte) | Terraform, CloudFormation |
| Re-ejecución | Puede duplicar acciones | Solo aplica lo que falte |
- Imperativo: das instrucciones secuenciales ("crea un servidor, luego instala esto, luego abre este puerto"). Tú controlas el cómo.
- Declarativo: describes el estado final deseado ("quiero un servidor con estas características y este puerto abierto") y la herramienta averigua qué acciones hacen falta para alcanzarlo desde el estado actual. Es el enfoque dominante en IaC moderna por ser más robusto y fácil de razonar.
- Comparativa de herramientas
| Herramienta | Enfoque | Ámbito | Estado | Ideal para |
|---|---|---|---|---|
| Terraform | Declarativo | Multi-nube (agnóstico) | Fichero de estado propio | Aprovisionar infraestructura en cualquier proveedor |
| CloudFormation | Declarativo | Solo AWS | Gestionado por AWS | Quien vive 100% en AWS |
| Ansible | Imperativo/declarativo | Configuración y aprovisionamiento | Sin estado persistente | Configurar SO y software en servidores |
| Pulumi | Declarativo (con lenguajes generales) | Multi-nube | Similar a Terraform | Equipos que prefieren TypeScript/Python |
Distinción clave a menudo confundida: aprovisionar (crear la infraestructura: VMs, redes) frente a gestionar la configuración (instalar y configurar software dentro de las máquinas). Terraform y CloudFormation destacan en aprovisionar; Ansible destaca en configurar el interior de los servidores. Es muy común combinarlos: Terraform crea las máquinas y Ansible las configura. Terraform usa su propio lenguaje, HCL (HashiCorp Configuration Language); CloudFormation usa YAML/JSON y está atado a AWS.
- Idempotencia: el concepto central
Idempotencia significa que aplicar la misma operación una o muchas veces produce el mismo resultado final, sin efectos secundarios acumulativos. En IaC es fundamental: ejecutar terraform apply diez veces sobre una configuración que no ha cambiado no debe crear diez servidores, sino dejar el estado tal como está. La herramienta compara el estado deseado (tu código), el estado real (lo que existe en el proveedor) y su fichero de estado (lo que cree que gestiona), y solo aplica la diferencia (el plan). Gracias a la idempotencia, IaC es segura de re-ejecutar, lo que permite automatizarla en pipelines sin miedo a duplicar recursos.
- Ejemplo práctico con Terraform
Definamos una instancia de servidor y su grupo de seguridad en AWS con HCL. Terraform funciona en un ciclo: escribir el código, ver el plan (qué va a cambiar) y aplicar.
# main.tf
# 1. Proveedor: indica a Terraform que vamos a trabajar con AWS
provider "aws" {
region = "eu-west-1" # region de Irlanda
}
# 2. Variable parametrizable (reutilizable entre entornos)
variable "instance_type" {
description = "Tamano de la instancia"
type = string
default = "t3.micro"
}
# 3. Recurso: un grupo de seguridad que permite HTTP entrante
resource "aws_security_group" "web_sg" {
name = "web-sg"
description = "Permite trafico HTTP"
ingress {
from_port = 80
to_port = 80
protocol = "tcp"
cidr_blocks = ["0.0.0.0/0"] # desde cualquier origen
}
}
# 4. Recurso: la instancia, que referencia al grupo de seguridad anterior
resource "aws_instance" "servidor_web" {
ami = "ami-0abcdef1234567890"
instance_type = var.instance_type # usa la variable
vpc_security_group_ids = [aws_security_group.web_sg.id] # dependencia implicita
tags = {
Name = "servidor-web"
Environment = "produccion"
}
}
# 5. Salida: muestra la IP publica tras aplicar
output "ip_publica" {
value = aws_instance.servidor_web.public_ip
}Explicación bloque a bloque:
provider "aws": configura el proveedor y la región. Terraform descargará el plugin adecuado.variable "instance_type": declara un parámetro con valor por defectot3.micro, que se puede sobrescribir por entorno (así reutilizas el mismo código en pruebas y producción).resource "aws_security_group" "web_sg": crea un grupo de seguridad (un firewall) que permite tráfico entrante (ingress) al puerto 80 desde cualquier IP (0.0.0.0/0).resource "aws_instance" "servidor_web": crea la máquina.instance_type = var.instance_typeusa la variable.vpc_security_group_ids = [aws_security_group.web_sg.id]referencia al grupo anterior: Terraform detecta esta dependencia y crea primero el grupo de seguridad y luego la instancia, en el orden correcto. Lastagsetiquetan el recurso.output "ip_publica": tras aplicar, Terraform mostrará la IP pública de la instancia.
El ciclo de trabajo en la terminal:
# Inicializa el directorio y descarga los plugins del proveedor terraform init # Muestra el PLAN: que recursos creara, modificara o destruira (no cambia nada) terraform plan # Aplica los cambios para alcanzar el estado deseado (pide confirmacion) terraform apply # Destruye toda la infraestructura gestionada (util en entornos efimeros) terraform destroy
Explicación: terraform init prepara el directorio. terraform plan es el paso de seguridad clave: muestra exactamente qué va a cambiar antes de tocar nada, lo que permite revisarlo. terraform apply ejecuta el plan y converge al estado deseado (es idempotente: si nada cambió, no hace nada). terraform destroy elimina lo creado, muy útil para entornos de pruebas que se levantan y se tiran.
- IaC en pipelines de CI/CD
El verdadero poder de IaC aparece al integrarlo en un pipeline automatizado: cada cambio en la infraestructura pasa por revisión y se aplica solo. Un flujo típico con GitHub Actions:
name: Terraform
on:
pull_request: # en cada PR, solo muestra el plan
push:
branches: [main] # al fusionar a main, aplica
jobs:
terraform:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: hashicorp/setup-terraform@v3
- run: terraform init
- run: terraform plan # plan en cada PR para revisar
- if: github.ref == 'refs/heads/main'
run: terraform apply -auto-approve # apply solo en mainExplicación: el pipeline se dispara en pull requests y en push a main. En un PR ejecuta terraform plan, de modo que los revisores ven el cambio propuesto en la infraestructura antes de aprobarlo (igual que se revisa código). Solo cuando el cambio se fusiona a main se ejecuta terraform apply -auto-approve, aplicando la infraestructura de forma automática. Así, la infraestructura se gobierna con el mismo rigor que el software: revisión, trazabilidad y despliegue automatizado. Esta práctica se conoce como GitOps cuando el repositorio Git es la fuente de verdad del estado deseado.
Errores Comunes y Consejos
- No versionar el fichero de estado correctamente. El estado de Terraform es sensible y crítico: guárdalo en un backend remoto compartido (con bloqueo) y nunca lo subas en texto plano a Git, pues puede contener secretos.
- Editar a mano lo que gestiona IaC. Cambiar recursos por la consola provoca deriva: el código deja de reflejar la realidad. Cambia siempre por código.
- No revisar el plan antes de aplicar.
terraform planexiste para evitar sorpresas (como destruir una base de datos sin querer). Léelo siempre. - Secretos hardcodeados en el código IaC. Usa variables, gestores de secretos o variables de entorno; nunca incrustes credenciales en los
.tf. - Monolitos de IaC gigantes. Un único estado para toda la empresa es frágil y lento. Divide por entornos y dominios (módulos, workspaces).
- Consejo: trata la infraestructura como software desechable y reproducible. Si no puedes recrear un entorno desde cero con un comando, aún no tienes verdadera IaC. Recuerda que en sectores regulados los cambios de infraestructura pueden requerir controles y aprobaciones adicionales; valida el flujo con tu equipo de gobierno y compliance.
Ejercicios
- Explica con tus palabras qué significa que
terraform applysea idempotente y por qué eso es importante para ejecutarlo dentro de un pipeline. - Tu compañero ha cambiado a mano el tamaño de una instancia desde la consola del proveedor, pero el código IaC sigue con el valor antiguo. ¿Qué problema se produce y qué hará Terraform en el siguiente
apply? - Quieres crear máquinas en la nube y, además, instalar y configurar software dentro de ellas. ¿Qué herramientas combinarías y qué rol tendría cada una?
Soluciones
- Que
terraform applysea idempotente significa que aplicar la misma configuración una o varias veces deja el sistema en el mismo estado final: si nada ha cambiado en el código, no crea ni modifica recursos. Esto es importante en un pipeline porque permite ejecutarlo automáticamente y repetidamente sin miedo a duplicar infraestructura o provocar efectos acumulativos; siempre converge al estado deseado. - Se produce deriva de configuración (drift): el estado real diverge del declarado en el código. En el siguiente
terraform plan/apply, Terraform detectará que el recurso real no coincide con el deseado y propondrá revertir el cambio manual para volver al valor del código (o mostrará la diferencia para que decidas). Por eso no se debe editar a mano lo que gestiona IaC. - Combinaría Terraform (o CloudFormation) para aprovisionar la infraestructura: crear las máquinas, redes y grupos de seguridad; y Ansible para la gestión de configuración: instalar paquetes, desplegar la aplicación y ajustar el sistema operativo dentro de esas máquinas. Terraform crea el "contenedor" físico/virtual y Ansible lo deja listo para funcionar.
Conclusión
Has aprendido qué es la Infraestructura como Código y por qué sustituye a la configuración manual: reproducibilidad, versionado y automatización. Distinguimos el enfoque declarativo del imperativo, comparamos Terraform, CloudFormation y Ansible, entendimos la idempotencia como concepto central, escribimos un ejemplo completo en Terraform y lo integramos en un pipeline de CI/CD con revisión del plan. Con esto cierras el Módulo 8 de Arquitectura en la Nube y Despliegue: ahora dispones de las piezas para diseñar, contenerizar, ejecutar (con o sin servidor) y aprovisionar aplicaciones cloud-native de principio a fin, listas para escalar y operar con fiabilidad en producción.
Curso de Arquitectura de Aplicaciones
Módulo 1: Fundamentos de la Arquitectura de Aplicaciones
- ¿Qué es la Arquitectura de Aplicaciones?
- El Rol del Arquitecto de Software
- Atributos de Calidad y Requisitos No Funcionales
- Decisiones Arquitectónicas y Compromisos (Trade-offs)
- Documentación de Arquitectura: Vistas y el Modelo C4
Módulo 2: Principios y Tácticas de Diseño
- Acoplamiento, Cohesión y Separación de Responsabilidades
- Principios SOLID Aplicados a la Arquitectura
- DRY, KISS, YAGNI y Otros Principios de Diseño
- Tácticas Arquitectónicas para los Atributos de Calidad
- Gestión de la Deuda Técnica
Módulo 3: Estilos y Patrones Arquitectónicos
- Arquitectura Monolítica
- Arquitectura en Capas (N-Tier)
- Arquitectura Cliente-Servidor
- Arquitectura Hexagonal (Puertos y Adaptadores)
- Arquitectura Limpia y Cebolla (Clean & Onion)
Módulo 4: Arquitecturas Distribuidas y Microservicios
- Introducción a los Sistemas Distribuidos
- Arquitectura de Microservicios
- Descomposición de Servicios y Bounded Contexts
- API Gateway, Service Discovery y Comunicación entre Servicios
- Patrones de Resiliencia: Circuit Breaker, Retry y Bulkhead
- El Teorema CAP y la Consistencia de Datos
Módulo 5: Arquitecturas Dirigidas por Eventos y Mensajería
- Fundamentos de la Arquitectura Orientada a Eventos
- Mensajería Asíncrona: Colas y Brokers
- Patrones de Eventos: Event Sourcing y CQRS
- Gestión de Transacciones Distribuidas: Patrón Saga
- Streaming de Datos en Tiempo Real
Módulo 6: Diseño Dirigido por el Dominio (DDD)
- Conceptos Fundamentales del DDD
- Diseño Estratégico: Bounded Contexts y Lenguaje Ubicuo
- Diseño Táctico: Entidades, Agregados y Repositorios
- Mapeo de Contextos (Context Mapping)
Módulo 7: Datos y Persistencia
- Estrategias de Persistencia: SQL vs NoSQL
- Patrones de Acceso a Datos: Repository, Unit of Work y DAO
- Base de Datos por Servicio y Gestión de Datos Distribuidos
- Caché y Estrategias de Invalidación
Módulo 8: Arquitectura en la Nube y Despliegue
- Fundamentos del Cloud Computing (IaaS, PaaS, SaaS)
- Contenedores y Orquestación con Docker y Kubernetes
- Arquitectura Serverless
- Patrones de Diseño Cloud-Native
- Infraestructura como Código (IaC)
Módulo 9: Calidad, Seguridad y Observabilidad
- Escalabilidad: Horizontal vs Vertical y Balanceo de Carga
- Alta Disponibilidad y Tolerancia a Fallos
- Seguridad por Diseño y Autenticación/Autorización
- Observabilidad: Logging, Métricas y Trazabilidad
- Rendimiento y Pruebas de Carga
