Snabbstart: Använd Azure Cosmos DB för tabell med Azure SDK för Go

Artikel
2025-04-09
Gäller för: ✅ Table

I den här snabbstarten distribuerar du ett grundläggande Azure Cosmos DB for Table-program med hjälp av Azure SDK för Go. Azure Cosmos DB for Table är ett schemalöst datalager som gör att program kan lagra strukturerade tabelldata i molnet. Du lär dig hur du skapar tabeller, rader och utför grundläggande uppgifter i din Azure Cosmos DB-resurs med hjälp av Azure SDK för Go.

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 tabellkonto och distribuera ett containerbaserat exempelprogram. Exempelprogrammet använder klientbiblioteket för att hantera, skapa, läsa och fråga efter exempeldata.

Öppna en terminal i en tom katalog.
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
```

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

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

Under initieringen konfigurerar du ett unikt miljönamn.
Distribuera Azure Cosmos DB-kontot med azd up. Bicep-mallarna distribuerar också ett exempel på ett webbprogram.
```
azd up
```
Under etableringsprocessen väljer du din prenumeration, önskad plats och målresursgrupp. Vänta tills etableringsprocessen har slutförts. Processen kan ta ungefär fem minuter.

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.

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

Skärmbild av webbprogrammet som körs.

Installera klientbiblioteket

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

Öppna en terminal och navigera till /src mappen.
```
cd ./src
```
Om det inte redan är installerat, installera aztables-paketet med hjälp av go install.
```
go install github.com/Azure/azure-sdk-for-go/sdk/data/aztables
```
Öppna och granska filen src/go.mod för att verifiera att posten github.com/Azure/azure-sdk-for-go/sdk/data/aztables finns.

Importera bibliotek

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

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

Objektmodell

Name	beskrivning
`ServiceClient`	Den här typen är den primära klienttypen och används för att hantera kontoomfattande metadata eller databaser.
`Client`	Den här typen representerar klienten för en tabell i kontot.

Exempelkoden i mallen använder en tabell med namnet cosmicworks-products. Tabellen cosmicworks-products innehåller information som namn, kategori, kvantitet, pris, en unik identifierare och en försäljningsflagga för varje produkt. Containern använder en unik identifierare som radnyckel och kategori som partitionsnyckel.

Autentisera klienten

Det här exemplet skapar en ny instans av ServiceClient typen.

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

client, err := aztables.NewServiceClient("<azure-cosmos-db-table-account-endpoint>", credential)
if err != nil {
    log.Fatal(err)
}

Hämta en tabell

Det här exemplet skapar en instans av typen Client med hjälp av funktionen NewClient av typen ServiceClient.

table, err := client.NewClient("<azure-cosmos-db-table-name>")
if err != nil {
    log.Fatal(err)
}

Skapa en entitet

Det enklaste sättet att skapa en ny entitet i en tabell är att skapa en instans av typen aztables.EDMEntity. Ange RowKey och PartitionKey egenskaperna med aztables.Entity-typen och ange sedan eventuella extra egenskaper med hjälp av en strängkarta.

entity := aztables.EDMEntity{
    Entity: aztables.Entity{
        RowKey:       "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
        PartitionKey: "gear-surf-surfboards",
    },
    Properties: map[string]any{
        "Name":      "Yamba Surfboard",
        "Quantity":  12,
        "Price":     850.00,
        "Clearance": false,
    },
}

Omvandla entiteten till en bytematris med json.Marshal och skapa sedan entiteten i tabellen med UpsertEntity.

bytes, err := json.Marshal(entity)
if err != nil {
    panic(err)
}

_, err = table.UpsertEntity(context.TODO(), bytes, nil)
if err != nil {
    panic(err)
}

Hämta en entitet

Du kan hämta en specifik entitet från en tabell med hjälp av GetEntity. Du kan sedan använda json.Unmarshal för att parsa den med hjälp av aztables.EDMEntity typen .

rowKey := "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb"
partitionKey := "gear-surf-surfboards"

response, err := table.GetEntity(context.TODO(), partitionKey, rowKey, nil)
if err != nil {
    panic(err)
}

var entity aztables.EDMEntity
err = json.Unmarshal(response.Value, &entity)
if err != nil {
    panic(err)
}

Söka entiteter

När du har infogat en entitet kan du också köra en fråga för att hämta alla entiteter som matchar ett visst filter med hjälp NewListEntitiesPager av tillsammans med ett strängfilter.

category := "gear-surf-surfboards"
// Ensure the value is OData-compliant by escaping single quotes
safeCategory := strings.ReplaceAll(category, "'", "''")
filter := fmt.Sprintf("PartitionKey eq '%s'", safeCategory)

options := &aztables.ListEntitiesOptions{
    Filter: &filter,
}

pager := table.NewListEntitiesPager(options)

Parsa sidnumrerade resultat för frågan med hjälp More av funktionen för sidsökaren för att avgöra om det finns fler sidor och sedan NextPage funktionen för att hämta nästa sida med resultat.

for pager.More() {
    response, err := pager.NextPage(context.TODO())
    if err != nil {
        panic(err)
    }
    for _, entityBytes := range response.Entities {
        var entity aztables.EDMEntity
        err := json.Unmarshal(entityBytes, &entity)
        if err != nil {
            panic(err)
        }
        
        writeOutput(fmt.Sprintf("Found entity:\t%s\t%s", entity.Properties["Name"], entity.RowKey))
    }
}

Rensa resurser

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

azd down

Dela via