Démarrage rapide : déployer une machine virtuelle à partir d’un modèle avec le kit de développement logiciel Microsoft Azure SDK pour Go

Article
04/11/2023

Ce démarrage rapide vous montre comment déployer des ressources à partir d’un modèle Azure Resource Manager, via Azure SDK pour Go. Les modèles sont des instantanés de toutes les ressources contenues dans un groupe de ressources Azure. Durant la procédure, vous allez vous familiariser avec les fonctionnalités et les conventions du Kit de développement logiciel (SDK).

À la fin de ce démarrage rapide, vous devrez connecter une machine virtuelle en cours d’exécution avec un nom d’utilisateur et un mot de passe.

Remarque

Pour voir la création d’une machine virtuelle dans Go sans utiliser de modèle Resource Manager, il existe un exemple impératif qui montre comment générer et configurer toutes les ressources de machine virtuelle avec le Kit de développement logiciel (SDK). Le fait d’utiliser un modèle dans cet exemple permet de se concentrer sur les conventions du Kit de développement logiciel (SDK), sans entrer trop dans les détails sur l’architecture de service Azure.

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Lancement d’Azure Cloud Shell

Azure Cloud Shell est un interpréteur de commandes interactif qui s’exécute sur Azure. Il dispose d’outils courants préinstallés et configurés pour être utilisés avec votre compte. Sélectionnez Copier pour copier le code, collez-le dans Cloud Shell, puis appuyez sur Entrée pour l’exécuter.

Cloud Shell peut être lancé de plusieurs façons :

Sélectionnez Essayer dans le coin supérieur droit d’un bloc de code.

Cloud Shell in this article

Ouvrez Cloud Shell dans votre navigateur.

Sélectionnez le bouton Cloud Shell du menu situé dans l’angle supérieur droit du portail Azure.

Si vous utilisez une installation locale de l’interface de ligne de commande Azure, ce démarrage rapide requiert la version d’interface CLI 2.0.28 ou une version ultérieure. Exécutez az --version pour vous assurer que votre installation d’interface de ligne de commande répond à cette exigence. Si vous devez effectuer une installation ou une mise à niveau, consultez Installer Azure CLI.

Installer le kit de développement logiciel Microsoft Azure SDK pour Go

Azure SDK pour Go est compatible avec les versions 1.8 et ultérieures de Go. Pour les environnements utilisant des profils Azure Stack, la version 1.9 de Go est la configuration minimale requise. Si vous devez installer Go, suivez les instructions d’installation de Go.

Vous pouvez télécharger Azure SDK pour Go et ses dépendances via go get.

go get -u -d github.com/Azure/azure-sdk-for-go/...

Avertissement

Assurez-vous de mettre Azure en majuscules dans l’URL. Procéder autrement peut entraîner des problèmes d’importation liés à la casse lorsque vous travaillez avec le kit de développement logiciel (SDK). Vous devez également mettre Azure en majuscules dans vos instructions d’importation.

Créer un principal du service

Pour vous connecter en mode non interactif sur Azure avec une application, vous avez besoin d’un principal de service. Les principaux de service font partie du contrôle d’accès basé sur le rôle (RBAC), qui crée une identité d’utilisateur unique. Pour créer un principal de service avec l’interface CLI, exécutez la commande suivante :

az ad sp create-for-rbac --role Contributor \
    --scopes /subscriptions/<subscription_id> \
    --sdk-auth > quickstart.auth

Définissez la variable d’environnement AZURE_AUTH_LOCATION pour qu’elle devienne le chemin d’accès complet à ce fichier. Ensuite, le kit de développement logiciel (SDK) localise et lit les informations d’identification directement à partir de ce fichier, sans que vous ayez à apporter des modifications ou à enregistrer des informations depuis le principal de service.

Obtenir le code

Obtenez le code de démarrage rapide et toutes ses dépendances avec go get.

go get -u -d github.com/Azure-Samples/azure-sdk-for-go-samples/quickstarts/deploy-vm/...

Vous n’avez pas besoin d’apporter des modifications au code source si la variable AZURE_AUTH_LOCATION est correctement définie. Lorsque le programme s’exécute, il charge toutes les informations d’authentification nécessaires à partir de là.

Exécution du code

Exécutez le démarrage rapide avec la commande go run.

cd $GOPATH/src/github.com/Azure-Samples/azure-sdk-for-go-samples/quickstarts/deploy-vm
go run main.go

Si le déploiement réussit, un message comportant le nom d’utilisateur, l’adresse IP et le mot de passe pour se connecter à la machine virtuelle nouvellement créée s’affiche. Connectez-vous avec SSH à cette machine pour vérifier qu’elle est en cours d’exécution.

Nettoyage

Nettoyez les ressources créées au cours de ce démarrage rapide en supprimant le groupe de ressources à l’aide de l’interface CLI.

az group delete -n GoVMQuickstart

Supprimez également le principal de service qui a été créé. Dans le fichier quickstart.auth, il existe une clé JSON pour clientId. Copiez cette valeur dans la variable d’environnement CLIENT_ID_VALUE et exécutez la commande Azure CLI suivante :

az ad sp delete --id ${CLIENT_ID_VALUE}

Emplacement où vous indiquez la valeur de CLIENT_ID_VALUE depuis quickstart.auth.

Avertissement

L’échec de la suppression du principal de service pour cette application la laisse active dans votre locataire Microsoft Entra. Bien que le nom et le mot de passe du principal de service soient générés en tant qu’UUID, veillez à suivre les bonnes pratiques de sécurité en supprimant les principaux de service inutilisés et les applications Microsoft Entra.

Le code en profondeur

Le code de démarrage rapide est divisé en un bloc de variables et plusieurs petites fonctions, qui sont toutes décrites ici.

Variables, constantes et types

Étant donné que le démarrage rapide est autonome, il utilise des variables et des constantes globales.

const (
    resourceGroupName     = "GoVMQuickstart"
    resourceGroupLocation = "eastus"

    deploymentName = "VMDeployQuickstart"
    templateFile   = "vm-quickstart-template.json"
    parametersFile = "vm-quickstart-params.json"
)

// Information loaded from the authorization file to identify the client
type clientInfo struct {
    SubscriptionID string
    VMPassword     string
}

var (
    ctx        = context.Background()
    clientData clientInfo
    authorizer autorest.Authorizer
)

Les valeurs sont déclarées, ce qui donne les noms des ressources créées. L’emplacement est également spécifié ici, vous pouvez le modifier pour voir comment les déploiements se comportent dans d’autres centres de données. Chaque centre de données ne dispose pas de toutes les ressources requises disponibles.

Le type clientInfo contient les informations chargées à partir du fichier d’authentification pour configurer les clients dans le Kit de développement logiciel (SDK) et définir le mot de passe de la machine virtuelle.

Les constantes templateFile et parametersFile pointent vers les fichiers nécessaires au déploiement. Le authorizer sera configuré par le kit de développement logiciel (SDK) Go pour l’authentification, et la variable ctx est un contexte Go pour les opérations réseau.

Initialisation et authentification

La fonction init configure l’authentification. Étant donné que l’authentification est une condition préalable pour tous les éléments du démarrage rapide, il est judicieux d’en disposer dans le cadre de l’initialisation. Elle charge également des informations permettant de configurer les clients et la machine virtuelle à partir du fichier d’authentification.

func init() {
    var err error
    authorizer, err = auth.NewAuthorizerFromFile(azure.PublicCloud.ResourceManagerEndpoint)
    if err != nil {
        log.Fatalf("Failed to get OAuth config: %v", err)
    }

    authInfo, err := readJSON(os.Getenv("AZURE_AUTH_LOCATION"))
    clientData.SubscriptionID = (*authInfo)["subscriptionId"].(string)
    clientData.VMPassword = (*authInfo)["clientSecret"].(string)
}

Tout d’abord, auth.NewAuthorizerFromFile est appelée pour charger les informations d’authentification à partir du fichier situé dans AZURE_AUTH_LOCATION. Ensuite, ce fichier est chargé manuellement par la fonction readJSON (omise ici) pour extraire les deux valeurs nécessaires pour exécuter le reste du programme : l’ID d’abonnement du client, et le secret du principal du service, qui est également utilisé pour le mot de passe de la machine virtuelle.

Avertissement

Pour simplifier le démarrage rapide, le mot de passe du principal de service est réutilisé. En production, veillez à ne jamais réutiliser un mot de passe qui permet d’accéder à vos ressources Azure.

Flux des opérations dans main()

La fonction main est simple, elle indique uniquement le flux des opérations et exécute la vérification des erreurs.

func main() {
    group, err := createGroup()
    if err != nil {
        log.Fatalf("failed to create group: %v", err)
    }
    log.Printf("Created group: %v", *group.Name)

    log.Printf("Starting deployment: %s", deploymentName)
    result, err := createDeployment()
    if err != nil {
        log.Fatalf("Failed to deploy: %v", err)
    }
    if result.Name != nil {
        log.Printf("Completed deployment %v: %v", deploymentName, *result.Properties.ProvisioningState)
    } else {
        log.Printf("Completed deployment %v (no data returned to SDK)", deploymentName)
    }
    getLogin()
}

Les étapes que le code parcourt sont, dans l’ordre :

Créer le groupe de ressources à déployer sur (createGroup)
Créer le déploiement au sein de ce groupe (createDeployment)
Obtenir et afficher des informations de connexion pour la machine virtuelle déployée (getLogin)

Créer le groupe de ressources

La fonction createGroup crée le groupe de ressources. Examiner le flux des appels et les arguments illustre la façon dont les interactions du service sont structurées dans le kit de développement logiciel (SDK).

func createGroup() (group resources.Group, err error) {
    groupsClient := resources.NewGroupsClient(clientData.SubscriptionID)
    groupsClient.Authorizer = authorizer

        return groupsClient.CreateOrUpdate(
                ctx,
                resourceGroupName,
                resources.Group{
                        Location: to.StringPtr(resourceGroupLocation)})
}

Le flux général d’interaction avec un service Azure est :

Créez le client à l’aide de la méthode service.New*Client(), où * est le type de ressource du service avec lequel vous souhaitez interagir. Cette fonction prend toujours un ID d’abonnement.
Définissez la méthode d’autorisation pour le client, en lui permettant d’interagir avec l’API distante.
Faites correspondre l’appel de méthode sur le client avec l’API distante. Les méthodes de client du service prennent généralement le nom de la ressource et un objet de métadonnées.

La fonction to.StringPtr est utilisée ici pour effectuer une conversion de type. Les paramètres pour les méthodes du kit de développement logiciel (SDK) acceptent presque exclusivement des pointeurs, des méthodes pratiques sont donc fournies pour faciliter les conversions de type. Consultez la documentation relative au module autorest/to pour la liste complète des convertisseurs de commodité et de leur comportement.

La méthode groupsClient.CreateOrUpdate retourne un pointeur vers un type de données qui représente le groupe de ressources. Une valeur de retour directe de ce type indique une opération d’exécution courte qui est destinée à être synchrone. Dans la section suivante, vous verrez un exemple d’une opération longue et comment interagir avec elle.

Effectuer le déploiement

Une fois que le groupe de ressources est créé, il est temps d’exécuter le déploiement. Ce code est divisé en sections plus petites pour mettre en évidence les différentes parties de sa logique.

func createDeployment() (deployment resources.DeploymentExtended, err error) {
    template, err := readJSON(templateFile)
    if err != nil {
        return
    }
    params, err := readJSON(parametersFile)
    if err != nil {
        return
    }
    (*params)["vm_password"] = map[string]string{
        "value": clientData.VMPassword,
    }
        // ...

Les fichiers de déploiement sont chargés par readJSON, dont détails sont ignorés ici. Cette fonction retourne un *map[string]interface{}, le type utilisé pour construire les métadonnées pour l’appel de déploiement de ressources. Le mot de passe de la machine virtuelle est également défini manuellement sur les paramètres de déploiement.

        // ...

    deploymentsClient := resources.NewDeploymentsClient(clientData.SubscriptionID)
    deploymentsClient.Authorizer = authorizer

    deploymentFuture, err := deploymentsClient.CreateOrUpdate(
        ctx,
        resourceGroupName,
        deploymentName,
        resources.Deployment{
            Properties: &resources.DeploymentProperties{
                Template:   template,
                Parameters: params,
                Mode:       resources.Incremental,
            },
        },
    )
    if err != nil {
        return
    }

Ce code suit le même modèle que pour la création du groupe de ressources. Un nouveau client est créé, la possibilité de s’authentifier avec Azure lui est donnée, puis une méthode est appelée. La méthode a le même nom (CreateOrUpdate) que la méthode correspondante pour les groupes de ressources. Ce modèle est visible dans le Kit de développement logiciel (SDK). Les méthodes qui effectuent un travail similaire portent généralement le même nom.

La différence principale réside dans la valeur de retour de la méthode deploymentsClient.CreateOrUpdate. Cette valeur est du type Perspective, qui suit le modèle de conception de perspective. Les perspectives représentent une opération longue dans Azure que vous pouvez interroger, annuler ou bloquer dès leur achèvement.

        //...
    err = deploymentFuture.Future.WaitForCompletion(ctx, deploymentsClient.BaseClient.Client)
    if err != nil {
        return
    }
    return deploymentFuture.Result(deploymentsClient)
}

Pour cet exemple, la meilleure chose à faire est d’attendre que l’opération se termine. L’attente d’une perspective requiert à la fois un objet de contexte et le client ayant créé le Future. Il existe deux sources d’erreur possibles ici : une erreur côté client lors de la tentative d’appel de la méthode et une réponse d’erreur provenant du serveur. Cette dernière est retournée dans le cadre de l’appel deploymentFuture.Result.

Obtenir l’adresse IP attribuée

Pour toute opération avec la machine virtuelle nouvellement créée, vous aurez besoin de l’adresse IP attribuée. Les adresses IP sont des ressources Azure distinctes et autonomes, liées aux ressources du contrôleur d’interface réseau.

func getLogin() {
    params, err := readJSON(parametersFile)
    if err != nil {
        log.Fatalf("Unable to read parameters. Get login information with `az network public-ip list -g %s", resourceGroupName)
    }

    addressClient := network.NewPublicIPAddressesClient(clientData.SubscriptionID)
    addressClient.Authorizer = authorizer
    ipName := (*params)["publicIPAddresses_QuickstartVM_ip_name"].(map[string]interface{})
    ipAddress, err := addressClient.Get(ctx, resourceGroupName, ipName["value"].(string), "")
    if err != nil {
        log.Fatalf("Unable to get IP information. Try using `az network public-ip list -g %s", resourceGroupName)
    }

    vmUser := (*params)["vm_user"].(map[string]interface{})

    log.Printf("Log in with ssh: %s@%s, password: %s",
        vmUser["value"].(string),
        *ipAddress.PublicIPAddressPropertiesFormat.IPAddress,
        clientData.VMPassword)
}

Cette méthode s’appuie sur les informations stockées dans le fichier de paramètres. Le code peut interroger la machine virtuelle directement pour obtenir sa carte d’interface réseau, interroger la carte d’interface réseau pour obtenir sa ressource IP et interroger directement la ressource IP. C’est une longue chaîne de dépendances et d’opérations à résoudre, ce qui rend le processus coûteux. Étant donné que les informations JSON sont locales, elles peuvent être chargées à la place.

La valeur de l’utilisateur de la machine virtuelle est également chargée à partir de JSON. Le mot de passe de la machine virtuelle a été chargé précédemment à partir du fichier d’authentification.

Étapes suivantes

Dans ce guide de démarrage rapide, vous avez pris un modèle existant et l’avez déployé via Go. Puis vous l’avez connecté à la machine virtuelle nouvellement créée via le protocole SSH.

Pour en savoir sur l’utilisation des machines virtuelles dans l’environnement Azure avec Go, consultez les exemples de calcul Azure pour Go ou les exemples de gestion de ressources Azure pour Go.

Pour en savoir plus sur les méthodes d’authentification disponibles dans le Kit de développement logiciel (SDK), et sur les types d’authentification qu’elles prennent en charge, consultez Authentification avec le Kit de développement logiciel (SDK) Azure pour Go.

Démarrage rapide : déployer une machine virtuelle à partir d’un modèle avec le kit de développement logiciel Microsoft Azure SDK pour Go

Lancement d’Azure Cloud Shell

Installer le kit de développement logiciel Microsoft Azure SDK pour Go

Créer un principal du service

Obtenir le code

Exécution du code

Nettoyage

Le code en profondeur

Variables, constantes et types

Initialisation et authentification

Flux des opérations dans main()

Créer le groupe de ressources

Effectuer le déploiement

Obtenir l’adresse IP attribuée

Étapes suivantes

Commentaires

Commentaires

Ressources supplémentaires