Gestión de Outputs en Terraform para Recursos Desplegados

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.

Daniel Ortiz

student•

Una pregunta un output podria ser la URL de conexion de una DB o servicio, para algo que sera usado mas adelante?

Platzi

student•

Si necesitara que esto se desplegara y después obtener el valor de salida, aparecería algo así como se va a saber después de aplicar. Podemos utilizar el ID. En lugar de location, pondré punto ID.

Jean Frannlee Rodriguez Tapiero

student•

Hola Daniel, en efecto el output puede ser una URL, recuerda que cada recurso es como un objeto con diferentes atributos. puedes usar el atributo connection_string o propiedades específicas del recurso de base de datos que estés utilizando. Por ejemplo, si es una base de datos de Azure SQL, el output podría definirse así:

output "db_url" { value = azurerm_sql_database.example.connection_string }

Jerson Mosquera Pretelt

student••

También puedes ejecutar:

para refrescar y actualizar valores:

terraform refresh

para ver todos los outputs definidos en tu proyecto:

terraform output

para ver todos los outputs definidos en tu proyecto en formato json:

terraform output -json

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.

Libardo Arturo Arroyave Bustos

student•

🌐 Outputs en Terraform: Cómo gestionar y aprovechar valores de salida en Azure

La lección nos guía por el proceso de trabajar con outputs en Terraform, una pieza clave en la gestión de infraestructura como código. Los outputs permiten exponer información útil de los recursos desplegados —como nombres, ubicaciones o identificadores— para usarlos en etapas posteriores o simplemente verificarlos tras un despliegue. Veamos los puntos más relevantes.

📦 Separación de proyectos y estructura de carpetas

El primer paso mostrado fue crear una carpeta nueva dedicada a outputs para no alterar el proyecto original de comandos básicos. Dentro de esta carpeta se replicaron archivos esenciales (main.tf y variables) para trabajar con un entorno limpio.

Ejemplo práctico:

Carpeta original: comandos-basicos/
Nueva carpeta: outputs/
Archivos copiados: main.tf, variables.tf, terraform.tfvars

Esta organización permite iterar sin riesgo de dañar la infraestructura base.

📝 Definiendo bloques de output en Terraform

El corazón del proceso está en la definición de bloques output dentro de Terraform. Estos sirven para exponer propiedades de recursos ya desplegados.

Ejemplo implementado:

Output del nombre del Resource Group en Azure.
Alternativas mostradas: obtener la location o el id del recurso.

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

Esto permite, tras aplicar la infraestructura, visualizar de inmediato el nombre o identificador del recurso creado.

⚙️ Ejecución paso a paso en la terminal

Se siguió la secuencia habitual de comandos para inicializar, planificar y aplicar la infraestructura:

terraform init → inicializa el proyecto en la nueva carpeta.
terraform plan -out=plan.out → genera un plan de ejecución, usando variables ya definidas.
terraform apply plan.out → despliega los recursos y muestra los outputs.

Durante el proceso, Terraform indica si un output estará disponible inmediatamente o solo después del apply (caso típico del id de un recurso).

Resultado esperado: Al finalizar el apply, se despliega el Resource Group y en la sección de outputs aparece su identificador único.

📑 Mejores prácticas: outputs organizados

Una recomendación clave es separar los outputs en un archivo dedicado (outputs.tf o output.tf). Esto evita sobrecargar el main.tf y facilita la escalabilidad de los proyectos.

Ventajas de esta práctica:

Código más limpio y modular.
Outputs centralizados y fáciles de consultar.
Mantenimiento más sencillo al crecer el proyecto.

Ejemplo:

main.tf → definición de recursos.
outputs.tf → definición de valores de salida.

🧩 Práctica y aprendizaje progresivo

La recomendación final es experimentar creando diferentes recursos y outputs para observar cómo cambian los valores de salida en cada despliegue. Esto entrena la habilidad de identificar qué información es más relevante exponer en entornos reales, como nombres de recursos, ubicaciones, direcciones IP o credenciales generadas dinámicamente.

🚀 Conclusión

El uso de outputs en Terraform es una práctica esencial para cualquier ingeniero de nube. Permite capturar información crítica de los recursos desplegados, facilitar integraciones entre módulos y mantener una infraestructura bien organizada.

Puntos clave para llevarse:

Siempre separar outputs en archivos propios (outputs.tf).
Usar outputs para exponer datos como id, name o location de recursos.
Incorporar terraform plan -out y apply para un ciclo de despliegue más controlado.
Practicar con distintos outputs para entender mejor el flujo de datos en Terraform.

Los outputs no son solo un detalle técnico: son el puente entre lo que Terraform crea y lo que necesitas consumir en tus flujos de trabajo posteriores.