MINI-LAB: Primeros pasos con Terraform y Dynatrace

Tiempo estimado: 1 hora
Dificultad: Media
Objetivo: Entender los fundamentos de Infrastructure as Code (IaC) aplicado a la monitorización

¿Qué vamos a construir?

Un laboratorio mínimo para experimentar con Terraform gestionando la configuración de Dynatrace. Crearemos un dashboard mediante código que podremos destruir y recrear en segundos.

Lo que aprenderás:

  • ✅ Configurar Terraform para Dynatrace
  • ✅ Crear dashboards mediante código
  • ✅ Destruir y recrear infraestructura en segundos
  • ✅ Entender cuándo usar (y cuándo NO usar) IaC

🔧 Requisitos previos

Hardware necesario

  • Sistema operativo: Linux (Ubuntu/Mint), macOS o Windows con WSL
  • RAM: 4GB disponibles (2GB para VM opcional)
  • Disco: 10GB libres

Software necesario

  1. Terraform 1.0+
  2. Cuenta Dynatrace (trial gratuito 15 días)
  3. Opcional: VM con Ubuntu Server + OneAgent (o usar tus hosts existentes)

FASE 1: Instalar Terraform

En Linux (Ubuntu/Mint/Debian)

bash

# Agregar repositorio de HashiCorp
wget -O- https://apt.releases.hashicorp.com/gpg | \
gpg --dearmor | \
sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg

# IMPORTANTE: Si usas Linux Mint, usa "noble" en lugar de $(lsb_release -cs)
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] \
https://apt.releases.hashicorp.com noble main" | \
sudo tee /etc/apt/sources.list.d/hashicorp.list

sudo apt update
sudo apt install terraform

# Verificar instalación
terraform --version

En macOS

bash

# Con Homebrew
brew tap hashicorp/tap
brew install hashicorp/tap/terraform

# Verificar
terraform --version

En Windows

powershell

# Con Chocolatey
choco install terraform

# O descargar binario desde:
# https://www.terraform.io/downloads

FASE 2: Configurar Dynatrace

Paso 2.1: Crear cuenta (si no la tienes)

  1. Ir a: https://www.dynatrace.com/trial
  2. Completar registro
  3. Activar cuenta por email
  4. Anotar la URL de tu tenant: https://XXXXX.live.dynatrace.com

Paso 2.2: Crear API Token

Permisos necesarios para este lab:

Read configuration
Write configuration
Read entities
Read settings
Write settings

Generar y copiar: El token empieza con dt0c01...

⚠️ IMPORTANTE: Guarda este token en un lugar seguro, solo se muestra una vez.

Paso 2.3: Asegurar que tienes al menos un host monitorizando

Opciones:

  • Ya tienes hosts con OneAgent → Listo
  • Crear VM Ubuntu con VirtualBox + OneAgent → Ver anexo
  • Usar contenedor Docker con OneAgent → Ver documentación oficial

Para este lab necesitas al menos 1 host visible en Infrastructure → Hosts.

FASE 3: Crear proyecto Terraform

Paso 3.1: Estructura de directorios

bash

# Crear directorio del proyecto
mkdir -p ~/dynatrace-terraform-lab
cd ~/dynatrace-terraform-lab

# Crear archivos
touch main.tf
touch variables.tf
touch terraform.tfvars
touch dashboard.tf
touch outputs.tf

Paso 3.2: Configurar archivos

Archivo: main.tf

terraform {
  required_version = ">= 1.0"
  
  required_providers {
    dynatrace = {
      source  = "dynatrace-oss/dynatrace"
      version = "~> 1.0"
    }
  }
}

provider "dynatrace" {
  dt_env_url   = var.dynatrace_url
  dt_api_token = var.dynatrace_token
}

Archivo: variables.tf

variable "dynatrace_url" {
  description = "URL de tu tenant Dynatrace"
  type        = string
}

variable "dynatrace_token" {
  description = "API Token de Dynatrace"
  type        = string
  sensitive   = true
}

Archivo: terraform.tfvars

#  REEMPLAZAR con tus valores reales
dynatrace_url   = "https://XXXXX.live.dynatrace.com"
dynatrace_token = "dt0c01.XXXXXXXXXXXXXXXXXXXXXXXXXX"

CRÍTICO: Este archivo contiene credenciales. NO subirlo a Git.

Archivo: dashboard.tf

resource "dynatrace_json_dashboard" "lab_dashboard" {
  contents = jsonencode({
    dashboardMetadata = {
      name   = "Terraform Lab - Dashboard"
      shared = true
      owner  = "terraform"
    }
    tiles = [
      {
        name       = "CPU Usage"
        tileType   = "DATA_EXPLORER"
        configured = true
        bounds = {
          top    = 0
          left   = 0
          width  = 608
          height = 304
        }
        queries = [
          {
            id               = "A"
            metric           = "builtin:host.cpu.usage"
            spaceAggregation = "AVG"
            timeAggregation  = "DEFAULT"
            splitBy          = ["dt.entity.host"]
            enabled          = true
          }
        ]
        visualConfig = {
          type = "GRAPH_CHART"
        }
      },
      {
        name       = "Memory Usage"
        tileType   = "DATA_EXPLORER"
        configured = true
        bounds = {
          top    = 0
          left   = 608
          width  = 608
          height = 304
        }
        queries = [
          {
            id               = "A"
            metric           = "builtin:host.mem.usage"
            spaceAggregation = "AVG"
            timeAggregation  = "DEFAULT"
            splitBy          = ["dt.entity.host"]
            enabled          = true
          }
        ]
        visualConfig = {
          type = "GRAPH_CHART"
        }
      }
    ]
  })
}

Archivo: outputs.tf

output "dashboard_id" {
  description = "ID del dashboard creado"
  value       = dynatrace_json_dashboard.lab_dashboard.id
}

output "dashboard_url" {
  description = "URL directa al dashboard"
  value       = "${var.dynatrace_url}/#dashboard;id=${dynatrace_json_dashboard.lab_dashboard.id}"
}

Archivo: .gitignore

bash

# Proteger archivos sensibles
terraform.tfvars
*.tfstate*
.terraform/
.terraform.lock.hcl

FASE 4: Ejecutar Terraform

Paso 4.1: Inicializar proyecto

bash

cd ~/dynatrace-terraform-lab

# Descargar el provider de Dynatrace
terraform init

Salida esperada:

Initializing the backend...
Initializing provider plugins...
- Finding dynatrace-oss/dynatrace versions matching "~> 1.0"...
- Installing dynatrace-oss/dynatrace v1.x.x...

Terraform has been successfully initialized!

Paso 4.2: Validar configuración

bash

# Formatear código
terraform fmt

# Validar sintaxis
terraform validate

Salida esperada:

Success! The configuration is valid.

Paso 4.3: Ver el plan de ejecución

bash

terraform plan

Salida esperada:

Terraform will perform the following actions:

  # dynatrace_json_dashboard.lab_dashboard will be created
  + resource "dynatrace_json_dashboard" "lab_dashboard" {
      + contents = jsonencode(...)
      + id       = (known after apply)
    }

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

Paso 4.4: Aplicar cambios (crear recursos)

bash

terraform apply

Terraform preguntará confirmación:

Do you want to perform these actions?
  Enter a value:

Escribir: yes

Salida esperada:

dynatrace_json_dashboard.lab_dashboard: Creating...
dynatrace_json_dashboard.lab_dashboard: Creation complete after 2s

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

Outputs:

dashboard_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
dashboard_url = "https://xxxxx.live.dynatrace.com/#dashboard;id=xxxxx"

FASE 5: Verificar en Dynatrace

Verificación 1: Dashboard creado

1. Dynatrace UI → Dashboards
2. Filtro: Show all tenant dashboards (activar)
3. Buscar: "Terraform Lab - Dashboard"
4. Abrir → Debe mostrar 2 tiles con métricas de CPU y Memoria

Verificación 2: Métricas mostrándose

El dashboard debe mostrar gráficas de:

  • ✅ CPU Usage de tus hosts
  • ✅ Memory Usage de tus hosts

EXPERIMENTOS: Ver Terraform en acción

Experimento 1: Modificar el dashboard

bash

# Editar dashboard.tf
nano dashboard.tf

# Cambiar línea 5:
name = "Terraform Lab - Dashboard v2.0"

# Guardar y aplicar
terraform apply
# Escribir: yes

# Verificar en Dynatrace → El nombre cambió automáticamente

Experimento 2: Añadir un tercer tile (Disco)

Editar dashboard.tf y añadir después del tile de Memory:

      ,
      {
        name       = "Disk Usage"
        tileType   = "DATA_EXPLORER"
        configured = true
        bounds = {
          top    = 304
          left   = 0
          width  = 608
          height = 304
        }
        queries = [
          {
            id               = "A"
            metric           = "builtin:host.disk.usedPct"
            spaceAggregation = "AVG"
            timeAggregation  = "DEFAULT"
            splitBy          = ["dt.entity.host"]
            enabled          = true
          }
        ]
        visualConfig = {
          type = "GRAPH_CHART"
        }
      }

Aplicar:

bash

terraform apply
# Verificar → Ahora hay 3 tiles

Experimento 3: LO MÁS IMPRESIONANTE – Destruir todo

bash

terraform destroy
# Escribir: yes

# Verificar en Dynatrace → El dashboard DESAPARECIÓ

Experimento 4: Recrear en segundos

bash

terraform apply
# Escribir: yes

# Verificar en Dynatrace → El dashboard VOLVIÓ exactamente igual

Esto es Infrastructure as Code: Destruir y recrear infraestructura en segundos.

Comandos clave de Terraform

bash

# Inicializar proyecto (solo una vez)
terraform init

# Formatear código
terraform fmt

# Validar sintaxis
terraform validate

# Ver qué cambios se aplicarán (sin ejecutar)
terraform plan

# Aplicar cambios (crear/modificar recursos)
terraform apply

# Destruir TODOS los recursos gestionados
terraform destroy

# Ver estado actual
terraform show

# Listar recursos gestionados
terraform state list

¿Cuándo usar Terraform con Dynatrace?

✅ Terraform es ÚTIL cuando:

  • Gestionas 50+ hosts con configuraciones similares
  • Necesitas múltiples entornos idénticos (dev, staging, prod)
  • Equipos grandes que deben colaborar en la configuración
  • Requieres auditoría y control de cambios (Git)
  • Despliegues repetitivos frecuentes
  • Automatización CI/CD completa
  • Necesitas replicar configuraciones entre tenants

Ejemplo real: Empresa con 200 microservicios que despliega 5 entornos al día.

Terraform es OVERKILL cuando:

  • Gestionas menos de 20 hosts
  • Configuración única o que cambia poco
  • Equipo pequeño (1-3 personas)
  • No necesitas replicar entornos
  • Proyectos temporales o pruebas
  • La configuración manual en UI es más rápida

Ejemplo real: Startup con 5 servidores que añade 1-2 al mes.

Análisis coste/beneficio

Tiempo de setup manual en Dynatrace UI:

  • Crear dashboard: 5 minutos
  • Configurar 3 alertas: 10 minutos
  • Total: 15 minutos por servidor

Tiempo con Terraform (primera vez):

  • Aprender sintaxis del provider: 3-5 horas
  • Crear configuración base: 2-3 horas
  • Debugging: 1-2 horas
  • Total primera vez: 6-10 horas

Break-even point:

  • Vale la pena si gestionas 20+ servidores con configuración idéntica
  • O si despliegas/destruyes entornos frecuentemente

Alternativas más simples

Opción 1: Scripts bash + API de Dynatrace

bash

#!/bin/bash
# deploy-dashboard.sh

curl -X POST "https://tenant.dynatrace.com/api/config/v1/dashboards" \
  -H "Authorization: Api-Token $DYNATRACE_TOKEN" \
  -H "Content-Type: application/json" \
  -d @dashboard-template.json

Ventajas:

  • Más simple que Terraform
  • Sin curva de aprendizaje
  • Suficiente para 5-20 servidores

Opción 2: Dynatrace Monaco

bash

# Herramienta oficial de Dynatrace para configuración como código
monaco deploy -e environments.yaml

Ventajas:

  • Específico para Dynatrace (más simple)
  • Menos bugs que el provider de Terraform
  • Documentación oficial completa

Documentación: https://dynatrace-oss.github.io/dynatrace-configuration-as-code/

Recursos para ampliar conocimientos

Documentación oficial

Terraform:

Terraform Provider Dynatrace:

Dynatrace API:

Dynatrace Configuration as Code:

Tutoriales y ejemplos

Certificaciones

  • HashiCorp Certified: Terraform Associate
  • Dynatrace Associate Certification
  • Dynatrace Professional Certification

Conclusiones del mini-lab

Lo que has conseguido:

  • ✅ Entender los fundamentos de Infrastructure as Code
  • ✅ Configurar Terraform con el provider de Dynatrace
  • ✅ Crear y gestionar dashboards mediante código
  • ✅ Experimentar con el ciclo: plan → apply → destroy
  • ✅ Comprender cuándo usar y cuándo NO usar Terraform

Lo que has aprendido:

Conceptos:

  • Infrastructure as Code (IaC)
  • Declarativo vs Imperativo
  • State management
  • Idempotencia
  • Providers y recursos

Skills técnicas:

  • Sintaxis HCL (HashiCorp Configuration Language)
  • API Tokens y autenticación
  • Terraform workflow básico
  • JSON encoding en Terraform

Valor profesional:

Aunque este lab es básico, los conceptos aprendidos son transferibles:

  • Terraform funciona igual con AWS, Azure, GCP, Kubernetes…
  • IaC es un skill muy demandado en DevOps/SRE
  • Entiendes cómo trabajan equipos enterprise

Limitaciones encontradas en este lab

Aspectos complejos del provider dynatrace-oss/dynatrace:

  1. Management Zones: Sintaxis compleja con múltiples bloques anidados
  2. Metric Events (alertas): Muchos parámetros obligatorios
  3. Filtros avanzados: La sintaxis de entity selectors en JSON es compleja
  4. Documentación: Algunos recursos están poco documentados con ejemplos

Recomendación: Para configuraciones complejas, considera usar:

  • Monaco (herramienta oficial de Dynatrace)
  • Scripts con la API REST directamente
  • Configuración manual para casos únicos

Recomendación final

Para tu caso específico:

Si gestionas 2-10 hosts/mes: → Configuración manual en UI (15 min/host)

Si gestionas 10-50 hosts/mes: → Scripts bash + API (más simple que Terraform)

Si gestionas 50+ hosts o múltiples entornos: → Terraform o Monaco (inversión de tiempo justificada)

El valor real de este lab:

No es necesariamente usar Terraform en producción mañana, sino:

  • ✅ Entender el paradigma IaC
  • ✅ Saber que existe y cómo funciona
  • ✅ Poder decidir cuándo usarlo
  • ✅ Tener base para aprenderlo cuando lo necesites

Anexo: Instalación rápida de host de prueba

Si no tienes hosts monitorizando, aquí una opción rápida:

Opción A: VM Ubuntu Server + VirtualBox

bash

# 1. Descargar Ubuntu Server 24.04 LTS
wget https://releases.ubuntu.com/24.04.1/ubuntu-24.04.1-live-server-amd64.iso

# 2. Crear VM en VirtualBox:
# - 2GB RAM, 20GB disco, NAT/Bridge
# - Instalar Ubuntu Server (minimal)
# - Habilitar SSH

# 3. Instalar OneAgent (comando desde Dynatrace UI):
wget -O Dynatrace-OneAgent-Linux.sh "https://TENANT.live.dynatrace.com/api/v1/deployment/..."
sudo /bin/sh Dynatrace-OneAgent-Linux.sh

Opción B: Contenedor Docker (más rápido)

bash

# Ejecutar contenedor con OneAgent
docker run -d \
  --name dynatrace-lab \
  -e DT_TENANT=https://XXXXX.live.dynatrace.com \
  -e DT_PAAS_TOKEN=dt0c01.XXXXXXX \
  ubuntu:22.04

# Ver documentación oficial:
# https://docs.dynatrace.com/docs/setup-and-configuration/setup-on-container-platforms

Checklist final

Antes de terminar el lab, verifica:

  • Dashboard visible en Dynatrace UI
  • Puedes modificar el código y aplicar cambios
  • terraform destroy elimina el dashboard
  • terraform apply lo vuelve a crear
  • Entiendes cuándo usar Terraform y cuándo no
  • Has guardado los archivos .tf como referencia futura

Archivos del laboratorio

Todos los archivos usados en este lab:

  • main.tf – Configuración del provider
  • variables.tf – Definición de variables
  • terraform.tfvars – Valores de variables (NO subir a Git)
  • dashboard.tf – Recurso del dashboard
  • outputs.tf – Salidas del proyecto
  • .gitignore – Protección de archivos sensibles

Guardar en: ~/dynatrace-terraform-lab/

Siguientes pasos sugeridos

  1. Experimentar: Modifica el dashboard, añade tiles, cambia métricas
  2. Versionar: Inicializa un repositorio Git local
  3. Documentar: Anota tus aprendizajes
  4. Decidir: ¿Necesitas Terraform para tu caso de uso real?
  5. Ampliar: Si la respuesta es sí, explora la documentación oficial

¡Felicidades por completar el mini-lab!

Has dado tus primeros pasos en Infrastructure as Code aplicado a la observabilidad. Aunque este es solo un pequeño atisbo de lo que se puede hacer, tienes las bases para decidir si Terraform es la herramienta adecuada para tu caso de uso.

Autor: Mini-Labs Observa Sistemas
Fecha: Enero 2026
Versión: 1.0

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.

ACEPTAR
Aviso de cookies