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 Management (AWS IAM) para autenticar a su usuario. Para obtener más información sobre la configuración de MongoDB Atlas, consulte 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 proveedores de credenciales para su uso con el servicio Elastic Kubernetes.

Para utilizar el SDK de AWS para Java para la autenticación MONGODB-AWS, debe 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éguelo como 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 SDK de AWS para Java v,1 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

Puede proporcionar sus credenciales de AWS IAM indicando al controlador que utilice el mecanismo de autenticación MONGODB-AWS y configurando las variables de entorno adecuadas.

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

1. Especificar el mecanismo de autenticación

2. Agregue 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éguelo como 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 puede configurar sus claves de acceso programático en variables de entorno utilizando bash o un 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 esa función.

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.

Especifique sus credenciales en un MongoCredential

Puede proporcionar sus credenciales de AWS IAM a una instancia MongoClient mediante una MongoCredential instancia. Para construir la MongoCredential instancia para la MONGODB-AWS autenticación, utilice 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 necesita especificar un token de sesión de AWS, páselo al método withMechanismProperty() 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 agregarla a su MongoClientSettings llamando al método applyConnectionString():

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)