Esplorazione del file system del container Docker

Ho notato con la finestra mobile che ho bisogno di capire cosa sta succedendo all'interno di un contenitore o quali file esistono. Un esempio è il download di immagini dall'indice docker: non hai idea di cosa contenga l'immagine, quindi è impossibile avviare l'applicazione.

Ciò che sarebbe l'ideale è essere in grado di inserirli o equivalere. C'è uno strumento per farlo, o la mia concettualizzazione della finestra mobile è errata nel pensare che dovrei essere in grado di farlo.

AGGIORNAMENTO
Metodo più semplice: utilizzo della finestra mobile exec

Docker versione 1.3 o successiva supporta il comando execche si comporta in modo simile nsenter. Questo comando può eseguire un nuovo processo in un contenitore già in esecuzione (nel contenitore deve essere già in esecuzione un processo PID 1). È possibile eseguire /bin/bashper esplorare lo stato del contenitore:

docker exec -t -i mycontainer /bin/bash

consultare la documentazione della riga di comando Docker

Metodo alternativo 1
Istantanea

È possibile valutare il filesystem contenitore in questo modo:

# 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

In questo modo, è possibile valutare il filesystem del container in esecuzione nel preciso momento temporale. Il contenitore è ancora in esecuzione, non sono incluse modifiche future.

Successivamente puoi eliminare l'istantanea usando (il filesystem del container in esecuzione non è interessato!):

docker rmi mysnapshot

Metodo alternativo 2
ssh

Se hai bisogno di un accesso continuo, puoi installare sshd nel tuo contenitore ed eseguire il demone sshd:

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

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

In questo modo, puoi eseguire la tua app usando ssh (connettiti ed esegui ciò che desideri).

AGGIORNAMENTO: metodo alternativo 3
nsenter

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

La versione breve è: con nsenter, è possibile ottenere una shell in un contenitore esistente, anche se quel contenitore non esegue SSH o alcun tipo di demone per scopi speciali

AGGIORNAMENTO: ESPLORANDO!

Questo comando dovrebbe consentire di esplorare un container docker in esecuzione :

docker exec -it name-of-container bash

L'equivalente per questo in docker-compose sarebbe:

docker-compose exec web bash

(web è il nome del servizio in questo caso e ha tty per impostazione predefinita.)

Una volta dentro fai:

ls -lsa

o qualsiasi altro comando bash come:

cd ..

Questo comando dovrebbe consentire di esplorare un'immagine finestra mobile :

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

una volta dentro fai:

ls -lsa

o qualsiasi altro comando bash come:

cd ..

Lo -itsta per interattivo ... e tty.

Questo comando dovrebbe consentire di ispezionare un contenitore o un'immagine docker in esecuzione :

docker inspect name-of-container-or-image

Potresti voler fare questo e scoprire se ce ne sono bashosh dentro. Cerca entrypoint o cmd nel ritorno json.

vedere la documentazione del docker exec

consultare la documentazione exec di docker-compose

vedere la finestra di ispezione della finestra mobile

Nel caso in cui il contenitore sia arrestato o non abbia una shell (ad esempio hello-worldmenzionata nella guida all'installazione o non alpine traefik), questo è probabilmente l'unico metodo possibile per esplorare il filesystem.

È possibile archiviare il filesystem del proprio contenitore in un file tar:

docker export adoring_kowalevski > contents.tar

Oppure elenca i file:

docker export adoring_kowalevski | tar t

Si noti che, a seconda dell'immagine, potrebbero essere necessari del tempo e dello spazio su disco.

Il file system del contenitore si trova nella cartella dati della finestra mobile, normalmente in / var / lib / docker. Per avviare e ispezionare un file system dei contenitori in esecuzione, procedere come segue:

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

E ora la directory di lavoro corrente è la radice del contenitore.

Prima della creazione del contenitore:

Se puoi esplorare la struttura dell'immagine montata all'interno del contenitore, puoi farlo

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

Ciò ti darebbe la visibilità di tutti i livelli di un'immagine e la sua configurazione presente nei file json.

Dopo la creazione del contenitore:

Per questo ci sono già molte risposte sopra. il mio modo preferito per farlo sarebbe:

docker exec -t -i container /bin/bash

La risposta più votata funziona per me quando il contenitore è effettivamente avviato, ma quando non è possibile eseguirlo e tu, ad esempio, vuoi copiare i file dal contenitore, questo mi ha salvato prima:

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

Grazie alla docker cp ( link ) puoi copiare direttamente dal contenitore come qualsiasi altra parte del tuo filesystem. Ad esempio, ripristinare tutti i file all'interno di un contenitore:

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

Si noti che non è necessario specificare che si desidera copiare in modo ricorsivo.

Su Ubuntu 14.04 che esegue Docker 1.3.1 , ho trovato il filesystem root del contenitore sul computer host nella seguente directory:

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

Informazioni sulla versione completa di 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

Prova a usare

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

Potrebbe esserci la possibilità che bash non sia implementato. per quello puoi usare

docker exec -it <container-name> sh

Uso un altro trucco sporco che è agnostico aufs / devicemapper.

Guardo il comando che il contenitore è in esecuzione ad es. docker ps E se è un apache o javafaccio semplicemente quanto segue:

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

e voilá sei dentro il container.

Fondamentalmente è possibile eseguire il root cd nella /proc/<PID>/root/cartella purché il processo sia eseguito dal contenitore. Attenzione, i collegamenti simbolici non avranno senso usando questa modalità.

La risposta più votata è buona tranne se il container non è un vero sistema Linux.

Molti contenitori (specialmente quelli basati su go) non hanno alcun binario standard (no /bin/basho/bin/sh ). In tal caso, dovrai accedere direttamente al file container effettivo:

Funziona come un fascino:

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: è necessario eseguirlo come root.

Nel mio caso nessuna shell era supportata nel contenitore tranne sh. Quindi, ha funzionato come un fascino

docker exec -it <container-name> sh

puoi usare l'immersione per visualizzare il contenuto dell'immagine in modo interattivo con TUI

https://github.com/wagoodman/dive

Questo avvierà una sessione bash per l'immagine:

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

Per me, questo funziona bene (grazie agli ultimi commenti per aver indicato la directory / var / lib / docker / ):

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

Qui, 2465790aa2c4 è l'ID breve del contenitore in esecuzione (come visualizzato dalla finestra mobile ps ), seguito da una stella.

Nelle versioni più recenti di Docker è possibile eseguire docker exec [container_name]che esegue una shell all'interno del contenitore

Quindi per ottenere un elenco di tutti i file in un contenitore è sufficiente eseguirlo docker exec [container_name] ls

Per il driver docker aufs:

Lo script troverà la directory principale del contenitore (Test sulla finestra mobile 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

Nessuna delle risposte esistenti risolve il caso di un contenitore che è uscito (e non può essere riavviato) e / o non ha alcuna shell installata (ad esempio, quelle senza problemi). Questo funziona finché hai l'accesso root all'host Docker.

Per una vera ispezione manuale, scopri prima gli ID layer:

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

Nell'output, dovresti vedere qualcosa di simile

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

Passare a questa cartella (come root) per trovare lo stato visibile corrente del filesystem contenitore.

Questa risposta aiuterà coloro (come me) che vogliono esplorare il filesystem del volume docker anche se il container non è in esecuzione.

Elenco di contenitori docker in esecuzione:

docker ps

=> ID CONTENITORE "4c721f1985bd"

Guarda i punti di montaggio del volume della finestra mobile sulla tua macchina fisica locale ( https://docs.docker.com/engine/tutorials/dockervolumes/ ):

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

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

Questo mi dice che la directory della macchina fisica locale / tmp / container-garren è mappata sulla destinazione del volume della finestra mobile / tmp.

Conoscere la directory della macchina fisica locale (/ tmp / container-garren) significa che posso esplorare il filesystem indipendentemente dal fatto che il contenitore docker sia in esecuzione. Questo è stato fondamentale per aiutarmi a capire che c'erano alcuni dati residui che non avrebbero dovuto persistere anche dopo che il container non era in esecuzione.

un altro trucco è usare lo strumento atomico per fare qualcosa del tipo:

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

L'immagine Docker verrà montata su / path / to / mnt per consentirne l' ispezione.

Solo per LINUX

Il modo più semplice che utilizzo è stato utilizzando proc dir, ovvero il contenitore deve essere in esecuzione per ispezionare i file del contenitore della finestra mobile.

1. Scopri l'id di processo (PID) del contenitore e memorizza in alcune variabili

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

2. Assicurarsi che il processo contenitore sia in esecuzione e utilizzare la variabile nameto per accedere alla cartella contenitore

   cd / proc / $ PID / root

Se vuoi passare attraverso la dir senza scoprire il numero PID semplicemente usando questo lungo comando

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

Suggerimenti:

Dopo essere entrati nel contenitore, tutto ciò che fai influenzerà l'effettivo processo del contenitore, come l'arresto del servizio o la modifica del numero di porta.

Spero che sia d'aiuto

Nota:

Questo metodo funziona solo se il contenitore è ancora in esecuzione, altrimenti la directory non esisterebbe più se il contenitore si è arrestato o rimosso

Il mio modo preferito per capire cosa sta succedendo all'interno del container è:

1. esporre -p 8000

   docker run -it -p 8000:8000 image
   

2. Avvia il server al suo interno

   python -m SimpleHTTPServer
   

Per un contenitore già in esecuzione, puoi fare:

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

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

Devi essere root per poter inserire cd in quella directory. Se non si è root, provare 'sudo su' prima di eseguire il comando.

Modifica: dopo v1.3, vedi la risposta di Jiri - è meglio.

Se si utilizza Docker v19.03, seguire i passaggi seguenti.

# 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 si utilizza il driver di archiviazione AUFS, è possibile utilizzare il mio script a livello di finestra mobile per trovare il root del filesystem (mnt) di qualsiasi contenitore e il livello readwrite:

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

Modifica 28-03-2018: il docker
-layer è stato sostituito dal docker-backup

Il docker execcomando per eseguire un comando in un contenitore in esecuzione può aiutare in più casi.

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

Esegui un comando in un contenitore in esecuzione

Opzioni:
  -d, --detach Modalità indipendente: esegue il comando in background
      --detach-keys string Sostituisce la sequenza di tasti per staccare a
                             contenitore
  -e, --env list Imposta le variabili di ambiente
  -i, --interattivo Tenere aperto STDIN anche se non collegato
      --privileged Assegna privilegi estesi al comando
  -t, --tty Assegna uno pseudo-TTY
  -u, --user stringa Nome utente o UID (formato:
                             [:])
  -w, --workdir stringa Directory di lavoro all'interno del contenitore

Per esempio :

1) Accesso in bash al filesystem del container in esecuzione:

docker exec -it containerId bash 

2) Accedere in bash al filesystem del container in esecuzione come root per poter avere i diritti richiesti:

docker exec -it -u root containerId bash  

Ciò è particolarmente utile per essere in grado di eseguire alcune elaborazioni come root in un contenitore.

3) Accesso in bash al filesystem del container in esecuzione con una directory di lavoro specifica:

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

È possibile eseguire un bash all'interno del contenitore con questo: $ docker run -it ubuntu /bin/bash