Já vimos como o Logstash funciona, de maneira bem simples.

Agora, vamos partir para a configuração de um ambiente distribuído, e usando uma interface Web com mais recursos. Neste ambiente, teremos dois tipos de máquinas: máquinas que enviam as mensagens e máquinas que coletam e indexam as mensagens.

Nas máquinas do primeiro tipo, iremos usar apenas o Logstash, já que elas apenas lêem as mensagens das aplicações de origem e aplicam alguns filtros.

No segundo tipo de máquina, iremos coletar e armazenar as mensagens. Do primeiro tipo, teremos várias máquinas, já do segundo, apenas uma (ou algumas poucas, no caso de uma carga muito grande de acessos).

Por isso, para que o ambiente consiga tratar uma grande quantidade de mensagens, iremos usar o Redis, como uma fila que vai receber as mensagens dos hosts que enviam as mensagens, o Logstasg para tratar e indexar as mensagens, o Elasticsearch para armazenar e o Kibana para visualizar as mensagens.

Crie as pastas /opt/monitor/logstash/{bin,conf,log} nos dois tipos de máquinas - já que todas elas irão executar uma instância do Logstash.

Faça o download do Logstash na pasta bin - lembre-se do pré-requisito de ter o Java instalado.

Nas máquinas que enviarão as mensagens, crie um arquivo de configuração para o Logstash, na pasta /opt/monitor/logstash/conf, chamado "shipper.conf", com o seguinte conteúdo:



Substituindo <endereço IP do redis server>, pelo endereço IP (ou DNS hostname) do servidor que vai executar o Redis.

Já na máquina que vai agregar, indexar e armazenar as mensagens, crie um arquivo chamado "indexer.conf", na pasta /opt/monitor/logstash/conf, com o seguinte conteúdo:



Aqui, o Elasticsearch vai executar na mesma máquina que o Redis e o Logstash indexer, mas é possível ter cada componente em seu próprio servidor, sem nenhum prejuízo de desempenho ou configuração - apenas lembrando de usar os endereços corretos.

Faça o download do Elasticsearch, disponível em:

• https://github.com/downloads/elasticsearch/elasticsearch/elasticsearch-0.19.9.tar.gz

Visite a página do Elasticsearch e verifique a versão mais recente, na pasta /opt/monitoring, descompacte o arquivo e renomeie a pasta criada para: elasticsearch

Crie uma pasta para os logs (o pacote do Elasticsearch já contém pastas com os binários e com as configurações):

# cd /opt/monitoring
# wget https://github.com/downloads/elasticsearch/elasticsearch/elasticsearch-0.19.9.tar.gz
# tar -zxf elasticsearch-0.19.9.tar.gz
# mv elasticsearch-0.19.9 elasticsearch
# mkdir /opt/monitoring/elasticsearch/log
# rm /opt/monitoring/elasticsearch-0.19.9.tar.gz

Para facilitar o processo, vamos também criar um script para iniciar o Elasticsearch junto com o sistema (no caso, estamos usando o Ubuntu).

Para isso, crie um arquivo chamado "elasticsearch" na pasta /etc/init.d/, com o seguinte conteúdo:

 #!/bin/sh
 ### BEGIN INIT INFO
 # Provides:          elasticsearch
 # Required-Start:    $all
 # Required-Stop:     $all
 # Default-Start:     2 3 4 5
 # Default-Stop:      0 1 6
 # Short-Description: Starts elasticsearch
 # Description:       Starts elasticsearch using start-stop-daemon
 ### END INIT INFO
  
 ES_HOME=/opt/monitoring/elasticsearch
 ES_MIN_MEM=256m
 ES_MAX_MEM=1g
 DAEMON=$ES_HOME/bin/elasticsearch
 NAME=elasticsearch
 DESC=elasticsearch
 PID_FILE=/var/run/$NAME.pid
 LOG_DIR=/opt/monitoring/$NAME/log
 DATA_DIR=/opt/monitoring/$NAME/data
 WORK_DIR=/tmp/$NAME
 CONFIG_FILE=/opt/monitoring/$NAME/config/elasticsearch.yml
 DAEMON_OPTS="-p $PID_FILE -Des.config=$CONFIG_FILE -Des.path.home=$ES_HOME -Des.path.logs=$LOG_DIR -Des.path.data=$DATA_DIR -Des.path.work=$WORK_DIR"


test -x $DAEMON || exit 0
  
set -e

case "$1" in
  start)
    echo -n "Starting $DESC: "
    mkdir -p $LOG_DIR $DATA_DIR $WORK_DIR
    if start-stop-daemon --start --pidfile $PID_FILE --startas $DAEMON -- $DAEMON_OPTS
    then
      echo "started."
    else
      echo "failed."
    fi
    ;;
  stop)
    echo -n "Stopping $DESC: "
    if start-stop-daemon --stop --pidfile $PID_FILE
    then
      echo "stopped."
    else
      echo "failed."
    fi
    ;;
  restart|force-reload)
    ${0} stop
    sleep 0.5
    ${0} start
    ;;
  *)
    N=/etc/init.d/$NAME
    echo "Usage: $N {start|stop|restart|force-reload}" >&2
    exit 1
    ;;
esac

exit 0

E instale o script:

# chmod +x /etc/init.d/elasticsearch
# update-rc.d elasticsearch defaults

Para este roteiro, as configurações disponíveis nos arquivos de configuração do Elasticsearch ("elasticsearch.yaml" e "logging.yaml") são o suficiente.

Para um ambiente de produção, pode ser necessário ajustar alguns parâmetros (Ex.: no caso de você pensar em usar um Cluster do Elasticsearch). Feito isso, inicie o Elasticsearch:

# /etc/init.d/elasticsearch start

Você pode acompanhar o startup do Elasticsearch através do log:

# tail -f /opt/monitoring/elasticsearch/log/elasticsearch.log

Agora, crie as pastas /opt/monitoring/redis/{bin,conf,log} para o Redis. Faça o download do código-fonte, disponível em:

• http://redis.googlecode.com/files/redis-2.4.17.tar.gz

Visite a página do Redis e verifique a versão mais recente. Descompacte o arquivo e compile o Redis:

# mkdir -p /opt/monitoring/redis/{conf,log,data}
# cd /opt/monitoring/redis
# wget http://redis.googlecode.com/files/redis-2.4.17.tar.gz
# tar -zxf redis-2.4.17.tar.gz
# make

Depois de compilar, pode ser uma boa ideia testar os arquivos (para rodar o teste, é necessário ter instalado o pacote tcl8.5):

# make test

E depois disso, o make install, passando o caminho onde os binários do Redis serão instalados:

# make PREFIX=/opt/monitoring/redis/ install

Para inicializar o Redis junto com o sistema, você pode copiar o script de inicialização redis_init_script, disponível dentro da pasta "utils", para a pasta /etc/init.d, editando os caminhos corretamente.

Feito isso, copie o arquivo "redis.conf" para a pasta /opt/monitoring/redis/conf com o nome "6379.conf" e edite as seguintes linhas:



Feito isso, você pode inicializar o Redis:

# /etc/init.d/redis start

E acompanhar a operação através do log. Agora, você já pode iniciar as duas instâncias do Logstash, começando pelas máquinas que irão enviar as mensagens (shipper).

Na pasta onde está o binário do Logstash:

# java -jar logstash-1.1.1-monolithic.jar agent -f ../conf/shipper.conf

O Logstash já pode enviar mensagens ao Redis. Como ele está configurado para receber eventos da entrada padrão, vamos digitar algumas mensagens no console do Logstash. No servidor onde roda o Redis, execute o seu cliente:

# /opt/monitoring/redis/bin/redis-cli

No console do Redis-cli, execute o comando: llen logstash - para ver o tamanho da fila do Redis.

E o comando: lpop logstash - para recuperar mensagens da fila.

Agora, inicie o Logstash da máquina que vai indexar as mensagens (indexer):

# java -jar logstash-1.1.1-monolithic.jar agent -f ../conf/indexer.conf

O Logstash agora vai começar a ler as mensagens no Redis e enviar para o Elasticsearch. Digite algumas mensagens no console do Logstash da máquina shipper. Se quiser, pode verificar no console do redis-cli, que a mensagens estão sendo consumidas.

Entretanto, agora nós não estamos mais rodando o Logstash com sua interface Web. Para visualizar o conteúdo do Elasticsearch - e as mensagens coletadas pelo Logstash - vamos usar o Kibana.

O Kibana é uma interface gráfica para o Logstash (e Elasticsearch), com bem mais recursos que a interface embutida no Logstash.

Dependências

O Kibana é uma aplicação PHP, então é necessário um servidor Web e o PHP instalados na máquina. Nesse caso, iremos usar o Apache e o mod-php. Também é necessário o módulo cURL do PHP.

Eu usei os pacotes disponíveis no repositório do Ubuntu. O nome dos pacotes:

• apache2
• libapache2-mod-php5
• php5-curl

Crie as pastas /opt/monitoring/kinaba/{www,log} e faça o download do Kibana, disponível em:

• http://github.com/rashidkpc/Kibana/tarball/master

Visite a página do Kibana e verifique a versão mais recente. Descompacte e mova os arquivos para a pasta /opt/monitoring/kibana/www. Com o Apache já instalado, crie um arquivo de configuração similar ao abaixo:



Também é necessário editar o arquivo de configuração do Kibana, o "config.php".

A princípio, a única opção que deve ser alterada é a "elasticsearch_server", que define o endereço e a porta do Elasticsearch. No nosso caso, o servidor é localhost e a porta é a padrão (9200).

Reinicie o Apache e aponte o browser para este servidor. A página inicial do Kibana será aberta. Clique no botão "Search" e veja as últimas mensagens que você digitou no console do Logstash Shipper.

Entretanto, coletar mensagens digitadas no console não é nada útil. Por isso, iremos configurar o Logstash para coletar alguma coisa mais interessante.