As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Acesso ao banco de dados usando o controle de acesso com base em perfil
É possível restringir o acesso às ações que os usuários podem executar nos bancos de dados usando o *role-based access control* (RBAC) no Amazon DocumentDB (compativel com MongoDB). O RBAC funciona concedendo uma ou mais funções a um usuário. Estas funções determinam as operações que um usuário pode realizar nos recursos do banco de dados. Atualmente, o Amazon DocumentDB oferece suporte a funções integradas com o escopo no nível do banco de dados, como `read`, `readWrite`, `readAnyDatabase`, `clusterAdmin`, e funções definidas pelo usuário que podem ter como escopo ações específicas e recursos granulares, como coleções com base em seus requisitos.
Casos de uso comuns para RBAC incluem a imposição de privilégios mínimos criando usuários com acesso somente para leitura aos bancos de dados ou coleções em um cluster e designs de aplicações de vários locatários que permitem que um único usuário acesse um determinado banco de dados ou coleção em um cluster.
**nota**
Todos os usuários criados antes de **26 de março de 2020** receberam as funções `dbAdminAnyDatabase`, `readWriteAnyDatabase` e `clusterAdmin`. Recomenda-se que você reavalie todos os usuários existentes e modifique as funções conforme necessário para impor privilégios mínimos para seus clusters.
**Topics**
+ [Conceitos do RBAC](#role_based_access_control-concepts)
+ [Introdução às funções integradas do RBAC](#role_based_access_control-getting_started)
+ [Introdução às funções definidas pelo usuário do RBAC](#w2aac29c29c15)
+ [Conectar-se ao Amazon DocumentDB como um usuário](#role_based_access_control-connecting_as_user)
+ [Comandos comuns](#role_based_access_control-common_commands)
+ [Diferenças funcionais](#role_based_access_control-functional_differences)
+ [Limites](#role_based_access_control-limits)
+ [Acesso ao banco de dados usando o controle de acesso com base em função](#role_based_access_control-built_in_roles)
## Conceitos do RBAC
Veja a seguir os termos e conceitos importantes relacionados ao controle de acesso baseado em função. Para obter mais informações sobre usuários do Amazon DocumentDB, consulte [Gerenciar usuários do Amazon DocumentDB](security.managing-users.md).
+ **Usuário** — Uma entidade individual que pode se autenticar no banco de dados e realizar operações.
+ **Senha** — Um segredo usado para autenticar o usuário.
+ **Função** — Autoriza um usuário a realizar ações em um ou mais bancos de dados.
+ **Banco de dados administrativo** — O banco de dados no qual os usuários são armazenados e autorizados.
+ **Banco de dados (`db`)**: o namespace dentro dos clusters que contém coleções para armazenar documentos.
O comando a seguir cria um cofre chamado `sample-user`.
```
db.createUser({user: "sample-user", pwd: "abc123", roles: [{role: "read", db: "sample-database"}]})
```
Neste exemplo:
+ `user: "sample-user"` — Indica o nome do usuário.
+ `pwd: "abc123"` — Indica a senha do usuário.
+ `role: "read", "db: "sample-database"` — Indica que o usuário `sample-user` terá permissões de leitura em`sample-database`.
![\[Exemplo de código que mostra um comando createUser indicando o nome de usuário, a senha e as permissões.\]](http://docs.aws.amazon.com/pt_br/documentdb/latest/developerguide/images/rbac-createuser-command.png)
O exemplo a seguir mostra a saída depois que você obtiver o usuário `sample-user` com `db.getUser(sample-user)`. Neste exemplo, o usuário `sample-user` reside no banco de dados `admin`, mas tem a função de leitura no banco de dados `sample-database`.
![\[Exemplo de saída de código mostrando o resultado do comando createUser definindo a nova ID de usuário, o banco de dados administrativo ao qual o novo usuário está atribuído e as permissões de perfil aplicadas ao usuário.\]](http://docs.aws.amazon.com/pt_br/documentdb/latest/developerguide/images/rbac-createuser-output-json.png)
Ao criar usuários, se você omitir o campo `db` ao especificar a função, o Amazon DocumentDB atribuirá implicitamente a função ao banco de dados no qual a conexão está sendo emitida. Por exemplo, se sua conexão for emitida no banco de dados `sample-database` e você executar o comando a seguir, o usuário `sample-user` será criado no banco de dados `admin` e terá permissões `readWrite` no banco de dados `sample-database`.
```
db.createUser({user: "sample-user", pwd: "abc123", roles: ["readWrite"]})
```
A saída dessa operação é semelhante à seguinte.
```
{
"user":"sample-user",
"roles":[
{
"db":"sample-database",
"role":"readWrite"
}
]
}
```
A criação de usuários com funções com escopo em todos os bancos de dados (por exemplo, `readAnyDatabase`) exige que você esteja no contexto do banco de dados `admin` ao criar o usuário ou que indique explicitamente o banco de dados para a função ao criar o usuário. Para emitir comandos no banco de dados `admin`, use o comando `use admin`. Para obter mais informações, consulte [Comandos comuns](#role_based_access_control-common_commands).
## Introdução às funções integradas do RBAC
Para ajudar você a começar a usar o controle de acesso baseado em função, esta seção demonstra um cenário de exemplo de aplicação de privilégios mínimos criando funções para três usuários com funções de trabalho diferentes.
+ O `user1` é um novo gerente que precisa poder visualizar e acessar todos os bancos de dados em um cluster.
+ O `user2` é um novo funcionário que precisa acessar apenas um banco de dados, `sample-database-1`, nesse mesmo cluster.
+ O `user3` é um funcionário existente que precisa visualizar e acessar um banco de dados diferente, `sample-database-2`, ao qual ele não tinha acesso anteriormente, no mesmo cluster.
Em um ponto mais tarde, tanto o `user1` como o `user2` saem da empresa e, portanto, seu acesso deve ser revogado.
Para criar usuários e conceder funções, o usuário com o qual você se autentica no cluster deve ter uma função associada que possa executar ações para `createUser` e `grantRole`. Por exemplo, as funções `admin` e `userAdminAnyDatabase` podem conceder essas capacidades, por exemplo. Para obter ações por função, consulte [Acesso ao banco de dados usando o controle de acesso com base em função](#role_based_access_control-built_in_roles).
**nota**
No Amazon DocumentDB, todas as operações de usuário e função (por exemplo `create`, `get`, `drop`, `grant`, `revoke`, etc.) são implicitamente executadas no banco de dados `admin`independentemente de você estar emitindo comandos ao banco de dados `admin`.
Primeiro, para entender quais são os usuários e funções atuais no cluster, você pode executar o comando `show users`, como no exemplo a seguir. Você verá dois usuários, o `serviceadmin` e o usuário principal do cluster. Esses dois usuários sempre existem e não podem ser excluídos. Para obter mais informações, consulte [Gerenciar usuários do Amazon DocumentDB](security.managing-users.md).
```
show users
```
Para o `user1`, crie uma função com acesso de leitura e gravação a todos os bancos de dados em todo o cluster com o seguinte comando.
```
db.createUser({user: "user1", pwd: "abc123", roles: [{role: "readWriteAnyDatabase", db: "admin"}]})
```
A saída dessa operação é semelhante à seguinte.
```
{
"user":"user1",
"roles":[
{
"role":"readWriteAnyDatabase",
"db":"admin"
}
]
}
```
Para o `user2`, crie uma função com acesso somente leitura ao banco de dados `sample-database-1` com o seguinte comando.
```
db.createUser({user: "user2", pwd: "abc123", roles: [{role: "read", db: "sample-database-1"}]})
```
A saída dessa operação é semelhante à seguinte.
```
{
"user":"user2",
"roles":[
{
"role":"read",
"db":"sample-database-1"
}
]
}
```
Para simular o cenário em que o `user3` é um usuário existente, primeiro crie o usuário `user3` e atribua uma nova função ao `user3`.
```
db.createUser({user: "user3", pwd: "abc123", roles: [{role: "readWrite", db: "sample-database-1"}]})
```
A saída dessa operação é semelhante à seguinte.
```
{
"user":"user3",
"roles":[
{
"role":"readWrite",
"db":"sample-database-1"
}
]
}
```
Agora que o usuário `user3` foi criado, atribua ao `user3` a função `read` no `sample-database-2`.
```
db.grantRolesToUser("user3", [{role: "read", db: "sample-database-2"}])
```
Por fim, ambos `user1` e `user2` saem da empresa e precisam que seu acesso ao cluster seja revogado. Você pode fazer isso descartando os usuários, da seguinte forma.
```
db.dropUser("user1")
db.dropUser("user2")
```
Para garantir que todos os usuários tenham as funções apropriadas, você pode listar todos os usuários com o comando a seguir.
```
show users
```
A saída dessa operação é semelhante à seguinte.
```
{
"_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"
}
]
}
```
## Introdução às funções definidas pelo usuário do RBAC
Para ajudar você a começar a usar o controle de acesso baseado em função, esta seção demonstra um cenário de exemplo de aplicação de privilégios mínimos criando funções para três usuários com funções de trabalho diferentes.
Neste exemplo, aplica-se o seguinte:
+ O `user1` é um novo gerente que precisa poder visualizar e acessar todos os bancos de dados em um cluster.
+ O `user2` é um funcionário novo que precisa somente a ação ‘buscar’ em apenas um banco de dados, `sample-database-1`, nesse mesmo cluster.
+ O `user3` é um funcionário existente que precisa visualizar e acessar uma coleção específica, col2 em um banco de dados diferente, `sample-database-2` ao qual ele não tinha acesso anteriormente, no mesmo cluster.
+ Para o `user1`, crie uma função com acesso de leitura e gravação a todos os bancos de dados em todo o cluster com o seguinte comando.
```
db.createUser(
{
user: "user1", pwd: "abc123",
roles: [{role: "readWriteAnyDatabase", db: "admin"}]
}
)
```
A saída dessa operação é semelhante à seguinte.
```
{
"user":"user1",
"roles":[
{
"role":"readWriteAnyDatabase",
"db":"admin"
}
]
}
```
Para`user2`, crie uma função com privilégios de 'busca' para todas as coleções no banco de dados `sample-database-1` com o comando a seguir. Observe que essa função garantiria que qualquer usuário associado só pudesse executar consultas de busca.
```
db.createRole(
{
role: "findRole",
privileges: [
{
resource: {db: "sample-database-1", collection: ""}, actions: ["find"]
}],
roles: []
}
)
```
A saída dessa operação é semelhante à seguinte.
```
{
"role":"findRole",
"privileges":[
{
"resource":{
"db":"sample-database-1",
"collection":""
},
"actions":[
"find"
]
}
],
"roles":[
]
}
```
Em seguida, crie o usuário (`user2`) e associe a função criada recentemente `findRole` ao usuário.
```
db.createUser(
{
user: "user2",
pwd: "abc123",
roles: []
})
db.grantRolesToUser("user2",["findRole"])
```
Para simular o cenário em que o `user3` é um usuário existente, primeiro crie o usuário `user3` e, em seguida, atribua uma nova função chamada collectionRole que atribuiremos a `user3` na próxima etapa.
Agora você pode atribuir uma nova função a `user3`. Esta nova função permitirá `user3` a inserir, atualizar, excluir e encontrar acesso a uma coleção específica col2 em `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: []
}
)
```
A saída dessa operação é semelhante à seguinte.
```
{
"role":"collectionRole",
"privileges":[
{
"resource":{
"db":"sample-database-2",
"collection":"col2"
},
"actions":[
"find",
"update",
"insert",
"remove"
]
}
],
"roles":[
]
}
```
Agora que o usuário `user3` foi criado, você pode conceder ao `user3` a função `collectionFind`.
```
db.grantRolesToUser("user3",["collectionRole"])
```
Por fim, ambos `user1` e `user2` saem da empresa e precisam que seu acesso ao cluster seja revogado. Você pode fazer isso descartando os usuários, da seguinte forma.
```
db.dropUser("user1")
db.dropUser("user2")
```
Para garantir que todos os usuários tenham as funções apropriadas, você pode listar todos os usuários com o comando a seguir.
```
show users
```
A saída dessa operação é semelhante à seguinte.
```
{
"_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"
}
]
}
```
## Conectar-se ao Amazon DocumentDB como um usuário
Ao conectar-se a um cluster do Amazon DocumentDB, você se conecta no contexto de um banco de dados específico. Por padrão, se não especificar um banco de dados em sua string de conexão, você será automaticamente conectado ao cluster no contexto do banco de dados `test`. Todos os comandos de nível de coleção, como `insert` e `find`, são emitidos em coleções no banco de dados `test`.
Para ver o banco de dados em cujo contexto você está ou, em outras palavras, para o qual você está emitindo comandos, use o comando `db` no shell do mongo, da seguinte forma.
Consulta:
```
db
```
Saída:
```
test
```
Embora a conexão padrão possa estar no contexto do banco de dados `test`, isso não significa necessariamente que o usuário associado à conexão está autorizado a executar ações no banco de dados `test`. No cenário de exemplo anterior, se você se autenticar como o usuário `user3`, que tem a função `readWrite` no banco de dados `sample-database-1`, o contexto padrão da conexão será o banco de dados `test`. No entanto, se você tentar inserir um documento em uma coleção no banco de dados `test`, receberá uma mensagem de erro de *falha de autorização*. Isso ocorre porque esse usuário não está autorizado a executar esse comando nesse banco de dados, como mostrado abaixo.
Consulta:
```
db
```
Saída:
```
test
```
Consulta:
```
db.col.insert({x:1})
```
Saída:
```
WriteCommandError({ "ok" : 0, "code" : 13, "errmsg" : "Authorization failure" })
```
Se você alterar o contexto da sua conexão com o banco de dados `sample-database-1`, poderá gravar na coleção na qual o usuário tem autorização para fazê-lo.
Consulta:
```
use sample-database-1
```
Saída:
```
switched to db sample-database-1
```
Consulta:
```
db.col.insert({x:1})
```
Saída:
```
WriteResult({ "nInserted" : 1})
```
Ao autenticar-se em um cluster com um usuário específico, você também pode especificar o banco de dados na string de conexão. Isso remove a necessidade de executar o comando `use` depois que o usuário foi autenticado no banco de dados `admin`.
A seguinte string de conexão autentica o usuário no banco de dados `admin`, mas o contexto da conexão será com o banco de dados `sample-database-1`.
```
mongo "mongodb://user3:abc123@sample-cluster.node.us-east-1.docdb.amazonaws.com:27017/sample-database-2"
```
## Comandos comuns
Esta seção fornece exemplos de comandos comuns usando o controle de acesso baseado em função no Amazon DocumentDB. Você deve estar no contexto do banco de dados `admin` para criar e modificar usuários e funções. Você pode usar o comando `use admin` para alternar para o banco de dados `admin`.
**nota**
As modificações em usuários e funções ocorrerão implicitamente no banco de dados `admin`. A criação de usuários com funções que têm escopo em todos os bancos de dados (por exemplo, `readAnyDatabase`) requer que você esteja no contexto do banco de dados `admin` (ou seja, `use admin`) ao criar o usuário, ou que indique explicitamente o banco de dados para a função ao criar o usuário (como mostrado no Exemplo 2 nesta seção).
**Exemplo 1**: criar um usuário com a função `read` para o banco de dados `foo`.
```
db.createUser({user: "readInFooBar", pwd: "abc123", roles: [{role: "read", db: "foo"}]})
```
A saída dessa operação é semelhante à seguinte.
```
{
"user":"readInFooBar",
"roles":[
{
"role":"read",
"db":"foo"
}
]
}
```
**Exemplo 2**: criar um usuário com acesso para leitura em todos os bancos de dados.
```
db.createUser({user: "readAllDBs", pwd: "abc123", roles: [{role: "readAnyDatabase", db: "admin"}]})
```
A saída dessa operação é semelhante à seguinte.
```
{
"user":"readAllDBs",
"roles":[
{
"role":"readAnyDatabase",
"db":"admin"
}
]
}
```
**Exemplo 3**: conceder a função `read` a um usuário existente em um banco de dados novo.
```
db.grantRolesToUser("readInFooBar", [{role: "read", db: "bar"}])
```
**Exemplo 4**: atualizar a função de um usuário.
```
db.updateUser("readInFooBar", {roles: [{role: "read", db: "foo"}, {role: "read", db: "baz"}]})
```
**Exemplo 5**: revogar o acesso a um banco de dados de um usuário.
```
db.revokeRolesFromUser("readInFooBar", [{role: "read", db: "baz"}])
```
**Exemplo 6**: descrever uma função interna.
```
db.getRole("read", {showPrivileges:true})
```
A saída dessa operação é semelhante à seguinte.
```
{
"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"
]
}
}
```
**Exemplo 7**: descartar um usuário do cluster.
```
db.dropUser("readInFooBar")
```
A saída dessa operação é semelhante à seguinte.
```
true
```
**Exemplo 8**: criar uma função com acesso para leitura e gravação a uma coleção específica
```
db.createRole(
{
role: "collectionRole",
privileges: [
{
resource: {db: "sample-database-2", collection: "col2"}, actions: ["find", "update", "insert", "remove"]
}],
roles: []
}
)
```
A saída dessa operação é semelhante à seguinte.
```
{
"role":"collectionRole",
"privileges":[
{
"resource":{
"db":"sample-database-2",
"collection":"col2"
},
"actions":[
"find",
"update",
"insert",
"remove"
]
}
],
"roles":[
]
}
```
**Exemplo 9**: criar um usuário e atribuir uma função definida pelo usuário
```
db.createUser(
{
user: "user3",
pwd: "abc123",
roles: []
})
db.grantRolesToUser("user3",["collectionRole"])
```
**Exemplo 10**: conceder privilégios adicionais a uma função definida pelo usuário
```
db.grantPrivilegesToRole(
"collectionRole",
[
{
resource: { db: "sample-database-1", collection: "col1" },
actions: ["find", "update", "insert", "remove"]
}
]
)
```
**Exemplo 11**: remover privilégios de uma função definida pelo usuário
```
db.revokePrivilegesFromRole(
"collectionRole",
[
{
resource: { db: "sample-database-1", collection: "col2" },
actions: ["find", "update", "insert", "remove"]
}
]
)
```
**Exemplo 12**: atualizar uma função existente definida pelo usuário
```
db.updateRole(
"collectionRole",
{
privileges: [
{
resource: {db: "sample-database-3", collection: "sample-collection-3"}, actions: ["find", "update", "insert", "remove"]
}],
roles: []
}
)
```
## Diferenças funcionais
No Amazon DocumentDB, as definições de usuário e função são armazenadas no banco de dados `admin`, e os usuários são autenticados no banco de dados `admin`. Essa funcionalidade difere do MongoDB Community Edition, mas é consistente com o MongoDB Atlas.
O Amazon DocumentDB também oferece suporte a fluxos de alterações, que fornecem uma sequência ordenada pelo tempo de eventos de alterações que ocorrem nas coleções do cluster. A ação `listChangeStreams` é aplicada no nível do cluster (ou seja, em todos os bancos de dados) e a ação `modifyChangeStreams` pode ser aplicada no nível do banco de dados e no nível do cluster.
## Limites
A tabela a seguir contém os limites do controle de acesso baseado em funções no Amazon DocumentDB.
****
| Description | Limite |
| --- | --- |
| Número de usuários por cluster | 1000 |
| Número de funções associadas a um usuário | 1000 |
| Número de funções definidas pelo usuário | 100 |
| Número de recursos associados a um privilégio | 100 |
## Acesso ao banco de dados usando o controle de acesso com base em função
Com o controle de acesso baseado em função, você pode criar um usuário e conceder a ele uma ou mais funções para determinar quais operações esse usuário pode executar em um banco de dados ou cluster.
Veja a seguir uma lista de funções integradas que são compatíveis atualmente com o Amazon DocumentDB.
**nota**
No Amazon DocumentDB 4.0 e 5.0, os comandos `ListCollection` e `ListDatabase`podem, opcionalmente, usar os parâmetros `authorizedCollections` e `authorizedDatabases` para listar as coleções e bancos de dados que o usuário tem permissão de acessar exigindo as funções `listCollections` e `listDatabase`, respectivamente. Além disso, os usuários agora podem matar seus próprios cursores sem precisar da função `KillCursor`.
------
#### [ Database user ]
****
| Nome do perfil | Description | Ações |
| --- | --- | --- |
| read | Concede acesso de leitura a um usuário ao banco de dados especificado. | `[changeStreams](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html)` `collStats` `dbStats` `find` `killCursors` `listIndexes` `listCollections` |
| readWrite | Concede ao usuário acesso de leitura e gravação ao banco de dados especificado. | Todas as ações de permissões `read`. `createCollection` `dropCollection` `createIndex` `dropIndex` `insert` `killCursors` `listIndexes` `listCollections` `remove` `update` |
------
#### [ Cluster user ]
****
| Nome do perfil | Description | Ações |
| --- | --- | --- |
| readAnyDatabase | Concede acesso de leitura a todos os bancos de dados do cluster a um usuário. | Todas as ações de permissões `read`. `listChangeStreams` `listDatabases` |
| readWriteAnyDatabase | Concede a um usuário acesso de leitura e gravação a todos os bancos de dados no cluster. | Todas as ações de permissões `readWrite`. `listChangeStreams` `listDatabases` |
| userAdminAnyDatabase | Concede a um usuário a capacidade de atribuir e modificar as funções ou privilégios que qualquer usuário tem ao banco de dados especificado. | `changeCustomData` `changePassword` `createUser` `dropRole` `dropUser` `grantRole` `listDatabases` `revokeRole` `viewRole` `viewUser` |
| dbAdminAnyDatabase | Concede a um usuário a capacidade de executar funções de administração de banco de dados em qualquer banco de dados especificado. | Todas as ações de permissões `dbAdmin`. `dropCollection` `listDatabases` `listChangeStreams` `modifyChangeStreams` |
------
#### [ Superuser ]
****
| Nome do perfil | Description | Ações |
| --- | --- | --- |
| root | Concede a um usuário acesso aos recursos e operações de todas as seguintes funções combinadas: readWriteAnyDatabase, dbAdminAnyDatabase, userAdminAnyDatabase, clusterAdmin, restore e backup. | Todas as ações de `readWriteAnyDatabase`, `dbAdminAnyDatabase`, `userAdminAnyDatabase`, `clusterAdmin`, `restore` e `backup`. |
------
#### [ Database administrator ]
****
| Nome do perfil | Description | Ações |
| --- | --- | --- |
| dbAdmin | Concede a um usuário a capacidade de executar tarefas administrativas no banco de dados especificado. | `bypassDocumentValidation` `collMod` `collStats` `createCollection` `createIndex` `dropCollection` `dropDatabase` `dropIndex` `dbStats` `find` `killCursors` `listIndexes` `listCollections` `modifyChangeStreams` |
| dbOwner | Concede a um usuário a capacidade de executar quaisquer tarefas administrativas no banco de dados especificado combinando as funções dbAdmin e readWrite. | Todas as ações de `dbAdmin` e `readWrite`. |
------
#### [ Cluster administrator ]
****
| Nome da função | Description | Ações |
| --- | --- | --- |
| clusterAdmin | Concede a um usuário o maior acesso de gerenciamento de cluster combinando as funções clusterManager, clusterMonitor e hostManager. | Todas as ações de `clusterManager`, `clusterMonitor` e `hostManager`. `listChangeStreams` `dropDatabase` `modifyChangeStreams` |
| clusterManager | Concede a um usuário a capacidade de executar ações de gerenciamento e monitoramento no cluster especificado. | `listChangeStreams` `listSessions` `modifyChangeStreams` `replSetGetConfig` |
| clusterMonitor | Concede a um usuário a capacidade de ter acesso somente leitura a ferramentas de monitoramento. | `collStats` `dbStats` `find` `getParameter` `hostInfo` `indexStats` `killCursors` `listChangeStreams` `listCollections` `listDatabases` `listIndexes` `listSessions` `replSetGetConfig` `serverStatus` `top` |
| hostManager | Concede a um usuário a capacidade de monitorar e gerenciar servidores. | `auditConfigure` `killCursors` `killAnyCursor` `killAnySession` `killop` |
------
#### [ Backup administrator ]
****
| Nome do perfil | Description | Ações |
| --- | --- | --- |
| backup | Concede a um usuário o acesso necessário para fazer backup de dados. | `getParameter` `insert` `find` `listChangeStreams` `listCollections` `listDatabases` `listIndexes` `update` |
| restore | Concede a um usuário o acesso necessário para restaurar dados. | `bypassDocumentValidation` `changeCustomData` `changePassword` `collMod` `createCollection` `createIndex` `createUser` `dropCollection` `dropRole` `dropUser` `getParameter` `grantRole` `find` `insert` `listCollections` `modifyChangeStreams` `revokeRole` `remove` `viewRole` `viewUser` `update` |
------