Dołączanie procesora GPU do maszyny wirtualnej z systemem Ubuntu Linux na platformie Azure lokalnie

2025-07-07

Dotyczy: Azure Local 2311.2 i nowsze

Uwaga

Zalecanym sposobem tworzenia maszyn wirtualnych na platformie Azure lokalnie i zarządzania nimi jest użycie płaszczyzny sterowania usługi Azure Arc . Jednak ponieważ funkcje opisane w tym artykule nie są jeszcze udostępniane przez usługę Azure Arc, możesz użyć Centrum administracyjnego systemu Windows lub programu PowerShell zgodnie z opisem w tym artykule. Maszyny wirtualne utworzone w ten sposób nie są włączone przez usługę Azure Arc, mają ograniczoną możliwość zarządzania z płaszczyzny sterowania usługi Azure Arc i mniej korzyści użycia hybrydowego platformy Azure, w tym użycie usługi Azure Update Manager bez dodatkowych kosztów.
Aby uzyskać więcej informacji, zobacz Porównanie możliwości zarządzania maszynami wirtualnymi na platformie Azure — lokalne i obsługiwane operacje dla lokalnych maszyn wirtualnych platformy Azure.

Ten temat zawiera szczegółowe instrukcje dotyczące instalowania i konfigurowania jednostki przetwarzania grafiki NVIDIA (GPU) na platformie Azure przy użyciu technologii dyskretnego przypisania urządzenia (DDA) dla maszyny wirtualnej z systemem Ubuntu. Musisz mieć już wdrożone lokalne wystąpienie usługi Azure i zainstalowane maszyny wirtualne.

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

Zainstaluj procesory GPU FIRMY NVIDIA fizycznie na odpowiedniej maszynie, postępując zgodnie z instrukcjami producenta OEM i zaleceniami systemu BIOS.
Włącz każdą maszynę.
Zaloguj się przy użyciu konta z uprawnieniami administracyjnymi do maszyny 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, który został wyróżniony na zrzucie ekranu. Kliknij prawym przyciskiem myszy pozycję Wartość i skopiuj/zapisz ją.
Otwórz program Windows PowerShell z podwyższonym poziomem uprawnień i wykonaj Dismount-VMHostAssignableDevice polecenie cmdlet, aby odinstalować urządzenie GPU dla DDA na maszynę wirtualną. 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ę klasyczną systemu Ubuntu w wersji 18.04.02 ISO.
Otwórz Hyper-V Manager na maszynie w lokalnym wystąpieniu platformy Azure z zainstalowanym procesorem graficznym.

Uwaga

DDA nie obsługuje trybu failover. Jest to ograniczenie maszyny wirtualnej w przypadku DDA. W związku z tym zalecamy użycie Menedżera funkcji Hyper-V do wdrożenia maszyny wirtualnej na maszynie zamiast Menedżera klastra trybu failover. Użycie Failover Cluster Manager (Menedżer klastra trybu failover) z DDA kończy się niepowodzeniem, wyświetlając komunikat o błędzie, ż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żerzeHyper-V , aby utworzyć maszynę wirtualną z systemem Ubuntu Generation 1 z 2 GB pamięci i dołączoną do niej kartą sieciową.

W programie PowerShell przypisz odłączone urządzenie GPU do maszyny wirtualnej za pomocą poleceń cmdlets, zastępując wartość LocationPath wartością dla swojego 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

Oto dane wyjściowe z pomyślnego przypisania procesora GPU do maszyny wirtualnej:

Skonfiguruj inne wartości zgodnie z dokumentacją 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 być wystarczająca 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 połącz się 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żeraHyper-V , aby zamknąć maszynę wirtualną i skonfigurować akcję automatycznego zatrzymywania maszyny wirtualnej w celu zamknięcia systemu operacyjnego gościa, jak na 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 .
Użyj klienta SSH, takiego jak OpenSSH (ssh.exe zainstalowany domyślnie z systemem Windows 10) lub Putty , aby nawiązać połączenie z maszyną wirtualną z systemem Ubuntu w celu dalszej konfiguracji.
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 postępuj dalej. Przed kontynuowaniem upewnij się, że przed kontynuowaniem wykonano powyższe kroki.
Na maszynie wirtualnej wyszukaj i otwórz pozycję Oprogramowanie i aktualizacje. Przejdź do pozycji Dodatkowe sterowniki, a następnie wybierz najnowsze sterowniki procesora GPU FIRMY NVIDIA wymienione 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 połącz się 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 zrzutu ekranu:

Używając klienta SSH, skonfiguruj repozytorium i zainstaluj silnik 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 NVIDIA-Deepstream-Azure-IoT-Edge-on-a-NVIDIA-Jetson-Nano GitHub, co wyjaśnia konieczność zainstalowania platformy Docker zamiast narzędzia Moby. Po przejrzeniu przejdź do następnych 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 sprawdź pomyślną instalację platformy NVIDIA Docker:
```
sudo docker run --runtime=nvidia --rm nvidia/cuda:9.0-base nvidia-smi
```
Oto dane wyjściowe pomyślnej instalacji:

Postępuj zgodnie z instrukcjami w tym miejscu, 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 usługi IoT Edge w witrynie Azure Portal, postępując zgodnie z poniższymi wskazówkami tutaj. Następnie skopiuj parametry połączenia urządzenia dla nowo utworzonej usługi IoT Edge.
Za pomocą 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 w pliku i odkomentuj sekcję "Ręczna konfiguracja aprowizacji". Zaktualizuj wartość device_connection_string przy użyciu ciągu połączenia z twojego urządzenia IoT Edge. Upewnij się, że wszystkie inne sekcje konfiguracji zostały zakomentowane. Upewnij się, że wiersz konfiguracji: nie ma poprzedzających odstępów i że zagnieżdżone elementy są wcięte przez dwie spacje.

Aby wkleić zawartość schowka do Nano, użyj shift + prawy przycisk myszy lub naciśnij shift+insert. Zapisz i zamknij plik (Ctrl + X, Y, Enter).
Za pomocą klienta SSH uruchom ponownie demona usługi IoT Edge:
```
sudo systemctl restart iotedge
```
Sprawdź instalację i sprawdź stan demona usługi IoT Edge:
```
systemctl status iotedge

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

Za pomocą 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 z materiałami demonstracyjnymi, 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
```
Rozpakuj pliki wideo:
```
tar -xzvf cars-streams.tar.gz
```
Zawartość katalogu /var/deepstream/custom_streams powinna być podobna do 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 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

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

Kliknij moduł "NVIDIADeepStreamSDK" i wybierz pozycję "Opcje tworzenia kontenera". Konfiguracja domyślna jest wyświetlana tutaj:

Zastąp konfigurację powyżej 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/"
}

Wybierz pozycję Przejrzyj i utwórz, a następnie na następnej stronie kliknij pozycję Utwórz. W portalu Azure powinny być widoczne trzy moduły dla urządzenia IoT Edge.
Nawiąż połączenie 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 trwa kilka minut. Możesz zweryfikować pobieranie przy użyciu polecenia journalctl -u iotedge --no-pager --no-full , aby przejrzeć dzienniki demona iotedge.
Upewnij się, że kontener NvdiaDeepStreem działa. Dane wyjściowe polecenia na 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ę Media — > 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.