Mecanismos de autenticación de empresa

Ejemplo

Este ejemplo especifica el mecanismo de autenticación utilizando los siguientes marcadores de posición:

• Kerberos principal: Tu principal de Kerberos. Un nombre de usuario de muestra es myuser@KERBEROS.EXAMPLE.COM.

• password: La contraseña del usuario Kerberos. También se puede almacenar la contraseña en un archivo keytab para evitar exponerla en el código.

• connection uri: Su URI de cadena de conexión.

El siguiente código muestra cómo puedes definir una estructura Credential para autenticarte en Kerberos y crear un cliente con tus preferencias de autenticación:

credential := options.Credential{
        AuthMechanism: "GSSAPI",
        Username:      "<Kerberos principal>",
        Password:      "<password>",
        PasswordSet:   true,
}
uri := "<connection uri>"
clientOpts := options.Client().ApplyURI(uri).SetAuth(credential)
client, err := mongo.Connect(context.TODO(), clientOpts)

No necesitas definir una contraseña o el campo PasswordSet en tu estructura de Credential si almacenas claves de autenticación en archivos keytab. Puedes inicializar una caché de credenciales para autenticar el principal de Kerberos utilizando el binario kinit. Para obtener más información sobre el binario kinit, consulta la documentación de Oracle.

El siguiente comando muestra cómo se puede invocar una caché de credenciales para un nombre de usuario de ejemplo:

kinit myuser@KERBEROS.EXAMPLE.COM

También puede autenticarse utilizando un URI de cadena de conexión, especificando su URL codificado Kerberos principal, la contraseña y hostname, la dirección de red del servidor MongoDB:

uri := "mongodb://<Kerberos principal>:<password>@<hostname>/?authMechanism=GSSAPI"

Configura campos personalizados SERVICE_NAME y SERVICE_REALM

Puedes especificar propiedades adicionales para tu mecanismo de autenticación usando el campo AuthMechanismProperties en la estructura Credential. El nombre de servicio por defecto para Kerberos es "mongodb". El siguiente código muestra cómo puedes establecer valores personalizados para los campos SERVICE_NAME y SERVICE_REALM al definir una estructura Credential:

credential := options.Credential{
        AuthMechanism: "GSSAPI",
        Username:      "<Kerberos principal>",
        Password:      "<password>",
        AuthMechanismProperties: map[string]string{
                "SERVICE_REALM": "<Kerberos service realm>",
                "SERVICE_NAME":  "<service name>",
        },
}

Para obtener propiedades adicionales, consulta la entrada del manual del servidor sobre propiedades de autenticación.

Ejemplo

Este ejemplo especifica el mecanismo de autenticación utilizando los siguientes marcadores de posición:

• LDAP username: Tu nombre de usuario LDAP

• password: Tu contraseña LDAP

• connection uriUri de tu cadena de conexión

El siguiente código muestra cómo se puede definir una estructura Credential para autenticarse en LDAP y crear un cliente con sus preferencias de autenticación:

credential := options.Credential{
        AuthMechanism: "PLAIN",
        Username:      "<LDAP username>",
        Password:      "<password>",
     }
uri := "<connection uri>"
clientOpts := options.Client().ApplyURI(uri).SetAuth(credential)
client, err := mongo.Connect(context.TODO(), clientOpts)

Como alternativa, puede autenticarse usando un URI de cadena de conexión, especificando su nombre de usuario LDAP, contraseña y hostname, la dirección de red de su servidor MongoDB:

uri := "mongodb://<LDAP username>:<password>@<hostname>/?authMechanism=PLAIN"

Azure IMDS

Si tu aplicación se ejecuta en una VM de Azure, o utiliza Azure Instancia Metadatos Service (IMDS) de otro modo, puedes autenticarte en MongoDB utilizando la funcionalidad incorporada con Azure del driver de Go.

Puedes configurar OIDC para Azure IMDS de las siguientes maneras:

• Creando una estructura Credential y pasándola al método SetAuth() al crear un cliente

• Estableciendo parámetros en su cadena de conexión

props := map[string]string{
       "ENVIRONMENT":    "azure",
       "TOKEN_RESOURCE": "<audience>",
}

uri := "mongodb://<hostname>:<port>"
props := map[string]string{
	"ENVIRONMENT":    "azure",
	"TOKEN_RESOURCE": "<audience>",
}
opts := options.Client().ApplyURI(uri)
opts.SetAuth(
	options.Credential{
		Username:                "<Azure client ID or application ID>",
		AuthMechanism:           "MONGODB-OIDC",
		AuthMechanismProperties: props,
	},
)
client, err := mongo.Connect(context.TODO(), opts)
if err != nil {
	panic(err)
}

uri := "mongodb://<hostname>:<port>/?" +
     "username=<Azure client ID or application ID>" +
     "&authMechanism=MONGODB-OIDC" +
     "&authMechanismProperties=ENVIRONMENT:azure,TOKEN_RESOURCE:<percent-encoded audience>"
client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
if err != nil {
  panic(err)
}

GCP IMDS

Si su aplicación se ejecuta en una VM de Google Compute Engine, o utiliza el Servicio de metadatos de instancia de GCP, puede autenticarse a MongoDB utilizando el soporte de funcionalidad incorporada de GCP del driver Go.

Puedes configurar OIDC para GCP IMDS de las siguientes formas:

• Creando una estructura Credential y pasándola al método SetAuth() al crear un cliente

• Estableciendo parámetros en su cadena de conexión

props := map[string]string{
       "ENVIRONMENT":    "gcp",
       "TOKEN_RESOURCE": "<audience>",
}

uri := "mongodb://<hostname>:<port>"
props := map[string]string{
	"ENVIRONMENT":    "gcp",
	"TOKEN_RESOURCE": "<audience>",
}
opts := options.Client().ApplyURI(uri)
opts.SetAuth(
	options.Credential{
		AuthMechanism:           "MONGODB-OIDC",
		AuthMechanismProperties: props,
	},
)
client, err := mongo.Connect(context.TODO(), opts)
if err != nil {
	panic(err)
}

uri := "mongodb://<hostname>:<port>/?" +
     "&authMechanism=MONGODB-OIDC" +
     "&authMechanismProperties=ENVIRONMENT:gcp,TOKEN_RESOURCE:<percent-encoded audience>"
client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
if err != nil {
  panic(err)
}

Función de retorno personalizado

El driver de Go no ofrece soporte de funcionalidad incorporada para todas las plataformas, incluido el Servicio de Kubernetes Elástico (EKS) de AWS. Para autenticarse en plataformas no compatibles, debe definir una función de retorno personalizada para usar OIDC para la autenticación. En el driver, puedes definir una función options.OIDCCallback y establecerla como el valor del campo struct OIDCMachineCallback en tu struct Credential.

El siguiente ejemplo define una función de retorno personalizada para un clúster de EKS con un proveedor OIDC de IAM configurado. El token de acceso se lee desde una ruta establecida en la variable de entorno AWS_WEB_IDENTITY_TOKEN_FILE:

eksCallback := func(_ context.Context,
	_ *options.OIDCArgs) (*options.OIDCCredential, error) {
	accessToken, err := os.ReadFile(
		os.Getenv("AWS_WEB_IDENTITY_TOKEN_FILE"))
	if err != nil {
		return nil, err
	}
	return &options.OIDCCredential{
		AccessToken: string(accessToken),
	}, nil
}

Luego, puedes crear una estructura Credential que use la función de retorno de EKS que definiste:

uri := "mongodb://<hostname>:<port>"
opts := options.Client().ApplyURI(uri)
opts.SetAuth(
	options.Credential{
		AuthMechanism:       "MONGODB-OIDC",
		OIDCMachineCallback: eksCallback,
	},
)
client, err := mongo.Connect(context.TODO(), opts)
if err != nil {
	panic(err)
}

Otros entornos de Azure

Si tu aplicación se ejecuta en Azure Functions, App Service Environment (ASE) o Azure Kubernetes Service (AKS), puedes usar el módulo azidentity para obtener credenciales de autenticación.

Primero, instala el módulo azidentity ejecutando el siguiente comando:

go get -u github.com/Azure/azure-sdk-for-go/sdk/azidentity

Su función OIDCCallback debe retornar una instancia OIDCCredential que use el AccessToken generado a partir del paquete azidentity. Consulte la sección anterior de función de retorno personalizada para ver un ejemplo que implementa una función de retorno personalizada para recuperar un token de acceso y luego crear un Credential.

GCP GKE

Si tu aplicación se ejecuta en un clúster de GCP Google Kubernetes Engine (GKE) con una cuenta de servicio configurada, puedes leer el token de OIDC desde la ubicación estándar del archivo de token de la cuenta de servicio.

En primer lugar, define la función OIDCCallback. Esta función lee el token OIDC y devuelve una instancia de OIDCCredential.

El siguiente ejemplo define una función de retorno llamada gkeCallback. La función recupera un token OIDC de un archivo en la ubicación estándar del archivo de token de la cuenta de servicio:

gkeCallback := func(_ context.Context,
	_ *options.OIDCArgs) (*options.OIDCCredential, error) {
	accessToken, err := os.ReadFile(
		"/var/run/secrets/kubernetes.io/serviceaccount/token")
	if err != nil {
		return nil, err
	}
	return &options.OIDCCredential{
		AccessToken: string(accessToken),
	}, nil
}

Luego, puedes crear un Credential struct que utilice la función de retorno de GKE que has definido:

uri := "mongodb://<hostname>:<port>"
opts := options.Client().ApplyURI(uri)
opts.SetAuth(
	options.Credential{
		AuthMechanism:       "MONGODB-OIDC",
		OIDCMachineCallback: gkeCallback,
	},
)
client, err := mongo.Connect(context.TODO(), opts)
if err != nil {
	panic(err)
}

Documentación de la API

• credenciales type

• Método SetAuth()

• Tipo OIDCCredential

• Función OIDCCallback