Estou procurando uma maneira de usar a GPU de dentro de um contêiner de docker.

O contêiner executará código arbitrário, portanto, não quero usar o modo privilegiado.

Alguma dica?

De pesquisas anteriores, entendi que run -ve / ou o LXC cgroupera o caminho a seguir, mas não sei ao certo como fazer isso exatamente

A resposta de Regan é ótima, mas está um pouco desatualizada, pois a maneira correta de fazer isso é evitar o contexto de execução lxc, pois o Docker descartou o LXC como o contexto de execução padrão no docker 0.9.

Em vez disso, é melhor falar ao docker sobre os dispositivos da nvidia por meio do sinalizador --device e usar o contexto de execução nativo em vez do lxc.

Meio Ambiente

Estas instruções foram testadas no seguinte ambiente:

• Ubuntu 14.04
• CUDA 6.5
• Instância da AWS GPU.

Instale o driver nvidia e cuda no seu host

Consulte CUDA 6.5 na instância da AWS GPU executando o Ubuntu 14.04 para obter a configuração da máquina host.

Instalar o Docker

$ sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9
$ sudo sh -c "echo deb https://get.docker.com/ubuntu docker main > /etc/apt/sources.list.d/docker.list"
$ sudo apt-get update && sudo apt-get install lxc-docker

Encontre seus dispositivos nvidia

ls -la /dev | grep nvidia

crw-rw-rw-  1 root root    195,   0 Oct 25 19:37 nvidia0 
crw-rw-rw-  1 root root    195, 255 Oct 25 19:37 nvidiactl
crw-rw-rw-  1 root root    251,   0 Oct 25 19:37 nvidia-uvm

Execute o contêiner do Docker com o driver da nvidia pré-instalado

Criei uma imagem do docker com os drivers cuda pré-instalados. O dockerfile está disponível no dockerhub se você quiser saber como essa imagem foi criada.

Você deseja personalizar este comando para corresponder aos seus dispositivos nvidia. Aqui está o que funcionou para mim:

 $ sudo docker run -ti --device /dev/nvidia0:/dev/nvidia0 --device /dev/nvidiactl:/dev/nvidiactl --device /dev/nvidia-uvm:/dev/nvidia-uvm tleyden5iwx/ubuntu-cuda /bin/bash

Verifique se o CUDA está instalado corretamente

Isso deve ser executado de dentro do contêiner do docker que você acabou de lançar.

Instale amostras CUDA:

$ cd /opt/nvidia_installers
$ ./cuda-samples-linux-6.5.14-18745345.run -noprompt -cudaprefix=/usr/local/cuda-6.5/

Exemplo de build deviceQuery:

$ cd /usr/local/cuda/samples/1_Utilities/deviceQuery
$ make
$ ./deviceQuery   

Se tudo funcionou, você deverá ver a seguinte saída:

deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 6.5, CUDA Runtime Version = 6.5, NumDevs =    1, Device0 = GRID K520
Result = PASS

Escrever uma resposta atualizada, pois a maioria das respostas já existentes está obsoleta a partir de agora.

Versões anteriores ao que Docker 19.03costumava exigir nvidia-docker2e o --runtime=nvidiasinalizador.

Desde então Docker 19.03, você precisa instalar o nvidia-container-toolkitpacote e depois usar o --gpus allsinalizador.

Então, aqui estão o básico,

Instalação do pacote

Instale o nvidia-container-toolkitpacote de acordo com a documentação oficial no Github .

Para sistemas operacionais baseados em Redhat, execute o seguinte conjunto de comandos:

$ distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
$ curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.repo | sudo tee /etc/yum.repos.d/nvidia-docker.repo

$ sudo yum install -y nvidia-container-toolkit
$ sudo systemctl restart docker

Para sistemas operacionais baseados em Debian, execute o seguinte conjunto de comandos:

# Add the package repositories
$ distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
$ curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
$ curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

$ sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
$ sudo systemctl restart docker

Executando a janela de encaixe com suporte à GPU

docker run --name my_all_gpu_container --gpus all -t nvidia/cuda

Observe que o sinalizador --gpus allé usado para atribuir todos os gpus disponíveis ao contêiner do docker.

Para atribuir gpu específica ao contêiner do docker (no caso de várias GPUs disponíveis em sua máquina)

docker run --name my_first_gpu_container --gpus device=0 nvidia/cuda

Ou

docker run --name my_first_gpu_container --gpus '"device=0"' nvidia/cuda

Ok, finalmente consegui fazê-lo sem usar o modo --privileged.

Estou executando no servidor ubuntu 14.04 e estou usando o ultimo cuda (6.0.37 para linux 13.04 64 bits).

Preparação

Instale o driver da nvidia e o cuda no seu host. (pode ser um pouco complicado, então eu sugiro que você siga este guia /ubuntu/451672/installing-and-testing-cuda-in-ubuntu-14-04 )

ATENÇÃO: É realmente importante que você mantenha os arquivos usados ​​para a instalação do host cuda

Faça o Docker Daemon executar usando lxc

Precisamos executar o docker daemon usando o driver lxc para poder modificar a configuração e conceder ao contêiner acesso ao dispositivo.

Utilização única:

sudo service docker stop
sudo docker -d -e lxc

Configuração permanente Modifique seu arquivo de configuração do docker localizado em / etc / default / docker Altere a linha DOCKER_OPTS adicionando '-e lxc' Aqui está minha linha após a modificação

DOCKER_OPTS="--dns 8.8.8.8 --dns 8.8.4.4 -e lxc"

Em seguida, reinicie o daemon usando

sudo service docker restart

Como verificar se o daemon usa efetivamente o driver lxc?

docker info

A linha do Driver de Execução deve ficar assim:

Execution Driver: lxc-1.0.5

Crie sua imagem com os drivers NVIDIA e CUDA.

Aqui está um Dockerfile básico para criar uma imagem compatível com CUDA.

FROM ubuntu:14.04
MAINTAINER Regan <http://stackoverflow.com/questions/25185405/using-gpu-from-a-docker-container>

RUN apt-get update && apt-get install -y build-essential
RUN apt-get --purge remove -y nvidia*

ADD ./Downloads/nvidia_installers /tmp/nvidia                             > Get the install files you used to install CUDA and the NVIDIA drivers on your host
RUN /tmp/nvidia/NVIDIA-Linux-x86_64-331.62.run -s -N --no-kernel-module   > Install the driver.
RUN rm -rf /tmp/selfgz7                                                   > For some reason the driver installer left temp files when used during a docker build (i don't have any explanation why) and the CUDA installer will fail if there still there so we delete them.
RUN /tmp/nvidia/cuda-linux64-rel-6.0.37-18176142.run -noprompt            > CUDA driver installer.
RUN /tmp/nvidia/cuda-samples-linux-6.0.37-18176142.run -noprompt -cudaprefix=/usr/local/cuda-6.0   > CUDA samples comment if you don't want them.
RUN export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64         > Add CUDA library into your PATH
RUN touch /etc/ld.so.conf.d/cuda.conf                                     > Update the ld.so.conf.d directory
RUN rm -rf /temp/*  > Delete installer files.

Execute sua imagem.

Primeiro, você precisa identificar seu número principal associado ao seu dispositivo. A maneira mais fácil é executar o seguinte comando:

ls -la /dev | grep nvidia

Se o resultado estiver em branco, o lançamento de uma das amostras no host deve fazer o truque. O resultado deve ser assim. Como você pode ver, há um conjunto de 2 números entre o grupo e a data. Esses 2 números são chamados de números maiores e menores (escritos nessa ordem) e projetam um dispositivo. Usaremos apenas os principais números por conveniência.

Por que ativamos o driver lxc? Para usar a opção lxc conf que nos permite permitir que nosso contêiner acesse esses dispositivos. A opção é: (eu recomendo usar * para o número menor, pois isso reduz o tamanho do comando executar)

--lxc-conf = 'lxc.cgroup.devices.allow = c [número principal]: [número menor ou *] rwm'

Então, se eu quiser iniciar um contêiner (supondo que o nome da imagem seja cuda).

docker run -ti --lxc-conf='lxc.cgroup.devices.allow = c 195:* rwm' --lxc-conf='lxc.cgroup.devices.allow = c 243:* rwm' cuda

Acabamos de lançar um repositório experimental do GitHub, que deve facilitar o processo de uso de GPUs NVIDIA dentro de contêineres do Docker.

Os aprimoramentos recentes da NVIDIA produziram uma maneira muito mais robusta de fazer isso.

Essencialmente, eles encontraram uma maneira de evitar a necessidade de instalar o driver CUDA / GPU dentro dos contêineres e combiná-lo com o módulo do kernel do host.

Em vez disso, os drivers estão no host e os contêineres não precisam deles. Ele requer um docker-cli modificado no momento.

Isso é ótimo, porque agora os contêineres são muito mais portáteis.

Um teste rápido no Ubuntu:

# Install nvidia-docker and nvidia-docker-plugin
wget -P /tmp https://github.com/NVIDIA/nvidia-docker/releases/download/v1.0.1/nvidia-docker_1.0.1-1_amd64.deb
sudo dpkg -i /tmp/nvidia-docker*.deb && rm /tmp/nvidia-docker*.deb

# Test nvidia-smi
nvidia-docker run --rm nvidia/cuda nvidia-smi

Para obter mais detalhes, consulte: Contêiner do Docker ativado por GPU e: https://github.com/NVIDIA/nvidia-docker

Atualizado para cuda-8.0 no ubuntu 16.04

• Instale o docker https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-16-04

• Crie a seguinte imagem que inclui os drivers da nvidia e o kit de ferramentas cuda

Dockerfile

FROM ubuntu:16.04
MAINTAINER Jonathan Kosgei <jonathan@saharacluster.com>

# A docker container with the Nvidia kernel module and CUDA drivers installed

ENV CUDA_RUN https://developer.nvidia.com/compute/cuda/8.0/prod/local_installers/cuda_8.0.44_linux-run

RUN apt-get update && apt-get install -q -y \
  wget \
  module-init-tools \
  build-essential 

RUN cd /opt && \
  wget $CUDA_RUN && \
  chmod +x cuda_8.0.44_linux-run && \
  mkdir nvidia_installers && \
  ./cuda_8.0.44_linux-run -extract=`pwd`/nvidia_installers && \
  cd nvidia_installers && \
  ./NVIDIA-Linux-x86_64-367.48.run -s -N --no-kernel-module

RUN cd /opt/nvidia_installers && \
  ./cuda-linux64-rel-8.0.44-21122537.run -noprompt

# Ensure the CUDA libs and binaries are in the correct environment variables
ENV LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-8.0/lib64
ENV PATH=$PATH:/usr/local/cuda-8.0/bin

RUN cd /opt/nvidia_installers &&\
    ./cuda-samples-linux-8.0.44-21122537.run -noprompt -cudaprefix=/usr/local/cuda-8.0 &&\
    cd /usr/local/cuda/samples/1_Utilities/deviceQuery &&\ 
    make

WORKDIR /usr/local/cuda/samples/1_Utilities/deviceQuery

3. Execute seu contêiner

sudo docker run -ti --device /dev/nvidia0:/dev/nvidia0 --device /dev/nvidiactl:/dev/nvidiactl --device /dev/nvidia-uvm:/dev/nvidia-uvm <built-image> ./deviceQuery

Você deve ver uma saída semelhante a:

deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 8.0, CUDA Runtime Version = 8.0, NumDevs = 1, Device0 = GRID K520 Result = PASS

Para usar a GPU do contêiner do docker, em vez de usar o Docker nativo, use o Nvidia-docker. Para instalar a docker Nvidia, use os seguintes comandos

curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey |  sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/ubuntu16.04/amd64/nvidia-
docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
sudo apt-get update
sudo apt-get install -y nvidia-docker
sudo pkill -SIGHUP dockerd # Restart Docker Engine
sudo nvidia-docker run --rm nvidia/cuda nvidia-smi # finally run nvidia-smi in the same container

Use o x11docker by mviereck:

https://github.com/mviereck/x11docker#hardware-acceleration diz

Aceleraçao do hardware

A aceleração de hardware para o OpenGL é possível com a opção -g, --gpu.

Isso funcionará imediatamente na maioria dos casos, com drivers de código aberto no host. Caso contrário, dê uma olhada no wiki: dependências de recursos. Os drivers NVIDIA de código fechado precisam de alguma configuração e suportam menos opções de servidor x11docker X.

Este script é realmente conveniente, pois lida com toda a configuração. A execução de uma imagem do docker no X com gpu é tão simples quanto

x11docker --gpu imagename