Alertas do Prometheus: Criar e Disparar Alertas de Alta CPU

Introdução

Um monitoramento eficaz não se trata apenas de coletar métricas; trata-se de ser notificado quando algo dá errado. O Prometheus possui um sistema de alertas poderoso e integrado que permite definir condições de alerta usando a mesma linguagem de consulta PromQL que você utiliza para gerar gráficos. Quando a condição de um alerta é atendida, ele entra em um estado de "disparo" (firing).

Neste laboratório, você aprenderá os fundamentos dos alertas no Prometheus. Você começará com um ambiente pré-configurado executando o Prometheus e o Node Exporter. Sua tarefa será criar um arquivo de regras de alerta separado, definir uma regra para detectar alto uso de CPU, configurar o Prometheus para carregar esse arquivo e, finalmente, simular uma carga alta de CPU para observar o alerta ser disparado na interface do Prometheus.

Entendendo o Ambiente de Alertas

Nesta etapa, você se familiarizará com o ambiente do laboratório. O script de configuração já iniciou dois containers Docker para você: um para o Prometheus e outro para o Node Exporter.

Primeiro, vamos verificar se ambos os containers estão em execução. Abra um terminal e execute o comando docker ps:

docker ps

Você deverá ver uma saída semelhante à seguinte, mostrando os containers prometheus e node-exporter com o status "Up".

CONTAINER ID   IMAGE                           COMMAND                  CREATED          STATUS          PORTS                                       NAMES
...            prom/prometheus                 "/bin/prometheus --c…"   15 seconds ago   Up 14 seconds   0.0.0.0:9090->9090/tcp, :::9090->9090/tcp   prometheus
...            prom/node-exporter               "/bin/node_exporter …"   16 seconds ago   Up 15 seconds   0.0.0.0:9100->9100/tcp, :::9100->9100/tcp   node-exporter

O container node-exporter expõe métricas sobre o sistema host (nossa VM de laboratório), e o container prometheus está configurado para coletar (scrape) essas métricas.

Agora, vamos verificar a interface do Prometheus. Para acessá-la:

Na interface do LabEx, clique no botão + (Nova Aba) na barra de navegação superior.
Escolha Web Service no menu suspenso.
Digite 9090 para o número da porta.
Clique em Open para iniciar a interface web do Prometheus.

Quando a nova aba abrir, você verá a página inicial do Expression Browser do Prometheus. Navegue até Status -> Targets no menu de navegação superior. Você verá que o job node_exporter possui um estado "UP" em verde, confirmando que o Prometheus está coletando dados com sucesso. Essa conexão é a base para nossa regra de alerta.

Interface de Targets do Prometheus

Criar o arquivo alert-rules.yml para Alerta de Alta CPU

Nesta etapa, você criará um arquivo dedicado para suas regras de alerta. É uma boa prática manter as regras separadas da configuração principal do Prometheus para uma melhor organização.

Criaremos um arquivo chamado alert-rules.yml dentro do diretório do seu projeto. Use o editor nano para criar e editar o arquivo:

nano ~/project/alert-rules.yml

Agora, copie e cole o seguinte conteúdo YAML no editor nano. Isso define um grupo de regras contendo um único alerta que é disparado quando o uso da CPU está alto.

groups:
  - name: node_alerts
    rules:
      - alert: HighCpuLoad
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[1m])) * 100) > 10
        for: 1m
        labels:
          severity: warning
        annotations:
          summary: "High CPU load on {{ $labels.instance }}"
          description: "CPU load is > 10% (current value: {{ $value }}%)"

Vamos analisar esta regra:

groups: As regras são organizadas em grupos. Todas as regras em um grupo são avaliadas sequencialmente.
alert: O nome do nosso alerta, HighCpuLoad.
expr: A expressão PromQL que é avaliada. Se ela retornar um valor, o alerta é disparado. Aqui, calculamos a porcentagem de tempo de CPU não ocioso (non-idle) no último minuto. Se for maior que 10%, a condição é atendida.
for: Esta cláusula especifica que a condição deve ser verdadeira por uma duração contínua (1 minuto) antes que o alerta se torne "Firing" (Disparando). Isso evita que alertas sejam disparados por picos breves.
annotations: Adicionam informações legíveis para humanos ao alerta. summary e description são anotações padrão. Você pode usar variáveis de template como {{ $labels.instance }} e {{ $value }} para incluir dados dinâmicos em suas mensagens de alerta.

Após colar o conteúdo, salve o arquivo e saia do nano pressionando Ctrl+X, depois Y e, em seguida, Enter.

Executar o Container do Prometheus com o Arquivo de Regras Montado

Nesta etapa, você dirá ao Prometheus para carregar seu novo arquivo de regras e reiniciar o container com a configuração atualizada.

Primeiro, você precisa editar o arquivo de configuração principal, prometheus.yml, para incluir uma referência ao seu arquivo de regras. Abra-o com o nano:

nano ~/project/prometheus.yml

Adicione a diretiva rule_files no nível superior do arquivo, não dentro do bloco global. O arquivo deve ficar assim após suas alterações:

global:
  scrape_interval: 15s

rule_files:
  - "alert-rules.yml"

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["prometheus:9090"]
  - job_name: "node_exporter"
    static_configs:
      - targets: ["node-exporter:9100"]

Salve o arquivo e saia do nano (Ctrl+X, Y, Enter).

Agora que a configuração foi atualizada, você deve reiniciar o container do Prometheus para aplicar as alterações. Primeiro, pare e remova o container antigo:

docker stop prometheus

docker rm prometheus

Finalmente, execute um novo container do Prometheus. Este comando é semelhante ao do script de configuração, mas inclui uma segunda flag -v para montar seu arquivo alert-rules.yml dentro do container.

docker run -d --name prometheus -p 9090:9090 \
  --network monitoring \
  -v /home/labex/project/prometheus.yml:/etc/prometheus/prometheus.yml \
  -v /home/labex/project/alert-rules.yml:/etc/prometheus/alert-rules.yml \
  prom/prometheus

Este comando garante que tanto a configuração principal quanto as regras de alerta estejam disponíveis dentro do container do Prometheus.

Verificar se as Regras de Alerta foram Carregadas na Interface do Prometheus

Nesta etapa, você confirmará que o Prometheus carregou com sucesso sua nova regra de alerta.

Volte para a aba da interface do Prometheus no seu navegador (ou abra uma nova aba de Web Service na porta 9090, se necessário). Se a página não carregar, aguarde alguns segundos para que o novo container inicie e, em seguida, atualize a página.

Na barra de navegação superior, clique no item de menu Alerts.

Agora você deve ver seu alerta HighCpuLoad listado. O alerta estará na seção Inactive, indicada por um fundo verde. Este é o estado esperado, pois a carga de CPU no sistema está atualmente baixa, portanto, a expressão do alerta (expr) é avaliada como falsa.

Alerta Inativo do Prometheus

É importante entender os três estados de um alerta:

Inactive (Verde): A condição do alerta é falsa.
Pending (Amarelo): A condição do alerta tornou-se verdadeira, mas a duração for ainda não passou. O Prometheus está aguardando para ver se a condição persiste.
Firing (Vermelho): A condição do alerta foi verdadeira durante toda a duração for. Em um ambiente de produção, é neste momento que o Prometheus enviaria o alerta para um Alertmanager.

Seu alerta está atualmente inativo, o que está correto. Na próxima etapa, faremos com que ele seja disparado.

Simular Carga para Testar o Disparo do Alerta

Nesta etapa final, você aumentará intencionalmente a carga de CPU no sistema para testar se seu alerta é disparado corretamente.

Podemos gerar carga de CPU usando um loop de shell simples e infinito. No seu terminal, execute o seguinte comando. O & no final executará o processo em segundo plano, para que você possa continuar usando seu terminal.

while true; do true; done &

Este comando inicia um processo que consome 100% de um núcleo de CPU. Agora, volte rapidamente para a página Alerts na interface do Prometheus (acessível via aba Web Service na porta 9090).

Você observará o estado do alerta HighCpuLoad mudar:

Dentro de cerca de 15-30 segundos, a expressão do alerta se tornará verdadeira. O alerta passará para a seção Pending e ficará amarelo. Isso significa que o Prometheus detectou a alta carga de CPU, mas está aguardando a duração de 1m especificada na cláusula for.
Após permanecer no estado Pending por um minuto, o alerta passará para a seção Firing e ficará vermelho. Isso confirma que sua regra de alerta funciona como esperado! Você pode expandir o alerta para ver as anotações que definiu, completas com o valor atual.

Alerta Disparado do Prometheus

Assim que vir o alerta ser disparado, você pode interromper a geração de carga. Volte ao seu terminal e execute o seguinte comando para encerrar o processo do loop em segundo plano:

Importante: Para economizar recursos do servidor da VM do LabEx, certifique-se de executar o comando abaixo para interromper a geração de carga.

kill $!

Após interromper a carga, observe a interface do Prometheus novamente. O alerta retornará em breve ao estado Inactive (verde), completando o ciclo de teste.

Resumo

Parabéns! Você configurou e testou com sucesso um alerta do Prometheus.

Neste laboratório, você aprendeu como:

Estruturar regras de alerta em um arquivo YAML separado.
Escrever uma expressão PromQL para definir uma condição de alerta para alto uso de CPU.
Usar anotações para criar mensagens de alerta significativas e legíveis para humanos.
Configurar o Prometheus para carregar seus arquivos de regras e reiniciá-lo para aplicar as alterações.
Observar o ciclo de vida de um alerta na interface do Prometheus, de Inactive para Pending e para Firing.
Simular uma condição para disparar e testar seu alerta.

Esta é a primeira metade do cenário de alertas. O próximo passo lógico, que está fora do escopo deste laboratório, seria configurar uma instância do Alertmanager. O Prometheus enviaria seus alertas disparados para o Alertmanager, que seria então responsável por desduplicar, agrupar e rotear os alertas para canais de notificação reais, como e-mail, Slack ou PagerDuty.