Mecanismos de autenticación empresarial

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 cadena de conexión URI.

El siguiente código muestra cómo puede definir una estructura Credential para autenticarse en Kerberos y crear un cliente con sus 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 es necesario definir una contraseña ni el PasswordSet campo en la Credential estructura si almacena las claves de autenticación en keytab archivos. Puede inicializar una caché de credenciales para autenticar el principal Kerberos mediante el kinit binario. Para obtener más información sobre el kinit binario, consulte la documentación de Oracle.

El siguiente comando muestra cómo puedes invocar un caché de credenciales para un nombre de usuario de muestra:

kinit myuser@KERBEROS.EXAMPLE.COM

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

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

Establecer campos personalizados SERVICE_NAME SERVICE_REALM y

Puede especificar propiedades adicionales con su mecanismo de autenticación mediante el campo AuthMechanismProperties en la estructura Credential. El nombre de servicio predeterminado para Kerberos es "mongodb". El siguiente código muestra cómo 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 conocer propiedades adicionales, consulte 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:Su nombre de usuario LDAP

• password: Tu contraseña LDAP

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

El siguiente código muestra cómo 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)

También puede autenticarse utilizando una cadena de conexión URI, 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"

IMDS de Azure

Si su aplicación se ejecuta en una máquina virtual de Azure o utiliza el Servicio de metadatos de instancia de Azure (IMDS), puede autenticarse en MongoDB mediante la compatibilidad integrada de Azure del controlador Go.

Puede configurar OIDC para Azure IMDS de las siguientes maneras:

• Al crear una estructura Credential y pasarla al método SetAuth() al crear un cliente

• Configurando 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 máquina virtual de Google Compute Engine o utiliza el servicio de metadatos de instancia de GCP, puede autenticarse en MongoDB mediante la compatibilidad con GCP integrada del controlador Go.

Puede configurar OIDC para GCP IMDS de las siguientes maneras:

• Al crear una estructura Credential y pasarla al método SetAuth() al crear un cliente

• Configurando 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)
}

Devolución de llamada personalizada

El controlador Go no ofrece compatibilidad integrada con todas las plataformas, incluido AWS Elastic Kubernetes Service (EKS). Para autenticarse en plataformas no compatibles, debe definir una función de devolución de llamada personalizada que use OIDC para la autenticación. En el controlador, puede definir una función options.OIDCCallback y establecerla como el valor del campo de estructura OIDCMachineCallback en su estructura Credential.

El siguiente ejemplo define una devolución de llamada personalizada para un clúster EKS con un proveedor IAM OIDC configurado. El token de acceso se lee desde una ruta definida 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, puede crear una estructura Credential que use la función de devolución de llamada EKS que definió:

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 su aplicación se ejecuta en Azure Functions, App Service Environment (ASE) o Azure Kubernetes Service (AKS), puede usar el módulo azidentity para obtener credenciales de autenticación.

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

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

Su OIDCCallback función debe devolver una OIDCCredential instancia que use la instancia AccessToken generada a partir del azidentity paquete. Consulte la sección anterior sobre devoluciones de llamada personalizadas para ver un ejemplo que implementa una devolucion de llamada personalizada para recuperar un token de acceso y luego crea una Credential instancia.

GCP GKE

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

Primero, defina la función OIDCCallback. Esta función lee el token OIDC y devuelve una instancia OIDCCredential.

El siguiente ejemplo define una función de devolución de llamada llamada gkeCallback. Esta función recupera un token OIDC de un archivo en la ubicación estándar del archivo de tokens 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 una estructura Credential que use la función de devolución de llamada de GKE que definiste:

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

• Tipo decredencial

• MétodoSetAuth()

• Tipode credencial OIDC

• FunciónOIDCCallback