Comment déployer Grafana Loki et enregistrer des données sur MinIO à l'aide de conteneurs Docker ou directement depuis la source

Grafana Loki est un système d'agrégation de journaux qui stocke et interroge les journaux des applications et de l'infrastructure. Bien que courants, les journaux contiennent des informations critiques sur les opérations du système et constituent une source précieuse d'informations de débogage et de dépannage. Les journaux sont fréquemment utilisés pour identifier et suivre les activités malveillantes, ou simplement pour suivre l'activité des utilisateurs afin de fournir des renseignements commerciaux.

Dans un article de blog précédent, Journalisation avec Grafana Loki et MinIO , nous avons fourni un aperçu des composants de Loki et de leur architecture globale. Considérez Loki pour les journaux comme analogue à Prometheus pour les métriques. Loki est léger et rentable car il indexe et interroge uniquement les métadonnées. Les agents Promtail collectent, étiquettent et transforment les journaux avant de les envoyer à Loki. Ensuite, Loki indexe les métadonnées et regroupe les entrées dans des flux indexés avec des étiquettes. Grafana est ensuite utilisé pour visualiser et interroger les informations de journal de Loki. Depuis la version 2.0, Loki stocke les données dans un seul backend de stockage d'objets, tel que MinIO. Alors que le précédent article de blog expliquait les avantages de l'enregistrement des données Loki sur MinIO, cet article de blog est un didacticiel qui vous apprend comment.

Tout d'abord, nous vous apprendrons à déployer Loki et MinIO à l'aide de conteneurs Docker, suivis d'instructions sur l'installation à partir de la source.

Apprendre Loki et maîtriser MinIO à l'aide de conteneurs Docker

Nous avons créé une démo à l'aide de conteneurs Docker, de scripts et d'un référentiel Git. Nous avons commencé avec le référentiel Grafana Loki, et ajouté la configuration yaml et les conteneurs pour MinIO et un script pour créer et exposer un compartiment MinIO pour les données Loki. Les étapes suivantes entraîneront l'exécution locale de ces cinq images dans des conteneurs Docker :

• Loki
• Promtail
• Grafana
• MinIO
• Créer des compartiments

Les trois premiers sont évidemment nécessaires pour Loki, Promtail et Grafana. Ils étaient déjà disponibles auprès de Grafana sous le référentiel Loki (il y a une courte vidéo explicative ). MinIO est un stockage d'objets pour Loki, et le conteneur final exécutera un script qui crée des compartiments en tant que cibles Loki.

Loki a été configuré pour enregistrer les données du journal sur MinIO en utilisant loki.yaml . La section :

 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

Notez le point dans l'adresse S3 pour MinIO. Ceci est utilisé car il n'est pas nécessaire de spécifier la région AWS.

Nous créons un environnement Docker à l'aide du fichier docker-compose.yaml . Nous configurerons les conteneurs, les volumes, les ports, les réseaux et fournirons des commandes de démarrage.

Pour que l'image loki s'exécute en tant que conteneur avec accès à la configuration Loki via des volumes :

 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 première configuration que vous devrez effectuer consiste à vous assurer que votre dossier local de production est partagé avec le conteneur. Veuillez modifier la section volumes de votre docker-compose.yaml pour faire référence au dossier local sur le système hôte où vous avez téléchargé le dossier production . Nous mappons le chemin de l'hôte au chemin du conteneur afin de lire loki.yaml .

Dans docker-compose.yaml , nous définissons également un réseau et exposons les ports du conteneur exécutant le serveur MinIO. Dans ce cas, les ports 9000 et 9001 seront exposés à votre machine locale afin que vous puissiez accéder au serveur MinIO avec un navigateur.

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

Nous configurons le réseau avec tous les conteneurs partageant un réseau loki . Chaque conteneur peut envoyer un ping aux autres et utiliser leurs API. N'utilisez pas d'adresses IP fixes pour vos conteneurs. Pour vous faciliter la tâche, nous avons configuré loki et minio dans notre environnement pour qu'ils se résolvent dans le conteneur approprié. Par exemple:

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

La prochaine action entreprise par docker-compose.yaml consiste à exécuter MinIO Client (mc) dans un conteneur pour configurer MinIO Server, créer le compartiment de destination pour les données Loki et définir la politique d'accès sur public selon les besoins.

 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 petit programme Go, est utilisé pour suivre ou collecter les fichiers journaux distribués et les livrer à Loki. Pour cette démo, Promtail est déployé dans son conteneur avec un fichier de configuration qui scrape le répertoire /var/log. Aucune modification n'est requise pour exécuter cette démo et lui faire traiter les fichiers journaux à cet emplacement - /var/log.

À la fin de ce didacticiel, nous expliquerons comment faire en sorte que Promtail récupère d'autres emplacements du système pour les fichiers journaux.

Pas

Maintenant que vous comprenez comment configurer Loki, Promtail et votre environnement Docker, veuillez suivre ces étapes pour configurer et exécuter l'environnement de démonstration. Les étapes suivantes utilisent docker-compose.yaml , loki.yaml et la configuration Promtail par défaut pour montrer comment Loki fonctionne avec MinIO. Après avoir téléchargé nos fichiers, modifiez-les pour votre environnement.

Clonez ce dépôt https://github.com/cniackz/loki :

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

Remplacez le répertoire par votre dossier production local :

https://github.com/cniackz/loki/tree/main/production

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

Créez votre environnement Docker local :

docker-compose build --no-cache

Lancez des conteneurs Docker locaux :

docker-compose up -d

Pour confirmer que les données Loki sont enregistrées sur MinIO, connectez-vous à la console MinIO à l'adresse http://localhost:9001 ou http://minio:9001 . Ce tutoriel utilise les identifiants suivants :

 user: minioadmin password: minioadmin 

Une fois connecté, cliquez sur Buckets. Vous devriez voir que le compartiment Loki a été créé.

Sur le côté droit, cliquez sur Parcourir pour voir le contenu du bucket nouvellement créé. Vous devriez voir le fake répertoire sous loki . C'est là que Loki enregistrera les données.

Cliquez sur son nom pour ouvrir le fake répertoire. Loki conserve les journaux en mémoire pendant un intervalle configuré, puis les écrit dans le stockage d'objets. La valeur par défaut est un intervalle de 5 minutes. Veuillez donc attendre 5 minutes pour que les données apparaissent dans votre compartiment.

À ce stade, Promtail envoie des journaux à Loki et Loki enregistre les données dans MinIO. Maintenant, configurons Grafana pour afficher les journaux Loki. Grafana 6.0 et versions ultérieures incluent la prise en charge intégrée de Loki. Grafana 6.3 et supérieur inclut la prise en charge de la fonctionnalité LogQL .

Connectez-vous à Grafana à http://loki:3000 (les informations d'identification par défaut sont admin:admin).

Dans Grafana, cliquez sur l'icône en forme de rouage dans la barre latérale gauche pour accéder à Configuration, puis à Sources de données. Cliquez sur le gros bouton Ajouter une source de données, puis sélectionnez Loki.

Modifiez le champ URL http pour que notre serveur Loki s'exécute localement à l'aide du mappage de port Docker : http://loki:3100 .

Cliquez ensuite sur Enregistrer et tester.

Pour afficher les journaux immédiatement, cliquez sur explorer. Vous pouvez également afficher les journaux en cliquant sur Explorer dans la barre latérale gauche. Quelle que soit la manière dont vous explorez, sélectionnez la source de données Loki dans la liste déroulante en haut à gauche, puis choisissez un flux de journal à l'aide du bouton Log Labels.

Vous pouvez taper une requête LogQL et cliquer sur Exécuter la requête. Cependant, si vous ne connaissez pas encore LogQL, vous pouvez utiliser l'interface graphique pour sélectionner un journal et des paramètres de requête.

Pour voir rapidement les journaux qui se trouvent dans Loki, cliquez sur Log browser, puis sous 1. Select labels to search in and choose job , puis sous 2. Find values for the selected labels click the name of your job (from promtail-local-config.yaml ). Dans ce cas, j'ai cliqué sur varlogs . Cliquez ensuite sur le bouton Afficher les journaux.

Vous pouvez sélectionner la plage de temps et définir l'intervalle d'actualisation de la requête en haut à droite de la fenêtre du navigateur.

Pour voir plus de détails sur les journaux, faites défiler vers le bas et cliquez sur l'une des entrées du journal, cela fournira des informations supplémentaires relatives à l'entrée du journal.

Une fonctionnalité vraiment puissante est la possibilité de filtrer ou de voir des statistiques sur labels et fields directement à partir des détails du journal en cliquant sur les icônes. Cela simplifie le dépannage car il est plus facile de rechercher les erreurs récurrentes et de basculer entre les termes de recherche.

Extension de la démo

Une fois la démo en cours d'exécution, l'étape suivante consiste à demander à Promtail de récupérer un ensemble de fichiers différent qui pourrait être plus intéressant pour votre cas d'utilisation. Pour ce faire, nous avons besoin que Promtail s'exécute à l'aide d'un fichier de configuration que nous pouvons modifier. Une façon d'y parvenir consiste à utiliser des volumes dans Docker.

Modifiez le fichier docker-compose.yaml pour créer 2 nouveaux volumes accessibles depuis le conteneur Promtail. Le premier donne accès au répertoire sur le système hôte où le nouveau fichier de configuration sera créé. Le second donne accès à un répertoire qui contiendra les fichiers journaux d'intérêt. De plus, Promtail sera lancé en faisant référence au nouveau fichier de configuration, que nous avons appelé 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; "

Vous pouvez faire beaucoup plus avec les données de journal dans Grafana. Pour commencer, vous pouvez installer promtail à plusieurs endroits pour envoyer plus de journaux à Loki. Copiez l'exécutable et promtail-local-config.yaml sur d'autres machines/instances/conteneurs, modifiez la configuration comme décrit dans Configuration de Promtail et exécutez-le.

Nous devons maintenant créer le fichier de configuration Promtail, promtail-local-config.yaml pour envoyer les journaux système locaux à Loki. Téléchargez et modifiez un exemple de fichier de configuration de Grafana. La section sur laquelle se concentrer est scrape_configs car c'est là que promtail est informé des journaux à extraire, comment les formater et où les envoyer. Veuillez consulter Obtenir les journaux dans Loki pour plus d'informations sur la configuration de promtail.

La section scrape_configs inclut les éléments suivants :

• job_name - Cela différencie les journaux collectés des autres groupes de journaux.
• cibles - Facultatif pour static_configs . Cependant, est souvent défini car dans les anciennes versions de Promtail, il n'était pas facultatif. Il s'agissait d'un artefact résultant de l'utilisation directe du code de découverte du service Prometheus, qui nécessitait cette entrée.
• labels - Libellé statique à appliquer à chaque ligne de journal récupérée par cette définition. De bons exemples incluent le nom de l'environnement, le nom de la tâche ou le nom de l'application.
• chemin - Le chemin d'accès où les journaux que Loki doit consommer sont stockés.

 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

Il est important de comprendre les différentes options de configuration pour le scraping dans Promtail, et Grafana fournit de nombreux détails .

Il peut être utile de consulter la référence de configuration complète de promtail pour voir toutes les capacités de l'application.

Enfin, placez des journaux d'accès au serveur Web Apache dans le répertoire spécifié dans le fichier docker-compose.yaml sur le système hôte. Voici les journaux que Promtail ingérera et enverra à Loki pour traitement :

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

Une fois les modifications effectuées et les exemples de journaux d'accès Apache mis en place, arrêtez les conteneurs et sauvegardez-les avec docker compose :

 docker-compose down docker-compose up -d

Promtail chargera ensuite les nouveaux fichiers journaux d'accès Apache et les mettra à la disposition de Loki.

L'environnement que nous avons créé dans ce didacticiel est utile pour démarrer avec Loki, mais il n'est pas prêt pour la production. Les prochaines étapes seraient de quitter Docker pour Kubernetes et d'utiliser MinIO distribué au lieu d'une seule instance. Finalement, les données de Loki deviennent suffisamment volumineuses pour bénéficier d'une base de données externe pour des recherches d'index rapides. Veuillez consulter Évolutivité - Évolutivité avec Grafana Loki pour plus d'informations.

Conclusion

La pile d'observabilité de Grafana, Prometheus et AlertManager a gagné un ajout puissant avec Loki (BTW, nous avons également un tutoriel pour Grafana, Prometheus et AlertManager sur MinIO ). Les systèmes distribués, en particulier lorsqu'ils sont conteneurisés et orchestrés par Kubernetes, disposent de nombreux journaux pour leurs applications et microservices. Loki combiné avec MinIO est un moyen rentable de collecter, stocker et interroger les journaux.

Si vous avez des questions, veuillez nous envoyer un e-mail à [email protected] , ou rejoignez le canal slack MinIO et posez des questions.