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). 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 sia ruoli integrati con ambito a livello di database, come,,,, `read` `readWrite` `readAnyDatabase``clusterAdmin`, 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 di 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.
**Topics**
+ [Concetti RBAC](#role_based_access_control-concepts)
+ [Guida introduttiva ai ruoli integrati RBAC](#role_based_access_control-getting_started)
+ [Guida introduttiva ai ruoli RBAC definiti dall'utente](#w2aac31c29c15)
+ [Connessione ad Amazon DocumentDB come utente](#role_based_access_control-connecting_as_user)
+ [Comandi comuni](#role_based_access_control-common_commands)
+ [Differenze funzionali](#role_based_access_control-functional_differences)
+ [Limits](#role_based_access_control-limits)
+ [Accesso al database tramite Role-Based Access Control](#role_based_access_control-built_in_roles)
## 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](security.managing-users.md)
+ **Utente**: una singola entità che può 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'utente `sample-user` avrà i permessi di lettura in`sample-database`.
![\[Esempio di codice che mostra un comando createUser che indica nome utente, password e autorizzazioni.\]](http://docs.aws.amazon.com/it_it/documentdb/latest/developerguide/images/rbac-createuser-command.png)
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`.
![\[Esempio di output di codice che mostra il risultato del comando CreateUser che definisce il nuovo ID utente, il database di amministrazione a cui è assegnato il nuovo utente e le autorizzazioni di ruolo applicate all'utente.\]](http://docs.aws.amazon.com/it_it/documentdb/latest/developerguide/images/rbac-createuser-output-json.png)
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](#role_based_access_control-common_commands).
## 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.
+ `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 database `sample-database-1`, nello stesso cluster.
+ `user3` è un dipendente esistente che deve visualizzare e accedere a un database diverso, `sample-database-2` a 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 tramite Role-Based Access Control](#role_based_access_control-built_in_roles).
**Nota**
In Amazon DocumentDB, tutte le operazioni relative agli utenti e ai ruoli (ad esempio`create`,`get`,`drop`,`grant`,`revoke`, ecc.) vengono eseguite implicitamente nel `admin` database indipendentemente dal fatto che tu stia emettendo comandi sul database o meno. `admin`
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](security.managing-users.md).
```
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 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 necessita solo dell'azione 'find' 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, a `sample-database-2` cui non aveva 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 'find' per tutte le raccolte nel database `sample-database-1` con il seguente comando. Nota 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 esistente, prima crea l'utente`user3`, quindi crea un nuovo ruolo chiamato collectionRole che 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 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 visualizzare 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 database`test`, 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`.
**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**: 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**: 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**: 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'`listChangeStreams`azione viene applicata a livello di cluster (ovvero su tutti i database) e può essere applicata a livello di database e cluster. `modifyChangeStreams`
## Limits
La tabella seguente contiene i limiti per il controllo degli accessi basato sui ruoli 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 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.
**Nota**
In Amazon DocumentDB 4.0 e 5.0, i `ListDatabase` comandi `ListCollection` and possono utilizzare facoltativamente i `authorizedDatabases` parametri `authorizedCollections` e per elencare le raccolte e i database a cui l'utente è autorizzato ad accedere richiedendo rispettivamente i `listDatabase` ruoli `listCollections` and. Inoltre, gli utenti ora hanno la possibilità di eliminare i propri cursori senza richiedere il ruolo. `KillCursor`
------
#### [ Database user ]
****
| Nome ruolo | Description | Azioni |
| --- | --- | --- |
| read | Concede a un utente l'accesso in lettura al database specificato. | `[changeStreams](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html)` `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 | Description | 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 | Description | 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 | Description | 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 | Description | 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 | Description | 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` |
------