Dołączanie procesora GPU do maszyny wirtualnej z systemem Ubuntu Linux w usłudze Azure Stack HCI

Artykuł
03/05/2024

Dotyczy: Azure Stack HCI, wersje 23H2 i 22H2

Uwaga

Zalecanym sposobem tworzenia maszyn wirtualnych i zarządzania nimi w usłudze Azure Stack HCI 23H2 jest użycie płaszczyzny sterowania usługi Azure Arc. Użyj mechanizmu opisanego poniżej, aby zarządzać maszynami wirtualnymi tylko wtedy, gdy potrzebujesz funkcji, które nie są dostępne na maszynach wirtualnych usługi Azure Arc.

Ten temat zawiera instrukcje krok po kroku dotyczące sposobu instalowania i konfigurowania jednostki przetwarzania grafiki (GPU) firmy NVIDIA za pomocą usługi Azure Stack HCI przy użyciu technologii dyskretnego przypisania urządzenia (DDA) dla maszyny wirtualnej z systemem Ubuntu. W tym dokumencie założono, że masz wdrożony klaster rozwiązania Azure Stack HCI i zainstalowano maszyny wirtualne.

Zainstaluj procesor GPU, a następnie odinstaluj go w programie PowerShell

Zainstaluj procesory GPU firmy NVIDIA fizycznie na odpowiednich serwerach, postępując zgodnie z instrukcjami producenta OEM i zaleceniami systemu BIOS.
Włącz każdy serwer.
Zaloguj się przy użyciu konta z uprawnieniami administracyjnymi do serwerów z zainstalowanym procesorem GPU firmy NVIDIA.
Otwórz Menedżer urządzeń i przejdź do sekcji inne urządzenia. Urządzenie powinno zostać wyświetlone jako "Kontroler wideo 3D".
Kliknij prawym przyciskiem myszy pozycję "Kontroler wideo 3D", aby wyświetlić stronę Właściwości . Kliknij pozycję Szczegóły. Z listy rozwijanej w obszarze Właściwość wybierz pozycję "Ścieżki lokalizacji".
Zanotuj wartość z ciągiem PCIRoot wyróżnioną na poniższym zrzucie ekranu. Kliknij prawym przyciskiem myszy pozycję Wartość i skopiuj/zapisz ją.
Otwórz Windows PowerShell z podwyższonym poziomem uprawnień i wykonaj Dismount-VMHostAssignableDevice polecenie cmdlet , aby odinstalować urządzenie gpu dla DDA na maszynie wirtualnej. Zastąp wartość LocationPath wartością urządzenia uzyskaną w kroku 6.
```
Dismount-VMHostAssignableDevice -LocationPath "PCIROOT(16)#PCI(0000)#PCI(0000)" -force
```
Upewnij się, że urządzenie znajduje się na liście urządzeń systemowych w Menedżer urządzeń jako Odinstalowane.

Tworzenie i konfigurowanie maszyny wirtualnej z systemem Ubuntu

Pobierz wersję 18.04.02 ISO dla systemu Ubuntu Desktop.
Otwórz Menedżera funkcji Hyper-V w węźle systemu z zainstalowanym procesorem GPU.

Uwaga

DDA nie obsługuje trybu failover. Jest to ograniczenie maszyny wirtualnej z DDA. Dlatego zalecamy użycie Menedżera funkcji Hyper-V do wdrożenia maszyny wirtualnej w węźle zamiast Menedżera klastra trybu failover. Użycie Menedżera klastra trybu failover z funkcją DDA zakończy się niepowodzeniem z komunikatem o błędzie wskazującym, że maszyna wirtualna ma urządzenie, które nie obsługuje wysokiej dostępności.
Korzystając z obrazu ISO systemu Ubuntu pobranego w kroku 1, utwórz nową maszynę wirtualną przy użyciu Kreatora nowej maszyny wirtualnej w Menedżerze funkcji Hyper-V , aby utworzyć maszynę wirtualną z systemem Ubuntu Gen 1 z 2 GB pamięci i dołączoną do niej kartą sieciową.

W programie PowerShell przypisz urządzenie Dismounted GPU do maszyny wirtualnej przy użyciu poniższych poleceń cmdlet, zastępując wartość LocationPath wartością dla urządzenia.

# 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

Pomyślne przypisanie procesora GPU do maszyny wirtualnej spowoduje wyświetlenie poniższych danych wyjściowych:

Skonfiguruj dodatkowe wartości następującej dokumentacji procesora GPU tutaj:

 # 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

Uwaga

Wartość 33280Mb powinna wystarczyć dla większości procesorów GPU, ale powinna zostać zastąpiona wartością większą niż pamięć procesora GPU.

Za pomocą Menedżera funkcji Hyper-V nawiąż połączenie z maszyną wirtualną i uruchom instalację systemu operacyjnego Ubuntu. Wybierz wartości domyślne, aby zainstalować system operacyjny Ubuntu na maszynie wirtualnej.
Po zakończeniu instalacji użyj Menedżera funkcji Hyper-V , aby zamknąć maszynę wirtualną i skonfigurować akcję automatycznego zatrzymywania maszyny wirtualnej w celu zamknięcia systemu operacyjnego gościa, jak pokazano na poniższym zrzucie ekranu:
Zaloguj się do systemu Ubuntu i otwórz terminal, aby zainstalować protokół SSH:
```
 $ sudo apt install openssh-server
```
Znajdź adres TCP/IP instalacji systemu Ubuntu przy użyciu polecenia ifconfig i skopiuj adres IP dla interfejsu eth0 .
Aby uzyskać dalszą konfigurację, użyj klienta SSH, takiego jak OpenSSH (ssh.exe zainstalowany z programem Windows 10) lub putty.
Po zalogowaniu się za pośrednictwem klienta SSH wydaj polecenie lspci i sprawdź, czy procesor GPU FIRMY NVIDIA jest wymieniony jako "kontroler 3D".

Ważne

Jeśli procesor GPU FIRMY NVIDIA nie jest postrzegany jako "kontroler 3D", nie kontynuuj dalej. Przed kontynuowaniem upewnij się, że przed kontynuowaniem wykonano powyższe kroki.
Na maszynie wirtualnej wyszukaj i otwórz & Aktualizacje oprogramowania. Przejdź do pozycji Dodatkowe sterowniki, a następnie wybierz najnowsze sterowniki procesora GPU firmy NVIDIA na liście. Ukończ instalację sterownika, klikając przycisk Zastosuj zmiany .
Uruchom ponownie maszynę wirtualną z systemem Ubuntu po zakończeniu instalacji sterownika. Po uruchomieniu maszyny wirtualnej nawiąż połączenie za pośrednictwem klienta SSH i wydaj polecenie nvidia-smi , aby sprawdzić, czy instalacja sterownika procesora GPU firmy NVIDIA zakończyła się pomyślnie. Dane wyjściowe powinny być podobne do poniższego zrzutu ekranu:

Korzystając z klienta SSH, skonfiguruj repozytorium i zainstaluj aparat Docker CE:

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

Dodaj oficjalny klucz GPG platformy Docker:

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

Sprawdź, czy masz teraz klucz z odciskiem palca 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88, wyszukując ostatnie osiem znaków odcisku palca:

$ sudo apt-key fingerprint 0EBFCD88

Dane wyjściowe powinny wyglądać mniej więcej tak:

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]

Skonfiguruj stabilne repozytorium dla architektury Ubuntu AMD64:

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

Aktualizowanie pakietów i instalowanie platformy Docker CE:

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

Sprawdź instalację platformy Docker CE:

$ sudo docker run hello-world

Konfigurowanie usługi Azure IoT Edge

Aby przygotować się do tej konfiguracji, zapoznaj się z często zadawanymi pytaniami zawartymi w repozytorium GitHub NVIDIA-Deepstream-Azure-IoT-Edge-on-a-NVIDIA-Jetson-Nano GitHub, w którym wyjaśniono konieczność zainstalowania platformy Docker zamiast narzędzia Moby. Po przejrzeniu przejdź do poniższych kroków.

Instalowanie platformy Docker firmy NVIDIA

Z poziomu klienta SSH dodaj repozytoria pakietów:

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

Zainstaluj narzędzie nvidia-docker2 i załaduj ponownie konfigurację demona platformy Docker:
```
sudo apt-get install -y nvidia-docker2
sudo pkill -SIGHUP dockerd
```
Uruchom ponownie maszynę wirtualną:
```
sudo /sbin/shutdown -r now
```
Po ponownym uruchomieniu zweryfikuj pomyślną instalację platformy DOcker FIRMY NVIDIA:
```
sudo docker run --runtime=nvidia --rm nvidia/cuda:9.0-base nvidia-smi
```
Pomyślna instalacja będzie wyglądać podobnie do danych wyjściowych na poniższym zrzucie ekranu:

Postępuj zgodnie z instrukcjami podanymi tutaj, aby zainstalować usługę Azure IoT Edge, pomijając instalację środowiska uruchomieniowego:

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

Uwaga

Po zainstalowaniu usługi Azure IoT Edge sprawdź, czy plik config.yaml jest obecny na maszynie wirtualnej z systemem Ubuntu pod adresem /etc/iotedge/config.yaml

Utwórz tożsamość urządzenia IoT Edge w Azure Portal zgodnie z poniższymi wskazówkami tutaj. Następnie skopiuj parametry połączenia urządzenia dla nowo utworzonej IoT Edge.
Korzystając z klienta SSH, zaktualizuj parametry połączenia urządzenia w pliku config.yaml na maszynie wirtualnej z systemem Ubuntu:
```
sudo nano /etc/iotedge/config.yaml
```
Znajdź konfiguracje aprowizacji pliku i usuń komentarz z sekcji "Ręczna konfiguracja aprowizacji". Zaktualizuj wartość device_connection_string przy użyciu parametry połączenia z urządzenia IoT Edge. Upewnij się, że wszystkie inne sekcje aprowizacji są oznaczane jako komentarz. Upewnij się, że aprowizacja: wiersz nie ma wcześniejszego odstępu i że zagnieżdżone elementy są wcięte przez dwie spacje:

Aby wkleić zawartość schowka do systemu Nano, naciśnij klawisze shift+prawym przyciskiem myszy lub naciśnij klawisze shift+insert. Zapisz i zamknij plik (Ctrl + X, Y, Enter).
Przy użyciu klienta SSH uruchom ponownie demona IoT Edge:
```
sudo systemctl restart iotedge
```
Sprawdź instalację i sprawdź stan demona IoT Edge:
```
systemctl status iotedge

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

Korzystając z klienta SSH, utwórz następującą strukturę katalogów na maszynie wirtualnej z systemem 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

Upewnij się, że katalog roboczy to /var/deepstream/custom_streams i pobierz plik wideo demonstracyjnych , wykonując następujące polecenie w kliencie SSH:
```
wget -O cars-streams.tar.gz --no-check-certificate https://onedrive.live.com/download?cid=0C0A4A69A0CDCB4C&resid=0C0A4A69A0CDCB4C%21588371&authkey=AAavgrxG95v9gu0
```
Cofnij kompresowanie plików wideo:
```
tar -xzvf cars-streams.tar.gz
```
Zawartość katalogu /var/deepstream/custom_streams powinna być podobna do poniższego zrzutu ekranu:

Utwórz nowy plik o nazwie test5_config_file_src_infer_azure_iotedge_edited.txt w katalogu /var/deepstream/custom_configs. Za pomocą edytora tekstów otwórz plik i wklej następujący kod, a następnie zapisz i zamknij plik.

# 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

Przejdź do witryny Azure Portal. Wybierz pozycję IoT Hub Aprowizowana, kliknij pozycję Automatyczne Zarządzanie urządzeniami, a następnie kliknij pozycję IoT Edge:
W okienku po prawej stronie wybierz tożsamość urządzenia, której urządzenie parametry połączenia zostało użyte powyżej. Kliknij pozycję Zestaw modułów:
W obszarze moduły IoT Edge kliknij i wybierz pozycję moduł IoT Edge:
W okienku Dodawanie modułu IoT Edge wybierz kartę Ustawienia modułu, a następnie wprowadź lub wybierz następujące wartości:
- nazwa modułu IoT Edge: NVIDIADeepStreamSDK
- Identyfikator URI obrazu: marketplace.azurecr.io/nvidia/deepstream-iot2
- Zasady ponownego uruchamiania: zawsze
- Żądany stan: uruchomiono
- Zasady ściągania obrazu: puste
Wybierz pozycję Dodaj.
Upewnij się, że moduł NvidiaDeepStreamSDK znajduje się na liście modułów IoT Edge:

Kliknij moduł "NVIDIADeepStreamSDK" i wybierz pozycję "Opcje tworzenia kontenera". Poniżej przedstawiono konfigurację domyślną:

Zastąp powyższą konfigurację poniższą konfiguracją:

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

Kliknij pozycję Przejrzyj i utwórz, a następnie na następnej stronie kliknij pozycję Utwórz. W Azure Portal powinny zostać wyświetlone trzy moduły wymienione poniżej dla urządzenia IoT Edge:
Połącz się z maszyną wirtualną z systemem Ubuntu przy użyciu klienta SSH i sprawdź, czy działają poprawne moduły:
```
sudo iotedge list
```
```
nvidia-smi
```
Uwaga

Pobranie kontenera NvidiaDeepstream potrwa kilka minut. Możesz zweryfikować pobieranie przy użyciu polecenia "journalctl -u iotedge --no-pager --no-full", aby przyjrzeć się dziennikom demona iotedge.
Upewnij się, że kontener NvdiaDeepStreem działa. Dane wyjściowe polecenia na poniższych zrzutach ekranu wskazują powodzenie.
```
sudo iotedge list
```
```
sudo iotedge logs -f NVIDIADeepStreamSDK
```
```
nvidia-smi
```
Potwierdź adres TCP/IP maszyny wirtualnej z systemem Ubuntu przy użyciu polecenia ifconfig i poszukaj adresu TCP/IP obok interfejsu eth0 .
Zainstaluj odtwarzacz VLC na stacji roboczej. W odtwarzaczu VLC kliknij pozycję Nośnik —> otwórz strumień sieciowy i wpisz adres w następującym formacie:

rtsp://ipaddress:8554/ds-test

gdzie ipaddress jest adresem TCP/IP maszyny wirtualnej.