Análise de Logs com Graylog | Guia Completo

Introdução

Neste laboratório, você aprenderá a usar o Graylog, uma poderosa plataforma de gerenciamento de logs de código aberto, para coletar e analisar dados de logs. O registro centralizado é um componente crítico da cibersegurança, permitindo monitorar eventos do sistema, detectar anomalias e investigar incidentes de segurança a partir de uma única interface.

Você começará implantando todo o stack do Graylog, que inclui MongoDB e OpenSearch (o substituto moderno para Elasticsearch), usando Docker Compose. Em seguida, configurará o Graylog para receber dados de logs, enviará logs de exemplo para ele, executará consultas de pesquisa para filtrar informações e, finalmente, criará um painel visual para monitorar métricas chave. Ao final deste laboratório, você terá experiência prática com o fluxo de trabalho fundamental da análise de logs no Graylog.

Implantar Graylog com Docker Compose

Nesta primeira etapa, você implantará a plataforma de logging Graylog. Usaremos o Docker Compose v2, uma ferramenta para definir e executar aplicações multi-container Docker. Essa abordagem simplifica o processo de configuração, gerenciando todos os componentes necessários — Graylog, OpenSearch e MongoDB — com um único arquivo de configuração.

Primeiro, vamos preparar o ambiente e iniciar os serviços.

O script de configuração já instalou o Docker Compose v2 para você. Você pode verificar a instalação verificando sua versão.
```
docker compose version
```
Você deverá ver uma saída indicando a versão do Docker Compose, semelhante a esta:
```
Docker Compose version v2.29.7
```
Navegue até o diretório dedicado para sua configuração do Graylog. Isso ajuda a manter seu projeto organizado.
```
cd /home/labex/project/graylog
```
Em seguida, crie o arquivo de configuração docker-compose.yml usando o editor de texto nano. Este arquivo informa ao Docker Compose quais contêineres executar e como configurá-los.
```
nano docker-compose.yml
```

Copie e cole a seguinte configuração YAML no editor nano. Esta configuração define três serviços:

mongodb: Armazena os dados de configuração do Graylog.
opensearch: Indexa e armazena as mensagens de log para pesquisa rápida. Observe que o OpenSearch 2.12+ requer uma senha de administrador inicial.
graylog: A aplicação principal, fornecendo a interface web e o motor de processamento de logs.

services:
  mongodb:
    image: mongo:6.0
    container_name: graylog_mongodb
    volumes:
      - mongo_data:/data/db
    networks:
      - graylog_network
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.runCommand('ping').ok"]
      interval: 30s
      timeout: 10s
      retries: 3
  opensearch:
    image: opensearchproject/opensearch:2.13.0
    container_name: graylog_opensearch
    environment:
      - discovery.type=single-node
      - plugins.security.disabled=true
      - bootstrap.memory_lock=true
      - "OPENSEARCH_JAVA_OPTS=-Xms512m -Xmx512m"
      - "OPENSEARCH_INITIAL_ADMIN_PASSWORD=StrongPassword123!"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - opensearch_data:/usr/share/opensearch/data
    networks:
      - graylog_network
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "curl -f http://localhost:9200/_cluster/health || exit 1"
        ]
      interval: 30s
      timeout: 10s
      retries: 3
  graylog:
    image: graylog/graylog:6.1
    container_name: graylog_server
    volumes:
      - graylog_data:/usr/share/graylog/data
    environment:
      - GRAYLOG_PASSWORD_SECRET=somepasswordpepper
      - GRAYLOG_ROOT_PASSWORD_SHA2=8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918
      - GRAYLOG_HTTP_EXTERNAL_URI=http://127.0.0.1:9000/
      - GRAYLOG_ELASTICSEARCH_HOSTS=http://opensearch:9200
      - GRAYLOG_MONGODB_URI=mongodb://mongodb:27017/graylog
    depends_on:
      mongodb:
        condition: service_healthy
      opensearch:
        condition: service_healthy
    ports:
      - "9000:9000"
      - "1514:1514"
      - "1514:1514/udp"
      - "12201:12201"
      - "12201:12201/udp"
    networks:
      - graylog_network
volumes:
  mongo_data:
  opensearch_data:
  graylog_data:
networks:
  graylog_network:
    driver: bridge

Pressione Ctrl+O, depois Enter para salvar o arquivo e Ctrl+X para sair do nano.

Agora, inicie todos os serviços em segundo plano usando o flag -d (detached).
```
docker compose up -d
```

Pode levar um ou dois minutos para que todos os serviços sejam inicializados. Você pode verificar o status de seus contêineres para garantir que eles estejam em execução corretamente.

docker compose ps

Você deverá ver todos os três serviços (graylog_server, graylog_opensearch, graylog_mongodb) com um State de Up.

NAME                 IMAGE                                 COMMAND                  SERVICE      CREATED              STATUS                        PORTS
graylog_mongodb      mongo:6.0                             "docker-entrypoint.s…"   mongodb      About a minute ago   Up About a minute (healthy)   27017/tcp
graylog_opensearch   opensearchproject/opensearch:2.13.0   "./opensearch-docker…"   opensearch   About a minute ago   Up About a minute (healthy)   9200/tcp, 9300/tcp, 9600/tcp, 9650/tcp
graylog_server       graylog/graylog:6.1                   "tini -- /docker-ent…"   graylog      About a minute ago   Up 34 seconds (healthy)       0.0.0.0:1514->1514/tcp, :::1514->1514/tcp, 0.0.0.0:9000->9000/tcp, 0.0.0.0:1514->1514/udp, :::9000->9000/tcp, :::1514->1514/udp, 0.0.0.0:12201->12201/tcp, 0.0.0.0:12201->12201/udp, :::12201->12201/tcp, :::12201->12201/udp

A interface web do Graylog está agora acessível. Você implantou com sucesso o stack do Graylog e está pronto para configurá-lo.

Configurar uma Entrada Syslog

Com o Graylog em execução, o próximo passo é configurar um "Input". Um input é um componente que informa ao Graylog como aceitar mensagens de log. Para este laboratório, você criará um input Syslog UDP, que é um padrão comum para coletar logs de dispositivos de rede e servidores Linux/Unix.

Abra a interface web do Graylog em seu navegador. Você pode fazer isso clicando na aba "Web Terminal" e selecionando "Desktop" para abrir o navegador, ou usando o ícone dedicado do navegador no ambiente do laboratório. Navegue para o seguinte URL:

http://127.0.0.1:9000
Faça login com as credenciais padrão:
- Nome de usuário: admin
- Senha: admin
Após o login, você criará o novo input. Na barra de navegação superior, clique em System e, em seguida, selecione Inputs no menu suspenso.
Na página Inputs, encontre o tipo de input "Syslog UDP" na lista suspensa "Select input" e clique no botão Launch new input ao lado dele.
Uma janela modal aparecerá. Preencha o formulário com os seguintes detalhes para configurar o input:
- Node: Selecione o único nó disponível na lista suspensa (será o seu servidor Graylog).
- Title: Syslog UDP Input (Este é um nome descritivo para o seu input).
- Bind address: 0.0.0.0 (Isso informa ao Graylog para escutar logs em todas as interfaces de rede do contêiner).
- Port: 1514 (Esta é a porta onde o Graylog escutará as mensagens syslog recebidas).
Deixe todas as outras configurações como padrão e clique em Save.
Após salvar, você retornará à página Inputs. Seu novo "Syslog UDP Input" deverá aparecer na lista com um status verde "Running", indicando que está ativo e pronto para receber dados.
Para testar o input, retorne ao seu terminal e envie uma mensagem de log de exemplo usando o utilitário netcat (nc). Este comando constrói uma mensagem syslog básica e a envia para a porta UDP 1514 em sua máquina local.
```
echo "<14>$(date +'%b %d %H:%M:%S') localhost labex: Test syslog message" | nc -w1 -u 127.0.0.1 1514
```

Você agora configurou com sucesso o Graylog para receber logs. Na próxima etapa, você enviará logs mais estruturados e aprenderá como visualizá-los na interface do Graylog.

Enviar e Visualizar Logs de Exemplo

Agora que seu input Syslog está pronto, é hora de gerar e enviar um lote de logs de exemplo. Isso preencherá o Graylog com dados, permitindo que você pratique a busca e a análise. Você criará um script simples de shell para simular mensagens de log de uma aplicação.

Primeiro, navegue de volta para o diretório raiz do seu projeto no terminal.
```
cd /home/labex/project
```
Crie um novo script de shell chamado generate_logs.sh usando o editor nano.
```
nano generate_logs.sh
```
Copie e cole o seguinte script no editor. Este script gera 10 mensagens de log em um loop. Cada mensagem tem um nível de severidade aleatório, um timestamp e um corpo de mensagem simples. Em seguida, ele usa nc para enviar cada log para o input do Graylog que você configurou.
```
#!/bin/bash
for i in {1..10}; do
  severity=$(((RANDOM % 8)))
  timestamp=$(date +'%b %d %H:%M:%S')
  echo "<$((severity + 8))>$timestamp localhost sample_app[$i]: Sample log message $i with severity $severity" | nc -w1 -u 127.0.0.1 1514
  echo "Sent log message $i"
  sleep 1
done
```
Pressione Ctrl+O, Enter e Ctrl+X para salvar e sair.
Torne o script executável usando o comando chmod.
```
chmod +x generate_logs.sh
```
Execute o script para enviar os logs para o Graylog.
```
./generate_logs.sh
```
Você verá a saída em seu terminal à medida que cada log é enviado.
```
Sent log message 1
Sent log message 2
...
Sent log message 10
```
Agora, vamos visualizar esses logs no Graylog. Volte para a interface web do Graylog em seu navegador (http://127.0.0.1:9000).
Clique na aba Search na barra de navegação superior. Você deverá ver as mensagens de log que acabou de enviar aparecerem na lista "Messages". Pode levar alguns segundos para que sejam indexadas e exibidas.

Você pode ver como o Graylog analisa automaticamente as mensagens, dividindo-as em campos como timestamp, source, application_name e severity. Esses dados estruturados são a chave para uma análise eficaz de logs.

Consultar e Analisar Dados de Logs

Com os logs fluindo para o Graylog, você agora pode aprender como pesquisá-los e filtrá-los. A funcionalidade de busca do Graylog é poderosa e permite que você localize rapidamente eventos específicos. Isso é essencial para solucionar problemas ou investigar incidentes de segurança.

Vá para a página Search na interface web do Graylog. A barra de busca fica no topo da página.
Vamos começar com uma consulta simples. Para encontrar todos os logs da sua aplicação simulada, digite o seguinte na barra de busca e pressione Enter:

application_name:sample_app

Isso filtra os resultados para mostrar apenas os logs onde o campo application_name é exatamente sample_app.
Agora, tente outras consultas para explorar diferentes capacidades de filtragem:
- Encontrar logs com um nível de severidade específico (por exemplo, nível 4):
  severity:4
- Encontrar logs com um nível de severidade maior que 5 (avisos, erros, etc.):
  severity:>5
- Pesquisar por uma frase dentro da mensagem de log:
  message:"log message 5"
- Combinar filtros usando AND:
  application_name:sample_app AND severity:<3
Você também pode controlar o período de tempo da sua busca. Por padrão, o Graylog mostra os logs dos "Últimos 5 minutos". Clique no seletor de intervalo de tempo à esquerda da barra de busca e altere-o para Last 30 minutes para garantir que todos os seus logs gerados sejam incluídos nos resultados da busca.
Para tornar uma consulta frequentemente usada facilmente acessível, você pode salvá-la. Vamos salvar uma busca por eventos de alta severidade.
- Execute a consulta: severity:>4
- À direita da barra de busca, clique no ícone do disquete (Save Search).
- Na caixa de diálogo "Save Search", insira um Title, por exemplo, High Severity Events.
- Clique em Save.
Você agora pode acessar essa busca salva a qualquer momento na lista "Saved Searches" na barra lateral esquerda, permitindo que você verifique rapidamente eventos críticos.

Criar um Painel de Monitoramento

Enquanto a página de busca é ótima para investigação ativa, os painéis (dashboards) fornecem uma visão geral dos seus dados de log. Nesta etapa final, você criará um painel com vários widgets para visualizar métricas chave dos seus logs.

Na interface web do Graylog, navegue até a seção Dashboards no menu superior.
Clique no botão Create dashboard.
- Insira um Title: Application Health Dashboard
- Insira uma Description: Monitors the health and activity of sample_app.
- Clique em Create.
Agora você tem um painel vazio. Vamos adicionar alguns widgets a ele. Clique no botão Unlock / Edit para entrar no modo de edição.
Adicionar um Widget "Log Count": Este widget mostrará o número total de mensagens de log ao longo do tempo.
- Clique em Create Widget for Dashboard.
- Selecione Aggregation como o tipo de widget.
- Na janela de configuração:
  - Title: Total Log Volume
  - Em "Rows", selecione timestamp como o campo.
  - Escolha Bar Chart como o tipo de visualização.
- Clique em Create.
Adicionar um Widget "Severity Distribution": Este widget mostrará a distribuição de logs por nível de severidade.
- Clique em Create Widget for Dashboard novamente.
- Selecione Aggregation como o tipo de widget.
- Na janela de configuração:
  - Title: Log Severity Distribution
  - Em "Rows", selecione severity como o campo.
  - Escolha Pie Chart como o tipo de visualização.
- Clique em Create.
Adicionar um Widget "Recent Messages": Este widget exibirá uma lista das mensagens de log mais recentes.
- Clique em Create Widget for Dashboard.
- Selecione Messages como o tipo de widget.
- Na janela de configuração:
  - Title: Recent Log Messages
  - No campo "Streams", certifique-se de que All messages esteja selecionado.
- Clique em Create.
Depois de adicionar os widgets, você pode arrastá-los e soltá-los para organizar o layout. Você também pode redimensioná-los arrastando seus cantos. Organize-os de uma forma que seja fácil de ler.
Quando estiver satisfeito com o layout, clique no botão Lock / Save no canto superior direito para salvar seu painel.

Você agora criou um painel de monitoramento básico. Em um cenário do mundo real, painéis como este são inestimáveis para acompanhar a saúde do sistema e a postura de segurança.

Resumo

Neste laboratório, você adquiriu experiência prática com as funcionalidades principais do Graylog para gerenciamento e análise de logs. Você começou implantando um ambiente Graylog completo usando Docker Compose, que incluiu o servidor Graylog, OpenSearch e MongoDB.

Em seguida, configurou uma entrada Syslog para habilitar a coleta de logs e usou um script para enviar dados de log de amostra, simulando logs de aplicações do mundo real. Você aprendeu a usar a poderosa linguagem de busca e consulta do Graylog para filtrar e encontrar informações específicas em seus logs. Finalmente, você juntou tudo construindo um painel personalizado com vários widgets para visualizar métricas de log, fornecendo uma visão geral da atividade do sistema. Essas habilidades formam uma base sólida para usar o Graylog em monitoramento de segurança cibernética e inteligência operacional.

Analisar Logs no Graylog