Creare una macchina virtuale Windows con Image Builder per macchine virtuali usando PowerShell

Articolo
06/23/2024

Si applica a: ✔️ macchine virtuali di Windows

Questo articolo illustra come creare un'immagine di macchina virtuale Windows personalizzata usando il modulo PowerShell di Image Builder per macchine virtuali di Azure.

Prerequisiti

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Se si sceglie di usare PowerShell in locale, per questo articolo è necessario installare il modulo Azure PowerShell e connettersi all'account di Azure usando il cmdlet Connect-AzAccount. Per altre informazioni, vedere Installare Azure PowerShell.

Alcuni passaggi richiedono i cmdlet del modulo Az.ImageBuilder. Eseguire l'installazione separatamente usando il comando seguente.

Install-Module -Name Az.ImageBuilder

Azure Cloud Shell

Azure Cloud Shell è un ambiente di shell interattivo ospitato in Azure e usato tramite il browser. È possibile usare Bash o PowerShell con Cloud Shell per usare i servizi di Azure. È possibile usare i comandi preinstallati di Cloud Shell per eseguire il codice contenuto in questo articolo senza dover installare strumenti nell'ambiente locale.

Per avviare Azure Cloud Shell:

Opzione	Esempio/Collegamento
Selezionare Prova nell'angolo superiore destro di un blocco di codice o di comando. Quando si seleziona Prova, il codice o il comando non viene copiato automaticamente in Cloud Shell.
Passare a https://shell.azure.com o selezionare il pulsante Avvia Cloud Shell per aprire Cloud Shell nel browser.
Selezionare il pulsante Cloud Shell nella barra dei menu nell'angolo in alto a destra del portale di Azure.

Per usare Azure Cloud Shell:

Avviare Cloud Shell.
Selezionare il pulsante Copia in un blocco di codice (o in un blocco di comando) per copiare il codice o il comando.
Incollare il codice o il comando nella sessione di Cloud Shell selezionando CTRL+MAIUSC+V in Windows e Linux o selezionando CMD+MAIUSC+V in macOS.
Premere Invio per eseguire il codice o il comando.

Se si possiedono più sottoscrizioni di Azure, scegliere quella appropriata in cui verranno fatturate le risorse. Selezionare una sottoscrizione specifica usando il cmdlet Set-AzContext.

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

Registrare i provider

Se non è già stato fatto, registrare i provider di risorse seguenti da usare con la sottoscrizione di 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

Definire le variabili

Poiché si useranno ripetutamente alcune informazioni, creare alcune variabili per archiviare tali informazioni:

# 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'

Creare una variabile per l'ID della sottoscrizione di Azure. Per confermare che la variabile subscriptionID contiene l'ID della sottoscrizione, è possibile eseguire la seconda riga dell'esempio seguente:

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

Creare un gruppo di risorse

Creare un Gruppo di risorse di Azure usando il cmdlet New-AzResourceGroup. Un gruppo di risorse è un contenitore logico in cui le risorse di Azure vengono distribuite e gestite come gruppo.

L'esempio seguente crea un gruppo di risorse basato sul nome incluso nella variabile $imageResourceGroup nell'area specificata nella variabile $location. Questo gruppo di risorse viene usato per archiviare l'artefatto del modello di configurazione dell'immagine e l’immagine.

New-AzResourceGroup -Name $imageResourceGroup -Location $location

Creare un'identità utente e impostare le autorizzazioni per il ruolo

Concedere al generatore di immagini di Azure le autorizzazioni per creare immagini nel gruppo di risorse specificato usando l'esempio seguente. Senza questa autorizzazione, il processo di creazione dell'immagine non verrà completato correttamente.

Creare variabili per la definizione del ruolo e i nomi di identità. Questi valori devono essere univoci.

[int]$timeInt = $(Get-Date -UFormat '%s')
$imageRoleDefName = "Azure Image Builder Image Def $timeInt"
$identityName = "myIdentity$timeInt"

Creare un'identità utente.

New-AzUserAssignedIdentity -ResourceGroupName $imageResourceGroup -Name $identityName -Location $location

Archiviare la risorsa di identità e gli ID entità di sicurezza nelle variabili.

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

Assegnare all'identità le autorizzazioni per la distribuzione delle immagini

Scaricare il file di configurazione JSON e quindi modificarlo in base alle impostazioni definite in questo articolo.

$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

Creare la definizione di ruolo.

New-AzRoleDefinition -InputFile $myRoleImageCreationPath

Concedere la definizione del ruolo all'entità servizio Image Builder della macchina virtuale.

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

Nota

Se viene visualizzato l'errore "New-AzRoleDefinition: Limite di definizione del ruolo superato. Non è possibile creare altre definizioni di ruolo", vedere Risolvere i problemi relativi al controllo degli accessi in base al ruolo di Azure.

Creare una Raccolta di calcolo di Azure

Creare la raccolta.

$myGalleryName = 'myImageGallery'
$imageDefName = 'winSvrImages'

New-AzGallery -GalleryName $myGalleryName -ResourceGroupName $imageResourceGroup -Location $location

Creare una definizione della raccolta.

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

Creare un'immagine

Creare un oggetto di origine Image Builder per macchine virtuali. Per i valori dei parametri validi, vedere Trovare immagini di macchine virtuali Windows in Azure Marketplace con Azure PowerShell.

$SrcObjParams = @{
  PlatformImageSource = $true
  Publisher = 'MicrosoftWindowsServer'
  Offer = 'WindowsServer'
  Sku = '2019-Datacenter'
  Version = 'latest'
}
$srcPlatform = New-AzImageBuilderTemplateSourceObject @SrcObjParams

Creare un oggetto di distribuzione Image Builder per macchine virtuali.

$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

Creare un oggetto di personalizzazione Image Builder per macchine virtuali.

$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

Creare un secondo oggetto di personalizzazione Image Builder per macchine virtuali.

$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

Creare un modello di Image Builder per macchine virtuali.

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

Dopo aver creato il modello, viene restituito un messaggio e creato un modello di configurazione di Image Builder per macchine virtuali in $imageResourceGroup.

Per determinare se il processo di creazione del modello è riuscito, usare l'esempio seguente:

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

In background, Image Builder per macchine virtuali crea anche un gruppo di risorse di staging nella sottoscrizione, Questo gruppo di risorse viene usato per la compilazione dell'immagine. che presenta il formato IT_<DestinationResourceGroup>_<TemplateName>.

Avviso

Non eliminare direttamente il gruppo di risorse di staging. Per eliminare il gruppo di risorse di staging, eliminare l'artefatto del modello di immagine.

Se il servizio segnala un errore quando viene inviato il modello di configurazione dell'immagine, eseguire le operazioni seguenti:

Vedere Risoluzione dei problemi di Image Builder per macchine virtuali di Azure.

Prima di riprovare a inviare il modello, eliminarlo seguendo questo esempio:

Remove-AzImageBuilderTemplate -ImageTemplateName $imageTemplateName -ResourceGroupName $imageResourceGroup

Avviare la compilazione dell'immagine

Inviare la configurazione dell'immagine al servizio Image Builder per macchine virtuali eseguendo il comando seguente:

Start-AzImageBuilderTemplate -ResourceGroupName $imageResourceGroup -Name $imageTemplateName

Attendere il completamento del processo di compilazione dell'immagine, che potrebbe richiedere fino a un'ora.

Se si verificano errori, vedere Risoluzione dei problemi di Image Builder per macchine virtuali di Azure.

Creazione di una macchina virtuale

Archiviare le credenziali di accesso della macchina virtuale in una variabile. La password deve essere complessa.
```
$Cred = Get-Credential
```

Creare la macchina virtuale usando l'immagine creata.

$ArtifactId = (Get-AzImageBuilderTemplateRunOutput -ImageTemplateName $imageTemplateName -ResourceGroupName $imageResourceGroup).ArtifactId

New-AzVM -ResourceGroupName $imageResourceGroup -Image $ArtifactId -Name myWinVM01 -Credential $Cred

Verificare le personalizzazioni

Creare una Connessione Desktop remoto alla macchina virtuale usando il nome utente e la password impostati al momento della creazione della macchina virtuale.
All'interno della macchina virtuale, aprire PowerShell ed eseguire Get-Content, come illustrato nell'esempio seguente:
```
Get-Content -Path C:\buildActions\buildActionsOutput.txt
```
L'output si basa sul contenuto del file creato durante il processo di personalizzazione dell'immagine.
```
Azure-Image-Builder-Was-Here
```
Dalla stessa sessione di PowerShell verificare che la seconda personalizzazione sia stata completata correttamente controllando la presenza di c:\buildArtifacts\index.html, come illustrato nell'esempio seguente:
```
Get-ChildItem c:\buildArtifacts\
```
Il risultato deve essere un elenco di directory che mostra che il file è stato scaricato durante il processo di personalizzazione dell'immagine.
```
    Directory: C:\buildArtifacts

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a---          29/01/2021    10:04            276 index.html
```

Pulire le risorse

Se non sono più necessarie le risorse create durante questo processo, è possibile eliminarle eseguendo la procedura seguente:

Eliminare il modello Image Builder per macchine virtuali.

Remove-AzImageBuilderTemplate -ResourceGroupName $imageResourceGroup -Name $imageTemplateName

Eliminare il gruppo di risorse dell’immagine.

Attenzione

L'esempio seguente elimina il gruppo di risorse specificato e tutte le risorse in esso contenute. Se nel gruppo sono presenti risorse che non rientrano nell'ambito di questo articolo, anche queste verranno eliminate.
```
Remove-AzResourceGroup -Name $imageResourceGroup
```

Passaggi successivi

Per altre informazioni sui componenti del file JSON usato in questo articolo, vedere Riferimento del modello Image Builder per macchine virtuali.

Condividi tramite