Läs på engelska

Dela via


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

GÄLLER FÖR: MongoDB

Azure Cosmos DB är en databastjänst med flera modeller som gör att du snabbt kan skapa och fråga efter dokument-, tabell-, nyckelvärde- och grafdatabaser med globala distributions- och vågräta 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:s API för MongoDB är kompatibelt med MongoDB-trådprotokollet, vilket gör det möjligt för alla MongoDB-klientdrivrutiner att ansluta till det. 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

Klona exempelprogrammet

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

  1. Öppna en kommandotolk, skapa en ny mapp med namnet git-samplesoch stäng sedan kommandotolken.

    mkdir "C:\git-samples"
    
  2. Ö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"
    
  3. 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

Steget är valfritt. Om du är intresserad av att lära dig hur programmet fungerar kan du granska följande kodfragment. Annars kan du gå vidare till Kör programmet. Programlayouten är följande:

.
├── 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

clientOptionskapslar in anslutningssträng för Azure Cosmos DB, som skickas med hjälp av en miljövariabel (information i det kommande avsnittet). Anslutningen initieras med vilken mongo.NewClient instansen clientOptions skickas. Ping funktionen anropas för att bekräfta lyckad anslutning (det är en snabb strategi för fel).

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

    clientOptions := options.Client().ApplyURI(mongoDBConnectionString).SetDirect(true)
    
    c, err := mongo.Connect(ctx, clientOptions)
    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 viktigt att använda konfigurationen SetDirect(true) , 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 en todofår vi ett handtag till en mongo.Collection och anropar InsertOne 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 in 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"`
}

Listobjekt todo

Vi kan lista TODO:er baserat på kriterier. A 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 med 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

A todo kan uppdateras baserat på dess _id. Ett bson.D filter skapas baserat på _id och ett annat skapas för den uppdaterade informationen, vilket är en ny status (completed eller pending) i det här fallet. 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

A todo tas bort baserat på dess _id och den är inkapslad 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 katalogen där du klonade programmet och skapa det (med ).go build

cd monogdb-go-quickstart
go build -o todo

Bekräfta att programmet har skapats korrekt.

./todo --help

Konfigurera Azure Cosmos DB

Logga in på Azure

Om du väljer att installera och använda CLI lokalt kräver det här avsnittet att du kör 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 läsa [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 ett installerat Azure CLI kontrollerar du om komponenten cosmosdb redan har installerats genom att az köra kommandot . 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 finns med i listan med baskommandon installerar du om Azure CLI.

Skapa en resursgrupp

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

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 Azure Cosmos DB-konto med kommandot az cosmosdb create.

I följande kommando, ersätter du ditt eget unika Azure Cosmos DB-kontonamn där du ser platshållaren <cosmosdb-name>. Den här unika namnet kommer att användas som en del av din Azure Cosmos DB-slutpunkt (https://<cosmosdb-name>.documents.azure.com/) så namnet måste vara unikt för alla Azure Cosmos DB-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/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/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 Azure Cosmos DB-databas, behöver du databasnyckeln. Använd kommandot az cosmosdb keys list för att hämta den primära nyckeln.

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äng, MongoDB-databas och samlingsnamn 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 Kraven för Azure Cosmos DB. Mer information finns i Krav för anslutningssträngar.

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

  1. <COSMOSDB_ACCOUNT_NAME>: Namnet på det Azure Cosmos DB-konto som du skapade
  2. <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 MONGODB_COLLECTION eller lämna dem som de är.

Kör appen

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 nyligen skapade dokumentet:

added todo ObjectID("5e9fd6befd2f076d1f03bd8a")

Skapa en till todo

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

Visa en lista över todoalla

./todo --list all

Du bör se de som du just har lagt 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 för en todo (t.ex. ändra den till completed status) använder du ID:t todo :

./todo --update 5e9fd6b1bcd2fa6bd267d4c4,completed

Visa endast en lista över slutförda todos

./todo --list completed

Du bör se den som du precis uppdaterade:

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

Visa data i datautforskaren

Data som lagras i 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 översta sökrutan anger du Azure Cosmos DB. När bladet Azure Cosmos DB-konto öppnas väljer du ditt Azure Cosmos DB-konto. I det vänstra navigeringsfältet 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 en todo med dess ID:

./todo --delete 5e9fd6b1bcd2fa6bd267d4c4,completed

Visa en lista över de todosom ska bekräftas:

./todo --list all

Du todo som just har tagit bort bör inte vara närvarande:

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

Rensa resurser

När du är klar med appen och Azure Cosmos DB-kontot kan du ta bort de Azure-resurser som du skapade så att du inte debiteras fler avgifter. Ta bort resurser:

  1. I Azure Portal sökfältet söker du efter och väljer Resursgrupper.

  2. I listan väljer du den resursgrupp som du skapade för den här snabbstarten.

    Välj den resursgrupp som ska tas bort

  3. På sidan Översikt för resursgrupp väljer du Ta bort resursgrupp.

    Ta bort resursgruppen

  4. I nästa fönster anger du namnet på resursgruppen 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 för MongoDB-konto med hjälp av Azure Cloud Shell och skapar och kör en Go-kommandoradsapp för att hantera todos. Du kan nu importera ytterligare data till ditt Azure Cosmos DB-konto.

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