Créer et déployer des applications de machine virtuelle

Les applications VM sont un type de ressource dans Azure Compute Gallery (anciennement Shared Image Gallery), qui simplifie la gestion, le partage et la distribution globale d’applications pour vos machines virtuelles.

Prérequis

Avant de commencer, vérifiez que vous disposez des éléments suivants :

Cet article part du principe que vous disposez déjà d’une galerie Azure Compute Gallery. Si vous n’avez pas encore de galerie, commencez par en créer une. Pour plus d’informations, consultez Créer une galerie pour le stockage et le partage de ressources.

Vous devez avoir chargé votre application dans un conteneur d’un compte de stockage Azure. Votre application peut être stockée dans un objet blob de blocs ou de pages. Si vous choisissez d’utiliser un objet blob de pages, vous devez aligner les octets des fichiers avant de les charger. Voici un exemple qui va aligner les octets de votre fichier :

$inputFile = <the file you want to pad>

$fileInfo = Get-Item -Path $inputFile

$remainder = $fileInfo.Length % 512

if ($remainder -ne 0){

    $difference = 512 - $remainder

    $bytesToPad = [System.Byte[]]::CreateInstance([System.Byte], $difference)

    Add-Content -Path $inputFile -Value $bytesToPad -Encoding Byte
    }

Vérifiez que le compte de stockage dispose d’un accès au niveau public ou utilisez un URI SAP avec des privilèges de lecture, car d’autres niveaux de restriction échouent dans les déploiements. Vous pouvez utiliser l’Explorateur Stockage pour créer rapidement un URI SAS si vous n’en avez pas encore un.

Si vous utilisez PowerShell, vous devez utiliser la version 3.11.0 du module Az.Storage.

Pour en savoir plus sur le mécanisme d’installation, consultez Interpréteur de commandes.

Créer l’application de machine virtuelle

Choisissez une option ci-dessous pour créer vos définition et version d’application de machine virtuelle :

Portail

1. Accédez au portail Azure, puis recherchez et sélectionnez Azure Compute Gallery.
2. Sélectionnez la galerie à utiliser dans la liste.
3. Dans la page de votre galerie, sélectionnez Ajouter en haut de la page, puis Définition d’application VM dans le menu déroulant. La page Créer une définition d’application de machine virtuelle s’ouvre.
4. Sous l’onglet De base, entrez un nom pour votre application et indiquez si l’application est destinée aux machines virtuelles exécutant Linux ou Windows.
5. Sélectionnez l’onglet Options de publication si vous souhaitez spécifier l’un des paramètres facultatifs suivants pour votre définition d’application de machine virtuelle :
   • Description de la définition d’application de machine virtuelle.
   • Date de fin de vie
   • Lien vers un CLUF
   • URI d’une déclaration de confidentialité
   • URI pour des notes de publication
6. Quand vous avez terminé, sélectionnez Vérifier + créer.
7. Une fois la validation terminée, sélectionnez Créer pour déployer la définition.
8. Une fois le déploiement effectué, sélectionnez Accéder à la ressource.
9. Dans la page de l’application, sélectionnez Créer une version d’application VM. La page Créer une version d’application de machine virtuelle s’ouvre.
10. Entrez un numéro de version comme 1.0.0.
11. Sélectionnez la région où vous avez chargé votre package d’application.
12. Sous Package d’application source, sélectionnez Parcourir. Sélectionnez le compte de stockage, puis le conteneur où se trouve votre package. Sélectionnez le package dans la liste, puis sélectionnez Sélectionner lorsque vous avez terminé. Vous pouvez aussi coller l’URI SAS dans ce champ si vous le souhaitez.
13. Tapez dans le Script d’installation. Vous pouvez également fournir le Script de désinstallation et le Script de mise à jour. Pour plus d’informations sur la création de scripts, consultez la Vue d’ensemble.
14. Si vous avez un fichier de configuration par défaut chargé dans un compte de stockage, vous pouvez le sélectionner dans Configuration par défaut.
15. Sélectionnez Exclure de la plus récente si vous ne souhaitez pas que cette version apparaisse comme la dernière version quand vous créez une machine virtuelle.
16. Pour Date de fin de vie, choisissez une date ultérieure pour suivre la mise hors service de cette version. Elle n’est pas supprimée ni effacée automatiquement, c’est juste pour votre propre suivi.
17. Pour répliquer cette version dans d’autres régions, sélectionnez l’onglet Réplication et ajoutez d’autres régions, puis apportez des changements au nombre de réplicas par région. La région d’origine où votre version a été créée doit figurer dans la liste et ne peut pas être supprimée.
18. Lorsque vous avez terminé vos changements, sélectionnez Vérifier + créer au bas de la page.
19. Lorsque la validation apparaît comme réussie, sélectionnez Créer pour déployer la version de votre application VM.

Vous pouvez maintenant créer une machine virtuelle et y déployer l’application de machine virtuelle à l’aide du portail. Il vous suffit de créer la machine virtuelle comme d’habitude, puis, sous l’onglet Avancé, de choisir Sélectionner une application de machine virtuelle à installer.

Sélectionnez l’application de machine virtuelle dans la liste, puis choisissez Enregistrer en bas de la page.

Si vous avez plusieurs applications de machine virtuelle à installer, vous pouvez définir l’ordre d’installation de chaque application de machine virtuelle sous longlet Avancé.

Vous pouvez également déployer l’application de machine virtuelle sur des machines virtuelles en cours d’exécution. Sélectionnez l’option Extensions + applications sous Paramètres dans le menu de gauche lors de l’affichage des détails de la machine virtuelle dans le portail.

Choisissez Applications de machine virtuelle, puis sélectionnez Ajouter une application pour ajouter votre application de machine virtuelle.

Sélectionnez l’application de machine virtuelle dans la liste, puis choisissez Enregistrer en bas de la page.

Pour afficher l’état de l’application de machine virtuelle, accédez à l’onglet Extensions + applications/Paramètres et vérifiez l’état de VMAppExtension :

Pour afficher l’état de l’application de machine virtuelle pour VMSS, accédez à la page VMSS, Instances, sélectionnez l’une des instances, puis accédez à VMAppExtension :

INTERFACE DE LIGNE DE COMMANDE

Les applications VM requièrent Azure CLI version 2.30.0 ou ultérieure.

Créez la définition d’application de machine virtuelle à l’aide de la commande az sig gallery-application create. Dans cet exemple, nous créons une définition d’application de machine virtuelle nommée myApp pour machines virtuelles basées sur Linux.

az sig gallery-application create \
    --application-name myApp \
    --gallery-name myGallery \
    --resource-group myResourceGroup \
    --os-type Linux \
    --location "East US"

Créez une version d’application de machine virtuelle à l’aide de la commande az sig gallery-application version create. Les caractères autorisés pour la version sont les chiffres et les points. Les nombres doivent être un entier 32 bits. Format: MajorVersion.MinorVersion.Patch.

Remplacez les valeurs des paramètres par vos propres valeurs.

az sig gallery-application version create \
   --version-name 1.0.0 \
   --application-name myApp \
   --gallery-name myGallery \
   --location "East US" \
   --resource-group myResourceGroup \
   --package-file-link "https://<storage account name>.blob.core.windows.net/<container name>/<filename>" \
   --install-command "mv myApp .\myApp\myApp" \
   --remove-command "rm .\myApp\myApp" \
   --update-command  "mv myApp .\myApp\myApp" \
   --default-configuration-file-link "https://<storage account name>.blob.core.windows.net/<container name>/<filename>"\

Définissez une application de machine virtuelle sur une machine virtuelle existante à l’aide d’az vm application set et remplacez les valeurs des paramètres par vos propres paramètres.

az vm application set \
	--resource-group myResourceGroup \
	--name myVM \
  	--app-version-ids /subscriptions/{subID}/resourceGroups/MyResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 \
  	--treat-deployment-as-failure true

Pour définir plusieurs applications sur une machine virtuelle :

az vm application set \
	--resource-group myResourceGroup \
	--name myVM \
	--app-version-ids /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp2/versions/1.0.1 \
	--treat-deployment-as-failure true true

Pour ajouter une application à un VMSS, utilisez az vmss application set :

az vmss application set \
	--resource-group myResourceGroup \
	--name myVmss \
	--app-version-ids /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 \
	--treat-deployment-as-failure true

Pour ajouter plusieurs applications à un VMSS :

az vmss application set \
	--resource-group myResourceGroup \
	--name myVmss
	--app-version-ids /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp2/versions/1.0.0 \
	--treat-deployment-as-failure true

Pour vérifier l’état du déploiement de la machine virtuelle d’application, utilisez az vm get-instance-view :

az vm get-instance-view -g myResourceGroup -n myVM --query "instanceView.extensions[?name == 'VMAppExtension']"

Pour vérifier l’état du déploiement du VMSS d’application, utilisez az vmss get-instance-view :

az vmss get-instance-view --ids (az vmss list-instances -g myResourceGroup -n myVmss --query "[*].id" -o tsv) --query "[*].extensions[?name == 'VMAppExtension']"

Notes

La commande d’état du déploiement de VMSS ci-dessus ne liste pas l’ID d’instance avec le résultat. Pour afficher l’ID d’instance avec l’état de l’extension dans chaque instance, certains scripts supplémentaires sont requis. Reportez-vous à l’exemple d’interface CLI pour VMSS ci-dessous qui contient la syntaxe PowerShell :

$ids = az vmss list-instances -g myResourceGroup -n myVmss --query "[*].{id: id, instanceId: instanceId}" | ConvertFrom-Json
$ids | Foreach-Object {
    $iid = $_.instanceId
    Write-Output "instanceId: $iid" 
    az vmss get-instance-view --ids $_.id --query "extensions[?name == 'VMAppExtension']" 
}

PowerShell

Créez la définition d’application de machine virtuelle à l’aide de la commande New-AzGalleryApplication. Dans cet exemple, nous créons une application Linux nommée MyApp dans la galerie Azure Compute Gallery myGallery, dans le groupe de ressources myGallery, et j’ai fourni une brève description de l’application de machine virtuelle pour mon propre usage. Remplacez les valeurs en fonction des besoins.

$galleryName = "myGallery"
$rgName = "myResourceGroup"
$applicationName = "myApp"
New-AzGalleryApplication `
  -ResourceGroupName $rgName `
  -GalleryName $galleryName `
  -Location "East US" `
  -Name $applicationName `
  -SupportedOSType Linux `
  -Description "Backend Linux application for finance."

Créez une version de votre application à l’aide de la commande New-AzGalleryApplicationVersion. Les caractères autorisés pour la version sont les chiffres et les points. Les nombres doivent être un entier 32 bits. Format: MajorVersion.MinorVersion.Patch.

Dans cet exemple, nous créons le numéro de version 1.0.0. Remplacez les valeurs des variables en fonction des besoins.

$galleryName = "myGallery"
$rgName = "myResourceGroup"
$applicationName = "myApp"
$version = "1.0.0"
New-AzGalleryApplicationVersion `
   -ResourceGroupName $rgName `
   -GalleryName $galleryName `
   -GalleryApplicationName $applicationName `
   -Name $version `
   -PackageFileLink "https://<storage account name>.blob.core.windows.net/<container name>/<filename>" `
   -DefaultConfigFileLink "https://<storage account name>.blob.core.windows.net/<container name>/<filename>" `
   -Location "East US" `
   -Install "mv myApp .\myApp\myApp" `
   -Remove "rm .\myApp\myApp" `

Pour ajouter l’application à une machine virtuelle existante, récupérez la version de l’application et utilisez-la pour obtenir l’ID de version de l’application de machine virtuelle. Utilisez l’ID pour ajouter l’application à la configuration de machine virtuelle.

$galleryName = "myGallery"
$rgName = "myResourceGroup"
$applicationName = "myApp"
$version = "1.0.0"
$vmName = "myVM"
$vm = Get-AzVM -ResourceGroupName $rgname -Name $vmName
$appVersion = Get-AzGalleryApplicationVersion `
   -GalleryApplicationName $applicationName `
   -GalleryName $galleryName `
   -Name $version `
   -ResourceGroupName $rgName
$packageId = $appVersion.Id
$app = New-AzVmGalleryApplication -PackageReferenceId $packageId
Add-AzVmGalleryApplication -VM $vm -GalleryApplication $app -TreatFailureAsDeploymentFailure true
Update-AzVM -ResourceGroupName $rgName -VM $vm

Pour ajouter l’application à un VMSS :

$vmss = Get-AzVmss -ResourceGroupName $rgname -Name $vmssName
$appVersion = Get-AzGalleryApplicationVersion `
   -GalleryApplicationName $applicationName `
   -GalleryName $galleryName `
   -Name $version `
   -ResourceGroupName $rgName
$packageId = $appVersion.Id
$app = New-AzVmssGalleryApplication -PackageReferenceId $packageId
Add-AzVmssGalleryApplication -VirtualMachineScaleSetVM $vmss.VirtualMachineProfile -GalleryApplication $app
Update-AzVmss -ResourceGroupName $rgName -VirtualMachineScaleSet $vmss -VMScaleSetName $vmssName

Vérifiez que l’application a réussi :

$rgName = "myResourceGroup"
$vmName = "myVM"
$result = Get-AzVM -ResourceGroupName $rgName -VMName $vmName -Status
$result.Extensions | Where-Object {$_.Name -eq "VMAppExtension"} | ConvertTo-Json

Pour vérifier pour le VMSS :

$rgName = "myResourceGroup"
$vmssName = "myVMss"
$result = Get-AzVmssVM -ResourceGroupName $rgName -VMScaleSetName $vmssName -InstanceView
$resultSummary  = New-Object System.Collections.ArrayList
$result | ForEach-Object {
    $res = @{ instanceId = $_.InstanceId; vmappStatus = $_.InstanceView.Extensions | Where-Object {$_.Name -eq "VMAppExtension"}}
    $resultSummary.Add($res) | Out-Null
}
$resultSummary | ConvertTo-Json -Depth 5

REST

Créez la définition d’application.

PUT
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/galleries/\<**galleryName**\>/applications/\<**applicationName**\>?api-version=2019-03-01

{
    "location": "West US",
    "name": "myApp",
    "properties": {
        "supportedOSType": "Windows | Linux",
        "endOfLifeDate": "2020-01-01"
    }
}

Nom du champ	Description	Limites
name	Nom unique de l’application de machine virtuelle dans la galerie	Longueur maximale de 117 caractères. Les caractères autorisés sont les lettres majuscules ou minuscules, les chiffres, les traits d’union (-), les points (.) et les traits de soulignement (_). Les noms ne peuvent pas se terminer par un point (.).
supportedOSType	Indique s’il s’agit d’une application Windows ou Linux	« Windows » ou « Linux »
endOfLifeDate	Date de fin de vie future de l’application. Notez que ces informations sont données à titre indicatif et ne sont pas appliquées.	Date future valide

Créez une version de l’application de machine virtuelle.

PUT
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/galleries/\<**galleryName**\>/applications/\<**applicationName**\>/versions/\<**versionName**\>?api-version=2019-03-01

{
  "location": "$location",
  "properties": {
    "publishingProfile": {
      "source": {
        "mediaLink": "$mediaLink",
        "defaultConfigurationLink": "$configLink"
      },
      "manageActions": {
        "install": "echo installed",
        "remove": "echo removed",
        "update": "echo update"
      },
      "targetRegions": [
        {
          "name": "$location1",
          "regionalReplicaCount": 1 
        },
        { "name": "$location1" }
      ]
    },
    "endofLifeDate": "datetime",
    "excludeFromLatest": "true | false"
  }
}

Nom du champ	Description	Limites
location	Emplacement source de la version de l’application de machine virtuelle	Région Azure valide
MediaLink	URL contenant le package de la version de l’application	URL de stockage valide et existante
defaultConfigurationLink	facultatif. URL contenant la configuration par défaut, qui peut être remplacée au moment du déploiement.	URL de stockage valide et existante
Installer	Commande pour installer l’application	Commande valide pour le système d’exploitation donné
Supprimer	Commande pour supprimer l’application	Commande valide pour le système d’exploitation donné
Update	facultatif. Commande permettant de mettre à jour l’application. Si elle n’est pas spécifiée et qu’une mise à jour est requise, l’ancienne version est supprimée et la nouvelle est installée.	Commande valide pour le système d’exploitation donné
targetRegions/name	Nom d’une région vers laquelle effectuer la réplication	Valider la région Azure
targetRegions/regionalReplicaCount	facultatif. Nombre de réplicas à créer dans la région. La valeur par défaut est de 1.	Entier compris entre 1 et 3 (inclus)
endOfLifeDate	Date de fin de vie future de la version de l’application. Notez que ces informations sont données à titre indicatif pour le client et ne sont pas appliquées.	Date future valide
excludeFromLatest	Si elle est spécifiée, cette version n’est pas prise en compte pour la dernière version.	True ou false

Pour ajouter une version d’application de machine virtuelle à une machine virtuelle, effectuez une requête PUT sur la machine virtuelle.

PUT
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/virtualMachines/\<**VMName**\>?api-version=2019-03-01

{
  "properties": {
    "applicationProfile": {
      "galleryApplications": [
        {
          "order": 1,
          "packageReferenceId": "/subscriptions/{subscriptionId}/resourceGroups/<resource group>/providers/Microsoft.Compute/galleries/{gallery name}/applications/{application name}/versions/{version}",
          "configurationReference": "{path to configuration storage blob}",
          "treatFailureAsDeploymentFailure": false
        }
      ]
    }
  },
  "name": "{vm name}",
  "id": "/subscriptions/{subscriptionId}/resourceGroups/{resource group}/providers/Microsoft.Compute/virtualMachines/{vm name}",
  "location": "{vm location}"
}

Pour appliquer l’application de machine virtuelle à un groupe identique uniforme :

PUT
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/
virtualMachineScaleSets/\<**VMSSName**\>?api-version=2019-03-01

{
  "properties": {
    "virtualMachineProfile": {
      "applicationProfile": {
        "galleryApplications": [
          {
            "order": 1,
            "packageReferenceId": "/subscriptions/{subscriptionId}/resourceGroups/<resource group>/providers/Microsoft.Compute/galleries/{gallery name}/applications/{application name}/versions/{version}",
            "configurationReference": "{path to configuration storage blob}",
            "treatFailureAsDeploymentFailure": false
          }
        ]
      }
    }
  },
  "name": "{vm name}",
  "id": "/subscriptions/{subscriptionId}/resourceGroups/{resource group}/providers/Microsoft.Compute/virtualMachines/{vm name}",
  "location": "{vm location}"
}

Nom du champ	Description	Limites
order	facultatif. Ordre dans lequel les applications doivent être déployées. Voir ci-dessous.	Valider l’entier
packageReferenceId	Référence de la version de l’application de la galerie	Référence de version d’application valide
configurationReference	facultatif. URL complète d’un blob de stockage contenant la configuration pour ce déploiement. Ceci remplace toute valeur fournie pour defaultConfiguration précédemment.	Référence de blob de stockage valide
treatFailureAsDeploymentFailure	facultatif. État de provisionnement pour l’application de machine virtuelle. Quand la valeur est false, l’état de provisionnement affiche toujours « succeeded » (réussi) indépendamment de l’échec du déploiement de l’application.	True ou False

Le champ d’ordre peut être utilisé pour spécifier des dépendances entre applications. Les règles pour l’ordre sont les suivantes :

Cas	Signification de l’installation	Signification de l’échec
Aucun ordre spécifié	Les applications non ordonnées sont installées après les applications ordonnées. Il n’y a aucune garantie d’ordre d’installation parmi les applications non ordonnées.	Les échecs d’installation d’autres applications, ordonnées ou non, n’affectent pas l’installation des applications non ordonnées.
Valeurs d’ordre en double	L’application est installée dans un ordre quelconque par rapport à d’autres applications ayant le même ordre. Toutes les applications de même ordre sont installées après celles dont l’ordre est inférieur et avant celles dont l’ordre est supérieur.	Si l’installation d’une application précédente dont l’ordre est inférieur échoue, aucune application de cet ordre ne s’installe. Si l’installation d’une application quelconque de cet ordre échoue, aucune application dont l’ordre est supérieur ne s’installe.
Ordres croissants	L’application est installée après celles dont l’ordre est inférieur et avant celles dont l’ordre est supérieur.	Si l’installation d’une application précédente d’ordre inférieur a échoué, cette application n’est pas installée. Si l’installation de cette application échoue, aucune application d’ordre supérieur ne s’installe.

La réponse inclut le modèle de machine virtuelle complet. Voici les parties pertinentes.

{
  "name": "{vm name}",
  "id": "{vm id}",
  "type": "Microsoft.Compute/virtualMachines",
  "location": "{vm location}",
  "properties": {
    "applicationProfile": {
      "galleryApplications": ""
    },
    "provisioningState": "Updating"
  },
  "resources": [
    {
      "name": "VMAppExtension",
      "id": "{extension id}",
      "type": "Microsoft.Compute/virtualMachines/extensions",
      "location": "centraluseuap",
      "properties": "@{autoUpgradeMinorVersion=True; forceUpdateTag=7c4223fc-f4ea-4179-ada8-c8a85a1399f5; provisioningState=Creating; publisher=Microsoft.CPlat.Core; type=VMApplicationManagerLinux; typeHandlerVersion=1.0; settings=}"
    }
  ]
}

Si les applications de machine virtuelle n’ont pas encore été installées sur la machine virtuelle, la valeur sera vide.

Pour obtenir le résultat de la vue d’instance de machine virtuelle :

GET
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/virtualMachines/\<**VMName**\>/instanceView?api-version=2019-03-01

Le résultat ressemble à ceci :

{
    ...
    "extensions"  [
    ...
        {
            "name":  "VMAppExtension",
            "type":  "Microsoft.CPlat.Core.VMApplicationManagerLinux",
            "typeHandlerVersion":  "1.0.9",
            "statuses":  [
                            {
                                "code":  "ProvisioningState/succeeded",
                                "level":  "Info",
                                "displayStatus":  "Provisioning succeeded",
                                "message":  "Enable succeeded: {\n \"CurrentState\": [\n  {\n   \"applicationName\": \"doNothingLinux\",\n   \"version\": \"1.0.0\",\n   \"result\": \"Install SUCCESS\"\n  },\n  {
        \n   \"applicationName\": \"badapplinux\",\n   \"version\": \"1.0.0\",\n   \"result\": \"Install FAILED Error executing command \u0027exit 1\u0027: command terminated with exit status=1\"\n  }\n ],\n \"ActionsPerformed\": []\n}
        "
                            }
                        ]
        }
    ...
    ]
}

L’état de l’application de machine virtuelle se trouve dans le message d’état du résultat de l’extension de l’application de machine virtuelle dans la vue de l’instance.

Pour obtenir l’état d’une application VMSS :

GET
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/ virtualMachineScaleSets/\<**VMSSName**\>/virtualMachines/<**instanceId**>/instanceView?api-version=2019-03-01

La sortie est similaire à l’exemple de machine virtuelle précédent.

Étapes suivantes

Apprenez-en davantage sur les applications de machine virtuelle.