Saltar al contenido

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

Crear y Usar Módulos de Terraform para Reutilización

Tipo de lección: VideoConcepto claveLos módulos de Terraform son contenedores reutilizables para grupos de recursos que funcionan juntos. Piensa en ellos como plantillas de infraestructura que puedes usar una y otra vez en.

Del concepto a la práctica

Taller de esta lección

Un módulo útil expone una interfaz pequeña y estable. Para una red, las entradas pueden ser nombre, CIDR y lista de zonas; las salidas pueden ser ID de VPC y subredes. Los recursos internos quedan encapsulados, mientras la configuración raíz decide cómo conectar otros módulos.

Ejemplo resuelto

Una llamada con name=reservas, cidr=10.42.0.0/16 y zones=[eu-west-1a,eu-west-1b] produce una salida vpc_id y dos subredes. No expongas cada atributo interno si ningún consumidor lo necesita: una interfaz menor reduce acoplamiento.

Pruébalo

  1. Crea un directorio modules/network con variables, recursos y outputs.

  2. Llama al módulo desde la raíz con valores del entorno.

  3. Conecta SG mediante vpc_id y la instancia mediante private_subnet_ids de una zona.

  4. Ejecuta validate y revisa que no haya IDs duplicados escritos manualmente.

Error frecuente: cambiar el nombre de una salida sin actualizar sus consumidores. Corrección: tratar outputs como contrato y revisar todas las referencias antes del plan.

Ejercicio: modifica el nombre del entorno sin tocar el módulo.

Comprueba tu resultado

cambia la etiqueta de la red y se conservan el número de subredes, el CIDR y las referencias de salida.

Módulo de red con contrato completo

Crea modules/network/main.tf con el bloque siguiente, y usa el proveedor AWS de raíz de la lección1. Define solamente VPC/subredes privadas; no promete Internet.

hcl
variable "environment" { type = string }
variable "cidr" { type = string }
variable "zones" { type = list(string) }
resource "aws_vpc" "this" {
  cidr_block = var.cidr
  tags = { Name = "reservas-${var.environment}" }
}
resource "aws_subnet" "private" {
  for_each = { for i, az in var.zones : az => i }
  vpc_id = aws_vpc.this.id
  cidr_block = cidrsubnet(var.cidr, 8, 11 + each.value)
  availability_zone = each.key
  map_public_ip_on_launch = false
}
output "vpc_id" { value = aws_vpc.this.id }
output "private_subnet_ids" {
  value = { for az, subnet in aws_subnet.private : az => subnet.id }
}

En root main.tf llama el módulo:

hcl
module "network" {
  source = "./modules/network"
  environment = "dev"
  cidr = "10.42.0.0/16"
  zones = ["eu-west-1a", "eu-west-1b"]
}

La entrada tiene dos zonas distintas y /16IPv4; los /24 derivados son10.42.11.0 y10.42.12.0. Una instancia recibe subnet_id desde private_subnet_ids["eu-west-1a"], no vpc_id; este sirve al SG. No existe modo dry-run de terraform apply: plan revisa sin solicitar esas creaciones, aunque consulta APIs. Al refactorizar recursos ya gestionados, conserva sus direcciones mediante moved para evitar destrucción/creación accidental. Local source se versiona en Git con el proyecto; un módulo de Registry usa version, y uno Git un ref revisado.

Diagrama de decisión con ramas Sí y No y un bucle que procesa cada elemento de una lista.
CursaloMapa de práctica
Cómo avanza un programa

Una condición decide qué camino ejecuta el programa. Un bucle repite una operación mientras queden elementos, y termina cuando la lista se agota. Separar ambas ideas ayuda a seguir el flujo y comprobar casos límite.

Ver la infografía en tamaño completo ↗

Tipo de lección: Video

Concepto clave

Los módulos de Terraform son contenedores reutilizables para grupos de recursos que funcionan juntos. Piensa en ellos como plantillas de infraestructura que puedes usar una y otra vez en diferentes proyectos o entornos. En el mundo real, es similar a cómo un arquitecto usa planos estandarizados para construir casas con la misma estructura básica, pero adaptándolas a diferentes terrenos o necesidades específicas.

Cuando trabajas en proyectos DevOps, encontrarás que ciertos patrones de infraestructura se repiten constantemente: una VPC con subredes públicas y privadas, un clúster ECS con balanceador de carga, o una base de datos RDS con réplicas. En lugar de copiar y pegar código cada vez, los módulos te permiten encapsular esta lógica en un componente que puedes versionar, compartir y reutilizar. Esto no solo ahorra tiempo, sino que también reduce errores y mantiene la consistencia en toda tu organización.

Cómo funciona en la práctica

Para crear un módulo, organizas tu código Terraform en una estructura de directorios específica. El directorio del módulo contiene archivos .tf que definen recursos, variables y outputs. Luego, desde tu configuración principal, llamas al módulo usando un bloque module, pasando los valores necesarios a través de variables.

Veamos el proceso paso a paso:

  1. Crea un directorio para tu módulo (ej: modules/ec2-instance)
  2. Dentro, define los archivos Terraform con recursos, variables y outputs
  3. En tu configuración raíz, llama al módulo especificando la ruta
  4. Proporciona valores para las variables requeridas
  5. Aplica los cambios como lo harías normalmente

La magia está en que puedes usar el mismo módulo para desplegar instancias EC2 en desarrollo, staging y producción, simplemente cambiando los valores de las variables como el tipo de instancia o el tamaño del almacenamiento.

Código en acción

Primero, veamos cómo se vería un despliegue de EC2 sin módulos:

# main.tf sin módulos
resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
  subnet_id     = aws_subnet.public.id
  
  tags = {
    Name = "web-server-prod"
    Environment = "production"
  }
}

resource "aws_security_group" "web_sg" {
  name        = "web-security-group"
  description = "Security group for web server"
  
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  
  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

Ahora, refactorizamos esto en un módulo reutilizable:

# modules/ec2-web-server/main.tf
variable "instance_type" {
  description = "Tipo de instancia EC2"
  type        = string
  default     = "t2.micro"
}

variable "environment" {
  description = "Entorno (dev, staging, prod)"
  type        = string
}

variable "subnet_id" {
  description = "ID de la subred donde desplegar"
  type        = string
}

resource "aws_instance" "this" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = var.instance_type
  subnet_id     = var.subnet_id
  
  tags = {
    Name        = "web-server-${var.environment}"
    Environment = var.environment
  }
}

resource "aws_security_group" "this" {
  name        = "web-sg-${var.environment}"
  description = "Security group for web server in ${var.environment}"
  
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  
  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

output "instance_id" {
  description = "ID de la instancia creada"
  value       = aws_instance.this.id
}

output "security_group_id" {
  description = "ID del security group creado"
  value       = aws_security_group.this.id
}

Y así lo usamos desde nuestra configuración principal:

# main.tf usando el módulo
module "web_server_prod" {
  source        = "./modules/ec2-web-server"
  instance_type = "t2.large"
  environment   = "production"
  subnet_id     = aws_subnet.public.id
}

module "web_server_dev" {
  source        = "./modules/ec2-web-server"
  instance_type = "t2.micro"
  environment   = "development"
  subnet_id     = aws_subnet.public.id
}

Errores comunes

  • Ciclos de dependencia en módulos: Cuando el módulo A depende del output del módulo B, y viceversa. Solución: Rediseña la arquitectura para tener dependencias unidireccionales o usa data sources.
  • Variables no documentadas: Crear módulos sin describir qué hace cada variable. Esto hace que otros desarrolladores no sepan cómo usarlos. Solución: Siempre incluye descripciones en todas las variables y outputs.
  • Módulos demasiado específicos o demasiado genéricos: Un módulo que solo sirve para un caso muy particular no es reutilizable, pero uno que intenta hacer todo se vuelve complejo. Solución: Encuentra el balance - módulos que encapsulan un patrón común pero permiten configuración.
  • No versionar módulos: Usar rutas locales sin control de versiones. Solución: Publica tus módulos en GitHub o Terraform Registry con versiones semánticas.
  • Ignorar outputs: No exponer información útil desde el módulo. Solución: Piensa qué información necesitarán otros módulos o configuraciones y exponla como output.

Checklist de dominio

  1. Puedo crear un módulo Terraform que encapsule al menos 3 recursos AWS relacionados
  2. Sé definir variables con tipos, descripciones y valores por defecto apropiados
  3. Puedo usar outputs para exponer información útil desde mis módulos
  4. Entiendo cómo llamar módulos desde diferentes fuentes (local, GitHub, Terraform Registry)
  5. Puedo usar el mismo módulo para desplegar recursos en diferentes entornos (dev/staging/prod)
  6. Sé cómo estructurar directorios para módulos reutilizables
  7. Puedo documentar mis módulos para que otros desarrolladores los usen correctamente

Crear un módulo Terraform para una arquitectura web básica en AWS

En este ejercicio práctico, crearás un módulo Terraform reutilizable que despliegue una arquitectura web básica en AWS. Sigue estos pasos:

  1. Crea una nueva carpeta llamada terraform-module-exercise y dentro de ella, crea la estructura:
    • modules/web-architecture/ (para tu módulo)
    • environments/production/ (para la configuración de producción)
    • environments/development/ (para la configuración de desarrollo)
  2. Dentro de modules/web-architecture/, crea los siguientes archivos:
    • main.tf - Define: una VPC, dos subredes (pública y privada), un Internet Gateway, una tabla de rutas, y una instancia EC2 en la subred pública con un security group que permita HTTP/HTTPS.
    • variables.tf - Define variables para: environment (string), instance_type (string con default "t2.micro"), vpc_cidr (string con default "10.0.0.0/16").
    • outputs.tf - Expone: vpc_id, public_subnet_id, instance_public_ip.
  3. En environments/production/main.tf, llama a tu módulo con:
    • environment = "production"
    • instance_type = "t2.large"
    • vpc_cidr = "10.1.0.0/16"
  4. En environments/development/main.tf, llama al mismo módulo con:
    • environment = "development"
    • instance_type = "t2.micro" (usa el valor por defecto)
    • vpc_cidr = "10.2.0.0/16"
  5. Ejecuta terraform init, terraform plan y terraform apply (en modo dry-run o con un backend configurado) para verificar que tu módulo funciona correctamente en ambos entornos.
Pistas
  • Recuerda que la VPC necesita un Internet Gateway y rutas para que la subred pública sea accesible desde internet.
  • Usa count o for_each en el módulo si quieres hacerlo más flexible para diferentes números de subredes.
  • Considera separar la VPC y la instancia EC2 en submódulos si tu arquitectura crece en complejidad.

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.