Anexando uma GPU a uma VM Ubuntu Linux no Azure Local

2025-07-07

Aplica-se a: Azure Local 2311.2 e posterior

Nota

A maneira recomendada de criar e gerenciar VMs no Azure Local é usando o plano de controle Azure Arc. No entanto, como a funcionalidade descrita neste artigo ainda não é fornecida pelo Azure Arc, você pode usar o Windows Admin Center ou o PowerShell conforme descrito neste artigo. As VMs criadas dessa forma não são habilitadas pelo Azure Arc, têm capacidade de gerenciamento limitada do plano de controle do Azure Arc e menos Benefícios Híbridos do Azure, incluindo o uso do Azure Update Manager sem custo extra.
Para obter mais informações, consulte Comparar recursos de gerenciamento de VMs no Azure Local e operações com suporte para VMs locais do Azure.

Este tópico fornece instruções passo a passo sobre como instalar e configurar uma unidade de processamento gráfico (GPU) NVIDIA no Azure Local usando a tecnologia DDA (Discrete Device Assignment) para uma máquina virtual (VM) Ubuntu. Você deve ter uma instância Local do Azure já implantada e VMs instaladas.

Instale a GPU e desmonte-a no PowerShell

Instale as GPUs NVIDIA fisicamente na máquina apropriada seguindo as instruções do OEM e as recomendações do BIOS.
Ligue cada máquina.
Entre usando uma conta com privilégios administrativos na máquina com a GPU NVIDIA instalada.
Abra o Gestor de Dispositivos e navegue até à secção de outros dispositivos . Você verá um dispositivo listado como "Controlador de vídeo 3D".
Clique com o botão direito do rato em "3D Video Controller" para abrir a página Propriedades . Clique em Detalhes. No menu pendente em Propriedade, selecione "Caminhos de localização".
Observe o valor com a cadeia de caracteres PCIRoot conforme destacado na captura de tela. Clique com o botão direito do rato em Valor e copie/guarde-o.
Abra o Windows PowerShell com privilégios elevados e execute o Dismount-VMHostAssignableDevice cmdlet para desmontar o dispositivo GPU do DDA para a VM. Substitua o valor LocationPath pelo valor para o dispositivo obtido na etapa 6.
```
Dismount-VMHostAssignableDevice -LocationPath "PCIROOT(16)#PCI(0000)#PCI(0000)" -force
```
Confirme se o dispositivo está listado em dispositivos do sistema no Gerenciador de dispositivos como desmontado.

Criar e configurar uma VM do Ubuntu

Download Ubuntu desktop versão 18.04.02 ISO.
Abra o Hyper-V Manager na máquina em sua instância local do Azure com a GPU instalada.

Nota

O DDA não suporta failover. Esta é uma limitação de VM com DDA. Portanto, recomendamos usar o Hyper-V Manager para implantar a VM na máquina em vez do Gerenciador de Cluster de Failover. O uso do Gerenciador de Cluster de Failover com DDA falha com uma mensagem de erro indicando que a VM tem um dispositivo que não suporta alta disponibilidade.
Usando o ISO do Ubuntu baixado na etapa 1, crie uma nova VM usando o Assistente de Nova Máquina Virtual no Hyper-V Manager para criar uma VM Ubuntu Geração 1 com 2 GB de memória e uma placa de rede conectada a ela.

No PowerShell, atribua o dispositivo GPU desmontado à VM usando os cmdlets, substituindo o valor LocationPath pelo valor do seu dispositivo.

# Confirm that there are no DDA devices assigned to the VM
Get-VMAssignableDevice -VMName Ubuntu

# Assign the GPU to the VM
Add-VMAssignableDevice -LocationPath "PCIROOT(16)#PCI(0000)#PCI(0000)" -VMName Ubuntu

# Confirm that the GPU is assigned to the VM
Get-VMAssignableDevice -VMName Ubuntu

Aqui está um resultado da atribuição bem-sucedida da GPU à VM:

Configure outros valores seguindo a documentação da GPU aqui:

 # Enable Write-Combining on the CPU
 Set-VM -GuestControlledCacheTypes $true -VMName VMName

 # Configure the 32 bit MMIO space
 Set-VM -LowMemoryMappedIoSpace 3Gb -VMName VMName

 # Configure greater than 32 bit MMIO space
 Set-VM -HighMemoryMappedIoSpace 33280Mb -VMName VMName

Nota

O valor 33280Mb deve ser suficiente para a maioria das GPUs, mas deve ser substituído por um valor maior do que a memória da GPU.

Usando o Gerenciador do Hyper-V, conecte-se à VM e inicie a instalação do sistema operacional Ubuntu. Escolha os padrões para instalar o Ubuntu OS na VM.
Após a conclusão da instalação, use o Hyper-V Manager para desligar a VM e configurar a Ação de parada automática para a VM desligar o sistema operacional convidado, como na captura de tela:
Faça login no Ubuntu e abra o terminal para instalar o SSH:
```
 $ sudo apt install openssh-server
```
Encontre o endereço TCP/IP para a instalação do Ubuntu usando o comando ifconfig e copie o endereço IP para a interface eth0 .
Use um cliente SSH como OpenSSH (ssh.exe instalado com o Windows 10 por padrão) ou Putty para se conectar à VM do Ubuntu para configuração adicional.
Após o login através do cliente SSH, emita o comando lspci e valide se a GPU NVIDIA está listada como "controlador 3D".

Importante

Se a GPU NVIDIA não for vista como "controlador 3D", não prossiga. Certifique-se de que os passos acima são seguidos antes de prosseguir.
Dentro da VM, procure e abra Atualizações de Software. Navegue até Drivers adicionais e escolha os drivers de GPU NVIDIA mais recentes listados. Conclua a instalação do driver clicando no botão Aplicar alterações .
Reinicie a VM do Ubuntu após a conclusão da instalação do driver. Quando a VM for iniciada, conecte-se através do cliente SSH e execute o comando nvidia-smi para verificar se a instalação do driver da GPU NVIDIA foi concluída com êxito. A saída deve ser semelhante à captura de tela:

Usando o cliente SSH, configure o repositório e instale o Docker CE Engine:

$ sudo apt-get update
$ sudo apt-get install \
apt-transport-https \
ca-certificates \
curl \
gnupg-agent \
software-properties-common

Adicione a chave GPG oficial do Docker:

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Verifique se agora tem a chave com a impressão digital 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88, procurando os últimos oito caracteres da impressão digital:

$ sudo apt-key fingerprint 0EBFCD88

O seu resultado deve assemelhar-se a isto:

pub   rsa4096 2017-02-22 [SCEA]
9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88
uid           [ unknown] Docker Release (CE deb) <docker@docker.com>
sub   rsa4096 2017-02-22 [S]

Configure o repositório estável para a arquitetura Ubuntu AMD64:

$ sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable"

Atualize pacotes e instale o Docker CE:

$ sudo apt-get update
$ sudo apt-get install docker-ce docker-ce-cli containerd.io

Verifique a instalação do Docker CE:

$ sudo docker run hello-world

Configurar o Azure IoT Edge

Para se preparar para essa configuração, consulte as perguntas frequentes contidas no repositório NVIDIA-Deepstream-Azure-IoT-Edge-on-a-NVIDIA-Jetson-Nano GitHub, que explica a necessidade de instalar o Docker em vez do Moby. Após a revisão, prossiga para as próximas etapas.

Instalar o NVIDIA Docker

No cliente SSH, adicione repositórios de pacotes:

curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | \
sudo apt-key add -
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)

curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt-get update

Instale o nvidia-docker2 e recarregue a configuração do daemon do Docker:
```
sudo apt-get install -y nvidia-docker2
sudo pkill -SIGHUP dockerd
```
Reinicialize a VM:
```
sudo /sbin/shutdown -r now
```
Após a reinicialização, verifique se a instalação do NVIDIA Docker foi bem-sucedida.
```
sudo docker run --runtime=nvidia --rm nvidia/cuda:9.0-base nvidia-smi
```
Aqui está uma saída de uma instalação bem-sucedida:

Seguindo as instruções aqui, prossiga para instalar o Azure IoT Edge, ignorando a instalação em tempo de execução:

curl https://packages.microsoft.com/config/ubuntu/18.04/multiarch/prod.list > ./microsoft-prod.list

sudo cp ./microsoft-prod.list /etc/apt/sources.list.d/

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo cp ./microsoft.gpg /etc/apt/trusted.gpg.d/
sudo apt-get update

sudo apt-get install iotedge

Nota

Depois de instalar o Azure IoT Edge, verifique se o config.yaml está presente na VM do Ubuntu em /etc/iotedge/config.yaml

Crie uma identidade de dispositivo IoT Edge no portal do Azure seguindo as orientações aqui. Em seguida, copie a cadeia de conexão do dispositivo para o IoT Edge recém-criado.
Usando o cliente SSH, atualize a cadeia de conexão do dispositivo em config.yaml na VM do Ubuntu:
```
sudo nano /etc/iotedge/config.yaml
```
Encontre as configurações de provisionamento do arquivo e descomente a seção "Configuração de provisionamento manual". Atualize o valor de device_connection_string com a cadeia de conexão do seu dispositivo IoT Edge. Certifique-se de que quaisquer outras secções de provisionamento estejam comentadas. Certifique-se de que a linha de provisionamento: não tenha espaços em branco antes e que os itens aninhados estejam indentados por dois espaços.

Para colar o conteúdo da área de transferência no Nano, shift+clique com o botão direito do rato ou prima shift+inserir. Salve e feche o arquivo (Ctrl + X, Y, Enter).
Usando o cliente SSH, reinicie o daemon do IoT Edge:
```
sudo systemctl restart iotedge
```
Verifique a instalação e verifique o status do daemon do IoT Edge:
```
systemctl status iotedge

journalctl -u iotedge --no-pager --no-full
```

Usando o cliente SSH, crie a seguinte estrutura de diretórios na VM do Ubuntu:

cd /var
sudo mkdir deepstream
mkdir ./deepstream/custom_configs
cd /var/deepstream
sudo mkdir custom_streams
sudo chmod -R 777 /var/deepstream
cd ./custom_streams

Certifique-se de que seu diretório de trabalho é /var/deepstream/custom_streams e baixe o arquivo de vídeos de demonstração executando o seguinte comando no cliente SSH:
```
wget -O cars-streams.tar.gz --no-check-certificate https://onedrive.live.com/download?cid=0C0A4A69A0CDCB4C&resid=0C0A4A69A0CDCB4C%21588371&authkey=AAavgrxG95v9gu0
```
Descompacte os arquivos de vídeo:
```
tar -xzvf cars-streams.tar.gz
```
O conteúdo do diretório /var/deepstream/custom_streams deve ser semelhante à captura de tela:

Crie um novo arquivo chamado test5_config_file_src_infer_azure_iotedge_edited.txt no diretório /var/deepstream/custom_configs. Usando um editor de texto, abra o arquivo e cole no código a seguir, salve e feche o arquivo.

# Copyright (c) 2018 NVIDIA Corporation.  All rights reserved.
#
# NVIDIA Corporation and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto.  Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA Corporation is strictly prohibited.

[application]
enable-perf-measurement=1
perf-measurement-interval-sec=5
#gie-kitti-output-dir=streamscl

[tiled-display]
enable=1
rows=2
columns=2
width=1280
height=720
gpu-id=0
#(0): nvbuf-mem-default - Default memory allocated, specific to particular platform
#(1): nvbuf-mem-cuda-pinned - Allocate Pinned/Host cuda memory, applicable for Tesla
#(2): nvbuf-mem-cuda-device - Allocate Device cuda memory, applicable for Tesla
#(3): nvbuf-mem-cuda-unified - Allocate Unified cuda memory, applicable for Tesla
#(4): nvbuf-mem-surface-array - Allocate Surface Array memory, applicable for Jetson
nvbuf-memory-type=0

[source0]
enable=1
#Type - 1=CameraV4L2 2=URI 3=MultiURI
type=3
uri=file://../../../../../samples/streams/sample_1080p_h264.mp4
num-sources=2
gpu-id=0
nvbuf-memory-type=0

[source1]
enable=1
#Type - 1=CameraV4L2 2=URI 3=MultiURI
type=3
uri=file://../../../../../samples/streams/sample_1080p_h264.mp4
num-sources=2
gpu-id=0
nvbuf-memory-type=0

[sink0]
enable=0

[sink3]
enable=1
#Type - 1=FakeSink 2=EglSink 3=File 4=RTSPStreaming
type=4
#1=h264 2=h265
codec=1
sync=0
bitrate=4000000
# set properties in case of RTSPStreaming
rtsp-port=8554
udp-port=5400

[sink1]
enable=1
#Type - 1=FakeSink 2=EglSink 3=File 4=UDPSink 5=nvoverlaysink 6=MsgConvBroker
type=6
msg-conv-config=../configs/dstest5_msgconv_sample_config.txt
#(0): PAYLOAD_DEEPSTREAM - Deepstream schema payload
#(1): PAYLOAD_DEEPSTREAM_MINIMAL - Deepstream schema payload minimal
#(256): PAYLOAD_RESERVED - Reserved type
#(257): PAYLOAD_CUSTOM   - Custom schema payload
msg-conv-payload-type=1
msg-broker-proto-lib=/opt/nvidia/deepstream/deepstream-4.0/lib/libnvds_azure_edge_proto.so
topic=mytopic
#Optional:
#msg-broker-config=../../../../libs/azure_protocol_adaptor/module_client/cfg_azure.txt

[sink2]
enable=0
type=3
#1=mp4 2=mkv
container=1
#1=h264 2=h265 3=mpeg4
## only SW mpeg4 is supported right now.
codec=3
sync=1
bitrate=2000000
output-file=out.mp4
source-id=0

[osd]
enable=1
gpu-id=0
border-width=1
text-size=15
text-color=1;1;1;1;
text-bg-color=0.3;0.3;0.3;1
font=Arial
show-clock=0
clock-x-offset=800
clock-y-offset=820
clock-text-size=12
clock-color=1;0;0;0
nvbuf-memory-type=0

[streammux]
gpu-id=0
##Boolean property to inform muxer that sources are live
live-source=0
batch-size=4
##time out in usec, to wait after the first buffer is available
##to push the batch even if the complete batch isn't formed
batched-push-timeout=40000
## Set muxer output width and height
width=1920
height=1080
##Enable to maintain aspect ratio wrt source, and allow black borders, works
##along with width, height properties
enable-padding=0
nvbuf-memory-type=0

[primary-gie]
enable=1
gpu-id=0
batch-size=4
## 0=FP32, 1=INT8, 2=FP16 mode
bbox-border-color0=1;0;0;1
bbox-border-color1=0;1;1;1
bbox-border-color2=0;1;1;1
bbox-border-color3=0;1;0;1
nvbuf-memory-type=0
interval=0
gie-unique-id=1
model-engine-file=../../../../../samples/models/Primary_Detector/resnet10.caffemodel_b4_int8.engine
labelfile-path=../../../../../samples/models/Primary_Detector/labels.txt
config-file=../../../../../samples/configs/deepstream-app/config_infer_primary.txt
#infer-raw-output-dir=../../../../../samples/primary_detector_raw_output/

[tracker]
enable=1
tracker-width=600
tracker-height=300
ll-lib-file=/opt/nvidia/deepstream/deepstream-4.0/lib/libnvds_mot_klt.so
#ll-config-file required for DCF/IOU only
#ll-config-file=tracker_config.yml
#ll-config-file=iou_config.txt
gpu-id=0
#enable-batch-process applicable to DCF only
enable-batch-process=0

[tests]
file-loop=1

Navegue para o portal do Azure. Selecione IoT Hub Provisioned, clique em Gerenciamento Automático de Dispositivos e, em seguida, clique em IoT Edge:
No painel direito, selecione a identidade do dispositivo cuja cadeia de conexão do dispositivo foi usada. Clique em definir módulos:
Em Módulos IoT Edge, clique e escolha Módulo IoT Edge:
No painel Adicionar Módulo de Borda IoT , selecione a guia Configurações do Módulo e insira ou selecione os seguintes valores:
- Nome do módulo IoT Edge: NVIDIADeepStreamSDK
- URI da imagem: marketplace.azurecr.io/nvidia/deepstream-iot2
- Política de reinicialização: sempre
- Status desejado: em execução
- Política de extração de imagem: em branco
Selecione Adicionar.
Verifique se o módulo NvidiaDeepStreamSDK está listado em Módulos IoT Edge:

Clique no módulo "NVIDIADeepStreamSDK" e escolha "Opções de criação de contêiner". A configuração padrão é mostrada aqui:

Substitua a configuração acima pela configuração:

{
  "ExposedPorts": {
    "8554/tcp": {}
  },
  "Entrypoint": [
    "/usr/bin/deepstream-test5-app",
    "-c",
    "test5_config_file_src_infer_azure_iotedge_edited.txt",
    "-p",
    "1",
    "-m",
    "1"
  ],
  "HostConfig": {
    "runtime": "nvidia",
    "Binds": [
      "/var/deepstream/custom_configs:/root/deepstream_sdk_v4.0.2_x86_64/sources/apps/sample_apps/deepstream-test5/custom_configs/",
      "/var/deepstream/custom_streams:/root/deepstream_sdk_v4.0.2_x86_64/sources/apps/sample_apps/deepstream-test5/custom_streams/"
    ],
    "PortBindings": {
      "8554/tcp": [
        {
          "HostPort": "8554"
        }
      ]
    }
  },
  "WorkingDir": "/root/deepstream_sdk_v4.0.2_x86_64/sources/apps/sample_apps/deepstream-test5/custom_configs/"
}

Selecione Rever e Criar e, na página seguinte, clique em Criar. Agora você deve ver os três módulos listados para seu dispositivo IoT Edge no portal do Azure:
Conecte-se à VM do Ubuntu usando o cliente SSH e verifique se os módulos corretos estão em execução:
```
sudo iotedge list
```
```
nvidia-smi
```
Nota

Leva alguns minutos para que o NvidiaDeepstream Container seja baixado. Você pode validar o download usando o comando journalctl -u iotedge --no-pager --no-full para examinar os logs do daemon iotedge.
Confirme se o contêiner NvdiaDeepStreem está operacional. A saída do comando nas capturas de tela indica sucesso.
```
sudo iotedge list
```
```
sudo iotedge logs -f NVIDIADeepStreamSDK
```
```
nvidia-smi
```
Confirme o endereço TCP/IP para sua VM Ubuntu usando o comando ifconfig e procure o endereço TCP/IP ao lado da interface eth0 .
Instale o VLC Player na sua estação de trabalho. No VLC Player, clique em Mídia -> fluxo de rede aberta e digite o endereço usando este formato:

rtsp://ipaddress:8554/ds-test

onde ipaddress é o endereço TCP/IP da sua VM.