En el mundo de la administración y el aprovisionamiento de infraestructura, Terraform se ha convertido en una opción popular entre los desarrolladores y los equipos de operaciones. Con su sintaxis declarativa (HCL: lenguaje de configuración de HashiCorp) y soporte para varios proveedores de infraestructura, Terraform permite prácticas de infraestructura como código (IaC).
Una de sus características clave es el uso de módulos que permiten crear y reutilizar el código de infraestructura modular. En este artículo, exploraremos el concepto de los módulos de Terraform y cómo pueden ayudar a organizar y simplificar nuestro código de infraestructura.
Introducción a los módulos de Terraform
Los módulos de Terraform son paquetes independientes de configuraciones de Terraform que representan un conjunto de recursos con variables de entrada y salida definidas. Proporcionan una forma de encapsular y reutilizar el código de infraestructura que facilita la gestión y el mantenimiento de implementaciones de infraestructura compleja.
Los módulos pueden crearse y usarse internamente dentro de un proyecto o compartirse entre múltiples proyectos o equipos.
Organización del Módulo
Cuando se organizan los módulos de Terraform, es común tener una estructura jerárquica que consta de módulos raíz y secundarios. Exploremos cómo funciona esta organización.
Módulo Raíz
El módulo raíz representa el módulo de nivel superior en nuestra configuración de Terraform. Es el punto de entrada para definir la infraestructura general y administrar las relaciones entre diferentes recursos.
El módulo raíz generalmente contiene el archivo 'main.tf' donde definimos los recursos y las configuraciones que forman la base de nuestra infraestructura. Opcionalmente podemos llevar consigo los archivos “variables.tf” y “outputs.tf”. Además, podemos definir nuestro directorio de 'módulos' dentro del directorio raíz para acceder fácilmente a los módulos secundarios.
Módulos secundarios
Los módulos secundarios son componentes modulares que encapsulan conjuntos específicos de recursos o configuraciones. Están diseñados para ser reutilizables y representan unidades autónomas de funcionalidad de infraestructura.
Los módulos secundarios se pueden usar dentro de la raíz u otros módulos secundarios que permitan la composición y la construcción de infraestructuras complejas. Cada módulo secundario normalmente tiene su directorio que contiene los archivos de configuración necesarios, como 'main.tf', 'variables.tf' y 'outputs.tf'.
Ahora, veamos cómo podemos crear un módulo Terraform.
Creación de un módulo de Terraform
Al crear módulos de Terraform, debemos crear un nuevo directorio para el módulo con los archivos de configuración de Terraform necesarios. Por lo general, ese directorio se llama 'módulos'. Definirlo dentro del directorio raíz de nuestro proyecto es una buena práctica.
Tomemos un ejemplo sencillo de un módulo simple para aprovisionar un servidor web local utilizando Docker. Primero, definimos el módulo en el directorio 'módulos' como 'main.tf'.
recurso 'docker_container' 'Servidor web' {nombre = var.nombre
imagen = var.imagen
puertos {
interno = var.puerto_interno
externo = var.puerto_externo
}
}
Aquí, creamos un módulo llamado 'docker_container' que toma el nombre del contenedor, la imagen de Docker, el puerto interno y el puerto externo como variables de entrada. El módulo encapsula la lógica para crear un recurso de contenedor Docker y permite que la persona que llama personalice las propiedades del contenedor.
Como se muestra en la siguiente imagen, creamos un archivo separado llamado 'variables.tf' en el directorio 'módulos' para definir las variables de entrada que se pueden personalizar al usar el módulo:
variable 'nombre' {descripción = 'Nombre del contenedor Docker'
tipo = cadena
}
variable 'imagen' {
descripción = 'Imagen acoplable'
tipo = cadena
}
variable 'Puerto interno' {
descripción = 'Puerto interno en el contenedor Docker'
tipo = número
}
variable 'puerto_externo' {
descripción = 'Puerto externo para asignar a'
tipo = número
}
Aquí, declaramos cuatro variables, cada una con 'descripción' y 'tipo' como atributos y valores relevantes para ellas.
Uso de un módulo Terraform
Dado que creamos nuestro módulo, ahora podemos usarlo en nuestra configuración principal de Terraform haciendo referencia a su fuente. Hagamos nuestro archivo de configuración principal, que es 'main.tf' en el directorio raíz.
módulo 'servidor_web_contenedor' {fuente = '../módulos/docker_container'
nombre = 'miservidorweb'
imagen = 'nginx: último'
puerto_interno = 80
puerto_externo = 8080
}
Usamos el bloque 'módulo' en el código anterior para crear una instancia del módulo contenedor de Docker. Proporcionamos los valores de entrada necesarios para el módulo, como el nombre del contenedor, la imagen de Docker y la configuración del puerto. El parámetro 'fuente' especifica la ruta relativa al directorio 'módulo'.
A continuación, veamos cómo usar las salidas de Terraform para usarlas con módulos.
Salidas del módulo
Los resultados del módulo en Terraform proporcionan una forma de exponer valores específicos desde dentro de un módulo, haciéndolos disponibles para su uso en la configuración principal o por otros módulos. Sirven como un canal de comunicación entre el módulo y la persona que llama, lo que permite que el módulo proporcione información o datos que pueden ser útiles o necesarios para una configuración posterior o una toma de decisiones.
producción 'id_contenedor' {descripción = 'ID del contenedor Docker creado'
valor = docker_container.webserver.id
}
Aquí, creamos un archivo 'outputs.tf' dentro del directorio 'módulos'. Esta variable de salida expone el ID del contenedor Docker creado por el recurso 'docker_container' denominado 'servidor web' dentro del módulo.
Ahora, podemos acceder al ID del contenedor en nuestro archivo de configuración raíz. Consulte el siguiente código actualizado del archivo 'main.tf' en el directorio raíz:
módulo 'servidor_web_contenedor' {fuente = '../módulos/docker_container'
nombre = 'miservidorweb'
imagen = 'nginx: último'
puerto_interno = 80
puerto_externo = 8080
}
recurso 'docker_volume' 'datos' {
# El resto de los argumentos va aquí
unir = módulo.webserver_container.container_id
}
Al usar 'module.webserver_container.container_id' como valor para el argumento 'bind', le indicamos a Terraform que vincule el volumen de Docker a la ubicación especificada por el ID del contenedor del módulo 'web_container'. Esto establece una relación entre el recurso de volumen de Docker y el contenedor creado por el módulo 'webserver_container', lo que garantiza que el volumen esté montado en la ubicación adecuada.
Prácticas recomendadas para los módulos de Terraform
Modularizar para la reutilización
Debemos considerar la reutilización al diseñar los módulos. Además, debemos identificar los componentes o patrones lógicos de nuestra infraestructura y encapsularlos en módulos separados. Esto promueve la reutilización de código, la estandarización y una colaboración más sencilla entre equipos.
Denominación clara y coherente
El uso de convenciones de nomenclatura claras y coherentes para módulos, variables y recursos mejora la legibilidad y la comprensión del código base, lo que facilita que otros trabajen con los módulos y los mantengan.
Aislar dependencias
Debemos evitar el acoplamiento estrecho entre módulos. Cada módulo debe encapsular sus propios recursos y dependencias. Esto asegura que los módulos se puedan reutilizar de forma independiente y promueve un mejor aislamiento y encapsulación.
Control de versiones y registro de módulos
Podemos publicar nuestros módulos en un repositorio controlado por versión o en un registro de módulos. Esto proporciona una ubicación centralizada para compartir y descubrir módulos, lo que garantiza un fácil acceso y control de versiones.
Conclusión
Tomamos una breve introducción a los módulos de Terraform y aprendimos cómo crearlos con un ejemplo simple. Luego, analizamos cómo usar las variables y los resultados con nuestro módulo para mejorar su flexibilidad, reutilización y mantenibilidad. En conclusión, los módulos de Terraform son herramientas poderosas para organizar y simplificar el código de infraestructura. Nos permiten encapsular un conjunto de recursos o configuraciones en componentes reutilizables que promueven la modularidad, la reutilización y la colaboración dentro de nuestros proyectos de infraestructura como código.