Bereitstellen von mongodb replicaset-Server mit Docker auf verschiedenen physikalischen Servern

Ich versuche zum bereitstellen einer mongodb replicaset mit docker.
Ich habe es geschafft, an ein und demselben server durch ausführen dieser :

docker run -d --expose 27017 --name mongodbmycompany1 dockerfile/mongodb mongod --replSet rsmycompa
docker run -d --expose  27017 --name mongodbmycompany2 dockerfile/mongodb mongod --replSet rsacommeassure
docker run -d --expose 27017 --name mongodbmycompany3 dockerfile/mongodb mongod --replSet rsacommeassure

MONGODB1=$(docker inspect --format '{{ .NetworkSettings.IPAddress }}' mongodbmycompany1)
MONGODB2=$(docker inspect --format '{{ .NetworkSettings.IPAddress }}' mongodbmycompany2)
MONGODB3=$(docker inspect --format '{{ .NetworkSettings.IPAddress }}' mongodbmycompany3)

echo $MONGODB1
echo $MONGODB2
echo $MONGODB3

echo "Mongodb Replicaset init"
docker exec mongodbmycompany1 mongo 127.0.0.1:27017/mycompany --eval 'if(!rs.conf()) {     rs.initiate(); cfg = rs.conf(); cfg.members[0].host = "'$MONGODB1':27017"; rs.reconfig(cfg); rs.add("'$MONGODB2':27017"); rs.add("'$MONGODB3':27017"); } rs.status();'

Funktioniert es wie erwartet. Meine replicaset initialisiert wird und meine mongodb resultset-config enthält meine 3 Server identifiziert durch Ihre interne IP-Adresse.
Es ist nicht perfekt, da würde ich es vorziehen, verwenden Sie Server-Namen, aber ich schaffte es nicht, es zu tun.
Andockfenster nur Auffüllen jeder /etc/hosts-Datei mit dem Server-Namen übergeben, im Bild Start mit --link-parameter. Wenn ich einen neuen server hinzuzufügen, während die anderen ausgeführt werden. Dieser Server nicht pingen Sie den neuen server.

Nun habe ich noch eine Frage. In der Produktion, mit einer Menge von Mongodb docker-image läuft auf dem gleichen physischen server ist möglich, aber es ist nicht sicher :
- wenn meine physischen server herunter fällt, verliere ich alle meine Mongodb-Replikate und mein service ist down
- wenn meine physischen server verwendet den internen Speicher, alle meine docker-images verwenden Sie die gleiche Festplatte... und ich bin zu haben, IO-Probleme.

Also meine Frage ist : Wie kann ich bereitstellen viele mongodb Replikate auf mehreren physischen Servern ? Wie diese mongodb Repliken kommunizieren kann mit jeder anderen (primäre und sekundäre Server ändern kann), während Sie auf anderen Servern oder sogar auf verschiedenen Datencentern ?

Was ist genau dein problem dabei? Was usign OpenStack zu planen, der Docker-container auf Ihrem mehrere physikalische Knoten?
Ich werde haben Sie einen Blick auf OpenStack um das problem zu lösen. Haben Sie ein Dokument, in dem OpenStack wird für die Verwaltung von mongodb-Andockfenster-Dateien, um ein replicaset verteilt auf viele Server ?
Nein, ich habe gerade verwendet OpenStack zu instatiate Andockfenster für Zwecke anders aus, erstellen einer MongoDB replica set.
Sie benötigen ein virtuelles LAN, das wirkt wie eine einzige sichtbar-Netzwerk-bridge, die für Ihre docker-container. Haben Sie einen Blick auf coreos/Flanell. Diese lösen Ihre Vernetzung mit geringstem Aufwand.

InformationsquelleAutor Pierre Le Roux | 2014-11-28

docker mongodb

15

Angenommen:
1. Sie haben 3 verschiedene docker-hosts (Servern), die mit IPs 10.1.1.101, 10.1.1.102, 10.1.1.103
2. bereitstellen möchten, eine einzige Replik-set mit dem Namen rsacommeassure
3. Dockerfiles für mongodb setzen port 27017
4. alle Server in einer vertrauenswürdigen zone und können miteinander reden
Zuerst beginnen wir mongodb Container auf jedem server (10.1.1.101 ~$ verwendet wird für die Eingabeaufforderung):
```
10.1.1.101 ~$ docker run -d -p 27017:27017 --name mongodbmycompany1 dockerfile/mongodb mongod --replSet rsacommeassure
10.1.1.102 ~$ docker run -d -p 27017:27017 --name mongodbmycompany2 dockerfile/mongodb mongod --replSet rsacommeassure
10.1.1.103 ~$ docker run -d -p 27017:27017 --name mongodbmycompany3 dockerfile/mongodb mongod --replSet rsacommeassure
```
-p 27017:27017 macht port 27017 auf dem host-IP, so dass "mongo" ist zugänglich auf dem Server-host-IP-Adresse.

Dann müssen Sie initiieren die Replikatgruppe, so führen Sie einfach diese gegen eine mongodb-container (ich Hole server1 hier):
```
your_laptop ~$ > mongo --host 10.1.1.101 
MongoDB shell version: 2.6.9
connecting to: test
> rs.initiate()
> cfg = rs.conf()
> cfg.members[0].host = "10.1.1.101:27017"
> rs.reconfig(cfg)
> rs.add("10.1.1.102:27017")
> rs.add("10.1.1.103:27017") 
> rs.status();
```
Die IPs sind lokale, sondern es arbeitet mit globalen, solange die Server können miteinander reden (VPN, firewall, DMZ, was auch immer). Btw sollten Sie überlegen, Sicherheit gezielt.
- Vielen Dank @milan
- Das ist sehr nützlich. Ich möchte Sie Fragen, ob Sie denken, es wäre auch denkbar, die Verbindung von zwei docker-Container mit einem echten mongo-Instanz. Ich wirklich brauchen, um mit der Synchronisierung ein 450-GB-db-ab einem remote-host mit replica-sets läuft auf meinem Container befindet sich auf einem anderen physischen server.
- klingt wie eine andere Frage, möglicherweise für die serverfault.com
- Danke. Werde ich wohl dort posten zu bitten, einen Hinweis auf die best practice. 🙂
InformationsquelleAutor milan

Ich habe eine Replik auf verschiedenen physischen Servern mithilfe von docker-Maschine und die virtual box als Fahrer:

$ docker-machine create --driver virtualbox server1
$ docker-machine create --driver virtualbox server2
$ docker-machine create --driver virtualbox server3

Öffnen 3 verschiedenen Klemmen, in jedem

$(Terminal1) eval "$(docker-machine env server1)"
$(Terminal2) eval "$(docker-machine env server2)"
$(Terminal3) eval "$(docker-machine env server3)"

In jedem terminal:

$(Terminal1) docker run -d -p 27017:27017 --name mongoClient1 mongo mongod --replSet r1
$(Terminal2) docker run -d -p 27017:27017 --name mongoClient2 mongo mongod --replSet r1
$(Terminal3) docker run -d -p 27017:27017 --name mongoClient3 mongo mongod --replSet r1

Gehen Sie in VirtualBox -> auf jede Umgebung(server1,server2,server3) -> Einstellung -> Netzwerk -> Adapter 1 -> Port Forwarding. Erstellen Sie eine neue Regel aus Protokoll TCP, Host-Port - 27017, Gast-Port - 27017, verlassen die Host-Ip und die Gast-Ip leer

Nun starten Sie die Umgebungen, Sie können dies tun, aus dem VirtualBox oder vom terminal, vom terminal ausgeführt werden:

$(Terminal1) docker-machine restart server1
$(Terminal2) docker-machine restart server2
$(Terminal3) docker-machine restart server3

Starten Sie den Container:

$(Terminal1) docker start mongoClient1
$(Terminal2) docker start mongoClient2
$(Terminal3) docker start mongoClient3

Nun der Container ausgeführt werden sollten, können Sie überprüfen Sie durch ausführen
$ docker ps in jedem terminal

Bekommen in den ersten Behälter(oder ein anderer) Mongo Shell

$(Terminal1) docker exec -it mongoClient1 mongo
//now we are in the Mongo Shell
$(Mongo Shell) rs.initiate()
$(Mongo Shell) cfg = rs.conf()
$(Mongo Shell) cfg.members[0].host = <server1's Ip Address>
//you should get server1's Ip Address by running $ docker-machine ls, mine was 192.168.99.100
$(Mongo Shell) rs.reconfig(cfg)
$(Mongo Shell Primary) rs.add("<server2's Ip Address>:27017")
//now we added a Secondary
$(Mongo Shell Primary) rs.add("<server3's Ip Address>:27017", true)
//now we added an Arbiter
$(Mongo Shell Primary) use planes
//now we create a new database
$(Mongo Shell Primary) db.tranporters.insert({name:'Boeing'})
//create a new collection
$(Mongo Shell Primary) db.tranporters.find()
//we obtain the inserted plane

Verbindung zu einem Sekundären, können Sie entweder:

$(Terminal2) docker exec -it mongoClient2 mongo planes
//or
$(Mongo Shell Primary) db = connect ("<server2's Ip Address>:27017/planes")

Nun sind wir in der Mongo Shell eine Sekundäre

$(Mongo Shell Secondary) rs.slaveOk()
//to allow readings from the Shell
$(Mongo Shell Secondary)db.tranporters.find()
//should return inserted plane

InformationsquelleAutor Relu Mesaros

1

Könnten Sie "Weben - Andockfenster-Netzwerk" um Ihr problem zu lösen einfach.

Gewebe schafft ein overlay-Netzwerk, das verbindet Containern auf verschiedenen hosts, sogar bei unterschiedlichen cloud-Anbietern. Webart versorgt auch einen DNS-Dienst, können Sie sich die Container um den Namen innerhalb der Weave-Netzwerk.
- Bitte nicht nur nach dem link Antworten. Setzen Sie einfach die in wesentlichen teilen den link in deine Antwort
InformationsquelleAutor Thomas Garcia

#Here stop already running instances
docker stop m1 m2 m3
#Cleanup of the volumes
docker rm -f m1 m2 m3

# Start MongoDB services optimised for faster startup
docker run  -dP --name m1 mongo mongod --replSet "r1" --noprealloc --smallfiles --nojournal --syncdelay 0 
docker run  -dP --name m2 mongo mongod --replSet "r1" --noprealloc --smallfiles --nojournal --syncdelay 0 
docker run  -dP --name m3 mongo mongod --replSet "r1" --noprealloc --smallfiles --nojournal --syncdelay 0

export M1_ADDRESS=`docker inspect --format '{{ .NetworkSettings.IPAddress }}' m1`
export M2_ADDRESS=`docker inspect --format '{{ .NetworkSettings.IPAddress }}' m2`
export M3_ADDRESS=`docker inspect --format '{{ .NetworkSettings.IPAddress }}' m3`

docker exec m1 mongo --eval "rs.initiate();"
docker exec m1 mongo --eval "cfg = rs.conf(); cfg.members[0].host = '$M1_ADDRESS:27017'; rs.reconfig(cfg);"
docker exec m1 mongo --eval "rs.add('$M2_ADDRESS:27017');rs.add('$M3_ADDRESS:27017')"

# Check if everything is fine.
docker exec m1 mongo --eval "rs.status();"

InformationsquelleAutor SunnyShah

-2

Ich gescriptet ein docker-image, das setzt eine mongodb replicaSet für eine beliebige Anzahl von Containern und automatisiert Skalierung, wie Sie weitere Container hinzufügen. überprüfen Sie auf der github github repo oder docker registry

Verwenden Docker Compose

einrichten von docker-Komponieren.yml
```
version: "2"
services:
  <your_service_name>:
     image: rollymaduk/mongo-replica:local
     environment:
       REPLICA_NAME: "<your_replica_name>"
     volumes:
     -  /var/config:/var/config
```
führen Sie in der Befehlszeile
```
docker-compose up
```
Skala bis zu mehr Container
```
docker-compose scale <your_service_name>=3
```
Andockfenster Cloud

Zum bereitstellen von mongo-db replicaSet mit docker-cloud legen Sie einen Stapel
Datei

stack.yml: Stapel-Datei, die nicht erfordern, shared volumes
```
<service_name>:
  image: rollymaduk/mongo-replica:cloud
  deployment_strategy: high_availability
  target_num_containers: 3
  environment:
    REPLICA_NAME: <your_replica_name>
    DOCKERCLOUD_AUTH: <your_docker_auth_key>
```
stack.yml: stack Datei erfordert shared volume
```
<service_name>:
  image: rollymaduk/mongo-replica:local
  deployment_strategy: high_availability
  target_num_containers: 3
  volumes:
    - /var/config:/var/config
  environment:
    REPLICA_NAME: <your_replica_name>
```
mithilfe von docker-cloud-cli führen Sie in der Befehlszeile (Falls Stapel-Datei existiert nicht in der cloud)
```
docker-cloud stack create --name <your_stack_name> -f <your_stack_file>

docker-cloud stack start <your_stack_name>
```
mithilfe von docker-cloud-cli führen Sie in der Befehlszeile (Falls Stapel-Datei bereits in der cloud)
```
docker-cloud stack update -f <your_stack_file> <your_stack_name>

docker-cloud stack redeploy <your_stack_name>
```
Wichtig: Sie müssen geben Sie eine freigegebene Volumes und mounten des Containers
config directory [default: /var/config ] das Beispiel unten stellt eine host
Verzeichnis /var/config auf die container-config-Volumen.

Sie können die Andockfenster empfohlene Möglichkeiten zum Austausch von volumes zwischen
Behälter ich.e Montage ein host-Verzeichnis oder Datenträger-container),nur
geben Sie den richtigen Pfad für die config-volume (/var/config).

_to ändern der Standard-config-Verzeichnis verwenden Sie die Umgebungsvariable
--CONFIG_DIR zur Einrichtung Ihres Containers. Stellen Sie sicher, dass update-host-Volumen
Pfad zeigt Ihre neue --CONFIG_DIR name_

InformationsquelleAutor Ronald Maduka

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.