De Azure SDK voor Go gebruiken met Azure Table

VAN TOEPASSING OP: Tabel

• .NET
• Node.js
• Java
• C++
• PHP
• Go

Tip

De inhoud in dit artikel is van toepassing op Azure Table Storage en Azure Cosmos DB for Table. De API voor Table is een premium-aanbieding voor tabelopslag met tabellen die zijn geoptimaliseerd voor doorvoer, wereldwijde distributie en automatische secundaire indexen.

In dit artikel leert u hoe u Azure Tables and Table-entiteiten kunt maken, weergeven en verwijderen met de Azure SDK voor Go.

Met Azure Table kunt u gestructureerde NoSQL-gegevens opslaan in de cloud door u een sleutelkenmerkarchief te bieden met een schemaloos ontwerp. Omdat Azure Table Storage schemaloos is, kunt u uw gegevens eenvoudig aanpassen aan de veranderende behoeften van uw toepassingen. Toegang tot de gegevens en API van de tabel is een snelle en rendabele oplossing voor veel toepassingen.

U kunt Table Storage of Azure Cosmos DB gebruiken om flexibele gegevenssets op te slaan, zoals gebruikersgegevens voor webtoepassingen, adresboeken, apparaatgegevens. Of andere typen metagegevens die uw service nodig heeft. In elke tabel kunt u een willekeurig aantal entiteiten opslaan. Een opslagaccount kan een onbeperkt aantal tabellen bevatten, tot de maximale capaciteit van het opslagaccount.

Volg dit artikel voor meer informatie over het beheren van Azure Table Storage met behulp van de Azure SDK voor Go.

Vereisten

• Een Azure-abonnement (u kunt een gratis abonnement maken).
• Go geïnstalleerd: versie 1.17 of hoger
• Azure-CLI

Uw omgeving instellen

Als u deze zelfstudie wilt volgen, hebt u een Azure-resourcegroep, een opslagaccount en een tabelresource nodig. Voer de volgende opdrachten uit om uw omgeving in te stellen:

1. Maak een Azure-resourcegroep.

   az group create --name myResourceGroup --location eastus
   

2. Maak vervolgens een Azure-opslagaccount voor uw nieuwe Azure-tabel.

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

3. Maak een tabelresource.

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

Pakketten installeren

U hebt twee pakketten nodig om Azure Table te beheren met Go; azidentity en aztables. Het azidentity pakket biedt u een manier om u te verifiëren bij Azure. En de aztables pakketten bieden u de mogelijkheid om de tabelresource in Azure te beheren. Voer de volgende Go-opdrachten uit om deze pakketten te installeren:

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

Raadpleeg Azure-verificatie met de Azure SDK voor Go voor meer informatie over de manieren om te verifiëren bij Azure.

De voorbeeldtoepassing maken

Zodra de pakketten zijn geïnstalleerd, maakt u een voorbeeldtoepassing die gebruikmaakt van de Azure SDK voor Go om Azure Table te beheren. Voer de opdracht uit om een nieuwe module met de go mod naam azTableSamplete maken.

go mod init azTableSample

Maak vervolgens een bestand met de naam main.goen kopieer er hieronder naartoe:

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

Belangrijk

Zorg ervoor dat het account waarmee u bent geverifieerd, het juiste toegangsbeleid heeft om uw Azure-opslagaccount te beheren. Als u de bovenstaande code wilt uitvoeren, moet u minimaal de rol Bijdrager voor opslagblobgegevens en de rol Inzender voor opslagtabelgegevens hebben.

Codevoorbeelden

De client verifiëren

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

Een tabel maken

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

Een entiteit maken

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

Een entiteit ophalen

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

Een entiteit verwijderen

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

Een tabel verwijderen

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

De code uitvoeren

U hoeft alleen maar de toepassing uit te voeren. Maar voordat u dat doet, moet u uw omgevingsvariabelen instellen. Maak twee omgevingsvariabelen en stel deze in op de juiste waarde met behulp van de volgende opdrachten:

Bash

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

PowerShell

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

Voer vervolgens de volgende go run opdracht uit om de app uit te voeren:

go run main.go

Resources opschonen

Voer de volgende opdracht uit om de resourcegroep en alle resterende resources te verwijderen:

az group delete --resource-group myResourceGroup

Volgende stappen

In deze Quick Start hebt u geleerd hoe u een Azure Cosmos DB-account kunt maken, hebt u een tabel gemaakt met de Data Explorer en hebt u een app uitgevoerd. U kunt nu query's uitvoeren op uw gegevens met behulp van de API voor Table.

Query's uitvoeren op Azure Cosmos DB met behulp van de API voor Table