Partager via

Utiliser l'Kit de développement logiciel (SDK) Azure pour Go pour les opérations de plan de contrôle

Découvrez comment provisionner, configurer et gérer des ressources Azure par programmation à l’aide des Kit de développement logiciel (SDK) Azure pour les bibliothèques de gestion Go. Les flux de travail courants du plan de contrôle incluent la création de groupes de ressources, la gestion de l’infrastructure de stockage et de mise en réseau et la gestion des opérations de cycle de vie des machines virtuelles telles que la création, le démarrage, l’arrêt, le redimensionnement, la mise à jour et la suppression. Si vous souhaitez l’introduction de niveau supérieur à la façon dont les bibliothèques de gestion s’intègrent dans la Kit de développement logiciel (SDK) Azure pour Go, commencez par Overview des bibliothèques de gestion Kit de développement logiciel (SDK) Azure pour Go. Cet article se concentre sur les modèles de plan de contrôle Go que vous réutilisez entre les services et les liens vers des instructions de plan de données lorsque le chemin d’exécution passe de la gestion des ressources à l’utilisation des données de service.

Qu’est-ce que le plan de contrôle Azure ?

Le plan de contrôle Azure est l’ensemble d’API qui contrôlent le cycle de vie des ressources Azure , en créant, en mettant à jour, en configurant et en les supprimant. Chaque opération que vous effectuez dans le portail Azure, Azure CLI ou l’outil infrastructure-as-code appelle finalement ces API de plan de contrôle.

Le Kit de développement logiciel (SDK) Azure pour Go expose le plan de contrôle via une famille de packages arm* sous github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/. Chaque package est mappé à un fournisseur de ressources Azure et suit un modèle cohérent :

  1. Authentifiez-vous à l’aide du azidentity package.
  2. Créez un client typé pour la ressource que vous souhaitez gérer.
  3. Appelez des méthodes sur le client pour créer, lire, mettre à jour ou supprimer des ressources.
  4. Gérez les opérations de longue durée à l’aide des pollers.

Les scénarios courants pour l’automatisation du plan de contrôle Go sont les suivants :

  • Infrastructure d’approvisionnement pour les pipelines de déploiement
  • Gestion des opérations de cycle de vie des machines virtuelles telles que la création, la mise à jour, la suppression, le démarrage, l’arrêt et le redimensionnement
  • Création d'interfaces en ligne de commande et d'opérateurs personnalisés pour les équipes de plateforme
  • Implémentation de la réconciliation de l'infrastructure de type GitOps
  • Automatisation de l’audit de conformité et de la détection de dérive

Authentification

Toutes les opérations de gestion nécessitent des informations d’identification authentifiées à partir du package azidentity. Le package fournit des types d’informations d’identification pour chaque environnement, notamment le développement local, les pipelines CI/CD et les charges de travail de production s’exécutant dans Azure. Tous les types d’informations d’identification implémentent la même azcore.TokenCredential interface. Vous pouvez donc les échanger sans modifier le code client.

Une fois que vous avez obtenu des informations d’identification, créez une fabrique de client pour le package, puis demandez-lui le client typé dont vous avez besoin :

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

Les documents de package actuels arm* affichent généralement le modèle de fabrique du client, car il centralise la configuration partagée pour les clients associés. De nombreux packages exposent également des constructeurs directs New<ResourceType>Client(subscriptionID, credential, options) , mais NewClientFactory(...).New<ResourceType>Client() il s’agit du modèle que vous verrez le plus souvent sur pkg.go.dev. Pour le développement local, DefaultAzureCredential récupère généralement votre connexion Azure CLI. Dans CI/CD et les charges de travail déployées, vous pouvez basculer vers des informations d’identification basées sur l’environnement ou une identité managée sans modifier le reste de votre code client.

Pour obtenir un guide complet sur les types d’informations d’identification et les bonnes pratiques, consultez Authentication avec la Kit de développement logiciel (SDK) Azure pour Go et la documentation du package azidentity.

Packages clients et clients typés

Les packages de gestion sont sous github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/<service>/arm<service>. Installez le package d’identité et uniquement les arm* packages que vous envisagez d’utiliser. Par exemple, si vous gérez uniquement des machines virtuelles et des groupes de ressources, vous avez uniquement besoin armcompute et armresources. Chaque package contient des clients pour les ressources de ce service. Par exemple, armcompute a des clients pour les machines virtuelles, les disques, les images et les ressources de calcul associées.

Un package de gestion unique contient souvent plusieurs clients, chaque client se concentrant sur un type de ressource ou un groupe d’opérations. Par exemple, armcompute inclut des clients pour les machines virtuelles, les disques, les images et les ressources associées. Après avoir choisi le package d’un service, créez une fabrique de clients et réutilisez-la pour créer les clients à type qui correspondent aux ressources que vous souhaitez gérer.

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

Ce modèle de fabrique de package et de client est cohérent entre les resourcemanager modules. Il s’agit d’un raccourci utile lorsque vous analysez pkg.go.dev ou demandez à un agent de trouver le client approprié pour une tâche.

Opérations de longue durée

De nombreuses opérations de gestion, telles que la création de clusters, la suppression de groupes de ressources et la mise à niveau de l’infrastructure, s’exécutent de manière asynchrone. Les méthodes précédées de Begin démarrent le travail côté serveur et retournent immédiatement un sondeur. Votre code peut décider d’attendre ou de continuer à effectuer d’autres tâches :

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

Un appel réussi Begin* signifie uniquement qu'Azure a accepté la demande. L’opération peut toujours échouer plus tard pendant l’exécution du sondeur. C’est pourquoi l’appel initial et PollUntilDone nécessitent une gestion des erreurs. Utilisez PollUntilDone quand vous souhaitez utiliser le flux le plus simple. Utilisez poller.Poll et poller.Done quand vous avez besoin d’une logique d’attente personnalisée ou d’un rapport de progression.

Pour plus d’informations sur les modèles, consultez les modèles d’utilisation Common dans Kit de développement logiciel (SDK) Azure pour Go.

Gestion des erreurs

Les opérations de gestion retournent des erreurs structurées que vous pouvez inspecter pour des codes d’erreur spécifiques :

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

La plupart des opérations CreateOrUpdate sont idempotentes. Appeler une ressource existante met à jour cette dernière plutôt que d’échouer.

Provisionner un exemple de ressource

Cet exemple montre le modèle de plan de contrôle commun : authentifiez, créez une ressource avec des balises et un délai d’expiration, puis vérifiez le résultat. Utilisez ce modèle comme modèle pour toutes les opérations de gestion, car les informations d’identification, le contexte et le modèle d’ID d’abonnement s’appliquent à tous les 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)
}

Groupes de ressources

Le package armresources gère les groupes de ressources , les conteneurs organisationnels fondamentaux dans Azure. Chaque Azure ressource existe au sein d’un groupe de ressources, ce qui en fait le point de départ de tout flux de travail d’approvisionnement.

Utilisez-le pour créer et mettre à jour des groupes de ressources avec des emplacements et des balises, répertorier des groupes dans un abonnement et supprimer des groupes, ainsi que toutes les ressources contenues. La création d’un groupe de ressources est synchrone et idempotente. La suppression est asynchrone et permanente.

La liste des groupes de ressources introduit également un modèle de plan de contrôle important : de nombreuses opérations de lecture utilisent des pagineurs. Lorsque vous énumérez des groupes de ressources ou d'autres grandes collections ARM, créez un pagineur et itérez jusqu'à ce que pager.More() renvoie 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)
	}
}

exemple de code de gestion de groupe Resource.

Pour obtenir un guide de prise en main, consultez la documentation du package armresources.

Machines virtuelles

Le package armcompute est un exemple de plan de contrôle canonique, car la gestion des machines virtuelles est principalement un travail de cycle de vie : créer ou mettre à jour une machine virtuelle, le démarrer ou l’arrêter, le redimensionner et le supprimer. Dans Go, ces workflows utilisent le même modèle de fabrique de client DefaultAzureCredential et context.Context montré dans l'exemple de groupe de ressources. Une fois ce modèle en place, vous pouvez l'appliquer aux opérations de calcul sans modifier votre approche d'authentification.

Si vous avez besoin d’un point de départ rapide, créez la fabrique du client de calcul, puis demandez-lui le client de machine virtuelle typée :

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

Pour obtenir des exemples complets de machines virtuelles et des instructions spécifiques aux opérations, consultez les exemples de gestion des machines virtuelles virtual et la documentation du package armcompute. Utilisez ces références pour les modèles de requête complets et les détails de l’opération longue au lieu de dupliquer des modèles de machines virtuelles volumineux dans cet article.

Key Vault

Le package armkeyvault gère le cycle de vie des instances de Azure Key Vault. Ce package gère le plan de contrôle pour l'infrastructure Vault. Utilisez les packages distincts de plan de données azsecrets, azkeys et azcertificates pour lire et écrire des secrets, des clés et des certificats.

Utilisez ce package pour approvisionner des coffres avec les SKU et les paramètres de sécurité appropriés, tels que la suppression réversible et la protection contre la purge. Vous pouvez également gérer les stratégies d’accès pour les principaux, configurer l’accès réseau et les points de terminaison privés et activer la journalisation des diagnostics. Vous pouvez intégrer le provisionnement de coffre dans les workflows d’intégration d’applications.

exemple de code de gestion Key Vault.

Pour les clients Key Vault côté runtime, consultez Utilisez la Kit de développement logiciel (SDK) Azure pour les opérations de plan de données.

Pour obtenir un guide de prise en main, consultez la documentation du package armkeyvault.

Clusters AKS

Le package armcontainerservice gère les clusters Azure Kubernetes Service dans leur cycle de vie complet.

Utilisez ce package pour créer des clusters avec une mise en réseau configurable, une version Kubernetes et une identité managée. Vous pouvez ajouter et mettre à l’échelle des pools de nœuds, mettre à niveau le plan de contrôle et les versions de nœud, activer des modules complémentaires tels que Azure Policy et surveiller et interroger l’intégrité du cluster pour les tableaux de bord opérationnels. Toutes les opérations de cluster sont longues et suivent le modèle d’interrogation.

exemple de code de gestion AKS.

Pour obtenir un guide de prise en main, consultez la documentation du package armcontainerservice.

RBAC et autorisation

Le package armauthorization gère Azure Role-Based Access Control. Utilisez-la pour automatiser les stratégies d’accès au privilège minimum entre les abonnements et les groupes de ressources.

Utilisez-le pour répertorier et rechercher des rôles intégrés, attribuer des rôles à des principaux (utilisateurs, principaux de service, identités managées ou groupes) dans n’importe quelle étendue, créer des définitions de rôle personnalisées avec des autorisations affinées et auditer les affectations pour la création de rapports de conformité et la détection de dérive. Attribuez des rôles à des groupes plutôt qu’à des individus et utilisez des rôles intégrés lorsque c'est possible.

Pour obtenir un guide de prise en main, consultez la documentation du package armauthorization.

Réseaux virtuels et sécurité réseau

Le package armnetwork gère Azure infrastructure de mise en réseau virtuelle.

Utilisez-le pour créer des réseaux virtuels et des sous-réseaux, configurer des groupes de sécurité réseau avec des règles entrantes et sortantes, configurer des points de terminaison privés pour les services PaaS, automatiser le peering réseau entre les régions et implémenter des topologies hub-and-spoke par programmation.

exemple de code de gestion de réseau.

Pour obtenir un guide de prise en main, consultez la documentation du package armnetwork.

Registre de conteneurs

Le package armcontainerregistry gère les instances Azure Container Registry.

Utilisez-le pour approvisionner des registres avec la référence SKU et la géoréplication appropriées, configurer l’authentification (administrateur, principal de service ou identité managée), gérer des webhooks pour CI/CD, activer l’analyse des vulnérabilités et appliquer des stratégies de rétention aux images. Vous utilisez souvent Container Registry en même temps que Azure Kubernetes Service. Tout d’abord, provisionnez le Registre, puis référencez-le lors de la création du cluster.

exemple de code de gestion de registre Container Registry.

Pour obtenir un guide de prise en main, consultez la documentation du package armcontainerregistry.

Comptes de stockage

Le package armstorage gère les comptes stockage Azure.

Utilisez-le pour créer des comptes de stockage avec le niveau de performance et la redondance appropriés, gérer les clés d’accès et les signatures d’accès partagé, configurer les stratégies de cycle de vie des objets blob et configurer la journalisation des diagnostics. Les comptes de stockage sont une dépendance courante pour de nombreuses applications, de sorte que l’automatisation de leur approvisionnement et de leur configuration est un scénario de plan de contrôle courant.

exemple de code de gestion de compte Storage.

Pour obtenir un guide de prise en main, consultez la documentation du package armstorage.

Étapes suivantes

  • Last updated on