--- title: "Cómo instalar CUDA Toolkit y cuDNN en Ubuntu 24.04" description: "Instala CUDA Toolkit y cuDNN desde el repositorio oficial de NVIDIA en Ubuntu 24.04, configura el PATH, compila un programa de prueba y gestiona versiones." category: "Infraestructura de IA y ML" language: es source: https://cubepath.com/es/docs/infraestructura-de-ia-y-ml/instalacion-y-configuracion-de-cuda-toolkit updated: 2026-09-25 --- # Cómo instalar CUDA Toolkit y cuDNN en Ubuntu 24.04 CUDA Toolkit es el conjunto de herramientas de NVIDIA para desarrollar y ejecutar código en la GPU: incluye el compilador `nvcc`, las bibliotecas de CUDA (cuBLAS, cuFFT, cuRAND, etc.) y las herramientas de depuración. En este tutorial instalarás CUDA Toolkit y cuDNN desde el repositorio oficial de NVIDIA en Ubuntu 24.04, configurarás las variables de entorno, compilarás un programa de prueba y verás cómo tener varias versiones de CUDA a la vez. ## Requisitos previos - Un servidor con Ubuntu 24.04 LTS y una GPU NVIDIA, con un usuario no root con privilegios `sudo`. - El driver de NVIDIA instalado y funcionando: `nvidia-smi` debe mostrar la GPU. Si todavía no lo tienes, instálalo primero con la guía de instalación de drivers NVIDIA en Ubuntu 24.04. - Unos 10 GB libres en disco para el toolkit completo. > Nota: si solo vas a usar PyTorch o TensorFlow instalados con `pip`, probablemente no necesites este tutorial. Los paquetes oficiales de ambos frameworks incluyen sus propias bibliotecas de CUDA y cuDNN y solo requieren el driver. CUDA Toolkit hace falta para compilar código CUDA propio, extensiones de PyTorch o proyectos como llama.cpp. ## Paso 1: Elegir la versión de CUDA Cada versión del driver admite hasta una versión concreta de CUDA. El toolkit que instales no puede ser más nuevo que lo que admite tu driver. Consulta ese límite con `nvidia-smi`: ```bash nvidia-smi | grep "CUDA Version" ``` ```output | NVIDIA-SMI 570.172.08 Driver Version: 570.172.08 CUDA Version: 12.8 | ``` En este ejemplo el driver admite hasta CUDA 12.8, así que puedes instalar 12.8 o cualquier 12.x anterior. Si el software que vas a usar exige una versión concreta, instala esa. Si no, usa la más alta que admita tu driver. Los ejemplos de esta guía usan CUDA 12.8. Sustituye `12-8` y `12.8` por tu versión en todos los comandos. ## Paso 2: Añadir el repositorio de NVIDIA NVIDIA publica un paquete `cuda-keyring` que instala la clave de firma y la definición del repositorio para Ubuntu 24.04: ```bash cd /tmp wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb sudo dpkg -i cuda-keyring_1.1-1_all.deb sudo apt update ``` Si tu servidor es ARM64 (por ejemplo, un Grace Hopper), cambia `x86_64` por `sbsa` en la URL. Comprueba que el repositorio está activo y qué versiones del toolkit ofrece: ```bash apt-cache search --names-only '^cuda-toolkit-[0-9]+-[0-9]+$' ``` ```output cuda-toolkit-12-6 - CUDA Toolkit 12.6 meta-package cuda-toolkit-12-8 - CUDA Toolkit 12.8 meta-package cuda-toolkit-12-9 - CUDA Toolkit 12.9 meta-package cuda-toolkit-13-0 - CUDA Toolkit 13.0 meta-package ``` ## Paso 3: Instalar CUDA Toolkit Instala el metapaquete de la versión elegida. También necesitas `build-essential`, ya que `nvcc` usa el compilador de C++ del sistema: ```bash sudo apt install build-essential cuda-toolkit-12-8 ``` > Importante: instala `cuda-toolkit-X-Y` y no los metapaquetes `cuda` o `cuda-X-Y`. Estos últimos incluyen también el driver del repositorio de NVIDIA, que puede sustituir o entrar en conflicto con el driver que ya tienes instalado. El toolkit se instala en `/usr/local/cuda-12.8`, y el sistema crea el enlace `/usr/local/cuda` apuntando a la versión activa. Compruébalo: ```bash ls -l /usr/local/ | grep cuda ``` ```output lrwxrwxrwx 1 root root 22 Sep 25 11:04 cuda -> /etc/alternatives/cuda lrwxrwxrwx 1 root root 25 Sep 25 11:04 cuda-12 -> /etc/alternatives/cuda-12 drwxr-xr-x 15 root root 4096 Sep 25 11:04 cuda-12.8 ``` ## Paso 4: Configurar el PATH Los paquetes de NVIDIA registran las bibliotecas en el enlazador dinámico mediante archivos en `/etc/ld.so.conf.d/`, así que no hace falta tocar `LD_LIBRARY_PATH`. Lo que sí falta es añadir los binarios, como `nvcc`, al `PATH`. Crea un script en `/etc/profile.d/` para que se aplique a todos los usuarios en cada inicio de sesión: ```bash sudo nano /etc/profile.d/cuda.sh ``` ```bash export PATH=/usr/local/cuda/bin${PATH:+:${PATH}} ``` Usar `/usr/local/cuda` en lugar de una versión concreta hace que el `PATH` siga funcionando cuando cambies de versión. Carga el script en la sesión actual y comprueba `nvcc`: ```bash source /etc/profile.d/cuda.sh nvcc --version ``` ```output nvcc: NVIDIA (R) Cuda compiler driver Copyright (c) 2005-2025 NVIDIA Corporation Built on Fri_Feb_21_20:23:50_PST_2025 Cuda compilation tools, release 12.8, V12.8.93 Build cuda_12.8.r12.8/compiler.35583870_0 ``` Verifica también que el enlazador encuentra las bibliotecas de CUDA: ```bash ldconfig -p | grep -E 'libcudart\.so|libcublas\.so' | head -n 2 ``` ```output libcudart.so.12 (libc6,x86-64) => /usr/local/cuda/targets/x86_64-linux/lib/libcudart.so.12 libcublas.so.12 (libc6,x86-64) => /usr/local/cuda/targets/x86_64-linux/lib/libcublas.so.12 ``` ## Paso 5: Compilar y ejecutar un programa de prueba `nvcc --version` solo confirma que el compilador está instalado. Para comprobar que el toolkit, el driver y la GPU funcionan juntos, compila un programa que sume dos vectores en la GPU y verifique el resultado. Crea un directorio de trabajo y el archivo fuente: ```bash mkdir -p ~/cuda-test && cd ~/cuda-test nano vector_add.cu ``` ```cpp #include #include __global__ void vectorAdd(const float *a, const float *b, float *c, int n) { int i = blockIdx.x * blockDim.x + threadIdx.x; if (i < n) c[i] = a[i] + b[i]; } int main() { const int n = 1 << 20; float *a, *b, *c; cudaMallocManaged(&a, n * sizeof(float)); cudaMallocManaged(&b, n * sizeof(float)); cudaMallocManaged(&c, n * sizeof(float)); for (int i = 0; i < n; i++) { a[i] = 1.0f; b[i] = 2.0f; } vectorAdd<<<(n + 255) / 256, 256>>>(a, b, c, n); cudaError_t err = cudaDeviceSynchronize(); if (err != cudaSuccess) { printf("Error de CUDA: %s\n", cudaGetErrorString(err)); return 1; } for (int i = 0; i < n; i++) { if (c[i] != 3.0f) { printf("Resultado incorrecto en %d\n", i); return 1; } } cudaDeviceProp prop; cudaGetDeviceProperties(&prop, 0); printf("OK: %d elementos sumados en %s\n", n, prop.name); cudaFree(a); cudaFree(b); cudaFree(c); return 0; } ``` Compila y ejecuta el programa: ```bash nvcc -o vector_add vector_add.cu ./vector_add ``` ```output OK: 1048576 elementos sumados en NVIDIA L40S ``` Si ves el nombre de tu GPU, CUDA funciona de extremo a extremo. ## Paso 6: Instalar cuDNN cuDNN es la biblioteca de NVIDIA con primitivas optimizadas para redes neuronales (convoluciones, normalización, atención). La necesitas si compilas frameworks de deep learning o usas software que enlaza contra la cuDNN del sistema. El repositorio que añadiste en el paso 2 también contiene cuDNN. Instala la versión 9 para CUDA 12: ```bash sudo apt install cudnn9-cuda-12 ``` Si usas CUDA 13, instala `cudnn9-cuda-13` en su lugar. Comprueba la versión instalada: ```bash dpkg -l | grep cudnn | awk '{print $2, $3}' ``` ```output cudnn9-cuda-12 9.13.0.50-1 libcudnn9-cuda-12 9.13.0.50-1 libcudnn9-dev-cuda-12 9.13.0.50-1 libcudnn9-headers-cuda-12 9.13.0.50-1 ``` ## Paso 7: Tener varias versiones de CUDA Algunos proyectos exigen una versión concreta de CUDA. Los paquetes de NVIDIA se instalan cada uno en su propio directorio, así que pueden convivir. Por ejemplo, para añadir CUDA 12.6: ```bash sudo apt install cuda-toolkit-12-6 ``` El enlace `/usr/local/cuda` lo gestiona el sistema de alternativas de Debian. Para cambiar la versión activa para todo el sistema, usa `update-alternatives` y elige la versión en el menú: ```bash sudo update-alternatives --config cuda ``` ```output There are 2 choices for the alternative cuda (providing /usr/local/cuda). Selection Path Priority Status ------------------------------------------------------------ * 0 /usr/local/cuda-12.8 128 auto mode 1 /usr/local/cuda-12.6 126 manual mode 2 /usr/local/cuda-12.8 128 manual mode Press to keep the current choice[*], or type selection number: ``` Si solo un proyecto necesita otra versión, es mejor no cambiar la global y seleccionar la versión en la shell de ese proyecto: ```bash export PATH=/usr/local/cuda-12.6/bin:$PATH nvcc --version | tail -n 2 ``` Muchos sistemas de compilación (CMake, las extensiones de PyTorch) también respetan la variable `CUDA_HOME`, que puedes apuntar a `/usr/local/cuda-12.6` en ese mismo entorno. ## Solución de problemas **`nvcc: command not found`.** El `PATH` no incluye `/usr/local/cuda/bin`. Cierra la sesión y vuelve a entrar, o ejecuta `source /etc/profile.d/cuda.sh`. Si usas un servicio de systemd, define el `PATH` en la propia unidad, porque no lee `/etc/profile.d/`. **`CUDA driver version is insufficient for CUDA runtime version`.** El toolkit es más nuevo que lo que admite el driver. Compara la línea `CUDA Version` de `nvidia-smi` con `nvcc --version` y actualiza el driver o instala un toolkit más antiguo. **`unsupported GNU version! gcc versions later than X are not supported!`.** Tu versión de GCC es más nueva que las que admite ese toolkit. Instala una versión soportada (por ejemplo, `sudo apt install g++-12`) y pásala a `nvcc` con `-ccbin g++-12`. **`apt` intenta instalar o actualizar paquetes del driver.** Has instalado `cuda` o `cuda-X-Y` en lugar de `cuda-toolkit-X-Y`, o un paquete que depende de ellos. Revisa con `apt-cache rdepends --installed` qué lo arrastra y reinstala solo el toolkit. ## Conclusión Tienes CUDA Toolkit y cuDNN instalados desde el repositorio oficial de NVIDIA, `nvcc` en el `PATH`, un programa de prueba ejecutándose en la GPU y un método para mantener varias versiones. Como siguientes pasos, puedes compilar tus propias extensiones de PyTorch, construir llama.cpp con soporte CUDA o instalar el NVIDIA Container Toolkit para ejecutar cargas de GPU en contenedores Docker.