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 utilizzando Role-Based Controllo degli accessi
Puoi limitare l'accesso alle azioni che gli utenti possono eseguire sui database utilizzando controllo degli accessi basato sui ruoli (RBAC) in Amazon DocumentDB (con compatibilità MongoDB). RBAC funziona 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 entrambi i ruoli integrati con ambito a livello di database, come read, readWrite, readAnyDatabase, clusterAdmine ruoli definiti dall'utente che possono essere assegnati ad azioni specifiche e risorse granulari, come le raccolte in base alle esigenze dell'utente.
I casi d'uso più comuni per 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 la progettazione di applicazioni multi-tenant che consentono a un singolo utente di accedere a un determinato database o raccolta in un cluster.
Nota
Tutti i nuovi utenti creati prima del 26 marzo 2020 hanno ottenuto i ruoli dbAdminAnyDatabase, readWriteAnyDatabase e clusterAdmin. Ti consigliamo di rivalutare tutti gli utenti esistenti e modificare i ruoli in base alle necessità per applicare i privilegi minimi per i cluster.
Argomenti
Concetti RBAC
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.
-
Utente — Una singola entità in grado di autenticarsi nel database ed eseguire operazioni.
-
• Password — Un segreto utilizzato per autenticare l'utente.
-
• Ruolo — Autorizza un utente a eseguire azioni su uno o più database.
-
Database di amministrazione — Il database in cui gli utenti sono archiviati e su cui sono autorizzati.
-
Database (
db) — Lo spazio dei nomi all'interno dei cluster che contiene le raccolte per l'archiviazione dei documenti.
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:
-
user: "sample-user"— Indica il nome utente. -
pwd: "abc123"— Indica la password dell'utente. -
role: "read", "db: "sample-database"— Indica che l'utentesample-useravrà i permessi di lettura insample-database.
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.
Quando si creano 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 in 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.
-
user1è un nuovo manager che deve essere in grado di visualizzare e accedere a tutti i database in un cluster. -
user2è un nuovo dipendente che ha bisogno di accedere a un solo databasesample-database-1, nello stesso cluster. -
user3è un dipendente esistente che deve visualizzare e accedere a un database diverso,sample-database-2a cui non aveva accesso prima, nello stesso cluster.
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 utilizzando Role-Based Controllo degli accessi.
Nota
In Amazon DocumentDB, tutte le operazioni relative a utenti e ruoli (ad esempio, create, get, drop, grant, revoke, ecc.) vengono eseguite implicitamente nel admin database indipendentemente dal fatto che si stiano emettendo comandi contro il admin database.
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 definiti dall'utente RBAC
Per aiutarti a iniziare con i ruoli definiti dall'utente, questa sezione illustra uno scenario di esempio in cui viene applicato il privilegio minimo creando ruoli per tre utenti con diverse funzioni lavorative.
In questo esempio, vale quanto segue:
-
user1è un nuovo manager che deve essere in grado di visualizzare e accedere a tutti i database in un cluster. -
user2è un nuovo dipendente che richiede solo l'azione «trova» per un solo database,sample-database-1, nello stesso cluster. -
user3è un dipendente esistente che deve visualizzare e accedere a una raccolta specifica, col2 in un database diverso,sample-database-2a cui non avevano accesso prima, nello stesso cluster. -
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 privilegi di «ricerca» 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 allega il ruolo creato di recente findRole all'utente.
db.createUser( { user: "user2", pwd: "abc123", roles: [] }) db.grantRolesToUser("user2",["findRole"])
Per simulare lo scenario che user3 è un utente esistente, crea prima l'utente user3, quindi crea un nuovo ruolo chiamato collectionRole che nel passaggio successivo assegneremo a user3.
Ora puoi assegnare un nuovo ruolo a user3. Questo nuovo ruolo consentirà user3 per poter inserire, aggiornare, eliminare e trovare l'accesso a una raccolta specifica 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 ruolo collectionFind.
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, su cui stai emettendo comandi, usa db comando nella shell mongo, come segue.
Query:
db
Output:
testSebbene 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:
testQuery:
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-1Query:
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.
Nota
Modifiche a utenti e ruoli si verificheranno implicitamente nel database admin. La creazione di utenti con ruoli con ambito in tutti i database (ad esempio, readAnyDatabase) richiede che tu sia nell’ambito del database admin (ovvero, use
admin) durante la creazione dell'utente, oppure devi specificare esplicitamente il database per il ruolo durante la creazione dell'utente (come illustrato nell'esempio 2 in questa sezione).
Esempio 1: Crea 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: Crea 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: Concessione read ruolo a un utente esistente in un nuovo database.
db.grantRolesToUser("readInFooBar", [{role: "read", db: "bar"}])
Esempio 4: aggiorna il ruolo di un utente.
db.updateUser("readInFooBar", {roles: [{role: "read", db: "foo"}, {role: "read", db: "baz"}]})
Esempio 5: Revoca l'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: Elimina un utente dal cluster.
db.dropUser("readInFooBar")
L'aspetto dell'output di questa operazione è simile al seguente.
trueEsempio 8: Crea 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: Creare un utente e assegnare 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: aggiorna 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 di utenti e ruoli sono archiviate nel admin il database e gli utenti sono autenticati con admin database. 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. Il listChangeStreams l'azione viene applicata a livello di cluster (ovvero su tutti i database) e modifyChangeStreams l'azione può essere applicata a livello di database e di cluster.
Limits
La tabella seguente contiene i limiti per Role-Based Controllo degli accessi in Amazon DocumentDB.
| Description | Limite |
|---|---|
| Numero di utenti per cluster | 1000 |
| Numero di ruoli associati a un utente | 1000 |
| Numero di ruoli definiti dall'utente | 100 |
| Numero di risorse associate a un privilegio | 100 |
Accesso al database utilizzando Role-Based Controllo degli accessi
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.
Nota
In Amazon DocumentDB 4.0 e 5.0, ListCollection e ListDatabase i comandi possono opzionalmente utilizzare authorizedCollections e authorizedDatabases parametri per elencare le raccolte e i database a cui l'utente ha il permesso di accedere richiedendo listCollections e listDatabase ruoli, rispettivamente. Inoltre, gli utenti hanno ora la possibilità di uccidere i propri cursori senza richiedere KillCursor ruolo.
