Come proteggere MongoDB con nome utente e password

Voglio impostare l'autenticazione con nome utente e password per la mia istanza MongoDB, in modo che qualsiasi accesso remoto richieda il nome utente e la password. Ho provato il tutorial dal sito MongoDB e ho fatto quanto segue:

use admin
db.addUser('theadmin', '12345');
db.auth('theadmin','12345');

Dopo di ciò, sono uscito e ho corso di nuovo mongo. E non ho bisogno di password per accedervi. Anche se mi collego al database in remoto, non mi viene richiesto il nome utente e la password.

AGGIORNAMENTO Ecco la soluzione che ho finito per usare

1) At the mongo command line, set the administrator:

    use admin;
    db.addUser('admin','123456');

2) Shutdown the server and exit

    db.shutdownServer();
    exit

3) Restart mongod with --auth

  $ sudo ./mongodb/bin/mongod --auth --dbpath /mnt/db/

4) Run mongo again in 2 ways:

   i) run mongo first then login:

        $ ./mongodb/bin/mongo localhost:27017
        use admin
        db.auth('admin','123456');

  ii) run & login to mongo in command line.

        $ ./mongodb/bin/mongo localhost:27017/admin -u admin -p 123456

Il nome utente e la password funzioneranno allo stesso modo per mongodumpe mongoexport.

È necessario iniziare mongodcon l' --authopzione dopo aver impostato l'utente.

Dal sito MongoDB:

Eseguire il database (processo mongod) con l' --authopzione per abilitare la sicurezza. È necessario aver aggiunto un utente al db admin prima di avviare il server --autho aggiungere il primo utente dall'interfaccia localhost.

Autenticazione MongoDB

Wow così tante risposte complicate / confuse qui.

Questo è dalla v3.4 .

Risposta breve.

1) Avviare MongoDB senza controllo di accesso.

mongod --dbpath /data/db

2) Connettersi all'istanza.

mongo

3) Creare l'utente.

use some_db
db.createUser(
  {
    user: "myNormalUser",
    pwd: "xyz123",
    roles: [ { role: "readWrite", db: "some_db" },
             { role: "read", db: "some_other_db" } ]
  }
)

4) Arrestare l'istanza MongoDB e avviarla nuovamente con il controllo di accesso.

mongod --auth --dbpath /data/db

5) Connettiti e autenticati come utente.

use some_db
db.auth("myNormalUser", "xyz123")
db.foo.insert({x:1})
use some_other_db
db.foo.find({})

Risposta lunga: leggi questo se vuoi capire correttamente.

È davvero semplice Mi stupirò di seguito https://docs.mongodb.com/manual/tutorial/enable-authentication/

Se vuoi saperne di più su ciò che i ruoli effettivamente fanno, leggi di più qui: https://docs.mongodb.com/manual/reference/built-in-roles/

1) Avviare MongoDB senza controllo di accesso.

mongod --dbpath /data/db

2) Connettersi all'istanza.

mongo

3) Creare l'amministratore utente. Di seguito viene creato un amministratore utente nel admindatabase di autenticazione. L'utente è dbOwnersul some_dbdatabase e NON sul admindatabase, questo è importante da ricordare.

use admin
db.createUser(
  {
    user: "myDbOwner",
    pwd: "abc123",
    roles: [ { role: "dbOwner", db: "some_db" } ]
  }
)

O se si desidera creare un amministratore che è admin su qualsiasi database:

use admin
db.createUser(
  {
    user: "myUserAdmin",
    pwd: "abc123",
    roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
  }
)

4) Arrestare l'istanza MongoDB e avviarla nuovamente con il controllo di accesso.

mongod --auth --dbpath /data/db

5) Connettersi e autenticarsi come amministratore utente verso il admindatabase di autenticazione, NON verso il some_dbdatabase di autenticazione. L'amministratore utente è stato creato nel admindatabase di autenticazione, l'utente non esiste nel some_dbdatabase di autenticazione.

use admin
db.auth("myDbOwner", "abc123")

Ora sei autenticato come dbOwnersopra il some_dbdatabase. Quindi ora se desideri leggere / scrivere / fare cose direttamente nel some_dbdatabase puoi cambiarlo.

use some_db
//...do stuff like db.foo.insert({x:1})
// remember that the user administrator had dbOwner rights so the user may write/read, if you create a user with userAdmin they will not be able to read/write for example.

Altre informazioni sui ruoli: https://docs.mongodb.com/manual/reference/built-in-roles/

Se desideri creare altri utenti che non sono amministratori utenti e che sono solo utenti normali, continua a leggere di seguito.

6) Creare un utente normale. Questo utente verrà creato nel some_dbdatabase di autenticazione in basso.

use some_db
db.createUser(
  {
    user: "myNormalUser",
    pwd: "xyz123",
    roles: [ { role: "readWrite", db: "some_db" },
             { role: "read", db: "some_other_db" } ]
  }
)

7) Esci dalla shell mongo, riconnetti, autentica come utente.

use some_db
db.auth("myNormalUser", "xyz123")
db.foo.insert({x:1})
use some_other_db
db.foo.find({})

Per prima cosa, #auth=trueannulla la commento della riga che inizia con nel file di configurazione di mongod (percorso predefinito /etc/mongo.conf). Ciò consentirà l'autenticazione per mongodb.

Quindi, riavvia mongodb: sudo service mongod restart

Questa risposta è per Mongo 3.2.1 Riferimento

Terminale 1:

$ mongod --auth

Terminale 2:

db.createUser({user:"admin_name", pwd:"1234",roles:["readWrite","dbAdmin"]})

se si desidera aggiungere senza ruoli (facoltativo):

db.createUser({user:"admin_name", pwd:"1234", roles:[]})

per verificare se autenticato o meno:

db.auth("admin_name", "1234")

dovrebbe darti:

1

altro :

Error: Authentication failed.
0

Ecco un codice javascript per aggiungere utenti.

1. Inizia mongodcon--auth = true

2. Accedi al database di amministrazione dalla shell mongo e passa il file javascript.

   mongo admin "Nomefile.js"

   "Filename.js"

   // Adding admin user
   db.addUser("admin_username", " admin_password");
   // Authenticate admin user
   db.auth("admin_username ", " admin_password ");
   // use  database code from java script
   db = db.getSiblingDB("newDatabase");
   // Adding newDatabase database user  
   db.addUser("database_username ", " database_ password ");

3. Ora l'aggiunta dell'utente è completa, possiamo verificare l'accesso al database dalla shell mongo

https://docs.mongodb.com/manual/reference/configuration-options/#security.authorization

Modifica il file delle impostazioni di mongo;

sudo nano /etc/mongod.conf

Aggiungi la riga:

security.authorization : enabled

Riavvia il servizio

sudo service mongod restart

Saluti

Eseguire prima mongoDB sul terminale usando

mongod

ora esegui mongo shell usa i seguenti comandi

    use admin
db.createUser(
  {
    user: "myUserAdmin",
    pwd: "abc123",
    roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
  }
)

Riavvia l'istanza MongoDB con controllo degli accessi.

mongod --auth

Ora autenticati dalla riga di comando utilizzando

mongo --port 27017 -u "myUserAdmin" -p "abc123" --authenticationDatabase "admin"

L'ho letto da

https://docs.mongodb.com/manual/tutorial/enable-authentication/

Questo è quello che ho fatto su Ubuntu 18.04:

$ sudo apt install mongodb
$ mongo
> show dbs
> use admin
> db.createUser({  user: "root",  pwd: "rootpw",  roles: [ "root" ]  })  // root user can do anything
> use lefa
> db.lefa.save( {name:"test"} )
> db.lefa.find()
> show dbs
> db.createUser({  user: "lefa",  pwd: "lefapw",  roles: [ { role: "dbOwner", db: "lefa" } ]  }) // admin of a db
> exit
$ sudo vim /etc/mongodb.conf
auth = true
$ sudo systemctl restart mongodb
$ mongo -u "root" -p "rootpw" --authenticationDatabase  "admin"
> use admin
> exit
$ mongo -u "lefa" -p "lefapw" --authenticationDatabase  "lefa"
> use lefa
> exit

Si potrebbe cambiare /etc/mongod.conf.

Prima

#security:

Dopo

security:
    authorization: "enabled"

Poi sudo service mongod restart

Seguire i passaggi seguenti in ordine

• Creare un utente utilizzando l'interfaccia della riga di comando

use admin
db.createUser(
  {
    user: "admin",
    pwd: "admin123",
    roles: [ { role: "userAdminAnyDatabase", db: "admin" }, "readWriteAnyDatabase" ]
  }
)

• Abilita l'autenticazione, il modo in cui lo fai differisce in base al tuo sistema operativo, se stai usando Windows puoi semplicemente mongod --authin caso di Linux puoi modificare il /etc/mongod.conffile da aggiungere security.authorization : enablede quindi riavviare il servizio mongd
• Per connettersi tramite cli mongo -u "admin" -p "admin123" --authenticationDatabase "admin". Questo è tutto

Puoi dare un'occhiata a questo post per entrare in maggiori dettagli e per imparare a collegarti usando la mangusta.

Creazione utente con password per un database specifico per proteggere l'accesso al database:

use dbName

db.createUser(
   {
     user: "dbUser",
     pwd: "dbPassword",
     roles: [ "readWrite", "dbAdmin" ]
   }
)

Dovrai passare al database su cui vuoi che l'utente (non l'amministratore db) ...

use mydatabase

Vedi questo post per ulteriori informazioni ... https://web.archive.org/web/20140316031938/http://learnmongo.com/posts/quick-tip-mongodb-users/

Questi passaggi hanno funzionato su di me:

1. scrivi mongod --port 27017 su cmd
2. quindi connettersi alla shell mongo: mongo --port 27017
3. crea l'utente admin: usa admin db.createUser ({utente: "myUserAdmin", pwd: "abc123", ruoli: [{ruolo: "userAdminAnyDatabase", db: "admin"}]})
4. scollegare la shell mongo
5. riavviare il mongodb: mongod --auth --port 27017
6. avvia mongo shell: mongo --port 27017 -u "myUserAdmin" -p "abc123" --authenticationDatabase "admin"
7. Per eseguire l'autenticazione dopo la connessione, collegare la shell mongo al mongod: mongo --port 27017
8. passare al database di autenticazione: utilizzare admin db.auth ("myUserAdmin", "abc123"

Le migliori pratiche per connettersi a mongoDB come segue:

1. Dopo l'installazione iniziale,

   use admin

2. Quindi eseguire il seguente script per creare l'utente amministratore

   db.createUser( { user: "YourUserName", pwd: "YourPassword", roles: [ { role: "userAdminAnyDatabase", db: "admin" }, { role: "readWriteAnyDatabase", db: "admin" }, { role: "dbAdminAnyDatabase", db: "admin" }, { role: "clusterAdmin", db: "admin" } ] })

il seguente script creerà l'utente admin per il DB.

3. accedi a db.admin usando

   mongo -u YourUserName -p YourPassword admin

4. Dopo l'accesso, è possibile creare un numero N del database con le stesse credenziali di amministratore o diverso ripetendo da 1 a 3.

Ciò consente di creare diversi utenti e password per la diversa raccolta che si sta creando in MongoDB

dopo aver creato un nuovo utente, non dimenticare di grant read/write/rootautorizzare l'utente. puoi provare il

cmd: db.grantRolesToUser('yourNewUsername',[{ role: "root", db: "admin" }])