🐳 Guía: Compilar código CUDA con nvcc en contenedores Docker

El uso de Docker con CUDA permite crear entornos aislados, reproducibles y listos para escalar aplicaciones que requieren procesamiento en GPU. NVIDIA proporciona imágenes oficiales que integran nvcc y librerías CUDA, facilitando mucho esta tarea.

A continuación, se detalla paso a paso cómo compilar código CUDA con nvcc dentro de un contenedor Docker utilizando imágenes oficiales de NVIDIA.

✅ Requisitos previos

• Docker instalado
  Descárgalo de: https://www.docker.com/products/docker-desktop
• NVIDIA Container Toolkit (nvidia-docker)
  Para acceder a la GPU desde Docker, instala:

# Para sistemas basados en Debian/Ubuntu
sudo apt update
sudo apt install -y nvidia-container-toolkit
sudo systemctl restart docker

Verifica que funciona correctamente:

docker run --rm --gpus all nvidia/cuda:12.3.2-base-ubuntu22.04 nvidia-smi

🧱 1. Crear el código fuente CUDA

Crea un archivo llamado vector_add.cu con un ejemplo simple de suma de vectores:

// vector_add.cu
#include <iostream>

__global__ void vector_add(float *a, float *b, float *c, int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) c[idx] = a[idx] + b[idx];
}

int main() {
    int N = 512;
    size_t size = N * sizeof(float);

    float *h_a = new float[N];
    float *h_b = new float[N];
    float *h_c = new float[N];

    for (int i = 0; i < N; ++i) {
        h_a[i] = i;
        h_b[i] = i * 2;
    }

    float *d_a, *d_b, *d_c;
    cudaMalloc(&d_a, size);
    cudaMalloc(&d_b, size);
    cudaMalloc(&d_c, size);

    cudaMemcpy(d_a, h_a, size, cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, h_b, size, cudaMemcpyHostToDevice);

    vector_add<<<(N + 255) / 256, 256>>>(d_a, d_b, d_c, N);
    cudaMemcpy(h_c, d_c, size, cudaMemcpyDeviceToHost);

    for (int i = 0; i < 5; ++i)
        std::cout << h_a[i] << " + " << h_b[i] << " = " << h_c[i] << std::endl;

    cudaFree(d_a); cudaFree(d_b); cudaFree(d_c);
    delete[] h_a; delete[] h_b; delete[] h_c;

    return 0;
}

🐳 2. Crear un Dockerfile para compilar con nvcc

# Dockerfile
FROM nvidia/cuda:12.3.2-devel-ubuntu22.04

RUN apt-get update && \
    apt-get install -y build-essential

COPY vector_add.cu /workspace/vector_add.cu
WORKDIR /workspace

RUN nvcc -o vector_add vector_add.cu
CMD ["./vector_add"]

🛠️ 3. Construir la imagen Docker

docker build -t cuda-vector-add .

🚀 4. Ejecutar el contenedor con acceso a la GPU

docker run --rm --gpus all cuda-vector-add

Deberías ver una salida como:

0 + 0 = 0
1 + 2 = 3
2 + 4 = 6
3 + 6 = 9
4 + 8 = 12

📦 Opción alternativa: Usar volúmenes y compilar dinámicamente

Si quieres mantener tu código fuera del contenedor para desarrollo ágil:

docker run --rm -it --gpus all -v $PWD:/workspace -w /workspace nvidia/cuda:12.3.2-devel-ubuntu22.04 bash

Y dentro del contenedor:

nvcc -o vector_add vector_add.cu
./vector_add

🧪 Bonus: Integración con VS Code

Puedes usar la extensión «Remote – Containers» en VS Code para compilar y depurar desde el entorno gráfico, usando este mismo Dockerfile como contenedor de desarrollo.

🧾 En resumen

Compilar y ejecutar código CUDA con nvcc dentro de Docker permite encapsular dependencias, mejorar la portabilidad entre entornos (cloud, CI, equipos locales) y mantener el entorno limpio. Esta técnica es especialmente útil para proyectos de inteligencia artificial, HPC o simulaciones científicas, donde las dependencias pueden ser complejas o conflictivas.