Condividi tramite

Guida introduttiva: Usare Azure Cosmos DB for Table con Azure SDK per Go

  • Si applica a: ✅ Table

In questa guida introduttiva si distribuisce un'applicazione Azure Cosmos DB for Table di base usando Azure SDK for Go. Azure Cosmos DB for Table è un archivio dati senza schema che consente alle applicazioni di archiviare dati strutturati della tabella nel cloud. Viene spiegato come creare tabelle, righe ed eseguire attività di base all'interno della risorsa di Azure Cosmos DB utilizzando Azure SDK for Go.

Codice sorgente della libreria | Pacchetto (Go) | Interfaccia della riga di comando per sviluppatori di Azure

Prerequisiti

  • Azure Developer CLI
  • Docker Desktop
  • Go 1.21 o versione successiva

Se non si ha un account Azure, crearne uno gratuito prima di iniziare.

Inizializzare il progetto

Usare Azure Developer CLI (azd) per creare un account Azure Cosmos DB for Table e distribuire un'applicazione di esempio in contenitori. L'applicazione di esempio usa la libreria client per gestire, creare, leggere ed eseguire query sui dati di esempio.

  1. Aprire un terminale in una directory vuota.

  2. Se non si è già autenticati, eseguire l'autenticazione a Azure Developer CLI usando azd auth login. Seguire i passaggi specificati dallo strumento per eseguire l'autenticazione all'interfaccia della riga di comando usando le credenziali di Azure preferite.

    azd auth login

  3. Usare azd init per inizializzare il progetto.

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

  4. Durante l'inizializzazione, configurare un nome di ambiente univoco.

  5. Distribuire l'account Azure Cosmos DB usando azd up. I modelli Bicep distribuiscono anche un'applicazione Web di esempio.

    azd up

  6. Durante il processo di provisioning, selezionare la sottoscrizione, la posizione desiderata e il gruppo di risorse di destinazione. Attendere il completamento del processo di provisioning. Per il processo sono necessari circa 5 minuti.

  7. Al termine del provisioning delle risorse di Azure, nell'output viene incluso un URL dell'applicazione Web in esecuzione.

    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. Usare l'URL nella console per passare all'applicazione Web nel browser. Osservare l'output dell'app in esecuzione.

Screenshot dell'applicazione Web in esecuzione.

Installare la libreria client

La libreria client è disponibile tramite Go, come pacchetto aztables.

  1. Aprire un terminale e passare alla cartella /src.

    cd ./src

  2. Se non è già installato, installare il pacchetto aztables usando go install.

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

  3. Aprire ed esaminare il file src/go.mod per verificare che la voce github.com/Azure/azure-sdk-for-go/sdk/data/aztables esista.

Importare le librerie

Importare i pacchetti github.com/Azure/azure-sdk-for-go/sdk/azidentity e github.com/Azure/azure-sdk-for-go/sdk/data/aztables nel codice dell'applicazione.

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

Modello a oggetti

Nome Descrizione
ServiceClient Questo tipo è il tipo client primaria e viene usata per gestire i metadati o i database a livello di account.
Client Questo tipo rappresenta il client per una tabella all'interno dell'account.

Esempi di codice

Il codice di esempio nel modello usa una tabella denominata cosmicworks-products. La tabella cosmicworks-products contiene dettagli quali nome, categoria, quantità, prezzo, identificatore univoco e flag di vendita per ogni prodotto. Il contenitore usa un identificatore univoco come chiave di riga e categoria come chiave di partizione.

Autenticare il client

In questo esempio, viene creata una nuova istanza del tipo ServiceClient.

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)
}

Ottenere una tabella

In questo esempio viene creata un'istanza del tipo Client utilizzando la funzione NewClient del tipo ServiceClient.

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

Creare un'entità

Il modo più semplice per creare una nuova entità in una tabella consiste nel creare un'istanza di tipo aztables.EDMEntity. Impostare le proprietà RowKey e PartitionKey usando il tipo aztables.Entity e quindi impostare eventuali proprietà aggiuntive usando una mappa di stringhe.

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,
    },
}

Convertire l'entità in una matrice di byte usando json.Marshal e quindi creare l'entità nella tabella usando UpsertEntity.

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

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

Ottenere un'entità

È possibile recuperare un'entità specifica da una tabella usando GetEntity. È quindi possibile usare json.Unmarshal per analizzarlo usando il tipo aztables.EDMEntity.

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)
}

Eseguire query sulle entità

Dopo aver inserito un'entità, è anche possibile eseguire una query per ottenere tutte le entità che corrispondono a un filtro specifico usando NewListEntitiesPager insieme a un filtro stringa.

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)

Analizzare i risultati impaginati della query usando la funzione More del cercapersone per determinare se sono presenti più pagine e quindi la funzione NextPage per ottenere la pagina successiva dei risultati.

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))
    }
}

Pulire le risorse

Quando l'applicazione o le risorse di esempio non sono più necessarie, rimuovere la distribuzione corrispondente e tutte le risorse.

azd down

Contenuti correlati

  • Last updated on