Configurare un Dev Box usando Azure VM Image Builder e Microsoft Dev Box

2025-04-23

In questo articolo si usa Image Builder di macchine virtuali di Azure per creare una casella di sviluppo personalizzata in Microsoft Dev Box usando un modello. Il modello include un passaggio di personalizzazione per installare Visual Studio Code (VS Code).

L'uso di immagini di macchine virtuali standardizzate consente di garantire distribuzioni coerenti durante la migrazione al cloud. Queste immagini possono includere la sicurezza predefinita, le impostazioni di configurazione e il software necessario. La configurazione di una pipeline di imaging può richiedere molto tempo e complessità. Azure Image Builder per macchine virtuali semplifica questo processo consentendo di creare una configurazione per l'immagine, che il servizio crea e invia a un progetto di dev box.

La creazione di immagini di macchine virtuali personalizzate manualmente o con altri strumenti può essere difficile e inaffidabile. VM Image Builder, basato su Packer di HashiCorp, offre i vantaggi di un servizio gestito.

Per semplificare la creazione delle immagini delle macchine virtuali, VM Image Builder:

Elimina la necessità di strumenti, processi e passaggi manuali complessi. Astrae questi dettagli e nasconde le esigenze specifiche di Azure, ad esempio la generalizzazione dell'immagine (Sysprep), consentendo agli utenti avanzati di eseguire l'override, se necessario.
Funziona con le pipeline di compilazione di immagini esistenti. È possibile chiamare Generatore di Immagini VM dalla pipeline o usare un'attività DevOps del servizio Azure Generatore di Immagini VM.
Raccoglie i dati di personalizzazione da varie origini, quindi non è necessario raccoglierli tutti in un'unica posizione.
Si integra con Azure Compute Gallery, creando un sistema di gestione delle immagini per la distribuzione globale, la replica, il controllo delle versioni e il ridimensionamento. È possibile distribuire la stessa immagine di un disco rigido virtuale o di immagini gestite senza ricompilarle.

Importante

Microsoft Dev Box supporta solo immagini che utilizzano il tipo di sicurezza Avvio protetto abilitato.

Prerequisiti

Per effettuare il provisioning di un'immagine personalizzata creata usando Image Builder di macchine virtuali, è necessario:

Azure PowerShell 6.0 o versione successiva. Se PowerShell non è installato, seguire la procedura descritta in Installare Azure PowerShell in Windows.
Autorizzazioni di proprietario o collaboratore per una sottoscrizione di Azure o per un gruppo di risorse specifico.
Un gruppo di risorse.
Dev Center con una connessione di rete collegata. Se non è disponibile, seguire la procedura descritta in Connettere le caselle di sviluppo alle risorse configurando le connessioni di rete.

Creare un'immagine Windows e distribuirla in Azure Compute Gallery

Il primo passaggio consiste nell'usare Image Builder di macchine virtuali di Azure e Azure PowerShell per creare un'immagine in Azure Compute Gallery e distribuirla a livello globale.

L'esempio seguente usa PowerShell. È anche possibile usare l'interfaccia della riga di comando di Azure.

Per usare VM Image Builder, è necessario registrare le funzionalità.

Controlla le registrazioni del tuo fornitore. Assicurarsi che ogni comando restituisca Registered per la funzionalità specificata.

   Get-AzResourceProvider -ProviderNamespace Microsoft.VirtualMachineImages | Format-table -Property ResourceTypes,RegistrationState 
   Get-AzResourceProvider -ProviderNamespace Microsoft.Storage | Format-table -Property ResourceTypes,RegistrationState  
   Get-AzResourceProvider -ProviderNamespace Microsoft.Compute | Format-table -Property ResourceTypes,RegistrationState 
   Get-AzResourceProvider -ProviderNamespace Microsoft.KeyVault | Format-table -Property ResourceTypes,RegistrationState 
   Get-AzResourceProvider -ProviderNamespace Microsoft.Network | Format-table -Property ResourceTypes,RegistrationState

Se le registrazioni del provider non restituiscono Registered, registrare i provider eseguendo i comandi seguenti:

   Register-AzResourceProvider -ProviderNamespace Microsoft.VirtualMachineImages  
   Register-AzResourceProvider -ProviderNamespace Microsoft.Storage  
   Register-AzResourceProvider -ProviderNamespace Microsoft.Compute  
   Register-AzResourceProvider -ProviderNamespace Microsoft.KeyVault  
   Register-AzResourceProvider -ProviderNamespace Microsoft.Network

Installare i moduli di PowerShell:

'Az.ImageBuilder', 'Az.ManagedServiceIdentity' | ForEach-Object {Install-Module -Name $_ -AllowPrerelease}

Creare variabili per archiviare le informazioni usate più volte.

Copiare il codice di esempio seguente.
Sostituire <Resource group> con il gruppo di risorse usato per creare il dev center.
Eseguire il codice aggiornato in PowerShell.

# Get existing context 
$currentAzContext = Get-AzContext

# Get your current subscription ID  
$subscriptionID=$currentAzContext.Subscription.Id

# Destination image resource group  
$imageResourceGroup="<Resource group>"

# Location  
$location="eastus2"

# Image distribution metadata reference name  
$runOutputName="aibCustWinManImg01"

# Image template name  
$imageTemplateName="vscodeWinTemplate"

Creare un'identità assegnata dall'utente e impostare le autorizzazioni per il gruppo di risorse eseguendo il codice seguente in PowerShell.

VM Image Builder utilizza l'identità utente specificata per archiviare l'immagine in Azure Compute Gallery. L'esempio seguente crea una definizione di ruolo di Azure con azioni specifiche per la distribuzione dell'immagine. La definizione del ruolo viene quindi assegnata all'identità utente.

# Set up role definition names, which need to be unique 
$timeInt=$(get-date -UFormat "%s") 
$imageRoleDefName="Azure Image Builder Image Def"+$timeInt 
$identityName="aibIdentity"+$timeInt 

# Add an Azure PowerShell module to support AzUserAssignedIdentity 
Install-Module -Name Az.ManagedServiceIdentity 

# Create an identity 
New-AzUserAssignedIdentity -ResourceGroupName $imageResourceGroup -Name $identityName -Location $location

$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.

Usare questo comando per scaricare un modello di definizione del ruolo di Azure e aggiornarlo con i parametri specificati in precedenza:

$aibRoleImageCreationUrl="https://raw.githubusercontent.com/azure/azvmimagebuilder/master/solutions/12_Creating_AIB_Security_Roles/aibRoleImageCreation.json" 
$aibRoleImageCreationPath = "aibRoleImageCreation.json" 

# Download the configuration 
Invoke-WebRequest -Uri $aibRoleImageCreationUrl -OutFile $aibRoleImageCreationPath -UseBasicParsing 
((Get-Content -path $aibRoleImageCreationPath -Raw) -replace '<subscriptionID>',$subscriptionID) | Set-Content -Path $aibRoleImageCreationPath 
((Get-Content -path $aibRoleImageCreationPath -Raw) -replace '<rgName>', $imageResourceGroup) | Set-Content -Path $aibRoleImageCreationPath 
((Get-Content -path $aibRoleImageCreationPath -Raw) -replace 'Azure Image Builder Service Image Creation Role', $imageRoleDefName) | Set-Content -Path $aibRoleImageCreationPath 

# Create a role definition 
New-AzRoleDefinition -InputFile  ./aibRoleImageCreation.json

# Grant the role definition to the VM Image Builder service principal 
New-AzRoleAssignment -ObjectId $identityNamePrincipalId -RoleDefinitionName $imageRoleDefName -Scope "/subscriptions/$subscriptionID/resourceGroups/$imageResourceGroup"

Creare una galleria

Per usare Image Builder per macchine virtuali con la Raccolta di calcolo di Azure, assicurarsi di avere una raccolta esistente e una definizione di immagine. VM Image Builder non crea la galleria e la definizione di immagine per te.

Eseguire i comandi seguenti per creare una nuova raccolta e una nuova definizione di immagine.

Questo codice crea una definizione con il tipo di sicurezza avvio attendibile e soddisfa i requisiti dell'immagine di Windows 365.

# Gallery name 
$galleryName= "devboxGallery" 

# Image definition name 
$imageDefName ="vscodeImageDef" 

# Additional replication region 
$replRegion2="eastus" 

# Create the gallery 
New-AzGallery -GalleryName $galleryName -ResourceGroupName $imageResourceGroup -Location $location 

$SecurityType = @{Name='SecurityType';Value='TrustedLaunch'} 
$features = @($SecurityType) 

# Create the image definition
New-AzGalleryImageDefinition -GalleryName $galleryName -ResourceGroupName $imageResourceGroup -Location $location -Name $imageDefName -OsState generalized -OsType Windows -Publisher 'myCompany' -Offer 'vscodebox' -Sku '1-0-0' -Feature $features -HyperVGeneration "V2"

Creare un file per archiviare la definizione del modello, ad esempio c:/temp/mytemplate.txt.

Copiare il seguente modello di Azure Resource Manager per VM Image Builder nel tuo nuovo file modello.

Questo modello indica l'immagine di origine e le personalizzazioni applicate. Installa Choco e VS Code e indica anche il percorso di distribuzione delle immagini.

{
   "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
   "contentVersion": "1.0.0.0",
   "parameters": {
     "imageTemplateName": {
      "type": "string"
     },
     "api-version": {
      "type": "string"
     },
     "svclocation": {
      "type": "string"
     }
   },
   "variables": {},
   "resources": [
     {
      "name": "[parameters('imageTemplateName')]",
      "type": "Microsoft.VirtualMachineImages/imageTemplates",
      "apiVersion": "[parameters('api-version')]",
      "location": "[parameters('svclocation')]",
      "dependsOn": [],
      "tags": {
        "imagebuilderTemplate": "win11multi",
        "userIdentity": "enabled"
      },
      "identity": {
        "type": "UserAssigned",
        "userAssignedIdentities": {
         "<imgBuilderId>": {}
        }
      },
      "properties": {
        "buildTimeoutInMinutes": 100,
        "vmProfile": {
         "vmSize": "Standard_DS2_v2",
         "osDiskSizeGB": 127
        },
      "source": {
         "type": "PlatformImage",
         "publisher": "MicrosoftWindowsDesktop",
         "offer": "Windows-11",
         "sku": "win11-21h2-ent",
         "version": "latest"
      },
        "customize": [
         {
            "type": "PowerShell",
            "name": "Install Choco and VS Code",
            "inline": [
               "Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))",
               "choco install -y vscode"
            ]
         }
        ],
         "distribute": 
         [
            {   
               "type": "SharedImage",
               "galleryImageId": "/subscriptions/<subscriptionID>/resourceGroups/<rgName>/providers/Microsoft.Compute/galleries/<sharedImageGalName>/images/<imageDefName>",
               "runOutputName": "<runOutputName>",
               "artifactTags": {
                  "source": "azureVmImageBuilder",
                  "baseosimg": "win11multi"
               },
               "replicationRegions": [
                 "<region1>",
                 "<region2>"
               ]
            }
         ]
      }
     }
   ]
  }

Chiudere il file del modello prima di procedere al passaggio successivo.

Configurare il nuovo modello con le variabili.

Sostituire <Template Path> con il percorso del file modello, ad esempio c:/temp/mytemplate.

$templateFilePath = <Template Path>

(Get-Content -path $templateFilePath -Raw ) -replace '<subscriptionID>',$subscriptionID | Set-Content -Path $templateFilePath 
(Get-Content -path $templateFilePath -Raw ) -replace '<rgName>',$imageResourceGroup | Set-Content -Path $templateFilePath 
(Get-Content -path $templateFilePath -Raw ) -replace '<runOutputName>',$runOutputName | Set-Content -Path $templateFilePath  
(Get-Content -path $templateFilePath -Raw ) -replace '<imageDefName>',$imageDefName | Set-Content -Path $templateFilePath  
(Get-Content -path $templateFilePath -Raw ) -replace '<sharedImageGalName>',$galleryName| Set-Content -Path $templateFilePath  
(Get-Content -path $templateFilePath -Raw ) -replace '<region1>',$location | Set-Content -Path $templateFilePath  
(Get-Content -path $templateFilePath -Raw ) -replace '<region2>',$replRegion2 | Set-Content -Path $templateFilePath  
((Get-Content -path $templateFilePath -Raw) -replace '<imgBuilderId>',$identityNameResourceId) | Set-Content -Path $templateFilePath

Inviare il modello al servizio.

Il comando seguente scarica tutti gli artefatti dipendenti, ad esempio gli script, e li archivia nel gruppo di risorse di staging. Il gruppo di risorse di staging è preceduto da IT_.
```
New-AzResourceGroupDeployment  -ResourceGroupName $imageResourceGroup  -TemplateFile $templateFilePath  -Api-Version "2020-02-14"  -imageTemplateName $imageTemplateName  -svclocation $location 
```
Compilare l'immagine richiamando il Run comando nel modello:

Al prompt per confermare il processo di esecuzione immettere Sì.
```
Invoke-AzResourceAction  -ResourceName $imageTemplateName  -ResourceGroupName $imageResourceGroup  -ResourceType Microsoft.VirtualMachineImages/imageTemplates  -ApiVersion "2020-02-14"  -Action Run
```
Importante

La creazione dell'immagine e la relativa replica in entrambe le aree possono richiedere del tempo. Potresti vedere una differenza nel reporting del progresso tra PowerShell e il portale di Azure. Prima di iniziare a creare una definizione di dev box, attendere il completamento del processo.

Ottenere informazioni sull'immagine appena creata, tra cui lo stato di esecuzione e lo stato di provisioning.

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

Output di esempio:

Name                 LastRunStatusRunState    LastRunStatusMessage   ProvisioningState
---------------------------------------------------------------------------------------
vscodeWinTemplate                                                    Creating

È anche possibile visualizzare lo stato di provisioning dell'immagine nel portale di Azure. Passare alla raccolta e visualizzare la definizione dell'immagine.

Configurare la galleria

Quando l'immagine personalizzata viene archiviata nella raccolta, è possibile configurare la raccolta per l'uso delle immagini nel dev center. Per ulteriori informazioni, vedere Configurazione della Galleria Compute di Azure.

Configurare Microsoft Dev Box con un'immagine personalizzata

Quando le immagini della raccolta sono disponibili nel dev center, è possibile usare l'immagine personalizzata con Microsoft Dev Box. Per altre informazioni, vedere Avvio rapido: Configurare Microsoft Dev Box.

Creare una definizione di box di sviluppo

Condividi tramite

Configurare un Dev Box usando Azure VM Image Builder e Microsoft Dev Box

Prerequisiti

Creare un'immagine Windows e distribuirla in Azure Compute Gallery

Creare una galleria

Configurare la galleria

Configurare Microsoft Dev Box con un'immagine personalizzata

Contenuto correlato

Commenti e suggerimenti

Risorse aggiuntive