Wie aktiviere ich die Authentifizierung in MongoDB über Docker?

Ich möchte ein Docker für starten, mongodb:latestaber nur bestimmten Benutzern erlauben, auf bestimmte Datenbanken zuzugreifen (dh zu aktivieren --auth). Niemand sonst sollte auf Mongodb zugreifen! Wie soll ich das im Rahmen der Docker-Initiierung tun?

Übrigens, data directorysitzt auf dem Host, indem der folgende Befehl während der Initiierung verwendet wird : -v /my/own/datadir:/data/db.

Wenn Sie sich Folgendes ansehen:

• https://github.com/docker-library/mongo/blob/master/4.2/Dockerfile
• https://github.com/docker-library/mongo/blob/master/4.2/docker-entrypoint.sh#L303-L313

Sie werden feststellen, dass zwei Variablen verwendet werden docker-entrypoint.sh:

• MONGO_INITDB_ROOT_USERNAME
• MONGO_INITDB_ROOT_PASSWORD

Sie können sie verwenden, um den Root-Benutzer einzurichten. Zum Beispiel können Sie folgende docker-compose.ymlDatei verwenden:

mongo-container:
  image: mongo:3.4.2
  environment:
      # provide your credentials here
      - MONGO_INITDB_ROOT_USERNAME=root
      - MONGO_INITDB_ROOT_PASSWORD=rootPassXXX
  ports:
    - "27017:27017"
  volumes:
      # if you wish to setup additional user accounts specific per DB or with different roles you can use following entry point
    - "$PWD/mongo-entrypoint/:/docker-entrypoint-initdb.d/"
  # no --auth is needed here as presence of username and password add this option automatically
  command: mongod

Wenn Sie nun den Container starten docker-compose up, sollten Sie folgende Einträge beachten:

...
I CONTROL  [initandlisten] options: { net: { bindIp: "127.0.0.1" }, processManagement: { fork: true }, security: { authorization: "enabled" }, systemLog: { destination: "file", path: "/proc/1/fd/1" } }
...
I ACCESS   [conn1] note: no users configured in admin.system.users, allowing localhost access
...
Successfully added user: {
    "user" : "root",
    "roles" : [
        {
            "role" : "root",
            "db" : "admin"
        }
    ]
}

Um benutzerdefinierte Benutzer neben root hinzuzufügen, verwenden Sie das exectuable-Skript für den Einstiegspunkt (platziert unter $ PWD / mongo-entrypoint dir, wenn es docker-composeam Einstiegspunkt bereitgestellt wird):

#!/usr/bin/env bash
echo "Creating mongo users..."
mongo admin --host localhost -u USER_PREVIOUSLY_DEFINED -p PASS_YOU_PREVIOUSLY_DEFINED --eval "db.createUser({user: 'ANOTHER_USER', pwd: 'PASS', roles: [{role: 'readWrite', db: 'xxx'}]}); db.createUser({user: 'admin', pwd: 'PASS', roles: [{role: 'userAdminAnyDatabase', db: 'admin'}]});"
echo "Mongo users created."

Das Einstiegspunktskript wird ausgeführt und zusätzliche Benutzer werden erstellt.

ein. Sie können Umgebungsvariablen über das Terminal verwenden:

$ docker run -d --name container_name \
      -e MONGO_INITDB_ROOT_USERNAME=admin \
      -e MONGO_INITDB_ROOT_PASSWORD=password \
      mongo

Wenn Sie testen möchten, ob alles funktioniert:

// ssh into the running container
// Change container name if necessary
$ docker exec -it mongo /bin/bash

// Enter into mongo shell
$ mongo

// Caret will change when you enter successfully
// Switch to admin database
$> use admin
$> db.auth("admin", passwordPrompt())

// Show available databases
$> show dbs

Wenn Sie eine Datenbank beim ersten Ausführen instanziieren möchten, aktivieren Sie die Option b.

b. Sie können Umgebungsvariablen in Ihrer Docker-Stack-Bereitstellungsdatei verwenden oder eine Datei für die Versionen 3.4 bis 4.1 erstellen.

Da es auf dem Schnellreferenzteil des erläutert offiziellen Mongo BildsatzesMONGO_INITDB_ROOT_USERNAME und MONGO_INITDB_ROOT_PASSWORDin Ihrer YAML - Datei:

mongo:
    image: mongo
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: password

Die Datei docker-entrypoint.sh im Mongo-Image prüft, ob diese beiden Variablen vorhanden sind, und setzt das --authFlag entsprechend.

c. Sie können auch Docker-Geheimnisse verwenden.

MONGO_INITDB_ROOT_USERNAMEund MONGO_INITDB_ROOT_PASSWORDwird indirekt von docker-entrypoint.sh von MONGO_INITDB_ROOT_USERNAME_FILEund MONGO_INITDB_ROOT_PASSWORD_FILEVariablen festgelegt:

mongo:
    image: mongo
    environment:
        - MONGO_INITDB_ROOT_USERNAME_FILE=/run/secrets/db_root_username
        - MONGO_INITDB_ROOT_PASSWORD_FILE=/run/secrets/db_root_password
    secrets:
      - db_root_username
      - db_root_password

docker-entrypoint.sh konvertiert MONGO_INITDB_ROOT_USERNAME_FILEund MONGO_INITDB_ROOT_PASSWORD_FILEnach MONGO_INITDB_ROOT_USERNAMEund MONGO_INITDB_ROOT_PASSWORD.

Sie können MONGO_INITDB_ROOT_USERNAMEund MONGO_INITDB_ROOT_PASSWORDin Ihrem .shoder .jsSkripten im docker-entrypoint-initdb.dOrdner verwenden, während Sie die Datenbankinstanz initialisieren.

Wenn ein Behälter zum ersten Mal gestartet wird es Dateien mit den Erweiterungen ausgeführt wird .shund .jsdass gefunden werden /docker-entrypoint-initdb.d. Dateien werden in alphabetischer Reihenfolge ausgeführt. .jsDateien werden von Mongo unter Verwendung der von der MONGO_INITDB_DATABASEVariablen angegebenen Datenbank ausgeführt , sofern vorhanden, oder auf andere Weise getestet. Sie können auch die Datenbank innerhalb des .jsSkripts wechseln .

Diese letzte Methode befindet sich nicht in den Referenzdokumenten, sodass sie ein Update möglicherweise nicht überlebt.

Bessere Lösungen für die Weiterentwicklung:
https://blog.madisonhub.org/setting-up-a-mongodb-server-with-auth-on-docker/ https://docs.mongodb.com/v2.6/tutorial/add -user-Administrator /

Hier ist, was ich für das gleiche Problem getan habe, und es hat funktioniert.

1. Führen Sie die Mongo Docker-Instanz auf Ihrem Server aus

   docker run -d -p 27017:27017 -v ~/dataMongo:/data/db mongo
   

2. Öffnen Sie die Bash auf der laufenden Docker-Instanz.

   docker ps
   

   BEHÄLTER-IDIMAGE-BEFEHL ERSTELLTE STATUS-PORTS-NAMEN

   b07599e429fb mongo "docker-entrypoint ..." vor 35 Minuten Up 35 Minuten 0.0.0.0:27017->27017/tcp musing_stallman

   docker exec -it b07599e429fb bash
   root@b07599e429fb:/#
   

   Referenz- https://github.com/arunoda/meteor-up-legacy/wiki/Accessing-the-running-Mongodb-docker-container-from-command-line-on-EC2

3. Betreten Sie die Mongo-Shell, indem Sie Mongo eingeben.

   root@b07599e429fb:/# mongo
   

4. In diesem Beispiel werde ich einen Benutzer namens ian einrichten und diesem Benutzer Lese- und Schreibzugriff auf die Datenbank cool_db gewähren.

   > use cool_db
   
   > db.createUser({
       user: 'ian',
       pwd: 'secretPassword',
       roles: [{ role: 'readWrite', db:'cool_db'}]
   })
   

   Referenz: https://ianlondon.github.io/blog/mongodb-auth/ (nur erster Punkt)

5. Verlassen Sie die Mongod-Muschel und schlagen Sie.

6. Stoppen Sie die Docker-Instanz mit dem folgenden Befehl.

   docker stop mongo
   

7. Führen Sie nun den Mongo Docker mit aktivierter Authentifizierung aus.

   docker run -d -p 27017:27017 -v ~/dataMongo:/data/db mongo mongod --auth
   

   Referenz: Wie aktiviere ich die Authentifizierung in MongoDB über Docker? (Usman Ismails Antwort auf diese Frage)

8. Mit dem folgenden Befehl konnte ich von meinem lokalen Windows-Laptop aus eine Verbindung zu der auf einem Google Cloud-Server ausgeführten Instanz herstellen.

   mongo <ip>:27017/cool_db -u ian -p secretPassword
   

   Referenz: Wie kann ich vom Mac OS-Terminal aus eine Verbindung zu einem Remote-Mongo-Server herstellen?

Es fällt mir schwer, es zu versuchen

• Erstellen Sie eine andere Datenbank als admin
• Fügen Sie neue Benutzer hinzu und aktivieren Sie die Authentifizierung für die obige Datenbank

Also habe ich 2020 hier antworten lassen

Mein Verzeichnis sieht so aus

├── docker-compose.yml
└── mongo-entrypoint
    └── entrypoint.js

Mein docker-compose.ymlsieht so aus

version: '3.4'
services:
  mongo-container:
    # If you need to connect to your db from outside this container 
    network_mode: host
    image: mongo:4.2
    environment:
        - MONGO_INITDB_ROOT_USERNAME=admin
        - MONGO_INITDB_ROOT_PASSWORD=pass
    ports:
      - "27017:27017"
    volumes:
      - "$PWD/mongo-entrypoint/:/docker-entrypoint-initdb.d/"
    command: mongod

Bitte ändern Sie adminund passmit Ihrem Bedarf.

Im Inneren habe mongo-entrypointich entrypoint.jsDatei mit diesem Inhalt:

var db = connect("mongodb://admin:pass@localhost:27017/admin");

db = db.getSiblingDB('new_db'); // we can not use "use" statement here to switch db

db.createUser(
    {
        user: "user",
        pwd: "pass",
        roles: [ { role: "readWrite", db: "new_db"} ],
        passwordDigestor: "server",
    }
)

Auch hier müssen Sie admin:passIhre Root-Mongo-Anmeldeinformationen in Ihren docker-compose.ymlzuvor angegebenen ändern . In weiteren müssen Sie ändern new_db, user, passzu Ihrem neuen Datenbanknamen und Anmeldeinformationen , die Sie benötigen.

Jetzt kannst du:

docker-compose up -d

Und stellen Sie von localhost aus eine Verbindung zu dieser Datenbank her. Bitte beachten Sie, dass ich bereits mongo cli habe. Sie können es installieren oder im obigen Container ausführen, um den folgenden mongoBefehl zu verwenden :

mongo new_db -u user -p pass

Oder Sie können eine Verbindung von einem anderen Computer aus herstellen

mongo host:27017/new_db -u user -p pass

Mein Git-Repository: https://github.com/sexydevops/docker-compose-mongo

Hoffe es kann jemandem helfen, ich habe meinen Nachmittag dafür verloren;)

Das Dockerfile für das offizielle Mongo-Bild ist hier . Der Standardbefehl ist mongod, aber Sie können ihn überschreiben, um den Schalter --auth hinzuzufügen, vorausgesetzt, die Benutzer sind bereits konfiguriert.

docker run -d .... mongodb:latest mongod --auth

Wenn der Benutzer erstellt werden muss, müssen Sie ein Startskript in ein Volume einbinden /entrypoint.sh, um das Standardstart- Skript zu ersetzen. Anschließend muss dieses Skript Benutzer erstellen und mongo mit dem Auth-Schalter starten.

docker run -d .... -v $PWD/my_custom_script.sh:/entrypoint.sh mongodb:latest

Das Ablegen einer .js-Datei in den Einstiegspunkt-Init-Ordner funktioniert hierfür

zB entrypoint.js

var db = connect("mongodb://localhost/admin");

db.createUser(
    {
        user: "yourAdminUserName",
        pwd: "yourAdminPassword",
        roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
    }
)

docker-compose.yml:

db:
  image: mongo:3.2
  volumes:
   - /my/own/datadir:/data/db
   - ../mongo-entrypoint:/docker-entrypoint-initdb.d

Den Rest von Hand oder mehr der gleichen Arbeiten erledigen.

Wenn Sie möchten, können Sie auch eine .sh-Datei in den init-Ordner legen, um die Dateien zu bereinigen, damit sie nicht herumliegen: zz-cleanup.sh.

Ich möchte einen Kommentar abgeben, habe aber nicht genug Ruf.

Das oben gezeigte ausführbare Skript zum Hinzufügen von Benutzern muss mit --authenticationDatabase admin und NEWDATABASENAME geändert werden .

mongo --authenticationDatabase admin --host localhost -u USER_PREVIOUSLY_DEFINED -p PASS_YOU_PREVIOUSLY_DEFINED NEWDATABASENAME --eval "db.createUser({user: 'NEWUSERNAME', pwd: 'PASSWORD', roles: [{role: 'readWrite', db: 'NEWDATABASENAME'}]});"

https://i.stack.imgur.com/MdyXo.png

@jbochniak: Danke, obwohl ich beim ersten Lesen dachte, ich hätte das alles bereits entdeckt, stellte sich heraus, dass Ihr Beispiel (insbesondere die Version des Mongo Docker-Bildes) mir geholfen hat!

Diese Version (v3.4.2) und die Version 3.4 (die derzeit v3.4.3 entspricht) unterstützen weiterhin 'MONGO_INITDB_ROOT', die über diese Variablen angegeben wurden, ab Version 3.5 (mindestens Tags '3' und 'neueste') NICHT Arbeiten Sie wie in Ihrer Antwort und in den Dokumenten beschrieben.

Ich habe mir schnell den Code auf GitHub angesehen, aber eine ähnliche Verwendung dieser Variablen festgestellt und konnte den Fehler nicht sofort finden. Sollte dies tun, bevor ich ihn als Fehler einreiche ...

Verwenden Sie diese Bilder, um Folgendes zu beheben:

Mit docker-compose.yml

services:
  db:
    image: aashreys/mongo-auth:latest
    environment:
      - AUTH=yes
      - MONGODB_ADMIN_USER=admin
      - MONGODB_ADMIN_PASS=admin123
      - MONGODB_APPLICATION_DATABASE=sample
      - MONGODB_APPLICATION_USER=aashrey
      - MONGODB_APPLICATION_PASS=admin123
    ports:
      - "27017:27017"
     // more configuration

• aashreys / mongo-auth - Docker Hub
• aashreys / docker-mongo-auth: Einfache Einrichtung der Authentifizierung für das offizielle MongoDB-Image von Docker.

Sie können env-Variablen verwenden, um Benutzername und Passwort für Mongo einzurichten

MONGO_INITDB_ROOT_USERNAME
MONGO_INITDB_ROOT_PASSWORD

mit einfachen Docker-Befehl

docker run -e MONGO_INITDB_ROOT_USERNAME=my-user MONGO_INITDB_ROOT_PASSWORD=my-password mongo

mit Docker-Compose

version: '3.1'

services:

  mongo:
    image: mongo
    restart: always
    environment:
      MONGO_INITDB_ROOT_USERNAME: my-user
      MONGO_INITDB_ROOT_PASSWORD: my-password

und die letzte Option besteht darin, manuell auf den Container zuzugreifen und den Benutzer und das Kennwort im Mongo Docker-Container festzulegen

docker exec -it mongo-container bash

Jetzt können Sie mit dem Befehl mongo shell alles konfigurieren, was Sie wollen