Autenticação

MongoCredential

Inclua as seguintes declarações de importação:

import org.mongodb.scala._
import scala.collection.JavaConverters._

Uma credencial de autenticação é representada como uma instância da classe MongoCredential . A classe MongoCredential inclui métodos auxiliares para cada um dos mecanismos de autenticação suportados.

Mecanismo de autenticação padrão

No MongoDB 3.0, O MongoDB alterou o mecanismo de autenticação padrão de MONGODB-CR para SCRAM-SHA-1. No MongoDB 4.0, o suporte para o mecanismo MONGODB-CR obsoleto foi removido e o suporte SCRAM-SHA-256 foi adicionado.

Para criar uma credencial que autentique usando o mecanismo de autenticação padrão, independentemente da versão do servidor, crie uma credencial usando o método auxiliar createCredential() :

val user: String = ...          // the user name
val source: String = ...        // the source where the user is defined
val password: Array[Char] = ... // the password as a character array
// ...
val credential = MongoCredential.createCredential(user, source, password)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

Ou você pode usar uma connection string sem especificar explicitamente o mecanismo de autenticação:

val mongoClient: MongoClient = MongoClient("mongodb://user1:pwd1@host1/?authSource=db1")

Para mecanismos de desafio e resposta, o uso do mecanismo de autenticação padrão é a abordagem recomendada, pois ele torna a atualização do MongoDB 2.6 para o MongoDB 3.0 mais simples, mesmo após a atualização do esquema de autenticação. Para usuários do MongoDB 4.0 , o uso do mecanismo de autenticação padrão também é recomendado, pois os mecanismos são verificados e o algoritmo de hash correto é usado.

Mecanismos baseados em SCRAM

O mecanismo de autenticação de resposta e desafio salgado (SCRAM) é o mecanismo de autenticação padrão do MongoDB desde 3.0. SCRAM é baseado no padrão IETF RFC 5802 que define as melhores práticas para a implementação de mecanismos de resposta a desafios para autenticar usuários com senhas.

O MongoDB 3.0 introduziu suporte para SCRAM-SHA-1, que usa a função de hash SHA-1 . O MongoDB 4.0 introduziu suporte para SCRAM-SHA-256 que usa a função de hash SHA-256 .

val user: String = ...          // the user name
val source: String = ...        // the source where the user is defined
val password: Array[Char] = ... // the password as a character array
// ...
val credential = MongoCredential.createScramSha256Credential(user, source, password)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

val mongoClient: MongoClient = MongoClient("mongodb://user1:pwd1@host1/?authSource=db1&authMechanism=SCRAM-SHA-256")

val user: String = ...          // the user name
val source: String = ...        // the source where the user is defined
val password: Array[Char] = ... // the password as a character array
// ...
val credential = MongoCredential.createScramSha1Credential(user, source, password)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

val mongoClient: MongoClient = MongoClient("mongodb://user1:pwd1@host1/?authSource=db1&authMechanism=SCRAM-SHA-1")

MONGODB-CR

Para criar explicitamente uma credencial do tipo MONGODB-CR utilize o método assistente createMongCRCredential() :

val user: String = ...          // the user name
val source: String = ...        // the source where the user is defined
val password: Array[Char] = ... // the password as a character array
// ...
val credential = MongoCredential.createMongoCRCredential(user, database, password)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

Ou você pode usar uma connection string que especifique explicitamente authMechanism=MONGODB-CR:

val mongoClient: MongoClient = MongoClient("mongodb://user1:pwd1@host1/?authSource=db1&authMechanism=MONGODB-CR")

X.509

Com o mecanismo X.509 , o MongoDB usa o certificado X.509 apresentado durante a negociação SSL para autenticar um usuário cujo nome é derivado do nome distinto do certificado X.509 .

X. A autenticação 509 requer o uso de conexões SSL com validação de certificado. Para criar uma credencial deste tipo, use o método assistente createMongoX509Credential() :

val user: String = ...     // The X.509 certificate derived user name, e.g. "CN=user,OU=OrgUnit,O=myOrg,..."
// ...
val credential = MongoCredential.createMongoX509Credential(user)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

Ou você pode usar uma connection string que especifique explicitamente authMechanism=MONGODB-X509:

val mongoClient: MongoClient = MongoClient("mongodb://subjectName@host1/?authMechanism=MONGODB-X509&ssl=true")

Veja Usar x.509 Tutorial de certificados para autenticação de clientes no manual do servidor MongoDB para saber mais sobre como determinar o nome do assunto a partir do certificado.

Kerberos (GSSAPI)

O MongoDB Enterprise oferece suporte à autenticação proxy por meio do serviço Kerberos. Para criar uma credencial do tipo Kerberos (GSSAPI), utilize o método auxiliar createGSSAPICredential() :

val user: String = ...   // The Kerberos user name, including the realm, e.g. "user1@MYREALM.ME"
// ...
val credential = MongoCredential.createGSSAPICredential(user)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

Ou você pode usar uma connection string que especifique explicitamente authMechanism=GSSAPI:

val mongoClient: MongoClient = MongoClient("mongodb://username%40REALM.ME@host1/?authMechanism=GSSAPI")

Para autenticar com êxito usando o Kerberos, o aplicativo normalmente deve especificar várias propriedades do sistema para que as bibliotecas Java GSSAPI subjacentes possam adquirir um ticket Kerberos:

java.security.krb5.realm=MYREALM.ME
java.security.krb5.kdc=mykdc.myrealm.me

Dependendo da configuração do Kerberos, podem ser necessárias especificações de propriedade adicionais, dentro do código do aplicativo ou, em alguns casos, usando o método withMechanismProperty() da instância MongoCredential :

• SERVICE_NAME

• CANONICALIZE_HOST_NAME

• JAVA_SUBJECT

• JAVA_SASL_CLIENT_PROPERTIES

O seguinte código mostra como especificar a propriedade SERVICE_NAME dentro do objeto MongoCredential :

val credentialWithProperty = credential.withMechanismProperty(MongoCredential.SERVICE_NAME_KEY, "othername")

Ou você pode especificar a propriedade SERVICE_NAME dentro de ConnectionString:

val uri = "mongodb://username%40MYREALM.com@myserver/?authMechanism=GSSAPI&authMechanismProperties=SERVICE_NAME:othername"

LDAP (simples)

O MongoDB Enterprise oferece suporte à autenticação proxy por meio de um serviço Lightweight Directory Access Protocol (LDAP). Para criar uma credencial do tipo LDAP , use o método auxiliar createPlainCredential() :

val user: String = ...            // The LDAP user name
val password: Array[Char] = ...   // The LDAP password
// ...
val credential = MongoCredential.createPlainCredential(user, "$external", password)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

Ou você pode usar uma connection string que especifique explicitamente authMechanism=PLAIN:

val mongoClient: MongoClient = MongoClient("mongodb://user1@host1/?authSource=$external&authMechanism=PLAIN")