Monitoramento e alertas
Acompanhe os quatro sinais de ouro, meça a latência com percentis, defina SLOs e só acione pessoas por problemas que importam - com alertas de burn rate.
- Monitorar serviços com os quatro sinais de ouro e latências em percentis
- Definir SLIs e SLOs, e usar o error budget para equilibrar velocidade e confiabilidade
- Escrever alertas acionáveis e alertar sobre a velocidade com que o error budget está sendo consumido
A Byte Bakery costumava saber das quedas por posts furiosos: “meu croissant está dando voltas em cima da minha casa há uma hora”. Fazer deploy várias vezes por dia só funciona se você descobre rápido quando algo dá errado - de preferência antes dos clientes.
O livro de SRE do Google sugere quatro sinais de ouro (golden signals) para qualquer serviço voltado ao usuário:
| Sinal | Pergunta | Exemplo |
|---|---|---|
| Latência | quanto tempo as requisições levam? (sucessos e falhas separados) | tempo de checkout p99 |
| Tráfego | quanta demanda existe? | pedidos por segundo |
| Erros | quantas requisições falham? | parcela de respostas 5xx |
| Saturação | quão cheio está o serviço? | CPU, memória, tamanho da fila, uso do pool de conexões |
Uma stack típica: os serviços expõem métricas, o Prometheus as coleta e guarda como séries temporais, o Grafana desenha os painéis e o Alertmanager encaminha os alertas para o chat ou para um pager. Entre as opções hospedadas estão Datadog, New Relic e Grafana Cloud; o OpenTelemetry padroniza como métricas, logs e traces são produzidos.
Percentis, não médias
1import math
2
3latencies = [80, 85, 90, 90, 95, 100, 110, 120, 130, 2400] # milliseconds
4
5def percentile(values, p):
6 ordered = sorted(values)
7 return ordered[math.ceil(p / 100 * len(ordered)) - 1]
8
9print(f"mean {sum(latencies) / len(latencies):.0f} ms")
10print(f"p50 {percentile(latencies, 50)} ms, p90 {percentile(latencies, 90)} ms, p99 {percentile(latencies, 99)} ms")mean 330 ms p50 95 ms, p90 130 ms, p99 2400 ms
A média (330 ms) não descreve ninguém: a maioria das requisições leva cerca de 100 ms, e um cliente esperou 2,4 segundos. Os percentis contam a história real - o p50 é a experiência típica, o p99 é o 1% mais lento. Com milhares de requisições por segundo, “só 1%” é muita gente com fome.
SLOs e error budgets
- Um indicador de nível de serviço (SLI) mede algo que importa para os usuários: “a parcela de requisições de checkout que dão certo em menos de 500 ms”.
- Um objetivo de nível de serviço (SLO) é a meta: “99,9% em 30 dias”. (Um SLA é um contrato com penalidades - defina-o mais folgado que o seu SLO.)
- O error budget (orçamento de erros) é o que sobra: 0,1% das requisições podem falhar. Enquanto houver orçamento, entregue funcionalidades rápido; quando ele acabar, desacelere e invista em confiabilidade. 100% é a meta errada - é caríssimo e impossível, e os usuários não conseguem distinguir 99,99% de 100% pelo próprio Wi-Fi.
Alertas em que as pessoas podem confiar
Todo acionamento deve ser urgente, acionável e real, e vir com o link de um runbook. Alertar sobre cada pico de CPU causa fadiga de alertas: as pessoas começam a ignorar os acionamentos e então perdem o de verdade.
Uma abordagem robusta é alertar sobre o burn rate - a velocidade com que você está gastando o error budget. Um burn rate de 1 usa o orçamento exatamente ao longo do período do SLO; 14,4 usaria 2% de um orçamento de 30 dias em uma hora. Conferir uma janela longa e uma curta faz você acionar as pessoas por problemas sérios, e parar de acionar logo depois que eles forem corrigidos. (Essa configuração vem do workbook de SRE do Google.)
1groups:
2 - name: checkout-slo
3 rules:
4 - alert: CheckoutErrorBudgetBurn
5 # 99.9% SLO: page when 1h and 5m error rates both exceed 14.4 x 0.1%
6 expr: |
7 (sum(rate(http_requests_total{service="checkout",code=~"5.."}[1h]))
8 / sum(rate(http_requests_total{service="checkout"}[1h]))) > (14.4 * 0.001)
9 and
10 (sum(rate(http_requests_total{service="checkout",code=~"5.."}[5m]))
11 / sum(rate(http_requests_total{service="checkout"}[5m]))) > (14.4 * 0.001)
12 labels:
13 severity: page
14 annotations:
15 summary: Checkout is burning its error budget fast
16 runbook: https://runbooks.bytebakery.example/checkout-errorsExperimente
Até 15 XPQual sinal de ouro?
Classifique cada métrica da Byte Bakery no sinal de ouro que ela mede.
“Tempo p99 para carregar o cardápio”
“Pedidos feitos por segundo”
“Parcela das requisições de pagamento que devolvem 5xx”
“Tamanho da fila de despacho dos drones”
“Pool de conexões do banco de dados 95% em uso”
“Checkouts que devolveram “sucesso”, mas não cobraram nada”
Principais conclusões
Acompanhe os sinais de ouro: latência, tráfego, erros e saturação.
Use percentis para a latência; a média esconde a cauda.
Os SLIs medem o que os usuários sentem, os SLOs definem as metas e o error budget decide quando desacelerar.
Só acione pessoas por problemas urgentes e acionáveis - alertas de burn rate com um runbook.
Quiz da aula
7 perguntas · aprovação com 5 acertos · até 50 XP
Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.
Pratique: automatize tarefas de DevOps com Python
Escreva as pequenas ferramentas em Python que times de DevOps realmente criam, como executores de pipeline, verificadores de plano, calculadoras de métricas e scanners, e execute-as com entradas de exemplo. Elas rodam localmente no navegador; não é preciso ter servidores nem contas na nuvem.
Calcule percentis de latência
A primeira linha da entrada é um SLO: percent threshold_ms, como 95 300 (“95% das requisições abaixo de 300 ms”). As linhas restantes têm latências em milissegundos, separadas por espaços.
Use o método da posição mais próxima: o p-ésimo percentil é o valor na posição ceil(p / 100 × n) (contando a partir de 1) na ordem crescente. Imprima requests: 20, mean: 182.5 ms (uma casa decimal), p50: 90 ms, p95: 1200 ms, p99: 2400 ms e depois SLO 95% under 300 ms: met (96.0% under) ou violated (...). “Abaixo” significa estritamente menor que o limite.
- Serviço de cardápio
- Saudável
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Decida os alertas de burn rate
A primeira linha da entrada é a porcentagem do SLO, como 99.9. Cada linha seguinte é uma janela: name requests errors para as janelas 5m, 30m, 1h e 6h. O burn rate de uma janela é a taxa de erros dela dividida pela taxa de erros permitida (100% − SLO).
Imprima cada janela como 1h: error rate 2.000%, burn rate 20.0x e depois a decisão: PAGE (1h and 5m burn rates above 14.4x) se as duas estiverem acima; senão, TICKET (6h and 30m burn rates above 6x) se as duas estiverem; senão, no alert.
- Checkout pegando fogo
- Vazamento lento
- Já se recuperou
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Dúvidas sobre esta lição
Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.
Carregando publicações…