Copiar ficheiros a partir da janela de Encaixe o recipiente para o host
https://stackoverflow.com//questions/22049212
-
21-12-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Estou pensando em usar a janela de Encaixe para construir a minha dependências em uma Integração Contínua (CI) do servidor, de modo que eu não tenho que instalar todos os tempos de execução e bibliotecas sobre os próprios agentes.
Para conseguir isso eu precisaria para copiar a construir artefatos que são construídos no interior do recipiente de volta para o host.Isso é possível?
Solução
Para copiar um ficheiro a partir de um recipiente para o host, você pode usar o comando
docker cp <containerId>:/file/path/within/container /host/path/target
Aqui está um exemplo:
$ sudo docker cp goofy_roentgen:/out_read.jpg .
Aqui goofy_roentgen é o nome do contentor eu tenho de o seguinte comando:
$ 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
Você também pode usar (ou parte do) ID do recipiente.O seguinte comando é equivalente ao primeiro
$ sudo docker cp 1b4a:/out_read.jpg .
Outras dicas
Você não precisa usar docker run
Você pode fazer isso com docker create
A partir do google docs A janela de encaixe comando create cria um gravável de camada de contêiner sobre a imagem especificada e prepara-lo para executar o comando especificado.O recipiente de IDENTIFICAÇÃO, em seguida, impresso para o STDOUT.Isso é semelhante à janela de encaixe de execução -d, exceto o recipiente é nunca começou.
Assim, você pode fazer
docker create -ti --name dummy IMAGE_NAME bash
docker cp dummy:/path/to/file /dest/to/file
docker rm -f dummy
Aqui, você nunca inicie o recipiente.Que parecia benéfico para mim.
Montar um "volume" e copie os artefatos para lá:
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
Em seguida, quando termina a compilação e o recipiente não é executado, ele já copiou os artefatos da compilação para o artifacts diretório no host.
Editar
Ressalva: Quando você fizer isso, você pode executar em problemas com a id de usuário da janela de encaixe usuário corresponder o id de utilizador de execução atual do usuário.Isto é, os arquivos em /artifacts será mostrado como propriedade do utilizador com o UID do usuário usado dentro da janela de encaixe recipiente.Uma maneira de contornar isso pode ser usar a chamar o UID do utilizador:
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
Montar um volume, copie os artefatos, ajustar o id do proprietário e identificação do grupo:
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
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
Descrição
docker run com um volume do host, chown o artefato, cp o artefato para o volume do host:
$ 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
Esse truque funciona porque o chown invocação dentro do heredoc a demora $(id -u):$(id -g) valores a partir de fora a execução do recipiente;por exemplo, a janela de encaixe host.
Os benefícios são:
- você não tem que
docker container run --nameoudocker container create --nameantes de - você não tem que
docker container rmdepois de
Se você não tem uma execução recipiente, apenas uma imagem, e supondo que você deseja copiar apenas um arquivo de texto, você poderia fazer algo assim:
docker run the-image cat path/to/container/file.txt > path/to/host/file.txt
A maioria das respostas não indicam que o recipiente deve executar antes de docker cp vai funcionar:
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
Estou postando isso para alguém que está usando a janela de Encaixe para Mac.Isso é o que funcionou para mim:
$ mkdir mybackup # local directory on Mac
$ docker run --rm --volumes-from <containerid> \
-v `pwd`/mybackup:/backup \
busybox \
cp /data/mydata.txt /backup
Observe que, quando eu montar usando -v que backup diretório é criado automaticamente.
Espero que este seja útil para alguém um dia.:)
como uma solução mais geral, há umCloudbees plugin para Jenkins para construir dentro de um contêiner de encaixe .Você pode selecionar uma imagem para usar de um registro de Docker ou definir um DockerFile para construir e usar.
Montará o espaço de trabalho no contêiner como um volume (com o usuário apropriado), configurá-lo como seu diretório de trabalho, faça quaisquer comandos solicitados (dentro do contêiner). Você também pode usar o plugin do fluxo de trabalho do Docker (se preferir o código UI) para fazer isso, com o comando image.inside () {}.
Basicamente tudo isso, cozido no servidor CI / CD e depois alguns.
Se você quiser apenas para extrair um arquivo de um imagem (em vez de um recipiente) você pode fazer isso:
docker run --rm <image> cat <source> > <local_dest>
Isto irá abrir o recipiente, gravar o novo arquivo e, em seguida, remover o recipiente.Uma desvantagem, no entanto, é que as permissões de ficheiro e a data de modificação não será preservado.
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/
Eu usei PowerShell (Admin) com este comando.
docker cp {container id}:{container path}/error.html C:\\error.html
Exemplo
docker cp ff3a6608467d:/var/www/app/error.html C:\\error.html
Com o lançamento da janela de Encaixe 19.03, você pode ignorar a criar o recipiente e mesmo a construção de uma imagem.Há uma opção com BuildKit com base cria para alterar o destino de saída.Você pode usar isso para escrever os resultados da compilação para o seu diretório local, em vez de em uma imagem.E. g.aqui está uma compilação de ir binário:
$ 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
A partir do exposto acima Dockerfile, eu estou construindo a artifact fase que inclui apenas os arquivos que deseja exportar.E o recém-lançado --output bandeira me permite escrever os para um diretório local em vez de uma imagem.Isso precisa ser realizada com o BuildKit do motor que acompanha o 19.03:
$ 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
Após a compilação foi concluída a app binário foi exportada:
$ ls
Dockerfile app go.mod main.go
$ ./app
Ready to receive requests on port 8080
Janela de encaixe tem outras opções para a --output bandeira documentado em seu montante BuildKit repo: https://github.com/moby/buildkit#output
Criar um diretório de dados no sistema host (fora da embalagem) e montar isso para um diretório visível a partir do interior do recipiente.Isso coloca os arquivos em um local conhecido no sistema host, e torna mais fácil para ferramentas e aplicativos no host do sistema para acesso a arquivos
docker run -d -v /path/to/Local_host_dir:/path/to/docker_dir docker_image:tag
Criar um caminho onde você deseja copiar o arquivo e, em seguida, use:
docker run -d -v hostpath:dockerimag
Você pode usar bind em vez de volume se você deseja montar apenas uma pasta, e não criar condições especiais de armazenamento para um recipiente:
Criar sua imagem com a tag :
docker build . -t <image>Execute sua imagem e vincular atuais us $(pwd) diretório onde app.py lojas e mapeá-lo para o /root/exemplo/ dentro de seu recipiente.
docker run --mount type=bind,source="$(pwd)",target=/root/example/ <image> python app.py
