Leggi in inglese

Condividi tramite

Gestire i gruppi di risorse con Azure SDK per Go

  • Articolo

Questo articolo illustra come creare e gestire un gruppo di risorse con la libreria di gestione di Azure SDK for Go.

1. Configurare le risorse di Azure

Per completare i passaggi descritti in questo articolo, sono necessari gli identificatori e le risorse di Azure seguenti:

  • Sottoscrizione di Azure: se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

  • Ottenere l'ID sottoscrizione di Azure.

  • Ottenere l'ID tenant di Microsoft Entra.

  • Creare un'entità servizio. Prendere nota dell'ID applicazione (client) dell'entità servizio e del segreto. Assicurarsi di seguire anche le istruzioni per assegnare il ruolo Collaboratore nella sottoscrizione all'applicazione. Il ruolo Collaboratore è un ruolo di amministratore con privilegi che concede l'autorizzazione per gestire tutte le risorse nella sottoscrizione.

Prima di passare alla sezione successiva, assicurarsi di aver annotato l'ID sottoscrizione (Guid), l'ID tenant (Guid) e l'ID client/applicazione (Guid) e il segreto per l'entità servizio.

2. Impostare le variabili di ambiente di autenticazione

Usando le informazioni di autenticazione di Azure, impostare le variabili di ambiente appropriate in modo che il codice possa eseguire l'autenticazione in Azure.

Impostare le variabili di ambiente seguenti. Sostituire i segnaposto con i valori appropriati della sezione precedente.

Bash 
export AZURE_SUBSCRIPTION_ID="<azure_subscription_id>"
export AZURE_TENANT_ID="<active_directory_tenant_id>"
export AZURE_CLIENT_ID="<service_principal_appid>"
export AZURE_CLIENT_SECRET="<service_principal_password>"

3. Creare un gruppo di risorse

  1. Creare una directory in cui testare ed eseguire il codice Go di esempio e impostarla come directory corrente.

  2. Eseguire go mod init per creare un modulo nella directory corrente.

    Console 
    go mod init <module_path>

    Punti principali:

    • Il <module_path> parametro è in genere una posizione in un repository GitHub, ad esempio github.com/<your_github_account_name>/<directory>.
    • Quando si crea un'app da riga di comando come test e non si pubblica l'app, <module_path> non è necessario fare riferimento a una posizione effettiva.

  3. Eseguire go per scaricare, compilare e installare i moduli necessari di Azure SDK per Go.

    Console 
    go get github.com/Azure/azure-sdk-for-go/sdk/azcore
go get github.com/Azure/azure-sdk-for-go/sdk/azcore/to
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity
go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources

    Importante

    I pacchetti per la versione corrente delle librerie di gestione delle risorse di Azure si trovano in sdk/**/arm**. I pacchetti per la versione precedente delle librerie di gestione si trovano in /services. Se si usa la versione precedente, vedere la Guida alla migrazione di Azure SDK for Go.

  4. Creare un file denominato main.go e aggiungere il codice seguente. Ogni sezione del codice è commentata per spiegarne lo scopo.

    Go 
    package main

// Import key modules.
import (
	"context"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"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/resources/armresources"
)

// Define key global variables.
var (
	subscriptionId    = os.Getenv("AZURE_SUBSCRIPTION_ID")
	location          = "eastus"
	resourceGroupName = "myResourceGroup" // !! IMPORTANT: Change this to a unique name in your subscription.
	ctx               = context.Background()
)

// Define the function to create a resource group.
func createResourceGroup(subscriptionId string, credential azcore.TokenCredential) (armresources.ResourceGroupsClientCreateOrUpdateResponse, error) {
	rgClient, _ := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)

	param := armresources.ResourceGroup{
		Location: to.Ptr(location),
	}

	return rgClient.CreateOrUpdate(ctx, resourceGroupName, param, nil)
}

// Define the standard 'main' function for an app that is called from the command line.
func main() {

	// Create a credentials object.
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("Authentication failure: %+v", err)
	}

	// Call your function to create an Azure resource group.
	resourceGroup, err := createResourceGroup(subscriptionId, cred)
	if err != nil {
		log.Fatalf("Creation of resource group failed: %+v", err)
	}

	// Print the name of the new resource group.
	log.Printf("Resource group %s created", *resourceGroup.ResourceGroup.ID)
}

    Punti principali:

    • Il subscriptionId valore viene recuperato dalla AZURE_SUBSCRIPTION_ID variabile di ambiente.
    • Le location stringhe e resourceGroupName vengono impostate per testare i valori. Se necessario, modificare questi valori in un valore appropriato per la località e la sottoscrizione.

  5. Eseguire go mod tidy per pulire le dipendenze nel file in base al go.mod codice sorgente.

    Console 
    go mod tidy

  6. Eseguire go run per compilare ed eseguire l'app.

    Console 
    go run .

4. Verificare i risultati

  1. Accedere al portale di Azure.

  2. Accedere e selezionare la sottoscrizione di Azure.

  3. Nel menu a sinistra selezionare Gruppi di risorse.

  4. Il nuovo gruppo di risorse è elencato tra i gruppi di risorse della sottoscrizione di Azure.

5. Aggiornare un gruppo di risorse

  1. Tornare al main.go file.

  2. Inserire il codice seguente appena sopra la main funzione.

    Go 
    // Update the resource group by adding a tag to it.
func updateResourceGroup(subscriptionId string, credential azcore.TokenCredential) (armresources.ResourceGroupsClientUpdateResponse, error) {
    rgClient, _ := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)

    update := armresources.ResourceGroupPatchable{
        Tags: map[string]*string{
            "new": to.Ptr("tag"),
        },
    }
    return rgClient.Update(ctx, resourceGroupName, update, nil)
}

Dopo aver aggiunto il codice, passare alla sezione successiva. Il codice viene eseguito in una sezione successiva.

6. Elencare i gruppi di risorse di una sottoscrizione di Azure

  1. Tornare al main.go file.

  2. Inserire il codice seguente appena sopra la main funzione.

    Go 
    // List all the resource groups of an Azure subscription.
func listResourceGroups(subscriptionId string, credential azcore.TokenCredential) ([]*armresources.ResourceGroup, error) {
    rgClient, _ := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)

    pager := rgClient.NewListPager(nil)

    var resourceGroups []*armresources.ResourceGroup
    for pager.More() {
        resp, err := pager.NextPage(ctx)
        if err != nil {
            return nil, err
        }
        if resp.ResourceGroupListResult.Value != nil {
            resourceGroups = append(resourceGroups, resp.ResourceGroupListResult.Value...)
        }
    }
    return resourceGroups, nil
}

Dopo aver aggiunto il codice, passare alla sezione successiva. Il codice viene eseguito in una sezione successiva.

7. Eliminare un gruppo di risorse

  1. Tornare al main.go file.

  2. Inserire il codice seguente appena sopra la main funzione.

    Go 
    // Delete a resource group.
func deleteResourceGroup(subscriptionId string, credential azcore.TokenCredential) error {
    rgClient := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)

    poller, err := rgClient.BeginDelete(ctx, resourceGroupName, nil)
    if err != nil {
        return err
    }
    if _, err := poller.PollUntilDone(ctx, nil); err != nil {
        return err
    }
    return nil
}

Dopo aver aggiunto il codice, passare alla sezione successiva. Il codice viene eseguito in una sezione successiva.

8. Aggiornare la funzione principale

Nelle sezioni precedenti è stato aggiunto il codice per main.go creare, aggiornare ed eliminare un gruppo di risorse. È stato aggiunto anche il codice per elencare tutti i gruppi di risorse in una sottoscrizione di Azure. Per eseguire tutte queste funzioni in sequenza:

  1. In main.gosostituire la main funzione con il codice seguente:

    Go 
    func main() {

    // Create a credentials object.
    cred, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        log.Fatalf("Authentication failure: %+v", err)
    }

    // Call your function to create an Azure resource group.
    resourceGroup, err := createResourceGroup(subscriptionId, cred)
    if err != nil {
        log.Fatalf("Creation of resource group failed: %+v", err)
    }
    // Print the name of the new resource group.
    log.Printf("Resource group %s created", *resourceGroup.ResourceGroup.ID)

    // Call your function to add a tag to your new resource group.
    updatedRG, err := updateResourceGroup(subscriptionId, cred)
    if err != nil {
        log.Fatalf("Update of resource group failed: %+v", err)
    }
    log.Printf("Resource Group %s updated", *updatedRG.ResourceGroup.ID)

    // Call your function to list all the resource groups.
    rgList, err := listResourceGroups(subscriptionId, cred)
    if err != nil {
        log.Fatalf("Listing of resource groups failed: %+v", err)
    }
    log.Printf("Your Azure subscription has a total of %d resource groups", len(rgList))

    // Call your function to delete the resource group you created.
    if err := deleteResourceGroup(subscriptionId, cred); err != nil {
        log.Fatalf("Deletion of resource group failed: %+v", err)
    }
    log.Printf("Resource group deleted")
}

  2. Eseguire il codice e osservare l'output.

    Console 
    go run .
    Output 
    2024/07/31 15:29:06 Resource group /subscriptions/<subscription ID>/resourceGroups/myResourceGroup created
2024/07/31 15:29:07 Resource Group /subscriptions/<subscription ID>/resourceGroups/myResourceGroup updated
2024/07/31 15:29:07 Your Azure subscription has a total of 8 resource groups
2024/07/31 15:30:25 Resource group deleted

    Nota

    L'eliminazione del gruppo di risorse può richiedere alcuni minuti.

Risoluzione dei problemi

Passaggi successivi

Altre informazioni sull'uso di Azure SDK per Go