Domina la REST API de Dynatrace: Automatiza tu Monitorización con Python

1. ¿Qué es la API REST de Dynatrace y para qué sirve?

La API REST de Dynatrace es un conjunto de servicios HTTP(S) que permiten automatizar tareas de monitorización, extraer datos de rendimiento y configuración, y crear integraciones con herramientas de terceros. Gracias a esta API puedes:

• Automatizar la gestión de tus entornos Dynatrace (por ejemplo, crear o actualizar dashboards, gestionar alertas, etiquetar entidades).
• Extraer métricas y series temporales para análisis históricos o en sistemas externos de Business Intelligence.
• Consultar eventos y problemas detectados por la plataforma.
• Obtener topologías de infraestructura y relaciones entre servicios.
• Ingestar nuevos datos o eventos personalizados (Custom events, Log ingestion, OpenTelemetry).
• Gestionar usuarios y tokens de acceso (API tokens).

La comunicación se realiza siempre por HTTPS y requiere un token de acceso con los permisos necesarios. Cada endpoint cubre un dominio funcional distinto (métricas, eventos, configuración, logs, etc.) y está documentado en la referencia oficial de Dynatrace docs.dynatrace.com.

2. Autenticación y estructura básica de la API

1. Generación del API token
   • En tu entorno Dynatrace, ve a Settings > Integration > Dynatrace API y genera un nuevo token, asignándole los scopes (permisos) adecuados para las operaciones que vas a realizar (por ejemplo, metrics.read, entities.read, events.ingest, config.read) GitHub.
2. URL base
   • Para Dynatrace SaaS: ruby
     https://<tu-entorno>.live.dynatrace.com/api/v2/
   • Para Dynatrace Managed: perl
     https://<host>/e/<tenant-id>/api/v2/
3. Encabezados HTTP http
   Authorization: Api-Token <TU_API_TOKEN> Content-Type: application/json
4. Códigos de respuesta
   • 200 OK, 201 Created, 204 No Content
   • 400 Bad Request, 401 Unauthorized, 404 Not Found
   • 429 Too Many Requests (límite de uso) docs.dynatrace.com

3. Principales endpoints y tipos de datos consultables

A continuación, un resumen de los dominios de datos accesibles vía API:

Cada uno de estos endpoints admite múltiples parámetros de filtrado (por ejemplo, rango de tiempo, entidades específicas) que permiten extraer sólo la información necesaria docs.dynatrace.com docs.dynatrace.com.

4. Ejemplo de uso desde Python

Para ilustrar cómo consumir la API REST de Dynatrace desde Python, veamos un script básico que:

1. Obtiene las últimas muestras de una métrica.
2. Formatea el JSON de respuesta para hacerlo legible.

# python
import requests
import json

# Parámetros de conexión
DT_ENV = "mi-entorno"
DT_TOKEN = "TU_API_TOKEN"
BASE_URL = f"https://{DT_ENV}.live.dynatrace.com/api/v2"

# Endpoint de series temporales (timeseries)
metric_id = "builtin:host.cpu.usage"
params = {
    "metricSelector": f"{metric_id}.avg",
    "resolution": "Inf",
    "from": "now-1h",
    "to": "now"
}

headers = {
    "Authorization": f"Api-Token {DT_TOKEN}",
    "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/metrics/query", headers=headers, params=params)
data = response.json()

# Mostrar JSON sin procesar
print(json.dumps(data, indent=2))

• requests.get: ejecuta la llamada al API.
• Parámetros: metricSelector define la métrica y la función de agregación; from y to acotan el periodo.
• json.dumps(indent=2): formatea el JSON con sangrías para mejorar la legibilidad.

Este mismo enfoque sirve para cualquier endpoint: basta con cambiar la URL, los parámetros y el procesamiento de la respuesta GitHub.

5. Mejoras en la legibilidad de los datos JSON

Más allá de json.dumps, puedes usar bibliotecas de Python para tabular o explorar los datos:

• pandas.json_normalize: convierte una estructura JSON anidada en un DataFrame plano.
• Exportación a CSV o Excel: python
  import pandas as pd
df = pd.json_normalize(data, record_path=['result', 'data'], meta=['metricId']) df.to_csv('metricas.csv', index=False)
• Uso interactivo: Jupyter notebooks permiten visualizar DataFrames con estilo.

Estas técnicas facilitan el análisis posterior en herramientas de BI o en hojas de cálculo.

6. Limitaciones y cuotas de uso

Aunque la API de Dynatrace es muy poderosa, existen limitaciones derivadas de:

1. Tamaño de payload
   • Límite general de 1 MiB por petición (varía según el endpoint: logs hasta 10 MiB, symbol upload hasta 500 MiB descomprimido) docs.dynatrace.com.
2. Límites de tasa (rate limits)
   • En Dynatrace SaaS, el límite es de 50 peticiones por minuto por entorno, compartido entre todos los tokens y clientes. Intentos adicionales devuelven 429 Too Many Requests hasta que se restablezca el contador community.dynatrace.comDynatrace.
   • En Dynatrace Managed, no se aplica este límite (ya que corre en tu propio data center).
3. Retención y granularidad de datos
   • Algunas métricas clásicas pierden granularidad tras 14 días. Para mayor capacidad, Dynatrace ofrece Metrics powered by Grail con retención configurable hasta 10 años y mayor volumen de datos docs.dynatrace.com.
4. Complejidad de filtros
   • Consultas muy amplias (por ejemplo, todas las entidades) pueden ser lentas o saturar el entorno. Es recomendable usar filtros por host, service, tag o entidad padre para reducir el volumen de datos retornados Dynatrace.

7. Comparativa con Data Explorer y Notebooks

Dynatrace ofrece en su UI dos formas interactivas de consulta:

1. Data Explorer
   • Interfaz gráfica para consultas ad-hoc de métricas y logs.
   • Permite combinar series temporales, aplicar agregaciones y visualizar gráficos en tiempo real.
   • No requiere escritura de código; ideal para diagnósticos rápidos.
2. Notebooks
   • Documentos interactivos que combinan texto, consultas y visualizaciones (basados en un subconjunto de la API de documentos y de la API de métricas).
   • Permiten compartir análisis reproducibles dentro de Dynatrace.

Diferencias clave con la API REST:

Dynatrace recomienda usar la API REST para:

• Integraciones con plataformas de CI/CD (ej. crear entornos, configurar alertas).
• Extracción automática de datos para informes externos.
• Scripting de tareas repetitivas (rotación de tokens, generación de tags).
• Orquestación con herramientas externas (Terraform, Ansible, etc.) docs.dynatrace.com.

Mientras que Data Explorer y Notebooks están más orientados a:

• Investigaciones puntuales de rendimiento.
• Visualización rápida de datos en la consola.
• Documentar procesos de resolución de problemas.

8. Buenas prácticas al usar la API

• Cachear información estática (topologías, metadatos) para no volver a consultarla cada vez Dynatrace.
• Distribuir las consultas a lo largo del tiempo para evitar picos de carga (por ejemplo, escalonar reportes mensuales).
• Emplear paginación y filtros para procesar grandes volúmenes de datos en lotes pequeños.
• Obedecer las cabeceras de rate limit (x-ratelimit-remaining, x-ratelimit-reset) y aplicar retries exponenciales al recibir 429 Dynatrace.
• Limitar la retención de datos externos: si sólo necesitas análisis de las últimas 24 horas, acota el rango de consulta.

9. Ejemplo avanzado: integración en un Notebook de Python

A continuación, un esqueleto de Notebook que podrías ejecutar localmente (o en JupyterHub) para:

1. Conectar a la API.
2. Extraer métricas de varias entidades.
3. Tabular y visualizar datos.

# python
import requests, json
import pandas as pd
import matplotlib.pyplot as plt

# Configuración
ENV = "mi-entorno"
TOKEN = "TU_API_TOKEN"
BASE = f"https://{ENV}.live.dynatrace.com/api/v2"
HEADERS = {"Authorization": f"Api-Token {TOKEN}"}

# Función de consulta de métricas
def consulta_metricas(metric_id, host_id, desde, hasta):
    params = {
        "metricSelector": f"{metric_id}.avg:splitBy():fold",
        "from": desde,
        "to": hasta,
        "entity": host_id
    }
    r = requests.get(f"{BASE}/metrics/query", headers=HEADERS, params=params)
    r.raise_for_status()
    return r.json()

# Ejecución
resp = consulta_metricas("builtin:host.cpu.usage", "HOST-XXXX", "now-2h", "now")
df = pd.json_normalize(resp["result"][0]["data"], record_path=["timestamps"], meta=["values"])
df.columns = ["timestamp", "value"]
df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")

# Visualización
plt.figure()
plt.plot(df["timestamp"], df["value"])
plt.title("Uso de CPU del host en las últimas 2 horas")
plt.xlabel("Tiempo")
plt.ylabel("Porcentaje CPU")
plt.show()

Este ejemplo muestra cómo combinar la API con pandas y matplotlib para análisis más profundos.

10. Conclusión

La API REST de Dynatrace es una herramienta esencial para:

• Automatizar workflows de monitorización.
• Integrar con sistemas externos y orquestación.
• Extraer grandes volúmenes de datos de forma programática.

Sin embargo, ten presente sus limitaciones en cuanto a payload, rate limits y retención de datos. Para exploración interactiva y diagnóstico rápido, sigue confiando en el Data Explorer y los Notebooks del propio Dynatrace.

Con esta guía ya dispones de un punto de partida para diseñar tus propias integraciones y aprovechar al máximo los datos de Dynatrace desde tus aplicaciones Python o scripts de automatización.