Cómo implementar Grafana Loki y guardar datos en MinIO usando contenedores Docker o directamente desde la fuente

Grafana Loki es un sistema de agregación de registros que almacena y consulta registros de aplicaciones e infraestructura. Aunque son comunes, los registros contienen información crítica sobre las operaciones del sistema y son una fuente valiosa de información de depuración y solución de problemas. Los registros se utilizan con frecuencia para identificar y realizar un seguimiento de la actividad maliciosa, o simplemente para realizar un seguimiento de la actividad del usuario para proporcionar inteligencia comercial.

En una publicación de blog anterior, Logging with Grafana Loki and MinIO , brindamos una descripción general de los componentes de Loki y su arquitectura general. Piense en Loki para registros como análogo a Prometheus para métricas. Loki es liviano y rentable porque solo indexa y consulta metadatos. Los agentes de Promtail recopilan, etiquetan y transforman registros antes de enviarlos a Loki. Luego, Loki indexa los metadatos y agrupa las entradas en secuencias que se indexan con etiquetas. Luego, Grafana se usa para visualizar y consultar información de registro de Loki. A partir de la versión 2.0, Loki almacena datos en un backend de almacenamiento de un solo objeto, como MinIO. Mientras que la publicación de blog anterior explicaba las ventajas de guardar datos de Loki en MinIO, esta publicación de blog es un tutorial que le enseña cómo hacerlo.

Primero, le enseñaremos cómo implementar Loki y MinIO usando contenedores Docker, seguido de instrucciones sobre cómo instalar desde la fuente.

Aprende Loki y domina MinIO usando contenedores Docker

Construimos una demostración utilizando contenedores Docker, algunas secuencias de comandos y un repositorio Git. Comenzamos con el repositorio de Grafana Loki y agregamos la configuración yaml y los contenedores para MinIO y un script para crear y exponer un depósito de MinIO para los datos de Loki. Los siguientes pasos darán como resultado que estas cinco imágenes se ejecuten localmente en contenedores Docker:

• Loki
• Promtail
• Grafana
• E/S mínima
• Crear cubos

Los primeros tres obviamente son necesarios para Loki, Promtail y Grafana. Ya estaban disponibles en Grafana bajo el repositorio de Loki (hay un breve video explicativo ). MinIO es un almacenamiento de objetos para Loki, y el contenedor final ejecutará un script que crea depósitos como objetivos de Loki.

Loki se configuró para guardar datos de registro en MinIO usando loki.yaml . De particular importancia es la sección:

 storage_config: boltdb_shipper: active_index_directory: /loki/index cache_location: /loki/index_cache resync_interval: 5s shared_store: s3 aws: s3: http://minioadmin:minioadmin@minio.:9000/loki s3forcepathstyle: true

Tenga en cuenta el punto en la dirección S3 para MinIO. Se utiliza porque no es necesario especificar la región de AWS.

Creamos un entorno Docker usando el archivo docker-compose.yaml . Configuraremos contenedores, volúmenes, puertos, redes y proporcionaremos comandos de inicio.

Para que la imagen loki se ejecute como un contenedor con acceso a la configuración de Loki a través de volúmenes:

 services: loki: image: grafana/loki:latest volumes: - <your-local-path>/loki/production:/home/loki/production ports: - "3100:3100" command: -config.file=/home/loki/production/loki.yaml networks: - loki

La primera configuración que deberá realizar es asegurarse de que su carpeta local de production se comparte con el contenedor. Edite la sección volumes de su docker-compose.yaml para hacer referencia a la carpeta local en el sistema host donde descargó la carpeta production . Estamos asignando la ruta del host a la ruta del contenedor para leer loki.yaml .

En docker-compose.yaml , también definimos una red y exponemos los puertos del contenedor que ejecuta el servidor MinIO. En este caso, los puertos 9000 y 9001 estarán expuestos a su máquina local para que pueda acceder al servidor MinIO con un navegador.

 Console UI: minio: image: minio/minio:latest ports: - "9000:9000" - "9001:9001" networks: - loki command: server ~ --address ':9000' --console-address ':9001'

Configuramos la red con todos los contenedores compartiendo una red loki . Cada contenedor puede hacer ping a los demás y usar sus API. No utilice direcciones IP fijas para sus contenedores. Para hacerlo más fácil, hemos configurado loki y minio en nuestro entorno para que se resuelvan en el contenedor adecuado. Por ejemplo:

 http://minio:9000 for MinIO http://loki:3100 for Loki http://loki:3000 for Grafana

La siguiente acción que realiza docker-compose.yaml es ejecutar MinIO Client (mc) en un contenedor para configurar MinIO Server, crear el depósito de destino para los datos de Loki y configurar la política de acceso como public según sea necesario.

 createbuckets: image: minio/mc networks: - loki depends_on: - minio entrypoint: > /bin/sh -c " /usr/bin/mc config host add myminio http://minio:9000 minioadmin minioadmin; /usr/bin/mc rm -r --force myminio/loki; /usr/bin/mc mb myminio/loki; /usr/bin/mc policy set public myminio/loki; exit 0; "

Promtail, un pequeño programa Go, se utiliza para rastrear o recopilar los archivos de registro distribuidos y entregarlos a Loki. Para esta demostración, Promtail se implementa en su contenedor con un archivo de configuración que extrae el directorio /var/log. No se requieren cambios para ejecutar esta demostración y hacer que procese los archivos de registro en esa ubicación: /var/log.

Al final de este tutorial, cubriremos cómo hacer que Promtail raspe otras ubicaciones en el sistema en busca de archivos de registro.

Pasos

Ahora que comprende cómo configurar Loki, Promtail y su entorno Docker, siga estos pasos para configurar y ejecutar el entorno de demostración. Los siguientes pasos usan docker-compose.yaml , loki.yaml y la configuración predeterminada de Promtail para demostrar cómo funciona Loki con MinIO. Después de descargar nuestros archivos, edítelos para su entorno.

Clona este repositorio https://github.com/cniackz/loki :

git clone https://github.com/cniackz/loki.git minio-loki-tutorial

Cambie el directorio a su carpeta production local:

https://github.com/cniackz/loki/tree/main/producción

 cd <your-local-path>/minio-loki-tutorial/production Edit docker-compose.yaml to reference your local home directory If necessary, edit promtail.yaml

Cree su entorno Docker local:

docker-compose build --no-cache

Inicie contenedores Docker locales:

docker-compose up -d

Para confirmar que los datos de Loki se están guardando en MinIO, inicie sesión en MinIO Console en http://localhost:9001 o http://minio:9001 . Este tutorial utiliza las siguientes credenciales:

 user: minioadmin password: minioadmin 

Después de iniciar sesión, haga clic en Cubos. Debería ver que se ha creado el depósito de Loki.

En el lado derecho, haga clic en Examinar para ver el contenido del depósito recién creado. Deberías ver el directorio fake debajo de loki . Aquí es donde Loki guardará los datos.

Haga clic en su nombre para abrir el directorio fake . Loki mantiene los registros en la memoria durante un intervalo configurado y luego los escribe en el almacenamiento de objetos. El valor predeterminado es un intervalo de 5 minutos, así que espere 5 minutos para que los datos aparezcan en su depósito.

En este punto, Promtail está enviando registros a Loki y Loki está guardando datos en MinIO. Ahora, configuremos Grafana para ver los registros de Loki. Grafana 6.0 y superior incluyen soporte integrado para Loki. Grafana 6.3 y superior incluye soporte para la funcionalidad LogQL .

Inicie sesión en Grafana en http://loki:3000 (las credenciales predeterminadas son admin:admin).

En Grafana, haga clic en el icono de la rueda dentada en la barra lateral izquierda para ir a Configuración y luego a Fuentes de datos. Haga clic en el botón grande Agregar fuente de datos y luego seleccione Loki.

Edite el campo de URL http para que sea para nuestro servidor Loki que se ejecuta localmente usando el mapeo de puertos de Docker: http://loki:3100 .

Luego haga clic en Guardar y probar.

Para ver los registros inmediatamente, haga clic en explorar. También puede ver los registros haciendo clic en Explorar en la barra lateral izquierda. Independientemente de cómo explore, seleccione la fuente de datos de Loki en el menú desplegable de la parte superior izquierda y, a continuación, elija un flujo de registro con el botón Etiquetas de registro.

Puede escribir una consulta de LogQL y hacer clic en Ejecutar consulta. Sin embargo, si aún no conoce LogQL, puede usar la GUI para seleccionar un registro y consultar parámetros.

Para ver rápidamente los registros que están en Loki, haga clic en Navegador de registros, luego en 1. Select labels to search in y elija job , luego en 2. Find values for the selected labels , haga clic en el nombre de su trabajo (desde promtail-local-config.yaml ). En este caso, he hecho clic en varlogs . Luego haga clic en el botón Mostrar registros.

Puede seleccionar el intervalo de tiempo y establecer el intervalo de actualización de la consulta en la parte superior derecha de la ventana del navegador.

Para ver más detalles de los registros, desplácese hacia abajo y haga clic en una de las entradas del registro, le proporcionará información adicional relacionada con la entrada del registro.

Una característica realmente poderosa es la capacidad de filtrar o ver estadísticas sobre labels y fields directamente desde los detalles del registro haciendo clic en los íconos. Esto simplifica la resolución de problemas, ya que facilita la búsqueda de errores recurrentes y la alternancia entre los términos de búsqueda.

Ampliación de la demostración

Una vez que se ejecuta la demostración, el siguiente paso es hacer que Promtail extraiga un conjunto diferente de archivos que podrían ser más interesantes para su caso de uso. Para hacer esto, necesitamos que Promtail se ejecute usando un archivo de configuración que podemos editar. Una forma de lograr esto es usando volúmenes en Docker.

Edite el archivo docker-compose.yaml para crear 2 nuevos volúmenes accesibles desde el contenedor Promtail. El primero proporciona acceso al directorio en el sistema host donde se creará el nuevo archivo de configuración. El segundo proporciona acceso a un directorio que contendrá los archivos de registro de interés. Además, se iniciará Promtail haciendo referencia al nuevo archivo de configuración, que hemos llamado promtail-local-config.yaml :

 version: "3" networks: loki: services: loki: image: grafana/loki:latest volumes: - <your-local-path>/loki/minio-loki-tutorial/production:/home/loki/production ports: - "3100:3100" command: -config.file=/home/loki/production/loki.yaml networks: - loki promtail: image: grafana/promtail:2.4.2 volumes: - /var/log:/var/log -- <your-local-path>/loki/minio-loki-tutorial/production:/home/loki/production -- <your-local-path>/access_logs:/home/loki/access_logs command: -config.file=/home/loki/production/promtail-local-config.yaml networks: - loki grafana: image: grafana/grafana:latest ports: - "3000:3000" networks: - loki minio: image: minio/minio:latest ports: - "9000:9000" - "9001:9001" networks: - loki command: server ~ --address ':9000' --console-address ':9001' createbuckets: image: minio/mc networks: - loki depends_on: - minio entrypoint: > /bin/sh -c " /usr/bin/mc config host add myminio http://minio:9000 minioadmin minioadmin; /usr/bin/mc rm -r --force myminio/loki; /usr/bin/mc mb myminio/loki; /usr/bin/mc policy set public myminio/loki; exit 0; "

Hay mucho más que puede hacer con los datos de registro en Grafana. Para empezar, puede instalar promtail en más lugares para seguir más registros a Loki. Copie el ejecutable y promtail-local-config.yaml a otras máquinas/instancias/contenedores, edite la configuración como se describe en Configuración de Promtail y ejecútelo.

Ahora necesitamos crear el archivo de configuración de Promtail, promtail-local-config.yaml para enviar los registros del sistema local a Loki. Descargue y edite un archivo de configuración de muestra de Grafana. La sección en la que debe concentrarse es scrape_configs porque aquí es donde se le dice a promtail qué registros extraer, cómo formatearlos y dónde enviarlos. Consulte Obtener registros en Loki para obtener más información sobre la configuración de promtail.

La sección scrape_configs incluye lo siguiente:

• job_name: esto diferencia los registros recopilados de otros grupos de registros.
• objetivos: opcional para static_configs . Sin embargo, a menudo se define porque en versiones anteriores de Promtail no era opcional. Este fue un artefacto del uso directo del código de descubrimiento del servicio Prometheus, que requería esta entrada.
• etiquetas: etiqueta estática que se aplica a cada línea de registro raspada por esta definición. Buenos ejemplos incluyen el nombre del entorno, el nombre del trabajo o el nombre de la aplicación.
• ruta: la ruta a donde se almacenan los registros que Loki va a consumir.

 server: http_listen_port: 9080 grpc_listen_port: 0 positions: filename: /tmp/positions.yaml clients: - url: http://loki:3100/loki/api/v1/push scrape_configs: - job_name: apache static_configs: - targets: - localhost labels: job: access_logs __path__: /home/loki/access_logs/*log

Es importante comprender las diferentes opciones de configuración para raspar en Promtail, y Grafana proporciona muchos detalles .

Puede ser útil consultar la referencia completa de configuración de promtail para ver todas las capacidades de la aplicación.

Finalmente, coloque algunos registros de acceso al servidor web Apache en el directorio especificado en el archivo docker-compose.yaml en el sistema host. Estos son los registros que Promtail ingerirá y enviará a Loki para su procesamiento:

-- <your-local-path>/access_logs:/home/loki/access_logs

Una vez que se hayan realizado las ediciones y se hayan colocado los registros de acceso de muestra de Apache, baje los contenedores y vuelva a subirlos con docker compose:

 docker-compose down docker-compose up -d

Promtail cargará posteriormente los nuevos archivos de registro de acceso de Apache y los pondrá a disposición de Loki.

El entorno que hemos creado en este tutorial es útil para comenzar con Loki, pero no está listo para la producción. Los siguientes pasos serían dejar Docker por Kubernetes y usar MinIO distribuido en lugar de una sola instancia. Eventualmente, los datos de Loki se vuelven lo suficientemente grandes como para beneficiarse de una base de datos externa para búsquedas de índice rápidas. Consulte Escalabilidad - Escalamiento con Grafana Loki para obtener más información.

Conclusión

La pila de observabilidad de Grafana, Prometheus y AlertManager obtuvo una poderosa adición con Loki (por cierto, también tenemos un tutorial para Grafana, Prometheus y AlertManager en MinIO ). Los sistemas distribuidos, especialmente cuando están en contenedores y orquestados por Kubernetes, tienen muchos registros para sus aplicaciones y microservicios. Loki combinado con MinIO es una forma rentable de recopilar, almacenar y consultar registros.

Si tiene alguna pregunta, envíenos un correo electrónico a hello@min.io , o únase al canal slack de MinIO y pregunte.