Mecanismos de autenticação empresarial

Exemplo

Este exemplo especifica o mecanismo de autenticação usando os seguintes espaços reservados:

• Kerberos principal: Seu principal Kerberos. Um exemplo de nome de usuário é myuser@KERBEROS.EXAMPLE.COM.

• password: A senha do usuário Kerberos. Você também pode armazenar sua senha em um arquivo keytab para evitar expor sua senha no código.

• connection uriSeu URI da cadeia de conexão.

O código a seguir mostra como você pode definir uma estrutura Credential para se autenticar no Kerberos e criar um cliente com suas preferências de autenticação:

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)

Você não precisa definir uma senha nem o campo PasswordSet em sua estrutura Credential se armazenar chaves de autenticação em arquivos keytab. Você pode inicializar um cache de credenciais para autenticar a entidade Kerberos utilizando o binário kinit. Para saber mais sobre o kinit binário, consulte a documentação da Oracle.

O comando a seguir mostra como você pode chamar um cache de credenciais para um exemplo de nome de usuário:

kinit myuser@KERBEROS.EXAMPLE.COM

Como alternativa, é possível se autenticar usando uma URI de string de conexão especificando a entidade Kerberos codificada por URL, a senha, o hostname e o endereço de rede do servidor MongoDB:

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

SERVICE_NAME Definir SERVICE_REALM campos personalizados e

Você pode especificar propriedades adicionais com seu mecanismo de autenticação usando o campo AuthMechanismProperties na estrutura Credential. O nome de serviço padrão para Kerberos é "mongodb". O código a seguir mostra como você pode definir valores personalizados para os campos SERVICE_NAME e SERVICE_REALM ao definir uma estrutura 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 mais informações sobre propriedades adicionais, consulte a entrada manual do servidor sobre propriedades de autenticação.

Exemplo

Este exemplo especifica o mecanismo de autenticação usando os seguintes espaços reservados:

• LDAP username: Seu nome de usuário LDAP

• password: Sua senha LDAP

• connection uri: Seu URI da cadeia de conexão

O código a seguir mostra como você pode definir uma estrutura Credential para se autenticar no LDAP e criar um cliente com suas preferências de autenticação:

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, você pode autenticar usando uma URI de string de conexão, especificando seu nome de usuário LDAP, senha e hostname, o endereço de rede do seu servidor MongoDB:

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

IMDS do Azure

Se seu aplicação for executado em uma VM do Azure ou usar o Serviço de Metadados de Instância do Azure (IMDS), você pode autenticar no MongoDB usando o suporte Azure integrado do driver Go.

Você pode configurar o OIDC para o Azure IMDS das seguintes maneiras:

• Ao criar uma estrutura Credential e passá-la para o método SetAuth() ao criar um cliente

• Ao definir parâmetros em sua string de conexão

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

Se seu aplicação é executado em uma VM do Google Compute Engine ou usa o Serviço de Metadados de Instância GCP, você pode autenticar no MongoDB usando o suporte GCP integrado do driver Go.

Você pode configurar o OIDC para o GCP IMDS das seguintes maneiras:

• Ao criar uma estrutura Credential e passá-la para o método SetAuth() ao criar um cliente

• Ao definir parâmetros em sua string de conexão

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

Chamada de resposta personalizada

O driver Go não oferece suporte integrado para todas as plataformas, incluindo o Amazon Web Services Elastic Kubernetes Service (EKS). Para autenticar em plataformas não suportadas, você deve definir uma função de chamada de resposta de chamada personalizada para usar o OIDC para autenticar. No driver, você pode definir uma função options.OIDCCallback e defini-la como o valor do campo de estrutura OIDCMachineCallback em sua estrutura Credential .

O exemplo a seguir define um retorno de chamada de resposta personalizado para um cluster EKS com um fornecedor IAM OIDC configurado. O token de acesso é lido a partir de um caminho definido na variável de ambiente 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
}

Em seguida, você pode criar uma estrutura Credential que use a função de chamada de resposta de resposta EKS definida por você:

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

Outros ambientes Azure

Se o seu aplicação for executado no Azure Functions, App Service Environment (ASE) ou Azure Kubernetes Service (AKS), você pode usar a azidentity módulo para buscar credenciais de autenticação.

Primeiro, instale o módulo azidentity executando o seguinte comando:

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

Sua função OIDCCallback deve retornar uma instância OIDCCredential que utilize o AccessToken gerado a partir do pacote azidentity . Consulte a seção anterior Chamada de resposta personalizada para obter um exemplo que implementa uma chamada de resposta de resposta personalizada para recuperar um token de acesso e, em seguida, cria um Credential.

GCP GKE

Se o seu aplicação for executado em um cluster GCP do Google Kubernetes Engine (GKE) com uma conta de serviço configurada, você pode ler o token OIDC a partir do local padrão do arquivo de token da conta de serviço.

Primeiro, defina a função OIDCCallback . Esta função lê o token OIDC e retorna uma instância do OIDCCredential .

O exemplo seguinte define uma função de chamada de resposta de chamada denominada gkeCallback. A função recupera um token OIDC de um arquivo no local padrão do arquivo de token da conta de serviço:

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
}

Em seguida, você pode criar uma estrutura Credential que use a função de chamada de resposta de chamada do GKE definida:

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

Documentação da API

• Tipo de Credencial

• SetAuth() método

• OIDCCredential tipo

• OIDCCallback função