Installa i driver della GPU

Dopo aver creato un'istanza di macchina virtuale (VM) con una o più GPU, il sistema richiede i driver di dispositivo NVIDIA per consentire alle applicazioni di accedere al dispositivo. Assicurati che le istanze di macchine virtuali (VM) dispongano di spazio libero su disco sufficiente. Quando crei la nuova VM, devi scegliere almeno 40 GB per il disco di avvio.

Per installare i driver, hai due opzioni tra cui scegliere:

  • Se hai bisogno di GPU per grafiche 3D con accelerazione hardware, come il desktop remoto o i giochi, consulta Installa i driver per le workstation virtuali (vWS) NVIDIA RTX.

  • Per altri workload, segui le istruzioni riportate in questo documento per installare il driver NVIDIA.

Versioni del driver NVIDIA, del toolkit CUDA e del runtime CUDA

Nel tuo ambiente potrebbero essere necessari diversi componenti con controllo delle versioni di driver e runtime. Sono inclusi i seguenti componenti:

  • Driver NVIDIA
  • Toolkit CUDA
  • Runtime CUDA

Quando installi questi componenti, hai la possibilità di configurare il tuo ambiente in base alle tue esigenze. Ad esempio, se hai una versione precedente di TensorFlow che funziona meglio con una versione precedente del toolkit CUDA, ma la GPU che vuoi utilizzare richiede una versione successiva del driver NVIDIA, puoi installare una versione precedente di un toolkit CUDA insieme a una versione successiva del driver NVIDIA.

Tuttavia, devi assicurarti che le versioni del driver NVIDIA e del toolkit CUDA siano compatibili. Per la compatibilità del toolkit CUDA e del driver NVIDIA, consulta la documentazione di NVIDIA sulla compatibilità CUDA.

Informazioni sui rami dei driver NVIDIA

NVIDIA fornisce i seguenti tre rami di driver:

  • Long-Term Support Branch (LTSB): questo ramo dà la priorità alla stabilità e riduce al minimo la manutenzione, con un ciclo di vita del supporto esteso di tre anni. L'ultima LTSB testata e verificata da Google è R580, la cui data di fine del supporto è agosto 2028.
  • Production Branch (PB): questo ramo fornisce miglioramenti delle prestazioni e supporto per l'hardware più recente. Supporta completamente i carichi di lavoro di produzione, ma ha un ciclo di vita di assistenza più breve, fino a un anno. L'ultima PB testata e verificata da Google è R570, che non sarà più supportata a partire da febbraio 2026.
  • New Feature Branch (NFB): questo ramo è destinato ai primi utenti per testare nuove funzionalità e non è consigliato per gli ambienti di produzione.

Per i carichi di lavoro di produzione, utilizza il ramo di produzione o il ramo di supporto a lungo termine. Per ulteriori dettagli sui rami NVIDIA, consulta la documentazione NVIDIA.

Utilizza la tabella in questa sezione per determinare il ramo del driver NVIDIA più adatto al tuo tipo di macchina GPU.

Nella tabella seguente, EOS indica la fine del supporto. N/A indica che il sistema operativo specificato non può essere eseguito sul tipo di macchina.

Tipo di macchina Modello di GPU Rami supportati Branch consigliato
(data di fine del supporto)
Driver minimo per il ramo consigliato
A4X NVIDIA Blackwell GB200 Superchip R570 o versioni successive R580 (agosto 2028)
  • Linux: 580.82.07 o versioni successive
  • Windows: N/A
A4 NVIDIA Blackwell B200 R570 o versioni successive R580 (agosto 2028)
  • Linux: 580.82.07 o versioni successive
  • Windows: N/A
A3 Ultra NVIDIA H200 R570 o versioni successive R580 (agosto 2028)
  • Linux: 580.82.07 o versioni successive
  • Windows: N/A
A3 Mega, High, Edge NVIDIA H100 R535 o versioni successive R535 (giugno 2026)
  • Linux: 535.230.02 o versioni successive
  • Windows: N/A
G2 NVIDIA L4 R535 o versioni successive R535 (giugno 2026)
  • Linux: 535.230.02 o versioni successive
  • Windows: 538.67 o versioni successive
A2 Standard, A2 Ultra NVIDIA A100 R535 o versioni successive R535 (giugno 2026)
  • Linux: 535.230.02 o versioni successive
  • Windows: 538.67 o versioni successive
N1 NVIDIA T4 R535 o versioni successive R535 (giugno 2026)
  • Linux: 535.230.02 o versioni successive
  • Windows: 538.67 o versioni successive
N1 NVIDIA V100, P100, P4 Da R35 a R5801 R535 (giugno 2026)
  • Linux: 535.230.02 o versioni successive
  • Windows: 538.67 o versioni successive

1NVIDIA ha annunciato che R580 è l'ultimo ramo del driver a supportare l'architettura Pascal (P4 e P100) e Volta (V100).

Installa i driver della GPU sulle VM tramite le guide del toolkit CUDA

Un modo per installare il driver NVIDIA sulla maggior parte delle VM è installare il toolkit CUDA.

Per installare il toolkit CUDA, completa i seguenti passaggi:

  1. Seleziona una versione del toolkit CUDA che supporti la versione del driver di cui hai bisogno.

    Tipo di macchina Modello di GPU Toolkit CUDA consigliato
    A4X NVIDIA Blackwell GB200 Superchip CUDA 12.8.1 o versioni successive
    A4 NVIDIA Blackwell B200 CUDA 12.8.1 o versioni successive
    A3 Ultra NVIDIA H200 CUDA 12.4 o versioni successive
    G2 NVIDIA L4 CUDA 12.2.2 o versioni successive
    A3 Mega, High, Edge NVIDIA H100 CUDA 12.2.2 o versioni successive
    A2 Standard, A2 Ultra NVIDIA A100 CUDA 12.2.2 o versioni successive
    N1 NVIDIA T4 CUDA 12.2.2 o versioni successive
    N1 NVIDIA V100, P100, P4 CUDA 12.2.2 a CUDA 12 (versione finale)1

    1CUDA Toolkit 12 è l'ultimo a supportare l'architettura Pascal (P4 e P100) e Volta (V100). NVIDIA ha annunciato che la compilazione offline e il supporto delle librerie per queste architetture vengono rimossi a partire dalla release della versione principale di CUDA Toolkit 13.0. Per maggiori informazioni, consulta le note di rilascio del driver NVIDIA 13.0.

  2. Connettiti alla VM dove vuoi installare il driver.

  3. Nella VM, scarica e installa il toolkit CUDA. Per trovare il pacchetto del toolkit CUDA e le istruzioni di installazione, consulta Archivio del toolkit CUDA nella documentazione di NVIDIA.

Installa i driver della GPU sulle VM tramite lo script di installazione

Puoi utilizzare i seguenti script per automatizzare la procedura di installazione. Per esaminare questi script, consulta il repository GitHub.

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 12
  • Red Hat Enterprise Linux (RHEL) 8 e 9
  • Rocky Linux 8 e 9
  • Ubuntu 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 della GPU e il Toolkit CUDA, 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.

    Per installare 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 --installation-mode=INSTALLATION_MODE --installation-branch=BRANCH

    • INSTALLATION_MODE: il metodo di installazione. Utilizza uno dei seguenti valori:
      • repo: (impostazione predefinita) installa il driver dal repository del pacchetto NVIDIA ufficiale.
      • binary: installa il driver utilizzando il pacchetto di installazione binario.
    • BRANCH: il ramo del driver che vuoi installare. Utilizza uno dei seguenti valori:
      • prod: (predefinito) il branch di produzione. Questo ramo è qualificato per l'utilizzo in ambienti di produzione per GPU aziendali e di data center.
      • nfb: il nuovo ramo della funzionalità. Questo ramo include gli ultimi aggiornamenti per i primi utenti. Questo ramo non è consigliato per gli ambienti di produzione.
      • lts: il ramo di assistenza a lungo termine. Questo ramo viene mantenuto per un periodo di tempo più lungo rispetto a un ramo di produzione normale.

    L'esecuzione dello script richiede qualche istante. La VM verrà riavviata. Quando la VM si riavvia, esegui di nuovo lo script per continuare l'installazione.

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

  6. Puoi anche utilizzare questo strumento per installare il toolkit CUDA. Per installare il toolkit CUDA, esegui il seguente comando:

    sudo python3 cuda_installer.pyz install_cuda --installation-mode=INSTALLATION_MODE --installation-branch=BRANCH

    Assicurati di utilizzare gli stessi valori per INSTALLATION_MODE e BRANCH utilizzati durante l'installazione del driver.

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

  7. Verifica l'installazione del toolkit CUDA.

    python3 cuda_installer.pyz verify_cuda
  8. Al termine dell'installazione, devi riavviare la VM.

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 12
  • Red Hat Enterprise Linux (RHEL) 8 e 9
  • Rocky Linux 8 e 9
  • Ubuntu 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 del toolkit CUDA:

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

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

if test -f cuda_installation
then
  exit
fi

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

Puoi aggiungere i flag --installation-mode INSTALLATION_MODE e --installation-branch BRANCH al comando di installazione per indicare la modalità di installazione e il ramo del driver che vuoi installare.

  • INSTALLATION_MODE: il metodo di installazione. Utilizza uno dei seguenti valori:
    • repo: (impostazione predefinita) installa il driver dal repository del pacchetto NVIDIA ufficiale.
    • binary: installa il driver utilizzando il pacchetto di installazione binario.
  • BRANCH: il ramo del driver che vuoi installare. Utilizza uno dei seguenti valori:
    • prod: (predefinito) il branch di produzione. Questo ramo è qualificato per l'utilizzo in ambienti di produzione per GPU aziendali e di data center.
    • nfb: il nuovo ramo della funzionalità. Questo ramo include gli ultimi aggiornamenti per i primi utenti. Questo ramo non è consigliato per gli ambienti di produzione.
    • lts: il ramo di assistenza a lungo termine. Questo ramo viene mantenuto per un periodo di tempo più lungo rispetto a un ramo di produzione normale.

Windows

Questo script di installazione può essere utilizzato nelle VM in 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 macchina, 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 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 qualche istante. Durante la procedura di installazione non vengono visualizzati prompt dei comandi. Alla chiusura dello script, il driver viene installato.

    Questo script installa i driver nella seguente posizione predefinita sulla VM: C:\Program Files\NVIDIA Corporation\\.

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

Installa i driver della GPU (VM con avvio protetto)

Queste istruzioni riguardano l'installazione dei driver GPU sulle VM Linux che utilizzano l'avvio protetto.

Supporto GPU

Le procedure descritte in questa sezione supportano tutti i modelli di GPU disponibili su Compute Engine.

Non puoi utilizzare queste procedure per installare i driver sulle istanze di avvio protetto a cui sono collegate versioni di workstation virtuali (vWS) NVIDIA RTX delle nostre GPU.

Se utilizzi una VM Windows o Linux che non utilizza l'avvio protetto, consulta una delle seguenti istruzioni:

L'installazione del driver su una VM con l'avvio protetto è diversa per le VM Linux, poiché queste VM richiedono che tutti i moduli kernel abbiano una firma di certificato attendibile.

Installazione

Puoi utilizzare una delle seguenti opzioni per installare i driver con certificati attendibili:

  • Crea un certificato attendibile per i tuoi driver. Per questa opzione, scegli una delle seguenti:
    • Metodo automatizzato: utilizza uno strumento di creazione di immagini per creare immagini di avvio con certificati attendibili per i driver installati.
    • Metodo manuale: genera il tuo certificato e utilizzalo per firmare i moduli del kernel del driver GPU
  • Utilizza driver pre-firmati con un certificato attendibile esistente. Questo metodo supporta solo Ubuntu.

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, completa i seguenti passaggi:

    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 per l'esecuzione dell'immagine python3 cuda_installer.pyz build_image --help. Puoi anche consultare la documentazione di cuda_installer su GitHub.

    4. Verifica l'immagine. Segui questi passaggi per verificare che l'immagine abbia l'avvio protetto abilitato 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 di 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 il toolkit CUDA, 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 mantenere 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
      
    7. Autofirma (manuale)

      Sistemi operativi supportati

      Questo metodo di autofirma 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 il tuo certificato da utilizzare per firmare il driver.
      2. Crea una VM per installare e firmare il driver della GPU. Per creare la VM, puoi utilizzare il sistema operativo che preferisci. Quando crei la VM, devi disattivare Secure Boot. Non è necessario collegare GPU alla VM.
      3. Installa e firma il driver GPU e, facoltativamente, CUDA Toolkit.
      4. Crea un'immagine 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 Avvio protetto abilitato.

      Creazione di immagini

        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 dell'avvio protetto vengono eseguite utilizzando i normali certificati X.509 con codifica Distinguished Encoding Rules (DER). Esegui questo comando 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 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 del toolkit CUDA 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 il toolkit CUDA 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 del disco che può 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 del 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 la più recente in 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"
            

            Puoi verificare che la chiave pubblica del certificato sia allegata a questa nuova immagine eseguendo 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 con 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 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 il toolkit CUDA, 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 loro. 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
          
        9. Pre-signed (solo Ubuntu)

          Queste istruzioni sono disponibili solo per le VM Linux con l'avvio protetto che sono in esecuzione su sistemi operativi Ubuntu 18.04, 20.04 e 22.04. È in corso lo sviluppo 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 dove vuoi installare il driver.

          2. Aggiorna il repository.

             sudo apt-get update
            
          3. Cerca il pacchetto del modulo kernel NVIDIA più recente o la versione che preferisci. Questo pacchetto contiene i moduli kernel NVIDIA firmati dalla chiave Ubuntu. Se vuoi trovare una versione precedente, modifica il numero del parametro di coda per ottenere una versione precedente. Ad esempio, specifica tail -n 2.

            Ubuntu PRO e LTS

            Per Ubuntu PRO e LTS, esegui il seguente comando:

            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 di Ubuntu FIPS.

              sudo ua enable fips-updates
              
            2. Arresta e riavvia

              sudo shutdown -r now
              
            3. Scarica il pacchetto più recente.

              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 scelta eseguendo echo $NVIDIA_DRIVER_VERSION. L'output è una stringa di versione come 455.

          4. Installa il pacchetto del modulo 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 di NVIDIA. Dopo il riavvio, devi reimpostare la variabile NVIDIA_DRIVER_VERSION eseguendo di nuovo il comando utilizzato nel passaggio 3.

          7. Configura APT in modo che utilizzi il repository dei pacchetti NVIDIA.

            1. Per aiutare APT a scegliere la dipendenza corretta, fissa i repository come segue:

              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 il seguente comando:

              export UBUNTU_VERSION=ubuntu1804/x86_64

              Ubuntu 20.04

              Per Ubuntu 20.04, esegui il seguente comando:

              export UBUNTU_VERSION=ubuntu2004/x86_64

              Ubuntu 22.04

              Per Ubuntu 22.04, esegui il seguente 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.

            Lo script seguente determina la versione più recente del driver CUDA compatibile con il driver NVIDIA che abbiamo 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) Mantieni in sospeso i pacchetti dkms.

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

            Per mantenere in sospeso i pacchetti dkms, esegui il seguente comando:

             sudo apt-get remove dkms && sudo apt-mark hold dkms
            
          11. Installa il toolkit e il runtime CUDA.

            Scegli la versione CUDA adatta. Lo script seguente determina la versione CUDA più recente compatibile con il driver CUDA che abbiamo 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 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 stampa la versione del compilatore CUDA installato.

Verifica l'installazione del driver della GPU

Dopo aver completato i passaggi di installazione del driver, verifica che il driver sia stato installato e inizializzato correttamente.

Linux

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

sudo nvidia-smi

L'output è simile al seguente:

  +-----------------------------------------------------------------------------------------+
  | NVIDIA-SMI 580.82.07              Driver Version: 580.82.07      CUDA Version: 13.0     |
  +-----------------------------------------+------------------------+----------------------+
  | 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   53C    P8             17W /   70W |       0MiB /  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, verifica se le GPU sono collegate alla VM. Per verificare la presenza di dispositivi PCI NVIDIA, esegui il seguente comando:

sudo lspci | grep -i "nvidia"

Windows Server

Connettiti all'istanza Windows Server e apri un terminale PowerShell, quindi esegui il seguente comando per verificare che il driver funzioni 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      |
+---------------------------------------------------------------------------------------+

Passaggi successivi