Mecanismo de autenticación de OIDC

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:

• Crear una 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.

Puede configurar OIDC para GCP IMDS de las siguientes maneras:

• Crea una estructura Credential y pásala al método SetAuth() cuando creas 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)
}

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

Kubernetes

Si su aplicación se ejecuta en un clúster de Kubernetes con una cuenta de servicio configurada, puede autenticarse en MongoDB mediante la compatibilidad integrada con Kubernetes del controlador Go. Para obtener más información sobre cómo configurar una cuenta de servicio, consulte la guía "Administrar 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 creas 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()

• Tipode credencial OIDC

• FunciónOIDCCallback