Compartilhar via

Implantar VMs no seu dispositivo Azure Stack Edge através do Azure PowerShell

  • Artigo

APLICA-SE A: Sim, ao SKU do Pro GPUAzure Stack Edge Pro - GPUSim, ao SKU do Pro 2Azure Stack Edge Pro 2Sim, ao SKU do Pro RAzure Stack Edge Pro RSim, ao SKU do Mini RAzure Stack Edge Mini R

Este artigo descreve como criar e gerenciar uma máquina virtual (VM) em seu dispositivo Azure Stack Edge, usando o Azure PowerShell.

Fluxo de trabalho de implantação da VM

O fluxo de trabalho de implantação de alto nível de implantação da VM é o seguinte:

  1. Conectar-se ao Azure Resource Manager do dispositivo.
  2. Identificar a assinatura interna no dispositivo.
  3. Trazer a imagem de VM.
  4. Criar um grupo de recursos na assinatura interna. O grupo de recursos contém a VM e todos os recursos relacionados.
  5. Crie uma conta de armazenamento local no dispositivo para armazenar o VHD que é usado para criar uma imagem de VM.
  6. Carregar uma imagem de origem do Windows/do Linux na conta de armazenamento para criar um disco gerenciado.
  7. Usar o disco gerenciado para criar uma imagem de VM.
  8. Habilitar a computação em uma porta de dispositivo para criar um comutador virtual.
  9. Isso criará uma rede virtual usando o comutador virtual anexado à porta na qual você habilitou a computação.
  10. Criar uma VM usando a imagem de VM criada anteriormente, a rede virtual e os adaptadores de rede virtual para se comunicar dentro da rede virtual e atribuir um endereço IP público para acessar remotamente a VM. Opcionalmente, inclua discos de dados para fornecer mais armazenamento para sua VM.

Pré-requisitos

Antes de implantar VMs no dispositivo Azure Stack Edge, é necessário configurar seu cliente para se conectar ao dispositivo via Azure Resource Manager sobre o Azure PowerShell. Para obter instruções detalhadas, consulte Conectar-se a Azure Resource Manager no dispositivo Azure Stack Edge.

Certifique-se de que possa usar as etapas a seguir para acessar o dispositivo a partir do cliente. Você já fez essa configuração quando se conectou ao Azure Resource Manager e, agora, está verificando se a configuração foi bem-sucedida.

  1. Verifique se a comunicação do Azure Resource Manager está funcionando executando o seguinte comando:

    Add-AzEnvironment -Name <Environment Name> -ARMEndpoint "https://management.<appliance name>.<DNSDomain>"

  2. Para chamar as APIs do dispositivo local para autenticar, insira:

    login-AzAccount -EnvironmentName <Environment Name> -TenantId c0257de7-538f-415c-993a-1b87a031879d

    Para se conectar via Azure Resource Manager, forneça o nome de usuário EdgeArmUser e sua senha.

  3. Se tiver configurado a computação para Kubernetes, você poderá ignorar essa etapa. Caso contrário, certifique-se de que tenha habilitado uma interface de rede para computação fazendo o seguinte:

    a. Na interface do usuário local, vá para configurações de Computação.
    b. Selecione o adaptador de rede que será usado para criar um comutador virtual. As VMs que você criar serão anexadas a um comutador virtual anexado a essa porta e à rede associada. Certifique-se de escolher uma rede que corresponda ao endereço IP que você usará para a VM.

    Captura de tela do painel de definições da rede de configuração de computação.

    c. Em Habilitar para computação no adaptador de rede, selecione Sim. O Azure Stack Edge criará e gerenciará um comutador virtual que corresponde a esse adaptador de rede. Não insira IPs específicos para Kubernetes no momento. A habilitação da computação pode levar vários minutos.

    Observação

    Se estiver criando VMs de GPU, selecione um adaptador de rede que esteja conectado à Internet. Isso permite que você instale uma extensão de GPU em seu dispositivo.

Consultar sobre uma assinatura interna no dispositivo

Para o Azure Resource Manager, há suporte apenas para uma única assinatura fixa, visível para o usuário. Essa assinatura é exclusiva por dispositivo e o nome da assinatura e a ID da assinatura não podem ser alterados.

A assinatura contém todos os recursos necessários para a criação da VM.

Importante

A assinatura é criada quando você habilita VMs do portal do Azure e ela reside localmente em seu dispositivo.

A assinatura é utilizada para implantar as VMs.

  1. Para listar a assinatura, execute o comando a seguir:

    Get-AzSubscription

    Veja a seguir um exemplo de saída:

    PS C:\WINDOWS\system32> Get-AzSubscription

Name                          Id                                   TenantId
----                          --                                   --------
Default Provider Subscription ...                                  ...


PS C:\WINDOWS\system32>

  2. Obter uma lista dos provedores de recursos registrados que estão em execução no dispositivo. A lista normalmente inclui computação, rede e armazenamento.

    Get-AzResourceProvider

    Observação

    Os provedores de recursos são pré-registrados e não podem ser modificados ou alterados.

    Veja a seguir um exemplo de saída:

    PS C:\WINDOWS\system32>  Get-AzResourceProvider

ProviderNamespace : Microsoft.AzureBridge
RegistrationState : Registered
ResourceTypes     : {locations, operations, locations/ingestionJobs}
Locations         : {DBELocal}

ProviderNamespace : Microsoft.Compute
RegistrationState : Registered
ResourceTypes     : {virtualMachines, virtualMachines/extensions, locations, operations...}
Locations         : {DBELocal}

ProviderNamespace : Microsoft.Network
RegistrationState : Registered
ResourceTypes     : {operations, locations, locations/operations, locations/usages...}
Locations         : {DBELocal}

ProviderNamespace : Microsoft.Resources
RegistrationState : Registered
ResourceTypes     : {tenants, locations, providers, checkresourcename...}
Locations         : {DBELocal}

ProviderNamespace : Microsoft.Storage
RegistrationState : Registered
ResourceTypes     : {storageaccounts, storageAccounts/blobServices, storageAccounts/tableServices,
                    storageAccounts/queueServices...}
Locations         : {DBELocal}

PS C:\WINDOWS\system32>

Criar um grupo de recursos

Comece criando um novo grupo de recursos do Azure e use-o como um contêiner lógico para todos os recursos relacionados à VM, como conta de armazenamento, disco, interface de rede e disco gerenciado.

Importante

Todos os recursos são criados no mesmo local que o do dispositivo e o local é configurado como DBELocal.

  1. Defina alguns parâmetros.

    $ResourceGroupName = "<Resource group name>"

  2. Crie um grupo de recursos para os recursos criados para a VM.

    New-AzResourceGroup -Name $ResourceGroupName -Location DBELocal

    Veja a seguir um exemplo de saída:

    PS C:\WINDOWS\system32> New-AzResourceGroup -Name myaseazrg -Location DBELocal

ResourceGroupName : myaseazrg
Location          : dbelocal
ProvisioningState : Succeeded
Tags              :
ResourceId        : /subscriptions/.../resourceGroups/myaseazrg

PS C:\WINDOWS\system32>

Criar uma conta de armazenamento local

Crie uma conta de armazenamento local usando um grupo de recursos existente. Use essa conta de armazenamento local para carregar a imagem de disco virtual ao criar uma VM.

Antes de criar uma conta de armazenamento local, é necessário configurar seu cliente para se conectar ao dispositivo via Azure Resource Manager sobre o Azure PowerShell. Para obter instruções detalhadas, consulte Conectar-se a Azure Resource Manager no dispositivo Azure Stack Edge.

  1. Defina alguns parâmetros.

    $StorageAccountName = "<Storage account name>"

  2. Crie uma conta nova de armazenamento local no seu dispositivo.

    New-AzStorageAccount -Name $StorageAccountName -ResourceGroupName $ResourceGroupName -Location DBELocal -SkuName Standard_LRS

    Observação

    Usando o Azure Resource Manager, você pode criar apenas contas de armazenamento local, como armazenamento com redundância local (standard ou premium). Para criar contas de armazenamento em camadas, consulte o Tutorial: transferir dados por meio de contas de armazenamento com o Azure Stack Edge Pro com GPU.

    Veja um exemplo de saída:

    PS C:\WINDOWS\system32> New-AzStorageAccount -Name myaseazsa -ResourceGroupName myaseazrg -Location DBELocal -SkuName Standard_LRS

StorageAccountName ResourceGroupName PrimaryLocation SkuName      Kind    AccessTier CreationTime
------------------ ----------------- --------------- -------      ----    ---------- ------------
myaseazsa          myaseazrg         DBELocal        Standard_LRS Storage            6/10/2021 11:45...

PS C:\WINDOWS\system32>

Para obter as chaves de acesso para uma conta de armazenamento local existente que você criou, forneça o nome do grupo de recursos associado e o nome da conta de armazenamento local.

Get-AzStorageAccountKey

Veja um exemplo de saída:

PS C:\WINDOWS\system32> Get-AzStorageAccountKey
    
cmdlet Get-AzStorageAccountKey at command pipeline position 1
Supply values for the following parameters:
(Type !? for Help.)
ResourceGroupName: myaseazrg
Name: myaseazsa
    
KeyName    Value                                                                                       Permissions
-------    -----                                                                                       ------
key1       gv3OF57tuPDyzBNc1M7fhil2UAiiwnhTT6zgiwE3TlF/CD217Cvw2YCPcrKF47joNKRvzp44leUe5HtVkGx8RQ==    Full
key2       kmEynIs3xnpmSxWbU41h5a7DZD7v4gGV3yXa2NbPbmhrPt10+QmE5PkOxxypeSqbqzd9si+ArNvbsqIRuLH2Lw==    Full
    
PS C:\WINDOWS\system32>

Adicionar o URI do blob ao arquivo de host

Você já adicionou o URI de blob no arquivo de hosts para o cliente que você está usando para se conectar ao Armazenamento de Blobs do Azure em Modificar arquivo de host para resolução de nome de ponto de extremidade de Conectar-se ao Azure Resource Manager com seu dispositivo do Azure Stack Edge. Essa entrada foi usada para adicionar o URI do blob:

<Device IP address> <storage name>.blob.<appliance name>.<dnsdomain>

Instalar certificados

Se você estiver usando HTTPS, precisa instalar os certificados apropriados em seu dispositivo. Nesse caso, instale o certificado de ponto de extremidade de blob. Para obter mais informações, consulte Usar certificados com seu Azure Stack Edge Pro com dispositivo GPU.

Carregar um VHD

Copie quaisquer imagens de disco a serem usadas em blobs de páginas na conta de armazenamento local que você antes. Você pode usar uma ferramenta como o AzCopy para carregar o disco rígido virtual (VHD) na conta de armazenamento.

Use os seguintes comandos com o AzCopy 10:

  1. Definir alguns parâmetros, incluindo a versão apropriada das APIs para o AzCopy. Neste exemplo, o AzCopy 10 foi usado.

    $Env:AZCOPY_DEFAULT_SERVICE_API_VERSION="2019-07-07"    
$ContainerName = <Container name>
$ResourceGroupName = <Resource group name>
$StorageAccountName = <Storage account name>
$VHDPath = "Full VHD Path"
$VHDFile = <VHD file name>

  2. Copie o VHD da origem (nesse caso, o sistema local) para a conta de armazenamento que você criou em seu dispositivo na etapa anterior.

    $StorageAccountKey = (Get-AzStorageAccountKey -ResourceGroupName $ResourceGroupName -Name $StorageAccountName)[0].Value
$blobendpoint = (Get-AzEnvironment -Name Environment Name).StorageEndpointSuffix
$StorageAccountContext = New-AzStorageContext -StorageAccountName $StorageAccountName -StorageAccountKey $StorageAccountKey -Endpoint $blobendpoint
<Create the container if it does not exist>
$containerName = "con1"
$container = New-AzStorageContainer -Name $containerName -Context $StorageAccountContext -Permission Container
$StorageAccountSAS = New-AzStorageAccountSASToken -Service Blob -ResourceType Container,Service,Object -Permission "acdlrw" -Context $StorageAccountContext -Protocol HttpsOnly
$endPoint = (Get-AzStorageAccount -name $StorageAccountName -ResourceGroupName $ResourceGroupName).PrimaryEndpoints.Blob
<Path to azcopy.exe> cp "$VHDPath\$VHDFile" "$endPoint$ContainerName$StorageAccountSAS"

    Veja um exemplo de saída:

    PS C:\windows\system32> $ContainerName = "testcontainer1"
PS C:\windows\system32> $ResourceGroupName = "myaseazrg"
PS C:\windows\system32> $StorageAccountName = "myaseazsa"
PS C:\windows\system32> $VHDPath = "C:\Users\alkohli\Downloads\Ubuntu1604"           
PS C:\windows\system32> $VHDFile = "ubuntu13.vhd"

PS C:\windows\system32> $StorageAccountKey = (Get-AzStorageAccountKey -ResourceGroupName $ResourceGroupName -Name $StorageAccountName)[0].Value
PS C:\windows\system32> $endPoint = (Get-AzStorageAccount -name $StorageAccountName -ResourceGroupName $ResourceGroupName).PrimaryEndpoints.Blob
PS C:\windows\system32> $StorageAccountContext = New-AzStorageContext -StorageAccountName $StorageAccountName -StorageAccountKey $StorageAccountKey -Endpoint $endpoint
PS C:\windows\system32> $StorageAccountSAS = New-AzStorageAccountSASToken -Service Blob -ResourceType Container,Service,Object -Permission "acdlrw" -Context $StorageAccountContext -Protocol HttpsOnly

PS C:\windows\system32> C:\azcopy\azcopy_windows_amd64_10.10.0\azcopy.exe cp "$VHDPath\$VHDFile" "$endPoint$ContainerName$StorageAccountSAS"
INFO: Scanning...
INFO: Any empty folders will not be processed, because source and/or destination doesn't have full folder support

Job 72a5e3dd-9210-3e43-6691-6bebd4875760 has started
Log file is located at: C:\Users\alkohli\.azcopy\72a5e3dd-9210-3e43-6691-6bebd4875760.log

INFO: azcopy.exe: A newer version 10.11.0 is available to download

Criar um disco gerenciado do VHD

Crie um disco gerenciado a partir do VHD carregado.

  1. Defina alguns parâmetros.

    $DiskName = "<Managed disk name>"
$HyperVGeneration = "<Generation of the image: V1 or V2>"

  2. Criar um disco gerenciado com base em um VHD carregado. Para obter a URL de origem do VHD, acesse o contêiner na conta de armazenamento que contém o VHD no Gerenciador de Armazenamento. Selecione o VHD, clique com o botão direito do mouse e, em seguida, selecione Propriedades. Na caixa de diálogo Propriedades de Blob, selecione o URI.

    $StorageAccountId = (Get-AzStorageAccount -ResourceGroupName $ResourceGroupName -Name $StorageAccountName).Id    
$DiskConfig = New-AzDiskConfig -Location DBELocal -HyperVGeneration $HyperVGeneration -StorageAccountId $StorageAccountId -CreateOption Import -SourceUri "Source URL for your VHD"
New-AzDisk -ResourceGroupName $ResourceGroupName -DiskName $DiskName -Disk $DiskConfig

    Veja um exemplo de saída:.

    PS C:\WINDOWS\system32> $DiskName = "myazmd"
PS C:\WINDOWS\system32  $HyperVGeneration = "V1"
PS C:\WINDOWS\system32> $StorageAccountId = (Get-AzStorageAccount -ResourceGroupName $ResourceGroupName -Name $StorageAccountName).Id
PS C:\WINDOWS\system32> $DiskConfig = New-AzDiskConfig -Location DBELocal -HyperVGeneration $HyperVGeneration -StorageAccountId $StorageAccountId -CreateOption Import -SourceUri "https://myaseazsa.blob.myasegpu.wdshcsso.com/testcontainer1/ubuntu13.vhd"
PS C:\WINDOWS\system32> New-AzDisk -ResourceGroupName $ResourceGroupName -DiskName $DiskName -Disk $DiskConfig

ResourceGroupName            : myaseazrg
ManagedBy                    :
Sku                          : Microsoft.Azure.Management.Compute.Models.DiskSku
Zones                        :
TimeCreated                  : 6/24/2021 12:19:56 PM
OsType                       :
HyperVGeneration             : V1
CreationData                 : Microsoft.Azure.Management.Compute.Models.CreationDat
                               a
DiskSizeGB                   : 30
DiskSizeBytes                : 32212254720
UniqueId                     : 53743801-cbf2-4d2f-acb4-971d037a9395
EncryptionSettingsCollection :
ProvisioningState            : Succeeded
DiskIOPSReadWrite            : 500
DiskMBpsReadWrite            : 60
DiskState                    : Unattached
Encryption                   : Microsoft.Azure.Management.Compute.Models.Encryption
Id                           : /subscriptions/.../r
                               esourceGroups/myaseazrg/providers/Microsoft.Compute/d
                               isks/myazmd
Name                         : myazmd
Type                         : Microsoft.Compute/disks
Location                     : DBELocal
Tags                         : {}

PS C:\WINDOWS\system32>

Criar uma imagem de VM com base no disco gerenciado

Agora você irá criar uma imagem de VM com base no disco gerenciado.

  1. Defina alguns parâmetros.

    $DiskSize = "<Size greater than or equal to size of source managed disk>"
$OsType = "<linux or windows>" 
$ImageName = "<Image name>"

  2. Criar uma imagem de VM. Os tipos de sistema operacional com suporte são Linux e Windows.

    $imageConfig = New-AzImageConfig -Location DBELocal -HyperVGeneration $hyperVGeneration 
$ManagedDiskId = (Get-AzDisk -Name $DiskName -ResourceGroupName $ResourceGroupName).Id
Set-AzImageOsDisk -Image $imageConfig -OsType $OsType -OsState 'Generalized' -DiskSizeGB $DiskSize -ManagedDiskId $ManagedDiskId 
New-AzImage -Image $imageConfig -ImageName $ImageName -ResourceGroupName $ResourceGroupName

    Veja um exemplo de saída.

    PS C:\WINDOWS\system32> $OsType = "linux"
PS C:\WINDOWS\system32> $ImageName = "myaseazlinuxvmimage"
PS C:\WINDOWS\system32> $DiskSize = 35
PS C:\WINDOWS\system32> $imageConfig = New-AzImageConfig -Location DBELocal
PS C:\WINDOWS\system32> $ManagedDiskId = (Get-AzDisk -Name $DiskName -ResourceGroupName $ResourceGroupName).Id
PS C:\WINDOWS\system32> Set-AzImageOsDisk -Image $imageConfig -OsType $OsType -OsState 'Generalized' -DiskSizeGB $DiskSize -ManagedDiskId $ManagedDiskId

ResourceGroupName    :
SourceVirtualMachine :
StorageProfile       : Microsoft.Azure.Management.Compute.Models.ImageStorageProfile
ProvisioningState    :
HyperVGeneration     : V1
Id                   :
Name                 :
Type                 :
Location             : DBELocal
Tags                 :

PS C:\WINDOWS\system32> New-AzImage -Image $imageConfig -ImageName $ImageName -ResourceGroupName $ResourceGroupName

ResourceGroupName    : myaseazrg
SourceVirtualMachine :
StorageProfile       : Microsoft.Azure.Management.Compute.Models.ImageStorageProfile
ProvisioningState    : Succeeded
HyperVGeneration     : V1
Id                   : /subscriptions/.../resourceG
                       roups/myaseazrg/providers/Microsoft.Compute/images/myaseazlin
                       uxvmimage
Name                 : myaseazlinuxvmimage
Type                 : Microsoft.Compute/images
Location             : dbelocal
Tags                 : {}

PS C:\WINDOWS\system32>

Criar sua VM com recursos criados anteriormente

Antes de criar e implantar a VM, você deve criar uma rede virtual e associar uma interface de rede virtual a ela.

Importante

As seguintes regras se aplicam:

  • Você pode criar apenas uma rede virtual, mesmo entre grupos de recursos. A rede virtual deve ter exatamente o mesmo espaço de endereço que a rede lógica.
  • A rede virtual pode ter apenas uma sub-rede. A sub-rede deve ter exatamente o mesmo espaço de endereço que a rede virtual.
  • Ao criar a placa de interface de rede virtual, você pode usar apenas o método de alocação estática. O usuário precisa fornecer um endereço IP privado.

Consultar a rede virtual criada automaticamente

Quando você habilita a computação a partir da IU local do seu dispositivo, uma rede virtual chamada ASEVNET é criada automaticamente, no grupo de recursos ASERG.

Use o comando seguinte para consultar a rede virtual existente:

$ArmVn = Get-AzVirtualNetwork -Name ASEVNET -ResourceGroupName ASERG

Criar uma placa de adaptador de rede virtual

Crie uma placa de adaptador de rede virtual usando a ID de sub-rede da rede virtual.

  1. Defina alguns parâmetros.

    $IpConfigName = "<IP config name>"
$NicName = "<Network interface name>"

  2. Criar um adaptador de rede virtual.

    $ipConfig = New-AzNetworkInterfaceIpConfig -Name $IpConfigName -SubnetId $aRmVN.Subnets[0].Id 
$Nic = New-AzNetworkInterface -Name $NicName -ResourceGroupName $ResourceGroupName -Location DBELocal -IpConfiguration $IpConfig

    Por padrão, um IP é atribuído dinamicamente à sua interface de rede da rede habilitada para computação. Use o -PrivateIpAddress parameter se você estiver alocando um IP estático à sua interface de rede.

    Veja um exemplo de saída:

    PS C:\WINDOWS\system32> $IpConfigName = "myazipconfig1"
PS C:\WINDOWS\system32> $NicName = "myaznic1"
PS C:\WINDOWS\system32> $ipConfig = New-AzNetworkInterfaceIpConfig -Name $IpConfigName -SubnetId $aRmVN.Subnets[0].Id 
PS C:\WINDOWS\system32> $ipConfig = New-AzNetworkInterfaceIpConfig -Name $IpConfigName -SubnetId $aRmVN.Subnets[0].Id
PS C:\WINDOWS\system32> $Nic = New-AzNetworkInterface -Name $NicName -ResourceGroupName $ResourceGroupName -Location DBELocal -IpConfiguration $IpConfig
PS C:\WINDOWS\system32> $Nic

Name                        : myaznic1
ResourceGroupName           : myaseazrg
Location                    : dbelocal
Id                          : /subscriptions/.../re
                              sourceGroups/myaseazrg/providers/Microsoft.Network/net
                              workInterfaces/myaznic1
Etag                        : W/"0b20057b-2102-4f34-958b-656327c0fb1d"
ResourceGuid                : e7d4131f-6f01-4492-9d4c-a8ff1af7244f
ProvisioningState           : Succeeded
Tags                        :
VirtualMachine              : null
IpConfigurations            : [
                                {
                                  "Name": "myazipconfig1",
                                  "Etag":
                              "W/\"0b20057b-2102-4f34-958b-656327c0fb1d\"",
                                  "Id": "/subscriptions/.../resourceGroups/myaseazrg/providers/Microsoft.
                              Network/networkInterfaces/myaznic1/ipConfigurations/my
                              azipconfig1",
                                  "PrivateIpAddress": "10.126.76.60",
                                  "PrivateIpAllocationMethod": "Dynamic",
                                  "Subnet": {
                                    "Delegations": [],
                                    "Id": "/subscriptions/.../resourceGroups/ASERG/providers/Microsoft.Ne
                              twork/virtualNetworks/ASEVNET/subnets/ASEVNETsubNet",
                                    "ServiceAssociationLinks": []
                                  },
                                  "ProvisioningState": "Succeeded",
                                  "PrivateIpAddressVersion": "IPv4",
                                  "LoadBalancerBackendAddressPools": [],
                                  "LoadBalancerInboundNatRules": [],
                                  "Primary": true,
                                  "ApplicationGatewayBackendAddressPools": [],
                                  "ApplicationSecurityGroups": []
                                }
                              ]
DnsSettings                 : {
                                "DnsServers": [],
                                "AppliedDnsServers": [],
                                "InternalDomainNameSuffix": "auwlfcx0dhxurjgisct43fc
                              ywb.a--x.internal.cloudapp.net"
                              }
EnableIPForwarding          : False
EnableAcceleratedNetworking : False
NetworkSecurityGroup        : null
Primary                     :
MacAddress                  : 001DD84A58D1

PS C:\WINDOWS\system32>

Opcionalmente, enquanto você estiver criando uma placa de interface de rede virtual para uma VM, você pode passar o IP público. Nessa instância, o IP público retorna o IP privado.

New-AzPublicIPAddress -Name <Public IP> -ResourceGroupName <ResourceGroupName> -AllocationMethod Static -Location DBELocal
$publicIP = (Get-AzPublicIPAddress -Name <Public IP> -ResourceGroupName <Resource group name>).Id
$ipConfig = New-AzNetworkInterfaceIpConfig -Name <ConfigName> -PublicIpAddressId $publicIP -SubnetId $subNetId

Criar uma VM

Agora você pode usar a imagem da VM para criar uma VM e anexá-la à rede virtual que você criou anteriormente.

  1. Defina o nome de usuário e a senha para entrar na VM que você deseja criar.

    $pass = ConvertTo-SecureString "<Password>" -AsPlainText -Force;
$cred = New-Object System.Management.Automation.PSCredential("<Enter username>", $pass)

    Depois de criar e iniciar a VM, use o nome de usuário e a senha anteriores para entrar nela.

  2. Defina os parâmetros.

    $VmName = "<VM name>"
$ComputerName = "<VM display name>"
$OsDiskName = "<OS disk name>"

  3. Crie a VM.

    $VirtualMachine =  New-AzVMConfig -VmName $VmName -VMSize "Standard_D1_v2"

$VirtualMachine =  Set-AzVMOperatingSystem -VM $VirtualMachine -Linux -ComputerName $ComputerName -Credential $cred

$VirtualMachine =  Set-AzVmOsDisk -VM $VirtualMachine -Name $OsDiskName -Caching "ReadWrite" -CreateOption "FromImage" -Linux -StorageAccountType Standard_LRS

$nicID = (Get-AzNetworkInterface -Name $NicName -ResourceGroupName $ResourceGroupName).Id

$VirtualMachine =  Add-AzVMNetworkInterface -Vm $VirtualMachine -Id $nicID

$image = ( Get-AzImage -ResourceGroupName $ResourceGroupName -ImageName $ImageName).Id

$VirtualMachine =  Set-AzVMSourceImage -VM $VirtualMachine -Id $image

New-AzVM -ResourceGroupName $ResourceGroupName -Location DBELocal -VM $VirtualMachine -Verbose

    Veja um exemplo de saída.

    PS C:\WINDOWS\system32> $pass = ConvertTo-SecureString "Password1" -AsPlainText -Force;
PS C:\WINDOWS\system32> $cred = New-Object System.Management.Automation.PSCredential("myazuser", $pass)
PS C:\WINDOWS\system32> $VmName = "myazvm"
>> $ComputerName = "myazvmfriendlyname"
>> $OsDiskName = "myazosdisk1"
PS C:\WINDOWS\system32> $VirtualMachine =  New-AzVMConfig -VmName $VmName -VMSize "Standard_D1_v2"
PS C:\WINDOWS\system32> $VirtualMachine =  Set-AzVMOperatingSystem -VM $VirtualMachine -Linux -ComputerName $ComputerName -Credential $cred
PS C:\WINDOWS\system32> $VirtualMachine =  Set-AzVmOsDisk -VM $VirtualMachine -Name $OsDiskName -Caching "ReadWrite" -CreateOption "FromImage" -Linux -StorageAccountType Standard_LRS
PS C:\WINDOWS\system32> $nicID = (Get-AzNetworkInterface -Name $NicName -ResourceGroupName $ResourceGroupName).Id
PS C:\WINDOWS\system32> $nicID/subscriptions/.../resourceGroups/myaseazrg/providers/Microsoft.Network/networkInterfaces/myaznic1
PS C:\WINDOWS\system32> $VirtualMachine =  Add-AzVMNetworkInterface -VM $VirtualMachine -Id $nicID
PS C:\WINDOWS\system32> $image = ( Get-AzImage -ResourceGroupName $ResourceGroupName -ImageName $ImageName).Id
PS C:\WINDOWS\system32> $VirtualMachine =  Set-AzVMSourceImage -VM $VirtualMachine -Id $image
PS C:\WINDOWS\system32> New-AzVM -ResourceGroupName $ResourceGroupName -Location DBELocal -VM $VirtualMachine -Verbose
WARNING: Since the VM is created using premium storage or managed disk, existing
standard storage account, myaseazsa, is used for boot diagnostics.
VERBOSE: Performing the operation "New" on target "myazvm".

RequestId IsSuccessStatusCode StatusCode ReasonPhrase
--------- ------------------- ---------- ------------
                         True         OK OK

  4. Para descobrir o IP atribuído à VM que você criou, consulte a interface de rede virtual criada. Localize o PrivateIPAddress e copie o IP da VM. Veja um exemplo de saída.

    PS C:\WINDOWS\system32> $Nic

Name                        : myaznic1
ResourceGroupName           : myaseazrg
Location                    : dbelocal
Id                          : /subscriptions/.../re
                              sourceGroups/myaseazrg/providers/Microsoft.Network/net
                              workInterfaces/myaznic1
Etag                        : W/"0b20057b-2102-4f34-958b-656327c0fb1d"
ResourceGuid                : e7d4131f-6f01-4492-9d4c-a8ff1af7244f
ProvisioningState           : Succeeded
Tags                        :
VirtualMachine              : null
IpConfigurations            : [
                                {
                                  "Name": "myazipconfig1",
                                  "Etag":
                              "W/\"0b20057b-2102-4f34-958b-656327c0fb1d\"",
                                  "Id": "/subscriptions/.../resourceGroups/myaseazrg/providers/Microsoft.
                              Network/networkInterfaces/myaznic1/ipConfigurations/my
                              azipconfig1",
                                  "PrivateIpAddress": "10.126.76.60",
                                  "PrivateIpAllocationMethod": "Dynamic",
                                  "Subnet": {
                                    "Delegations": [],
                                    "Id": "/subscriptions/.../resourceGroups/ASERG/providers/Microsoft.Ne
                              twork/virtualNetworks/ASEVNET/subnets/ASEVNETsubNet",
                                    "ServiceAssociationLinks": []
                                  },
                                  "ProvisioningState": "Succeeded",
                                  "PrivateIpAddressVersion": "IPv4",
                                  "LoadBalancerBackendAddressPools": [],
                                  "LoadBalancerInboundNatRules": [],
                                  "Primary": true,
                                  "ApplicationGatewayBackendAddressPools": [],
                                  "ApplicationSecurityGroups": []
                                }
                              ]
DnsSettings                 : {
                                "DnsServers": [],
                                "AppliedDnsServers": [],
                                "InternalDomainNameSuffix": "auwlfcx0dhxurjgisct43fc
                              ywb.a--x.internal.cloudapp.net"
                              }
EnableIPForwarding          : False
EnableAcceleratedNetworking : False
NetworkSecurityGroup        : null
Primary                     :
MacAddress                  : 001DD84A58D1

PS C:\WINDOWS\system32>

Conectar-se à VM

Conforme você tenha criado uma VM de Windows ou de Linux, as instruções de conexão podem ser diferentes.

Conectar-se a uma VM do Linux

Para conectar-se a uma VM de Linux, faça o seguinte:

Conecte-se à VM usando o IP privado que você passou durante a criação da VM.

  1. Abra uma sessão SSH para se conectar com o endereço IP.

    ssh -l <username> <ip address>

  2. Quando for solicitada, forneça a senha que você usou ao criar a VM.

    Se você precisar informar a chave SSH, use este comando.

    ssh -i c:/users/Administrator/.ssh/id_rsa Administrator@5.5.41.236

    Veja aqui um exemplo de saída quando você se conecta à VM:

    PS C:\WINDOWS\system32> ssh -l myazuser "10.126.76.60"
The authenticity of host '10.126.76.60 (10.126.76.60)' can't be established.
ECDSA key fingerprint is SHA256:V649Zbo58zAYMKreeP7M6w7Na0Yf9QPg4SM7JZVV0E4.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '10.126.76.60' (ECDSA) to the list of known hosts.
myazuser@10.126.76.60's password:
Welcome to Ubuntu 18.04.2 LTS (GNU/Linux 4.18.0-1013-azure x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

 System information disabled due to load higher than 1.0

  Get cloud support with Ubuntu Advantage Cloud Guest:
    http://www.ubuntu.com/business/services/cloud

284 packages can be updated.
192 updates are security updates. 

The programs included with the Ubuntu system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Ubuntu comes with ABSOLUTELY NO WARRANTY, to the extent permitted by
applicable law.

To run a command as administrator (user "root"), use "sudo <command>".
See "man sudo_root" for details.

myazuser@myazvmfriendlyname:~$ client_loop: send disconnect: Connection reset
PS C:\WINDOWS\system32>

Se você usou um endereço IP público durante a criação da VM, pode usar esse IP para se conectar à VM. Para obter o IP público, execute o seguinte comando:

$publicIp = Get-AzPublicIpAddress -Name $PublicIp -ResourceGroupName $ResourceGroupName

Nessa instância, o IP público é o mesmo que o particular passado durante a criação do adaptador de rede virtual.

Conectar-se a uma VM do Windows

Para conectar-se a uma VM de Windows, faça o seguinte:

Conecte-se à sua VM do Windows usando o Protocolo de Desktop Remoto (RDP) por meio do IP que você passou durante a criação da VM.

  1. Em seu cliente, abra o RDP.

  2. Acesse Iniciar e digite mstsc.

  3. No painel Conexão de Área de Trabalho Remota, insira o endereço IP da VM e as credenciais de acesso usadas no arquivo de parâmetros do modelo de VM. Depois, selecione Conectar.

    Captura de tela do painel de Conexão de Área de Trabalho Remota para se conectar via RDP à sua VM do Windows.

    Observação

    Talvez seja necessário aprovar a conexão com um computador não confiável.

Agora você está conectado à sua VM que é executada no dispositivo.

Gerenciar a VM

As seções a seguir descrevem algumas das operações comuns que você pode criar em seu dispositivo Azure Stack Edge Pro.

Listar as VMs que estão em execução no dispositivo

Para retornar uma lista de todas as VMs em execução em seu dispositivo Azure Stack Edge, execute este comando:

Get-AzVM -ResourceGroupName <String> -Name <String>

Para obter mais informações sobre esse cmdlet, consulte Get-AzVM.

Ligar a VM

Para ligar uma máquina virtual em execução em seu dispositivo, execute o seguinte cmdlet:

Start-AzVM [-Name] <String> [-ResourceGroupName] <String>

Para obter mais informações sobre esse cmdlet, consulte Start-AzVM.

Suspender ou desligar a VM

Para parar ou desligar uma máquina virtual que esteja em execução no seu dispositivo, execute o seguinte cmdlet:

Stop-AzVM [-Name] <String> [-StayProvisioned] [-ResourceGroupName] <String>

Para obter mais informações sobre esse cmdlet, consulte Stop-AzVM cmdlet.

Redimensionar a VM

Para redimensionar uma máquina virtual existente, execute os seguintes cmdlets:

Importante

Antes de redimensioná-la, interrompa a VM sem o sinalizador -StayProvisioned.

$vm = Get-AzVM [-Name] <String> [-ResourceGroupName] <String>

$vm.HardwareProfile.VmSize = <new size> - Example: "Standard_D3_v2"

$vm | Update-AzVM

Adicionar um disco de dados

Se os requisitos de carga de trabalho em sua VM aumentarem, talvez seja necessário adicionar um disco de dados. Para fazer isso, execute o comando a seguir:

Add-AzRmVMDataDisk -VM $VirtualMachine -Name "disk1" -VhdUri "https://contoso.blob.core.windows.net/vhds/diskstandard03.vhd" -LUN 0 -Caching ReadOnly -DiskSizeinGB 1 -CreateOption Empty 
 
Update-AzVM -ResourceGroupName "<Resource Group Name string>" -VM $VirtualMachine

Excluir a VM

Para remover uma máquina virtual do seu dispositivo, execute o cmdlet a seguir:

Remove-AzVM [-Name] <String> [-ResourceGroupName] <String>

Para obter mais informações sobre esse cmdlet, consulte Remove-AzVm cmdlet.

Próximas etapas

Cmdlets do Azure Resource Manager