Módulos de Terraform

Introducción

Imagine que es un arquitecto que diseña un vecindario. No dibujaría cada casa desde cero, ladrillo a ladrillo. En su lugar, crearía el plano de una «casa estándar» y simplemente copiaría ese plano 50 veces.

En Terraform, estos planos reutilizables se llaman módulos.

Los módulos son la principal forma en que Terraform pasa de ejemplos pequeños a bases de código de infraestructura reales. Permiten a los equipos empaquetar patrones una vez y reutilizarlos muchas veces.

En lugar de repetir la misma configuración una y otra vez, la escribe una sola vez dentro de un módulo y la reutiliza. Los módulos son importantes porque las bases de código de infraestructura reales crecen rápidamente y necesitan una estructura, al igual que el código de una aplicación.

En este laboratorio creará un módulo sencillo que genera archivos de configuración de servidores y, después, utilizará ese módulo para crear dos servidores diferentes.

Cree el directorio del módulo

Primero necesitamos un lugar para guardar nuestros planos. Los módulos de Terraform son simplemente carpetas normales que contienen archivos de Terraform.

Este detalle es importante: en términos de formato de archivos, un módulo no es una nueva funcionalidad especial del lenguaje. Es simplemente una configuración de Terraform empaquetada detrás de una interfaz reutilizable.

Por convención, normalmente creamos una carpeta llamada modules para mantener todo ordenado. Dentro de ella crearemos una carpeta para nuestro módulo específico webserver.

Configure esta estructura:

cd ~/project
mkdir -p modules/webserver

Verifique el resultado:

ls -R

Debería ver un directorio modules que contiene un directorio webserver. Esta carpeta webserver funcionará como un miniproyecto independiente.

Defina el módulo

Ahora debemos escribir el plano.

Un módulo funciona igual que un proyecto raíz: contiene main.tf para definir recursos y variables.tf para aceptar entradas.

En este laboratorio utilizaremos un recurso sencillo llamado local_file. Este recurso solo crea un archivo de texto en el disco. Es perfecto para aprender sobre módulos porque es rápido y no requiere configuraciones complejas en la nube.

Primero, cree el archivo main.tf del módulo con nano:

nano modules/webserver/main.tf

Añada este contenido. Indica a Terraform que cree un archivo con un texto específico:

resource "local_file" "server_config" {
  content  = "Server Name: ${var.server_name}\nEnvironment: ${var.env}"
  filename = "${path.root}/${var.server_name}-config.txt"
}

Guarde y salga de nano (Ctrl+O, Enter, Ctrl+X).

Un momento: ¿var.server_name? ¡Todavía no lo hemos definido! Un módulo debe declarar qué entradas acepta, igual que una función en programación.

Este modelo similar al de una función es una buena analogía conceptual. Un módulo expone entradas y salidas, y oculta al llamador los detalles de sus recursos internos.

Cree el archivo variables.tf del módulo:

nano modules/webserver/variables.tf

Añada estas definiciones de entrada:

variable "server_name" {
  description = "The name of the server"
  type        = string
}

variable "env" {
  description = "The environment (e.g., dev, prod)"
  type        = string
  default     = "dev"
}

Guarde y salga de nano.

Ahora nuestro plano (el módulo) está completo. Sabe cómo crear un archivo y sabe qué información necesita (el nombre y el entorno) para hacerlo.

Llame al módulo

Ahora asumiremos el papel del administrador del sitio. Queremos crear un servidor, pero no queremos preocuparnos por los detalles. Solo queremos «contratar» al módulo para que lo haga.

Para ello, crearemos un bloque module en el archivo main.tf raíz, es decir, el archivo situado en ~/project.

Cree el archivo main.tf raíz:

cd ~/project
nano main.tf

Añada este contenido para «llamar» al módulo:

module "my_first_server" {
  source      = "./modules/webserver"
  server_name = "web-01"
  env         = "production"
}

Recuerde guardar y salir de nano.

Veamos qué significa cada elemento:

• module "my_first_server": es el nombre de esta instancia específica.
• source: ¡esencial! Indica a Terraform dónde encontrar la carpeta del plano (./modules/webserver).
• server_name y env: son las entradas que estamos pasando al módulo.

Esto significa que una llamada a un módulo permite que la configuración raíz describa la intención en un nivel más alto. En lugar de volver a escribir cada recurso de bajo nivel, indica «instancie este patrón reutilizable con estas entradas».

IMPORTANTE: cada vez que añada un módulo, debe indicar a Terraform que lo prepare. Ejecute init para instalar el módulo:

terraform init

Ahora aplique el diseño:

terraform apply -auto-approve

Compruebe el resultado. Debería ver un archivo nuevo creado por el módulo:

cat web-01-config.txt

¡Correcto! El módulo recibió nuestras entradas ("web-01" y "production") y realizó el trabajo por nosotros.

Reutilice el módulo

Aquí es donde ocurre la magia. Queremos un segundo servidor. En lugar de copiar todo el código del recurso, simplemente volveremos a estampar el plano una vez más.

Abra de nuevo el archivo main.tf raíz con nano:

nano main.tf

Utilice las teclas de flecha para desplazarse hasta el final del archivo y añada este bloque:

module "my_second_server" {
  source      = "./modules/webserver"
  server_name = "web-02"
  ## We are not setting 'env' here, so it will use the default value "dev"
}

Guarde y salga de nano.

¿Ve lo limpio que resulta? Solo indicamos «quiero otro servidor llamado web-02». No necesitamos saber cómo funciona internamente local_file. Simplemente utilizamos la interfaz.

Aplique los cambios:

terraform init
terraform apply -auto-approve

Verifique que ahora tiene dos archivos de servidor independientes:

ls -l *-config.txt

Compruebe también que el segundo utiliza el entorno predeterminado "dev":

cat web-02-config.txt

¡Acaba de dominar el principio básico de la infraestructura reutilizable!

Resumen

¡Enhorabuena! Ha dado un gran paso hacia la escritura de código profesional de Terraform.

En este laboratorio ha aprendido:

• Módulos: cómo agrupar el código en carpetas reutilizables, sus «planos».
• Entradas: cómo utilizar variables para hacer que los módulos sean flexibles.
• Llamadas a módulos: cómo utilizar el bloque module para crear instancias de su plano.
• Reutilización: cómo crear fácilmente varias copias de la infraestructura con una cantidad mínima de código.

En lugar de tener un montón desordenado de ladrillos, ahora cuenta con un conjunto de componentes reutilizables. Esto le ayuda a crear infraestructura de forma más rápida, segura y limpia.