Monitoramento básico de site com Riemann

Riemann é um sistema de processamento de eventos de uso geral, mas a sua aplicação mais comum é como um lugar para enviar e gerar métricas sobre os aplicativos. Eu recentemente configurei um servidor de Riemann para os meus projetos pessoais, e sinto que minhas habilidades de DevOps aumentaram em 1000%.

Ou, pelo menos, é como se eu tivesse conhecimento assim que um dos meus sites cai.

Há uma abundância de artigos que falam sobre as virtudes do Riemann, mas este pretende ser um guia prático inicial para aqueles que já estão convencidos. Este breve artigo irá cobrir:

Como instalar e configurar o servidor Riemann em uma box de Ubuntu da Digital Ocean
Como configurar o monitoramento da saúde do sistema Riemann
Como gravar arquivos de configuração básica para notificar via e-mail quando algo está acontecendo

Instalando o servidor Riemann

Provavelmente vale a pena, se você é um hobista crônico como eu, deixar US$5 por mês em um servidor Riemann dedicado. Vá até a Digital Ocean ou ao provedor VPS de sua preferência e ative uma instância Ubuntu 16.04 se você quiser acompanhar diretamente.

Antes de instalar o Riemann, você precisa do Java. Basta executar apt install default-jre no seu servidor.

A instalação do Riemann está presente no guia de início rápido. Isso irá instalar um servidor Riemann e um serviço systemd para rodar automaticamente. Se você é como eu e quer apenas um deb em vez de compilar e instalar você mesmo, pode obter uma URL para fazer isso a partir de chef recipe. Apenas certifique-se de atualizar o número de versão na URL. Em seguida, execute dpkg -i <arquivo .deb>.

Vendo o seu primeiro evento

Para fazer isso, vamos precisar de uma cópia das ferramentas de linha de comando do cliente do Riemann, que estão disponíveis usando gem. Primeiro, vamos ter que instalar o Ruby e o Java:

$ apt install ruby

Depois de tudo isso ser feito, podemos usar gem para instalar algumas ferramentas extras do Riemann:

$ gem install riemann-tools riemann-dash riemann-client --no-rdoc --no-ri

Nesse ponto, para ver a mágica acontecer, você primeiro tem que criar um arquivo chamado “config.rb” e colocar o seguinte nele:

set :bind, "0.0.0.0"

Em seguida, no mesmo diretório, execute

$ riemann-dash

Como você não ainda não configurou o ufw ainda, vá para http://<vps_ip>:4567/ e você será capaz de ver um painel lá.

Eu vou tirar um tempo aqui para falar que o painel do Riemann é muito funcional, mas super estranho para configurar, contando principalmente com atalhos de teclado e divisão de janela. Se você tem um chefe que você quer impressionar, tire um tempo para instalar algo como Grafana. Você pode reforçar com o InfluxDB, recebendo eventos do Riemann.

De qualquer forma, quando você vê aquele painel glorioso, a primeira coisa a fazer é corrigir o servidor. Na entrada de texto cinza no canto superior direito, substitua “127.0.0.1” com o IP do seu VPS.

Então, corra para criar de uma nova view (cmd+clique no grande “Riemann”, ctrl+shift+esquerda, cmd+clique espaço, e) selecione log, e digite o que quiser para o título e “true” para a consulta. Isso irá mostrar todos os eventos, quando entrarem no Riemann. Você deve ver um monte de eventos que o Riemann reporta sobre si mesmo por padrão, o que é bom! Isso significa que a sua instalação está funcionando. Uma vez que você está ativo e usando o Riemann corretamente, isso será inútil, porque tudo que você vê é lixo na tela, mas é bom para começar.

Configurando o monitoramento do Riemann

Você deve colocar a sua própria máscara de oxigênio em primeiro lugar, certo? Vamos ter certeza de que o nosso servidor pode manter o controle sobre sua própria saúde.

Pressione “s” para salvar seu dashboard com a janela de log, em seguida, abra uma nova janela ssh (ou tmux ou qualquer outra) para que você possa executar outro comando no seu servidor, enquanto o dashboard ainda estiver ativo:

$ riemann-health

Agora, você deve ver vários outros eventos voando no seu log, com nomes como “memory”, “disk /” e “cpu”. Estes são os que nós queremos ver. Para ver apenas um deles no log, selecione com cmd+clique, pressione “e” e altere a consulta para (por exemplo) service = “cpu”. Agora, você só deve ver os eventos de CPU.

Gaste um pouco de tempo reorganizando seu dashboard (você pode adicionar uma nova página de dashboard com o + no canto superior direito). Eu recomendo a criação de um Gauge e um Flot para cada CPU, memória, disco /, e Load. Lembre-se de salvar o seu trabalho!

Nós sempre vamos querer o riemann-health rodando, então vamos configurar um job systemd para ele. Edite o novo arquivo /etc/systemd/system/riemann-health.service e digite o seguinte:

[Unit]
Description=Riemann Health
After=network.target

[Service]
ExecStart=/usr/local/bin/riemann-health
PidFile=/var/run/riemann-health.pid
Restart=on-failure

[Install]
Alias=riemann-health.service

Em seguida, você pode iniciar o serviço usando $ service riemann-health start.

Tornando o dashboard permanente

Você quer ser capaz de ver o lindo dashboard, certo? Aqui está um serviço systemd que você pode colocar em /etc/systemd/system/riemann-dash.service:

[Unit]
Description=Riemann Dashboard
After=network.target

[Service]
ExecStart=/usr/local/bin/riemann-dash
PidFile=/var/run/riemann-dash.pid
Restart=on-failure

[Install]
Alias=riemann-dash.service

No entanto, a menos que você tenha criado o arquivo config.rb anteriormente em seu diretório raiz, ele não vai se ligar ao 0.0.0.0, mas em localhost (127.0.0.1). Isso é bom, porque por uma variedade de razões você vai querer executá-lo atrás do nginx.

Instale o Nginx agora. Além disso, vamos instalar o pacote apache2-utils para obter o utilitário htpasswd:

$ apt install nginx apache2-utils

Você vai querer um pouco de autenticação, então vamos criar um arquivo .htpasswd para uso com autenticação http básica:

$ htpasswd -c /etc/nginx/.htpasswd <your_username>

Siga as instruções para ativar sua senha. Depois disso, edite o seu arquivo /etc/nginx/sites-available/default. Aqui está uma configuração básica (substituir o arquivo inteiro com o seguinte):

server {
    listen 80 default_server;
    listen [::]:80 default_server;

    location / {
    auth_basic "Riemann Dashboard";
    auth_basic_user_file /etc/nginx/.htpasswd;
    proxy_pass http://localhost:4567;
    proxy_pass_request_headers      on;
    }

}

Agora, supondo que o riemann-dash e os serviços nginx estão rodando, você pode ir para http://<your_ip_or_hostname>/ e ver o dashboard logo após o login. Hurrah!

Habilite o SSL para o dashboard

Você pode obter um certificado SSL gratuitamente através do letsencrypt e certbot; para fazer isso, siga as suas instruções. Você deve acabar com uma certificação em algum lugar no /etc/letsencrypt/.

É bem fácil configurar nginx para exigir SSL. Substitua a sua configuração com o seguinte:

server {
    listen 80 default_server;
    listen [::]:80 default_server;
    location / {
        rewrite ^(.*)$ https://example.com$1 permanent;
    }

}

server {

    # SSL configuration
    listen 443 ssl default_server;
    listen [::]:443 ssl default_server;

    ssl on;
    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/example.com/fullchain.pem;

    # Index
    index index.html index.htm index.nginx-debian.html;

    location / {
        auth_basic "Riemann Dashboard";
        auth_basic_user_file /etc/nginx/.htpasswd;
        proxy_pass http://localhost:4567;
        proxy_pass_request_headers      on;
    }
}

Lembre-se de substituir o example.com com o seu domínio.

No entanto, não terminamos ainda. O dashboard usa WebSockets, e você vai começar a receber erros porque o padrão é ws: connections. Entretanto, podemos usar nginx também para ser o proxy das conexões WebSocket não seguras, atualizando-os com conexões wss: no processo. Basta adicionar o seguinte ao seu arquivo de configuração nginx:

map $http_upgrade $connection_upgrade {
    default upgrade;
    '' close;
}

upstream riemann_ws {
    server 127.0.0.1:5556;
}

server {
    listen 5566;
    ssl on;
    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/example.com/fullchain.pem;

    location / {
        proxy_pass http://riemann_ws;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
    }
}

Agora, você precisa mudar seu dashboard Riemann para usar a porta 5566 em vez da 5556. Basta alterar a porta na caixa de texto do canto superior direito no dashboard (e não se esqueça de salvar).

Finalmente, você deve ter certeza de que todas as portas que não são necessárias estão bloqueadas com ufw (5555 é a porta de cliente do Riemann):

$ ufw default deny
$ ufw allow ssh
$ ufw allow http
$ ufw allow https
$ ufw allow 5555
$ ufw deny 5556
$ ufw allow 5566
$ ufw enable

E é isso! Você conseguiu um dashboard Riemann razoavelmente seguro com auth. Agora, vamos tornar isso útil.

Adicionando monitoramento a outros servidores

(Pode ser necessário instalar o Ruby mais recente em servidores mais antigos para esta parte. O repositório Ubuntu do Brightbox me ajudou muito com isso.)

Qualquer servidor pode executar riemann-health e responder ao seu novo servidor Riemann. Aqui vai o procedimento geral:

Instale o riemann-tools: $ sudo gem install riemann-tools.

Crie um serviço para executar riemann-health no startup, com o argumento –host <my_riemann_server_host>.

Configure seu dashboard Riemann para mostrar as estatísticas desse servidor.

Você já viu a configuração systemd para riemann-health, aqui está uma configuração inicial:

description "Riemann health"

start on [2345]
stop on [!2345]

respawn

exec /usr/local/bin/riemann-health --host my-riemann-server.com

Monitorando nginx

Você pode monitorar o Nginx usando o utilitário riemann-nginx-status incluído no pacote riemann-tools, que funciona como riemann-health. A única diferença é que você vai ter que configurar um endpoint de estado do stub no servidor nginx que você deseja monitorar. Basta adicionar a seguinte declaração do servidor na sua configuração nginx:

server {
    listen 127.0.0.1:9000;
    location "/status" {
        stub_status on;
    }
}

Em seguida, configure um serviço para executar riemann-nginx-status –host your_riemann_server.com –uri http://localhost:9000/status no seu servidor, e você vai começar a obter métricas a partir dele (se você não liga para métricas, basta passar uma URI para monitorar e só vai enviar mensagens de “ok”).

Notificações por e-mail

Para enviar uma notificação, você vai precisar instalar o sendmail no seu servidor Riemann (apt install sendmail) e editar a configuração do Riemann.

O arquivo de configuração do Riemann é na verdade um arquivo Clojure. Isso pode ou não significar algo para você, por isso o site do Riemann tem uma introdução rápida a respeito.

O arquivo de configuração é uma uma linguagem completa, o que significa que você pode fazer coisas muito complexas com os seus fluxos de eventos, mas as mais comuns envolvem agregações e notificações. Aqui está um exemplo: abra /etc/riemann/riemann.config e adicione no topo:

(require '[riemann.email :refer :all])

Em seguida, substitua a seção streams existente por isto:

(streams
 (default :ttl 60

  ; Index all events immediately.
  (index)

  ; Log expired events.
  (expired
   (fn [event] (info "expired" event)))

  (where (and (service "nginx health")
              (state "critical"))
         (changed-state {:init "ok"}
         (rollup 1 3600
                 ((mailer {:from "riemann@<my_riemann_server_host>"}) "my@email.address"))))
  ))

A última parte pode ser lida aproximadamente como a seguinte:

“Para todos os eventos where, o service é “nginx health ‘ e o state é “critical”, se o “state” mudou, me envie um e-mail com o primeiro evento e um resumo de todos os eventos da última hora”.

Mais pensamentos

Como os dados de monitoramento do Riemann expiram rapidamente, se você quiser manter um conjunto de dados de longo prazo, considere encaminhar do Riemann para um armazenamento de timeseries como o Influxdb ou Graphite.
Para alertas de e-mail mais consistentes, configure smtp, mailgun ou algo parecido.
O outro uso principal do Riemann é monitorar métricas específicas da aplicação. Se você quiser manter o controle de aplicativos que está executando, você pode usar uma biblioteca cliente Riemann e tê-la relatando coisas de volta. Por exemplo, Later for Reddit relata o estado de cada tentativa de post, que é agregado em posts por hora e posts por dia para minha diversão (e depuração). Ele também encaminha as mensagens de log de erro de status para serem manipulados.

Você pode encontrar muitos mais exemplos no howto do Riemann. A parte difícil é ter o servidor instalado e funcionando; uma vez que você tem isso funcionando, vai encontrar todos os tipos de usos para ele, eu prometo. É isso por hoje!

***

Adam Bard faz parte do time de colunistas internacionais do iMasters. A tradução do artigo é feita pela redação iMasters, com autorização do autor, e você pode acompanhar o artigo em inglês no link: https://adambard.com/blog/basic-website-monitoring-with-riemann/

De 0 a 10, o quanto você recomendaria este artigo para um amigo?