Uso delle librerie di gestione di Azure SDK per Go

Articolo
10/23/2023

Come illustrato nell'articolo Che cos'è Azure SDK per Go?, Azure SDK per Go contiene un set di librerie client e di gestione. Le librerie di gestione condividono molte funzionalità, ad esempio il supporto di Identità di Azure, la pipeline HTTP e la gestione degli errori. È possibile trovare l'elenco completo delle librerie di gestione nella pagina del modulo Azure SDK for Go.

Questo articolo illustra i passaggi di base per usare le librerie di gestione per interagire con le risorse di Azure.

Installazione dei pacchetti Go

Nella maggior parte dei progetti si installeranno i pacchetti Go per il controllo delle versioni e la gestione delle dipendenze.

Per installare un pacchetto Go, usare il go get comando .

Ad esempio, per installare il armcompute pacchetto, eseguire quanto segue nella riga di comando:

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

Nella maggior parte delle app Go verranno installati i pacchetti seguenti per l'autenticazione:

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

Importazione di pacchetti nel codice Go

Dopo il download, il pacchetto viene importato nell'app tramite l'istruzione 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"
)

Autenticazione in Azure

Per eseguire il codice in una sottoscrizione di Azure, è necessario eseguire l'autenticazione in Azure. Il pacchetto azidentity supporta più opzioni per l'autenticazione in Azure. Queste opzioni includono client/segreto, certificato e identità gestita.

L'opzione di autenticazione predefinita è DefaultAzureCredential, che usa le variabili di ambiente impostate in precedenza in questo articolo. Nel codice Go si creerà un azidentity oggetto come segue:

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

Creazione di un client di Gestione risorse

Dopo aver ottenuto credenziali da Identità di Azure, creare un client per connettersi al servizio di Azure di destinazione.

Si supponga, ad esempio, di volersi connettere al servizio di calcolo di Azure. Il pacchetto di calcolo è costituito da uno o più client. Un client raggruppa un set di API correlate, fornendo l'accesso alla relativa funzionalità all'interno della sottoscrizione specificata. Creare uno o più client per accedere alle API necessarie.

Nel frammento di codice seguente, armcompute . Il tipo NewVirtualMachinesClient viene usato per creare un client per gestire le macchine virtuali:

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

Lo stesso modello viene usato per connettersi ad altri servizi di Azure. Ad esempio, installare il pacchetto armnetwork e creare un client VirtualNetwork per gestire le risorse della rete virtuale.For example, install the armnetwork package and create a VirtualNetwork client to manage virtual network (VNET) resources.

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

Esempio di codice:

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("SubID", cred, nil)
	if err != nil {
        // handle error
    }
}

Uso della documentazione di riferimento di Azure SDK per Go

Una volta creata un'istanza, i client vengono usati per effettuare chiamate API alle risorse di Azure. Per gli scenari di gestione delle risorse, la maggior parte dei casi d'uso sono operazioni CRUD (Creazione/Lettura/Aggiornamento/Eliminazione).

Per cercare le operazioni per un tipo specifico, seguire questa procedura:

Passare alla documentazione di riferimento di Azure SDK per Go.
Cercare il pacchetto nella pagina. (Premendo <CTRL+F> espande automaticamente tutti i nodi nella pagina per la ricerca.
Selezionare il pacchetto.
Cercare il tipo nella pagina del pacchetto.
Leggere la descrizione del tipo e le informazioni sull'utilizzo nel codice Go.

È anche possibile compilare manualmente l'URL aggiungendo il nome del pacchetto a github.com/Azure/azure-sdk-for-go/sdk/.

Ad esempio, se si sta cercando la compute/armcompute documentazione di riferimento, l'URL è github.com/Azure/azure-sdk-for-go/sdk/compute/armcompute.

L'esempio seguente illustra come trovare la documentazione di riferimento per le operazioni del gruppo di risorse di Azure:

Passare alla documentazione di riferimento principale di Azure SDK for Go in pkg.go.dev.
Fare clic su CTRL+F> e immettere resourcemanager/resources/armresources.< Quando si digita il termine di ricerca, viene visualizzata una corrispondenza di chiusura con il pacchetto resources/armresources .
Selezionare il pacchetto appropriato per l'applicazione.
Leggere le sezioni "Introduzione" o cercare un'operazione specifica. Ad esempio, la ricerca del termine "resourcegroupsclient.create" (se si vuole creare un gruppo di risorse) consente di accedere alla funzione CreateOrUpdate.
A questo punto, è possibile leggere come chiamare l'API per creare un gruppo di risorse di Azure.

Operazioni a esecuzione prolungata

Poiché alcune operazioni possono richiedere molto tempo, le librerie di gestione contengono funzioni per supportare operazioni a esecuzione prolungata (LRO) tramite chiamate asincrone. Questi nomi di funzione iniziano con Begin. Esempi di questo modello sono BeginCreate e BeginDelete.

Poiché queste funzioni sono asincrone, il codice non si blocca finché la funzione non termina l'attività. La funzione restituisce invece immediatamente un oggetto poller . Il codice chiama quindi una funzione poller sincrona che restituisce quando la funzione asincrona originale è stata completata.

Il frammento di codice seguente illustra un esempio di questo modello.

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.

Punti principali:

La PollUntilDone funzione richiede un intervallo di polling che specifica la frequenza con cui deve tentare di ottenere lo stato.
L'intervallo è in genere breve. Per gli intervalli consigliati, vedere la documentazione relativa alla risorsa di Azure specifica.
La sezione LRO della pagina Go Azure SDK Design Guidelines (Linee guida per la progettazione di Go Azure SDK) include un esempio avanzato di spostamento e linee guida generali per LRO.

Passaggi successivi

Manage Azure resource groups (Gestire gruppi di risorse di Azure)

Share via