Mecanismo de autenticación de OIDC

IMDS de Azure

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 struct y páselo al método SetAuth() cuando crea un cliente

• Establezca 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 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.

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 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 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 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 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 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.

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 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 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

• Tipo decredencial

• MétodoSetAuth()

• Tipo OIDCCredential

• FunciónOIDCCallback