Freigeben über

Erstellen einer Go-Konsolen-App mit Azure DocumentDB

In diesem Handbuch wird erläutert, wie Sie eine Go-Konsolenanwendung erstellen, um eine Verbindung mit einem Azure DocumentDB-Cluster herzustellen. Sie richten Ihre Entwicklungsumgebung ein, verwenden das azidentity Paket aus dem Azure SDK zur Authentifizierung und führen allgemeine Vorgänge an Dokumenten in der Datenbank aus.

Voraussetzungen

  • Ein Azure-Abonnement

    • Wenn Sie nicht über ein Azure-Abonnement verfügen, erstellen Sie ein kostenloses Konto

  • Ein vorhandener Azure DocumentDB-Cluster

    • Wenn Sie keinen Cluster haben, erstellen Sie einen neuen Cluster.

  • Microsoft Entra-Authentifizierung ist für den Cluster konfiguriert, wobei Ihrer Identität die root Rolle zugewiesen wurde.

  • Neueste Version von Go.

Konfigurieren der Konsolenanwendung

Erstellen Sie als Nächstes ein neues Konsolenanwendungsprojekt, und importieren Sie die erforderlichen Bibliotheken, um sich bei Ihrem Cluster zu authentifizieren.

  1. Erstellen Sie mithilfe des go mod init Befehls ein neues Go-Modul für Ihr Projekt.

    go mod init cosmicworks

  2. Installieren Sie das Paket azidentity, um die Authentifizierung mit der Microsoft Entra ID zu behandeln.

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

  3. Installieren Sie das mongo Paket, das mit Ihrem Cluster interagiert.

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

  4. Erstellen Sie eine neue Datei mit dem Namen main.go in Ihrem Projektverzeichnis.

    touch main.go

Herstellen einer Verbindung mit dem Cluster

Verwenden Sie nun die Azure.Identity Bibliothek, um ein TokenCredential zu erhalten, das Sie verwenden können, um sich mit Ihrem Cluster zu verbinden. Der offizielle MongoDB-Treiber verfügt über eine spezielle Schnittstelle, die implementiert werden muss, um Token von Microsoft Entra für die Verwendung beim Herstellen einer Verbindung mit dem Cluster abzurufen.

  1. Importieren Sie zunächst die erforderlichen Pakete am Anfang der main.go Datei.

    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. Erstellen Sie einen Hintergrundkontext, der in der gesamten Anwendung verwendet wird.

     ctx := context.Background()

  3. Erstellen Sie eine Instanz von DefaultAzureCredential, die zur Authentifizierung bei Microsoft Entra ID verwendet wird.

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

  4. Erstellen Sie eine Rückruffunktion, die Zugriffstoken abruft, wenn der MongoDB-Treiber authentifiziert werden muss.

     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. Legen Sie den Clusternamen fest, und erstellen Sie den Verbindungs-URI.

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

  6. Konfigurieren Sie die Authentifizierungsanmeldeinformationen für den MongoDB-Client.

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

  7. Richten Sie die Clientoptionen mit Verbindungsparametern, TLS-Konfiguration (Transport Layer Security) und Authentifizierung ein.

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

  8. Erstellen Sie eine MongoDB-Clientinstanz mithilfe der konfigurierten Optionen.

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

 fmt.Println("Client created")

  9. Fügen Sie eine Rückstellungsanweisung hinzu, um sicherzustellen, dass der Client ordnungsgemäß getrennt wird, wenn die Anwendung beendet wird.

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

Ausführen gängiger Vorgänge

Verwenden Sie schließlich die offizielle Bibliothek, um allgemeine Aufgaben mit Datenbanken, Sammlungen und Dokumenten auszuführen. Hier verwenden Sie die gleichen Klassen und Methoden, mit denen Sie mit MongoDB oder DocumentDB interagieren würden, um Ihre Sammlungen und Elemente zu verwalten.

  1. Rufen Sie einen Verweis auf Ihre Datenbank nach Namen ab.

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

 fmt.Println("Database pointer created")

  2. Rufen Sie einen Verweis auf Ihre Sammlung in der Datenbank ab.

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

 fmt.Println("Collection pointer created")

  3. Definieren Sie eine Produktstruktur, um die Dokumentstruktur darzustellen.

    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. Erstellen oder Aktualisieren eines Dokuments mithilfe des collection.ReplaceOne für upsert konfigurierten Vorgangs.

     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. Lesen Sie ein bestimmtes Dokument mithilfe collection.FindOne und eines Filters mit _id und 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. Abfrage mehrerer Dokumente, die mit einer bestimmten `category` unter Verwendung von `collection.Find` übereinstimmen.

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

  7. Rufen Sie alle übereinstimmenden Dokumente vom Cursor ab.

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

  8. Durchlaufen Sie alle in der Abfrage gefundenen Produkte, und zeigen Sie sie an.

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

Verwandte Inhalte

  • Last updated on