Curso de OpenTelemetry Avanzado para Equipos de Infraestructura y SRE

Diseño de arquitecturas con Collector como agente, gateway centralizado, sidecar, DaemonSet, Deployment o topología híbrida según necesidades operativas.

Comparación entre enviar telemetría directamente desde aplicaciones al backend y pasar por Collectors intermedios con control de pipelines.

Definición de patrones de despliegue para Kubernetes, máquinas virtuales, bare metal, edge, cloud y entornos híbridos.

Separación de responsabilidades entre Collectors de nodo, Collectors de cluster, gateways regionales y exporters hacia backends externos.

Diseño de rutas para trazas, métricas, logs y perfiles evitando mezclar señales sin criterio.

Evaluación de latencia, resiliencia, coste, seguridad y mantenimiento de cada topología.

Preparación de patrones multi-cluster y multi-region con normalización de recursos y atributos comunes.

Identificación de puntos críticos: saturación de gateway, pérdida de telemetría, duplicidad de métricas, loops y fallos de exporter.

Creación de diagramas de arquitectura que expliquen flujo de datos, límites de confianza, almacenamiento y dependencias.

Ejercicio práctico: diseñar tres arquitecturas OpenTelemetry para pyme, plataforma Kubernetes y entorno corporativo multi-cluster.

Desglose avanzado de receivers, processors, exporters, extensions, connectors y service pipelines.

Diseño de configuraciones mantenibles con separación por señal, entorno, equipo, namespace, backend y criticidad.

Uso de receivers OTLP, Prometheus, hostmetrics, kubeletstats, filelog, jaeger, zipkin y otros componentes relevantes según escenario.

Aplicación de processors como batch, memory_limiter, resource, attributes, filter, transform, k8sattributes y probabilistic_sampler.

Configuración de exporters OTLP, Prometheus Remote Write, logging/debug, Jaeger, Kafka, Loki, Elasticsearch, Datadog, New Relic o backends compatibles.

Uso de extensions para health_check, pprof, zpages, basicauth, oauth2client u otros mecanismos de soporte operativo.

Validación de configuración antes de desplegar cambios en producción.

Organización de Collector configs por plantillas, includes, Helm values o repositorio Git.

Análisis de rendimiento del Collector bajo carga y detección de cuellos de botella.

Ejercicio práctico: construir una configuración Collector multi-signal con recepción OTLP, enriquecimiento, filtrado, batch y exportación a varios destinos.

Diseño de pipelines separados para cada señal con políticas específicas de enriquecimiento, filtrado, sampling, retención y exportación.

Correlación entre trazas, métricas y logs mediante service.name, trace_id, span_id, deployment.environment y atributos de recurso coherentes.

Incorporación conceptual de perfiles como señal emergente dentro del ecosistema OpenTelemetry, considerando su estado public alpha desde marzo de 2026.

Definición de cuándo cada señal aporta valor durante un incidente: métricas para detectar, logs para explicar, trazas para localizar y perfiles para analizar consumo.

Prevención de duplicidades entre métricas Prometheus existentes y métricas OTEL generadas por instrumentación.

Diseño de pipelines de logs que no conviertan OpenTelemetry en un simple forwarder sin estructura.

Uso de filtros para separar señales críticas, ruidosas, de laboratorio, productivas o sensibles.

Preparación de convenciones internas de atributos que funcionen en todas las señales.

Validación de correlación extremo a extremo en backend observability.

Ejercicio práctico: correlacionar un error realista mediante métrica, traza, log y contexto de recurso.

Revisión avanzada del valor de las semantic conventions como esquema común para correlacionar operaciones, recursos y señales.

Aplicación de atributos estándar para servicios, deployments, Kubernetes, HTTP, RPC, bases de datos, mensajería, cloud, host y procesos.

Identificación de atributos internos que conviene normalizar en la empresa: equipo, producto, criticidad, entorno, región, tenant, coste y owner.

Diseño de políticas para evitar cardinalidad explosiva en atributos como user_id, session_id, order_id, URL completa, payloads o etiquetas dinámicas.

Uso de processors attributes, resource y transform para limpiar, renombrar, eliminar o enriquecer atributos.

Revisión de la hoja de ruta 2026 de semantic conventions, incluyendo áreas como GenAI, messaging, security, CI/CD y profiling.

Definición de un catálogo corporativo de atributos permitidos, restringidos y prohibidos.

Creación de controles para evitar datos personales, secretos, tokens o información sensible dentro de telemetría.

Validación de consistencia entre aplicaciones, infraestructura, Kubernetes y backends.

Ejercicio práctico: auditar atributos de un servicio y aplicar una política de normalización y reducción de cardinalidad.

Despliegue del Collector como DaemonSet para telemetría de nodo y como Deployment o gateway para agregación de señales.

Uso de componentes importantes para Kubernetes como kubeletstats, k8sattributes, hostmetrics, filelog, Prometheus receiver y receivers específicos.

Enriquecimiento de telemetría con metadata Kubernetes: namespace, pod, deployment, node, container, cluster y labels controladas.

Revisión de riesgos de capturar demasiadas labels de Kubernetes y disparar cardinalidad.

Scraping de métricas Prometheus desde workloads, kube-state-metrics, kubelet o servicios internos.

Recolección de logs de contenedores desde paths estándar y parseo adecuado de formatos.

Separación de telemetría de plataforma, aplicaciones, sistema y componentes críticos.

Gestión de RBAC, ServiceAccounts, ConfigMaps, Secrets y permisos mínimos para Collectors.

Diseño de pipelines por namespace, equipo, entorno o criticidad.

Ejercicio práctico: desplegar OpenTelemetry Collector en Kubernetes para recoger métricas, logs y traces con enriquecimiento k8sattributes.

Comprensión del OpenTelemetry Operator como mecanismo para desplegar y gestionar Collectors e instrumentación en Kubernetes.

Diseño de Custom Resources para Collector, Instrumentation y estrategias de auto-instrumentación.

Comparación entre manifests manuales, Helm charts y Operator para entornos de plataforma.

Gestión de upgrades del Operator, CRDs, compatibilidad de versiones y rollback.

Definición de patrones por entorno: desarrollo, staging, producción, clusters compartidos y namespaces de aplicación.

Uso de anotaciones y configuración declarativa para instrumentación automática cuando aplique.

Separación de responsabilidades entre equipo de plataforma y equipos de aplicación.

Control de límites de recursos, requests, tolerations, affinities y escalado de Collectors.

Validación de despliegues mediante health checks, logs y telemetría interna del Collector.

Ejercicio práctico: preparar una estrategia declarativa para gestionar Collectors en un cluster corporativo.

Recolección de métricas de CPU, memoria, disco, filesystem, red, procesos y carga mediante hostmetrics receiver.

Adaptación de OpenTelemetry a servidores Linux, máquinas virtuales, bare metal y entornos no Kubernetes.

Enriquecimiento de recursos con host.name, os.type, cloud.provider, region, environment y owner.

Diseño de pipelines para infraestructura clásica que convive con Kubernetes y cloud.

Revisión de métricas útiles para operaciones: saturación, errores, latencia, throughput, capacidad y disponibilidad.

Integración con exporters compatibles con Prometheus, OTLP o backends comerciales.

Gestión de permisos mínimos para leer métricas del sistema sin elevar privilegios innecesarios.

Comparación con agentes tradicionales de monitorización y criterios de migración progresiva.

Preparación de dashboards de infraestructura basados en métricas OpenTelemetry.

Ejercicio práctico: instrumentar un servidor Linux de laboratorio y visualizar métricas de sistema en backend.

Diseño de pipelines de logs con filelog receiver, parseo, operadores, enriquecimiento y exportación.

Recolección de logs de contenedores, servicios systemd, aplicaciones, NGINX, proxies, bases de datos y procesos internos.

Normalización de severity, timestamp, service.name, trace_id, span_id y atributos de recurso.

Correlación de logs con trazas mediante IDs propagados por la aplicación.

Filtrado de logs ruidosos, sanitización de campos sensibles y reducción de volumen antes de exportar.

Diferenciación entre logs de infraestructura, aplicación, auditoría y seguridad.

Diseño de rutas de logs hacia Loki, Elasticsearch, Splunk, OTLP o backends compatibles.

Gestión de multiline logs, JSON logs, logs planos y formatos inconsistentes.

Prevención de costes descontrolados por ingestión masiva de logs.

Ejercicio práctico: recoger logs de contenedor, parsearlos, enriquecerlos y correlacionarlos con trazas.

Integración entre Prometheus y OpenTelemetry mediante scraping, exporters, remote write y conversión de formatos.

Diferenciación entre métricas nativas OTEL, métricas Prometheus y métricas generadas por instrumentación automática.

Diseño de pipelines que evitan duplicar métricas y generar dashboards contradictorios.

Gestión de temporality, aggregation, histograms, exemplars y atributos con impacto en cardinalidad.

Scraping de endpoints Prometheus existentes desde Collector para centralizar procesamiento.

Exportación hacia Prometheus, Mimir, Cortex, VictoriaMetrics, Datadog, New Relic u otros backends.

Revisión de métricas RED, USE y Golden Signals aplicadas a infraestructura y servicios.

Uso de transformaciones para renombrar, filtrar y adaptar métricas a convenciones internas.

Control de labels dinámicas que disparan series temporales y costes.

Ejercicio práctico: integrar métricas Prometheus existentes en pipeline OTEL y aplicar reducción de cardinalidad.

Análisis de trazas distribuidas en sistemas con microservicios, colas, APIs, proxies, bases de datos y llamadas externas.

Revisión de sampling head-based, tail-based y estrategias híbridas para no perder trazas relevantes.

Configuración de tail sampling en Collector para conservar errores, latencias altas, rutas críticas o clientes específicos.

Gestión de context propagation entre servicios HTTP, gRPC, mensajería, workers y procesos asíncronos.

Detección de spans huérfanos, trazas fragmentadas, servicios sin propagación y atributos incompletos.

Enriquecimiento de spans con información útil sin incluir datos sensibles.

Correlación con logs y métricas durante análisis de incidentes.

Diseño de convenciones internas para span names, atributos y eventos.

Preparación de consultas y vistas útiles en Jaeger, Tempo, Grafana, Datadog o backend equivalente.

Ejercicio práctico: diagnosticar una latencia distribuida usando trazas, sampling y correlación con métricas.

Comprensión de por qué el sampling avanzado es imprescindible en sistemas con alto volumen de trazas.

Diferenciación entre sampling en SDK, Collector gateway y backend.

Configuración de tail_sampling processor para capturar trazas completas basadas en error, latencia, status code, atributos o políticas compuestas.

Diseño de estrategias por criticidad de servicio, entorno, ruta, tenant o tipo de operación.

Evaluación de impacto del sampling sobre análisis de incidentes, costes y cumplimiento.

Prevención de sesgos operativos al muestrear demasiado agresivamente.

Combinación de sampling con filtros, batch y memory_limiter.

Medición de ratio de retención, pérdida de trazas y utilidad durante incidentes.

Preparación de políticas de sampling revisables por SRE y equipos de aplicación.

Ejercicio práctico: implementar tail sampling para conservar errores y transacciones lentas reduciendo volumen total.

Dimensionamiento del Collector según volumen de telemetría, número de pipelines, exporters, batch size y procesamiento aplicado.

Uso de memory_limiter para evitar OOM y degradación del Collector bajo carga.

Configuración de batch processor para optimizar exportación y reducir overhead.

Gestión de colas, retry_on_failure, sending_queue y comportamiento ante backend no disponible.

Detección de backpressure, dropped data, exporter failures y saturación de CPU o memoria.

Monitorización del propio Collector mediante métricas internas, health checks, pprof y zpages.

Diseño de alta disponibilidad para gateways Collector.

Separación de pipelines pesados y livianos para evitar interferencias entre señales.

Pruebas de carga con generación de telemetría sintética.

Ejercicio práctico: someter un Collector a carga, detectar drops y ajustar memoria, batch y colas.

Comprensión de OpenTelemetry eBPF Instrumentation como alternativa de instrumentación automática mediante eBPF, útil especialmente para reducir fricción inicial.

Diferenciación entre auto-instrumentación por agente de lenguaje, instrumentación manual, sidecar, SDK y eBPF.

Evaluación de ventajas de eBPF en entornos donde no es viable modificar código o reconstruir aplicaciones.

Revisión de límites: visibilidad parcial, compatibilidad, contexto semántico, overhead, permisos kernel y soporte por lenguaje.

Análisis de objetivos recientes del proyecto eBPF Instrumentation, incluyendo trabajo sobre trazas distribuidas y métricas RED.

Diseño de casos de uso para sistemas, plataforma y SRE: descubrimiento de dependencias, latencia de red, llamadas HTTP y servicios no instrumentados.

Evaluación de seguridad y permisos necesarios para ejecutar instrumentación eBPF en Kubernetes o hosts.

Comparación de resultados entre eBPF y SDK instrumentado manualmente.

Integración de telemetría eBPF con pipelines Collector existentes.

Ejercicio práctico conceptual: decidir cuándo usar eBPF, auto-instrumentación o instrumentación manual en un entorno mixto.

Introducción avanzada a perfiles como señal emergente para analizar CPU, memoria y comportamiento de ejecución.

Revisión del estado public alpha de OpenTelemetry Profiles y su relación con especificaciones y semantic conventions.

Diferenciación entre métricas de infraestructura, trazas de latencia y perfiles de ejecución.

Identificación de casos donde profiling aporta valor: consumo de CPU, hotspots, degradación progresiva, fugas, optimización y capacidad.

Diseño de una estrategia prudente para experimentar con perfiles sin comprometer estabilidad ni costes.

Integración conceptual de perfiles con servicios, recursos, deployments y entornos.

Revisión de limitaciones actuales, compatibilidad de tooling y madurez del ecosistema.

Preparación de criterios para adoptar perfiles cuando pasen a estados más maduros.

Comunicación de valor de profiling a equipos de desarrollo y sistemas.

Ejercicio práctico conceptual: analizar un incidente de consumo alto combinando métricas, trazas y perfiles.

Identificación de datos sensibles que pueden filtrarse en atributos, logs, spans, URLs, headers, queries, excepciones o payloads.

Diseño de políticas de redacción, eliminación y hashing mediante processors attributes, filter y transform.

Control de headers HTTP, authorization, cookies, tokens, emails, IDs de usuario, datos financieros y datos personales.

Cifrado de comunicaciones OTLP mediante TLS y control de endpoints expuestos.

Autenticación entre aplicaciones, Collectors y backends con tokens, mTLS o mecanismos soportados.

Separación de telemetría por entorno, tenant, cliente, región o criticidad.

Revisión de retención, almacenamiento y acceso en backends observability.

Coordinación con seguridad, DPO, compliance y equipos de plataforma.

Creación de tests para verificar que campos sensibles no llegan al backend.

Ejercicio práctico: auditar una telemetría con PII simulada y aplicar sanitización en Collector.

Diseño de separación lógica por entorno, namespace, equipo, producto, tenant, región o criticidad.

Uso de atributos de recurso para enrutar telemetría a diferentes exporters o backends.

Aplicación de filtros para evitar que un equipo consulte telemetría que no le corresponde cuando el backend lo permita.

Control de costes por equipo o producto mediante etiquetas normalizadas.

Diseño de políticas de ingestión diferenciadas para desarrollo, staging, producción y entornos regulados.

Gestión de noisy neighbors cuando un servicio genera demasiada telemetría.

Separación de pipelines para plataformas compartidas y aplicaciones de negocio.

Preparación de dashboards y alertas por equipo sin duplicar configuración.

Documentación de ownership de servicios y pipelines.

Ejercicio práctico: enrutar telemetría de varios namespaces a destinos distintos usando atributos y filtros.

Comparación de patrones de exportación hacia stacks open source y comerciales: Grafana Tempo, Loki, Prometheus, Jaeger, Elasticsearch, Splunk, Datadog, New Relic, Dynatrace y otros.

Diseño de arquitectura vendor-neutral para evitar acoplar aplicaciones a un backend concreto.

Uso de OTLP como protocolo preferente cuando el backend lo soporta.

Gestión de diferencias entre backends en soporte de logs, trazas, métricas, perfiles, exemplars y atributos.

Configuración de exporters específicos y validación de datos recibidos.

Preparación de dashboards portables basados en semantic conventions.

Revisión de costes de ingestión, almacenamiento, retención y consultas por backend.

Migración progresiva desde agentes propietarios hacia OpenTelemetry.

Estrategia de dual export durante transiciones o pruebas de proveedor.

Ejercicio práctico: exportar señales a dos backends y comparar visibilidad, coste y limitaciones.

Diseño de dashboards operativos que conecten métricas RED, USE, saturación, errores, latencia, disponibilidad y dependencias.

Creación de vistas para sistemas, clusters, servicios, equipos, incidentes y dirección técnica.

Definición de SLI y SLO usando señales OpenTelemetry como fuente normalizada.

Integración con alerting evitando alertas basadas en síntomas irrelevantes o ruido.

Uso de trazas y logs como contexto de investigación tras alerta, no como disparadores indiscriminados.

Diseño de alertas por tasa de error, latencia, saturación, drops del Collector, pérdida de telemetría y fallos de exporter.

Priorización de alertas por impacto al usuario o servicio crítico.

Preparación de dashboards de salud de la plataforma OpenTelemetry.

Revisión de errores habituales: dashboards bonitos pero inútiles, métricas sin owner o alertas sin acción clara.

Ejercicio práctico: diseñar un dashboard y un conjunto mínimo de alertas para una plataforma Kubernetes.

Diagnóstico de ausencia de telemetría desde aplicación, Collector, red, autenticación, exporter o backend.

Uso de debug exporter, logs del Collector, zpages, pprof y métricas internas para localizar fallos.

Verificación de conectividad OTLP gRPC y HTTP entre SDK, Collector y backend.

Identificación de errores de certificados, DNS, puertos, endpoints, payload size, rate limits y credenciales.

Depuración de pipelines con transformaciones que eliminan datos inesperadamente.

Detección de pérdida por memory_limiter, colas llenas, backend caído o batch mal configurado.

Resolución de problemas de correlación entre logs, métricas y trazas.

Creación de runbooks de diagnóstico para incidencias recurrentes.

Preparación de comandos y pruebas reproducibles para soporte.

Ejercicio práctico: resolver un laboratorio con tres fallos encadenados en el pipeline OTEL.

Análisis de inventario actual: agentes, exporters, Prometheus, logs, APM propietario, scripts, dashboards y alertas.

Identificación de qué señales pueden migrarse primero sin impacto operativo.

Diseño de coexistencia entre stack actual y OpenTelemetry durante transición.

Priorización de servicios críticos, plataformas comunes y puntos de mayor valor.

Evitación de big bang migration que deja sin visibilidad a producción.

Adaptación de dashboards y alertas a semantic conventions.

Comunicación con equipos de desarrollo para instrumentación progresiva.

Retirada controlada de agentes duplicados y reducción de costes.

Gestión de resistencia interna por cambio de herramientas o pérdida de hábitos.

Ejercicio práctico: crear roadmap de migración OpenTelemetry para una empresa con monitorización heredada.

Observabilidad de ingress controllers, gateways, reverse proxies, service mesh y balanceadores mediante métricas, logs y trazas.

Integración con Envoy, NGINX, Istio, Linkerd o componentes equivalentes según stack.

Análisis de latencia de red, errores 4xx/5xx, timeouts, retries y saturación de conexiones.

Propagación de contexto a través de proxies y gateways.

Correlación entre trazas de aplicación y métricas de infraestructura de red.

Detección de problemas de DNS, TLS, routing, circuit breaking o políticas de malla.

Separación de errores de cliente, backend, proxy y red.

Diseño de dashboards para tráfico norte-sur y este-oeste.

Control de cardinalidad en rutas, hosts, clients y labels de red.

Ejercicio práctico: investigar una degradación de latencia originada en ingress o proxy.

Instrumentación y monitorización de PostgreSQL, MySQL, Redis, Kafka, RabbitMQ, Elasticsearch u otros sistemas críticos.

Correlación entre spans de aplicación y métricas del sistema externo.

Identificación de queries lentas, saturación, errores de conexión, retries, timeouts y backpressure.

Uso de semantic conventions para bases de datos y mensajería.

Observabilidad de procesos asíncronos donde la traza se fragmenta si no se propaga contexto.

Diseño de métricas de salud para brokers, colas, consumers y productores.

Control de atributos sensibles en queries, statements o mensajes.

Integración con exporters existentes y Collector.

Creación de runbooks para degradaciones en base de datos o cola.

Ejercicio práctico: diagnosticar un cuello de botella entre API, cola y base de datos.

Evaluación de cuándo basta auto-instrumentación y cuándo se requiere instrumentación manual.

Revisión de agentes por lenguaje como Java, .NET, Python, Node.js, Go y otros, sin repetir fundamentos de SDK.

Definición de responsabilidades entre plataforma y desarrollo: qué instala infraestructura y qué debe añadir aplicación.

Uso de auto-instrumentación en Kubernetes mediante Operator o configuración declarativa.

Identificación de gaps de auto-instrumentación: spans mal nombrados, contexto de negocio ausente, errores no capturados o atributos insuficientes.

Diseño de guías para que desarrollo añada spans y métricas de negocio mínimos.

Control de versiones de agentes y compatibilidad con frameworks.

Validación de instrumentación antes de liberar servicios.

Preparación de estándares internos de instrumentación.

Ejercicio práctico: analizar una aplicación auto-instrumentada y definir qué faltaría instrumentar manualmente.

Uso de telemetría para observar pipelines CI/CD, despliegues, releases, fallos de build y tiempos de entrega.

Aplicación de semantic conventions emergentes de CI/CD cuando estén disponibles o en evolución.

Correlación entre despliegue reciente e incidente operativo.

Enriquecimiento de recursos con versión, commit, build, release, deployment.environment y service.version.

Integración de OpenTelemetry con GitOps, Helm, Argo CD, Flux o pipelines equivalentes.

Creación de dashboards de calidad de despliegue y frecuencia de errores post-release.

Registro de cambios de configuración del Collector como parte del ciclo de entrega.

Validación automática de Collector configs en CI antes de aplicar cambios.

Uso de entornos staging para probar telemetría antes de producción.

Ejercicio práctico: incorporar service.version y deployment metadata al análisis de una incidencia tras despliegue.

Cálculo de costes de observabilidad por volumen de métricas, logs, trazas, perfiles, cardinalidad, retención y consultas.

Identificación de fuentes de coste invisible: labels dinámicas, logs verbose, sampling inexistente, duplicidad de señales y entornos no productivos.

Diseño de políticas de reducción de ruido antes de exportar datos al backend.

Priorización de telemetría de alto valor operativo frente a telemetría exhaustiva sin uso.

Uso de filtros, agregaciones, sampling y drop de atributos para controlar ingestión.

Asignación de costes por equipo, servicio, namespace o producto.

Creación de métricas FinOps de observabilidad.

Comunicación de decisiones de reducción de telemetría sin generar sensación de pérdida de visibilidad.

Preparación de revisiones periódicas de cardinalidad y uso de dashboards.

Ejercicio práctico: reducir un 40% de volumen simulado manteniendo señales críticas.

Diseño de un modelo de gobierno para OpenTelemetry con ownership, estándares, revisiones, plantillas y soporte interno.

Creación de golden paths para equipos de aplicación: cómo instrumentar, qué atributos usar, dónde ver dashboards y cómo pedir ayuda.

Definición de políticas de servicio: naming, resource attributes, logs estructurados, trazas mínimas, métricas obligatorias y datos prohibidos.

Gestión de excepciones para servicios legacy o críticos.

Creación de repositorio central de Collector configs, Helm values, dashboards y runbooks.

Definición de proceso de onboarding de nuevos equipos y servicios.

Preparación de formación interna para que OpenTelemetry no dependa de una sola persona.

Evaluación periódica de adopción, calidad de telemetría, costes y utilidad en incidentes.

Coordinación entre SRE, plataforma, seguridad, desarrollo y dirección técnica.

Ejercicio práctico: crear una guía corporativa de OpenTelemetry para equipos internos.

Diseño de runbooks conectados a señales OpenTelemetry para incidentes de latencia, errores, saturación, pérdida de logs o fallo de Collector.

Uso de dashboards, trazas, logs y métricas en un flujo de investigación ordenado.

Separación entre detección, triage, diagnóstico, mitigación, comunicación y postmortem.

Creación de preguntas operativas durante un incidente: qué cambió, qué servicio falla, qué dependencia se degradó, qué usuarios impacta y qué señal lo demuestra.

Uso de trace exemplars, logs correlacionados y métricas de infraestructura para acortar diagnóstico.

Documentación de evidencias en postmortems.

Identificación de gaps de telemetría detectados durante incidentes reales.

Mejora continua de dashboards, alertas y sampling después de incidentes.

Preparación de ejercicios de simulación GameDay con fallos de Collector, backend y aplicación.

Ejercicio práctico: resolver un incidente simulado usando señales OpenTelemetry y redactar postmortem técnico.

Diseño de arquitectura OpenTelemetry para una plataforma Kubernetes con servicios, nodos, logs, métricas, trazas, Prometheus y backend observability.

Despliegue de Collectors como DaemonSet y gateway con pipelines separados para traces, metrics y logs.

Configuración de receivers, processors, exporters, k8sattributes, memory_limiter, batch, filtros y políticas de atributos.

Incorporación de hostmetrics, kubeletstats, Prometheus scraping, logs de contenedores y telemetría OTLP de aplicaciones.

Implementación de tail sampling para conservar errores y latencias altas reduciendo volumen.

Aplicación de sanitización de atributos sensibles y reducción de cardinalidad.

Configuración de dashboards y alertas para salud del Collector, Kubernetes, servicios y pipeline de telemetría.

Simulación de incidencia con pérdida de telemetría, latencia distribuida y saturación de Collector.

Documentación del despliegue en Markdown con arquitectura, configuración, runbooks, políticas y procedimientos de operación.

Presentación final defendiendo decisiones técnicas, seguridad, escalabilidad, coste, gobierno, limitaciones y evolución futura.