คัดลอกไฟล์จากคอนเทนเนอร์ Docker ไปยังโฮสต์


1708

ฉันกำลังคิดที่จะใช้นักเทียบท่าเพื่อสร้างการพึ่งพาของฉันบนเซิร์ฟเวอร์การรวมอย่างต่อเนื่อง (CI) ดังนั้นฉันจึงไม่ต้องติดตั้ง runtimes และไลบรารีทั้งหมดในเอเจนต์ด้วยตนเอง

เพื่อให้บรรลุนี้ฉันจะต้องคัดลอกการสร้างสิ่งประดิษฐ์ที่สร้างขึ้นภายในภาชนะกลับเข้าไปในโฮสต์ เป็นไปได้ไหม


พวกคุณอาจชอบวิธีแฮ็กเกอร์ของฉันที่นี่: stackoverflow.com/a/55876794/990618
colin lamarre

1
คำตอบที่ถูกต้องและเป็นจริงจากกัปตันนักเทียบท่าที่ด้านล่างของคำตอบ
burtsevyg

คำตอบ:


2945

ในการคัดลอกไฟล์จากคอนเทนเนอร์ไปยังโฮสต์คุณสามารถใช้คำสั่ง

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

นอกจากนี้คุณยังสามารถใช้ (ส่วนหนึ่งของ) เดอะรหัสคอนเทนเนอร์ คำสั่งต่อไปนี้เทียบเท่ากับคำสั่งแรก

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

42
docker ps -alqนี่คือวิธีที่มีประโยชน์ที่จะได้รับตู้คอนเทนเนอร์ล่าสุดของคุณถ้าคุณเพียงแค่ใช้นักเทียบท่าสำหรับสภาพแวดล้อมอุณหภูมิลินุกซ์:
Josh Habdas

37
คำสั่ง cp นี้ทำงานตามที่เป็นอยู่สำหรับการคัดลอกแผนผังไดเร็กทอรีด้วย (ไม่ใช่แค่ไฟล์เดียว)
ecoe

88
ใน Docker เวอร์ชันใหม่คุณสามารถคัดลอกแบบสองทิศทาง (โฮสต์ไปยังคอนเทนเนอร์หรือคอนเทนเนอร์ไปยังโฮสต์) ด้วยdocker cp ...
Freedom_Ben

9
ฉันต้องการdocker cp -Lคัดลอก symlinks
Harrison Powers

24
หมายเหตุ: ไม่จำเป็นต้องเรียกใช้คอนเทนเนอร์เพื่อใช้คำสั่ง cp มีประโยชน์ถ้าภาชนะของคุณล่มตลอดเวลา
Martlark

219

docker runคุณไม่จำเป็นต้องใช้

docker createคุณสามารถทำมันได้ด้วย

จากเอกสาร :

docker createคำสั่งสร้างชั้นภาชนะเขียนได้มากกว่าภาพที่ระบุไว้และเตรียมความพร้อมสำหรับการเรียกใช้คำสั่งที่ระบุ 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
สิ่งนี้ต้องการ upvotes มากขึ้น ยอดเยี่ยมเมื่อคุณต้องการสร้างบางสิ่งในคอนเทนเนอร์แล้วคัดลอกผลลัพธ์
Honza Kalfus

4
@HonzaKalfus ฉันยอมรับความต้องการนี้ว่าจะสูงขึ้น นี่คือสิ่งที่ฉันเป็นหลังจากนั้น ฉันใช้สิ่งนี้เพื่อที่ฉันจะสามารถสร้างไฟล์ไบนารีบางอย่างโดยใช้สภาพแวดล้อมที่รู้จัก (amazon linux ในรุ่นที่ระบุ) สามารถสร้างเชลล์สคริปต์ที่สร้างตัวเชื่อมต่ออย่างสมบูรณ์และแยกไบนารีผลลัพธ์จากมัน! สมบูรณ์
มาร์ค

1
เป็น-tiสิ่งจำเป็นและbashจำเป็น?
jII

@ jII ฉันได้ทำเพราะหลังจากนั้นฉันจะเทียบท่าทำงานกับมัน ในกรณีง่าย ๆ ไม่จำเป็น แต่ก็ไม่เป็นอันตรายเช่นกัน
Ishan Bhatt

เป็นไปได้ไหมที่จะใช้อักขระตัวแทน? ฉันหมายถึง ... ฉันไม่ทราบชื่อที่แน่นอนของไฟล์ที่ฉันต้องการคัดลอกเพราะมีหมายเลขเวอร์ชันอยู่
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ไดเรกทอรีบนโฮสต์แล้ว

แก้ไข

Caveat:เมื่อคุณทำเช่นนี้คุณอาจพบปัญหากับ ID ผู้ใช้ของผู้ใช้นักเทียบท่าที่ตรงกับ ID ผู้ใช้ของผู้ใช้ปัจจุบัน นั่นคือไฟล์ที่อยู่ใน/artifactsนั้นจะแสดงเป็นเจ้าของโดยผู้ใช้ที่มี 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 ดูอ้างอิงการกำหนดค่า
djhaskin987

ทำไปแล้วและนั่นก็ไม่ได้ผล เมื่อคอนเทนเนอร์คัดลอกไฟล์ไปยังไดรฟ์ข้อมูลเป็นครั้งแรกในครั้งถัดไปวอลุ่มจะไม่ว่างอีกต่อไปและไฟล์จะไม่ถูกแทนที่โดยไฟล์ใหม่ คอนเทนเนอร์กำลังให้ความสำคัญกับไฟล์โฮสต์ (ไฟล์ที่คัดลอกในครั้งแรกที่คุณเมานต์อิมเมจคอนเทนเนอร์)
Frondor

เสียงเหมือนสิ่งที่อาจเป็นคำถามของตัวเอง @Frondor
djhaskin987

1
ฉันซื้อเบียร์ให้คุณ! ขอบคุณ!
Dimitar Vukman

27

เมานต์ไดรฟ์คัดลอกสิ่งประดิษฐ์ปรับ 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

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

เคล็ดลับนี้ใช้งานได้เนื่องจากการchownเรียกใช้ภายในheredocการรับ$(id -u):$(id -g)ค่าจากนอกคอนเทนเนอร์ที่กำลังทำงานอยู่ เช่นโฮสต์นักเทียบท่า

ประโยชน์คือ:

  • คุณไม่จำเป็นต้องdocker container run --nameหรือdocker container create --nameก่อน
  • คุณไม่จำเป็นต้องทำdocker container rmหลังจากนั้น

2
เพิ่มขึ้นสำหรับการเปรียบเทียบระหว่างcpและคำตอบตามปริมาณ นอกจากนี้สำหรับidเคล็ดลับในการเป็นเจ้าของนั่นเป็นอาการปวดหัวที่แท้จริงบางครั้ง
Marc Ghorayeb

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
BTW, ไม่ว่าจะเป็นตู้คอนเทนเนอร์ต้อง / อาจจะทำงาน / หยุด / ทั้งดูเหมือนว่าจะขึ้นอยู่กับประเภทของโฮสต์ virtualization / เทคนิค เอกสารนักเทียบท่าปัจจุบันบอกว่า "คอนเทนเนอร์สามารถเป็นคอนเทนเนอร์ที่ทำงานหรือหยุดทำงาน" หลาย ๆ สถานที่บน SO รวมถึงความคิดเห็นเกี่ยวกับคำตอบที่ได้รับการยอมรับพูดว่า "วิธีนี้ใช้ได้กับคอนเทนเนอร์ที่หยุด" ภายใต้Windows Hyper-Vมันเห็นได้ชัดคือความจำเป็นที่จะหยุดภาชนะก่อนที่จะคัดลอกไฟล์
ToolmakerSteve

การทำสำเนายังใช้งานได้เมื่อคอนเทนเนอร์หยุด
ลุค W

17

หากคุณไม่มีคอนเทนเนอร์ที่ใช้งานอยู่เพียงแค่รูปภาพและสมมติว่าคุณต้องการคัดลอกเพียงไฟล์ข้อความคุณสามารถทำสิ่งนี้:

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

7

ฉันโพสต์สิ่งนี้สำหรับทุกคนที่ใช้ Docker สำหรับ 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ไดเรกทอรีจะถูกสร้างขึ้นโดยอัตโนมัติ

ฉันหวังว่านี่จะมีประโยชน์กับบางคนในวันข้างหน้า :)


หากคุณใช้นักเทียบท่าการเขียนโวลุ่มจะถูกคัดค้านในเวอร์ชัน 3 และหลังจากนั้น
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 เป็นพื้นฐานสร้างเพื่อเปลี่ยนปลายทางผลลัพธ์ คุณสามารถใช้สิ่งนี้เพื่อเขียนผลลัพธ์ของการสร้างไปยังไดเรกทอรีท้องถิ่นของคุณแทนที่จะเป็นภาพ เช่นนี่คือการสร้างไบนารีไป:

$ 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ค่าสถานะที่เพิ่งแนะนำให้ฉันเขียนสิ่งเหล่านั้นไปยังไดเรกทอรีภายในเครื่องแทนที่จะเป็นรูป สิ่งนี้ต้องดำเนินการกับเอ็นจิ้น BuildKit ที่มาพร้อมกับ 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

หลังจากการสร้างเสร็จสมบูรณ์แล้วappไบนารีถูกส่งออก:

$ ls
Dockerfile  app  go.mod  main.go

$ ./app
Ready to receive requests on port 8080

นักเทียบท่ามีตัวเลือกอื่น ๆ ในการ--outputตั้งค่าสถานะเอกสารใน repo BuildKit repo ของพวกเขา: https://github.com/moby/buildkit#output


แคช
บิลด์

@burtsevyg Buildkit เป็นตัวสร้างอื่นโดยใช้สภาพแวดล้อมแคชที่แตกต่างกัน แคชมีประสิทธิภาพมากขึ้น
BMitch

ขอบคุณฉันจะปรับปรุงการสร้างโหนดของฉัน
burtsevyg

4

ในฐานะที่เป็นวิธีการแก้ปัญหาทั่วไปมากขึ้นมี CloudBees ปลั๊กอินสำหรับเจนกินส์ที่จะสร้างภายในภาชนะเทียบท่า คุณสามารถเลือกรูปภาพที่จะใช้จากรีจิสทรี Docker หรือกำหนด Dockerfile เพื่อสร้างและใช้

มันจะติดตั้งพื้นที่ทำงานลงในคอนเทนเนอร์เป็นไดรฟ์ข้อมูล (มีผู้ใช้ที่เหมาะสม) ตั้งเป็นไดเรกทอรีการทำงานของคุณทำสิ่งที่คำสั่งที่คุณร้องขอ (ภายในภาชนะ) คุณยังสามารถใช้ปลั๊กอิน docker-workflow (หากคุณต้องการรหัสผ่าน UI) เพื่อทำสิ่งนี้โดยใช้คำสั่ง image.inside () {}

โดยพื้นฐานทั้งหมดนี้นำเข้าสู่ CI / CD เซิร์ฟเวอร์ของคุณ



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) ชื่อดูเหมือนว่าจะเป็นการต่อกันของนักวิทยาศาสตร์และคำคุณศัพท์ (เช่น "relax_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()

ดังนั้นสิ่งนี้จะดึงออกจากเส้นทางที่ระบุ (/ เอาท์พุท) ในคอนเทนเนอร์ไปยังเครื่องโฮสต์ของคุณและแกะน้ำมันดินออก

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()
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.