Copierea fișierelor din Docker container pentru a găzdui

Am'm de gândire de a folosi Docker să-mi construiesc dependențe pe un Continuous Integration (CI) server, așa că eu nu't trebuie să instalați toate runtime-uri și biblioteci de pe agenții ei înșiși.

Pentru a realiza acest lucru am nevoie pentru a copia construi artefacte care sunt construite în interiorul containerului înapoi în gazdă. Este posibil?

Andry
Întrebarea editată 21 martie 2019 в 11:45
Programare
docker file-copying docker-container
26 februarie 2014 в 5:46
10 vizualizări
Comentarii la întrebare (1)
Soluția

Pentru a copia un fișier de la un container la gazdă, puteți folosi comanda

docker cp :/file/path/within/container /host/path/target

Aici's un exemplu:

$ sudo docker cp goofy_roentgen:/out_read.jpg .

Aici goofy_roentgen este numele containerului am primit de la următoarea comandă:

$ 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

Puteți folosi, de asemenea, (o parte din) Container ID. Următoarea comandă este echivalentă cu prima

$ sudo docker cp 1b4a:/out_read.jpg .
GM 180
Răspuns editat 7 noiembrie 2019 в 3:25
Comentarii (19)

Nu aveți nevoie pentru a utiliza docker run

O poti face cu docker crea`

Din docs Docher crea comandă creează o inscriptibil recipient strat peste imaginea specificată și o pregătește pentru funcționare specificate de comandă. Recipientul ID-ul este apoi tipărite la STDOUT. Acest lucru este similar cu docker run-d, cu excepția recipientului nu este pornit.

Deci, puteți face

docker create -ti --name dummy IMAGE_NAME bash
docker cp dummy:/path/to/file /dest/to/file
docker rm -f dummy

Aici, n-ai începe container. Care părea benefic pentru mine.

Ishan Bhatt
Răspuns editat 11 septembrie 2019 в 11:31
Comentarii (6)

De montare a "volumul" și copia artefacte într-acolo:


mkdir artifacts
docker run -i -v ${PWD}/artifacts:/artifacts ubuntu:14.04 sh
Andry
Răspuns editat 21 martie 2019 в 11:42
Comentarii (6)

Monta un volum, copiați artefacte, pentru a regla proprietar id-ul și id-ul grupului:

mkdir artifacts
docker run -i --rm -v ${PWD}/artifacts:/mnt/artifacts centos:6 /bin/bash  /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
Comentarii (0)

TLDR;


$ docker run --rm -iv${PWD}:/host-volume my-image sh -s
Andry
Răspuns editat 21 martie 2019 в 11:43
Comentarii (1)

Dacă tu nu't au o funcționare container, doar o imagine, și presupunând că doriți să copiați un fișier text, ai putea face ceva de genul asta: 

docker run the-image cat path/to/container/file.txt > path/to/host/file.txt
Comentarii (0)

Cele mai multe dintre răspunsuri nu indică faptul că recipientul trebuie să ruleze înainte de docker cp va lucra:

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
Comentarii (1)

Am posta acest lucru pentru oricine care utilizează Docker pentru Mac. Aceasta este ceea ce a lucrat pentru mine:

 $ mkdir mybackup # local directory on Mac

 $ docker run --rm --volumes-from  \
    -v `pwd`/mybackup:/backup \  
    busybox \                   
    cp /data/mydata.txt /backup

Rețineți că, atunci când am monta folosind -v că backup director este creat automat.

Sper că acest lucru este util pentru cineva într-o zi. :)

Comentarii (2)

Ca o soluție generală, acolo's o CloudBees plugin pentru Jenkins a construi în interiorul unui container Docker. Puteți selecta o imagine pentru a folosi la un Docher registru sau defini o Dockerfile de a construi și de a folosi.

L'll monta spațiu de lucru în recipient ca un volum (cu utilizare corespunzător), setați-l ca director de lucru, face tot ce poruncește cerere (în interiorul containerului). Puteți folosi, de asemenea, docker-flux de lucru plugin (dacă preferați cod UI) pentru a face acest lucru, cu imaginea.în interiorul() {} comanda.

Practic toate acestea, coapte în CI/CD server și apoi unele.

Comentarii (0)
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/

Comentarii (0)

Dacă doriți doar să trageți un fișier dintr-un imagine (în loc de o funcționare container), puteți face acest lucru:

docker termen-rm <imagine> cat <sursa> > <local_dest>

Acest lucru va aduce containerul, scrie noul fișier, apoi scoateți recipientul. Un dezavantaj, cu toate acestea, este că permisiunile de fișiere și a modificat data nu vor fi păstrate.

Comentarii (0)

Am folosit PowerShell (Admin) cu această comandă.

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

Exemplu

docker cp ff3a6608467d:/var/www/app/error.html  C:\\error.html
Comentarii (0)

Cu eliberarea de Docker 19.03, puteți sări crearea containerului și chiar construirea unei imagini. Nu's o opțiune cu BuildKit bazat construiește pentru a schimba destinația de ieșire. Puteți utiliza acest pentru a scrie rezultatele construi la directorul local, mai degrabă decât într-o imagine. E. g. aici's a construi un du-te binar:

$ 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

Din cele de mai sus Dockerfile, am'm construirea artefact etapă, care include doar fișierele vreau sa export. Și nou introdus --output flag-mi permite să scriu cei de la un director local în loc de o imagine. Acest lucru trebuie să fie efectuate cu BuildKit motor care navele cu 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

După ce clădirea a fost complet " app " binar fost exportate:

$ ls
Dockerfile  app  go.mod  main.go

$ ./app
Ready to receive requests on port 8080

Docker are alte opțiuni pentru --ieșire pavilion documentat în amonte BuildKit repo: https://github.com/moby/buildkit#output

BMitch
Răspuns editat 7 noiembrie 2019 в 5:49
Comentarii (0)

A crea o cale în cazul în care doriți să copiați fișierul și apoi utilizați:

docker run -d -v hostpath:dockerimag
Peter Mortensen
Răspuns editat 23 iulie 2018 в 11:00
Comentarii (0)

Creați un director de date de pe sistemul gazdă (în afara containerului) și muntele asta de la un director vizibil din interiorul containerului. Acest lucru pune fișierele într-o locație cunoscută pe sistemul gazdă, și îl face ușor pentru instrumente și aplicații de pe sistemul gazdă pentru a accesa fișierele

docker run -d -v /path/to/Local_host_dir:/path/to/docker_dir docker_image:tag
Comentarii (2)

Puteți utiliza încurcătură în loc de volum dacă doriți să montați un singur dosar, nu să creeze speciale de depozitare pentru un recipient:

  1. Construi imaginea dvs. cu tag-ul :

docker construi . -t <imagine> 2. Rula imaginea și se leagă de curent $(pwd) directorul unde app.py magazine și o hartă a /root/exemplu/ în interiorul containerului.

docker rula --muntele tip=a lega,sursa="$(pwd)",target=/root/exemplu/ <imagine> python app.py

Comentarii (0)