saymrwulf/onnxruntime
1
0
Fork 0
mirror of https://github.com/saymrwulf/onnxruntime.git synced 2026-05-17 21:10:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
onnxruntime/dockerfiles/Dockerfile.cuda

111 lines
4.1 KiB
Text
Raw Normal View History

Dockerfiles for TensorRT, CUDA, build from source (#922) * dockerfile updates for BYOC scenario * updates for 3 different build versions * updating to remove libopenblas, python3, python3-pip * Including LICENSE-IMAGE.txt for CUDA/TensorRT dockerfiles * remove unnecessary cmake files * fixing comment typo * optimizing dockerfile.source as per review suggestions (not working currently) * Optimizing dockerfiles with install_dependencies script * update dockerfile with --cmake_extra_defines version number * add &&\ for license copy lines * updates, adding miniconda to path, reincluded clearing the pycache * adding maintainer note * update readme instructions * update tensorrt versioning in dockerfile
2019-07-09 09:03:55 +00:00
# --------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
# --------------------------------------------------------------
[CUDA] Add CUDA_VERSION and CUDNN_VERSION etc. arguments to Dockerfile.cuda (#22351) ### Description * Add a few arguments CUDA_VERSION, CUDNN_VERSION, OS, GIT_COMMIT, GIT_BRANCH and ONNXRUNTIME_VERSION to the Dockerfile.cuda to allow for more flexibility in the build process. * Update README.md to include the new arguments and their usage. * Output labels to image so that it is easy to inspect the image. Available CUDA versions for ubuntu 24.04 can be found [here](https://hub.docker.com/r/nvidia/cuda/tags), and available CUDNN versions can be found [here](https://pypi.org/project/nvidia-cudnn-cu12/#history). Example command line to build docker image: ``` docker build -t onnxruntime-cuda --build-arg CUDA_VERSION=12.6.1 \ --build-arg CUDNN_VERSION=9.5.0.50 \ --build-arg GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD) \ --build-arg GIT_COMMIT=$(git rev-parse HEAD) \ --build-arg ONNXRUNTIME_VERSION=$(cat ../VERSION_NUMBER) \ -f Dockerfile.cuda .. ``` Example labels from `docker inspect onnxruntime-cuda`: ``` "Labels": { "CUDA_VERSION": "12.6.1", "CUDNN_VERSION": "9.5.0.50", "maintainer": "Changming Sun <chasun@microsoft.com>", "onnxruntime_git_branch": "main", "onnxruntime_git_commit": "bc84958dcef5c6017ae58085f55b669efd74f4a5", "onnxruntime_version": "1.20.0", "org.opencontainers.image.ref.name": "ubuntu", "org.opencontainers.image.version": "24.04" } ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/pull/22339 has hard-coded the cuda and cudnn versions. User might want to choose specified cuda and cudnn version during building docker image.
2024-10-09 19:06:33 +00:00
# Build onnxruntime-gpu python package with CUDA 12.x & CUDNN 9.x for python 3.12 in Ubuntu 24.04.
[CUDA] Update Dockerfile.cuda with cuda 12.5.1 and cudnn 9 (#21987) ### Description Previous image is based on cuda 12.1 and cudnn 8, which is out of date since we have moved to cudnn 9 since 1.19 release. (1) Upgrade base image to cuda 12.5.1 and cudnn 9. (2) Update CMAKE_CUDA_ARCHITECTURES from 52;60;61;70;75;86 to 61;70;75;80;86;90 to support A100 and H100 (3) Make the build faster: exclude unit test; use ninja etc. (4) upgrade some packages (like packaging etc) before building to avoid build error. ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/21792 https://github.com/microsoft/onnxruntime/issues/21532
2024-09-05 22:25:40 +00:00
# If memory is less than 64GB, you may change "--parallel" to "--parallel 4" to avoid out-of-memory error.
Dockerfiles for TensorRT, CUDA, build from source (#922) * dockerfile updates for BYOC scenario * updates for 3 different build versions * updating to remove libopenblas, python3, python3-pip * Including LICENSE-IMAGE.txt for CUDA/TensorRT dockerfiles * remove unnecessary cmake files * fixing comment typo * optimizing dockerfile.source as per review suggestions (not working currently) * Optimizing dockerfiles with install_dependencies script * update dockerfile with --cmake_extra_defines version number * add &&\ for license copy lines * updates, adding miniconda to path, reincluded clearing the pycache * adding maintainer note * update readme instructions * update tensorrt versioning in dockerfile
2019-07-09 09:03:55 +00:00
[CUDA] Add CUDA_VERSION and CUDNN_VERSION etc. arguments to Dockerfile.cuda (#22351) ### Description * Add a few arguments CUDA_VERSION, CUDNN_VERSION, OS, GIT_COMMIT, GIT_BRANCH and ONNXRUNTIME_VERSION to the Dockerfile.cuda to allow for more flexibility in the build process. * Update README.md to include the new arguments and their usage. * Output labels to image so that it is easy to inspect the image. Available CUDA versions for ubuntu 24.04 can be found [here](https://hub.docker.com/r/nvidia/cuda/tags), and available CUDNN versions can be found [here](https://pypi.org/project/nvidia-cudnn-cu12/#history). Example command line to build docker image: ``` docker build -t onnxruntime-cuda --build-arg CUDA_VERSION=12.6.1 \ --build-arg CUDNN_VERSION=9.5.0.50 \ --build-arg GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD) \ --build-arg GIT_COMMIT=$(git rev-parse HEAD) \ --build-arg ONNXRUNTIME_VERSION=$(cat ../VERSION_NUMBER) \ -f Dockerfile.cuda .. ``` Example labels from `docker inspect onnxruntime-cuda`: ``` "Labels": { "CUDA_VERSION": "12.6.1", "CUDNN_VERSION": "9.5.0.50", "maintainer": "Changming Sun <chasun@microsoft.com>", "onnxruntime_git_branch": "main", "onnxruntime_git_commit": "bc84958dcef5c6017ae58085f55b669efd74f4a5", "onnxruntime_version": "1.20.0", "org.opencontainers.image.ref.name": "ubuntu", "org.opencontainers.image.version": "24.04" } ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/pull/22339 has hard-coded the cuda and cudnn versions. User might want to choose specified cuda and cudnn version during building docker image.
2024-10-09 19:06:33 +00:00
ARG CUDA_VERSION=12.6.1
ARG CUDNN_VERSION=9.5.0.50
ARG OS=ubuntu24.04
[CUDA] Update Dockerfile.cuda with cuda 12.5.1 and cudnn 9 (#21987) ### Description Previous image is based on cuda 12.1 and cudnn 8, which is out of date since we have moved to cudnn 9 since 1.19 release. (1) Upgrade base image to cuda 12.5.1 and cudnn 9. (2) Update CMAKE_CUDA_ARCHITECTURES from 52;60;61;70;75;86 to 61;70;75;80;86;90 to support A100 and H100 (3) Make the build faster: exclude unit test; use ninja etc. (4) upgrade some packages (like packaging etc) before building to avoid build error. ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/21792 https://github.com/microsoft/onnxruntime/issues/21532
2024-09-05 22:25:40 +00:00
[CUDA] Add CUDA_VERSION and CUDNN_VERSION etc. arguments to Dockerfile.cuda (#22351) ### Description * Add a few arguments CUDA_VERSION, CUDNN_VERSION, OS, GIT_COMMIT, GIT_BRANCH and ONNXRUNTIME_VERSION to the Dockerfile.cuda to allow for more flexibility in the build process. * Update README.md to include the new arguments and their usage. * Output labels to image so that it is easy to inspect the image. Available CUDA versions for ubuntu 24.04 can be found [here](https://hub.docker.com/r/nvidia/cuda/tags), and available CUDNN versions can be found [here](https://pypi.org/project/nvidia-cudnn-cu12/#history). Example command line to build docker image: ``` docker build -t onnxruntime-cuda --build-arg CUDA_VERSION=12.6.1 \ --build-arg CUDNN_VERSION=9.5.0.50 \ --build-arg GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD) \ --build-arg GIT_COMMIT=$(git rev-parse HEAD) \ --build-arg ONNXRUNTIME_VERSION=$(cat ../VERSION_NUMBER) \ -f Dockerfile.cuda .. ``` Example labels from `docker inspect onnxruntime-cuda`: ``` "Labels": { "CUDA_VERSION": "12.6.1", "CUDNN_VERSION": "9.5.0.50", "maintainer": "Changming Sun <chasun@microsoft.com>", "onnxruntime_git_branch": "main", "onnxruntime_git_commit": "bc84958dcef5c6017ae58085f55b669efd74f4a5", "onnxruntime_version": "1.20.0", "org.opencontainers.image.ref.name": "ubuntu", "org.opencontainers.image.version": "24.04" } ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/pull/22339 has hard-coded the cuda and cudnn versions. User might want to choose specified cuda and cudnn version during building docker image.
2024-10-09 19:06:33 +00:00
FROM nvcr.io/nvidia/cuda:${CUDA_VERSION}-devel-${OS}
ARG CUDA_VERSION
ARG CUDNN_VERSION
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
ARG CMAKE_CUDA_ARCHITECTURES="61;70;75;80;86;90"
[CUDA] Update Dockerfile.cuda with cuda 12.5.1 and cudnn 9 (#21987) ### Description Previous image is based on cuda 12.1 and cudnn 8, which is out of date since we have moved to cudnn 9 since 1.19 release. (1) Upgrade base image to cuda 12.5.1 and cudnn 9. (2) Update CMAKE_CUDA_ARCHITECTURES from 52;60;61;70;75;86 to 61;70;75;80;86;90 to support A100 and H100 (3) Make the build faster: exclude unit test; use ninja etc. (4) upgrade some packages (like packaging etc) before building to avoid build error. ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/21792 https://github.com/microsoft/onnxruntime/issues/21532
2024-09-05 22:25:40 +00:00
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
ENV DEBIAN_FRONTEND=noninteractive
# Add source code to /code
Update dockerfiles (#5929) 1. Remove conda from the images. Because conda contains a file named /opt/miniconda/lib/libcrypto.so.1.0.0 which can't pass our security scan. Also, it will be easier for us to manage the third party usage registrations. 2. Remove openssh from the images. Because the official openssh package provided by Ubuntu can't pass our security scan. 3. Reduce the image size to 1/3 by using stages. Also, because it contains less packages, it will be less often needed to update. 4. Put the LICENSE-IMAGE.txt file in right place. It is missed in current images. You can see it was added to a temp folder "/code" but it got deleted afterwards. 5. Update the CPU docker image's base image to Ubuntu 18.04. The GPU one is already 18.04. It's better to keep them the same. 6. Remove the build arg ONNXRUNTIME_REPO/ONNXRUNTIME_BRANCH. Instead, the new one always uses the local source. I feel it can reduce confusion.
2020-11-25 23:38:22 +00:00
ADD . /code
Dockerfiles for TensorRT, CUDA, build from source (#922) * dockerfile updates for BYOC scenario * updates for 3 different build versions * updating to remove libopenblas, python3, python3-pip * Including LICENSE-IMAGE.txt for CUDA/TensorRT dockerfiles * remove unnecessary cmake files * fixing comment typo * optimizing dockerfile.source as per review suggestions (not working currently) * Optimizing dockerfiles with install_dependencies script * update dockerfile with --cmake_extra_defines version number * add &&\ for license copy lines * updates, adding miniconda to path, reincluded clearing the pycache * adding maintainer note * update readme instructions * update tensorrt versioning in dockerfile
2019-07-09 09:03:55 +00:00
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
ENV PATH=/usr/local/cuda/bin:${PATH}
# Install required packages
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates \
g++ \
gcc \
make \
git \
cmake \
wget \
ninja-build \
python3-pip \
python3.12-dev \
python3.12-venv \
&& rm -rf /var/lib/apt/lists/*
Update dockerfiles (#5929) 1. Remove conda from the images. Because conda contains a file named /opt/miniconda/lib/libcrypto.so.1.0.0 which can't pass our security scan. Also, it will be easier for us to manage the third party usage registrations. 2. Remove openssh from the images. Because the official openssh package provided by Ubuntu can't pass our security scan. 3. Reduce the image size to 1/3 by using stages. Also, because it contains less packages, it will be less often needed to update. 4. Put the LICENSE-IMAGE.txt file in right place. It is missed in current images. You can see it was added to a temp folder "/code" but it got deleted afterwards. 5. Update the CPU docker image's base image to Ubuntu 18.04. The GPU one is already 18.04. It's better to keep them the same. 6. Remove the build arg ONNXRUNTIME_REPO/ONNXRUNTIME_BRANCH. Instead, the new one always uses the local source. I feel it can reduce confusion.
2020-11-25 23:38:22 +00:00
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
# Install CUDNN 9.4.0.58 for building ONNX Runtime with CUDA.
[CUDA] Add CUDA_VERSION and CUDNN_VERSION etc. arguments to Dockerfile.cuda (#22351) ### Description * Add a few arguments CUDA_VERSION, CUDNN_VERSION, OS, GIT_COMMIT, GIT_BRANCH and ONNXRUNTIME_VERSION to the Dockerfile.cuda to allow for more flexibility in the build process. * Update README.md to include the new arguments and their usage. * Output labels to image so that it is easy to inspect the image. Available CUDA versions for ubuntu 24.04 can be found [here](https://hub.docker.com/r/nvidia/cuda/tags), and available CUDNN versions can be found [here](https://pypi.org/project/nvidia-cudnn-cu12/#history). Example command line to build docker image: ``` docker build -t onnxruntime-cuda --build-arg CUDA_VERSION=12.6.1 \ --build-arg CUDNN_VERSION=9.5.0.50 \ --build-arg GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD) \ --build-arg GIT_COMMIT=$(git rev-parse HEAD) \ --build-arg ONNXRUNTIME_VERSION=$(cat ../VERSION_NUMBER) \ -f Dockerfile.cuda .. ``` Example labels from `docker inspect onnxruntime-cuda`: ``` "Labels": { "CUDA_VERSION": "12.6.1", "CUDNN_VERSION": "9.5.0.50", "maintainer": "Changming Sun <chasun@microsoft.com>", "onnxruntime_git_branch": "main", "onnxruntime_git_commit": "bc84958dcef5c6017ae58085f55b669efd74f4a5", "onnxruntime_version": "1.20.0", "org.opencontainers.image.ref.name": "ubuntu", "org.opencontainers.image.version": "24.04" } ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/pull/22339 has hard-coded the cuda and cudnn versions. User might want to choose specified cuda and cudnn version during building docker image.
2024-10-09 19:06:33 +00:00
RUN cudnn_tar="cudnn-linux-x86_64-${CUDNN_VERSION}_cuda${CUDA_VERSION%%.*}-archive.tar.xz" \
&& wget "https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/${cudnn_tar}" \
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
&& mkdir -p /code/build/cudnn \
[CUDA] Add CUDA_VERSION and CUDNN_VERSION etc. arguments to Dockerfile.cuda (#22351) ### Description * Add a few arguments CUDA_VERSION, CUDNN_VERSION, OS, GIT_COMMIT, GIT_BRANCH and ONNXRUNTIME_VERSION to the Dockerfile.cuda to allow for more flexibility in the build process. * Update README.md to include the new arguments and their usage. * Output labels to image so that it is easy to inspect the image. Available CUDA versions for ubuntu 24.04 can be found [here](https://hub.docker.com/r/nvidia/cuda/tags), and available CUDNN versions can be found [here](https://pypi.org/project/nvidia-cudnn-cu12/#history). Example command line to build docker image: ``` docker build -t onnxruntime-cuda --build-arg CUDA_VERSION=12.6.1 \ --build-arg CUDNN_VERSION=9.5.0.50 \ --build-arg GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD) \ --build-arg GIT_COMMIT=$(git rev-parse HEAD) \ --build-arg ONNXRUNTIME_VERSION=$(cat ../VERSION_NUMBER) \ -f Dockerfile.cuda .. ``` Example labels from `docker inspect onnxruntime-cuda`: ``` "Labels": { "CUDA_VERSION": "12.6.1", "CUDNN_VERSION": "9.5.0.50", "maintainer": "Changming Sun <chasun@microsoft.com>", "onnxruntime_git_branch": "main", "onnxruntime_git_commit": "bc84958dcef5c6017ae58085f55b669efd74f4a5", "onnxruntime_version": "1.20.0", "org.opencontainers.image.ref.name": "ubuntu", "org.opencontainers.image.version": "24.04" } ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/pull/22339 has hard-coded the cuda and cudnn versions. User might want to choose specified cuda and cudnn version during building docker image.
2024-10-09 19:06:33 +00:00
&& tar -Jxvf ${cudnn_tar} -C /code/build/cudnn --strip=1 \
&& rm -f ${cudnn_tar}
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
# Create a virtual environment and install dependencies, then build ONNX Runtime with CUDA support.
[CUDA] Update Dockerfile.cuda with cuda 12.5.1 and cudnn 9 (#21987) ### Description Previous image is based on cuda 12.1 and cudnn 8, which is out of date since we have moved to cudnn 9 since 1.19 release. (1) Upgrade base image to cuda 12.5.1 and cudnn 9. (2) Update CMAKE_CUDA_ARCHITECTURES from 52;60;61;70;75;86 to 61;70;75;80;86;90 to support A100 and H100 (3) Make the build faster: exclude unit test; use ninja etc. (4) upgrade some packages (like packaging etc) before building to avoid build error. ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/21792 https://github.com/microsoft/onnxruntime/issues/21532
2024-09-05 22:25:40 +00:00
RUN cd /code \
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
&& python3 -m venv /code/env \
&& . /code/env/bin/activate \
&& pip install --upgrade psutil setuptools wheel packaging \
&& pip install -r tools/ci_build/github/linux/docker/inference/x86_64/python/cpu/scripts/requirements.txt \
&& python /code/tools/ci_build/build.py --build_dir /code/build/Linux \
--allow_running_as_root --skip_submodule_sync \
--use_cuda --cuda_home /usr/local/cuda \
--cudnn_home /code/build/cudnn \
--build_shared_lib --skip_tests \
--config Release --build_wheel --update --build --parallel \
--cmake_generator Ninja \
--cmake_extra_defines ONNXRUNTIME_VERSION=$(cat ./VERSION_NUMBER) "CMAKE_CUDA_ARCHITECTURES=${CMAKE_CUDA_ARCHITECTURES}" onnxruntime_BUILD_UNIT_TESTS=OFF
# Start second stage to copy the build artifacts
[CUDA] Add CUDA_VERSION and CUDNN_VERSION etc. arguments to Dockerfile.cuda (#22351) ### Description * Add a few arguments CUDA_VERSION, CUDNN_VERSION, OS, GIT_COMMIT, GIT_BRANCH and ONNXRUNTIME_VERSION to the Dockerfile.cuda to allow for more flexibility in the build process. * Update README.md to include the new arguments and their usage. * Output labels to image so that it is easy to inspect the image. Available CUDA versions for ubuntu 24.04 can be found [here](https://hub.docker.com/r/nvidia/cuda/tags), and available CUDNN versions can be found [here](https://pypi.org/project/nvidia-cudnn-cu12/#history). Example command line to build docker image: ``` docker build -t onnxruntime-cuda --build-arg CUDA_VERSION=12.6.1 \ --build-arg CUDNN_VERSION=9.5.0.50 \ --build-arg GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD) \ --build-arg GIT_COMMIT=$(git rev-parse HEAD) \ --build-arg ONNXRUNTIME_VERSION=$(cat ../VERSION_NUMBER) \ -f Dockerfile.cuda .. ``` Example labels from `docker inspect onnxruntime-cuda`: ``` "Labels": { "CUDA_VERSION": "12.6.1", "CUDNN_VERSION": "9.5.0.50", "maintainer": "Changming Sun <chasun@microsoft.com>", "onnxruntime_git_branch": "main", "onnxruntime_git_commit": "bc84958dcef5c6017ae58085f55b669efd74f4a5", "onnxruntime_version": "1.20.0", "org.opencontainers.image.ref.name": "ubuntu", "org.opencontainers.image.version": "24.04" } ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/pull/22339 has hard-coded the cuda and cudnn versions. User might want to choose specified cuda and cudnn version during building docker image.
2024-10-09 19:06:33 +00:00
FROM nvcr.io/nvidia/cuda:${CUDA_VERSION}-runtime-${OS}
ARG CUDA_VERSION
ARG CUDNN_VERSION
ARG GIT_COMMIT
ARG GIT_BRANCH
ARG ONNXRUNTIME_VERSION
# Make sure the required build arguments are set. See README.md for more information.
RUN test -n ${GIT_COMMIT:?}
RUN test -n ${GIT_BRANCH:?}
RUN test -n ${ONNXRUNTIME_VERSION:?}
LABEL CUDA_VERSION="${CUDA_VERSION}"
LABEL CUDNN_VERSION="${CUDNN_VERSION}"
LABEL maintainer="Changming Sun <chasun@microsoft.com>"
LABEL onnxruntime_version="${ONNXRUNTIME_VERSION}"
LABEL onnxruntime_git_branch="${GIT_BRANCH}"
LABEL onnxruntime_git_commit="${GIT_COMMIT}"
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
# Copy built wheel and license
COPY --from=0 /code/build/Linux/Release/dist /ort
Update dockerfiles (#5929) 1. Remove conda from the images. Because conda contains a file named /opt/miniconda/lib/libcrypto.so.1.0.0 which can't pass our security scan. Also, it will be easier for us to manage the third party usage registrations. 2. Remove openssh from the images. Because the official openssh package provided by Ubuntu can't pass our security scan. 3. Reduce the image size to 1/3 by using stages. Also, because it contains less packages, it will be less often needed to update. 4. Put the LICENSE-IMAGE.txt file in right place. It is missed in current images. You can see it was added to a temp folder "/code" but it got deleted afterwards. 5. Update the CPU docker image's base image to Ubuntu 18.04. The GPU one is already 18.04. It's better to keep them the same. 6. Remove the build arg ONNXRUNTIME_REPO/ONNXRUNTIME_BRANCH. Instead, the new one always uses the local source. I feel it can reduce confusion.
2020-11-25 23:38:22 +00:00
COPY --from=0 /code/dockerfiles/LICENSE-IMAGE.txt /code/LICENSE-IMAGE.txt
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
[CUDA] Add CUDA_VERSION and CUDNN_VERSION etc. arguments to Dockerfile.cuda (#22351) ### Description * Add a few arguments CUDA_VERSION, CUDNN_VERSION, OS, GIT_COMMIT, GIT_BRANCH and ONNXRUNTIME_VERSION to the Dockerfile.cuda to allow for more flexibility in the build process. * Update README.md to include the new arguments and their usage. * Output labels to image so that it is easy to inspect the image. Available CUDA versions for ubuntu 24.04 can be found [here](https://hub.docker.com/r/nvidia/cuda/tags), and available CUDNN versions can be found [here](https://pypi.org/project/nvidia-cudnn-cu12/#history). Example command line to build docker image: ``` docker build -t onnxruntime-cuda --build-arg CUDA_VERSION=12.6.1 \ --build-arg CUDNN_VERSION=9.5.0.50 \ --build-arg GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD) \ --build-arg GIT_COMMIT=$(git rev-parse HEAD) \ --build-arg ONNXRUNTIME_VERSION=$(cat ../VERSION_NUMBER) \ -f Dockerfile.cuda .. ``` Example labels from `docker inspect onnxruntime-cuda`: ``` "Labels": { "CUDA_VERSION": "12.6.1", "CUDNN_VERSION": "9.5.0.50", "maintainer": "Changming Sun <chasun@microsoft.com>", "onnxruntime_git_branch": "main", "onnxruntime_git_commit": "bc84958dcef5c6017ae58085f55b669efd74f4a5", "onnxruntime_version": "1.20.0", "org.opencontainers.image.ref.name": "ubuntu", "org.opencontainers.image.version": "24.04" } ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/pull/22339 has hard-coded the cuda and cudnn versions. User might want to choose specified cuda and cudnn version during building docker image.
2024-10-09 19:06:33 +00:00
# Set environment variables
ENV DEBIAN_FRONTEND=noninteractive
ENV CUDNN_VERSION=$CUDNN_VERSION
ENV ONNXRUNTIME_VERSION=$ONNXRUNTIME_VERSION
# CUDNN from nvidia-cudnn-cu12 python package is located in the site-packages directory of python virtual environment.
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
ENV LD_LIBRARY_PATH="/ort/env/lib/python3.12/site-packages/nvidia/cudnn/lib:/usr/local/cuda/lib64"
[CUDA] Add CUDA_VERSION and CUDNN_VERSION etc. arguments to Dockerfile.cuda (#22351) ### Description * Add a few arguments CUDA_VERSION, CUDNN_VERSION, OS, GIT_COMMIT, GIT_BRANCH and ONNXRUNTIME_VERSION to the Dockerfile.cuda to allow for more flexibility in the build process. * Update README.md to include the new arguments and their usage. * Output labels to image so that it is easy to inspect the image. Available CUDA versions for ubuntu 24.04 can be found [here](https://hub.docker.com/r/nvidia/cuda/tags), and available CUDNN versions can be found [here](https://pypi.org/project/nvidia-cudnn-cu12/#history). Example command line to build docker image: ``` docker build -t onnxruntime-cuda --build-arg CUDA_VERSION=12.6.1 \ --build-arg CUDNN_VERSION=9.5.0.50 \ --build-arg GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD) \ --build-arg GIT_COMMIT=$(git rev-parse HEAD) \ --build-arg ONNXRUNTIME_VERSION=$(cat ../VERSION_NUMBER) \ -f Dockerfile.cuda .. ``` Example labels from `docker inspect onnxruntime-cuda`: ``` "Labels": { "CUDA_VERSION": "12.6.1", "CUDNN_VERSION": "9.5.0.50", "maintainer": "Changming Sun <chasun@microsoft.com>", "onnxruntime_git_branch": "main", "onnxruntime_git_commit": "bc84958dcef5c6017ae58085f55b669efd74f4a5", "onnxruntime_version": "1.20.0", "org.opencontainers.image.ref.name": "ubuntu", "org.opencontainers.image.version": "24.04" } ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/pull/22339 has hard-coded the cuda and cudnn versions. User might want to choose specified cuda and cudnn version during building docker image.
2024-10-09 19:06:33 +00:00
# Install runtime dependencies
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
RUN apt-get update && apt-get install -y --no-install-recommends \
libstdc++6 \
ca-certificates \
python3-pip \
python3.12-venv \
&& python3 -m venv /ort/env \
&& . /ort/env/bin/activate \
&& pip install /ort/*.whl \
[CUDA] Add CUDA_VERSION and CUDNN_VERSION etc. arguments to Dockerfile.cuda (#22351) ### Description * Add a few arguments CUDA_VERSION, CUDNN_VERSION, OS, GIT_COMMIT, GIT_BRANCH and ONNXRUNTIME_VERSION to the Dockerfile.cuda to allow for more flexibility in the build process. * Update README.md to include the new arguments and their usage. * Output labels to image so that it is easy to inspect the image. Available CUDA versions for ubuntu 24.04 can be found [here](https://hub.docker.com/r/nvidia/cuda/tags), and available CUDNN versions can be found [here](https://pypi.org/project/nvidia-cudnn-cu12/#history). Example command line to build docker image: ``` docker build -t onnxruntime-cuda --build-arg CUDA_VERSION=12.6.1 \ --build-arg CUDNN_VERSION=9.5.0.50 \ --build-arg GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD) \ --build-arg GIT_COMMIT=$(git rev-parse HEAD) \ --build-arg ONNXRUNTIME_VERSION=$(cat ../VERSION_NUMBER) \ -f Dockerfile.cuda .. ``` Example labels from `docker inspect onnxruntime-cuda`: ``` "Labels": { "CUDA_VERSION": "12.6.1", "CUDNN_VERSION": "9.5.0.50", "maintainer": "Changming Sun <chasun@microsoft.com>", "onnxruntime_git_branch": "main", "onnxruntime_git_commit": "bc84958dcef5c6017ae58085f55b669efd74f4a5", "onnxruntime_version": "1.20.0", "org.opencontainers.image.ref.name": "ubuntu", "org.opencontainers.image.version": "24.04" } ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/pull/22339 has hard-coded the cuda and cudnn versions. User might want to choose specified cuda and cudnn version during building docker image.
2024-10-09 19:06:33 +00:00
&& pip install nvidia-cudnn-cu${CUDA_VERSION%%.*}==${CUDNN_VERSION} \
[CUDA] Update Docker to use Ubuntu 24.04, cuda 12.6, cudnn 9.4 and python 3.12 (#22339) ### Description Serve as example to build and run onnxruntime-gpu with latest software stack. To build docker image: ``` git clone https://github.com/microsoft/onnxruntime cd onnxruntime/dockerfiles docker build -t onnxruntime-cuda -f Dockerfile.cuda .. ``` To launch the docker image built from previous step (and mount the code directory to run a unit test below): ``` cd .. docker run --rm -it --gpus all -v $PWD:/code onnxruntime-cuda /bin/bash ``` Then run the following in docker image to verify that the cuda provider is good: ``` python /code/onnxruntime/test/python/onnxruntime_test_python_cudagraph.py ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/issues/22335
2024-10-08 16:54:46 +00:00
&& python -c 'import onnxruntime; print(onnxruntime.get_available_providers())' \
&& rm -rf /ort/*.whl \
&& rm -rf /var/lib/apt/lists/*
# Ensure the virtual environment is always activated when running commands in the container.
RUN echo ". /ort/env/bin/activate" >> ~/.bashrc
[CUDA] Add CUDA_VERSION and CUDNN_VERSION etc. arguments to Dockerfile.cuda (#22351) ### Description * Add a few arguments CUDA_VERSION, CUDNN_VERSION, OS, GIT_COMMIT, GIT_BRANCH and ONNXRUNTIME_VERSION to the Dockerfile.cuda to allow for more flexibility in the build process. * Update README.md to include the new arguments and their usage. * Output labels to image so that it is easy to inspect the image. Available CUDA versions for ubuntu 24.04 can be found [here](https://hub.docker.com/r/nvidia/cuda/tags), and available CUDNN versions can be found [here](https://pypi.org/project/nvidia-cudnn-cu12/#history). Example command line to build docker image: ``` docker build -t onnxruntime-cuda --build-arg CUDA_VERSION=12.6.1 \ --build-arg CUDNN_VERSION=9.5.0.50 \ --build-arg GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD) \ --build-arg GIT_COMMIT=$(git rev-parse HEAD) \ --build-arg ONNXRUNTIME_VERSION=$(cat ../VERSION_NUMBER) \ -f Dockerfile.cuda .. ``` Example labels from `docker inspect onnxruntime-cuda`: ``` "Labels": { "CUDA_VERSION": "12.6.1", "CUDNN_VERSION": "9.5.0.50", "maintainer": "Changming Sun <chasun@microsoft.com>", "onnxruntime_git_branch": "main", "onnxruntime_git_commit": "bc84958dcef5c6017ae58085f55b669efd74f4a5", "onnxruntime_version": "1.20.0", "org.opencontainers.image.ref.name": "ubuntu", "org.opencontainers.image.version": "24.04" } ``` ### Motivation and Context https://github.com/microsoft/onnxruntime/pull/22339 has hard-coded the cuda and cudnn versions. User might want to choose specified cuda and cudnn version during building docker image.
2024-10-09 19:06:33 +00:00
# Set the default command to start an interactive bash shell
CMD [ "/bin/bash" ]
Reference in a new issue Copy permalink