Instalar controladores de GPU


Después de crear una instancia de máquina virtual con una o varias GPUs, tu sistema necesita controladores de dispositivo NVIDIA para que tus aplicaciones puedan acceder al dispositivo. Asegúrate de que tus instancias de máquina virtual tengan suficiente espacio libre en disco. Debes elegir al menos 40 GB para el disco de arranque al crear la nueva VM.

Para instalar los controladores, puedes elegir entre dos opciones:

Versiones del controlador de NVIDIA, del kit de herramientas CUDA y del tiempo de ejecución de CUDA

Hay diferentes componentes versionados de controladores y tiempos de ejecución que pueden ser necesarios en tu entorno. Entre ellos, se incluyen los siguientes componentes:

  • Controlador de NVIDIA
  • Kit de herramientas de CUDA
  • Tiempo de ejecución de CUDA

Al instalar estos componentes, puedes configurar tu entorno según tus necesidades. Por ejemplo, si tienes una versión anterior de TensorFlow que funciona mejor con una versión anterior del kit de herramientas de CUDA, pero la GPU que quieres usar requiere una versión posterior del controlador de NVIDIA, puedes instalar una versión anterior del kit de herramientas de CUDA junto con una versión posterior del controlador de NVIDIA.

Sin embargo, debes asegurarte de que las versiones de tu controlador de NVIDIA y del kit de herramientas de CUDA sean compatibles. Para obtener información sobre la compatibilidad del kit de herramientas de CUDA y los controladores de NVIDIA, consulta la documentación de NVIDIA sobre la compatibilidad con CUDA.

Información sobre las ramas de controladores de NVIDIA

NVIDIA ofrece las tres ramas de controladores siguientes:

  • Rama de asistencia a largo plazo (LTSB): esta rama prioriza la estabilidad y minimiza el mantenimiento, con un ciclo de vida de asistencia ampliado de tres años. La última versión LTSB probada y verificada por Google es la 535, que dejará de recibir asistencia en junio del 2026.
  • Rama de producción (PB): esta rama ofrece mejoras de rendimiento y compatibilidad con el hardware más reciente. Es totalmente compatible con las cargas de trabajo de producción, pero tiene un ciclo de vida de asistencia más corto, de hasta un año. La última versión de PB probada y verificada por Google es la 570, que dejará de recibir asistencia en febrero del 2026.
  • Rama de nuevas funciones (NFB): esta rama es para los usuarios pioneros que quieran probar nuevas funciones y no se recomienda para entornos de producción.

Para las cargas de trabajo de producción, usa la rama de producción o la rama de asistencia a largo plazo. Para obtener más información sobre las ramas de NVIDIA, consulta la documentación de NVIDIA.

Usa la tabla de esta sección para determinar la mejor rama de controladores de NVIDIA para tu tipo de máquina con GPU.

En la siguiente tabla, EOS indica el final de la asistencia. N/A indica que el sistema operativo especificado no se puede ejecutar en el tipo de máquina.

Tipo de máquina Modelo de GPU Rama más antigua admitida Rama recomendada (fecha de fin de asistencia) Controlador mínimo para la rama recomendada
A4X Superchip NVIDIA Blackwell GB200 570 570 (febrero del 2026)
  • Linux: 570.133.20 o versiones posteriores
  • Windows: N/A
A4 NVIDIA Blackwell B200 570 570 (febrero del 2026)
  • Linux: 570.124.06 o versiones posteriores
  • Windows: N/A
A3 Ultra NVIDIA H200 R550 (EOS) 570 (febrero del 2026)
  • Linux: 570.124.06 o versiones posteriores
  • Windows: N/A
A3 Mega, High y Edge NVIDIA H100 535 535 (junio del 2026)
  • Linux: 535.230.02 o versiones posteriores
  • Windows: N/A
G2 NVIDIA L4 535 535 (junio del 2026)
  • Linux: 535.230.02 o versiones posteriores
  • Windows: 538.67 o posterior
A2 Standard y A2 Ultra NVIDIA A100 535 535 (junio del 2026)
  • Linux: 535.230.02 o versiones posteriores
  • Windows: 538.67 o posterior
N1 NVIDIA V100, T4, P100 y P4 R410 (EOS) 535 (junio del 2026)
  • Linux: 535.230.02 o versiones posteriores
  • Windows: 538.67 o posterior

Instalar controladores de GPU en máquinas virtuales con las guías de CUDA Toolkit

Una forma de instalar el controlador de NVIDIA en la mayoría de las máquinas virtuales es instalar el CUDA Toolkit.

Para instalar CUDA Toolkit, sigue estos pasos:

  1. Selecciona una versión de CUDA Toolkit que sea compatible con la versión del controlador que necesites.

    Tipo de máquina Modelo de GPU CUDA Toolkit recomendado
    A4X Superchip NVIDIA Blackwell GB200 CUDA 12.8.1 o posterior
    A4 NVIDIA Blackwell B200 CUDA 12.8.1 o posterior
    A3 Ultra NVIDIA H200 CUDA 12.4 o versiones posteriores
    G2 NVIDIA L4 CUDA 12.2.2 o versiones posteriores
    A3 Mega, High y Edge NVIDIA H100 CUDA 12.2.2 o versiones posteriores
    A2 Standard y A2 Ultra NVIDIA A100 CUDA 12.2.2 o versiones posteriores
    N1 NVIDIA V100, T4, P100 y P4 CUDA 12.2.2 o versiones posteriores
  2. Conéctate a la VM en la que quieras instalar el controlador.

  3. En tu VM, descarga e instala el kit de herramientas CUDA. Para encontrar el paquete del kit de herramientas de CUDA y las instrucciones de instalación, consulta el archivo del kit de herramientas de CUDA en la documentación de NVIDIA.

Instalar controladores de GPU en máquinas virtuales mediante una secuencia de comandos de instalación

Puedes usar las siguientes secuencias de comandos para automatizar el proceso de instalación. Para consultar estas secuencias de comandos, ve al repositorio de GitHub.

Linux

Sigue estas instrucciones para instalar los controladores de GPU en una VM en ejecución.

Sistemas operativos compatibles

La secuencia de comandos de instalación de Linux se ha probado en los siguientes sistemas operativos:

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

Si usas esta secuencia de comandos en otros sistemas operativos, es posible que la instalación falle. Esta secuencia de comandos puede instalar el controlador de NVIDIA y el CUDA Toolkit. Para instalar los controladores de la GPU y CUDA Toolkit, sigue estos pasos:

  1. Si tienes la versión 2.38.0 o posterior del Ops Agent que recoge métricas de GPU en tu VM, debes detener el agente antes de poder instalar o actualizar los controladores de GPU con esta secuencia de comandos de instalación.

    Para detener el agente de Ops, ejecuta el siguiente comando:

    sudo systemctl stop google-cloud-ops-agent
  2. Asegúrate de que Python 3 esté instalado en tu sistema operativo.

  3. Descarga la secuencia de comandos de instalación.

    curl -L https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz --output cuda_installer.pyz
  4. Ejecuta la secuencia de comandos de instalación.

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

    • INSTALLATION_MODE: el método de instalación. Utilice uno de los siguientes valores:
      • repo: (opción predeterminada) instala el controlador desde el repositorio oficial de paquetes de NVIDIA.
      • binary: instala el controlador mediante el paquete de instalación binario.
    • BRANCH: la rama del controlador que quieras instalar. Utilice uno de los siguientes valores:
      • prod: (predeterminado) la rama de producción. Esta rama es apta para usarse en entornos de producción para GPUs empresariales y de centros de datos.
      • nfb: la nueva rama de funciones. Esta rama incluye las últimas actualizaciones para los primeros usuarios. No se recomienda usar esta rama en entornos de producción.
      • lts: la rama de asistencia a largo plazo. Esta rama se mantiene durante un periodo más largo que una rama de producción normal.

    La secuencia de comandos tarda un poco en ejecutarse. Se reiniciará la VM. Si la máquina virtual se reinicia, vuelve a ejecutar la secuencia de comandos para continuar con la instalación.

  5. Verifica la instalación. Consulta Verificar la instalación del controlador de GPU.

  6. También puedes usar esta herramienta para instalar el kit de herramientas de CUDA. Para instalar el CUDA Toolkit, ejecuta el siguiente comando:

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

    Asegúrate de usar los mismos valores para INSTALLATION_MODE y BRANCH que usaste durante la instalación del controlador.

    Esta secuencia de comandos puede tardar al menos 30 minutos en ejecutarse. Se reiniciará la VM. Si la máquina virtual se reinicia, vuelve a ejecutar la secuencia de comandos para continuar con la instalación.

  7. Verifica la instalación del kit de herramientas de CUDA.

    python3 cuda_installer.pyz verify_cuda
  8. Después de completar la instalación o la actualización del controlador de la GPU, debes reiniciar la VM.

Linux (secuencia de comandos de inicio)

Sigue estas instrucciones para instalar los controladores de GPU durante el inicio de una VM.

Sistemas operativos compatibles

La secuencia de comandos de instalación de Linux se ha probado en los siguientes sistemas operativos:

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

Si usas esta secuencia de comandos en otros sistemas operativos, es posible que la instalación falle. Esta secuencia de comandos puede instalar el controlador de NVIDIA y el CUDA Toolkit.

Usa la siguiente secuencia de comandos de inicio para automatizar la instalación del controlador y del 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

Puedes añadir las marcas --installation-mode INSTALLATION_MODE y --installation-branch BRANCH al comando de instalación para indicar el modo de instalación y la rama del controlador que quieres instalar.

  • INSTALLATION_MODE: el método de instalación. Utilice uno de los siguientes valores:
    • repo: (opción predeterminada) instala el controlador desde el repositorio oficial de paquetes de NVIDIA.
    • binary: instala el controlador mediante el paquete de instalación binario.
  • BRANCH: la rama del controlador que quieras instalar. Utilice uno de los siguientes valores:
    • prod: (predeterminado) la rama de producción. Esta rama es apta para usarse en entornos de producción para GPUs empresariales y de centros de datos.
    • nfb: la nueva rama de funciones. Esta rama incluye las últimas actualizaciones para los primeros usuarios. No se recomienda usar esta rama en entornos de producción.
    • lts: la rama de asistencia a largo plazo. Esta rama se mantiene durante un periodo más largo que una rama de producción normal.

Windows

Esta secuencia de comandos de instalación se puede usar en VMs que tengan habilitado el arranque seguro.

  • En las VMs de Windows que usan una serie de máquinas G2, esta secuencia de comandos solo instala el controlador de NVIDIA.
  • En el caso de otros tipos de máquinas, la secuencia de comandos instala el controlador de NVIDIA y el kit de herramientas CUDA.

Abre un terminal de PowerShell como administrador y sigue estos pasos:

  1. Si usas Windows Server 2016, define la versión 1.2 de Seguridad en la capa de transporte (TLS).

    [Net.ServicePointManager]::SecurityProtocol = 'Tls12'
    
  2. Descarga la secuencia de comandos.

    Invoke-WebRequest https://github.com/GoogleCloudPlatform/compute-gpu-installation/raw/main/windows/install_gpu_driver.ps1 -OutFile C:\install_gpu_driver.ps1
  3. Ejecuta la secuencia de comandos.

    C:\install_gpu_driver.ps1

    La secuencia de comandos tarda un poco en ejecutarse. No se proporcionan peticiones de comandos durante el proceso de instalación. Cuando se cierre la secuencia de comandos, se instalará el controlador.

    Esta secuencia de comandos instala los controladores en la siguiente ubicación predeterminada de tu máquina virtual: C:\Program Files\NVIDIA Corporation\\.

  4. Verifica la instalación. Consulta Verificar la instalación del controlador de GPU.

Instalar controladores de GPU (VMs con arranque seguro)

Estas instrucciones sirven para instalar controladores de GPU en VMs Linux que usan Arranque seguro.

Compatibilidad con GPU

Los procedimientos de esta sección son compatibles con todos los modelos de GPU disponibles en Compute Engine.

No puedes usar estos procedimientos para instalar controladores en instancias de arranque seguro que tengan conectadas versiones de estaciones de trabajo virtuales (vWS) NVIDIA RTX de nuestras GPUs.

Si usas una VM de Windows o una VM de Linux que no utiliza el arranque seguro, consulta una de las siguientes instrucciones:

La instalación del controlador en una VM con arranque seguro es diferente en las VMs Linux, ya que estas VMs requieren que todos los módulos del kernel tengan una firma de certificado de confianza.

Instalación

Puede usar una de las siguientes opciones para instalar controladores que tengan certificados de confianza:

  • Crea un certificado de confianza para tus controladores. Para esta opción, elige una de las siguientes:
    • Método automatizado: usa una herramienta de creación de imágenes para crear imágenes de arranque que tengan instalados certificados de confianza para tus controladores.
    • Método manual: genera tu propio certificado y úsalo para firmar los módulos del kernel del controlador de la GPU
  • Usa controladores prefirmados con un certificado de confianza. Este método solo es compatible con Ubuntu.

Autofirma (automatizada)

Sistemas operativos compatibles:

Este método de autofirma automatizado se ha probado en los siguientes sistemas operativos:

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

Procedimiento

Para crear una imagen del SO que tenga certificados autofirmados, sigue estos pasos:

    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. Descarga la herramienta cuda_installer. Para descargar la última versión de la secuencia de comandos, ejecuta el siguiente comando:

      curl -L https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz --output cuda_installer.pyz
      
    3. Crea una imagen con el arranque seguro habilitado ejecutando el siguiente comando. El proceso de creación de la imagen puede tardar hasta 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
      

      Haz los cambios siguientes:

      • PROJECT_ID: ID del proyecto en el que se va a crear la imagen.
      • ZONE: zona en la que se creará una VM temporal. Por ejemplo, us-west4-a.
      • IMAGE_NAME: nombre de la imagen que se creará.
      • BASE_IMAGE_NAME: selecciona una de las siguientes opciones:

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

      También puedes añadir la marca --family NAME para añadir la nueva imagen a una familia de imágenes.

      Para ver todas las opciones de personalización de la imagen, ejecuta python3 cuda_installer.pyz build_image --help. También puedes consultar la documentación de cuda_installer en GitHub.

    4. Verifica la imagen. Sigue estos pasos para verificar que la imagen tiene habilitado el arranque seguro y puede crear instancias de GPU que tengan instalados los controladores de NVIDIA.

      1. Crea una instancia de VM de prueba para verificar que la imagen esté configurada correctamente y que los controladores de GPU se carguen correctamente. En el siguiente ejemplo se crea un tipo de máquina N1 con un solo acelerador NVIDIA T4 conectado. Sin embargo, puedes usar cualquier tipo de máquina con GPU compatible.

        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
        

        Haz los cambios siguientes:

        • TEST_INSTANCE_NAME: nombre de la instancia de VM de prueba
        • ZONE: una zona que tenga GPUs T4 o la GPU que elijas. Para obtener más información, consulta el artículo sobre regiones y zonas de GPU.
      2. Comprueba que el arranque seguro esté habilitado ejecutando el comando mokutil --sb-state en la VM de prueba con gcloud compute ssh.

        gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_INSTANCE_NAME --command "mokutil --sb-state"
        
      3. Para comprobar que el controlador está instalado, ejecuta el comando nvidia-smi en la VM de prueba mediante gcloud compute ssh.

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

        Si has instalado CUDA Toolkit, puedes usar la cuda_installer herramienta para verificar la instalación de la siguiente manera:

        gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_INSTANCE_NAME --command "python3 cuda_installer.pyz verify_cuda"
        
    5. Limpiar. Una vez que hayas verificado que la imagen personalizada funciona, no es necesario que conserves la VM de verificación. Para eliminar la VM, ejecuta el siguiente comando:

      gcloud compute instances delete --zone=$ZONE --project=$PROJECT $TEST_INSTANCE_NAME
      
    6. Opcional: Para eliminar la imagen de disco que has creado, ejecuta el siguiente comando:

      gcloud compute images delete --project=$PROJECT $SECURE_BOOT_IMAGE
      
    7. Autofirma (manual)

      Sistemas operativos compatibles

      Este método de firma manual se ha probado en los siguientes sistemas operativos:

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

      Descripción general

      El proceso de instalación, firma y creación de imágenes es el siguiente:

      1. Genera tu propio certificado para firmar el controlador.
      2. Crea una máquina virtual para instalar y firmar el controlador de la GPU. Para crear la VM, puedes usar el SO que quieras. Cuando crees la VM, debes inhabilitar el arranque seguro. No es necesario que asigne ninguna GPU a la VM.
      3. Instala y firma el controlador de la GPU y el kit de herramientas CUDA (opcional).
      4. Crea una imagen de disco basada en el equipo con un controlador autofirmado y añade tu certificado a la lista de certificados de confianza.
      5. Usa la imagen para crear VMs con GPU que tengan habilitado el arranque seguro.

      Creación de imágenes

        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 tu propio certificado con OpenSSL. Con OpenSSL, la firma y la verificación de Arranque seguro se realizan mediante certificados X.509 codificados con las reglas de codificación distinguidas (DER) habituales. Ejecuta el siguiente comando para generar un nuevo certificado X.509 autofirmado y un archivo de clave 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. Crea una VM para instalar el controlador autofirmado. Cuando crees la VM, no tendrás que adjuntar ninguna GPU ni habilitar el arranque seguro. Puedes usar un tipo de máquina E2 estándar que tenga al menos 40 GB de espacio disponible para que el proceso de instalación se complete correctamente.

          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
          

          Haz los cambios siguientes:

          • BUILD_INSTANCE_NAME: nombre de la instancia de VM usada para crear la imagen.
          • IMAGE_NAME: nombre de la imagen de disco.
          • ZONE: zona en la que se creará la VM.
          • PROJECT_ID: ID del proyecto que quieres usar para crear la nueva imagen de disco.
          • IMAGE_DETAILS: la familia de imágenes y el proyecto de la imagen del SO base que hayas seleccionado:

            • 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 el archivo de clave privada generado en la VM. Para firmar el archivo del controlador, debes tener disponible en la VM el par de claves que acabas de generar.

          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. Instala y firma el controlador. El script de instalación se encarga de instalar y firmar el controlador y el CUDA Toolkit. También se usa para instalaciones que no utilizan el arranque seguro. Para instalar y firmar el controlador, sigue estos pasos:

          1. Conéctate a la VM con SSH:

            gcloud compute ssh --zone $ZONE --project $PROJECT $INSTANCE_NAME
            
          2. Comprueba que las claves privada y pública se hayan copiado correctamente:

            ls private.key public.der
            
          3. Descarga la secuencia de comandos de instalación del controlador:

            curl -L https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz --output cuda_installer.pyz
            
          4. Comprueba que la instalación del controlador se haya configurado con la firma. La máquina de compilación se reinicia durante la configuración. Una vez que se haya reiniciado la máquina de compilación, conéctate a la VM mediante SSH y vuelve a ejecutar la secuencia de comandos para reanudar la instalación.

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

            Si quieres instalar CUDA Toolkit al mismo tiempo, puedes hacerlo con el siguiente comando.

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

            Es posible que veas algunos mensajes de error o de advertencia. Estos resultados se deben a que no se ha detectado ninguna GPU y son los esperados. El sistema se reiniciará después de completar la instalación del kit de herramientas CUDA. Una vez que se haya restablecido la conexión, puede continuar con los pasos siguientes.

          5. Elimina los archivos de certificado, ya que no son necesarios en la máquina temporal. Para mejorar la seguridad, usa shred en lugar del comando rm. Las claves no deben estar presentes en la imagen de disco final.

            shred -uz private.key public.der
            
          6. Apaga la VM para poder usar su disco y crear la nueva imagen.

            sudo shutdown now
            
        6. Prepara la imagen de disco base. Para crear una imagen de disco que se pueda usar para crear instancias con Arranque seguro habilitado, debes configurar la imagen para que confíe en la clave que acabas de generar. La nueva imagen de disco sigue aceptando los certificados predeterminados que usa el sistema operativo. Para preparar la imagen base, sigue estos pasos.

          1. Descarga los certificados predeterminados. Usa los siguientes comandos para descargar los certificados MicWinProPCA2011_2011-10-19.crt y 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 los certificados:

            cat <<EOF >>check.sha1
            46def63b5ce61cf8ba0de2e6639c1019d0ed14f3  MicCorUEFCA2011_2011-06-27.crt
            580a6f4cc4e4b669b9ebdc1b2b3e087b80d0678d  MicWinProPCA2011_2011-10-19.crt
            EOF
            
            sha1sum -c check.sha1
            
          3. Crea una imagen basada en el disco de la VM temporal. Puedes añadir --family=IMAGE_FAMILY_NAME como opción para que la imagen se defina como la más reciente de una familia de imágenes determinada. La creación de la nueva imagen puede tardar un par de minutos.

            Ejecuta el siguiente comando en el mismo directorio en el que se encuentran el archivo public.der y los certificados descargados.

            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 que la clave pública de tu certificado está adjunta a esta nueva imagen, ejecuta el siguiente comando:

            gcloud compute images describe --project=$PROJECT $SECURE_BOOT_IMAGE
            
        7. Verifica la nueva imagen. Puedes crear una VM con GPU mediante la nueva imagen de disco. Para este paso, recomendamos un tipo de máquina N1 con un solo acelerador T4 que tenga habilitado el arranque seguro. Sin embargo, la imagen también admite otros tipos de GPUs y tipos de máquinas.

          1. Crea una VM de GPU de prueba:

            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
            

            Haz los cambios siguientes:

            • TEST_GPU_INSTANCE_NAME: nombre de la instancia de VM con GPU
              que vas a crear para probar la nueva imagen.
            • ZONE: zona que tiene GPUs T4 u otra GPU de tu elección. Para obtener más información, consulta Regiones y zonas de GPU.
          2. Comprueba que el arranque seguro esté habilitado ejecutando el comando mokutil --sb-state en la VM de prueba con gcloud compute ssh.

            gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_GPU_INSTANCE --command "mokutil --sb-state"
            
          3. Para comprobar que el controlador está instalado, ejecuta el comando nvidia-smi en la VM de prueba mediante gcloud compute ssh.

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

            Si has instalado CUDA Toolkit, puedes usar la herramienta cuda_installer para verificar la instalación de la siguiente manera:

            gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_GPU_INSTANCE --command "python3 cuda_installer.pyz verify_cuda"
            
        8. Limpiar. Una vez que hayas verificado que la nueva imagen funciona, no es necesario que conserves la VM temporal ni la VM de verificación. La imagen de disco que has creado no depende de ellos de ninguna manera. Puedes eliminarlos con el siguiente comando:

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

          No te recomendamos que almacenes tu certificado de firma de arranque seguro en un estado sin cifrar en tu disco. Si quieres almacenar las claves de forma segura para poder compartirlas con otros usuarios, puedes usar Secret Manager para proteger tus datos.

          Cuando ya no necesites los archivos del disco, lo mejor es que los elimines de forma segura con la herramienta shred. Ejecuta el siguiente comando:

          # Safely delete the key pair from your system
          shred -uz private.key public.der
          
        9. Prefirmado (solo Ubuntu)

          Estas instrucciones solo están disponibles para las VMs Linux con arranque seguro que se ejecutan en los sistemas operativos Ubuntu 18.04, 20.04 y 22.04. Estamos trabajando para incluir más sistemas operativos Linux.

          Para instalar controladores de GPU en tus VMs de Ubuntu que usen Arranque seguro, sigue estos pasos:

          1. Conéctate a la VM en la que quieras instalar el controlador.

          2. Actualiza el repositorio.

             sudo apt-get update
            
          3. Busca el paquete de módulos del kernel de NVIDIA más reciente o la versión que quieras. Este paquete contiene módulos del kernel de NVIDIA firmados por la clave de Ubuntu. Si quieres encontrar una versión anterior, cambia el número del parámetro tail para obtenerla. Por ejemplo, especifica tail -n 2.

            Ubuntu PRO y LTS

            En Ubuntu PRO y LTS, ejecuta el siguiente 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

            En Ubuntu PRO FIPS, ejecuta los siguientes comandos:

            1. Habilita las actualizaciones de FIPS de Ubuntu.

              sudo ua enable fips-updates
              
            2. Apagar y reiniciar

              sudo shutdown -r now
              
            3. Descarga el paquete más reciente.

              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}')
              

            Puedes comprobar la versión del controlador seleccionada ejecutando echo $NVIDIA_DRIVER_VERSION. El resultado es una cadena de versión, como 455.

          4. Instala el paquete del módulo del kernel y el controlador de NVIDIA correspondiente.

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

            Si el comando ha fallado con package not found error, es posible que falte el controlador más reciente de NVIDIA en el repositorio. Vuelve a intentar el paso anterior y selecciona una versión anterior del controlador cambiando el número de cola.

          5. Verifica que el controlador de NVIDIA esté instalado. Es posible que tengas que reiniciar la VM.

          6. Si has reiniciado el sistema para verificar la versión de NVIDIA. Después de reiniciar, debes restablecer la variable NVIDIA_DRIVER_VERSION volviendo a ejecutar el comando que has usado en el paso 3.

          7. Configura APT para que use el repositorio de paquetes de NVIDIA.

            1. Para ayudar a APT a elegir la dependencia correcta, fija los repositorios de la siguiente manera:

              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. Instala software-properties-common. Esto es obligatorio si usas imágenes mínimas de Ubuntu.

              sudo apt install software-properties-common
              
            3. Define la versión de Ubuntu.

              Ubuntu 18.04

              En Ubuntu 18.04, ejecuta el siguiente comando:

              export UBUNTU_VERSION=ubuntu1804/x86_64

              Ubuntu 20.04

              En Ubuntu 20.04, ejecuta el siguiente comando:

              export UBUNTU_VERSION=ubuntu2004/x86_64

              Ubuntu 22.04

              En Ubuntu 22.04, ejecuta el siguiente comando:

              export UBUNTU_VERSION=ubuntu2204/x86_64
            4. Descarga el paquete cuda-keyring.

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

              sudo dpkg -i cuda-keyring_1.0-1_all.deb
            6. Añade el repositorio de NVIDIA.

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

            Si se te pide, selecciona la acción predeterminada para mantener la versión actual.

          8. Busca la versión compatible del controlador CUDA.

            La siguiente secuencia de comandos determina la versión más reciente del controlador CUDA que es compatible con el controlador de 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)
            

            Puedes consultar la versión del controlador CUDA ejecutando echo $CUDA_DRIVER_VERSION. El resultado es una cadena de versión, como 455.32.00-1.

          9. Instala los controladores de CUDA con la versión identificada en el paso anterior.

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

          10. Opcional: Retener dkms paquetes.

            Después de habilitar el arranque seguro, todos los módulos del kernel deben estar firmados para poder cargarse. Los módulos del kernel creados por dkms no funcionan en la VM porque no están firmados correctamente de forma predeterminada. Este paso es opcional, pero puede ayudarte a evitar que instales otros paquetes dkms por error en el futuro.

            Para mantener los paquetes dkms, ejecuta el siguiente comando:

             sudo apt-get remove dkms && sudo apt-mark hold dkms
            
          11. Instala el kit de herramientas y el tiempo de ejecución de CUDA.

            Elige la versión de CUDA adecuada. La siguiente secuencia de comandos determina la versión de CUDA más reciente que es compatible con el controlador de 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)
            

            Puedes comprobar la versión de CUDA ejecutando echo $CUDA_VERSION. El resultado es una cadena de versión, como 11-1.

          12. Instala el paquete CUDA.

             sudo apt install cuda-${CUDA_VERSION}
            
          13. Verifica la instalación de CUDA.

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

            El primer comando imprime la información de la GPU. El segundo comando imprime la versión del compilador de CUDA instalado.

Verificar la instalación del controlador de GPU

Después de completar los pasos de instalación del controlador, comprueba que se haya instalado e inicializado correctamente.

Linux

Conéctate a la instancia de Linux y usa el comando nvidia-smi para verificar que el controlador se está ejecutando correctamente.

sudo nvidia-smi

El resultado debería ser similar al siguiente:

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

Si este comando falla, comprueba si hay GPUs conectadas a la VM. Para comprobar si hay dispositivos PCI de NVIDIA, ejecuta el siguiente comando:

sudo lspci | grep -i "nvidia"

Windows Server

Conéctate a la instancia de Windows Server y abre un terminal de PowerShell. A continuación, ejecuta el siguiente comando para verificar que el controlador se está ejecutando correctamente.

nvidia-smi

El resultado debería ser similar al siguiente:

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

Siguientes pasos