Snabbstart: Använda Azure Cosmos DB för NoSQL med Azure SDK för Go

I den här snabbstarten distribuerar du ett grundläggande Azure Cosmos DB for NoSQL-program med hjälp av Azure SDK för Go. Azure Cosmos DB for NoSQL är ett schemalöst datalager som gör det möjligt för program att lagra ostrukturerade data i molnet. Fråga efter data i dina containrar och utför vanliga åtgärder på enskilda objekt med hjälp av Azure SDK för Go.

API-referensdokumentation | Bibliotekskällkod | Paket (Go) | Azure Developer CLI

Förutsättningar

• Azure Developer CLI
• Docker Desktop
• Go 1.21 eller senare

Om du inte har något Azure-konto skapar du ett kostnadsfritt konto innan du börjar.

Initiera projektet

Använd Azure Developer CLI (azd) för att skapa ett Azure Cosmos DB för NoSQL-konto och distribuera ett containerbaserat exempelprogram. Exempelprogrammet använder klientbiblioteket för att hantera, skapa, läsa och fråga efter exempeldata.

1. Öppna en terminal i en tom katalog.

2. Om du inte redan är autentiserad autentiserar du till Azure Developer CLI med .azd auth login Följ stegen som anges av verktyget för att autentisera till CLI med dina önskade Azure-autentiseringsuppgifter.

   azd auth login
   

3. Använd azd init för att initiera projektet.

   azd init --template cosmos-db-nosql-go-quickstart
   

4. Under initieringen konfigurerar du ett unikt miljönamn.

5. Distribuera Azure Cosmos DB-kontot med azd up. Bicep-mallarna distribuerar också ett exempel på ett webbprogram.

   azd up
   

6. Under etableringsprocessen väljer du din prenumeration, önskad plats och målresursgrupp. Vänta tills tilldelningsprocessen har slutförts. Processen kan ta ungefär fem minuter.

7. När etableringen av dina Azure-resurser är klar inkluderas en URL till det webbprogram som körs i utdata.

   Deploying services (azd deploy)
   
     (✓) Done: Deploying service web
   - Endpoint: <https://[container-app-sub-domain].azurecontainerapps.io>
   
   SUCCESS: Your application was provisioned and deployed to Azure in 5 minutes 0 seconds.
   

8. Använd URL:en i konsolen för att navigera till webbprogrammet i webbläsaren. Observera utdata från appen som körs.

Installera klientbiblioteket

Klientbiblioteket är tillgängligt via Go som azcosmos paket.

1. Öppna en terminal och navigera till /src mappen.

   cd ./src
   

2. Installera azcosmos paketet med go install om detta inte redan är installerat.

   go install github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos
   

3. Installera även paketet om det azidentity inte redan är installerat.

   go install github.com/Azure/azure-sdk-for-go/sdk/azidentity
   

4. Öppna och granska filen src/go.mod för att verifiera att båda posterna github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos och github.com/Azure/azure-sdk-for-go/sdk/azidentity finns.

Importera bibliotek

Importera paketen github.com/Azure/azure-sdk-for-go/sdk/azidentity och github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos till programkoden.

import (
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
)

Objektmodell

Kodexempel

• Autentisera klienten
• Hämta en databas
• Hämta en container
• Skapa ett objekt
• Hämta ett objekt
• Frågeobjekt

Exempelkoden i mallen använder en databas med namnet cosmicworks och containern med namnet products. Containern products innehåller information som namn, kategori, kvantitet, en unik identifierare och en försäljningsflagga för varje produkt. Containern använder egenskapen /category som en logisk partitionsnyckel.

Autentisera klienten

Det här exemplet skapar en ny instans av CosmosClient och autentiserar med en instans av azcosmos.NewClient med hjälp av DefaultAzureCredential.

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

clientOptions := azcosmos.ClientOptions{
    EnableContentResponseOnWrite: true,
}

client, err := azcosmos.NewClient("<azure-cosmos-db-nosql-account-endpoint>", credential, &clientOptions)
if err != nil {
    return err
}

Hämta en databas

Använd client.NewDatabase för att hämta den befintliga databasen med namnet cosmicworks.

database, err := client.NewDatabase("cosmicworks")
if err != nil {
    return err
}

Hämta en container

Hämta den befintliga products containern med .database.NewContainer

container, err := database.NewContainer("products")
if err != nil {
    return err
}

Skapa ett objekt

Skapa en Go-typ med alla medlemmar som du vill serialisera till JSON. I det här exemplet har typen en unik identifierare och fält för kategori, namn, kvantitet, pris och försäljning.

type Item struct {
  Id        string  `json:"id"`
  Category  string  `json:"category"`
  Name      string  `json:"name"`
  Quantity  int     `json:"quantity"`
  Price     float32 `json:"price"`
  Clearance bool    `json:"clearance"`
}

Skapa ett objekt i containern med .container.UpsertItem Den här metoden "infogar eller uppdaterar" objektet och ersätter objektet effektivt om det redan finns.

item := Item {
    Id:        "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
    Category:  "gear-surf-surfboards",
    Name:      "Yamba Surfboard",
    Quantity:  12,
    Price:     850.00,
    Clearance: false,
}

partitionKey := azcosmos.NewPartitionKeyString("gear-surf-surfboards")

context := context.TODO()

bytes, err := json.Marshal(item)
if err != nil {
    return err
}

response, err := container.UpsertItem(context, partitionKey, bytes, nil)
if err != nil {
    return err
}

Läsa ett objekt

Utför en punktläsningsåtgärd med hjälp av både de unika identifierarna (id) och partitionsnyckelfälten. Använd container.ReadItem för att effektivt hämta det specifika objektet.

partitionKey := azcosmos.NewPartitionKeyString("gear-surf-surfboards")

context := context.TODO()

itemId := "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb"

response, err := container.ReadItem(context, partitionKey, itemId, nil)
if err != nil {
    return err
}

if response.RawResponse.StatusCode == 200 {
    read_item := Item{}
    err := json.Unmarshal(response.Value, &read_item)
    if err != nil {
        return err
    }
}

Frågeobjekt

Utför en fråga över flera objekt i en container med hjälp av container.NewQueryItemsPager. Hitta alla objekt i en angiven kategori med den här parameteriserade frågan:

SELECT * FROM products p WHERE p.category = @category

partitionKey := azcosmos.NewPartitionKeyString("gear-surf-surfboards")

query := "SELECT * FROM products p WHERE p.category = @category"

queryOptions := azcosmos.QueryOptions{
    QueryParameters: []azcosmos.QueryParameter{
        {Name: "@category", Value: "gear-surf-surfboards"},
    },
}

pager := container.NewQueryItemsPager(query, partitionKey, &queryOptions)

Parsa resultatet av frågan genom att loopa igenom varje paginering av resultaten med hjälp av pager.NextPage. Använd pager.More för att avgöra om det finns några resultat kvar i början av varje loop.

items := []Item{}

for pager.More() {
    response, err := pager.NextPage(context.TODO())
    if err != nil {
        return err
    }

    for _, bytes := range response.Items {
        item := Item{}
        err := json.Unmarshal(bytes, &item)
        if err != nil {
            return err
        }
        items = append(items, item)
    }
}

Utforska dina data

Använd Visual Studio Code-tillägget för Azure Cosmos DB för att utforska dina NoSQL-data. Du kan utföra grundläggande databasåtgärder, inklusive, men inte begränsat till:

• Utföra frågor med hjälp av en skrivbok eller frågeredigeraren
• Ändra, uppdatera, skapa och ta bort objekt
• Importera massdata från andra källor
• Hantera databaser och containrar

Mer information finns i Använda Visual Studio Code-tillägget för att utforska Azure Cosmos DB för NoSQL-data.

Rensa resurser

När du inte längre behöver exempelprogrammet eller resurserna tar du bort motsvarande distribution och alla resurser.

azd down

Relaterat innehåll

• .NET-snabbstart
• Node.js snabbstart
• Snabbstart för Java
• Snabbstart för Python
• Snabbstart för Rust