TOC

So synchronisieren Sie transformierte Daten von MongoDB zu Elasticsearch mit Transporter unter Ubuntu 16.04

Einführung

Transporter ist ein Open-Source-Tool zum Verschieben von Daten zwischen verschiedenen Datenspeichern. Entwickler schreiben oft einmalige Skripte für Aufgaben wie das Verschieben von Daten über Datenbanken, das Verschieben von Daten aus Dateien in eine Datenbank oder umgekehrt. Die Verwendung eines Tools wie Transporter bietet jedoch mehrere Vorteile.

In Transporter erstellen Sie Pipelines, die den Datenfluss von einer Quelle (wo die Daten gelesen werden) zu einer Senke (wo die Daten geschrieben werden) definieren. Quellen und Senken können SQL- oder NoSQL-Datenbanken, Flatfiles oder andere Ressourcen sein. Transporter verwendet adaptors, bei denen es sich um steckbare Erweiterungen handelt, um mit diesen Ressourcen zu kommunizieren. Das Projekt enthält standardmäßig several adapters für gängige Datenbanken.

Zusätzlich zum Verschieben von Daten können Sie in Transporter auch Daten ändern, während sie mithilfe eines Transformators durch eine Pipeline verschoben werden. Wie bei Adaptern sind standardmäßig several transformers enthalten. Sie können auch eigene Transformatoren schreiben, um die Änderung Ihrer Daten anzupassen.

In diesem Lernprogramm wird ein Beispiel für das Verschieben und Verarbeiten von Daten aus einer MongoDB-Datenbank in Elasticsearch mit den in Transporter integrierten Adaptern und einem in JavaScript geschriebenen benutzerdefinierten Transformator gezeigt.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

Transporter-Pipelines sind in JavaScript geschrieben. Sie benötigen keine JavaScript-Vorkenntnisse oder -Erfahrungen, um diesem Lernprogramm folgen zu können. Weitere Informationen finden Sie jedoch unter these JavaScript tutorials.

Schritt 1 - Transporter installieren

Transporter bietet Binärdateien für die meisten gängigen Betriebssysteme. Der Installationsprozess für Ubuntu besteht aus zwei Schritten: Herunterladen der Linux-Binärdatei und Ausführen.

Holen Sie sich zunächst den Link für die neueste Version von Transporters neueste Release-Seite auf GitHub. Kopieren Sie den Link, der mit "+ -linux-amd64 +" endet. In diesem Tutorial wird Version 0.5.2 verwendet, die zum Zeitpunkt des Schreibens die aktuellste Version ist.

Laden Sie die Binärdatei in Ihr Home-Verzeichnis herunter.

cd
wget https://github.com/compose/transporter/releases/download/v/transporter--linux-amd64

Verschieben Sie es in + / usr / local / bin + oder in Ihr bevorzugtes Installationsverzeichnis.

mv transporter-*-linux-amd64 /usr/local/bin/transporter

Machen Sie es dann ausführbar, damit Sie es ausführen können.

chmod +x /usr/local/bin/

Sie können testen, ob der Transporter korrekt eingerichtet ist, indem Sie die Binärdatei ausführen.

transporter

Sie sehen die Ausgabe der Verwendungshilfe und die Versionsnummer:

OutputUSAGE
 transporter <command> [flags]

COMMANDS
 run       run pipeline loaded from a file
 . . .

VERSION

Um Transporter zum Verschieben von Daten von MongoDB nach Elasticsearch zu verwenden, benötigen wir zwei Dinge: Daten in MongoDB, die wir verschieben möchten, und eine Pipeline, die Transporter mitteilt, wie sie verschoben werden sollen. Im nächsten Schritt werden einige Beispieldaten erstellt. Wenn Sie jedoch bereits eine MongoDB-Datenbank haben, die Sie verschieben möchten, können Sie den nächsten Schritt überspringen und direkt mit Schritt 3 fortfahren.

Schritt 2 - Hinzufügen von Beispieldaten zu MongoDB (optional)

In diesem Schritt erstellen wir eine Beispieldatenbank mit einer einzelnen Sammlung in MongoDB und fügen dieser Sammlung einige Dokumente hinzu. Im weiteren Verlauf des Lernprogramms migrieren und transformieren wir diese Beispieldaten mit einer Transporter-Pipeline.

Stellen Sie zunächst eine Verbindung zu Ihrer MongoDB-Datenbank her.

mongo

Dies ändert Ihre Eingabeaufforderung in "+ mongo> +" und zeigt an, dass Sie die MongoDB-Shell verwenden.

Wählen Sie hier eine Datenbank aus, an der Sie arbeiten möchten. Wir nennen uns "+ meine_Anwendung +".

use my_application

In + MongoDB + müssen Sie keine Datenbank oder Sammlung explizit erstellen. Sobald Sie einer nach Namen ausgewählten Datenbank Daten hinzufügen, wird diese Datenbank automatisch erstellt.

Um die Datenbank "+ my_application " zu erstellen, speichern Sie zwei Dokumente in der Sammlung " users +": eines für Sammy Shark und eines für Gilly Glowfish. Dies werden unsere Testdaten sein.

db.users.save({"firstName": "Sammy", "lastName": "Shark"});
db.users.save({"firstName": "Gilly", "lastName": "Glowfish"});

Nachdem Sie die Dokumente hinzugefügt haben, können Sie die Sammlung "+ users +" abfragen, um Ihre Datensätze anzuzeigen.

db.users.find().pretty();

Die Ausgabe ähnelt der folgenden Ausgabe, die Spalten "+ _id +" unterscheiden sich jedoch. MongoDB fügt automatisch Objekt-IDs hinzu, um die Dokumente in einer Sammlung eindeutig zu identifizieren.

output{
 "_id" : ObjectId("59299ac7f80b31254a916456"),
 "firstName" : "Sammy",
 "lastName" : "Shark"
}
{
 "_id" : ObjectId("59299ac7f80b31254a916457"),
 "firstName" : "Gilly",
 "lastName" : "Glowfish"
}

Drücken Sie + STRG + C +, um die MongoDB-Shell zu verlassen.

Als Nächstes erstellen wir eine Transporter-Pipeline, um diese Daten von MongoDB nach Elasticsearch zu verschieben.

Schritt 3 - Erstellen einer Basispipeline

Eine Pipeline in Transporter wird standardmäßig durch eine JavaScript-Datei mit dem Namen "+ pipeline.js " definiert. Mit dem eingebauten Befehl " init +" wird eine grundlegende configuration file im richtigen Verzeichnis erstellt, wobei eine Quelle und eine Senke angegeben werden.

Initialisieren Sie einen Starter "+ pipeline.js +" mit MongoDB als Quelle und Elasticsearch als Senke.

transporter init mongodb elasticsearch

Sie sehen die folgende Ausgabe:

OutputWriting pipeline.js...

Sie müssen für diesen Schritt nicht "+ pipeline.js +" ändern, aber schauen wir uns an, wie es funktioniert.

Die Datei sieht so aus, aber Sie können den Inhalt der Datei auch mit dem Befehl + cat pipeline.js +, + less pipeline.js + (Verlassen von + less + durch Drücken von + q +) oder mit anzeigen Öffnen Sie es mit Ihrem bevorzugten Texteditor.

pipeline.js

var source = mongodb({
 "uri": "${MONGODB_URI}"
 // "timeout": "30s",
 // "tail": false,
 // "ssl": false,
 // "cacerts": ["/path/to/cert.pem"],
 // "wc": 1,
 // "fsync": false,
 // "bulk": false,
 // "collection_filters": "{}",
 // "read_preference": "Primary"
})

var sink = elasticsearch({
 "uri": "${ELASTICSEARCH_URI}"
 // "timeout": "10s", // defaults to 30s
 // "aws_access_key": "ABCDEF", // used for signing requests to AWS Elasticsearch service
 // "aws_access_secret": "ABCDEF" // used for signing requests to AWS Elasticsearch service
 // "parent_id": "elastic_parent" // defaults to "elastic_parent" parent identifier for Elasticsearch
})

t.Source("source", source, "/.*/").Save("sink", sink, "/.*/")

Die Zeilen, die mit + var source + und + var sink + beginnen, definieren JavaScript variables für MongoDB und Elasticsearch-Adapter. Wir definieren die Umgebungsvariablen "+ MONGODB_URI " und " ELASTICSEARCH_URI +", die diese Adapter später in diesem Schritt benötigen.

Die Zeilen, die mit + // + beginnen, sind Kommentare. Sie heben einige häufig verwendete Konfigurationsoptionen hervor, die Sie für Ihre Pipeline festlegen können. Sie werden jedoch nicht für die grundlegende Pipeline verwendet, die wir hier erstellen.

Die letzte Linie verbindet die Quelle und die Senke. Mit der Variable "+ transporter " oder " t " können wir auf unsere Pipeline zugreifen. Wir verwenden die Zeichen ` .Source () ` und ` .Save () ` https://www.digitalocean.com/community/tutorials/how-to-define-functions-in-javascript[functions], um hinzuzufügen die Quelle und Senke unter Verwendung der zuvor in der Datei definierten Variablen " source " und " sink +".

Das dritte Argument für die Funktionen + Source () + und + Save () + ist der + Namespace. + Übergeben von + /. * / + Als letztes Argument bedeutet, dass alle Daten übertragen werden sollen Daten aus MongoDB und speichern Sie sie unter demselben Namespace in Elasticsearch.

Bevor wir diese Pipeline ausführen können, müssen wir https://www.digitalocean.com/community/tutorials/how-to-read-and-set-environmental-and-shell-variables-on-a-linux- vps [Umgebungsvariablen] für den MongoDB URI und https://www.elastic.co/guide/en/elasticsearch/reference/current/ modules-network.html [Elasticsearch URI]. In dem von uns verwendeten Beispiel werden beide lokal mit Standardeinstellungen gehostet. Passen Sie diese Optionen jedoch an, wenn Sie vorhandene MongoDB- oder Elasticsearch-Instanzen verwenden.

export MONGODB_URI='mongodb://localhost/my_application'
export ELASTICSEARCH_URI='http://localhost:9200/my_application'

Jetzt können wir die Pipeline ausführen.

transporter run pipeline.js

Sie sehen eine Ausgabe, die folgendermaßen endet:

Output. . .
INFO[0001] metrics source records: 2                     path=source ts=1522942118483391242
INFO[0001] metrics source/sink records: 2                path="source/sink" ts=1522942118483395960
INFO[0001] exit map[source:mongodb sink:elasticsearch]   ts=1522942118483396878

In der vorletzten und vorletzten Zeile gibt diese Ausgabe an, dass 2 Datensätze in der Quelle vorhanden waren und 2 Datensätze in die Senke verschoben wurden.

Um zu bestätigen, dass beide Datensätze verarbeitet wurden, können Sie Elasticsearch nach dem Inhalt der Datenbank "+ my_application +" abfragen, die jetzt vorhanden sein sollte.

curl $ELASTICSEARCH_URI/_search?pretty=true

Der Parameter +? Pretty = true + erleichtert das Lesen der Ausgabe:

Output{
 "took" : 5,
 "timed_out" : false,
 "_shards" : {
   "total" : 5,
   "successful" : 5,
   "skipped" : 0,
   "failed" : 0
 },
 "hits" : {
   "total" : 2,
   "max_score" : 1.0,
   "hits" : [
     {
       "_index" : "my_application",
       "_type" : "users",
       "_id" : "5ac63e9c6687d9f638ced4fe",
       "_score" : 1.0,
       "_source" : {
         "firstName" : "Gilly",
         "lastName" : "Glowfish"
       }
     },
     {
       "_index" : "my_application",
       "_type" : "users",
       "_id" : "5ac63e986687d9f638ced4fd",
       "_score" : 1.0,
       "_source" : {
         "firstName" : "Sammy",
         "lastName" : "Shark"
       }
     }
   ]
 }
}

Datenbanken und Sammlungen in MongoDB entsprechen den Indizes und Typen in Elasticsearch. In diesem Sinne sollten Sie Folgendes sehen:

  • Das Feld "+ _index " wurde auf " my_application" (der Name der ursprünglichen MongoDB-Datenbank) gesetzt.

  • Das Feld + _type + wurde auf + users, + den Namen der MongoDB-Sammlung gesetzt.

  • Die Felder "+ Vorname " und " Nachname +" sind mit "Sammy", "Shark" und "Gilly", "Glowfish" ausgefüllt.

Dies bestätigt, dass beide Datensätze aus MongoDB erfolgreich über Transporter verarbeitet und in Elasticsearch geladen wurden. Um auf dieser grundlegenden Pipeline aufzubauen, fügen wir einen Zwischenverarbeitungsschritt hinzu, der die Eingabedaten transformieren kann.

Schritt 4 - Erstellen eines Transformators

Wie der Name schon sagt, ändern transformers die Quelldaten, bevor sie in die Senke geladen werden. Sie können beispielsweise ein neues Feld hinzufügen, ein Feld entfernen oder die Daten eines Felds ändern. Transporter enthält einige vordefinierte Transformatoren sowie Unterstützung für benutzerdefinierte.

In der Regel werden benutzerdefinierte Transformatoren als JavaScript-Funktionen geschrieben und in einer separaten Datei gespeichert. Um sie zu verwenden, fügen Sie einen Verweis auf die Umsetzungsdatei in + pipeline.js + hinzu. Transporter enthält sowohl die JavaScript-Engines von Otto als auch von Goja. Da Goja neuer und im Allgemeinen schneller ist, verwenden wir es hier. Der einzige funktionale Unterschied ist die Syntax.

Erstellen Sie eine Datei mit dem Namen "+ transform.js +", mit der wir unsere Transformationsfunktion schreiben.

nano transform.js

Hier ist die von uns verwendete Funktion, die ein neues Feld mit dem Namen "+ fullName " erstellt, dessen Wert aus den Feldern " firstName " und " lastName " besteht, die durch ein Leerzeichen getrennt sind (wie " Sammy Shark +") `).

transform.js

function transform(msg) {
   msg.data.fullName = msg.data.firstName + " " + msg.data.lastName;
   return msg
}

Gehen wir die Zeilen dieser Datei durch:

Speichern und schließen Sie die Datei.

Als nächstes müssen wir die Pipeline modifizieren, um diesen Transformator zu verwenden. Öffnen Sie die Datei + pipeline.js + zum Bearbeiten.

nano pipeline.js

In der letzten Zeile müssen wir der Funktion "+ Transform () " einen Aufruf hinzufügen, um den Transformator zur Pipeline zwischen den Aufrufen von " Source () " und " Save () +" hinzuzufügen :

~ / transporter / pipeline.js

. . .
t.Source("source", source, "/.*/")

.Save("sink", sink, "/.*/")

Das an + Transform () + übergebene Argument ist die Art der Transformation, in diesem Fall Goja. Mit der Funktion + goja + geben wir den Dateinamen des Transformers unter Verwendung der https://www.digitalocean.com/community/tutorials/basic-linux-navigation-and-file-management#moving-around-the- Dateisystem mit "cd" [relativer Pfad].

Speichern und schließen Sie die Datei. Bevor wir die Pipeline erneut ausführen, um den Transformator zu testen, löschen wir die vorhandenen Daten in Elasticsearch aus dem vorherigen Test.

curl -XDELETE $ELASTICSEARCH_URI

Sie sehen, dass diese Ausgabe den Erfolg des Befehls bestätigt.

Output{"acknowledged":true}

Führen Sie nun die Pipeline erneut aus.

transporter run pipeline.js

Die Ausgabe wird dem vorherigen Test sehr ähnlich sein, und Sie können in den letzten Zeilen sehen, ob die Pipeline wie zuvor erfolgreich abgeschlossen wurde. Natürlich können wir Elasticsearch erneut überprüfen, um festzustellen, ob die Daten in dem von uns erwarteten Format vorliegen.

curl $ELASTICSEARCH_URI/_search?pretty=true

Sie können das Feld "+ fullName +" in der neuen Ausgabe sehen:

Output{
 "took" : 9,
 "timed_out" : false,
 "_shards" : {
   "total" : 5,
   "successful" : 5,
   "skipped" : 0,
   "failed" : 0
 },
 "hits" : {
   "total" : 2,
   "max_score" : 1.0,
   "hits" : [
     {
       "_index" : "my_application",
       "_type" : "users",
       "_id" : "5ac63e9c6687d9f638ced4fe",
       "_score" : 1.0,
       "_source" : {
         "firstName" : "Gilly",

         "lastName" : "Glowfish"
       }
     },
     {
       "_index" : "my_application",
       "_type" : "users",
       "_id" : "5ac63e986687d9f638ced4fd",
       "_score" : 1.0,
       "_source" : {
         "firstName" : "Sammy",

         "lastName" : "Shark"
       }
     }
   ]
 }
}

Beachten Sie, dass das Feld "+ fullName +" in beiden Dokumenten mit den richtigen Werten hinzugefügt wurde. Damit wissen wir jetzt, wie wir einer Transporter-Pipeline benutzerdefinierte Transformationen hinzufügen können.

Fazit

Sie haben eine grundlegende Transporter-Pipeline mit einem Transformator erstellt, um Daten von MongoDB nach Elasticsearch zu kopieren und zu ändern. Sie können komplexere Transformationen auf dieselbe Weise anwenden, mehrere Transformationen in derselben Pipeline verketten und vieles mehr. MongoDB und Elasticsearch sind nur zwei der von Transporter unterstützten Adapter. Es werden auch Flatfiles, SQL-Datenbanken wie Postgres und viele andere Datenquellen unterstützt.

Sie können das Transporter-Projekt auf GitHub überprüfen, um über die neuesten Änderungen in der API informiert zu sein. Besuchen Sie auch the Transporter-Wiki, um detailliertere Informationen zur Verwendung von Adaptern, Transformern und anderen Funktionen von Transformer zu erhalten.

Related