Snabbstart: Anslut ett Go-program till Azure Cosmos DB API för MongoDB

Artikel
11/25/2021
9 minuter för att läsa

GÄLLER för: Azure Cosmos DB-API för MongoDB

Azure Cosmos DB är en databastjänst med flera modeller som gör att du snabbt kan skapa och fråga databaser för dokument, tabeller, nyckelvärden och grafer med global distribution och horisontella skalningsfunktioner. I den här snabbstarten skapar och hanterar du ett Azure Cosmos DB-konto med hjälp av Azure Cloud Shell, klonar ett befintligt exempelprogram från GitHub och konfigurerar det så att det fungerar med Azure Cosmos DB.

Exempelprogrammet är ett kommandoradsbaserat todo hanteringsverktyg som skrivits i Go. Azure Cosmos DB API för MongoDB är kompatibelt med MongoDB-trådprotokollet,vilket gör det möjligt för alla MongoDB-klientdrivrutiner att ansluta till den. Det här programmet använder Go-drivrutinen för MongoDB på ett sätt som är transparent för programmet att data lagras i en Azure Cosmos DB databas.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Skapa en utan kostnad. Eller prova Azure Cosmos DB utan en Azure-prenumeration. Du kan också använda Azure Cosmos DB Emulator med anslutningssträngen .mongodb://localhost:C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==@localhost:10255/admin?ssl=true .
Installera på datorn och ha kunskaper om Go.
Git.

Använd bash-miljön i Azure Cloud Shell.
Om du vill kan du i stället installera Azure CLI för att köra CLI-referenskommandon.
- Om du använder en lokal installation loggar du in på Azure CLI med hjälp av kommandot az login. Slutför autentiseringsprocessen genom att följa stegen som visas i terminalen. Fler inloggningsalternativ finns i Logga in med Azure CLI.
- När du uppmanas till det installerar du Azure CLI-tillägg vid första användning. Mer information om tillägg finns i Använda tillägg med Azure CLI.
- Kör az version om du vill hitta versionen och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade.

Klona exempelprogrammet

Kör följande kommandon för att klona exempellagringsplatsen.

Öppna en kommandotolk, skapa en ny mapp med git-samples namnet och stäng sedan kommandotolken.
```
mkdir "C:\git-samples"
```
Öppna ett git-terminalfönster, t.ex. git bash, och använd kommandot cd för att ändra till den nya mappen där du vill installera exempelappen.
```
cd "C:\git-samples"
```
Klona exempellagringsplatsen med följande kommando. Detta kommando skapar en kopia av exempelappen på din dator.
```
git clone https://github.com/Azure-Samples/cosmosdb-go-mongodb-quickstart
```

Granska koden

Det här är valfritt. Om du är intresserad av att lära dig hur programmet fungerar kan du granska följande kodavsnitt. Annars kan du gå vidare till Kör programmet. Programlayouten ser ut så här:

.
├── go.mod
├── go.sum
└── todo.go

Följande kodavsnitt är alla hämtade från filen todo.go.

Ansluta Go-appen till Azure Cosmos DB

clientOptions kapslar in anslutningssträngen för Azure Cosmos DB, som skickas med hjälp av en miljövariabel (information i det kommande avsnittet). Anslutningen initieras med hjälp mongo.NewClient av vilken clientOptions instansen skickas. Ping funktionen anropas för att bekräfta en lyckad anslutning (det är en strategi som går snabbt att redundansväxa)

    ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
    defer cancel()

    clientOptions := options.Client().ApplyURI(mongoDBConnectionString).SetDirect(true)
    
    c, err := mongo.NewClient(clientOptions)
    err = c.Connect(ctx)
    if err != nil {
        log.Fatalf("unable to initialize connection %v", err)
    }

    err = c.Ping(ctx, nil)
    if err != nil {
        log.Fatalf("unable to connect %v", err)
    }

Anteckning

Det är SetDirect(true) viktigt att använda konfigurationen, utan vilken du får följande anslutningsfel: unable to connect connection(cdb-ms-prod-<azure-region>-cm1.documents.azure.com:10255[-4]) connection is closed

Skapa ett `todo` objekt

För att skapa todo en får vi en referens till en och mongo.Collection InsertOne anropar funktionen .

func create(desc string) {
    c := connect()
    ctx := context.Background()
    defer c.Disconnect(ctx)

    todoCollection := c.Database(database).Collection(collection)
    r, err := todoCollection.InsertOne(ctx, Todo{Description: desc, Status: statusPending})
    if err != nil {
        log.Fatalf("failed to add todo %v", err)
    }

Vi skickar en Todo struct som innehåller beskrivningen och statusen (som ursprungligen är inställd på pending )

type Todo struct {
    ID          primitive.ObjectID `bson:"_id,omitempty"`
    Description string             `bson:"description"`
    Status      string             `bson:"status"`
}

`todo`Listobjekt

Vi kan lista TODOs baserat på kriterier. En bson.D skapas för att kapsla in filtervillkoren

func list(status string) {
    .....
    var filter interface{}
    switch status {
    case listAllCriteria:
        filter = bson.D{}
    case statusCompleted:
        filter = bson.D{{statusAttribute, statusCompleted}}
    case statusPending:
        filter = bson.D{{statusAttribute, statusPending}}
    default:
        log.Fatal("invalid criteria for listing todo(s)")
    }

Find används för att söka efter dokument baserat på filtret och resultatet konverteras till ett segment av Todo

    todoCollection := c.Database(database).Collection(collection)
    rs, err := todoCollection.Find(ctx, filter)
    if err != nil {
        log.Fatalf("failed to list todo(s) %v", err)
    }
    var todos []Todo
    err = rs.All(ctx, &todos)
    if err != nil {
        log.Fatalf("failed to list todo(s) %v", err)
    }

Slutligen återges informationen i tabellformat

    todoTable := [][]string{}

    for _, todo := range todos {
        s, _ := todo.ID.MarshalJSON()
        todoTable = append(todoTable, []string{string(s), todo.Description, todo.Status})
    }

    table := tablewriter.NewWriter(os.Stdout)
    table.SetHeader([]string{"ID", "Description", "Status"})

    for _, v := range todoTable {
        table.Append(v)
    }
    table.Render()

Uppdatera ett `todo` objekt

En todo kan uppdateras baserat på dess _id . Ett filter skapas baserat på och ett annat skapas för den uppdaterade informationen, vilket i det här fallet är en bson.D ny status ( eller _id completed pending ). Slutligen UpdateOne anropas funktionen med filtret och det uppdaterade dokumentet

func update(todoid, newStatus string) {
....
    todoCollection := c.Database(database).Collection(collection)
    oid, err := primitive.ObjectIDFromHex(todoid)
    if err != nil {
        log.Fatalf("failed to update todo %v", err)
    }
    filter := bson.D{{"_id", oid}}
    update := bson.D{{"$set", bson.D{{statusAttribute, newStatus}}}}
    _, err = todoCollection.UpdateOne(ctx, filter, update)
    if err != nil {
        log.Fatalf("failed to update todo %v", err)
    }

Ta bort en `todo`

En todo tas bort baserat på dess och _id kapslas in i form av en bson.D instans. DeleteOne anropas för att ta bort dokumentet.

func delete(todoid string) {
....
    todoCollection := c.Database(database).Collection(collection)
    oid, err := primitive.ObjectIDFromHex(todoid)
    if err != nil {
        log.Fatalf("invalid todo ID %v", err)
    }
    filter := bson.D{{"_id", oid}}
    _, err = todoCollection.DeleteOne(ctx, filter)
    if err != nil {
        log.Fatalf("failed to delete todo %v", err)
    }
}

Skapa programmet

Ändra till den katalog där du klonade programmet och skapa det (med hjälp av go build ).

cd monogdb-go-quickstart
go build -o todo

Bekräfta att programmet har skapats korrekt.

./todo --help

Konfigurera Azure Cosmos DB

Om du väljer att installera och använda CLI lokalt måste du köra Azure CLI version 2.0 eller senare. Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera kan du gå till [Installera Azure CLI].

Om du använder ett installerat Azure CLI loggar du in på din Azure-prenumeration med kommandot az login och följer anvisningarna på skärmen. Du kan hoppa över det här steget om du använder Azure Cloud-gränssnittet.

az login

Lägg till Azure Cosmos DB-modulen

Om du använder en installerad Azure CLI, kontrollera om cosmosdb-komponenten har installerats genom att köra kommandot az. Om cosmosdb är i listan över grundläggande kommandon, fortsätter du med nästa kommando. Du kan hoppa över det här steget om du använder Azure Cloud-gränssnittet.

Om cosmosdb inte är i listan över grundläggande kommandon, installerar du om Azure CLI.

Skapa en resursgrupp

Skapa en resursgrupp med az group create. En Azure-resursgrupp är en logisk container som Azure-resurser (t.ex. webbappar, databaser och lagringskonton) distribueras och hanteras i.

Följande exempel skapar en resursgrupp i regionen västeuropa. Välj ett unikt namn för resursgruppen.

Om du använder Azure Cloud Shell väljer du Prova, följer anvisningarna på skärmen för att logga in och kopierar sedan kommandot till kommandotolken.

az group create --name myResourceGroup --location "West Europe"

Skapa ett Azure Cosmos DB-konto

Skapa ett Cosmos-konto med kommandot az cosmosdb create.

I följande kommando ersätter du ditt eget unika Cosmos-kontonamn där du ser platshållaren <cosmosdb-name>. Den här unika namnet kommer att användas som en del av din Cosmos DB-slutpunkt (https://<cosmosdb-name>.documents.azure.com/) så namnet måste vara unikt för alla Cosmos-konton i Azure.

az cosmosdb create --name <cosmosdb-name> --resource-group myResourceGroup --kind MongoDB

Parametern --kind MongoDB aktiverar MongoDB-klientanslutningar.

När Azure Cosmos DB-kontot har skapats, visar Azure CLI information liknande följande exempel.

Anteckning

I det här exemplet används JSON som standardalternativ för Azure CLI-utdataformat. Om du vill använda andra format läser du Utdataformat för Azure CLI-kommandon.

{
  "databaseAccountOfferType": "Standard",
  "documentEndpoint": "https://<cosmosdb-name>.documents.azure.com:443/",
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Document
DB/databaseAccounts/<cosmosdb-name>",
  "kind": "MongoDB",
  "location": "West Europe",
  "name": "<cosmosdb-name>",
  "readLocations": [
    {
      "documentEndpoint": "https://<cosmosdb-name>-westeurope.documents.azure.com:443/",
      "failoverPriority": 0,
      "id": "<cosmosdb-name>-westeurope",
      "locationName": "West Europe",
      "provisioningState": "Succeeded"
    }
  ],
  "resourceGroup": "myResourceGroup",
  "type": "Microsoft.DocumentDB/databaseAccounts",
  "writeLocations": [
    {
      "documentEndpoint": "https://<cosmosdb-name>-westeurope.documents.azure.com:443/",
      "failoverPriority": 0,
      "id": "<cosmosdb-name>-westeurope",
      "locationName": "West Europe",
      "provisioningState": "Succeeded"
    }
  ]
}

Hämta databasnyckeln

För att kunna ansluta till en Cosmos-databas behöver du databasnyckeln. Använd kommandot az cosmosdb keys list för att hämta primärnyckeln.

az cosmosdb keys list --name <cosmosdb-name> --resource-group myResourceGroup --query "primaryMasterKey"

Azure CLI matar ut information som liknar följande exempel.

"RUayjYjixJDWG5xTqIiXjC..."

Konfigurera programmet

Exportera anslutningssträngen, MongoDB-databasen och samlingsnamnen som miljövariabler.

export MONGODB_CONNECTION_STRING="mongodb://<COSMOSDB_ACCOUNT_NAME>:<COSMOSDB_PASSWORD>@<COSMOSDB_ACCOUNT_NAME>.documents.azure.com:10255/?ssl=true&replicaSet=globaldb&maxIdleTimeMS=120000&appName=@<COSMOSDB_ACCOUNT_NAME>@"

Anteckning

Alternativet ssl=true är viktigt på grund av Cosmos DB krav. Mer information finns i Krav på anslutningssträng.

För MONGODB_CONNECTION_STRING miljövariabeln ersätter du platshållarna för <COSMOSDB_ACCOUNT_NAME> och <COSMOSDB_PASSWORD>

<COSMOSDB_ACCOUNT_NAME>: Namnet på det Azure Cosmos DB-konto som du skapade
<COSMOSDB_PASSWORD>: Databasnyckeln som extraherades i föregående steg

export MONGODB_DATABASE=todo-db
export MONGODB_COLLECTION=todos

Du kan välja önskade värden för MONGODB_DATABASE och eller lämna dem som de MONGODB_COLLECTION är.

Kör programmet

Så här skapar du en todo

./todo --create "Create an Azure Cosmos DB database account"

Om det lyckas bör du se utdata med MongoDB _id för det nya dokumentet:

added todo ObjectID("5e9fd6befd2f076d1f03bd8a")

Skapa en till todo

./todo --create "Get the MongoDB connection string using the Azure CLI"

Visa en lista över todo alla

./todo --list all

Du bör se dem som du just lade till i tabellformat som sådana

+----------------------------+--------------------------------+-----------+
|             ID             |          DESCRIPTION           |  STATUS   |
+----------------------------+--------------------------------+-----------+
| "5e9fd6b1bcd2fa6bd267d4c4" | Create an Azure Cosmos DB      | pending   |
|                            | database account               |           |
| "5e9fd6befd2f076d1f03bd8a" | Get the MongoDB connection     | pending   |
|                            | string using the Azure CLI     |           |
+----------------------------+--------------------------------+-----------+

Om du vill uppdatera statusen todo för en (t.ex. ändra den till completed status) använder du todo ID:t

./todo --update 5e9fd6b1bcd2fa6bd267d4c4,completed

Lista endast todo slutförda s

./todo --list completed

Du bör se den som du precis har uppdaterat

+----------------------------+--------------------------------+-----------+
|             ID             |          DESCRIPTION           |  STATUS   |
+----------------------------+--------------------------------+-----------+
| "5e9fd6b1bcd2fa6bd267d4c4" | Create an Azure Cosmos DB      | completed |
|                            | database account               |           |
+----------------------------+--------------------------------+-----------+

Visa data i datautforskaren

Data som lagras Azure Cosmos DB är tillgängliga för att visa och fråga i Azure Portal.

Om du vill visa, fråga och arbeta med användardata som skapats i föregående steg, loggar du in på Azure-portalen i din webbläsare.

I den övre sökrutan anger du Azure Cosmos DB. När ditt Cosmos-kontoblad öppnas väljer du ditt Cosmos-konto. I det vänstra navigeringsfönstret väljer du Datautforskaren. Utöka din samling i samlings-fönstret så kan du visa dokumenten i samlingen, fråga data och skapa och köra lagrade procedurer, utlösare och UDF:er.

Det nyligen skapade dokumentet visas i Datautforskaren

Ta bort todo en med hjälp av id:t

./todo --delete 5e9fd6b1bcd2fa6bd267d4c4,completed

Visa en lista todo med de s som ska bekräftas

./todo --list all

Den todo som du precis har tagit bort bör inte finnas

+----------------------------+--------------------------------+-----------+
|             ID             |          DESCRIPTION           |  STATUS   |
+----------------------------+--------------------------------+-----------+
| "5e9fd6befd2f076d1f03bd8a" | Get the MongoDB connection     | pending   |
|                            | string using the Azure CLI     |           |
+----------------------------+--------------------------------+-----------+

Rensa resurser

När du är klar med din app och Azure Cosmos DB-konto kan du ta bort de Azure-resurser som du skapade så att du inte debiteras mer. Ta bort resurser:

I sökfältet Azure Portal du efter och väljer Resursgrupper.
I listan väljer du den resursgrupp som du skapade för den här snabbstarten.
På sidan Översikt för resursgruppen väljer du Ta bort resursgrupp.
I nästa fönster anger du namnet på den resursgrupp som ska tas bort och väljer sedan Ta bort.

Nästa steg

I den här snabbstarten har du lärt dig hur du skapar ett Azure Cosmos DB MongoDB API-konto med hjälp av Azure Cloud Shell och skapar och kör en Go-kommandoradsapp för att todo hantera s. Du kan nu importera ytterligare data till ditt Azure Cosmos DB-konto.

Försöker du göra kapacitetsplanering för en migrering till Azure Cosmos DB? Du kan använda information om ditt befintliga databaskluster för kapacitetsplanering.

Om allt du vet är antalet virtuella kärnor och servrar i ditt befintliga databaskluster kan du läsa om att uppskatta enheter för programbegäran med hjälp av virtuella kärnor eller virtuella processorer
Om du känner till vanliga begärandefrekvenser för din aktuella databasarbetsbelastning kan du läsa om att uppskatta enheter för programbegäran med Azure Cosmos DB kapacitetsplaneraren

Importera MongoDB-data till Azure Cosmos DB

Snabbstart: Anslut ett Go-program till Azure Cosmos DB API för MongoDB

Betygsätta din upplevelse

Förutsättningar

Klona exempelprogrammet

Granska koden

Ansluta Go-appen till Azure Cosmos DB

Skapa ett todo objekt

todoListobjekt

Uppdatera ett todo objekt

Ta bort en todo

Skapa programmet

Konfigurera Azure Cosmos DB

Logga in på Azure

Lägg till Azure Cosmos DB-modulen

Skapa en resursgrupp

Skapa ett Azure Cosmos DB-konto

Hämta databasnyckeln

Konfigurera programmet

Exportera anslutningssträngen, MongoDB-databasen och samlingsnamnen som miljövariabler.

Kör programmet

Visa data i datautforskaren

Rensa resurser

Nästa steg

Skapa ett `todo` objekt

`todo`Listobjekt

Uppdatera ett `todo` objekt

Ta bort en `todo`