Come usare Elasticsearch con MongoDB?


152

Ho esaminato molti blog e siti sulla configurazione di Elasticsearch per MongoDB per indicizzare le raccolte in MongoDB, ma nessuna di queste era semplice.

Spiegami una procedura passo passo per l'installazione di elasticsearch, che dovrebbe includere:

  • configurazione
  • eseguire nel browser

Sto usando Node.js con express.js, quindi per favore aiutate di conseguenza.


4
Nota: i fiumi sono deprecati
abdul qayyum,

Risposte:


287

Questa risposta dovrebbe essere sufficiente per iniziare a seguire questo tutorial sulla creazione di un componente di ricerca funzionale con MongoDB, Elasticsearch e AngularJS .

Se stai cercando di utilizzare la ricerca sfaccettata con i dati di un'API, BirdWatch Repo di Matthiasn è qualcosa che potresti voler guardare.

Ecco quindi come configurare un "cluster" di Elasticsearch a nodo singolo per indicizzare MongoDB per l'uso in un'app NodeJS, Express su una nuova istanza EC2 Ubuntu 14.04.

Assicurati che tutto sia aggiornato.

sudo apt-get update

Installa NodeJS.

sudo apt-get install nodejs
sudo apt-get install npm

Installa MongoDB - Questi passaggi sono direttamente dai documenti MongoDB. Scegli la versione che preferisci. Sto attaccando con v2.4.9 perché sembra essere la versione più recente MongoDB-River supportata da senza problemi.

Importa la chiave GPG pubblica MongoDB.

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

Aggiorna il tuo elenco di fonti.

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

Ottieni il pacchetto 10gen.

sudo apt-get install mongodb-10gen

Quindi scegli la tua versione se non vuoi la più recente. Se stai impostando il tuo ambiente su una macchina Windows 7 o 8, stai lontano dalla v2.6 fino a quando non risolvono alcuni bug eseguendolo come servizio.

apt-get install mongodb-10gen=2.4.9

Impedisci che la versione dell'installazione di MongoDB venga bloccata durante l'aggiornamento.

echo "mongodb-10gen hold" | sudo dpkg --set-selections

Avviare il servizio MongoDB.

sudo service mongodb start

I file del database vengono impostati automaticamente su / var / lib / mongo e i file di registro su / var / log / mongo.

Crea un database attraverso la shell mongo e inseriscici alcuni dati fittizi.

mongo YOUR_DATABASE_NAME
db.createCollection(YOUR_COLLECTION_NAME)
for (var i = 1; i <= 25; i++) db.YOUR_COLLECTION_NAME.insert( { x : i } )

Ora per convertire il MongoDB autonomo in un set di repliche .

Primo arresto del processo.

mongo YOUR_DATABASE_NAME
use admin
db.shutdownServer()

Ora stiamo eseguendo MongoDB come servizio, quindi non passiamo l'opzione "--replSet rs0" nell'argomento della riga di comando quando riavviamo il processo mongod. Invece, lo inseriamo nel file mongod.conf.

vi /etc/mongod.conf

Aggiungi queste righe, sottolineando i percorsi db e log.

replSet=rs0
dbpath=YOUR_PATH_TO_DATA/DB
logpath=YOUR_PATH_TO_LOG/MONGO.LOG

Ora apri di nuovo la shell mongo per inizializzare il set di repliche.

mongo DATABASE_NAME
config = { "_id" : "rs0", "members" : [ { "_id" : 0, "host" : "127.0.0.1:27017" } ] }
rs.initiate(config)
rs.slaveOk() // allows read operations to run on secondary members.

Ora installa Elasticsearch. Sto solo seguendo questo utile Gist .

Assicurarsi che Java sia installato.

sudo apt-get install openjdk-7-jre-headless -y

Rimani con v1.1.x per ora fino a quando il bug del plugin Mongo-River non viene corretto in v1.2.1.

wget https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-1.1.1.deb
sudo dpkg -i elasticsearch-1.1.1.deb

curl -L http://github.com/elasticsearch/elasticsearch-servicewrapper/tarball/master | tar -xz
sudo mv *servicewrapper*/service /usr/local/share/elasticsearch/bin/
sudo rm -Rf *servicewrapper*
sudo /usr/local/share/elasticsearch/bin/service/elasticsearch install
sudo ln -s `readlink -f /usr/local/share/elasticsearch/bin/service/elasticsearch` /usr/local/bin/rcelasticsearch

Assicurati che /etc/elasticsearch/elasticsearch.yml abbia le seguenti opzioni di configurazione abilitate se per il momento stai sviluppando su un singolo nodo:

cluster.name: "MY_CLUSTER_NAME"
node.local: true

Avvia il servizio Elasticsearch.

sudo service elasticsearch start

Verifica che funzioni.

curl http://localhost:9200

Se vedi qualcosa del genere, allora sei bravo.

{
  "status" : 200,
  "name" : "Chi Demon",
  "version" : {
    "number" : "1.1.2",
    "build_hash" : "e511f7b28b77c4d99175905fac65bffbf4c80cf7",
    "build_timestamp" : "2014-05-22T12:27:39Z",
    "build_snapshot" : false,
    "lucene_version" : "4.7"
  },
  "tagline" : "You Know, for Search"
}

Ora installa i plugin Elasticsearch in modo che possa giocare con MongoDB.

bin/plugin --install com.github.richardwilly98.elasticsearch/elasticsearch-river-mongodb/1.6.0
bin/plugin --install elasticsearch/elasticsearch-mapper-attachments/1.6.0

Questi due plug-in non sono necessari ma sono utili per testare le query e visualizzare le modifiche agli indici.

bin/plugin --install mobz/elasticsearch-head
bin/plugin --install lukas-vlcek/bigdesk

Riavvia Elasticsearch.

sudo service elasticsearch restart

Infine indicizza una raccolta da MongoDB.

curl -XPUT localhost:9200/_river/DATABASE_NAME/_meta -d '{
  "type": "mongodb",
  "mongodb": {
    "servers": [
      { "host": "127.0.0.1", "port": 27017 }
    ],
    "db": "DATABASE_NAME",
    "collection": "ACTUAL_COLLECTION_NAME",
    "options": { "secondary_read_preference": true },
    "gridfs": false
  },
  "index": {
    "name": "ARBITRARY INDEX NAME",
    "type": "ARBITRARY TYPE NAME"
  }
}'

Verifica che il tuo indice sia in Elasticsearch

curl -XGET http://localhost:9200/_aliases

Controlla lo stato del tuo cluster.

curl -XGET 'http://localhost:9200/_cluster/health?pretty=true'

Probabilmente è giallo con alcuni frammenti non assegnati. Dobbiamo dire a Elasticsearch con cosa vogliamo lavorare.

curl -XPUT 'localhost:9200/_settings' -d '{ "index" : { "number_of_replicas" : 0 } }'

Controlla di nuovo lo stato del cluster. Dovrebbe essere verde ora.

curl -XGET 'http://localhost:9200/_cluster/health?pretty=true'

Vai a giocare.


@ Duck5auce ha idea di come ottenere il risultato (il risultato della ricerca elastica) da express.js e visualizzarlo nel browser utilizzando il modello jade o ejs, ad esempio app.get ('search = "google"', funzione (req , rES) {}); e grazie per la meravigliosa risposta
bibin david,

@bibindavid Verificherei questa risorsa. Ti guida nella creazione di un modulo client ES lato server attraverso il quale esegui il push delle query filtrate tramite altri due moduli personalizzati. Il rendering dei dati è ancora gestito sul client, ma dovrebbe essere un buon punto di partenza. sahan.me/posts/dabbling-in-elasticsearch-part-2-with-nodejs Repository Github situato qui: github.com/sahan/sahan.github.io/tree/master/resources/…
Donald Gary

Potete dirmi quale sarà meglio mongoosastic o usando il modulo mongose ​​ed elasticsearch in modo diverso ????
Sudhanshu Gaur,

7
È passato un anno dalla risposta eccellente di duck5auce. Pensa che le persone ora stiano usando 10gens [mongo-connettore] [1] per sincronizzare un cluster MongoDB con ElasticSearch in tempo reale. Codifica l'oplog MongoDB. [1]: github.com/10gen-labs/mongo-connector/wiki/…
Andrew Betts,

8
@ duck5auce Aggiorna questa risposta, è obsoleta. Il fiume è stato deprecato
tsturzl,

36

L'uso di river può presentare problemi quando la tua operazione si ingrandisce. River userà una tonnellata di memoria quando è sottoposto a pesanti operazioni. Ti consiglio di implementare i tuoi modelli di elasticsearch, o se stai usando mangusta puoi costruire i tuoi modelli di elasticsearch direttamente o usare elasticsearch direttamente mongoosastic che essenzialmente lo fa per te.

Un altro svantaggio di Mongodb River è che rimarrai bloccato usando il ramo mongodb 2.4.xe ElasticSearch 0.90.x. Inizierai a scoprire che ti stai perdendo un sacco di funzioni davvero interessanti e il progetto mongodb river non produce un prodotto utilizzabile abbastanza velocemente da rimanere stabile. Detto questo, Mongodb River non è sicuramente qualcosa con cui andrei in produzione. Ha posto più problemi del suo valore. Rilascerà casualmente la scrittura sotto carico pesante, consumerà molta memoria e non ci sono impostazioni per limitarla. Inoltre, river non si aggiorna in tempo reale, legge oplog da mongodb e questo può ritardare gli aggiornamenti di ben 5 minuti nella mia esperienza.

Di recente abbiamo dovuto riscrivere gran parte del nostro progetto, perché è un evento settimanale che qualcosa vada storto con ElasticSearch. Eravamo persino arrivati ​​al punto di assumere un consulente Dev Ops, che concorda anche sul fatto che è meglio allontanarsi da River.

AGGIORNARE: Elasticsearch-mongodb-river ora supporta ES v1.4.0 e mongodb v2.6.x. Tuttavia, potresti comunque riscontrare problemi di prestazioni in operazioni di inserimento / aggiornamento pesanti poiché questo plug-in tenterà di leggere gli oplog di mongodb da sincronizzare. Se ci sono molte operazioni poiché il blocco (o il latch piuttosto) si sblocca, noterai un utilizzo della memoria estremamente elevato sul tuo server elasticsearch. Se hai intenzione di fare una grande operazione, river non è una buona opzione. Gli sviluppatori di ElasticSearch ti consigliano ancora di gestire i tuoi indici comunicando direttamente con la loro API usando la libreria client per la tua lingua, piuttosto che usare river. Questo non è davvero lo scopo del fiume. Twitter-river è un ottimo esempio di come usare river. È essenzialmente un ottimo modo per estrarre dati da fonti esterne,

Considera anche che mongodb-river rimane indietro nella versione, poiché non è gestito da ElasticSearch Organization, è gestito da una terza parte. Lo sviluppo è stato bloccato sul ramo v0.90 per molto tempo dopo il rilascio di v1.0, e quando è stata rilasciata una versione per v1.0 non era stabile fino a quando elasticsearch ha rilasciato v1.3.0. Anche le versioni Mongodb restano indietro. Potresti trovarti in una situazione difficile quando stai cercando di passare a una versione successiva di ciascuno, in particolare con ElasticSearch in fase di sviluppo così pesante, con molte funzionalità molto attese sulla strada. Stare al passo con le ultime novità su ElasticSearch è stato molto importante in quanto ci affidiamo costantemente al miglioramento costante della nostra funzionalità di ricerca in quanto parte fondamentale del nostro prodotto.

Tutto sommato probabilmente otterrai un prodotto migliore se lo fai da solo. Non è così difficile. È solo un altro database da gestire nel codice e può essere facilmente inserito nei modelli esistenti senza importanti refactoring.


Hai un link o un consiglio in cui posso indicizzare, ad esempio, le informazioni sull'autore nell'indice della pubblicazione poiché la pubblicazione e l'autore sono in 2 raccolte e link via referenceone e referencemany
Marcel Djaman


Questo spiegherebbe come si uniscono / si collegano i dati elastic.co/guide/en/elasticsearch/guide/current/…
tsturzl

1
Elasticsearch è un DB di archiviazione dei documenti, piuttosto che un database relazionale. Non è impossibile correlare i dati in elasticsearch, ma è più probabile che si verifichi la denormalizzazione, ma può essere gestito con una logica aggiuntiva (ci sono plugin). Il modo più comune per mettere in relazione i dati, come lo stato nel link sopra, è quello di memorizzare un riferimento ID nel relativo documento. Assicurati di archiviare questo ID in un campo impostato not_analyzed, altrimenti avrai difficoltà a interrogarlo, per il modo in cui i campi analizzati vengono tokenizzati.
tsturzl,

4

Ho trovato utile il connettore mongo. È formato da Mongo Labs (MongoDB Inc.) e può essere utilizzato ora con Elasticsearch 2.x

Elastic 2.x doc manager: https://github.com/mongodb-labs/elastic2-doc-manager

mongo-connettore crea una pipeline da un cluster MongoDB a uno o più sistemi di destinazione, come Solr, Elasticsearch o un altro cluster MongoDB. Sincronizza i dati in MongoDB con la destinazione, quindi codifica l'oplog MongoDB, tenendo il passo con le operazioni in MongoDB in tempo reale. È stato testato con Python 2.6, 2.7 e 3.3+. Documentazione dettagliata è disponibile sul wiki.

https://github.com/mongodb-labs/mongo-connector https://github.com/mongodb-labs/mongo-connector/wiki/Usage%20with%20ElasticSearch


4

River è una buona soluzione quando si desidera avere una sincronizzazione quasi in tempo reale e una soluzione generale.

Se disponi già di dati in MongoDB e desideri spedirli facilmente a Elasticsearch come "one-shot", puoi provare il mio pacchetto in Node.js https://github.com/itemsapi/elasticbulk .

Utilizza i flussi Node.js in modo da poter importare dati da tutto ciò che supporta i flussi (ad es. MongoDB, PostgreSQL, MySQL, file JSON, ecc.)

Esempio da MongoDB a Elasticsearch:

Installa i pacchetti:

npm install elasticbulk
npm install mongoose
npm install bluebird

Crea script, ad esempio script.js:

const elasticbulk = require('elasticbulk');
const mongoose = require('mongoose');
const Promise = require('bluebird');
mongoose.connect('mongodb://localhost/your_database_name', {
  useMongoClient: true
});

mongoose.Promise = Promise;

var Page = mongoose.model('Page', new mongoose.Schema({
  title: String,
  categories: Array
}), 'your_collection_name');

// stream query 
var stream = Page.find({
}, {title: 1, _id: 0, categories: 1}).limit(1500000).skip(0).batchSize(500).stream();

elasticbulk.import(stream, {
  index: 'my_index_name',
  type: 'my_type_name',
  host: 'localhost:9200',
})
.then(function(res) {
  console.log('Importing finished');
})

Spedisci i tuoi dati:

node script.js

Non è estremamente veloce ma funziona per milioni di dischi (grazie agli stream).


3

Ecco come farlo su mongodb 3.0. Ho usato questo bel blog

  1. Installa mongodb.
  2. Creare directory di dati:
$ mkdir RANDOM_PATH/node1
$ mkdir RANDOM_PATH/node2> 
$ mkdir RANDOM_PATH/node3
  1. Avviare istanze Mongod
$ mongod --replSet test --port 27021 --dbpath node1
$ mongod --replSet test --port 27022 --dbpath node2
$ mongod --replSet test --port 27023 --dbpath node3
  1. Configurare il set di repliche:
$ mongo
config = {_id: 'test', members: [ {_id: 0, host: 'localhost:27021'}, {_id: 1, host: 'localhost:27022'}]};    
rs.initiate(config);
  1. Installazione di Elasticsearch:
a. Download and unzip the [latest Elasticsearch][2] distribution

b. Run bin/elasticsearch to start the es server.

c. Run curl -XGET http://localhost:9200/ to confirm it is working.
  1. Installazione e configurazione del fiume MongoDB:

$ bin / plugin --install com.github.richardwilly98.elasticsearch / elasticsearch-river-mongodb

$ bin / plugin - installa elasticsearch / elasticsearch-mapper-attachments

  1. Crea il "fiume" e l'indice:

curl -XPUT ' http: // localhost: 8080 / _river / mongodb / _meta ' -d '{"type": "mongodb", "mongodb": {"db": "mydb", "collection": "foo" }, "index": {"name": "name", "type": "random"}} '

  1. Test sul browser:

    http: // localhost: 9200 / _search q = casa


6
ElasticSearch ha deprecato i plugin del fiume. Questo non è certamente il modo migliore per mantenere un indice di ricerca.
tsturzl,

3

Qui ho trovato un'altra buona opzione per migrare i tuoi dati MongoDB su Elasticsearch. Un demone go che sincronizza mongodb con elasticsearch in tempo reale. È il Monstache. È disponibile su: Monstache

Sotto il setp iniziale per configurarlo e utilizzarlo.

Passo 1:

C:\Program Files\MongoDB\Server\4.0\bin>mongod --smallfiles --oplogSize 50 --replSet test

Passo 2 :

C:\Program Files\MongoDB\Server\4.0\bin>mongo

C:\Program Files\MongoDB\Server\4.0\bin>mongo
MongoDB shell version v4.0.2
connecting to: mongodb://127.0.0.1:27017
MongoDB server version: 4.0.2
Server has startup warnings:
2019-01-18T16:56:44.931+0530 I CONTROL  [initandlisten]
2019-01-18T16:56:44.931+0530 I CONTROL  [initandlisten] ** WARNING: Access control is not enabled for the database.
2019-01-18T16:56:44.931+0530 I CONTROL  [initandlisten] **          Read and write access to data and configuration is unrestricted.
2019-01-18T16:56:44.931+0530 I CONTROL  [initandlisten]
2019-01-18T16:56:44.931+0530 I CONTROL  [initandlisten] ** WARNING: This server is bound to localhost.
2019-01-18T16:56:44.931+0530 I CONTROL  [initandlisten] **          Remote systems will be unable to connect to this server.
2019-01-18T16:56:44.931+0530 I CONTROL  [initandlisten] **          Start the server with --bind_ip <address> to specify which IP
2019-01-18T16:56:44.931+0530 I CONTROL  [initandlisten] **          addresses it should serve responses from, or with --bind_ip_all to
2019-01-18T16:56:44.931+0530 I CONTROL  [initandlisten] **          bind to all interfaces. If this behavior is desired, start the
2019-01-18T16:56:44.931+0530 I CONTROL  [initandlisten] **          server with --bind_ip 127.0.0.1 to disable this warning.
2019-01-18T16:56:44.931+0530 I CONTROL  [initandlisten]
MongoDB Enterprise test:PRIMARY>

Passaggio 3: verificare la replica.

MongoDB Enterprise test:PRIMARY> rs.status();
{
        "set" : "test",
        "date" : ISODate("2019-01-18T11:39:00.380Z"),
        "myState" : 1,
        "term" : NumberLong(2),
        "syncingTo" : "",
        "syncSourceHost" : "",
        "syncSourceId" : -1,
        "heartbeatIntervalMillis" : NumberLong(2000),
        "optimes" : {
                "lastCommittedOpTime" : {
                        "ts" : Timestamp(1547811537, 1),
                        "t" : NumberLong(2)
                },
                "readConcernMajorityOpTime" : {
                        "ts" : Timestamp(1547811537, 1),
                        "t" : NumberLong(2)
                },
                "appliedOpTime" : {
                        "ts" : Timestamp(1547811537, 1),
                        "t" : NumberLong(2)
                },
                "durableOpTime" : {
                        "ts" : Timestamp(1547811537, 1),
                        "t" : NumberLong(2)
                }
        },
        "lastStableCheckpointTimestamp" : Timestamp(1547811517, 1),
        "members" : [
                {
                        "_id" : 0,
                        "name" : "localhost:27017",
                        "health" : 1,
                        "state" : 1,
                        "stateStr" : "PRIMARY",
                        "uptime" : 736,
                        "optime" : {
                                "ts" : Timestamp(1547811537, 1),
                                "t" : NumberLong(2)
                        },
                        "optimeDate" : ISODate("2019-01-18T11:38:57Z"),
                        "syncingTo" : "",
                        "syncSourceHost" : "",
                        "syncSourceId" : -1,
                        "infoMessage" : "",
                        "electionTime" : Timestamp(1547810805, 1),
                        "electionDate" : ISODate("2019-01-18T11:26:45Z"),
                        "configVersion" : 1,
                        "self" : true,
                        "lastHeartbeatMessage" : ""
                }
        ],
        "ok" : 1,
        "operationTime" : Timestamp(1547811537, 1),
        "$clusterTime" : {
                "clusterTime" : Timestamp(1547811537, 1),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
}
MongoDB Enterprise test:PRIMARY>

Passaggio 4. Scarica il " https://github.com/rwynn/monstache/releases ". Decomprimi il download e modifica la variabile PATH per includere il percorso della cartella per la tua piattaforma. Vai a cmd e digita"monstache -v" # 4.13.1 Monstache utilizza il formato TOML per la sua configurazione. Configurare il file per la migrazione denominato config.toml

Passaggio 5.

My config.toml ->

mongo-url = "mongodb://127.0.0.1:27017/?replicaSet=test"
elasticsearch-urls = ["http://localhost:9200"]

direct-read-namespaces = [ "admin.users" ]

gzip = true
stats = true
index-stats = true

elasticsearch-max-conns = 4
elasticsearch-max-seconds = 5
elasticsearch-max-bytes = 8000000 

dropped-collections = false
dropped-databases = false

resume = true
resume-write-unsafe = true
resume-name = "default"
index-files = false
file-highlighting = false
verbose = true
exit-after-direct-reads = false

index-as-update=true
index-oplog-time=true

Passaggio 6.

D:\15-1-19>monstache -f config.toml

Monstache in esecuzione ...

Conferma i dati migrati su Elasticsearch

Aggiungi record su Mongo

Monstache Ha catturato l'evento e migra i dati su elasticsearch


3

Dato che il connettore mongo ora sembra morto, la mia azienda ha deciso di creare uno strumento per utilizzare i flussi di cambio Mongo per l'output su Elasticsearch.

I nostri risultati iniziali sembrano promettenti. Puoi verificarlo su https://github.com/electionsexperts/mongo-stream . Siamo ancora all'inizio dello sviluppo e saremo lieti di ricevere suggerimenti o contributi.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.