Fala Hackers, beleza?

Nesse mini artigo vamos mostrar como subir uma stack completa de Graylog em container utilizando o Docker. YES!

Mas antes vamos falar um pouquinho sobre essa ferramenta. O Graylog é uma ferramenta de gestão de logs. Para quê usamos isso? Para centralizar logs, isso facilita na busca de informações dos serviços e aplicações que utilizamos no dia a dia, mas não é só isso, ele também ajuda na observalidade, aquele famoso termo (Triangle of Observability in Monitoring) mas não vamos falar muito disso nesse post, vamos deixar esse assunto para outro momento hehe, o que precisamos saber agora sobre Triangle of Observability in Monitoring ou no PTBR (Triângulo de observabilidade no monitoramento) são basicamente três coisas:

Logs – Os Logs registram praticamente todos os eventos e transações que acontecem a todo momento. Diferente das métricas, os logs fornecem informações mais detalhadas sobre os recurso da infra-estrutura, portanto se as métricas indicarem que o recurso está morto os logs ajudarão a saber porque o recurso morreu.

O Problema dos Logs é que em geral eles possuem muitas informações então é muito comum encontrarmos pilhas e pilhas de logs centralizados e quem já trabalhou com logs sabe que é um parto de égua ficar trabalhando com grep em texto puro para tirar alguma informação desses logs. No entanto, existem várias ferramentas que podem auxiliar na coleta e tratativa dos logs como o Fluentd, Graylog o Datadog entre outras =) .

Metrics – Métricas das aplicações utilizadas no monitoramento.

Traces – São os dados de rastreamentos de aplicativos, eles são exclusivamente focados na camada de aplicação e basicamente rastreiam informações sobre operações específicas do aplicativo.

Voce pode ler um pouco mais sobre isso nesse link do DevOps.com.

Bom, o escolhido para esse post foi o Graylog então bora colocar a mão na massa.

O Graylog utiliza um ElasticSearch para armazenar os logs tratados e um MongoDB para armazenar configurações do próprio Graylog, como os usuários por exemplo. É importante ressaltar aqui que eu não aconselho executar o ElasticSearch em container, porque?

Porque ele precisa armazenar os Logs, ou seja, qualquer dado que o Graylog receber. Sendo assim o volume precisa ser persistente e se você, assim como eu, precisa armazenar isso por 5 anos, existem soluções mais adequadas para isso. Criar um cluster de ElasticSearch seria uma delas, ou utilizar um Saas como o ElasticService da AWS por exemplo, mas para esse Lab vamos subir um ElasticSearch na própria stack com volume local mesmo.

Vamos começar com o primeiro docker-compose:

version: '3.7'

services:
  mongo:
    image: mongo:3
    volumes:
      - ./mongo_data:/data/db
    networks:
      - graylog-network

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch-oss:6.8.2
    volumes:
      - ./es_data:/usr/share/elasticsearch/data
    environment:
      - http.host=0.0.0.0
      - transport.host=localhost
      - network.host=0.0.0.0
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    networks:
      - graylog-network

  graylog:
    image: graylog/graylog:3.1.0
    volumes:
      - ./graylog_journal:/usr/share/graylog/data/journal
    environment:
      - TZ=America/Sao_Paulo
      - GRAYLOG_ROOT_TIMEZONE=America/Sao_Paulo
      - GRAYLOG_PASSWORD_SECRET=somepasswordpepper
      # Password: admin
      - GRAYLOG_ROOT_PASSWORD_SHA2=8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918
      - GRAYLOG_HTTP_EXTERNAL_URI=http://127.0.0.1:9000/
      - GRAYLOG_ELASTICSEARCH_INDEX_PREFIX=graylog
    depends_on:
      - elasticsearch
      - mongo
    networks:
      - graylog-network
    ports:
      # GELF TCP LOG
      - 12201:12201
      # Graylog web interface and REST API
      - 9000:9000

networks:
  graylog-network:
    external: false

Refêrencia: https://docs.graylog.org/en/3.1/pages/installation/docker.html Nesse Compose file estamos definindo três serviços, um Mongodb, um ElasticSearch e um Graylog ambos com volume local e uma network chamada graylog-network. A network vai permitir a conexão desses containers pelo nome do serviço. Poderíamos utilizar o parâmetro link do Compose, mas eu acho mais “bonito” criar networks, isso fica a critério de cada um.

Beleza, Compose pronto vamos executar o comando docker-compose-up para subir os containers.

Em alguns minutos todos os serviços vão estar disponiveis , e o Graylog vai informar que está up and running:

Sucesso! agora basta acessar via browser o endereço 127.0.0.1:9000 e logar com o usuário e senha que configuramos na env GRAYLOG_ROOT_PASSWORD_SHA2 (admin/admin). Por sinal para aprender a gerar essa chave pode verificar esse link da própria Graylog, na sessão Properties ele mostra como gerar uma chave.

O proximo passo é enviar um log para esse cara, como o nosso exemplo está utilizando container vamos subir um Nginx (WebServer) em container e configurar o log drive como GELF, assim podemos enviar os logs diretamente para o Graylog sem grandes dificuldades. Não sabe o que é GELF? Dá uma olhadinha nesse link.

Bora! Primeiro precisamos criar nosso primeiro input, para isso basta clicar em system > inputs depois selecionar o tipo de input como GELF TCP e clicar em Launch new input, selecionar o node que vamos utilizar (nesse caso temos um só, mas o Graylog pode ser configurado em cluster e ter vários nodes). Adicione um título e escolha a porta que ficara exposta, aqui estamos utilizando a porta padrão 12201/tcp, depois é só salvar. Importante salientar que a porta escolhida precisa ser exposta no Docker, por esse motivo tem uma porta 12201 ali no docker-compose.yml.

Okay, agora que nosso Graylog já tem um Input configurado para receber Logs GELF vindo na porta 12201/tcp, vamos criar o Compose do Nginx com Log drive GELF configurado, vamos chamar ele de nginx.yml e adicionar o conteúdo abaixo.

PS: trocar o conteúdo do gelf-address: pelo ip do host onde está seu Graylog, no meu caso o ip 192.168.0.6:

version: '3.4'

services:
  web:
    image: nginx
    ports:
      - 8888:80
    logging:
      driver: gelf
      options:
        gelf-address: "tcp://192.168.0.7:12201"
        tag: meu-primeiro-site

Simples, não? Agora basta executar um “docker-compose -f nginx.yml up” e assim que o Container terminar de ser construído vamos ver a mensagem:

web_1  | WARNING: no logs are available with the 'gelf' log driver

Acesse o endereço 127.0.0.1:8888 para ver se o Nginx já está rodando.

Nginx funcionando, agora podemos acessar a página Search do Graylog e ver todos os Logs que estão chegando.

Clicando em cima dos Logs ele vai expandir e você pode ver todas as informações que vieram com esse log.

Lembrando que isso é só uma palhinha do que o Graylog consegue fazer, ali na Lupinha podemos pesquisar todos os Logs utilizando Regex e isso é muito bom para pesquisar Logs quando você tem 3 mil Logs por segundo, e ainda podemos extrair informações e criar novos campos (Fields) para facilitar a separação de Logs por nomes de aplicação ou ambientes. Aí a criatividade e necessidade entram em ação, podemos por exemplo, separar somente o http_response e criar um gráfico com status 200,300… 404 ou sei lá mais o que, segue uma imagem exemplo.

Muito fácil e prático não?

Lembrando que essa é somente uma forma de enviar logs para o Graylog, mas existem outras formas de fazer isso. Você pode obter mais informações nesse link Sending log to Graylog. Dê uma atenção especial ao Sidecar.

Um pouco sobre as configurações do Graylog: você consegue configurar quase tudo pela WEB GUI, no menu Stream você pode criar regras específicas para separar grupos de Logs, no Dashboard você pode montar as “perfumarias” dos Logs como vimos acima, em System temos todas as configurações que podem ser feitas inclusive a parte de Autenticação de usuário =), nesse mesmo menu temos as configurações dos Índices que usamos no ElasticSearch, essa é uma configuração muito delicada e vale a pena dar uma lida na documentação Index Set.

Bom, agora temos um Graylog operando normalmente, mas ainda podemos fazer alguns upgrades no nosso Compose, como por exemplo adicionar o Cerebro (lmenezes/cerebro)[https://github.com/lmenezes/cerebro] uma Web GUI para nosso ElasticSearch, assim podemos fazer uma gestão melhor do nosso ElasticSearch (espero que você tenha lido a documentação do Index Set porque isso vai fazer sentido =D). Outra melhoria que podemos fazer é utilizar um Traefik carregando um certificado SSL e assim ter um Graylog mais seguro utilizando HTTPS, mas por enquanto vamos ver somente o Cerebro.

Para adicionar o Cerebro a nossa Stack, primeiro vamos precisar criar o arquivo de configuração do Cerebro no diretório local.

Vamos criar o arquivo application.conf que vai estar dentro do diretório cerebro-config:

$ vim cerebro-config/application.conf

Conteúdo do arquivo:

# Secret will be used to sign session cookies, CSRF tokens and for other encryption utilities.
# It is highly recommended to change this value before running cerebro in production.
secret = "ki:s:[[@=Ag?QI`W2jMwkY:eqvrJ]JqoJyi2axj3ZvOv^/KavOT4ViJSv?6YY4[N"

# Application base path
basePath = "/"

# Defaults to RUNNING_PID at the root directory of the app.
# To avoid creating a PID file set this value to /dev/null
pidfile.path=/dev/null

# Rest request history max size per user
rest.history.size = 50 // defaults to 50 if not specified

# Path of local database file
data.path = "/opt/cerebro/cerebro.db"

es = {
  gzip = true
}

# A list of known hosts
hosts = [
  {
   host = "http://elasticsearch:9200"
   name = "ES Local"
   headers-whitelist = [ "x-proxy-user", "x-proxy-roles", "X-Forwarded-For" ]
  }
]

Beleza, vamos precisar deste arquivo para informar ao Cerebro onde está nosso ES. Como podem ver, passamos o endereço elasticsearch:9200 porque vamos colocar o Cérebro na mesma networking da Stack do Graylog.

Agora basta adicionar o serviço do Cerebro ao docker-compose.yml, ele vai ficar assim:

version: '3.7'

services:
  cerebro:
    image: lmenezes/cerebro:latest
    volumes:
      - ./cerebro-config:/app
    command: bin -Dconfig.file=/app/application.conf
    depends_on:
      - elasticsearch
    ports:
      - 8080:9000
    networks:
      - graylog-network

  mongo:
    image: mongo:3
    volumes:
      - ./mongo_data:/data/db
    networks:
      - graylog-network

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch-oss:6.8.2
    volumes:
      - ./es_data:/usr/share/elasticsearch/data
    environment:
      - http.host=0.0.0.0
      - transport.host=localhost
      - network.host=0.0.0.0
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    networks:
      - graylog-network

  graylog:
    image: graylog/graylog:3.1.0
    volumes:
      - ./graylog_journal:/usr/share/graylog/data/journal
    environment:
      # SET TIMEZONE CONTAINER AND GRAYLOG
      - TZ=America/Sao_Paulo
      - GRAYLOG_ROOT_TIMEZONE=America/Sao_Paulo
      # CHANGE ME (must be at least 16 characters)!
      - GRAYLOG_PASSWORD_SECRET=somepasswordpepper
      # Password: admin
      - GRAYLOG_ROOT_PASSWORD_SHA2=8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918
      - GRAYLOG_HTTP_EXTERNAL_URI=http://127.0.0.1:9000/
      - GRAYLOG_ELASTICSEARCH_INDEX_PREFIX=graylog
    depends_on:
      - elasticsearch
      - mongo
    networks:
      - graylog-network
    ports:
      # GELF TCP LOG
      - 12201:12201
      # Graylog web interface and REST API
      - 9000:9000

networks:
  graylog-network:
    external: false

Show, agora basta derrubar o Compose e subir novamente.

$docker-compose down
$docker-compose up

Vamos acessar o endereço do Cerebro http://127.0.0.1:8080, selecionar nosso ElasticSearch com o nome de ES local e clicar em connect. Como deixamos o acesso sem restrições de usuário e senha ele vai acessar diretamente.

O Cerebro é uma ferramenta bem poderosa, podendo ser utilizada para configurar grande parte do ES, inclusive o backup com envio direto para um Bucket na nuvem. Vale a pena dar uma olhada de perto nesse cara.

Pronto galera acho que é isso, lembrando que criamos um Lab aqui, somente uma POC para futuros projetos. Hoje eu tenho um Graylog em produção executando em Container porém o ES e o MongoDB estão em Saas completamente isolados da Stack e tenho somente o Graylog, Cerebro e um Treafik rodando em Container.

— O Traefik é uma coisa interessante desse projeto e pretendo escrever um outro Artigo sobre como colocar um Traefik na frente disso tudo e ter uma conexão mais segura usando Https–.

Dúvidas sobre alguma coisa relacionada a Graylog podem perguntar nos comentários que vamos responder ou fazer um post sobre o assunto =)

É isso galera, abraços.