TOC

Comment centraliser vos journaux Docker avec Fluentd et ElasticSearch sur Ubuntu 16.04

Un article de Fluentd

introduction

Au fur et à mesure que vous lancez les conteneurs Docker dans la production, vous constaterez un besoin croissant de conserver les journaux quelque part moins éphémères que les conteneurs. Docker est fourni avec un pilote de journalisation natif pour Fluentd, ce qui facilite la collecte de ces journaux et leur acheminement ailleurs, comme Elasticsearch, ce qui vous permet d’analyser les données.

Fluentd est un collecteur de données open source conçu pour unifier votre infrastructure de journalisation. Il réunit des ingénieurs d’exploitation, des ingénieurs d’application et des ingénieurs de données en simplifiant et en adaptant la collecte et le stockage des journaux.

Fluentd possède quatre caractéristiques clés qui permettent de construire des pipelines de journalisation propres et fiables:

  • * Enregistrement unifié avec JSON: * Fluentd tente de structurer les données au format JSON autant que possible. Cela permet à Fluentd d’unifier toutes les facettes des données de journal de traitement: collecte, filtrage, mise en mémoire tampon et sortie des journaux sur plusieurs sources et destinations. Le traitement de données en aval est beaucoup plus facile avec JSON, car il a suffisamment de structure pour être accessible sans imposer de schémas rigides.

  • * Architecture pluggable: * Fluentd a un système de plugin flexible qui permet à la communauté d’étendre ses fonctionnalités. Plus de 300 plugins fournis par la communauté connectent des dizaines de sources de données à des dizaines de sorties de données, manipulant les données en fonction des besoins. En utilisant des plugins, vous pouvez immédiatement utiliser vos journaux au mieux.

  • * Ressources minimales requises: * Un collecteur de données doit être léger afin de fonctionner aisément sur une machine occupée. Fluentd est écrit en C et Ruby et nécessite un minimum de ressources système. L’instance vanilla fonctionne sur 30 à 40 Mo de mémoire et peut traiter 13 000 événements / seconde / cœur.

  • * Fiabilité intégrée: * La perte de données ne devrait jamais se produire. Fluentd prend en charge la mise en mémoire tampon et la mise en mémoire tampon des fichiers pour éviter la perte de données entre nœuds. Fluentd prend également en charge le basculement robuste et peut être configuré pour la haute disponibilité.

Dans ce didacticiel, vous apprendrez à installer Fluentd et à le configurer pour collecter les journaux à partir de conteneurs Docker. Vous transmettez ensuite les données à un autre conteneur exécutant Elasticsearch sur le même serveur Ubuntu 16.04 et interrogez les journaux.

Conditions préalables

Pour compléter ce tutoriel, vous aurez besoin des éléments suivants:

Étape 1 - Installation de Fluentd

Le moyen le plus courant d’installer http://www.fluentd.org [Fluentd] consiste à utiliser le paquetage + td-agent +. https://www.treasuredata.com [Treasure Data], l’auteur de Fluentd, fournit à Fluentd un environnement d’exécution Ruby autonome, de sorte que vous n’avez pas besoin de configurer un environnement Ruby pour exécuter Fluentd. Ils fournissent également un script pour obtenir le dernier paquet + td-agent qui configure un référentiel et installe le paquet pour vous.

Connectez-vous à votre serveur en tant qu’utilisateur non root:

ssh sammy@

Puis installez + td-agent en utilisant le script fourni par Treasure Data. Tout d’abord, téléchargez le script:

\curl -L http://toolbelt.treasuredata.com/sh/install-ubuntu-xenial-td-agent2.sh -o install-td-agent.sh

Si vous souhaitez auditer le script, ouvrez-le avec votre éditeur de texte:

nano install-td-agent.sh

Une fois que vous êtes familiarisé avec le contenu du script, exécutez-le pour installer + td-agent:

sh install-td-agent.sh

Une fois l’installation terminée, lancez + td-agent:

sudo systemctl start td-agent

Vérifiez les journaux pour vous assurer qu’il a été installé avec succès:

tail /var/log/td-agent/td-agent.log

Vous verrez une sortie semblable à celle-ci:

Output    port 8888
 </source>
 <source>
   @type debug_agent
   bind 127.0.0.1
   port 24230
 </source>
</ROOT>
2016-12-02 19:45:31 +0000 [info]: listening fluent socket on 0.0.0.0:24224
2016-12-02 19:45:31 +0000 [info]: listening dRuby uri="druby://127.0.0.1:24230" object="Engine"

Ensuite, installez le plugin Elasticsearch pour Fluentd en utilisant la commande + td-agent-gem +:

sudo td-agent-gem install fluent-plugin-elasticsearch

Fluentd est maintenant opérationnel avec la configuration par défaut. Nous allons ensuite configurer Fluentd pour pouvoir écouter les événements Docker et les transmettre à une instance Elasticsearch.

Étape 2 - Configuration de Fluentd

Fluentd a besoin de savoir où recueillir les informations et où les transmettre. Vous définissez ces règles dans le fichier de configuration Fluentd situé dans + / etc / td-agent / td-agent.conf +.

Ouvrez ce fichier dans votre éditeur de texte:

sudo nano /etc/td-agent/td-agent.conf

Supprimer le contenu du fichier. Vous allez écrire vos propres règles à partir de zéro dans ce tutoriel.

Vous définissez les sources d’information dans la section + source +. Ajoutez cette configuration au fichier:

/etc/td-agent/td-agent.conf

<source>
 @type
 port  24224
</source>

Cela définit la source comme + forward +, qui est le protocole Fluentd qui s’exécute sur TCP et qui sera utilisé par Docker lors de l’envoi des journaux à Fluentd.

Lorsque les enregistrements de journal arriveront, ils auront des champs associés supplémentaires, y compris + time,` + tag`, + message,` + container_id` et quelques autres. Vous utilisez les informations du champ + tag + pour décider où Fluentd doit envoyer ces données. Ceci s’appelle data routing.

Pour le configurer, définissez une section + match + qui correspond au contenu du champ + tag + et acheminez-la de manière appropriée. Ajoutez cette configuration au fichier:

/etc/td-agent/td-agent.conf

<match >
 @type
 logstash_format true
 host 127.0.0.1
 port 9200
 flush_interval
</match>

Cette règle indique que chaque enregistrement avec une balise précédée de + docker. + Sera envoyé à Elasticsearch, qui s’exécute sur + 127.0.0.1 + sur le port + 9200 +. Le + flush_interval + indique à Fluentd combien de fois il devrait enregistrer dans Elasticsearch.

Une fois que vous avez enregistré le nouveau fichier de configuration, redémarrez le service + td-agent + afin que les modifications soient appliquées:

sudo systemctl restart td-agent

Maintenant que Fluentd est configuré correctement pour nos besoins, installons Elasticsearch pour capturer nos journaux à partir de Fluentd.

Étape 3 - Démarrage du conteneur Elasticsearch

Nous utiliserons Docker pour exécuter notre instance d’Elasticsearch, car c’est plus rapide que de configurer nous-mêmes. Nous allons utiliser l’image Elasticsearch Docker pour créer notre conteneur. Pour utiliser cette image, augmentez la valeur de + max_map_count + sur votre hôte Docker comme suit:

sudo sysctl -w vm.max_map_count=262144

Exécutez ensuite cette commande pour télécharger l’image Elasticsearch et démarrez le conteneur:

docker run -d -p 9200:9200 -p 9300:9300 elasticsearch

L’image sera téléchargée et le conteneur Elasticsearch démarrera. Assurez-vous que le conteneur fonctionne correctement en vérifiant les processus Docker et en recherchant le conteneur:

docker ps

Vous devriez voir la sortie comme ceci:

OutputCONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS              PORTS                                            NAMES
76e96943491f               "/docker-entrypoint.s"   About a minute ago   Up 51 seconds

Si le conteneur n’est pas répertorié, redémarrez-le sans le commutateur + -d + pour qu’il s’exécute au premier plan. Exécutez la commande + docker run -p 9200: 9200 -p 9300: 9300 elasticsearch + et recherchez les éventuels messages d’erreur spécifiques. Les erreurs les plus probables que vous rencontrerez sont le manque de mémoire système ou le fait que la valeur + max_map_count + sur votre hôte Docker est trop basse. Vérifiez toutes les étapes de ce didacticiel pour vous assurer de ne rien manquer et réessayez.

Maintenant que Elasticsearch est exécuté dans le conteneur, générons des journaux et ingérons-les dans Fluentd.

Étape 4 - Générer des journaux à partir d’un conteneur Docker

Avec Docker, vous pouvez traiter les journaux comme un flux de données via les interfaces de sortie standard (+ STDOUT +) et d’erreur (+ STDERR +). Lorsque vous démarrez une application Docker, demandez simplement à Docker de vider les journaux à l’aide du pilote de journalisation natif Fluentd. Le service Fluentd recevra ensuite les journaux et les enverra à Elasticsearch.

Testez cela en lançant une commande Bash dans un conteneur Docker comme ceci:

docker run  ubuntu /bin/echo 'Hello world'

Ceci imprimera le message + Hello world + sur la sortie standard, mais il sera également capturé par le pilote Docker Fluentd et envoyé au service Fluentd que vous avez configuré précédemment. Après environ cinq secondes, les enregistrements seront vidés à Elasticsearch. Vous avez configuré cet intervalle dans la section + match + de votre fichier de configuration Fluentd.

Cela suffit pour obtenir les journaux sur Elasticsearch, mais vous voudrez peut-être consulter la page official pour plus de détails sur les options disponibles. peut utiliser avec Docker pour gérer le pilote Fluentd.

Enfin, confirmons que Elasticsearch reçoit les événements. Utilisez + curl + pour envoyer une requête à Elasticsearch:

curl -XGET 'http://localhost:9200/_all/_search?q=*'

La sortie contiendra des événements qui ressemblent à ceci:

{"took":2,"timed_out":false,"_shards":{"total":1,"successful":1,"failed":0},"hits":{"total":1,"max_score":1.0,"hits":[{"_index":"logstash-2016.12.02","_type":"fluentd","_id":"AVQwUi-UHBhoWtOFQKVx","_score":1.0,"_source":{"container_id":"d16af3ad3f0d361a1764e9a63c6de92d8d083dcc502cd904155e217f0297e525","container_name":"","source":"stdout","log":"","@timestamp":"2016-12-02T14:59:26-06:00"}}]}}

Vous pouvez avoir plusieurs événements enregistrés en fonction de votre configuration. Un seul événement devrait commencer par + {" prenant ": + et se terminer par un horodatage. Il contiendra également des informations supplémentaires associées au conteneur source. Comme le montre cette sortie, Elasticsearch reçoit des données de notre conteneur Docker.

Conclusion

La collecte de journaux à partir de conteneurs Docker n’est qu’un des moyens d’utiliser Fluentd. De nombreux utilisateurs ont recours à Fluentd pour créer un pipeline de journalisation qui effectue à la fois une recherche de journal en temps réel et un stockage à long terme. Cette architecture tire parti de la capacité de Fluentd à copier des flux de données et à les exporter vers plusieurs systèmes de stockage. Par exemple, vous pouvez utiliser Elasticsearch pour la recherche en temps réel, mais MongoDB ou Hadoop pour les analyses par lots et le stockage à long terme.

Les applications Web génèrent de nombreux journaux. Ils sont souvent formatés de manière arbitraire et stockés sur le système de fichiers local. Cela peut présenter des problèmes pour deux raisons. Premièrement, les journaux sont difficiles à analyser par programmation, nécessitant beaucoup de larges, et ne sont donc pas très accessibles pour ceux qui souhaitent comprendre le comportement des utilisateurs par le biais d’une analyse statistique, de la révision des résultats de tests A / B ou de la détection de fraudes.

Deuxièmement, les journaux ne sont pas accessibles en temps réel car ils sont chargés en bloc dans les systèmes de stockage. Pire, si le disque du serveur est corrompu entre des chargements en bloc, les journaux sont perdus ou corrompus.

Fluentd résout ces deux problèmes en fournissant des bibliothèques de consignateurs pour différents langages de programmation avec une API cohérente. Chaque enregistreur envoie un enregistrement contenant l’horodatage, une balise et un événement au format JSON à Fluentd, comme celui présenté dans ce didacticiel. Il existe des bibliothèques logger pour Ruby, Node.js, Go, Python, Perl, PHP, Java et C ++. Cela permet aux applications de «tirer et d’oublier»; le consignateur envoie les données à Fluentd de manière asynchrone, qui les met ensuite en mémoire tampon avant de les envoyer aux systèmes dorsaux.

Fluentd et Elasticsearch permettent de réaliser de nombreuses autres tâches utiles. Vous pouvez trouver les liens suivants intéressants:

Related