Criar um aplicativo de console Go com o Azure DocumentDB

Este guia explica como criar um aplicativo de console Go para se conectar a um cluster do Azure DocumentDB. Configure seu ambiente de desenvolvimento, use o azidentity pacote do SDK do Azure para Go para autenticar e execute operações comuns em documentos no banco de dados.

Pré-requisitos

Uma assinatura do Azure
- Se você não tiver uma assinatura do Azure, crie uma conta gratuita

Um cluster existente do Azure DocumentDB
- Se você não tiver um cluster, crie um novo cluster

Utilize o ambiente Bash no Azure Cloud Shell. Para obter mais informações, confira Introdução ao Azure Cloud Shell.
Se você preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se você estiver executando no Windows ou no macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, confira Como executar a CLI do Azure em um contêiner do Docker.
- Se você estiver usando uma instalação local, entre na CLI do Azure usando o comando az login . Para concluir o processo de autenticação, siga as etapas exibidas em seu terminal. Para obter outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.
- Quando solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar e gerenciar extensões com a CLI do Azure.
- Execute o comando az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

Autenticação do Microsoft Entra configurada para o cluster com sua identidade concedida à função root.
- Para habilitar a autenticação do Microsoft Entra, examine o guia de configuração.
Versão mais recente do Go.

Configurar seu aplicativo de console

Em seguida, crie um novo projeto de aplicativo de console e importe as bibliotecas necessárias para autenticar no cluster.

Crie um novo módulo Go para seu projeto usando o go mod init comando.
```
go mod init cosmicworks
```
Instale o azidentity pacote para lidar com a autenticação com a ID do Microsoft Entra.
```
go get -u github.com/Azure/azure-sdk-for-go/sdk/azidentity
```
Instale o pacote mongo para interagir com o cluster.
```
go get -u  go.mongodb.org/mongo-driver/v2/mongo
```
Crie um novo arquivo nomeado main.go no diretório do projeto.
```
touch main.go
```

Conectar-se ao cluster

Agora, use a biblioteca Azure.Identity para obter uma TokenCredential a ser usada para conectar-se ao cluster. O driver oficial do MongoDB tem uma interface especial que deve ser implementada para obter tokens do Microsoft Entra para uso ao se conectar ao cluster.

Comece importando os pacotes necessários na parte superior do main.go arquivo.

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

Crie um contexto em segundo plano usado em todo o aplicativo.
```
 ctx := context.Background()
```
Crie uma instância de DefaultAzureCredential que seja usada para autenticar com o Microsoft Entra ID.
```
 credential, err := azidentity.NewDefaultAzureCredential(nil)
 if err != nil {
 	panic(err)
 }
```

Crie uma função callback que obtenha tokens de acesso quando o driver do MongoDB precisar se autenticar.

 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
 }

Defina o nome do cluster e construa o URI de conexão.

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

Configure as credenciais de autenticação para o cliente MongoDB.

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

Configure as opções do cliente com parâmetros de conexão, configuração de TLS (segurança de camada de transporte) e autenticação.

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

Crie uma instância de cliente do MongoDB usando as opções configuradas.

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

 fmt.Println("Client created")

Adicione uma instrução de adiamento para garantir que o cliente esteja corretamente desconectado quando seu aplicativo for encerrado.
```
 defer func() {
 	if err = client.Disconnect(ctx); err != nil {
 		panic(err)
 	}
 }()
```

Executar operações comuns

Por fim, use a biblioteca oficial para executar tarefas comuns com bancos de dados, coleções e documentos. Aqui, você usa as mesmas classes e métodos que usaria para interagir com MongoDB ou DocumentDB para gerenciar suas coleções e itens.

Obtenha uma referência ao banco de dados pelo nome.

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

 fmt.Println("Database pointer created")

Obtenha uma referência à sua coleção no banco de dados.

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

 fmt.Println("Collection pointer created")

Defina uma struct de Produto para representar a estrutura do 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"`
}

Crie ou atualize um documento usando a collection.ReplaceOne operação 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)

Leia um documento específico usando collection.FindOne e um filtro com _id e 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)

Consultar vários documentos correspondentes a um específico category usando collection.Find.

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

Recupere todos os documentos que correspondem a partir do cursor.

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

Itere e exiba todos os produtos encontrados na consulta.

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

Comentários

Esta página foi útil?

Last updated on 2025-11-19