Ya sabes que un módulo es una caja con entradas y salidas (subcapítulo 18.1). Ahora veremos cómo se usa realmente: cómo le pasas valores, cómo recoges sus resultados y cómo conectas varios módulos entre sí para componer una infraestructura completa. Esta es la parte práctica que convierte los módulos en una herramienta potentísima.

Para usar un módulo, se utiliza un bloque module. Le indicas dónde está (source) y le pasas los valores de sus variables de entrada:

Esto es como «llamar a la receta» del subcapítulo anterior, indicando los ingredientes concretos. Terraform tomará el módulo y creará sus recursos con estos valores.

Fíjate en lo poderoso que es: con esas pocas líneas, creas toda la VPC con subredes, gateway y rutas que el módulo encapsula. La complejidad está escondida; tú solo pasas dos valores.

Como una función, puedes llamar al mismo módulo varias veces con valores distintos. Por ejemplo, crear la red de tres entornos:

Un único módulo, dos redes independientes, sin duplicar código. Si mejoras el módulo, ambas redes se benefician.

El módulo devuelve información a través de sus outputs (subcapítulo 18.1). Para usar esa información desde fuera, se accede con module.<nombre>.<output>:

Por ejemplo, si quieres mostrar el ID de la VPC que creó el módulo:

Aquí está la verdadera magia de la composición. Puedes conectar la salida de un módulo con la entrada de otro, igual que conectabas recursos en el subcapítulo 12.4. Esto te permite construir arquitecturas complejas componiendo módulos pequeños.

Imagina dos módulos: uno crea la red (modulo-vpc) y otro crea servidores (modulo-servidores). El módulo de servidores necesita saber en qué VPC y subred colocarse. Le pasas esa información usando los outputs del módulo de red:

Igual que con los recursos (subcapítulo 12.4), esta conexión crea automáticamente la dependencia: como el módulo de servidores usa una salida del módulo de red, Terraform sabe que debe crear primero la red y luego los servidores. No especificas el orden; se deduce de las conexiones. La filosofía declarativa funciona también entre módulos.

Ejemplo del mundo real: una arquitectura completa se compone de varios módulos encadenados: un módulo de red que produce la VPC, un módulo de base de datos que se coloca en la red, un módulo de aplicación que usa la red y la base de datos, y un módulo de balanceador delante de la aplicación. Cada módulo es una pieza reutilizable y bien definida; las salidas de unos alimentan las entradas de otros, y Terraform orquesta todo en el orden correcto. Es como construir con piezas de Lego: cada pieza es simple, pero combinadas forman algo grande.

Esta forma de trabajar —módulos pequeños y bien definidos que se componen conectando entradas y salidas— es el corazón de un buen diseño con Terraform. En vez de un archivo gigante e inmanejable, tienes piezas:

• Reutilizables: cada módulo sirve en muchos proyectos.
• Comprensibles: cada pieza hace una cosa y es fácil de entender.
• Mantenibles: arreglas o mejoras un módulo y todos los que lo usan se benefician.
• Combinables: las conectas para formar arquitecturas tan complejas como necesites.

• Para usar un módulo, se utiliza un bloque module con source (dónde está) y los valores de sus variables de entrada. Es «llamar a la receta» con ingredientes concretos.
• Puedes reutilizar el mismo módulo varias veces con valores distintos (ej. redes de dev y producción), sin duplicar código.
• Las salidas de un módulo se leen con module.<nombre>.<output> y permiten usar su información desde fuera.
• Conectas módulos pasando los outputs de uno como entradas de otro; esto crea automáticamente la dependencia y el orden de creación (igual que entre recursos).
• La filosofía: componer piezas pequeñas, reutilizables y bien definidas (como Lego) para construir arquitecturas grandes, mantenibles y comprensibles.

En el siguiente subcapítulo veremos de dónde sacar módulos: los que tú creas (locales) frente a los públicos del Terraform Registry, listos para usar.