Carregando
0xC0Lição 13 de 16

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.

28 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • 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:

SinalPerguntaExemplo
Latênciaquanto tempo as requisições levam? (sucessos e falhas separados)tempo de checkout p99
Tráfegoquanta demanda existe?pedidos por segundo
Errosquantas requisições falham?parcela de respostas 5xx
Saturaçãoquã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

latency.py
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")
Saída
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.)

alerts.yaml
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-errors

Experimente

Até 15 XP

Qual sinal de ouro?

Classifique cada métrica da Byte Bakery no sinal de ouro que ela mede.

0 de 6 classificadosPontuação 0/0
  • “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.

Exercício 1

Calcule percentis de latência

+25 XP

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
main.py
Carregando editor…

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.

Exercício 2

Decida os alertas de burn rate

+25 XP

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
main.py
Carregando editor…

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…