Udostępnij przez

Tworzenie aplikacji konsolowej języka Go za pomocą usługi Azure DocumentDB

W tym przewodniku wyjaśniono, jak utworzyć aplikację konsolową języka Go w celu nawiązania połączenia z klastrem usługi Azure DocumentDB. Skonfigurujesz środowisko programistyczne, używając pakietu azidentity z zestawu Azure SDK for Go do uwierzytelniania i wykonywania typowych operacji na dokumentach w bazie danych.

Wymagania wstępne

  • Subskrypcja platformy Azure

  • Istniejący klaster usługi Azure DocumentDB

  • Uwierzytelnianie Microsoft Entra zostało skonfigurowane dla klastra z przypisaną rolą dla Twojej tożsamości root.

  • Najnowsza wersja języka Go.

Konfigurowanie aplikacji konsolowej

Następnie utwórz nowy projekt aplikacji konsolowej i zaimportuj niezbędne biblioteki do uwierzytelniania w klastrze.

  1. Utwórz nowy moduł Języka Go dla projektu przy użyciu go mod init polecenia .

    go mod init cosmicworks

  2. Zainstaluj pakiet azidentity, aby obsługiwać uwierzytelnianie za pomocą Microsoft Entra ID.

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

  3. Zainstaluj pakiet mongo, aby współdziałać z klastrem.

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

  4. Utwórz nowy plik o nazwie main.go w katalogu projektu.

    touch main.go

Połącz się z klastrem

Teraz użyj biblioteki Azure.Identity, aby uzyskać TokenCredential, którego możesz użyć do połączenia się z klastrem. Oficjalny sterownik bazy danych MongoDB ma specjalny interfejs, który należy zaimplementować w celu uzyskania tokenów z firmy Microsoft Entra do użycia podczas nawiązywania połączenia z klastrem.

  1. Zacznij od zaimportowania wymaganych pakietów w górnej części main.go pliku.

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

  2. Utwórz kontekst tła używany w całej aplikacji.

     ctx := context.Background()

  3. Utwórz wystąpienie DefaultAzureCredential, które jest używane do uwierzytelniania za pomocą Microsoft Entra ID.

     credential, err := azidentity.NewDefaultAzureCredential(nil)
 if err != nil {
 	panic(err)
 }

  4. Utwórz funkcję wywołania zwrotnego, która uzyskuje tokeny dostępu, gdy sterownik bazy danych MongoDB musi się uwierzytelnić.

     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
 }

  5. Ustaw nazwę klastra i skonstruuj identyfikator URI połączenia.

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

  6. Skonfiguruj poświadczenia uwierzytelniania dla klienta bazy danych MongoDB.

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

  7. Skonfiguruj opcje klienta z parametrami połączenia, konfiguracją zabezpieczeń warstwy transportu (TLS) i uwierzytelnianiem.

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

  8. Utwórz instancję klienta MongoDB przy użyciu skonfigurowanych opcji.

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

 fmt.Println("Client created")

  9. Dodaj instrukcję odroczenia, aby upewnić się, że klient jest prawidłowo odłączony po zakończeniu działania aplikacji.

     defer func() {
 	if err = client.Disconnect(ctx); err != nil {
 		panic(err)
 	}
 }()

Wykonywanie typowych operacji

Na koniec użyj oficjalnej biblioteki do wykonywania typowych zadań z bazami danych, kolekcjami i dokumentami. W tym miejscu użyjesz tych samych klas i metod, których należy użyć do interakcji z bazą danych MongoDB lub DocumentDB w celu zarządzania kolekcjami i elementami.

  1. Uzyskaj odwołanie do bazy danych według nazwy.

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

 fmt.Println("Database pointer created")

  2. Uzyskaj odwołanie do swojej kolekcji w bazie danych.

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

 fmt.Println("Collection pointer created")

  3. Zdefiniuj strukturę Produktu, aby reprezentować strukturę dokumentu.

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

  4. Utwórz lub zaktualizuj dokument przy użyciu operacji skonfigurowanej collection.ReplaceOne dla 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)

  5. Przeczytaj konkretny dokument przy użyciu collection.FindOne i filtru z _id oraz 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)

  6. Wykonaj zapytanie dotyczące wielu dokumentów pasujących do określonego category przy użyciu polecenia collection.Find.

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

  7. Pobierz wszystkie pasujące dokumenty z kursora.

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

  8. Iterowanie i wyświetlanie wszystkich produktów znalezionych w zapytaniu.

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

Treści powiązane

  • Last updated on