Gerenciamento de identidade e acesso do Amazon Web Services

Visão geral

O MONGODB-AWS mecanismo de autenticação utiliza suas credenciais do Amazon Web Services Identity and Access Gerenciamento (AWS IAM) para autenticar o usuário. Para saber mais sobre como configurar o MongoDB Atlas, consulte o guia Configurar autenticação sem senha com funções do AWS IAM.

Para instruir o driver a usar esse mecanismo de autenticação, você pode especificar MONGODB-AWS como um parâmetro na string de conexão ou usando o método de fábrica MongoCredential.createAwsCredential().

AWS SDK

Você pode usar um dos AWS SDK para Java v1 ou v2 para especificar suas credenciais. Este método oferece as seguintes funcionalidades:

• Várias opções para obter credenciais

• Cache de credenciais que ajuda seu aplicativo a evitar limitação de taxa

• Gerenciamento de fornecedor de credencial para uso com o Serviço Elastic Kubernetes.

Para usar o AWS SDK para Java para autenticação MONGODB-AWS, você deve executar o seguinte:

1. Especifique o mecanismo de autenticação

2. Adicione o SDK como uma dependência ao seu projeto

3. Forneça suas credenciais usando um dos métodos na cadeia de fornecedores de credencial

Para especificar o mecanismo de autenticação usando uma MongoCredential, use o método de fábrica MongoCredential.createAwsCredential() e adicione a instância MongoCredential ao seu MongoClient, conforme mostrado no exemplo a seguir:

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 o mecanismo de autenticação na connection string, adicione-o como um parâmetro, conforme mostrado no exemplo a seguir:

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

Para adicionar a AWS SDK como uma dependência ao seu projeto, consulte a seguinte documentação da AWS para a versão necessária:

• Para o AWS SDK for Java v2, consulte a página de Configuração do guia.

• Para o AWS SDK for Java v1, consulte o Guia de Primeiros passos.

Para fornecer suas credenciais, consulte a seguinte documentação AWS para a versão que você precisa:

• Para saber mais sobre a classe AWS SDK para Java v2 que o driver usa para obter as credenciais, consulte a documentação da API DefaultCredentialsProvider.

  Saiba como fornecer suas credenciais a essa classe na seção Usar a cadeia de fornecedores de credenciais padrão.

• Para saber mais sobre a classe AWS SDK for Java v1 que o driver usa para obter as credenciais, consulte a documentação da API DefaultAWSCredentialsProviderChain.

  Saiba como fornecer suas credenciais a essa classe na seção Usar a cadeia de fornecedores de credenciais padrão.

Especifique suas Credenciais no Ambiente

Você pode fornecer suas credenciais do AWS IAM instruindo o driver a usar o mecanismo de autenticação MONGODB-AWS e definindo as variáveis de ambiente apropriadas.

Para usar as variáveis de ambiente para fornecer suas credenciais, você deve executar o seguinte:

1. Especifique o mecanismo de autenticação

2. Adicione as variáveis de ambiente apropriadas

Você pode especificar o mecanismo de autenticação utilizando um MongoCredential ou na cadeia de conexão.

Para especificar o mecanismo de autenticação usando uma MongoCredential, use o método de fábrica MongoCredential.createAwsCredential() e adicione a instância MongoCredential ao seu MongoClient, conforme mostrado no exemplo a seguir:

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 o mecanismo de autenticação na connection string, adicione-o como um parâmetro, conforme mostrado no exemplo a seguir:

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

Os próximos exemplos mostram como fornecer suas credenciais configurando variáveis de ambiente para os seguintes tipos de autenticação:

• Chaves de acesso programático

• Credenciais do container ECS

• Credenciais do container EC2

O exemplo a seguir mostra como você pode definir suas chaves de acesso programático em variáveis de ambiente usando bash ou um shell similar:

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

Omita a linha que contém AWS_SESSION_TOKEN se não precisar de um token de sessão AWS para essa função.

Para autenticar usando credenciais de container do ECS, defina o URI relativo do ponto de extremidade do ECS em uma variável de ambiente usando bash ou um shell semelhante, conforme mostrado no exemplo a seguir:

export AWS_CONTAINER_CREDENTIALS_RELATIVE_URI=<your ECS endpoint>

Para autenticar usando credenciais de container do EC2, verifique se nenhuma das variáveis de ambiente mencionadas acima está definida. O driver obtém as credenciais do endpoint de metadados de instância IPv4 EC2 padrão.

Especifique Suas Credenciais em uma MongoCredential

Você pode fornecer suas credenciais do AWS IAM para um MongoClient utilizando uma instância MongoCredential. Para criar a instância do MongoCredential para a autenticação do MONGODB-AWS, utilize o método de fábrica createAwsCredential().

Você pode fornecer somente chaves de acesso programáticas para o método MongoCredential.createAwsCredential() . Se você precisar fornecer credenciais de contêiner ECS ou EC2, use as instruções em Specify Your Credentials in the Environment ou Amazon Web Services SDK.

Para usar o MongoCredential para autenticação do MONGODB-AWS, você deve executar o seguinte:

1. Especifique o mecanismo de autenticação

2. Fornecer as credenciais

Para especificar o mecanismo de autenticação usando uma MongoCredential, use o método de fábrica MongoCredential.createAwsCredential() e adicione a instância MongoCredential ao seu MongoClient, conforme mostrado no exemplo a seguir:

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)

Se você precisar especificar um token de sessão AWS, passe para o método withMechanismProperty() como mostrado no exemplo a seguir:

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 atualizar suas credenciais, você pode declarar uma expressão lambda do Supplier que retorna novas credenciais como mostrado no seguinte exemplo:

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)

Se você precisar fornecer credenciais do Amazon Web Services IAM em uma string de conexão, poderá adicioná-la ao seu MongoClientSettings chamando o 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)