Gestión de Outputs en Terraform para Recursos Desplegados

Clase 15 de 37 • Curso de Terraform

Contenido del curso

Infraestructura como Código

Fundamentos de Terraform

Variables y Estado

Bloques y Comandos Útiles

Creación y Gestión de Recursos

Módulos en Terraform

Integración y Despliegue Continuo

Documentación y Recursos

37
Navegación Eficiente en la Documentación de Terraform
08:35 min

Tomar examen

Resumen

¿Cómo gestionar variables de salida en Terraform?

Las variables de salida, conocidas como outputs, son fundamentales en Terraform. Permiten obtener valores específicos de los recursos desplegados. Estos outputs son esenciales para continuar con otras configuraciones o integraciones en proyectos más grandes. Aquí te mostraremos cómo gestionar variables de salida en Terraform de manera eficiente y práctica.

¿Cómo iniciar un proyecto de outputs en Terraform?

Para empezar, es crucial tener un proyecto organizado. Asegúrate de mover tu proyecto actual a una nueva carpeta. Así, no alterarás el proyecto original y podrás experimentar con tranquilidad. Crear un archivo main.tf en esa carpeta es el primer paso crítico.

mkdir outputs
cd outputs
touch main.tf

A continuación, copia los archivos de tu proyecto base como referencia para mantener la consistencia en tu nuevo documento. Esta es la magia de Terraform: la portabilidad y la reutilización del código.

¿Cómo agregar un bloque de output en Terraform?

Agregar un bloque de output al final del despliegue de tus recursos es clave para obtener valores específicos después de su creación. Aquí tienes un ejemplo de cómo hacerlo:

output "nombre_rg_output" {
  value = azurerm_resource_group.mi_grupo_de_recursos.name
}

Este bloque permitirá saber el nombre del grupo de recursos creado. Además, puedes cambiarlo para obtener diferentes datos, como la ubicación o el ID del recurso.

¿Cómo ejecutar el plan y aplicar los cambios en Terraform?

Antes de desplegar, es recomendable saber qué cambios se aplicarán ejecutando el comando terraform plan. Este comando te mostrará los cambios planeados y los outputs esperados.

terraform init
terraform plan -out=plan.out

El archivo plan.out guarda el estado planeado del despliegue, facilitando la revisión antes de aplicar los cambios con terraform apply.

terraform apply plan.out

Después de ejecutar terraform apply, obtendrás el identificador o valor calculado del recurso en el bloque de outputs. Modificar el output para recibir, por ejemplo, el ID, se realiza de forma simple:

value = azurerm_resource_group.mi_grupo_de_recursos.id

¿Cómo gestionar archivos más limpios y escalables?

Crear un archivo separado para tus outputs, como outputs.tf, ayuda a mantener tu proyecto ordenado y facilitan su escalabilidad. De esta manera, el archivo principal main.tf no se sobrecarga y puedes gestionar los outputs cómodamente.

touch outputs.tf

Dentro de outputs.tf, mueve todos los bloques de output que hayas creado anteriormente. Esto es una buena práctica que optimiza tu código:

output "nombre_rg_output" {
  value = azurerm_resource_group.mi_grupo_de_recursos.id
}

Implementar estas estrategias no solo mejora la organización de tu proyecto, sino que facilita la comprensión y el mantenimiento del código a lo largo del tiempo. Practica creando recursos y observando cómo varían tus valores de salida al modificar tus recursos para sacarle el máximo provecho a Terraform en tus proyectos.

Libardo Arturo Arroyave Bustos

student•

Este es un ejemplo más avanzado donde usamos outputs con módulos reutilizables, backend remoto en Azure Storage + Key Vault para proteger el estado, y un pipeline de CI/CD en GitHub Actions que ejecuta init → plan → apply → destroy.

🏗️ Arquitectura del ejemplo

Módulos reutilizables:
- modules/resource-group → crea un Resource Group.
- modules/network → crea una VNet y una Subnet dentro del RG.
Backend remoto seguro:
- Estado (terraform.tfstate) almacenado en un Azure Storage Account.
- Acceso seguro a través de un Azure Key Vault, donde se guarda el storage access key.
Outputs estratégicos:
- Desde el módulo de red exponemos subnet_id, vnet_name.
- Desde el módulo de RG exponemos rg_name.
- Outputs consolidados en el root module para orquestar integraciones.
CI/CD con GitHub Actions:
- Jobs para terraform fmt, init, plan, apply.
- Uso de secrets de GitHub para inyectar credenciales de Azure (ARM_CLIENT_ID, ARM_CLIENT_SECRET, ARM_SUBSCRIPTION_ID, ARM_TENANT_ID).

📂 Estructura de carpetas

infra/
├── modules/
│   ├── resource-group/
│   │   └── main.tf
│   └── network/
│       └── main.tf
├── main.tf
├── variables.tf
├── outputs.tf
├── provider.tf
├── backend.tf
└── .github/
    └── workflows/
        └── terraform-ci.yml

🔑 Configuración del backend remoto (backend.tf)

Aquí definimos que el estado de Terraform viva en Azure Storage:

terraform {
  backend "azurerm" {
    resource_group_name  = "rg-tfstates"
    storage_account_name = "mystorageiac123"
    container_name       = "tfstate"
    key                  = "infra-demo.tfstate"
  }
}

La storage access key no se pone en texto plano, se guarda en Key Vault y se inyecta al pipeline desde GitHub Secrets.

📦 Ejemplo de módulo: resource-group (modules/resource-group/main.tf)

resource "azurerm_resource_group" "rg" {
  name     = var.name
  location = var.location
}

output "rg_name" {
  value = azurerm_resource_group.rg.name
}

🌐 Ejemplo de módulo: network (modules/network/main.tf)

resource "azurerm_virtual_network" "vnet" {
  name                = var.vnet_name
  address_space       = ["10.0.0.0/16"]
  location            = var.location
  resource_group_name = var.rg_name
}

resource "azurerm_subnet" "subnet" {
  name                 = var.subnet_name
  resource_group_name  = var.rg_name
  virtual_network_name = azurerm_virtual_network.vnet.name
  address_prefixes     = ["10.0.1.0/24"]
}

output "subnet_id" {
  value = azurerm_subnet.subnet.id
}

output "vnet_name" {
  value = azurerm_virtual_network.vnet.name
}

🧩 Root module: main.tf

module "rg" {
  source   = "./modules/resource-group"
  name     = var.rg_name
  location = var.location
}

module "network" {
  source     = "./modules/network"
  vnet_name  = "demo-vnet"
  subnet_name = "demo-subnet"
  location   = var.location
  rg_name    = module.rg.rg_name
}

output "infra_summary" {
  value = {
    rg_name   = module.rg.rg_name
    vnet_name = module.network.vnet_name
    subnet_id = module.network.subnet_id
  }
}

🤖 GitHub Actions Workflow (.github/workflows/terraform-ci.yml)

name: Terraform CI/CD

on:
  push:
    branches: [ "main" ]
  pull_request:

jobs:
  terraform:
    runs-on: ubuntu-latest

    env:
      ARM_CLIENT_ID: ${{ secrets.ARM_CLIENT_ID }}
      ARM_CLIENT_SECRET: ${{ secrets.ARM_CLIENT_SECRET }}
      ARM_SUBSCRIPTION_ID: ${{ secrets.ARM_SUBSCRIPTION_ID }}
      ARM_TENANT_ID: ${{ secrets.ARM_TENANT_ID }}

    steps:
      - name: Checkout
        uses: actions/checkout@v3

      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v2

      - name: Terraform Init
        run: terraform init

      - name: Terraform Validate
        run: terraform validate

      - name: Terraform Plan
        run: terraform plan -out=tfplan

      - name: Terraform Apply
        if: github.ref == 'refs/heads/main'
        run: terraform apply -auto-approve tfplan

📊 Resultado esperado

El estado se guarda seguro en Azure Storage.
El pipeline CI/CD despliega la infraestructura automáticamente al hacer push en main.
Los outputs consolidados (infra_summary) aparecen en la salida del pipeline y pueden reutilizarse en otros módulos o integraciones (por ejemplo, pasar el subnet_id a un módulo de AKS o App Service).

🚀 Conclusión

Este ejemplo combina tres piezas críticas en un flujo realista de DevOps en Azure:

Módulos reutilizables → Infraestructura escalable y organizada.
Backend remoto con Key Vault → Seguridad y trabajo en equipo sin conflictos de estado.
Outputs estratégicos en CI/CD → Información lista para integraciones automáticas y despliegues multi-entorno.

Gestión de Outputs en Terraform para Recursos Desplegados

Infraestructura como Código

Despliegue de Infraestructura en la Nube con Terraform

Infraestructura como Código: Implementación con Terraform en Azure

Curso Completo de Terraform: Infraestructura como Código

Instalación de Terraform en Ubuntu usando WSL en Windows

Configuración de Cuenta Azure y Preparación para Terraform

Instalación y Configuración de la Línea de Comandos de Azure en Ubuntu

Prueba Inicial de Terraform con Docker y Visual Studio Code

Fundamentos de Terraform

Configuración de Proveedores en Terraform para Nube Híbrida

Creación de Grupos de Recursos en Azure con Terraform

Uso del comando Terraform Plan para validar configuraciones

Automatización de Despliegue con Terraform: Init, Plan y Apply

Uso de Terraform Destroy para Gestión de Recursos en Azure

Recapitulación de Comandos Básicos en Terraform

Variables y Estado

Automatización de Variables en Terraform para Despliegue en Azure