Verwenden Sie das Azure SDK für Steuerungsebene-Operationen

Erfahren Sie, wie Sie Azure Ressourcen programmgesteuert mithilfe der Azure SDK für Go-Verwaltungsbibliotheken bereitstellen, konfigurieren und verwalten. Zu den allgemeinen Workflows auf der Steuerungsebene gehören das Erstellen von Ressourcengruppen, das Verwalten von Speicher- und Netzwerkinfrastrukturen sowie das Behandeln von VM-Lebenszyklusvorgängen wie Erstellen, Starten, Beenden, Ändern der Größe, Aktualisieren und Löschen von virtuellen Computern. Wenn Sie eine höhere Einführung in die Rolle von Verwaltungsbibliotheken im Azure SDK für Go wünschen, beginnen Sie mit der Übersicht über die Azure SDK für Go-Verwaltungsbibliotheken. Dieser Artikel konzentriert sich auf die Muster der Steuerungsebene in Go, die Sie über Dienste hinweg wiederverwenden, und verweist auf Anleitungen zur Datenebene, wenn der Laufzeitpfad von der Ressourcenverwaltung zum Bearbeiten von Dienstdaten übergeht.

Was ist die Azure Kontrollebene?

Die Azure Steuerebene ist der Satz von APIs, die den Lebenszyklus von Azure Ressourcen steuern – erstellen, aktualisieren, konfigurieren und löschen. Jeder Vorgang, den Sie im Azure-Portal, Azure CLI oder infrastrukturbasierten Code-Tool ausführen, ruft diese Steuerebenen-APIs letztendlich auf.

Die Azure SDK für Go macht die Steuerebene über eine Familie von arm*-Paketen unter github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/ verfügbar. Jedes Paket wird einem Azure Ressourcenanbieter zugeordnet und folgt einem konsistenten Muster:

1. Authentifizieren Sie sich mithilfe des azidentity Pakets.
2. Erstellen Sie einen typierten Client für die Ressource, die Sie verwalten möchten.
3. Rufen Sie Methoden auf dem Client auf, um Ressourcen zu erstellen, zu lesen, zu aktualisieren oder zu löschen.
4. Handhaben Sie langlaufende Vorgänge mithilfe von Pollern.

Zu den gängigen Szenarien für die Automatisierung der Go-Steuerungsebene gehören:

• Infrastruktur für Bereitstellungspipelines
• Verwalten von VM-Lebenszyklusvorgängen wie Erstellen, Aktualisieren, Löschen, Starten, Beenden und Ändern der Größe
• Erstellen von benutzerdefinierten CLIs und Operatoren für Plattformteams
• Umsetzung einer GitOps-basierten Infrastruktur-Synchronisation
• Automatisieren der Compliance-Überwachung und Abweichungserkennung

Authentifizierung

Alle Verwaltungsvorgänge erfordern authentifizierte Anmeldeinformationen des Pakets azidentity. Das Paket stellt Anmeldeinformationstypen für jede Umgebung bereit, einschließlich lokaler Entwicklung, CI/CD-Pipelines und Produktionsworkloads, die in Azure ausgeführt werden. Alle Anmeldeinformationstypen implementieren dieselbe azcore.TokenCredential Schnittstelle, sodass Sie sie austauschen können, ohne den Clientcode zu ändern.

Nachdem Sie eine Anmeldeinformation erhalten haben, erstellen Sie eine Client-Factory für das Paket, und fragen Sie diese nach dem typspezifischen Client, den Sie benötigen.

// Create credential that auto-discovers authentication (Azure CLI, env vars, managed identity)
cred, err := azidentity.NewDefaultAzureCredential(nil)

// Construct a client factory, then the typed client for management operations
clientFactory, err := armresources.NewClientFactory(subscriptionID, cred, nil)
rgClient := clientFactory.NewResourceGroupsClient()

Aktuelle arm* Paketdokumente veranschaulichen üblicherweise das Client-Factory-Muster, weil es die gemeinsame Konfiguration für zugehörige Clients zentral zusammenfasst. Viele Pakete machen auch direkte New<ResourceType>Client(subscriptionID, credential, options) Konstruktoren verfügbar, doch NewClientFactory(...).New<ResourceType>Client() ist das Muster, das sie am häufigsten auf pkg.go.dev sehen. Bei der lokalen Entwicklung nimmt DefaultAzureCredential in der Regel Ihre Azure CLI Anmeldung auf. In CI/CD und bereitgestellten Workloads können Sie zu umgebungsbasierten Anmeldeinformationen oder verwalteter Identität wechseln, ohne den Rest Ihres Clientcodes zu ändern.

Eine vollständige Anleitung zu Anmeldeinformationstypen und bewährten Methoden finden Sie in Authentication mit der Azure SDK für Go und der Dokumentation zum azidentity-Paket.

Clientpakete und typisierte Clients

Verwaltungspakete befinden sich unter github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/<service>/arm<service>. Installieren Sie das Identitätspaket und nur die Pakete, die Sie arm* verwenden möchten. Wenn Sie beispielsweise nur VMs und Ressourcengruppen verwalten, benötigen armcompute und armresources. Jedes Paket enthält Clients für die Ressourcen in diesem Dienst. Beispielsweise verfügt armcompute über Clients für virtuelle Maschinen, Festplatten, Images und zugehörige Rechenressourcen.

Ein einzelnes Verwaltungspaket enthält häufig mehrere Clients, wobei sich jeder Client auf einen Ressourcentyp oder eine Vorgangsgruppe konzentriert. Zum Beispiel enthält armcompute Clients für virtuelle Maschinen, Datenträger, Images und zugehörige Ressourcen. Nachdem Sie das Paket für einen Dienst ausgewählt haben, erstellen Sie eine Clientfactory, und verwenden Sie es wieder, um die typierten Clients zu erstellen, die den Ressourcen entsprechen, die Sie verwalten möchten.

clientFactory, err := armcompute.NewClientFactory(subscriptionID, cred, nil)
if err != nil {
	return err
}
vmClient := clientFactory.NewVirtualMachinesClient()

Dieses Paket- und Clientfactorymuster ist in allen resourcemanager Modulen konsistent. Es ist eine nützliche Verknüpfung, wenn Sie pkg.go.dev scannen oder einen Agent auffordern, den richtigen Client für eine Aufgabe zu finden.

Zeitintensive Vorgänge

Viele Verwaltungsvorgänge, z. B. das Erstellen von Clustern, das Löschen von Ressourcengruppen und das Aktualisieren der Infrastruktur, werden asynchron ausgeführt. Methoden mit dem Präfix Begin starten die serverseitige Arbeit und geben sofort einen Poller zurück. Ihr Code kann entscheiden, ob gewartet oder andere Aufgaben ausgeführt werden sollen:

// Start an asynchronous operation (returns immediately)
poller, err := client.BeginCreateOrUpdate(ctx, resourceGroupName, parameters, nil)
if err != nil {
	return err
}

// Block until the operation completes or fails
result, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	return err
}

Ein erfolgreicher Begin* Anruf bedeutet nur, dass Azure die Anforderung akzeptiert hat. Der Vorgang kann später noch fehlschlagen, während der Poller ausgeführt wird. Deshalb benötigen sowohl der anfängliche Aufruf als auch PollUntilDone eine Fehlerbehandlung. Verwenden Sie PollUntilDone, wenn Sie den einfachsten Fluss wünschen. Verwenden Sie poller.Poll und poller.Done, wenn Sie eine benutzerdefinierte Wartelogik oder Fortschrittsberichte benötigen.

Weitere Informationen zu Mustern finden Sie in den Common-Verwendungsmustern in Azure SDK für Go.

Fehlerbehandlung

Verwaltungsvorgänge geben strukturierte Fehler zurück, die Sie auf bestimmte Fehlercodes überprüfen können:

import "github.com/Azure/azure-sdk-for-go/sdk/azcore"

// Check if the error is an Azure service error with structured details
var respErr *azcore.ResponseError
if errors.As(err, &respErr) {
	fmt.Printf("Error code: %s\n", respErr.ErrorCode)
	fmt.Printf("Status code: %d\n", respErr.StatusCode)
}

Die meisten CreateOrUpdate Vorgänge sind idempotent. Rufen Sie sie für eine bestehende Ressource auf, wird diese aktualisiert, anstatt einen Fehler zu erzeugen.

Bereitstellen eines Ressourcenbeispiels

Dieses Beispiel zeigt das allgemeine Steuerelementebenenmuster: Authentifizieren, Erstellen einer Ressource mit Tags und Timeout und Überprüfen des Ergebnisses. Verwenden Sie dieses Muster als Vorlage für alle Verwaltungsvorgänge, da das Muster für Anmeldeinformationen, Kontext und Abonnement-ID für alle arm* Clients gilt.

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

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

func main() {
	// Read subscription ID from environment (avoid hardcoding)
	subscriptionID := os.Getenv("AZURE_SUBSCRIPTION_ID")
	if subscriptionID == "" {
		log.Fatal("AZURE_SUBSCRIPTION_ID not set")
	}

	// Create credential that auto-discovers authentication
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to create credential: %v", err)
	}

	// Set a timeout for the entire operation (prevents hanging indefinitely)
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
	defer cancel()

	// Create a client factory for this management package
	clientFactory, err := armresources.NewClientFactory(subscriptionID, cred, nil)
	if err != nil {
		log.Fatalf("failed to create client factory: %v", err)
	}

	// Create the typed client for resource groups
	rgClient := clientFactory.NewResourceGroupsClient()

	// Many ARM models use pointer fields for optional values.
	resp, err := rgClient.CreateOrUpdate(ctx, "example-rg", armresources.ResourceGroup{
		Location: to.Ptr("eastus"),
		Tags: map[string]*string{
			"env":  to.Ptr("dev"),
			"team": to.Ptr("platform"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to create or update resource group: %v", err)
	}

	fmt.Printf("resource group %s ready in %s\n", *resp.Name, *resp.Location)
}

Ressourcengruppen

Das Paket armresources verwaltet Ressourcengruppen – die grundlegenden Organisationscontainer in Azure. Jede Azure Ressource ist innerhalb einer Ressourcengruppe vorhanden, wodurch dies der Ausgangspunkt für jeden Bereitstellungsworkflow ist.

Verwenden Sie sie, um Ressourcengruppen mit Standort und Tags, Listengruppen in einem Abonnement zu erstellen und zu aktualisieren und Gruppen zusammen mit allen enthaltenen Ressourcen zu löschen. Die Ressourcengruppenerstellung ist synchron und idempotent. Das Löschen ist asynchron und dauerhaft.

Das Auflisten von Ressourcengruppen führt auch ein wichtiges Kontrollebene-Muster ein: Viele Lesevorgänge verwenden die Pager-Funktion. Wenn Sie Ressourcengruppen oder andere große ARM-Auflistungen aufzählen, erstellen Sie einen Pager und iterieren Sie, bis pager.More() zurückkehrt false.

pager := rgClient.NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		return err
	}

	for _, group := range page.ResourceGroupListResult.Value {
		fmt.Println(*group.Name)
	}
}

Beispielcode für die Verwaltung von Ressourcengruppen.

Eine Anleitung für die ersten Schritte finden Sie in der armresources-Paketdokumentation.

Virtuelle Computer

Das paket armcompute ist ein kanonisches Beispiel für die Steuerungsebene, da die VM-Verwaltung hauptsächlich Lebenszyklusarbeit ist: Erstellen oder Aktualisieren einer VM, Starten oder Beenden, Ändern der Größe und Löschen. In Go verwenden diese Workflows dasselbe Muster, DefaultAzureCredential, context.Context, und das clientseitige Factorymuster, das im Beispiel der Ressourcengruppe gezeigt wird. Sobald dieses Muster implementiert ist, können Sie es auf Berechnungsoperationen anwenden, ohne Ihren Authentifizierungsansatz zu ändern.

Wenn Sie einen schnellen Ausgangspunkt benötigen, erstellen Sie die Computeclientfactory, und fragen Sie ihn dann nach dem typierten VM-Client:

clientFactory, err := armcompute.NewClientFactory(subscriptionID, cred, nil)
if err != nil {
	return err
}
vmClient := clientFactory.NewVirtualMachinesClient()

Vollständige VM-Beispiele und betriebsspezifische Anleitungen finden Sie in den vorhandenen virtual Machine Management-Beispielen und der armcompute package documentation. Verwenden Sie diese Verweise für vollständige Anforderungsmodelle und ausführliche Vorgangsdetails, anstatt große VM-Vorlagen in diesem Artikel zu duplizieren.

Key Vault

Das paket armkeyvault verwaltet den Lebenszyklus von Azure Key Vault Instanzen. Dieses Paket verwaltet die Steuerebene der Vault-Infrastruktur. Verwenden Sie die separaten azsecrets, azkeys und azcertificates Datenebenenpakete, um Geheimnisse, Schlüssel und Zertifikate zu lesen und zu schreiben.

Verwenden Sie dieses Paket, um Tresore mit den entsprechenden SKU- und Sicherheitseinstellungen bereitzustellen, wie Soft Delete und Schutz gegen Löschung. Sie können auch Zugriffsrichtlinien für Prinzipale verwalten, Netzwerkzugriff und private Endpunkte konfigurieren und die Diagnoseprotokollierung aktivieren. Sie können die Vault-Bereitstellung in Onboarding-Workflows für Anwendungen integrieren.

Key Vault Verwaltungscodebeispiel.

Informationen zu laufzeitseitigen Key Vault Clients finden Sie unter Use the Azure SDK for Go for data plane operations.

Eine Anleitung für die ersten Schritte finden Sie in der Dokumentation zum armkeyvault-Paket.

AKS-Cluster

Das paket armcontainerservice verwaltet Azure Kubernetes Service Cluster während des gesamten Lebenszyklus.

Verwenden Sie dieses Paket, um Cluster mit konfigurierbaren Netzwerken, Kubernetes-Version und verwalteter Identität zu erstellen. Sie können Knotenpools hinzufügen und skalieren, Controlplane- und Knotenversionen aktualisieren sowie Add-Ons wie Azure Policy und Überwachung aktivieren. Zudem können Sie die Clusterintegrität abfragen, um Informationen in Betriebsdashboards darzustellen. Alle Clustervorgänge sind langandauernd und folgen dem Polling-Muster.

AKS-Verwaltungscodebeispiel.

Eine Anleitung für die ersten Schritte finden Sie in der Dokumentation zum armcontainerservice.

RBAC und Autorisierung

Das paket armauthorization verwaltet Azure Role-Based Access Control. Verwenden Sie sie, um Zugriffsrichtlinien mit geringsten Rechten für Abonnements und Ressourcengruppen zu automatisieren.

Verwenden Sie es zum Auflisten und Durchsuchen integrierter Rollen, Zuweisen von Rollen zu Prinzipalen (Benutzer, Dienstprinzipalen, verwaltete Identitäten oder Gruppen) in jedem Bereich, Erstellen von benutzerdefinierten Rollendefinitionen mit differenzierten Berechtigungen und Überwachungszuweisungen für Compliance-Berichte und Drift-Erkennung. Weisen Sie Gruppen anstelle von Einzelpersonen Rollen zu, und verwenden Sie ggf. integrierte Rollen.

Eine Anleitung für die ersten Schritte finden Sie in der Dokumentation zum armauthentifizierungspaket.

Virtuelle Netzwerke und Netzwerksicherheit

Das Paket armnetwork verwaltet Azure virtuelle Netzwerkinfrastruktur.

Verwenden Sie sie, um virtuelle Netzwerke und Subnetze zu erstellen, Netzwerksicherheitsgruppen mit eingehenden und ausgehenden Regeln zu konfigurieren, private Endpunkte für PaaS-Dienste einzurichten, Netzwerk-Peering über Regionen hinweg zu automatisieren und Hub-and-Spoke-Topologien programmgesteuert zu implementieren.

Network-Verwaltungscodebeispiel.

Eine Anleitung für die ersten Schritte finden Sie in der Dokumentation zum armnetwork-Paket.

Containerregistrierung

Das armcontainerregistry-Paket verwaltet Azure Container Registry Instanzen.

Verwenden Sie sie, um Registrierungen mit der entsprechenden SKU und Georeplikation bereitzustellen, die Authentifizierung (Administrator, Dienstprinzipal oder verwaltete Identität) zu konfigurieren, Webhooks für CI/CD zu verwalten, Sicherheitsrisikoüberprüfungen zu aktivieren und Aufbewahrungsrichtlinien auf Bilder anzuwenden. Sie verwenden die Containerregistrierung häufig zusammen mit Azure Kubernetes Service. Stellen Sie zunächst die Registrierung bereit, und verweisen Sie dann während der Clustererstellung darauf.

Container-Registry-Verwaltungscode-Beispiel

Eine Anleitung für die ersten Schritte finden Sie in der Dokumentation zum armcontainerregistry-Paket.

Speicherkonten

Das paket armstorage verwaltet Azure Storage Konten.

Verwenden Sie sie, um Speicherkonten mit der richtigen Leistungsstufe und Redundanz zu erstellen, Zugriffsschlüssel und freigegebene Zugriffssignaturen zu verwalten, Blob-Lebenszyklusrichtlinien zu konfigurieren und die Diagnoseprotokollierung einzurichten. Speicherkonten sind eine häufige Abhängigkeit für viele Anwendungen, sodass die Automatisierung ihrer Bereitstellung und Konfiguration ein gängiges Szenario für die Steuerungsebene ist.

Beispiel für einen Code zur Verwaltung von Speicherkonten.

Eine Anleitung für die ersten Schritte finden Sie in der Dokumentation zum armstorage-Paket.

Nächste Schritte

• Overview der Azure SDK für Go-Verwaltungsbibliotheken
• Verwenden Sie das Azure SDK für Vorgänge auf der Datenebene
• Azure SDK für die Go-Authentifizierung
• Azure SDK für Go Beispiele auf GitHub