Instale controladores da GPU

Linux

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

Sistemas operativos compatíveis

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

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

Se usar este guião noutros sistemas operativos, a instalação pode falhar. Este script pode instalar o controlador da NVIDIA, bem como o CUDA Toolkit. Para instalar os controladores da GPU e o CUDA Toolkit, conclua os seguintes passos:

1. Se tiver a versão 2.38.0 ou posterior do agente Ops a recolher métricas da GPU na sua VM, tem de parar o agente antes de poder instalar ou atualizar os controladores da GPU através deste script de instalação.

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

   sudo systemctl stop google-cloud-ops-agent

2. Certifique-se de que o Python 3 está instalado no seu sistema operativo.

3. Transfira o 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 guião de instalação.

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

   • INSTALLATION_MODE: o método de instalação. Use um dos seguintes valores:
     • repo: (Predefinição) instala o controlador a partir do repositório de pacotes oficial da NVIDIA.
     • binary: instala o controlador através do pacote de instalação binário.
   • BRANCH: o ramo do controlador que quer instalar. Use um dos seguintes valores:
     • prod: (predefinição) o ramo de produção. Este ramo está qualificado para utilização em ambientes de produção para GPUs empresariais e de centros de dados.
     • nfb: o novo ramo de funcionalidades. Esta ramificação inclui as atualizações mais recentes para os primeiros utilizadores. Este ramo não é recomendado para ambientes de produção.
     • lts: o ramo de apoio técnico a longo prazo. Esta ramificação é mantida durante um período mais longo do que uma ramificação de produção normal.

   A execução do script demora algum tempo. Vai reiniciar a VM. Se a MV for reiniciada, execute o script novamente para continuar a instalação.

5. Valide a instalação. Consulte o artigo Valide a instalação do controlador da GPU.

6. Também pode usar esta ferramenta para instalar o CUDA Toolkit. Para instalar o CUDA Toolkit, execute o seguinte comando:

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

   Certifique-se de que usa os mesmos valores para INSTALLATION_MODE e BRANCH que usou durante a instalação do controlador.

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

7. Valide a instalação do CUDA Toolkit.

   python3 cuda_installer.pyz verify_cuda

8. Depois de concluir a instalação ou a atualização do controlador da GPU, tem de reiniciar a VM.

Linux (script de arranque)

Use estas instruções para instalar controladores de GPU durante o arranque de uma VM.

Sistemas operativos compatíveis

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

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

Se usar este guião noutros sistemas operativos, a instalação pode falhar. Este script pode instalar o controlador da NVIDIA, bem como o CUDA Toolkit.

Use o seguinte script de arranque para automatizar a instalação do controlador e do 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

Pode anexar as flags --installation-mode INSTALLATION_MODE e --installation-branch BRANCH ao comando de instalação para indicar o modo de instalação e a ramificação do controlador que quer instalar.

• INSTALLATION_MODE: o método de instalação. Use um dos seguintes valores:
  • repo: (Predefinição) instala o controlador a partir do repositório de pacotes oficial da NVIDIA.
  • binary: instala o controlador através do pacote de instalação binário.
• BRANCH: o ramo do controlador que quer instalar. Use um dos seguintes valores:
  • prod: (predefinição) o ramo de produção. Este ramo está qualificado para utilização em ambientes de produção para GPUs empresariais e de centros de dados.
  • nfb: o novo ramo de funcionalidades. Esta ramificação inclui as atualizações mais recentes para os primeiros utilizadores. Este ramo não é recomendado para ambientes de produção.
  • lts: o ramo de apoio técnico a longo prazo. Esta ramificação é mantida durante um período mais longo do que uma ramificação de produção normal.

Windows

Este script de instalação pode ser usado em VMs com o arranque seguro ativado.

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

Abra um terminal do PowerShell como administrador e, de seguida, conclua os seguintes passos:

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

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

2. Transfira o 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

   A execução do script demora algum tempo. Não são apresentadas instruções de comando durante o processo de instalação. Quando o script é terminado, o controlador é instalado.

   Este script instala os controladores na seguinte localização predefinida na sua VM: C:\Program Files\NVIDIA Corporation\\.

4. Valide a instalação. Consulte o artigo Valide a instalação do controlador da GPU.

Assinatura automática

Sistemas operativos compatíveis:

Este método de assinatura automática foi testado nos seguintes sistemas operativos:

• 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, conclua os seguintes passos:

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. Transfira a ferramenta cuda_installer. Para transferir a 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 o arranque seguro ativado executando o seguinte comando. O processo de criação de imagens pode demorar 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 o seguinte:

      • PROJECT_ID: ID do projeto no qual criar a imagem
      • ZONE: zona a usar para criar uma VM temporária. Por exemplo, us-west4-a.
      • IMAGE_NAME: nome da imagem que vai 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

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

      Para ver todas as opções de personalização da execução de imagens python3 cuda_installer.pyz build_image --help. Também pode rever a documentação da cuda_installer no GitHub.

   4. Valide a imagem. Siga os passos abaixo para verificar se a imagem tem o arranque seguro ativado e se pode criar instâncias de GPU com os controladores da NVIDIA instalados.

      1. Crie uma instância de VM de teste para verificar se a imagem está corretamente configurada e se os controladores de GPU são carregados com êxito. O exemplo seguinte cria um tipo de máquina N1 com um único acelerador NVIDIA T4 anexado. No entanto, pode usar qualquer tipo de máquina de GPU suportado à sua escolha.

         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 o seguinte:

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

      2. Verifique se o arranque seguro está ativado executando o comando mokutil --sb-state na VM de teste através de gcloud compute ssh.

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

      3. Verifique se o controlador está instalado executando o comando nvidia-smi na VM de teste através de gcloud compute ssh.

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

         Se tiver instalado o CUDA Toolkit, pode usar a cuda_installer ferramenta para validar a instalação da seguinte forma:

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

   5. Limpar. Depois de validar que a imagem personalizada funciona, não é necessário manter a VM de validação. Para eliminar a VM, execute o seguinte comando:

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

   6. Opcional: para eliminar a imagem do disco que criou, execute o seguinte comando:

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

   Autocertificação (manual)

   Sistemas operativos compatíveis

   Este método de autoassinatura manual foi testado nos seguintes sistemas operativos:

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

   Overview

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

   1. Gere o seu próprio certificado para ser usado na assinatura do controlador.
   2. Crie uma VM para instalar e assinar o controlador da GPU. Para criar a VM, pode usar o SO da sua escolha. Quando cria a VM, tem de desativar o Arranque seguro. Não precisa de anexar GPUs à VM.
   3. Instale e assine o controlador da GPU e o CUDA Toolkit opcional.
   4. Crie uma imagem de disco com base na máquina com um controlador autoassinado, adicionando o seu certificado à lista de certificados fidedignos.
   5. Use a imagem para criar VMs de GPU com o arranque seguro ativado.

   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 o seu próprio certificado através do OpenSSL. Com o OpenSSL, a assinatura e a validação do arranque seguro são feitas através dos certificados X.509 codificados em Distinguished Encoding Rules (DER) normais. Execute o seguinte comando para gerar um novo certificado X.509 autoassinado e um ficheiro 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 controlador autoassinado. Quando cria a VM, não tem de anexar nenhuma GPU nem ativar o arranque seguro. Pode usar 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 bem-sucedido.

         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 o seguinte:

         • BUILD_INSTANCE_NAME: nome da instância de VM usada para criar a imagem.
         • IMAGE_NAME: nome da imagem de disco.
         • ZONE: zona onde criar a VM.
         • PROJECT_ID: ID do projeto que 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 ficheiro de chave privada gerado para a VM. Para assinar o ficheiro do controlador, tem de ter o par de chaves recém-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 controlador. A instalação e a assinatura do controlador e do CUDA Toolkit são processadas pelo script de instalação que também é usado para instalações que não usam o arranque seguro. Para instalar e assinar o controlador, conclua os seguintes passos:

         1. Estabeleça ligação à 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. Transfira o script de instalação do controlador:

            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 controlador está configurada com a assinatura configurada. O computador de compilação é reiniciado durante a configuração. Após o reinício da máquina de compilação, estabeleça ligação à VM através de SSH e volte a executar o script 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 CUDA Toolkit ao mesmo tempo, pode fazê-lo com o seguinte comando.

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

            Pode ver algumas mensagens de erro ou aviso. Estes são o resultado de não ter sido detetada nenhuma GPU e são esperados. O sistema é reiniciado após a conclusão da instalação do CUDA Toolkit. Após a nova associação, pode continuar para os passos seguintes.

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

            shred -uz private.key public.der
            

         6. Encerre a VM para poder usar o respetivo disco para criar a nova imagem.

            sudo shutdown now
            

      6. Prepare a imagem de disco base. Para criar uma nova imagem de disco que possa ser usada para criar instâncias com o arranque seguro ativado, tem de configurar a imagem para confiar na chave gerada recentemente. A nova imagem de disco continua a aceitar os certificados predefinidos usados pelo sistema operativo. Para preparar a imagem base, conclua os seguintes passos.

         1. Transfira os certificados predefinidos. Use os seguintes comandos para transferir 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. Valide 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. Pode adicionar --family=IMAGE_FAMILY_NAME como uma opção para que a imagem seja definida como a imagem mais recente numa determinada família de imagens. A criação da nova imagem pode demorar alguns minutos.

            Execute o seguinte comando no mesmo diretório onde se encontram o ficheiro public.der e os certificados transferidos.

            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"
            

            Pode verificar se a chave pública do seu certificado está anexada a esta nova imagem executando o seguinte comando:

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

      7. Valide a nova imagem. Pode criar uma VM de GPU com a nova imagem do disco. Para este passo, recomendamos um tipo de máquina N1 com um único acelerador T4 que tenha o arranque seguro ativado. No entanto, a imagem também suporta 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 o seguinte:

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

         2. Verifique se o arranque seguro está ativado executando o comando mokutil --sb-state na VM de teste com gcloud compute ssh.

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

         3. Verifique se o controlador está instalado executando o comando nvidia-smi na VM de teste através de gcloud compute ssh.

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

            Se tiver instalado o CUDA Toolkit, pode usar a ferramenta cuda_installer para validar a instalação da seguinte forma:

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

      8. Limpar. Depois de verificar que a nova imagem funciona, não precisa de manter a VM temporária nem a VM de validação. A imagem de disco que criou não depende deles de forma alguma. Pode eliminá-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 que armazene o seu certificado de assinatura do arranque seguro num estado não encriptado no disco. Se quiser armazenar as chaves de forma segura para que possam ser partilhadas com outras pessoas, pode usar o Secret Manager para manter os seus dados seguros.

         Quando já não precisar dos ficheiros no disco, é melhor removê-los em segurança através da ferramenta shred. Execute o seguinte comando:

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

      Pré-assinado (apenas para Ubuntu)

      Estas instruções só estão disponíveis para VMs Linux de arranque seguro que são executadas nos sistemas operativos Ubuntu 18.04, 20.04 e 22.04. Está em curso o suporte de mais sistemas operativos Linux.

      Para instalar controladores de GPU nas suas VMs do Ubuntu que usam o arranque seguro, conclua os seguintes passos:

      1. Estabeleça ligação à VM onde quer instalar o controlador.

      2. Atualize o repositório.

          sudo apt-get update
         

      3. Pesquise o pacote de módulo do kernel da NVIDIA mais recente ou a versão que pretende. Este pacote contém módulos do kernel da NVIDIA assinados pela chave do Ubuntu. Se quiser encontrar uma versão anterior, altere o número do parâmetro tail para obter uma versão anterior. Por exemplo, especifique tail -n 2.

         Ubuntu PRO e LTS

         Para o 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 atualizações FIPS do Ubuntu.

            sudo ua enable fips-updates
            

         2. Encerrar e reiniciar

            sudo shutdown -r now
            

         3. Transfira o 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}')
            

         Pode verificar a versão do controlador selecionada executando echo $NVIDIA_DRIVER_VERSION. O resultado é uma string de versão, como 455.

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

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

         Se o comando falhou com o erro package not found error, o controlador NVIDIA mais recente pode estar em falta no repositório. Tente novamente o passo anterior e selecione uma versão anterior do controlador alterando o número de cauda.

      5. Verifique se o controlador da NVIDIA está instalado. Pode ter de reiniciar a VM.

      6. Se reiniciou o sistema para validar a versão da NVIDIA. Após o reinício, tem de repor a variável NVIDIA_DRIVER_VERSION executando novamente o comando que usou no passo 3.

      7. Configure o APT para usar o repositório de pacotes da NVIDIA.

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

            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. Isto é necessário se estiver a usar imagens mínimas do Ubuntu.

            sudo apt install software-properties-common
            

         3. Defina 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. Transfira o 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 lhe for pedido, selecione a ação predefinida para manter a versão atual.

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

         O seguinte script determina a versão mais recente do controlador CUDA compatível com o controlador NVIDIA que acabámos 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)
         

         Pode verificar a versão do controlador CUDA executando echo $CUDA_DRIVER_VERSION. O resultado é uma string de versão, como 455.32.00-1.

      9. Instale os controladores CUDA com a versão identificada no passo anterior.

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

      10. Opcional: retenha dkms encomendas.

          Depois de ativar o arranque seguro, todos os módulos do kernel têm de estar assinados para serem carregados. Os módulos do kernel criados por dkms não funcionam na VM porque, por predefinição, não têm uma assinatura adequada. Este é um passo opcional, mas pode ajudar a evitar a instalação acidental de outros pacotes dkmsno futuro.

          Para reter pacotes dkms, execute o seguinte comando:

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

      11. Instale o CUDA Toolkit e o tempo de execução.

          Escolha a versão do CUDA adequada. O seguinte script determina a versão mais recente do CUDA compatível com o controlador do CUDA que acabámos 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)
          

          Pode verificar a versão do CUDA executando echo $CUDA_VERSION. O resultado é uma string de versão, como 11-1.

      12. Instale o pacote CUDA.

           sudo apt install cuda-${CUDA_VERSION}
          

      13. Valide 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 instalada.

Linux

Ligue-se à instância do Linux e use o comando nvidia-smi para verificar se o controlador está a ser executado corretamente.

sudo nvidia-smi

O resultado é semelhante ao seguinte:

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 este comando falhar, verifique se as GPUs estão associadas à VM. Para verificar se existem dispositivos PCI da NVIDIA, execute o seguinte comando:

sudo lspci | grep -i "nvidia"

Windows Server

Ligue-se à instância do Windows Server e abra um terminal do PowerShell. Em seguida, execute o seguinte comando para verificar se o controlador está a ser executado corretamente.

nvidia-smi

O resultado é semelhante ao seguinte:

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