Mecanismo de autenticación OIDC

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:

• Crear un(a) Credential estructura y pásela al método SetAuth() cuando cree un cliente.

• Establezca los 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(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(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:

• Crea una estructura Credential y pásala al método SetAuth() cuando crees un cliente

• Establezca los 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(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(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(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(opts)
if err != nil {
	panic(err)
}

Kubernetes

Si tu aplicación se ejecuta en un clúster de Kubernetes con una cuenta de servicio configurada, puedes autenticarte en MongoDB utilizando la funcionalidad incorporada de Kubernetes del driver Go. Para obtener más información sobre cómo configurar una cuenta de servicio, consulta la guía Gestionar cuentas de servicio en la documentación de Kubernetes.

Se puede configurar OIDC para Kubernetes de las siguientes maneras:

• Crea una estructura Credential y pásala al método SetAuth() cuando crees un cliente

• Establezca los parámetros en su cadena de conexión

props := map[string]string{
       "ENVIRONMENT":    "k8s",
}

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

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

Documentación de la API

• credenciales type

• Método SetAuth()

• Tipo OIDCCredential

• Función OIDCCallback