Conexión de una GPU a una máquina virtual Ubuntu Linux en Azure Local

2025-07-07

Se aplica a: Azure Local 2311.2 y versiones posteriores

Nota:

La manera recomendada de crear y administrar máquinas virtuales en Azure Local es usar el plano de control de Azure Arc. Sin embargo, dado que Azure Arc aún no proporciona la funcionalidad descrita en este artículo, puede usar Windows Admin Center o PowerShell como se describe en este artículo. Las máquinas virtuales creadas de esta manera no están habilitadas por Azure Arc, tienen una capacidad de administración limitada desde el plano de control de Azure Arc y menos ventajas híbridas de Azure, incluido el uso de Azure Update Manager sin costo adicional.
Para más información, consulte Comparar las capacidades de gestión de las máquinas virtuales en Azure Local y Operaciones admitidas para máquinas virtuales locales en Azure.

En este tema se proporcionan instrucciones paso a paso sobre cómo instalar y configurar una unidad de procesamiento de gráficos (GPU) de NVIDIA en Azure Local mediante la tecnología de asignación de dispositivos discretos (DDA) para una máquina virtual Ubuntu. Debe tener una instancia local de Azure ya implementada y máquinas virtuales instaladas.

Instalación de la GPU y su posterior desmontaje en PowerShell

Instale las GPU de NVIDIA físicamente en la máquina adecuada siguiendo las instrucciones de OEM y las recomendaciones de BIOS.
Encienda cada máquina.
Inicie sesión con una cuenta con privilegios administrativos en la máquina con la GPU de NVIDIA instalada.
Abra el Administrador de dispositivos y vaya a la sección otros dispositivos . Verá en la lista un dispositivo "Controladora de vídeo 3D".
Haga clic con el botón derecho en "Controlador de vídeo 3D" para abrir la página Propiedades . Haga clic en Detalles. En la lista desplegable en Propiedad, seleccione "Rutas de acceso de ubicación".
Tome nota del valor con la cadena PCIRoot que se muestra en la captura de pantalla. Haga clic con el botón derecho en Valor y cópielo o guárdelo.
Abra Windows PowerShell con privilegios elevados y ejecute el cmdlet Dismount-VMHostAssignableDevice para desmontar el dispositivo GPU de DDA en la máquina virtual. Reemplace el valor locationPath por el valor del dispositivo obtenido en el paso 6.
```
Dismount-VMHostAssignableDevice -LocationPath "PCIROOT(16)#PCI(0000)#PCI(0000)" -force
```
Confirme que el dispositivo aparece en dispositivos del sistema en Administrador de dispositivos como Desmontado.

Creación y configuración de una máquina virtual Ubuntu

Descargue la versión de escritorio de Ubuntu 18.04.02 ISO.
Abra Hyper-V Manager en el equipo donde se encuentra su instancia local de Azure con la GPU instalada.

Nota:

DDA no admite la conmutación por error. Se trata de una limitación de máquina virtual con DDA. Por lo tanto, se recomienda usar Administrador de Hyper-V para implementar la máquina virtual en lugar de Administrador de clústeres de conmutación por error. El uso de Administrador de clústeres de conmutación por error con DDA produce un error que indica que la máquina virtual tiene un dispositivo que no admite alta disponibilidad.
Con la ISO de Ubuntu descargada en el paso 1, cree una nueva máquina virtual mediante el Asistente para nueva máquina virtual en Hyper-V Manager para crear una máquina virtual de Ubuntu Generation 1 con 2 GB de memoria y una tarjeta de red conectada a ella.

En PowerShell, asigne el dispositivo GPU desmontado a la máquina virtual mediante los cmdlets y reemplace el valor locationPath por el valor del 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

Esta es una salida de la asignación correcta de la GPU a la máquina virtual:

Configura otros valores según la documentación de la GPU aquí

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

El valor 33280Mb debe ser suficiente para la mayoría de las GPU, pero debe reemplazarse por un valor mayor que la memoria de GPU.

Mediante el Administrador de Hyper-V, conéctese a la máquina virtual e inicie la instalación del sistema operativo Ubuntu. Elija los valores predeterminados para instalar el sistema operativo Ubuntu en la máquina virtual.
Una vez completada la instalación, use Hyper-V Manager para apagar la máquina virtual y configurar la acción de detención automática para que la máquina virtual apague el sistema operativo invitado como en la captura de pantalla:
Inicie sesión en Ubuntu y abra el terminal para instalar SSH:
```
 $ sudo apt install openssh-server
```
Busque la dirección TCP/IP de la instalación de Ubuntu mediante el comando ifconfig y copie la dirección IP de la interfaz eth0 .
Use un cliente SSH como OpenSSH (ssh.exe instalado con Windows 10 de forma predeterminada) o Putty para conectarse a la máquina virtual Ubuntu para una configuración adicional.
Al iniciar sesión a través del cliente SSH, emita el comando lspci y valide que la GPU de NVIDIA aparece como "controlador 3D".

Importante

Si la GPU de NVIDIA no se ve como "controlador 3D", no continúe. Asegúrese de que se siguen los pasos anteriores antes de continuar.
Dentro de la máquina virtual, busque y abra Software & Updates. Vaya a Controladores adicionales y elija los controladores de GPU de NVIDIA más recientes enumerados. Complete la instalación del controlador haciendo clic en el botón Aplicar cambios .
Una vez completada la instalación del controlador, reinicie la máquina virtual Ubuntu. Una vez iniciada la máquina virtual, conéctese a través del cliente SSH y emita el comando nvidia-smi para comprobar que la instalación del controlador de GPU de NVIDIA se completó correctamente. La salida debe ser similar a la captura de pantalla:

Mediante el cliente SSH, configure el repositorio e instale el motor de Docker CE:

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

Agregue la clave GPG oficial de Docker:

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

Compruebe que ahora tiene la clave con la huella digital 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88; para ello, busque los últimos ocho caracteres de la huella digital:

$ sudo apt-key fingerprint 0EBFCD88

La salida se parecerá a esta:

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 el repositorio estable para la arquitectura de Ubuntu AMD64:

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

Actualice los paquetes e instale Docker CE:

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

Compruebe la instalación de Docker CE:

$ sudo docker run hello-world

Configuración de Azure IoT Edge

Para prepararse para esta configuración, revise las preguntas más frecuentes contenidas en el repositorio NVIDIA-Deepstream-Azure-IoT-Edge-on-a-NVIDIA-Jetson-Nano GitHub, que explica la necesidad de instalar Docker en lugar de Moby. Después de revisarlo, continúe con los pasos siguientes.

Instalación de Docker de MVIDIA

En el cliente SSH, agregue repositorios de paquetes:

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 nvidia-docker2 y vuelva a cargar la configuración del demonio de Docker:
```
sudo apt-get install -y nvidia-docker2
sudo pkill -SIGHUP dockerd
```
Reinicie la máquina virtual:
```
sudo /sbin/shutdown -r now
```
Tras el reinicio, compruebe que Docker de NVDIA se ha instalado correctamente:
```
sudo docker run --runtime=nvidia --rm nvidia/cuda:9.0-base nvidia-smi
```
Esta es una salida de una instalación correcta:

Siga las instrucciones que se indican aquí y continúe con la instalación de Azure IoT Edge, pero omita la instalación del entorno de ejecución:

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:

Después de instalar Azure IoT Edge, compruebe que el archivo config.yaml existe en la máquina virtual Ubuntu en /etc/iotedge/config.yaml

Cree una identidad de dispositivo IoT Edge en Azure Portal siguiendo las instrucciones que se indican aquí. A continuación, copie la cadena de conexión del dispositivo para la instancia de IoT Edge recién creada.
Mediante el cliente SSH, actualice la cadena de conexión del dispositivo en config.yaml en la máquina virtual Ubuntu:
```
sudo nano /etc/iotedge/config.yaml
```
Busque las configuraciones de aprovisionamiento del archivo y quite la marca de comentario de la sección "Manual provisioning configuration". Actualice el valor de device_connection_string con la cadena de conexión desde un dispositivo IoT Edge. Compruebe que cualquier otra sección de aprovisionamiento esté comentada. Asegúrese de que la línea provisioning: no tenga ningún espacio en blanco antes y que los elementos anidados tengan una sangría de dos espacios:

Para pegar el contenido del portapapeles en Nano, mantenga presionada la tecla Mayús y haga clic con el botón derecho o presione Mayús + Insertar. Guarde y cierre el archivo (Ctrl + X, Y, Entrar).
Con el cliente SSH, reinicie el demonio de IoT Edge:
```
sudo systemctl restart iotedge
```
Compruebe la instalación y el estado del demonio de IoT Edge:
```
systemctl status iotedge

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

Mediante el cliente SSH, cree la siguiente estructura de directorio en la máquina virtual 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

Asegúrese de que el directorio de trabajo es /var/deepstream/custom_streams y descargue el archivo de vídeos de demostración ejecutando el siguiente comando en el cliente SSH:
```
wget -O cars-streams.tar.gz --no-check-certificate https://onedrive.live.com/download?cid=0C0A4A69A0CDCB4C&resid=0C0A4A69A0CDCB4C%21588371&authkey=AAavgrxG95v9gu0
```
Descomprima los archivos de vídeo:
```
tar -xzvf cars-streams.tar.gz
```
El contenido del directorio /var/deepstream/custom_streams debe ser similar a la captura de pantalla:

Cree un archivo llamado test5_config_file_src_infer_azure_iotedge_edited.txt en el directorio /var/deepstream/custom_configs. Con un editor de texto, abra el archivo, pegue el código siguiente y, luego, guarde y cierre el archivo.

# 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

Acceda a Azure Portal. Seleccione IoT Hub Provisioned, haga clic en Administración automática de dispositivos y, a continuación, haga clic en IoT Edge:
En el panel derecho, seleccione la identidad del dispositivo cuya cadena de conexión de dispositivo se usó. Haga clic en Establecer módulos:
En Módulos IoT Edge, haga clic y elija el módulo IoT Edge:
En el panel Agregar módulo ioT Edge , seleccione la pestaña Configuración del módulo y, a continuación, escriba o seleccione los valores siguientes:
- Nombre del módulo ioT Edge: NVIDIADeepStreamSDK
- URI de imagen: marketplace.azurecr.io/nvidia/deepstream-iot2
- Directiva de reinicio: siempre
- Estado deseado: en ejecución
- Directiva de extracción de imágenes: blanco
Seleccione Agregar.
Asegúrese de que el módulo NvidiaDeepStreamSDK aparece en Módulos de IoT Edge:

Haga clic en el módulo "NVIDIADeepStreamSDK" y elija "Opciones de creación del contenedor". La configuración predeterminada se muestra a continuación:

Reemplace la configuración anterior por la configuración:

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

Seleccione Revisar y crear y, en la página siguiente, haga clic en Crear. Ahora debería ver los tres módulos enumerados para el dispositivo IoT Edge en Azure Portal:
Conéctese a la máquina virtual Ubuntu mediante el cliente SSH y compruebe que se ejecutan los módulos correctos:
```
sudo iotedge list
```
```
nvidia-smi
```
Nota:

El contenedor NvidiaDeepstream tarda unos minutos en descargarse. Puede validar la descarga mediante el comando journalctl -u iotedge --no-pager --no-full para consultar los registros del daemon de iotedge.
Confirme que el contenedor NvdiaDeepStreem está operativo. La salida del comando en las capturas de pantalla indica que se ha realizado correctamente.
```
sudo iotedge list
```
```
sudo iotedge logs -f NVIDIADeepStreamSDK
```
```
nvidia-smi
```
Confirme la dirección TCP/IP de la máquina virtual Ubuntu mediante el comando ifconfig y busque la dirección TCP/IP junto a la interfaz eth0 .
Instale VLC Player en la estación de trabajo. En el VLC Reproductor, haga clic en Medios -> abrir secuencia de red y escriba la dirección con este formato:

rtsp://ipaddress:8554/ds-test

donde ipaddress es la dirección TCP/IP de la máquina virtual.