# Criando alertas com Prometheus e Alertmanager > Neste artigo, parte 3 de uma série sobre monitoramento com Grafana, Prometheus, Docker e Docker Compose, exploramos a configuração de alertas personalizados utilizando o Prometheus e o Alertmanager. Aprendemos a instalar e integrar o Alertmanager com o Prometheus para enviar alertas por e-mail, criamos regras de alerta no Prometheus para monitorar uptime e uso de CPU, e configuramos o Alertmanager para enviar notificações via SMTP. Além disso, validamos todo o processo simulando condições de alerta e observamos como as notificações são disparadas e resolvidas. --- Fala pessoal tudo beleza? Se você está lendo este artigo pela primeira vez, saiba que ele faz parte de uma série onde explico como montar uma stack de monitoramento usando Grafana e Prometheus com Docker e Docker Compose. Neste artigo, parte 3, vou criar alertas personalizados para suas métricas no Prometheus e Alertmanager, que será responsável por enviar o evento para um e-mail. ## Pré requisitos * Ter uma instância do Prometheus em execução. * Ter acompanhado os artigos anteriores onde subimos uma stack do Grafana e Prometheus. ## Instalando o Alertmanager O Alertmanager é um software que lida com alertas enviados por aplicativos clientes, como o servidor Prometheus. Ele é responsável em gerenciar esses alertas recebidos e encaminhar para algum cliente que esteja pré configurado, como um e-mail. Com ele também é possível configurar o modo de silenciamento, ou seja, silenciar algum alerta já esperado por algumas horas ou apenas para o fim de semana. Para subir uma instância do Alertmanager, iremos usar o docker. Para isso, utilize a stack que estamos criando nessa série de artigo e abra o arquivo `docker-compose.yaml`. Você pode encontrar no meu [Github](https://github.com/aristidesneto/stack-de-monitoramento-grafana-e-prometheus?ref=aristides.dev). Para nosso exemplo de hoje com o Alertmanager, iremos usar o Node Exporter em uma imagem docker. No arquivo `docker-comose.yaml` já existe um serviço para ele, que está comentado. Descomente o bloco referente ao node\_exporter e adicione logo abaixo o bloco do Alertmanager: ```yaml # Arquivo: docker-compose.yaml services: # ...services # Exemplo de usar o exporter com o Docker ao invés do binário node_exporter: image: quay.io/prometheus/node-exporter:latest container_name: node_exporter command: - '--path.rootfs=/host' pid: host restart: always volumes: - '/:/host:ro,rslave' networks: - monitoring alertmanager: image: prom/alertmanager:v0.25.0 container_name: alertmanager restart: always volumes: - ./alertmanager/:/etc/alertmanager/ command: - '--config.file=/etc/alertmanager/config.yaml' - '--storage.path=/alertmanager' ports: - 9093:9093 networks: - monitoring ``` Explicando algumas linhas importantes do Alertmanager no arquivo `docker-compose.yaml`: 1. No serviço `alertmanager`, informamos a versão do Alertmanager que será utilizada que é a `0.25.0` (a mais recente na data desse artigo). 2. Criamos um volume para mapear um arquivo de configuração para o Alertmanager, que ao iniciar o serviço essa configuração será aplicada. 3. Em `command`, estamos passando dois parâmetros para o Alertmanager, o primeiro `--config.file` informamos que o arquivo de configuração deve ser lido no diretório `/etc/alertmanager/config.yaml` e o segundo `--storage.path` informamos que o local de armazenamento dos dados serão armazenados no próprio host em `/alertmanager`. 4. Em `ports` estamos expondo a porta 9093 do host para a porta 9093 do container. 5. Em `networks` informamos ao docker-compose que iremos utilizar uma rede já criada por nós, que no caso é a rede `monitoring`. Agora vamos subir os containers na nossa stack. No diretório raiz do projeto, execute o comando do docker compose para subir todas as instâncias de containers: ```bash $ docker-compose up -d ``` Verifique se todos os containers estão em execução: ```bash $ docker-compose ps NAME COMMAND SERVICE STATUS PORTS alertmanager "/bin/alertmanager -…" alertmanager running 0.0.0.0:9093->9093/tcp, :::9093->9093/tcp grafana "/run.sh" grafana running 0.0.0.0:3000->3000/tcp, :::3000->3000/tcp node_exporter "/bin/node_exporter …" node_exporter running 9100/tcp prometheus "/bin/prometheus --c…" prometheus running 0.0.0.0:9090->9090/tcp, :::9090->9090/tcp ``` Agora o Alertmanager está `running` e está acessível na porta 9093. Acesse o navegador com o endereço `localhost:9093` e confirme se o Alertmanager irá carregar. ![Tela inicial Alertmanager](https://cdn.hashnode.com/res/hashnode/image/upload/v1735047351674/65aa3398-6050-4e3a-987e-00269017684b.png align="left") Tela inicial Alertmanager ## Integrando Alertmanager com Prometheus Já temos nossa instância do Alertmanager em execução, precisamos agora configurar o Prometheus para qualquer evento de alerta seja enviado ao Alertmanager e ele ser responsável em disparar para um cliente. Abra o arquivo de configuração do Prometheus que está em `prometheus/prometheus.yaml`. Adicione a seguinte entrada no final do arquivo referenciando ao Alertmanager: ```yaml # ... alerting: alertmanager: - scheme: http static_configs: - targets: - 'alertmanager:9093' ``` prometheus/prometheus.yaml Nesse bloco de código, informamos ao Prometheus que existe agora um cliente de alerta. Na sessão `alerting` criamos um, chamado `alertmanager`. Informamos que o Alertmanager está rodando no protocolo `http` e no host `alertmanager:9093`. Vamos validar se o Prometheus reconheceu essa nossa configuração. Para isso reinicie o serviço do Prometheus com o comando: ```bash $ docker-compose restart prometheus ``` Abra o Prometheus no seu navegador em `localhost:9090` e navegue no menu `Status -> Runtime & Build Information`. Certifique que na sessão Alertmanagers, agora há um endpoint apontando para a instância do Alertmanager. Com isso já temos a integração entre os dois serviços. Agora é necessário criar os alertas no Prometheus e quando acionado será enviado um evento de alerta para o Alertmanager. ## Criando regras de alertas no Prometheus Agora que já temos nossa instância em execução, vamos criar as regras de alertas no Prometheus. Para isso vamos criar um arquivo chamado `alert.rules` no diretório do `prometheus`. Adicone o seguinte conteúdo nesse arquivo: ```yaml groups: # Grupo de alertas: hosts - name: hosts rules: - alert: Uptime expr: up == 0 for: 15s labels: severity: critical annotations: summary: "O servidor {{ $labels.alias }} está offline!" description: "O servidor {{ $labels.alias }} parou de responder." - alert: Uso de CPU expr: 100 - (avg(rate(node_cpu_seconds_total{mode="idle"}[2m])) by(instance) * 100) > 80 for: 1m labels: severity: warning annotations: summary: Consumo alto de CPU (instance {{ $labels.instance }}) description: "O servidor {{ $labels.alias }} está com o consumo de CPU acima de 80%\n VALUE = {{ $value }}\n LABELS = {{ $labels }}" ``` prometheus/alert.rules Foram criadas duas regras de alertas, onde o primeiro é o Uptime, que verifica se a instância está no ar e a segunda verifica o uso de CPU se está acima de 80% em um período de 2 minutos. Lembre-se de validar as regras para seu ambiente antes de usar em produção. Após criarmos o arquivo de regras, devemos informar ao Prometheus que ele deve carregar esse arquivo a aplicar suas configurações. Para isso abra novamente o arquivo `prometheus/prometheus.yaml` e adicione no inicio do arquivo o seguinte trecho: ```yaml # Arquivo: prometheus/prometheus.yaml global: scrape_interval: 15s # Carrega arquivo de regras de alertas rule_files: - "alert.rules" ``` Nesse arquivo adicionamos a sessão de regras `rules_files`, que indica que o Prometheus deve carregar o arquivo correspondente que contém as regras de alertas. Agora reinicie o Prometheus para aplicar as configurações: ```bash $ docker-compose restart prometheus ``` Para validarmos todo esse processo, vamos abrir o Prometheus no navegador e acessar o menu `Status -> Rules`. Você verá a seguinte tela com as regras criadas. ![Regras de alertas para Prometheus](https://cdn.hashnode.com/res/hashnode/image/upload/v1735047393058/e9831bd9-2e52-4125-803d-47bb188eea1d.png align="left") Regras de alertas para Prometheus Acesse também o menu `Alerts`, você verá as regras criadas e o status de cada uma. ![Prometheus rules status Inactive](https://cdn.hashnode.com/res/hashnode/image/upload/v1735047425614/f5fb66cc-04cb-460a-bbc9-c304e7f8f7dc.png align="left") Prometheus rules status Inactive Nessa tela, é possível acompanhar o status de cada evento de alerta. Podemos ver os status: * **Inactive**: Esse status significa que não há nenhum evento de alerta que possa ser acionado, ou seja, está tudo bem! * **Pending**: Quando um alerta entra nesse status, quer dizer que alguma regra definida foi acionada, ficará nesse status pelo tempo determinado no arquivo de regras. * **Firing**: Após o status de `Pending`, o status `Firing` entra em ação, após um evento ficar em espera por alguns segundos seu status muda para `Firing` e automaticamente é dispardo um alerta para o Alertmanager. ## Configurando Alertmanager com SMTP Agora é hora de configurar o Alertmanager com as informações de credenciais de e-mail usando o SMTP. Para isso, crie um arquivo `config.yaml` no diretório `alertmanager`. Cole o seguinte conteúdo no arquivo: ```yaml # Arquivo: alertmanager/config.yaml global: smtp_smarthost: smtp.email.com:587 smtp_from: noreply@email.com smtp_auth_username: noreply@email.com smtp_auth_password: suaSenhaAqui route: group_by: ['alertname'] group_interval: 5m group_wait: 30s receiver: 'email' repeat_interval: 3h receivers: - name: 'email' email_configs: - to: alerta@gmail.com send_resolved: true ``` **Você deve adicionar as suas configurações SMTP do seu provedor de e-mail.** Basicamente neste arquivo eu digo ao Alertmanager que ele deverá enviar um e-mail para `receivers.name.email_configs: alerta@gmail.com` após 30 segundos `route.group_wait` que ele receber o alerta. Em `receivers.name.email_configs.send_resolved: true` informo que após a resolução de um incidente, o Alertmanager deverá enviar outro e-mail alertando que o incidente foi resolvido. Defino o remetente padrão em `route.receiver: email`. Na sessão `global` informo as credenciais de e-mail SMTP. Esse é um arquivo simples de configuração, é possível realizar mais configurações, realizar `matchers` dos e-mails e enviar para determinados grupos. Caso queira entender mais como funciona, acesse a [documentação oficial](https://prometheus.io/docs/alerting/latest/configuration/?ref=aristides.dev). Após criarmos esse arquivo de configuração, reinicie o serviço do Prometheus e Alertmanager: ```bash $ docker-compose restart alertmanager $ docker-compose restart prometheus ``` ## Validando toda a configuração Vamos validar todo esse processo de configuração que fizemos, primeiro vamos ver o que acontece quando um dos hosts que está sendo monitorado fica down, por algum motivo seu servidor Linux não está mais acessível exportando as métricas, métricas essas que o Prometheus utiliza para saber da saúde do seu servidor. Para simular um servidor que esteja down, vamos parar o container do `node_exporter`. Execute o comando: ```bash $ docker-compose stop node_exporter $ docker-compose ps NAME COMMAND SERVICE STATUS PORTS alertmanager "/bin/alertmanager -…" alertmanager running 0.0.0.0:9093->9093/tcp, :::9093->9093/tcp grafana "/run.sh" grafana running 0.0.0.0:3000->3000/tcp, :::3000->3000/tcp node_exporter "/bin/node_exporter …" node_exporter exited (143) prometheus "/bin/prometheus --c…" prometheus running 0.0.0.0:9090->9090/tcp, :::9090->9090/tcp ``` Podemos ver que agora o container `node_exporter` está com o status de `exited`. Abra o Prometheus no navegador e acessa o menu `Alerts`. Veja que agora o status está como `Pending` e depois de alguns segundos ficará como `Firing`. ![Prometheus rules status pending](https://cdn.hashnode.com/res/hashnode/image/upload/v1735047470717/7cca3872-ae3d-4e62-8d73-e584db3474cb.png align="left") Prometheus rules status pending ![Prometheus rules status firing](https://cdn.hashnode.com/res/hashnode/image/upload/v1735047488726/b5608ad5-7489-411e-be9c-b397ddd1bdc9.png align="left") Prometheus rules status firing Se abrirmos agora o Alertmanager no navegador, veremos que foi enviado um alerta para ele. ![Alertmanager alerta recebido](https://cdn.hashnode.com/res/hashnode/image/upload/v1735047513909/f507c96e-c5ab-4de6-850c-648154c1cdfa.png align="left") Alertmanager alerta recebido Dentro de alguns instantes será enviado um e-mail informando que host está down, conforme imagem: ![Prometheus Alert Host Down](https://cdn.hashnode.com/res/hashnode/image/upload/v1735047562681/cba4d2a4-949b-471b-8799-838e792db3f2.jpeg align="left") Prometheus Alert Host Down Show de bola. Agora vamos consertar esse host que está fora, execute o comando abaixo para subir o container do `node_exporter` e vamos aguardar até que o Prometheus consiga se comunicar novamente com ele. ```bash $ docker-compose up -d $ docker-compose ps NAME COMMAND SERVICE STATUS PORTS alertmanager "/bin/alertmanager -…" alertmanager running 0.0.0.0:9093->9093/tcp, :::9093->9093/tcp grafana "/run.sh" grafana running 0.0.0.0:3000->3000/tcp, :::3000->3000/tcp node_exporter "/bin/node_exporter …" node_exporter running 9100/tcp prometheus "/bin/prometheus --c…" prometheus running 0.0.0.0:9090->9090/tcp, :::9090->9090/tcp ``` Veja no Prometheus no menu `Alerts` que o evento de alerta que antes estava como `Firing` voltará ao seu estado normal e desejado que é `Inactive`. Quando tudo tiver "verdinho" o Prometheus irá enviar um novo evento ao Alertmanager, só que agora um evento que informa que o host voltou a responder. O Alertmanager por sua vez, irá remover o alerta e enviará um outro e-mail informando que o problema de host down foi resolvido. ![Prometheus Alert Host UP](https://cdn.hashnode.com/res/hashnode/image/upload/v1735047582614/1c949abb-6cc2-47b6-9ec4-5bb90a6ac044.jpeg align="left") Prometheus Alert Host UP Mais uma vez, show de bola. Caso você queira fazer um teste também pelo alto consumo de CPU para receber o alerta, fique a vontade, pode até dimunuir o percentual de 80% para 30% apenas para validar o envio. Acredito que chegamos ao fim desse artigo com o recebimento desse alerta. ## Download código Todo o código dessa stack você pode baixar pelo link do [Github](https://github.com/aristidesneto/stack-de-monitoramento-grafana-e-prometheus?ref=aristides.dev). ## Conclusão Nesse artigo fizemos a instalação, configuração e integração do Alertmanager com o Prometheus. Criamos duas regras de alertas e validamos o envio de uma delas. O Alertmanager em si, o uso dele é bem simples, não estarei abordando ele aqui, mas acessando a página dele é possível criar alertas por lá e silenciar um alerta por um período de tempo. Para saber mais sobre o template de notificação acesse a [documentação](https://prometheus.io/docs/alerting/latest/notifications/?ref=aristides.dev). Espero que tenha ajudado até aqui. Se você encontrar algum erro, sugestões de melhorias ou se tiver alguma dúvida, deixe seu comentário abaixo. Até a próxima.