Installa i driver della GPU

Linux

Segui queste istruzioni per installare i driver GPU su una VM in esecuzione.

Sistemi operativi supportati

Lo script di installazione di Linux è stato testato sui seguenti sistemi operativi:

• Debian 11 e 12
• Red Hat Enterprise Linux (RHEL) 8 e 9
• Rocky Linux 8 e 9
• Ubuntu 20, 22 e 24

Se utilizzi questo script su altri sistemi operativi, l'installazione potrebbe non riuscire. Questo script può installare il driver NVIDIA e il toolkit CUDA. Per installare i driver GPU e CUDA Toolkit, completa i seguenti passaggi:

1. Se hai la versione 2.38.0 o successive di Ops Agent che raccoglie le metriche della GPU sulla tua VM, devi arrestare l'agente prima di poter installare o eseguire l'upgrade dei driver della GPU utilizzando questo script di installazione.

   Dopo aver completato l'installazione o l'upgrade del driver GPU, devi riavviare la VM.

   Per arrestare Ops Agent, esegui questo comando:

   sudo systemctl stop google-cloud-ops-agent

2. Assicurati che Python 3 sia installato sul tuo sistema operativo.

3. Scarica lo script di installazione.

   curl -L https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz --output cuda_installer.pyz

4. Esegui lo script di installazione.

   sudo python3 cuda_installer.pyz install_driver

   L'esecuzione dello script richiede un po' di tempo. La VM verrà riavviata. Se la VM si riavvia, esegui di nuovo lo script per continuare l'installazione.

5. Verifica l'installazione. Consulta Verificare l'installazione del driver GPU.

6. Puoi anche utilizzare questo strumento per installare CUDA Toolkit. Per installare CUDA Toolkit, esegui questo comando:

   sudo python3 cuda_installer.pyz install_cuda

   L'esecuzione di questo script potrebbe richiedere almeno 30 minuti. La VM verrà riavviata. Se la VM viene riavviata, esegui di nuovo lo script per continuare l'installazione.

7. Verifica l'installazione del toolkit CUDA.

   python3 cuda_installer.pyz verify_cuda

Linux (script di avvio)

Segui queste istruzioni per installare i driver GPU durante l'avvio di una VM.

Sistemi operativi supportati

Lo script di installazione di Linux è stato testato sui seguenti sistemi operativi:

• Debian 11 e 12
• Red Hat Enterprise Linux (RHEL) 8 e 9
• Rocky Linux 8 e 9
• Ubuntu 20, 22 e 24

Se utilizzi questo script su altri sistemi operativi, l'installazione potrebbe non riuscire. Questo script può installare il driver NVIDIA e il toolkit CUDA.

Utilizza il seguente script di avvio per automatizzare l'installazione del driver e di CUDA Toolkit:

#!/bin/bash
if test -f /opt/google/cuda-installer
then
  exit
fi

mkdir -p /opt/google/cuda-installer
cd /opt/google/cuda-installer/ || exit

curl -fSsL -O https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz
python3 cuda_installer.pyz install_cuda

Windows

Questo script di installazione può essere utilizzato sulle VM su cui è abilitato l'avvio protetto.

• Per le VM Windows che utilizzano una serie di macchine G2, questo script installa solo il driver NVIDIA.
• Per gli altri tipi di macchine, lo script installa il driver NVIDIA e il toolkit CUDA.

Apri un terminale PowerShell come amministratore, quindi completa i seguenti passaggi:

1. Se utilizzi Windows Server 2016, imposta la versione di Transport Layer Security (TLS) su 1.2.

   [Net.ServicePointManager]::SecurityProtocol = 'Tls12'
   

2. Scarica lo script.

   Invoke-WebRequest https://github.com/GoogleCloudPlatform/compute-gpu-installation/raw/main/windows/install_gpu_driver.ps1 -OutFile C:\install_gpu_driver.ps1

3. Esegui lo script.

   C:\install_gpu_driver.ps1

   L'esecuzione dello script richiede un po' di tempo. Durante la procedura di installazione non vengono visualizzati prompt dei comandi. Una volta uscito dallo script, il driver viene installato.

   Questo script installa i driver nel seguente percorso predefinito sulla tua VM: C:\Program Files\NVIDIA Corporation\.

4. Verifica l'installazione. Consulta Verificare l'installazione del driver GPU.

Firma automatica

Sistemi operativi supportati:

Questo metodo di autofirma automatica è stato testato sui seguenti sistemi operativi:

• Debian 12
• Red Hat Enterprise Linux (RHEL) 8 e 9
• Rocky Linux 8 e 9
• Ubuntu 22 e 24

Procedura

Per creare un'immagine del sistema operativo con certificati autofirmati:

1. 1. In the Google Cloud console, activate Cloud Shell.

      Activate Cloud Shell

      At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Scarica lo strumento cuda_installer. Per scaricare l'ultima versione dello script, esegui questo comando:

   curl -L https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz --output cuda_installer.pyz
   

3. Crea un'immagine con Secure Boot abilitato eseguendo il seguente comando. La procedura di creazione dell'immagine può richiedere fino a 20 minuti.

   PROJECT=PROJECT_ID
   ZONE=ZONE
   BASE_IMAGE=BASE_IMAGE_NAME
   SECURE_BOOT_IMAGE=IMAGE_NAME
   
   python3 cuda_installer.pyz build_image \
     --project $PROJECT \
     --vm-zone $ZONE \
     --base-image $BASE_IMAGE $SECURE_BOOT_IMAGE
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del progetto in cui creare l'immagine
   • ZONE: la zona in cui creare una VM temporanea utilizzata. Ad esempio us-west4-a.
   • IMAGE_NAME: il nome dell'immagine che verrà creata.

   • BASE_IMAGE_NAME: seleziona una delle seguenti opzioni:

     • debian-12
     • rhel-8 o rhel-9
     • rocky-8 o rocky-9
     • ubuntu-22 o ubuntu-24

   Puoi anche aggiungere il flag --family NAME per aggiungere la nuova immagine a una famiglia di immagini.

   Per visualizzare tutte le opzioni di personalizzazione dell'immagine, esegui python3 cuda_installer.pyz build_image --help. Puoi anche consultare la documentazione relativa a cuda_installer su GitHub.

4. Verifica l'immagine. Per verificare che l'immagine abbia Secure Boot attivato e possa creare istanze GPU con i driver NVIDIA installati:

   1. Crea un'istanza VM di test per verificare che l'immagine sia configurata correttamente e che i driver GPU vengano caricati correttamente. L'esempio seguente crea un tipo di macchina N1 con un singolo acceleratore NVIDIA T4 collegato. Tuttavia, puoi utilizzare qualsiasi tipo di macchina GPU supportato a tua scelta.

      TEST_INSTANCE_NAME=TEST_INSTANCE_NAME
      ZONE=ZONE
      
      gcloud compute instances create $TEST_INSTANCE_NAME \
       --project=$PROJECT \
       --zone=$ZONE \
       --machine-type=n1-standard-4 \
       --accelerator=count=1,type=nvidia-tesla-t4 \
       --create-disk=auto-delete=yes,boot=yes,device-name=$TEST_INSTANCE_NAME,image=projects/$PROJECT/global/images/$SECURE_BOOT_IMAGE,mode=rw,size=100,type=pd-balanced \
       --shielded-secure-boot \
       --shielded-vtpm \
       --shielded-integrity-monitoring \
       --maintenance-policy=TERMINATE
      

      Sostituisci quanto segue:

      • TEST_INSTANCE_NAME: un nome per l'istanza VM di test
      • ZONE: una zona con GPU T4 o la GPU che preferisci. Per saperne di più, consulta Regioni e zone GPU.

   2. Verifica che l'avvio protetto sia abilitato eseguendo il comando mokutil --sb-state sulla VM di test utilizzando gcloud compute ssh.

      gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_INSTANCE_NAME --command "mokutil --sb-state"
      

   3. Verifica che il driver sia installato eseguendo il comando nvidia-smi sulla VM di test utilizzando gcloud compute ssh.

      gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_INSTANCE_NAME --command "nvidia-smi"
      

      Se hai installato CUDA Toolkit, puoi utilizzare lo strumento cuda_installer per verificare l'installazione nel seguente modo:

      gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_INSTANCE_NAME --command "python3 cuda_installer.pyz verify_cuda"
      

5. Eseguire la pulizia. Dopo aver verificato che l'immagine personalizzata funzioni, non è necessario conservare la VM di verifica. Per eliminare la VM, esegui questo comando:

   gcloud compute instances delete --zone=$ZONE --project=$PROJECT $TEST_INSTANCE_NAME
   

6. (Facoltativo) Per eliminare l'immagine disco che hai creato, esegui questo comando:

   gcloud compute images delete --project=$PROJECT $SECURE_BOOT_IMAGE
   

Autofirma (manuale)

Sistemi operativi supportati

Questo metodo di auto-firma manuale è stato testato sui seguenti sistemi operativi:

• Debian 12
• Red Hat Enterprise Linux (RHEL) 8 e 9
• Rocky Linux 8 e 9
• Ubuntu 22 e 24

Panoramica

La procedura di installazione, firma e creazione dell'immagine è la seguente:

1. Genera un certificato da utilizzare per firmare il driver.
2. Crea una VM per installare e firmare il driver GPU. Per creare la VM, puoi utilizzare il sistema operativo che preferisci. Quando crei la VM, devi disattivare Avvio protetto. Non devi collegare GPU alla VM.
3. Installa e firma il driver della GPU e, facoltativamente, CUDA Toolkit.
4. Crea un'immagine del disco basata sulla macchina con un driver autofirmato, aggiungendo il tuo certificato all'elenco dei certificati attendibili.
5. Utilizza l'immagine per creare VM GPU con l'avvio protetto abilitato.

Creazione di immagini

1. 1. In the Google Cloud console, activate Cloud Shell.

      Activate Cloud Shell

      At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Genera il tuo certificato utilizzando OpenSSL. Con OpenSSL, la firma e la verifica per l'avvio protetto vengono eseguite utilizzando i normali certificati X.509 con codifica Distinguished Encoding Rules (DER). Esegui il comando seguente per generare un nuovo certificato X.509 autofirmato e un file di chiave privata RSA.

   openssl req -new -x509 -newkey rsa:2048 -keyout private.key -outform DER -out public.der -noenc -days 36500 -subj "/CN=Graphics Drivers Secure Boot Signing"
   

3. Crea una VM per installare il driver autofirmato. Quando crei la VM, non devi collegare GPU o abilitare Avvio protetto. Puoi utilizzare un tipo di macchina E2 standard con almeno 40 GB di spazio disponibile, in modo che la procedura di installazione possa essere completata.

   INSTANCE_NAME=BUILD_INSTANCE_NAME
   DISK_NAME=IMAGE_NAME
   ZONE=ZONE
   PROJECT=PROJECT_ID
   OS_IMAGE=IMAGE_DETAILS
   
   # Create the build VM
   gcloud compute instances create $INSTANCE_NAME \
    --zone=$ZONE \
    --project=$PROJECT \
    --machine-type=e2-standard-4 \
    --create-disk=auto-delete=yes,boot=yes,name=$DISK_NAME,$OS_IMAGE,mode=rw,size=100,type=pd-balanced \
    --no-shielded-secure-boot
   

   Sostituisci quanto segue:

   • BUILD_INSTANCE_NAME: il nome dell'istanza VM utilizzata per creare l'immagine.
   • IMAGE_NAME: il nome dell'immagine del disco.
   • ZONE: la zona in cui creare la VM.
   • PROJECT_ID: l'ID del progetto che vuoi utilizzare per creare la nuova immagine disco.

   • IMAGE_DETAILS: la famiglia di immagini e il progetto per l'immagine sistema operativo di base selezionata:

     • Debian 12: "image-family=debian-12,image-project=debian-cloud"
     • RHEL 8: "image-family=rhel-8,image-project=rhel-cloud"
     • RHEL 9: "image-family=rhel-9,image-project=rhel-cloud"
     • Rocky Linux 8: "image-family=rocky-linux-8,image-project=rocky-linux-cloud"
     • Rocky Linux 9: "image-family=rocky-linux-9,image-project=rocky-linux-cloud"
     • Ubuntu 22: "image-family=ubuntu-2204-lts-amd64,image-project=ubuntu-os-cloud"
     • Ubuntu 24: "image-family=ubuntu-2404-lts-amd64,image-project=ubuntu-os-cloud"

4. Copia il file della chiave privata generato nella VM. Per firmare il file del driver, devi disporre della coppia di chiavi appena generata sulla VM.

   gcloud compute scp --zone $ZONE --project $PROJECT private.key $INSTANCE_NAME:~/private.key
   gcloud compute scp --zone $ZONE --project $PROJECT public.der $INSTANCE_NAME:~/public.der
   

5. Installa e firma il driver. L'installazione e la firma del driver e di CUDA Toolkit vengono gestite dallo script di installazione utilizzato anche per le installazioni che non utilizzano l'avvio protetto. Per installare e firmare il driver, completa i seguenti passaggi:

   1. Connettiti alla VM tramite SSH:

      gcloud compute ssh --zone $ZONE --project $PROJECT $INSTANCE_NAME
      

   2. Verifica che le chiavi privata e pubblica siano state copiate correttamente:

      ls private.key public.der
      

   3. Scarica lo script di installazione del driver:

      curl -L https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz --output cuda_installer.pyz
      

   4. Verifica che l'installazione del driver sia configurata con la firma. La macchina di compilazione si riavvia durante la configurazione. Dopo il riavvio della macchina di build, connettiti alla VM utilizzando SSH ed esegui di nuovo lo script per riprendere l'installazione.

      sudo python3 cuda_installer.pyz install_driver --secure-boot-pub-key=public.der --secure-boot-priv-key=private.key --ignore-no-gpu
      

      Se vuoi installare CUDA Toolkit contemporaneamente, puoi farlo con il seguente comando.

      sudo python3 cuda_installer.pyz install_cuda --ignore-no-gpu
      

      Potresti visualizzare alcuni messaggi di errore o avviso. Questi sono il risultato del mancato rilevamento della GPU e sono previsti. Il sistema si riavvierà al termine dell'installazione di CUDA Toolkit. Dopo aver ristabilito la connessione, puoi continuare con i passaggi successivi.

   5. Rimuovi i file del certificato, in quanto non sono più necessari sulla macchina temporanea. Per una maggiore sicurezza, utilizza shred anziché il comando rm. Le chiavi non devono essere presenti nell'immagine disco finale.

      shred -uz private.key public.der
      

   6. Arresta la VM in modo da poter utilizzare il relativo disco per creare la nuova immagine.

      sudo shutdown now
      

6. Prepara l'immagine disco di base. Per creare una nuova immagine disco che possa essere utilizzata per creare istanze con Secure Boot abilitato, devi configurare l'immagine in modo che consideri attendibile la chiave appena generata. La nuova immagine disco accetta ancora i certificati predefiniti, utilizzati dal sistema operativo. Per preparare l'immagine di base, completa i seguenti passaggi.

   1. Scarica i certificati predefiniti. Utilizza i seguenti comandi per scaricare i certificati MicWinProPCA2011_2011-10-19.crt e MicCorUEFCA2011_2011-06-27.crt:

      curl -L https://storage.googleapis.com/compute-gpu-installation-us/certificates/MicCorUEFCA2011_2011-06-27.crt --output MicCorUEFCA2011_2011-06-27.crt
      curl -L https://storage.googleapis.com/compute-gpu-installation-us/certificates/MicWinProPCA2011_2011-10-19.crt --output MicWinProPCA2011_2011-10-19.crt
      

   2. Verifica i certificati:

      cat <<EOF >>check.sha1
      46def63b5ce61cf8ba0de2e6639c1019d0ed14f3  MicCorUEFCA2011_2011-06-27.crt
      580a6f4cc4e4b669b9ebdc1b2b3e087b80d0678d  MicWinProPCA2011_2011-10-19.crt
      EOF
      
      sha1sum -c check.sha1
      

   3. Crea un'immagine basata sul disco della VM temporanea. Puoi aggiungere --family=IMAGE_FAMILY_NAME come opzione, in modo che l'immagine venga impostata come l'ultima immagine di una determinata famiglia di immagini. La creazione della nuova immagine potrebbe richiedere un paio di minuti.

      Esegui questo comando nella stessa directory in cui si trovano il file public.der e i certificati scaricati.

      SECURE_BOOT_IMAGE=IMAGE_NAME
      
      gcloud compute images create $SECURE_BOOT_IMAGE \
      --source-disk=$DISK_NAME \
      --source-disk-zone=$ZONE \
      --project=$PROJECT  \
      --signature-database-file=MicWinProPCA2011_2011-10-19.crt,MicCorUEFCA2011_2011-06-27.crt,public.der \
      --guest-os-features="UEFI_COMPATIBLE"
      

      Per verificare che la chiave pubblica del certificato sia allegata a questa nuova immagine, esegui il comando seguente:

      gcloud compute images describe --project=$PROJECT $SECURE_BOOT_IMAGE
      

7. Verifica la nuova immagine. Puoi creare una VM GPU utilizzando la nuova immagine del disco. Per questo passaggio, consigliamo un tipo di macchina N1 con un singolo acceleratore T4 che abbia Avvio protetto abilitato. Tuttavia, l'immagine supporta anche altri tipi di GPU e tipi di macchine.

   1. Crea una VM GPU di test:

      TEST_GPU_INSTANCE=TEST_GPU_INSTANCE_NAME
      ZONE=ZONE
      
      gcloud compute instances create $TEST_GPU_INSTANCE \
      --project=$PROJECT \
      --zone=$ZONE \
      --machine-type=n1-standard-4 \
      --accelerator=count=1,type=nvidia-tesla-t4 \
      --create-disk=auto-delete=yes,boot=yes,device-name=$TEST_GPU_INSTANCE,image=projects/$PROJECT/global/images/$SECURE_BOOT_IMAGE,mode=rw,size=100,type=pd-balanced \
      --shielded-secure-boot \
      --shielded-vtpm \
      --shielded-integrity-monitoring \
      --maintenance-policy=TERMINATE
      

      Sostituisci quanto segue:

      • TEST_GPU_INSTANCE_NAME: il nome dell'istanza VM con GPU
        che stai creando per testare la nuova immagine.
      • ZONE: la zona che contiene le GPU T4 o altre GPU a tua scelta. Per saperne di più, consulta Regioni e zone GPU.

   2. Verifica che l'avvio protetto sia abilitato eseguendo il comando mokutil --sb-state sulla VM di test utilizzando gcloud compute ssh.

      gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_GPU_INSTANCE --command "mokutil --sb-state"
      

   3. Verifica che il driver sia installato eseguendo il comando nvidia-smi sulla VM di test utilizzando gcloud compute ssh.

      gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_GPU_INSTANCE --command "nvidia-smi"
      

      Se hai installato CUDA Toolkit, puoi utilizzare lo strumento cuda_installer per verificare l'installazione nel seguente modo:

      gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_GPU_INSTANCE --command "python3 cuda_installer.pyz verify_cuda"
      

8. Eseguire la pulizia. Dopo aver verificato che la nuova immagine funzioni, non è necessario conservare la VM temporanea o la VM di verifica. L'immagine del disco che hai creato non dipende in alcun modo da questi file. Puoi eliminarli con il seguente comando:

   gcloud compute instances delete --zone=$ZONE --project=$PROJECT $INSTANCE_NAME
   gcloud compute instances delete --zone=$ZONE --project=$PROJECT $TEST_GPU_INSTANCE
   

   Ti sconsigliamo di archiviare il certificato di firma di Avvio protetto in uno stato non criptato sul disco. Se vuoi archiviare in modo sicuro le chiavi in modo che possano essere condivise con altri, puoi utilizzare Secret Manager per proteggere i tuoi dati.

   Quando non hai più bisogno dei file sul disco, è consigliabile rimuoverli in modo sicuro utilizzando lo strumento shred. Esegui questo comando:

   # Safely delete the key pair from your system
   shred -uz private.key public.der
   

Pre-signed (solo Ubuntu)

Queste istruzioni sono disponibili solo per le VM Linux con avvio protetto che eseguono i sistemi operativi Ubuntu 18.04, 20.04 e 22.04. È in corso l'implementazione del supporto per altri sistemi operativi Linux.

Per installare i driver GPU sulle VM Ubuntu che utilizzano l'avvio protetto, completa i seguenti passaggi:

1. Connettiti alla VM in cui vuoi installare il driver.

2. Aggiorna il repository.

    sudo apt-get update
   

3. Cerca il pacchetto del modulo del kernel NVIDIA più recente o la versione che ti interessa. Questo pacchetto contiene moduli del kernel NVIDIA firmati con la chiave Ubuntu. Se vuoi trovare una versione precedente, modifica il numero del parametro tail per ottenere una versione precedente. Ad esempio, specifica tail -n 2.

   Ubuntu PRO e LTS

   Per Ubuntu PRO e LTS, esegui il comando seguente:

   NVIDIA_DRIVER_VERSION=$(sudo apt-cache search 'linux-modules-nvidia-[0-9]+-gcp$' | awk '{print $1}' | sort | tail -n 1 | head -n 1 | awk -F"-" '{print $4}')
   

   Ubuntu PRO FIPS

   Per Ubuntu PRO FIPS, esegui i seguenti comandi:

   1. Attiva gli aggiornamenti FIPS di Ubuntu.

      sudo ua enable fips-updates
      

   2. Arresta e riavvia

      sudo shutdown -r now
      

   3. Scarica l'ultimo pacchetto.

      NVIDIA_DRIVER_VERSION=$(sudo apt-cache search 'linux-modules-nvidia-[0-9]+-gcp-fips$' | awk '{print $1}' | sort | tail -n 1 | head -n 1 | awk -F"-" '{print $4}')
      

   Puoi controllare la versione del driver selezionata eseguendo echo $NVIDIA_DRIVER_VERSION. L'output è una stringa di versione come 455.

4. Installa il pacchetto del modulo del kernel e il driver NVIDIA corrispondente.

    sudo apt install linux-modules-nvidia-${NVIDIA_DRIVER_VERSION}-gcp nvidia-driver-${NVIDIA_DRIVER_VERSION}
   

   Se il comando non è riuscito con package not found error, il driver NVIDIA più recente potrebbe non essere presente nel repository. Riprova il passaggio precedente e seleziona una versione precedente del driver modificando il numero di coda.

5. Verifica che il driver NVIDIA sia installato. Potresti dover riavviare la VM.

6. Se hai riavviato il sistema per verificare la versione NVIDIA. Dopo il riavvio, devi reimpostare la variabile NVIDIA_DRIVER_VERSION eseguendo di nuovo il comando che hai utilizzato nel passaggio 3.

7. Configura APT per utilizzare il repository di pacchetti NVIDIA.

   1. Per aiutare APT a scegliere la dipendenza corretta, blocca i repository nel seguente modo:

      sudo tee /etc/apt/preferences.d/cuda-repository-pin-600 > /dev/null <<EOL
      Package: nsight-compute
      Pin: origin *ubuntu.com*
      Pin-Priority: -1
      
      Package: nsight-systems
      Pin: origin *ubuntu.com*
      Pin-Priority: -1
      
      Package: nvidia-modprobe
      Pin: release l=NVIDIA CUDA
      Pin-Priority: 600
      
      Package: nvidia-settings
      Pin: release l=NVIDIA CUDA
      Pin-Priority: 600
      
      Package: *
      Pin: release l=NVIDIA CUDA
      Pin-Priority: 100
      EOL
      

   2. Installa software-properties-common. Questo è necessario se utilizzi immagini Ubuntu minimal.

      sudo apt install software-properties-common
      

   3. Imposta la versione di Ubuntu.

      Ubuntu 18.04

      Per Ubuntu 18.04, esegui questo comando:

      export UBUNTU_VERSION=ubuntu1804/x86_64

      Ubuntu 20.04

      Per Ubuntu 20.04, esegui questo comando:

      export UBUNTU_VERSION=ubuntu2004/x86_64

      Ubuntu 22.04

      Per Ubuntu 22.04, esegui questo comando:

      export UBUNTU_VERSION=ubuntu2204/x86_64

   4. Scarica il pacchetto cuda-keyring.

      wget https://developer.download.nvidia.com/compute/cuda/repos/$UBUNTU_VERSION/cuda-keyring_1.0-1_all.deb

   5. Installa il pacchetto cuda-keyring.

      sudo dpkg -i cuda-keyring_1.0-1_all.deb

   6. Aggiungi il repository NVIDIA.

      sudo add-apt-repository "deb https://developer.download.nvidia.com/compute/cuda/repos/$UBUNTU_VERSION/ /"

   Se richiesto, seleziona l'azione predefinita per mantenere la versione corrente.

8. Trova la versione del driver CUDA compatibile.

   Il seguente script determina la versione più recente del driver CUDA compatibile con il driver NVIDIA appena installato:

    CUDA_DRIVER_VERSION=$(apt-cache madison cuda-drivers | awk '{print $3}' | sort -r | while read line; do
       if dpkg --compare-versions $(dpkg-query -f='${Version}\n' -W nvidia-driver-${NVIDIA_DRIVER_VERSION}) ge $line ; then
          echo "$line"
          break
       fi
    done)
   

   Puoi controllare la versione del driver CUDA eseguendo echo $CUDA_DRIVER_VERSION. L'output è una stringa di versione come 455.32.00-1.

9. Installa i driver CUDA con la versione identificata nel passaggio precedente.

    sudo apt install cuda-drivers-${NVIDIA_DRIVER_VERSION}=${CUDA_DRIVER_VERSION} cuda-drivers=${CUDA_DRIVER_VERSION}
   

10. (Facoltativo) Trattieni dkms pacchi.

    Dopo aver attivato l'avvio protetto, tutti i moduli del kernel devono essere firmati per essere caricati. I moduli del kernel creati da dkms non funzionano sulla VM perché non sono firmati correttamente per impostazione predefinita. Questo passaggio è facoltativo, ma può aiutarti a evitare di installare accidentalmente altri pacchetti dkms in futuro.

    Per bloccare i pacchetti dkms, esegui questo comando:

     sudo apt-get remove dkms && sudo apt-mark hold dkms
    

11. Installa CUDA Toolkit e il runtime.

    Scegli la versione di CUDA adatta. Lo script seguente determina l'ultima versione di CUDA compatibile con il driver CUDA appena installato:

     CUDA_VERSION=$(apt-cache showpkg cuda-drivers | grep -o 'cuda-runtime-[0-9][0-9]-[0-9],cuda-drivers [0-9\\.]*' | while read line; do
        if dpkg --compare-versions ${CUDA_DRIVER_VERSION} ge $(echo $line | grep -Eo '[[:digit:]]+\.[[:digit:]]+') ; then
           echo $(echo $line | grep -Eo '[[:digit:]]+-[[:digit:]]')
           break
        fi
     done)
    

    Puoi controllare la versione di CUDA eseguendo echo $CUDA_VERSION. L'output è una stringa di versione come 11-1.

12. Installa il pacchetto CUDA.

     sudo apt install cuda-${CUDA_VERSION}
    

13. Verifica l'installazione di CUDA.

     sudo nvidia-smi
     /usr/local/cuda/bin/nvcc --version
    

    Il primo comando stampa le informazioni sulla GPU. Il secondo comando <x0A>stampa la versione del compilatore CUDA installata.

Linux

Connettiti all'istanza Linux e utilizza il comando nvidia-smi per verificare che il driver sia in esecuzione correttamente.

sudo nvidia-smi

L'output è simile al seguente:

Tue Mar 21 19:50:15 2023
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 550.90.07              Driver Version: 550.90.07      CUDA Version: 12.4     |
|-----------------------------------------+------------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  Tesla T4                       On  |   00000000:00:04.0 Off |                    0 |
| N/A   50C    P8             16W /   70W |       1MiB /  15360MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+

+-----------------------------------------------------------------------------------------+
| Processes:                                                                              |
|  GPU   GI   CI        PID   Type   Process name                              GPU Memory |
|        ID   ID                                                               Usage      |
|=========================================================================================|
|  No running processes found                                                             |
+-----------------------------------------------------------------------------------------+

Se questo comando non va a buon fine, controlla quanto segue:

• Controlla se le GPU sono collegate alla VM. Per verificare la presenza di dispositivi NVIDIA PCI, esegui questo comando:

  sudo lspci | grep -i "nvidia"

• Verifica che la versione del kernel del driver e la versione del kernel della VM siano uguali.

  • Per controllare la versione del kernel della VM, esegui questo comando:

    uname -r

  • Per controllare la versione del kernel del driver, esegui questo comando:

    sudo apt-cache show linux-modules-nvidia-NVIDIA_DRIVER_VERSION-gcp

    Se le versioni non corrispondono, riavvia la VM con la nuova versione del kernel.

Windows Server

Connettiti all'istanza di Windows Server e apri un terminale PowerShell, poi esegui il seguente comando per verificare che il driver sia in esecuzione correttamente.

nvidia-smi

L'output è simile al seguente:

+---------------------------------------------------------------------------------------+
| NVIDIA-SMI 538.67                 Driver Version: 538.67       CUDA Version: 12.2     |
|-----------------------------------------+----------------------+----------------------+
| GPU  Name                     TCC/WDDM  | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |
|                                         |                      |               MIG M. |
|=========================================+======================+======================|
|   0  NVIDIA L4                    WDDM  | 00000000:00:03.0 Off |                    0 |
| N/A   66C    P8              17W /  72W |    128MiB / 23034MiB |      0%      Default |
|                                         |                      |                  N/A |
+-----------------------------------------+----------------------+----------------------+

+---------------------------------------------------------------------------------------+
| Processes:                                                                            |
|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |
|        ID   ID                                                             Usage      |
|=======================================================================================|
|    0   N/A  N/A      4888    C+G   ...CBS_cw5n1h2txyewy\TextInputHost.exe    N/A      |
|    0   N/A  N/A      5180    C+G   ....Search_cw5n1h2txyewy\SearchApp.exe    N/A      |
+---------------------------------------------------------------------------------------+