Eksploracja systemu plików kontenera Docker

UPDATE: EXPLORING!

To polecenie powinno pozwolić ci zbadać działający kontener Dockera :

docker exec -it name-of-container bash

Odpowiednikiem tego w docker-compose będzie:

docker-compose exec web bash

(web jest nazwą usługi w tym przypadku i domyślnie ma tty.)

Gdy już będziesz w środku do:

ls -lsa

Lub inne polecenie bash typu:

cd ..

To polecenie powinno pozwolić Ci zbadać obraz dokera :

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

Once inside do:

ls -lsa

Lub inne polecenie bash typu:

cd ..

-it oznacza interactive... i tty.

To polecenie powinno pozwolić Ci sprawdzić uruchomiony kontener dokera lub obraz :

docker inspect name-of-container-or-image

Uwaga: ta odpowiedź polega na obecności narzędzia commen, ale jeśli nie ma bash powłoki lub popularne narzędzia, takie jak ls present możesz najpierw dodać jeden w warstwie, jeśli masz dostęp do Dockerfile: przykład dla alpine:

RUN apk add --no-cache bash

W przeciwnym razie, jeśli nie masz dostępu do Dockerfile, po prostu skopiuj pliki z nowo utworzonego kontenera i poszukaj ich wykonując:

docker create <image>  # returns container ID the container is never started.
docker cp <container ID>:<source_path> <destination_path>
docker rm <container ID>
cd <destination_path> && ls -lsah

Zobacz docker Exec documentation

Zobacz docker-compose Exec documentation

Zobacz docker inspect documentation

Zobacz docker create dokumentacja

W przypadku, gdy kontener jest zatrzymany lub nie ma powłoki (np. hello-world wymienione w poradniku instalacji , lub nie-alpine traefik), jest to prawdopodobnie jedyna możliwa metoda eksploracji systemu plików.

Możesz zarchiwizować system plików kontenera do pliku tar:

docker export adoring_kowalevski > contents.tar

Lub Lista plików:

docker export adoring_kowalevski | tar t

Należy pamiętać, że w zależności od obrazu, może to zająć trochę czasu i miejsca na dysku.

System plików kontenera znajduje się w folderze danych Dockera, zwykle w /var/lib/docker. Aby uruchomić i sprawdzić działający system plików containers wykonaj następujące czynności:

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

I teraz bieżący katalog roboczy jest katalogiem głównym kontenera.

Przed Utworzeniem Kontenera:

Jeśli chcesz zbadać strukturę obrazu zamontowanego wewnątrz kontenera, możesz to zrobić

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

Daje to widoczność wszystkich warstw obrazu i jego konfiguracji, która jest obecna w plikach json.

Po utworzeniu kontenera:

Na to jest już wiele odpowiedzi powyżej. my preferred way to do to byłoby -

docker exec -t -i container /bin/bash

Najbardziej upvoted odpowiedź działa dla mnie, gdy kontener jest rzeczywiście uruchomiony, ale gdy nie jest możliwe, aby uruchomić i na przykład chcesz skopiować pliki z kontenera to zapisało mnie wcześniej:

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

Dzięki docker CP (link) możesz kopiować bezpośrednio z kontenera tak, jak to było w każdej innej części Twojego systemu plików. Na przykład odzyskiwanie wszystkich plików wewnątrz kontenera:

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

Zauważ, że nie musisz określać, że chcesz kopiować rekurencyjnie.

On Ubuntu 14.04 running Docker 1.3.1, I found the container root filesystem on the host machine in the following directory:

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

Pełna informacja o wersji Dockera:

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

Możesz użyć dive do interaktywnego wyświetlania zawartości obrazu za pomocą TUI

Https://github.com/wagoodman/dive

Spróbuj użyć

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

Istnieje możliwość, że bash nie jest zaimplementowany. do tego możesz użyć

docker exec -it <container-name> sh

Używam innego brudnego triku, który jest aufs / devicemapper agnostic.

Patrzę na komendę, że kontener działa np. docker ps a jeśli jest to apache lub java to po prostu robię co następuje:

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

Zasadniczo Możesz jako root cd do folderu /proc/<PID>/root/ tak długo, jak ten proces jest uruchamiany przez kontener. Uwaga dowiązania symboliczne nie będą miały sensu używać tego trybu.

Najczęściej głosowana odpowiedź jest dobra, chyba że Twój kontener nie jest prawdziwym systemem Linux.

Wiele kontenerów (zwłaszcza tych opartych na go) nie ma standardowych binarnych (no /bin/bash lub /bin/sh). W takim przypadku będziesz musiał uzyskać bezpośredni dostęp do aktualnego pliku containers:

Działa jak czar:

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

Uwaga: musisz uruchomić go jako root.

W moim przypadku żadna powłoka nie była obsługiwana w kontenerze z wyjątkiem sh. Więc, to działało jak urok

docker exec -it <container-name> sh

Tylko dla Linuksa

Najprostszym sposobem, którego używam, było użycie katalogu proc, czyli kontener musi być uruchomiony, aby sprawdzić pliki kontenera Dockera.

1. Znajdź identyfikator procesu (PID) kontenera i zapisz go do zmiennej

   PID = $(Docker inspect-f' {{.Stan.Pid}} ' your-container-name-here)

2. Upewnij się, że proces kontenera jest uruchomiony i użyj nazwy zmiennej, aby dostać się do kontenera folder

   Cd / proc / $PID / root

Jeśli chcesz przejść przez dir BEZ poznawania numeru PID , po prostu nam to długie polecenie

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

Porady:

Po wejściu do kontenera wszystko, co zrobisz, wpłynie na rzeczywisty proces kontenera, taki jak zatrzymanie usługi lub zmiana numeru portu.

Hope it helps

Uwaga:

Ta metoda działa tylko wtedy, gdy kontener jest nadal uruchomiony, w przeciwnym razie katalog przestałby istnieć, gdyby kontener został zatrzymany lub usunięty

Żadna z istniejących odpowiedzi nie odnosi się do przypadku kontenera, który się zakończył (i nie może zostać uruchomiony ponownie) i/lub nie ma zainstalowanej powłoki (np. bezstratnej). Ten działa tak długo, jak masz dostęp roota do hosta dokera.

Aby uzyskać prawdziwą kontrolę ręczną, najpierw znajdź identyfikatory warstw:

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

W wyjściu powinieneś zobaczyć coś w rodzaju

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

Przejdź do tego folderu (jako root), aby znaleźć aktualny widoczny stan systemu plików kontenera.

To uruchomi sesję bash dla obrazu:

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

Dla mnie ten działa dobrze (dzięki ostatnim komentarzom za wskazanie katalogu / var / lib/docker/):

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

Tutaj, 2465790aa2c4 jest krótkim identyfikatorem działającego kontenera (wyświetlanym przez docker ps ), po którym następuje gwiazdka.

W nowszych wersjach Dockera można uruchomić docker exec [container_name], który uruchamia powłokę wewnątrz kontenera

Więc aby uzyskać listę wszystkich plików w kontenerze wystarczy uruchomić docker exec [container_name] ls

Dla sterownika docker aufs:

Skrypt znajdzie katalog główny kontenera (Test na dockerze 1.7.1 i 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

Ta odpowiedź pomoże tym (takim jak ja), którzy chcą zbadać system plików woluminu Dockera, nawet jeśli kontener nie jest uruchomiony.

Lista uruchomionych kontenerów Dockera:

docker ps

= > identyfikator kontenera "4c721f1985bd"

Spójrz na punkty montowania głośności dokera na lokalnej maszynie fizycznej ( https://docs.docker.com/engine/tutorials/dockervolumes/):

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

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

To mi mówi, że lokalny fizyczny katalog maszyn /tmp /container-garren jest mapowany do miejsca docelowego woluminu dokującego / tmp.

Znajomość lokalnego fizycznego katalogu maszyn (/tmp / container-garren) oznacza, że mogę zbadać system plików, czy kontener Dockera jest uruchomiony. Miało to kluczowe znaczenie, aby pomóc mi zrozumieć, że istnieją pewne szczątkowe dane, które nie powinny się utrzymywać nawet po tym, jak kontener nie był uruchomiony.

Kolejną sztuczką jest użycie narzędzia atomic do zrobienia czegoś takiego jak:

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

Obraz dokera zostanie zamontowany do /path/to / mnt, abyś mógł go sprawdzić.

Moim preferowanym sposobem na zrozumienie tego, co dzieje się wewnątrz kontenera jest:

1. Expose-p 8000

   docker run -it -p 8000:8000 image
   

2. Uruchom serwer w nim

   python -m SimpleHTTPServer
   

Dla już działającego kontenera, możesz zrobić:

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

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

Musisz być rootem, aby nagrać płytę do tego katalogu. Jeśli nie jesteś rootem, spróbuj 'sudo su' przed uruchomieniem polecenia.

Edit: po v1.3, Zobacz odpowiedź Jiri - jest lepiej.

Jeśli używasz Docker v19. 03, wykonaj poniższe kroki.

# 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

Jeśli używasz sterownika pamięci AUFS, możesz użyć skryptu my Docker-layer, aby znaleźć główny system plików kontenera (mnt) i warstwę readwrite:

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

Edycja 2018-03-28:
Docker-layer został zastąpiony przez Docker-backup

Polecenie docker exec do uruchomienia polecenia w uruchomionym kontenerze może pomóc w wielu przypadkach.

Usage:  docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

Run a command in a running container

Options:
  -d, --detach               Detached mode: run command in the background
      --detach-keys string   Override the key sequence for detaching a
                             container
  -e, --env list             Set environment variables
  -i, --interactive          Keep STDIN open even if not attached
      --privileged           Give extended privileges to the command
  -t, --tty                  Allocate a pseudo-TTY
  -u, --user string          Username or UID (format:
                             [:])
  -w, --workdir string       Working directory inside the container

Na przykład:

1) Dostęp w bash do uruchomionego systemu plików kontenera :

docker exec -it containerId bash 

2) dostęp w bash do uruchomionego systemu plików kontenera jako root, aby mieć wymagane prawa :

docker exec -it -u root containerId bash  

Jest to szczególnie przydatne, aby móc wykonać pewne przetwarzanie jako root w kontenerze.

3) Dostęp w bash do uruchomionego systemu plików kontenera z konkretnym katalogiem roboczym:

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

Możesz uruchomić bash wewnątrz kontenera za pomocą tego: $ docker run -it ubuntu /bin/bash

Chciałem to zrobić, ale nie byłem w stanie uruchomić kontenera, ponieważ zatrzymał się i nie uruchamiał się ponownie z powodu błędu w kodzie.

To, co zadziałało dla mnie, to po prostu skopiowanie zawartości całego kontenera do nowego folderu, takiego jak ten:

docker cp container_name:/app/ new_dummy_folder

Byłem wtedy w stanie zbadać zawartość tego folderu tak, jak zrobi się to w normalnym folderze.