Curso de Grafana

Comparar instalación autogestionada, Grafana Cloud y Grafana Enterprise valorando costes, control, actualizaciones, plugins, permisos y operación.

Desplegar Grafana OSS en local con Docker Compose para disponer de un entorno reproducible de prácticas.

Preparar una instancia con volúmenes persistentes, variables de entorno, provisioning inicial y credenciales seguras de administración.

Revisar configuración básica de `grafana.ini`, rutas, puertos, base de datos interna, logs, plugins y opciones de servidor.

Configurar Grafana detrás de un proxy inverso con dominio, HTTPS, cabeceras, subpath o root URL según arquitectura corporativa.

Preparar entornos separados para desarrollo, staging y producción evitando cambios directos sobre instancias críticas.

Establecer una estrategia de actualización y rollback compatible con plugins, dashboards, provisioning y compatibilidad de versiones.

Validar instalación mediante health checks, logs, panel inicial, API básica y creación controlada de recursos.

Documentar el entorno para que sistemas, DevOps y observabilidad puedan reproducirlo sin conocimiento informal.

Revisar decisiones iniciales que condicionan el futuro: autenticación, persistencia, base de datos, plugins, usuarios, carpetas y provisioning.

Comprender la estructura de Grafana: organizaciones, usuarios, equipos, carpetas, dashboards, data sources, alerting resources y service accounts.

Diseñar una jerarquía de carpetas que refleje equipos, productos, plataformas, entornos, servicios o dominios de negocio.

Evitar estructuras planas donde todos los dashboards se mezclan y resulta imposible saber quién mantiene cada recurso.

Definir ownership de dashboards, fuentes de datos, alertas y carpetas para evitar recursos huérfanos o duplicados.

Establecer convenciones de nombres para dashboards, paneles, variables, carpetas, data sources y alert rules.

Separar dashboards operativos, ejecutivos, exploratorios, de troubleshooting, de producto y de capacidad.

Diseñar un modelo de permisos que permita colaboración sin exponer información sensible ni habilitar cambios accidentales.

Revisar implicaciones de multi-organización frente a separación por carpetas, equipos o stacks independientes.

Documentar estándares internos para que los nuevos dashboards mantengan estructura, contexto y criterios de calidad.

Preparar una base de gobierno que permita escalar Grafana a varios equipos sin degradar la experiencia de uso.

Configurar data sources habituales como Prometheus, Loki, Tempo, Mimir, PostgreSQL, MySQL, Elasticsearch, InfluxDB, CloudWatch o Azure Monitor.

Diferenciar fuentes de métricas, logs, trazas, perfiles, SQL, cloud y APIs para seleccionar la herramienta adecuada en cada análisis.

Configurar autenticación mediante credenciales, tokens, service accounts, headers, TLS, IAM o mecanismos propios del proveedor.

Revisar el modo de acceso, timeouts, límites, caché, query options y seguridad de la conexión antes de exponer datos a usuarios finales.

Preparar data sources por entorno evitando que un dashboard de pruebas consulte datos productivos por error.

Diseñar convenciones para nombres de data sources que permitan identificar origen, entorno, región, cuenta o criticidad.

Validar conexión, permisos y consultas básicas antes de construir dashboards complejos sobre una fuente nueva.

Controlar quién puede crear, editar o consultar data sources cuando contienen datos sensibles o acceso privilegiado.

Documentar cada fuente con propietario, finalidad, credenciales, origen de datos, límites y procedimientos de soporte.

Detectar problemas habituales: latencia alta, cardinalidad excesiva, credenciales caducadas, permisos incompletos y consultas demasiado costosas.

Comprender el modelo de series temporales, labels, samples, scrape, targets, exporters y remote write dentro del ecosistema Prometheus.

Conectar Grafana a Prometheus o Mimir para visualizar métricas de infraestructura, aplicaciones, Kubernetes, bases de datos y servicios internos.

Diseñar consultas PromQL que permitan responder preguntas operativas y no solo dibujar líneas en un panel.

Diferenciar gauges, counters, histograms y summaries para evitar interpretaciones incorrectas de tasas, latencias o percentiles.

Utilizar funciones como `rate`, `increase`, `histogram_quantile`, agregaciones por label y filtros de entorno con criterio técnico.

Controlar cardinalidad de métricas evitando labels dinámicos, series explosivas y consultas que degradan la plataforma.

Crear dashboards orientados a golden signals: latencia, tráfico, errores y saturación.

Relacionar métricas de aplicación con despliegues, versiones, infraestructura y eventos para facilitar diagnóstico.

Preparar recording rules cuando las consultas repetidas son costosas o se necesitan indicadores estables.

Traducir métricas técnicas en señales comprensibles para equipos de producto, operaciones y dirección.

Comprender la arquitectura de Loki y su enfoque de indexación por labels frente a sistemas que indexan todo el contenido del log.

Conectar Grafana a Loki y diseñar una estrategia de labels que facilite búsqueda sin disparar cardinalidad.

Utilizar LogQL para filtrar, parsear, agrupar y extraer información útil de logs de aplicaciones, contenedores, Kubernetes o sistemas.

Diferenciar consultas de exploración, paneles permanentes y alertas basadas en logs para evitar costes y ruido innecesario.

Analizar logs estructurados JSON, logs de texto libre y formatos mixtos aplicando parsers adecuados.

Relacionar logs con métricas mediante labels compartidos, correlaciones y enlaces hacia servicios o trazas.

Detectar patrones de error, picos de excepciones, mensajes repetitivos y logs inútiles que aumentan coste sin mejorar observabilidad.

Preparar dashboards de logs para soporte, desarrollo, seguridad y operaciones con filtros accionables.

Configurar alertas basadas en logs solo cuando el evento representa una señal relevante y no ruido operativo.

Diseñar guías internas para instrumentar logs con contexto suficiente: servicio, entorno, request id, usuario técnico y severidad.

Comprender el valor de las trazas distribuidas en sistemas con microservicios, APIs, colas, funciones serverless y dependencias externas.

Conectar Grafana a Tempo y explorar spans, traces, servicios, latencias, errores y relaciones entre componentes.

Revisar conceptos de OpenTelemetry: traces, spans, attributes, resources, context propagation, OTLP y collectors.

Utilizar Grafana Alloy u OpenTelemetry Collector para recibir, procesar y enviar trazas hacia Tempo o Grafana Cloud.

Analizar una traza completa desde entrada HTTP hasta base de datos, cache, cola, servicio externo y respuesta final.

Aplicar TraceQL para localizar trazas por duración, estado, atributos, servicio, endpoint o condiciones específicas.

Relacionar métricas, logs y trazas mediante exemplars, trace IDs, labels compartidos y enlaces de correlación.

Detectar problemas habituales: propagación rota, spans sin atributos útiles, exceso de ruido, sampling mal ajustado o servicios sin instrumentar.

Definir estrategias de sampling según volumen, criticidad, coste y necesidad de diagnóstico.

Diseñar paneles e investigaciones que usen trazas para reducir el tiempo de localización de causa raíz.

Comprender qué aporta el profiling continuo frente a métricas agregadas, logs y trazas cuando el problema está en CPU, memoria o llamadas internas.

Conectar Grafana con Pyroscope para analizar perfiles de aplicaciones y procesos con foco en rendimiento sostenido.

Interpretar flame graphs, funciones calientes, consumo de CPU, asignaciones de memoria y comportamiento por versión o entorno.

Relacionar perfiles con despliegues, cambios de código, endpoints, servicios y trazas para explicar degradaciones reales.

Detectar cuellos de botella que no aparecen claramente en dashboards de métricas tradicionales.

Preparar paneles de profiling orientados a equipos de desarrollo, SRE y rendimiento.

Definir cuándo merece la pena instrumentar profiling continuo y cuándo el coste o la complejidad no se justifican.

Analizar problemas de optimización en servicios backend, workers, procesos batch y aplicaciones con consumo elevado.

Incorporar profiling en investigaciones de incidentes de latencia, saturación o coste cloud.

Traducir hallazgos de perfiles en acciones de refactorización, optimización o cambio de arquitectura.

Situar Grafana Alloy como componente para recopilar, transformar y enviar métricas, logs, trazas y datos OpenTelemetry hacia la pila Grafana.

Configurar Alloy en Docker, Linux o Kubernetes según el laboratorio y el tipo de telemetría que se necesita recoger.

Diseñar pipelines para recibir OTLP, procesar datos, aplicar relabeling, filtrar señales y reenviar hacia Loki, Tempo, Mimir o Prometheus Remote Write.

Diferenciar Alloy, Grafana Agent heredado, OpenTelemetry Collector y exporters específicos según el entorno.

Preparar configuraciones modulares que puedan mantenerse, versionarse y reutilizarse entre servicios o clusters.

Controlar secretos, endpoints, tokens, certificados y credenciales usados por Alloy para enviar datos a Grafana Cloud o entornos internos.

Diagnosticar problemas de pipeline: datos no llegan, labels incorrectos, latencia, rechazos, errores de autenticación o cardinalidad inesperada.

Incorporar scraping de métricas, recolección de logs y recepción de trazas dentro de una estrategia unificada.

Validar el flujo completo desde aplicación instrumentada hasta paneles, Explore, alertas y dashboards.

Documentar decisiones de telemetría para que desarrollo y operaciones conozcan qué se recopila, por qué y con qué coste.

Utilizar Explore para investigar datos sin crear dashboards permanentes antes de entender el problema.

Navegar entre métricas, logs, trazas y perfiles durante una investigación, manteniendo contexto temporal y filtros coherentes.

Utilizar Query Inspector para analizar consultas, tiempos, errores, payloads y problemas de rendimiento.

Aplicar Metrics Drilldown, Logs Drilldown y Traces Drilldown cuando el entorno los incluye, acelerando exploración sin escribir todas las consultas manualmente.

Construir hipótesis de incidente a partir de cambios de latencia, errores, saturación, logs anómalos y trazas lentas.

Usar correlaciones para saltar entre señales relacionadas sin depender de enlaces improvisados en cada dashboard.

Crear consultas temporales que luego puedan convertirse en panel, alerta o documentación de troubleshooting.

Evitar investigaciones caóticas definiendo una secuencia de observación, hipótesis, validación y acción.

Documentar hallazgos durante el incidente para alimentar postmortems, runbooks y mejoras de observabilidad.

Preparar a equipos de guardia para investigar con Grafana sin depender de una persona experta en cada fuente de datos.

Diferenciar dashboards de diagnóstico, seguimiento operativo, reporting ejecutivo, capacidad, negocio, seguridad y exploración técnica.

Definir audiencia, objetivo, pregunta principal y decisión esperada antes de crear paneles.

Diseñar estructura visual con filas, secciones, jerarquía, contexto temporal, leyendas y unidades consistentes.

Evitar dashboards saturados que mezclan demasiadas señales, escalas, fuentes y niveles de detalle.

Crear paneles que faciliten acción: detectar problema, localizar alcance, estimar impacto y decidir siguiente paso.

Utilizar library panels para reutilizar componentes críticos entre dashboards sin duplicar mantenimiento.

Incorporar anotaciones de despliegues, incidentes, cambios de configuración y eventos de negocio.

Preparar dashboards ejecutivos que traduzcan disponibilidad, errores, SLOs y rendimiento a lenguaje de servicio.

Documentar dashboards con owner, descripción, fuentes, interpretación, límites y acciones recomendadas.

Revisar dashboards periódicamente para eliminar paneles obsoletos, métricas sin uso y duplicidades entre equipos.

Seleccionar visualizaciones adecuadas: time series, stat, table, bar chart, heatmap, state timeline, logs, traces, geomap o node graph.

Configurar unidades, thresholds, mappings, overrides, enlaces, tooltips y leyendas para mejorar interpretación inmediata.

Aplicar transformaciones para unir, filtrar, agrupar, pivotar, calcular campos, renombrar columnas o combinar resultados de varias consultas.

Diseñar tablas operativas que permitan ordenar, filtrar y detectar valores anómalos sin exportar datos a hojas de cálculo.

Usar field overrides para adaptar formato según serie, severidad, servicio, entorno o dimensión relevante.

Incorporar data links y dashboard links para conectar paneles con Explore, trazas, logs, tickets, runbooks o sistemas externos.

Evitar transformaciones excesivas que ocultan lógica crítica dentro del panel y dificultan mantenimiento.

Preparar visualizaciones para pantallas NOC, reuniones ejecutivas, análisis técnico y troubleshooting en profundidad.

Validar que cada panel responde una pregunta concreta y no solo muestra una métrica disponible.

Crear patrones visuales internos para homogeneizar dashboards entre equipos y reducir curva de aprendizaje.

Crear variables de entorno, servicio, cluster, namespace, instancia, región, equipo o producto para reutilizar dashboards.

Diseñar consultas de variables eficientes que no ralenticen la carga ni generen listas inmanejables.

Utilizar variables encadenadas cuando la selección de un entorno condiciona servicios, pods, endpoints o data sources disponibles.

Gestionar valores multi-select, all value, regex, intervalos y ad hoc filters con cuidado para evitar consultas demasiado amplias.

Crear dashboards genéricos para múltiples servicios sin perder claridad ni precisión diagnóstica.

Evitar dashboards excesivamente parametrizados que se vuelven difíciles de interpretar para usuarios no expertos.

Documentar valores esperados y criterios de uso de variables para equipos que consumen el dashboard.

Combinar variables con links, annotations y data sources para crear navegación fluida entre niveles de detalle.

Preparar plantillas de dashboard por tipo de aplicación, Kubernetes workload, base de datos, API o servicio crítico.

Revisar impacto de variables sobre caché, rendimiento y coste de consultas.

Comprender Grafana Alerting como sistema para evaluar condiciones sobre métricas, logs u otras fuentes y activar respuestas operativas.

Diseñar alert rules con consultas, condiciones, ventanas, severidad, labels, annotations y criterios de recuperación.

Diferenciar alertas de síntoma, causa, predicción y SLO para evitar duplicidad y ruido.

Configurar contact points, notification policies, mute timings, silences y rutas de escalado según equipo, servicio y criticidad.

Crear plantillas de notificación con información accionable: impacto, entorno, servicio, enlace al dashboard, runbook y posible causa.

Evitar alertas que solo informan de un dato sin indicar acción, propietario o consecuencia operativa.

Diseñar estrategias para reducir fatiga: agrupación, deduplicación, umbrales adecuados, ventanas razonables y revisión periódica.

Probar alertas antes de producción verificando evaluación, routing, mensaje, destinatarios y comportamiento de recuperación.

Gestionar alertas provisionadas como código para evitar cambios manuales no trazables.

Medir calidad del alerting con falsos positivos, alertas ignoradas, tiempo de respuesta y utilidad durante incidentes.

Comprender SLI, SLO, error budget y burn rate como herramientas para gestionar fiabilidad desde la experiencia del usuario.

Definir SLIs útiles para disponibilidad, latencia, errores, completitud, frescura de datos o éxito de transacciones críticas.

Evitar SLOs basados en métricas técnicas que no reflejan impacto real sobre clientes, usuarios o procesos de negocio.

Construir paneles de SLO que muestren cumplimiento, consumo de error budget, tendencia y riesgo de incumplimiento.

Diseñar alertas de burn rate que avisen antes de agotar presupuesto sin multiplicar ruido.

Relacionar SLOs con decisiones de release, deuda técnica, capacidad, calidad y priorización de incidencias.

Preparar SLOs para APIs, aplicaciones web, procesos batch, plataformas internas, bases de datos y servicios de terceros.

Establecer responsables de cada SLO y acuerdos de revisión entre producto, ingeniería, operaciones y dirección.

Utilizar SLOs en postmortems para separar percepción, impacto real y compromisos de mejora.

Incorporar SLOs al gobierno de observabilidad para que los dashboards no sean solo técnicos, sino orientados a servicio.

Diseñar observabilidad para clusters Kubernetes considerando nodos, namespaces, workloads, pods, contenedores, servicios e ingress.

Recopilar métricas de Kubernetes mediante exporters, Prometheus, Mimir o integraciones de Grafana Cloud.

Recoger logs de pods y control plane con labels coherentes para filtrar por cluster, namespace, workload, pod y contenedor.

Instrumentar aplicaciones desplegadas en Kubernetes con OpenTelemetry para conectar trazas, logs y métricas.

Crear dashboards para capacidad, saturación, reinicios, errores, latencia, consumo, scheduling y salud de workloads.

Analizar incidentes habituales: CrashLoopBackOff, OOMKilled, HPA ineficaz, saturación de nodos, errores de ingress y latencia entre servicios.

Configurar alertas para señales relevantes sin alertar por cada pod temporal o cambio normal del cluster.

Revisar coste y cardinalidad derivados de etiquetas Kubernetes, namespaces efímeros y métricas de alta dimensión.

Integrar eventos de despliegue y cambios de configuración para contextualizar variaciones en métricas.

Crear un modelo de dashboards por plataforma, equipo, aplicación y servicio que evite duplicidades y mejore ownership.

Diseñar telemetría para aplicaciones backend, frontend, APIs y procesos asíncronos con foco en experiencia real de usuario.

Instrumentar servicios con OpenTelemetry para capturar latencia, errores, dependencias, trazas y atributos útiles.

Analizar frontend observability cuando se necesita visibilidad sobre rendimiento en navegador, errores JavaScript y experiencia real.

Relacionar métricas de aplicación con releases, feature flags, versiones, regiones, navegadores o segmentos de usuario.

Crear dashboards para endpoints críticos, transacciones de negocio, errores por versión y comportamiento de clientes.

Integrar logs de aplicación con trace IDs y request IDs para reducir tiempo de investigación.

Preparar alertas orientadas a impacto funcional, no solo a uso de CPU o memoria.

Revisar diferencias entre observabilidad técnica y product analytics, evitando mezclar finalidades sin criterio.

Incorporar pruebas sintéticas para detectar problemas antes de que los usuarios los reporten.

Documentar patrones de instrumentación que los equipos de desarrollo puedan aplicar de forma consistente.

Utilizar Grafana Cloud k6 para diseñar pruebas de carga, estrés, smoke, breakpoint o pruebas continuas de rendimiento.

Relacionar resultados de k6 con métricas de infraestructura, logs, trazas y comportamiento de aplicación en Grafana.

Diseñar escenarios de prueba realistas que representen usuarios, endpoints críticos, autenticación, ramp-up y datos de prueba.

Incorporar pruebas de rendimiento al ciclo de entrega para detectar regresiones antes de producción.

Configurar Synthetic Monitoring para checks HTTP, TCP, DNS, ping, browser o scripts según criticidad del servicio.

Seleccionar ubicaciones de probes que reflejen usuarios reales, regiones de negocio o dependencias externas relevantes.

Crear alertas sintéticas que indiquen disponibilidad, latencia, errores y degradación desde fuera de la infraestructura interna.

Evitar pruebas sintéticas excesivas que generan costes, ruido o tráfico innecesario sobre servicios propios.

Documentar thresholds, expectativas y acciones cuando una prueba sintética falla.

Integrar disponibilidad externa, pruebas de rendimiento y SLOs en una visión coherente de fiabilidad.

Configurar usuarios, equipos y roles básicos Viewer, Editor y Admin según responsabilidades reales y principio de mínimo privilegio.

Utilizar carpetas como frontera de permisos para separar áreas, servicios, departamentos y proyectos.

Gestionar service accounts para automatización, provisioning, APIs, Terraform y generación de recursos sin usar cuentas personales.

Revisar RBAC en Grafana Enterprise y Grafana Cloud cuando se necesitan permisos más granulares que los roles básicos.

Diseñar permisos para dashboards, alertas, data sources, reports, configuración y recursos administrativos.

Integrar autenticación corporativa con OAuth, LDAP, SAML, OIDC o proveedor compatible según arquitectura de identidad.

Controlar accesos externos, usuarios invitados, cuentas inactivas y permisos heredados que ya no se justifican.

Documentar roles, grupos, owners y procedimientos de alta, baja y revisión periódica.

Auditar acciones administrativas, cambios críticos y uso de tokens cuando el entorno lo permite.

Construir un modelo de gobierno que permita colaboración sin comprometer datos, alertas o configuración crítica.

Analizar riesgos de exposición de métricas, logs, trazas, perfiles y dashboards que pueden contener información sensible.

Configurar HTTPS, cookies, cabeceras, secretos, base de datos, sesiones y opciones de servidor con criterios de endurecimiento.

Evitar que logs o labels incluyan datos personales, tokens, emails, identificadores sensibles o información contractual.

Diseñar políticas de retención y acceso según criticidad, regulación, coste y utilidad operativa.

Revisar permisos de data sources para impedir que usuarios accedan indirectamente a datos que no deberían consultar.

Proteger tokens de service accounts, claves de API y credenciales usadas por provisioning, Alloy, Terraform o integraciones.

Preparar dashboards públicos, snapshots o enlaces compartidos solo cuando la política de seguridad lo permite.

Documentar criterios de anonimización, minimización y exclusión de datos sensibles en telemetría.

Revisar plugins antes de instalarlos considerando origen, mantenimiento, permisos, compatibilidad y riesgo operativo.

Crear checklist de seguridad previa a producción para instalaciones Grafana OSS, Enterprise o Cloud.

Provisionar data sources, dashboards, alertas y otros recursos para evitar configuraciones manuales imposibles de auditar.

Utilizar archivos YAML, JSON, APIs, Terraform y Git para mantener recursos de Grafana versionados y revisables.

Diseñar un repositorio de observability as code con carpetas por entorno, equipo, servicio y tipo de recurso.

Crear service accounts con permisos mínimos para automatizar provisioning sin usar cuentas personales.

Gestionar dashboards como código manteniendo equilibrio entre edición visual y control de versiones.

Configurar alerting resources mediante provisioning o API cuando se necesita consistencia entre entornos.

Revisar Git Sync y flujos de sincronización cuando el equipo quiere gobernar dashboards desde repositorios.

Preparar pipelines para validar sintaxis, revisar cambios, desplegar recursos y aplicar rollback cuando una configuración falla.

Evitar divergencias entre recursos editados manualmente en UI y recursos gestionados como código.

Documentar convenciones para que equipos distintos puedan contribuir sin romper estándares globales.

Evaluar plugins de data source, panel, app e integraciones según necesidad, madurez, soporte, seguridad y mantenimiento.

Instalar plugins en entornos OSS o Enterprise controlando versiones, firmas, compatibilidad y permisos necesarios.

Diferenciar plugins oficiales, community plugins y desarrollos internos antes de incorporarlos a producción.

Crear criterios para aprobar nuevos plugins evitando que cada equipo instale componentes sin evaluación.

Analizar impacto de plugins sobre rendimiento, estabilidad, actualización de Grafana y experiencia de usuario.

Integrar Grafana con sistemas cloud, bases de datos, colas, mensajería, ITSM, incident management y herramientas corporativas.

Revisar alternativas cuando una integración puede resolverse mejor mediante OpenTelemetry, Alloy, API, Prometheus exporter o data source existente.

Preparar inventario de plugins instalados con owner, versión, finalidad, riesgo y plan de actualización.

Retirar plugins obsoletos o sin uso para reducir superficie de ataque y deuda operativa.

Diseñar una política de extensibilidad que combine innovación y seguridad.

Analizar cómo cardinalidad, volumen de logs, trazas, perfiles, métricas y consultas influyen en coste y rendimiento.

Identificar labels de alta cardinalidad que multiplican series, encarecen almacenamiento y degradan consultas.

Diseñar estrategias de relabeling, sampling, filtrado y agregación antes de enviar datos a la plataforma.

Establecer políticas de retención diferenciadas para métricas, logs, trazas y perfiles según valor operativo.

Medir dashboards y alertas que ejecutan consultas costosas con demasiada frecuencia.

Preparar recording rules, dashboards simplificados y paneles de alto nivel para reducir carga en fuentes de datos.

Revisar ingestión por equipo, servicio, entorno o fuente para asignar ownership del coste.

Optimizar logs eliminando ruido, mensajes repetitivos, campos inútiles y eventos sin valor diagnóstico.

Diseñar informes de coste de telemetría que permitan decidir qué medir, qué reducir y qué conservar.

Crear una estrategia de escalabilidad que combine observabilidad útil con sostenibilidad económica.

Comprender el papel de Grafana Assistant como agente de observabilidad para investigar, consultar y correlacionar señales cuando el plan lo incluye.

Formular preguntas en lenguaje natural sobre rendimiento, errores, latencia, alertas, dashboards, consultas y recursos de Grafana.

Utilizar investigaciones asistidas para explorar métricas, logs, trazas, perfiles y datos SQL durante incidentes complejos.

Pedir ayuda para construir o refinar consultas PromQL, LogQL, TraceQL, SQL o k6 manteniendo revisión técnica.

Utilizar Assistant para mejorar dashboards, sugerir paneles, navegar recursos y acelerar onboarding de usuarios.

Revisar limitaciones de las respuestas IA, evitando aceptar hipótesis sin contrastarlas con datos, consultas y evidencias.

Incorporar conocimiento del equipo mediante skills o configuraciones cuando la plataforma lo permite.

Analizar cómo la IA puede reducir tiempo de investigación sin sustituir guardias, SRE, desarrolladores ni responsables de servicio.

Definir políticas de uso cuando las preguntas puedan exponer datos sensibles, nombres de clientes o información operativa crítica.

Medir valor real de las investigaciones asistidas comparando tiempo, precisión, acciones recomendadas y aprendizaje del equipo.

Situar AI Observability dentro de Grafana Cloud como capacidad orientada a monitorizar aplicaciones y agentes basados en IA.

Comprender qué señales importan en sistemas LLM: trazas de conversaciones, latencia, coste, errores, calidad, tokens y comportamiento por modelo.

Instrumentar aplicaciones de IA con SDKs o integraciones compatibles cuando el equipo necesita visibilidad end-to-end.

Relacionar llamadas a modelos con métricas de aplicación, logs, trazas, rendimiento, coste y experiencia de usuario.

Crear dashboards para seguimiento de uso, consumo, errores, respuestas lentas, herramientas invocadas y flujos conversacionales.

Diseñar alertas sobre degradación de calidad, aumento de coste, fallos de proveedor o latencias inaceptables.

Revisar riesgos de privacidad al observar prompts, respuestas, conversaciones o datos enviados a modelos.

Conectar observabilidad de IA con SLOs, auditoría técnica y decisiones de arquitectura.

Preparar casos de uso para agentes internos, chatbots corporativos, RAG, copilotos y automatizaciones con LLM.

Definir cuándo AI Observability debe implantarse como parte del gobierno corporativo de IA, no como un panel aislado.

Crear reportes periódicos cuando el entorno Grafana permite enviar dashboards por correo o generar entregables para stakeholders.

Preparar snapshots y enlaces compartidos con cuidado para evitar exposición accidental de datos sensibles.

Diseñar dashboards ejecutivos que comuniquen disponibilidad, rendimiento, incidentes, SLOs y capacidad sin exceso técnico.

Adaptar visualizaciones a reuniones de dirección, comités de operación, revisión de servicio y seguimiento de proveedor.

Construir narratives operativas que expliquen qué ocurrió, qué impacto tuvo, cómo se detectó y qué acción se tomó.

Usar annotations y eventos para contextualizar caídas, despliegues, mantenimientos, campañas o picos de demanda.

Preparar paneles para pantallas de centro de operaciones con información legible y priorizada.

Evitar reportes automáticos que nadie lee por exceso de detalle, falta de contexto o ausencia de acciones claras.

Definir periodicidad, destinatarios, owners y criterios de calidad para cada informe generado desde Grafana.

Convertir Grafana en herramienta de comunicación entre técnica, negocio y dirección sin simplificar en exceso la realidad operativa.

Integrar Grafana Alerting con flujos de guardia, escalado, notificación y respuesta a incidentes.

Diseñar políticas de enrutado que conecten servicio, severidad, equipo responsable y canal de comunicación adecuado.

Utilizar OnCall e Incident Response Management cuando la organización necesita turnos, escalados, timelines y coordinación centralizada.

Preparar dashboards de incidente que reúnan señales clave, últimos despliegues, alertas relacionadas, logs y trazas relevantes.

Documentar acciones durante el incidente para facilitar comunicación, seguimiento y postmortem posterior.

Reducir MTTR conectando alertas con runbooks, paneles, consultas predefinidas y responsables claros.

Evitar escalados innecesarios mediante alertas agrupadas, severidades correctas y silences bien gestionados.

Crear postmortems basados en datos observables y no únicamente en percepciones de los equipos.

Relacionar hallazgos de incidentes con mejoras de instrumentación, SLOs, dashboards, alertas y arquitectura.

Diseñar una rutina de mejora continua tras incidentes que mantenga Grafana alineado con la realidad del sistema.

Crear rutinas de revisión de salud de Grafana, data sources, plugins, dashboards críticos, alertas, tokens y jobs de provisioning.

Gestionar actualizaciones de Grafana, plugins y componentes relacionados mediante entornos de prueba y ventanas controladas.

Revisar logs de Grafana, errores de data source, fallos de alerting, problemas de permisos y consultas lentas.

Preparar backups de configuración, base de datos, dashboards, provisioning, plugins y secretos según modelo de despliegue.

Definir procedimientos de restauración y rollback ante fallos de actualización, corrupción de recursos o pérdida de configuración.

Mantener inventario de dashboards, alertas, data sources, owners, plugins y service accounts.

Revisar recursos huérfanos, dashboards duplicados, alertas sin destinatario y tokens caducados.

Crear playbooks de soporte para problemas frecuentes de usuarios, data sources, permisos y paneles.

Medir disponibilidad y rendimiento de la propia plataforma Grafana como servicio crítico interno.

Establecer una operación sostenible que evite que Grafana crezca sin mantenimiento ni criterios de calidad.

Evaluar migraciones desde herramientas de monitorización tradicionales, dashboards internos, hojas de cálculo, Kibana, Datadog, New Relic u otras plataformas.

Mapear dashboards existentes identificando qué debe migrarse, rediseñarse, eliminarse o mantenerse en otra herramienta.

Preparar una estrategia de convivencia temporal entre fuentes, paneles, alertas y equipos mientras se consolida observabilidad.

Revisar diferencias de modelo entre logs indexados, métricas Prometheus, trazas OpenTelemetry y paneles SQL heredados.

Evitar migrar dashboards antiguos sin cuestionar si todavía responden preguntas útiles.

Diseñar un plan de adopción por equipos con formación, estándares, plantillas y acompañamiento técnico.

Crear dashboards base por plataforma, aplicación, base de datos, Kubernetes, negocio y SLOs.

Gestionar resistencia al cambio mostrando valor en incidentes reales, reducción de ruido y facilidad de investigación.

Documentar equivalencias, limitaciones y cambios de procedimiento para usuarios que vienen de otras herramientas.

Medir éxito de la migración con uso efectivo, reducción de alertas inútiles, cobertura de servicios y satisfacción de equipos.

Definir principios de observabilidad corporativa: medir lo necesario, responder preguntas reales y mantener ownership de cada señal.

Crear estándares internos de dashboards, labels, métricas, logs, trazas, alertas, SLOs, nombres y carpetas.

Establecer un comité o comunidad de práctica para revisar nuevas integraciones, patrones, costes y mejoras.

Preparar plantillas oficiales para servicios, APIs, Kubernetes, bases de datos, frontend, SLOs e incidentes.

Diseñar un proceso de revisión de dashboards antes de promoverlos a entornos compartidos o ejecutivos.

Definir roles de platform team, SRE, equipos de producto, seguridad, desarrollo y dirección en la observabilidad.

Crear documentación interna de onboarding para que nuevos equipos instrumenten correctamente desde el primer proyecto.

Revisar métricas de madurez: cobertura de servicios, calidad de alertas, dashboards con owner, SLOs definidos y coste por señal.

Establecer políticas de retirada de recursos obsoletos para evitar degradación progresiva de la plataforma.

Construir un modelo de observabilidad como producto interno con roadmap, soporte, documentación y mejora continua.

Diseñar una plataforma Grafana para una empresa con aplicaciones web, APIs, Kubernetes, bases de datos, logs, trazas, SLOs y alerting.

Desplegar o utilizar una instancia Grafana con data sources de métricas, logs y trazas conectadas al entorno de laboratorio.

Configurar Prometheus o Mimir para métricas, Loki para logs, Tempo para trazas y Alloy u OpenTelemetry para recopilar telemetría.

Crear una estructura de carpetas, equipos, permisos, service accounts y convenciones de naming preparada para varios equipos.

Construir un dashboard operativo para un servicio crítico con golden signals, variables, anotaciones, links, logs relacionados y trazas.

Diseñar un dashboard ejecutivo con disponibilidad, SLOs, incidentes, rendimiento, capacidad y señales de negocio relevantes.

Crear alert rules, contact points, notification policies, silences y mensajes de alerta con enlaces a dashboards y runbooks.

Incorporar una prueba sintética o escenario k6 para validar disponibilidad, latencia o comportamiento de un endpoint crítico.

Definir un SLO con SLI, objetivo, error budget, dashboard de seguimiento y alerta de burn rate.

Provisionar al menos parte de la configuración mediante archivos, Terraform, API o enfoque observability as code.

Revisar seguridad, permisos, service accounts, exposición de datos, retención, cardinalidad y coste estimado de telemetría.

Preparar documentación de operación con arquitectura, decisiones, owners, fuentes de datos, alertas, mantenimiento y plan de mejora.

Simular un incidente, investigar en Grafana correlacionando métricas, logs, trazas y eventos, y proponer acciones correctoras.

Presentar el proyecto final defendiendo diseño, decisiones técnicas, gobierno, calidad de dashboards, alertas, SLOs y escalabilidad.