Översikt över Azure SDKs för Go-bibliotek

Azure SDKs för Go innehåller både hanteringsbibliotek och dataplansklientbibliotek. Den här artikeln innehåller en översikt så att du kan förstå vad biblioteken är, hur de passar in i Azure arbetsflöden och vart du ska gå härnäst för Go-specifika mönster.

Förvaltningsbibliotek

Använd hanteringsbiblioteken för att etablera, konfigurera och styra Azure resurser. De fokuserar på att hantera själva resurserna i stället för de data som lagras i dem. Hanteringsbibliotek utför styrplan åtgärder som hanterar Azure resurser och tjänstkonfiguration. Vanliga uppgifter är:

Skapa eller uppdatera resursgrupper, virtuella nätverk eller virtuella datorer.
Konfigurera säkerhetsinställningar, identiteter, åtkomstprinciper och diagnostik.
Lista, tagga och ta bort Azure resurser i en prenumeration.
Automatisera distribution, rensning, efterlevnad och plattformsåtgärder.

Hanteringsbibliotekspaket har namn som armcompute, armnetworkoch armkeyvault. Använd hanteringsbibliotek under konfigurations-, konfigurations- och styrningsfaserna i en programlivscykel. Om du vill ha detaljerad paketdokumentation söker du efter paketet på pkg.go.dev.

Klientbibliotek

Använd klientbiblioteken när go-programmet behöver arbeta med data eller körningsytor i en redan etablerad Azure tjänst. Klientbibliotek utför dataplansåtgärder som fungerar med data som lagras i eller flödar genom en tjänst. Vanliga uppgifter är:

Ladda upp och ladda ned blobar från ett lagringskonto.
Skicka och ta emot meddelanden med Service Bus eller Event Hubs.
Läsa, skriva eller ta bort poster i en databas.
Hämtar hemligheter från Key Vault.
Köra sökfrågor eller operationer mot tilldelade resurser.

Klientbibliotekspaket har namn som azblob, azstorage, azsecrets, azservicebusoch azeventhubs. Använd klientbibliotek när du redan har etablerat den underliggande Azure-tjänsten med hjälp av hanteringsbibliotek. Om du vill ha detaljerad paketdokumentation söker du efter paketet på pkg.go.dev.

Använda både hanterings- och klientbibliotek

En enda Go-lösning kan använda både hanterings- och klientbibliotek över kontroll- och dataplan. Du kan till exempel använda ett hanteringsbibliotek under installationen för att skapa ett lagringskonto (kontrollplan) och sedan använda ett klientbibliotek i programmet för att ladda upp och ladda ned blobar (dataplan). Genom att förstå skillnaden kan du välja rätt bibliotek för varje uppgift i arbetsflödet.

För Go-specifika mönster och exempel för varje plan, se följande artiklar:

Installera Go-paket

I de flesta projekt installerar du Go-paketen för versionshantering och beroendehantering.

För att installera ett Go-paket, kör kommandot go get.

Om du till exempel vill installera armcompute paketet kör du följande kommando:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute

Installera följande paket för autentisering i de flesta Go-appar:

github.com/Azure/azure-sdk-for-go/sdk/azcore/to
github.com/Azure/azure-sdk-for-go/sdk/azidentity

Importera paket till din Go-kod

När du har laddat ned paketen importerar du dem till din app med hjälp av -instruktionen import :

import (
    "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/resourcemanager/compute/armcompute"
)

Autentisera till Azure

Go-appar som använder Azure SDKs-bibliotek bör autentisera genom att använda Microsoft Entra ID och Azure Identity-biblioteket. Tokenbaserad autentisering är säkrare och hanterbar än anslutningssträngar eller nycklar. De rekommenderade autentiseringsuppgifterna beror på var appen körs: använd hanterade identiteter för Azure värdbaserade appar, autentiseringsuppgifter för utvecklare eller ett tjänsthuvudnamn för lokal utveckling och ett huvudnamn för tjänsten för de flesta lokala scenarier.

Standardalternativet för autentisering är DefaultAzureCredential, som använder miljövariablerna som angavs tidigare i den här artikeln. I Go-koden skapar du ett azidentity objekt på följande sätt:

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
  // handle error
}

Mer information om autentisering finns i Azure SDKs för Go-autentisering.

Skapa en Resurshanteringsklient

När du har fått en autentiseringsuppgift från Azure identitet skapar du en klient för att ansluta till måltjänsten Azure.

Anta till exempel att du vill ansluta till tjänsten Azure Compute. paketet Compute består av en eller flera klienter. En klient grupperar en uppsättning relaterade API:er, vilket ger åtkomst till dess funktioner i den angivna prenumerationen. Du skapar en eller flera klienter för att få åtkomst till de API:er som du behöver.

Följande kod använder armcompute. NewVirtualMachinesClient för att skapa en klient för att hantera virtuella datorer:

client, err := armcompute.NewVirtualMachinesClient("<subscription ID>", cred, nil)
if err != nil {
  // handle error
}

Mer information om hur du hanterar Azure resurser med Go finns i Använd Azure SDKs för Go för kontrollplansåtgärder.

Använd samma mönster för att ansluta till andra Azure tjänster. Installera till exempel paketet armnetwork och skapa ett virtuellt nätverk-klienten för att hantera virtuella nätverksresurser.

client, err := armnetwork.NewVirtualNetworksClient("<subscription ID>", cred, nil)
if err != nil {
  // handle error
}

Kodexempel:

package main

import (
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute"
)

func main() {
    cred, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        // handle error
    }
    client, err := armcompute.NewVirtualMachinesClient("<subscription ID>", cred, nil)
    if err != nil {
        // handle error
    }
}

Mer information om hur du använder Azure SDKs för Go för Azure-tjänster finns i Använd Azure SDKs för Go för dataplansåtgärder.

Använda Azure SDKs för Go-lagringsplatsen

När du har instansierat en klient använder du den för att göra API-anrop till dina Azure resurser. För resurshanteringsscenarier är de flesta användningsfall CRUD-åtgärder (skapa, läsa, uppdatera, ta bort).

Om du vill hitta åtgärder för en viss typ bläddrar du i källan i Azure SDKs för Go GitHub-lagringsplatsen. SDK-källan ordnas under katalogen sdk/, med hanteringsbibliotek under sdk/resourcemanager/ och klientbibliotek i tjänstspecifika mappar som sdk/storage/ och sdk/security/keyvault/.

Följ dessa steg för att hitta källan för en viss typ:

Gå till Azure SDKs för Go-repositoryt på GitHub.
Navigera till sdk/resourcemanager/ för hanteringsbibliotek eller sdk/ för klientbibliotek.
Öppna tjänstmappen och sedan paketmappen. Till exempel sdk/resourcemanager/compute/armcompute/.
Leta reda på källfilen som innehåller den typ du behöver. Klienttyper och deras metoder finns vanligtvis i filer med namnet efter klienten, till exempel virtualmachines_client.go.
Läs typens kommentarer och metodsignaturer för användningsinformation.

Du kan också skapa URL:en direkt. Om du till exempel vill hitta resursgruppens åtgärdskälla går du till https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/resourcemanager/resources/armresources.

Det här exemplet visar hur du hittar källan för Azure resursgruppsåtgärder:

Gå till Azure SDKs för Go-repositoriet på GitHub.
Gå till sdk/resourcemanager/resources/armresources/.
Öppna resource_groups_client.go för att hitta ResourceGroupsClient-typen och dess metod CreateOrUpdate.
Läs metodens kommentarer och parametrar för att förstå hur du gör API-anropet.

För genererad referensdokumentation söker du efter paketet på pkg.go.dev.

Tidskrävande åtgärder

Vissa åtgärder tar lång tid att slutföra. För att hantera dessa åtgärder tillhandahåller hanteringsbiblioteken funktioner som stöder långvariga åtgärder (LRO) via asynkrona anrop. Dessa funktionsnamn börjar med Begin, till exempel BeginCreate och BeginDelete.

Eftersom de här funktionerna är asynkrona blockeras inte koden när funktionen har slutfört sin uppgift. I stället returnerar funktionen ett pollerobjekt omedelbart. Koden anropar sedan en synkron pollerfunktion som returneras när den ursprungliga asynkrona funktionen har slutförts.

Följande kodfragment visar ett exempel på det här mönstret.

ctx := context.Background()
// Call an asynchronous function to create a client. The return value is a poller object.
poller, err := client.BeginCreate(ctx, "resource_identifier", "additional_parameter")

if err != nil {
    // handle error...
}

// Call the poller object's PollUntilDone function that will block until the poller object
// has been updated to indicate the task has completed.
resp, err = poller.PollUntilDone(ctx, nil)
if err != nil {
    // handle error...
}

// Print the fact that the LRO completed.
fmt.Printf("LRO done")

// Work with the response ("resp") object.

Viktiga punkter:

Funktionen PollUntilDone kräver ett avsökningsintervall som anger hur ofta den ska försöka hämta statusen. interval är som standard 30 sekunder om du skickar nil för alternativparametern, men du kan justera den baserat på dina behov.
Intervallet är vanligtvis kort. Se dokumentationen för den specifika Azure resursen för rekommenderade intervall.
Avsnittet LRO på sidan Riktlinjer för Go Azure SDKs-design har ett mer avancerat exempel och allmänna riktlinjer för LRO.

Mer information om mönster finns i användningsmönstren Common i Azure SDKs för Go.

Nästa steg

Mer information om autentisering, klientkonstruktion, tidskrävande åtgärder och genomgångsmönster för tjänster finns i de planspecifika artiklarna:

Använd Azure SDKs för Go för kontrollplansåtgärder för hanteringsorienterade Go-arbetsflöden.
Använd Azure SDKs för Go för dataplanoperationer för körningstidens dataåtkomstmönster som ofta följer tilldelningen.

Exempel finns i Azure SDKs för Go-exempel på GitHub.

Feedback

Var den här sidan till hjälp?

Last updated on 2026-04-10