Docker

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.

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.

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.

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!

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.

Para configurar:

1. Abra seu arquivo ~/.bashrc no editor de texto preferido, se for no terminal pode usar o nano: nano ~/.bashrc

1. Cole as seguintes funções no final desse arquivo e salve o mesmo:

# 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"
}

Problemas com a instalação na máquina

Caso mesmo após estes passos o docker apresente problemas, pode ser necessário realizar a configuração de modo a executar ele manualmente direcionando para a sua pasta na /draft-XXX. Para isso é preciso é preciso:

1. Criar uma pasta na /draft-XXX do usuário que será usada pelo runtime do dockerd-rootless, executando:
   

mkdir /draft-XXX/<user>/.docker
mkdir /draft-XXX/<user>/.docker/run

1. Após isso é preciso criar as variaveis de ambiente no ~/.bashrc para XDG_RUNTIME_DIR e DOCKER_HOST.

export XDG_RUNTIME_DIR=/draft-XXX/<user>/.docker/run
export DOCKER_HOST=unix:///draft-XXX/<user>/.docker/run/docker.sock

A partir deste ponto, enquanto quiser executar o docker, é preciso deixar uma janela excutando o bash script dockerd-rootless.sh. Para isso abra uma janela do tmux ou byobu, e execute: bash dockerd-rootless.sh

Em outro terminal, é possível verificar a instalação executando docker run hello-world ou docker version.