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


1705

我正在考虑使用Docker在持续集成(CI)服务器上构建我的依赖项,这样我就不必在代理程序本身上安装所有运行时和库。

为此,我需要将容器内部构建的构建工件复制回主机。那可能吗?


你们可能在这里喜欢我的黑客方法:stackoverflow.com/a/55876794/990618
colin lamarre

1
答案底部来自Docker船长的正确答案和实际答案。
burtsevyg

Answers:


2939

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

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

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

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

42
如果您只是在临时Linux环境中使用docker,这是一种获取最新容器的便捷方法:docker ps -alq
乔什·哈布达斯

37
此cp命令也可以按原样工作以复制目录树(不仅仅是单个文件)。
ecoe

88
在较新版本的docker中,您可以使用docker cp ...
Freedom_Ben

9
我需要docker cp -L复制符号链接
Harrison Powers

24
注意:容器不必运行即可使用cp命令。如果您的容器经常崩溃,则非常方便。
Martlark

219

您不需要使用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

在这里,您永远不会启动容器。这对我来说看起来很有益。


19
这需要更多的投票。非常适合只需要在容器中构建某些东西然后复制输出的情况。
Honza Kalfus

4
@HonzaKalfus我同意这需要更高。这正是我所追求的。我用它来使用已知环境(特定版本的amazon linux)构建一些二进制文件。能够制作一个完全构建docker并从中提取生成的二进制文件的shell脚本!完善。
标记

1
-ti必需的还是bash必需的?
jII

@jII,我这样做是因为稍后,我在上面运行了docker。在简单的情况下,它不是必需的,但在这里也无害。
伊桑·巴特

是否可以使用通配符?我的意思是...我不知道我需要复制的文件的确切名称,因为它上面有版本号。
juzzlin

87

挂载“卷”,然后将工件复制到其中:

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主机上的目录中。

编辑

注意:执行此操作时,可能会遇到docker用户的用户ID与当前运行用户的用户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

7
实际上,您可以使用chown命令来匹配主机上的用户ID和组ID。
Dimchansky


已经做到了,那将行不通。一旦容器第一次将文件复制到该卷,下一次,该卷将不再为空,并且新的文件也不会覆盖这些文件。容器优先于主机文件(首次安装容器映像时复制的主机文件)。
Frondor

听起来像是自己的问题@Frondor
djhaskin987

1
我要给你买啤酒伴侣!谢谢!
Dimitar Vukman,

27

挂载卷,复制工件,调整所有者标识和组标识:

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

24

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

这个技巧之所以有效,是因为chownHeredoc中的调用$(id -u):$(id -g)从正在运行的容器外部获取值。即码头工人主机。

好处是:

  • 您不必docker container run --namedocker container create --name之前
  • 你不必docker container rm追求

2
为与cp基于答案的答案进行比较而推荐。此外,对于id所有权的trick
俩,

18

大多数答案并不表示该容器必须先运行,然后才能运行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

3
顺便说一句,无论容器必须/可以运行/停止/或者似乎取决于类型的主机/虚拟化技术当前的Docker文档说:“容器可以是正在运行或已停止的容器。”。在SO上的多个位置,包括对已接受答案的评论,都说“这在停止的容器上也有效”。在Windows Hyper-V,这显然是必要的,以复制文件之前停止容器
ToolmakerSteve

容器停止时,复制也可以进行。
路加福音

17

如果您没有正在运行的容器,而只是一个图像,并且假设只想复制一个文本文件,则可以执行以下操作:

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

7

我要为使用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 

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

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


如果使用docker-compose,在版本3及更高版本中不建议使用volume-from。
mulg0r

要添加到mulg0r的注释中,请参阅stackoverflow.com/a/45495380/199364-在v.3中,将volumes命令放置在config.yml的根目录中,以使多个容器可以访问卷。
ToolmakerSteve

5

如果只想从映像中提取文件(而不是正在运行的容器),则可以执行以下操作:

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

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



5

在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


标准构建缓存不用于带有输出的构建,这很糟糕
burtsevyg

@burtsevyg Buildkit是一个不同的生成器,使用了不同的缓存环境。它的缓存效率更高。
BMitch

谢谢,我将改善我的构建节点。
burtsevyg

4

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

它将工作空间作为卷(使用适当的用户)安装到容器中,将其设置为工作目录,执行您请求的任何命令(在容器内部)。您也可以通过image.inside(){}命令使用docker-workflow插件(如果您更喜欢UI而不是代码)来执行此操作。

基本上,所有这些都放入CI / CD服务器,然后再放入其中。


4

我在此命令中使用了PowerShell(Admin)。

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

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

2

另一个不错的选择是首先构建容器,然后使用带有解释器解释器的-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让您引入一个命令作为参数,该命令会将您的家庭作业文件复制到容器路径。

我希望这个额外的答案可以对您有所帮助


1

在主机系统上(容器外部)创建一个数据目录,并将其安装到从容器内部可见的目录中。这会将文件放置在主机系统上的已知位置,并使主机系统上的工具和应用程序易于访问文件

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

4
这样就可以将目录及其内容从主机注入到容器中。它不允许您将文件从容器复制回主机。
BMitch

如果主机文件夹具有非常宽的权限,该怎么办?
giorgiosironi


0

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

  1. 使用标签构建图片:

    docker build . -t <image>

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

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


0

这也可以在SDK中完成,例如python。如果您已经建立了一个容器,则可以通过控制台(docker ps -a)查找名称,该名称似乎是科学家和形容词的某种组合(即“ relaxed_pa​​steur”)。

签出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 instance
    Retrieve a file or folder from the container in the form of a tar
    archive.

    Args:
        path (str): Path to the file or folder to retrieve
        chunk_size (int): The number of bytes returned by each iteration
            of the generator. If ``None``, data will be streamed as it is
            received. Default: 2 MB

    Returns:
        (tuple): First element is a raw tar data stream. Second element is
        a 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 docker
import os
import tarfile

# Docker client
client = docker.from_env()
#container object
container = client.containers.get("relaxed_pasteur")
#setup tar to write bits to
f = open(os.path.join(os.getcwd(),"output.tar"),"wb")
#get the bits
bits, stat = container.get_archive('/output')
#write the bits
for chunk in bits:
    f.write(chunk)
f.close()
#unpack
tar = tarfile.open("output.tar")
tar.extractall()
tar.close()
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.