Az Azure SDK for Go használata az Azure Table használatával

A KÖVETKEZŐKRE VONATKOZIK: Asztal

• .NET
• Node.js
• Java
• C++
• PHP
• Ugrás

Tipp.

A cikk tartalma az Azure Table Storage-ra és az Azure Cosmos DB for Tablere vonatkozik. A Table API egy prémium szintű ajánlat a table storage számára, amely átviteli sebességre optimalizált táblákat, globális eloszlást és automatikus másodlagos indexeket kínál.

Ebben a cikkben megtudhatja, hogyan hozhat létre, listázhat és törölhet Azure Tables és Table entitásokat az Azure SDK for Go használatával.

Az Azure Table lehetővé teszi strukturált NoSQL-adatok felhőben való tárolását azáltal, hogy séma nélküli kialakítású kulcsattribútum-tárolót biztosít. Mivel az Azure Table Storage séma nélküli, egyszerűen igazíthatja az adatokat az alkalmazások változó igényeihez. A tábla adatainak és API-jának elérése számos alkalmazás gyors és költséghatékony megoldása.

A Table Storage vagy az Azure Cosmos DB segítségével rugalmas adatkészleteket tárolhat, például felhasználói adatokat webalkalmazásokhoz, címjegyzékekhez és eszközinformációkhoz. Vagy a szolgáltatás által igényelt egyéb metaadatok. Egy táblán korlátlan számú entitást tárolhat, és egy tárfiók a kapacitásán belül korlátlan számú táblát tartalmazhat.

Ebből a cikkből megtudhatja, hogyan kezelheti az Azure Table Storage-t az Azure SDK for Go használatával.

Előfeltételek

• Azure-előfizetés – hozzon létre egyet ingyenesen.
• Telepítés: 1.17-es vagy újabb verzió
• Azure CLI

Saját környezet beállítása

Az oktatóanyag követéséhez szüksége lesz egy Azure-erőforráscsoportra, egy tárfiókra és egy táblaerőforrásra. Futtassa a következő parancsokat a környezet beállításához:

1. Azure-erőforráscsoport létrehozása

   az group create --name myResourceGroup --location eastus
   

2. Ezután hozzon létre egy Azure Storage-fiókot az új Azure-táblához.

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

3. Hozzon létre egy táblaerőforrást.

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

Csomagok telepítése

Az Azure Table go-val való kezeléséhez két csomagra lesz szüksége; azidentity, és az aztables. A azidentity csomag lehetővé teszi az Azure-ban való hitelesítést. A aztables csomagok lehetővé teszik a táblák erőforrásának kezelését az Azure-ban. A csomagok telepítéséhez futtassa az alábbi Go-parancsokat:

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

Ha többet szeretne megtudni az Azure-beli hitelesítés módjáról, tekintse meg az Azure-hitelesítést az Azure SDK for Go használatával.

A mintaalkalmazás létrehozása

Miután telepítette a csomagokat, létrehoz egy mintaalkalmazást, amely az Azure SDK for Go használatával kezeli az Azure Tableet. Futtassa a go mod parancsot egy új modul létrehozásához.azTableSample

go mod init azTableSample

Ezután hozzon létre egy nevű main.gofájlt, majd másolja bele az alábbiakat:

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

Fontos

Győződjön meg arról, hogy a hitelesített fiók rendelkezik a megfelelő accces-szabályzattal az Azure Storage-fiók kezeléséhez. A fenti kód futtatásához legalább a Storage Blob Data Közreműködő szerepkörrel és a Storage Table Data Közreműködő szerepkörrel kell rendelkeznie.

Kódpéldák

Az ügyfél hitelesítése

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

Tábla létrehozása

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

Entitás létrehozása

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

Entitás lekérése

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

Entitás törlése

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

Tábla törlése

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

A kód futtatása

Már csak az alkalmazás futtatása maradt hátra. Ehhez azonban be kell állítania a környezeti változókat. Hozzon létre két környezeti változót, és állítsa őket a megfelelő értékre az alábbi parancsokkal:

Erősen megüt

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

PowerShell

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

Ezután futtassa a következő go run parancsot az alkalmazás futtatásához:

go run main.go

Az erőforrások eltávolítása

Futtassa a következő parancsot az erőforráscsoport és az összes többi erőforrás törléséhez:

az group delete --resource-group myResourceGroup

Következő lépések

Ebben a rövid útmutatóban bemutattuk, hogyan lehet Azure Cosmos DB-fiókot létrehozni, hogyan lehet az Adatkezelő segítségével táblát készíteni, és hogyan lehet futtatni az alkalmazást. Most már lekérdezheti az adatokat a Table API használatával.

Az Azure Cosmos DB lekérdezése a Table API használatával