Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Accesso al database tramite Role-Based Access Control

Puoi limitare l'accesso alle azioni che gli utenti possono eseguire sui database utilizzando il controllo degli accessi basato sui ruoli (RBAC) in Amazon DocumentDB (con compatibilità con MongoDB). RBACfunziona concedendo uno o più ruoli a un utente. Questi ruoli determinano le operazioni che un utente può eseguire sulle risorse del database. Amazon DocumentDB attualmente supporta sia ruoli integrati con ambito a livello di database, come,,,, read readWrite readAnyDatabaseclusterAdmin, sia ruoli definiti dall'utente che possono essere limitati ad azioni specifiche e risorse granulari come raccolte basate sui requisiti dell'utente.

I casi d'uso più comuni RBAC includono l'applicazione dei privilegi minimi mediante la creazione di utenti con accesso in sola lettura ai database o alle raccolte in un cluster e progetti di applicazioni multi-tenant che consentono a un singolo utente di accedere a un determinato database o raccolta in un cluster.

RBACconcetti

Di seguito sono riportati termini e concetti importanti relativi al controllo accessi basato sui ruoli. Per ulteriori informazioni sugli utenti di Amazon DocumentDB, consulta. Gestione degli utenti di Amazon DocumentDB

Il comando seguente crea un utente denominato sample-user.

db.createUser({user: "sample-user", pwd: "abc123", roles: [{role: "read", db: "sample-database"}]})

In questo esempio:

L'esempio seguente mostra l'output dopo aver ottenuto l'utente sample-user con db.getUser(sample-user). In questo esempio, l'utente sample-user risiede nel database admin ma ha il ruolo di lettura per il database sample-database.

Durante la creazione di utenti, se si omette il db campo quando si specifica il ruolo, Amazon DocumentDB attribuirà implicitamente il ruolo al database in cui viene emessa la connessione. Ad esempio, se la connessione viene emessa in relazione al database sample-database ed esegui il comando seguente, l'utente sample-user verrà creato nel database admin e avrà le autorizzazioni readWrite per il database sample-database.

db.createUser({user: "sample-user", pwd: "abc123", roles: ["readWrite"]})

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "user":"sample-user",
   "roles":[
      {
         "db":"sample-database",
         "role":"readWrite"
      }
   ]
}

La creazione di utenti con ruoli con ambito in tutti i database (ad esempio, readAnyDatabase) richiede che tu sia nell’ambito del database admin durante la creazione dell'utente oppure devi specificare esplicitamente il database per il ruolo durante la creazione dell'utente. Per emettere comandi sul database admin, puoi utilizzare il comando use admin. Per ulteriori informazioni, consulta Comandi comuni.

Guida introduttiva ai ruoli integrati RBAC

Per aiutarti a iniziare a utilizzare il controllo accessi basato sui ruoli, questa sezione illustra uno scenario di esempio per l'applicazione dei privilegi minimi creando ruoli per tre utenti con funzioni di lavoro diverse.

Successivamente, sia user1 che user2 lasciano la società e quindi il loro accesso deve essere revocato.

Per creare utenti e concedere ruoli, l'utente per il quale esegui l'autenticazione nel cluster deve disporre di un ruolo associato in grado di eseguire operazioni per createUser e grantRole. Ad esempio, i ruoli admin e userAdminAnyDatabase possono entrambi concedere tali capacità, per esempio. Per le operazioni per ruolo, consulta Accesso al database tramite Role-Based Access Control.

Innanzitutto, per capire quali sono gli utenti e i ruoli correnti nel cluster, puoi eseguire il comando show users, come nell'esempio seguente. Vedrai due utenti serviceadmin e l'utente principale del cluster. Questi due utenti sono sempre presenti e non possono essere eliminati. Per ulteriori informazioni, consulta Gestione degli utenti di Amazon DocumentDB.

show users

Per user1, crea un ruolo con accesso in lettura e scrittura a tutti i database dell'intero cluster con il comando seguente.

db.createUser({user: "user1", pwd: "abc123", roles: [{role: "readWriteAnyDatabase", db: "admin"}]})

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "user":"user1",
   "roles":[
      {
         "role":"readWriteAnyDatabase",
         "db":"admin"
      }
   ]
}

Per user2, crea un ruolo con accesso di sola lettura al database sample-database-1 con il comando seguente.

db.createUser({user: "user2", pwd: "abc123", roles: [{role: "read", db: "sample-database-1"}]})

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "user":"user2",
   "roles":[
      {
         "role":"read",
         "db":"sample-database-1"
      }
   ]
}

Per simulare lo scenario nel quale user3 è un utente esistente, crea innanzitutto l'utente user3 e quindi assegna un nuovo ruolo a user3.

db.createUser({user: "user3", pwd: "abc123", roles: [{role: "readWrite", db: "sample-database-1"}]})

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "user":"user3",
   "roles":[
      {
         "role":"readWrite",
         "db":"sample-database-1"
      }
   ]
}

Ora che l'utente user3 è stato creato, assegna a user3 il ruolo read su sample-database-2.

db.grantRolesToUser("user3", [{role: "read", db: "sample-database-2"}])

Infine, user1 e user2 lasciano l'azienda ed è necessario che il loro accesso al cluster venga revocato. Puoi farlo rilasciando gli utenti, come segue.

db.dropUser("user1")
db.dropUser("user2")

Per garantire che tutti gli utenti dispongano dei ruoli appropriati, puoi elencare tutti gli utenti con il comando seguente.

show users

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "_id":"serviceadmin",
   "user":"serviceadmin",
   "db":"admin",
   "roles":[
      {
         "db":"admin",
         "role":"root"
      }
   ]
}
{
   "_id":"master-user",
   "user":"master-user",
   "db":"admin",
   "roles":[
      {
         "db":"admin",
         "role":"root"
      }
   ]
}
{
   "_id":"user3",
   "user":"user3",
   "db":"admin",
   "roles":[
      {
         "db":"sample-database-2",
         "role":"read"
      },
      {
         "db":"sample-database-1",
         "role":"readWrite"
      }
   ]
}

Guida introduttiva ai ruoli RBAC definiti dall'utente

Per aiutarti a iniziare con i ruoli definiti dall'utente, questa sezione illustra uno scenario di esempio di applicazione del privilegio minimo mediante la creazione di ruoli per tre utenti con funzioni lavorative diverse.

In questo esempio, vale quanto segue:

db.createUser(
	{
	    user: "user1", pwd: "abc123", 
	    roles: [{role: "readWriteAnyDatabase", db: "admin"}]
	}
	)

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "user":"user1",
   "roles":[
      {
         "role":"readWriteAnyDatabase",
         "db":"admin"
      }
   ]
}

Peruser2, crea un ruolo con privilegi di 'find' per tutte le raccolte nel database sample-database-1 con il seguente comando. Tieni presente che questo ruolo garantirebbe che tutti gli utenti associati possano eseguire solo query di ricerca.

db.createRole(
{
    role: "findRole",
    privileges: [
    {
        resource: {db: "sample-database-1", collection: ""}, actions: ["find"]
    }],
    roles: []
}
)

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "role":"findRole",
   "privileges":[
      {
         "resource":{
            "db":"sample-database-1",
            "collection":""
         },
         "actions":[
            "find"
         ]
      }
   ],
   "roles":[
      
   ]
}

Quindi, crea l'utente (user2) e associa all'utente il ruolo creato findRole di recente.

db.createUser(
{
    user: "user2", 
    pwd: "abc123", 
    roles: []
})

	db.grantRolesToUser("user2",["findRole"])

Per simulare lo scenario in cui user3 si tratta di un utente esistenteuser3, crea prima l'utente, quindi crea un nuovo ruolo chiamato a collectionRole cui verrà assegnato nel passaggio successivo. user3

Ora puoi assegnare un nuovo ruolo a. user3 Questo nuovo ruolo permetterà di user3 poter inserire, aggiornare, eliminare e trovare l'accesso a una specifica raccolta col2 in. sample-database-2

db.createUser(
{
    user: "user3", 
    pwd: "abc123", 
    roles: []
})

db.createRole(
{
    role: "collectionRole",
    privileges: [
    {
        resource: {db: "sample-database-2", collection: "col2"}, actions: ["find", "update", "insert", "remove"]
    }],
    roles: []
}
)

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "role":"collectionRole",
   "privileges":[
      {
         "resource":{
            "db":"sample-database-2",
            "collection":"col2"
         },
         "actions":[
            "find",
            "update",
            "insert",
            "remove"
         ]
      }
   ],
   "roles":[
      
   ]
}

Ora che l'utente user3 è stato creato, puoi concedere user3 il ruolocollectionFind.

db.grantRolesToUser("user3",["collectionRole"])

Infine, user1 e user2 lasciano l'azienda ed è necessario che il loro accesso al cluster venga revocato. Puoi farlo rilasciando gli utenti, come segue.

db.dropUser("user1")
db.dropUser("user2")

Per garantire che tutti gli utenti dispongano dei ruoli appropriati, puoi elencare tutti gli utenti con il comando seguente.

show users

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "_id":"serviceadmin",
   "user":"serviceadmin",
   "db":"admin",
   "roles":[
      {
         "db":"admin",
         "role":"root"
      }
   ]
}
{
   "_id":"master-user",
   "user":"master-user",
   "db":"admin",
   "roles":[
      {
         "db":"admin",
         "role":"root"
      }
   ]
}
{
   "_id":"user3",
   "user":"user3",
   "db":"admin",
   "roles":[
      {
         "db":"admin",
         "role":"collectionRole"
      }
   ]
}

Connessione ad Amazon DocumentDB come utente

Quando ti connetti a un cluster Amazon DocumentDB, ti connetti nel contesto di un particolare database. Per impostazione predefinita, se non specifichi un database nella stringa di connessione, ti connetti automaticamente al cluster nell’ambito del database test. Tutti i comandi a livello di raccolta come insert e find sono emessi in relazione alle raccolte nel database test.

Per vedere il database in cui ti trovi o, in altre parole, per impartire comandi, usa il db comando nella shell mongo, come segue.

Query:

db

Output:

test

Sebbene la connessione predefinita possa trovarsi nell’ambito del database test, ciò non significa necessariamente che l'utente associato alla connessione sia autorizzato a eseguire operazioni sul database test. Nello scenario di esempio precedente, se esegui l'autenticazione come utente user3, che ha il ruolo readWrite per il database sample-database-1, l’ambito predefinito della connessione è il database test. Tuttavia, se tenti di inserire un documento in una raccolta nel databasetest, visualizzerai un messaggio di errore di autorizzazione. Questo perché tale utente non è autorizzato a eseguire tale comando su tale database, come illustrato di seguito.

Query:

db

Output:

test

Query:

db.col.insert({x:1})

Output:

WriteCommandError({ "ok" : 0, "code" : 13, "errmsg" : "Authorization failure" })

Se modifichi l’ambito della connessione al database sample-database-1, puoi scrivere nella raccolta per la quale l'utente dispone della relativa autorizzazione.

Query:

use sample-database-1

Output:

switched to db sample-database-1

Query:

db.col.insert({x:1})

Output:

WriteResult({ "nInserted" : 1})

Quando esegui l'autenticazione in un cluster con un determinato utente, puoi anche specificare il database nella stringa di connessione. In questo modo viene rimossa la necessità di eseguire il comando use dopo che l'utente è stato autenticato nel database admin.

La seguente stringa di connessione autentica l'utente in relazione al database admin, ma l’ambito della connessione sarà relativo al database sample-database-1.

mongo "mongodb://user3:abc123@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/sample-database-2"

Comandi comuni

Questa sezione fornisce esempi di comandi comuni che utilizzano il controllo degli accessi basato sui ruoli in Amazon DocumentDB. Devi trovarti nell’ambito del database admin per creare e modificare utenti e ruoli. Puoi utilizzare il comando use admin per passare al database admin.

Esempio 1: creare un utente con read ruolo per il database. foo

db.createUser({user: "readInFooBar", pwd: "abc123", roles: [{role: "read", db: "foo"}]})

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "user":"readInFooBar",
   "roles":[
      {
         "role":"read",
         "db":"foo"
      }
   ]
}

Esempio 2: creare un utente con accesso in lettura su tutti i database.

db.createUser({user: "readAllDBs", pwd: "abc123", roles: [{role: "readAnyDatabase", db: "admin"}]})

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "user":"readAllDBs",
   "roles":[
      {
         "role":"readAnyDatabase",
         "db":"admin"
      }
   ]
}

Esempio 3: concedere read il ruolo a un utente esistente su un nuovo database.

db.grantRolesToUser("readInFooBar", [{role: "read", db: "bar"}])

Esempio 4: Aggiornare il ruolo di un utente.

db.updateUser("readInFooBar", {roles: [{role: "read", db: "foo"}, {role: "read", db: "baz"}]})

Esempio 5: revoca dell'accesso a un database per un utente.

db.revokeRolesFromUser("readInFooBar", [{role: "read", db: "baz"}])

Esempio 6: descrivi un ruolo integrato.

db.getRole("read", {showPrivileges:true})

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "role":"read",
   "db":"sample-database-1",
   "isBuiltin":true,
   "roles":[
      
   ],
   "inheritedRoles":[
      
   ],
   "privileges":[
      {
         "resource":{
            "db":"sample-database-1",
            "collection":""
         },
         "actions":[
            "changeStream",
            "collStats",
            "dbStats",
            "find",
            "killCursors",
            "listCollections",
            "listIndexes"
         ]
      }
   ],
   "inheritedPrivileges":[
      {
         "resource":{
            "db":"sample-database-1",
            "collection":""
         },
         "actions":[
            "changeStream",
            "collStats",
            "dbStats",
            "find",
            "killCursors",
            "listCollections",
            "listIndexes"
         ]
      }
   }

Esempio 7: Eliminare un utente dal cluster.

db.dropUser("readInFooBar")

L'aspetto dell'output di questa operazione è simile al seguente.

true

Esempio 8: creazione di un ruolo con accesso in lettura e scrittura a una raccolta specifica

db.createRole(
{
    role: "collectionRole",
    privileges: [
    {
        resource: {db: "sample-database-2", collection: "col2"}, actions: ["find", "update", "insert", "remove"]
    }],
    roles: []
}
)

L'aspetto dell'output di questa operazione è simile al seguente.

{
   "role":"collectionRole",
   "privileges":[
      {
         "resource":{
            "db":"sample-database-2",
            "collection":"col2"
         },
         "actions":[
            "find",
            "update",
            "insert",
            "remove"
         ]
      }
   ],
   "roles":[
      
   ]
}

Esempio 9: creazione di un utente e assegnazione di un ruolo definito dall'utente

db.createUser(
{
    user: "user3", 
    pwd: "abc123", 
    roles: []
})

db.grantRolesToUser("user3",["collectionRole"])

Esempio 10: concedere privilegi aggiuntivi a un ruolo definito dall'utente

db.grantPrivilegesToRole(
  "collectionRole",
  [
    {
      resource: { db: "sample-database-1", collection: "col1" },
      actions: ["find", "update", "insert", "remove"]
    }
  ]
)

Esempio 11: rimuovere i privilegi da un ruolo definito dall'utente

db.revokePrivilegesFromRole(
  "collectionRole",
  [
    {
      resource: { db: "sample-database-1", collection: "col2" },
      actions: ["find", "update", "insert", "remove"]
    }
  ]
)

Esempio 12: aggiornamento di un ruolo definito dall'utente esistente

db.updateRole(
  "collectionRole",
  {
    privileges: [
    {
        resource: {db: "sample-database-3", collection: "sample-collection-3"}, actions: ["find", "update", "insert", "remove"]
    }],
    roles: []
  }
)

Differenze funzionali

In Amazon DocumentDB, le definizioni degli utenti e dei ruoli vengono archiviate nel admin database e gli utenti vengono autenticati tramite il database. admin Questa funzionalità differisce da MongoDB Community Edition, ma è coerente con MongoDB Atlas.

Amazon DocumentDB supporta anche i flussi di modifica, che forniscono una sequenza ordinata nel tempo di eventi di modifica che si verificano all'interno delle raccolte del cluster. L'listChangeStreamsazione viene applicata a livello di cluster (ovvero su tutti i database) e può essere applicata a livello di database e cluster. modifyChangeStreams

Limiti

La tabella seguente contiene i limiti per il controllo degli accessi basato sui ruoli in Amazon DocumentDB.

Accesso al database tramite Role-Based Access Control

Con il controllo accessi basato sui ruoli, puoi creare un utente e concedere uno o più ruoli per determinare le operazioni che l'utente può eseguire in un database o in un cluster.

Di seguito è riportato un elenco di ruoli integrati attualmente supportati in Amazon DocumentDB.

Database user

Nome ruolo	Descrizione	Azioni
read	Concede a un utente l'accesso in lettura al database specificato.	changeStreams collStats dbStats find killCursors listIndexes listCollections
readWrite	Concede all'utente l'accesso in lettura e scrittura al database specificato.	Tutte le operazioni dalle autorizzazioni read. createCollection dropCollection createIndex dropIndex insert killCursors listIndexes listCollections remove update

Cluster user

Nome ruolo	Descrizione	Azioni
readAnyDatabase	Concede a un utente l'accesso in lettura a tutti i database nel cluster.	Tutte le operazioni dalle autorizzazioni read. listChangeStreams listDatabases
readWriteAnyDatabase	Concede a un utente l'accesso in lettura e scrittura a tutti i database nel cluster.	Tutte le operazioni dalle autorizzazioni readWrite. listChangeStreams listDatabases
userAdminAnyDatabase	Concede a un utente la possibilità di assegnare e modificare i ruoli o i privilegi di un utente al database specificato.	changeCustomData changePassword createUser dropRole dropUser grantRole listDatabases revokeRole viewRole viewUser
dbAdminAnyDatabase	Concede a un utente la possibilità di eseguire ruoli di amministrazione del database su qualsiasi database specificato.	Tutte le operazioni dalle autorizzazioni dbAdmin. dropCollection listDatabases listChangeStreams modifyChangeStreams

Superuser

Nome ruolo	Descrizione	Azioni
root	Concede a un utente l'accesso alle risorse e alle operazioni di tutti i ruoli seguenti combinati: readWriteAnyDatabase, dbAdminAnyDatabase, userAdminAnyDatabase, clusterAdmin, restore e backup.	Tutte le operazioni da readWriteAnyDatabase, dbAdminAnyDatabase, userAdminAnyDatabase, clusterAdmin, restore e backup.

Database administrator

Nome ruolo	Descrizione	Azioni
dbAdmin	Concede a un utente la possibilità di eseguire attività amministrative nel database specificato.	bypassDocumentValidation collMod collStats createCollection createIndex dropCollection dropDatabase dropIndex dbStats find killCursors listIndexes listCollections modifyChangeStreams
dbOwner	Concede a un utente la possibilità di eseguire qualsiasi attività amministrativa nel database specificato combinando i ruoli dbAdmin e readWrite.	Tutte le operazioni da dbAdmin e readWrite.

Cluster administrator

Nome del ruolo	Descrizione	Azioni
clusterAdmin	Concede a un utente il massimo accesso alla gestione del cluster combinando i ruoli clusterManager, clusterMonitor e hostManager.	Tutte le operazioni da clusterManager, clusterMonitor e hostManager. listChangeStreams dropDatabase modifyChangeStreams
clusterManager	Concede a un utente la possibilità di eseguire operazioni di gestione e monitoraggio nel cluster specificato.	listChangeStreams listSessions modifyChangeStreams replSetGetConfig
clusterMonitor	Concede a un utente la possibilità di avere accesso in sola lettura agli strumenti di monitoraggio.	collStats dbStats find getParameter hostInfo indexStats killCursors listChangeStreams listCollections listDatabases listIndexes listSessions replSetGetConfig serverStatus top
hostManager	Concede a un utente la possibilità di monitorare e gestire i server.	auditConfigure killCursors killAnyCursor killAnySession killop

Backup administrator

Nome ruolo	Descrizione	Azioni
backup	Concede a un utente l'accesso necessario per eseguire il backup dei dati.	getParameter insert find listChangeStreams listCollections listDatabases listIndexes update
restore	Concede a un utente l'accesso necessario per ripristinare i dati.	bypassDocumentValidation changeCustomData changePassword collMod createCollection createIndex createUser dropCollection dropRole dropUser getParameter grantRole find insert listCollections modifyChangeStreams revokeRole remove viewRole viewUser update