AWS Identity and Access gestión

Overview

La MONGODB-AWS El mecanismo de autenticación utiliza sus credenciales de Amazon Web Services Identity and Access Gestión (AWS IAM) para autenticar su usuario. Para obtener más información sobre cómo configurar MongoDB Atlas, consulta el Guía Configura la autenticación sin contraseña con AWS IAM Roles.

Para indicar al controlador que use este mecanismo de autenticación, puedes especificar MONGODB-AWS como un parámetro en la cadena de conexión o utilizando el método factory MongoCredential.createAwsCredential().

AWS SDK

Puedes usar uno de los AWS SDK para Java v1 o v2 para especificar tus credenciales. Este método ofrece las siguientes funcionalidades:

• Varias opciones para obtener credenciales

• El almacenamiento en caché de credenciales ayuda a tu aplicación a evitar la limitación de tasa

• Gestión de proveedor de credenciales para su uso con el Elastic Kubernetes Service.

Para utilizar el AWS SDK para Java para la autenticación MONGODB-AWS, debes realizar lo siguiente:

1. Especificar el mecanismo de autenticación

2. Agregue el SDK como una dependencia a su proyecto

3. Suministra tus credenciales usando uno de los métodos en la cadena de proveedores de credenciales

Para especificar el mecanismo de autenticación utilizando un MongoCredential, utiliza el método de fábrica MongoCredential.createAwsCredential() y añade la instancia MongoCredential a tu MongoClient como se muestra en el siguiente ejemplo:

val credential = MongoCredential.createAwsCredential(null, null)
val settings = MongoClientSettings.builder()
    .applyToClusterSettings { builder: ClusterSettings.Builder ->
        builder.hosts(
            listOf(ServerAddress("<atlasUri>"))
        )
    }
    .credential(credential)
    .build()
val mongoClient = MongoClient.create(settings)

Para especificar el mecanismo de autenticación en la cadena de conexión, agrégalo como un parámetro, como se muestra en el siguiente ejemplo:

val mongoClient =
    MongoClient.create("mongodb://<atlasUri>?authMechanism=MONGODB-AWS")

Para añadir el SDK de AWS como dependencia a tu proyecto, consulta la siguiente documentación de AWS para la versión que necesitas:

• Para el AWS SDK para Java v2, consulta la guía Configuración.

• Para el AWS SDK para Java v1, consulte la Guía de introducción.

Para suministrar sus credenciales, consulte la siguiente documentación de AWS para la versión que necesita:

• Para **aprender** más sobre la clase AWS SDK for Java v2 que el driver utiliza para obtener las credenciales, consulta la documentación DefaultCredentialsProvider API.

  Aprende a proporcionar tus credenciales a esta clase desde la sección Utilizar la cadena de proveedores de credenciales predeterminada.

• Para aprender más sobre la clase AWS SDK para Java v1 que utiliza el controlador para obtener las credenciales, consulta la documentación de la API DefaultAWSCredentialsProviderChain.

  Aprenda cómo suministrar sus credenciales a esta clase en la sección Usar la cadena de proveedores de credenciales por defecto.

Especifique sus credenciales en el entorno

Puedes proporcionar tus credenciales de AWS IAM indicando al controlador que utilice el MONGODB-AWS mecanismo de autenticación y configurando las variables de entorno apropiadas.

Para usar las variables de entorno para proporcionar tus credenciales, debes realizar lo siguiente:

1. Especificar el mecanismo de autenticación

2. Agregar las variables de entorno apropiadas

Se puede especificar el mecanismo de autenticación utilizando una MongoCredential o en la cadena de conexión.

Para especificar el mecanismo de autenticación utilizando un MongoCredential, utiliza el método de fábrica MongoCredential.createAwsCredential() y añade la instancia MongoCredential a tu MongoClient como se muestra en el siguiente ejemplo:

val credential = MongoCredential.createAwsCredential(null, null)
val settings = MongoClientSettings.builder()
    .applyToClusterSettings { builder: ClusterSettings.Builder ->
        builder.hosts(
            listOf(ServerAddress("<atlasUri>"))
        )
    }
    .credential(credential)
    .build()
val mongoClient = MongoClient.create(settings)

Para especificar el mecanismo de autenticación en la cadena de conexión, agrégalo como un parámetro, como se muestra en el siguiente ejemplo:

val mongoClient =
    MongoClient.create("mongodb://<atlasUri>?authMechanism=MONGODB-AWS")

Los siguientes ejemplos muestran cómo proporcionar sus credenciales mediante la configuración de variables de entorno para los siguientes tipos de autenticación:

• Claves de acceso programático

• Credenciales de contenedor ECS

• credenciales del contenedor EC2

El siguiente ejemplo muestra cómo puedes configurar tus claves de acceso programáticas en variables de entorno usando bash o una shell similar:

export AWS_ACCESS_KEY_ID=<awsKeyId>
export AWS_SECRET_ACCESS_KEY=<awsSecretKey>
export AWS_SESSION_TOKEN=<awsSessionToken>

Omita la línea que contiene AWS_SESSION_TOKEN si no necesita un token de sesión de AWS para ese rol.

Para autenticarse usando credenciales de contenedor ECS, establece el URI del endpoint relativo de ECS en una variable de entorno utilizando bash o una shell similar, como se muestra en el siguiente ejemplo:

export AWS_CONTAINER_CREDENTIALS_RELATIVE_URI=<your ECS endpoint>

Para autenticarse utilizando credenciales del contenedor EC2, asegúrese de que ninguna de las variables de entorno mencionadas anteriormente esté configurada. El controlador obtiene las credenciales del endpoint de metadatos de la instancia EC2 IPv4 por defecto.

Especifica tus credenciales en MongoCredential

Puede suministrar sus credenciales IAM de AWS a un MongoClient usando una instancia de MongoCredential. Para construir la instancia de MongoCredential para la autenticación de MONGODB-AWS, usa el método de fábrica createAwsCredential().

Solo puedes proporcionar claves de acceso programáticas al método MongoCredential.createAwsCredential(). Si necesitas proveer credenciales para contenedores ECS o EC2, utiliza las instrucciones de Especificar tus credenciales en el entorno o AWS SDK.

Para utilizar el MongoCredential para la autenticación MONGODB-AWS, debes realizar lo siguiente:

1. Especificar el mecanismo de autenticación

2. Proporcione las credenciales

Para especificar el mecanismo de autenticación utilizando un MongoCredential, utiliza el método de fábrica MongoCredential.createAwsCredential() y añade la instancia MongoCredential a tu MongoClient como se muestra en el siguiente ejemplo:

val credential = MongoCredential.createAwsCredential("<awsKeyId>", "<awsSecretKey>".toCharArray())
val settings = MongoClientSettings.builder()
        .applyToClusterSettings { builder: ClusterSettings.Builder ->
            builder.hosts(
                listOf(ServerAddress("<atlasUri>"))
            )
        }
        .credential(credential)
        .build()
val mongoClient = MongoClient.create(settings)

Si necesitas especificar un token de sesión de AWS, pásalo al método withMechanismProperty() tal como se muestra en el siguiente ejemplo:

val credential = MongoCredential.createAwsCredential("<awsKeyId>", "<awsSecretKey>".toCharArray())
    .withMechanismProperty("AWS_SESSION_TOKEN", "<awsSessionToken>")
val settings = MongoClientSettings.builder()
        .applyToClusterSettings { builder: ClusterSettings.Builder ->
            builder.hosts(
                listOf(ServerAddress("<atlasUri>"))
            )
        }
        .credential(credential)
        .build()
val mongoClient = MongoClient.create(settings)

Para actualizar tus credenciales, puedes declarar una expresión lambda Supplier que devuelva nuevas credenciales, como se muestra en el siguiente ejemplo:

val awsFreshCredentialSupplier: Supplier<AwsCredential> = Supplier {
    // Add your code here to fetch new credentials
    // Return the new credentials
    AwsCredential("<awsKeyId>", "<awsSecretKey>", "<awsSessionToken>")
}
val credential = MongoCredential.createAwsCredential("<awsKeyId>", "<awsSecretKey>".toCharArray())
    .withMechanismProperty(MongoCredential.AWS_CREDENTIAL_PROVIDER_KEY, awsFreshCredentialSupplier)
val settings = MongoClientSettings.builder()
    .applyToClusterSettings { builder ->
        builder.hosts(listOf(ServerAddress("<hostname>", "<port>")))
    }
    .credential(credential)
    .build()
val mongoClient = MongoClient.create(settings)

Si debe proporcionar credenciales de AWS IAM en una cadena de conexión, puede añadirlas a su MongoClientSettings invocando el método applyConnectionString() método:

val credential = MongoCredential.createAwsCredential("<awsKeyId>", "<awsSecretKey>".toCharArray())
val connectionString = ConnectionString("mongodb://<atlasUri>/?authMechanism=MONGODB-AWS&authMechanismProperties=AWS_SESSION_TOKEN:<awsSessionToken>")
val settings = MongoClientSettings.builder()
    .applyConnectionString(connectionString)
    .credential(credential)
    .build()
val mongoClient = MongoClient.create(settings)