Docs Menu
Docs Home
/ /
Autenticación
Docs Home
/
Librerías de clientes
/
C++
/
Autenticación
Docs Home
/
Librerías de clientes
/
C++
/
Autenticación

Gestión de identidad y acceso de AWS

Overview

Nota

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

El MONGODB-AWS El mecanismo de autenticación utiliza AWS Gestión de Identidad y Acceso (IAM) y Servicio de Token de Seguridad de AWS (STS) para comprobar 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:

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

  • 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 de acceso secreta

  • Token de sesión opcional

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

Nota

El controlador nunca envía la clave de acceso secreta 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 de esta página utilizan los siguientes marcadores de posición:

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

  • <port>:El número de puerto de su implementación de MongoDB.

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

  • <aws_secret_access_key>:La clave de acceso secreta 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.

Uso de la autenticación de AWS IAM en su aplicación

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

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

  1. Credenciales pasadas en la URI de conexión

  2. Variables de entorno

  3. Solicitud AssumeRoleWithWebIdentity de AWS EKS

  4. Metadatos del contenedor ECS

  5. Metadatos de la instancia EC2

Proporcionar credenciales explícitamente

Puede proporcionar credenciales de IAM a largo plazo (no temporales) en la URI de conexión. Para ello, configure los siguientes parámetros de URI:

  • username:Configúrelo en su ID de clave de acceso de AWS.

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

  • authMechanism:Establecer en MONGODB-AWS.

Puede usar el URI de conexión solo o el URI de conexión con opciones TLS configuradas mediante las clases mongocxx::options::tls y mongocxx::options::client. Seleccione el Connection URI o la pestaña 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");
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

Puede proporcionar credenciales de IAM temporales en la URI de conexión incluyendo el token de sesión en el parámetro authMechanismProperties de la URI de conexión.

Seleccione 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 C++ primero verifica las credenciales de las siguientes variables de entorno:

  • AWS_ACCESS_KEY_ID

  • AWS_SECRET_ACCESS_KEY

  • AWS_SESSION_TOKEN (opcional)

Muchas herramientas y SDK de AWS, como AWS CLI, reconocen estas variables y también se configuran comúnmente en entornos de 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);

AsumirRolConIdentidadWeb

Si su aplicación se ejecuta en un clúster de Amazon EKS y se autentica mediante un proveedor de identidad OpenID Connect (OIDC), el controlador de C++ puede usar 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. Establezca las siguientes variables de entorno:

    • AWS_ROLE_ARN:Establezca el ARN del rol de IAM que se asumirá.

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

    • AWS_ROLE_SESSION_NAME (opcional): Establezca un identificador para la sesión de rol asumida. Si omite esta variable, el controlador genera un identificador aleatorio.

  3. Establezca el parámetro authMechanism en su URI de conexión en "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);

Para obtener más información sobre la autenticación con roles de identidad web, consulte la 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 punto final de metadatos de la tarea de ECS.

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

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

Luego, construya el cliente con authMechanism establecido en "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);

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 configura alguna de las variables de entorno de los métodos de autenticación de AWS anteriores, el controlador de C++ intentará recuperar las credenciales mediante esos métodos antes de intentar recuperarlas de una instancia de EC2. Para intentar recuperar las credenciales solo de una instancia de 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 C++ o configurar TLS, consulte la siguiente documentación de API:

Volver

X.509

Next

Kerberos (GSSAPI)

En esta página