Koppla en GPU till en virtuell Ubuntu Linux-dator på Azure Stack HCI

Artikel
02/23/2024

Gäller för: Azure Stack HCI, versionerna 23H2 och 22H2

Anteckning

Det rekommenderade sättet att skapa och hantera virtuella datorer på Azure Stack HCI 23H2 är att använda Azure Arc-kontrollplanet. Använd mekanismen som beskrivs nedan för att endast hantera dina virtuella datorer om du behöver funktioner som inte är tillgängliga på virtuella Azure Arc-datorer.

Det här avsnittet innehåller stegvisa instruktioner om hur du installerar och konfigurerar en NVIDIA-grafikprocessor (GPU) med Azure Stack HCI med hjälp av DDA-teknik (Discrete Device Assignment) för en virtuell Ubuntu-dator (VM). Det här dokumentet förutsätter att du har Azure Stack HCI-klustret distribuerat och virtuella datorer installerade.

Installera GPU:n och demontera den sedan i PowerShell

Installera NVIDIA GPU:er fysiskt i lämpliga servrar enligt OEM-instruktioner och BIOS-rekommendationer.
Starta på varje server.
Logga in med ett konto med administratörsbehörighet till servrarna med NVIDIA GPU installerat.
Öppna Enhetshanteraren och gå till avsnittet andra enheter. Du bör se en enhet som visas som "3D-videostyrenhet".
Högerklicka på "3D Video Controller" för att öppna sidan Egenskaper . Klicka på Information. I listrutan under Egenskap väljer du "Platssökvägar".
Observera värdet med strängen PCIRoot som markerat i skärmbilden nedan. Högerklicka på Värde och kopiera/spara det.
Öppna Windows PowerShell med förhöjd behörighet och kör cmdleten Dismount-VMHostAssignableDevice för att demontera GPU-enheten för DDA till virtuell dator. Ersätt Värdet LocationPath med värdet för din enhet som hämtades i steg 6.
```
Dismount-VMHostAssignableDevice -LocationPath "PCIROOT(16)#PCI(0000)#PCI(0000)" -force
```
Bekräfta att enheten visas under systemenheter i Enhetshanteraren som Demonterad.

Skapa och konfigurera en virtuell Ubuntu-dator

Ladda ned Ubuntu Desktop version 18.04.02 ISO.
Öppna Hyper-V Manager på noden i systemet med GPU:n installerad.

Anteckning

DDA stöder inte redundans. Det här är en begränsning för virtuella datorer med DDA. Därför rekommenderar vi att du använder Hyper-V Manager för att distribuera den virtuella datorn på noden i stället för Klusterhanteraren för växling vid fel. Användning av Klusterhanteraren för växling vid fel med DDA misslyckas med ett felmeddelande som anger att den virtuella datorn har en enhet som inte stöder hög tillgänglighet.
Använd Ubuntu ISO som laddades ned i steg 1 och skapa en ny virtuell dator med guiden Ny virtuell dator i Hyper-V Manager för att skapa en virtuell Ubuntu Gen 1-dator med 2 GB minne och ett nätverkskort kopplat till den.

I PowerShell tilldelar du den demonterade GPU-enheten till den virtuella datorn med hjälp av cmdletarna nedan och ersätter LocationPath-värdet med värdet för din enhet.

# 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

En lyckad tilldelning av GPU:n till den virtuella datorn visar utdata nedan:

Konfigurera ytterligare värden enligt GPU-dokumentationen här:

 # 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

Anteckning

Värdet 33280 Mb bör räcka för de flesta GPU:er, men bör ersättas med ett värde som är större än GPU-minnet.

Använd Hyper-V Manager, anslut till den virtuella datorn och starta installationen av Ubuntu OS. Välj standardinställningarna för att installera Ubuntu-operativsystemet på den virtuella datorn.
När installationen är klar använder du Hyper-V Manager för att stänga av den virtuella datorn och konfigurera åtgärden Automatiskt stopp för den virtuella datorn så att gästoperativsystemet stängs av som på skärmbilden nedan:
Logga in på Ubuntu och öppna terminalen för att installera SSH:
```
 $ sudo apt install openssh-server
```
Leta upp TCP/IP-adressen för Ubuntu-installationen med hjälp av kommandot ifconfig och kopiera IP-adressen för eth0-gränssnittet .
Använd en SSH-klient som OpenSSH (ssh.exe installeras med Windows 10 som standard) eller Putty för att ansluta till den virtuella Ubuntu-datorn för ytterligare konfiguration.
Vid inloggning via SSH-klienten utfärdar du kommandot lspci och verifierar att NVIDIA GPU visas som "3D-styrenhet".

Viktigt

Om NVIDIA GPU inte ses som "3D-styrenhet" ska du inte gå vidare. Kontrollera att stegen ovan följs innan du fortsätter.
I den virtuella datorn söker du efter och öppnar Software & Uppdateringar. Gå till Ytterligare drivrutiner och välj sedan de senaste NVIDIA GPU-drivrutinerna i listan. Slutför drivrutinsinstallationen genom att klicka på knappen Tillämpa ändringar .
Starta om den virtuella Ubuntu-datorn när drivrutinsinstallationen har slutförts. När den virtuella datorn startar ansluter du via SSH-klienten och utfärdar kommandot nvidia-smi för att kontrollera att NVIDIA GPU-drivrutinsinstallationen har slutförts. Utdata bör likna skärmbilden nedan:

Med hjälp av SSH-klienten konfigurerar du lagringsplatsen och installerar Docker CE-motorn:

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

Lägg till Docker officiella GPG-nyckel:

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

Kontrollera att du nu har nyckeln med fingeravtrycket 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88 genom att söka efter fingeravtryckets sista åtta tecken:

$ sudo apt-key fingerprint 0EBFCD88

Dina utdata bör se ut ungefär så här:

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]

Konfigurera den stabila lagringsplatsen för Ubuntu AMD64-arkitekturen:

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

Uppdatera paket och installera Docker CE:

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

Kontrollera Docker CE-installationen:

$ sudo docker run hello-world

Konfigurera Azure IoT Edge

För att förbereda för den här konfigurationen kan du läsa vanliga frågor och svar i GITHub-lagringsplatsen NVIDIA-Deepstream-Azure-IoT-Edge-on-a-NVIDIA-Jetson-Nano , som förklarar behovet av att installera Docker i stället för Moby. När du har granskat går du vidare till stegen nedan.

Installera NVIDIA Docker

Från SSH-klienten lägger du till paketlagringsplatser:

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

Installera nvidia-docker2 och ladda om Docker-daemonkonfigurationen:
```
sudo apt-get install -y nvidia-docker2
sudo pkill -SIGHUP dockerd
```
Starta om den virtuella datorn:
```
sudo /sbin/shutdown -r now
```
Vid omstart kontrollerar du att NVIDIA Docker har installerats:
```
sudo docker run --runtime=nvidia --rm nvidia/cuda:9.0-base nvidia-smi
```
Installationen kommer att se ut som utdata på skärmbilden nedan:

Följ anvisningarna här och fortsätt att installera Azure IoT Edge och hoppa över körningsinstallationen:

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

Anteckning

När du har installerat Azure IoT Edge kontrollerar du att config.yaml finns på den virtuella Ubuntu-datorn på /etc/iotedge/config.yaml

Skapa en IoT Edge enhetsidentitet i Azure Portal följande vägledning här. Kopiera sedan enhetens anslutningssträng för den nyligen skapade IoT Edge.
Använd SSH-klienten och uppdatera enheten anslutningssträng i config.yaml på den virtuella Ubuntu-datorn:
```
sudo nano /etc/iotedge/config.yaml
```
Leta reda på konfigurationerna för filen och avkommentera avsnittet "Manuell etableringskonfiguration". Uppdatera värdet för device_connection_string med anslutningssträng från IoT Edge enheten. Kontrollera att alla andra etableringsavsnitt har kommenterats bort. Kontrollera att etableringen: raden inte har något föregående blanksteg och att kapslade objekt är indragna med två blanksteg:

Om du vill klistra in innehållet i Urklipp i Nano skiftar du+högerklickar eller trycker på skift+insert. Spara och stäng filen (Ctrl + X, Y, Retur).
Starta om IoT Edge-daemon med hjälp av SSH-klienten:
```
sudo systemctl restart iotedge
```
Kontrollera installationen och kontrollera statusen för IoT Edge-daemon:
```
systemctl status iotedge

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

Använd SSH-klienten och skapa följande katalogstruktur på den virtuella Ubuntu-datorn:

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

Kontrollera att arbetskatalogen är /var/deepstream/custom_streams och ladda ned demovideofilen genom att köra följande kommando i SSH-klienten:
```
wget -O cars-streams.tar.gz --no-check-certificate https://onedrive.live.com/download?cid=0C0A4A69A0CDCB4C&resid=0C0A4A69A0CDCB4C%21588371&authkey=AAavgrxG95v9gu0
```
Avkomprimera videofilerna:
```
tar -xzvf cars-streams.tar.gz
```
Innehållet i katalogen /var/deepstream/custom_streams bör likna skärmbilden nedan:

Skapa en ny fil med namnet test5_config_file_src_infer_azure_iotedge_edited.txt i katalogen /var/deepstream/custom_configs. Öppna filen med hjälp av en textredigerare och klistra in följande kod och spara och stäng sedan filen.

# 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 below 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 is not 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

Gå till Azure-portalen. Välj IoT Hub Etablerad, klicka på Automatisk Enhetshantering och klicka sedan på IoT Edge:
I den högra rutan väljer du den enhetsidentitet vars anslutningssträng användes ovan. Klicka på Ange moduler:
Under IoT Edge moduler klickar du på och väljer IoT Edge modul:
I fönstret Lägg till IoT Edge modul väljer du fliken Modulinställningar och anger eller väljer sedan följande värden:
- IoT Edge modulnamn: NVIDIADeepStreamSDK
- Bild-URI: marketplace.azurecr.io/nvidia/deepstream-iot2
- Omstartsprincip: alltid
- Önskad status: körs
- Bildhämtningsprincip: tom
Välj Lägg till.
Se till att NvidiaDeepStreamSDK-modulen visas under IoT Edge-moduler:

Klicka på modulen "NVIDIADeepStreamSDK" och välj "Alternativ för att skapa container". Standardkonfigurationen visas här:

Ersätt konfigurationen ovan med konfigurationen nedan:

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

Klicka på Granska och skapa och klicka på Skapa på nästa sida. Nu bör du se de tre modulerna nedan för din IoT Edge-enhet i Azure Portal:
Anslut till den virtuella Ubuntu-datorn med SSH-klienten och kontrollera att rätt moduler körs:
```
sudo iotedge list
```
```
nvidia-smi
```
Anteckning

Det tar några minuter innan NvidiaDeepstream-containern laddas ned. Du kan verifiera nedladdningen med kommandot "journalctl -u iotedge --no-pager --no-full" för att titta på daemonloggarna för iotedge.
Kontrollera att NvdiaDeepStreem-containern fungerar. Kommandots utdata i skärmbilderna nedan indikerar att det lyckades.
```
sudo iotedge list
```
```
sudo iotedge logs -f NVIDIADeepStreamSDK
```
```
nvidia-smi
```
Bekräfta TCP/IP-adressen för din virtuella Ubuntu-dator med hjälp av kommandot ifconfig och leta efter TCP/IP-adressen bredvid eth0-gränssnittet .
Installera VLC Player på din arbetsstation. I VLC Player klickar du på Media –> öppna nätverksströmmen och skriver in adressen med det här formatet:

rtsp://ipaddress:8554/ds-test

där ipaddress är den virtuella datorns TCP/IP-adress.