Menu Docs
Página inicial do Docs
/ /
Autenticação
Página inicial do Docs
/
Bibliotecas do cliente
/
C++
/
Autenticação
Página inicial do Docs
/
Bibliotecas do cliente
/
C++
/
Autenticação

Gerenciamento de identidade e acesso do Amazon Web Services

Visão geral

Observação

A autenticação do Amazon Web Services está disponível apenas no MongoDB Enterprise Edition para MongoDB 4.4 e posterior.

O MONGODB-AWS mecanismo de autenticação do utiliza o AWS Identity and Access Management (IAM) e o AWS Security Token Service (STS) para provar a identidade do cliente para uma implantação MongoDB . As etapas a seguir descrevem o processo de autenticação da AWS:

  1. O cliente usa credenciais AWS IAM para criar uma assinatura e a envia para a implantação MongoDB .

  2. A implantação usa a assinatura do cliente para enviar uma solicitação ao Amazon Web Services STS.

  3. Se a solicitação for bem-sucedida, o STS retornará o nome do recurso da Amazon (ARN) do usuário ou da função do IAM que corresponde às credenciais do cliente.

  4. A implantação usa o ARN retornado para procurar o usuário. O cliente autentica como este usuário.

Observação

O cliente e o servidor usam nomes de usuário diferentes. O cliente envia o ID da chave de acesso da AWS como o nome de usuário. O servidor usa o ARN do usuário IAM ou função correspondente ao ID da chave de acesso como o nome de usuário.

Para autenticar com este mecanismo:

  • Crie um usuário no banco de dados $external cujo nome seja o ARN do usuário ou função IAM como você deseja autenticar.

  • Configure o cliente para utilizar o mecanismo de autenticação do MONGODB-AWS.

Credenciais Amazon Web Services

As credenciais do Amazon Web Services incluem os seguintes componentes:

  • ID da chave de acesso

  • chave de acesso secreta

  • Token de sessão opcional

A autenticação com credenciais do AWS IAM usa o ID da chave de acesso e a chave de acesso secreta. A autenticação com credenciais temporárias do AWS IAM usa todos os três componentes: ID da chave de acesso, chave de acesso secreta e token de sessão.

Observação

O driver nunca envia a chave de acesso secreta ou o token de sessão pela rede.

As credenciais temporárias são usadas com:

Espaços reservados de código

Os exemplos de código nesta página usam os seguintes espaços reservados:

  • <hostname>: O endereço de rede da sua implantação MongoDB .

  • <port>: o número da porta da sua implantação do MongoDB .

  • <aws_access_key_id>: O ID da chave de acesso da AWS.

  • <aws_secret_access_key>: A chave de acesso secreto AWS.

  • <aws_session_token>: O token de sessão AWS.

Para usar os exemplos de código nesta página, substitua esses espaços reservados por seus próprios valores.

Uso da autenticação IAM do Amazon Web Services em seu aplicativo

O driver C++ pode recuperar credenciais AWS IAM do ambiente, ou você pode fornecê-las explicitamente no código do aplicação .

Quando você usa o mecanismo de autenticação MONGODB-AWS, o driver C++ tenta recuperar as credenciais da AWS das seguintes fontes, nesta ordem:

  1. Credenciais passadas no URI de conexão

  2. Variáveis de ambiente

  3. Solicitação de Amazon Web Services EKS AssumeRoleWithWebIdentity

  4. Metadados do container ECS

  5. Metadados de instância do EC2

Fornecendo credenciais explicitamente

Você pode fornecer credenciais de IAM de longo prazo (não temporárias) no URI de conexão. Para fazer isso, defina os seguintes parâmetros de URI:

  • username: defina para seu ID de chave de acesso AWS.

  • password: defina sua chave de acesso secreto AWS.

  • authMechanism: Defina como MONGODB-AWS.

Você pode usar o URI de conexão sozinho ou o URI de conexão com opções TLS configuradas usando as classes mongocxx::options::tls e mongocxx::options::client. Selecione a aba Connection URI ou Client Options with TLS para ver a sintaxe correspondente :

auto uri = mongocxx::uri("mongodb://<aws_access_key_id>:<aws_secret_access_key>@<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS");
auto client = mongocxx::client(uri);
mongocxx::options::client client_options;
mongocxx::options::tls tls_options;
tls_options.ca_file("/path/to/ca.pem");
client_options.tls_opts(tls_options);
auto uri = mongocxx::uri("mongodb://<aws_access_key_id>:<aws_secret_access_key>@<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS&tls=true");
auto client = mongocxx::client(uri, client_options);

Observação

Se você fornecer credenciais em um URI, codifique por cento quaisquer caracteres especiais no ID da chave de acesso ou na chave de acesso secreta.

Fornecendo Credenciais Temporárias

Você pode fornecer credenciais IAM temporárias no URI de conexão incluindo o token de sessão no parâmetro authMechanismProperties do URI de conexão.

Selecione a aba Connection URI ou Client Options with TLS para ver a sintaxe correspondente:

auto uri = mongocxx::uri("mongodb://<aws_access_key_id>:<aws_secret_access_key>@<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS&authMechanismProperties=AWS_SESSION_TOKEN:<aws_session_token>");
auto client = mongocxx::client(uri);
mongocxx::options::client client_options;
mongocxx::options::tls tls_options;
tls_options.ca_file("/path/to/ca.pem");
client_options.tls_opts(tls_options);
auto uri = mongocxx::uri("mongodb://<aws_access_key_id>:<aws_secret_access_key>@<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS"
                         "&authMechanismProperties=AWS_SESSION_TOKEN:<aws_session_token>&tls=true");
auto client = mongocxx::client(uri, client_options);

Recuperando credenciais automaticamente

Quando você especifica o mecanismo de autenticação MONGODB-AWS e omite username e password, o driver C++ tenta recuperar automaticamente as credenciais da AWS de variáveis de ambiente, funções de identidade da Web e endpoints de metadados da AWS.

Variáveis de ambiente

O driver C++ primeiro verifica as credenciais das seguintes variáveis de ambiente:

  • AWS_ACCESS_KEY_ID

  • AWS_SECRET_ACCESS_KEY

  • AWS_SESSION_TOKEN (Opcional)

Essas variáveis são reconhecidas por muitas ferramentas e SDKs da AWS, como a CLI da AWS, e também são comumente definidas em ambientes do AWS Lambda.

Exemplo de configuração dessas variáveis:

export AWS_ACCESS_KEY_ID=<AWS IAM access key ID>
export AWS_SECRET_ACCESS_KEY=<AWS IAM secret access key>
export AWS_SESSION_TOKEN=<AWS session token>

Após definir estas variáveis de ambiente, configure o parâmetro authMechanism em seu URI de conexão para "MONGODB-AWS". Selecione a aba Connection URI ou Client Options with TLS para ver a sintaxe correspondente:

auto uri = mongocxx::uri("mongodb://<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS");
auto client = mongocxx::client(uri);
mongocxx::options::client client_options;
mongocxx::options::tls tls_options;
tls_options.ca_file("/path/to/ca.pem");
client_options.tls_opts(tls_options);
auto uri = mongocxx::uri("mongodb://<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS&tls=true");
auto client = mongocxx::client(uri, client_options);

AssumeRoleWithWebIdentity

Se o seu aplicação for executado em um cluster do Amazon EKS e autenticado por meio de um provedor de identidade OpenID Connect (OIDC), o driver C++ poderá usar uma solicitação AssumeRoleWithWebIdentity. Esta solicitação troca o token OIDC por credenciais temporárias da AWS para seu aplicação.

Para configurar este mecanismo:

  1. Crie ou atualize seu arquivo de configuração AWS . Para saber como criar esse arquivo de configuração, consulte Configurar globalmente SDKs e ferramentas da AWS.

  2. Defina as seguintes variáveis de ambiente:

    • AWS_ROLE_ARN: defina o ARN do role IAM a ser assumido.

    • AWS_WEB_IDENTITY_TOKEN_FILE: defina o caminho do arquivo que contém o token OIDC para sua conta de serviço.

    • AWS_ROLE_SESSION_NAME (opcional): defina um identificador para a sessão de função presumida. Se você omitir esta variável, o driver gerará um identificador aleatório.

  3. Configure o parâmetro authMechanism em seu URI de conexão para "MONGODB-AWS".

Selecione a aba Connection URI ou Client Options with TLS para ver a sintaxe correspondente:

auto uri = mongocxx::uri("mongodb://<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS");
auto client = mongocxx::client(uri);
mongocxx::options::client client_options;
mongocxx::options::tls tls_options;
tls_options.ca_file("/path/to/ca.pem");
client_options.tls_opts(tls_options);
auto uri = mongocxx::uri("mongodb://<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS&tls=true");
auto client = mongocxx::client(uri, client_options);

Para saber mais sobre autenticação com funções de identidade da Web, consulte API AssumeRoleWithWebIdentity

Metadados da Tarefa ECS

Se seu aplicação for executado em um container do Amazon ECS, o driver C++ poderá recuperar credenciais temporárias da AWS a partir do endpoint de metadados da tarefa do ECS.

Para habilitar esse comportamento, defina a variável de ambiente AWS_CONTAINER_CREDENTIALS_RELATIVE_URI para o URI relativo do ponto de extremidade dos metadados da tarefa do ECS, conforme mostrado no exemplo a seguir:

export AWS_CONTAINER_CREDENTIALS_RELATIVE_URI=<relative URI of the ECS task metadata endpoint>

Em seguida, construa o cliente com o authMechanism configurado para "MONGODB-AWS". Selecione a aba Connection URI ou Client Options with TLS para ver a sintaxe correspondente:

auto uri = mongocxx::uri("mongodb://<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS");
auto client = mongocxx::client(uri);
mongocxx::options::client client_options;
mongocxx::options::tls tls_options;
tls_options.ca_file("/path/to/ca.pem");
client_options.tls_opts(tls_options);
auto uri = mongocxx::uri("mongodb://<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS&tls=true");
auto client = mongocxx::client(uri, client_options);

EC2 Metadados de instância

Se seu aplicação for executado em uma instância do Amazon EC2, o driver C++ poderá recuperar credenciais temporárias da AWS do endpoint de metadados da instância do EC2.

Para habilitar esse comportamento, defina o parâmetro authMechanism em seu URI de conexão como "MONGODB-AWS". Selecione a aba Connection URI ou Client Options with TLS para ver a sintaxe correspondente:

auto uri = mongocxx::uri("mongodb://<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS");
auto client = mongocxx::client(uri);
mongocxx::options::client client_options;
mongocxx::options::tls tls_options;
tls_options.ca_file("/path/to/ca.pem");
client_options.tls_opts(tls_options);
auto uri = mongocxx::uri("mongodb://<hostname>:<port>/?"
                         "authMechanism=MONGODB-AWS&tls=true");
auto client = mongocxx::client(uri, client_options);

Observação

Se você definir qualquer uma das variáveis de ambiente dos métodos de autenticação anteriores do Amazon Web Services , o driver C++ tentará recuperar as credenciais usando esses métodos antes de tentar recuperá-las de uma instância do EC2. Para tentar recuperar credenciais somente de uma instância do EC2 , certifique-se de que as variáveis de ambiente não estejam definidas.

Se um aplicação for executado em um container do ECS em uma instância do EC2 e o container tiver acesso aos metadados da instância, o driver tentará recuperar as credenciais do Amazon Web Services do endpoint de metadados da instância do EC2. Se o driver recuperar as credenciais dessa forma, seu aplicação poderá se autenticar como a função IAM atribuída à instância do EC2.

Para saber como impedir que os contêineres acessem os metadados da instância EC2, consulte a documentação do Amazon Web Services.

Documentação da API

Para saber mais sobre como criar um objeto mongocxx::client no driver C++ ou configurar o TLS, consulte a seguinte documentação da API:

Voltar

X.509

Próximo

Kerberos (GSSAPI)

Nesta página