MongoDB
 sql >> Datenbank >  >> NoSQL >> MongoDB

MongoDB 4.x Echtzeitsynchronisierung mit ElasticSearch 6.x +

Wenn Sie mit Docker arbeiten, können Sie dieses Tutorial herunterladen

https://github.com/ziedtuihri/Monstache_Elasticsearch_Mongodb

Monstache ist ein in Go geschriebener Synchronisierungs-Daemon, der Ihre MongoDB-Sammlungen kontinuierlich in Elasticsearch indiziert. Monstache gibt Ihnen die Möglichkeit, Elasticsearch zu verwenden, um komplexe Suchen und Aggregationen Ihrer MongoDB-Daten durchzuführen und auf einfache Weise Kibana-Visualisierungen und Dashboards in Echtzeit zu erstellen. Dokumentation für Monstache:
https://rwynn.github.io/monstache-site/
github :
https://github.com/rwynn/monstache

docker-compose.yml

version: '2.3'
networks:
  test:
    driver: bridge

services:
  db:
    image: mongo:3.0.2
    expose:
      - "27017"
    container_name: mongodb
    volumes:
      - ./mongodb:/data/db
      - ./mongodb_config:/data/configdb
    ports:
      - "27018:27017"
    command: mongod --smallfiles --replSet rs0
    networks:
      - test

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:6.8.7
    container_name: elasticsearch
    volumes:
      - ./elastic:/usr/share/elasticsearch/data
      - ./elastic/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml
    ports:
      - 9200:9200
    command: elasticsearch -Enetwork.host=_local_,_site_ -Enetwork.publish_host=_local_
    healthcheck:
      test: "wget -q -O - http://localhost:9200/_cat/health"
      interval: 1s
      timeout: 30s
      retries: 300
    ulimits:
      nproc: 65536
      nofile:
        soft: 65536
        hard: 65536
      memlock:
        soft: -1
        hard: -1
    networks:
      - test

  monstache:
    image: rwynn/monstache:rel4
    expose:
      - "8080"
    ports:
      - "8080:8080"
    container_name: monstache
    command: -mongo-url=mongodb://db:27017 -elasticsearch-url=http://elasticsearch:9200 -direct-read-namespace=Product_DB.Product -direct-read-split-max=2
    links:
      - elasticsearch
      - db
    depends_on:
      db:
        condition: service_started
      elasticsearch:
        condition: service_healthy
    networks:
      - test

replikset.sh

#!/bin/bash

# this configuration is so important 
echo "Starting replica set initialize"
until mongo --host 192.168.144.2 --eval "print(\"waited for connection\")"
do
    sleep 2
done
echo "Connection finished"
echo "Creating replica set"
mongo --host 192.168.144.2 <<EOF
rs.initiate(
  {
    _id : 'rs0',
    members: [
      { _id : 0, host : "db:27017", priority : 1 }
    ]
  }
)
EOF
echo "replica set created"

1) Führen Sie diesen Befehl im Terminal $ sysctl -w vm.max_map_count=262144

aus

Wenn Sie auf einem Server arbeiten, weiß ich nicht, ob dies erforderlich ist

2) run en terminaldocker-compose build

3) run en terminal$ docker-compose up -d

mach deinen Container nicht runter.

$ Docker-PS

Kopieren Sie die IP-Adresse des Mongo-DB-Image

$ docker prüft id_of_mongo_image

Kopieren Sie die IP-Adresse und legen Sie sie in replicaset.sh fest und führen Sie replicaset.sh

aus

$ ./replicaset.sh

Auf dem Terminal sollten Sie sehen => Replikatsatz erstellt

$ docker-compose down

4)run en terminal$ docker-compose up

schließlich .......

Replikation in MongoDB

Ein Replikat-Set ist eine Gruppe von mongod Instanzen, die denselben Datensatz verwalten. Ein Replikatsatz enthält mehrere datentragende Knoten und optional einen Arbiter-Knoten. Von den datentragenden Knoten gilt ein und nur ein Mitglied als primärer Knoten, während die anderen Knoten als sekundäre Knoten gelten.
Der primärer Knoten erhält alle Schreiboperationen. Ein Replikatsatz kann nur einen primären Server haben, der Schreibvorgänge mit { w:"Mehrheit" } Anliegen schreiben; obwohl unter manchen Umständen eine andere Mongod-Instanz vorübergehend glauben kann, ebenfalls primär zu sein.
Sehen Sie sich die Konfiguration des Replikatsatzes an.Verwenden Sie rs.conf()

Replikatsatz ermöglicht es Ihnen, Ihre MongoDB-Sammlungen in Elasticsearch zu indizieren und in Echtzeit zu synchronisieren.