Gestión de registros moderna | La forma correcta con ELK Stack

Encora | 18 de agosto, 2018

La actividad del usuario en nuestras aplicaciones es información increíblemente valiosa. Los fallos del sistema y los estados de rendimiento proporcionan información valiosa que alimenta la calidad de un producto. Sin embargo, recopilar cada acción de humanos y máquinas a veces es una tarea compleja.

ELK es una pila de tecnología que combina Elastic Search, Logstach y Kibana para proporcionar un enfoque integral para consolidar, administrar y analizar los registros de sus aplicaciones, proporcionando información en tiempo real a partir de datos consolidados.

El Problema

Asumir que toda la actividad de los sistemas va a un solo punto es incorrecto pero no imposible, las soluciones modernas como los sistemas distribuidos producen miles y millones de entradas por día de diferentes fuentes en nuestra red.

En pocas palabras, es un crecimiento acelerado de datos de diferentes fuentes.

|            +------------+                +-------------+ 
| | | logs | |
| | web-1 <----------------> dashboard-1 |
| | | | |
| +------------+ +-------------+

Y con la generación de grandes registros viene el uso exponencial del disco.

[uso de disco de muning]

La Solución

La forma más común de obtener gráficos y números comerciales a partir de archivos de registro es colocar todos los recursos en un solo disco / almacenamiento.

Almacenamiento de registros centralizado
|                   +------------+                                             
| | |
| | web-1 >
| | |\
| +------------+ \
| \logs
| \
| +------------+ \ +------------+ +-------------+
| | | logs \| | | |
| | db-1 >-------------> log-1 +---------+ dashboard-1 |
| | | /| | | |
| +------------+ / +------------+ +-------------+
| /
| /logs
| +------------+ /
| | |/
| | api-1 >
| | |
| +------------+
Estrategia de tirar / empujar

Los datos pueden fluir en ambas direcciones, extraídos del servidor de registro central o enviados desde cada nodo. Depende de los recursos y la estrategia. Una vez que todos los huevos están en una canasta, analizar y buscar son tareas fáciles con las herramientas adecuadas. Y finalmente, el seguimiento y el gráfico producirán una interesante herramienta de toma de decisiones.

Buceando en ELK (Elasticsearch, Logstash, Kibana)

ELK Stack es popular porque satisface una necesidad específica en el espacio de análisis y gestión de registros. En las infraestructuras basadas en la nube, la consolidación de las salidas de los registros en una ubicación central desde diferentes fuentes, como servidores web, servidores de correo, servidores de bases de datos y dispositivos de red, puede resultar particularmente útil. Esto es especialmente cierto cuando se intenta tomar mejores decisiones basadas en datos. La pila ELK simplifica la búsqueda y el análisis de datos al proporcionar información en tiempo real a partir de los datos de registro.

Es común ejecutar la pila ELK completa, no cada componente individual por separado. Cada uno de estos servicios juega un papel importante y, para funcionar bajo una gran demanda, es más ventajoso implementar cada servicio en su propio servidor. Hacerlo introduce otros problemas relacionados con las implementaciones de múltiples nodos, las redes, la seguridad y la administración. Por ahora, nos quedaremos con la implementación de pila única para que podamos aprender los conceptos básicos de ELK y usarlo con fines de desarrollo y prueba. Abordaremos la implementación de múltiples nodos adecuada para entornos de producción más adelante en el proceso.

Componentes ELK el panorama general

|                                                                                                           
| +-----------+
| | Kibana UI |
| +----+------+
| |
| +-------------+ +--------------------------------------+ |
| | datasource | | logstash | |
| | logs | | | |
| +------+------+ | +--------------------------------+ | +--------+--------+
| | | | plugins | | | |
| | | | | |------| ElasticSearch |
| +------+-----+ +----------+ | | +-----+ +-------+ +------+ | | | |
| | web-2 |--->|file-beat |--->| | |input| |filter | |output| | | +-----------------+
| +------------+ +----------+ | | +-----+ +-------+ +------+ | |
| | +--------------------------------+ |
| +--------------------------------------+
Elasticsearch:

Un motor de búsqueda RESTful distribuido creado para la nube que almacena los mensajes registrados.

Logstash:

Recopila, procesa y reenvía eventos y mensajes de registro. Recibe mensajes registrados y los transmite a ElasticSearch.

Kibana:

Un panel de análisis y búsqueda de código abierto basado en navegador. Proporciona capacidades de visualización además del contenido indexado en un clúster de Elasticsearch.

Beats:

Agente cliente encargado de enviar cualquier archivo nuevo o modificación desde la fuente de datos.

Implementar ELK de manera fácil (Docker)

Esta guía ofrece un recorrido paso a paso sobre cómo realizar la configuración básica de un ELK Stack utilizando tecnología de contenedores (Docker) y aprender los conceptos básicos para implementar registros en la pila y realizar análisis en tiempo real de los datos.

Esta opción es un enfoque particularmente útil si no está interesado en entrar en detalles de bajo nivel del proceso de configuración de ELK y solo desea aprovechar sus beneficios.

Configuración del contenedor ELK

Lo primero que debemos hacer es descargar una imagen ELK. Usaremos la siguiente imagen disponible en DockerHub, que empaqueta las últimas versiones disponibles de los componentes:

Extraemos la imagen emitiendo el siguiente comando:

$ docker pull sebp/elk

Usando la etiqueta predeterminada: última

Trying to pull repository docker.io/sebp/elk ... latest: Pulling from sebp/elk

La imagen tiene alrededor de 900 + GB, por lo que, dependiendo de su conexión a Internet, llevará algún tiempo. Una vez descargada la imagen, verá el siguiente mensaje:

Status: Downloaded newer image for <a class="external-link" href="http://docker.io/sebp/elk:latest" rel="nofollow">docker.io/sebp/elk:latest</a>

Y debería poder ver la imagen ejecutando el comando docker images:

$ docker images
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
docker.io/sebp/elk latest 3e07e86fb40d 10 days ago 975.5 MB

Ahora podemos crear un contenedor a partir de la imagen con el siguiente comando:

$ sudo docker run -p 5601:5601 -p 9200:9200 -p 5044:5044 -p 5000:5000 -it --name elk sebp/elk

Este comando publica los siguientes puertos, que son necesarios para el correcto funcionamiento de la pila ELK:

  • 5601 (interfaz web de Kibana).

  • 9200 (interfaz JSON de Elasticsearch).

  • 5044 (interfaz de Logstash Beats, recibe registros de Beats como Filebeat; consulte la sección Reenvío de registros con Filebeat).

  • 5000 (interfaz Logstash Lumberjack, recibe registros de los reenviadores de Logstash; consulte la sección Reenvío de registros con el reenviador de Logstash).


Acceda a la interfaz web de Kibana navegando a http: //: 5601, donde se encuentra el nombre de host o la dirección IP del host en el que se ejecuta Docker, p. Ej. localhost (si se ejecuta una versión nativa local de Docker, o la dirección IP de la máquina virtual si se ejecuta una versión de Docker alojada en VM).

Al igual que en la versión 4.0.0 de Kibana, no podrá ver nada (ni siquiera un panel vacío) hasta que se haya registrado algo, así que pasemos directamente a la siguiente sección sobre cómo reenviar registros de aplicaciones normales, como Apache. Servidor web.

Configuración de Logstash

Primero revisemos cómo funciona el proceso:

  1. El servidor web Apache se está ejecutando y registra las solicitudes en la ruta configurada.

  2. Logstash, que se ejecuta como un demonio persistente, supervisa los registros de Apache en busca de nuevas líneas y las procesa.

  3. Logstash enviará registros analizados en forma de documento JSON a Elasticsearch para su almacenamiento y la capacidad de realizar análisis en ellos.

  4. Kibana usa Elasticsearch como back-end para el tablero y la búsqueda.

Lo primero que debe hacer es confirmar dónde está iniciando sesión Apache. El archivo de registro de Apache predeterminado se encontraría aquí:

sudo tail /var/log/apache2/access.log

Debería ver una o más líneas con este aspecto:

10.0.0.1 - - [18/Jun/2016:09:10:02 +0000] "GET / HTTP/1.1" 200 11359 "-" "curl/7.38.0"

Esto significa que Logstash ahora puede ingerir y analizar estos registros.

A continuación, cree un archivo de configuración logstash simple: cree un archivo llamado apache.conf (el nombre es arbitrario) en /etc/logstash/conf.d/apache.conf: /etc/logstash/conf.d/apache.conf

input {
file {
path => "/var/log/apache2/access.log"
start_position => beginning
}
}
filter {
grok {
match => { "message" => "%{COMBINEDAPACHELOG}" }
}
date {
match => [ "timestamp" , "dd/MMM/yyyy:HH:mm:ss Z" ]
}
}
output {
elasticsearch { host => localhost }
}

Si su archivo de registro se encuentra en otra ubicación no tradicional, ajuste la tercera línea, ruta => "/var/log/apache2/access.log", según corresponda.

El archivo de configuración simplemente busca eventos en el archivo de registro de Apache, los analiza con un patrón grok (una expresión regular predefinida simplificada) llamado COMBINEDAPACHELOG, e imprime esos eventos en la salida estándar (la documentación de Logstash tiene información adicional).

Visualización de datos

Para confirmar que la canalización funciona correctamente, realice algunas solicitudes a su servidor web utilizando su navegador web. Luego, mire una API de Elasticsearch para ver que se ha creado un nuevo índice (aparecerá en la lista de índices como logstash, seguido de la fecha):

curl localhost:9200/_cat/indices

Debe haber un índice con la fecha actual adjunta con los documentos insertados por Logstash. Ahora, con Kibana ejecutándose en segundo plano desde su unidad systemd, busque la dirección de la máquina en el puerto 5601 para comenzar a usar la interfaz de Kibana:

elk-kibana-setup

Kibana hace una suposición fundamentada sobre su índice y los nombres de los campos de tiempo, por lo que seleccionar "Crear" aquí lo ayudará a comenzar. Haga clic en la pestaña "Descubrir" en la parte superior y verá una línea de tiempo de los eventos de registro de Apache.

elk-kibana-discovery

Implementando ELK de manera difícil

Por difícil nos referimos a la implementación de cada componente individual desde cero en una nueva máquina en la nube.

Configurar repositorios de elasticsearch

wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
sudo apt-get install apt-transport-https
echo "deb https://artifacts.elastic.co/packages/5.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-5.x.list
sudo apt-get update

https://www.elastic.co/guide/en/elasticsearch/reference/current/deb.html
https://www.elastic.co/guide/en/elasticsearch/reference/master/heap-size.html

sudo apt-get install elasticsearch
vi /etc/elasticsearch/elasticsearch.yml
vi /etc/elasticsearch/jvm.options
-Xms512m
-Xmx1g
sudo systemctl start elasticsearch.service

Una forma sencilla de supervisar la actividad del servicio

sudo journalctl -f
sudo journalctl --unit elasticsearch --since "2016-10-30 18:17:16"

https://www.elastic.co/guide/en/logstash/current/installing-logstash.html#package-repositories

sudo apt-get install logstash

https://www.elastic.co/guide/en/logstash/current/running-logstash.html#running-logstash-systemd

vi /etc/logstash/logstash.yml
sudo systemctl start logstash.service

Probar el punto final de elasticsearch

curl -XGET 'localhost:9200/?pretty'

Primera Prueba
root@ubuntu-xenial:/vagrant# systemctl start logstash.service
root@ubuntu-xenial:/vagrant# ps aux | grep logstash
logstash 27235 152 39.8 3444488 404764 ? SNsl 23:22 0:15 /usr/bin/java -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=75 -XX:+UseCMSInitiatingOccupancyOnly -XX:+DisableExplicitGC -Djava.awt.headless=true -Dfile.encoding=UTF-8 -XX:+HeapDumpOnOutOfMemoryError -Xmx1g -Xms256m -Xss2048k -Djffi.boot.library.path=/usr/share/logstash/vendor/jruby/lib/jni -Xbootclasspath/a:/usr/share/logstash/vendor/jruby/lib/jruby.jar -classpath : -Djruby.home=/usr/share/logstash/vendor/jruby -Djruby.lib=/usr/share/logstash/vendor/jruby/lib -Djruby.script=jruby -Djruby.shell=/bin/sh org.jruby.Main /usr/share/logstash/lib/bootstrap/environment.rb logstash/runner.rb --path.settings /etc/logstash
root 27270 0.0 0.0 14224 928 pts/0 S+ 23:22 0:00 grep --color=auto logstash
root@ubuntu-xenial:/vagrant# whereis logstash
logstash: /etc/logstash /usr/share/logstash
root@ubuntu-xenial:/vagrant# /usr/share/logstash/bin/logstash -e 'input { stdin { } } output { stdout {} }'

advanced-pipeline

Install filebeat on client machine
sudo apt-get install filebeat
vi /etc/filebeat/filebeat.yml
filebeat.prospectors:
- input_type: log
paths:
- /var/log/syslog
output.logstash:
hosts: ["localhost:5044"]
systemctl start filebeat.service

Create your first pipeline
vi /etc/logstash/conf.d/localhost_syslog.conf
input {
beats {
port => "5044"
}
}
filter {
grok {
match => { "message" => "%{COMBINEDAPACHELOG}"}
}
geoip {
source => "clientip"
}
}
output {
stdout { codec => rubydebug }
}
systemctl restart logstash.service

Test config
root@ubuntu-xenial:/home/ubuntu# /usr/share/logstash/bin/logstash -f /etc/logstash/conf.d/localhost_syslog.conf --config.test_and_exit
WARNING: Could not find logstash.yml which is typically located in $LS_HOME/config or /etc/logstash. You can specify the path using --path.settings. Continuing using the defaults
Could not find log4j2 configuration at path /usr/share/logstash/config/log4j2.properties. Using default config which logs to console
Configuration OK
15:48:23.938 [LogStash::Runner] INFO logstash.runner - Using config.test_and_exit mode. Config Validation Result: OK. Exiting Logstash
root@ubuntu-xenial:/home/ubuntu#

Fire up the agent service on the client side
systemctl restart filebeat.service


Deploy kibana
sudo apt-get install kibana    
whereis kibana
kibana: /etc/kibana /usr/share/kibana
vi /etc/kibana/kibana.yml
elasticsearch.url: "http://localhost:9200"
  • Configure elasticsearch.url para que apunte a su instancia de Elasticsearch config / kibana.ym

               systemctl start kibana.service

  • Ejecutar botella / Kibana

               Kibana

Controlar los principales servicios
ubuntu@ubuntu-xenial:~$ 
ubuntu@ubuntu-xenial:~$ sudo su
root@ubuntu-xenial:/home/ubuntu# systemctl start elasticsearch.service
root@ubuntu-xenial:/home/ubuntu# systemctl start logstash.service
root@ubuntu-xenial:/home/ubuntu# systemctl start filebeat.service
root@ubuntu-xenial:/home/ubuntu# systemctl start kibana.service
root@ubuntu-xenial:/home/ubuntu#
Supervisar la actividad de inicio
Apr 19 21:42:49 ubuntu-xenial su[1779]: pam_systemd(su:session): Cannot create session: Already running in a session
Apr 19 21:43:01 ubuntu-xenial systemd[1]: Starting Elasticsearch...
Apr 19 21:43:01 ubuntu-xenial systemd[1]: Started Elasticsearch.
Apr 19 21:43:08 ubuntu-xenial systemd[1]: Started logstash.
Apr 19 21:43:15 ubuntu-xenial systemd[1]: Started filebeat.
Apr 19 21:43:21 ubuntu-xenial systemd[1]: Started Kibana.
Verificar que la instacia web esté disponible
root@ubuntu-xenial:/home/ubuntu# curl 'localhost:9200/_cat/indices?v'
health status index uuid pri rep docs.count docs.deleted store.size pri.store.size
yellow open .kibana Ru4w0KGQRLOa-Ogp5dHk7Q 1 1 2 0 23.4kb 23.4kb
yellow open filebeat-2017.04.20 bhSrqJLpQk2RTrJikBjTXw 5 1 1278749 0 152.8mb 152.8mb
yellow open logstash-2017.04.20 ez3TSPJZSniovcTPHtd92Q 5 1 586259 0 76.1mb 76.1mb
yellow open filebeat-2017.04.19 LvDgezqwSDaVVzg0utKIqg 5 1 3414161 0 407mb 407mb
root@ubuntu-xenial:/home/ubuntu#

Conclusión

La gestión y el análisis de registros son actividades clave cuando se trata de mantener una infraestructura estable. Tener la posibilidad de consolidar registros de diferentes fuentes y analizarlos fácilmente agrega mucho valor a su práctica de DevOps y fomenta una cultura de mejora continua dentro de su organización.

Contáctenos

Contenido

Categorías

Compartir Artículo

Artículos Destacados