Guia para Configurar Monitoramento de Recursos com Prometheus no VPS Linux

25 min de leitura  ·  Guia técnico

Guia para Configurar Monitoramento de Recursos com Prometheus no VPS Linux é um processo que permite acompanhar em tempo real o desempenho do seu servidor. Para implementar este sistema de monitoramento, você precisa instalar o Prometheus e configurar exportadores para coletar métricas. Neste guia, você aprenderá a configurar um sistema completo de monitoramento de recursos em seu VPS Linux, permitindo visualizar CPU, memória, disco e rede através de dashboards intuitivos.

Pré-requisitos

• Um servidor VPS Linux com Ubuntu 20.04 ou superior (testado em Ubuntu 22.04 LTS)
• Acesso root ou usuário com privilégios sudo
• Mínimo de 1GB de RAM disponível
• Pelo menos 2GB de espaço livre em disco
• Portas 9090 (Prometheus) e 9100 (Node Exporter) liberadas no firewall

O que é o Prometheus e como funciona

O Prometheus é um sistema de monitoramento de código aberto originalmente desenvolvido pelo SoundCloud. Ele coleta métricas de sistemas monitorados em intervalos regulares, armazena os dados localmente e executa regras sobre esses dados para agregar e gerar alertas. O Prometheus funciona com um modelo de pull, onde ele busca ativamente as métricas dos alvos configurados.

A arquitetura do Prometheus consiste em vários componentes:

• Servidor Prometheus: O núcleo que coleta e armazena dados de séries temporais
• Exportadores: Programas que expõem métricas de sistemas terceiros em formato compatível com Prometheus
• Alertmanager: Gerencia alertas, incluindo silenciamento e agrupamento
• Interface Web: Interface para visualização de dados e consultas

Para monitoramento de VPS Linux, o Node Exporter é o exportador mais importante, pois ele coleta métricas do sistema operacional como uso de CPU, memória, disco, rede e muito mais.

Instalando o Prometheus no VPS Linux

A instalação do Prometheus envolve a criação de um usuário dedicado, download do software, configuração de diretórios e criação de um serviço systemd. Vamos seguir um processo passo a passo para garantir uma instalação correta e segura.

1. Primeiro, crie um usuário específico para o Prometheus, para limitar os privilégios:

   sudo useradd --no-create-home --shell /bin/false prometheus

2. Crie os diretórios necessários para armazenar os arquivos do Prometheus:

   sudo mkdir /etc/prometheus
   sudo mkdir /var/lib/prometheus

3. Defina as permissões corretas para os diretórios:

   sudo chown prometheus:prometheus /etc/prometheus
   sudo chown prometheus:prometheus /var/lib/prometheus

4. Baixe a versão mais recente do Prometheus (verifique a versão atual no site oficial):

   cd /tmp
   wget https://github.com/prometheus/prometheus/releases/download/v2.43.0/prometheus-2.43.0.linux-amd64.tar.gz

5. Extraia os arquivos:

   tar -xvf prometheus-2.43.0.linux-amd64.tar.gz

6. Copie os binários para os diretórios apropriados:

   sudo cp prometheus-2.43.0.linux-amd64/prometheus /usr/local/bin/
   sudo cp prometheus-2.43.0.linux-amd64/promtool /usr/local/bin/

7. Defina o proprietário correto para os binários:

   sudo chown prometheus:prometheus /usr/local/bin/prometheus
   sudo chown prometheus:prometheus /usr/local/bin/promtool

8. Copie os diretórios consoles e console_libraries:

   sudo cp -r prometheus-2.43.0.linux-amd64/consoles /etc/prometheus
   sudo cp -r prometheus-2.43.0.linux-amd64/console_libraries /etc/prometheus

9. Defina o proprietário correto para esses diretórios:

   sudo chown -R prometheus:prometheus /etc/prometheus/consoles
   sudo chown -R prometheus:prometheus /etc/prometheus/console_libraries

Após a instalação dos binários, precisamos criar o arquivo de configuração do Prometheus:

sudo nano /etc/prometheus/prometheus.yml

Adicione a seguinte configuração básica:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
  
  - job_name: 'node_exporter'
    static_configs:
      - targets: ['localhost:9100']

Defina as permissões corretas para o arquivo de configuração:

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml

Agora, crie um serviço systemd para gerenciar o Prometheus:

sudo nano /etc/systemd/system/prometheus.service

Adicione o seguinte conteúdo:

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
    --config.file /etc/prometheus/prometheus.yml \
    --storage.tsdb.path /var/lib/prometheus/ \
    --web.console.templates=/etc/prometheus/consoles \
    --web.console.libraries=/etc/prometheus/console_libraries

[Install]
WantedBy=multi-user.target

Recarregue o systemd, inicie e habilite o serviço Prometheus:

sudo systemctl daemon-reload
sudo systemctl start prometheus
sudo systemctl enable prometheus

Verifique se o serviço está funcionando corretamente:

sudo systemctl status prometheus

Output esperado:
● prometheus.service - Prometheus
     Loaded: loaded (/etc/systemd/system/prometheus.service; enabled; vendor preset: enabled)
     Active: active (running) since Mon 2023-04-10 15:23:45 UTC; 5s ago
   Main PID: 12345 (prometheus)
      Tasks: 8 (limit: 4915)
     Memory: 21.5M
     CGroup: /system.slice/prometheus.service
             └─12345 /usr/local/bin/prometheus --config.file /etc/prometheus/prometheus.yml --storage.tsdb.path /var/lib/prometheus/ --web.console.templates=/etc/prometheus/consoles --web.console.libraries=/etc/prometheus/console_libraries

Instalando o Node Exporter para coletar métricas do sistema

O Node Exporter é um componente essencial para monitoramento de recursos do VPS, pois expõe métricas detalhadas sobre CPU, memória, disco, rede e outros recursos do sistema. Vamos instalar e configurar o Node Exporter para trabalhar com o Prometheus.

1. Crie um usuário dedicado para o Node Exporter:

   sudo useradd --no-create-home --shell /bin/false node_exporter

2. Baixe a versão mais recente do Node Exporter:

   cd /tmp
   wget https://github.com/prometheus/node_exporter/releases/download/v1.5.0/node_exporter-1.5.0.linux-amd64.tar.gz

3. Extraia os arquivos:

   tar -xvf node_exporter-1.5.0.linux-amd64.tar.gz

4. Copie o binário para o diretório apropriado:

   sudo cp node_exporter-1.5.0.linux-amd64/node_exporter /usr/local/bin/

5. Defina o proprietário correto para o binário:

   sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

6. Crie um serviço systemd para o Node Exporter:

   sudo nano /etc/systemd/system/node_exporter.service

7. Adicione o seguinte conteúdo:

   [Unit]
   Description=Node Exporter
   Wants=network-online.target
   After=network-online.target
   
   [Service]
   User=node_exporter
   Group=node_exporter
   Type=simple
   ExecStart=/usr/local/bin/node_exporter
   
   [Install]
   WantedBy=multi-user.target

8. Recarregue o systemd, inicie e habilite o serviço Node Exporter:

   sudo systemctl daemon-reload
   sudo systemctl start node_exporter
   sudo systemctl enable node_exporter

9. Verifique se o serviço está funcionando corretamente:

   sudo systemctl status node_exporter

   Output esperado:
   ● node_exporter.service - Node Exporter
        Loaded: loaded (/etc/systemd/system/node_exporter.service; enabled; vendor preset: enabled)
        Active: active (running) since Mon 2023-04-10 15:30:12 UTC; 5s ago
      Main PID: 12346 (node_exporter)
         Tasks: 4 (limit: 4915)
        Memory: 13.8M
        CGroup: /system.slice/node_exporter.service
                └─12346 /usr/local/bin/node_exporter

Agora que o Node Exporter está em execução, o Prometheus já deve estar coletando métricas do sistema. Você pode verificar isso acessando a interface web do Prometheus.

Configurando o firewall para acesso seguro ao Prometheus

A segurança é fundamental ao expor serviços de monitoramento. Vamos configurar o firewall para permitir acesso controlado ao Prometheus e Node Exporter, garantindo que apenas IPs autorizados possam acessar essas interfaces.

Se você estiver usando UFW (Uncomplicated Firewall), que é comum em distribuições Ubuntu, siga estas etapas:

1. Verifique o status atual do firewall:

   sudo ufw status

2. Se o firewall não estiver ativo, você pode habilitá-lo após configurar as regras necessárias:

   sudo ufw enable

   Atenção: Certifique-se de configurar o acesso SSH antes de habilitar o firewall para não perder acesso ao servidor.

3. Permita acesso SSH (se ainda não estiver permitido):

   sudo ufw allow ssh

4. Para acesso local apenas, permita o Prometheus e Node Exporter apenas na interface de loopback:

   sudo ufw allow from 127.0.0.1 to any port 9090
   sudo ufw allow from 127.0.0.1 to any port 9100

5. Para permitir acesso de um IP específico (por exemplo, seu IP de gerenciamento):

   sudo ufw allow from SEU_IP_AQUI to any port 9090

6. Verifique as regras configuradas:

   sudo ufw status numbered

   Output esperado:
   Status: active
   
        To                         Action      From
        --                         ------      ----
   [ 1] 22/tcp                     ALLOW IN    Anywhere
   [ 2] 9090                       ALLOW IN    127.0.0.1
   [ 3] 9100                       ALLOW IN    127.0.0.1
   [ 4] 9090                       ALLOW IN    SEU_IP_AQUI

Para acesso mais seguro, é recomendável configurar um proxy reverso com autenticação. Você pode usar o Nginx para isso:

1. Instale o Nginx:

   sudo apt update
   sudo apt install nginx apache2-utils -y

2. Crie um arquivo de senha para autenticação básica:

   sudo htpasswd -c /etc/nginx/.htpasswd admin

   Você será solicitado a definir uma senha para o usuário "admin".

3. Crie uma configuração do Nginx para o Prometheus:

   sudo nano /etc/nginx/sites-available/prometheus

   server {
       listen 80;
       server_name monitoring.seudominio.com;
   
       location / {
           proxy_pass http://localhost:9090;
           proxy_set_header Host $host;
           proxy_set_header X-Real-IP $remote_addr;
           auth_basic "Restricted Access";
           auth_basic_user_file /etc/nginx/.htpasswd;
       }
   }

4. Ative a configuração e reinicie o Nginx:

   sudo ln -s /etc/nginx/sites-available/prometheus /etc/nginx/sites-enabled/
   sudo nginx -t
   sudo systemctl restart nginx

5. Atualize o firewall para permitir o tráfego HTTP:

   sudo ufw allow 'Nginx HTTP'

Com essa configuração, você pode acessar o Prometheus de forma segura através do Nginx com autenticação básica, enquanto mantém as portas originais do Prometheus fechadas para acesso externo direto.

Configurando dashboards para visualização de métricas

Embora o Prometheus tenha uma interface web básica, o Grafana é a ferramenta mais popular para criar dashboards visualmente atraentes e interativos para as métricas coletadas. Vamos instalar e configurar o Grafana para visualizar as métricas do nosso VPS.

1. Adicione a chave GPG do Grafana:

   wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -

2. Adicione o repositório do Grafana:

   sudo add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"

3. Atualize os pacotes e instale o Grafana:

   sudo apt update
   sudo apt install grafana -y

4. Inicie e habilite o serviço Grafana:

   sudo systemctl start grafana-server
   sudo systemctl enable grafana-server

5. Verifique o status do serviço:

   sudo systemctl status grafana-server

   Output esperado:
   ● grafana-server.service - Grafana instance
        Loaded: loaded (/lib/systemd/system/grafana-server.service; enabled; vendor preset: enabled)
        Active: active (running) since Mon 2023-04-10 16:15:22 UTC; 5s ago
          Docs: http://docs.grafana.org
      Main PID: 12347 (grafana-server)
         Tasks: 8 (limit: 4915)
        Memory: 32.8M
        CGroup: /system.slice/grafana-server.service
                └─12347 /usr/sbin/grafana-server --config=/etc/grafana/grafana.ini --pidfile=/var/run/grafana/grafana-server.pid

6. Configure o firewall para permitir acesso ao Grafana (porta 3000):

   sudo ufw allow 3000/tcp

Agora, acesse o Grafana através do navegador em http://seu_ip_do_vps:3000. As credenciais padrão são:

• Usuário: admin
• Senha: admin

Você será solicitado a alterar a senha no primeiro login.

Para configurar o Prometheus como fonte de dados no Grafana:

1. No painel do Grafana, clique em "Configuration" (ícone de engrenagem) e selecione "Data Sources".
2. Clique em "Add data source" e selecione "Prometheus".
3. Em "URL", digite "http://localhost:9090".
4. Clique em "Save & Test". Você deve ver uma mensagem de sucesso.

Para importar um dashboard pré-configurado para monitoramento de sistema Linux:

1. No painel do Grafana, clique em "+" e selecione "Import".
2. Digite "1860" no campo "Import via grafana.com" (este é o ID do dashboard "Node Exporter Full" popular).
3. Clique em "Load".
4. Selecione o Prometheus como fonte de dados e clique em "Import".

Agora você terá um dashboard completo mostrando métricas detalhadas do seu VPS, incluindo CPU, memória, disco, rede e muito mais.

Configurando alertas para monitoramento proativo

O monitoramento de recursos é mais eficaz quando você recebe alertas proativos sobre problemas potenciais. Vamos configurar o AlertManager para enviar notificações quando determinadas condições forem atendidas.

1. Baixe e instale o AlertManager:

   cd /tmp
   wget https://github.com/prometheus/alertmanager/releases/download/v0.25.0/alertmanager-0.25.0.linux-amd64.tar.gz
   tar -xvf alertmanager-0.25.0.linux-amd64.tar.gz
   sudo cp alertmanager-0.25.0.linux-amd64/alertmanager /usr/local/bin/
   sudo cp alertmanager-0.25.0.linux-amd64/amtool /usr/local/bin/

2. Crie um usuário para o AlertManager:

   sudo useradd --no-create-home --shell /bin/false alertmanager

3. Crie os diretórios necessários:

   sudo mkdir /etc/alertmanager
   sudo mkdir /var/lib/alertmanager

4. Defina as permissões corretas:

   sudo chown alertmanager:alertmanager /usr/local/bin/alertmanager
   sudo chown alertmanager:alertmanager /usr/local/bin/amtool
   sudo chown -R alertmanager:alertmanager /etc/alertmanager
   sudo chown alertmanager:alertmanager /var/lib/alertmanager

5. Crie o arquivo de configuração do AlertManager:

   sudo nano /etc/alertmanager/alertmanager.yml

   global:
     resolve_timeout: 5m
     # Configuração para envio de e-mails
     smtp_smarthost: 'smtp.gmail.com:587'
     smtp_from: '[email protected]'
     smtp_auth_username: '[email protected]'
     smtp_auth_password: 'sua-senha-ou-app-password'
     smtp_require_tls: true
   
   route:
     group_by: ['alertname']
     group_wait: 30s
     group_interval: 5m
     repeat_interval: 1h
     receiver: 'email-notifications'
   
   receivers:
   - name: 'email-notifications'
     email_configs:
     - to: '[email protected]'
       send_resolved: true

6. Defina as permissões corretas para o arquivo de configuração:

   sudo chown alertmanager:alertmanager /etc/alertmanager/alertmanager.yml

7. Crie um serviço systemd para o AlertManager:

   sudo nano /etc/systemd/system/alertmanager.service

   [Unit]
   Description=Alertmanager
   Wants=network-online.target
   After=network-online.target
   
   [Service]
   User=alertmanager
   Group=alertmanager
   Type=simple
   ExecStart=/usr/local/bin/alertmanager \
     --config.file=/etc/alertmanager/alertmanager.yml \
     --storage.path=/var/lib/alertmanager
   
   [Install]
   WantedBy=multi-user.target

8. Recarregue o systemd, inicie e habilite o serviço AlertManager:

   sudo systemctl daemon-reload
   sudo systemctl start alertmanager
   sudo systemctl enable alertmanager

9. Verifique o status do serviço:

   sudo systemctl status alertmanager

Agora, precisamos configurar regras de alerta no Prometheus:

1. Crie um arquivo de regras de alerta:

   sudo nano /etc/prometheus/alert.rules.yml

   groups:
   - name: vps_alerts
     rules:
     - alert: HighCPULoad
       expr: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
       for: 5m
       labels:
         severity: warning
       annotations:
         summary: "High CPU load (instance {{ $labels.instance }})"
         description: "CPU load is > 80%\n  VALUE = {{ $value }}\n  LABELS: {{ $labels }}"
   
     - alert: HighMemoryUsage
       expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100 > 85
       for: 5m
       labels:
         severity: warning
       annotations:
         summary: "High memory usage (instance {{ $labels.instance }})"
         description: "Memory usage is > 85%\n  VALUE = {{ $value }}\n  LABELS: {{ $labels }}"
   
     - alert: HighDiskUsage
       expr: 100 - ((node_filesystem_avail_bytes{mountpoint="/"} * 100) / node_filesystem_size_bytes{mountpoint="/"}) > 85
       for: 5m
       labels:
         severity: warning
       annotations:
         summary: "High disk usage (instance {{ $labels.instance }})"
         description: "Disk usage is > 85%\n  VALUE = {{ $value }}\n  LABELS: {{ $labels }}"

2. Defina as permissões corretas para o arquivo de regras:

   sudo chown prometheus:prometheus /etc/prometheus/alert.rules.yml

3. Atualize a configuração do Prometheus para incluir as regras de alerta e o AlertManager:

   sudo nano /etc/prometheus/prometheus.yml

   global:
     scrape_interval: 15s
     evaluation_interval: 15s
   
   rule_files:
     - "alert.rules.yml"
   
   alerting:
     alertmanagers:
     - static_configs:
       - targets:
         - localhost:9093
   
   scrape_configs:
     - job_name: 'prometheus'
       static_configs:
         - targets: ['localhost:9090']
     
     - job_name: 'node_exporter'
       static_configs:
         - targets: ['localhost:9100']

4. Reinicie o Prometheus para aplicar as alterações:

   sudo systemctl restart prometheus

Com essa configuração, você receberá alertas por e-mail quando o uso de CPU, memória ou disco exceder 80-85% por mais de 5 minutos.

Problemas comuns e como resolver

Sintoma: Prometheus não inicia após a configuração

Causa: Geralmente, isso ocorre devido a erros de sintaxe no arquivo de configuração prometheus.yml ou permissões incorretas nos diretórios.
Solução: Verifique os logs do sistema com sudo journalctl -u prometheus para identificar o erro específico. Corrija a sintaxe do arquivo de configuração ou ajuste as permissões dos diretórios conforme necessário. Use o comando promtool check config /etc/prometheus/prometheus.yml para validar a configuração antes de reiniciar o serviço.

Sintoma: Node Exporter está em execução, mas o Prometheus não coleta métricas

Causa: Isso pode ocorrer devido a problemas de conectividade entre o Prometheus e o Node Exporter, configuração incorreta dos alvos ou problemas de firewall.
Solução: Verifique se o Node Exporter está acessível usando curl http://localhost:9100/metrics. Confirme se o endereço do alvo está correto no arquivo prometheus.yml. Verifique as regras do firewall para garantir que a porta 9100 esteja acessível para o Prometheus.

Sintoma: Alertas não estão sendo enviados

Causa: Configuração incorreta do AlertManager, problemas de conectividade com o servidor SMTP ou credenciais inválidas.
Solução: Verifique os logs do AlertManager com sudo journalctl -u alertmanager. Teste a configuração SMTP manualmente. Para Gmail, você pode precisar usar uma "senha de aplicativo" em vez da senha normal da conta. Verifique se o AlertManager está corretamente configurado no arquivo prometheus.yml.

Sintoma: Alto consumo de recursos pelo Prometheus

Causa: Intervalo de coleta muito curto, muitos alvos configurados ou retenção de dados muito longa.
Solução: Ajuste o scrape_interval para um valor mais alto (por exemplo, 30s ou 1m). Limite o número de métricas coletadas usando relabelagem. Configure a retenção de dados com --storage.tsdb.retention.time=15d no arquivo de serviço do Prometheus para manter dados por menos tempo.

Sintoma: Grafana não consegue se conectar ao Prometheus

Causa: Configuração incorreta da fonte de dados, problemas de conectividade ou permissões.
Solução: Verifique se o Prometheus está acessível usando curl http://localhost:9090/api/v1/status/config. Na configuração da fonte de dados do Grafana, certifique-se de usar o URL correto (http://localhost:9090). Se estiver usando um proxy reverso, verifique se ele está configurado corretamente.

Perguntas frequentes sobre monitoramento com Prometheus

O Prometheus consome muitos recursos do servidor?

O Prometheus é relativamente leve, consumindo cerca de 100-200MB de RAM na configuração básica. Para VPS com pelo menos 1GB de RAM, o impacto no desempenho é mínimo, especialmente considerando os benefícios de monitoramento que ele oferece.

É possível monitorar múltiplos servidores com uma única instância do Prometheus?

Sim, o Prometheus foi projetado para monitorar múltiplos servidores. Basta configurar o arquivo prometheus.yml para incluir os endpoints de todos os servidores que executam Node Exporter, permitindo centralizar o monitoramento de toda sua infraestrutura.

Quais são as alternativas ao Prometheus para monitoramento de VPS?

As principais alternativas incluem Zabbix, Nagios, Netdata e Grafana Cloud. Cada uma tem suas vantagens, mas o Prometheus se destaca pela simplicidade, modelo de dados baseado em séries temporais e ecossistema robusto de integrações.

Como configurar alertas no Prometheus quando recursos atingem níveis críticos?

Para configurar alertas, instale o AlertManager junto ao Prometheus e defina regras de alerta no arquivo alert.rules.yml. Configure canais de notificação como email, Slack ou Telegram para receber alertas quando métricas como uso de CPU, memória ou disco ultrapassarem limites predefinidos.

É necessário abrir portas no firewall para o Prometheus funcionar?

Sim, você precisa abrir as portas utilizadas pelo Prometheus (9090) e Node Exporter (9100) no firewall. Para ambientes de produção, recomenda-se restringir o acesso a estas portas apenas para IPs específicos ou usar um proxy reverso com autenticação.

Conclusão

• Implementar o monitoramento de recursos com Prometheus no seu VPS Linux permite identificar problemas de desempenho antes que afetem seus serviços, possibilitando uma resposta proativa.
• A combinação de Prometheus, Node Exporter, AlertManager e Grafana oferece uma solução completa de monitoramento, com coleta de métricas, visualização e alertas, tudo em um sistema integrado e de código aberto.
• Para ambientes de produção, sempre proteja suas interfaces de monitoramento com autenticação e restrições de firewall, garantindo que apenas pessoas autorizadas tenham acesso às métricas e configurações do sistema.

Seguindo este guia, você configurou um sistema robusto de monitoramento para seu VPS Linux, permitindo acompanhar o desempenho do servidor em tempo real e receber alertas quando surgirem problemas. Isso ajuda a manter seus serviços funcionando de forma confiável e a planejar upgrades de recursos quando necessário.

Precisa de ajuda com monitoramento de servidores?

Na AviraHost, oferecemos servidores VPS Linux otimizados com ferramentas de monitoramento pré-configuradas para garantir o máximo desempenho para suas aplicações.

Conheça nossos planos de Servidor VPS