Använda Azure SDK för Go med Azure Table
GÄLLER FÖR: Bord
Dricks
Innehållet i den här artikeln gäller för Azure Table Storage och Azure Cosmos DB for Table. API för tabell är ett premiumerbjudande för tabelllagring som erbjuder dataflödesoptimerade tabeller, global distribution och automatiska sekundära index.
I den här artikeln får du lära dig hur du skapar, listar och tar bort Azure-tabeller och tabellentiteter med Azure SDK för Go.
Med Azure Table kan du lagra strukturerade NoSQL-data i molnet genom att tillhandahålla ett nyckelattributarkiv med en schemalös design. Eftersom Azure Table Storage är schemalöst är det enkelt att anpassa dina data till de växande behoven i dina program. Åtkomst till tabellens data och API är en snabb och kostnadseffektiv lösning för många program.
Du kan använda Table Storage eller Azure Cosmos DB för att lagra flexibla datauppsättningar som användardata för webbprogram, adressböcker, enhetsinformation. Eller andra typer av metadata som din tjänst kräver. Du kan lagra valfritt antal enheter i en tabell, och ett lagringskonto kan innehålla valfritt antal tabeller, upp till lagringskontots kapacitetsgräns.
Följ den här artikeln om du vill lära dig hur du hanterar Azure Table Storage med hjälp av Azure SDK för Go.
Förutsättningar
- En Azure-prenumeration – skapa en kostnadsfritt.
- Go installerat: Version 1.17 eller senare
- Azure CLI
Konfigurera din miljö
Om du vill följa med i den här självstudien behöver du en Azure-resursgrupp, ett lagringskonto och en tabellresurs. Kör följande kommandon för att konfigurera din miljö:
Skapa en Azure-resursgrupp.
az group create --name myResourceGroup --location eastus
Skapa sedan ett Azure Storage-konto för din nya Azure Table.
az storage account create --name <storageAccountName> --resource-group myResourceGroup --location eastus --sku Standard_LRS
Skapa en tabellresurs.
az storage table create --account-name <storageAccountName> --account-key 'storageKey' --name mytable
Installera paket
Du behöver två paket för att hantera Azure Table with Go. azidentity och aztables. Paketet ger dig ett sätt att autentisera azidentity
till Azure. Och paketen aztables
ger dig möjlighet att hantera tabellresursen i Azure. Kör följande Go-kommandon för att installera dessa paket:
go get github.com/Azure/azure-sdk-for-go/sdk/data/aztables
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity
Mer information om hur du autentiserar till Azure finns i Azure-autentisering med Azure SDK for Go.
Skapa exempelprogrammet
När du har installerat paketen skapar du ett exempelprogram som använder Azure SDK för Go för att hantera Azure Table. go mod
Kör kommandot för att skapa en ny modul med namnet azTableSample
.
go mod init azTableSample
Skapa sedan en fil med namnet main.go
och kopiera sedan nedan till den:
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)
}
Viktigt!
Se till att det konto som du autentiserade med har rätt åtkomstprincip för att hantera ditt Azure-lagringskonto. Om du vill köra koden ovan måste du ha rollen Storage Blob Data-deltagare och rollen Storage Table Data-deltagare.
Kodexempel
Autentisera klienten
// 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)
}
Skapa en tabell
// Create a table and discard the response
_, err := client.Create(context.TODO(), nil)
if err != nil {
panic(err)
}
Skapa en entitet
// 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)
}
Hämta en entitet
// 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)
}
}
Ta bort en entitet
_, err := client.DeleteEntity(context.TODO(), "pk001", "rk001", nil)
if err != nil {
panic(err)
}
Ta bort en tabell
_, err := client.Delete(context.TODO(), nil)
if err != nil {
panic(err)
}
Kör koden
Allt som återstår är att köra programmet. Men innan du gör det måste du konfigurera dina miljövariabler. Skapa två miljövariabler och ange dem till lämpligt värde med hjälp av följande kommandon:
export AZURE_STORAGE_ACCOUNT=<YourStorageAccountName>
export AZURE_TABLE_NAME=<YourAzureTableName>
Kör sedan följande go run
kommando för att köra appen:
go run main.go
Rensa resurser
Kör följande kommando för att ta bort resursgruppen och alla dess återstående resurser:
az group delete --resource-group myResourceGroup
Nästa steg
I den här snabbstarten har du fått lära dig att skapa ett Azure Cosmos DB-konto, skapa en tabell med datautforskaren och att köra en app. Nu kan du köra frågor mot dina data med hjälp av API:et för Tabell.