Distribuire un modello di Gestione risorse di Azure con Azure SDK per Go

2025-01-13

In questa esercitazione si usa Azure SDK for Go per distribuire un modello di Azure Resource Manager.

Azure Resource Manager è il servizio di distribuzione e gestione di Azure. Consente di creare, aggiornare ed eliminare risorse nell'account Azure. I modelli di Azure Resource Manager descrivono in modo dichiarativo l'infrastruttura come codice nei documenti JSON.

Al termine di questa esercitazione si sarà scritto e distribuito un modello di Azure Resource Manager usando Go.

Prerequisiti

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

Go installato: versione 1.18 o successiva

Creazione di nuovo modulo

Creare una nuova directory denominata deployARM-how-to. Passare quindi a tale directory.

mkdir deployARM-how-to
cd deployARM-how-to

Eseguire il go mod init comando per creare i go.mod file e go.sum .

go mod init deployARM-how-to

Azure SDK per Go contiene diversi pacchetti per l'uso di Azure, per questa esercitazione sono necessari i azcore/topacchetti , azidentitye armresources .

Eseguire il go get comando per scaricare questi pacchetti:

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

Creare quindi un file denominato main.go

touch main.go

main.go Aprire l'editor e aggiungere il codice seguente:

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"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/resourcemanager/resources/armresources"
)

const (
	resourceGroupName     = "deployARM-how-to"
	resourceGroupLocation = "eastus"
	deploymentName        = "deployARM-how-to"
	templateFile          = "template.json"
)

var (
	ctx = context.Background()
)

func readJSON(path string) (map[string]interface{}, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		log.Fatalf("failed to read file: %v", err)
	}
	contents := make(map[string]interface{})
	_ = json.Unmarshal(data, &contents)
	return contents, nil
}

func main() {
	subscriptionId := os.Getenv("AZURE_SUBSCRIPTION_ID")

	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	client, err := armresources.NewResourceGroupsClient(subscriptionId, cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	resp, err := client.CreateOrUpdate(context.Background(), resourceGroupName, armresources.ResourceGroup{
		Location: to.Ptr(resourceGroupLocation),
	}, nil)
	if err != nil {
		log.Fatalf("failed to obtain a response: %v", err)
	}
	log.Printf("resource group ID: %s\n", *resp.ResourceGroup.ID)

	template, err := readJSON(templateFile)
	if err != nil {
		return
	}

	deploymentsClient, err := armresources.NewDeploymentsClient(subscriptionId, cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	deploy, err := deploymentsClient.BeginCreateOrUpdate(
		ctx,
		resourceGroupName,
		deploymentName,
		armresources.Deployment{
			Properties: &armresources.DeploymentProperties{
				Template: template,
				Mode:     to.Ptr(armresources.DeploymentModeIncremental),
			},
		},
		nil,
	)
	if err != nil {
		log.Fatalf("failed to deploy template: %v", err)
	}

	fmt.Println(deploy)
}

Creare il modello di Azure Resource Manager

All'interno della deployARM-how-to directory creare un altro file denominato template.json.

Aprire il file template.json e aggiungere il codice seguente:

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
    },
    "functions": [],
    "variables": {},
    "resources": [{
        "name": "<StorageAccountName>",
        "type": "Microsoft.Storage/storageAccounts",
        "apiVersion": "2021-04-01",
        "tags": {
            "displayName": "<StorageAccountDisplayName>"
        },
        "location": "EastUS",
        "kind": "StorageV2",
        "sku": {
            "name": "Premium_LRS",
            "tier": "Premium"
        }
    }],
    "outputs": {}
}

Sostituire <StorageAccountName> e <StorageAccountDisplayName> con un valore di nome di archiviazione valido.

Il codice in questo articolo usa il tipo DefaultAzureCredential del modulo Azure Identity per Go per l'autenticazione in Azure. DefaultAzureCredential supporta molti tipi di credenziali per l'autenticazione con Azure usando OAuth con l'ID Entra Di Microsoft. In questo articolo si usano le credenziali utente con cui si accede all'interfaccia della riga di comando di Azure.

Se non è già stato fatto, accedere all'interfaccia della riga di comando di Azure:

az login

Se sono presenti più sottoscrizioni associate all'account, usare il comando az account list per ottenere un elenco di tali sottoscrizioni e il comando az account set per impostare la sottoscrizione attiva. In questo modo si garantisce che tutti i comandi dell'interfaccia della riga di comando eseguiti nel resto di questo articolo vengano eseguiti nella sottoscrizione prevista.

Nota

DefaultAzureCredential supporta anche le credenziali di accesso dell'interfaccia della riga di comando per sviluppatori di Azure (AZD) o un'entità servizio di Azure configurata nelle variabili di ambiente durante l'esecuzione in locale. Per altre informazioni su tutti i tipi di credenziali supportati, vedere Autenticazione di Azure con il modulo Azure Identity for Go.

Eseguire l'applicazione

Prima di poter distribuire il modello, è necessario definire l'ID sottoscrizione di Azure come variabile di ambiente.

Creare una variabile di ambiente denominata AZURE_SUBSCRIPTION_ID impostata sul proprio ID sottoscrizione di Azure. Per ottenere l'ID sottoscrizione, è possibile eseguire il comando az account show seguente.

az account show --query id --output tsv

export AZURE_SUBSCRIPTION_ID=<AzureSubscriptionId>

Sostituire <AzureSubscriptionId> con l'ID della sottoscrizione.

Eseguire quindi il go run comando per distribuire il modello:

go run main.go

Risoluzione dei problemi

Se il programma restituisce un errore correlato all'autenticazione o all'autorizzazione, verificare quanto segue:

Se l'errore inizia con un timestamp e il testo seguente: "Failed to get a response: DefaultAzureCredential: failed to acquire a token.", assicurarsi di aver eseguito l'accesso all'interfaccia della riga di comando di Azure come indicato in precedenza.
Se l'errore è un errore di autorizzazione o accesso negato (codice di stato 401 o 403), assicurarsi che l'account utente si trova in un ruolo di Azure che concede i diritti per creare gruppi di risorse e aggiungere risorse nella sottoscrizione. Gli esempi includono i ruoli predefiniti collaboratore o proprietario di Azure. Per informazioni su come assegnare ruoli di Azure all'utente, vedere Assegnare ruoli di Azure usando l'interfaccia della riga di comando di Azure.

Per indicazioni più dettagliate sulla risoluzione dei problemi, vedere Risolvere i problemi di autenticazione di Identità di Azure.

Verificare le risorse in Azure

Esistono diversi comandi dell'interfaccia della riga di comando di Azure che è possibile usare per verificare che le risorse siano state create correttamente in Azure. I comandi seguenti sono alcuni esempi.

Per verificare che il gruppo di risorse sia stato creato, eseguire il comando az group exists .

az group exists --name deployARM-how-to

È possibile elencare le risorse nel gruppo con il comando az resource list .

az resource list --resource-group deployARM-how-to

È possibile esaminare i risultati della distribuzione (outputResources) e le proprietà con il comando az deployment group show .

az deployment group show -g deployARM-how-to -n deployARM-how-to

Pulire le risorse

Lasciare le risorse in Azure può comportare addebiti in corso, quindi assicurarsi di pulire le risorse create in questa procedura.

La distribuzione di un modello vuoto in modalità completa elimina tutte le risorse all'interno di un gruppo di risorse. È un modo ordinato per pulire le risorse senza eliminare il gruppo di risorse stesso.

Creare un nuovo modello vuoto denominato empty-template.json.

Aprire nell'editor empty-template.json e aggiungere il codice seguente:

{
    "$schema": "https://schema.management.azure.com/schemas/2019-08-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {},
    "variables": {},
    "resources": [],
    "outputs": {}
}

Aprire quindi il main.go file e modificare il tempo di distribuzione in modo che venga completato anziché incrementale. Per altre informazioni sulle modalità di distribuzione, vedere Modalità di distribuzione di Azure Resource Manager.

Modificare la modalità nelle proprietà di distribuzione in DeploymentModeComplete. Aggiornare il templateFile valore costante in empty-template.json. Assicurarsi di salvare le modifiche.

Aggiornare templateFile const:

const (
	resourceGroupName     = "deployARM-how-to"
	resourceGroupLocation = "eastus"
	deploymentName        = "deployARM-how-to"
	templateFile          = "empty-template.json"
)

Aggiornare la modalità di distribuzione:

deploy, err = deploymentsClient.BeginCreateOrUpdate(
    ctx,
    resourceGroupName,
    deploymentName,
    armresources.Deployment{
        Properties: &armresources.DeploymentProperties{
            Template: template,
            Mode:     to.Ptr(armresources.DeploymentModeComplete), //Deployment Mode is here
        },
    },
    nil,
)

Eseguire il go run comando per distribuire il modello vuoto ed eliminare l'account di archiviazione creato in precedenza.

go run main.go

Facoltativamente, è possibile eliminare il gruppo di risorse e tutte le relative risorse insieme.

az group delete --resource-group deployARM-how-to

Passaggi successivi

Concetti di base di Azure SDK per Go

Librerie di gestione di Azure SDK per Go

Condividi tramite