Share via

Verwenden des Azure SDK für Go mit Azure Table

  • Artikel

GILT FÜR: Tabelle

Tipp

Der Inhalt in diesem Artikel gilt für Azure Table Storage und Azure Cosmos DB for Table. Die API for Table ist ein Premiumangebot für Tabellenspeicher und bietet Tabellen mit optimiertem Durchsatz, globale Verteilung und automatische sekundäre Indizes.

In diesem Artikel erfahren Sie, wie Sie Azure Table-Instanzen und -Entitäten mit dem Azure SDK für Go erstellen, auflisten und löschen.

Azure Table ermöglicht das Speichern von strukturierten NoSQL-Daten in der Cloud, indem Ihnen ein Schlüsselattributspeicher mit schemalosem Design bereitgestellt wird. Aufgrund der Schemalosigkeit von Azure Table-Speicher ist es einfach, Ihre Daten an die Anforderungen Ihrer Anwendungen anzupassen. Der Zugriff auf die Daten und API der Tabelle ist eine schnelle und kostengünstige Lösung für viele Anwendungen.

Mit Azure Table-Speicher oder Azure Cosmos DB können Sie flexible Datasets wie Benutzerdaten für Webanwendungen, Adressbücher und Geräteinformationen speichern. Oder andere Arten von Metadaten, die Ihr Dienst erfordert. Sie können eine beliebige Anzahl von Entitäten in einer Tabelle speichern, und ein Speicherkonto kann eine beliebige Anzahl von Tabellen enthalten (bis zur Speicherkapazitätsgrenze eines Speicherkontos).

Folgen Sie diesem Artikel, um zu erfahren, wie Sie Azure Table-Speicher mithilfe des Azure SDK für Go verwalten.

Voraussetzungen

Erstellen Ihrer Umgebung

Um diesem Lernprogramm zu folgen, benötigen Sie eine Azure-Ressourcengruppe, ein Speicherkonto und eine Tabellenressource. Führen Sie die folgenden Befehle aus, um Ihre Umgebung einzurichten:

  1. Erstellen einer Azure-Ressourcengruppe.

    az group create --name myResourceGroup --location eastus

  2. Erstellen Sie als Nächstes ein Azure-Speicherkonto für Ihre neue Azure Table-Instanz.

    az storage account create --name <storageAccountName> --resource-group myResourceGroup --location eastus --sku Standard_LRS

  3. Erstellen Sie eine Tabellenressource.

    az storage table create --account-name <storageAccountName> --account-key 'storageKey' --name mytable

Installieren von Paketen

Sie benötigen zwei Pakete, um Azure Table mit Go zu verwalten; azidentity und aztables. Das Paket azidentity bietet Ihnen eine Möglichkeit, sich bei Azure zu authentifizieren. Und mithilfe der aztables-Pakete können Sie die Tabellenressource in Azure verwalten. Führen Sie die folgenden Go-Befehle aus, um diese Pakete zu installieren:

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

Weitere Informationen zu den Möglichkeiten, sich bei Azure zu authentifizieren, finden Sie unter Azure-Authentifizierung mit dem Azure SDK für Go.

Erstellen der Beispielanwendung

Nachdem Sie die Pakete installiert haben, erstellen Sie eine Beispielanwendung, die das Azure SDK für Go zum Verwalten von Azure Table verwendet. Führen Sie den Befehl go mod aus, um ein neues Modul namens azTableSample zu erstellen.

go mod init azTableSample

Erstellen Sie als Nächstes eine Datei namens main.go, und kopieren Sie es dann Folgendes in diese Datei:

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "os"

    "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/Azure/azure-sdk-for-go/sdk/data/aztables"
)

type InventoryEntity struct {
    aztables.Entity
    Price       float32
    Inventory   int32
    ProductName string
    OnSale      bool
}

type PurchasedEntity struct {
    aztables.Entity
    Price float32
    ProductName string
    OnSale bool
}

func getClient() *aztables.Client {
    accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT")
    if !ok {
        panic("AZURE_STORAGE_ACCOUNT environment variable not found")
    }

    tableName, ok := os.LookupEnv("AZURE_TABLE_NAME")
    if !ok {
        panic("AZURE_TABLE_NAME environment variable not found")
    }

    cred, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        panic(err)
    }
    serviceURL := fmt.Sprintf("https://%s.table.core.windows.net/%s", accountName, tableName)
    client, err := aztables.NewClient(serviceURL, cred, nil)
    if err != nil {
        panic(err)
    }
    return client
}

func createTable(client *aztables.Client) {
    //TODO: Check access policy, Storage Blob Data Contributor role needed
    _, err := client.Create(context.TODO(), nil)
    if err != nil {
        panic(err)
    }
}

func addEntity(client *aztables.Client) {
    myEntity := InventoryEntity{
        Entity: aztables.Entity{
            PartitionKey: "pk001",
            RowKey:       "rk001",
        },
        Price:       3.99,
        Inventory:   20,
        ProductName: "Markers",
        OnSale:      false,
    }

    marshalled, err := json.Marshal(myEntity)
    if err != nil {
        panic(err)
    }

    _, err = client.AddEntity(context.TODO(), marshalled, nil) // TODO: Check access policy, need Storage Table Data Contributor role
    if err != nil {
        panic(err)
    }
}

func listEntities(client *aztables.Client) {
    listPager := client.List(nil)
    pageCount := 0
    for listPager.More() {
        response, err := listPager.NextPage(context.TODO())
        if err != nil {
            panic(err)
        }
        fmt.Printf("There are %d entities in page #%d\n", len(response.Entities), pageCount)
        pageCount += 1
    }
}

func queryEntity(client *aztables.Client) {
    filter := fmt.Sprintf("PartitionKey eq '%v' or RowKey eq '%v'", "pk001", "rk001")
    options := &aztables.ListEntitiesOptions{
        Filter: &filter,
        Select: to.StringPtr("RowKey,Price,Inventory,ProductName,OnSale"),
        Top:    to.Int32Ptr(15),
    }

    pager := client.List(options)
    for pager.More() {
        resp, err := pager.NextPage(context.Background())
        if err != nil {
            panic(err)
        }
        for _, entity := range resp.Entities {
            var myEntity PurchasedEntity 
            err = json.Unmarshal(entity, &myEntity)
            if err != nil {
                panic(err)
            }
            fmt.Println("Return custom type [PurchasedEntity]")
            fmt.Printf("Price: %v; ProductName: %v; OnSale: %v\n", myEntity.Price, myEntity.ProductName, myEntity.OnSale)
        }
    }
}

func deleteEntity(client *aztables.Client) {
    _, err := client.DeleteEntity(context.TODO(), "pk001", "rk001", nil)
    if err != nil {
        panic(err)
    }
}

func deleteTable(client *aztables.Client) {
    _, err := client.Delete(context.TODO(), nil)
    if err != nil {
        panic(err)
    }
}

func main() {

    fmt.Println("Authenticating...")
    client := getClient()

    fmt.Println("Creating a table...")
    createTable(client)

    fmt.Println("Adding an entity to the table...")
    addEntity(client)

    fmt.Println("Calculating all entities in the table...")
    listEntities(client)

    fmt.Println("Querying a specific entity...")
    queryEntity(client) 

    fmt.Println("Deleting an entity...")
    deleteEntity(client) 

    fmt.Println("Deleting a table...")
    deleteTable(client)
}

Wichtig

Stellen Sie sicher, dass das Konto, mit dem Sie sich authentifiziert haben, über die richtige Zugriffsrichtlinie verfügt, um Ihr Azure-Speicherkonto zu verwalten. Wenn Sie den oben stehenden Code ausführen möchten, müssen Sie mindestens über die Rollen „Mitwirkender an Storage-Blobdaten“ und „Mitwirkender an Storage-Tabellendaten“ verfügen.

Codebeispiele

Authentifizieren des Clients

// Lookup environment variables
accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT")
if !ok {
  panic("AZURE_STORAGE_ACCOUNT environment variable not found")
}

tableName, ok := os.LookupEnv("AZURE_TABLE_NAME")
if !ok {
  panic("AZURE_TABLE_NAME environment variable not found")
}

// Create a credential
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
  panic(err)
}

// Create a table client
serviceURL := fmt.Sprintf("https://%s.table.core.windows.net/%s", accountName, tableName)
client, err := aztables.NewClient(serviceURL, cred, nil)
if err != nil {
  panic(err)
}

Erstellen einer Tabelle

// Create a table and discard the response
_, err := client.Create(context.TODO(), nil)
if err != nil {
  panic(err)
}

Erstellen einer Entität

// Define the table entity as a custom type
type InventoryEntity struct {
    aztables.Entity
    Price       float32
    Inventory   int32
    ProductName string
    OnSale      bool
}

// Define the entity values
myEntity := InventoryEntity{
    Entity: aztables.Entity{
        PartitionKey: "pk001",
        RowKey:       "rk001",
    },
    Price:       3.99,
    Inventory:   20,
    ProductName: "Markers",
    OnSale:      false,
}

// Marshal the entity to JSON
marshalled, err := json.Marshal(myEntity)
if err != nil {
    panic(err)
}

// Add the entity to the table
_, err = client.AddEntity(context.TODO(), marshalled, nil) // needs Storage Table Data Contributor role
if err != nil {
    panic(err)
}

Abrufen einer Entität

// Define the new custom type
type PurchasedEntity struct {
    aztables.Entity
    Price       float32
    ProductName string
    OnSale      bool
}

// Define the query filter and options
filter := fmt.Sprintf("PartitionKey eq '%v' or RowKey eq '%v'", "pk001", "rk001")
options := &aztables.ListEntitiesOptions{
    Filter: &filter,
    Select: to.StringPtr("RowKey,Price,Inventory,ProductName,OnSale"),
    Top:    to.Int32Ptr(15),
}

// Query the table for the entity
pager := client.List(options)
for pager.More() {
    resp, err := pager.NextPage(context.Background())
    if err != nil {
        panic(err)
    }
    for _, entity := range resp.Entities {
        var myEntity PurchasedEntity
        err = json.Unmarshal(entity, &myEntity)
        if err != nil {
            panic(err)
        }
        fmt.Println("Return custom type [PurchasedEntity]")
        fmt.Printf("Price: %v; ProductName: %v; OnSale: %v\n", myEntity.Price, myEntity.ProductName, myEntity.OnSale)
    }
}

Löschen einer Entität

_, err := client.DeleteEntity(context.TODO(), "pk001", "rk001", nil)
if err != nil {
  panic(err)
}

Löschen einer Tabelle

_, err := client.Delete(context.TODO(), nil)
if err != nil {
  panic(err)
}

Ausführen des Codes

Jetzt muss die Anwendung nur noch ausgeführt werden. Bevor Sie dies tun, müssen Sie jedoch Ihre Umgebungsvariablen einrichten. Erstellen Sie zwei Umgebungsvariablen, und legen Sie sie mithilfe der folgenden Befehle auf die entsprechenden Werte fest:

export AZURE_STORAGE_ACCOUNT=<YourStorageAccountName> 
export AZURE_TABLE_NAME=<YourAzureTableName>

Führen Sie als Nächstes den folgenden go run-Befehl aus, um die App auszuführen:

go run main.go

Bereinigen von Ressourcen

Führen Sie die folgenden Befehle aus, um die Ressourcengruppe und alle dazugehörigen Ressourcen zu löschen:

az group delete --resource-group myResourceGroup

Nächste Schritte

In diesem Schnellstart haben Sie gelernt, wie Sie ein Azure Cosmos DB-Konto erstellen, eine Tabelle mit dem Daten-Explorer erstellen und eine App ausführen. Jetzt können Sie Ihre Daten mithilfe der API für Table abfragen.

Abfragen von Azure Cosmos BD mithilfe der API für Table