Cuando despliegas una arquitectura completa en la nube, tu script de Terraform puede crecer hasta 2.000 líneas de código y volverse imposible de navegar. La solución es fragmentar ese archivo en módulos de Terraform, una práctica que funciona igual que las clases en programación: encapsulas código funcional y lo invocas desde un archivo principal.

¿Qué son los módulos en Terraform y por qué usarlos?

Un módulo es una carpeta con archivos .tf que agrupa recursos relacionados para reutilizarlos desde un script principal. La ventaja es directa: divides un archivo gigante en piezas pequeñas, mantenibles y reutilizables.

¿Qué es un módulo en Terraform? Es una carpeta que contiene recursos agrupados por función (red, seguridad, cómputo) y se invoca desde un main.tf principal usando variables de entrada y salidas.

En el ejercicio se parte de una máquina virtual ya desplegada con grupo de recursos, red virtual, subred, IP pública, grupo de seguridad de red, tarjeta de red y la VM. La idea es agrupar esos recursos en módulos según su responsabilidad.

¿Cómo decido qué recursos agrupar en cada módulo?

No existe una regla rígida sobre cómo separar recursos, pero sí un criterio práctico: agrupa por dominio funcional. En el ejemplo se crean tres carpetas dentro de Módulos [00:54]:

• VNet para la red virtual, la subred y la IP pública.
• NSG para el grupo de seguridad de red.
• VM para la tarjeta de red, su asociación con el NSG y la máquina virtual.

Podrías meter el NSG dentro de VNet, pero separarlo te da más control y muestra cómo conectar módulos entre sí.

¿Qué archivos necesita cada módulo en Terraform?

Cada carpeta de módulo necesita tres archivos básicos [02:30]:

• main.tf con los recursos del módulo.
• variables.tf con las variables de entrada que el módulo recibe.
• output.tf con los valores que el módulo devuelve al script principal.

Una práctica útil es nombrar el archivo en singular output.tf dentro de cada módulo y dejar outputs.tf en plural para el archivo general. Esa diferencia visual te ayuda a saber en qué nivel del proyecto estás trabajando.

¿Por qué separar variables.tf y output.tf en cada módulo? Porque un módulo es una caja negra: recibe datos por variables.tf y entrega resultados por output.tf. Sin esa separación, no podrías reutilizarlo.

¿Cómo refactorizo el main principal hacia los módulos?

El proceso consiste en mover bloques desde el main.tf principal hacia el main.tf de cada módulo. En el ejemplo:

• Los bloques virtual_network, subnet y public_ip se cortan y pegan en VNet/main.tf.
• El bloque network_security_group se mueve a NSG/main.tf.
• La tarjeta de red, la asociación con el NSG y la máquina virtual viajan a VM/main.tf.

En el main.tf principal queda únicamente el grupo de recursos, que sirve como punto de partida para todo lo demás.

¿Cómo conecto las variables entre módulos en Terraform?

Al mover los recursos, los módulos pierden acceso directo a valores como location o resource_group_name. Esos valores deben convertirse en variables de entrada usando la sintaxis var.nombre_variable.

En el módulo NSG, por ejemplo, se reemplaza la ubicación heredada por var.location y se declara esa variable en NSG/variables.tf junto con resource_group_name. El mismo patrón se aplica al módulo VNet [06:25].

¿Las variables del módulo deben llamarse igual que las del proyecto principal?

No es obligatorio. Podrías declarar nsg_location o nsg_resource_group dentro del módulo y funcionaría igual. Por economía de tiempo y claridad, suele convenir mantener los mismos nombres entre el módulo y el archivo principal.

¿Cómo paso un valor de un módulo a otro? Declaras un output en el módulo origen y lo recibes como variable en el módulo destino, conectándolos desde el main.tf principal.

¿Cómo manejo dependencias entre módulos como subnet_id o nsg_id?

El módulo VM necesita información que producen otros módulos: el ID de la subred, el ID de la IP pública y el ID del grupo de seguridad. Para resolverlo se crean tres variables nuevas en VM/variables.tf:

• subnet_id de tipo string.
• public_ip_address_id de tipo string.
• nsg_id de tipo string.

Luego, dentro de VM/main.tf, los valores fijos se reemplazan por var.subnet_id, var.public_ip_address_id y var.nsg_id. La recomendación es usar nombres de variables largos pero explícitos para que el código se lea solo.

¿Cómo me ubico entre tantos archivos main.tf y variables.tf?

Una ayuda visual fundamental viene de Visual Studio Code: las pestañas muestran la ruta completa del archivo. Verás variables.tf — Módulos o variables.tf — Módulos/VM, lo que evita que confundas el archivo de variables principal con el de un módulo cuando trabajas con varios abiertos a la vez.

Esta guía visual es fundamental para no equivocarte en Terraform, sobre todo cuando refactorizas decenas de bloques entre carpetas.

Con los tres módulos funcionando de manera fragmentada, el siguiente paso es enlazar las variables recién creadas desde el main.tf principal para que todo el despliegue se ejecute como un solo flujo. ¿Ya intentaste modularizar un proyecto propio? Cuéntame en los comentarios qué criterio usaste para separar tus carpetas.