【问题标题】:Docker: Copying files from Docker container to hostDocker:将文件从 Docker 容器复制到主机
【发布时间】:2014-03-29 17:49:49
【问题描述】:

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

要实现这一点,我需要将容器内构建的构建工件复制回主机。这可能吗?

【问题讨论】:

标签: docker docker-container file-copying


【解决方案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

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

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

【讨论】:

  • 如果您只是将 docker 用于临时 Linux 环境,这是获取最新容器的便捷方法:docker ps -alq
  • 这个 cp 命令也可以按原样用于复制目录树(不仅仅是单个文件)。
  • 在较新版本的 docker 中,您可以使用docker cp ...进行双向复制(主机到容器或容器到主机)
  • 我需要docker cp -L 来复制符号链接
  • 注意:容器不一定要运行才能使用 cp 命令。如果您的容器经常崩溃,这会很方便。
【解决方案2】:

安装一个“卷”并将工件复制到那里:

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

【讨论】:

  • 其实你可以使用chown命令来匹配宿主机上的user id和group id。
  • 我要给你买啤酒伴侣!谢谢!
【解决方案3】:

挂载卷、复制工件、调整所有者 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 -g)
chown -R $(id -u):$(id -g) /mnt/artifacts
COMMANDS

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

【讨论】:

  • 已编辑以澄清我几乎错过的一些事情。顺便说一句,我不确定您为什么将其更改为 user:user 而不是 user:group 但看起来不错!
【解决方案4】:

作为更通用的解决方案,there's a CloudBees plugin for Jenkins to build inside a Docker container。您可以从 Docker 注册表中选择要使用的映像,或者定义要构建和使用的 Dockerfile。

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

基本上所有这些,都嵌入到您的 CI/CD 服务器中,然后是一些。

【讨论】:

    【解决方案5】:

    我为使用 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 目录。

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

    【讨论】:

    • 如果您使用 docker-compose,volumes-from 在版本 3 及更高版本中已弃用。
    • 要添加到 mulg0r 的评论,请参阅 stackoverflow.com/a/45495380/199364 - 在 v.3 中,您将 volumes 命令放在 config.yml 的根目录中,以便多个容器可以访问卷。
    【解决方案6】:

    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 主机。

    好处是:

    • 之前您不必docker container run --namedocker container create --name
    • 之后您不必docker container rm

    【讨论】:

    • 赞成cp 和基于数量的答案之间的比较。此外,对于 id 所有权的技巧,这有时确实令人头疼
    【解决方案7】:

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

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

    【讨论】:

    • 这使您可以将目录及其内容从主机注入到容器中。它不允许您将文件从容器复制回主机。
    • 如果主机文件夹的权限非常宽,会这样吗?
    【解决方案8】:

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

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

    【讨论】:

    • 这会将文件从容器中的一个位置复制到容器中的其他位置。除非您将主机上的文件夹作为卷挂载,否则&gt; 之后的路径不一定是主机上的路径。
    【解决方案9】:

    如果您只想从 图像(而不是正在运行的容器)中提取文件,您可以这样做:

    docker run --rm &lt;image&gt; cat &lt;source&gt; &gt; &lt;local_dest&gt;

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

    【讨论】:

      【解决方案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
      

      【讨论】:

      • 顺便说一句,容器必须/可能是否运行/停止/任一似乎取决于主机类型/虚拟化技术Current docker doc 说“容器可以是正在运行或停止的容器。”。 SO上的多个地方,包括对已接受答案的评论,说“这也适用于停止的容器”。在Windows Hyper-V 下,stop container before copying a file 显然是必要的
      【解决方案11】:

      【讨论】:

        【解决方案12】:

        创建要复制文件的路径,然后使用:

        docker run -d -v hostpath:dockerimag
        

        【讨论】:

          【解决方案13】:

          您不需要使用docker run

          你可以用docker create来做。

          来自the docs

          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
          

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

          【讨论】:

          • 这需要更多的支持。非常适合您只需要在容器中构建一些东西然后复制输出。
          • @HonzaKalfus 我同意这需要更高。这正是我所追求的。我使用它是为了可以使用已知环境(特定版本的 amazon linux)构建一些二进制文件。能够制作一个完全构建 docker 并从中提取生成的二进制文件的 shell 脚本!完美。
          • 是否需要-tibash
          • @jII,我已经这样做了,因为后来我在它上面运行了 docker run。在简单的情况下,它不是必需的,但在这里也没有害处。
          • 这个答案非常适合在 Azure 中构建管道,因此您不必尝试找出容器 ID 最终是什么。
          【解决方案14】:

          我在这个命令中使用了 PowerShell(管理员)。

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

          示例

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

          【讨论】:

            【解决方案15】:

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

            1. 用标签构建你的图像:

              docker build . -t &lt;image&gt;

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

              docker run --mount type=bind,source="$(pwd)",target=/root/example/ &lt;image&gt; python app.py

            【讨论】:

              【解决方案16】:

              随着 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 在其上游 BuildKit 存储库中记录了 --output 标志的其他选项:https://github.com/moby/buildkit#output

              【讨论】:

              • 标准构建缓存不用于构建输出,这很糟糕
              • @burtsevyg Buildkit 是一个不同的构建器,使用不同的缓存环境。它的缓存效率更高。
              【解决方案17】:

              这也可以在 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()
              

              【讨论】:

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

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

                【讨论】:

                  【解决方案19】:
                  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
                  

                  【讨论】:

                    【解决方案20】:
                    docker cp containerId:source_path destination_path
                    

                    containerId可以通过命令docker ps -a获取

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

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

                    【讨论】:

                      【解决方案21】:

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

                      在创建容器后,如answer

                      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 /tmp
                        podman umount dummy
                      '
                      

                      1.podman 内部使用 buildah,它们也共享几乎相同的 api

                      【讨论】:

                        【解决方案22】:

                        如果你需要一个小文件,你可以使用这个部分

                        里面的 Docker 容器

                        docker run -it -p 4122:4122

                        nc -l -p 4122 < Output.txt
                        

                        主机

                        nc 127.0.0.1 4122 > Output.txt
                        

                        【讨论】:

                          【解决方案23】:

                          对于 Windows:

                          DockerContainer 到 LocalMachine

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

                          LocalMachine 到 DockerContainer

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

                          【讨论】:

                            【解决方案24】:

                            docker cp [OPTIONS] SRC_PATH CONTAINER:DEST_PATH

                            DEST_PATH 必须预先存在

                            【讨论】:

                              【解决方案25】:

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

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

                              【讨论】:

                                猜你喜欢
                                • 2015-07-08
                                • 1970-01-01
                                • 2020-01-03
                                • 2014-05-19
                                • 1970-01-01
                                • 1970-01-01
                                相关资源
                                最近更新 更多