So zentralisieren Sie Ihre Docker-Protokolle mit Fluentd und ElasticSearch unter Ubuntu 14.04

Ein Artikel von Fluentd

Einführung

Was ist fließend? *

Fluentd ist ein Open-Source-Datenkollektor zur Vereinheitlichung der Protokollierungsinfrastruktur. Es wurde entwickelt, um Betriebsingenieure, Anwendungstechniker und Datentechniker zusammenzubringen, indem es das Sammeln und Speichern von Protokollen einfach und skalierbar macht.

Vor Fluentd

image: https: //assets.digitalocean.com/articles/dockerlogs_fluentd/1.jpg [Unordentliche Protokollstruktur, die die Beziehungen zwischen vielen Programmen anzeigt]

Nach Fluentd

image: https://assets.digitalocean.com/articles/dockerlogs_fluentd/2.png [Fluentd sammelt Anwendungs- und Zugriffsprotokolle aus vielen Quellen und leitet sie an viele Analyse-, Archivierungs- und Metrikausgaben weiter.]

Hauptmerkmale

Fluentd verfügt über vier Hauptmerkmale, die den Bau sauberer und zuverlässiger Protokollierungsleitungen ermöglichen:

* Unified Logging mit JSON: * Fluentd versucht, Daten so weit wie möglich als JSON zu strukturieren. Auf diese Weise kann Fluentd alle Aspekte der Verarbeitung von Protokolldaten vereinheitlichen: Sammeln, Filtern, Puffern und Ausgeben von Protokollen über mehrere Quellen und Ziele hinweg. Die nachgelagerte Datenverarbeitung ist mit JSON viel einfacher, da die Struktur ausreicht, um darauf zuzugreifen, ohne starre Schemata zu erzwingen
* Steckbare Architektur: * Fluentd verfügt über ein flexibles Pluginsystem, mit dem die Community ihre Funktionalität erweitern kann. Die über 300 von der Community bereitgestellten Plugins verbinden Dutzende von Datenquellen mit Dutzenden von Datenausgängen und bearbeiten die Daten nach Bedarf. Durch die Verwendung von Plugins können Sie Ihre Protokolle sofort besser nutzen
* Erforderliche Mindestressourcen: * Ein Datensammler sollte leichtgewichtig sein, damit der Benutzer ihn bequem auf einem ausgelasteten Computer ausführen kann. Fluentd ist in einer Kombination aus C und Ruby geschrieben und benötigt nur minimale Systemressourcen. Die Vanilla-Instanz wird mit 30-40 MB Arbeitsspeicher ausgeführt und kann 13.000 Ereignisse / Sekunde / Kern verarbeiten
* Eingebaute Zuverlässigkeit: * Datenverlust sollte niemals auftreten. Fluentd unterstützt speicher- und dateibasiertes Puffern, um Datenverluste zwischen Knoten zu vermeiden. Fluentd unterstützt auch ein robustes Failover und kann für hohe Verfügbarkeit eingerichtet werden

Ziele: Sammeln zentraler Docker-Containerprotokolle mit Fluentd

Da Docker-Container in der Produktion eingeführt werden, besteht ein zunehmender Bedarf, die Protokolle von Containern an einem Ort beizubehalten, der weniger kurzlebig ist als Container.

In diesem Tutorial zeigen wir Ihnen, wie Sie Fluentd installieren und Protokolle von Docker-Containern sammeln und im Freien speichern, damit die Daten gespeichert werden können, nachdem die Container gestoppt wurden. Wir werden die Daten in einen anderen Container streamen, in dem Elasticsearch auf demselben Ubuntu 14.04-Server ausgeführt wird.

Wie in Kubernetes GitHub-Repo beschrieben, nutzt diese Architektur die Fähigkeit von Fluentd, JSON-Per zu analysieren und zu analysieren -Zeilenprotokolldateien, die vom Docker-Daemon für jeden Container erstellt wurden. Eine minimale Konfiguration finden Sie unter this recipe.

Am Ende dieses Lernprogramms werden zwei weitere Anwendungsfälle erläutert. Nachdem Sie diesen Artikel gelesen haben, sollten Sie die Grundlagen der Verwendung von Fluentd kennen.

Voraussetzungen

Stellen Sie sicher, dass Sie diese Voraussetzungen für das Lernprogramm erfüllen.

Ubuntu 14.04 Droplet
Benutzer mit sudo access

Schritt 1 - Fluentd installieren

Fluentd wird am häufigsten über das Paket "+ td-agent" bereitgestellt. Treasure Data, der ursprüngliche Autor von Fluentd, verpackt Fluentd mit einer eigenen Ruby-Laufzeit, sodass der Benutzer keinen eigenen Ruby einrichten muss, um Fluentd auszuführen.

Derzeit unterstützt + td-agent die folgenden Plattformen:

Ubuntu: Klar, präzise und zuverlässig
Debian: Keuchen und quetschen
RHEL / Centos: 5, 6 und 7
Mac OSX: 10.9 und höher

In diesem Tutorial wird davon ausgegangen, dass Sie sich auf DigitalOcean Droplet befinden und Ubuntu 14.04 LTS (Trusty) ausführen.

Installieren Sie + td-agent mit dem folgenden Befehl:

curl -L http://toolbelt.treasuredata.com/sh/install-ubuntu-trusty-td-agent2.sh | sh

Starten Sie + td-agent:

sudo /etc/init.d/td-agent start

Überprüfen Sie die Protokolle, um sicherzustellen, dass sie erfolgreich installiert wurden:

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

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   port 24230
 </source>
</ROOT>
2015-02-22 18:27:45 -0500 [info]: adding source type="forward"
2015-02-22 18:27:45 -0500 [info]: adding source type="http"
2015-02-22 18:27:45 -0500 [info]: adding source type="debug_agent"
2015-02-22 18:27:45 -0500 [info]: adding match pattern="td.*.*" type="tdlog"
2015-02-22 18:27:45 -0500 [info]: adding match pattern="debug.**" type="stdout"
2015-02-22 18:27:45 -0500 [info]: listening fluent socket on 0.0.0.0:24224
2015-02-22 18:27:45 -0500 [info]: listening dRuby uri="druby://127.0.0.1:24230" object="Engine"

_ _ * Hinweis: * Alternativ ist Fluentd als Ruby Gem erhältlich und kann mit + gem install fluentd + installiert werden. Wenn Sie KEINE Sudo-Rechte besitzen, installieren Sie Ruby (siehe https://www.digitalocean.com/community/tutorials/how-to-install-ruby-on-rails-with-rbenv-on-debian-7-wheezy) [Installieren von Ruby] hier zum Beispiel) und führen Sie Folgendes aus:

gem install fluentd --no-rdoc --no-ri

_ _

Schritt 2 - Docker installieren

Jetzt installieren wir Docker. Dieses Tutorial wurde mit Docker v1.5.0 getestet.

Fügen Sie den Schlüssel für das Docker-Repository hinzu, damit wir ein aktuelles Docker-Paket erhalten können:

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9

Fügen Sie das Repository Ihren Quellen hinzu:

sudo sh -c "echo deb https://get.docker.com/ubuntu docker main > /etc/apt/sources.list.d/docker.list"

Aktualisieren Sie Ihr System:

sudo apt-get update

Installieren Sie Docker:

sudo apt-get install lxc-docker

Stellen Sie sicher, dass Docker installiert wurde, indem Sie die Version überprüfen:

docker --version

Die Ausgabe sollte folgendermaßen aussehen:

Docker version 1.5.0, build a8a31ef

Schritt 3 - Hinzufügen eines Benutzers zur Docker-Gruppe

Docker wird als * root * ausgeführt. Fügen Sie also Ihren sudo-Benutzer zur Gruppe * docker * hinzu, um die Befehle + docker + auszuführen. Ersetzen Sie ++ durch den Benutzer Ihrer Wahl.

sudo gpasswd -a  docker

Starten Sie dann Docker neu.

sudo service docker restart

Wenn Sie derzeit als sudo-Benutzer angemeldet sind, müssen Sie sich abmelden und erneut anmelden.

Schritt 4 - Erstellen Sie das flüssige Image

In diesem Abschnitt erstellen wir das Docker-Image für den Fluentd Docker-Container. Wenn Sie mehr über Docker im Allgemeinen erfahren möchten, lesen Sie bitte https://www.digitalocean.com/community/tutorials/the-docker-ecosystem-and-introduction-to-common-components nach.

Erstellen Sie ein neues Verzeichnis für Ihre Fluentd Docker-Ressourcen und wechseln Sie in dieses Verzeichnis:

mkdir ~/fluentd-docker && cd ~/fluentd-docker

Erstellen Sie das folgende Dockerfile:

sudo nano Dockerfile

Fügen Sie Ihrer Datei genau den folgenden Inhalt hinzu. Diese Datei weist Docker an, den Docker-Container zu aktualisieren und Ruby, Fluentd und Elasticsearch zu installieren:

FROM ruby:2.2.0
MAINTAINER [email protected]
RUN apt-get update
RUN gem install fluentd -v "~>0.12.3"
RUN mkdir /etc/fluent
RUN apt-get install -y libcurl4-gnutls-dev make
RUN /usr/local/bin/gem install fluent-plugin-elasticsearch
ADD fluent.conf /etc/fluent/
ENTRYPOINT ["/usr/local/bundle/bin/fluentd", "-c", "/etc/fluent/fluent.conf"]

Sie müssen auch eine "+ fluent.conf +" - Datei im selben Verzeichnis erstellen.

sudo nano fluent.conf

Die Datei + fluent.conf + sollte so aussehen. Sie können diese Datei genau kopieren:

<source>
 type tail
 read_from_head true
 path /var/lib/docker/containers/*/*-json.log
 pos_file /var/log/fluentd-docker.pos
 time_format %Y-%m-%dT%H:%M:%S
 tag docker.*
 format json
</source>
# Using filter to add container IDs to each event
<filter docker.var.lib.docker.containers.*.*.log>
 type record_transformer
 <record>
   container_id ${tag_parts[5]}
 </record>
</filter>

<match docker.var.lib.docker.containers.*.*.log>
 type elasticsearch
 logstash_format true
 host "#{ENV['ES_PORT_9200_TCP_ADDR']}" # dynamically configured to use Docker's link feature
 port 9200
 flush_interval 5s
</match>

Der Zweck dieser Datei besteht darin, Fluentd mitzuteilen, wo sich die Protokolle für andere Docker-Container befinden.

Erstellen Sie dann Ihr Docker-Image mit dem Namen "+ fluentd-es +":

docker build -t fluentd-es .

Dies dauert einige Minuten. Überprüfen Sie, ob Sie die Bilder erfolgreich erstellt haben:

docker images

Sie sollten die Ausgabe so sehen:

REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
fluentd-es          latest              89ba1fb47b23        2 minutes ago       814.1 MB
ruby                2.2.0               51473a2975de        6 weeks ago         774.9 MB

Schritt 5 - Starten des Elasticsearch-Containers

Wechseln Sie nun zurück in Ihr Ausgangsverzeichnis oder in das bevorzugte Verzeichnis für Ihren Elasticsearch-Container:

cd ~

Laden Sie den Elasticsearch-Container herunter und starten Sie ihn. Dafür gibt es bereits einen automatisierten Build:

docker run -d -p 9200:9200 -p 9300:9300 --name es dockerfile/elasticsearch

Warten Sie, bis das Container-Image heruntergeladen und gestartet wurde.

Stellen Sie als Nächstes sicher, dass der Elasticsearch-Container ordnungsgemäß ausgeführt wird, indem Sie die Docker-Prozesse überprüfen:

docker ps

Sie sollten die Ausgabe so sehen:

CONTAINER ID        IMAGE                           COMMAND             CREATED             STATUS              PORTS                                           NAMES
c474fd99ce43        dockerfile/elasticsearch:latest   "/elasticsearch/bin/   4 minutes ago      Up 4 minutes        0.0.0.0:9200->9200/tcp, 0.0.0.0:9300->9300/tcp   es

Schritt 6 - Starten des Fluentd-to-Elasticsearch-Containers

Jetzt starten wir den Container, in dem Fluentd ausgeführt wird, sammeln die Protokolle und senden sie an Elastcisearch.

docker run -d --link es:es -v /var/lib/docker/containers:/var/lib/docker/containers fluentd-es

Im obigen Befehl verknüpft der Abschnitt "+ - link es: es " den Elasticsearch-Container mit dem Fluentd-Container. Der Teil ` -v / var / lib / docker / container: / var / lib / docker / container +` wird benötigt, um das Protokollverzeichnis des Host-Containers in den Fluentd-Container einzuhängen, damit Fluentd die Protokolldateien bei der Erstellung von Containern nachverfolgen kann .

Überprüfen Sie abschließend, ob der Container ausgeführt wird, indem Sie unsere aktiven Docker-Prozesse überprüfen:

docker ps

Dieses Mal sollten Sie sowohl den Elasticsearch-Container als auch den neuen + fluentd-es + -Container sehen:

CONTAINER ID        IMAGE                           COMMAND             CREATED             STATUS              PORTS                                           NAMES
f0d2cac81ac8        fluentd-es:latest               "/usr/local/bundle/b   2 seconds ago    Up 2 seconds                                                        stupefied_brattain
c474fd99ce43        dockerfile/elasticsearch:latest   "/elasticsearch/bin/   6 minutes ago      Up 6 minutes        0.0.0.0:9200->9200/tcp, 0.0.0.0:9300->9300/tcp   es

Schritt 7 - Bestätigen, dass Elasticsearch Ereignisse empfängt

Bestätigen wir abschließend, dass Elasticsearch die Ereignisse empfängt:

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

Die Ausgabe sollte Ereignisse enthalten, die wie folgt aussehen:

{"took":66,"timed_out":false,"_shards":{"total":5,"successful":5,"failed":0},"hits":{"total":0,"max_score":null,"hits":[]}}
{"took":59,"timed_out":false,"_shards":{"tod","_id":"AUwLaKjcnpi39wqZnTXQ","_score":1.0,"_source":{"log":"2015-03-12 00:35:44 +0000 [info]: following tail of /var/lib/docker/containers/6abeb6ec0019b2198ed708315f4770fc7ec6cc44a10705ea59f05fae23b81ee9/6abeb6ec0019b2198ed708315f4770fc7ec6cc44a10705ea59f05fae23b81ee9-json.log\n","stream":"stdout","container_id":"6abeb6ec0019b2198ed708315f4770fc7ec6cc44a10705ea59f05fae23b81ee9","@timestamp":"2015-03-12T00:35:44+00:00"}}]}}

Je nach Konfiguration werden möglicherweise einige Ereignisse protokolliert. Ein einzelnes Ereignis sollte mit + {" taken ": + beginnen und mit einem Zeitstempel enden.

Wie diese Ausgabe zeigt, empfängt Elasticsearch Daten. (Ihre Container-ID unterscheidet sich von der oben gezeigten!)

Schritt 8 - Ereignisprotokolle auf die nächste Ebene bringen

Was müssen Sie als Nächstes tun, nachdem Ihre Containerereignisse von Elasticsearch gespeichert wurden? Es gibt viele nützliche Dinge, die mit Elasticsearch zu tun haben. Wenn Sie nach Ideen suchen, sollten Sie Folgendes überprüfen:

https://www.digitalocean.com/community/tutorials/wie-mit-Daten-in-elastischer-Suche-mit-Crude-Operationen-in Kontakt tretenBasic Elasticsearch -Operationen]
Adding a dashboard, damit Sie Ihre Protokolle visualisieren können

Fazit

Das Sammeln von Protokollen aus Docker-Containern ist nur eine Möglichkeit, Fluentd zu verwenden. In diesem Abschnitt werden zwei weitere gängige Anwendungsfälle für Fluentd vorgestellt.

Anwendungsfall 1: Echtzeit-Protokollsuche und Protokollarchivierung

Viele Benutzer kommen zu Fluentd, um eine Protokollierungspipeline zu erstellen, die sowohl eine Echtzeit-Protokollsuche als auch eine Langzeitspeicherung durchführt. Die Architektur sieht so aus:

image: https: //assets.digitalocean.com/articles/dockerlogs_fluentd/3.png [Protokoll von mehreren Backends an Elasticsearch, MongoDB und Hadoop übertragen]

Diese Architektur nutzt die Fähigkeit von Fluentd, Datenströme zu kopieren und auf mehrere Speichersysteme auszugeben. In der obigen Einstellung wird Elasticsearch für die Echtzeitsuche verwendet, während MongoDB und / oder Hadoop für die Stapelanalyse und die Langzeitspeicherung verwendet werden.

Anwendungsfall 2: Zentrale Anwendungsprotokollierung

Webanwendungen erstellen viele Protokolle und werden häufig willkürlich formatiert und im lokalen Dateisystem gespeichert. Das ist aus zwei Gründen schlecht:

Die Protokolle sind programmgesteuert schwer zu analysieren (erfordern viele reguläre Ausdrücke) und daher für diejenigen, die das Benutzerverhalten durch statistische Analysen (A / B-Tests, Betrugserkennung usw.) verstehen möchten, nicht sehr zugänglich.
Auf die Protokolle kann nicht in Echtzeit zugegriffen werden, da die Textprotokolle als Bulk in Speichersysteme geladen werden. Wenn die Festplatte des Servers zwischen Massenladevorgängen beschädigt wird, gehen die Protokolle verloren oder sind beschädigt

Fluentd löst diese Probleme durch:

Bereitstellung von Logger-Bibliotheken für verschiedene Programmiersprachen mit einer konsistenten API: Jeder Logger sendet ein Triple von (Zeitstempel, Tag, JSON-formatiertes Ereignis) an Fluentd. Derzeit gibt es Logger-Bibliotheken für Ruby, Node.js, Go, Python, Perl, PHP, Java und C ++
Zulassen, dass die Anwendung ausgelöst und vergessen wird: Der Logger kann asynchron bei Fluentd protokollieren, wodurch die Protokolle vor dem Hochladen auf Back-End-Systeme zwischengespeichert werden

Ressourcen:

Lesen Sie mehr über die Unified Logging Layer
Fluentd + Elasticsearch for Kubernetes von Satnam Singh (Kubernetes committer)

TOC