Como todos sabemos, el comportamiento del usuario al utilizar nuestras aplicaciones es información altamente valiosa. Los reportes de fallas en el sistema y los estados de rendimiento nos brindan una gran cantidad de información útil para mejorar la calidad del producto. Sin embargo, recopilar cada acción de humanos y máquinas es una tarea compleja.
ELK es la combinación de Elastic Search, Logstash y Kibana que se utiliza para proporcionar un enfoque integral en la consolidación, gestión y análisis de registros de las aplicaciones. ELK Stack simplifica la búsqueda y el análisis de datos al proporcionar información en tiempo real a partir de los datos de registro.
Además, proporciona información en tiempo real a partir de datos consolidados.
El problema
Asumir que toda la actividad de los sistemas se dirige a un solo punto no es lo mejor, pero es posible.
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:
La solución
La forma más común de obtener gráficos y números de negocios a partir de archivos de registro es colocar todos los recursos en un solo disco o fuente de almacenamiento.
Almacenamiento Centralizado de Registros
| +------------+
| | |
| | web-1 >
| | |\
| +------------+ \
| \logs
| \
| +------------+ \ +------------+ +-------------+
| | | logs \| | | |
| | db-1 >-------------> log-1 +---------+ dashboard-1 |
| | | /| | | |
| +------------+ / +------------+ +-------------+
| /
| /logs
| +------------+ /
| | |/
| | api-1 >
| | |
| +------------+
Estrategia Pull/Push
Los datos pueden fluir en ambas direcciones, extraídos del servidor de registro central o enviados desde cada nodo. Todo depende de los recursos y la estrategia que se vaya a utilizar.
Una vez que toda la información se encuentra centralizada, el análisis y la búsqueda son tareas fáciles con las herramientas adecuadas. Por último, el seguimiento y el gráfico producirán una herramienta de toma de decisiones muy útil.
Adentrándonos en ELK (Elasticsearch, Logstash, Kibana)
El 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 salidas de registro a una ubicación central desde diferentes fuentes como servidores web, servidores de correo, servidores de bases de datos y dispositivos de red puede ser particularmente útil (sobre todo cuando se trata de tomar mejores decisiones basadas en datos).
Normalmente se ejecuta el ELK Stack completo, no cada componente individual por separado. Cada uno de estos servicios desempeña un papel importante y, para desempeñarse bajo una gran demanda, es más ventajoso implementar cada servicio en su propio servidor. Al hacerlo, se introducen otros problemas relacionados con implementaciones multinodos, redes, seguridad y administración. Por ahora, nos quedaremos con el despliegue de un solo stack para que podamos aprender los conceptos básicos de ELK y utilizarlo para fines de desarrollo y pruebas.
Más adelante en el proceso, abordaremos la implementación adecuada de varios nodos para entornos de producción.
Imagen completa de los componentes ELK
|
| +-----------+
| | 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 registra mensajes. Recibe mensajes registrados y los retransmite a ElasticSearch.
Kibana:
Un panel de búsqueda y análisis de código abierto basado en navegador. Proporciona capacidades de visualización sobre el contenido indexado en un clúster de Elasticsearch.
Beats:
Agente de cliente a cargo de empujar cualquier archivo nuevo o modificación de la fuente de datos
Implementando ELK de la manera fácil usando Docker
Esta guía ofrece un recorrido paso a paso para realizar la configuración básica de un ELK Stack utilizando tecnología de contenedores (Docker) y aprender los aspectos básicos de la implementación de 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 obtener detalles de bajo nivel del proceso de configuración de ELK y solo desea aprovechar sus beneficios.
Configurando el 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:
Vamos a extraer la imagen emitiendo el siguiente comando:
$ docker pull sebp/elkUsando el tag por defecto: latest
Trying to pull repository docker.io/sebp/elk ... latest: Pulling from sebp/elk
La imagen mide alrededor de 900 + GB, por lo que, dependiendo de su conexión a Internet, llevará algo de tiempo. Una vez que la imagen ha sido descargada, 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>
Debería poder ver la imagen que ejecuta el comando de imágenes de acoplador (docker):
$ 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 del ELK Stack:
- 5601 (interfaz web de Kibana).
- 9200 (interfaz Elasticsearch JSON).
- 5044 (interfaz de Logstash Beats, recibe registros de Beats como Filebeat; consulte los registros de reenvío con la sección Filebeat).
- 5000 (Interface Logstash Lumberjack, recibe registros de los reenviadores de Logstash; consulte los registros de reenvío con la sección de reenviadores de Logstash).
- Acceda a la interfaz web de Kibana navegando a http://:5601, donde se está ejecutando el nombre de host o la dirección IP del host Docker, ej. localhost (si ejecuta una versión nativa local de Docker, o la dirección IP de la máquina virtual si ejecuta una versión alojada en VM de Docker).
Al igual que en la versión 4.0.0 de Kibana, no podrá ver nada (ni siquiera un tablero vacío) hasta que se haya registrado algo, así que pasemos directamente a la siguiente sección sobre cómo reenviar registros de aplicaciones regulares, como Apache Web Server.
Configuración Logstash
Primero revisemos cómo funciona el proceso:
- El Apache Web Server se está ejecutando y registrando solicitudes en la ruta configurada.
- Logstash, ejecutándose como un daemon persistente, monitorea los registros de Apache para nuevas líneas y los procesa.
- Logstash enviará registros analizados en formato de documento JSON a Elasticsearch para su almacenamiento y con la capacidad de realizar análisis en ellos.
- Kibana usa Elasticsearch como back-end para el tablero de instrumentos y la búsqueda.
Lo primero que debe hacer es confirmar a dónde está ingresando Apache. El archivo de registro de apache predeterminado se encuentra aquí:
sudo tail /var/log/apache2/access.log
Debería ver una o más líneas que se ven así:
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 recibir y analizar estos registros.A continuación, haga un archivo de configuración de logstash simple: haga un archivo denominado 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 está ubicado en otra ubicación no tradicional, ajuste la tercera línea, path => '/var/log/apache2/access.log', según corresponda.
El archivo de configuración simplemente observa el archivo de registro de apache para eventos, los analiza con un patrón grok (una expresión regular predefinida simplificada) llamado COMBINEDAPACHELOG e imprimirá esos eventos a la salida estándar (la documentación de Logstash tiene información adicional).
Visualización de datos
Para confirmar que el pipeline está funcionando correctamente, realice algunas solicitudes a su servidor web usando su navegador web. Luego, observe una API de Elasticsearch para ver que se haya creado un nuevo índice (aparecerá en la lista de índices como logstash seguido de la fecha):
curl localhost:9200/_cat/indices
Debería 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 del sistema, busque la dirección de la máquina bajo el puerto 5601 para comenzar a usar la interfaz de Kibana:
elk-kibana-setup
Kibana hace una conjetura sobre los nombres de sus campos de índice y 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 eventos de registro de Apache.
elk-kibana-discovery
Implementando ELK de la manera difícil
En este caso nos referimos a la implementación de cada componente individual desde cero un nuevo equipo en la nube.
Configure los repositorios 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 {} }'
Instale filebeat en la máquina del cliente
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
Haga su primer 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
Configuración de prueba
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#
Encienda el servicio de agente del lado del cliente
systemctl restart filebeat.service
Implemente kibana
sudo apt-get install kibana
whereis kibana
kibana: /etc/kibana /usr/share/kibana
vi /etc/kibana/kibana.yml
elasticsearch.url: "http://localhost:9200"
-
Set elasticsearch.url to point at your Elasticsearch instance config/kibana.ym
systemctl start kibana.service
-
Run bin/kibana
Controle los servicios principales
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#
Monitoree 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.
Revise la instancia web si 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 un gran valor a su práctica de DevOps y fomenta una cultura de mejora continua dentro de su organización.
.png)
