Métricas do Prometheus: Monitore o Desempenho do Seu App
Métricas do Prometheus: Monitore o Desempenho do Seu App
O que é o Prometheus?
Prometheus é uma ferramenta de código aberto que acompanha o desempenho e a integridade de sistemas de software. Ela coleta pontos de dados, conhecidos como métricas, que fornecem insights sobre quão bem um sistema funciona. Essas métricas ajudam a detectar problemas cedo e a analisar o comportamento do sistema. Com o Prometheus, as equipes podem identificar problemas antes que eles afetem os usuários para manter serviços confiáveis e eficientes.
O que são as Métricas no Prometheus?
No Prometheus, métricas são valores numéricos que acompanham aspectos específicos do comportamento e do desempenho de um sistema ao longo do tempo. Essas métricas ajudam a entender quão bem um sistema funciona sob várias condições e também fornecem alertas em condições que poderiam indicar problemas, como um pico repentino no tráfego ou uma queda no desempenho do sistema. Elas podem monitorar uma ampla variedade de dados, desde o número de usuários ativos em um site até a quantidade de memória que uma aplicação usa.
Formato das Métricas no Prometheus
As métricas no Prometheus são armazenadas em um formato de séries temporais, com cada métrica identificada por seu nome e pares opcionais de chave-valor chamados labels, que fornecem contexto adicional, como nomes de serviços ou tipos de erro. O formato principal para dados de métricas no Prometheus é o Prometheus Exposition Format. Esse formato de texto simples é fácil de gerar e analisar, consistindo em linhas de dados que incluem o nome da métrica, labels opcionais, o valor da métrica e um carimbo de data/hora.
Os Quatro Tipos de Métricas no Prometheus
O Prometheus categoriza métricas em quatro tipos principais: counters, gauges, histogramas e summaries. Cada tipo serve a uma função específica no monitoramento e fornece diferentes insights sobre o comportamento dos seus sistemas.
Métricas de Counter
Métricas de counter no Prometheus registram o número de vezes que um determinado evento ocorre. Elas apenas aumentam ao longo do tempo ou são redefinidas para zero quando o processo reinicia. Portanto, são usadas para acompanhar quantidades cumulativas, como o número de solicitações tratadas, tarefas concluídas ou erros registrados.
Para implementar um counter que acompanha o número de solicitações recebidas por um servidor, você pode usar o seguinte trecho de código. Este exemplo configura um counter para monitorar o número total de solicitações HTTP recebidas. Cada vez que a função handle_request é chamada, o counter é incrementado.
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()
Boas Práticas para Usar Counters
Consciência de Redefinição: Esteja ciente de que counters são redefinidos para zero quando o processo reinicia. Projete seu monitoramento para levar essas redefinições em conta.
Use Labels: Use labels com counters para fornecer insights mais detalhados, como distinguir entre diferentes tipos de erros ou solicitações.
Incremento Consistente: Certifique-se de que o counter seja incrementado no local correto no seu código para refletir com precisão os eventos que você está acompanhando.
Monitoramento de Redefinições: Use a função rate em consultas para calcular a taxa média de aumento por segundo de um counter, o que pode ajudar você a entender tendências e detectar problemas, mesmo com redefinições.
Métricas de Gauge
Métricas de gauge no Prometheus medem valores que podem aumentar e diminuir, como temperaturas da CPU, números atuais de processos em execução ou quantidades de memória livre. Ao contrário de counters, que apenas aumentam, gauges refletem o estado atual do sistema em um momento específico no tempo, tornando-os essenciais para acompanhar métricas flutuantes.
Para implementar um gauge que monitore a quantidade de memória livre em um sistema, você pode usar o seguinte trecho de código. Este exemplo configura um gauge para monitorar a memória livre, atualizando o valor do gauge ao chamar a função update_free_memory(), que deve ser acionada para refletir mudanças no 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()
Dicas para Utilizar Gauges
Atualizações Regulares: Verifique se os gauges são atualizados regularmente para refletir com precisão o estado atual do sistema.
Uso Contextual: Use gauges para métricas que exigem o rastreamento de aumentos e quedas ao longo do tempo, como médias de carga ou recursos de sistema disponíveis.
Evite o Uso Indevido: Tenha cuidado para não usar gauges para métricas que deveriam apenas incrementar ou decrementar, nas quais um contador ou um histograma pode ser mais apropriado.
Métricas de Histograma
Histogramas no Prometheus resumem a distribuição de dados numéricos em um conjunto de buckets predefinidos. Cada bucket representa um intervalo de valores, e o histograma conta quantos valores caem em cada bucket. Esse tipo de métrica é útil para rastrear medições como latências de solicitações ou tamanhos de respostas, nas quais entender a distribuição pode fornecer mais insights do que simplesmente saber a média.
Para implementar um histograma que rastreie a latência de solicitações HTTP, você pode usar o seguinte trecho de código. Este exemplo configura um histograma com vários buckets para medir quanto tempo cada solicitação HTTP leva para ser processada. O bloco with mede automaticamente a duração do tratamento da solicitação e a registra no bucket apropriado.
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 e Sua Importância
Design dos Buckets: Escolher os buckets certos é crucial para histogramas úteis. Os buckets devem estar alinhados com os objetivos e limites de desempenho da sua aplicação. Por exemplo, se você se importa em diferenciar entre solicitações que levam 0,1 segundo e 1 segundo, seus buckets devem refletir esses intervalos.
Granularidade: Mais buckets aumentam a granularidade do histograma, mas também aumentam o uso de memória. Equilibre o nível de detalhe com a eficiência de recursos.
Contagem Cumulativa: Os histogramas do Prometheus são cumulativos. Isso significa que cada bucket conta o número total de observações que caem em seu intervalo e em todos os intervalos anteriores. Isso calcula percentis, que são mais informativos sobre a distribuição dos dados do que médias.
Uso em Consultas: Ao consultar histogramas, funções como histogram
_quantile()podem calcular quantis a partir dos buckets cumulativos, fornecendo insights poderosos sobre as características de desempenho do seu sistema.
Métricas de Resumo
Métricas de resumo no Prometheus oferecem uma maneira de calcular quantis de observações, como o 90º percentil das latências de solicitações, diretamente no cliente. Diferentemente dos histogramas, que coletam e categorizam dados em buckets, os resumos calculam quantis em streaming sem buckets predefinidos. Isso torna os resumos ideais para situações em que cálculos precisos de quantis são necessários, particularmente quando limites exatos são importantes, como em relatórios sobre acordos de nível de serviço (SLAs).
Para implementar um resumo que mede a latência das consultas ao banco de dados, você pode usar o seguinte trecho de código. Este exemplo configura um resumo para monitorar o tempo que as consultas ao banco de dados levam. O bloco with mede a duração da consulta e atualiza o resumo com esta nova observação, facilitando o cálculo de quantis.
from prometheus_client import Summary
# Cria um resumo para medir as latências das consultas ao banco de dados
db_query_latency = Summary('db_query_latency_seconds', 'Latências das consultas ao banco de dados')
def query_database(query):
with db_query_latency.time():
# Executa a consulta ao banco de dados
# O tempo gasto por este bloco é registrado automaticamente e calculado no resumo
pass
Diferença entre Histogramas e Resumos
Cálculo de Quantis: Histogramas estimam quantis com base nos buckets definidos, o que pode introduzir imprecisões dependendo da configuração dos buckets. Resumos calculam quantis diretamente a partir dos dados observados, oferecendo potencialmente mais precisão.
Carga no Lado do Cliente: Resumos calculam quantis no lado do cliente, o que pode aumentar a carga computacional, especialmente com um alto número de observações. Histogramas, com seus buckets predefinidos, podem reduzir a computação no lado do cliente.
Configuração: Histogramas exigem conhecimento prévio da distribuição para definir buckets apropriados. Resumos não exigem configuração de buckets, o que os torna mais fáceis de implantar inicialmente, mas potencialmente mais intensivos em recursos.
Casos de Uso: Resumos são preferidos quando quantis precisos em tempo real são necessários para métricas críticas, enquanto histogramas geralmente são mais adequados para capturar a distribuição mais ampla de uma métrica quando limites exatos são menos críticos.
Melhores Práticas para Rotulagem e Agrupamento de Métricas
Uso Apropriado de Rótulos
Rótulos no Prometheus são pares chave-valor que anexam metadados às métricas para consultas mais detalhadas e direcionadas. Eles são importantes para organizar e identificar métricas em dimensões como nomes de serviços, nomes de host ou tipos de erro. Aqui estão algumas melhores práticas para usar rótulos:
Descritivos e Consistentes: Escolha nomes de rótulos que descrevam claramente sua finalidade e mantenha consistência em suas métricas. Por exemplo, use service para todas as métricas que identificam o serviço ao qual pertencem.
Granularidade Necessária: Embora rótulos possam adicionar detalhes significativos às suas métricas, rótulos em excesso podem aumentar os custos de armazenamento e diminuir o desempenho das consultas. Use rótulos criteriosamente para equilibrar granularidade com desempenho.
Evite Alta Cardinalidade: Rótulos de alta cardinalidade, como aqueles que poderiam rotular cada usuário individual ou endereço de e-mail, podem aumentar o tamanho dos dados e degradar o desempenho. Atenha-se a rótulos que tenham um número razoável de valores distintos.
Este exemplo mostra um contador que usa rótulos para distinguir entre diferentes métodos HTTP e status para análise e monitoramento detalhados.
from prometheus_client import Counter
# Cria um contador com rótulos para métodos HTTP e status de resposta
http_requests_total = Counter('http_requests_total', 'Total de requisições HTTP',
['method', 'status'])
def handle_request(request):
# Incrementa o contador com os rótulos apropriados
http_requests_total.labels(method=request.method, status=request.response.status_code).inc()
Estratégias para Agrupar Métricas
Agrupar métricas logicamente pode aumentar a clareza e melhorar o desempenho dos sistemas de monitoramento. Aqui estão algumas estratégias:
Categorizar por Tipo: Agrupe métricas por tipo, como erros, tráfego, latência etc., para facilitar a localização e análise de métricas relacionadas.
Agrupamento Baseado em Serviço: Organize métricas pelo serviço que elas medem. Isso ajuda a isolar problemas dentro de um serviço específico rapidamente.
Use Nomenclatura Hierárquica: Ao nomear métricas, considere uma estrutura hierárquica que reflita seu agrupamento, como
service_database_queries_totalouservice_http_requests_total.
Benefícios de um Agrupamento Eficaz
Melhor Desempenho de Consultas: O agrupamento lógico pode levar a consultas mais eficientes ao reduzir o número de métricas que precisam ser examinadas para cada consulta.
Gerenciamento de Alertas Mais Fácil: Agrupar métricas semelhantes simplifica a criação de regras de alerta e facilita o gerenciamento de alertas em diferentes partes do seu sistema.
Melhor Visualização: Métricas agrupadas são mais fáceis de visualizar em dashboards, pois métricas relacionadas podem ser exibidas juntas, fornecendo uma visão coesa do desempenho do sistema.
Consultando Métricas com PromQL
Noções Básicas de PromQL e Sua Sintaxe
PromQL, ou Prometheus Query Language, é a poderosa linguagem de consulta usada pelo Prometheus para explorar dados e gerar alertas. O PromQL permite consultas simples e complexas para calcular os dados exatos necessários a partir de suas métricas. A sintaxe do PromQL oferece suporte à seleção e agregação de dados de séries temporais com base em nomes de métricas, rótulos e intervalos de tempo.
Principais Recursos do PromQL:
Consultas Instantâneas e de Intervalo: Consultas instantâneas fornecem o valor atual da série temporal para um ponto específico no tempo, enquanto consultas de intervalo retornam valores da série temporal para um intervalo de tempo.
Funções e Operadores: O PromQL inclui várias funções e operadores integrados para calcular taxas, médias e operações aritméticas entre métricas.
Trechos de Código: Consultas Comuns para Cada Tipo de Métrica
Métricas de Contador
Esta consulta calcula a taxa média por segundo de solicitações HTTP nos últimos 5 minutos, útil para monitorar a carga de tráfego nos seus servidores.
rate(http_requests_total[5m])
Métricas de Gauge
Esta consulta instantânea obtém a quantidade atual de memória livre, fornecendo um snapshot dos recursos do sistema.
node_memory_MemFree_bytes
Métricas de Histograma
A consulta a seguir calcula o percentil 95 das latências de solicitações nos últimos 10 minutos, o que ajuda a identificar outliers no desempenho do servidor web.
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[10m]))
Métricas de Summary
A consulta abaixo calcula a latência mediana dos eventos processados, o que é crucial para avaliar o desempenho de sistemas de tratamento de eventos.
quantile(0.5, rate(processed_events_latency_seconds_sum[5m]) / rate(processed_events_latency_seconds_count[5m]))
Dicas para Consultas Eficazes com PromQL:
Use Intervalos de Tempo Apropriados: Selecione intervalos de tempo que forneçam insights significativos sem sobrecarregar o sistema com consultas longas de dados históricos.
Aproveite a Filtragem por Rótulos: Use rótulos para filtrar e refinar resultados, concentrando-se em subconjuntos específicos de dados.
Otimize para Desempenho: Ao escrever consultas, especialmente para dashboards ou alertas, considere seu impacto no desempenho e otimize-as para serem executadas de forma eficiente.
Monitorando o Desempenho do Banco de Dados Vetorial Milvus com Prometheus
Milvus é um banco de dados vetorial de código aberto, alto desempenho e altamente escalável que pode armazenar, indexar e pesquisar dados não estruturados em escala de bilhões por meio de embeddings vetoriais de alta dimensão. Ele é perfeito para criar aplicações modernas de IA, como geração aumentada por recuperação (RAG), busca semântica, busca multimodal e sistemas de recomendação. O Milvus é executado com eficiência em vários ambientes, desde laptops e dispositivos de borda até sistemas distribuídos em grande escala.
O Prometheus oferece recursos abrangentes para supervisionar o desempenho do banco de dados vetorial Milvus. O Milvus integra-se perfeitamente ao Prometheus por meio de:
Endpoint do Prometheus: Coleta dados de vários exporters.
Prometheus Operator: Simplifica o gerenciamento de configurações de monitoramento do Prometheus.
Kube-Prometheus: Simplifica o monitoramento completo de clusters Kubernetes para uma operação robusta.
A utilização do Prometheus permite acompanhar métricas críticas do desempenho do Milvus, como tempos de resposta de consultas e uso de recursos (CPU, GPU e memória), possibilitando a resolução proativa de problemas e a otimização do sistema. Além disso, a integração do Prometheus com Grafana aprimora ainda mais sua estrutura de monitoramento, fornecendo painéis detalhados para análise aprofundada e manutenção eficiente de implantações do Milvus adaptadas a aplicações de GenAI e busca por similaridade.
Para obter orientações abrangentes sobre como configurar o Prometheus para o Milvus e visualizar métricas com o Grafana, explore os recursos abaixo:
Conclusão
Em conclusão, o Prometheus é uma ferramenta valiosa para monitorar várias métricas que refletem a integridade e o desempenho dos sistemas. Ao usar os recursos do Prometheus para acompanhar, analisar e visualizar dados operacionais críticos, as equipes podem aprimorar suas práticas de monitoramento e garantir que seus sistemas não sejam apenas estáveis, mas também otimizados para eficiência. Seja configurando alertas para detectar possíveis problemas antecipadamente ou usando painéis detalhados para uma visão clara das métricas do sistema, o Prometheus capacita desenvolvedores e administradores a manter serviços de alto desempenho e confiáveis.
Perguntas frequentes
- Quais são os quatro tipos de métricas no Prometheus?
O Prometheus categoriza as métricas em quatro tipos: contadores, gauges, histogramas e resumos. Cada tipo atende a um propósito específico de monitoramento, desde contar ocorrências de eventos até capturar a distribuição de medições ao longo do tempo.
- Como escolho entre usar um histograma e um resumo?
Escolha histogramas quando precisar capturar distribuições e puder definir buckets significativos com antecedência. Use resumos quando precisar de cálculos precisos de quantis e não exigir buckets predefinidos. A escolha depende do seu caso de uso específico e de considerações de desempenho.
- O que é PromQL e como ele é usado no Prometheus?
PromQL, ou Prometheus Query Language, é a linguagem poderosa usada para consultar métricas no Prometheus. Ela permite que os usuários selecionem e agreguem dados de séries temporais, realizem cálculos e extraiam insights de métricas com base em condições e intervalos de tempo específicos.
- Posso usar o Prometheus para monitorar aplicações que não foram construídas em uma arquitetura de microsserviços?
Sim, o Prometheus é versátil o suficiente para monitorar uma ampla variedade de aplicações, sejam elas construídas usando uma arquitetura de microsserviços ou uma abordagem monolítica mais tradicional. Ele pode ser configurado para coletar métricas de quase qualquer fonte que exponha dados no Prometheus Exposition Format.
- Quais são algumas práticas recomendadas para rotular e agrupar métricas no Prometheus?
Ao rotular e agrupar métricas, garanta que os rótulos sejam descritivos e consistentes entre as métricas. Evite rótulos de alta cardinalidade que possam degradar o desempenho. Agrupe métricas logicamente por tipo ou serviço para aumentar a clareza e melhorar a eficiência das consultas. Isso ajuda a manter um sistema de monitoramento organizado, mais fácil de consultar e gerenciar.
Recursos adicionais
- O que é o Prometheus?
- O que são as Métricas no Prometheus?
- Formato das Métricas no Prometheus
- Os Quatro Tipos de Métricas no Prometheus
- Melhores Práticas para Rotulagem e Agrupamento de Métricas
- Consultando Métricas com PromQL
- Monitorando o Desempenho do Banco de Dados Vetorial Milvus com Prometheus
- Conclusão
- Perguntas frequentes
- Recursos adicionais
Conteúdo
Comece grátis, escale facilmente
Experimente o banco de dados totalmente gerenciado, construído para seus aplicativos GenAI.
Experimente o Zilliz Cloud grátis