Instalar os drivers da GPU

Linux

Use estas instruções para instalar drivers de GPU em uma VM em execução.

Sistemas operacionais compatíveis

O script de instalação do Linux foi testado nos seguintes sistemas operacionais:

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

Se você usar esse script em outros sistemas operacionais, a instalação falhará. Esse script pode instalar drivers da NVIDIA e também o Kit de ferramentas do CUDA. Para instalar os drivers de GPU e o kit de ferramentas CUDA, conclua as etapas a seguir:

1. Se você tiver a versão 2.38.0 ou posterior do Agente de operações que coleta métricas da GPU na VM, interrompa o agente antes de instalar ou fazer upgrade dos drivers de GPU. usando este script de instalação.

   Depois de concluir a instalação ou o upgrade do driver da GPU, reinicie a VM.

   Para encerrar o agente de operações, execute o seguinte comando:

   sudo systemctl stop google-cloud-ops-agent

2. Verifique se o Python 3 está instalado no seu sistema operacional.

3. Faça o download do script de instalação.

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

4. Execute o script de instalação.

   sudo python3 cuda_installer.pyz install_driver

   O script leva algum tempo para ser executado. A VM será reiniciada. Se a VM for reiniciada, execute o script novamente para continuar a instalação.

5. Verifique a instalação. Consulte Verificar a instalação do driver da GPU.

6. Também é possível usar essa ferramenta para instalar o guia de ferramentas CUDA. Para instalar o kit de ferramentas CUDA, execute o seguinte comando:

   sudo python3 cuda_installer.pyz install_cuda

   Este script pode levar pelo menos 30 minutos para ser executado. A VM será reiniciada. Se a VM for reiniciada, execute o script novamente para continuar a instalação.

7. Verificar a instalação do kit de ferramentas CUDA.

   python3 cuda_installer.pyz verify_cuda

Linux (script de inicialização)

Use estas instruções para instalar drivers de GPU durante a inicialização de uma VM.

Sistemas operacionais compatíveis

O script de instalação do Linux foi testado nos seguintes sistemas operacionais:

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

Se você usar esse script em outros sistemas operacionais, a instalação falhará. Esse script pode instalar drivers da NVIDIA e também o Kit de ferramentas do CUDA.

Use o seguinte script de inicialização. para automatizar o driver e a instalação do kit de ferramentas do 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

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

Windows

Esse script de instalação pode ser usado em VMs com inicialização segura ativada.

• Para VMs do Windows que usam uma série de máquinas G2, esse script instala apenas o driver da NVIDIA.
• Para outros tipos de máquina, o script instala o driver da NVIDIA e o kit de ferramentas CUDA.

Abra um terminal do PowerShell como administrador e conclua as seguintes etapas:

1. Se você estiver usando o Windows Server 2016, defina a versão do Transport Layer Security (TLS) como 1.2.

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

2. Faça o download do script.

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

3. Execute o script.

   C:\install_gpu_driver.ps1

   O script leva algum tempo para ser executado. Nenhum prompt de comando é fornecido durante o processo de instalação. Depois que o script é encerrado, o driver é instalado.

   Esse script instala os drivers no seguinte local padrão na VM: C:\Program Files\NVIDIA Corporation\.

4. Verifique a instalação. Consulte Verificar a instalação do driver da GPU.

Autoassinatura (automatizada)

Sistemas operacionais compatíveis:

Esse método automatizado de autoassinatura foi testado nos seguintes sistemas operacionais:

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

Procedimento

Para criar uma imagem do SO com certificados autoassinados, siga estas etapas:

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. Faça o download da ferramenta cuda_installer. Para fazer o download da versão mais recente do script, execute o seguinte comando:

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

3. Crie uma imagem com a inicialização segura ativada executando o seguinte comando: O processo de criação da imagem pode levar até 20 minutos.

   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
   

   Substitua:

   • PROJECT_ID: ID do projeto em que a imagem será criada
   • ZONE: zona em que uma VM temporária será criada. Por exemplo, us-west4-a.
   • IMAGE_NAME: nome da imagem que será criada.

   • BASE_IMAGE_NAME: selecione uma das seguintes opções:

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

   Você também pode adicionar a flag --family NAME para adicionar a nova imagem a uma família de imagens.

   Para conferir todas as opções de personalização da imagem, execute python3 cuda_installer.pyz build_image --help. Você também pode revisar a documentação do cuda_installer no GitHub (em inglês).

4. Verifique a imagem. Siga estas etapas para verificar se a imagem tem a inicialização segura ativada e pode criar instâncias de GPU com drivers NVIDIA instalados.

   1. Crie uma instância de VM de teste para verificar se a imagem está configurada corretamente e se os drivers de GPU são carregados. O exemplo a seguir cria um tipo de máquina N1 com um único acelerador NVIDIA T4 anexado. No entanto, é possível usar qualquer tipo de máquina com GPU compatível.

      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
      

      Substitua:

      • TEST_INSTANCE_NAME: um nome para a instância de VM de teste
      • ZONE: uma zona com GPUs T4 ou a GPU de sua escolha. Para mais informações, consulte Regiões e zonas de GPU.

   2. Verifique se a Inicialização segura está ativada executando o comando mokutil --sb-state na VM de teste usando gcloud compute ssh.

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

   3. Verifique se o driver está instalado executando o comando nvidia-smi na VM de teste usando gcloud compute ssh.

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

      Se você tiver instalado o CUDA Toolkit, use a ferramenta cuda_installer para verificar a instalação da seguinte maneira:

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

5. Fazer a limpeza. Depois de verificar se a imagem personalizada funciona, não é necessário manter a VM de verificação. Para excluir a VM, execute o comando a seguir:

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

6. Opcional: para excluir a imagem de disco criada, execute o seguinte comando:

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

Autoassinatura (manual)

Sistemas operacionais compatíveis

Esse método manual de autoassinatura foi testado nos seguintes sistemas operacionais:

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

Visão geral

O processo de instalação, assinatura e criação de imagens é o seguinte:

1. Gere seu próprio certificado para assinar o driver.
2. Crie uma VM para instalar e assinar o driver da GPU. Para criar a VM, use o SO de sua escolha. Ao criar a VM, desative a Inicialização segura. Não é necessário anexar GPUs à VM.
3. Instale e assine o driver da GPU e o kit de ferramentas CUDA opcional.
4. Crie uma imagem de disco com base na máquina com um driver autoassinado, adicionando seu certificado à lista de certificados confiáveis.
5. Use a imagem para criar VMs de GPU com a inicialização segura ativada.

Criação de imagens

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. Gere seu próprio certificado usando o OpenSSL. Com o OpenSSL, a assinatura e a verificação da inicialização segura são feitas usando os certificados X.509 regulares codificados por regras distintas de codificação (DER, na sigla em inglês). Execute o comando a seguir para gerar um novo certificado X.509 autoassinado e um arquivo de chave privada 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. Crie uma VM para instalar o driver autoassinado. Ao criar a VM, não é necessário anexar GPUs nem ativar a inicialização segura. Use um tipo de máquina E2 padrão com pelo menos 40 GB de espaço disponível para que o processo de instalação seja concluído.

   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
   

   Substitua:

   • BUILD_INSTANCE_NAME: nome da instância de VM usada para criar a imagem.
   • IMAGE_NAME: nome da imagem de disco.
   • ZONE: zona em que a VM será criada.
   • PROJECT_ID: ID do projeto que você quer usar para criar a nova imagem de disco.

   • IMAGE_DETAILS: a família de imagens e o projeto da imagem do SO base selecionada:

     • 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. Copie o arquivo de chave privada gerado para a VM. Para assinar o arquivo de driver, é preciso ter o novo par de chaves gerado disponível na 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. Instale e assine o driver. A instalação e a assinatura do driver e do kit de ferramentas CUDA são processadas pelo script de instalação, que também é usado para instalações que não usam a inicialização segura. Para instalar e assinar o driver, siga estas etapas:

   1. Conecte-se à VM com SSH:

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

   2. Verifique se as chaves privada e pública foram copiadas corretamente:

      ls private.key public.der
      

   3. Faça o download do script de instalação do driver:

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

   4. Verifique se a instalação do driver está configurada com a assinatura. A máquina de build é reiniciada durante a configuração. Depois que a máquina de build for reiniciada, conecte-se à VM usando SSH e execute o script novamente para retomar a instalação.

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

      Se quiser instalar o kit de ferramentas CUDA ao mesmo tempo, use o seguinte comando.

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

      Talvez você veja algumas mensagens de erro ou aviso. Esses são os resultados esperados quando nenhuma GPU é detectada. O sistema será reinicializado após a conclusão da instalação do CUDA Toolkit. Depois de se reconectar, siga para as próximas etapas.

   5. Remova os arquivos de certificado, já que eles não são mais necessários na máquina temporária. Para ter mais segurança, use shred em vez do comando rm. As chaves não devem estar presentes na imagem final do disco.

      shred -uz private.key public.der
      

   6. Desligue a VM para usar o disco dela e criar a nova imagem.

      sudo shutdown now
      

6. Prepare a imagem do disco de base. Para criar uma nova imagem de disco que possa ser usada para criar instâncias com a inicialização segura ativada, configure a imagem para confiar na chave recém-gerada. A nova imagem de disco ainda aceita os certificados padrão usados pelo sistema operacional. Para preparar a imagem de base, siga estas etapas.

   1. Faça o download dos certificados padrão. Use os comandos a seguir para baixar os certificados 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. Verifique os certificados:

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

   3. Crie uma imagem com base no disco da VM temporária. É possível adicionar --family=IMAGE_FAMILY_NAME como uma opção para que a imagem seja definida como a mais recente em uma determinada família. A criação da nova imagem pode levar alguns minutos.

      Execute o seguinte comando no mesmo diretório em que estão o arquivo public.der e os certificados baixados.

      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"
      

      Para verificar se a chave pública do certificado está anexada a essa nova imagem, execute o seguinte comando:

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

7. Verifique a nova imagem. É possível criar uma VM com GPU usando a nova imagem de disco. Para esta etapa, recomendamos um tipo de máquina N1 com um único acelerador T4 e a Inicialização segura ativada. No entanto, a imagem também é compatível com outros tipos de GPUs e tipos de máquinas.

   1. Crie uma VM de GPU de teste:

      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
      

      Substitua:

      • TEST_GPU_INSTANCE_NAME: nome da instância de VM com GPU
        que você está criando para testar a nova imagem.
      • ZONE: zona com GPUs T4 ou outra GPU de sua escolha. Para mais informações, consulte Regiões e zonas de GPU.

   2. Execute o comando mokutil --sb-state na VM de teste usando gcloud compute ssh para verificar se a Inicialização segura está ativada.

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

   3. Verifique se o driver está instalado executando o comando nvidia-smi na VM de teste usando gcloud compute ssh.

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

      Se você tiver instalado o CUDA Toolkit, use a ferramenta cuda_installer para verificar a instalação da seguinte maneira:

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

8. Fazer a limpeza. Depois de verificar se a nova imagem funciona, não é necessário manter a VM temporária ou de verificação. A imagem de disco criada não depende deles de forma alguma. É possível excluí-los com o seguinte comando:

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

   Não recomendamos armazenar o certificado de assinatura do Inicialização segura em um estado não criptografado no disco. Se você quiser armazenar as chaves de forma segura para que possam ser compartilhadas com outras pessoas, use o Secret Manager para manter seus dados protegidos.

   Quando você não precisar mais dos arquivos no disco, é melhor removê-los com segurança usando a ferramenta shred. Execute este comando:

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

Pré-assinada (somente Ubuntu)

Estas instruções estão disponíveis apenas para VMs do Linux com inicialização segura executadas nos sistemas operacionais Ubuntu 18.04, 20.04 e 22.04. O suporte para mais sistemas operacionais está em andamento.

Para instalar drivers de GPU nas VMs do Ubuntu que usam a inicialização segura, siga estas etapas:

1. Conecte-se à VM em que você quer instalar o driver.

2. Atualize o repositório.

    sudo apt-get update
   

3. Procure o pacote de módulo do kernel da NVIDIA mais recente ou a versão escolhida. Esse pacote contém módulos de kernel da NVIDIA assinados pela chave do Ubuntu. Se você quiser encontrar uma versão anterior, mude o número do parâmetro cauda para receber uma versão anterior. Por exemplo, especifique tail -n 2.

   Ubuntu PRO e LTS

   Para Ubuntu PRO e LTS, execute o seguinte 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

   Para o Ubuntu PRO FIPS, execute os seguintes comandos:

   1. Ativar as atualizações do Ubuntu FIPS.

      sudo ua enable fips-updates
      

   2. Encerrar e reiniciar

      sudo shutdown -r now
      

   3. Faça o download do pacote mais 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}')
      

   Para verificar a versão do driver escolhido, execute echo $NVIDIA_DRIVER_VERSION. A saída é uma string de versão como 455.

4. Instale o pacote do módulo do kernel e o driver da NVIDIA correspondente.

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

   Se o comando falhar com package not found error, talvez o driver NVIDIA mais recente esteja ausente no repositório. Repita a etapa anterior e selecione uma versão anterior do driver mudando o número da cauda.

5. Verifique se o driver NVIDIA está instalado. Talvez seja necessário reinicializar a VM.

6. Se você reiniciou o sistema para verificar a versão da NVIDIA. Após a reinicialização, você precisa redefinir a variável NVIDIA_DRIVER_VERSION executando novamente o comando usado na etapa 3.

7. Configure o APT para usar o repositório do pacote da NVIDIA.

   1. Para ajudar o APT a escolher a dependência correta, fixe os repositórios da seguinte maneira:

      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. Instale software-properties-common. Isso é necessário se você estiver usando imagens mínimas do Ubuntu.

      sudo apt install software-properties-common
      

   3. Define a versão do Ubuntu.

      Ubuntu 18.04

      Para o Ubuntu 18.04, execute o seguinte comando:

      export UBUNTU_VERSION=ubuntu1804/x86_64

      Ubuntu 20.04

      Para o Ubuntu 20.04, execute o seguinte comando:

      export UBUNTU_VERSION=ubuntu2004/x86_64

      Ubuntu 22.04

      Para o Ubuntu 22.04, execute o seguinte comando:

      export UBUNTU_VERSION=ubuntu2204/x86_64

   4. Faça o download do pacote cuda-keyring:

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

   5. Instale o pacote cuda-keyring.

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

   6. Adicione o repositório da NVIDIA.

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

   Se solicitado, selecione a ação padrão para manter a versão atual.

8. Encontre a versão do driver CUDA compatível.

   O script a seguir determina a versão mais recente do driver CUDA compatível com o driver da NVIDIA que acabamos de instalar:

    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)
   

   Para verificar a versão do driver CUDA, execute echo $CUDA_DRIVER_VERSION. A saída é uma string de versão como 455.32.00-1.

9. Instale os drivers CUDA com a versão identificada na etapa anterior.

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

10. Opcional: mantenha pressionado pacotes dkms.

    Depois que a Inicialização segura for ativada, todos os módulos do kernel precisam ser assinados para que sejam carregados. Os módulos de kernel criados por dkms não funcionam na VM porque, por padrão, não são assinados corretamente. Essa etapa é opcional, mas pode ajudar a impedir a instalação acidental de outros pacotes dkms futuramente.

    Para manter os pacotes dkms, execute o seguinte comando:

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

11. Instale o kit de ferramentas e o ambiente de execução do CUDA.

    Escolha a versão apropriada do CUDA. O script a seguir determina a versão do CUDA mais recente, compatível com o driver CUDA que acabamos de instalar:

     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)
    

    Para verificar a versão do CUDA, execute echo $CUDA_VERSION. A saída é uma string de versão como 11-1.

12. Instale o pacote CUDA.

     sudo apt install cuda-${CUDA_VERSION}
    

13. Verifique a instalação do CUDA.

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

    O primeiro comando imprime as informações da GPU. O segundo comando imprime a versão do compilador CUDA instalado.

Linux

Conecte-se à instância do Linux e use o comando nvidia-smi para verificar se o driver está funcionando corretamente.

sudo nvidia-smi

O resultado será assim:

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 esse comando falhar, revise o seguinte:

• Verifique se as GPUs estão anexadas à VM. Para verificar se há dispositivos NVIDIA PCI, execute o seguinte comando:

  sudo lspci | grep -i "nvidia"

• Verifique se a versão do kernel do driver e a do kernel da VM são as mesmas.

  • Para verificar a versão do kernel da VM, execute o seguinte comando:

    uname -r

  • Para verificar a versão do kernel do driver, execute o seguinte comando:

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

    Se as versões não corresponderem, reinicialize a VM para a nova versão do kernel.

Windows Server

Conecte-se à instância do Windows Server e abra um terminal do PowerShell. Em seguida, execute o comando a seguir para verificar se o driver está sendo executado corretamente.

nvidia-smi

O resultado será assim:

+---------------------------------------------------------------------------------------+
| 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      |
+---------------------------------------------------------------------------------------+