Docker

From VeRLab Wiki
Revision as of 12:36, 9 April 2025 by Isaacreyes (talk | contribs) (→‎Docker abrindo janela no Ubuntu)
Jump to: navigation, search

Docker Rootless Mode

O modo disponível do Docker para os usuários da rede é o Docker Engine no modo Rootless, ou seja, apenas a versão em linha de comando e no modo de acesso non-root.

Em geral, funciona para todas as aplicações e pode-se ler mais informações no link Docker Rootless

Importante: para estas configurações é necessário que a máquina tenha um docker instalado com versão >= 20.10 (pode ser conferido com: docker version)

Este processo ainda se encontra em uma fase experimental e não está disponível em todas as máquinas. As máquinas disponíveis com docker até o momento são PROC1, PROC2, PROC5, PROC6, PROC7, EPONA, NYMERIA, DROGON, EVA, WALL-E, MAGRITTE e DALEK.


Configuração Docker rootless com Systemd (não é possível usar simultaneamente em outras máquinas, apenas em uma máquina da rede por vez)



A opção mais intuitiva para executar o Docker Rootless é gerenciando pelo systemctl --user. Porém tem a limitação de funcionar em apenas uma máquina da rede por vez, pois o arquivo que gerencia o systemctl do usuário é salvo na /home que é compartilhada em todas as máquinas, portanto apenas um processo docker rootless do usuário pode ser criado, mas em qualquer máquina da rede.

Pré-requisitos

Para utilizar docker rootless em uma máquina no laboratório é preciso que o usuário:

  • solicite à equipe de rede para criar uma pasta de rascunho no disco local como /draft-xxx/nome_do_usuario e dar permissão de leitura/escrita.
  • solicite à equipe de rede a instalação do docker na máquina.



Configuração

Feito estas etapas, para configurar o acesso na máquina é preciso seguir os seguintes passos para executar o docker rootless:

  1. Crie a pasta ~/.config/docker com o comando mkdir -p ~/.config/docker.
  2. Altere a pasta de armazenamento dos arquivos de cache do Docker para a pasta de rascunho /draft-xxx com:

echo '{"data-root":"/<path-em-disco-local>/<user>/docker-cache"}' | tee ~/.config/docker/daemon.json

Importante: Lembre-se de ajustar o <path-em-disco-local>/<user> para uma armazenamento de rascunho na máquina e alguma pasta do seu usuário (por exemplo, /draft-hdd/fulano).

Esses dois primeiros passos são específicos para as máquinas do VeRLab: por padrão o Docker guarda arquivos na /home do usuário, mas essa pasta é compartilhada em rede (por NFS ou MooseFS) e o Docker não dá suporte a isso.Aqui está um issue citando o problema

  1. Execute dockerd-rootless-setuptool.sh install.



Importante: Após terminar, o comando vai pedir que você altere seu .bashrc para adicionar uma linha semelhante a export DOCKER_HOST=unix:///run/user/<uid>/docker.sock (varia por usuário). Faça essa alteração antes de prosseguir copiando e colando o comando no terminal.

  1. Reinicie o Bash com exec bash.
  2. Ative a inicialização automática do Docker em seu usuário: systemctl --user enable --now docker ou manualmente: systemctl --user start docker


Com isso, a configuração está pronta!

Utilização

Comandos para confirmar se o Docker está funcionando:

  • Verificar status do docker daemon: systemctl --user status docker.service
  • Parar docker daemon: systemctl --user stop docker.service
  • Verificar configurações do Docker Rootless: docker version ou docker info
  • Baixar uma imagem teste e executá-la: docker run hello-world




Configuração Docker Rootless "Manual" para execução simultânea em várias máquinas da rede



Essa opção pode parecer menos intuitiva, pois o usuário precisará executar manualmente o daemon do docker rootless em um terminal e mantê-lo em execução para poder utilizar os comandos docker em outros terminais.

Isso pode ser facilmente feito utilizando os multiplexadores de terminal como tmux ou byobu.

Uma vez que parar a execução do docker daemon com ctrl+c ou fechar o terminal, isso vai "matar" a execução do docker rootless na máquina e parar todos seus containers de forma abrupta. Porém tem a flexibilidade de não precisar da pasta /home para armazenar as configurações do daemon, então com essa configuração é possível executar o docker rootless em várias máquinas simultaneamente!

Pré-requisitos

Para utilizar Docker Rootless em uma máquina no laboratório é preciso que o usuário:

  • solicite à equipe de rede para criar uma pasta de rascunho no disco local como /draft-xxx/nome_do_usuario e dar permissão de leitura/escrita.
  • solicite à equipe de rede a instalação do docker na máquina.


Configuração

  1. Abra seu arquivo ~/.bashrc no editor de texto preferido, se for no terminal pode usar o nano: nano ~/.bashrc
  2. Cole as seguintes funções no final desse arquivo e salve o mesmo:
Criar arquivo de configuração do tmux para habilitar o mouse e outras coisas úteis 
# Funções para adicionar no final do aquivo ~/.bashrc e usar docker rootless na rede VeRLab/JLab

# Função para criar pastas e configuração do docker rootless
function docker-rootless-create-dir(){
  MYUSER=$(whoami)
  # Cria environment variables para pastas
  echo -e "Exporting Environment Variables for Docker Rootless Create Folder..."
  export USER_BASE_DIR=/draft-hdd/${MYUSER}  && \
  export USER_DOCKER_DIR=$USER_BASE_DIR/docker-rootless  &&\
  echo -e "  USER_BASE_DIR=$USER_BASE_DIR\n  USER_DOCKER_DIR=$USER_DOCKER_DIR"
  # Verifica pasta do usuário usada pelo docker rootless
  if [ ! -w "$USER_BASE_DIR" ]; then
    echo -e "ERROR!\n  USER_BASE_DIR=$USER_BASE_DIR needs to be writable!"
    return 1
  fi
  # Cria pastas usadas pelo docker rootless
  mkdir --parents $USER_DOCKER_DIR
  export XDG_RUNTIME_DIR=$USER_DOCKER_DIR/.docker/run  && \
  export XDG_CONFIG_HOME=$USER_DOCKER_DIR/.config
  mkdir --parents $XDG_RUNTIME_DIR && \
  mkdir --parents $XDG_CONFIG_HOME/docker

  # Cria configuração do docker rootless
  echo "{\"data-root\":\"${USER_DOCKER_DIR}/docker-cache\"}" | tee $XDG_CONFIG_HOME/docker/daemon.json  && \
  nvidia-ctk runtime configure --runtime=docker --config=$XDG_CONFIG_HOME/docker/daemon.json

  echo -e "HOME=$HOME \nXDG_CONFIG_HOME=$XDG_CONFIG_HOME \nXDG_RUNTIME_DIR=$XDG_RUNTIME_DIR \nXDG_DATA_HOME=$XDG_DATA_HOME \nDOCKER_HOST=$DOCKER_HOST"  && \
  echo -e "cat $XDG_CONFIG_HOME/docker/daemon.json\n" && cat $XDG_CONFIG_HOME/docker/daemon.json
  echo -e "\nDocker Rootless Folders and Config Files Successfully Created!"
}

# Função para iniciar manualmente daemon do docker no modo rootless
function docker-rootless-daemon-run(){
  MYUSER=$(whoami)
  echo -e "Exporting Environment Variables for Docker Rootless Daemon..."
  export USER_DOCKER_DIR=/draft-hdd/${MYUSER}/docker-rootless  &&\
  export XDG_RUNTIME_DIR=$USER_DOCKER_DIR/.docker/run  && \
  export XDG_CONFIG_HOME=$USER_DOCKER_DIR/.config
  echo -e "  USER_DOCKER_DIR=$USER_DOCKER_DIR\n  XDG_RUNTIME_DIR=$XDG_RUNTIME_DIR\n  XDG_CONFIG_HOME=$XDG_CONFIG_HOME"
  # Verifica pasta do usuário usada pelo docker rootless
  if [ ! -w "$USER_DOCKER_DIR" ]; then
    echo -e "ERROR!\n  USER_DOCKER_DIR=$USER_DOCKER_DIR needs to be writable!"
    return 1
  fi
  echo -e "HOME=$HOME \nXDG_CONFIG_HOME=$XDG_CONFIG_HOME \nXDG_RUNTIME_DIR=$XDG_RUNTIME_DIR \nXDG_DATA_HOME=$XDG_DATA_HOME \nDOCKER_HOST=$DOCKER_HOST"  && \
  echo -e "cat $XDG_CONFIG_HOME/docker/daemon.json\n" && cat $XDG_CONFIG_HOME/docker/daemon.json
  # Start docker daemon
  echo -e "Starting Docker Rootless Daemon..."
  dockerd-rootless.sh
}

# Função para exportar variáveis de ambiente para executar comandos do docker rootless
function docker-rootless-export(){
  MYUSER=$(whoami)
  echo -e "Exporting Environment Variables for Docker Rootless Daemon..."
  export USER_DOCKER_DIR=/draft-hdd/${MYUSER}/docker-rootless  &&\
  export DOCKER_HOST=unix://$USER_DOCKER_DIR/.docker/run/docker.sock
  # Verifica pasta do usuário usada pelo docker rootless
  if [ ! -w "$USER_DOCKER_DIR" ]; then
    echo -e "ERROR!\n  USER_DOCKER_DIR=$USER_DOCKER_DIR needs to be writable!"
    return 1
  fi
  echo -e "  USER_DOCKER_DIR=$USER_DOCKER_DIR\n  DOCKER_HOST=$DOCKER_HOST"
}

Utilização

Uma vez que tiver as funções salvas em seu ~/.bashrc elas serão usadas para:

Como usar as funções docker-rootless-*
Função Descrição Utilização
docker-rootless-create-dir()

 Cria uma pasta para os arquivos do docker rootless daemon em "/draft-hdd/<usuario>/docker-rootless" Usada apenas a primeira vez na máquina. Se a pasta já foi criada anteriormente, não precisa mais usar essa função na mesma máquina.
docker-rootless-daemon-run()

 Executar o docker rootless daemon no terminal atual no tmux ou byobu Usada uma vez, para não haver outro terminal executando o docker rootless daemon na máquina.
docker-rootless-export()

 Exportar as variáveis de ambiente com o path correto do docker rootless daemon e do docker.sock (XDG_RUNTIME_DIR e DOCKER_HOST) Usada em todo novo terminal que abrir e quiser usar comando docker. Também pode ser colocada no final do ~/.bashrc para valer automaticamente.


Para utilizar o docker:

  1. Faça ssh numa das máquinas que tem o docker rootless instalado
  2. Se a pasta "/draft-hdd/<usuario>/docker-rootless" ainda não foi criada para seu usuário na máquina, execute: docker-rootless-create-dir
  3. No terminal abra o multiplexador de terminais, por exemplo, comando: tmux
  4. Dentro da janela 0 do tmux, execute o docker rootless daemon: docker-rootless-daemon-run
  5. Abra outra janela no tmux: ctrl+b c
  6. Na janela 1 faça o export do path para executar comandos docker: docker-rootless-export
  7. Na janela 1 execute os comandos docker: docker version ; docker compose version; docker info;





Limpar dados do docker rootless: cache, images e containers

Para desocupar espaço em disco das máquinas, caso não esteja utilizando o docker, mas deseja manter a estrutura de pastas do docker rootless daemon, pode-se apagar todas as imagens, cache e containers com:

docker system prune --all


Alguns links de referencia:


Docker abrindo janela no Ubuntu

exemplo com ROS
docker run --detach --privileged \
--volume /tmp/.X11-unix:/tmp/.X11-unix \
--volume /home:/home/host \
--device=/dev/bus/usb:/dev/bus/usb \
--volume /dev:/dev \
--runtime=nvidia \
--gpus 'all,"capabilities=utility,display,compute"' \
--env DISPLAY=$DISPLAY \
--network=host \
--name ros_noetic_gps_testing_container \
ros_noetic_gps_testing:latest \
tail -f /dev/null


Criar regra udev para dispositivo USB

Para descobrir o idProduct e idVendor do dispositivo, pode

udevadm info -a -n /dev/ttyACM0 <\code>


Criar o arquivo com a regra:

<code> sudo nano /etc/udev/rules.d/99-ublox-gps.rules

Adicionar essa linha no arquivo :

SUBSYSTEM=="tty", ATTRS{idVendor}=="1546", ATTRS{idProduct}=="01a9", MODE="0666", GROUP="dialout"

Se quiser criar um novo nome (link simbolico /dev/ublox) adicionar SYMLINK:

SUBSYSTEM=="tty", ATTRS{idVendor}=="2341", ATTRS{idProduct}=="0043", SYMLINK+="ublox", MODE="0666", GROUP="dialout"

Retrieved from "http://www.verlab.dcc.ufmg.br/mediawiki/index.php?title=Docker&oldid=1484"