将文件从Docker容器复制到主机

Question

我正在考虑使用Docker在持续集成(CI)服务器上构建我的依赖项,这样我就不必在代理本身上安装所有运行时和库.为了实现这一点,我需要将容器内部构建的构建工件复制回主机.

那可能吗？

Answer 1

要将文件从容器复制到主机,可以使用该命令

docker cp <containerId>:/file/path/within/container /host/path/target

这是一个例子:

$ sudo docker cp goofy_roentgen:/out_read.jpg .

这里goofy_roentgen是我从以下命令获得的名称:

$ 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

Answer 2

你不需要使用 docker run

你可以做到 docker create

从文档中 ,docker create命令在指定的映像上创建可写容器层,并准备运行指定的命令.然后将容器ID打印到STDOUT.这类似于docker run -d,但容器从未启动过.

所以,你可以做到

docker create -ti --name dummy IMAGE_NAME bash
docker cp dummy:/path/to/file /dest/to/file
docker rm -f dummy

在这里,你永远不会启动容器.这看起来对我有益.

Answer 3

挂载"卷"并将工件复制到那里:

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

然后,当构建完成并且容器不再运行时,它已经将构建中的工件复制到artifacts主机上的目录中.

编辑:

CAVEAT:执行此操作时,您可能会遇到与当前正在运行的用户的用户ID匹配的docker用户的用户ID问题.也就是说,文件/artifacts将显示为用户拥有的Docker容器内使用的用户的UID.解决这个问题的方法可能是使用调用用户的UID:

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

Answer 4

docker cp containerId:source_path destination_path

可以通过命令获取containerIddocker ps -a

源路径应该是绝对路径。例如，如果应用程序/服务目录从 docker 容器中的应用程序开始，则路径将为 /app/some_directory/file

示例： docker cp d86844abc129:/app/server/output/server-test.png C:/Users/someone/Desktop/output

Answer 5

从DockerContainer 到 LocalMachine

$docker cp containerId:/sourceFilePath/someFile.txt C:/localMachineDestinationFolder

从本地机器到 DockerContainer

$docker cp C:/localMachineSourceFolder/someFile.txt containerId:/containerDestinationFolder

Answer 6

装载卷,复制工件,调整所有者ID和组ID:

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

Answer 7

对于任何尝试使用 MySQL 容器执行此操作并将卷本地存储在计算机上的人。我使用了该问题的最高评价回复中提供的语法。但必须使用特定于 MySQL 的特定路径

docker cp containerIdHere:/var/lib/mysql pathToYourLocalMachineHere

Answer 8

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

长...

docker run使用主机卷,chown工件,主机卷的工件cp:

$ 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

这个技巧有效,因为heredoc中的chown调用从正在运行的容器外部获取值; 即,码头主机.$(id -u):$(id -g)

好处是:

• 你没必要docker container run --name或docker container create --name之前
• 你不必docker container rm后

Answer 9

如果你没有要复制一个文本文件运行的容器,只是一个形象,并假设,你可以这样做:

docker run the-image cat path/to/container/file.txt > path/to/host/file.txt

Answer 10

大多数答案并未表明容器必须在运行之前运行docker cp:

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

Answer 11

随着 Docker 19.03 的发布，您可以跳过创建容器甚至构建镜像的步骤。基于 BuildKit 的构建有一个选项可以更改输出目标。您可以使用它来将构建结果写入本地目录而不是图像。例如，这是一个 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

从上面的 Dockerfile 中，我正在构建artifact仅包含我想要导出的文件的阶段。新引入的--output标志让我可以将它们写入本地目录而不是图像。这需要使用 19.03 附带的 BuildKit 引擎来执行：

$ 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

构建完成后，app二进制文件被导出：

$ ls
Dockerfile  app  go.mod  main.go

$ ./app
Ready to receive requests on port 8080

Docker--output在其上游 BuildKit 存储库中记录了该标志的其他选项：https : //github.com/moby/buildkit#output

Answer 12

docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH从容器复制到主机。

例如docker cp test:/opt/file1 /etc/

对于反之亦然：

docker cp [OPTIONS] SRC_PATH CONTAINER:DEST_PATH从主机复制到容器。

Answer 13

我正在为使用Docker for Mac的任何人发布这个.这对我有用:

 $ mkdir mybackup # local directory on Mac

 $ docker run --rm --volumes-from <containerid> \
    -v `pwd`/mybackup:/backup \  
    busybox \                   
    cp /data/mydata.txt /backup 

请注意,当我使用-v该backup目录挂载时会自动创建.

我希望有一天这对某人有用.:)

Answer 14

我在此命令中使用了 PowerShell（管理员）。

docker cp {container id}:{container path}/error.html  C:\\error.html

例子

docker cp ff3a6608467d:/var/www/app/error.html  C:\\error.html

Answer 15

sudo docker cp <running_container_id>:<full_file_path_in_container> <path_on_local_machine>

例子 ：

sudo docker cp d8a17dfc455f:/tests/reports /home/acbcb/Documents/abc

Answer 16

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/

Answer 17

如果您只想从图像（而不是正在运行的容器）中提取文件，您可以这样做：

docker run --rm <image> cat <source> > <local_dest>

这将启动容器，写入新文件，然后删除容器。但是，一个缺点是不会保留文件权限和修改日期。

Answer 18

另一个不错的选择是首先构建容器，然后使用 -c 标志和 shell 解释器运行它以执行一些命令

docker run --rm -i -v <host_path>:<container_path> <mydockerimage> /bin/sh -c "cp -r /tmp/homework/* <container_path>"

上面的命令执行以下操作：

-i = 以交互模式运行容器

--rm = 执行后移除容器。

-v = 共享一个文件夹作为从主机路径到容器路径的卷。

最后， /bin/sh -c 允许您引入一个命令作为参数，该命令会将您的作业文件复制到容器路径。

我希望这个额外的答案可以帮助你