El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Creando Módulos

Siguiente ►
►

En este tema, aprenderemos cómo crear módulos en Terraform. Los módulos son una forma de organizar y reutilizar el código de Terraform, lo que facilita la gestión de infraestructuras complejas. Vamos a cubrir los siguientes puntos:

  1. ¿Qué es un módulo en Terraform?
  2. Estructura de un módulo
  3. Creación de un módulo simple
  4. Uso de variables y salidas en módulos
  5. Ejemplo práctico: Módulo de red en AWS
  6. Ejercicios prácticos

  1. ¿Qué es un módulo en Terraform?

Un módulo en Terraform es un conjunto de archivos de configuración que se agrupan en una carpeta. Los módulos permiten reutilizar configuraciones y organizarlas de manera lógica. Cada configuración de Terraform utiliza al menos un módulo, el módulo raíz, que puede llamar a otros módulos.

Ventajas de usar módulos:

  • Reutilización: Puedes reutilizar configuraciones en diferentes proyectos.
  • Organización: Facilita la organización del código.
  • Mantenimiento: Simplifica el mantenimiento y las actualizaciones.

  1. Estructura de un módulo

Un módulo típico de Terraform tiene la siguiente estructura:

module_name/
├── main.tf
├── variables.tf
├── outputs.tf
└── README.md
  • main.tf: Contiene los recursos y la lógica principal del módulo.
  • variables.tf: Define las variables que el módulo acepta como entrada.
  • outputs.tf: Define las salidas que el módulo produce.
  • README.md: Documentación del módulo.

  1. Creación de un módulo simple

Vamos a crear un módulo simple que despliegue una instancia de EC2 en AWS.

Paso 1: Crear la estructura del módulo

Crea una carpeta llamada ec2_instance y dentro de ella, crea los archivos main.tf, variables.tf y outputs.tf.

Paso 2: Definir los recursos en main.tf

// main.tf
provider "aws" {
  region = var.region
}

resource "aws_instance" "example" {
  ami           = var.ami
  instance_type = var.instance_type

  tags = {
    Name = var.instance_name
  }
}

Paso 3: Definir las variables en variables.tf

// variables.tf
variable "region" {
  description = "The AWS region to deploy the instance"
  type        = string
}

variable "ami" {
  description = "The AMI ID to use for the instance"
  type        = string
}

variable "instance_type" {
  description = "The type of instance to deploy"
  type        = string
}

variable "instance_name" {
  description = "The name tag for the instance"
  type        = string
}

Paso 4: Definir las salidas en outputs.tf

// outputs.tf
output "instance_id" {
  description = "The ID of the EC2 instance"
  value       = aws_instance.example.id
}

output "public_ip" {
  description = "The public IP of the EC2 instance"
  value       = aws_instance.example.public_ip
}

  1. Uso de variables y salidas en módulos

Las variables permiten parametrizar los módulos, haciéndolos más flexibles y reutilizables. Las salidas permiten exportar valores importantes del módulo para que puedan ser utilizados en otras partes de la configuración.

Ejemplo de uso de variables

En el archivo variables.tf, definimos las variables que el módulo acepta. Estas variables se pueden pasar cuando se llama al módulo desde otra configuración.

Ejemplo de uso de salidas

En el archivo outputs.tf, definimos las salidas que el módulo produce. Estas salidas se pueden utilizar en otras configuraciones que llamen al módulo.

  1. Ejemplo práctico: Módulo de red en AWS

Vamos a crear un módulo más complejo que configure una red en AWS, incluyendo una VPC, subredes y una gateway de internet.

Paso 1: Crear la estructura del módulo

Crea una carpeta llamada network y dentro de ella, crea los archivos main.tf, variables.tf y outputs.tf.

Paso 2: Definir los recursos en main.tf

// main.tf
resource "aws_vpc" "main" {
  cidr_block = var.vpc_cidr
}

resource "aws_subnet" "subnet" {
  count             = length(var.subnet_cidrs)
  vpc_id            = aws_vpc.main.id
  cidr_block        = element(var.subnet_cidrs, count.index)
  availability_zone = element(var.availability_zones, count.index)
}

resource "aws_internet_gateway" "gw" {
  vpc_id = aws_vpc.main.id
}

Paso 3: Definir las variables en variables.tf

// variables.tf
variable "vpc_cidr" {
  description = "The CIDR block for the VPC"
  type        = string
}

variable "subnet_cidrs" {
  description = "A list of CIDR blocks for the subnets"
  type        = list(string)
}

variable "availability_zones" {
  description = "A list of availability zones for the subnets"
  type        = list(string)
}

Paso 4: Definir las salidas en outputs.tf

// outputs.tf
output "vpc_id" {
  description = "The ID of the VPC"
  value       = aws_vpc.main.id
}

output "subnet_ids" {
  description = "The IDs of the subnets"
  value       = aws_subnet.subnet[*].id
}

output "internet_gateway_id" {
  description = "The ID of the internet gateway"
  value       = aws_internet_gateway.gw.id
}

  1. Ejercicios prácticos

Ejercicio 1: Crear un módulo de S3

Objetivo: Crear un módulo que despliegue un bucket de S3 en AWS.

Instrucciones:

  1. Crea una carpeta llamada s3_bucket.
  2. Dentro de la carpeta, crea los archivos main.tf, variables.tf y outputs.tf.
  3. Define un recurso aws_s3_bucket en main.tf.
  4. Define las variables necesarias en variables.tf.
  5. Define las salidas en outputs.tf.

Solución:

// main.tf
resource "aws_s3_bucket" "bucket" {
  bucket = var.bucket_name
  acl    = var.acl
}

// variables.tf
variable "bucket_name" {
  description = "The name of the S3 bucket"
  type        = string
}

variable "acl" {
  description = "The ACL for the S3 bucket"
  type        = string
  default     = "private"
}

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

Ejercicio 2: Usar el módulo de S3

Objetivo: Usar el módulo de S3 creado en el ejercicio anterior en una configuración de Terraform.

Instrucciones:

  1. Crea una nueva carpeta para la configuración.
  2. Dentro de la carpeta, crea un archivo main.tf.
  3. Llama al módulo de S3 y pasa las variables necesarias.

Solución:

// main.tf
module "s3_bucket" {
  source      = "../s3_bucket"
  bucket_name = "my-unique-bucket-name"
  acl         = "public-read"
}

Conclusión

En esta sección, hemos aprendido cómo crear y utilizar módulos en Terraform. Los módulos son una herramienta poderosa para organizar y reutilizar configuraciones, lo que facilita la gestión de infraestructuras complejas. Hemos visto cómo definir recursos, variables y salidas en un módulo, y hemos creado un módulo práctico para desplegar una red en AWS. Además, hemos realizado ejercicios prácticos para reforzar los conceptos aprendidos.

En el próximo tema, exploraremos cómo usar módulos existentes del registro de módulos de Terraform.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados