Skapa en Go-konsolapp med Azure DocumentDB

Den här guiden beskriver hur du skapar ett Go-konsolprogram för att ansluta till ett Azure DocumentDB-kluster. Du konfigurerar utvecklingsmiljön, använder azidentity paketet från Azure SDK för Go för att autentisera och utför vanliga åtgärder på dokument i databasen.

Förutsättningar

En prenumeration på Azure
- Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto

Ett befintligt Azure DocumentDB-kluster
- Om du inte har något kluster skapar du ett nytt kluster

Använd Bash-miljön i Azure Cloud Shell. Mer information finns i Kom igång med Azure Cloud Shell.
Om du föredrar att köra CLI-referenskommandon lokalt installerar du Azure CLI. Om du kör på Windows eller macOS, överväg att köra Azure CLI i en Docker-container. För mer information, se Hur man kör Azure CLI i en Docker-container.
- Om du använder en lokal installation loggar du in på Azure CLI med hjälp av kommandot az login. För att avsluta autentiseringsprocessen, följ stegen som visas i din terminal. Andra inloggningsalternativ finns i Autentisera till Azure med Azure CLI.
- När du blir uppmanad, installera Azure CLI-tillägget vid första användning. Mer information om tillägg finns i Använda och hantera tillägg med Azure CLI.
- Kör az version för att ta reda på versionen och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade.

Microsoft Entra-autentisering har konfigurerats för klustret och din identitet har tilldelats root roll.
- Om du vill aktivera Microsoft Entra-autentisering läser du konfigurationsguiden.
Senaste versionen av Go.

Konfigurera konsolprogrammet

Skapa sedan ett nytt konsolprogramprojekt och importera de bibliotek som behövs för att autentisera till klustret.

Skapa en ny Go-modul för projektet med kommandot go mod init .
```
go mod init cosmicworks
```
azidentity Installera paketet för att hantera autentisering med Microsoft Entra-ID.
```
go get -u github.com/Azure/azure-sdk-for-go/sdk/azidentity
```

Installera paketet mongo interagera med klustret.

go get -u  go.mongodb.org/mongo-driver/v2/mongo

Skapa en ny fil med namnet main.go i projektkatalogen.
```
touch main.go
```

Anslut till klustret

Använd nu Azure.Identity biblioteket för att få en TokenCredential som du kan använda för att ansluta till din kluster. Den officiella MongoDB-drivrutinen har ett särskilt gränssnitt som måste implementeras för att hämta token från Microsoft Entra för användning vid anslutning till klustret.

Börja med att importera de paket som krävs överst i main.go-filen.

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

Skapa en bakgrundskontext som används i hela programmet.
```
 ctx := context.Background()
```
Skapa en instans av DefaultAzureCredential som används för att autentisera med Microsoft Entra-ID.
```
 credential, err := azidentity.NewDefaultAzureCredential(nil)
 if err != nil {
 	panic(err)
 }
```

Skapa en återanropsfunktion som hämtar åtkomsttoken när MongoDB-drivrutinen behöver autentiseras.

 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
 }

Ange klusternamnet och konstruera anslutnings-URI:n.

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

Konfigurera autentiseringsuppgifterna för MongoDB-klienten.

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

Konfigurera klientalternativen med anslutningsparametrar, TLS-konfiguration (Transport Layer Security) och autentisering.

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

Skapa en MongoDB-klientinstans med hjälp av de konfigurerade alternativen.

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

 fmt.Println("Client created")

Lägg till en avvakta-sats för att säkerställa att klienten är ordentligt frånkopplad när programmet avslutas.
```
 defer func() {
 	if err = client.Disconnect(ctx); err != nil {
 		panic(err)
 	}
 }()
```

Utföra vanliga åtgärder

Använd slutligen det officiella biblioteket för att utföra vanliga uppgifter med databaser, samlingar och dokument. Här använder du samma klasser och metoder som du skulle använda för att interagera med MongoDB eller DocumentDB för att hantera dina samlingar och objekt.

Hämta en referens till din databas med namn.

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

 fmt.Println("Database pointer created")

Hämta en referens till din samling i databasen.

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

 fmt.Println("Collection pointer created")

Definiera en produktstruktur som representerar dokumentstrukturen.

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"`
}

Skapa eller uppdatera ett dokument med hjälp av åtgärden collection.ReplaceOne som är konfigurerad för 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)

Läs ett specifikt dokument med collection.FindOne och ett filter med _id och 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)

Fråga efter flera dokument som matchar en specifik category med hjälp av collection.Find.

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

Hämta alla matchande dokument från markören.

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

Iterera igenom och visa alla produkter som finns i frågan.

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

Feedback

Var den här sidan till hjälp?

Last updated on 2025-11-19