Logstash - Guia rápido

Logstash é uma ferramenta baseada nos padrões de filtro / tubos para coletar, processar e gerar os logs ou eventos. Ele ajuda a centralizar e fazer análises em tempo real de logs e eventos de diferentes fontes.

O Logstash é escrito na linguagem de programação JRuby que é executada na JVM, portanto, você pode executar o Logstash em diferentes plataformas. Ele coleta diferentes tipos de dados, como logs, pacotes, eventos, transações, dados de carimbo de data / hora, etc., de quase todos os tipos de fontes. A fonte de dados pode ser dados sociais, comércio eletrônico, artigos de notícias, CRM, dados de jogos, tendências da web, dados financeiros, Internet das coisas, dispositivos móveis, etc.

Recursos gerais do Logstash

As características gerais do Logstash são as seguintes -

• O Logstash pode coletar dados de diferentes fontes e enviar para vários destinos.

• Logstash pode lidar com todos os tipos de dados de registro, como Apache Logs, Windows Event Logs, dados sobre protocolos de rede, dados de entrada padrão e muito mais.

• O Logstash também pode lidar com solicitações HTTP e dados de resposta.

• O Logstash fornece uma variedade de filtros, que ajudam o usuário a encontrar mais significado nos dados, analisando-os e transformando-os.

• O Logstash também pode ser usado para lidar com dados de sensores na internet das coisas.

• O Logstash é um código-fonte aberto e está disponível sob a licença Apache versão 2.0.

Conceitos-chave do Logstash

Os conceitos-chave do Logstash são os seguintes -

Objeto de Evento

É o objeto principal no Logstash, que encapsula o fluxo de dados no pipeline do Logstash. Logstash usa este objeto para armazenar os dados de entrada e adicionar campos extras criados durante o estágio de filtro.

Logstash oferece uma API de eventos para que os desenvolvedores manipulem eventos. Neste tutorial, este evento é referido com vários nomes, como Evento de registro de dados, Evento de registro, Dados de registro, Dados de registro de entrada, Dados de registro de saída etc.

Pipeline

É composto por estágios de fluxo de dados no Logstash, da entrada à saída. Os dados de entrada são inseridos no pipeline e são processados ​​na forma de um evento. Em seguida, envia para um destino de saída no formato desejável do usuário ou do sistema final.

Entrada

Este é o primeiro estágio no pipeline do Logstash, que é usado para obter os dados no Logstash para processamento posterior. Logstash oferece vários plug-ins para obter dados de diferentes plataformas. Alguns dos plugins mais comumente usados ​​são - File, Syslog, Redis e Beats.

Filtro

Este é o estágio intermediário do Logstash, onde ocorre o processamento real dos eventos. Um desenvolvedor pode usar Padrões Regex predefinidos por Logstash para criar sequências para diferenciar entre os campos nos eventos e critérios para eventos de entrada aceitos.

O Logstash oferece vários plug-ins para ajudar o desenvolvedor a analisar e transformar os eventos em uma estrutura desejável. Alguns dos plug-ins de filtro mais comumente usados ​​são - Grok, Mutate, Drop, Clone e Geoip.

Resultado

Este é o último estágio no pipeline do Logstash, onde os eventos de saída podem ser formatados na estrutura exigida pelos sistemas de destino. Por último, ele envia o evento de saída após o processamento completo para o destino usando plug-ins. Alguns dos plug-ins mais usados ​​são - Elasticsearch, File, Graphite, Statsd, etc.

Vantagens do Logstash

Os pontos a seguir explicam as várias vantagens do Logstash.

• O Logstash oferece sequências de padrão regex para identificar e analisar os vários campos em qualquer evento de entrada.

• Logstash oferece suporte a uma variedade de servidores web e fontes de dados para extrair dados de registro.

• O Logstash fornece vários plug-ins para analisar e transformar os dados de registro em qualquer formato desejável pelo usuário.

• O Logstash é centralizado, o que facilita o processamento e a coleta de dados de diferentes servidores.

• O Logstash suporta muitos bancos de dados, protocolos de rede e outros serviços como fonte de destino para os eventos de registro.

• O Logstash usa o protocolo HTTP, que permite ao usuário atualizar as versões do Elasticsearch sem ter que atualizar o Logstash em uma etapa de bloqueio.

Desvantagens do Logstash

Os pontos a seguir explicam as várias desvantagens do Logstash.

• O Logstash usa http, o que afeta negativamente o processamento dos dados de registro.

• Trabalhar com o Logstash às vezes pode ser um pouco complexo, pois requer um bom entendimento e análise dos dados de registro de entrada.

• Os plug-ins de filtro não são genéricos, portanto, o usuário pode precisar encontrar a sequência correta de padrões para evitar erros na análise.

No próximo capítulo, entenderemos o que é a pilha ELK e como ela ajuda o Logstash.

ELK significa Elasticsearch, Logstash, e Kibana. Na pilha ELK, o Logstash extrai os dados de registro ou outros eventos de diferentes fontes de entrada. Ele processa os eventos e depois os armazena no Elasticsearch. Kibana é uma interface web que acessa o formulário de dados de registro Elasticsearch e o visualiza.

Logstash e Elasticsearch

Logstash fornece plug-in Elasticsearch de entrada e saída para ler e gravar eventos de log no Elasticsearch. Elasticsearch como um destino de saída também é recomendado pela Elasticsearch Company por causa de sua compatibilidade com Kibana. O Logstash envia os dados ao Elasticsearch por meio do protocolo http.

Elasticsearch fornece facilidade de upload em massa, que ajuda a carregar os dados de diferentes fontes ou instâncias do Logstash para um mecanismo Elasticsearch centralizado. ELK tem as seguintes vantagens sobre outras soluções DevOps -

• A pilha ELK é mais fácil de gerenciar e pode ser escalada para lidar com petabytes de eventos.

• A arquitetura da pilha ELK é muito flexível e fornece integração com o Hadoop. O Hadoop é usado principalmente para fins de arquivamento. Logstash pode ser conectado diretamente ao Hadoop usando flume e Elasticsearch fornece um conector chamadoes-hadoop para se conectar ao Hadoop.

• O custo total de propriedade da ELK é muito menor do que suas alternativas.

Logstash e Kibana

Kibana não interage com o Logstash diretamente, mas por meio de uma fonte de dados, que é Elasticsearch na pilha ELK. O Logstash coleta os dados de todas as fontes e o Elasticsearch os analisa em uma velocidade muito rápida, então Kibana fornece os insights acionáveis ​​sobre esses dados.

Kibana é uma ferramenta de visualização baseada na web, que ajuda os desenvolvedores e outros a analisar as variações em grandes quantidades de eventos coletados pelo Logstash no mecanismo Elasticsearch. Essa visualização torna fácil prever ou ver as mudanças nas tendências de erros ou outros eventos significativos da fonte de entrada.

Para instalar o Logstash no sistema, devemos seguir as etapas abaixo -

Step 1- Verifique a versão do seu Java instalada no seu computador; deve ser Java 8 porque não é compatível com Java 9. Você pode verificar isso -

Em um sistema operacional Windows (SO) (usando prompt de comando) -

> java -version

No sistema operacional UNIX (usando terminal) -

$ echo $JAVA_HOME

Step 2 - Baixe Logstash de -

https://www.elastic.co/downloads/logstash.

• Para o sistema operacional Windows, baixe o arquivo ZIP.

• Para o sistema operacional UNIX, faça download do arquivo TAR.

• Para o sistema operacional Debian, baixe o arquivo DEB.

• Para Red Hat e outras distribuições Linux, baixe o arquivo RPN.

• Os utilitários APT e Yum também podem ser usados ​​para instalar o Logstash em muitas distribuições Linux.

Step 3- O processo de instalação do Logstash é muito fácil. Vamos ver como você pode instalar o Logstash em diferentes plataformas.

Note - Não coloque nenhum espaço em branco ou dois pontos na pasta de instalação.

• Windows OS - Descompacte o pacote zip e o Logstash é instalado.

• UNIX OS - Extraia o arquivo tar em qualquer local e o Logstash é instalado.

$tar –xvf logstash-5.0.2.tar.gz

Using APT utility for Linux OS −

• Baixe e instale a chave de assinatura pública -

$ wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

• Salve a definição do repositório -

$ echo "deb https://artifacts.elastic.co/packages/5.x/apt stable main" | sudo
   tee -a /etc/apt/sources.list.d/elastic-5.x.list

• Executar atualização -

$ sudo apt-get update

• Agora você pode instalar usando o seguinte comando -

$ sudo apt-get install logstash

Using YUM utility for Debian Linux OS -

• Baixe e instale a chave de assinatura pública -

$ rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

• Adicione o seguinte texto no arquivo com o sufixo .repo em seu diretório o “/etc/yum.repos.d/”. Por exemplo,logstash.repo

[logstash-5.x]
name = Elastic repository for 5.x packages
baseurl = https://artifacts.elastic.co/packages/5.x/yum
gpgcheck = 1
gpgkey = https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled = 1
autorefresh = 1
type = rpm-md

• Agora você pode instalar o Logstash usando o seguinte comando -

$ sudo yum install logstash

Step 4- Vá para o diretório inicial do Logstash. Dentro da pasta bin, execute oelasticsearch.batno caso do windows ou você pode fazer o mesmo usando o prompt de comando e através do terminal. No UNIX, execute o arquivo Logstash.

Precisamos especificar a fonte de entrada, fonte de saída e filtros opcionais. Para verificar a instalação, você pode executá-lo com a configuração básica usando um fluxo de entrada padrão (stdin) como fonte de entrada e um fluxo de saída padrão (stdout) como fonte de saída. Você pode especificar a configuração na linha de comando também usando–e opção.

In Windows −

> cd logstash-5.0.1/bin
> Logstash -e 'input { stdin { } } output { stdout {} }'

In Linux −

$ cd logstash-5.0.1/bin
$ ./logstash -e 'input { stdin { } } output { stdout {} }'

Note- no caso do Windows, você pode obter um erro informando que JAVA_HOME não está definido. Para isso, defina-o nas variáveis ​​de ambiente como “C: \ Arquivos de programas \ Java \ jre1.8.0_111” ou o local onde instalou o java.

Step 5 - As portas padrão para a interface da web do Logstash são 9600 a 9700 são definidas no logstash-5.0.1\config\logstash.yml Enquanto o http.port e pegará a primeira porta disponível no intervalo fornecido.

Podemos verificar se o servidor Logstash está instalado e funcionando, navegando http://localhost:9600ou se a porta for diferente e, em seguida, verifique o prompt de comando ou terminal. Podemos ver a porta atribuída como “Terminal da API Logstash iniciado com sucesso {: porta ⇒ 9600}. Ele retornará um objeto JSON, que contém as informações sobre o Logstash instalado da seguinte maneira -

{
   "host":"manu-PC", 
   "version":"5.0.1",
   "http_address":"127.0.0.1:9600",
   "build_date":"2016-11-11T22:28:04+00:00",
   "build_sha":"2d8d6263dd09417793f2a0c6d5ee702063b5fada",
   "build_snapshot":false
}

Neste capítulo, discutiremos sobre a arquitetura interna e os diferentes componentes do Logstash.

Arquitetura de serviço Logstash

Logstash processa logs de diferentes servidores e fontes de dados e se comporta como o remetente. Os remetentes são usados ​​para coletar os logs e estes são instalados em todas as fontes de entrada. Corretores gostamRedis, Kafka ou RabbitMQ são buffers para conter os dados para indexadores, pode haver mais de um brokers como instâncias de failover.

Indexadores gostam Lucenesão usados ​​para indexar os logs para melhor desempenho de pesquisa e, em seguida, a saída é armazenada no Elasticsearch ou outro destino de saída. Os dados no armazenamento de saída estão disponíveis para Kibana e outro software de visualização.

Arquitetura interna Logstash

O pipeline Logstash consiste em três componentes Input, Filters e Output. A parte de entrada é responsável por especificar e acessar a fonte de dados de entrada, como a pasta de log doApache Tomcat Server.

Exemplo para explicar o pipeline Logstash

O arquivo de configuração Logstash contém os detalhes sobre os três componentes do Logstash. Neste caso, estamos criando um nome de arquivo chamadoLogstash.conf.

A configuração a seguir captura dados de um log de entrada “inlog.log” e os grava em um log de saída “outlog.log” sem quaisquer filtros.

Logstash.conf

O arquivo de configuração do Logstash apenas copia os dados do inlog.log arquivo usando o plug-in de entrada e descarrega os dados de registro para outlog.log arquivo usando o plugin de saída.

input {
   file {
      path => "C:/tpwork/logstash/bin/log/inlog.log"
   }
}
output {
   file {
      path => "C:/tpwork/logstash/bin/log/outlog.log"
   }
}

Executar Logstash

Logstash usa –f opção para especificar o arquivo de configuração.

C:\logstash\bin> logstash –f logstash.conf

inlog.log

O bloco de código a seguir mostra os dados de registro de entrada.

Hello tutorialspoint.com

outlog.log

A saída do Logstash contém os dados de entrada no campo da mensagem. O Logstash também adiciona outros campos à saída, como Timestamp, Caminho da fonte de entrada, Versão, Host e Tags.

{
   "path":"C:/tpwork/logstash/bin/log/inlog1.log",
   "@timestamp":"2016-12-13T02:28:38.763Z",
   "@version":"1", "host":"Dell-PC",
   "message":" Hello tutorialspoint.com", "tags":[]
}

Como você pode, a saída do Logstash contém mais do que os dados fornecidos por meio do log de entrada. A saída contém o caminho de origem, carimbo de data / hora, versão, nome do host e tag, que são usados ​​para representar as mensagens extras como erros.

Podemos usar filtros para processar os dados e torná-los úteis para as nossas necessidades. No próximo exemplo, estamos usando um filtro para obter os dados, o que restringe a saída apenas aos dados com um verbo como GET ou POST seguido por umUnique Resource Identifier.

Logstash.conf

Nesta configuração do Logstash, adicionamos um filtro chamado grokpara filtrar os dados de entrada. O evento de registro de entrada, que corresponde ao registro de entrada da sequência padrão, só chega ao destino de saída com erro. O Logstash adiciona uma tag chamada "_grokparsefailure" nos eventos de saída, que não corresponde à sequência do padrão do filtro grok.

Logstash oferece muitos padrões regex embutidos para analisar logs de servidor populares como o Apache. O padrão usado aqui espera um verbo como get, post, etc., seguido por um identificador de recurso uniforme.

input {
   file {
      path => "C:/tpwork/logstash/bin/log/inlog2.log"
   }
}
filter {
   grok {
      match => {"message" => "%{WORD:verb} %{URIPATHPARAM:uri}"}
   }
}
output {
   file {
      path => "C:/tpwork/logstash/bin/log/outlog2.log"
   }
}

Executar Logstash

Podemos executar o Logstash usando o seguinte comando.

C:\logstash\bin> logstash –f  Logstash.conf

inlog2.log

Nosso arquivo de entrada contém dois eventos separados por delimitador padrão, ou seja, delimitador de nova linha. O primeiro evento corresponde ao padrão especificado em GROk e o segundo não.

GET /tutorialspoint/Logstash
Input 1234

outlog2.log

Podemos ver que o segundo evento de saída contém a tag "_grokparsefailure", porque não corresponde ao padrão de filtro grok. O usuário também pode remover esses eventos incomparáveis ​​na saída usando o‘if’ condição no plugin de saída.

{
   "path":"C:/tpwork/logstash/bin/log/inlog2.log",
   "@timestamp":"2016-12-13T02:47:10.352Z","@version":"1","host":"Dell-PC","verb":"GET",
   "message":"GET /tutorialspoint/logstash", "uri":"/tutorialspoint/logstash", "tags":[]
}
{
   "path":"C:/tpwork/logstash/bin/log/inlog2.log",
   "@timestamp":"2016-12-13T02:48:12.418Z", "@version":"1", "host":"Dell-PC",
   "message":"t 1234\r", "tags":["_grokparsefailure"]
}

Logs de diferentes servidores ou fontes de dados são coletados usando remetentes. Um remetente é uma instância do Logstash instalada no servidor, que acessa os logs do servidor e envia para um local de saída específico.

Ele envia principalmente a saída para o Elasticsearch para armazenamento. O Logstash recebe informações das seguintes fontes -

• STDIN
• Syslog
• Files
• TCP/UDP
• Logs de eventos do Microsoft Windows
• Websocket
• Zeromq
• Extensões personalizadas

Coletando registros usando o servidor Apache Tomcat 7

Neste exemplo, estamos coletando logs do servidor Apache Tomcat 7 instalado no Windows usando o plugin de entrada de arquivo e enviando-os para o outro log.

logstash.conf

Aqui, o Logstash é configurado para acessar o log de acesso do Apache Tomcat 7 instalado localmente. Um padrão regex é usado na configuração do caminho do plugin de arquivo para obter os dados do arquivo de log. Este contém “access” em seu nome e adiciona um tipo apache, que ajuda a diferenciar os eventos apache de outros em uma fonte de destino centralizada. Finalmente, os eventos de saída serão mostrados no output.log.

input {
   file {
      path => "C:/Program Files/Apache Software Foundation/Tomcat 7.0/logs/*access*"
      type => "apache"
   }
} 
output {
   file {
      path => "C:/tpwork/logstash/bin/log/output.log"
   }
}

Executar Logstash

Podemos executar o Logstash usando o seguinte comando.

C:\logstash\bin> logstash –f  Logstash.conf

Log do Apache Tomcat

Acesse o Apache Tomcat Server e seus aplicativos da web (http://localhost:8080) para gerar logs. Os dados atualizados nos logs são lidos pelo Logstash em tempo real e armazenados em output.log conforme especificado no arquivo de configuração.

O Apache Tomcat gera um novo arquivo de log de acesso de acordo com a data e registra os eventos de acesso lá. No nosso caso, era localhost_access_log.2016-12-24.txt nologs diretório do Apache Tomcat.

0:0:0:0:0:0:0:1 - - [
   25/Dec/2016:18:37:00 +0800] "GET / HTTP/1.1" 200 11418
0:0:0:0:0:0:0:1 - munish [
   25/Dec/2016:18:37:02 +0800] "GET /manager/html HTTP/1.1" 200 17472
0:0:0:0:0:0:0:1 - - [
   25/Dec/2016:18:37:08 +0800] "GET /docs/ HTTP/1.1" 200 19373
0:0:0:0:0:0:0:1 - - [
   25/Dec/2016:18:37:10 +0800] "GET /docs/introduction.html HTTP/1.1" 200 15399

output.log

Você pode ver nos eventos de saída, um campo de tipo é adicionado e o evento está presente no campo de mensagem.

{
   "path":"C:/Program Files/Apache Software Foundation/Tomcat 7.0/logs/
   localhost_access_log.2016-12-25.txt",
   "@timestamp":"2016-12-25T10:37:00.363Z","@version":"1","host":"Dell-PC",
   "message":"0:0:0:0:0:0:0:1 - - [25/Dec/2016:18:37:00 +0800] \"GET /
   HTTP/1.1\" 200 11418\r","type":"apache","tags":[]
}
{
   "path":"C:/Program Files/Apache Software Foundation/Tomcat 7.0/logs/
   localhost_access_log.2016-12-25.txt","@timestamp":"2016-12-25T10:37:10.407Z",
   "@version":"1","host":"Dell-PC",
   "message":"0:0:0:0:0:0:0:1 - munish [25/Dec/2016:18:37:02 +0800] \"GET /
   manager/html HTTP/1.1\" 200 17472\r","type":"apache","tags":[]
}
{
   "path":"C:/Program Files/Apache Software Foundation/Tomcat 7.0/logs/
   localhost_access_log.2016-12-25.txt","@timestamp":"2016-12-25T10:37:10.407Z",
   "@version":"1","host":"Dell-PC",
   "message":"0:0:0:0:0:0:0:1 - - [25/Dec/2016:18:37:08 +0800] \"GET /docs/
   HTTP/1.1\" 200 19373\r","type":"apache","tags":[]
}
{
   "path":"C:/Program Files/Apache Software Foundation/Tomcat 7.0/logs/
   localhost_access_log.2016-12-25.txt","@timestamp":"2016-12-25T10:37:20.436Z",
   "@version":"1","host":"Dell-PC",
   "message":"0:0:0:0:0:0:0:1 - - [25/Dec/2016:18:37:10 +0800] \"GET /docs/
   introduction.html HTTP/1.1\" 200 15399\r","type":"apache","tags":[]
}

Coletando registros usando o plug-in STDIN

Nesta seção, discutiremos outro exemplo de coleta de logs usando o STDIN Plugin.

logstash.conf

É um exemplo muito simples, onde o Logstash está lendo os eventos inseridos pelo usuário em uma entrada padrão. No nosso caso, é o prompt de comando, que armazena os eventos no arquivo output.log.

input {
   stdin{}
}
output {
   file {
      path => "C:/tpwork/logstash/bin/log/output.log"
   }
}

Executar Logstash

Podemos executar o Logstash usando o seguinte comando.

C:\logstash\bin> logstash –f  Logstash.conf

Escreva o seguinte texto no prompt de comando -

O usuário inseriu as duas linhas a seguir. Logstash separa os eventos pela configuração do delimitador e seu valor por padrão é '\ n'. O usuário pode alterar alterando o valor do delimitador no plugin do arquivo.

Tutorialspoint.com welcomes you
Simply easy learning

output.log

O bloco de código a seguir mostra os dados do log de saída.

{
   "@timestamp":"2016-12-25T11:41:16.518Z","@version":"1","host":"Dell-PC",
   "message":"tutrialspoint.com welcomes you\r","tags":[]
}
{
   "@timestamp":"2016-12-25T11:41:53.396Z","@version":"1","host":"Dell-PC",
   "message":"simply easy learning\r","tags":[]
}

O Logstash oferece suporte a uma grande variedade de registros de diferentes fontes. Ele está trabalhando com fontes famosas, conforme explicado abaixo.

Colete registros de métricas

Os eventos do sistema e outras atividades temporais são registrados nas métricas. O Logstash pode acessar o log das métricas do sistema e processá-los usando filtros. Isso ajuda a mostrar ao usuário o feed ao vivo dos eventos de maneira personalizada. As métricas são liberadas de acordo com oflush_interval settingde filtro de métricas e por padrão; está definido para 5 segundos.

Estamos rastreando as métricas de teste geradas pelo Logstash, reunindo e analisando os eventos em execução por meio do Logstash e mostrando o feed ao vivo no prompt de comando.

logstash.conf

Essa configuração contém um plug-in gerador, que é oferecido pelo Logstash para métricas de teste e define a configuração de tipo como “gerado” para análise. Na fase de filtragem, estamos processando apenas as linhas com um tipo gerado usando a instrução 'if'. Então, o plugin de métricas conta o campo especificado nas configurações do medidor. O plug-in de métricas limpa a contagem a cada 5 segundos especificado noflush_interval.

Por último, a saída dos eventos de filtro para uma saída padrão como prompt de comando usando o codec pluginpara formatação. O plugin Codec está usando o valor [ events ] [ rate_1m ] para gerar os eventos por segundo em uma janela deslizante de 1 minuto.

input {
   generator {
     	type => "generated"
   }
}
filter {
   if [type] == "generated" {
      metrics {
         meter => "events"
         add_tag => "metric"
      }
   }
}
output {
   # only emit events with the 'metric' tag
   if "metric" in [tags] {
      stdout {
         codec => line { format => "rate: %{[events][rate_1m]}"
      }
   }
}

Executar Logstash

Podemos executar o Logstash usando o seguinte comando.

>logsaths –f logstash.conf

stdout (prompt de comando)

rate: 1308.4
rate: 1308.4
rate: 1368.654529135342
rate: 1416.4796003951449
rate: 1464.974293984808
rate: 1523.3119444107458
rate: 1564.1602979542715
rate: 1610.6496496890895
rate: 1645.2184750334154
rate: 1688.7768007612485
rate: 1714.652283095914
rate: 1752.5150680019278
rate: 1785.9432934744932
rate: 1806.912181962126
rate: 1836.0070454626025
rate: 1849.5669494173826
rate: 1871.3814756851832
rate: 1883.3443123790712
rate: 1906.4879113216743
rate: 1925.9420717997118
rate: 1934.166137658981
rate: 1954.3176526556897
rate: 1957.0107444542625

Colete registros do servidor web

Os servidores da Web geram um grande número de logs sobre o acesso do usuário e erros. O Logstash ajuda a extrair os logs de diferentes servidores usando plug-ins de entrada e armazená-los em um local centralizado.

Estamos extraindo os dados do stderr logs do servidor Apache Tomcat local e armazenando-o no output.log.

logstash.conf

Este arquivo de configuração do Logstash direciona o Logstash para ler os logs de erro do apache e adicionar uma tag chamada “apache-error”. Podemos simplesmente enviá-lo para o output.log usando o plugin de saída de arquivo.

input {
   file {
      path => "C:/Program Files/Apache Software Foundation/Tomcat 7.0 /logs/*stderr*"
      type => "apache-error"  
   }
} 
output {
   file {
      path => "C:/tpwork/logstash/bin/log/output.log"
   }
}

Executar Logstash

Podemos executar o Logstash usando o seguinte comando.

>Logstash –f Logstash.conf

Amostra de registro de entrada

Esta é a amostra stderr log, que é gerado quando os eventos do servidor ocorrem no Apache Tomcat.

C: \ Arquivos de programas \ Apache Software Foundation \ Tomcat 7.0 \ logs \ tomcat7-stderr.2016-12-25.log

Dec 25, 2016 7:05:14 PM org.apache.coyote.AbstractProtocol start
INFO: Starting ProtocolHandler ["http-bio-9999"]
Dec 25, 2016 7:05:14 PM org.apache.coyote.AbstractProtocol start
INFO: Starting ProtocolHandler ["ajp-bio-8009"]
Dec 25, 2016 7:05:14 PM org.apache.catalina.startup.Catalina start
INFO: Server startup in 823 ms

output.log

{
   "path":"C:/Program Files/Apache Software Foundation/Tomcat 7.0/logs/
   tomcat7-stderr.2016-12-25.log","@timestamp":"2016-12-25T11:05:27.045Z",
   "@version":"1","host":"Dell-PC",
   "message":"Dec 25, 2016 7:05:14 PM org.apache.coyote.AbstractProtocol start\r",
   "type":"apache-error","tags":[]
}
{
   "path":"C:/Program Files/Apache Software Foundation/Tomcat 7.0/logs/
   tomcat7-stderr.2016-12-25.log","@timestamp":"2016-12-25T11:05:27.045Z",
   "@version":"1","host":"Dell-PC",
   "message":"INFO: Starting ProtocolHandler [
      \"ajp-bio-8009\"]\r","type":"apache-error","tags":[]
}
{
   "path":"C:/Program Files/Apache Software Foundation/Tomcat 7.0/logs/
   tomcat7-stderr.2016-12-25.log","@timestamp":"2016-12-25T11:05:27.045Z",
   "@version":"1","host":"Dell-PC",
   "message":"Dec 25, 2016 7:05:14 PM org.apache.catalina.startup.Catalina start\r",
   "type":"apache-error","tags":[]
}
{
   "path":"C:/Program Files/Apache Software Foundation/Tomcat 7.0/logs/
   tomcat7-stderr.2016-12-25.log","@timestamp":"2016-12-25T11:05:27.045Z",
   "@version":"1","host":"Dell-PC",
   "message":"INFO: Server startup in 823 ms\r","type":"apache-error","tags":[]
}

Colete registros de fontes de dados

Para começar, vamos entender como configurar o MySQL para registro. Adicione as seguintes linhas emmy.ini file do servidor de banco de dados MySQL em [mysqld].

No Windows, está presente no diretório de instalação do MySQL, que está em -

C:\wamp\bin\mysql\mysql5.7.11

No UNIX, você pode encontrá-lo em - /etc/mysql/my.cnf

general_log_file   = "C:/wamp/logs/queries.log"
general_log = 1

logstash.conf

Neste arquivo de configuração, o plugin de arquivo é usado para ler o log do MySQL e gravá-lo no ouput.log.

input {
   file {
      path => "C:/wamp/logs/queries.log"
   }
}
output {
   file {
      path => "C:/tpwork/logstash/bin/log/output.log"
   }
}

queries.log

Este é o log gerado pelas consultas executadas no banco de dados MySQL.

2016-12-25T13:05:36.854619Z   2 Query		select * from test1_users
2016-12-25T13:05:51.822475Z    2 Query	select count(*) from users
2016-12-25T13:05:59.998942Z    2 Query         select count(*) from test1_users

output.log

{
   "path":"C:/wamp/logs/queries.log","@timestamp":"2016-12-25T13:05:37.905Z",
   "@version":"1","host":"Dell-PC",
   "message":"2016-12-25T13:05:36.854619Z    2 Query\tselect * from test1_users",
   "tags":[]
}
{
   "path":"C:/wamp/logs/queries.log","@timestamp":"2016-12-25T13:05:51.938Z",
   "@version":"1","host":"Dell-PC",
   "message":"2016-12-25T13:05:51.822475Z    2 Query\tselect count(*) from users",
   "tags":[]
}
{
   "path":"C:/wamp/logs/queries.log","@timestamp":"2016-12-25T13:06:00.950Z",
   "@version":"1","host":"Dell-PC",
   "message":"2016-12-25T13:05:59.998942Z    2 Query\tselect count(*) from test1_users",
   "tags":[]
}

O Logstash recebe os logs usando plug-ins de entrada e, em seguida, usa os plug-ins de filtro para analisar e transformar os dados. A análise e transformação dos logs são realizadas de acordo com os sistemas presentes no destino de saída. O Logstash analisa os dados de registro e encaminha apenas os campos obrigatórios. Posteriormente, esses campos são transformados na forma compatível e compreensível do sistema de destino.

Como analisar os logs?

A análise dos registros é realizada usando o GROK (Representação gráfica do conhecimento) padrões e você pode encontrá-los no Github -

https://github.com/elastic/logstash/tree/v1.4.2/patterns.

Logstash corresponde aos dados de logs com um padrão GROK especificado ou uma sequência de padrão para analisar os logs como "% {COMBINEDAPACHELOG}", que é comumente usado para logs do apache.

Os dados analisados ​​são mais estruturados e fáceis de pesquisar e realizar consultas. O Logstash procura os padrões GROK especificados nos logs de entrada e extrai as linhas correspondentes dos logs. Você pode usar o depurador GROK para testar seus padrões GROK.

A sintaxe para um padrão GROK é% {SYNTAX: SEMANTIC}. O filtro Logstash GROK é escrito da seguinte forma -

%{PATTERN:FieldName}

Aqui, PATTERN representa o padrão GROK e fieldname é o nome do campo, que representa os dados analisados ​​na saída.

Por exemplo, usando o depurador GROK online https://grokdebug.herokuapp.com/

Entrada

Um exemplo de linha de erro em um log -

[Wed Dec 07 21:54:54.048805 2016] [:error] [pid 1234:tid 3456829102]
   [client 192.168.1.1:25007] JSP Notice:  Undefined index: abc in
   /home/manu/tpworks/tutorialspoint.com/index.jsp on line 11

Sequência de padrão GROK

Essa sequência de padrão GROK corresponde ao evento de log, que consiste em um carimbo de data / hora seguido por Nível de log, Id de processo, Id de transação e uma mensagem de erro.

\[(%{DAY:day} %{MONTH:month} %{MONTHDAY} %{TIME} %{YEAR})\] \[.*:%{LOGLEVEL:loglevel}\]
   \[pid %{NUMBER:pid}:tid %{NUMBER:tid}\] \[client %{IP:clientip}:.*\]
   %{GREEDYDATA:errormsg}

resultado

A saída está no formato JSON.

{
   "day": [
      "Wed"
   ],
   "month": [
      "Dec"
   ],
   "loglevel": [
      "error"
   ],
   "pid": [
      "1234"
   ],
   "tid": [
      "3456829102"
   ],
   "clientip": [
      "192.168.1.1"
   ],
   "errormsg": [
      "JSP Notice:  Undefined index: abc in
      /home/manu/tpworks/tutorialspoint.com/index.jsp on line 11"
   ]
}

O Logstash usa filtros no meio do pipeline entre a entrada e a saída. Os filtros das medidas Logstash manipulam e criam eventos comoApache-Access. Muitos plug-ins de filtro usados ​​para gerenciar os eventos no Logstash. Aqui, em um exemplo doLogstash Aggregate Filter, estamos filtrando a duração de cada transação SQL em um banco de dados e calculando o tempo total.

Instalando o Plug-in de Filtro Agregado

Instalando o Aggregate Filter Plugin usando o utilitário Logstash-plugin. O plug-in Logstash é um arquivo em lote para janelas embin folder no Logstash.

>logstash-plugin install logstash-filter-aggregate

logstash.conf

Nesta configuração, você pode ver três instruções 'if' para Initializing, Incrementing, e generating a duração total da transação, ou seja, o sql_duration. O plugin agregado é usado para adicionar o sql_duration, presente em todos os eventos do log de entrada.

input {
   file {
      path => "C:/tpwork/logstash/bin/log/input.log"
   }
} 
filter {
   grok {
      match => [
         "message", "%{LOGLEVEL:loglevel} - 
            %{NOTSPACE:taskid} - %{NOTSPACE:logger} - 
            %{WORD:label}( - %{INT:duration:int})?" 
      ]
   }
   if [logger] == "TRANSACTION_START" {
      aggregate {
         task_id => "%{taskid}"
         code => "map['sql_duration'] = 0"
         map_action => "create"
      }
   }
   if [logger] == "SQL" {
      aggregate {
         task_id => "%{taskid}"
         code => "map['sql_duration'] ||= 0 ;
            map['sql_duration'] += event.get('duration')"
      }
   }
   if [logger] == "TRANSACTION_END" {
      aggregate {
         task_id => "%{taskid}"
         code => "event.set('sql_duration', map['sql_duration'])"
         end_of_task => true
         timeout => 120
      }
   }
}
output {
   file {
      path => "C:/tpwork/logstash/bin/log/output.log"    
   }
}

Executar Logstash

Podemos executar o Logstash usando o seguinte comando.

>logstash –f logstash.conf

input.log

O bloco de código a seguir mostra os dados de registro de entrada.

INFO - 48566 - TRANSACTION_START - start
INFO - 48566 - SQL - transaction1 - 320
INFO - 48566 - SQL - transaction1 - 200
INFO - 48566 - TRANSACTION_END - end

output.log

Conforme especificado no arquivo de configuração, a última instrução 'if' onde o logger está - TRANSACTION_END, que imprime o tempo total da transação ou sql_duration. Isso foi destacado em amarelo no output.log.

{
   "path":"C:/tpwork/logstash/bin/log/input.log","@timestamp": "2016-12-22T19:04:37.214Z",
   "loglevel":"INFO","logger":"TRANSACTION_START","@version": "1","host":"wcnlab-PC",
   "message":"8566 - TRANSACTION_START - start\r","tags":[]
}
{
   "duration":320,"path":"C:/tpwork/logstash/bin/log/input.log",
   "@timestamp":"2016-12-22T19:04:38.366Z","loglevel":"INFO","logger":"SQL",
   "@version":"1","host":"wcnlab-PC","label":"transaction1",
   "message":" INFO - 48566 - SQL - transaction1 - 320\r","taskid":"48566","tags":[]
}
{
   "duration":200,"path":"C:/tpwork/logstash/bin/log/input.log",
   "@timestamp":"2016-12-22T19:04:38.373Z","loglevel":"INFO","logger":"SQL",
   "@version":"1","host":"wcnlab-PC","label":"transaction1",
   "message":" INFO - 48566 - SQL - transaction1 - 200\r","taskid":"48566","tags":[]
}
{
   "sql_duration":520,"path":"C:/tpwork/logstash/bin/log/input.log",
   "@timestamp":"2016-12-22T19:04:38.380Z","loglevel":"INFO","logger":"TRANSACTION_END",
   "@version":"1","host":"wcnlab-PC","label":"end",
   "message":" INFO - 48566 - TRANSACTION_END - end\r","taskid":"48566","tags":[]
}

O Logstash oferece vários plug-ins para transformar o log analisado. Esses plug-ins podemAdd, Delete, e Update campos nos logs para melhor compreensão e consulta nos sistemas de saída.

Estamos usando o Mutate Plugin para adicionar um usuário de nome de campo em cada linha do registro de entrada.

Instale o Plug-in de Filtro Mutate

Para instalar o plugin de filtro mutate; podemos usar o seguinte comando.

>Logstash-plugin install Logstash-filter-mutate

logstash.conf

Neste arquivo de configuração, o Plug-in Mutate é adicionado após o Plug-in Aggregate para adicionar um novo campo.

input {
   file {
      path => "C:/tpwork/logstash/bin/log/input.log"
   }
} 
filter {
   grok {
      match => [ "message", "%{LOGLEVEL:loglevel} -
         %{NOTSPACE:taskid} - %{NOTSPACE:logger} -
         %{WORD:label}( - %{INT:duration:int})?" ]
   }
   if [logger] == "TRANSACTION_START" {
      aggregate {
         task_id => "%{taskid}"
         code => "map['sql_duration'] = 0"
         map_action => "create"
      }
   }
   if [logger] == "SQL" {
      aggregate {
         task_id => "%{taskid}"
         code => "map['sql_duration'] ||= 0 ; 
            map['sql_duration'] += event.get('duration')"
      }
   }
   if [logger] == "TRANSACTION_END" {
      aggregate {
         task_id => "%{taskid}"
         code => "event.set('sql_duration', map['sql_duration'])"
         end_of_task => true
         timeout => 120
      }
   }
   mutate {
      add_field => {"user" => "tutorialspoint.com"}
   }
}
output {
   file {
      path => "C:/tpwork/logstash/bin/log/output.log"
   }
}

Executar Logstash

Podemos executar o Logstash usando o seguinte comando.

>logstash –f logstash.conf

input.log

O bloco de código a seguir mostra os dados de registro de entrada.

INFO - 48566 - TRANSACTION_START - start
INFO - 48566 - SQL - transaction1 - 320
INFO - 48566 - SQL - transaction1 - 200
INFO - 48566 - TRANSACTION_END - end

output.log

Você pode ver que há um novo campo denominado “usuário” nos eventos de saída.

{
   "path":"C:/tpwork/logstash/bin/log/input.log",
   "@timestamp":"2016-12-25T19:55:37.383Z",
   "@version":"1",
   "host":"wcnlab-PC",
   "message":"NFO - 48566 - TRANSACTION_START - start\r",
   "user":"tutorialspoint.com","tags":["_grokparsefailure"]
}
{
   "duration":320,"path":"C:/tpwork/logstash/bin/log/input.log",
   "@timestamp":"2016-12-25T19:55:37.383Z","loglevel":"INFO","logger":"SQL",
   "@version":"1","host":"wcnlab-PC","label":"transaction1",
   "message":" INFO - 48566 - SQL - transaction1 - 320\r",
   "user":"tutorialspoint.com","taskid":"48566","tags":[]
}
{
   "duration":200,"path":"C:/tpwork/logstash/bin/log/input.log",
   "@timestamp":"2016-12-25T19:55:37.399Z","loglevel":"INFO",
   "logger":"SQL","@version":"1","host":"wcnlab-PC","label":"transaction1",
   "message":" INFO - 48566 - SQL - transaction1 - 200\r",
   "user":"tutorialspoint.com","taskid":"48566","tags":[]
}
{
   "sql_duration":520,"path":"C:/tpwork/logstash/bin/log/input.log",
   "@timestamp":"2016-12-25T19:55:37.399Z","loglevel":"INFO",
   "logger":"TRANSACTION_END","@version":"1","host":"wcnlab-PC","label":"end",
   "message":" INFO - 48566 - TRANSACTION_END - end\r",
   "user":"tutorialspoint.com","taskid":"48566","tags":[]
}

A saída é o último estágio no pipeline do Logstash, que envia os dados do filtro dos logs de entrada para um destino especificado. O Logstash oferece vários plug-ins de saída para armazenar os eventos de log filtrados em vários mecanismos de armazenamento e pesquisa diferentes.

Armazenamento de registros

O Logstash pode armazenar os logs filtrados em um File, Elasticsearch Engine, stdout, AWS CloudWatch, etc. Protocolos de rede como TCP, UDP, Websocket também pode ser usado no Logstash para transferir os eventos de log para sistemas de armazenamento remoto.

Na pilha ELK, os usuários usam o mecanismo Elasticsearch para armazenar os eventos de log. Aqui, no exemplo a seguir, geraremos eventos de log para um mecanismo Elasticsearch local.

Instalando o plug-in de saída Elasticsearch

Podemos instalar o plugin de saída Elasticsearch com o seguinte comando.

>logstash-plugin install Logstash-output-elasticsearch

logstash.conf

Este arquivo de configuração contém um plug-in Elasticsearch, que armazena o evento de saída no Elasticsearch instalado localmente.

input {
   file {
      path => "C:/tpwork/logstash/bin/log/input.log"
   }
} 
filter {
   grok {
      match => [ "message", "%{LOGLEVEL:loglevel} -
      %{NOTSPACE:taskid} - %{NOTSPACE:logger} -  
      %{WORD:label}( - %{INT:duration:int})?" ]
   }
   if [logger] == "TRANSACTION_START" {
      aggregate {
         task_id => "%{taskid}"
         code => "map['sql_duration'] = 0"
         map_action => "create"
      }
   }
   if [logger] == "SQL" {
      aggregate {
         task_id => "%{taskid}"
         code => "map['sql_duration'] ||= 0 ;
            map['sql_duration'] += event.get('duration')"
      }
   }
   if [logger] == "TRANSACTION_END" {
      aggregate {
         task_id => "%{taskid}"
         code => "event.set('sql_duration', map['sql_duration'])"
         end_of_task => true
         timeout => 120
      }
   }
   mutate {
      add_field => {"user" => "tutorialspoint.com"}
   }
}
output {
   elasticsearch {
      hosts => ["127.0.0.1:9200"]
   }
}

Input.log

O bloco de código a seguir mostra os dados de registro de entrada.

INFO - 48566 - TRANSACTION_START - start
INFO - 48566 - SQL - transaction1 - 320
INFO - 48566 - SQL - transaction1 - 200
INFO - 48566 - TRANSACTION_END - end

Inicie Elasticsearch em Localhost

Para iniciar o Elasticsearch no localhost, você deve usar o seguinte comando.

C:\elasticsearch\bin> elasticsearch

Assim que o Elasticsearch estiver pronto, você pode verificá-lo digitando a seguinte URL no seu navegador.

http://localhost:9200/

Resposta

O bloco de código a seguir mostra a resposta de Elasticsearch em localhost.

{
   "name" : "Doctor Dorcas",
   "cluster_name" : "elasticsearch",
   "version" : {
      "number" : "2.1.1",
      "build_hash" : "40e2c53a6b6c2972b3d13846e450e66f4375bd71",
      "build_timestamp" : "2015-12-15T13:05:55Z",
      "build_snapshot" : false,
      "lucene_version" : "5.3.1"
   },
   "tagline" : "You Know, for Search"
}

Note - Para obter mais informações sobre Elasticsearch, você pode clicar no link a seguir.

https://www.tutorialspoint.com/elasticsearch/index.html

Agora, execute o Logstash com o Logstash.conf mencionado acima

>Logstash –f Logstash.conf

Depois de colar o texto mencionado acima no log de saída, esse texto será armazenado no Elasticsearch por Logstash. Você pode verificar os dados armazenados digitando a seguinte URL no navegador.

http://localhost:9200/logstash-2017.01.01/_search?pretty

Resposta

São os dados no formato JSON armazenados no índice Logstash-2017.01.01.

{
   "took" : 20,
   "timed_out" : false,
   "_shards" : {
      "total" : 5,
      "successful" : 5,
      "failed" : 0
   },
   "hits" : {
      "total" : 10,
      "max_score" : 1.0,
      "hits" : [ {
         "_index" : "logstash-2017.01.01",
         "_type" : "logs",
         "_id" : "AVlZ9vF8hshdrGm02KOs",
         "_score" : 1.0,
         "_source":{
            "duration":200,"path":"C:/tpwork/logstash/bin/log/input.log", 
            "@timestamp":"2017-01-01T12:17:49.140Z","loglevel":"INFO",
            "logger":"SQL","@version":"1","host":"wcnlab-PC",
            "label":"transaction1",
            "message":" INFO - 48566 - SQL - transaction1 - 200\r",
            "user":"tutorialspoint.com","taskid":"48566","tags":[]
         }
      },
      {
         "_index" : "logstash-2017.01.01",
         "_type" : "logs",
         "_id" : "AVlZ9vF8hshdrGm02KOt",
         "_score" : 1.0,
         "_source":{
            "sql_duration":520,"path":"C:/tpwork/logstash/bin/log/input.log",
            "@timestamp":"2017-01-01T12:17:49.145Z","loglevel":"INFO",
            "logger":"TRANSACTION_END","@version":"1","host":"wcnlab-PC",
            "label":"end",
            "message":" INFO - 48566 - TRANSACTION_END - end\r",
            "user":"tutorialspoint.com","taskid":"48566","tags":[]
         }
      }
   }
}

O Logstash fornece vários plug-ins para oferecer suporte a vários armazenamentos de dados ou mecanismos de pesquisa. Os eventos de saída dos logs podem ser enviados para um arquivo de saída, saída padrão ou um mecanismo de busca como o Elasticsearch. Existem três tipos de saídas com suporte no Logstash, que são -

• Saída Padrão
• Saída de arquivo
• Saída Nula

Vamos agora discutir cada um deles em detalhes.

Saída padrão (stdout)

Ele é usado para gerar os eventos de log filtrados como um fluxo de dados para a interface da linha de comandos. Aqui está um exemplo de como gerar a duração total de uma transação de banco de dados para stdout.

logstash.conf

Este arquivo de configuração contém um plugin de saída stdout para gravar o sql_duration total em uma saída padrão.

input {
   file {
      path => "C:/tpwork/logstash/bin/log/input.log"
   }
} 
filter {
   grok {
      match => [
         "message", "%{LOGLEVEL:loglevel} - %{NOTSPACE:taskid}
            - %{NOTSPACE:logger} - %{WORD:label}( - %{INT:duration:int})?" 
      ]
   }
   if [logger] == "TRANSACTION_START" {
      aggregate {
         task_id => "%{taskid}"
         code => "map['sql_duration'] = 0"
         map_action => "create"
      }
   }
   if [logger] == "SQL" {
      aggregate {
         task_id => "%{taskid}"
         code => "map['sql_duration'] ||= 0 ;
            map['sql_duration'] += event.get('duration')"
      }
   }
   if [logger] == "TRANSACTION_END" {
      aggregate {
         task_id => "%{taskid}"
         code => "event.set('sql_duration', map['sql_duration'])"
         end_of_task => true
         timeout => 120
      }
   }
}
output {
   if [logger] == "TRANSACTION_END" {
      stdout {
         codec => line{format => "%{sql_duration}"}
      }
   }
}

Note - Instale o filtro agregado, se ainda não estiver instalado.

>logstash-plugin install Logstash-filter-aggregate

Executar Logstash

Podemos executar o Logstash usando o seguinte comando.

>logstash –f logsatsh.conf

Input.log

O bloco de código a seguir mostra os dados de registro de entrada.

INFO - 48566 - TRANSACTION_START - start
INFO - 48566 - SQL - transaction1 - 320
INFO - 48566 - SQL - transaction1 - 200
INFO - 48566 - TRANSACTION_END – end

stdout (será prompt de comando no Windows ou terminal no UNIX)

Este é o sql_duration total 320 + 200 = 520.

520

Saída de arquivo

O Logstash também pode armazenar os eventos de log do filtro em um arquivo de saída. Usaremos o exemplo mencionado acima e armazenaremos a saída em um arquivo em vez de STDOUT.

logstash.conf

Este arquivo de configuração do Logstash direciona o Logstash a armazenar o sql_duration total em um arquivo de log de saída.

input {
   file {
      path => "C:/tpwork/logstash/bin/log/input1.log"
   }
} 
filter {
   grok {
      match => [
         "message", "%{LOGLEVEL:loglevel} - %{NOTSPACE:taskid} -
            %{NOTSPACE:logger} - %{WORD:label}( - %{INT:duration:int})?" 
      ]
   }
   if [logger] == "TRANSACTION_START" {
      aggregate {
         task_id => "%{taskid}"
         code => "map['sql_duration'] = 0"
         map_action => "create"
      }
   }
   if [logger] == "SQL" {
      aggregate {
         task_id => "%{taskid}"
         code => "map['sql_duration'] ||= 0 ;
            map['sql_duration'] += event.get('duration')"
      }
   }
   if [logger] == "TRANSACTION_END" {
      aggregate {
         task_id => "%{taskid}"
         code => "event.set('sql_duration', map['sql_duration'])"
         end_of_task => true
         timeout => 120
      }
   }
}
output {
   if [logger] == "TRANSACTION_END" {
      file {
         path => "C:/tpwork/logstash/bin/log/output.log"
         codec => line{format => "%{sql_duration}"}
      }
   }
}

Executar logstash

Podemos executar o Logstash usando o seguinte comando.

>logstash –f logsatsh.conf

input.log

O bloco de código a seguir mostra os dados de registro de entrada.

INFO - 48566 - TRANSACTION_START - start
INFO - 48566 - SQL - transaction1 - 320
INFO - 48566 - SQL - transaction1 - 200
INFO - 48566 - TRANSACTION_END – end

output.log

O bloco de código a seguir mostra os dados do log de saída.

520

Saída Nula

Este é um plugin de saída especial, que é usado para analisar o desempenho de plugins de entrada e filtro.

O Logstash oferece vários plug-ins para todos os três estágios de seu pipeline (entrada, filtro e saída). Esses plug-ins ajudam o usuário a capturar logs de várias fontes, como servidores da Web, bancos de dados, protocolos de rede, etc.

Após a captura, o Logstash pode analisar e transformar os dados em informações significativas, conforme exigido pelo usuário. Por último, o Logstash pode enviar ou armazenar essas informações significativas para várias fontes de destino, como Elasticsearch, AWS Cloudwatch, etc.

Plugins de entrada

Os plug-ins de entrada no Logstash ajudam o usuário a extrair e receber logs de várias fontes. A sintaxe para usar o plugin de entrada é a seguinte -

Input {
   Plugin name {
      Setting 1……
      Setting 2……..
   }
}

Você pode baixar o plugin de entrada usando o seguinte comando -

>Logstash-plugin install Logstash-input-<plugin name>

O utilitário Logstash-plugin está presente no bin folderdo diretório de instalação do Logstash. A tabela a seguir contém uma lista dos plug-ins de entrada oferecidos pelo Logstash.

Sr. Não.	Nome e descrição do plugin
1	beats Para obter os dados de registro ou eventos da estrutura de batidas elásticas.
2	cloudwatch Para extrair eventos do CloudWatch, uma oferta de API da Amazon Web Services.
3	couchdb_changes Eventos do URI _chages do couchdb enviados usando este plugin.
4	drupal_dblog Para extrair os dados de registro do watchdog do drupal com DBLog habilitado.
5	Elasticsearch Para recuperar os resultados das consultas realizadas no cluster Elasticsearch.
6	eventlog Para obter os eventos do log de eventos do Windows.
7	exec Para obter a saída do comando shell como uma entrada no Logstash.
8	file Para obter os eventos de um arquivo de entrada. Isso é útil quando o Logstash é instalado localmente com a fonte de entrada e tem acesso aos logs da fonte de entrada.
9	generator É usado para fins de teste, o que cria eventos aleatórios.
10	github Captura eventos do webhook do GitHub.
11	graphite Para obter dados de métricas da ferramenta de monitoramento de grafite.
12	heartbeat Também é usado para teste e produz eventos semelhantes a batimentos cardíacos
13	http Para coletar eventos de log em dois protocolos de rede, http e https.
14	http_poller É usado para decodificar a saída da API HTTP para um evento.
15	jdbc Ele converte as transações JDBC em um evento no Logstash.
16	jmx Para extrair as métricas de aplicativos Java remotos usando JMX.
17	log4j Capture eventos do objeto socketAppender de Log4j sobre o soquete TCP.
18	rss Para a saída de ferramentas de linha de comando como um evento de entrada no Logstash.
19	tcp Captura eventos no soquete TCP.
20	twitter Colete eventos da API de streaming do Twitter.
21	unix Colete eventos no soquete UNIX.
22	websocket Capture eventos sobre protocolo de websocket.
23	xmpp Lê eventos sobre protocolos Jabber / xmpp.

Configurações de plug-in

Todos os plug-ins têm suas configurações específicas, o que ajuda a especificar os campos importantes como Porta, Caminho, etc., em um plug-in. Discutiremos as configurações de alguns dos plug-ins de entrada.

Arquivo

Este plugin de entrada é usado para extrair eventos diretamente de arquivos de log ou de texto presentes na fonte de entrada. Ele funciona de forma semelhante ao comando tail no UNIX e salva o último cursor lido e lê apenas os novos dados acrescentados do arquivo de entrada, mas pode ser alterado usando a configuração star_position. A seguir estão as configurações deste plugin de entrada.

Nome da configuração	Valor padrão	Descrição
adicionar campo	{}	Acrescente um novo campo ao evento de entrada.
close_older	3600	Os arquivos com tempo de última leitura (em segundos) maior que o especificado neste plugin são fechados.
codec	"avião"	Ele é usado para decodificar os dados antes de entrar no pipeline do Logstash.
delimitador	“\ N”	É usado para especificar um novo delimitador de linha.
descobrir_intervalo	15	É o intervalo de tempo (em segundos) entre a descoberta de novos arquivos no caminho especificado.
enable_metric	verdadeiro	É usado para habilitar ou desabilitar o relatório e a coleta de métricas para o plugin especificado.
excluir		É usado para especificar o nome do arquivo ou padrões, que devem ser excluídos do plugin de entrada.
Eu iria		Para especificar uma identidade única para essa instância do plugin.
max_open_files		Ele especifica o número máximo de arquivos de entrada por Logstash a qualquer momento.
caminho		Especifique o caminho dos arquivos e ele pode conter os padrões de nome de arquivo.
posição inicial	"fim"	Você pode mudar para “início”, se quiser; inicialmente, o Logstash deve começar a ler os arquivos desde o início e não apenas o novo evento de log.
start_interval	1	Ele especifica o intervalo de tempo em segundos, após o qual o Logstash verifica os arquivos modificados.
Tag		Para adicionar qualquer informação adicional, como Logstash, ele adiciona "_grokparsefailure" em tags, quando qualquer evento de log falha em cumprir com o filtro grok especificado.
tipo		Este é um campo especial, que você pode adicionar a um evento de entrada e é útil em filtros e kibana.

Elasticsearch

Este plug-in específico é usado para ler os resultados das consultas de pesquisa em um cluster Elasticsearch. A seguir estão as configurações usadas neste plugin -

Nome da configuração	Valor padrão	Descrição
adicionar campo	{}	Da mesma forma que no plugin de arquivo, é usado para anexar um campo no evento de entrada.
ca_file		É usado para especificar o caminho do arquivo de autoridade de certificação SSL.
codec	"avião"	É usado para decodificar os eventos de entrada do Elasticsearch antes de entrar no pipeline do Logstash.
docinfo	"falso"	Você pode alterá-lo para verdadeiro, se desejar extrair as informações adicionais como índice, tipo e id do mecanismo Elasticsearch.
docinfo_fields	["_index", "_type", "_id"]	Você pode eliminar qualquer campo que não queira na entrada do Logstash.
enable_metric	verdadeiro	É usado para habilitar ou desabilitar o relatório e coleta de métricas para essa instância do plugin.
hospedeiros		É usado para especificar os endereços de todos os mecanismos do elasticsearch, que serão a fonte de entrada dessa instância do Logstash. A sintaxe é host: porta ou IP: porta.
Eu iria		É usado para fornecer um número de identidade exclusivo para essa instância de plugin de entrada específica.
índice	"logstash- *"	É usado para especificar o nome do índice ou um padrão, que Logstash monitorará por Logstash para entrada.
senha		Para fins de autenticação.
inquerir	"{\" classificar \ ": [\" _ doc \ "]}"	Consulta para a execução.
ssl	falso	Ative ou desative a camada de soquete seguro.
Tag		Para adicionar qualquer informação adicional em eventos de entrada.
tipo		É usado para classificar os formulários de entrada de forma que seja fácil pesquisar todos os eventos de entrada em estágios posteriores.
do utilizador		Para fins autênticos.

log de eventos

Este plugin de entrada lê dados da API win32 de servidores Windows. A seguir estão as configurações deste plugin -

Nome da configuração	Valor padrão	Descrição
adicionar campo	{}	Da mesma forma que no plugin de arquivo, ele é usado para anexar um campo no evento de entrada
codec	"avião"	Ele é usado para decodificar os eventos de entrada das janelas; antes de entrar no pipeline Logstash
arquivo de log	["Aplicativo", "Segurança", "Sistema"]	Eventos necessários no arquivo de registro de entrada
intervalo	1000	É em milissegundos e define o intervalo entre duas verificações consecutivas de novos registros de eventos
Tag		Para adicionar qualquer informação adicional em eventos de entrada
tipo		É usado para classificar a entrada de um plug-in específico para um determinado tipo, de modo que seja fácil pesquisar todos os eventos de entrada em estágios posteriores

Twitter

Este plug-in de entrada é usado para coletar o feed do Twitter de sua API de streaming. A tabela a seguir descreve as configurações deste plugin.

Nome da configuração	Valor padrão	Descrição
adicionar campo	{}	Da mesma forma que no plugin de arquivo, ele é usado para anexar um campo no evento de entrada
codec	"avião"	Ele é usado para decodificar os eventos de entrada das janelas; antes de entrar no pipeline Logstash
Chave do consumidor		Ele contém a chave do consumidor do aplicativo do Twitter. Para mais informações, visitehttps://dev.twitter.com/apps/new
consumidor secreto		Ele contém a chave secreta do consumidor do aplicativo do Twitter. Para mais informações, visitehttps://dev.twitter.com/apps/new
enable_metric	verdadeiro	É usado para habilitar ou desabilitar o relatório e coleta de métricas para essa instância do plugin
segue		Ele especifica os IDs de usuário separados por vírgulas e o LogStash verifica o status desses usuários no Twitter. Para mais informações, visite https://dev.twitter.com
full_tweet	falso	Você pode alterá-lo para verdadeiro, se quiser que o Logstash leia o retorno completo do objeto da API do Twitter
Eu iria		É usado para dar um número de identidade único a essa instância específica do plugin de entrada
ignore_retweets	Falso	Você pode alterar defini-lo como verdadeiro para ignorar os retuítes no feed do Twitter de entrada
palavras-chave		É uma série de palavras-chave, que precisam ser rastreadas no feed de entrada dos twitters
língua		Ele define o idioma dos tweets necessários para LogStash a partir do feed de entrada do Twitter. Este é um array de identificador, que define um idioma específico no twitter
Localizações		Para filtrar os tweets do feed de entrada de acordo com o local especificado. Esta é uma matriz que contém a longitude e a latitude do local
oauth_token		É um campo obrigatório, que contém o token oauth do usuário. Para obter mais informações, visite o seguinte linkhttps://dev.twitter.com/apps
oauth_token_secret		É um campo obrigatório, que contém o token secreto do usuário oauth. Para obter mais informações, visite o seguinte linkhttps://dev.twitter.com/apps
Tag		Para adicionar qualquer informação adicional em eventos de entrada
tipo		É usado para classificar a entrada de um plug-in específico para um determinado tipo, de modo que seja fácil pesquisar todos os eventos de entrada em estágios posteriores

TCP

O TCP é usado para obter os eventos no soquete TCP; ele pode ler a partir das conexões do usuário ou do servidor, que é especificado na configuração de modo. A tabela a seguir descreve as configurações deste plugin -

Nome da configuração	Valor padrão	Descrição
adicionar campo	{}	Da mesma forma que no plugin de arquivo, ele é usado para anexar um campo no evento de entrada
codec	"avião"	Ele é usado para decodificar os eventos de entrada das janelas; antes de entrar no pipeline Logstash
enable_metric	verdadeiro	É usado para habilitar ou desabilitar o relatório e coleta de métricas para essa instância do plugin
hospedeiro	“0.0.0.0”	O endereço do sistema operacional do servidor do qual o cliente depende
Eu iria		Ele contém a chave do consumidor do aplicativo do Twitter
modo	"servidor"	É usado para especificar se a fonte de entrada é o servidor ou cliente.
porta		Define o número da porta
ssl_cert		É usado para especificar o caminho do certificado SSL
ssl_enable	falso	Ativar ou desativar SSL
ssl_key		Para especificar o caminho do arquivo de chave SSL
Tag		Para adicionar qualquer informação adicional em eventos de entrada
tipo		É usado para classificar a entrada de um plug-in específico para um determinado tipo, de modo que seja fácil pesquisar todos os eventos de entrada em estágios posteriores

Logstash - Plug-ins de saída

Logstash oferece suporte a várias fontes de saída e em diferentes tecnologias, como banco de dados, arquivo, e-mail, saída padrão, etc.

A sintaxe para usar o plugin de saída é a seguinte -

output {
   Plugin name {
      Setting 1……
      Setting 2……..
   }
}

Você pode baixar o plugin de saída usando o seguinte comando -

>logstash-plugin install logstash-output-<plugin name>

o Logstash-plugin utilityestá presente na pasta bin do diretório de instalação do Logstash. A tabela a seguir descreve os plug-ins de saída oferecidos pelo Logstash.

Sr. Não.	Nome e descrição do plugin
1	CloudWatch Este plugin é usado para enviar dados métricos agregados para CloudWatch de serviços web amazon.
2	csv É usado para gravar os eventos de saída separados por vírgula.
3	Elasticsearch É usado para armazenar os logs de saída no índice Elasticsearch.
4	email É usado para enviar um email de notificação, quando a saída é gerada. O usuário pode adicionar informações sobre a saída no e-mail.
5	exec É usado para executar um comando, que corresponde ao evento de saída.
6	ganglia Isso distorce as métricas para gmond of Gangila.
7	gelf É usado para produzir saída para Graylog2 no formato GELF.
8	google_bigquery Ele gera os eventos para o Google BigQuery.
9	google_cloud_storage Ele armazena os eventos de saída no Google Cloud Storage.
10	graphite É usado para armazenar os eventos de saída no Graphite.
11	graphtastic É usado para escrever as métricas de saída no Windows.
12	hipchat É usado para armazenar os eventos de registro de saída no HipChat.
13	http É usado para enviar os eventos de log de saída para terminais http ou https.
14	influxdb É usado para armazenar o evento de saída no InfluxDB.
15	irc É usado para escrever os eventos de saída no irc.
16	mongodb Ele armazena os dados de saída no MongoDB.
17	nagios É usado para notificar o Nagios com os resultados da verificação passiva.
18	nagios_nsca É usado para notificar o Nagios com os resultados da verificação passiva no protocolo NSCA.
19	opentsdb Ele armazena os eventos de saída do Logstash no OpenTSDB.
20	pipe Ele transmite os eventos de saída para a entrada padrão de outro programa.
21	rackspace É usado para enviar os eventos de log de saída para o serviço de fila da Rackspace Cloud.
22	redis Ele usa o comando rpush para enviar os dados de registro de saída para a fila do Redis.
23	riak É usado para armazenar os eventos de saída no par chave / valor distribuído Riak.
24	s3 Ele armazena os dados de registro de saída no Amazon Simple Storage Service.
25	sns É usado para enviar os eventos de saída para o Serviço de Notificação Simples da Amazon.
26	solr_http Ele indexa e armazena os dados de registro de saída no Solr.
27	sps Ele é usado para enviar os eventos ao Simple Queue Service da AWS.
28	statsd Ele é usado para enviar os dados de métricas para o daemon de rede statsd.
29	stdout É usado para mostrar os eventos de saída na saída padrão do prompt de comando do tipo CLI.
30	syslog Ele é usado para enviar os eventos de saída para o servidor syslog.
31	tcp É usado para enviar os eventos de saída para o soquete TCP.
32	udp Ele é usado para enviar os eventos de saída por UDP.
33	websocket Ele é usado para enviar os eventos de saída pelo protocolo WebSocket.
34	xmpp Ele é usado para enviar os eventos de saída pelo protocolo XMPP.

Todos os plug-ins têm suas configurações específicas, o que ajuda a especificar os campos importantes como Porta, Caminho, etc., em um plug-in. Discutiremos as configurações de alguns dos plug-ins de saída.

Elasticsearch

O plug-in de saída do Elasticsearch permite que o Logstash armazene a saída nos clusters específicos do mecanismo Elasticsearch. Esta é uma das escolhas mais famosas dos usuários porque vem no pacote do ELK Stack e, portanto, fornece soluções ponta a ponta para Devops. A tabela a seguir descreve as configurações deste plugin de saída.

Nome da configuração	Valor padrão	Descrição
açao	índice	É usado para definir a ação executada no mecanismo Elasticsearch. Outros valores para essas configurações são excluir, criar, atualizar, etc.
cacert		Ele contém o caminho do arquivo com .cer ou .pem para validação do certificado do servidor.
codec	"avião"	É usado para codificar os dados de registro de saída antes de enviá-los à fonte de destino.
doc_as_upset	falso	Esta configuração é usada em caso de ação de atualização. Ele cria um documento no mecanismo Elasticsearch, se o id do documento não for especificado no plugin de saída.
tipo de documento		É usado para armazenar o mesmo tipo de eventos no mesmo tipo de documento. Se não for especificado, o tipo de evento será usado para o mesmo.
flush_size	500	Isso é usado para melhorar o desempenho do upload em massa no Elasticsearch
hospedeiros	[“127.0.0.1”]	É uma matriz de endereços de destino para dados de registro de saída
idle_flush_time	1	Ele define o limite de tempo (segundo) entre as duas descargas, Logstash força a descarga após o limite de tempo especificado nesta configuração
índice	"logstash -% {+ AAAA.MM.dd}"	É usado para especificar o índice do motor Elasticsearch
manage_temlpate	verdadeiro	É usado para aplicar o modelo padrão no Elasticsearch
pai	nada	É usado para especificar o id do documento pai no Elasticsearch
senha		É usado para autenticar a solicitação em um cluster seguro no Elasticsearch
caminho		É usado para especificar o caminho HTTP do Elasticsearch.
pipeline	nada	É usado para definir o pipeline de ingestão, o usuário deseja executar para um evento
procuração		É usado para especificar o proxy HTTP
retry_initial_interval	2	É usado para definir o intervalo de tempo inicial (segundos) entre as tentativas em massa. Obtém o dobro após cada tentativa até chegar a retry_max_interval
retry_max_interval	64	É usado para definir o intervalo de tempo máximo para retry_initial_interval
retry_on_conflict	1	É o número de tentativas do Elasticsearch para atualizar um documento
ssl		Para ativar ou desativar SSL / TLS protegido para Elasticsearch
modelo		Ele contém o caminho do modelo personalizado no Elasticsearch
template_name	"logstash"	Isso é usado para nomear o modelo no Elasticsearch
tempo esgotado	60	É o tempo limite para solicitações de rede para Elasticsearch
upsert	“”	Ele atualiza o documento ou se o document_id não existe, ele cria um novo documento no Elasticsearch
do utilizador		Ele contém o usuário para autenticar a solicitação Logstash em um cluster Elasticsearch seguro

O email

O plugin de saída de email é usado para notificar o usuário, quando o Logstash gera saída. A tabela a seguir descreve as configurações para este plugin.

Nome da configuração	Valor padrão	Descrição
endereço	“Localhost”	É o endereço do servidor de e-mail
anexos	[]	Ele contém os nomes e locais dos arquivos anexados
corpo	“”	Ele contém o corpo do e-mail e deve ser um texto simples
cc		Ele contém os endereços de e-mail separados por vírgulas para o cc do e-mail
codec	"avião"	É usado para codificar os dados de registro de saída antes de enviá-los à fonte de destino.
tipo de conteúdo	"text / html; charset = UTF-8"	É usado para o tipo de conteúdo do e-mail
depurar	falso	É usado para executar a retransmissão de e-mail no modo de depuração
domínio	"localhost"	É usado para definir o domínio para enviar as mensagens de e-mail
de	"[email protected]"	É usado para especificar o endereço de e-mail do remetente
htmlbody	“”	É usado para especificar o corpo do e-mail em formato html
senha		É usado para autenticar com o servidor de e-mail
porta	25	É usado para definir a porta de comunicação com o servidor de e-mail
responder a		É usado para especificar o id do email para o campo de resposta do email
sujeito	“”	Ele contém a linha de assunto do e-mail
use_tls	falso	Habilite ou desabilite o TSL para a comunicação com o servidor de e-mail
nome do usuário		Contém o nome de usuário para autenticação com o servidor
através da	“Smtp”	Ele define os métodos de envio de e-mail por Logstash

Http

Essa configuração é usada para enviar os eventos de saída via http para o destino. Este plugin tem as seguintes configurações -

Nome da configuração	Valor padrão	Descrição
tentativas automáticas	1	É usado para definir o número de tentativas de solicitação de http por logstash
cacert		Ele contém o caminho do arquivo para a validação do certificado do servidor
codec	"avião"	É usado para codificar os dados de registro de saída antes de enviá-los à fonte de destino.
tipo de conteúdo		I especifica o tipo de conteúdo da solicitação http para o servidor de destino
biscoitos	verdadeiro	É usado para habilitar ou desabilitar cookies
formato	"json"	É usado para definir o formato do corpo da solicitação http
cabeçalhos		Ele contém as informações do cabeçalho http
http_method	“”	É usado para especificar o método http usado na solicitação por logstash e os valores podem ser "put", "post", "patch", "delete", "get", "head"
request_timeout	60	É usado para autenticar com o servidor de e-mail
url		É uma configuração necessária para este plugin especificar o ponto de extremidade http ou https

saída padrão

O plugin de saída stdout é usado para escrever os eventos de saída na saída padrão da interface de linha de comando. É o prompt de comando no Windows e o terminal no UNIX. Este plugin possui as seguintes configurações -

Nome da configuração	Valor padrão	Descrição
codec	"avião"	É usado para codificar os dados de registro de saída antes de enviá-los à fonte de destino.
operários	1	É usado para especificar o número de trabalhadores para a saída

statsd

É um daemon de rede usado para enviar os dados das matrizes sobre UDP para os serviços de backend de destino. É o prompt de comando no Windows e o terminal no UNIX. Este plugin tem as seguintes configurações -

Nome da configuração	Valor padrão	Descrição
codec	"avião"	É usado para codificar os dados de registro de saída antes de enviá-los à fonte de destino.
contagem	{}	É usado para definir a contagem a ser usada nas métricas
decremento	[]	É usado para especificar os nomes das métricas de decremento
hospedeiro	“Localhost”	Ele contém o endereço do servidor statsd
incremento	[]	É usado para especificar os nomes das métricas de incremento
porta	8125	Ele contém a porta do servidor statsd
taxa de amostragem	1	É usado para especificar a taxa de amostragem da métrica
remetente	"%{hospedeiro}"	Ele especifica o nome do remetente
conjunto	{}	É usado para especificar uma métrica definida
cronometragem	{}	É usado para especificar uma métrica de tempo
operários	1	É usado para especificar o número de trabalhadores para a saída

Plugins de filtro

Logstash oferece suporte a vários plug-ins de filtro para analisar e transformar logs de entrada em um formato mais estruturado e fácil de consultar.

A sintaxe para usar o plugin de filtro é a seguinte -

filter {
   Plugin name {
      Setting 1……
      Setting 2……..
   }
}

Você pode baixar o plugin de filtro usando o seguinte comando -

>logstash-plugin install logstash-filter-<plugin name>

O utilitário Logstash-plugin está presente na pasta bin do diretório de instalação do Logstash. A tabela a seguir descreve os plug-ins de saída oferecidos pelo Logstash.

Sr. Não.	Nome e descrição do plugin
1	aggregate Este plugin coleta ou agrega os dados de vários eventos do mesmo tipo e os processa no evento final
2	alter Ele permite que o usuário altere o campo de eventos de log, que o filtro mutate não manipula
3	anonymize É usado para substituir os valores dos campos por um hash consistente
4	cipher É usado para criptografar os eventos de saída antes de armazená-los na fonte de destino
5	clone É usado para criar duplicatas dos eventos de saída no Logstash
6	collate Ele mescla os eventos de diferentes registros por tempo ou contagem
7	csv Este plugin analisa os dados dos registros de entrada de acordo com o separador
8	date Ele analisa as datas dos campos no evento e as define como um carimbo de data / hora para o evento
9	dissect Este plugin ajuda o usuário a extrair campos de dados não estruturados e torna mais fácil para o filtro grok analisá-los corretamente
10	drop É usado para descartar todos os eventos do mesmo tipo ou qualquer outra similaridade
11	elapsed É usado para calcular o tempo entre os eventos de início e término
12	Elasticsearch É usado para copiar os campos de eventos de log anteriores presentes no Elasticsearch para o atual no Logstash
13	extractnumbers É usado para extrair o número de strings nos eventos de log
14	geoip Adiciona um campo no evento, que contém a latitude e longitude da localização do IP presente no evento de log
15	grok É o plugin de filtro comumente usado para analisar o evento para obter os campos
16	i18n Exclui os caracteres especiais de um campo no evento de log
17	json É usado para criar um objeto Json estruturado no evento ou em um campo específico de um evento
18	kv Este plugin é útil para emparelhar pares de valores-chave nos dados de registro
19	metrics É usado para agregar métricas como a contagem do tempo de duração em cada evento
20	multiline É também um dos plugins de filtro comumente usados, que ajuda o usuário no caso de converter dados de registro multilinha em um único evento.
21	mutate Este plugin é usado para renomear, remover, substituir e modificar campos em seus eventos
22	range É usado para verificar os valores numéricos dos campos em eventos em relação a um intervalo esperado e o comprimento da string dentro de um intervalo.
23	ruby É usado para executar código Ruby arbitrário
24	sleep Isso faz o Logstash dormir por um determinado período de tempo
25	split É usado para dividir um campo de um evento e colocar todos os valores de divisão nos clones desse evento
26	xml É usado para criar eventos pareando os dados XML presentes nos logs

Plugins codec

Os plug-ins de codec podem fazer parte de plug-ins de entrada ou saída. Esses plug-ins são usados ​​para alterar ou formatar a apresentação dos dados de registro. O Logstash oferece vários plug-ins de codec e esses são os seguintes -

Sr. Não.	Nome e descrição do plugin
1	avro Este plugin codifica serializa eventos Logstash para datums avro ou decodifica registros avro para eventos Logstash
2	cloudfront Este plugin lê os dados codificados do AWS cloudfront
3	cloudtrail Este plugin é usado para ler os dados do AWS cloudtrail
4	collectd Este lê os dados do protocolo binário chamado coletado sobre UDP
5	compress_spooler É usado para compactar os eventos de log no Logstash para lotes em spool
6	dots Este é o rastreamento de desempenho usado definindo um ponto para cada evento para stdout
7	es_bulk Isso é usado para converter os dados em massa de Elasticsearch em eventos Logstash, incluindo metadados Elasticsearch
8	graphite Este codec lê dados de grafite em eventos e transforma o evento em registros formatados em grafite
9	gzip_lines Este plugin é usado para lidar com dados codificados por gzip
10	json Isso é usado para converter um único elemento na matriz Json em um único evento Logstash
11	json_lines É usado para lidar com dados Json com delimitador de nova linha
12	line O plugin irá ler e gravar o evento em um único live, o que significa que após o delimitador de nova linha haverá um novo evento
13	multiline É usado para converter dados de registro multilinha em um único evento
14	netflow Este plugin é usado para converter dados nertflow v5 / v9 em eventos logstash
15	nmap Ele analisa os dados de resultado do nmap em um formato XML
16	plain Lê texto sem delimitadores
17	rubydebug Este plugin irá escrever os eventos Logstash de saída usando a incrível biblioteca de impressão Ruby

Construa Seu Próprio Plugin

Você também pode criar seus próprios plug-ins no Logstash, que atendem aos seus requisitos. O utilitário Logstash-plugin é usado para criar plug-ins personalizados. Aqui, iremos criar um plugin de filtro, que irá adicionar uma mensagem personalizada nos eventos.

Gere a Estrutura de Base

Um usuário pode gerar os arquivos necessários usando a opção gerar do utilitário logstash-plugin ou também está disponível no GitHub.

>logstash-plugin generate --type filter --name myfilter --path c:/tpwork/logstash/lib

Aqui, typeopção é usada para especificar se o plugin é Entrada, Saída ou Filtro. Neste exemplo, estamos criando um plugin de filtro chamadomyfilter. A opção de caminho é usada para especificar o caminho, onde você deseja que o diretório do plugin seja criado. Depois de executar o comando mencionado acima, você verá que uma estrutura de diretório foi criada.

Desenvolva o Plugin

Você pode encontrar o arquivo de código do plug-in no \lib\logstash\filterspasta no diretório do plugin. A extensão do arquivo será.rb.

Em nosso caso, o arquivo de código estava localizado dentro do seguinte caminho -

C:\tpwork\logstash\lib\logstash-filter-myfilter\lib\logstash\filters\myfilter.rb

Mudamos a mensagem para - padrão ⇒ "Oi, você está aprendendo isso em tutorialspoint.com" e salvamos o arquivo.

Instale o Plugin

Para instalar este plugin, o Gemfile do Logstash precisa ser modificado. Você pode encontrar esse arquivo no diretório de instalação do Logstash. No nosso caso, será emC:\tpwork\logstash. Edite este arquivo usando qualquer editor de texto e adicione o seguinte texto nele.

gem "logstash-filter-myfilter",:path => "C:/tpwork/logstash/lib/logstash-filter-myfilter"

No comando acima, especificamos o nome do plugin junto com onde podemos encontrá-lo para instalação. Em seguida, execute o utilitário Logstash-plugin para instalar este plugin.

>logstash-plugin install --no-verify

Testando

Aqui, estamos adicionando myfilter em um dos exemplos anteriores -

logstash.conf

Este arquivo de configuração Logstash contém myfilter na seção de filtro após o plugin de filtro grok.

input {
   file {
      path => "C:/tpwork/logstash/bin/log/input1.log"
   } 
}
filter {
   grok {
      match => [
         "message", "%{LOGLEVEL:loglevel} - %{NOTSPACE:taskid} -
            %{NOTSPACE:logger} - %{WORD:label}( - %{INT:duration:int})?" ]
   }
   myfilter{}
}
output {
   file {
      path => "C:/tpwork/logstash/bin/log/output1.log"
      codec => rubydebug
   }
}

Run logstash

Podemos executar o Logstash usando o seguinte comando.

>logstash –f logsatsh.conf

input.log

O bloco de código a seguir mostra os dados de registro de entrada.

INFO - 48566 - TRANSACTION_START - start

output.log

O bloco de código a seguir mostra os dados do log de saída.

{
   "path" => "C:/tpwork/logstash/bin/log/input.log",
   "@timestamp" => 2017-01-07T06:25:25.484Z,
   "loglevel" => "INFO",
   "logger" => "TRANSACTION_END",
   "@version" => "1",
   "host" => "Dell-PC",
   "label" => "end",
   "message" => "Hi, You are learning this on tutorialspoint.com",
   "taskid" => "48566",
   "tags" => []
}

Publique no Logstash

Um desenvolvedor também pode publicar seu plug-in personalizado no Logstash, enviando-o no github e seguindo as etapas padronizadas definidas pela Elasticsearch Company.

Consulte o seguinte URL para obter mais informações sobre a publicação -

https://www.elastic.co/guide/en/logstash/current/contributing-to-logstash.html

Logstash oferece APIs para monitorar seu desempenho. Essas APIs de monitoramento extraem métricas de tempo de execução sobre o Logstash.

API Node Info

Esta API é usada para obter informações sobre os nós do Logstash. Ele retorna as informações do sistema operacional, do pipeline do Logstash e da JVM no formato JSON.

Você pode extrair as informações enviando um get pedido para Logstash usando o seguinte URL -

GET http://localhost:9600/_node?pretty

Resposta

A seguir está a resposta da API de informações do nó.

{
   "host" : "Dell-PC",
   "version" : "5.0.1",
   "http_address" : "127.0.0.1:9600",
   
   "pipeline" : {
      "workers" : 4,
      "batch_size" : 125,
      "batch_delay" : 5,
      "config_reload_automatic" : false,
      "config_reload_interval" : 3
   },
   "os" : {
      "name" : "Windows 7",
      "arch" : "x86",
      "version" : "6.1",
      "available_processors" : 4
   },
   "jvm" : {
      "pid" : 312,
      "version" : "1.8.0_111",
      "vm_name" : "Java HotSpot(TM) Client VM",
      "vm_version" : "1.8.0_111",
      "vm_vendor" : "Oracle Corporation",
      "start_time_in_millis" : 1483770315412,
      
      "mem" : {
         "heap_init_in_bytes" : 16777216,
         "heap_max_in_bytes" : 1046937600,
         "non_heap_init_in_bytes" : 163840,
         "non_heap_max_in_bytes" : 0
      },
      "gc_collectors" : [ "ParNew", "ConcurrentMarkSweep" ]
   }
}

Você também pode obter as informações específicas de Pipeline, OS e JVM, apenas adicionando seus nomes na URL.

GET http://localhost:9600/_node/os?pretty
GET http://localhost:9600/_node/pipeline?pretty
GET http://localhost:9600/_node/jvm?pretty

API Plugins Info

Esta API é usada para obter informações sobre os plug-ins instalados no Logstash. Você pode recuperar essas informações enviando uma solicitação get para o URL mencionado abaixo -

GET http://localhost:9600/_node/plugins?pretty

Resposta

A seguir está a resposta da API Plugins Info.

{
   "host" : "Dell-PC",
   "version" : "5.0.1",
   "http_address" : "127.0.0.1:9600",
   "total" : 95,
   "plugins" : [ {
      "name" : "logstash-codec-collectd",
      "version" : "3.0.2"
   },
   {
      "name" : "logstash-codec-dots",
      "version" : "3.0.2"
   },
   {
      "name" : "logstash-codec-edn",
      "version" : "3.0.2"
   },
   {
      "name" : "logstash-codec-edn_lines",
      "version" : "3.0.2"
   },
   ............
}

API Node Stats

Esta API é usada para extrair as estatísticas do Logstash (Memória, Processo, JVM, Pipeline) em objetos JSON. Você pode recuperar essas informações enviando uma solicitação get para os URLs mencionados abaixo -

GET http://localhost:9600/_node/stats/?pretty
GET http://localhost:9600/_node/stats/process?pretty
GET http://localhost:9600/_node/stats/jvm?pretty
GET http://localhost:9600/_node/stats/pipeline?pretty

API Hot Threads

Esta API recupera as informações sobre os tópicos ativos no Logstash. Threads ativos são os threads java, que têm alto uso da CPU e são executados por mais tempo do que o tempo de execução normal. Você pode recuperar essas informações enviando uma solicitação get para o URL mencionado abaixo -

GET http://localhost:9600/_node/hot_threads?pretty

Um usuário pode usar o seguinte URL para obter a resposta em um formato mais legível.

GET http://localhost:9600/_node/hot_threads?human = true

Neste capítulo, discutiremos os aspectos de segurança e monitoramento do Logstash.

Monitoramento

Logstash é uma ferramenta muito boa para monitorar os servidores e serviços em ambientes de produção. Os aplicativos em ambiente de produção produzem diferentes tipos de dados de registro, como registros de acesso, registros de erros, etc. O Logstash pode contar ou analisar o número de erros, acessos ou outros eventos usando plug-ins de filtro. Esta análise e contagem podem ser usadas para monitorar diferentes servidores e seus serviços.

Logstash oferece plugins como HTTP Pollerpara monitorar o monitoramento de status do site. Aqui, estamos monitorando um site chamadomysite hospedado em um servidor Apache Tomcat local.

logstash.conf

Neste arquivo de configuração, o plug-in http_poller é usado para acessar o site especificado no plug-in após um intervalo de tempo especificado na configuração de intervalo. Finalmente, ele grava o status do site em uma saída padrão.

input {
   http_poller {
      urls => {
         site => "http://localhost:8080/mysite"
      }
      request_timeout => 20
      interval => 30
      metadata_target => "http_poller_metadata"
   }
}
output {
   if [http_poller_metadata][code] == 200 {
      stdout {
         codec => line{format => "%{http_poller_metadata[response_message]}"}
      }
   }
   if [http_poller_metadata][code] != 200 {
      stdout {
         codec => line{format => "down"}
      }
   }
}

Executar logstash

Podemos executar o Logstash com o seguinte comando.

>logstash –f logstash.conf

saída padrão

Se o site estiver ativo, a saída será -

Ok

Se pararmos o site usando o Manager App do Tomcat, a saída mudará para -

down

Segurança

O Logstash fornece muitos recursos para comunicação segura com sistemas externos e suporta mecanismo de autenticação. Todos os plug-ins Logstash oferecem suporte para autenticação e criptografia em conexões HTTP.

Segurança com protocolo HTTP

Existem configurações como usuário e senha para fins de autenticação em vários plug-ins oferecidos pelo Logstash, como no plug-in Elasticsearch.

elasticsearch {
   user => <username>
   password => <password>
}

A outra autenticação é PKI (public key infrastructure)para Elasticsearch. O desenvolvedor precisa definir duas configurações no plug-in de saída Elasticsearch para habilitar a autenticação PKI.

elasticsearch {
   keystore => <string_value>
   keystore_password => <password>
}

No protocolo HTTPS, um desenvolvedor pode usar o certificado da autoridade para SSL / TLS.

elasticsearch {
   ssl => true
   cacert => <path to .pem file>
}

Segurança com protocolo de transporte

Para usar o protocolo de transporte com Elasticsearch, os usuários precisam definir a configuração do protocolo para transporte. Isso evita o desempacotamento de objetos JSON e leva a mais eficiência.

A autenticação básica é a mesma realizada no protocolo http no protocolo de saída Elasticsearch.

elasticsearch {
   protocol => “transport”
   user => <username>
   password => <password>
}

A autenticação PKI também precisa que os conjuntos SSL sejam verdadeiros com outras configurações no protocolo de saída Elasticsearch -

elasticsearch {
   protocol => “transport”
   ssl => true
   keystore => <string_value>
   keystore_password => <password>
}

Por fim, a segurança SSL exige um pouco mais configurações do que outros métodos de segurança na comunicação.

elasticsearch {
   ssl => true
   ssl => true
   keystore => <string_value>
   keystore_password => <password>
   truststore => 
      
        truststore_password => <password> } 
      

Outros benefícios de segurança do Logstash

O Logstash pode ajudar a inserir as fontes do sistema para prevenir ataques como ataques de negação de serviço. O monitoramento de logs e a análise dos diferentes eventos nesses logs podem ajudar os administradores de sistema a verificar a variação nas conexões de entrada e erros. Essas análises podem ajudar a ver se o ataque está acontecendo ou vai acontecer nos servidores.

Outros produtos da Elasticsearch Company, como x-pack e filebeat fornece algumas funcionalidades para comunicação segura com o Logstash.