Bereitstellen einer Azure Resource Manager-Vorlage mithilfe des Azure SDK für Go

In diesem Lernprogramm verwenden Sie das Azure SDK for Go, um eine Azure Resource Manager-Vorlage bereitzustellen.

Azure Resource Manager ist der Bereitstellungs- und Verwaltungsdienst für Azure. Es ermöglicht Ihnen, Ressourcen in Ihrem Azure-Konto zu erstellen, zu aktualisieren und zu löschen. Azure Resource Manager-Vorlagen beschreiben Ihre Infrastruktur deklarativ als Code in JSON-Dokumenten.

Am Ende dieses Lernprogramms schreiben und bereitstellen Sie mithilfe von Go eine Azure Resource Manager-Vorlage.

Voraussetzungen

  • Azure-Abonnement: Wenn Sie nicht über ein Azure-Abonnement verfügen, erstellen Sie ein kostenloses Konto , bevor Sie beginnen.

Erstellen eines neuen Moduls

In diesem Abschnitt erstellen Sie ein neues Go-Modul und installieren die erforderlichen Azure SDK-Pakete. Anschließend erstellen Sie die Hauptanwendungsdatei und fügen Code hinzu, der eine Azure Resource Manager-Vorlage bereitstellt.

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen deployARM-how-to. Wechseln Sie dann in dieses Verzeichnis.

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

  2. Führen Sie den go mod init Befehl aus, um die go.mod und go.sum Dateien zu erstellen.

    go mod init deployARM-how-to

  3. Das Azure SDK for Go enthält mehrere Pakete für die Arbeit mit Azure. Für dieses Tutorial benötigen Sie die Pakete azcore/to, azidentity und armresources.

    Führen Sie den go get Befehl aus, um diese Pakete herunterzuladen:

    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

  4. Erstellen Sie eine Datei mit dem Namen main.go.

    touch main.go

  5. Öffnen Sie main.go Ihren Editor, und fügen Sie den folgenden Code hinzu, der sich bei Azure authentifiziert, eine Ressourcengruppe erstellt und eine Azure Resource Manager-Vorlage bereitstellt.

    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()
)

// Read a JSON file from the given path.

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")

	// Authenticate to Azure

	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}

 	// Create a resource group.

	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)

	// Read the template file.

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

	// Deploy the Azure Resource Manager template.

	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)
}

Erstellen der Azure Resource Manager-Vorlage

  1. Erstellen Sie im deployARM-how-to-Verzeichnis eine Datei mit dem Namen template.json.

  2. Öffnen Sie die template.json Datei, und fügen Sie den folgenden Azure Resource Manager-Vorlagencode hinzu, der ein Azure-Speicherkonto erstellt:

    {
    "$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": {}
}

  3. Ersetzen Sie <StorageAccountName> und <StorageAccountDisplayName> durch einen gültigen Speichernamenwert.

Weitere Informationen zu Azure Resource Manager-Vorlagen finden Sie in der Übersicht über Azure Resource Manager-Vorlagen.

Anmelden bei Azure

Der Code in diesem Artikel verwendet den DefaultAzureCredential-Typ aus dem Azure Identity-Modul für Go, um sich bei Azure zu authentifizieren. DefaultAzureCredential unterstützt viele Anmeldeinformationstypen für die Authentifizierung bei Azure via OAuth mit Microsoft Entra ID. In diesem Artikel verwenden Sie die Benutzeranmeldeinformationen, mit denen Sie sich bei der Azure CLI anmelden.

Falls noch nicht geschehen, melden Sie sich bei der Azure CLI an:

az login

Wenn Ihrem Konto mehrere Abonnements zugeordnet sind, verwenden Sie den Befehl "az-Kontoliste ", um eine Liste dieser Abonnements abzurufen. Verwenden Sie den Befehl "az account set ", um das aktive Abonnement festzulegen. Durch Festlegen des aktiven Abonnements stellen Sie sicher, dass alle CLI-Befehle, die Sie im rest dieses Artikels ausführen, für Ihr beabsichtigtes Abonnement ausgeführt werden.

Hinweis

Wenn Sie lokal die Anwendung ausführen, unterstützt DefaultAzureCredential auch Anmeldeinformationen der Azure Developer CLI (AZD) oder eines Azure-Dienstprinzipals, den Sie in Umgebungsvariablen konfigurieren. Weitere Informationen zu allen unterstützten Anmeldeinformationstypen finden Sie unter Azure-Authentifizierung mit dem Azure Identity-Modul für Go.

Ausführen der Anwendung

Bevor Sie die Vorlage bereitstellen können, müssen Sie Ihre Azure-Abonnement-ID als Umgebungsvariable definieren.

  1. Führen Sie zum Abrufen der Abonnement-ID den folgenden Befehl "az account show" aus .

    az account show --query id --output tsv

  2. Legen Sie die AZURE_SUBSCRIPTION_ID Umgebungsvariable mit Ihrer Abonnement-ID fest. Ersetzen Sie <AzureSubscriptionId> durch Ihre Abonnement-ID.

    export AZURE_SUBSCRIPTION_ID=<AzureSubscriptionId>

  3. Führen Sie den go run Befehl aus, um die Vorlage bereitzustellen:

    go run main.go

Troubleshoot

Wenn die Bereitstellung des Speicherkontos fehlschlägt, überprüfen Sie, ob Sie einen gültigen Speichernamenwert verwendet haben. Speicherkontonamen müssen zwischen 3 und 24 Zeichen lang sein und dürfen nur Kleinbuchstaben und Zahlen enthalten.

Wenn das Programm einen Fehler im Zusammenhang mit der Authentifizierung oder Autorisierung zurückgibt, überprüfen Sie die folgenden Elemente:

  • Wenn der Fehler mit einem Zeitstempel und dem folgenden Text beginnt: "Fehler beim Abrufen einer Antwort: DefaultAzureCredential: Fehler beim Abrufen eines Tokens.", stellen Sie sicher, dass Sie sich wie zuvor bei der Azure CLI angemeldet haben.

  • Wenn es sich bei dem Fehler um einen Autorisierungs- oder unzulässigen Fehler handelt (Statuscode 401 oder 403), stellen Sie sicher, dass sich Ihr Benutzerkonto in einer Azure-Rolle befindet, mit der es Rechte zum Erstellen von Ressourcengruppen und zum Hinzufügen von Ressourcen zu Ihrem Abonnement erhält. Beispiele sind die integrierten Azure-Rollen"Mitwirkender" oder "Besitzer". Informationen zum Zuweisen von Azure-Rollen zu Ihrem Benutzer finden Sie unter Zuweisen von Azure-Rollen mithilfe der Azure CLI.

Ausführlichere Anleitungen zur Problembehandlung finden Sie unter "Behandeln von Problemen bei der Azure Identity-Authentifizierung".

Überprüfen der Ressourcen in Azure

Sie können mehrere Azure CLI-Befehle verwenden, um zu überprüfen, ob die Ressourcen erfolgreich in Azure erstellt wurden. Die folgenden Befehle sind einige Beispiele.

Um zu überprüfen, ob die Ressourcengruppe vorhanden ist, führen Sie den Befehl az group exists aus.

az group exists --name deployARM-how-to

Sie können die Ressourcen in der Gruppe mithilfe des Befehls "az-Ressourcenliste " auflisten.

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

Sie können die Bereitstellungsergebnisse (outputResources) und Eigenschaften mithilfe des Befehls "az deployment group show" untersuchen.

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

Bereinigen von Ressourcen

Ressourcen in Azure können laufende Gebühren verursachen. Achten Sie darauf, die in diesem Artikel erstellten Ressourcen aufzuräumen.

Durch die Bereitstellung einer leeren Vorlage im vollständigen Modus werden alle Ressourcen innerhalb einer Ressourcengruppe gelöscht. Es ist eine ordentliche Möglichkeit, Ressourcen zu bereinigen, ohne die Ressourcengruppe selbst zu löschen.

  1. Erstellen Sie eine neue leere Vorlage mit dem Namen empty-template.json.

  2. Öffnen Sie empty-template.json in Ihrem Editor, und fügen Sie den folgenden Code hinzu:

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

  3. Öffnen Sie erneut Ihre Datei main.go.

  4. Aktualisieren Sie den templateFile Konstantenwert auf empty-template.json.

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

  5. Ändern Sie die Bereitstellungszeit von inkrementell auf vollständig, indem Sie die Eigenschaften des Bereitstellungsmodus zu DeploymentModeComplete ändern. Weitere Informationen zu Bereitstellungsmodi finden Sie unter Azure Resource Manager-Bereitstellungsmodi.

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

  6. Führen Sie den go run Befehl aus, um die leere Vorlage bereitzustellen, und löschen Sie das zuvor erstellte Speicherkonto.

    go run main.go

Anstatt eine Bereitstellung zu verwenden, können Sie die Ressourcengruppe und alle zugehörigen Ressourcen löschen, indem Sie den folgenden Azure CLI-Befehl ausführen:

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

Nächste Schritte

Azure SDK for Go Core Concepts

Azure SDK für Go-Verwaltungsbibliotheken

  • Zuletzt aktualisiert um