Enabling NVIDIA Runtime in Docker

Oct 13, 2025 by talynt.org 140 views

Introduction

In this article, we will explore a Dockerfile designed for deep learning and computer vision tasks. The Dockerfile is optimized for NVIDIA GPUs and includes popular libraries such as PyTorch, OpenCV, and scikit-image. We will also cover the necessary steps to enable the NVIDIA runtime in Docker and build the container.

Dockerfile Content

The Dockerfile is as follows:

FROM nvidia/cuda:11.8.0-cudnn8-devel-ubuntu18.04

ENV DEBIAN_FRONTEND noninteractive

# Install basic dependencies
RUN apt-get update && apt-get install -y \
    curl \
    build-essential \
    git \
    software-properties-common \
    ffmpeg \
    libsm6 \
    libxext6 \
    libgl1 \
    ninja-build \
    unzip

# This step must be completed before setting a different python (3.8) as system default
RUN add-apt-repository ppa:ubuntu-toolchain-r/test
RUN apt-get update && apt-get install -y gcc-11 g++-11
RUN update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 90 \
    --slave /usr/bin/g++ g++ /usr/bin/g++-11
RUN update-alternatives --config gcc


# Add deadsnakes PPA and install Python 3.8
RUN add-apt-repository ppa:deadsnakes/ppa && \
    apt-get update && \
    apt-get install -y python3.8 python3.8-dev python3.8-venv python3.8-distutils

# Make Python 3.8 the default
RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.8 1

# Install UV
COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/

# Install PyTorch with CUDA support using Python 3.8
RUN uv pip install --python python3.8 torch==2.1.0 --index-url https://download.pytorch.org/whl/cu118 --system

# Install other dependencies
RUN uv pip install --python python3.8 \
    opencv-python==4.8.1.78 \
    trimesh==3.23.5 \
    open3d==0.17 \
    pyvista==0.42.3 \
    scipy==1.10.1 \
    scikit-image==0.21.0 \
    pyhocon==0.3.59 \
    pyexr==0.3.10 \
    tensorboard==2.14.0 \
    icecream==2.1.3 \
    PyMCubes==0.1.4 \
    pyembree==0.2.11 \
    --system

# install tcnn, set TCNN_CUDA_ARCHITECTURES to your compute platform. 
# Your compute arch can be obtained by the following command
# unfortunately - I have not found a way to automatically find this during the docker build stage
# nvidia-smi --query-gpu=compute_cap --format=csv | tail -1 | sed "s#\.##g"

RUN PATH="/usr/local/cuda/bin:${PATH}" \
    LIBRARY_PATH="/usr/local/cuda/lib64/stubs:${LIBRARY_PATH}" \
    TCNN_CUDA_ARCHITECTURES="86" \
    CXXFLAGS="-std=c++17" \
    uv pip install --no-build-isolation --python python3.8 git+https://github.com/NVlabs/tiny-cuda-nn/@2ec562e853e6f482b5d09168705205f46358fb39#subdirectory=bindings/torch  --system

# Install nerfacc and other dependencies
# Note: This assumes the directory will be available in the Docker context
RUN git clone https://github.com/CyberAgentAILab/SuperNormal.git /supernormal
WORKDIR /supernormal

RUN uv pip install --upgrade pip setuptools wheel --system
RUN PATH="/usr/local/cuda/bin:${PATH}" \
    LIBRARY_PATH="/usr/local/cuda/lib64/stubs:${LIBRARY_PATH}" \
    uv pip install --python python3.8 \
    # --config-settings build-backend=setuptools.build_meta \
    --no-build-isolation -e ./third_parties/nerfacc-0.3.5/nerfacc-0.3.5/ --system

Enabling NVIDIA Runtime in Docker

To enable the NVIDIA runtime in Docker, you need to follow these steps:

Install nvidia-container-runtime: Run the following command to install the NVIDIA container runtime:

sudo apt-get install nvidia-container-runtime

2. **Edit the /etc/docker/daemon.json file**: Create or edit the `/etc/docker/daemon.json` file and add the following content:
   ```json
{
    "runtimes": {
        "nvidia": {
            "path": "/usr/bin/nvidia-container-runtime",
            "runtimeArgs": []
         } 
    },
    "default-runtime": "nvidia" 
}

Restart the Docker daemon: Run the following command to restart the Docker daemon:

sudo systemctl restart docker


**Building the Container**
---------------------------

Once you have enabled the NVIDIA runtime in Docker, you can build the container using the following command:
```bash
DOCKER_BUILDKIT=0 docker build . --tag supernormal

Connecting to the Container in VSCode

To connect to the container in VSCode, you need to create a devcontainer.json file in the root of your project. The file should contain the following content:

{
  "name": "CUDA",
  "image": "supernormal",

  "runArgs": [
    "--gpus=all"
  ],
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-python.python",
        "ms-vscode.cpptools",
        "ms-python.vscode-pylance"
      ]
    }
  },
  "workspaceMount": "source=${localWorkspaceFolder},target=/workspace,type=bind",
  "workspaceFolder": "/workspace"

}

This will allow you to connect to the container in VSCode and start working on your deep learning and computer vision tasks.

Conclusion

Q: What is the purpose of the Dockerfile?

A: The Dockerfile is designed to create a containerized environment for deep learning and computer vision tasks. It includes popular libraries such as PyTorch, OpenCV, and scikit-image, making it an ideal choice for researchers and developers working on these tasks.

Q: What are the system requirements for running the Dockerfile?

A: The Dockerfile requires a system with an NVIDIA GPU to run efficiently. Additionally, the system should have Docker installed and configured to use the NVIDIA runtime.

Q: How do I enable the NVIDIA runtime in Docker?

A: To enable the NVIDIA runtime in Docker, you need to install the nvidia-container-runtime package and edit the /etc/docker/daemon.json file to include the NVIDIA runtime configuration. Finally, restart the Docker daemon to apply the changes.

Q: What is the `devcontainer.json` file, and how do I use it?

A: The devcontainer.json file is a configuration file used to create a development container in VSCode. It allows you to connect to the container and start working on your deep learning and computer vision projects. To use it, create a new file named devcontainer.json in the root of your project and add the necessary configuration.

Q: Can I customize the Dockerfile to suit my specific needs?

A: Yes, you can customize the Dockerfile to suit your specific needs. The Dockerfile is designed to be flexible and can be modified to include additional libraries or dependencies.

Q: How do I build the container using the Dockerfile?

A: To build the container using the Dockerfile, navigate to the directory containing the Dockerfile and run the following command:

DOCKER_BUILDKIT=0 docker build . --tag supernormal

This will create a container with the name supernormal based on the Dockerfile.

Q: Can I use the container in a production environment?

A: Yes, you can use the container in a production environment. However, you may need to modify the Dockerfile to include additional security features and optimize the container for production use.

Q: How do I troubleshoot issues with the Dockerfile or container?

A: To troubleshoot issues with the Dockerfile or container, you can use the Docker logs to identify any errors or issues. Additionally, you can use tools such as docker inspect to inspect the container and identify any issues.

Q: Can I use the Dockerfile with other deep learning frameworks?

A: Yes, you can use the Dockerfile with other deep learning frameworks such as TensorFlow or Keras. However, you may need to modify the Dockerfile to include the necessary dependencies and libraries for the specific framework.

Q: How do I contribute to the Dockerfile or provide feedback?

A: To contribute to the Dockerfile or provide feedback, you can submit a pull request to the GitHub repository containing the Dockerfile. Additionally, you can provide feedback through the comments section of this article.