Como gerenciar usuários e autenticação no MongoDB

Introdução

Gerenciar usuários e autenticação são algumas das tarefas administrativas mais importantes do gerenciamento de servidores MongoDB. Você deve garantir que o servidor esteja configurado para identificar corretamente seus usuários e aplicativos e negar conexões ou operações que não podem ser autenticadas corretamente.

Para gerenciar esses requisitos, você deve poder decidir quais usuários seu servidor requer e criar essas contas. Como parte desse processo, você pode definir os detalhes de autenticação para permitir acesso externo usando a nova identidade.

Neste guia, veremos como criar, visualizar e remover contas de usuário. Veremos como configurar a autenticação para suas contas e como atualizar as credenciais quando você precisar alterar suas senhas de usuário.

Pré-requisitos

Para acompanhar este guia, você precisará de uma conta em um servidor MongoDB com os privilégios apropriados.

Comandos e métodos que usaremos

Para criar, modificar e excluir usuários no MongoDB e configurar a autenticação, os principais métodos necessários são:

db.createUser :crie uma nova conta de usuário do MongoDB
db.updateUser :atualizar os detalhes de uma conta de usuário
db.changeUserPassword :alterar a senha usada por uma conta de usuário
db.dropUser :excluir uma conta de usuário do MongoDB

Além disso, o seguinte comando de banco de dados é útil para localizar informações sobre usuários no sistema:

db.runCommand('usersInfo') :mostra informações sobre uma ou mais contas de usuário do MongoDB

Privilégios necessários

Para executar os comandos acima, você precisa fazer login no MongoDB com uma conta com várias ações de privilégios diferentes. Os privilégios específicos necessários dependem dos comandos que você precisa usar.

Para obter informações sobre outros usuários, seu usuário atual deve ter a seguinte ação de privilégio habilitada:

viewUser ação de privilégio

Para criar novos usuários, seu usuário atual deve ter as seguintes ações de privilégio habilitadas:

createUser ação de privilégio
grantRole ação de privilégio

Para alterar a senha ou os detalhes da conta de um usuário, talvez você precise dos seguintes privilégios:

changeOwnPassword ação de privilégio para alterar a senha da sua própria conta
changeOwnCustomData ação de privilégio para alterar os dados personalizados de sua própria conta
changePassword ação de privilégio para alterar as senhas de outros usuários
changeCustomData ação de privilégio para alterar os dados personalizados de outros usuários

Não abordaremos o gerenciamento de funções neste guia, portanto, o grantRole e revokeRole ações de privilégio não são necessárias.

Para excluir uma conta de usuário, seu usuário atual deve ter a seguinte ação de privilégio habilitada:

dropUser ação de privilégio

Compreendendo como o MongoDB implementa usuários e autenticação

Antes de começarmos a criar e gerenciar contas, é útil dedicar algum tempo para se familiarizar com a forma como o MongoDB define e armazena essas informações.

No MongoDB, as contas de usuário são uma combinação do nome de usuário da conta junto com um banco de dados de autenticação específico. O banco de dados de autenticação é simplesmente o banco de dados onde o usuário é definido e não implica em limitação de escopo ou direitos. Bancos de dados de autenticação são bancos de dados regulares usados para gerenciar outros dados e não são bancos de dados especiais e dedicados.

Um nome de conta de usuário deve ser exclusivo em seu banco de dados de autenticação. No entanto, o mesmo nome de usuário pode ser reutilizado com um banco de dados de autenticação diferente para criar uma nova conta de usuário distinta.

Como resultado desse design, uma conta só pode ser identificada com precisão incluindo o nome de usuário e o banco de dados de autenticação. Para se autenticar em uma conta, também é necessário fornecer as credenciais associadas a uma conta. Geralmente é uma senha, mas também pode ser um certificado.

Como você cria usuários?

Agora que vimos como o MongoDB conceitua contas de usuário, podemos discutir como criar novos usuários. Lembre-se de fazer login no seu servidor MongoDB com um usuário que tenha os privilégios apropriados para acompanhar.

Para criar um novo usuário, você deve primeiro alternar para o banco de dados que deseja usar como banco de dados de autenticação do novo usuário.

Primeiro, você pode obter uma lista dos bancos de dados que já estão configurados em seu sistema digitando:

show dbs

admin   0.000GBconfig  0.000GBlocal   0.000GB

Mude para o banco de dados ao qual o usuário será associado usando o use comando:

use admin

switched to db admin

Para criar um novo usuário, você pode usar o db.createUser() ou você pode usar o método createUser comando do banco de dados. De qualquer forma, você precisará passar o nome de usuário (o user campo), senha (o pwd campo) e uma matriz de funções às quais o usuário deve ser adicionado (as roles key) dentro de um user objeto.

Para criar um novo usuário chamado tom com uma senha definida como hellothere com um array de funções vazio usando o db.createUser() método, você pode digitar:

db.createUser({    user: "tom",    pwd: "hellothere",    roles: []})

Successfully added user: { "user" : "tom", "roles" : [ ] }

A mesma operação usando o createUser comando de banco de dados ficaria assim:

db.runCommand({    createUser: "tom",    pwd: "hellothere",    roles: []})

Successfully added user: { "user" : "tom", "roles" : [ ] }

As duas opções diferentes são muito semelhantes, portanto, apenas mostraremos os métodos de banco de dados quando aplicável daqui para frente. No entanto, se você preferir a sintaxe de comando do banco de dados, poderá encontrar cada um dos comandos associados na documentação de referência de comando do MongoDB.

Nos comandos acima, definimos explicitamente a senha inline dentro do user objeto. Para evitar que a senha seja registrada e recuperável, você pode usar alternativamente o passwordPrompt() método dentro do user document para que o MongoDB solicite interativamente uma senha quando o comando for executado. A senha não estará visível, então seu histórico de comandos estará limpo:

db.createUser({    user: "tom",    pwd: passwordPrompt(),    roles: []})

Enter password:Successfully added user: { "user" : "tom", "roles" : [ ] }

Lembre-se de que a senha ainda será enviada ao servidor em texto simples se você não tiver o TLS/SSL ativado.

Como você mostra os usuários existentes?

Em seguida, vamos dar uma olhada em como encontrar informações sobre os usuários existentes.

Para retornar vários usuários, você pode usar o db.getUsers() para mostrar todos os usuários no banco de dados atual. Primeiro, mude para o banco de dados que você está interessado em consultar:

use admin

Em seguida, use o db.getUsers() método para retornar todos os usuários associados ao banco de dados atual:

db.getUsers()

[    {            "_id" : "admin.root",            "userId" : UUID("f5ded238-19c9-4886-b649-711ec36993cb"),            "user" : "root",            "db" : "admin",            "roles" : [                    {                            "role" : "root",                            "db" : "admin"                    }            ],            "mechanisms" : [                    "SCRAM-SHA-1",                    "SCRAM-SHA-256"            ]    },    {            "_id" : "admin.tom",            "userId" : UUID("e7a0abde-a9f9-412a-bfd5-eb11fda41fd3"),            "user" : "tom",            "db" : "admin",            "roles" : [ ],            "mechanisms" : [                    "SCRAM-SHA-1",                    "SCRAM-SHA-256"            ]    }]

Para mostrar adicionalmente as informações de credencial de cada usuário, passe um objeto para o método com o showCredentials chave para true :

use admindb.getUsers({    showCredentials: true})

[        {                "_id" : "admin.root",                . . .                "credentials" : {                        "SCRAM-SHA-1" : {                                "iterationCount" : 10000,                                "salt" : "WpB0H4f7dG8XlCDyaVzarA==",                                "storedKey" : "b11nA1+mGo3+Tr8P//u3NEdJLHk=",                                "serverKey" : "3xE8o663hjqySrMCQcXjSxmjmhk="                        },                        "SCRAM-SHA-256" : {                                "iterationCount" : 15000,                                "salt" : "UtsfNRedf2ek5tbWFoGs2g52U0H7Na44wV4rYA==",                                "storedKey" : "mz9/qHnI79pNAIQm0MZTKZ0U3qFk0xhUDd2grvKtMdI=",                                "serverKey" : "c/sA4j+I/29Ea1y07zxoMcBgHFoYTUAa6luX3Z9sToQ="                        }                },                . . .        },        {                "_id" : "admin.tom",                . . .                "credentials" : {                        "SCRAM-SHA-1" : {                                "iterationCount" : 10000,                                "salt" : "qCbxWQSGt3QoN3S1aM5AEg==",                                "storedKey" : "hypim5+m2wqbS1gc47o2itc7jew=",                                "serverKey" : "h9myNoSvY2015yqvw3UldmJzZCg="                        },                        "SCRAM-SHA-256" : {                                "iterationCount" : 15000,                                "salt" : "lNtIVL79J8FF+uPaFfRMwPK079gfLEUrsQe3Qg==",                                "storedKey" : "u8pgn3OJiZxIwEL7ryZkoAF5bnMefQEEsZDTXNDCTRY=",                                "serverKey" : "BmmfVeikSA0DN1aZmyZP9NXi5owxGr1ZRmVX2XH8qVg="                        }                },                . . .        }]

Para consultar usuários que correspondam a determinados critérios, você pode passar um objeto que defina um filter chave que define a condição de correspondência.

Por exemplo, para obter informações sobre todos os usuários no banco de dados atual que possuem o root função, você pode digitar:

use admindb.getUsers({    filter: {        "roles.role": "root"    }})

[        {                "_id" : "admin.root",                "userId" : UUID("f5ded238-19c9-4886-b649-711ec36993cb"),                "user" : "root",                "db" : "admin",                "roles" : [                        {                                "role" : "root",                                "db" : "admin"                        }                ],                "mechanisms" : [                        "SCRAM-SHA-1",                        "SCRAM-SHA-256"                ]        }]

Para obter um usuário específico, você pode usar o db.getUser() método em vez disso. Isso funciona como o db.getUsers() método, mas retorna um único usuário. Em vez de passar um objeto para o método, você passa uma string contendo o nome de usuário que deseja recuperar:

use admindb.getUser("tom")

{        "_id" : "admin.tom",        "userId" : UUID("e7a0abde-a9f9-412a-bfd5-eb11fda41fd3"),        "user" : "tom",        "db" : "admin",        "roles" : [ ],        "mechanisms" : [                "SCRAM-SHA-1",                "SCRAM-SHA-256"        ]}

Opcionalmente, você pode incluir um args extra objeto que permite especificar informações adicionais desejadas definindo as seguintes chaves como true :

showCredentials :mostra informações de credenciais além da saída normal
showPrivileges :mostra informações de privilégios além da saída normal
showAuthenticationRestrictions :mostra as restrições de autenticação na conta além da saída normal

Por exemplo, você pode dizer ao MongoDB para fornecer todas as informações acima digitando:

use admindb.getUser("tom",{    showCredentials: true,    showPrivileges: true,    showAuthenticationRestrictions: true})

{        "_id" : "admin.tom",        "userId" : UUID("e7a0abde-a9f9-412a-bfd5-eb11fda41fd3"),        "user" : "tom",        "db" : "admin",        "mechanisms" : [                "SCRAM-SHA-1",                "SCRAM-SHA-256"        ],        "credentials" : {                "SCRAM-SHA-1" : {                        "iterationCount" : 10000,                        "salt" : "qCbxWQSGt3QoN3S1aM5AEg==",                        "storedKey" : "hypim5+m2wqbS1gc47o2itc7jew=",                        "serverKey" : "h9myNoSvY2015yqvw3UldmJzZCg="                },                "SCRAM-SHA-256" : {                        "iterationCount" : 15000,                        "salt" : "lNtIVL79J8FF+uPaFfRMwPK079gfLEUrsQe3Qg==",                        "storedKey" : "u8pgn3OJiZxIwEL7ryZkoAF5bnMefQEEsZDTXNDCTRY=",                        "serverKey" : "BmmfVeikSA0DN1aZmyZP9NXi5owxGr1ZRmVX2XH8qVg="                }        },        "roles" : [ ],        "inheritedRoles" : [ ],        "inheritedPrivileges" : [ ],        "inheritedAuthenticationRestrictions" : [ ],        "authenticationRestrictions" : [ ]}

Como você altera a senha de um usuário do MongoDB?

Para alterar a senha de um usuário, você pode usar o db.changeUserPassword() método. Novamente, você deve alternar para o banco de dados de autenticação do usuário antes de executar o comando.

O db.changeUserPassword() O método recebe dois argumentos:o nome de usuário da conta que você deseja alterar e a nova senha da conta.

Por exemplo, para alterar a senha do usuário tom autenticado com o admin banco de dados para secretpassword , você pode digitar:

use admindb.changeUserPassword("tom", "secretpassword")

Assim como com o db.createUser() método, você pode usar o passwordPrompt() método para o segundo argumento em vez de fornecer uma senha embutida. O MongoDB solicitará que você insira uma senha quando o comando for executado:

use admindb.changeUserPassword("tom", passwordPrompt())

Enter password:

Como você altera outros detalhes da conta de usuário?

Para alterar outras informações associadas a uma conta de usuário, você pode usar o db.updateUser() método. Certifique-se de alternar para o banco de dados de autenticação do usuário antes de atualizar seus detalhes.

O db.updateUser() O método exige que você especifique o nome de usuário e, em seguida, forneça um objeto contendo os dados que deseja atualizar. Qualquer campo que você escolher atualizar será completamente substituído pelas novas informações, portanto, certifique-se de incluir os dados originais, bem como os novos dados em seu objeto, se desejar apenas anexar novas informações.

O objeto que você inclui no comando com as informações de alteração pode conter muitos campos diferentes. Vamos a eles:

customData :quaisquer dados arbitrários a serem associados à conta do usuário.
roles :as funções que o usuário recebe. Geralmente é melhor usar o db.grantRolesToUser() e db.revokeRolesFromUser() métodos para controlar a associação da função em vez de atualizar com essa chave, pois você pode anexar e remover funções individualmente.
pwd :A senha do usuário. Usando o db.ChangeUserPassword() geralmente é mais fácil se esse for o único campo que precisa ser atualizado.
authenticationRestrictions :especifica as restrições para a conta que podem limitar os endereços IP dos quais os usuários podem se conectar. O valor desta chave é um objeto ou array que define clientSource e ou serverAddress , que contêm matrizes que especificam os endereços IP ou intervalos válidos. Saiba mais nos documentos do MongoDB sobre restrições de autenticação.
mechanisms :os mecanismos de autenticação específicos a serem usados para credenciais. Pode ser definido como um ou ambos SCRAM-SHA-1 ou SCRAM-SHA-256 , mas só pode ser alterado para um subconjunto dos mecanismos atuais se uma nova senha não estiver sendo fornecida no momento.
passwordDigestor :Especifica qual componente processa a senha do usuário. Pode ser server (o padrão) ou client .

Como exemplo, podemos atualizar o tom conta que se autentica no admin banco de dados para poder fazer login apenas no mesmo computador que hospeda o próprio servidor alterando as authenticationRestrictions campo:

use admindb.updateUser("tom", {    authenticationRestrictions: [ {        clientSource: ["127.0.0.1", "::1"],        serverAddress: ["127.0.0.1", "::1"]    } ]})

Agora, se você pedir ao MongoDB para mostrar as informações relevantes sobre o usuário, ele exibirá restrições adicionais para a conta:

use admindb.getUser("tom", {    showAuthenticationRestrictions: true})

{        "_id" : "admin.tom",        "userId" : UUID("e7a0abde-a9f9-412a-bfd5-eb11fda41fd3"),        "user" : "tom",        "db" : "admin",        "mechanisms" : [                "SCRAM-SHA-1",                "SCRAM-SHA-256"        ],        "roles" : [ ],        "authenticationRestrictions" : [                {                        "clientSource" : [                                "127.0.0.1",                                "::1"                        ],                        "serverAddress" : [                                "127.0.0.1",                                "::1"                        ]                }        ],        "inheritedRoles" : [ ],        "inheritedPrivileges" : [ ],        "inheritedAuthenticationRestrictions" : [ ]}

Para revogar essas restrições, podemos executar o comando novamente com um array vazio:

use admindb.changeUser("tom", {    authenticationRestrictions: []})

Como você exclui usuários do MongoDB?

Para remover contas de usuário do MongoDB, você pode usar o db.dropUser() método. Certifique-se de conectar-se ao banco de dados de autenticação do usuário antes de removê-los.

Para executar o db.dropUser() método, você precisa fornecer o nome do usuário que deseja remover:

db.dropUser("tom")

Após a exclusão bem-sucedida, o MongoDB retornará true :

true

Se a conta não existia no banco de dados atual, ela retornará false .

Conclusão

O gerenciamento de usuários e a configuração de autenticação do MongoDB permitem controlar quem pode se conectar aos seus servidores e quais são suas propriedades de usuário. Em um artigo a seguir, abordaremos como restringir o nível de acesso que os usuários têm abordando a parte de autorização do gerenciamento de usuários.