Implementación de Módulos de Terraform

Introducción

Los módulos de Terraform son un concepto central en la Infraestructura como Código (IaC) que le permiten crear componentes reutilizables, configurables y organizados. En lugar de escribir el mismo bloque de código en múltiples lugares, puede encapsularlo en un módulo y llamarlo cuando sea necesario. Esta práctica mejora significativamente la mantenibilidad y la consistencia del código en todos sus proyectos.

En este laboratorio, aprenderá los fundamentos de la implementación de módulos de Terraform. Comenzará creando una estructura de directorio de módulo estándar. Luego, definirá un módulo simple que crea un archivo local. Hará que este módulo sea configurable mediante variables y expondrá sus resultados mediante salidas (outputs). Finalmente, llamará a este módulo desde su configuración raíz de Terraform para desplegar el recurso.

Al finalizar este laboratorio, tendrá una comprensión práctica de cómo construir y utilizar sus propios módulos de Terraform.

Crear el directorio de módulos en la raíz del proyecto

En este paso, creará la estructura de directorio estándar para un módulo local de Terraform. Es una convención común colocar todos los módulos locales dentro de un directorio llamado modules en la raíz de su proyecto. Cada subdirectorio dentro de modules representa entonces un módulo único y autocontenido.

Primero, creemos un directorio para nuestros módulos y un subdirectorio específico para un módulo que llamaremos localfile_creator. Todas las operaciones se realizarán en el directorio ~/project.

Ejecute el siguiente comando para crear la estructura de directorios anidada:

mkdir -p modules/localfile_creator

La bandera -p asegura que mkdir cree el directorio padre modules si aún no existe.

Ahora, puede verificar que los directorios se han creado correctamente utilizando el comando tree. Si tree no está instalado, puede usar ls -R.

tree

Debería ver la siguiente salida, confirmando su nueva estructura de directorios:

.
└── modules
    └── localfile_creator

2 directories, 0 files

Esta estructura separa claramente el código de su módulo reutilizable de la configuración raíz que lo utilizará.

Crear main.tf en el módulo para el recurso local_file

En este paso, creará el archivo de configuración principal para su nuevo módulo. Cada módulo es un proyecto de Terraform autocontenido, por lo que tiene su propio conjunto de archivos .tf. El archivo main.tf es típicamente donde se definen los recursos centrales del módulo.

Definiremos un recurso local_file, que forma parte del proveedor hashicorp/local. Este recurso es excelente para fines de aprendizaje, ya que simplemente administra archivos en el sistema de archivos local sin necesidad de credenciales de ningún proveedor de nube.

Primero, cree el archivo main.tf dentro del directorio de su módulo usando el editor nano:

nano modules/localfile_creator/main.tf

Ahora, agregue el siguiente código HCL (HashiCorp Configuration Language) al archivo. Este código define un recurso de tipo local_file llamado example.

resource "local_file" "example" {
  content  = "This is a file created by a Terraform module."
  filename = "${path.module}/module_output.txt"
}

Analicemos este código:

• resource "local_file" "example": Esto declara un recurso de tipo local_file y le da un nombre local example.
• content: Este argumento establece el contenido que se escribirá en el archivo.
• filename: Este argumento especifica la ruta y el nombre del archivo a crear. Usamos la variable incorporada path.module, que siempre se refiere a la ruta del sistema de archivos del módulo donde se coloca la expresión. Esto hace que la ruta del archivo sea relativa al módulo en sí.

Guarde el archivo y salga de nano presionando Ctrl+X, seguido de Y, y luego Enter.

Definir variables y salidas del módulo

En este paso, hará que su módulo sea configurable y capaz de devolver información. Codificar valores fijos como nombres de archivo y contenido limita la reutilización de un módulo. Usaremos variables de entrada (input variables) para pasar valores personalizados y valores de salida (output values) para exponer información sobre los recursos que crea el módulo.

Por convención, las variables se definen en un archivo variables.tf y las salidas en un archivo outputs.tf.

Primero, cree el archivo variables.tf para su módulo:

nano modules/localfile_creator/variables.tf

Agregue el siguiente código para definir dos variables de entrada: file_content y file_name.

variable "file_content" {
  description = "The content of the file."
  type        = string
  default     = "Default content."
}

variable "file_name" {
  description = "The name of the file to create."
  type        = string
}

A continuación, cree el archivo outputs.tf para declarar qué información devolverá el módulo:

nano modules/localfile_creator/outputs.tf

Agregue el siguiente código para emitir la ruta completa del archivo creado:

output "filename" {
  description = "The full path to the created file."
  value       = local_file.example.filename
}

Finalmente, debe actualizar el main.tf del módulo para usar estas nuevas variables en lugar de los valores codificados. Abra el archivo nuevamente:

nano modules/localfile_creator/main.tf

Modifique el archivo para que se vea así. Estamos reemplazando las cadenas codificadas con var.file_content y var.file_name.

resource "local_file" "example" {
  content  = var.file_content
  filename = "${path.module}/${var.file_name}"
}

Guarde y salga del editor. Su módulo ahora es flexible y está listo para ser utilizado con diferentes entradas.

Llamar al módulo en el archivo main.tf raíz

En este paso, creará un archivo de configuración raíz que llama al módulo que acaba de construir. El main.tf raíz es el punto de entrada para su ejecución de Terraform. Es donde compone su infraestructura llamando a uno o más módulos.

Ahora trabajará en la raíz del directorio de su proyecto, ~/project. Cree un archivo main.tf aquí:

nano main.tf

Agregue el siguiente código a este archivo. Esta configuración utilizará el módulo localfile_creator.

terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "2.4.0"
    }
  }
}

module "file_creator_instance" {
  source = "./modules/localfile_creator"

  file_content = "Hello from the root module!"
  file_name    = "my_test_file.txt"
}

output "created_file_path" {
  description = "Path of the file created by the module."
  value       = module.file_creator_instance.filename
}

Analicemos esta configuración raíz:

• terraform { ... }: Este bloque define los requisitos del proveedor (provider requirements). Dado que nuestro módulo utiliza el proveedor local, el módulo raíz que lo llama también debe declararlo.
• module "file_creator_instance" { ... }: Este es el bloque del módulo. file_creator_instance es un nombre local para esta instancia específica del módulo.
• source = "./modules/localfile_creator": Esto le indica a Terraform dónde encontrar el código fuente del módulo. En este caso, es una ruta local.
• file_content = "..." y file_name = "...": Aquí, está pasando valores a las variables de entrada definidas en el variables.tf del módulo.
• output "created_file_path" { ... }: Este bloque de salida (output) a nivel raíz recupera un valor del módulo. La sintaxis es module.<NOMBRE_INSTANCIA_MODULO>.<NOMBRE_SALIDA>.

Guarde el archivo y salga de nano. Su proyecto ahora está completamente configurado para usar el módulo.

Ejecutar terraform apply para desplegar a través del módulo

En este paso final, utilizará comandos estándar de Terraform para inicializar, planificar y aplicar su configuración. Esto ejecutará el código en su módulo y creará el archivo local.

Primero, inicialice el directorio de trabajo de Terraform. Este comando descarga los plugins de proveedor necesarios (en este caso, hashicorp/local).

terraform init

Debería ver un mensaje de éxito que indica que Terraform ha sido inicializado.

Initializing the backend...
Initializing provider plugins...
- Finding hashicorp/local versions matching "2.4.0"...
- Installing hashicorp/local v2.4.0...
- Installed hashicorp/local v2.4.0 (signed by HashiCorp)

Terraform has been successfully initialized!
...

A continuación, ejecute terraform plan para ver qué cambios realizará Terraform. Esta es una ejecución de prueba (dry run) que no cambia nada, pero le muestra el plan de ejecución.

terraform plan

La salida mostrará que se creará un recurso (el local_file dentro de su módulo).

...
Plan: 1 to add, 0 to change, 0 to destroy.

Changes to Outputs:
  + created_file_path = (known after apply)
...

Ahora, aplique la configuración para crear el archivo. Usaremos la bandera -auto-approve para omitir la solicitud de confirmación interactiva.

terraform apply -auto-approve

Terraform ejecutará el plan y creará el archivo. La salida confirmará la creación y mostrará el valor de salida que definió.

...
module.file_creator_instance.local_file.example: Creating...
module.file_creator_instance.local_file.example: Creation complete after 0s [id=f73598097552a798110a31388c54c1194b539a53]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Outputs:

created_file_path = "./modules/localfile_creator/my_test_file.txt"

Finalmente, verifique que el archivo se creó con el contenido correcto. Liste los archivos en el directorio del módulo y luego muestre el contenido del nuevo archivo.

ls -l modules/localfile_creator/

cat modules/localfile_creator/my_test_file.txt

La salida del comando cat debería ser:

Hello from the root module!

¡Felicidades, ha creado y utilizado con éxito un módulo de Terraform!

Resumen

En este laboratorio, ha aprendido con éxito los fundamentos de la creación y el uso de módulos de Terraform. Ha recorrido todo el proceso, desde la configuración de una estructura de directorios adecuada hasta el despliegue de un recurso a través de un módulo reutilizable.

Usted ha aprendido a:

• Crear una estructura de directorios estándar para módulos locales.
• Definir recursos dentro del archivo main.tf de un módulo.
• Usar variables.tf para hacer que su módulo sea configurable y reutilizable.
• Usar outputs.tf para exponer datos de su módulo a la configuración que lo llama.
• Llamar a un módulo local desde un archivo main.tf raíz, pasando variables de entrada y accediendo a los valores de salida.
• Aplicar la configuración para ver el módulo en acción.

Al dominar los módulos, puede escribir Código de Infraestructura como Código (Infrastructure as Code) más limpio, organizado y escalable. ¡Bien hecho por completar este laboratorio!