Copie de fichiers du conteneur Docker vers l'hôte
https://stackoverflow.com//questions/22049212
-
21-12-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Je pense utiliser Docker pour créer mes dépendances sur un serveur d'intégration continue (CI), afin de ne pas avoir à installer tous les runtimes et bibliothèques sur les agents eux-mêmes.
Pour y parvenir, je devrais copier les artefacts de construction construits à l'intérieur du conteneur vers l'hôte.Est-ce possible?
La solution
Pour copier un fichier à partir d'un conteneur vers l'hôte, vous pouvez utiliser la commande
docker cp <containerId>:/file/path/within/container /host/path/target
Voici un exemple:
$ sudo docker cp goofy_roentgen:/out_read.jpg .
ici goofy_roentgen est le nom du conteneur que j'ai reçu de la commande suivante:
$ sudo docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
1b4ad9311e93 bamos/openface "/bin/bash" 33 minutes ago Up 33 minutes 0.0.0.0:8000->8000/tcp, 0.0.0.0:9000->9000/tcp goofy_roentgen
Vous pouvez également utiliser (une partie de) l'identifiant
$ sudo docker cp 1b4a:/out_read.jpg .
Autres conseils
Vous n'avez pas besoin d'utiliser docker run
Vous pouvez le faire avec docker create
des docs La commande Docker Create crée une couche de conteneur écrite sur l'image spécifiée et la prépare à exécuter la commande spécifiée.L'identifiant du conteneur est ensuite imprimé sur stdout.Ceci est similaire à Docker Run -D sauf que le conteneur n'est jamais démarré.
Alors, vous pouvez faire
docker create -ti --name dummy IMAGE_NAME bash
docker cp dummy:/path/to/file /dest/to/file
docker rm -f dummy
Ici, vous ne démarrez jamais le conteneur.Cela semblait bénéfique pour moi.
Montez un "volume" et copiez-y les artefacts :
mkdir artifacts
docker run -i -v ${PWD}/artifacts:/artifacts ubuntu:14.04 sh << COMMANDS
# ... build software here ...
cp <artifact> /artifacts
# ... copy more artifacts into `/artifacts` ...
COMMANDS
Ensuite, lorsque la build se termine et que le conteneur n'est plus en cours d'exécution, il a déjà copié les artefacts de la build dans le artifacts répertoire sur l'hôte.
Modifier
Mise en garde: Lorsque vous faites cela, vous pouvez rencontrer des problèmes avec l'identifiant utilisateur de l'utilisateur Docker correspondant à l'identifiant utilisateur de l'utilisateur en cours d'exécution.Autrement dit, les fichiers dans /artifacts sera affiché comme appartenant à l'utilisateur avec l'UID de l'utilisateur utilisé à l'intérieur du conteneur Docker.Une solution consiste à utiliser l'UID de l'utilisateur appelant :
docker run -i -v ${PWD}:/working_dir -w /working_dir -u $(id -u) \
ubuntu:14.04 sh << COMMANDS
# Since $(id -u) owns /working_dir, you should be okay running commands here
# and having them work. Then copy stuff into /working_dir/artifacts .
COMMANDS
Montez un volume, copiez les artefacts, ajustez le propriétaire ID et ID de groupe:
mkdir artifacts
docker run -i --rm -v ${PWD}/artifacts:/mnt/artifacts centos:6 /bin/bash << COMMANDS
ls -la > /mnt/artifacts/ls.txt
echo Changing owner from \$(id -u):\$(id -g) to $(id -u):$(id -u)
chown -R $(id -u):$(id -u) /mnt/artifacts
COMMANDS
TLDR ;
$ docker run --rm -iv${PWD}:/host-volume my-image sh -s <<EOF
chown $(id -u):$(id -g) my-artifact.tar.xz
cp -a my-artifact.tar.xz /host-volume
EOF
Description
docker run avec un volume hôte, chown l'artefact, cp l'artefact sur le volume hôte :
$ docker build -t my-image - <<EOF
> FROM busybox
> WORKDIR /workdir
> RUN touch foo.txt bar.txt qux.txt
> EOF
Sending build context to Docker daemon 2.048kB
Step 1/3 : FROM busybox
---> 00f017a8c2a6
Step 2/3 : WORKDIR /workdir
---> Using cache
---> 36151d97f2c9
Step 3/3 : RUN touch foo.txt bar.txt qux.txt
---> Running in a657ed4f5cab
---> 4dd197569e44
Removing intermediate container a657ed4f5cab
Successfully built 4dd197569e44
$ docker run --rm -iv${PWD}:/host-volume my-image sh -s <<EOF
chown -v $(id -u):$(id -g) *.txt
cp -va *.txt /host-volume
EOF
changed ownership of '/host-volume/bar.txt' to 10335:11111
changed ownership of '/host-volume/qux.txt' to 10335:11111
changed ownership of '/host-volume/foo.txt' to 10335:11111
'bar.txt' -> '/host-volume/bar.txt'
'foo.txt' -> '/host-volume/foo.txt'
'qux.txt' -> '/host-volume/qux.txt'
$ ls -n
total 0
-rw-r--r-- 1 10335 11111 0 May 7 18:22 bar.txt
-rw-r--r-- 1 10335 11111 0 May 7 18:22 foo.txt
-rw-r--r-- 1 10335 11111 0 May 7 18:22 qux.txt
Cette astuce fonctionne parce que le chown invocation au sein du hérdoc les prises $(id -u):$(id -g) valeurs provenant de l’extérieur du conteneur en cours d’exécution ;c'est-à-dire l'hôte du docker.
Les avantages sont :
- tu n'es pas obligé
docker container run --nameoudocker container create --nameavant - tu n'es pas obligé
docker container rmaprès
Si vous n'avez pas de conteneur en cours d'exécution, juste une image et en supposant que vous souhaitiez copier un fichier texte, vous pouvez faire quelque chose comme ceci:
docker run the-image cat path/to/container/file.txt > path/to/host/file.txt
La plupart des réponses n'indiquent pas que le conteneur doit fonctionner avant que docker cp fonctionnera:
docker build -t IMAGE_TAG .
docker run -d IMAGE_TAG
CONTAINER_ID=$(docker ps -alq)
# If you do not know the exact file name, you'll need to run "ls"
# FILE=$(docker exec CONTAINER_ID sh -c "ls /path/*.zip")
docker cp $CONTAINER_ID:/path/to/file .
docker stop $CONTAINER_ID
Je publie ceci pour toute personne utilisant Docker pour Mac.C'est ce qui a fonctionné pour moi:
$ mkdir mybackup # local directory on Mac
$ docker run --rm --volumes-from <containerid> \
-v `pwd`/mybackup:/backup \
busybox \
cp /data/mydata.txt /backup
Notez que lorsque je monte en utilisant -v que backup Le répertoire est automatiquement créé.
J'espère que cela sera utile à quelqu'un un jour.:)
Une solution plus générale, Il y a unPlugin Cloudbees pour Jenkins pour construire à l'intérieur d'un conteneur Docker .Vous pouvez sélectionner une image à utiliser à partir d'un registre Docker ou définir un DockerFile pour construire et utiliser.
Il montez l'espace de travail dans le conteneur en tant que volume (avec l'utilisateur approprié), définissez-le comme votre répertoire de travail, faites toutes les commandes que vous demandez (à l'intérieur du conteneur). Vous pouvez également utiliser le plug-in Docker-Workflow (si vous préférez le code sur UI) pour le faire, avec la commande image.Inside () {}.
Fondamentalement tout cela, cuit dans votre serveur CI / CD, puis certains.
Si vous souhaitez simplement extraire un fichier d'un image (au lieu d'un conteneur en cours d'exécution), vous pouvez faire ceci :
docker run --rm <image> cat <source> > <local_dest>
Cela fera apparaître le conteneur, écrira le nouveau fichier, puis supprimera le conteneur.Un inconvénient, cependant, est que les autorisations du fichier et la date de modification ne seront pas conservées.
docker run -dit --rm IMAGE
docker cp CONTAINER:SRC_PATH DEST_PATH
https://docs.docker.com/engine/reference/commandLine/Run / https://docs.docker.com/Engine/reference/commandLine/cp/
J'ai utilisé PowerShell (admin) avec cette commande.
docker cp {container id}:{container path}/error.html C:\\error.html
docker cp ff3a6608467d:/var/www/app/error.html C:\\error.html
Avec la sortie de Docker 19.03, vous pouvez ignorer la création du conteneur et même créer une image.Il existe une option avec les versions basées sur BuildKit pour modifier la destination de sortie.Vous pouvez l'utiliser pour écrire les résultats de la construction dans votre répertoire local plutôt que dans une image.Par exemple.voici une version d'un binaire go :
$ ls
Dockerfile go.mod main.go
$ cat Dockerfile
FROM golang:1.12-alpine as dev
RUN apk add --no-cache git ca-certificates
RUN adduser -D appuser
WORKDIR /src
COPY . /src/
CMD CGO_ENABLED=0 go build -o app . && ./app
FROM dev as build
RUN CGO_ENABLED=0 go build -o app .
USER appuser
CMD [ "./app" ]
FROM scratch as release
COPY --from=build /etc/passwd /etc/group /etc/
COPY --from=build /src/app /app
USER appuser
CMD [ "/app" ]
FROM scratch as artifact
COPY --from=build /src/app /app
FROM release
À partir du Dockerfile ci-dessus, je construis le artifact étape qui inclut uniquement les fichiers que je souhaite exporter.Et le nouveau introduit --output flag me permet de les écrire dans un répertoire local au lieu d'une image.Cela doit être effectué avec le moteur BuildKit fourni avec 19.03 :
$ DOCKER_BUILDKIT=1 docker build --target artifact --output type=local,dest=. .
[+] Building 43.5s (12/12) FINISHED
=> [internal] load build definition from Dockerfile 0.7s
=> => transferring dockerfile: 572B 0.0s
=> [internal] load .dockerignore 0.5s
=> => transferring context: 2B 0.0s
=> [internal] load metadata for docker.io/library/golang:1.12-alpine 0.9s
=> [dev 1/5] FROM docker.io/library/golang:1.12-alpine@sha256:50deab916cce57a792cd88af3479d127a9ec571692a1a9c22109532c0d0499a0 22.5s
=> => resolve docker.io/library/golang:1.12-alpine@sha256:50deab916cce57a792cd88af3479d127a9ec571692a1a9c22109532c0d0499a0 0.0s
=> => sha256:1ec62c064901392a6722bb47a377c01a381f4482b1ce094b6d28682b6b6279fd 155B / 155B 0.3s
=> => sha256:50deab916cce57a792cd88af3479d127a9ec571692a1a9c22109532c0d0499a0 1.65kB / 1.65kB 0.0s
=> => sha256:2ecd820bec717ec5a8cdc2a1ae04887ed9b46c996f515abc481cac43a12628da 1.36kB / 1.36kB 0.0s
=> => sha256:6a17089e5a3afc489e5b6c118cd46eda66b2d5361f309d8d4b0dcac268a47b13 3.81kB / 3.81kB 0.0s
=> => sha256:89d9c30c1d48bac627e5c6cb0d1ed1eec28e7dbdfbcc04712e4c79c0f83faf17 2.79MB / 2.79MB 0.6s
=> => sha256:8ef94372a977c02d425f12c8cbda5416e372b7a869a6c2b20342c589dba3eae5 301.72kB / 301.72kB 0.4s
=> => sha256:025f14a3d97f92c07a07446e7ea8933b86068d00da9e252cf3277e9347b6fe69 125.33MB / 125.33MB 13.7s
=> => sha256:7047deb9704134ff71c99791be3f6474bb45bc3971dde9257ef9186d7cb156db 125B / 125B 0.8s
=> => extracting sha256:89d9c30c1d48bac627e5c6cb0d1ed1eec28e7dbdfbcc04712e4c79c0f83faf17 0.2s
=> => extracting sha256:8ef94372a977c02d425f12c8cbda5416e372b7a869a6c2b20342c589dba3eae5 0.1s
=> => extracting sha256:1ec62c064901392a6722bb47a377c01a381f4482b1ce094b6d28682b6b6279fd 0.0s
=> => extracting sha256:025f14a3d97f92c07a07446e7ea8933b86068d00da9e252cf3277e9347b6fe69 5.2s
=> => extracting sha256:7047deb9704134ff71c99791be3f6474bb45bc3971dde9257ef9186d7cb156db 0.0s
=> [internal] load build context 0.3s
=> => transferring context: 2.11kB 0.0s
=> [dev 2/5] RUN apk add --no-cache git ca-certificates 3.8s
=> [dev 3/5] RUN adduser -D appuser 1.7s
=> [dev 4/5] WORKDIR /src 0.5s
=> [dev 5/5] COPY . /src/ 0.4s
=> [build 1/1] RUN CGO_ENABLED=0 go build -o app . 11.6s
=> [artifact 1/1] COPY --from=build /src/app /app 0.5s
=> exporting to client 0.1s
=> => copying files 10.00MB 0.1s
Une fois la construction terminée, app le binaire a été exporté :
$ ls
Dockerfile app go.mod main.go
$ ./app
Ready to receive requests on port 8080
Docker a d'autres options que --output indicateur documenté dans leur dépôt BuildKit en amont : https://github.com/moby/buildkit#output
Créer un répertoire de données sur le système hôte (en dehors du conteneur) et monter ceci à un répertoire visible de l'intérieur du conteneur.Cela place les fichiers dans un emplacement connu sur le système hôte et facilite la tâche des outils et des applications sur le système hôte d'accéder aux fichiers
docker run -d -v /path/to/Local_host_dir:/path/to/docker_dir docker_image:tag
Créer un chemin d'accès où vous souhaitez copier le fichier, puis utiliser:
docker run -d -v hostpath:dockerimag
Vous pouvez utiliser bind au lieu de volume si vous souhaitez monter un seul dossier, ne créez pas de stockage spécial pour un conteneur :
Construisez votre image avec le tag :
docker build . -t <image>Exécutez votre image et liez le répertoire $(pwd) actuel où app.py stocke et mappez-le à /root/example/ à l'intérieur de votre conteneur.
docker run --mount type=bind,source="$(pwd)",target=/root/example/ <image> python app.py
