我正在考虑使用Docker在持续集成（CI）服务器上构建我的依赖项，这样我就不必在代理本身上安装所有运行时和库。
为了实现这一点，我需要将容器内部构建的构建工件复制回主机。这可能吗？
答案 0 :(得分：2145)
要将文件从容器复制到主机，可以使用命令
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
答案 1 :(得分：74)
装载＆＃34;卷＆＃34;并将工件复制到那里：
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目录中。
警告：执行此操作时，您可能会遇到与当前正在运行的用户的用户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
答案 2 :(得分：45)
您不需要使用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 -fv dummy
在这里，您永远不会启动容器。这对我来说很有益。
答案 3 :(得分：20)
装载卷，复制工件，调整所有者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
答案 4 :(得分：17)
$ 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
这个技巧有效，因为chown内的$(id -u):$(id -g)调用从正在运行的容器外部取docker container run --name个值;即码头主持人。
好处是：
docker container create --name或docker container rm
Site<-get_download(20131, verbose = TRUE)
taxa<-as.vector(Site$'20131'$taxon.list$taxon.name)
答案 5 :(得分：13)
如果您没有正在运行的容器，只有图像，并且假设您只想复制文本文件，则可以执行以下操作：
docker run the-image cat path/to/container/file.txt > path/to/host/file.txt
答案 6 :(得分：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
答案 7 :(得分：6)
我正在为使用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目录。
我希望有一天这对某人有用。 ：）
答案 8 :(得分：5)
另一个不错的选择是先构建容器，然后使用-c标志和外壳解释器运行容器以执行一些命令
SELECT active AS task_active, name AS task_name FROM task...
以上命令执行此操作：
-i =以交互模式运行容器
-rm =执行后删除了容器。
-v =从主机路径到容器路径将一个文件夹作为卷共享。
最后，/ bin / sh -c允许您引入一个命令作为参数，该命令会将您的家庭作业文件复制到容器路径。
我希望这个额外的答案可以对您有所帮助
答案 9 :(得分：3)
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/
答案 10 :(得分：3)
作为更通用的解决方案，there's a CloudBees plugin for Jenkins to build inside a Docker container。您可以从Docker注册表中选择要使用的映像，或者定义要构建和使用的Dockerfile。
它将工作区作为卷（使用适当的用户）安装到容器中，将其设置为工作目录，执行您请求的任何命令（在容器内）。 您还可以使用docker-workflow插件（如果您更喜欢基于UI的代码）使用image.inside（）{}命令执行此操作。
基本上所有这些都融入了您的CI / CD服务器，然后是一些。
答案 11 :(得分：2)
如果您只想从图像（而不是正在运行的容器）中提取文件，则可以执行以下操作：
docker run --rm <image> cat <source> > <local_dest>
这将打开容器，写入新文件，然后删除容器。但是，一个缺点是不会保留文件权限和修改日期。
答案 12 :(得分：2)
在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
答案 13 :(得分：2)
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
答案 14 :(得分：1)
我在此命令中使用了PowerShell（Admin）。
docker cp {container id}:{container path}/error.html C:\\error.html
示例
docker cp ff3a6608467d:/var/www/app/error.html C:\\error.html
答案 15 :(得分：1)
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
答案 16 :(得分：0)
创建要在其中复制文件的路径，然后使用：
docker run -d -v hostpath:dockerimag
答案 17 :(得分：0)
如果您只想装载一个文件夹，而不是为容器创建特殊存储，则可以使用bind代替volume：
使用标记构建图像：
docker build . -t <image>
运行图像，并将当前$（pwd）目录绑定到app.py存储的目录，并将其映射到容器内的/ root / example/。
docker run --mount type=bind,source="$(pwd)",target=/root/example/ <image> python app.py
答案 18 :(得分：0)
这也可以在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 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()
答案 19 :(得分：0)
如果您使用 podman/buildah1，它将为将文件从容器复制到主机提供更大的灵活性，因为它允许您挂载容器。 >
在您创建容器之后answer
podman create --name dummy IMAGE_NAME
现在我们可以挂载整个容器，然后我们使用几乎在每个 linux box 中都能找到的 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
答案 20 :(得分：-1)
在主机系统（容器外）上创建一个数据目录，并将其挂载到容器内可见的目录中。这会将文件放在主机系统上的已知位置，并使主机系统上的工具和应用程序可以轻松访问文件
element.all(by.css(".sidesection>p>a")).getText().then(function(menus){
for(var i=0; i<array.length; i++){
expect(menus.indexOf(array[i])!=-1).toBeTruthy();
}
});