Déployer un modèle Azure Resource Manager à l’aide du Kit de développement logiciel (SDK) Azure pour Go

Dans ce tutoriel, vous utilisez le Kit de développement logiciel (SDK) Azure pour Go pour déployer un modèle Azure Resource Manager.

Azure Resource Manager est le service de déploiement et de gestion d’Azure. Il vous permet de créer, mettre à jour et supprimer des ressources dans votre compte Azure. Les modèles Azure Resource Manager décrivent de manière déclarative votre infrastructure en tant que code dans des documents JSON.

À la fin de ce didacticiel, vous écrivez et déployez un modèle Azure Resource Manager à l’aide de Go.

Prerequisites

  • Abonnement Azure : si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Créer un module

Dans cette section, vous allez créer un module Go et installer les packages du Kit de développement logiciel (SDK) Azure requis. Vous créez ensuite le fichier d’application principal et ajoutez du code qui déploie un modèle Azure Resource Manager.

  1. Créez un répertoire nommé deployARM-how-to. Ensuite, passez à ce répertoire.

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

  2. Exécutez la commande go mod init pour créer les fichiers go.mod et go.sum.

    go mod init deployARM-how-to

  3. Le Kit de développement logiciel (SDK) Azure pour Go contient plusieurs packages pour l’utilisation d’Azure. Pour ce tutoriel, vous avez besoin des packages azcore/to, azidentity et armresources.

    Exécutez la go get commande pour télécharger ces packages :

    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. Créez un fichier appelé main.go.

    touch main.go

  5. Ouvrez main.go votre éditeur et ajoutez le code suivant qui s’authentifie auprès d’Azure, crée un groupe de ressources et déploie un modèle Azure Resource Manager :

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

Créer le modèle Azure Resource Manager

  1. Dans le deployARM-how-to répertoire, créez un autre fichier nommé template.json.

  2. Ouvrez le template.json fichier et ajoutez le code de modèle Azure Resource Manager suivant qui crée un compte de stockage Azure :

    {
    "$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. Remplacez <StorageAccountName> et <StorageAccountDisplayName> par une valeur de nom de stockage valide.

Pour plus d’informations sur les modèles Azure Resource Manager, consultez la vue d’ensemble des modèles Azure Resource Manager.

Connexion à Azure

Le code de cet article utilise le type DefaultAzureCredential du module Identité Azure pour Go pour s’authentifier auprès d’Azure. DefaultAzureCredential prend en charge de nombreux types d’informations d’identification pour l’authentification auprès d’Azure à l’aide d’OAuth avec Microsoft Entra ID. Dans cet article, vous utilisez les informations d’identification de l’utilisateur avec lesquelles vous vous connectez à Azure CLI.

Si ce n’est déjà fait, connectez-vous à Azure CLI :

az login

Si plusieurs abonnements sont associés à votre compte, utilisez la commande az account list pour obtenir la liste de ces abonnements. Utilisez la commande az account set pour définir l’abonnement actif. En définissant l’abonnement actif, vous vérifiez que toutes les commandes CLI que vous exécutez dans le reste de cet article s’exécutent sur votre abonnement prévu.

Note

Lors de l’exécution localement, DefaultAzureCredential prend également en charge les informations d’identification de connexion Azure Developer CLI (AZD) ou un principal de service Azure que vous configurez dans les variables d’environnement. Pour en savoir plus sur tous les types d’informations d’identification pris en charge, consultez l’authentification Azure avec le module Azure Identity pour Go.

Exécuter l’application

Avant de pouvoir déployer le modèle, vous devez définir votre ID d’abonnement Azure en tant que variable d’environnement.

  1. Pour obtenir l’ID d’abonnement, exécutez la commande az account show suivante.

    az account show --query id --output tsv

  2. Définissez la variable d’environnement AZURE_SUBSCRIPTION_ID avec votre ID d’abonnement. Remplacez <AzureSubscriptionId> par votre ID d’abonnement.

    export AZURE_SUBSCRIPTION_ID=<AzureSubscriptionId>

  3. Exécutez la go run commande pour déployer le modèle :

    go run main.go

Troubleshoot

Si le déploiement du compte de stockage échoue, vérifiez que vous avez utilisé une valeur de nom de stockage valide. Un nom de compte de stockage doit comporter entre 3 et 24 caractères, et ne peut contenir que des lettres minuscules et des chiffres.

Si le programme retourne une erreur liée à l’authentification ou à l’autorisation, vérifiez les éléments suivants :

  • Si l’erreur commence par un horodatage et le texte suivant : « Échec de l’obtention d’une réponse : DefaultAzureCredential : échec de l’acquisition d’un jeton ». Assurez-vous que vous vous êtes connecté à Azure CLI comme indiqué précédemment.

  • Si l’erreur est une erreur d’autorisation ou d’interdiction (code d’état 401 ou 403), vérifiez que votre compte d’utilisateur se trouve dans un rôle Azure qui lui donne les droits de créer des groupes de ressources et d’ajouter des ressources sur votre abonnement. Par exemple, citons les rôles intégrésContributeur ou Propriétaire Azure. Pour savoir comment attribuer des rôles Azure à votre utilisateur, consultez Affecter des rôles Azure à l’aide d’Azure CLI.

Pour obtenir des conseils de dépannage plus détaillés, consultez Résoudre les problèmes d’authentification d’identité Azure.

Vérifier les ressources sur Azure

Vous pouvez utiliser plusieurs commandes Azure CLI pour vérifier que les ressources ont été correctement créées sur Azure. Les commandes suivantes sont quelques exemples.

Pour vérifier que le groupe de ressources existe, exécutez la commande az group exists .

az group exists --name deployARM-how-to

Vous pouvez répertorier les ressources du groupe à l’aide de la commande az resource list .

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

Vous pouvez examiner les résultats du déploiement (outputResources) et les propriétés à l’aide de la commande az deployment group show .

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

Nettoyer les ressources

Les ressources dans Azure peuvent entraîner des frais en cours. Veillez à nettoyer les ressources que vous avez créées dans cet article.

Le déploiement d’un modèle vide en mode complet supprime toutes les ressources d’un groupe de ressources. Il s’agit d’un moyen simple de nettoyer les ressources sans supprimer le groupe de ressources lui-même.

  1. Créez un modèle vide nommé empty-template.json.

  2. Ouvrez empty-template.json votre éditeur et ajoutez le code suivant :

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

  3. Ouvrez votre fichier main.go.

  4. Mettez à jour la templateFile valeur constante sur empty-template.json.

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

  5. Modifiez le temps de déploiement de l’incrémentiel à complet en modifiant les propriétés du mode de déploiement à DeploymentModeComplete. Pour en savoir plus sur les modes de déploiement, consultez modes de déploiement Azure Resource Manager.

    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. Exécutez la go run commande pour déployer le modèle vide et supprimer le compte de stockage que vous avez créé précédemment.

    go run main.go

Au lieu d’utiliser un déploiement, vous pouvez supprimer le groupe de ressources et toutes ses ressources en exécutant la commande Azure CLI suivante :

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

Étapes suivantes

Concepts principaux du Kit de développement logiciel (SDK) Azure pour Go

Bibliothèques de gestion du Kit de développement logiciel (SDK) Azure pour Go

  • Dernière mise à jour :