Creación de una máquina virtual a partir de una versión de imagen generalizada

Artículo
10/15/2024

Cree una máquina virtual a partir de una versión de imagen generalizada almacenada en Azure Compute Gallery (anteriormente conocida como Shared Image Gallery). Si desea crear una máquina virtual mediante una imagen especializada, consulte Creación de una máquina virtual a partir de una imagen especializada.

En este artículo se muestra cómo crear una máquina virtual a partir de una imagen generalizada:

En su propia galería
Compartido dentro de su organización mediante RBAC
Compartido entre suscriptores mediante RBAC
Compartido con todo el mundo de una galería de comunidad
Compartido directamente con su suscripción o inquilino

Su propia galería

Enumere las definiciones de imagen en una galería mediante az sig image-definition list para ver el nombre y el identificador de las definiciones.

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

Cree una máquina virtual mediante az vm create. Para usar la versión más reciente de la imagen, establezca --image en el identificador de la definición de la imagen.

Este ejemplo es para crear una máquina virtual Linux protegida con SSH. Para Windows o para proteger una máquina virtual Linux con una contraseña, quite --generate-ssh-keys para que se le solicite una contraseña. Si desea proporcionar una contraseña directamente, reemplace --generate-ssh-keys por --admin-password. Reemplace los nombres de los recursos según sea necesario en este ejemplo.

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

También puede usar una versión específica con el identificador de la versión de imagen del parámetro --image. Por ejemplo, para usar la versión de imagen 1.0.0, escriba: --image "/subscriptions/<subscription ID where the gallery is located>/resourceGroups/myGalleryRG/providers/Microsoft.Compute/galleries/myGallery/images/myImageDefinition/versions/1.0.0".

Cuando tenga una versión de una imagen generalizada, puede crear una o varias VM. Mediante el uso del cmdlet New-AzVM.

En este ejemplo, se usa el identificador de definición de imagen para asegurarse de que la nueva máquina virtual usará la versión más reciente de una imagen. También puede usar una versión específica con el identificador de la versión de imagen de Set-AzVMSourceImage -Id. Por ejemplo, para usar la versión de imagen 1.0.0, escriba: Set-AzVMSourceImage -Id "/subscriptions/<subscription ID where the gallery is located>/resourceGroups/myGalleryRG/providers/Microsoft.Compute/galleries/myGallery/images/myImageDefinition/versions/1.0.0".

Tenga en cuenta que el uso de una versión de imagen específica significa que la automatización podría producir un error si dicha versión específica no está disponible porque se eliminó o se quitó de la región. Se recomienda usar el id. de definición de la imagen para crear la nueva VM, a menos que se requiera una versión de imagen específica.

Reemplace los nombres de recursos según sea necesario en estos ejemplos.

Conjunto de parámetros simplificado

Puede usar el conjunto de parámetros simplificado para crear rápidamente una VM a partir de una imagen. El conjunto de parámetros simplificado usa el nombre de la VM para crear automáticamente algunos de los recursos necesarios, como la red virtual y la dirección IP pública.

# 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

Conjunto de parámetros completo

Puede crear una VM mediante recursos específicos con el conjunto de parámetros 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

Crea una red virtual.

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"
}

Cree una subred.

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"
    },
}

Cree una dirección IP pública.

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

{
  "location": "eastus"
}

Crear un grupo de seguridad de red.

# @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"
}

Cree una NIC.

# @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",
}

Cree una máquina virtual Linux. La sección oSProfile contiene algunos detalles específicos del sistema operativo. Consulte el ejemplo de código siguiente para obtener la sintaxis de 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}",
                }
            ]
        }
    },
}

Creación de una máquina virtual 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}",
                }
            ]
        }
    },

Ahora puede crear una o varias máquinas virtuales. En este ejemplo se crea una máquina virtual denominada myVM, en el myResourceGroup, en el centro de recursos del Este de EE. UU.

Vaya a la definición de la imagen. Puede usar el filtro de recursos para mostrar todas las definiciones de imagen disponibles.
En la página de la definición de la imagen, seleccione Crear máquina virtual en el menú de la parte superior de la página.
En Grupo de recursos, seleccione Crear nuevo y escriba myResourceGroup como nombre.
En Nombre de máquina virtual, escriba myVM.
En Región, seleccione Este de EE. UU. .
En Opciones de disponibilidad, deje el valor predeterminado No se requiere redundancia de la infraestructura.
El valor de Imagen se completa automáticamente con la versión de imagen latest si el inicio se realizó desde la página para la definición de la imagen.
En Tamaño, elija un tamaño de máquina virtual en la lista de tamaños disponibles y, después, elija Seleccionar.
En Cuenta de administrador, debe proporcionar un nombre de usuario, como azureuser, y una contraseña o clave SSH. La contraseña debe tener al menos 12 caracteres de largo y cumplir con los requisitos de complejidad definidos.
Si quiere permitir el acceso remoto a la máquina virtual, en Puertos de entrada públicos, elija Permitir puertos seleccionados y, después, seleccione SSH (22) o RDP (3389) en la lista desplegable. Si no desea permitir el acceso remoto a la máquina virtual, deje Ninguno seleccionado en Puertos de entrada públicos.
Cuando haya terminado, seleccione el botón Revisar y crear situado en la parte inferior de la página.
Una vez que la máquina virtual haya superado la validación, seleccione Crear en la parte inferior de la página para iniciar la implementación.

RBAC - Compartido dentro de su organización

Si la suscripción donde reside la galería está dentro del mismo suscriptor, las imágenes compartidas mediante RBAC se pueden usar para crear máquinas virtuales mediante la CLI y PowerShell.

Necesitará la imageID de la imagen que quiere usar y asegurarse de que se replica en la región donde desea crear la máquina virtual.

CLI
PowerShell

Asegúrese de que el estado de la imagen sea Generalized. Si quiere usar una imagen con el estado Specialized, consulte Creación de una máquina virtual a partir de una versión de imagen especializada.

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

Cree la máquina virtual. Reemplace la información del ejemplo por la suya. Antes de crear la máquina virtual, asegúrese de que la imagen se replica en la región donde desea crear la máquina virtual.

$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

RBAC - Compartido desde otro suscriptor

Si la imagen que quiere usar está almacenada en una galería que no está en el mismo inquilino (directorio), debe iniciar sesión en cada inquilino para comprobar que tiene acceso.

También necesita el valor imageID de la imagen que quiere usar y asegurarse de que se replica en la región donde quiere crear la máquina virtual. También necesitará tenantID para la galería de origen y la tenantID para ubicación en la que desea crear la máquina virtual.

CLI
PowerShell

En este ejemplo se muestra cómo crear una máquina virtual a partir de una imagen generalizada. Si está usando una imagen especializada, consulte Creación de una VM mediante una versión de imagen especializada.

Debe iniciar sesión en el suscriptor donde se almacena la imagen, obtener un token de acceso y, a continuación, iniciar sesión en el suscriptor donde desea crear la máquina virtual. En este caso, tenant1 es donde se almacena la imagen y tenant2 es donde desea crear la máquina virtual. Así es como Azure autentica que tiene acceso a la imagen.


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

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


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

$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

Galería de la comunidad

Importante

Microsoft no proporciona compatibilidad con las imágenes de la galería de la comunidad.

Notificación de problemas con una imagen de la comunidad

El uso de imágenes de máquina virtual enviadas por la comunidad tiene varios riesgos. Las imágenes podrían contener malware, vulnerabilidades de seguridad o infringir la propiedad intelectual de alguien. Para ayudar a crear una experiencia segura y de confianza para la comunidad, puede notificar imágenes cuando ve estos problemas.

La manera más fácil de notificar problemas con una galería de la comunidad es usar el portal, que rellenará automáticamente la información necesaria para el informe:

Para problemas con vínculos u otra información en los campos de una definición de imagen, seleccione Notificar imagen de la comunidad.
Si una versión de imagen contiene código malintencionado o hay otros problemas con una versión específica de una imagen, seleccione Notificar en la columna Versión del informe de la tabla de versiones de la imagen.

También puede usar los vínculos siguientes para notificar problemas, pero los formularios no se rellenarán previamente:

Imágenes malintencionadas: use la Notificación de abuso.
Infracciones de propiedad intelectual: use la Notificación de infracción.

Para crear una máquina virtual con una imagen compartida en una galería de la comunidad, use el identificador único de la imagen para --image que tendrá el siguiente formato:

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

Siga estas instrucciones para obtener la lista de imágenes de Community mediante la CLI:

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

Para obtener el nombre público de una galería de comunidad desde el portal. Vaya a Máquinas virtuales>Crear>Máquina virtual de Azure>Imagen>Ver todas las imágenes>Imágenes de la comunidad>Nombre público de la galería.

En este ejemplo, vamos a crear una máquina virtual a partir de una imagen de Linux y a crear claves SSH para la autenticación.

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

Al usar una imagen de la comunidad, se le pedirá que acepte los términos legales. El mensaje tiene este aspecto:

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):

Obtenga el identificador de la versión de la imagen. El valor se usará en la solicitud de implementación de la máquina virtual.

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

Respuesta:

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

Ahora puede implementar la máquina virtual. El ejemplo requiere la versión de API 2021-07-01 o posterior.

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 
 	 	 	 	 	} 
 	 	 	 	} 
 	 	 	] 
 	 	} 
 	} 
}

Galería compartida directa

Importante

Azure Compute Gallery: la galería compartida directa está actualmente en versión preliminar y sujeta a los Términos de versión preliminar de Azure Compute Gallery.

Para publicar imágenes en una galería compartida directa durante la versión preliminar, debe registrarse en https://aka.ms/directsharedgallery-preview. La creación de máquinas virtuales desde la galería de compartida está disponible para todos los usuarios de Azure.

Durante la versión preliminar, debe crear una nueva galería, con la propiedad sharingProfile.permissions establecida en Groups. Al usar la CLI para crear una galería, especifique el parámetro --permissions groups. No se puede usar una galería existente, la propiedad no se puede actualizar en este momento.

Para crear una máquina virtual con una imagen compartida en su suscripción o inquilino, necesita el identificador de la imagen en el siguiente formato:

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

Para buscar el elemento uniqueID de una galería que se comparte con el usuario, use az sig list-shared. En este ejemplo, estamos buscando galerías en la región Oeste de EE. UU.

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

Use el nombre de la galería para buscar las imágenes disponibles. En este ejemplo, se enumeran todas las imágenes en la región Oeste de EE. UU. y por nombre, el identificador único necesario para crear una máquina virtual, el sistema operativo y el estado 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

Use el Id de la salida, anexado a /Versions/latest para usar la versión más reciente, como valor de --image para crear una máquina virtual. En este ejemplo, vamos a crear una máquina virtual a partir de una imagen de Linux que se comparte con nosotros directamente y a crear claves SSH para la autenticación.

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

Obtenga el identificador de la versión de la imagen. El valor se usará en la solicitud de implementación de la máquina virtual.

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

Respuesta:

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

Ahora puede implementar la máquina virtual. El ejemplo requiere la versión de API 2021-07-01 o posterior.

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 
 	 	 	 	 	} 
 	 	 	 	} 
 	 	 	] 
 	 	} 
 	} 
}

Nota:

Problema conocido: en Azure Portal, si selecciona una región o una imagen, y luego cambia la región, recibirá un mensaje de error: "Solo puede crear una máquina virtual en las regiones de replicación de esta imagen", incluso aunque la imagen se replique en esa región. Para eliminar el error, seleccione otra región y vuelva a la región que desee. Si la imagen está disponible, el mensaje de error debería desaparecer.

También puede usar la CLI de Azure para comprobar qué imágenes se comparten con el usuario. Por ejemplo, puede usar az sig list-shared --location westus para ver qué imágenes se comparten con usted en la región Oeste de EE. UU.

Escriba máquinas virtuales en la búsqueda.
En Servicios, seleccione Máquinas virtuales.
En la página Máquinas virtuales, seleccione Crear y, luego, Máquina virtual. Se abrirá la página Creación de una máquina virtual.
En la pestaña Aspectos básicos, en Detalles del proyecto, asegúrese de que esté seleccionada la suscripción correcta y luego elija Crear nuevo grupo de recursos o seleccione uno de la lista desplegable.
En Detalles de la instancia, escriba un nombre para la máquina virtual.
En Tipo de seguridad, asegúrese de que esté seleccionado Estándar.
Como Imagen, seleccione Ver todas las imágenes. Se abrirá la página Seleccionar una imagen.
En el menú de la izquierda, en Otros elementos, seleccione Imágenes compartidas directamente (VERSIÓN PRELIMINAR). Se abrirá la página Otros elementos | Imágenes compartidas directamente (VERSIÓN PRELIMINAR).
El ámbito de esta sección está establecido en "Suscripción" de forma predeterminada; cámbielo a "Inquilino" si no ve las imágenes y haga clic fuera del cuadro para ver la lista de imágenes compartidas en todo el inquilino.
Seleccione una imagen de la lista. Asegúrese de que el estado del sistema operativo es Generalizado. Si desea usar una imagen especializada, consulte Creación de una VM mediante una versión de imagen especializada. En función de la imagen que elija, la región en la que se creará la máquina virtual cambiará para que coincida con la imagen.
Complete el resto de las opciones y, a continuación, seleccione el botón Revisar y crear en la parte inferior de la página.
En la página Crear una máquina virtual verá los detalles de la máquina virtual que va a crear. Cuando esté listo, seleccione Crear.

Compartir a través de