ඩෝකර් බහාලුමේ සිට ධාරකයට ගොනු පිටපත් කිරීම


1753

අඛණ්ඩ ඒකාබද්ධතා (CI) සේවාදායකයක් මත මගේ පරායත්තතාවයන් ගොඩනැගීම සඳහා ඩෝකර් භාවිතා කිරීමට මම කල්පනා කරමි, එවිට සියලු ධාවන වේලාවන් සහ පුස්තකාල ඒජන්තවරුන් මත ස්ථාපනය කිරීමට මට අවශ්‍ය නොවේ.

මෙය සාක්ෂාත් කර ගැනීම සඳහා මට කන්ටේනරය තුළ ඉදිකර ඇති පුරාවස්තු නැවත ධාරකයට පිටපත් කිරීමට අවශ්‍ය වේ. එය කළ හැකිද?


ඔබ මගේ හැකර් ක්‍රමයට කැමති විය හැකිය: stackoverflow.com/a/55876794/990618
කොලින් ලැමර්

1
පිළිතුරු පතුලේ ඇති ඩොකර් කැප්ටන්ගෙන් නිවැරදි සහ සත්‍ය පිළිතුර.
burtsevyg

Answers:


3014

බහාලුමක සිට ධාරකයට ගොනුවක් පිටපත් කිරීම සඳහා, ඔබට විධානය භාවිතා කළ හැකිය

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 .

44
ඔබ තාවකාලික ලිනක්ස් පරිසරයක් සඳහා ඩොකර් භාවිතා කරන්නේ නම් ඔබේ නවතම බහාලුම ලබා ගැනීමට පහසු ක්‍රමයක් මෙන්න : docker ps -alq.
ජොෂ් හබ්දාස්

37
මෙම cp විධානය ක්‍රියාත්මක වන්නේ ඩිරෙක්ටරි ගස් පිටපත් කිරීම සඳහා ය (එක් ගොනුවක් පමණක් නොවේ).
ඉකෝ

89
ඩොකර් හි නවතම අනුවාද වලදී ඔබට ද්විපාර්ශ්විකව පිටපත් කළ හැකිය (ධාරකයට බහාලුම් හෝ ධාරකයට බහාලුම්)docker cp ...
Freedom_Ben

11
මට docker cp -Lසිම්ලින්ක්ස් පිටපත් කිරීමට අවශ්‍ය විය
හැරිසන් පවර්ස්

24
සටහන: cp විධානය භාවිතා කිරීම සඳහා කන්ටේනරය ක්‍රියාත්මක විය යුතු නැත. ඔබේ බහාලුම නිරන්තරයෙන් කඩා වැටෙන්නේ නම් හැන්ඩි.
මාර්ට්ලාර්ක්

247

ඔබ භාවිතා කිරීමට අවශ්ය නොවේ 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

මෙන්න, ඔබ කිසි විටෙකත් කන්ටේනරය ආරම්භ නොකරයි. එය මට ප්‍රයෝජනවත් විය.


22
මේ සඳහා වැඩි දියුණු කිරීම් අවශ්‍යයි. ඔබට කන්ටේනරයක යමක් තැනීමට අවශ්‍ය වූ විට ප්‍රතිදානයන් පිටපත් කළ යුතුය.
හොන්සා කල්ෆස්

5
On හොන්සා කැල්ෆස් මෙය වඩා ඉහළ විය යුතු බව මම එකඟ වෙමි. මෙය හරියටම මා පසු විය. දන්නා පරිසරයක් භාවිතා කරමින් ද්විමය ලිපිගොනු සෑදීම සඳහා මම මෙය භාවිතා කළෙමි (නිශ්චිත අනුවාදයක ඇමසන් ලිනක්ස්). ෂෝකර් ස්ක්‍රිප්ට් එකක් සෑදීමට හැකි වූ අතර එය ඩොකර් එක මුළුමනින්ම ගොඩනඟා එහි ප්‍රති b ලයක් ලෙස ද්විමය උපුටා ගන්නා ලදි! පරිපූර්ණ.
මාර්ක්

1
ඇත -tiඅවශ්ය හා bashඅවශ්ය ද?
jII

අයිජි, මම එය කර ඇත්තේ පසුකාලීනව මම ඩොකර් එය මත ධාවනය කරන බැවිනි. සරල අවස්ථා වලදී, එය අවශ්‍ය නොවන නමුත් එය මෙහි ද හානියක් නොකරයි.
ඉෂාන් භට්

කෙසේ හෝ ආදේශක කාඩ්පත් භාවිතා කළ හැකිද? මම කිව්වේ ... මට පිටපත් කිරීමට අවශ්‍ය ගොනුවේ නිශ්චිත නම මම නොදනිමි, මන්ද එහි අනුවාද අංකයක් ඇත.
ජුස්ලින්

90

“පරිමාවක්” සවි කර පුරාවස්තු එහි පිටපත් කරන්න:

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: ඔබ මෙය කරන විට, දැනට ක්‍රියාත්මක වන පරිශීලකයාගේ පරිශීලක හැඳුනුම්පතට ගැලපෙන ඩොකර් පරිශීලකයාගේ පරිශීලක හැඳුනුම්පත සමඟ ඔබට ගැටළු ඇති විය හැකිය. එනම්, /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ධාරක යන්ත්‍රයේ පරිශීලක හැඳුනුම්පත සහ කණ්ඩායම් හැඳුනුම්පත ගැලපීමට විධානය භාවිතා කළ හැකිය .
ඩිම්චාන්ස්කි

Ro ෆ්‍රොන්ඩර් පරිමාව වින්‍යාස යොමුව බලන්න docs.docker.com/compose/compose-file/…
djhaskin987

දැනටමත් කර ඇති අතර එය ක්‍රියාත්මක නොවේ. කන්ටේනරය පළමු වරට පරිමාවට ලිපිගොනු පිටපත් කළ පසු, ඊළඟ වතාවේදී, ශබ්දය තවදුරටත් හිස් නොවන අතර නව ඒවා මගින් ලිපිගොනු අභිබවා යන්නේ නැත. කන්ටේනරය ධාරක ලිපිගොනු වලට ප්‍රමුඛතාවය ලබා දෙයි (ඔබ පළමු වරට බහාලුම් රූපය සවි කළ විට ඒවා පිටපත් කරන ලදි).
ෆ්‍රොන්ඩර්

එය තමන්ගේම SO ප්‍රශ්නයක් විය හැකි දෙයක් මෙන් පෙනේ ro ෆ්‍රොන්ඩර්
djhaskin987

1
මම ඔබට බියර් සහකරුවෙකු මිලදී ගන්නවා! ස්තූතියි!
ඩිමිටර් වුක්මන්

27

පරිමාවක් සවි කරන්න, පුරාවස්තු පිටපත් කරන්න, අයිතිකරුගේ හැඳුනුම්පත සහ කණ්ඩායම් හැඳුනුම්පත සකසන්න:

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

25

ටීඑල්ඩීආර්;

$ 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පසු

2
cpපරිමාව පදනම් කරගත් පිළිතුරු අතර සංසන්දනය සඳහා ඉහළට . එසේම, idහිමිකාරිත්වය සඳහා වූ උපක්‍රමය සඳහා එය සමහර විට සැබෑ හිසරදයක් වේ
මාක් ගොරායෙබ්

19

බොහෝ පිළිතුරු වල කන්ටේනරය ක්‍රියාත්මක වීමට පෙර ධාවනය කළ යුතු බව අඟවන්නේ නැත 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, යන්න කන්ටේනර් යුතු / හැකි විය ධාවනය / නතර / හෝ මත රඳා පවතී පෙනේ සත්කාරක / අථත්යකරණ-තාක්ෂණය වර්ගය . වත්මන් ඩොකර් ලේඛනය පවසන්නේ " CONTAINER ධාවනය වන හෝ නැවැත්වූ බහාලුමක් විය හැකි" බවයි. SO හි බහුවිධ ස්ථාන, පිළිගත් පිළිතුර පිළිබඳ අදහස් දැක්වීමක් ඇතුළුව, "මෙය ද නැවතුම් බහාලුමක් මත ක්‍රියා කරයි" යනුවෙන් පවසන්න. යටතේ Windows Hyper-V, එය පැහැදිලිවම අවශ්ය කිරීමට ගොනුවක් පිටපත් පෙර කන්ටේනර් නතර .
මෙවලම් සාදන්නා

17

ඔබ සතුව ධාවන බහාලුමක්, රූපයක් නොමැති නම් සහ ඔබට පෙළ ගොනුවක් පිටපත් කිරීමට අවශ්‍ය යැයි උපකල්පනය කරන්නේ නම්, ඔබට මෙවැනි දෙයක් කළ හැකිය:

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

8

මැක් සඳහා ඩොකර් භාවිතා කරන ඕනෑම කෙනෙකුට මම මෙය පළ කරමි. මෙය මට වැඩ කළේ:

 $ 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 හි මූලයේ විධානයක් තබයි.
මෙවලම් සාදන්නා

5

ඔබට රූපයකින් ගොනුවක් අදින්නට අවශ්‍ය නම් (ධාවනය වන බහාලුමක් වෙනුවට) ඔබට මෙය කළ හැකිය:

docker run --rm <image> cat <source> > <local_dest>

මෙය කන්ටේනරය ගෙන එනු ඇත, නව ගොනුව ලියන්න, ඉන්පසු කන්ටේනරය ඉවත් කරන්න. කෙසේ වෙතත්, එක් අඩුපාඩුවක් නම්, ගොනු අවසරයන් සහ වෙනස් කළ දිනය සුරැකීම නොවේ.



5

ඩෝකර් 19.03 නිකුත් කිරීමත් සමඟ, ඔබට කන්ටේනරය සෑදීම සහ රූපයක් තැනීම පවා මඟ හැරිය හැක. ප්‍රතිදාන ගමනාන්තය වෙනස් කිරීම සඳහා බිල්ඩ්කිට් පදනම් කරගත් ගොඩනැඟිලි සමඟ විකල්පයක් ඇත. රූපයක් තුළට වඩා ඔබේ දේශීය නාමාවලියට ගොඩනැගීමේ ප්‍රති results ල ලිවීමට ඔබට මෙය භාවිතා කළ හැකිය. උදා: මෙහි ද්විමය ගොඩනැගීමකි:

$ 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

ඉහත ඩොකර්ෆයිල් වෙතින්, මම artifactඅපනයනය කිරීමට අවශ්‍ය ලිපිගොනු පමණක් ඇතුළත් වන වේදිකාව ගොඩනඟමි . අලුතින් හඳුන්වා දුන් --outputධජය රූපයක් වෙනුවට දේශීය නාමාවලියකට ලිවීමට මට ඉඩ දෙයි. 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 හි ලේඛනගත කර ඇති ධජයට වෙනත් විකල්ප ඇත : https://github.com/moby/buildkit#output


සම්මත නිමැවුම් හැඹිලිය ප්‍රතිදානය සමඟ ගොඩනැගීම සඳහා භාවිතා නොකෙරේ, එය නරකයි
burtsevyg

urt බර්ට්සෙවිග් බිල්ඩ්කිට් යනු වෙනස් හැඹිලි පරිසරයක් භාවිතා කරමින් වෙනස් සාදන්නෙකි. එය වඩා හැඹිලි කාර්යක්ෂම වේ.
BMitch

4

වඩාත් පොදු විසඳුමක් ලෙස, ඩෝකර් බහාලුමක් තුළ ජෙන්කින්ස් සෑදීම සඳහා ක්ලවුඩ්බීස් ප්ලගිනයක් තිබේ . ඔබට ඩෝකර් රෙජිස්ට්රි එකකින් භාවිතා කිරීමට රූපයක් තෝරා ගත හැකිය හෝ ඩොකර් ෆයිල් එකක් තැනීමට සහ භාවිතා කිරීමට අර්ථ දැක්විය හැකිය.

එය වැඩබිම පරිමාවක් ලෙස බහාලුම් තුළට සවි කරයි (සුදුසු පරිශීලකයෙකු සමඟ), එය ඔබගේ වැඩ කරන නාමාවලිය ලෙස සකසනු ඇත, ඔබ ඉල්ලන ඕනෑම විධානයක් කරන්න (කන්ටේනරය තුළ). Image.inside ()}} විධානය සමඟ ඔබට මෙය කිරීමට ඩොකර්-වර්ක්ෆ්ලෝ ප්ලගිනය (ඔබ UI ට වඩා කේතයක් කැමති නම්) භාවිතා කළ හැකිය.

මූලික වශයෙන් මේ සියල්ලම, ඔබේ සීඅයි / සීඩී සේවාදායකයට පුළුස්සා පසුව සමහරක්.


4

මම මෙම විධානය සමඟ පවර්ෂෙල් (පරිපාලක) භාවිතා කළෙමි.

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

උදාහරණයක්

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

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

ඔබට ගොනුව පිටපත් කිරීමට අවශ්‍ය මාර්ගයක් සාදා ඉන්පසු භාවිතා කරන්න:

docker run -d -v hostpath:dockerimag

0

ඔබට එක් ෆෝල්ඩරයක් පමණක් සවි කිරීමට අවශ්‍ය නම් bindවෙනුවට භාවිතා කළ හැකිය volume, බහාලුමක් සඳහා විශේෂ ආචයනයක් සාදන්නේ නැත:

  1. ටැගය සමඟ ඔබේ රූපය සාදන්න:

    docker build . -t <image>

  2. ඔබගේ රූපය ධාවනය කර app.py ගබඩා කරන වත්මන් $ (pwd) බහලුම බැඳ ඔබේ බහාලුම තුළ / root / example / වෙත සිතියම් ගත කරන්න.

    docker run --mount type=bind,source="$(pwd)",target=/root/example/ <image> python app.py


0

මෙය SDK හි උදාහරණයක් ලෙස පයිතන් ද කළ හැකිය. ඔබ සතුව දැනටමත් කන්ටේනරයක් ඉදිකර තිබේ නම්, ඔබට කොන්සෝලය ( docker ps -a) නම හරහා නම සොයා බැලිය හැකිය .

පරීක්ෂා කරන්න 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()
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.