Partager via


Créer une machine virtuelle Windows avec VM Image Builder en utilisant PowerShell

S’applique à : ✔️ Machine virtuelles Windows

Cet article montre comment créer une image de machine virtuelle Windows personnalisée en utilisant le module PowerShell d’Azure VM Image Builder.

Prérequis

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

Si vous choisissez d’utiliser PowerShell localement, cet article vous demande d’installer le module Azure PowerShell et de vous connecter à votre compte Azure en utilisant l’applet de commande Connect-AzAccount. Pour plus d’informations, consultez l’article Installation et configuration d’Azure PowerShell.

Certaines étapes nécessitent des applets de commande à partir du module Az.ImageBuilder. Installez séparément à l’aide de la commande suivante.

Install-Module -Name Az.ImageBuilder

Azure Cloud Shell

Azure héberge Azure Cloud Shell, un environnement d’interpréteur de commandes interactif que vous pouvez utiliser dans votre navigateur. Vous pouvez utiliser Bash ou PowerShell avec Cloud Shell pour utiliser les services Azure. Vous pouvez utiliser les commandes préinstallées Cloud Shell pour exécuter le code de cet article sans avoir à installer quoi que ce soit dans votre environnement local.

Pour démarrer Azure Cloud Shell :

Option Exemple/Lien
Sélectionnez Essayer dans le coin supérieur droite d’un bloc de codes ou de commandes. La sélection de Essayer ne copie pas automatiquement le code ni la commande dans Cloud Shell. Capture d’écran présentant un exemple d’essai pour Azure Cloud Shell.
Accédez à https://shell.azure.com ou sélectionnez le bouton Lancer Cloud Shell pour ouvrir Cloud Shell dans votre navigateur. Bouton permettant de lancer Azure Cloud Shell.
Sélectionnez le bouton Cloud Shell dans la barre de menus en haut à droite du portail Azure. Capture d’écran présentant le bouton Cloud Shell dans le portail Azure.

Pour utiliser Azure Cloud Shell :

  1. Démarrez Cloud Shell.

  2. Sélectionnez le bouton Copier sur un bloc de codes (ou un bloc de commandes) pour copier le code ou la commande.

  3. Collez le code ou la commande dans la session Cloud Shell en sélectionnant Ctrl+Maj+V sur Windows et Linux ou en sélectionnant Cmd+Maj+V sur macOS.

  4. Sélectionnez Entrée pour exécuter le code ou la commande.

Si vous avez plusieurs abonnements Azure, sélectionnez l’abonnement approprié dans lequel les ressources doivent être facturées. Sélectionnez un abonnement spécifique en utilisant l’applet de commande Set-AzContext.

Set-AzContext -SubscriptionId 00000000-0000-0000-0000-000000000000

Inscrire des fournisseurs

Si ce n’est pas déjà fait, inscrivez les fournisseurs de ressources suivants à utiliser avec votre abonnement Azure :

  • Microsoft.Compute
  • Microsoft.KeyVault
  • Microsoft.Storage
  • Microsoft.Network
  • Microsoft.VirtualMachineImages
  • Microsoft.ManagedIdentity
  • Microsoft.ContainerInstance
Get-AzResourceProvider -ProviderNamespace Microsoft.Compute, Microsoft.KeyVault, Microsoft.Storage, Microsoft.VirtualMachineImages, Microsoft.Network, Microsoft.ManagedIdentity |
  Where-Object RegistrationState -ne Registered |
    Register-AzResourceProvider

Définir des variables

Étant donné que vous utiliserez certaines informations à plusieurs reprises, créez des variables pour les stocker :

# Destination image resource group name
$imageResourceGroup = 'myWinImgBuilderRG'

# Azure region
$location = 'WestUS2'

# Name of the image to be created
$imageTemplateName = 'myWinImage'

# Distribution properties of the managed image upon completion
$runOutputName = 'myDistResults'

Créez une variable pour votre ID d’abonnement Azure. Pour confirmer que la variable subscriptionID contient votre ID d’abonnement, vous pouvez exécuter la deuxième ligne de l’exemple suivant :

# Your Azure Subscription ID
$subscriptionID = (Get-AzContext).Subscription.Id
Write-Output $subscriptionID

Créer un groupe de ressources

Créez un groupe de ressources Azure avec le cmdlet New-AzResourceGroup. Un groupe de ressources est un conteneur logique dans lequel les ressources Azure sont déployées et gérées en tant que groupe.

L’exemple suivant crée un groupe de ressources basé sur le nom dans la variable $imageResourceGroup dans la région que vous avez spécifiée dans la variable $location. Ce groupe de ressources sert à stocker l’artefact de modèle de configuration d’image et l’image.

New-AzResourceGroup -Name $imageResourceGroup -Location $location

Créer une identité d’utilisateur et définir des autorisations de rôle

Accordez au générateur d’images Azure les autorisations nécessaires pour créer des images dans le groupe de ressources spécifié. Pour cela, utilisez l’exemple suivant. Sans ces autorisations, le processus de génération d’image ne se termine pas correctement.

  1. Créer des variables pour les noms de définition de rôle et d’identité. Ces valeurs doivent être uniques.

    [int]$timeInt = $(Get-Date -UFormat '%s')
    $imageRoleDefName = "Azure Image Builder Image Def $timeInt"
    $identityName = "myIdentity$timeInt"
    
  2. Créez une identité d’utilisateur.

    New-AzUserAssignedIdentity -ResourceGroupName $imageResourceGroup -Name $identityName -Location $location
    
  3. Stockez les ressources d’identité et les ID du principal dans les variables.

    $identityNameResourceId = (Get-AzUserAssignedIdentity -ResourceGroupName $imageResourceGroup -Name $identityName).Id
    $identityNamePrincipalId = (Get-AzUserAssignedIdentity -ResourceGroupName $imageResourceGroup -Name $identityName).PrincipalId
    

Attribuer à l’identité les autorisations nécessaires pour distribuer les images

  1. Téléchargez le fichier de configuration JSON, puis modifiez-le en fonction des paramètres définis dans cet article.

    $myRoleImageCreationUrl = 'https://raw.githubusercontent.com/azure/azvmimagebuilder/master/solutions/12_Creating_AIB_Security_Roles/aibRoleImageCreation.json'
    $myRoleImageCreationPath = "myRoleImageCreation.json"
    
    Invoke-WebRequest -Uri $myRoleImageCreationUrl -OutFile $myRoleImageCreationPath -UseBasicParsing
    
    $Content = Get-Content -Path $myRoleImageCreationPath -Raw
    $Content = $Content -replace '<subscriptionID>', $subscriptionID
    $Content = $Content -replace '<rgName>', $imageResourceGroup
    $Content = $Content -replace 'Azure Image Builder Service Image Creation Role', $imageRoleDefName
    $Content | Out-File -FilePath $myRoleImageCreationPath -Force
    
  2. Créez la définition de rôle.

    New-AzRoleDefinition -InputFile $myRoleImageCreationPath
    
  3. Accordez la définition de rôle au principal de service VM Image Builder.

    $RoleAssignParams = @{
      ObjectId = $identityNamePrincipalId
      RoleDefinitionName = $imageRoleDefName
      Scope = "/subscriptions/$subscriptionID/resourceGroups/$imageResourceGroup"
    }
    New-AzRoleAssignment @RoleAssignParams
    

Remarque

Si vous recevez l’erreur « New-AzRoleDefinition : Limite de définition de rôle dépassée. Aucune autre définition de rôle ne peut être créée. », consultez Résoudre les problèmes liés au contrôle d’accès en fonction du rôle (RBAC) Azure.

  1. Créez la galerie.

    $myGalleryName = 'myImageGallery'
    $imageDefName = 'winSvrImages'
    
    New-AzGallery -GalleryName $myGalleryName -ResourceGroupName $imageResourceGroup -Location $location
    
  2. Créez une définition de galerie.

    $GalleryParams = @{
      GalleryName = $myGalleryName
      ResourceGroupName = $imageResourceGroup
      Location = $location
      Name = $imageDefName
      OsState = 'generalized'
      OsType = 'Windows'
      Publisher = 'myCo'
      Offer = 'Windows'
      Sku = 'Win2019'
    }
    New-AzGalleryImageDefinition @GalleryParams
    

Créer une image

  1. Créez un objet source VM Image Builder. Pour obtenir les valeurs valides des paramètres, consultez Rechercher des images de machine virtuelle Windows dans la Place de marché Azure avec Azure PowerShell.

    $SrcObjParams = @{
      PlatformImageSource = $true
      Publisher = 'MicrosoftWindowsServer'
      Offer = 'WindowsServer'
      Sku = '2019-Datacenter'
      Version = 'latest'
    }
    $srcPlatform = New-AzImageBuilderTemplateSourceObject @SrcObjParams
    
  2. Créez un objet de distribution pour VM Image Builder.

    $disObjParams = @{
      SharedImageDistributor = $true
      ArtifactTag = @{tag='dis-share'}
      GalleryImageId = "/subscriptions/$subscriptionID/resourceGroups/$imageResourceGroup/providers/Microsoft.Compute/galleries/$myGalleryName/images/$imageDefName"
      ReplicationRegion = $location
      RunOutputName = $runOutputName
      ExcludeFromLatest = $false
    }
    $disSharedImg = New-AzImageBuilderTemplateDistributorObject @disObjParams
    
  3. Créez un objet de personnalisation pour VM Image Builder.

    $ImgCustomParams01 = @{
      PowerShellCustomizer = $true
      Name = 'settingUpMgmtAgtPath'
      RunElevated = $false
      Inline = @("mkdir c:\\buildActions", "mkdir c:\\buildArtifacts", "echo Azure-Image-Builder-Was-Here  > c:\\buildActions\\buildActionsOutput.txt")
    }
    $Customizer01 = New-AzImageBuilderTemplateCustomizerObject @ImgCustomParams01
    
  4. Créez un deuxième objet de personnalisation pour VM Image Builder.

    $ImgCustomParams02 = @{
      FileCustomizer = $true
      Name = 'downloadBuildArtifacts'
      Destination = 'c:\\buildArtifacts\\index.html'
      SourceUri = 'https://raw.githubusercontent.com/azure/azvmimagebuilder/master/quickquickstarts/exampleArtifacts/buildArtifacts/index.html'
    }
    $Customizer02 = New-AzImageBuilderTemplateCustomizerObject @ImgCustomParams02
    
  5. Créez un modèle VM Image Builder.

    $ImgTemplateParams = @{
      ImageTemplateName = $imageTemplateName
      ResourceGroupName = $imageResourceGroup
      Source = $srcPlatform
      Distribute = $disSharedImg
      Customize = $Customizer01, $Customizer02
      Location = $location
      UserAssignedIdentityId = $identityNameResourceId
    }
    New-AzImageBuilderTemplate @ImgTemplateParams
    

Une fois le modèle créé, un message est retourné et un modèle de configuration VM Image Builder est créé dans $imageResourceGroup.

Pour déterminer si le processus de création du modèle a réussi, utilisez l’exemple suivant :

Get-AzImageBuilderTemplate -ImageTemplateName $imageTemplateName -ResourceGroupName $imageResourceGroup |
  Select-Object -Property Name, LastRunStatusRunState, LastRunStatusMessage, ProvisioningState

En arrière-plan, Azure VM Image Builder crée également un groupe de ressources intermédiaire dans votre abonnement. Ce groupe de ressources est utilisé pour générer l’image. Il est au format IT_<DestinationResourceGroup>_<TemplateName>.

Avertissement

Ne supprimez pas directement le groupe de ressources intermédiaire. Pour provoquer la suppression du groupe de ressources intermédiaire, supprimez l’artefact de modèle d’image.

Si le service signale une défaillance quand vous envoyez le modèle de configuration d’image, effectuez les étapes suivantes :

Lancer la génération de l’image

Envoyez la configuration de l’image au service VM Image Builder en exécutant la commande suivante :

Start-AzImageBuilderTemplate -ResourceGroupName $imageResourceGroup -Name $imageTemplateName

Attendez la fin du processus de génération d’image, celui-ci pouvant prendre jusqu’à une heure.

Si vous rencontrez des erreurs, consultez Résoudre les problèmes liés à Azure VM Image Builder.

Créer une machine virtuelle

  1. Stockez les informations d’identification de connexion à la machine virtuelle dans une variable. Le mot de passe doit être complexe.

    $Cred = Get-Credential
    
  2. Créez la machine virtuelle en utilisant l’image que vous avez créée.

    $ArtifactId = (Get-AzImageBuilderTemplateRunOutput -ImageTemplateName $imageTemplateName -ResourceGroupName $imageResourceGroup).ArtifactId
    
    New-AzVM -ResourceGroupName $imageResourceGroup -Image $ArtifactId -Name myWinVM01 -Credential $Cred
    

Vérifier les personnalisations

  1. Créez une connexion Bureau à distance à la machine virtuelle avec le nom d’utilisateur et le mot de passe que vous avez définis lors de la création de la machine virtuelle.

  2. À l’intérieur de la machine virtuelle, ouvrez PowerShell et exécutez Get-Content comme indiqué dans l’exemple suivant :

    Get-Content -Path C:\buildActions\buildActionsOutput.txt
    

    La sortie est basée sur le contenu du fichier que vous avez créé durant le processus de personnalisation d’image.

    Azure-Image-Builder-Was-Here
    
  3. Dans la même session PowerShell, pour vérifier que la deuxième personnalisation a réussi, recherchez la présence de c:\buildArtifacts\index.html, comme illustré dans l’exemple suivant :

    Get-ChildItem c:\buildArtifacts\
    

    Le résultat doit être une liste de répertoires indiquant que le fichier a été téléchargé durant le processus de personnalisation d’image.

        Directory: C:\buildArtifacts
    
    Mode                 LastWriteTime         Length Name
    ----                 -------------         ------ ----
    -a---          29/01/2021    10:04            276 index.html
    

Nettoyer vos ressources

Si vous n’avez plus besoin des ressources qui ont été créées durant ce processus, vous pouvez les supprimer en effectuant les étapes suivantes :

  1. Supprimez le modèle VM Image Builder.

    Remove-AzImageBuilderTemplate -ResourceGroupName $imageResourceGroup -Name $imageTemplateName
    
  2. Supprimez le groupe de ressources d’image.

    Attention

    L’exemple suivant supprime le groupe de ressources spécifié et toutes les ressources qu’il contient. Si des ressources en dehors du cadre de cet article existent dans le groupe de ressources, elles seront également supprimées.

    Remove-AzResourceGroup -Name $imageResourceGroup
    

Étapes suivantes

Pour en savoir plus sur les composants du fichier JSON utilisé dans cet article, consultez les informations de référence sur le modèle VM Image Builder.