Dela via

Använd Azure SDKs för Go för kontrollplansåtgärder

Lär dig hur du etablerar, konfigurerar och hanterar Azure resurser programmatiskt med hjälp av Azure SDKs för Go-hanteringsbibliotek. Vanliga arbetsflöden för kontrollplan är att skapa resursgrupper, hantera lagrings- och nätverksinfrastruktur och hantera livscykelåtgärder för virtuella datorer (VM), till exempel skapa, starta, stoppa, ändra storlek på, uppdatera och ta bort. Om du vill ha en introduktion på högre nivå till hur hanteringsbibliotek passar in i Azure SDKs för Go börjar du med Översikt av Azure SDKs för Go-hanteringsbibliotek. Den här artikeln fokuserar på Go-kontrollplansmönster som du återanvänder mellan tjänster och länkar till vägledning för dataplanet när körvägen flyttas från resurshantering till arbete med tjänstdata.

Vad är Azure kontrollplan?

Det Azure kontrollplanet är den uppsättning API:er som styr livscykeln för Azure resurser – skapa, uppdatera, konfigurera och ta bort dem. Varje åtgärd som du utför i Azure-portalen, Azure CLI eller infrastruktur-som-kod-verktyg anropar i slutändan dessa kontrollplans-API:er.

Azure SDKs för Go exponerar kontrollplanet via en familj med arm*-paket under github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/. Varje paket mappar till en Azure resursprovider och följer ett konsekvent mönster:

  1. Autentisera azidentity med hjälp av paketet.
  2. Skapa en typad klient för den resurs som du vill hantera.
  3. Anropa metoder på klienten för att skapa, läsa, uppdatera eller ta bort resurser.
  4. Hantera långvariga åtgärder med hjälp av pollers.

Vanliga scenarier för automatisering av kontrollplanen i Go inkluderar:

  • Etableringsinfrastruktur för distributionspipelines
  • Hantera livscykelåtgärder för virtuella datorer, till exempel skapa, uppdatera, ta bort, starta, stoppa och ändra storlek på
  • Skapa anpassade CLI:er och operatörer för plattformsteam
  • Implementera infrastrukturavstämning i GitOps-stil
  • Automatisering av efterlevnadsgranskning och avdriftsidentifiering

Authentication

Alla hanteringsåtgärder kräver en autentiserad autentiseringsuppgift från paketet azidentity. Paketet innehåller autentiseringstyper för varje miljö, inklusive lokal utveckling, CI/CD-pipelines och produktionsarbetsbelastningar som körs i Azure. Alla typer av autentiseringsuppgifter implementerar samma azcore.TokenCredential gränssnitt så att du kan växla dem utan att ändra klientkoden.

När du har fått en autentiseringstoken, skapa en klientfabrik för paketbiblioteket och be den sedan om den specificerade klienten som du behöver.

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

Aktuella arm* paketdokument visar vanligtvis klientfabriksmönstret eftersom det centraliserar delad konfiguration för relaterade klienter. Många paket exponerar även direktkonstruktorer New<ResourceType>Client(subscriptionID, credential, options), men NewClientFactory(...).New<ResourceType>Client() är det mönster du oftast ser på pkg.go.dev. För lokal utveckling hämtar DefaultAzureCredential vanligtvis din Azure CLI inloggning. I CI/CD och distribuerade arbetsbelastningar kan du växla till miljöbaserade autentiseringsuppgifter eller hanterad identitet utan att ändra resten av klientkoden.

En fullständig guide om behörighetstyper och bästa praxis finns i Authentication with the Azure SDKs for Go och dokumentationen för azidentity-paketet.

Klientpaket och inskrivna klienter

Hanteringspaket finns under github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/<service>/arm<service>. Installera identitetspaketet och endast de arm* paket som du planerar att använda. Om du till exempel bara hanterar virtuella datorer och resursgrupper behöver du bara armcompute och armresources. Varje paket innehåller klienter för resurserna i den tjänsten. Till exempel armcompute har klienter för virtuella datorer, diskar, avbildningar och relaterade beräkningsresurser.

Ett enda hanteringspaket innehåller ofta flera klienter, där varje klient fokuserar på en resurstyp eller åtgärdsgrupp. Till exempel omfattar armcompute klienter för virtuella maskiner, diskar, avbildningar och relaterade resurser. När du har valt paketet för en tjänst skapar du en klientfabrik och återanvänder den för att skapa de inskrivna klienter som matchar de resurser som du vill hantera.

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

Det här paket- och klientfabriksmönstret är konsekvent i modulerna resourcemanager . Det är en användbar genväg när du skannar pkg.go.dev eller ber en agent att hitta rätt klient för en uppgift.

Tidskrävande åtgärder

Många hanteringsåtgärder, till exempel att skapa kluster, ta bort resursgrupper och uppgradera infrastruktur, körs asynkront. Metoder som inleds med Begin startar arbetet på serversidan och returnerar omedelbart en poller. Koden kan avgöra om du vill vänta eller fortsätta utföra annat arbete:

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

Ett lyckat Begin*-anrop innebär bara att Azure accepterade begäran. Åtgärden kan fortfarande misslyckas senare medan pollern körs. Det är därför både det första anropet och PollUntilDone behöver felhantering. Använd PollUntilDone när du vill ha det enklaste flödet. Använd poller.Poll och poller.Done när du behöver anpassad väntelogik eller förloppsrapportering.

Mer information om mönster finns i användningsmönstren Common i Azure SDKs för Go.

Felhantering

Hanteringsåtgärder returnerar strukturerade fel som du kan kontrollera efter specifika felkoder:

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 flesta CreateOrUpdate åtgärder är idempotenta. Om du anropar dem på en befintlig resurs uppdateras resursen i stället för att misslyckas.

Etablera ett resursexempel

Det här exemplet visar det vanliga kontrollplanets mönster: autentisera, skapa en resurs med taggar och timeout och kontrollera resultatet. Använd det här mönstret som en mall för alla hanteringsåtgärder eftersom mönstret för autentiseringsuppgifter, kontext och prenumerations-ID gäller för alla arm* klienter.

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

Resursgrupper

Paketet armresources hanterar resursgrupper – de grundläggande organisationscontainrarna i Azure. Varje Azure resurs finns i en resursgrupp, vilket gör detta till startpunkten för alla etableringsarbetsflöden.

Använd den för att skapa och uppdatera resursgrupper med plats och taggar, lista grupper i en prenumeration och ta bort grupper tillsammans med alla inneslutna resurser. Skapande av resursgrupper är synkront och idempotent. Borttagningen är asynkron och permanent.

En lista över resursgrupper introducerar också ett viktigt kontrollplansmönster: många läsåtgärder använder pagers. När du räknar upp resursgrupper eller andra stora ARM-samlingar skapar du en sidsökare och itererar tills pager.More() returnerar 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)
	}
}

Resource-kodexempel för grupphantering.

För en guide för att komma igång, se dokumentationen för paketet armresources.

Virtuella datorer

paketet armcompute är ett kanoniskt kontrollplansexempel eftersom VM-hanteringen främst är livscykelarbete: skapa eller uppdatera en virtuell dator, starta eller stoppa den, ändra storlek på den och ta bort den. I Go använder dessa arbetsflöden samma DefaultAzureCredential, context.Contextoch klientfabriksmönster som visas i resursgruppsexemplet, så när det mönstret är på plats kan du tillämpa det i beräkningsåtgärder utan att ändra din autentiseringsmetod.

Om du behöver en snabb startpunkt skapar du beräkningsklientfabriken och ber den sedan om den typerade VM-klienten:

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

Fullständiga VM-exempel och åtgärdsspecifik vägledning finns i de befintliga prover för hantering av virtuella maskiner och armcompute-paketdokumentationen. Använd dessa referenser för fullständiga begärandemodeller och tidskrävande åtgärdsinformation i stället för att duplicera stora VM-mallar i den här artikeln.

Nyckelvalv

Paketet armkeyvault hanterar livscykeln för Azure Key Vault instanser. Det här paketet hanterar kontrollplanet för valvets infrastruktur. Använd de separata azsecrets, azkeys, och azcertificates dataplanepaketen för att läsa och skriva säkerhetsdata, nycklar och certifikat.

Använd det här paketet för att etablera valv med lämpliga SKU- och säkerhetsinställningar, till exempel skydd för mjuk borttagning och rensning. Du kan också hantera åtkomstprinciper för huvudkonton, konfigurera nätverksåtkomst och privata slutpunkter och aktivera diagnostikloggning. Du kan integrera vault-provisionering i arbetsflöden för applikationsintroduktion.

Key Vault exempel på hanteringskod.

Information om Key Vault-klienter under körning finns i Använd Azure SDKs för Go för operationer på dataplanet.

En komma igång-guide finns i armkeyvault-paketdokumentationen.

AKS-kluster

Paketet armcontainerservice hanterar Azure Kubernetes Service kluster under hela livscykeln.

Använd det här paketet för att skapa kluster med konfigurerbara nätverk, Kubernetes-version och hanterad identitet. Du kan lägga till och skala nodpooler, uppgradera kontrollplans- och nodversioner, aktivera tillägg som Azure Policy och övervakning samt fråga klusterhälsa för operativa instrumentpaneler. Alla klusteråtgärder är långvariga och följer pollermönstret.

AKS-hanteringskodexempel.

En komma igång-guide finns i dokumentationen armcontainerservice package.

RBAC och auktorisering

Paketet armauthorization hanterar Azure Role-Based Access Control. Använd den för att automatisera principer för åtkomst med lägsta behörighet mellan prenumerationer och resursgrupper.

Använd den för att visa och söka i inbyggda roller, tilldela roller till huvudprincipaler (användare, tjänstprincipaler, hanterade identiteter eller grupper) i alla omfång, skapa anpassade rolldefinitioner med detaljerade behörigheter och granska tilldelningar för efterlevnadsrapportering och identifiering av förändringar. Tilldela roller till grupper i stället för enskilda användare och använd inbyggda roller där det är möjligt.

En komma igång-guide finns i dokumentationen armauthorization package.

Virtuella nätverk och nätverkssäkerhet

Paketet armnetwork hanterar Azure infrastruktur för virtuella nätverk.

Använd den för att skapa virtuella nätverk och undernät, konfigurera nätverkssäkerhetsgrupper med regler för inkommande och utgående trafik, konfigurera privata slutpunkter för PaaS-tjänster, automatisera nätverkspeering mellan regioner och implementera hub-and-spoke-topologier programmatiskt.

Nätverkshanteringskodexempel.

En komma igång-guide finns i dokumentationen om armnetwork-paket.

Container-registertjänst

paketet armcontainerregistry hanterar Azure Container Registry instanser.

Använd den för att etablera register med lämplig SKU och geo-replikering, konfigurera autentisering (administratör, tjänstens huvudnamn eller hanterad identitet), hantera webhooks för CI/CD, aktivera sårbarhetsgenomsökning och tillämpa kvarhållningsprinciper på bilder. Du använder ofta Container Registry tillsammans med Azure Kubernetes Service. Först etablerar du registret och refererar sedan till det när klustret skapas.

Exempelkod för hantering av Container Registry.

En komma igång-guide finns i dokumentationen armcontainerregistry package.

Lagringskonton

Paketet armstorage hanterar Azure Storage konton.

Använd den för att skapa lagringskonton med rätt prestandanivå och redundans, hantera åtkomstnycklar och signaturer för delad åtkomst, konfigurera principer för bloblivscykel och konfigurera diagnostikloggning. Lagringskonton är ett vanligt beroende för många program, så att automatisera etableringen och konfigurationen av dem är ett vanligt scenario med kontrollplan.

Lagringskontohanteringskodexempel.

En komma igång-guide finns i dokumentationen armstorage-paket.

Nästa steg

  • Last updated on