TOC

Comment synchroniser des données transformées de MongoDB vers Elasticsearch avec Transporter sur Ubuntu 14.04

introduction

Elasticsearch facilite la recherche en texte intégral de vos données, tandis que MongoDB excelle dans son stockage. Utiliser MongoDB pour stocker vos données et Elasticsearch for search constituent une architecture commune.

Souvent, vous aurez peut-être besoin de migrer des données de MongoDB vers Elasticsearch en bloc. Écrire votre propre programme pour cela, même s’il s’agit d’un bon exercice, peut s’avérer fastidieux. Il existe un formidable utilitaire open source appelé Transporter, développé par Compose (une plate-forme cloud pour les bases de données), qui s’acquitte de cette tâche de manière très efficace.

Ce didacticiel explique comment utiliser l’utilitaire open source Transporter pour copier rapidement des données de MongoDB vers Elasticsearch avec des transformations personnalisées.

Buts

Dans cet article, nous allons expliquer comment copier des données de MongoDB vers Elasticsearch sur * Ubuntu 14.04 *, à l’aide de l’utilitaire Transporter.

Nous allons commencer par un bref aperçu de la procédure d’installation de MongoDB et d’Elasticsearch, sans toutefois entrer dans les détails de la modélisation des données dans les deux systèmes. N’hésitez pas à parcourir rapidement les étapes d’installation si vous les avez déjà installées.

Ensuite, nous allons passer à Transporter.

Les instructions sont similaires pour d’autres versions d’Ubuntu, ainsi que pour d’autres distributions Linux.

Conditions préalables

S’il vous plaît remplir les conditions préalables suivantes.

  • Ubuntu 14.04 Droplet

  • sudo utilisateur

Étape 1 - Installation de MongoDB

Importez la clé publique du référentiel MongoDB.

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10

Créez un fichier de liste pour MongoDB.

echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' | sudo tee /etc/apt/sources.list.d/mongodb.list

Rechargez la base de données de paquets locale.

sudo apt-get update

Installez les packages MongoDB:

sudo apt-get install -y mongodb-org

Notez que chaque package contient le numéro de version associé.

Une fois l’installation terminée, vous pouvez démarrer, arrêter et vérifier le statut du service. Il démarrera automatiquement après l’installation.

Essayez de vous connecter à l’instance MongoDB exécutée en tant que service:

mongo

S’il est opérationnel, vous verrez quelque chose comme ceci:

MongoDB shell version: 2.6.9
connecting to: test
Welcome to the MongoDB shell.
For interactive help, type "help".
For more comprehensive documentation, see
   http://docs.mongodb.org/
Questions? Try the support group
   http://groups.google.com/group/mongodb-user

Cela signifie que le serveur de base de données est en cours d’exécution! Vous pouvez sortir maintenant:

exit

Étape 2 - Installation de Java

Java est une condition préalable à Elasticsearch. Laissons l’installer maintenant.

Tout d’abord, ajoutez le référentiel:

sudo apt-add-repository ppa:webupd8team/java

Mettez à jour vos listes de paquets à nouveau:

sudo apt-get update

Installez Java:

sudo apt-get install oracle-java8-installer

Lorsque vous êtes invité à accepter la licence, sélectionnez + <Ok> + puis + <Oui> +.

Étape 3 - Installation d’Elasticsearch

Nous allons maintenant installer Elasticsearch.

Commencez par créer un nouveau répertoire dans lequel vous installerez le logiciel de recherche, puis accédez-y.

mkdir ~/utils
cd ~/utils

Visitez la page download d’Elasticsearch] pour afficher la dernière version.

Téléchargez maintenant la dernière version de Elasticsearch. Au moment de la rédaction de cet article, la dernière version était la 1.5.0.

wget https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-.zip

Installez unzip:

sudo apt-get install unzip

Décompressez l’archive:

unzip elasticsearch-.zip

Naviguez jusqu’au répertoire où vous l’avez extrait:

cd elasticsearch-

Lancez Elasticsearch en lançant la commande suivante:

bin/elasticsearch

Elasticsearch mettra quelques secondes à démarrer. Vous verrez certains journaux de démarrage comme cela. Elasticsearch sera maintenant exécuté dans la fenêtre du terminal.

_ * Remarque: * Vous voudrez peut-être exécuter Elasticsearch en tant que service afin de pouvoir le contrôler avec + sudo service elasticsearch restart + et des commandes similaires; voir ce tutoriel sur Upstart pour obtenir des conseils. Vous pouvez également installer Elasticsearch à partir des référentiels d’Ubuntu, bien que vous obteniez probablement une version plus ancienne. _

Gardez ce terminal ouvert. Établissez une autre connexion SSH avec votre serveur dans * une autre fenêtre de terminal * et vérifiez si votre instance est active et active:

curl -XGET http://localhost:9200

9200 est le port par défaut pour Elasticsearch. Si tout se passe bien, vous verrez une sortie similaire à celle présentée ci-dessous:

{
 "status" : 200,
 "name" : "Northstar",
 "cluster_name" : "elasticsearch",
 "version" : {
   "number" : "1.5.0",
   "build_hash" : "927caff6f05403e936c20bf4529f144f0c89fd8c",
   "build_timestamp" : "2015-03-23T14:30:58Z",
   "build_snapshot" : false,
   "lucene_version" : "4.10.4"
 },
 "tagline" : "You Know, for Search"
}

_ * Remarque *: Pour la dernière partie de cet article, lors de la copie des données, assurez-vous qu’Elasticsearch est en cours d’exécution (et sur le port 9200). _

Étape 4 - Installation de Mercurial

Nous allons ensuite installer l’outil de contrôle de révision Mercurial.

sudo apt-get install mercurial

Vérifiez que Mercurial est correctement installé:

hg

Vous obtiendrez le résultat suivant s’il est correctement installé:

Mercurial Distributed SCM

basic commands:

. . .

Étape 5 - Installation de Go

Transporter est écrit en langue Go. Donc, vous devez installer + golang + sur votre système.

sudo apt-get install golang

Pour que Go fonctionne correctement, vous devez définir les variables d’environnement suivantes:

Créez un dossier pour Go à partir de votre répertoire + $ HOME:

mkdir ~/go; echo "export GOPATH=$HOME/go" >> ~/.bashrc

Mettez à jour votre chemin:

echo "export PATH=$PATH:$HOME/go/bin:/usr/local/go/bin" >> ~/.bashrc

  • Déconnectez-vous de votre session SSH actuelle et reconnectez-vous. * Vous pouvez fermer uniquement la session où vous avez travaillé et conserver la session Elasticsearch en cours. Cette étape est cruciale pour la mise à jour de vos variables d’environnement. Connectez-vous à nouveau et vérifiez que votre variable a été ajoutée:

echo $GOPATH

Cela devrait afficher le nouveau chemin pour Go. Dans notre cas, ce sera:

/home//go

S’il n’affiche pas correctement le chemin, veuillez vérifier les étapes décrites dans cette section.

Une fois que notre + $ GOPATH + est défini correctement, nous devons vérifier que Go est correctement installé en construisant un programme simple.

Créez un fichier nommé + hello.go + et mettez-y le programme suivant. Vous pouvez utiliser l’éditeur de texte de votre choix. Nous allons utiliser l’éditeur de texte nano dans cet article. Tapez la commande suivante pour créer un nouveau fichier:

nano ~/hello.go

Maintenant, copiez ce bref programme «Hello, world» ci-dessous dans le fichier récemment ouvert. Le but de ce fichier est de nous aider à vérifier que Go fonctionne.

package main;
import "fmt"

func main() {
   fmt.Printf("Hello, world\n")
}

Une fois terminé, appuyez sur + CTRL + X + pour quitter le fichier. Il vous demandera de sauvegarder le fichier. Appuyez sur + Y + puis sur + ENTER. il vous demandera si vous voulez changer le nom du fichier. Appuyez à nouveau sur + ENTER pour enregistrer le fichier actuel.

Ensuite, à partir de votre répertoire personnel, exécutez le fichier avec Go:

go run hello.go

Vous devriez voir cette sortie:

Hello, world

Si vous voyez le message «Hello, world», alors Go est correctement installé.

Allez maintenant dans le répertoire + $ GOPATH et créez les sous-répertoires` + src`, + pkg et` + bin + `. Ces répertoires constituent un espace de travail pour Go.

cd $GOPATH
mkdir src pkg bin

  • + src + contient les fichiers source Go organisés en paquets (un paquet par répertoire)

  • + pkg + contient des objets de package

  • + bin + contient des commandes exécutables

Étape 6 - Installation de Git

Nous allons utiliser Git pour installer Transporter. Installez Git avec la commande suivante:

sudo apt-get install git

Étape 7 - Installation de Transporter

Maintenant, créez et déplacez-vous dans un nouveau répertoire pour Transporter. Depuis que cet utilitaire a été développé par Compose, nous appellerons le répertoire + compose +.

mkdir -p $GOPATH/src/github.com/compose
cd $GOPATH/src/github.com/compose

C’est ici que + compose / transporter + sera installé.

Clonez le référentiel Transporter GitHub:

git clone https://github.com/compose/transporter.git

Déplacer dans le nouveau répertoire:

cd transporter

Prenez possession du répertoire + / usr / lib / go +:

sudo chown -R $USER /usr/lib/go

Assurez-vous que + build-essential + est installé pour GCC:

sudo apt-get install build-essential

Exécutez la commande + go get + pour obtenir toutes les dépendances:

go get -a ./cmd/...

Cette étape peut prendre un certain temps, alors soyez patient. Une fois cela fait, vous pouvez construire Transporter.

go build -a ./cmd/...

Si tout va bien, il se terminera sans erreur ni avertissement. Vérifiez que Transporter est installé correctement en exécutant cette commande:

transporter

Vous devriez voir la sortie comme ceci:

usage: transporter [--version] [--help] <command> [<args>]

Available commands are:
   about    Show information about database adaptors
   eval     Eval javascript to build and run a transporter application

. . .

Donc, l’installation est terminée. Nous avons maintenant besoin de certaines données de test dans MongoDB que nous souhaitons synchroniser avec Elasticsearch.

Dépannage:

Si vous obtenez l’erreur suivante:

transporter: command not found

Cela signifie que votre + $ GOPATH + n’a pas été ajouté à votre variable + PATH +. Vérifiez que vous avez correctement exécuté la commande:

echo "export PATH=$PATH:$HOME/go/bin:/usr/local/go/bin" >> ~/.bashrc

Essayez de vous déconnecter et de vous reconnecter. Si l’erreur persiste, utilisez plutôt la commande suivante:

$GOPATH/bin/transporter

Étape 8 - Créer des exemples de données

Maintenant que tout est installé, nous pouvons passer à la partie synchronisation des données.

Connectez-vous à MongoDB:

mongo

Vous devriez maintenant voir l’invite MongoDB, +> +. Créez une base de données nommée + foo +.

use foo

Insérez des exemples de documents dans une collection nommée + bar +:

db.bar.save({"firstName": "Robert", "lastName": "Baratheon"});
db.bar.save({"firstName": "John", "lastName": "Snow"});

Sélectionnez le contenu que vous venez d’entrer:

db.bar.find().pretty();

Cela devrait afficher les résultats affichés ci-dessous (+ ObjectId + sera différent sur votre machine):

{
   "_id" : ObjectId("549c3ef5a0152464dde10bc4"),
   "firstName" : "Robert",
   "lastName" : "Baratheon"
}
{
   "_id" : ObjectId("549c3f03a0152464dde10bc5"),
   "firstName" : "John",
   "lastName" : "Snow"
}

Maintenant, vous pouvez sortir de la base de données:

exit

Un peu de terminologie:

  • Une base de données dans MongoDB est analogue à un index dans Elasticsearch

  • Une collection dans MongoDB est analogue à un type dans Elasticsearch

Notre objectif ultime est de synchroniser les données de la collection * bar * de la base de données * foo * de MongoDB vers le type * bar * de l’index * foo * dans Elasticsearch.

Étape 9 - Configuration de Transporter

Nous pouvons maintenant passer aux modifications de configuration pour migrer nos données de MongoDB vers Elasticsearch. Transporter requiert un fichier de configuration (+ config.yaml +), un fichier de transformation (+ .js +) et un fichier d’application (+ application.js +)

  • Le fichier de configuration spécifie les noeuds, les types et les URI

  • Le fichier d’application spécifie le flux de données de la source à la destination et les étapes de transformation facultatives.

  • Le fichier de transformation applique des transformations aux données

_ * Remarque: * Toutes les commandes de cette section supposent que vous exécutez les commandes à partir du répertoire de transporteur. _

Déplacez-vous dans le répertoire + transport +:

cd ~/go/src/github.com/compose/transporter

Fichier de configuration

Vous pouvez consulter l’exemple de fichier + config.yaml + si vous le souhaitez. Nous allons sauvegarder l’original et le remplacer par notre propre contenu.

mv test/config.yaml test/config.yaml.00

Le nouveau fichier est similaire, mais met à jour certains des URI et quelques autres paramètres pour qu’ils correspondent à ceux de notre serveur. Copions le contenu d’ici et collons dans le nouveau fichier + config.yaml +. Utilisez à nouveau l’éditeur nano.

nano test/config.yaml

Copiez le contenu ci-dessous dans le fichier. Une fois terminé, enregistrez le fichier comme décrit précédemment.

# api:
#   interval: 60s
#   uri: "http://requestb.in/13gerls1"
#   key: "48593282-b38d-4bf5-af58-f7327271e73d"
#   pid: "something-static"
nodes:
 localmongo:
   type: mongo
   uri: mongodb://localhost/foo
 es:
   type: elasticsearch
   uri: http://localhost:9200/
 timeseries:
   type: influx
   uri: influxdb://root:root@localhost:8086/compose
 debug:
   type: file
   uri: stdout://
 foofile:
   type: file
   uri: file:///tmp/foo

Remarquez la section + nodes +. Nous avons légèrement modifié les nœuds + localmongo + et + es + par rapport au fichier d’origine. Les nœuds sont les différentes sources de données et destinations. Type définit le type de nœud. Par exemple.,

  • + mongo + signifie que c’est une instance / un cluster MongoDB

  • + elasticsearch + signifie qu’il s’agit d’un nœud Elasticsearch

  • + fichier + signifie que c’est un fichier texte brut

+ uri + donnera au point de terminaison de l’API de se connecter au nœud. Le port par défaut sera utilisé pour MongoDB (27017) s’il n’est pas spécifié. Puisque nous devons capturer des données de la base de données * foo * de MongoDB, l’URI devrait ressembler à ceci:

mongodb://localhost/foo

De même, l’URI pour Elasticsearch ressemblera à ceci:

http://localhost:9200/

Enregistrez le fichier + config.yaml +. Vous n’avez pas besoin de faire d’autres changements.

Fichier d’application

Ouvrez maintenant le fichier + application.js dans le répertoire` + test`.

nano test/application.js

Remplacez le contenu exemple du fichier par le contenu ci-dessous:

Source({name:"localmongo", namespace:"foo.bar"})
.transform({filename: "transformers/addFullName.js"})
.save({name:"es", namespace:"foo.bar"});

Enregistrez le fichier et quittez. Voici une brève explication de notre pipeline.

  • + Source () + identifie la source à partir de laquelle récupérer les données

  • + transform + spécifie quelle transformation appliquer sur chaque enregistrement

  • + save () + identifie où sauvegarder les données

Les options comprennent:

  • + name: + nom du noeud tel qu’il apparaît dans le fichier + config.yaml +

  • + namespace: + identifie la base de données et le nom de la table; il doit être qualifié par un point (*. *)

Fichier de transformation

La dernière pièce du puzzle est la transformation. Si vous vous en souvenez bien, nous avons stocké deux enregistrements dans MongoDB avec + firstName + et + lastName +. C’est là que vous pouvez voir le pouvoir réel de transformer des données lorsque vous les synchronisez de MongoDB vers Elasticsearch.

Supposons que nous voulions que les documents stockés dans Elasticsearch aient un autre champ appelé + nom complet +. Pour cela, nous devons créer un nouveau fichier de transformation, + test / transformers / addFullName.js +.

nano test/transformers/addFullName.js

Collez le contenu ci-dessous dans le fichier. Enregistrez et quittez comme décrit précédemment.

module.exports = function(doc) {
 doc._id = doc._id['$oid'];
 doc["fullName"] = doc["firstName"] + " " + doc["lastName"];
 return doc
}

La première ligne est nécessaire pour aborder la manière dont Transporter traite le champ + ObjectId () + de MongoDB. La deuxième ligne indique à Transporter de concaténer + firstName + et + lastName + pour former + fullName +.

Ceci est une transformation simple pour l’exemple, mais avec un peu de JavaScript, vous pouvez effectuer une manipulation de données plus complexe pendant que vous préparez vos données pour la recherche.

Étape 10 - Exécution de la transformation

Maintenant que la configuration est terminée, il est temps de synchroniser et de transformer nos données.

  • Assurez-vous que Elasticsearch est en cours d’exécution! * Si ce n’est pas le cas, redémarrez-le dans une nouvelle fenêtre * nouveau terminal *:

~/utils/elasticsearch-/bin/elasticsearch

Dans votre * terminal d’origine *, assurez-vous de vous trouver dans le répertoire + transport +:

cd ~/go/src/github.com/compose/transporter

Exécutez la commande suivante pour copier les données:

transporter run --config ./test/config.yaml ./test/application.js

La commande + run + de Transporter attend deux arguments. Le premier est le fichier de configuration et le second est le fichier d’application. Si tout se passe bien, la commande se terminera sans erreur.

Vérifiez Elasticsearch pour vérifier que les données ont été copiées, avec notre transformation:

curl -XGET localhost:9200/foo/bar/_search?pretty=true

Vous obtiendrez un résultat comme celui-ci:

{
 "took" : 10,
 "timed_out" : false,
 "_shards" : {
   "total" : 5,
   "successful" : 5,
   "failed" : 0
 },
 "hits" : {
   "total" : 2,
   "max_score" : 1.0,
   "hits" : [ {
     "_index" : "foo",
     "_type" : "bar_full_name",
     "_id" : "549c3ef5a0152464dde10bc4",
     "_score" : 1.0,
     "_source":{"_id":"549c3ef5a0152464dde10bc4","firstName":"Robert","fullName":"Robert Baratheon","lastName":"Baratheon"}
   }, {
     "_index" : "foo",
     "_type" : "bar_full_name",
     "_id" : "549c3f03a0152464dde10bc5",
     "_score" : 1.0,
     "_source":{"_id":"549c3f03a0152464dde10bc5","firstName":"John","fullName":"John Snow","lastName":"Snow"}
   } ]
 }
}

Remarquez le champ + nom complet +, qui contient le + prénom + et + dernier nom + concaténés par un espace entre les deux - notre transformation a fonctionné.

Conclusion

Nous savons maintenant comment utiliser Transporter pour copier des données de MongoDB vers Elasticsearch et comment appliquer des transformations à nos données lors de la synchronisation. Vous pouvez appliquer des transformations beaucoup plus complexes de la même manière. Vous pouvez également chaîner plusieurs transformations dans le pipeline.

Si vous effectuez plusieurs transformations, conservez-les dans des fichiers séparés et chaînez-les. De cette façon, vous rendez chacune de vos transformations utilisable indépendamment pour le futur.

Donc, c’est à peu près tout. Vous pouvez consulter le projet Transporter sur GitHub pour rester à jour des dernières modifications apportées à l’API.

Vous pouvez également consulter ce didacticiel sur les opérations de base https://www.digitalocean.com/community/tutorials/how-to-interact-with-data-in-elataearch-using-crud-operations-CRUD dans Elasticsearch] .

Related