Použití sady Azure SDK for Go s tabulkou Azure

PLATÍ PRO: Tabulka

• .NET
• Node.js
• Java
• C++
• PHP
• Přejít

Tip

Obsah v tomto článku se týká služby Azure Table Storage a Azure Cosmos DB for Table. Rozhraní API pro tabulku je prémiová nabídka pro úložiště tabulek, která nabízí tabulky optimalizované pro propustnost, globální distribuci a automatické sekundární indexy.

V tomto článku se dozvíte, jak vytvářet, vypisovat a odstraňovat entity Tabulek a tabulek Azure pomocí sady Azure SDK for Go.

Azure Table umožňuje ukládat strukturovaná data NoSQL v cloudu tím, že poskytuje úložiště klíčových atributů s návrhem bez schématu. Vzhledem k tomu, že azure Table Storage je bez schématu, je snadné přizpůsobit data měnícím se potřebám vašich aplikací. Přístup k datům a rozhraní API tabulky je rychlé a nákladově efektivní řešení pro mnoho aplikací.

Službu Table Storage nebo Azure Cosmos DB můžete použít k ukládání flexibilních datových sad, jako jsou uživatelská data pro webové aplikace, adresáře, informace o zařízení. Nebo jiné typy metadat, které vaše služba vyžaduje. V tabulce můžete uložit libovolný počet entit a účet úložiště může obsahovat libovolný počet tabulek, až do limitu kapacity účtu úložiště.

V tomto článku se dozvíte, jak spravovat Azure Table Storage pomocí sady Azure SDK for Go.

Požadavky

• Předplatné Azure – vytvořte si ho zdarma.
• Go installed: Version 1.17 or above
• Azure CLI

Nastavení prostředí

Abyste mohli postupovat podle tohoto kurzu, budete potřebovat skupinu prostředků Azure, účet úložiště a prostředek tabulky. Spuštěním následujících příkazů nastavte prostředí:

1. Vytvořte skupinu prostředků Azure.

   az group create --name myResourceGroup --location eastus
   

2. Dále vytvořte účet úložiště Azure pro novou tabulku Azure.

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

3. Vytvořte prostředek tabulky.

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

Instalace balíčků

Ke správě tabulky Azure pomocí Go budete potřebovat dva balíčky. azidentity a aztables. Balíček azidentity poskytuje způsob, jak se ověřit v Azure. aztables A balíčky umožňují spravovat prostředky tabulek v Azure. Spuštěním následujících příkazů Go nainstalujte tyto balíčky:

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

Další informace o způsobech ověřování v Azure najdete v tématu Ověřování Azure pomocí sady Azure SDK for Go.

Vytvoření ukázkové aplikace

Po instalaci balíčků vytvoříte ukázkovou aplikaci, která ke správě tabulky Azure používá sadu Azure SDK for Go. Spuštěním go mod příkazu vytvořte nový modul s názvem azTableSample.

go mod init azTableSample

Dále vytvořte soubor s názvem main.goa zkopírujte ho do něj:

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

Důležité

Ujistěte se, že účet, který jste ověřili, má správné zásady přístupu ke správě účtu úložiště Azure. Abyste mohli spustit výše uvedený kód, musíte mít minimálně roli Přispěvatel dat v objektech blob služby Storage a roli Přispěvatel dat tabulky úložiště.

Příklady kódu

Ověření klienta

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

Vytvoření tabulky

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

Vytvoření entity

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

Získání entity

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

Odstranění entity

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

Odstraní tabulku

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

Spuštění kódu

Zbývá jen spustit aplikaci. Než to ale uděláte, musíte nastavit proměnné prostředí. Vytvořte dvě proměnné prostředí a nastavte je na odpovídající hodnotu pomocí následujících příkazů:

Bash

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

PowerShell

$env:AZURE_STORAGE_ACCOUNT=<YourStorageAccountName> 
$env:AZURE_TABLE_NAME=<YourAzureTableName>

Potom spusťte aplikaci spuštěním následujícího go run příkazu:

go run main.go

Vyčištění prostředků

Spuštěním následujícího příkazu odstraňte skupinu prostředků a všechny její zbývající prostředky:

az group delete --resource-group myResourceGroup

Další kroky

V tomto rychlém startu jste se seznámili s postupem vytvoření databázového účtu Azure Cosmos DB, vytvoření tabulky pomocí Průzkumníka dat a spuštění aplikace. Teď se můžete dotazovat na data pomocí rozhraní API pro tabulku.

Dotazování služby Azure Cosmos DB pomocí rozhraní API pro tabulku