Docs Menu
Docs Home
/ /
Conéctese a MongoDB
Docs Home
/ /
Tutorials
/
Conéctese a MongoDB
Docs Home
/
Idiomas
/
Java
/
Driver de Java Reactive Streams
/
Tutorials
/
Conéctese a MongoDB

Autenticación

El controlador admite todos los mecanismos de autenticación de MongoDB, incluidos aquellos disponibles solo en MongoDB Enterprise Edition.

Credencial de Mongo

Incluya las siguientes declaraciones de importación:

import com.mongodb.MongoCredential;
import com.mongodb.ConnectionString;
import com.mongodb.reactivestreams.client.MongoClients;
import com.mongodb.reactivestreams.client.MongoClient;

Una credencial de autenticación se representa como una instancia de la MongoCredential clase. La clase MongoCredential incluye métodos de fábrica estáticos para cada uno de los mecanismos de autenticación admitidos.

Mecanismo de autenticación predeterminado

Para crear una credencial que se autentique mediante el mecanismo de autenticación predeterminado, SCRAM-SHA-256, cree una credencial utilizando el método de fábrica estático createCredential():

String user;     // the user name
String source;   // the source where the user is defined
char[] password; // the password as a character array
// ...
MongoCredential credential = MongoCredential.createCredential(user, source, password);
MongoClient mongoClient = MongoClients.create(
    MongoClientSettings.builder()
        .applyToClusterSettings(builder ->
            builder.hosts(Arrays.asList(new ServerAddress("host1", 27017))))
        .credential(credential)
        .build());

O bien, puede utilizar una cadena de conexión sin especificar explícitamente el mecanismo de autenticación:

MongoClient mongoClient = MongoClients.create("mongodb://user1:pwd1@host1/?authSource=db1");

Para los mecanismos de desafío y respuesta, recomendamos usar el mecanismo de autenticación predeterminado. Esto simplifica las actualizaciones y garantiza el uso del algoritmo hash correcto.

Mecanismos basados ​​en SCRAM

El mecanismo de autenticación de desafío-respuesta con sal ()SCRAM se basa en el RFC de IETF 5802Estándar que define las mejores prácticas para la implementación de mecanismos de desafío-respuesta para la autenticación de usuarios con contraseñas. MongoDB admite SCRAM-SHA-1 tanto, que utiliza la SHA-1 función hash,SCRAM- SHA-256 como, que utiliza la SHA-256 función hash.

SCRAM-SHA-256

Para crear explícitamente una credencial de tipo SCRAM-SHA-256, utilice el método createScramSha256Credential():

String user;     // the user name
String source;   // the source where the user is defined
char[] password; // the password as a character array
// ...
MongoCredential credential = MongoCredential.createScramSha256Credential(user, source, password);
MongoClient mongoClient = MongoClients.create(
    MongoClientSettings.builder()
        .applyToClusterSettings(builder ->
            builder.hosts(Arrays.asList(new ServerAddress("host1", 27017))))
        .credential(credential)
        .build());

O bien, puedes utilizar una cadena de conexión que especifique explícitamente authMechanism=SCRAM-SHA-256:

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

SCRAM-SHA-1

Para crear explícitamente una credencial de tipo SCRAM-SHA-1, utilice el método createScramSha1Credential():

String user;     // the user name
String source;   // the source where the user is defined
char[] password; // the password as a character array
// ...
MongoCredential credential = MongoCredential.createScramSha1Credential(user, source, password);
MongoClient mongoClient = MongoClients.create(
    MongoClientSettings.builder()
        .applyToClusterSettings(builder ->
            builder.hosts(Arrays.asList(new ServerAddress("host1", 27017))))
        .credential(credential)
        .build());

O bien, puedes utilizar una cadena de conexión que especifique explícitamente authMechanism=SCRAM-SHA-1:

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

MONGODB-CR

Importante

MongoDB ya no admite el mecanismo de autenticación de desafío-respuesta (MONGODB-CR), que ya no se utiliza. Si su implementación tiene credenciales de usuario almacenadas en un esquema MONGODB-CR, debe actualizar a un mecanismo basado en SCRAM.

Para crear explícitamente una credencial de tipo MONGODB-CR utilice el método de fábrica estático createMongCRCredential():

String user; // the user name
String database; // the name of the database in which the user is defined
char[] password; // the password as a character array
// ...
MongoCredential credential = MongoCredential.createMongoCRCredential(user, database, password);
MongoClient mongoClient = MongoClients.create(
    MongoClientSettings.builder()
        .applyToClusterSettings(builder ->
            builder.hosts(Arrays.asList(new ServerAddress("host1", 27017))))
        .credential(credential)
        .build());

O bien, puedes utilizar una cadena de conexión que especifique explícitamente authMechanism=MONGODB-CR:

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

Nota

Después de actualizar el esquema de autenticación de MONGODB-CR a SCRAM, las credenciales de MONGODB-CR no se autenticarán.

X.509

Con el mecanismo X.509, MongoDB utiliza el certificado X.509 presentado durante la negociación SSL para autenticar a un usuario cuyo nombre se deriva del nombre distinguido del certificado X.509.

La autenticación X.509 requiere el uso de conexiones SSL con validación de certificado. Para crear una credencial de este tipo, utilice el método de fábrica estático createMongoX509Credential():

String user;     // The X.509 certificate derived user name, e.g. "CN=user,OU=OrgUnit,O=myOrg,..."
// ...
MongoCredential credential = MongoCredential.createMongoX509Credential(user);
MongoClient mongoClient = MongoClients.create(
    MongoClientSettings.builder()
        .applyToClusterSettings(builder ->
            builder.hosts(Arrays.asList(new ServerAddress("host1", 27017))))
        .credential(credential)
        .build());

O bien, puedes utilizar una cadena de conexión que especifique explícitamente authMechanism=MONGODB-X509:

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

Consulte el tutorial Usar certificados x. para autenticar clientes en509 el manual del servidor para obtener más información sobre cómo determinar el nombre del sujeto a partir del certificado.

Kerberos (GSSAPI)

MongoDB Enterprise admite la autenticación por proxy a través del servicio Kerberos. Para crear una credencial de tipo Kerberos (GSSAPI), utilice el método de fábrica estático createGSSAPICredential():

String user;   // The Kerberos user name, including the realm, e.g. "user1@MYREALM.ME"
// ...
MongoCredential credential = MongoCredential.createGSSAPICredential(user);
MongoClient mongoClient = MongoClients.create(
    MongoClientSettings.builder()
        .applyToClusterSettings(builder ->
            builder.hosts(Arrays.asList(new ServerAddress("host1", 27017))))
        .credential(credential)
        .build());

O bien, puedes utilizar una cadena de conexión que especifique explícitamente authMechanism=GSSAPI:

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

Nota

El método hace referencia al mecanismo de autenticación GSSAPI en lugar de Kerberos porque el controlador se autentica utilizando el mecanismo SASL GSSAPI.

Para autenticarse exitosamente mediante Kerberos, la aplicación generalmente debe especificar varias propiedades del sistema para que las bibliotecas Java GSSAPI subyacentes puedan adquirir un ticket Kerberos:

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

Dependiendo de la configuración de Kerberos, es posible que se requieran especificaciones de propiedades adicionales, ya sea dentro del código de la aplicación o, en algunos casos, mediante el método withMechanismProperty() de la instancia MongoCredential:

  • SERVICE_NAME

  • CANONICALIZE_HOST_NAME

  • JAVA_SUBJECT

  • JAVA_SASL_CLIENT_PROPERTIES

El siguiente código muestra cómo especificar la propiedad SERVICE_NAME dentro del objeto MongoCredential:

credential = credential.withMechanismProperty(MongoCredential.SERVICE_NAME_KEY, "othername");

O bien, puede especificar la propiedad SERVICE_NAME dentro de ConnectionString:

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

Nota

En Windows, Oracles JRE utiliza LSA en lugar de SSPI en su implementación de GSSAPI, lo que limita la interoperabilidad con Windows Active Directory y, en particular, la capacidad de implementar el inicio de sesión único.

LDAP (PLAIN)

MongoDB Enterprise admite la autenticación por proxy mediante un servicio de Protocolo Ligero de Acceso a Directorios (LDAP). Para crear una credencial de tipo LDAP, utilice el método de fábrica estático createPlainCredential():

String user;          // The LDAP user name
char[] password;      // The LDAP password
// ...
MongoCredential credential = MongoCredential.createPlainCredential(user, "$external", password);
MongoClient mongoClient = MongoClients.create(
    MongoClientSettings.builder()
        .applyToClusterSettings(builder ->
            builder.hosts(Arrays.asList(new ServerAddress("host1", 27017))))
        .credential(credential)
        .build());

O bien, puedes utilizar una cadena de conexión que especifique explícitamente authMechanism=PLAIN:

MongoClient mongoClient = MongoClients.create("mongodb://user1@host1/?authSource=$external&authMechanism=PLAIN");

Nota

El método hace referencia al mecanismo de autenticación PLAIN en lugar de LDAP porque el controlador se autentica utilizando el mecanismo SASL PLAIN.

Volver

TLS/SSL

Next

Compresión

En esta página