0Pricing
Terraform Infrastructure as Code · Lección

Introducción a los módulos de Terraform

Comprenda las ventajas de utilizar módulos para encapsular y reutilizar patrones de infraestructura habituales, y mejorar la organización y mantenibilidad del código.

Introducción a los módulos de Terraform es una lección gratuita de Terraform Infrastructure as Code en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Terraform Infrastructure as Code, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Terraform Infrastructure as Code incluye 4 lecciones en total.

¿Qué son los módulos de Terraform?

Un módulo de Terraform es un paquete independiente de configuraciones de Terraform. Puede considerarlo como una función o una clase de los lenguajes de programación. Permite agrupar recursos relacionados y administrarlos como una sola unidad.

Los módulos le ayudan a organizar el código de su infraestructura y facilitan su administración, especialmente en proyectos grandes.

¿Por qué utilizar módulos de Terraform?

Los módulos ofrecen varias ventajas importantes para su infraestructura como código:

  • Reutilización: Defina una parte de la infraestructura una vez y utilícela varias veces en distintos proyectos o entornos.
  • Organización: Divida configuraciones complejas en componentes más pequeños, manejables y lógicos.
  • Coherencia: Garantice que los recursos se aprovisionen de forma estandarizada cada vez, reduciendo las desviaciones de configuración y los errores.
  • Colaboración: Los equipos pueden desarrollar y compartir módulos, acelerando el desarrollo y manteniendo los estándares.

Estructura de un módulo

Un módulo de Terraform es, esencialmente, un directorio que contiene uno o más archivos .tf. Aunque la estructura es flexible, una estructura habitual incluye:

  • main.tf: Define los recursos principales que crea el módulo.
  • variables.tf: Declara las variables de entrada que personalizan el comportamiento del módulo.
  • outputs.tf: Define los valores de salida que el módulo expone a quienes lo invocan.
  • versions.tf: Especifica las restricciones de versión de Terraform y del proveedor para el módulo.

Esta estructura organizada ayuda a mantener el código ordenado y fácil de comprender.

El código de su primer módulo

Definamos un módulo muy sencillo que cree un bucket de AWS S3. Normalmente, este código se encontraría en su propio directorio, por ejemplo, modules/my_s3_bucket/main.tf.

Este archivo completo podría ejecutarse como módulo raíz para verlo en funcionamiento, pero aquí su objetivo principal es mostrar la estructura interna de un módulo.

provider "aws" {
  region = "us-east-1" # Example region
}

variable "bucket_name" {
  description = "Name for the S3 bucket."
  type        = string
}

variable "acl_setting" {
  description = "ACL for the S3 bucket."
  type        = string
  default     = "private"
}

resource "aws_s3_bucket" "example_bucket" {
  bucket = var.bucket_name
  acl    = var.acl_setting

  tags = {
    Environment = "Dev" # Example tag
  }
}

output "bucket_id" {
  description = "The ID of the S3 bucket."
  value       = aws_s3_bucket.example_bucket.id
}

output "bucket_arn" {
  description = "The ARN of the S3 bucket."
  value       = aws_s3_bucket.example_bucket.arn
}

Entradas del módulo: variables

Las variables de entrada permiten personalizar el comportamiento del módulo sin modificar su código principal. Se definen en un archivo variables.tf dentro del directorio del módulo.

Al invocar un módulo, se pasan valores a estas variables, lo que hace que el módulo sea muy reutilizable en distintos escenarios y entornos. Considérelas como los argumentos de una función.

variable "bucket_name" {
  description = "Name for the S3 bucket."
  type        = string
}

variable "acl_setting" {
  description = "ACL for the S3 bucket."
  type        = string
  default     = "private"
}

Salidas del módulo: exposición de datos

Los valores de salida se utilizan para exponer datos de un módulo a la configuración que lo invoca. Así puede acceder a información importante sobre los recursos creados por el módulo.

Las salidas se definen en un archivo outputs.tf dentro del directorio del módulo y pueden ser referenciadas por otras partes de su configuración de Terraform o incluso por otros módulos.

output "bucket_id" {
  description = "The ID of the S3 bucket."
  value       = aws_s3_bucket.example_bucket.id
}

output "bucket_arn" {
  description = "The ARN of the S3 bucket."
  value       = aws_s3_bucket.example_bucket.arn
}

Invocación de su módulo personalizado

Ahora que hemos definido el módulo my_s3_bucket, invoquémoslo desde una configuración raíz. El atributo source especifica dónde puede encontrar Terraform el módulo.

Para los módulos locales, se trata de una ruta relativa al directorio del módulo. Pasamos valores a las variables de entrada del módulo y podemos acceder a sus salidas expuestas.

provider "aws" {
  region = "us-east-1"
}

module "my_website_bucket" {
  source      = "./modules/my_s3_bucket" # Path to your local module
  bucket_name = "my-unique-website-bucket-12345"
  acl_setting = "public-read"
}

output "website_bucket_arn" {
  description = "ARN of the website S3 bucket."
  value       = module.my_website_bucket.bucket_arn
}

output "website_bucket_id" {
  description = "ID of the website S3 bucket."
  value       = module.my_website_bucket.bucket_id
}

Distintos orígenes de módulos

¡Los módulos no tienen que ser únicamente locales! Terraform puede obtener módulos de distintos orígenes, lo que le proporciona flexibilidad:

  • Rutas locales: ./modules/my_module (como en nuestro ejemplo)
  • Terraform Registry: hashicorp/vpc/aws (módulos disponibles públicamente)
  • Repositorios de Git: git::https://example.com/repo.git
  • Buckets de S3: s3::https://s3-us-west-2.amazonaws.com/example-bucket/module.zip

Terraform Registry es un excelente lugar para encontrar módulos prediseñados y revisados por la comunidad para patrones de infraestructura habituales.

El impacto práctico de los módulos

Imagine que administra cientos de recursos en varios entornos (desarrollo, preparación y producción). Sin módulos, tendría archivos de configuración enormes y repetitivos.

Los módulos le permiten definir una vez un patrón de "servidor web" o "base de datos". Después, solo tiene que invocar ese módulo para cada instancia y pasar distintas variables para la configuración específica de cada entorno. Esto reduce considerablemente los errores, simplifica las actualizaciones y hace que su infraestructura sea realmente escalable.

Comprobación rápida

Ha aprendido sobre la estructura y las ventajas de los módulos de Terraform. Veamos si puede identificar una ventaja clave.

Repaso y próximos pasos

En esta lección, presentamos los módulos de Terraform como herramientas eficaces para organizar y reutilizar el código de su infraestructura. Ha aprendido lo siguiente:

  • Los módulos encapsulan recursos en unidades reutilizables.
  • Mejoran la organización, la coherencia y la reutilización del código.
  • Los módulos utilizan variables.tf para las entradas y outputs.tf para los datos expuestos.
  • Puede invocar módulos desde rutas locales, registros o repositorios de Git.

A continuación, profundizaremos en la creación de sus propios módulos reutilizables y exploraremos patrones y prácticas recomendadas más avanzados.

Preguntas frecuentes

¿La lección «Introducción a los módulos de Terraform» es gratis?

Sí — el texto completo de «Introducción a los módulos de Terraform» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Terraform Infrastructure as Code, actualiza a CoddyKit PRO. El curso de Terraform Infrastructure as Code incluye 4 lecciones en total.

¿Qué aprenderé en «Introducción a los módulos de Terraform»?

Comprenda las ventajas de utilizar módulos para encapsular y reutilizar patrones de infraestructura habituales, y mejorar la organización y mantenibilidad del código. Practicas Terraform Infrastructure as Code con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Terraform Infrastructure as Code?

No se requiere experiencia previa. Terraform Infrastructure as Code en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Introducción a los módulos de Terraform»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Terraform Infrastructure as Code?

Sí. Cada lección de Terraform Infrastructure as Code incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Introducción a los módulos de Terraform
  2. Creación de módulos reutilizables
  3. Uso de espacios de trabajo para entornos
  4. Publicación de módulos en un registro
← Volver a Terraform Infrastructure as Code