Métricas de Prometheus: monitoriza el rendimiento de tu aplicación
Métricas de Prometheus: monitoriza el rendimiento de tu aplicación
¿Qué es Prometheus?
Prometheus es una herramienta de código abierto que realiza un seguimiento del rendimiento y la salud de los sistemas de software. Recopila puntos de datos, conocidos como métricas, que ofrecen información sobre qué tan bien funciona un sistema. Estas métricas ayudan a detectar problemas de forma temprana y a analizar el comportamiento del sistema. Con Prometheus, los equipos pueden detectar problemas antes de que afecten a los usuarios para mantener servicios fiables y eficientes.
¿Qué son las métricas en Prometheus?
En Prometheus, las métricas son valores numéricos que realizan un seguimiento de aspectos específicos del comportamiento y el rendimiento de un sistema a lo largo del tiempo. Estas métricas ayudan a comprender qué tan bien funciona un sistema en diversas condiciones y también proporcionan alertas en condiciones que podrían indicar problemas, como un aumento repentino del tráfico o una caída en el rendimiento del sistema. Pueden monitorizar una amplia variedad de datos, desde el número de usuarios activos en un sitio web hasta la cantidad de memoria que usa una aplicación.
Formato de métricas en Prometheus
Las métricas en Prometheus se almacenan en un formato de series temporales, donde cada métrica se identifica por su nombre y pares clave-valor opcionales llamados etiquetas, que proporcionan contexto adicional como nombres de servicios o tipos de errores. El formato principal para los datos de métricas en Prometheus es el Prometheus Exposition Format. Este formato de texto plano es fácil de generar y analizar, y consta de líneas de datos que incluyen el nombre de la métrica, etiquetas opcionales, el valor de la métrica y una marca de tiempo.
Los cuatro tipos de métricas en Prometheus
Prometheus clasifica las métricas en cuatro tipos principales: contadores, medidores, histogramas y resúmenes. Cada tipo cumple una función específica en la monitorización y proporciona diferentes perspectivas sobre el comportamiento de tus sistemas.
Métricas de contador
Las métricas de contador en Prometheus registran el número de veces que ocurre un evento particular. Solo aumentan con el tiempo o se restablecen a cero cuando el proceso se reinicia. Por lo tanto, se utilizan para realizar un seguimiento de cantidades acumulativas como el número de solicitudes gestionadas, tareas completadas o errores registrados.
Para implementar un contador que realice un seguimiento del número de solicitudes recibidas por un servidor, puedes usar el siguiente fragmento de código. Este ejemplo configura un contador para monitorizar el número total de solicitudes HTTP recibidas. Cada vez que se llama a la función handle_request, el contador se incrementa.
from prometheus_client import Counter
# Create a counter metric for tracking received requests
request_counter = Counter('http_requests_received_total', 'Total HTTP requests received')
def handle_request(request):
# Process the request
# ...
# Increment the counter by 1 each time this function is called
request_counter.inc()
Mejores prácticas para usar contadores
Conciencia de restablecimiento: Ten en cuenta que los contadores se restablecen a cero cuando el proceso se reinicia. Diseña tu monitorización para tener en cuenta estos restablecimientos.
Usa etiquetas: Usa etiquetas con contadores para proporcionar información más detallada, como distinguir entre diferentes tipos de errores o solicitudes.
Incremento coherente: Asegúrate de que el contador se incremente en el lugar correcto de tu código para reflejar con precisión los eventos que estás siguiendo.
Monitorización de restablecimientos: Usa la función rate en las consultas para calcular la tasa media de aumento por segundo de un contador, lo que puede ayudarte a comprender tendencias y detectar problemas, incluso con restablecimientos.
Métricas de medidor
Las métricas de medidor en Prometheus miden valores que pueden aumentar y disminuir, como temperaturas de CPU, números actuales de procesos en ejecución o cantidades de memoria libre. A diferencia de los contadores, que solo aumentan, los medidores reflejan el estado actual del sistema en un momento específico, lo que los hace esenciales para realizar un seguimiento de métricas fluctuantes.
Para implementar un gauge que monitorice la cantidad de memoria libre en un sistema, puedes usar el siguiente fragmento de código. Este ejemplo configura un gauge para monitorizar la memoria libre, actualizando el valor del gauge llamando a la función update_free_memory(), que debe activarse para reflejar los cambios del sistema.
from prometheus_client import Gauge
# Create a gauge metric to track free memory
free_memory_gauge = Gauge('system_free_memory_bytes', 'Amount of free memory in bytes')
def update_free_memory():
# Assume get_free_memory() is a function that fetches the current free memory
free_memory = get_free_memory()
free_memory_gauge.set(free_memory)
# Update gauge regularly or upon specific system events
update_free_memory()
Consejos para utilizar gauges
Actualizaciones regulares: Verifica que los gauges se actualicen regularmente para reflejar con precisión el estado actual del sistema.
Uso contextual: Usa gauges para métricas que requieran hacer seguimiento de subidas y bajadas a lo largo del tiempo, como promedios de carga o recursos del sistema disponibles.
Evitar el uso indebido: Ten cuidado de no usar gauges para métricas que solo deberían incrementarse o decrementarse, donde un contador o un histograma podrían ser más apropiados.
Métricas de histograma
Los histogramas en Prometheus resumen la distribución de datos numéricos en un conjunto de buckets predefinidos. Cada bucket representa un rango de valores, y el histograma cuenta cuántos valores caen en cada bucket. Este tipo de métrica es útil para hacer seguimiento de mediciones como latencias de solicitudes o tamaños de respuesta, donde comprender la distribución puede proporcionar más información que simplemente conocer el promedio.
Para implementar un histograma que haga seguimiento de la latencia de solicitudes HTTP, puedes usar el siguiente fragmento de código. Este ejemplo configura un histograma con varios buckets para medir cuánto tarda en procesarse cada solicitud HTTP. El bloque with mide automáticamente la duración del manejo de la solicitud y la registra en el bucket correspondiente.
from prometheus_client import Histogram
# Define a histogram with buckets for request latency
request_latency_histogram = Histogram('http_request_latency_seconds', 'HTTP request latencies', buckets=[0.1, 0.2, 0.5, 1, 2, 5])
def handle_request(request):
with request_latency_histogram.time():
# Process the request
# This automatically measures the time taken by this block and records it in the histogram
pass
Buckets de histograma y su importancia
Diseño de buckets: Elegir los buckets adecuados es crucial para obtener histogramas útiles. Los buckets deben alinearse con los objetivos y umbrales de rendimiento de tu aplicación. Por ejemplo, si te importa diferenciar entre solicitudes que tardan 0,1 segundos y 1 segundo, tus buckets deben reflejar estos intervalos.
Granularidad: Más buckets aumentan la granularidad del histograma, pero también aumentan el uso de memoria. Equilibra el nivel de detalle con la eficiencia de recursos.
Conteo acumulativo: Los histogramas de Prometheus son acumulativos. Esto significa que cada bucket cuenta el número total de observaciones que caen dentro de su rango y de todos los rangos anteriores. Esto calcula percentiles, que son más informativos sobre la distribución de los datos que los promedios.
Uso en consultas: Al consultar histogramas, funciones como histogram
_quantile()pueden calcular cuantiles a partir de los buckets acumulativos, proporcionando información valiosa sobre las características de rendimiento de tu sistema.
Métricas de resumen
Las métricas de resumen en Prometheus ofrecen una forma de calcular cuantiles de observaciones, como el percentil 90 de las latencias de solicitudes, directamente dentro del cliente. A diferencia de los histogramas, que recopilan y categorizan datos en buckets, los resúmenes calculan cuantiles en streaming sin buckets predefinidos. Esto hace que los resúmenes sean ideales para situaciones en las que se necesitan cálculos de cuantiles precisos, especialmente cuando los umbrales exactos son importantes, como al informar sobre acuerdos de nivel de servicio (SLA).
Para implementar un resumen que mida la latencia de las consultas a la base de datos, puedes usar el siguiente fragmento de código. Este ejemplo configura un resumen para supervisar el tiempo que tardan las consultas a la base de datos. El bloque with mide la duración de la consulta y actualiza el resumen con esta nueva observación, facilitando el cálculo de cuantiles.
from prometheus_client import Summary
# Crear un resumen para medir las latencias de las consultas a la base de datos
db_query_latency = Summary('db_query_latency_seconds', 'Database query latencies')
def query_database(query):
with db_query_latency.time():
# Ejecutar la consulta a la base de datos
# El tiempo que tarda este bloque se registra y calcula automáticamente en el resumen
pass
Diferencia entre histogramas y resúmenes
Cálculo de cuantiles: Los histogramas estiman cuantiles en función de los buckets definidos, lo que puede introducir imprecisiones dependiendo de la configuración de los buckets. Los resúmenes calculan cuantiles directamente a partir de los datos observados, lo que potencialmente ofrece más precisión.
Carga del lado del cliente: Los resúmenes calculan cuantiles en el lado del cliente, lo que puede aumentar la carga computacional, especialmente con un alto número de observaciones. Los histogramas, con sus buckets predefinidos, pueden reducir el cálculo del lado del cliente.
Configuración: Los histogramas requieren conocimiento previo de la distribución para establecer buckets adecuados. Los resúmenes no requieren configuración de buckets, lo que los hace más fáciles de desplegar inicialmente, pero potencialmente más intensivos en recursos.
Casos de uso: Los resúmenes se prefieren cuando se necesitan cuantiles precisos en tiempo real para métricas críticas, mientras que los histogramas suelen ser más adecuados para capturar la distribución más amplia de una métrica donde los umbrales exactos son menos críticos.
Mejores prácticas para etiquetar y agrupar métricas
Uso adecuado de etiquetas
Las etiquetas en Prometheus son pares clave-valor que adjuntan metadatos a las métricas para consultas más detalladas y específicas. Son importantes para organizar e identificar métricas en dimensiones como nombres de servicios, nombres de host o tipos de error. Estas son algunas mejores prácticas para usar etiquetas:
Descriptivas y consistentes: Elige nombres de etiquetas que describan claramente su propósito y mantén la coherencia en todas tus métricas. Por ejemplo, usa service para todas las métricas que identifican el servicio al que pertenecen.
Granularidad necesaria: Aunque las etiquetas pueden añadir un detalle significativo a tus métricas, demasiadas etiquetas pueden aumentar los costos de almacenamiento y disminuir el rendimiento de las consultas. Usa etiquetas con criterio para equilibrar la granularidad con el rendimiento.
Evitar alta cardinalidad: Las etiquetas de alta cardinalidad, como aquellas que podrían etiquetar a cada usuario individual o dirección de correo electrónico, pueden aumentar el tamaño de los datos y degradar el rendimiento. Cíñete a etiquetas que tengan un número razonable de valores distintos.
Este ejemplo muestra un contador que usa etiquetas para distinguir entre diferentes métodos HTTP y estados para un análisis y monitoreo detallados.
from prometheus_client import Counter
# Crear un contador con etiquetas para métodos HTTP y estados de respuesta
http_requests_total = Counter('http_requests_total', 'Total HTTP requests',
['method', 'status'])
def handle_request(request):
# Incrementar el contador con las etiquetas apropiadas
http_requests_total.labels(method=request.method, status=request.response.status_code).inc()
Estrategias para agrupar métricas
Agrupar métricas de forma lógica puede mejorar la claridad y el rendimiento de los sistemas de monitoreo. Estas son algunas estrategias:
Categorizar por tipo: Agrupa las métricas por tipo, como errores, tráfico, latencia, etc., para que sea más fácil encontrar y analizar métricas relacionadas.
Agrupación basada en servicios: Organiza las métricas por el servicio que miden. Esto ayuda a aislar rápidamente problemas dentro de un servicio específico.
Usar nomenclatura jerárquica: Al nombrar métricas, considera una estructura jerárquica que refleje su agrupación, como
service_database_queries_totaloservice_http_requests_total.
Beneficios de una agrupación eficaz
Mejor rendimiento de consultas: La agrupación lógica puede dar lugar a consultas más eficientes al reducir el número de métricas que deben escanearse para cada consulta.
Gestión de alertas más sencilla: Agrupar métricas similares simplifica la creación de reglas de alerta y facilita la gestión de alertas en diferentes partes de tu sistema.
Mejor visualización: Las métricas agrupadas son más fáciles de visualizar en paneles, ya que las métricas relacionadas pueden mostrarse juntas, proporcionando una vista cohesionada del rendimiento del sistema.
Consultar métricas con PromQL
Conceptos básicos de PromQL y su sintaxis
PromQL, o Prometheus Query Language, es el potente lenguaje de consulta utilizado por Prometheus para explorar datos y generar alertas. PromQL permite consultas simples y complejas para calcular los datos exactos necesarios a partir de tus métricas. La sintaxis de PromQL admite la selección y agregación de datos de series temporales basándose en nombres de métricas, etiquetas e intervalos de tiempo.
Características clave de PromQL:
Consultas instantáneas y de rango: Las consultas instantáneas proporcionan el valor actual de la serie temporal para un punto específico en el tiempo, mientras que las consultas de rango devuelven valores de la serie temporal para un rango de tiempo.
Funciones y operadores: PromQL incluye varias funciones y operadores integrados para calcular tasas, promedios y operaciones aritméticas entre métricas.
Fragmentos de código: consultas comunes para cada tipo de métrica
Métricas de contador
Esta consulta calcula la tasa promedio por segundo de solicitudes HTTP durante los últimos 5 minutos, útil para monitorear la carga de tráfico en tus servidores.
rate(http_requests_total[5m])
Métricas de indicador
Esta consulta instantánea obtiene la cantidad actual de memoria libre, proporcionando una instantánea de los recursos del sistema.
node_memory_MemFree_bytes
Métricas de histograma
La siguiente consulta calcula el percentil 95 de las latencias de solicitudes durante los últimos 10 minutos, lo que ayuda a identificar valores atípicos en el rendimiento del servidor web.
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[10m]))
Métricas de resumen
La consulta siguiente calcula la latencia mediana de los eventos procesados, lo cual es crucial para evaluar el rendimiento de los sistemas de manejo de eventos.
quantile(0.5, rate(processed_events_latency_seconds_sum[5m]) / rate(processed_events_latency_seconds_count[5m]))
Consejos para consultas eficaces con PromQL:
Usa rangos de tiempo adecuados: Selecciona rangos de tiempo que proporcionen información significativa sin sobrecargar el sistema con consultas de datos históricos largos.
Aprovecha el filtrado por etiquetas: Usa etiquetas para filtrar y refinar los resultados, centrándote en subconjuntos específicos de datos.
Optimiza el rendimiento: Al escribir consultas, especialmente para paneles o alertas, considera su impacto en el rendimiento y optimízalas para que se ejecuten de manera eficiente.
Monitoreo del rendimiento de la base de datos vectorial Milvus con Prometheus
Milvus es una base de datos vectorial de código abierto, alto rendimiento y altamente escalable que puede almacenar, indexar y buscar datos no estructurados a escala de miles de millones mediante incrustaciones vectoriales de alta dimensión. Es perfecta para crear aplicaciones modernas de IA como generación aumentada por recuperación (RAG), búsqueda semántica, búsqueda multimodal y sistemas de recomendación. Milvus se ejecuta de manera eficiente en varios entornos, desde portátiles y dispositivos de borde hasta sistemas distribuidos a gran escala.
Prometheus ofrece capacidades integrales para supervisar el rendimiento de la base de datos vectorial Milvus. Milvus se integra perfectamente con Prometheus mediante:
Endpoint de Prometheus: Recopila datos de diversos exporters.
Prometheus Operator: Simplifica la gestión de las configuraciones de monitoreo de Prometheus.
Kube-Prometheus: Simplifica el monitoreo completo de clústeres Kubernetes para una operación robusta.
Utilizar Prometheus te permite hacer seguimiento de métricas críticas del rendimiento de Milvus, como los tiempos de respuesta de las consultas y el uso de recursos (CPU, GPU y memoria), lo que permite la resolución proactiva de problemas y la optimización del sistema. Además, integrar Prometheus con Grafana mejora aún más tu marco de monitoreo, proporcionando dashboards detallados para un análisis en profundidad y un mantenimiento eficiente de implementaciones de Milvus adaptadas a aplicaciones de GenAI y búsqueda por similitud.
Para obtener una guía completa sobre cómo configurar Prometheus para Milvus y visualizar métricas con Grafana, explora los recursos a continuación:
Conclusión
En conclusión, Prometheus es una herramienta valiosa para monitorear diversas métricas que reflejan el estado y el rendimiento de los sistemas. Al utilizar las capacidades de Prometheus para rastrear, analizar y visualizar datos operativos críticos, los equipos pueden mejorar sus prácticas de monitoreo y asegurarse de que sus sistemas no solo sean estables, sino que también estén optimizados para la eficiencia. Ya sea mediante la configuración de alertas para detectar posibles problemas de forma temprana o mediante el uso de dashboards detallados para obtener una vista clara de las métricas del sistema, Prometheus permite a los desarrolladores y administradores mantener servicios de alto rendimiento y confiables.
Preguntas frecuentes
- ¿Cuáles son los cuatro tipos de métricas en Prometheus?
Prometheus clasifica las métricas en cuatro tipos: contadores, medidores, histogramas y resúmenes. Cada tipo cumple un propósito de monitoreo específico, desde contar ocurrencias de eventos hasta capturar la distribución de mediciones a lo largo del tiempo.
- ¿Cómo elijo entre usar un histograma y un resumen?
Elige histogramas cuando necesites capturar distribuciones y puedas definir buckets significativos con antelación. Usa resúmenes cuando necesites cálculos de cuantiles precisos y no requieras buckets predefinidos. La elección depende de tu caso de uso específico y de las consideraciones de rendimiento.
- ¿Qué es PromQL y cómo se utiliza en Prometheus?
PromQL, o Prometheus Query Language, es el potente lenguaje utilizado para consultar métricas en Prometheus. Permite a los usuarios seleccionar y agregar datos de series temporales, realizar cálculos y obtener información a partir de métricas basadas en condiciones y rangos de tiempo específicos.
- ¿Puedo usar Prometheus para monitorear aplicaciones que no están construidas en una arquitectura de microservicios?
Sí, Prometheus es lo suficientemente versátil como para monitorear una amplia gama de aplicaciones, ya sea que estén construidas utilizando una arquitectura de microservicios o un enfoque monolítico más tradicional. Puede configurarse para extraer métricas de casi cualquier fuente que exponga datos en el Prometheus Exposition Format.
- ¿Cuáles son algunas mejores prácticas para etiquetar y agrupar métricas en Prometheus?
Al etiquetar y agrupar métricas, asegúrate de que las etiquetas sean descriptivas y coherentes en todas las métricas. Evita etiquetas de alta cardinalidad que puedan degradar el rendimiento. Agrupa las métricas lógicamente por tipo o servicio para aumentar la claridad y mejorar la eficiencia de las consultas. Esto ayuda a mantener un sistema de monitoreo organizado que sea más fácil de consultar y gestionar.
Recursos adicionales
- ¿Qué es Prometheus?
- ¿Qué son las métricas en Prometheus?
- Formato de métricas en Prometheus
- Los cuatro tipos de métricas en Prometheus
- Mejores prácticas para etiquetar y agrupar métricas
- Consultar métricas con PromQL
- Monitoreo del rendimiento de la base de datos vectorial Milvus con Prometheus
- Conclusión
- Preguntas frecuentes
- Recursos adicionales
Contenido
Comienza Gratis, Escala Fácilmente
Prueba la base de datos vectorial completamente gestionada construida para tus aplicaciones GenAI.
Prueba Zilliz Cloud Gratis