Comment utiliser le kit de développement logiciel Azure SDK pour Go avec Table Azure

  • Article

S’APPLIQUE À : Table

Conseil

Le contenu de cet article s’applique au stockage Table Azure et à Azure Cosmos DB for Table. L’API pour Table est une offre premium de stockage de tables qui propose des tables optimisées pour le débit, la distribution globale et des index secondaires automatiques.

Dans cet article, vous allez apprendre à créer, répertorier et supprimer des entités Table et Tables Azure à l’aide du kit de développement logiciel Azure SDK pour Go.

Table Azure vous permet de stocker des données NoSQL structurées dans le cloud, en fournissant un magasin d’attributs de clés reposant sur une conception sans schéma. Comme le stockage Table Azure est sans schéma, il est aisé d’adapter vos données en fonction de l’évolution des besoins de vos applications. L’accès aux données et à l’API de table est une solution rapide et rentable pour de nombreuses applications.

Vous pouvez utiliser le stockage Table ou Azure Cosmos DB pour stocker des jeux de données flexibles comme des données utilisateur pour des applications web, des carnets d’adresses ou des informations sur les appareils. Il peut également servir pour d’autres types de métadonnées requis par votre service. Vous pouvez stocker un nombre quelconque d'entités dans une table, et un compte de stockage peut contenir un nombre quelconque de tables, jusqu'à la limite de capacité du compte de stockage.

Suivez cet article pour découvrir comment gérer le stockage Table Azure à l’aide du kit de développement logiciel Azure SDK pour Go.

Prérequis

Configurer votre environnement

Pour suivre ce tutoriel, vous aurez besoin d’un groupe de ressources Azure, d’un compte de stockage et d’une ressource de table. Exécutez les commandes suivantes pour configurer votre environnement :

  1. Création d’un groupe de ressources Azure.

    az group create --name myResourceGroup --location eastus

  2. Créez ensuite un compte de stockage Azure pour votre nouvelle Table Azure.

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

  3. Créez une ressource de table.

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

Installer des packages

Vous aurez besoin de deux packages pour gérer la Table Azure avec Go ; azidentity et aztables. Le package azidentity vous permet de vous authentifier auprès d’Azure. Et les packages aztables vous permettent de gérer la ressource de tables dans Azure. Exécutez les commandes Go suivantes pour installer ces packages :

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

Pour en savoir plus sur les différentes méthodes d’authentification, consultez Authentification Azure avec Azure SDK pour Go.

Créer l’exemple d’application

Une fois les packages installés, vous créez un exemple d’application qui utilise le kit de développement logiciel Azure SDK pour Go pour gérer Table Azure. Exécutez la commande go mod pour créer un module nommé azTableSample.

go mod init azTableSample

Ensuite, créez un fichier appelé main.go, puis copiez :

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

Important

Vérifiez que le compte avec lequel vous vous êtes authentifié dispose de la stratégie d’accès appropriée pour gérer votre compte de stockage Azure. Pour exécuter le code ci-dessus, votre compte doit disposer au minimum du rôle de contributeur de données de stockage Blob et du rôle de contributeur de données de table de stockage.

Exemples de code

Authentifier le client

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

Créer une table

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

Créer une entité

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

Obtenir une entité

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

Suppression d’une entité

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

Suppression d’une table

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

Exécuter le code

Il ne nous reste qu’à exécuter l’application. Mais avant de le faire, vous devez configurer vos variables d’environnement. Créez deux variables d’environnement et définissez-les sur la valeur appropriée à l’aide des commandes suivantes :

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

Ensuite, exécutez la commande go run suivante pour exécuter l’application :

go run main.go

Nettoyer les ressources

Exécutez la commande suivante pour supprimer le groupe de ressources et toutes ses ressources restantes :

az group delete --resource-group myResourceGroup

Étapes suivantes

Dans ce guide de démarrage rapide, vous avez appris à créer un compte Azure Cosmos DB, à créer une table à l’aide de l’Explorateur de données, et à exécuter une application. Maintenant, vous pouvez interroger vos données à l’aide de l’API pour Table.

Interroger Azure Cosmos DB à l’aide de l’API pour Table