Alertas Prometheus: Criar e Disparar Alertas de CPU Alta

Introdução

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 alerta integrado e poderoso que permite definir condições de alerta usando a mesma linguagem de consulta PromQL que você usa para criar gráficos. Quando a condição de um alerta é atendida, ele entra em estado de "disparo" (firing).

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

Compreender o Ambiente de Alerta

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

Primeiro, vamos verificar se ambos os contêineres 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 contêineres prometheus e node-exporter em 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 contêiner node-exporter expõe métricas sobre o sistema hospedeiro (nossa VM de laboratório), e o contêiner prometheus está configurado para fazer scrape (coletar) essas métricas.

Agora, vamos verificar a interface web (UI) do Prometheus. Para acessá-la:

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

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

Prometheus Targets UI

Criar alert-rules.yml para Alerta de CPU Elevada

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 melhor organização.

Criaremos um arquivo chamado alert-rules.yml dentro do seu diretório de 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 durante o ú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" (Disparado). Isso evita que alertas sejam disparados por picos breves.
annotations: Estes adicionam informações legíveis por 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 nas 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 Prometheus com Arquivo de Regras Montado

Nesta etapa, você instruirá o Prometheus a carregar seu novo arquivo de regras e reiniciará o contêiner 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 nano:

nano ~/project/prometheus.yml

Adicione a diretiva rule_files sob a seção 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 contêiner Prometheus para aplicar as alterações. Primeiro, pare e remova o contêiner antigo:

docker stop prometheus

docker rm prometheus

Finalmente, execute um novo contêiner Prometheus. Este comando é semelhante ao usado no script de configuração, mas inclui um segundo flag -v para montar seu arquivo alert-rules.yml dentro do contêiner.

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 contêiner Prometheus.

Verificar Regras de Alerta Carregadas na UI do Prometheus

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

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

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

Você deverá ver agora seu alerta HighCpuLoad listado. O alerta estará na seção Inactive (Inativo), indicado por um fundo verde. Este é o estado esperado porque a carga da CPU no sistema está atualmente baixa, então a expressão do alerta (expr) é avaliada como falsa.

Prometheus Inactive Alert

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

Inactive (Verde): A condição do alerta é falsa.
Pending (Amarelo): A condição do alerta se tornou verdadeira, mas a duração especificada em for ainda não passou. O Prometheus está esperando para ver se a condição persiste.
Firing (Vermelho): A condição do alerta tem sido verdadeira durante toda a duração especificada em for. Em uma configuração 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 dispare.

Simular Carga para Testar o Disparo do Alerta

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

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

while true; do true; done &

Este comando inicia um processo que consome 100% de um único núcleo de CPU. Agora, mude rapidamente de volta para a página Alerts (Alertas) na UI do Prometheus (acessível através da aba Serviço Web na porta 9090).

Você observará a mudança de estado do alerta HighCpuLoad:

Em cerca de 15 a 30 segundos, a expressão do alerta se tornará verdadeira. O alerta se moverá para a seção Pending (Pendente) e ficará amarelo. Isso significa que o Prometheus detectou a alta carga de CPU, mas está esperando pela duração de 1m especificada na cláusula for.
Após permanecer no estado Pendente por um minuto, o alerta se moverá para a seção Firing (Disparando) 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.

Prometheus Firing Alert

Depois de ver o alerta disparar, você pode interromper a geração de carga. Volte ao seu terminal e execute o seguinte comando para encerrar o processo de loop em segundo plano:

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

kill $!

Após interromper a carga, observe a UI do Prometheus novamente. O alerta logo retornará 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 a:

Estruturar regras de alerta em um arquivo YAML separado.
Escrever uma expressão PromQL para definir uma condição de alerta para uso elevado da CPU.
Usar anotações (annotations) para criar mensagens de alerta significativas e legíveis por 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 UI do Prometheus, de Inactive (Inativo) para Pending (Pendente) e para Firing (Disparando).
Simular uma condição para disparar e testar seu alerta.

Esta é a primeira metade do panorama 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 roteá-los para canais de notificação reais, como e-mail, Slack ou PagerDuty.

Alertas do Prometheus