Join us at MongoDB.local London on 7 May to unlock new possibilities for your data. Use WEB50 to save 50%.
Register now >
Docs Menu
Docs Home
/ /
Autenticación
Docs Home
/
Librerías de clientes
/
C++
/
Autenticación
Docs Home
/
Librerías de clientes
/
C++
/
Autenticación

AWS Identity and Access gestión

Overview

Nota

La autenticación de AWS solo está disponible en la MongoDB Enterprise Edition para MongoDB 4.4 y posteriores.

La MONGODB-AWS El mecanismo de autenticación utiliza AWS Gestión de identidades y accesos (IAM) y AWS Security Token Service (STS) para demostrar la identidad del cliente en una implementación de MongoDB. Los siguientes pasos describen el proceso de autenticación de AWS:

  1. El cliente utiliza las credenciales de AWS IAM para crear una firma y la envía a la implementación de MongoDB.

  2. La implementación utiliza la firma del cliente para enviar una solicitud a AWS STS.

  3. Si la solicitud tiene éxito, STS devuelve el Nombre de recurso de Amazon (ARN) del usuario o rol de IAM que corresponde a las credenciales del cliente.

  4. La implementación utiliza el ARN devuelto para buscar al usuario. El cliente se autentica como este usuario.

Nota

El cliente y el servidor usan nombres de usuario diferentes. El cliente envía el ID de la clave de acceso de AWS como nombre de usuario. El servidor usa el ARN del usuario o rol de IAM correspondiente al ID de la clave de acceso como nombre de usuario.

Para autenticarse con este mecanismo:

  • Crea un usuario en la base de datos $external cuyo nombre sea la ARN del usuario o rol de IAM con el que se desea autenticar.

  • Configure el cliente para utilizar el mecanismo de autenticación MONGODB-AWS.

Credenciales de AWS

Las credenciales de AWS incluyen los siguientes componentes:

  • ID de clave de acceso

  • Clave secreta de acceso

  • Token de sesión opcional

La autenticación con credenciales AWS IAM usa la clave de acceso ID y la clave de acceso secreta. La autenticación con credenciales temporales de AWS IAM usa los tres componentes: ID de clave de acceso, clave de acceso secreta y token de sesión.

Nota

El driver nunca envía la clave secreta de acceso ni el token de sesión a través de la red.

Las credenciales temporales se utilizan con:

Marcadores de posición de código

Los ejemplos de código en esta página utilizan los siguientes marcadores de posición:

  • <hostname>: La dirección de red de tu implementación de MongoDB.

  • <port>Número de puerto de tu implementación de MongoDB.

  • <aws_access_key_id>: El ID de clave de acceso de AWS.

  • <aws_secret_access_key>: La clave secreta de acceso de AWS.

  • <aws_session_token>El token de sesión de AWS.

Para utilizar los ejemplos de código en esta página, reemplace estos marcadores de posición con sus propios valores.

Usar la autenticación de AWS IAM en tu aplicación

El controlador de C++ puede recuperar credenciales de AWS IAM del entorno, o puede proporcionarlas explícitamente en el código de su aplicación.

Cuando utilices el mecanismo de autenticación MONGODB-AWS, el controlador de C++ intentará recuperar las credenciales de AWS de las siguientes fuentes, en este orden:

  1. Credenciales transmitidas en el URI de conexión

  2. Variables de entorno

  3. Solicitud AssumeRoleWithWebIdentity de AWS EKS

  4. Metadatos de contenedor ECS

  5. Metadatos de la instancia EC2

Proporcionar credenciales explícitamente

Puedes proporcionar credenciales de IAM a largo plazo (no temporales) en el URI de la conexión. Para hacerlo, establezca los siguientes parámetros URI:

  • username: Configúralo en tu ID de clave de acceso de AWS.

  • password:Configúrelo en su clave de acceso secreta de AWS.

  • authMechanism:Establecer en MONGODB-AWS.

Puedes usar el URI de conexión por sí solo o el URI de conexión con opciones TLS configuradas usando las clases mongocxx::options::tls y mongocxx::options::client. Selecciona el Connection URI o Client Options with TLS pestaña para ver la sintaxis correspondiente:

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);

Nota

Si proporciona credenciales en una URI, codifique con porcentaje cualquier carácter especial en el ID de la clave de acceso o en la clave de acceso secreta.

Proporcionar credenciales temporales

Se pueden proporcionar credenciales IAM temporales en el URI de conexión incluyendo el token de sesión en el parámetro authMechanismProperties del URI de conexión.

Selecciona la pestaña Connection URI o Client Options with TLS para ver la sintaxis correspondiente:

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);

Recuperación automática de credenciales

Cuando especifica el mecanismo de autenticación MONGODB-AWS y omite username y password, el controlador de C++ intenta automáticamente recuperar las credenciales de AWS de las variables de entorno, los roles de identidad web y los puntos finales de metadatos de AWS.

Variables de entorno

El controlador de C++ primero verifica las credenciales de las siguientes variables de entorno:

  • AWS_ACCESS_KEY_ID

  • AWS_SECRET_ACCESS_KEY

  • AWS_SESSION_TOKEN (opcional)

Estas variables son reconocidas por muchas herramientas y SDKs de AWS, como la AWS CLI, y también suelen configurarse en entornos AWS Lambda.

Ejemplo de configuración de estas variables:

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>

Después de configurar estas variables de entorno, configure el parámetro authMechanism en la URI de conexión como "MONGODB-AWS". Seleccione la pestaña Connection URI o Client Options with TLS para ver la sintaxis correspondiente:

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);

AsumeRolConIdentidadWeb

Si su aplicación se ejecuta en un clúster de Amazon EKS y se autentica a través de un proveedor de identidad OpenID Connect (OIDC), el driver C++ puede utilizar una solicitud AssumeRoleWithWebIdentity. Esta solicitud intercambia el token OIDC por credenciales temporales de AWS para su aplicación.

Para configurar este mecanismo:

  1. Cree o actualice su archivo de configuración de AWS. Para saber cómo crear este archivo de configuración, consulte Configuración global de los SDK y las herramientas de AWS.

  2. Configure las siguientes variables de entorno:

    • AWS_ROLE_ARN⚠️ warning: Establecer el ARN del rol IAM a suponer.

    • AWS_WEB_IDENTITY_TOKEN_FILE: Configurado en la ruta del archivo que contiene el token OIDC para la cuenta de servicio.

    • AWS_ROLE_SESSION_NAME (opcional): Establecido en un identificador para la asunción de la sesión de rol. Si omites esta variable, el driver genera un identificador aleatorio.

  3. Establece el parámetro authMechanism en tu URI de conexión en "MONGODB-AWS".

Selecciona la pestaña Connection URI o Client Options with TLS para ver la sintaxis correspondiente:

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 aprender más sobre la autenticación con roles de identidad web, consulta API AssumeRoleWithWebIdentity.

Metadatos de tareas de ECS

Si su aplicación se ejecuta en un contenedor de Amazon ECS, el controlador C++ puede recuperar credenciales temporales de AWS desde el endpoint de metadatos de la tarea de ECS.

Para activar este comportamiento, configure la variable de entorno AWS_CONTAINER_CREDENTIALS_RELATIVE_URI al URI relativo del punto final de metadatos de tareas de ECS, como se muestra en el siguiente ejemplo:

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

Luego, crea el cliente con el authMechanism configurado en "MONGODB-AWS". Selecciona la pestaña Connection URI o Client Options with TLS para ver la sintaxis correspondiente:

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);

Metadatos de instancia EC2

Si su aplicación se ejecuta en una instancia de Amazon EC2, el controlador C++ puede recuperar credenciales temporales de AWS desde el punto final de metadatos de la instancia EC2.

Para habilitar este comportamiento, configure el parámetro authMechanism en la URI de conexión como "MONGODB-AWS". Seleccione la pestaña Connection URI o Client Options with TLS para ver la sintaxis correspondiente:

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);

Nota

Si configuras alguna de las variables de entorno de los métodos de autenticación de AWS anteriores, el driver de C++ intentará recuperar las credenciales utilizando esos métodos antes de intentar obtenerlas de una instancia EC2. Para intentar recuperar credenciales solo desde una instancia EC2, asegúrese de que las variables de entorno no estén configuradas.

Si una aplicación se ejecuta en un contenedor ECS en una instancia EC2 y el contenedor tiene acceso a los metadatos de la instancia, el controlador intenta recuperar las credenciales de AWS desde el punto de conexión de metadatos de la instancia EC2. Si el controlador recupera las credenciales de esta manera, la aplicación puede autenticarse con el rol de IAM asignado a la instancia EC2.

Para saber cómo evitar que los contenedores accedan a los metadatos de la2 instancia EC, consulte la documentación de AWS.

Documentación de la API

Para obtener más información sobre cómo crear un objeto mongocxx::client en el controlador de C++ o configurar TLS, consulta la siguiente documentación de la API:

Volver

X.509

Next

Kerberos (GSSAPI)

En esta página