Uso de Variables en Terraform

Introducción

Terraform es una herramienta potente para construir, modificar y versionar infraestructura de forma segura y eficiente. Una característica clave que hace que las configuraciones de Terraform sean flexibles y reutilizables es el uso de variables de entrada (input variables). Las variables permiten parametrizar sus configuraciones, de modo que puede evitar codificar valores (hardcoding) y personalizar fácilmente los despliegues sin modificar el código fuente.

En este laboratorio, aprenderá los fundamentos del uso de variables de Terraform. Creará una configuración simple que genera un archivo local. El nombre y el contenido de este archivo se determinarán mediante variables que usted definirá y pasará durante la ejecución de sus comandos de Terraform.

Al finalizar este laboratorio, comprenderá:

• Cómo declarar variables en un archivo .tf.
• Cómo hacer referencia a variables dentro de un bloque de recurso (resource block).
• Cómo suministrar valores para sus variables al ejecutar terraform apply.

Crear el archivo variables.tf para las definiciones de variables

En este paso, creará un archivo dedicado para albergar sus declaraciones de variables. Aunque puede declarar variables en cualquier archivo .tf, es una convención común colocarlas en un archivo llamado variables.tf. Esta práctica ayuda a mantener su proyecto organizado y facilita a otros la comprensión de qué valores de entrada espera su configuración.

Todo su trabajo se realizará en el directorio ~/project. Primero, cree el archivo variables.tf usando el comando touch.

touch variables.tf

Puede verificar que el archivo se ha creado listando el contenido del directorio:

ls

Debería ver variables.tf en la salida.

variables.tf

Por ahora, este archivo está vacío. En los siguientes pasos, agregará definiciones de variables en él.

Definir la variable de tipo cadena (string) para el nombre del archivo

En este paso, definirá su primera variable. Esta variable se utilizará para especificar el nombre del archivo que Terraform creará.

Las variables se declaran utilizando un bloque variable. Cada bloque define una única variable de entrada. Definamos una variable llamada filename.

Abra el archivo variables.tf que creó en el paso anterior usando el editor nano.

nano variables.tf

Ahora, agregue el siguiente código al archivo. Este código declara una variable llamada filename, especifica su tipo como string (cadena) e incluye una descripción útil.

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

• variable "filename": Esto inicia la declaración de una variable llamada filename.
• description: Este argumento opcional proporciona una descripción legible por humanos del propósito de la variable.
• type: Este argumento especifica el tipo de dato para la variable. Aquí, usamos string para indicar que aceptará valores de texto.

Después de agregar el código, guarde el archivo y salga de nano presionando Ctrl+X, seguido de Y, y luego Enter.

Definir la variable de tipo cadena (string) para el contenido

En este paso, definirá una segunda variable para almacenar el contenido que se escribirá en el archivo. Esto sigue el mismo patrón que el paso anterior.

Abra el archivo variables.tf nuevamente con nano.

nano variables.tf

Agregue el siguiente bloque variable debajo de la definición de la variable filename que añadió anteriormente.

variable "content" {
  description = "The content to write into the file."
  type        = string
}

Su archivo variables.tf completo debería verse ahora así:

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

variable "content" {
  description = "The content to write into the file."
  type        = string
}

Esto define dos parámetros de entrada para su configuración de Terraform: uno para el nombre del archivo y otro para su contenido.

Guarde el archivo y salga de nano (Ctrl+X, Y, Enter).

Referenciar variables en el bloque de recurso local_file

En este paso, creará el archivo de configuración principal de Terraform, main.tf, y utilizará las variables que acaba de definir. Usará el recurso local_file, que forma parte del proveedor hashicorp/local, para crear un archivo en el sistema de archivos local.

Primero, cree un nuevo archivo llamado main.tf.

nano main.tf

Ahora, agregue la siguiente configuración al archivo main.tf.

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

resource "local_file" "my_file" {
  filename = var.filename
  content  = var.content
}

Analicemos esta configuración:

• terraform { ... }: Este bloque configura los ajustes de Terraform, incluidos los proveedores requeridos. Le estamos indicando a Terraform que nuestra configuración necesita el proveedor local.
• resource "local_file" "my_file": Esto define un recurso de tipo local_file y le asigna un nombre local my_file.
• filename = var.filename: Aquí es donde se hace referencia a una variable. El prefijo var. seguido del nombre de la variable (filename) le indica a Terraform que utilice el valor de la variable filename para este argumento.
• content = var.content: De manera similar, esto asigna el valor de la variable content al argumento content del recurso.

Después de agregar el código, guarde el archivo y salga de nano (Ctrl+X, Y, Enter).

Ejecutar terraform apply con los valores de las variables

En este paso final, ejecutará su configuración de Terraform y proporcionará valores para sus variables.

Primero, necesita inicializar el directorio de trabajo de Terraform. El comando terraform init descarga e instala los proveedores definidos en la configuración (en nuestro caso, el proveedor local).

Ejecute el siguiente comando:

terraform init

Debería ver una salida que indica que Terraform se ha inicializado correctamente.

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!
...

Ahora, puede aplicar la configuración. Para pasar valores a sus variables, puede usar la bandera (flag) de línea de comandos -var. También usaremos la bandera -auto-approve para omitir la solicitud de confirmación interactiva.

Ejecute el comando terraform apply con valores para filename y content:

terraform apply -var="filename=hello.txt" -var="content=Hello, Terraform Variables." -auto-approve

Terraform ahora ejecutará el plan y creará el archivo. La salida se verá similar a esta:

Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  ## local_file.my_file will be created
  + resource "local_file" "my_file" {
      + content              = "Hello, Terraform Variables."
      + directory_permission = "0777"
      + file_permission      = "0777"
      + filename             = "hello.txt"
      + id                   = "..."
    }

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

local_file.my_file: Creating...
local_file.my_file: Creation complete after 0s [id=...]

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

Para verificar que todo funcionó, use el comando cat para mostrar el contenido del archivo recién creado.

cat hello.txt

Debería ver el contenido que proporcionó en la variable:

Hello, Terraform Variables.

¡Felicidades! Ha utilizado con éxito las variables de Terraform para crear un archivo.

Resumen

En este laboratorio, ha aprendido el flujo de trabajo fundamental para usar variables en Terraform. Ha parametrizado con éxito una configuración, haciéndola más dinámica y reutilizable.

Usted ha aprendido a:

• Organizar las declaraciones de variables en un archivo dedicado variables.tf.
• Declarar variables usando el bloque variable, especificando su type (tipo) y description (descripción).
• Referenciar variables dentro de bloques de recursos usando la sintaxis var.<nombre_de_la_variable>.
• Inicializar un proyecto de Terraform con terraform init para descargar los proveedores necesarios.
• Suministrar valores de variables en tiempo de ejecución usando la bandera -var con el comando terraform apply.

Este conocimiento es un bloque de construcción crucial para crear infraestructura como código (Infrastructure as Code) más compleja y modular con Terraform.