Compilación de una aplicación de consola de Go con Azure DocumentDB

En esta guía se explica cómo crear una aplicación de consola de Go para conectarse a un clúster de Azure DocumentDB. Configure el entorno de desarrollo, use el azidentity paquete del SDK de Azure para Go para autenticarse y realice operaciones comunes en documentos de la base de datos.

Prerrequisitos

Una suscripción de Azure
- Si no tiene ninguna suscripción a Azure, cree una cuenta gratuita

Un clúster de Azure DocumentDB existente
- Si no tiene un clúster, cree un nuevo clúster.

Use el entorno de Bash en Azure Cloud Shell. Para más información, consulte Introducción a Azure Cloud Shell.
Si prefieres ejecutar comandos de referencia CLI localmente, instala la CLI de Azure. Si estás utilizando Windows o macOS, considera ejecutar Azure CLI en un contenedor Docker. Para obtener más información, consulte Cómo ejecutar el Azure CLI en un contenedor de Docker.
- Si estás utilizando una instalación local, inicia sesión en Azure CLI utilizando el comando az login. Siga los pasos que se muestran en el terminal para completar el proceso de autenticación. Para ver otras opciones de inicio de sesión, consulte Autenticación en Azure mediante la CLI de Azure.
- En caso de que se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para obtener más información sobre las extensiones, consulte Uso y administración de extensiones con la CLI de Azure.
- Ejecute az version para ver la versión y las bibliotecas dependientes que están instaladas. Para actualizar a la versión más reciente, ejecute az upgrade.

La autenticación de Microsoft Entra está configurada para el clúster con el rol root concedido a la identidad.
- Para habilitar la autenticación de Microsoft Entra, revise la guía de configuración.
Última versión de Go.

Configuración de la aplicación de consola

A continuación, cree un nuevo proyecto de aplicación de consola e importe las bibliotecas necesarias para autenticarse en el clúster.

Cree un nuevo módulo go para el proyecto mediante el go mod init comando .
```
go mod init cosmicworks
```
Instale el paquete azidentity para controlar la autenticación con Microsoft Entra ID.
```
go get -u github.com/Azure/azure-sdk-for-go/sdk/azidentity
```
Instale el paquete mongo para interactuar con su clúster.
```
go get -u  go.mongodb.org/mongo-driver/v2/mongo
```
Cree un nuevo archivo denominado main.go en el directorio del proyecto.
```
touch main.go
```

Conectarse al clúster

Ahora, utilice la Azure.Identity biblioteca para obtener un TokenCredential que usará para conectarse a su clúster. El controlador oficial de MongoDB tiene una interfaz especial que se debe implementar para obtener tokens de Microsoft Entra para su uso al conectarse al clúster.

Empiece por importar los paquetes necesarios en la parte superior del main.go archivo.

import (
	"context"
	"crypto/tls"
	"encoding/json"
	"fmt"
	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

Cree un contexto en segundo plano que se use en toda la aplicación.
```
 ctx := context.Background()
```
Cree una instancia de DefaultAzureCredential que se use para autenticarse con el identificador de Microsoft Entra.
```
 credential, err := azidentity.NewDefaultAzureCredential(nil)
 if err != nil {
 	panic(err)
 }
```

Cree una función de devolución de llamada que obtenga tokens de acceso cuando el controlador de MongoDB necesite autenticarse.

 azureIdentityTokenCallback := func(_ context.Context,
 	_ *options.OIDCArgs) (*options.OIDCCredential, error) {
 	accessToken, err := credential.GetToken(ctx, policy.TokenRequestOptions{
 		Scopes: []string{"https://ossrdbms-aad.database.windows.net/.default"},
 	})
 	if err != nil {
 		return nil, err
 	}
 	return &options.OIDCCredential{
 		AccessToken: accessToken.Token,
 	}, nil
 }

Establezca el nombre del clúster y construya el URI de conexión.

 clusterName := "<azure-documentdb-cluster-name>"
 uri := fmt.Sprintf("mongodb+srv://%s.global.mongocluster.cosmos.azure.com/", clusterName)

Configure las credenciales de autenticación para el cliente de MongoDB.

 auth := options.Credential{
 	AuthMechanism:       "MONGODB-OIDC",
 	OIDCMachineCallback: azureIdentityTokenCallback,
 }

Configure las opciones de cliente con parámetros de conexión, configuración de seguridad de la capa de transporte (TLS) y autenticación.

 clientOptions := options.Client().
 	ApplyURI(uri).
 	SetConnectTimeout(2 * time.Minute).
 	SetRetryWrites(true).
 	SetTLSConfig(&tls.Config{}).
 	SetAuth(auth)

Cree una instancia de cliente de MongoDB mediante las opciones configuradas.

 client, err := mongo.Connect(clientOptions)
 if err != nil {
 	panic(err)
 }

 fmt.Println("Client created")

Agregue una instrucción de aplazamiento para asegurarse de que el cliente está desconectado correctamente cuando se cierra la aplicación.
```
 defer func() {
 	if err = client.Disconnect(ctx); err != nil {
 		panic(err)
 	}
 }()
```

Realización de operaciones comunes

Por último, use la biblioteca oficial para realizar tareas comunes con bases de datos, colecciones y documentos. Aquí, usará las mismas clases y métodos que usaría para interactuar con MongoDB o DocumentDB para administrar las colecciones y los elementos.

Obtenga una referencia a su base de datos por nombre.

 database := client.Database("<database-name>")

 fmt.Println("Database pointer created")

Obtenga una referencia a la colección dentro de la base de datos.

 collection := database.Collection("<collection-name>")

 fmt.Println("Collection pointer created")

Defina una estructura de tipo Product para representar la estructura de su documento.

type Product struct {
    ID        string `bson:"_id"`
    Category  string `bson:"category"`
    Name      string `bson:"name"`
    Quantity  int    `bson:"quantity"`
    Price     decimal128.Decimal128 `bson:"price"`
    Clearance bool   `bson:"clearance"`
}

Cree o actualice un documento mediante la collection.ReplaceOne operación configurada para upsert.

 opts := options.Replace().SetUpsert(true)
 upsertFilter := bson.D{{Key: "_id", Value: "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb"}}
 priceDecimal, err := bson.ParseDecimal128("850.00")
 if err != nil {
 	panic(err)
 }
 document := Product{
 	ID:        "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
 	Category:  "gear-surf-surfboards",
 	Name:      "Yamba Surfboard",
 	Quantity:  12,
 	Price:     priceDecimal,
 	Clearance: false}

 result, err := collection.ReplaceOne(ctx, upsertFilter, document, opts)
 if err != nil {
 	panic(err)
 }

 fmt.Printf("Documents upserted count:\t%d\n", result.UpsertedCount)

Lea un documento específico mediante collection.FindOne y un filtro con _id y category.

 readFilter := bson.D{{Key: "_id", Value: "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb"}, {Key: "category", Value: "gear-surf-surfboards"}}
 var target Product
 err = collection.FindOne(ctx, readFilter).Decode(&target)
 if err != nil {
 	panic(err)
 }

 fmt.Printf("Read document name:\t%s\n", target.Name)

Consulte varios documentos que coincidan con un específico category mediante collection.Find.

 queryFilter := bson.D{{Key: "category", Value: "gear-surf-surfboards"}}
 cursor, err := collection.Find(ctx, queryFilter)
 if err != nil {
 	panic(err)
 }

Obtenga todos los documentos que coincidan del cursor.

 var products []Product
 if err = cursor.All(ctx, &products); err != nil {
 	panic(err)
 }

Recorre en iteración y muestra todos los productos encontrados en la consulta.

 for _, product := range products {
 	json, err := json.Marshal(product)
 	if err != nil {
 		panic(err)
 	}
 	fmt.Printf("Found document:\t%s\n", string(json))
 }

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-11-19