Explorando o sistema de arquivos do contêiner do Docker

Percebi com o docker que preciso entender o que está acontecendo dentro de um contêiner ou quais arquivos existem nele. Um exemplo é o download de imagens do índice da janela de encaixe - você não tem idéia do que a imagem contém, por isso é impossível iniciar o aplicativo.

O que seria ideal é ser capaz de ssh neles ou equivalente. Existe uma ferramenta para fazer isso ou minha conceituação de docker está errada ao pensar que eu deveria ser capaz de fazer isso.

ATUALIZAÇÃO
Método mais fácil: Usando o docker exec

O Docker versão 1.3 ou mais recente suporta o comando execque se comporta de maneira semelhante nsenter. Este comando pode executar um novo processo no contêiner já em execução (o contêiner já deve ter o processo PID 1 em execução). Você pode executar /bin/bashpara explorar o estado do contêiner:

docker exec -t -i mycontainer /bin/bash

consulte a documentação da linha de comandos do Docker

Método alternativo 1
Instantâneo

Você pode avaliar o sistema de arquivos do contêiner desta maneira:

# find ID of your running container:
docker ps

# create image (snapshot) from container filesystem
docker commit 12345678904b5 mysnapshot

# explore this filesystem using bash (for example)
docker run -t -i mysnapshot /bin/bash

Dessa forma, você pode avaliar o sistema de arquivos do contêiner em execução no momento preciso. O contêiner ainda está em execução, nenhuma alteração futura está incluída.

Mais tarde, você pode excluir o instantâneo usando (o sistema de arquivos do contêiner em execução não é afetado!):

docker rmi mysnapshot

Método alternativo 2
ssh

Se você precisar de acesso contínuo, poderá instalar o sshd no seu contêiner e executar o daemon sshd:

 docker run -d -p 22 mysnapshot /usr/sbin/sshd -D

 # you need to find out which port to connect:
 docker ps

Dessa forma, você pode executar seu aplicativo usando ssh (conecte e execute o que quiser).

UPDATE: Método alternativo 3
nsenter

Use nsenter, consulte https://web.archive.org/web/20160305150559/http://blog.docker.com/2014/06/why-you-dont-need-to-run-sshd-in-docker/

A versão curta é: com o nsenter, você pode obter um shell em um contêiner existente, mesmo que esse contêiner não execute SSH ou qualquer tipo de daemon de finalidade especial

ATUALIZAÇÃO: EXPLORANDO!

Este comando deve permitir que você explore um contêiner de estivador em execução :

docker exec -it name-of-container bash

O equivalente para isso na janela de encaixe-composição seria:

docker-compose exec web bash

(web é o nome do serviço nesse caso e tem tty por padrão.)

Quando estiver dentro, faça:

ls -lsa

ou qualquer outro comando bash como:

cd ..

Este comando deve permitir que você explore uma imagem da janela de encaixe :

docker run --rm -it --entrypoint=/bin/bash name-of-image

uma vez dentro faça:

ls -lsa

ou qualquer outro comando bash como:

cd ..

A -itsignifica interativo ... e tty.

Este comando deve permitir que você inspecione um contêiner ou imagem do docker em execução :

docker inspect name-of-container-or-image

Você pode fazer isso e descobrir se há algum bash oush lá dentro. Procure o ponto de entrada ou cmd no retorno do json.

Vejo documentação executável do docker

Vejo executor de doca-composição

consulte a janela de encaixe inspecionar a documentação

Caso seu contêiner esteja parado ou não possua um shell (por exemplo, hello-worldmencionado no guia de instalação ou não alpine traefik), este é provavelmente o único método possível de explorar o sistema de arquivos.

Você pode arquivar o sistema de arquivos do seu contêiner no arquivo tar:

docker export adoring_kowalevski > contents.tar

Ou liste os arquivos:

docker export adoring_kowalevski | tar t

Observe que, dependendo da imagem, pode levar algum tempo e espaço em disco.

O sistema de arquivos do contêiner está na pasta de dados da janela de encaixe, normalmente em / var / lib / docker. Para iniciar e inspecionar um sistema de arquivos de contêineres em execução, faça o seguinte:

hash=$(docker run busybox)
cd /var/lib/docker/aufs/mnt/$hash

E agora o diretório de trabalho atual é a raiz do contêiner.

Antes da criação do contêiner:

Se você explorar a estrutura da imagem montada dentro do contêiner, poderá fazer

sudo docker image save image_name > image.tar
tar -xvf image.tar

Isso lhe daria a visibilidade de todas as camadas de uma imagem e sua configuração, presente nos arquivos json.

Após a criação do contêiner:

Para isso, já existem muitas respostas acima. minha maneira preferida de fazer isso seria -

docker exec -t -i container /bin/bash

A resposta mais votada está funcionando para mim quando o contêiner é realmente iniciado, mas quando não é possível executar e você, por exemplo, deseja copiar arquivos do contêiner, isso me salvou antes:

docker cp <container-name>:<path/inside/container> <path/on/host/>

Graças ao docker cp ( link ), você pode copiar diretamente do contêiner, como qualquer outra parte do seu sistema de arquivos. Por exemplo, recuperando todos os arquivos dentro de um contêiner:

mkdir /tmp/container_temp
docker cp example_container:/ /tmp/container_temp/

Observe que você não precisa especificar que deseja copiar recursivamente.

No Ubuntu 14.04, executando o Docker 1.3.1 , encontrei o sistema de arquivos raiz do contêiner na máquina host no seguinte diretório:

/var/lib/docker/devicemapper/mnt/<container id>/rootfs/

Informações completas da versão do Docker:

Client version: 1.3.1
Client API version: 1.15
Go version (client): go1.3.3
Git commit (client): 4e9bbfa
OS/Arch (client): linux/amd64
Server version: 1.3.1
Server API version: 1.15
Go version (server): go1.3.3
Git commit (server): 4e9bbfa

Tente usar

docker exec -it <container-name> /bin/bash

Pode haver possibilidade de que o bash não seja implementado. para isso você pode usar

docker exec -it <container-name> sh

Eu uso outro truque sujo que é aufs / devicemapper agnóstico.

Eu olho para o comando que o contêiner está executando, por exemplo, docker ps e se é um apache ou javaeu apenas faço o seguinte:

sudo -s
cd /proc/$(pgrep java)/root/

e voilá você está dentro do contêiner.

Basicamente, você pode colocar o CD raiz na /proc/<PID>/root/pasta, desde que esse processo seja executado pelo contêiner. Cuidado com links simbólicos não fará sentido usar esse modo.

A resposta mais votada é boa, exceto se o seu contêiner não for um sistema Linux real.

Muitos contêineres (especialmente os baseados em go) não têm nenhum binário padrão (nenhum /bin/bashou/bin/sh ). Nesse caso, você precisará acessar o arquivo de contêineres diretamente:

Funciona como um encanto:

name=<name>
dockerId=$(docker inspect -f {{.Id}} $name)
mountId=$(cat /var/lib/docker/image/aufs/layerdb/mounts/$dockerId/mount-id)
cd /var/lib/docker/aufs/mnt/$mountId

Nota: Você precisa executá-lo como root.

No meu caso, nenhum shell era suportado no contêiner, exceto sh. Então, isso funcionou como um encanto

docker exec -it <container-name> sh

você pode usar o mergulho para visualizar o conteúdo da imagem interativamente com a TUI

https://github.com/wagoodman/dive

Isso iniciará uma sessão do bash para a imagem:

docker run --rm -it --entrypoint = / bin / bash

Para mim, este funciona bem (graças aos últimos comentários por apontar o diretório / var / lib / docker / ):

chroot /var/lib/docker/containers/2465790aa2c4*/root/

Aqui, 2465790aa2c4 é o ID curto do contêiner em execução (conforme exibido pelo docker ps ), seguido por uma estrela.

Nas versões mais recentes do Docker, você pode executar docker exec [container_name]um shell dentro do contêiner

Então, para obter uma lista de todos os arquivos em um contêiner, execute docker exec [container_name] ls

Para o docker aufs driver:

O script encontrará o diretório raiz do contêiner (Teste no docker 1.7.1 e 1.10.3)

if [ -z "$1" ] ; then
 echo 'docker-find-root $container_id_or_name '
 exit 1
fi
CID=$(docker inspect   --format {{.Id}} $1)
if [ -n "$CID" ] ; then
    if [ -f  /var/lib/docker/image/aufs/layerdb/mounts/$CID/mount-id ] ; then
        F1=$(cat /var/lib/docker/image/aufs/layerdb/mounts/$CID/mount-id)
       d1=/var/lib/docker/aufs/mnt/$F1
    fi
    if [ ! -d "$d1" ] ; then
        d1=/var/lib/docker/aufs/diff/$CID
    fi
    echo $d1
fi

Nenhuma das respostas existentes trata do caso de um contêiner que saiu (e não pode ser reiniciado) e / ou não possui nenhum shell instalado (por exemplo, sem distração). Este funciona desde que você tenha acesso root ao host do Docker.

Para uma inspeção manual real, descubra primeiro os IDs da camada:

docker inspect my-container | jq '.[0].GraphDriver.Data'

Na saída, você verá algo como

"MergedDir": "/var/lib/docker/overlay2/03e8df748fab9526594cfdd0b6cf9f4b5160197e98fe580df0d36f19830308d9/merged"

Navegue até esta pasta (como root) para encontrar o estado visível atual do sistema de arquivos do contêiner.

Esta resposta ajudará aqueles (como eu) que desejam explorar o sistema de arquivos de volume do docker, mesmo que o contêiner não esteja em execução.

Lista de contêineres de docker em execução:

docker ps

=> ID DO RECIPIENTE "4c721f1985bd"

Observe os pontos de montagem do volume da janela de encaixe na sua máquina física local ( https://docs.docker.com/engine/tutorials/dockervolumes/ ):

docker inspect -f {{.Mounts}} 4c721f1985bd

=> [{/ tmp / container-garren / tmp true rprivate}]

Isso indica que o diretório da máquina física local / tmp / container-garren é mapeado para o destino do volume da janela de encaixe / tmp.

Conhecer o diretório da máquina física local (/ tmp / container-garren) significa que eu posso explorar o sistema de arquivos se o contêiner do docker está ou não em execução. Isso foi fundamental para me ajudar a descobrir que havia alguns dados residuais que não deveriam ter persistido mesmo depois que o contêiner não estava em execução.

outro truque é usar a ferramenta atômica para fazer algo como:

mkdir -p /path/to/mnt && atomic mount IMAGE /path/to/mnt

A imagem do Docker será montada em / path / to / mnt para você inspecioná-la.

Somente para LINUX

A maneira mais simples de usar usando proc dir, que é o contêiner, deve estar em execução para inspecionar os arquivos do contêiner do docker.

1. Descubra a identificação do processo (PID) do contêiner e armazene em alguma variável

   PID = $ (janela de encaixe inspeciona -f '{{.State.Pid}}' your-container-name-here)

2. Verifique se o processo do contêiner está em execução e use a variável nameto para entrar na pasta do contêiner

   cd / proc / $ PID / root

Se você deseja passar pelo diretório sem descobrir o número PID, basta usar este comando longo

cd /proc/$(docker inspect -f '{{.State.Pid}}' your-container-name-here)/root

Dicas:

Depois de entrar no contêiner, tudo o que você fizer afetará o processo real do contêiner, como interromper o serviço ou alterar o número da porta.

Espero que ajude

Nota:

Esse método funciona apenas se o contêiner ainda estiver em execução, caso contrário, o diretório não existiria mais se o contêiner tivesse parado ou removido

Minha maneira preferida de entender o que está acontecendo dentro do contêiner é:

1. expor -p 8000

   docker run -it -p 8000:8000 image
   

2. Iniciar servidor dentro dele

   python -m SimpleHTTPServer
   

Para um contêiner já em execução, você pode:

dockerId=$(docker inspect -f {{.Id}} [docker_id_or_name])

cd /var/lib/docker/btrfs/subvolumes/$dockerId

Você precisa ser root para entrar nesse diretório. Se você não é root, tente 'sudo su' antes de executar o comando.

Edit: Após a v1.3, veja a resposta de Jiri - é melhor.

Se você estiver usando o Docker v19.03, siga as etapas abaixo.

# find ID of your running container:

  docker ps

# create image (snapshot) from container filesystem

  docker commit 12345678904b5 mysnapshot

# explore this filesystem 

  docker run -t -i mysnapshot /bin/sh

Se você estiver usando o driver de armazenamento AUFS, poderá usar o script da camada de encaixe para encontrar a camada de raiz do sistema de arquivos (mnt) e a leitura e gravação de qualquer contêiner:

# docker-layer musing_wiles
rw layer : /var/lib/docker/aufs/diff/c83338693ff190945b2374dea210974b7213bc0916163cc30e16f6ccf1e4b03f
mnt      : /var/lib/docker/aufs/mnt/c83338693ff190945b2374dea210974b7213bc0916163cc30e16f6ccf1e4b03f

Edit 2018-03-28:
docker-layer foi substituído por docker-backup

O docker execcomando para executar um comando em um contêiner em execução pode ajudar em vários casos.

Uso: docker exec [OPÇÕES] COMANDO DE RECIPIENTE [ARG ...]

Executar um comando em um contêiner em execução

Opções:
  -d, --detach Modo desanexado: execute o comando em segundo plano
      --detach-keys string Substitui a sequência de teclas para desanexar um
                             recipiente
  -e, --env list Definir variáveis ​​de ambiente
  -i, --interactive Mantenha o STDIN aberto, mesmo que não esteja conectado
      --privileged Concede privilégios estendidos ao comando
  -t, --tty Aloca um pseudo-TTY
  -u, --user string Nome de usuário ou UID (formato:
                             [:])
  -w, --workdir string Diretório de trabalho dentro do contêiner

Por exemplo :

1) Acessando no bash o sistema de arquivos do contêiner em execução:

docker exec -it containerId bash 

2) Acessando no bash o sistema de arquivos do contêiner em execução como root para poder ter os direitos necessários:

docker exec -it -u root containerId bash  

Isso é particularmente útil para poder fazer algum processamento como raiz em um contêiner.

3) Acesso no bash ao sistema de arquivos do contêiner em execução com um diretório de trabalho específico:

docker exec -it -w /var/lib containerId bash 

Você pode executar um bash dentro do contêiner com este: $ docker run -it ubuntu /bin/bash