Alertas do Prometheus

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:

1. Na interface LabEx, clique no botão + (Nova Aba) na barra de navegação superior
2. Escolha Web Service no menu suspenso
3. Insira 9090 para o número da porta
4. 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.

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.

É 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:

1. 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.
2. 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.

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.