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

为了将文件从容器复制到主机，您可以使用命令

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                                            NAMES1b4ad9311e93        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

您还可以使用容器ID的（部分）。以下命令等效于第一个

$ sudo docker cp 1b4a:/out_read.jpg .

挂载一个“卷”并将工件复制到那里：

mkdir artifactsdocker run -i -v ${PWD}/artifacts:/artifacts ubuntu:14.04 sh << COMMANDS# ... build software here ...cp <artifact> /artifacts# ... copy more artifacts into `/artifacts` ...COMMANDS

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

编辑

警告：执行此操作时，您可能会遇到docker用户的用户ID与当前运行用户的用户ID匹配的问题。也就是说，/artifacts中的文件将显示为用户拥有，用户的UID在docker容器中使用。解决此问题的方法可能是使用调用用户的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

挂载卷，复制工件，调整所有者ID和组ID：

mkdir artifactsdocker run -i --rm -v ${PWD}/artifacts:/mnt/artifacts centos:6 /bin/bash << COMMANDSls -la > /mnt/artifacts/ls.txtecho Changing owner from \$(id -u):\$(id -g) to $(id -u):$(id -g)chown -R $(id -u):$(id -g) /mnt/artifactsCOMMANDS

编辑：请注意，一些像$(id -u)这样的命令是反斜杠的，因此将在容器中处理，而不是反斜杠的命令将在命令发送到容器之前由主机中运行的shell处理。

作为更通用的解决方案，有一个CloudBees插件供Jenkins在Docker容器中构建。您可以从Docker注册表中选择要使用的映像或定义要构建和使用的Dockerfile。

它将工作区作为卷（使用适当的用户）挂载到容器中，将其设置为您的工作目录，执行您请求的任何命令（在容器内）。您还可以使用docker-workflow插件（如果您更喜欢代码而不是UI）使用image.inside () {} 命令执行此操作。

基本上所有这些都烘焙到您的CI/CD服务器中，然后一些。

我发布这个给任何使用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目录。

希望有一天能对大家有用：）

TLDR；

$ docker run --rm -iv${PWD}:/host-volume my-image sh -s <<EOFchown $(id -u):$(id -g) my-artifact.tar.xzcp -a my-artifact.tar.xz /host-volumeEOF

特性介绍

docker run为主机卷，chown为工件，cp为主机卷的工件：

$ docker build -t my-image - <<EOF> FROM busybox> WORKDIR /workdir> RUN touch foo.txt bar.txt qux.txt> EOFSending build context to Docker daemon  2.048kBStep 1/3 : FROM busybox---> 00f017a8c2a6Step 2/3 : WORKDIR /workdir---> Using cache---> 36151d97f2c9Step 3/3 : RUN touch foo.txt bar.txt qux.txt---> Running in a657ed4f5cab---> 4dd197569e44Removing intermediate container a657ed4f5cabSuccessfully built 4dd197569e44
$ docker run --rm -iv${PWD}:/host-volume my-image sh -s <<EOFchown -v $(id -u):$(id -g) *.txtcp -va *.txt /host-volumeEOFchanged ownership of '/host-volume/bar.txt' to 10335:11111changed ownership of '/host-volume/qux.txt' to 10335:11111changed 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 -ntotal 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

这个技巧之所以有效，是因为heldoc中的chown调用从正在运行的容器外部获取$(id -u):$(id -g)值；即docker主机。

好处是：

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

在主机系统上（容器外部）创建一个数据目录并将其挂载到从容器内部可见的目录中。这将文件放置在主机系统上的已知位置，并使主机系统上的工具和应用程序可以轻松访问文件

docker run -d -v /path/to/Local_host_dir:/path/to/docker_dir docker_image:tag

如果您没有正在运行的容器，只有一个图像，并且假设您只想复制一个文本文件，您可以这样做：

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

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

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

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

大多数答案并没有表明容器必须在docker cp工作之前运行：

docker build -t IMAGE_TAG .docker run -d IMAGE_TAGCONTAINER_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

docker run -dit --rm IMAGEdocker cp CONTAINER:SRC_PATH DEST_PATH

https://docs.docker.com/engine/reference/commandline/run/https://docs.docker.com/engine/reference/commandline/cp/

创建一个要复制文件的路径，然后使用：

docker run -d -v hostpath:dockerimag

您不需要使用docker run。

你可以用docker create来做。

从的文档：

docker create命令在指定的映像上创建一个可写的容器层，并准备好运行指定的命令。然后将容器ID打印到STDOUT。这与docker run -d类似，只是容器从未启动。

所以，你可以这样做：

docker create --name dummy IMAGE_NAMEdocker cp dummy:/path/to/file /dest/to/filedocker rm -f dummy

在这里，你从来没有启动容器。这看起来对我有益。

我将PowerShell（Admin）与此命令一起使用。

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

示例

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

如果您只想挂载一个文件夹，而不是为容器创建特殊存储，则可以使用bind而不是volume：

1. 使用标签构建您的图像：

   docker build . -t <image>

2. 运行映像并绑定app.py存储的当前$（pwd）目录，并将其映射到容器内的 /root/example/。

   docker run --mount type=bind,source="$(pwd)",target=/root/example/ <image> python app.py

随着Docker 19.03的发布，您可以跳过创建容器甚至构建映像。基于BuildKit的构建有一个选项来更改输出目标。您可以使用它将构建结果写入本地目录而不是映像。例如。这是go二进制的构建：

$ lsDockerfile  go.mod  main.go
$ cat DockerfileFROM golang:1.12-alpine as devRUN apk add --no-cache git ca-certificatesRUN adduser -D appuserWORKDIR /srcCOPY . /src/CMD CGO_ENABLED=0 go build -o app . && ./app
FROM dev as buildRUN CGO_ENABLED=0 go build -o app .USER appuserCMD [ "./app" ]
FROM scratch as releaseCOPY --from=build /etc/passwd /etc/group /etc/COPY --from=build /src/app /appUSER appuserCMD [ "/app" ]
FROM scratch as artifactCOPY --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二进制文件被导出：

$ lsDockerfile  app  go.mod  main.go
$ ./appReady to receive requests on port 8080

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

这也可以在SDK中完成，例如python。如果您已经构建了一个容器，您可以通过控制台查找名称（docker ps -a）名称似乎是科学家和形容词的连接（即“relaxed_pasteur”）。

查看help(container.get_archive)：

Help on method get_archive in module docker.models.containers:
get_archive(path, chunk_size=2097152) method of docker.models.containers.Container instanceRetrieve a file or folder from the container in the form of a tararchive.
Args:path (str): Path to the file or folder to retrievechunk_size (int): The number of bytes returned by each iterationof the generator. If ``None``, data will be streamed as it isreceived. Default: 2 MB
Returns:(tuple): First element is a raw tar data stream. Second element isa dict containing ``stat`` information on the specified ``path``.
Raises::py:class:`docker.errors.APIError`If the server returns an error.
Example:
>>> f = open('./sh_bin.tar', 'wb')>>> bits, stat = container.get_archive('/bin/sh')>>> print(stat){'name': 'sh', 'size': 1075464, 'mode': 493,'mtime': '2018-10-01T15:37:48-07:00', 'linkTarget': ''}>>> for chunk in bits:...    f.write(chunk)>>> f.close()

因此，类似这样的东西将从容器中的指定路径（ /output）拉出到您的主机并解压缩tar。

import dockerimport osimport tarfile
# Docker clientclient = docker.from_env()#container objectcontainer = client.containers.get("relaxed_pasteur")#setup tar to write bits tof = open(os.path.join(os.getcwd(),"output.tar"),"wb")#get the bitsbits, stat = container.get_archive('/output')#write the bitsfor chunk in bits:f.write(chunk)f.close()#unpacktar = tarfile.open("output.tar")tar.extractall()tar.close()

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

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允许您引入一个命令作为参数，该命令将您的作业文件复制到容器路径。

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

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

docker cp containerId:source_path destination_path

容器ID可以从命令docker ps -a获得

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

示例：docker cp d86844abc129：/app/server/输出/server-test.pngC：/用户/某人/桌面/输出

如果您使用podman/建筑¹，它为将文件从容器复制到主机提供了更大的灵活性，因为它允许您挂载容器。

创建容器后，如回答所示

podman create --name dummy IMAGE_NAME

现在我们可以挂载整个容器，然后我们使用几乎每个linux盒子中的cp实用程序将/etc/foobar的内容从容器（dummy）复制到我们主机上的/tmp中。所有这些都可以完成无根。观察：

$ podman unshare -- bash -c 'mnt=$(podman mount dummy)cp -R ${mnt}/etc/foobar /tmppodman umount dummy'

^1.Podman在内部使用Buildah，它们也共享几乎相同的api

如果您需要一个小文件，您可以使用此部分

里面的Docker容器

docker run-it-p 4122:4122

nc -l -p 4122 < Output.txt

主机

nc 127.0.0.1 4122 > Output.txt

从从DockerContainer到LocalMachine

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

从从本地机器到DockerContainer

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

Docker cp[选项]SRC_PATH容器：DEST_PATH

DEST_PATH必须预先存在

最简单的方法是创建一个容器，获取ID，然后从那里复制

IMAGE_TAG=my-image-tagcontainer=$(docker create ${IMAGE_TAG})docker cp ${container}:/src-path ./dst-path/

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

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

反之亦然：

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

对于任何试图使用MySQL容器并将卷本地存储在您的机器上的人来说。我使用了对这个问题的顶级回复中提供的语法。但必须使用特定于MySQL的特定路径

docker cp imageIdHere:/var/lib/mysql pathToYourLocalMachineHere