Creare una VM da una versione dell'immagine generalizzata

Elencare le definizioni di immagine in una raccolta usando az sig image-definition list per visualizzare il nome e l'ID delle definizioni.

resourceGroup=myGalleryRG
gallery=myGallery
az sig image-definition list --resource-group $resourceGroup --gallery-name $gallery --query "[].[name, id]" --output tsv

Creare una macchina virtuale usando il comando az vm create. Per usare la versione più recente dell'immagine, impostare --image sull'ID della definizione dell'immagine.

Questo esempio riguarda la creazione di una macchina virtuale Linux protetta con SSH. Per Windows o per proteggere una macchina virtuale Linux con una password, rimuovere --generate-ssh-keys per richiedere una password. Se si vuole specificare direttamente una password, sostituire --generate-ssh-keys con --admin-password. Sostituire i nomi delle risorse di questo esempio secondo necessità.

imgDef="/subscriptions/<subscription ID where the gallery is located>/resourceGroups/myGalleryRG/providers/Microsoft.Compute/galleries/myGallery/images/myImageDefinition"
vmResourceGroup=myResourceGroup
location=eastus
vmName=myVM
adminUsername=azureuser

az group create --name $vmResourceGroup --location $location

az vm create\
   --resource-group $vmResourceGroup \
   --name $vmName \
   --image $imgDef \
   --admin-username $adminUsername \
   --generate-ssh-keys

È anche possibile usare una versione specifica usando l'ID versione dell'immagine per il parametro --image. Ad esempio, per usare la versione dell'immagine 1.0.0 tipo: --image "/subscriptions/<subscription ID where the gallery is located>/resourceGroups/myGalleryRG/providers/Microsoft.Compute/galleries/myGallery/images/myImageDefinition/versions/1.0.0".

Dopo aver creato una versione generalizzata dell'immagine, è possibile creare una o più nuove macchine virtuali. usando il cmdlet New-AzVM.

In questo esempio viene usato l'ID definizione dell'immagine per assicurarsi che la nuova macchina virtuale usi la versione più recente di un'immagine. È anche possibile usare una versione specifica tramite l'ID versione dell'immagine per Set-AzVMSourceImage -Id. Ad esempio, per usare la versione dell'immagine 1.0.0 tipo: Set-AzVMSourceImage -Id "/subscriptions/<subscription ID where the gallery is located>/resourceGroups/myGalleryRG/providers/Microsoft.Compute/galleries/myGallery/images/myImageDefinition/versions/1.0.0".

Ricordare che l'uso di una versione specifica dell'immagine significa che l'automazione potrebbe non riuscire se tale versione specifica dell'immagine non è disponibile perché è stata eliminata o rimossa dall'area. È consigliabile usare l'ID definizione dell'immagine per la creazione della nuova macchina virtuale, a meno che non sia necessaria una versione specifica dell'immagine.

Sostituire i nomi delle risorse di questi esempi secondo necessità.

Set di parametri semplificato

È possibile usare il set di parametri semplificato per creare rapidamente una macchina virtuale da un'immagine. Il set di parametri semplificato usa il nome della macchina virtuale per creare automaticamente alcune delle risorse necessarie, ad esempio la rete virtuale e l'indirizzo IP pubblico.

# Create some variables for the new VM 
$resourceGroup = "myResourceGroup"
$location = "South Central US"
$vmName = "myVMfromImage"

# Get the image. Replace the name of your resource group, gallery, and image definition. This will create the VM from the latest image version available.

$imageDefinition = Get-AzGalleryImageDefinition `
   -GalleryName myGallery `
   -ResourceGroupName myResourceGroup `
   -Name myImageDefinition

# Create user object
$cred = Get-Credential `
   -Message "Enter a username and password for the virtual machine."

# Create a resource group
New-AzResourceGroup `
   -Name $resourceGroup `
   -Location $location

New-AzVM `
   -ResourceGroupName $resourceGroup `
   -Location $location `
   -Name $vmName `
   -Image $imageDefinition.Id
   -Credential $cred

Set di parametri completo

È possibile creare una macchina virtuale usando risorse specifiche usando il set di parametri completo.

# Create some variables for the new VM 
$resourceGroup = "myResourceGroup"
$location = "South Central US"
$vmName = "myVMfromImage"

# Get the image. Replace the name of your resource group, gallery, and image definition. This will create the VM from the latest image version available.

$imageDefinition = Get-AzGalleryImageDefinition `
   -GalleryName myGallery `
   -ResourceGroupName myResourceGroup `
   -Name myImageDefinition

# Create user object
$cred = Get-Credential `
   -Message "Enter a username and password for the virtual machine."

# Create a resource group
New-AzResourceGroup `
   -Name $resourceGroup `
   -Location $location

# Network pieces
$subnetConfig = New-AzVirtualNetworkSubnetConfig `
   -Name mySubnet `
   -AddressPrefix 192.168.1.0/24
$vnet = New-AzVirtualNetwork `
   -ResourceGroupName $resourceGroup `
   -Location $location `
   -Name MYvNET `
   -AddressPrefix 192.168.0.0/16 `
   -Subnet $subnetConfig
$pip = New-AzPublicIpAddress `
   -ResourceGroupName $resourceGroup `
   -Location $location `
  -Name "mypublicdns$(Get-Random)" `
  -AllocationMethod Static `
  -IdleTimeoutInMinutes 4
$nsgRuleRDP = New-AzNetworkSecurityRuleConfig `
   -Name myNetworkSecurityGroupRuleRDP  `
   -Protocol Tcp `
  -Direction Inbound `
   -Priority 1000 `
   -SourceAddressPrefix * `
   -SourcePortRange * `
   -DestinationAddressPrefix * `
   -DestinationPortRange 3389 `
   -Access Deny
$nsg = New-AzNetworkSecurityGroup `
   -ResourceGroupName $resourceGroup `
   -Location $location `
  -Name myNetworkSecurityGroup `
  -SecurityRules $nsgRuleRDP
$nic = New-AzNetworkInterface `
   -Name myNic `
   -ResourceGroupName $resourceGroup `
   -Location $location `
  -SubnetId $vnet.Subnets[0].Id `
  -PublicIpAddressId $pip.Id `
  -NetworkSecurityGroupId $nsg.Id

# Create a virtual machine configuration using $imageDefinition.Id to use the latest image version.
$vmConfig = New-AzVMConfig `
   -VMName $vmName `
   -VMSize Standard_D1_v2 | `
   Set-AzVMOperatingSystem -Windows -ComputerName $vmName -Credential $cred | `
   Set-AzVMSourceImage -Id $imageDefinition.Id | `
   Add-AzVMNetworkInterface -Id $nic.Id

# Create a virtual machine
New-AzVM `
   -ResourceGroupName $resourceGroup `
   -Location $location `
   -VM $vmConfig

Questo comando crea una rete virtuale.

PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{vNetName}?api-version=2020-05-01

{
    "properties": {
        "addressSpace": {
            "addressPrefixes": [
                "10.0.0.0/16"
            ]
        }
    },
    "location": "eastus"
}

Creare una subnet.

PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{vNetName}/subnets/{subnetName}?api-version=2020-05-01

{
    "properties": {
        "addressPrefix": "10.0.0.0/16"
    },
}

Creare un indirizzo IP pubblico.

PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/{pIPName}?api-version=2020-11-01

{
  "location": "eastus"
}

Creare un gruppo di sicurezza di rete.

# @name vmNSG
PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{nsgName}?api-version=2020-11-01

{
  "properties": {
    "securityRules": [
      {
        "name": "AllowSSH",
        "properties": {
          "protocol": "Tcp",
          "sourceAddressPrefix": "*",
          "destinationAddressPrefix": "*",
          "access": "Deny",
          "destinationPortRange": "3389",
          "sourcePortRange": "*",
          "priority": 1000,
          "direction": "Inbound"
        }
      }
    ]
  },
  "location": "eastus"
}

Creare una scheda di interfaccia di rete.

# @name vmNIC
PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{nicName}?api-version=2020-05-01

{
    "properties": {
        "enableAcceleratedNetworking": true,
        "networkSecurityGroup": {
          "id": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{nsgName}"
        },
        "ipConfigurations": [
            {
                "name": "ipconfig1",
                "properties": {
                    "subnet": {
                        "id": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{vNetName}/subnets/{subNetName}",
                    },
                    "publicIPAddress": {
                        "id": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/{pipName}"
          }
                }
            }
        ]
    },
    "location": "eastus",
}

Creare una macchina virtuale Linux. La sezione oSProfile contiene alcuni dettagli specifici del sistema operativo. Vedere l'esempio di codice successivo per la sintassi di Windows.

# @name vm
PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}?api-version=2020-06-01

{
    "location": "eastus",
    "properties": {
        "hardwareProfile": {
            "vmSize": "Standard_DS3_v2"
        },
        "storageProfile": {
            "imageReference": {
                "id": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/images/{galleryImageName}/versions/{versionNumber}"
            },
            "osDisk": {
                "caching": "ReadWrite",
                "managedDisk": {
                    "storageAccountType": "StandardSSD_LRS"
                },
                "createOption": "FromImage"
            }
        },
        "osProfile": {
            "adminUsername": "{your-username}",
            "computerName": "myVM",
            "linuxConfiguration": {
                "ssh": {
                    "publicKeys": [
                        {
                            "path": "/home/{your-username}/.ssh/authorized_keys",
                            "keyData": "{sshKey}",
                        }
                    ]
                },
                "disablePasswordAuthentication": true
            }
        },
        "networkProfile": {
            "networkInterfaces": [
                {
                    "id": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{nicName}",
                }
            ]
        }
    },
}

Creare una VM Windows.

# @name vm
PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}?api-version=2020-06-01

{
    "location": "eastus",
    "properties": {
        "hardwareProfile": {
            "vmSize": "Standard_DS3_v2"
        },
        "storageProfile": {
            "imageReference": {
                "id": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/images/{galleryImageName}/versions/{versionNumber}"
            },
            "osDisk": {
                "caching": "ReadWrite",
                "managedDisk": {
                    "storageAccountType": "StandardSSD_LRS"
                },
                "createOption": "FromImage"
            }
        },
        "osProfile": {
            "adminUsername": "{your-username}",
            "computerName": "myVM",
            "adminPassword": "{your-password}"
        },
        "networkProfile": {
            "networkInterfaces": [
                {
                    "id": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{nicName}",
                }
            ]
        }
    },

È ora possibile creare una o più nuove macchine virtuali. Questo esempio crea una macchina virtuale denominata myVM in myResourceGroup nel datacenter Stati Uniti orientali.

1. Passare alla definizione dell'immagine. È possibile usare il filtro delle risorse per visualizzare tutte le definizioni di immagine disponibili.
2. Nella pagina per la definizione dell'immagine selezionare Crea macchina virtuale dal menu nella parte superiore della pagina.
3. In Gruppo di risorse selezionare Crea nuovo e digitare myResourceGroup come nome.
4. In Nome macchina virtuale digitare myVM.
5. In Area selezionare Stati Uniti orientali.
6. Per Opzioni di disponibilità, lasciare l'impostazione predefinita Nessuna ridondanza dell'infrastruttura richiesta.
7. Il valore per Immagine viene compilato automaticamente con la versione dell'immagine latest se si è avviata l'operazione dalla pagina per la definizione dell'immagine.
8. Per Dimensioni, scegliere una dimensione della macchina virtuale dall'elenco delle dimensioni disponibili e quindi scegliere Seleziona.
9. In Account amministratore è necessario specificare un nome utente, ad esempio azureuser e una password o una chiave SSH. La password deve contenere almeno 12 caratteri e soddisfare i requisiti di complessità definiti.
10. Se si vuole consentire l'accesso remoto alla macchina virtuale, in Porte in ingresso pubbliche scegliere Consenti porte selezionate e quindi selezionare SSH (22) o RDP (3389) dall'elenco a discesa. Se non si vuole consentire l'accesso remoto alla macchina virtuale, lasciare selezionata l'opzione Nessuna per Porte in ingresso pubbliche.
11. Una volta fatto, selezionare quindi il pulsante Rivedi e crea nella parte inferiore della pagina.
12. Dopo aver superato la convalida della macchina virtuale, selezionare Crea nella parte inferiore della pagina per avviare la distribuzione.

Assicurarsi che lo stato dell'immagine sia Generalized. Se si vuole usare un'immagine con lo stato Specialized, vedere Creare una macchina virtuale da una versione specializzata dell'immagine.

imgDef="/SharedGalleries/1a2b3c4d-1234-abcd-1234-1a2b3c4d5e6f-MYDIRECTSHARED/Images/myDirectDefinition/Versions/latest"
vmResourceGroup=myResourceGroup
location=westus
vmName=myVM
adminUsername=azureuser

az group create --name $vmResourceGroup --location $location

az vm create\
   --resource-group $vmResourceGroup \
   --name $vmName \
   --image $imgDef \
   --admin-username $adminUsername \
   --generate-ssh-keys

Creare la macchina virtuale. Sostituire le informazioni nell'esempio con le proprie. Prima di creare la macchina virtuale, assicurarsi che l'immagine venga replicata nell'area in cui si vuole creare la macchina virtuale.

$resourceGroup = "myResourceGroup"
$location = "South Central US"
$vmName = "myVMfromImage"

# Set a variable for the image version in Tenant 1 using the full image ID of the image version
$image = "/subscriptions/<Tenant 1 subscription>/resourceGroups/<Resource group>/providers/Microsoft.Compute/galleries/<Gallery>/images/<Image definition>/versions/<version>"

# Create user object
$cred = Get-Credential -Message "Enter a username and password for the virtual machine."

# Create a resource group
New-AzResourceGroup -Name $resourceGroup -Location $location

# Networking pieces
$subnetConfig = New-AzVirtualNetworkSubnetConfig -Name mySubnet -AddressPrefix 192.168.1.0/24
$vnet = New-AzVirtualNetwork -ResourceGroupName $resourceGroup -Location $location `
  -Name MYvNET -AddressPrefix 192.168.0.0/16 -Subnet $subnetConfig
$pip = New-AzPublicIpAddress -ResourceGroupName $resourceGroup -Location $location `
  -Name "mypublicdns$(Get-Random)" -AllocationMethod Static -IdleTimeoutInMinutes 4
$nsgRuleRDP = New-AzNetworkSecurityRuleConfig -Name myNetworkSecurityGroupRuleRDP  -Protocol Tcp `
  -Direction Inbound -Priority 1000 -SourceAddressPrefix * -SourcePortRange * -DestinationAddressPrefix * `
  -DestinationPortRange 3389 -Access Allow
$nsg = New-AzNetworkSecurityGroup -ResourceGroupName $resourceGroup -Location $location `
  -Name myNetworkSecurityGroup -SecurityRules $nsgRuleRDP
$nic = New-AzNetworkInterface -Name myNic -ResourceGroupName $resourceGroup -Location $location `
  -SubnetId $vnet.Subnets[0].Id -PublicIpAddressId $pip.Id -NetworkSecurityGroupId $nsg.Id

# Create a virtual machine configuration using the $image variable to specify the image
$vmConfig = New-AzVMConfig -VMName $vmName -VMSize Standard_D1_v2 | `
Set-AzVMOperatingSystem -Windows -ComputerName $vmName -Credential $cred | `
Set-AzVMSourceImage -Id $image | `
Add-AzVMNetworkInterface -Id $nic.Id

# Create a virtual machine
New-AzVM -ResourceGroupName $resourceGroup -Location $location -VM $vmConfig

In questo esempio viene illustrato come creare una macchina virtuale da un'immagine generalizzata. Per usare un'immagine specializzata, vedere Creare una macchina virtuale usando una versione generalizzata dell'immagine.

È necessario accedere al tenant in cui è archiviata l'immagine, ottenere un token di accesso, quindi accedere al tenant in cui si vuole creare la macchina virtuale. In questo caso, tenant1 è la posizione in cui è archiviata l'immagine e tenant2 è la posizione in cui si vuole creare la macchina virtuale. Questo è il modo in cui Azure autentica e verifica che l'utente ha accesso all'immagine.

tenant1='<ID for tenant 1>'
tenant2='<ID for tenant 2>'

az account clear
az login --tenant $tenant1
az account get-access-token 
az login --tenant $tenant2
az account get-access-token

Creare la macchina virtuale. Sostituire le informazioni nell'esempio con le proprie. Prima di creare la macchina virtuale, assicurarsi che l'immagine venga replicata nell'area in cui si vuole creare la macchina virtuale.

imageid="<ID of the image that you want to use>"
resourcegroup="<name for the resource group>"
location="<location where the image is replicated>"
user='<username for the VM>'
name='<name for the VM>'

az group create --location $location --resource-group $resourcegroup
az vm create \
  --resource-group $resourcegroup \
  --name $name \
  --image $imageid \
  --admin-username $user \
  --generate-ssh-keys

In questo esempio viene illustrato come creare una macchina virtuale da un'immagine generalizzata. Per usare un'immagine specializzata, vedere Creare una macchina virtuale usando una versione generalizzata dell'immagine.

È necessario accedere al tenant in cui è archiviata l'immagine, ottenere un token di accesso, quindi accedere al tenant in cui si vuole creare la macchina virtuale. In questo caso, tenant1 è la posizione in cui è archiviata l'immagine e tenant2 è la posizione in cui si vuole creare la macchina virtuale. Questo è il modo in cui Azure autentica e verifica che l'utente ha accesso all'immagine.

$tenant1 = "<Tenant 1 ID>"
$tenant2 = "<Tenant 2 ID>"
Connect-AzAccount -Tenant "<Tenant 1 ID>" -UseDeviceAuthentication
Connect-AzAccount -Tenant "<Tenant 2 ID>" -UseDeviceAuthentication

Creare la macchina virtuale. Sostituire le informazioni nell'esempio con le proprie. Prima di creare la macchina virtuale, assicurarsi che l'immagine venga replicata nell'area in cui si vuole creare la macchina virtuale.

$resourceGroup = "myResourceGroup"
$location = "South Central US"
$vmName = "myVMfromImage"

# Set a variable for the image version in Tenant 1 using the full image ID of the image version
$image = "/subscriptions/<Tenant 1 subscription>/resourceGroups/<Resource group>/providers/Microsoft.Compute/galleries/<Gallery>/images/<Image definition>/versions/<version>"

# Create user object
$cred = Get-Credential -Message "Enter a username and password for the virtual machine."

# Create a resource group
New-AzResourceGroup -Name $resourceGroup -Location $location

# Networking pieces
$subnetConfig = New-AzVirtualNetworkSubnetConfig -Name mySubnet -AddressPrefix 192.168.1.0/24
$vnet = New-AzVirtualNetwork -ResourceGroupName $resourceGroup -Location $location `
  -Name MYvNET -AddressPrefix 192.168.0.0/16 -Subnet $subnetConfig
$pip = New-AzPublicIpAddress -ResourceGroupName $resourceGroup -Location $location `
  -Name "mypublicdns$(Get-Random)" -AllocationMethod Static -IdleTimeoutInMinutes 4
$nsgRuleRDP = New-AzNetworkSecurityRuleConfig -Name myNetworkSecurityGroupRuleRDP  -Protocol Tcp `
  -Direction Inbound -Priority 1000 -SourceAddressPrefix * -SourcePortRange * -DestinationAddressPrefix * `
  -DestinationPortRange 3389 -Access Allow
$nsg = New-AzNetworkSecurityGroup -ResourceGroupName $resourceGroup -Location $location `
  -Name myNetworkSecurityGroup -SecurityRules $nsgRuleRDP
$nic = New-AzNetworkInterface -Name myNic -ResourceGroupName $resourceGroup -Location $location `
  -SubnetId $vnet.Subnets[0].Id -PublicIpAddressId $pip.Id -NetworkSecurityGroupId $nsg.Id

# Create a virtual machine configuration using the $image variable to specify the image
$vmConfig = New-AzVMConfig -VMName $vmName -VMSize Standard_D1_v2 | `
Set-AzVMOperatingSystem -Windows -ComputerName $vmName -Credential $cred | `
Set-AzVMSourceImage -Id $image | `
Add-AzVMNetworkInterface -Id $nic.Id

# Create a virtual machine
New-AzVM -ResourceGroupName $resourceGroup -Location $location -VM $vmConfig

Per creare una macchina virtuale usando un'immagine condivisa in una raccolta community, usare l'ID univoco dell'immagine per --image, che sarà nel formato seguente:

/CommunityGalleries/<community gallery name, like: ContosoImages-1a2b3c4d-1234-abcd-1234-1a2b3c4d5e6f>/Images/<image name>/Versions/latest

Seguire queste istruzioni per ottenere l'elenco delle immagini della community tramite l'interfaccia della riga di comando:

Step 1:  Show all 'Community images' in a specific location
az sig list-community --location westus2

Step 2: Once you have the public gallery name from Step 1, Get the Image definition (Name) of the image by running the following command
az sig image-definition list-community --public-gallery-name <<public gallery name>> --location westus2

Step 3: Finally, run the following command to list different image versions available for the specific image
az sig image-version list-community --public-gallery-name <<galleryname>> --gallery-image-definition <<image name>> --location westus2

Per ottenere il nome pubblico di una raccolta community dal portale. Passare a Macchine virtuali>Crea>Macchina virtuale di Azure>Immagine>Visualizza tutte le immagini>Immagini della community>Nome della raccolta pubblica.

In questo esempio si crea una macchina virtuale da un'immagine Linux e si creano chiavi SSH per l'autenticazione.

imgDef="/CommunityGalleries/ContosoImages-1a2b3c4d-1234-abcd-1234-1a2b3c4d5e6f>/Images/myLinuxImage/Versions/latest"
vmResourceGroup=myResourceGroup
location=eastus
vmName=myVM
adminUsername=azureuser

az group create --name $vmResourceGroup --location $location

az vm create\
   --resource-group $vmResourceGroup \
   --name $vmName \
   --image $imgDef \
   --admin-username $adminUsername \
   --generate-ssh-keys

Quando si usa un'immagine della community, verrà richiesto di accettare le condizioni legali. Il messaggio è simile al seguente:

To create the VM from community gallery image, you must accept the license agreement and privacy statement: http://contoso.com. (If you want to accept the legal terms by default, please use the option '--accept-term' when creating VM/VMSS) (Y/n): 

Ottenere l'ID della versione dell'immagine. Il valore verrà usato nella richiesta di distribuzione della macchina virtuale.

GET 
https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.Compute/Locations/{location}/CommunityGalleries/{CommunityGalleryPublicName}/Images/{galleryImageName}/Versions/{1.0.0}?api-version=2021-07-01 

Risposta:

"location": "West US",
  "identifier": {
    "uniqueId": "/CommunityGalleries/{PublicGalleryName}/Images/{imageName}/Versions/{verionsName}"
  },
  "name": "1.0.0"

È ora possibile distribuire la macchina virtuale. L'esempio richiede l'API versione 2021-07-01 o successiva.

PUT 
https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{rg}/providers/Microsoft.Compute/virtualMachines/{VMName}?api-version=2021-03-01   
{ 
 	"location": "{location}", 
 	"properties": { 
 	 	"hardwareProfile": { 
 	 	 	"vmSize": "Standard_D1_v2" 
 	 	}, 
 	 	"storageProfile": { 
 	 	 	"imageReference": { 
 	 	 	 	"communityGalleryImageId":"/communityGalleries/{publicGalleryName}/images/{galleryImageName}/versions/1.0.0" 
 	 	 	}, 
 	 	 	"osDisk": { 
 	 	 	 	"caching": "ReadWrite", 
 	 	 	 	"managedDisk": { 
 	 	 	 	 	"storageAccountType": "Standard_LRS" 
 	 	 	 	}, 
 	 	 	 	"name": "myVMosdisk", 
 	 	 	 	"createOption": "FromImage" 
 	 	 	} 
   	}, 
 	 	"osProfile": { 
 	 	 	"adminUsername": "azureuser", 
 	 	 	"computerName": "myVM", 
 	 	 	"adminPassword": "{password}}" 
 	 	}, 
 	 	"networkProfile": { 
 	 	 	"networkInterfaces": [ 
 	 	 	 	{ 
 	 	 	 	 	"id": "/subscriptions/00000000-0000-0000-0000-
000000000000/resourceGroups/{rg}/providers/Microsoft.Network/networkInterfaces/{networkIntefaceName}", 
 	 	 	 	 	"properties": { 
 	 	 	 	 	 	"primary": true 
 	 	 	 	 	} 
 	 	 	 	} 
 	 	 	] 
 	 	} 
 	} 
} 

1. Digitare Immagini della community nella ricerca.
2. In Servizi selezionare Immagini della community.
3. Selezionare l'immagine nell'elenco delle immagini disponibili. È possibile usare il filtro per restringere l'elenco in base alle esigenze.
4. Nella pagina dell'immagine selezionare Crea macchina virtuale. Viene visualizzata la pagina Crea una macchina virtuale con il valore Immagine selezionato.
5. Nella scheda Informazioni di base, in Dettagli progetto verificare che sia selezionata la sottoscrizione corretta e quindi scegliere Crea nuovo gruppo di risorse o selezionarne uno nell'elenco a discesa.
6. In Dettagli istanza digitare un nome per il Nome della macchina virtuale.
7. Completare le altre opzioni e quindi selezionare il pulsante Rivedi e crea nella parte inferiore della pagina.
8. Nella pagina Crea macchina virtuale è possibile visualizzare i dettagli sulla macchina virtuale che si sta creando. Al termine, selezionare Crea.

Per creare una macchina virtuale usando un'immagine condivisa nella sottoscrizione o nel tenant, è necessario l'ID univoco dell'immagine nel formato seguente:

/SharedGalleries/<uniqueID>/Images/<image name>/Versions/latest

Per trovare il valore uniqueID di una raccolta condivisa con l'utente, usare az sig list-shared. In questo esempio si stanno cercando raccolte nell'area Stati Uniti occidentali.

region=westus
az sig list-shared --location $region --query "[].name" -o tsv

Usare il nome della raccolta per trovare le immagini disponibili. In questo esempio vengono elencate tutte le immagini in Stati Uniti occidentali e, in base al nome, l'ID univoco necessario per creare una macchina virtuale, un sistema operativo e uno stato del sistema operativo.

galleryName="1a2b3c4d-1234-abcd-1234-1a2b3c4d5e6f-myDirectShared"
 az sig image-definition list-shared \
   --gallery-unique-name $galleryName \
   --location $region \
   --query [*]."{Name:name,ID:uniqueId,OS:osType,State:osState}" -o table

Assicurarsi che lo stato dell'immagine sia Generalized. Se si vuole usare un'immagine con lo stato Specialized, vedere Creare una macchina virtuale da una versione specializzata dell'immagine.

Usare il valore Id dell'output, con /Versions/latest aggiunto per usare la versione più recente, come valore per --image per creare una macchina virtuale. In questo esempio viene creata una macchina virtuale da un'immagine Linux condivisa direttamente e si creano chiavi SSH per l'autenticazione.

imgDef="/SharedGalleries/1a2b3c4d-1234-abcd-1234-1a2b3c4d5e6f-MYDIRECTSHARED/Images/myDirectDefinition/Versions/latest"
vmResourceGroup=myResourceGroup
location=westus
vmName=myVM
adminUsername=azureuser

az group create --name $vmResourceGroup --location $location

az vm create\
   --resource-group $vmResourceGroup \
   --name $vmName \
   --image $imgDef \
   --admin-username $adminUsername \
   --generate-ssh-keys

Ottenere l'ID della versione dell'immagine. Il valore verrà usato nella richiesta di distribuzione della macchina virtuale.

GET 
https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.Compute/Locations/{location}/sharedGalleries/{galleryUniqueName}/Images/{galleryImageName}/Versions/{1.0.0}?api-version=2021-07-01 

Risposta:

"location": "West US",
  "identifier": {
    "uniqueId": "/sharedGalleries/{PublicGalleryName}/Images/{imageName}/Versions/{verionsName}"
  },
  "name": "1.0.0"

È ora possibile distribuire la macchina virtuale. L'esempio richiede l'API versione 2021-07-01 o successiva.

PUT 
https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{rg}/providers/Microsoft.Compute/virtualMachines/{VMName}?api-version=2021-03-01   
{ 
 	"location": "{location}", 
 	"properties": { 
 	 	"hardwareProfile": { 
 	 	 	"vmSize": "Standard_D1_v2" 
 	 	}, 
 	 	"storageProfile": { 
 	 	 	"imageReference": { 
 	 	 	 	"sharedGalleryImageId":"/sharedGalleries/{galleryUniqueName}/images/{galleryImageName}/versions/1.0.0" 
 	 	 	}, 
 	 	 	"osDisk": { 
 	 	 	 	"caching": "ReadWrite", 
 	 	 	 	"managedDisk": { 
 	 	 	 	 	"storageAccountType": "Standard_LRS" 
 	 	 	 	}, 
 	 	 	 	"name": "myVMosdisk", 
 	 	 	 	"createOption": "FromImage" 
 	 	 	} 
   	}, 
 	 	"osProfile": { 
 	 	 	"adminUsername": "azureuser", 
 	 	 	"computerName": "myVM", 
 	 	 	"adminPassword": "{password}}" 
 	 	}, 
 	 	"networkProfile": { 
 	 	 	"networkInterfaces": [ 
 	 	 	 	{ 
 	 	 	 	 	"id": "/subscriptions/00000000-0000-0000-0000-
000000000000/resourceGroups/{rg}/providers/Microsoft.Network/networkInterfaces/{networkIntefaceName}", 
 	 	 	 	 	"properties": { 
 	 	 	 	 	 	"primary": true 
 	 	 	 	 	} 
 	 	 	 	} 
 	 	 	] 
 	 	} 
 	} 
} 

1. Digitare macchine virtuali nella casella di ricerca.
2. In Servizi selezionare Macchine virtuali.
3. Nella pagina Macchine virtuali, selezionare Crea e quindi Macchina virtuale. Viene visualizzata la pagina Creare una macchina virtuale.
4. Nella scheda Informazioni di base, in Dettagli progetto verificare che sia selezionata la sottoscrizione corretta e quindi scegliere Crea nuovo gruppo di risorse o selezionarne uno nell'elenco a discesa.
5. In Dettagli istanza digitare un nome per il Nome della macchina virtuale.
6. Per Tipo di sicurezza, assicurarsi che sia selezionato Standard.
7. Per Immagine, selezionare Visualizza tutte le immagini. Viene visualizzata la pagina Seleziona immagine.
8. Nel menu a sinistra, in Altri elementi selezionare Immagini condivise dirette (ANTEPRIMA). Si aprirà la pagina Altri elementi | Immagini condivise dirette (ANTEPRIMA).
9. L'ambito in questa sezione è impostato su "Sottoscrizione" per impostazione predefinita, modificare l'ambito in "Tenant" se non vengono visualizzate le immagini e fare clic all'esterno della casella per visualizzare l'elenco di immagini condivise nell'intero tenant.
10. Selezionare un'immagine dall'elenco. Assicurarsi che lo stato del sistema operativo sia generalizzato. Per usare un'immagine specializzata, vedere Creare una macchina virtuale usando una versione specializzata dell'immagine. A seconda dell'immagine scelta, l'area in cui verrà creata la macchina virtuale cambierà in modo da corrispondere all'immagine.
11. Completare le altre opzioni e quindi selezionare il pulsante Rivedi e crea nella parte inferiore della pagina.
12. Nella pagina Crea macchina virtuale è possibile visualizzare i dettagli sulla macchina virtuale che si sta creando. Al termine, selezionare Crea.