Observabilidad
Observabilidad es poder saber qué está pasando dentro de tus aplicaciones mirando sólo lo que ellas cuentan desde fuera: sus registros, sus números y el recorrido de cada petición.
El problema: cientos de piezas, ¿cuál falla?
Con una sola aplicación en un solo servidor, si algo va mal entras y miras. En Kubernetes la tienda puede ser veinte microservicios con tres copias cada uno, repartidos por diez nodos, y los Pods nacen y mueren constantemente. Cuando un cliente se queja de que «el pago va lento», no puedes entrar en sesenta Pods a mirar uno a uno.
Hace falta que las aplicaciones cuenten lo que les pasa y que haya herramientas que recojan, guarden y crucen toda esa información.
Monitorizar y observar no es lo mismo
- Monitorizar (monitoring) es vigilar cosas que ya sabes que pueden fallar: «avísame si la CPU pasa del 90 %». Responde a preguntas que te hiciste antes.
- Observabilidad (observability) es tener datos suficientes para responder preguntas nuevas que no habías previsto: «¿por qué sólo los clientes de Portugal que pagan con tarjeta tardan 8 segundos?».
Monitorizar es el testigo del aceite del coche: se enciende cuando pasa algo concreto que alguien previó. La observabilidad es lo que tiene el mecánico cuando conecta el ordenador de diagnóstico: puede investigar cualquier síntoma raro, aunque no exista un testigo para él.
Los tres pilares: logs, métricas y trazas
La información que cuentan las aplicaciones es de tres tipos. El examen los llama los tres pilares de la observabilidad:
- Logs
- Mensajes de texto que la aplicación va escribiendo con la hora, como un diario. Sirven para saber qué pasó exactamente en un momento concreto.
- Métricas
- Números que se miden cada pocos segundos, como las peticiones por segundo o la memoria usada. Sirven para ver tendencias y saber cuánto de algo hay.
- Trazas
- El recorrido de una sola petición por todos los servicios que toca, con el tiempo que pasa en cada uno. Sirven para encontrar dónde se atasca.
| Pilar | Qué es | Cuándo lo usas |
|---|---|---|
| Logs logs | Mensajes de texto con fecha que la aplicación escribe cuando pasa algo. | Para saber el detalle de un suceso: qué error exacto dio el pedido 881. |
| Métricas metrics | Números medidos cada poco tiempo: peticiones por segundo, memoria usada, errores por minuto. | Para ver tendencias y lanzar alertas. Ocupan poco y se guardan mucho tiempo. |
| Trazas traces | El recorrido de una petición por todos los servicios, con cuánto tardó en cada uno. | Para encontrar dónde se pierde el tiempo en un sistema de microservicios. |
A las 10:00 salta una alerta: los errores de la tienda han subido al 5 % (métrica). Abres una traza de un pedido fallido y ves que se queda atascado en el servicio de pagos. Miras los logs de pagos a esa hora y aparece: «ERROR: el banco no responde». Las tres piezas juntas te llevan del síntoma a la causa.
Métricas con Prometheus
Prometheus es la herramienta estándar de métricas en Kubernetes. Fue el segundo proyecto en graduarse en la CNCF, después del propio Kubernetes. Guarda las métricas como series temporales (time series): una lista de valores con la hora a la que se midió cada uno, y unas etiquetas que dicen de qué es (de qué Pod, de qué servicio…).
Prometheus va a buscar los datos: modelo pull
Lo más característico de Prometheus es que no espera a que le manden datos: él visita cada aplicación cada pocos segundos y lee sus números. A esa visita se le llama scrape (raspar). Cada aplicación publica sus métricas en una dirección web, normalmente /metrics, en un formato de texto sencillo.
Prometheus es el lector de contadores de la luz. Pasa por cada casa cada cierto tiempo, mira el contador y lo apunta. Las casas no tienen que llamar a la compañía; sólo tienen que tener el contador a la vista.
- /metrics
- Una dirección web que la aplicación deja abierta con sus números actuales, para que Prometheus pase a leerlos.
- Exporter
- Un pequeño programa traductor. Saca los números de algo que no habla el idioma de Prometheus, como una base de datos MySQL o un servidor, y los publica en /metrics.
- scrape
- Así se llama la lectura periódica: Prometheus visita cada /metrics cada 15 o 30 segundos y se lleva los números.
- Prometheus
- El programa de la CNCF que recoge las métricas y las guarda. Es el estándar para métricas en Kubernetes.
- Series temporales
- Cada métrica guardada como una lista de valores con su hora, para poder ver cómo cambia a lo largo del tiempo.
- PromQL
- El lenguaje para preguntarle cosas a Prometheus, por ejemplo «peticiones por segundo de la tienda en la última hora».
- Grafana
- La herramienta que dibuja paneles y gráficas bonitas a partir de los datos de Prometheus y de otras fuentes.
- Alertmanager
- La pieza que recibe las alertas de Prometheus, junta las repetidas y avisa a las personas por correo, Slack o el móvil.
- Exporters: pequeños programas que traducen a formato Prometheus las métricas de algo que no lo habla de serie, como una base de datos MySQL o el propio servidor (el node exporter).
- PromQL: el lenguaje para hacer preguntas a Prometheus, como «media de peticiones por segundo de los últimos 5 minutos, por servicio».
- Alertmanager: Prometheus evalúa reglas de alerta («errores por encima del 5 % durante 5 minutos») y, cuando una salta, se la pasa a Alertmanager, que agrupa los avisos repetidos, los silencia si hace falta y los envía por correo, Slack, etc.
- Grafana: no guarda métricas. Es la herramienta para dibujarlas en paneles, leyendo de Prometheus y de muchas otras fuentes.
Para trabajos muy cortos que terminan antes de que Prometheus pase a leerlos existe una excepción, el Pushgateway: el trabajo deja allí sus números y Prometheus los lee después. Es la excepción que confirma la regla del modelo pull.
Los cuatro tipos de métrica
| Tipo | Cómo se comporta | Ejemplo cotidiano |
|---|---|---|
| Counter | Sólo sube (o vuelve a cero si la aplicación se reinicia). | El cuentakilómetros: total de pedidos atendidos. |
| Gauge | Sube y baja. | El indicador de gasolina: memoria usada ahora mismo, usuarios conectados. |
| Histogram | Reparte las mediciones en tramos (buckets) para ver la distribución. | Cuántas peticiones tardaron menos de 0,1 s, menos de 0,5 s, menos de 1 s… |
| Summary | Parecido al histograma, pero calcula los percentiles en la propia aplicación. | «El 95 % de las peticiones tardó menos de 0,4 s». |
Prometheus usa un modelo pull: hace scrape del endpoint HTTP /metrics de cada objetivo. Si una respuesta dice que «las aplicaciones envían sus métricas a Prometheus», es incorrecta (salvo el caso especial del Pushgateway). Y un contador que «baja» no es un counter: es un gauge.
Métricas del propio Kubernetes
Dos piezas que conviene distinguir:
- metrics-server: recoge el consumo de CPU y memoria de Pods y nodos en tiempo real. Es lo que usan kubectl top y el autoescalado HPA de la lección 05. No guarda historial.
- kube-state-metrics: publica en formato Prometheus el estado de los objetos de Kubernetes: cuántas réplicas pide un Deployment y cuántas están listas, cuántos Pods están en Pending…
Trazas: seguir una petición de punta a punta
Una traza (trace) es el viaje completo de una petición. Está hecha de tramos (spans): cada tramo es el trabajo de un servicio, con su hora de inicio y su duración. Todos los tramos de un mismo viaje comparten un identificador, así se pueden juntar aunque pasen por diez servicios distintos.
Es el seguimiento de un paquete de mensajería: «recogido en Madrid 9:00, centro de Zaragoza 13:00, en reparto 18:00». Con el número de seguimiento ves todo el recorrido y dónde estuvo parado más tiempo.
- Span
- Cada barra del dibujo: un tramo de trabajo hecho por un servicio, con su inicio y su duración.
- Traza
- El conjunto de todos los spans de una misma petición. Juntos cuentan la historia completa de esa petición de principio a fin.
Jaeger es la herramienta de trazas más conocida de la CNCF (proyecto graduado): recoge los tramos, los junta y los dibuja como en el diagrama de arriba.
OpenTelemetry: un solo idioma para contarlo todo
Para que una aplicación cuente sus métricas y trazas hay que instrumentarla: añadirle el código que mide. Antes cada herramienta tenía su propia forma, y cambiar de herramienta obligaba a cambiar el código. OpenTelemetry (OTel) es el estándar abierto que lo unifica.
OpenTelemetry es como el cargador USB-C. Antes cada marca tenía su enchufe; ahora todos usan el mismo y puedes conectar cualquier aparato a cualquier cargador. Instrumentas una vez con OpenTelemetry y mandas los datos a la herramienta que quieras.
- OTel
- Abreviatura de OpenTelemetry: el estándar abierto de la CNCF para que las aplicaciones generen métricas, trazas y logs de la misma manera, en cualquier lenguaje.
- OTel Collector
- Un programa intermedio que recibe los datos de todas las aplicaciones, los filtra y los reparte a las herramientas que elijas.
- Prometheus
- Herramienta que guarda métricas. Aquí es uno de los destinos a los que el Collector envía datos.
- Jaeger
- Herramienta de la CNCF para guardar y ver trazas. Muestra el recorrido de cada petición como el dibujo de barras anterior.
- OpenTelemetry cubre los tres pilares: métricas, trazas y logs.
- Da librerías para cada lenguaje (SDKs) y un programa intermedio, el Collector, que recibe los datos, los procesa y los manda a una o varias herramientas.
- OpenTelemetry no guarda ni dibuja datos: sólo los genera y los transporta. Para guardarlos sigues necesitando Prometheus, Jaeger u otra.
- Nació en 2019 de la fusión de dos proyectos anteriores: OpenTracing y OpenCensus.
Logs en Kubernetes
En Kubernetes, la regla es sencilla: las aplicaciones escriben sus logs por la salida estándar (stdout y stderr), es decir, como si los imprimieran en pantalla, en vez de guardarlos en ficheros propios. El runtime de cada nodo recoge esa salida y la guarda en ficheros del nodo. Es lo que lees con kubectl logs.
El problema: si el Pod se borra o el nodo se cae, esos ficheros desaparecen. Por eso se instala un recolector de logs en cada nodo, normalmente con un DaemonSet (una copia por nodo, lección 03), que lee los ficheros y los envía a un almacén central.
- Nodo
- Un ordenador del clúster donde se ejecutan los Pods.
- Pod
- Tu aplicación en marcha dentro del clúster.
- stdout
- La «salida estándar»: el sitio donde un programa escribe sus mensajes normales. En Kubernetes, lo que la aplicación escribe ahí acaba como log.
- /var/log/pods
- La carpeta del nodo donde se guardan en ficheros los logs de los Pods de ese nodo.
- Fluent Bit
- Un programa ligero que lee esos ficheros de logs y los envía a un almacén central. Es de la familia de Fluentd, proyecto de la CNCF.
- DaemonSet
- El tipo de objeto que pone una copia de un Pod en cada nodo. Así hay un recolector de logs en cada máquina.
- Elasticsearch, Loki
- Almacenes donde se guardan los logs de todo el clúster para poder buscarlos aunque el Pod ya no exista.
- kubectl logs
- El comando para ver los logs de un Pod. Sólo lee lo que queda en el nodo, por eso hace falta un almacén central.
Las herramientas de la CNCF para esto son Fluentd (proyecto graduado) y su hermano pequeño Fluent Bit, más ligero, que es el que se suele poner en cada nodo. Los dos recogen logs de muchos sitios, los transforman y los envían a donde se guardan.
Kubernetes no trae un sistema para guardar logs de forma centralizada. kubectl logs sólo lee lo que queda en el nodo. La forma recomendada es que las aplicaciones escriban por stdout/stderr y que un agente por nodo (DaemonSet) los envíe fuera. Otra opción es un contenedor sidecar que recoja los logs de su Pod.
¿Va bien o va mal? SLI, SLO y SLA
Con todos estos datos falta decidir qué es «ir bien». Para eso hay tres siglas que se confunden mucho:
- SLI
- Service Level Indicator, el indicador: lo que se mide, por ejemplo el porcentaje de pedidos que salen bien en menos de un segundo.
- SLO
- Service Level Objective, el objetivo: la cifra que el equipo se exige a sí mismo para ese indicador.
- SLA
- Service Level Agreement, el contrato: lo prometido al cliente por escrito, con compensación si no se cumple. Suele ser menos exigente que el SLO.
- Error budget
- El margen de fallo permitido: lo que queda hasta el 100 %. Con un SLO del 99,9 %, son unos 43 minutos al mes en los que algo puede ir mal.
- SLI (Service Level Indicator): el indicador, lo que mides. Por ejemplo, el porcentaje de peticiones que responden bien en menos de un segundo.
- SLO (Service Level Objective): el objetivo interno para ese indicador. «El 99,9 % de las peticiones tiene que ir bien cada mes».
- SLA (Service Level Agreement): el contrato con el cliente, con consecuencias si no se cumple (devolver dinero, por ejemplo). Suele ser menos exigente que el SLO, para tener margen.
- Error budget (presupuesto de errores): lo que te puedes permitir fallar sin romper el SLO. Con un SLO del 99,9 %, el presupuesto es un 0,1 %, unos 43 minutos al mes. Mientras quede presupuesto, el equipo puede arriesgarse a sacar versiones nuevas; si se agota, toca centrarse en estabilidad.
Un tren de cercanías. El SLI es el porcentaje de trenes que llegan con menos de 5 minutos de retraso. El SLO es la meta interna de la compañía: el 98 %. El SLA es lo que pone en el billete: si llegas con más de 15 minutos de retraso, te devuelven el dinero.
Y cuánto cuesta: FinOps
En la nube, cada Pod consume CPU y memoria que alguien paga. FinOps es la práctica de hacer visible y repartir ese gasto entre equipos, y de reducirlo: ajustar los requests a lo que de verdad se usa (lección 05), apagar entornos de pruebas por la noche, usar máquinas más baratas cuando se puede. OpenCost es un proyecto de la CNCF que calcula cuánto cuesta cada namespace, Deployment o Pod.
Resumen en cinco frases
- Monitorizar vigila lo previsto; la observabilidad permite investigar lo imprevisto.
- Los tres pilares son logs (qué pasó), métricas (cuánto) y trazas (por dónde pasó una petición).
- Prometheus va a leer el /metrics de cada aplicación (pull), se consulta con PromQL, avisa con Alertmanager y se dibuja con Grafana.
- OpenTelemetry es el estándar para instrumentar y transportar los datos; Jaeger muestra trazas y Fluentd o Fluent Bit recogen logs.
- El SLI es la medida, el SLO el objetivo, el SLA el contrato, y el error budget lo que te puedes permitir fallar.
Términos del examen
- Observability
- Capacidad de entender qué pasa dentro de un sistema a partir de los datos que emite.
- Logs · Metrics · Traces
- Los tres pilares: mensajes con fecha, números medidos y recorridos de peticiones.
- Span
- Cada tramo de una traza: el trabajo de un servicio.
- Prometheus
- Sistema de métricas y alertas, proyecto graduado de la CNCF.
- Scrape
- La lectura periódica que hace Prometheus del endpoint /metrics.
- Time series
- Serie de valores con su hora y sus etiquetas.
- PromQL
- El lenguaje de consultas de Prometheus.
- Exporter
- Traductor de métricas de otro sistema al formato Prometheus.
- Alertmanager
- Agrupa, silencia y envía las alertas de Prometheus.
- Pushgateway
- Excepción para trabajos cortos que dejan allí sus métricas.
- Counter · Gauge
- Métrica que sólo sube · métrica que sube y baja.
- Histogram · Summary
- Métricas que describen la distribución de valores (tramos o percentiles).
- Grafana
- Herramienta para dibujar paneles a partir de datos.
- metrics-server
- Consumo de CPU y memoria en tiempo real; lo usan kubectl top y el HPA.
- OpenTelemetry
- Estándar para instrumentar y enviar métricas, trazas y logs. Une OpenTracing y OpenCensus.
- OTel Collector
- Programa que recibe, procesa y reparte los datos de telemetría.
- Jaeger
- Herramienta de trazas distribuidas, graduada en la CNCF.
- Fluentd · Fluent Bit
- Recolectores de logs; Fluent Bit es la versión ligera.
- stdout / stderr
- Salidas estándar por las que las aplicaciones deben escribir sus logs.
- SLI · SLO · SLA
- Indicador · objetivo interno · contrato con el cliente.
- Error budget
- Margen de fallo permitido por el SLO.
- FinOps · OpenCost
- Gestión del gasto en la nube · herramienta de la CNCF para medirlo.
Comprueba que lo has entendido
1. How does Prometheus usually collect metrics from applications?
- Applications push metrics to Prometheus over SMTP
- Prometheus scrapes an HTTP endpoint such as /metrics on each target
- Prometheus reads metrics directly from etcd
- Fluentd forwards metrics to Prometheus
Ver respuesta
B. Prometheus usa el modelo pull: visita periódicamente el endpoint /metrics de cada objetivo y lee sus valores.
2. Which metric type can only increase, or reset to zero when the process restarts?
- Gauge
- Histogram
- Counter
- Summary
Ver respuesta
C. El counter es el cuentakilómetros: sólo sube. El gauge sube y baja, como el indicador de gasolina.
3. Which signal shows the path of a single request across multiple microservices and how long each step took?
- Logs
- Metrics
- Traces
- Events
Ver respuesta
C. Una traza sigue una petición de punta a punta y la divide en spans, uno por servicio, con su duración.
4. Which CNCF project provides vendor-neutral APIs, SDKs and a collector for metrics, traces and logs, and was formed by merging OpenTracing and OpenCensus?
- Jaeger
- OpenTelemetry
- Grafana
- Fluent Bit
Ver respuesta
B. OpenTelemetry es el estándar de instrumentación. Ojo: genera y transporta datos, pero no los guarda; para eso están Prometheus, Jaeger y otras herramientas.
5. What is the recommended way for a containerized application to emit logs in Kubernetes?
- Write them to a file inside the container image
- Send them directly to etcd
- Write them to stdout and stderr, and let a node-level agent collect them
- Store them in a ConfigMap
Ver respuesta
C. Las aplicaciones escriben por stdout/stderr, el nodo lo guarda y un agente por nodo (normalmente un DaemonSet de Fluent Bit o Fluentd) lo envía a un almacén central.