Gebruik de Azure SDK voor Go voor besturingsvlakbewerkingen

Meer informatie over het programmatisch inrichten, configureren en beheren van Azure resources met behulp van de Azure SDK voor Go-beheerbibliotheken. Algemene besturingsvlakwerkstromen zijn het maken van resourcegroepen, het beheren van de opslag- en netwerkinfrastructuur en het verwerken van levenscyclusbewerkingen voor virtuele machines (VM's), zoals maken, starten, stoppen, verkleinen, bijwerken en verwijderen. Als u een introductie op hoger niveau wilt over hoe beheerbibliotheken bij de Azure SDK voor Go passen, begint u met Overzicht van de Azure SDK voor Go-beheerbibliotheken. Dit artikel richt zich op de Go-besturingsvlakpatronen die u hergebruikt in diverse services en bevat koppelingen naar richtlijnen voor gegevensvlakken wanneer het runtimepad verschuift van resourcebeheer naar samenwerking met servicegegevens.

Wat is het Azure besturingsvlak?

Het Azure besturingsvlak is de set API's waarmee de levenscyclus van Azure resources wordt bepaald: ze maken, bijwerken, configureren en verwijderen. Elke bewerking die u uitvoert in de Azure-portal, Azure CLI of hulpprogramma voor infrastructuur als code, roept uiteindelijk deze API's voor het besturingsvlak aan.

De Azure SDK voor Go toont het besturingsvlak via een familie van arm* pakketten onder github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/. Elk pakket wordt toegewezen aan een Azure resourceprovider en volgt een consistent patroon:

1. Verifieer met behulp van het azidentity pakket.
2. Maak een getypte client voor de resource die u wilt beheren.
3. Roep methoden op de client aan om resources te maken, te lezen, bij te werken of te verwijderen.
4. Langlopende bewerkingen afhandelen met behulp van pollers.

Veelvoorkomende scenario's voor Go-controlevlakautomatisering zijn:

• Inrichtingsinfrastructuur voor implementatiepijplijnen
• Levenscyclusbewerkingen voor VM's beheren, zoals maken, bijwerken, verwijderen, starten, stoppen en het formaat ervan wijzigen
• Aangepaste CLIS's en operators bouwen voor platformteams
• Infrastructuurafstemming in GitOps-stijl implementeren
• Nalevingscontrole en driftdetectie automatiseren

Authentication

Voor alle beheerbewerkingen is een geauthenticeerde referentie vereist uit het pakket azidentity. Het pakket biedt referentietypen voor elke omgeving, waaronder lokale ontwikkeling, CI/CD-pijplijnen en productieworkloads die worden uitgevoerd in Azure. Alle referentietypen implementeren dezelfde azcore.TokenCredential interface, zodat u deze kunt wisselen zonder clientcode te wijzigen.

Nadat u een referentie hebt ontvangen, maakt u een client-fabriek voor het pakket en vraagt u vervolgens om de gespecificeerde client die u nodig hebt.

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

In de huidige arm* pakketdocumenten wordt meestal het patroon van de clientfactory weergegeven, omdat hiermee de gedeelde configuratie voor gerelateerde clients wordt gecentraliseerd. Veel pakketten bieden ook directe New<ResourceType>Client(subscriptionID, credential, options) constructors weer, maar NewClientFactory(...).New<ResourceType>Client() dit is het patroon dat u het vaakst zult zien op pkg.go.dev. Voor lokale ontwikkeling neemt DefaultAzureCredential meestal uw Azure CLI aanmelding op. In CI/CD en geïmplementeerde workloads kunt u overschakelen naar omgevingsreferenties of beheerde identiteit zonder de rest van uw clientcode te wijzigen.

Zie Authentication with the Azure SDK for Go and the azidentity package documentation voor een volledige handleiding over referentietypen en aanbevolen procedures.

Clientpakketten en typegespecificeerde clients

Beheerpakketten vallen onder github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/<service>/arm<service>. Installeer het identiteitspakket en alleen de arm* pakketten die u wilt gebruiken. Als u bijvoorbeeld alleen VM's en resourcegroepen beheert, hebt u alleen armcomputearmresources nodig. Elk pakket bevat clients voor de resources in die service. armcompute heeft bijvoorbeeld cliënten voor virtuele machines, schijven, installatiekopieën en gerelateerde rekenresources.

Eén beheerpakket bevat vaak meerdere clients, waarbij elke client zich richt op één resourcetype of bewerkingsgroep. Omvat bijvoorbeeld armcompute clientsoftware voor virtuele machines, schijven, afbeeldingen en gerelateerde resources. Nadat u het pakket voor een service hebt gekozen, maakt u één client-factory en hergebruikt u deze om de getypeerde clients te maken die passen bij de resources die u wilt beheren.

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

Dit pakket- en klant-fabriekspatroon is consistent in de resourcemanager modules. Het is een handige snelkoppeling wanneer u pkg.go.dev scant of een agent vraagt om de juiste client voor een taak te vinden.

Langlopende bewerkingen

Veel beheerbewerkingen, zoals het maken van clusters, het verwijderen van resourcegroepen en het upgraden van de infrastructuur, worden asynchroon uitgevoerd. Methoden die voorafgegaan worden door Begin starten het werk aan de serverzijde en keren onmiddellijk een poller terug. Uw code kan bepalen of u wilt wachten of ander werk wilt blijven doen:

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

Een geslaagde Begin* oproep betekent alleen dat Azure de aanvraag heeft geaccepteerd. De bewerking kan later nog steeds mislukken terwijl de poller actief is. Daarom hebben zowel de eerste aanroep als PollUntilDone foutafhandeling nodig. Gebruik PollUntilDone wanneer u de eenvoudigste stroom wilt. Gebruik poller.Poll en poller.Done wanneer u aangepaste wachtlogica of voortgangsrapportage nodig hebt.

Zie de Common-gebruikspatronen in Azure SDK voor Go voor meer informatie over patronen.

Foutafhandeling

Beheerbewerkingen retourneren gestructureerde fouten die u kunt controleren op specifieke foutcodes:

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

De meeste CreateOrUpdate bewerkingen zijn idempotent. Wanneer ze op een bestaande resource worden aangeroepen, wordt de resource bijgewerkt in plaats van te falen.

Een resourcevoorbeeld inrichten

In dit voorbeeld ziet u het algemene besturingsvlakpatroon: verifiëren, een resource maken met tags en time-outs en het resultaat controleren. Gebruik dit patroon als sjabloon voor alle beheerbewerkingen omdat het patroon referentie, context en abonnements-id van toepassing is op alle arm* clients.

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

Resourcegroepen

Het pakket armresources beheert resourcegroepen: de fundamentele organisatiecontainers in Azure. Elke Azure resource bestaat in een resourcegroep, waardoor dit het startpunt is voor elke inrichtingswerkstroom.

Gebruik het om resourcegroepen te maken en bij te werken met locatie en tags, groepen binnen een abonnement op te sommen en groepen samen met alle ingesloten resources te verwijderen. Het maken van resourcegroepen is synchroon en idempotent. Verwijdering wordt asynchroon uitgevoerd en is permanent.

Het vermelden van resourcegroepen zorgt ook voor een belangrijk control-plane patroon: veel leesbewerkingen maken gebruik van pagers. Wanneer u resourcegroepen of andere grote ARM-verzamelingen opsomt, maakt u een pager en blijft u deze doorlopen totdat pager.More() geretourneerd wordt 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)
	}
}

Codevoorbeeld voor resourcegroepbeheer.

Zie de documentatie armresources-pakketdocumentatie voor een introductiehandleiding.

Virtuele machines

Het pakket armcompute is een canoniek besturingsvlakvoorbeeld omdat VM-beheer voornamelijk levenscycluswerk is: een virtuele machine maken of bijwerken, starten of stoppen, het formaat ervan wijzigen en verwijderen. In Go gebruiken deze werkstromen hetzelfde DefaultAzureCredential- en context.Context, en het client-factorypatroon dat is weergegeven in het resourcegroepenvoorbeeld. Eenmaal ingesteld, kunt u dit patroon toepassen op rekenbewerkingen zonder uw authenticatiebenadering te wijzigen.

Als u een snel startpunt nodig hebt, maakt u de rekenclientfactory en vraagt u deze vervolgens om de getypte VM-client:

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

Zie de bestaande virtual machine management samples and the armcompute package documentation voor volledige VM-voorbeelden en bewerkingsspecifieke richtlijnen. Gebruik deze verwijzingen voor volledige aanvraagmodellen en langlopende bewerkingsgegevens in plaats van grote VM-sjablonen in dit artikel te dupliceren.

Key Vault

Het pakket armkeyvault beheert de levenscyclus van Azure Key Vault exemplaren. Dit pakket beheert het controlevlak voor de Vault-infrastructuur. Gebruik de afzonderlijke azsecretspakketten en azkeysazcertificates gegevensvlakpakketten om geheimen, sleutels en certificaten te lezen en te schrijven.

Gebruik dit pakket om kluizen in te richten met de juiste SKU en beveiligingsinstellingen, zoals tijdelijk verwijderen en opruimbeveiliging. U kunt ook toegangsbeleid voor principals beheren, netwerktoegang en privé-eindpunten configureren en diagnostische logboekregistratie inschakelen. U kunt kluisvoorziening integreren in de onboarding-werkstromen van toepassingen.

Key Vault voorbeeld van beheercode.

Zie Gebruik de Azure SDK voor Go voor gegevensvlakbewerkingen voor runtime Key Vault-clients.

Zie de documentatie armkeyvault-pakket voor een introductiehandleiding.

AKS-clusters

Het pakket armcontainerservice beheert Azure Kubernetes Service clusters gedurende hun volledige levenscyclus.

Gebruik dit pakket om clusters te maken met configureerbare netwerken, Kubernetes-versie en beheerde identiteit. U kunt knooppuntgroepen toevoegen en schalen, besturingsvlak- en knooppuntversies upgraden, invoegtoepassingen zoals Azure Policy en bewaking inschakelen en de status van het cluster opvragen voor operationele dashboards. Alle clusterbewerkingen worden langdurig uitgevoerd en volgen het poller-patroon.

AKS-beheercodevoorbeeld.

Zie de documentatie armcontainerservice-pakketdocumentatie voor een introductiehandleiding.

RBAC en autorisatie

Het pakket armauthorization beheert Azure Role-Based Access Control. Gebruik deze om toegangsbeleid met minimale bevoegdheden voor abonnementen en resourcegroepen te automatiseren.

Gebruik het om ingebouwde rollen te weergeven en te doorzoeken, rollen toe te wijzen aan principals (gebruikers, service principals, beheerde identiteiten of groepen) binnen elke scope, aangepaste roldefinities met fijnmazige machtigingen te creëren, en auditopdrachten uit te voeren voor nalevingsrapportage en detectie van afwijkingen. Wijs rollen toe aan groepen in plaats van personen en gebruik waar mogelijk ingebouwde rollen.

Zie de documentatie armauthorization package voor een introductiehandleiding.

Virtuele netwerken en netwerkbeveiliging

Het pakket armnetwork beheert Azure virtuele netwerkinfrastructuur.

Gebruik dit om virtuele netwerken en subnetten te maken, netwerkbeveiligingsgroepen te configureren met inkomende en uitgaande regels, privé-eindpunten in te stellen voor PaaS-services, netwerkpeering tussen regio's te automatiseren en hub-and-spoke-topologieën programmatisch te implementeren.

Netwerkbeheer voorbeeldcode.

Zie de documentatie voor het armnetwork-pakket voor een introductiehandleiding.

Containerregistratie

Het pakket armcontainerregistry beheert Azure Container Registry exemplaren.

Gebruik dit om registers in te richten met de juiste SKU en geo-replicatie, verificatie te configureren (beheerder, service-principal of beheerde identiteit), webhooks voor CI/CD te beheren, scannen van beveiligingsproblemen in te schakelen en bewaarbeleid toe te passen op installatiekopieën. Vaak gebruikt u Container Registry naast Azure Kubernetes Service. Richt eerst het register in en verwijs ernaar tijdens het maken van het cluster.

Container Registry-beheercodevoorbeeld.

Zie de documentatie armcontainerregistry-pakket voor een introductiehandleiding.

Opslagrekeningen

Het pakket armstorage beheert Azure Storage accounts.

Gebruik deze om opslagaccounts te maken met de juiste prestatielaag en redundantie, toegangssleutels en handtekeningen voor gedeelde toegang te beheren, levenscyclusbeleid voor blobs te configureren en diagnostische logboekregistratie in te stellen. Opslagaccounts zijn een veelvoorkomende afhankelijkheid voor veel toepassingen, dus het automatiseren van hun provisioning en configuratie is een gebruikelijk besturingsvlak scenario.

Voorbeeldcode voor opslagaccountbeheer.

Zie de documentatie armstorage-pakket voor een introductiehandleiding.

Volgende stappen 

• Overview van de Azure SDK voor Go-beheerbibliotheken
• Gebruik de Azure SDK voor Go voor bewerkingen in het gegevensvlak
• Azure SDK voor Go-verificatie
• Azure SDK voor Go-voorbeelden op GitHub