docker-run - Online sa Cloud

PROGRAMA:

NAME

docker-run - Magpatakbo ng isang command sa isang bagong lalagyan

SINOPSIS

docker tumakbo [-a|--kabit[=[]]] [--add-host[=[]]] [--blkio-timbang[=[BLKIO-WEIGHT]]]
[--blkio-weight-device[=[]]] [--cpu-shares[=0]] [--cap-add[=[]]] [--cap-drop[=[]]]
[--cgroup-magulang[=CGROUP-PATH]] [--cidfile[=CIDFILE]] [--cpu-panahon[=0]] [--cpu-quota[=0]]
[--cpuset-cpus[=CPUSET-CPUS]] [--cpuset-mems[=CPUSET-MEMS]] [-d|--maghiwalay]
[--detach-keys[=[]]] [--aparato[=[]]] [--device-read-bps[=[]]] [--device-read-iops[=[]]]
[--device-write-bps[=[]]] [--device-write-iops[=[]]] [--dns[=[]]] [--dns-opt[=[]]]
[--dns-search[=[]]] [-e|--env[=[]]] [--pasukan[=PASUKAN]] [--env-file[=[]]]
[--ilantad[=[]]] [--group-add[=[]]] [-h|--hostname[=PANGALAN NG HOST]] [- Tumulong] [-i|--interactive]
[--ip[=IPv4-ADDRESS]] [--ip6[=IPv6-ADDRESS]] [--ipc[=IPC]] [--paghihiwalay[=default]]
[--kernel-memorya[=KERNEL-MEMORY]] [-l|--label[=[]]] [--label-file[=[]]] [--link[=[]]]
[--log-driver[=[]]] [--log-opt[=[]]] [-m|--alaala[=ALAALA]] [--mac-address[=MAC-ADDRESS]]
[--memory-reservation[=MEMORY-RESERVATION]] [--memory-swap[=LIMIT]]
[--memory-swappiness[=MEMORY-SWAPPINESS]] [--pangalan[=NAME]] [--net[="tulay"]]
[--net-alias[=[]]] [--oom-kill-disable] [--oom-score-adj[=0]] [-P|--publish-lahat]
[-p|--publish[=[]]] [--pid[=[]]] [--pribilehiyo] [--Basahin lamang] [--restart[=I-restart]] [--rm]
[--security-opt[=[]]] [--stop-signal[=SINYAL]] [--shm-laki[=[]]] [--sig-proxy[=totoo]]
[-t|--tty] [--tmpfs[=[CONTAINER-DIR[: ]]] [-u|--gumagamit[=USER]] [--ulimit[=[]]]
[--uts[=[]]] [-v|--volume[=[[HOST-DIR:]CONTAINER-DIR[:OPTIONS]]]]
[--volume-driver[=Tsuper]] [--volume-mula sa[=[]]] [-w|--workdir[=WORKDIR]] LARAWAN [COMMAND]
[ARG...]

DESCRIPTION

Magpatakbo ng proseso sa isang bagong lalagyan. docker tumakbo nagsisimula ng isang proseso gamit ang sarili nitong file system,
sarili nitong networking, at sarili nitong nakahiwalay na puno ng proseso. Ang LARAWAN na nagsisimula sa proseso
maaaring tukuyin ang mga default na nauugnay sa proseso na tatakbo sa lalagyan, ang
networking upang ilantad, at higit pa, ngunit docker tumakbo nagbibigay ng panghuling kontrol sa operator o
administrator na nagsisimula sa lalagyan mula sa larawan. Sa kadahilanang iyon docker tumakbo mas marami
mga pagpipilian kaysa sa anumang iba pang utos ng Docker.

Kung ang IMAGE ay hindi pa na-load pagkatapos docker tumakbo hihilahin ang LARAWAN, at lahat ng larawan
dependencies, mula sa repository sa parehong paraan na tumatakbo docker paghila LARAWAN, bago ito
sinisimulan ang lalagyan mula sa larawang iyon.

Opsyon

-a, --kabit=[]
I-attach sa STDIN, STDOUT o STDERR.

Sa foreground mode (ang default kapag -d ay hindi tinukoy), docker tumakbo maaaring simulan ang
proseso sa lalagyan at ikabit ang console sa karaniwang input, output,
at karaniwang error. Maaari pa itong magpanggap na isang TTY (ito ang pinaka commandline
inaasahan ng mga executable) at nagpapasa ng mga signal. Ang -a maaaring itakda ang opsyon para sa bawat stdin,
stdout, at stderr.

--add-host=[]
Magdagdag ng custom na host-to-IP na pagmamapa (host:ip)

Magdagdag ng linya sa /etc/hosts. Ang format ay hostname:ip. Ang --add-host maaaring itakda ang opsyon
maraming beses.

--blkio-timbang=0
Tumatanggap ang block IO weight (relative weight) ng weight value sa pagitan ng 10 at 1000.

--blkio-weight-device=[]
I-block ang timbang ng IO (kaugnay na timbang ng device, format: DEVICE_NAME:WEIGHT).

--cpu-shares=0
Mga bahagi ng CPU (kamag-anak na timbang)

Bilang default, lahat ng container ay nakakakuha ng parehong proporsyon ng mga cycle ng CPU. Ang proporsyon na ito ay maaaring
binago sa pamamagitan ng pagbabago sa pagtimbang ng bahagi ng CPU ng container na may kaugnayan sa pagtimbang ng lahat
iba pang tumatakbong mga lalagyan.

Upang baguhin ang proporsyon mula sa default na 1024, gamitin ang --cpu-shares bandila upang itakda ang
pagtimbang sa 2 o mas mataas.

Malalapat lamang ang proporsyon kapag tumatakbo ang mga prosesong masinsinang CPU. Kapag pumasok ang mga gawain
idle ang isang container, maaaring gamitin ng ibang container ang natitirang oras ng CPU. Ang aktwal na halaga
ng oras ng CPU ay mag-iiba depende sa bilang ng mga container na tumatakbo sa system.

Halimbawa, isaalang-alang ang tatlong lalagyan, ang isa ay may cpu-share na 1024 at dalawang iba pa ay may a
setting ng cpu-share na 512. Kapag sinubukang gamitin ng mga proseso sa lahat ng tatlong lalagyan ang 100% ng
CPU, ang unang lalagyan ay makakatanggap ng 50% ng kabuuang oras ng CPU. Kung magdadagdag ka ng pang-apat
container na may cpu-share na 1024, ang unang container ay nakakakuha lamang ng 33% ng CPU. Ang
Ang natitirang mga container ay tumatanggap ng 16.5%, 16.5% at 33% ng CPU.

Sa isang multi-core system, ang mga bahagi ng oras ng CPU ay ipinamamahagi sa lahat ng mga core ng CPU. Kahit na
ang isang lalagyan ay limitado sa mas mababa sa 100% ng oras ng CPU, maaari nitong gamitin ang 100% ng bawat indibidwal
CPU core.

Halimbawa, isaalang-alang ang isang system na may higit sa tatlong mga core. Kung magsisimula ka ng isang lalagyan {C0}
sa -c=512 nagpapatakbo ng isang proseso, at isa pang lalagyan {C1} sa -c=1024 tumatakbong dalawa
mga proseso, maaari itong magresulta sa sumusunod na dibisyon ng mga bahagi ng CPU:

PID container CPU share
100 {C0} 0 100% ng CPU0
101 {C1} 1 100% ng CPU1
102 {C1} 2 100% ng CPU2

--cap-add=[]
Magdagdag ng mga kakayahan sa Linux

--cap-drop=[]
I-drop ang mga kakayahan ng Linux

--cgroup-magulang=""
Path sa mga cgroup kung saan gagawin ang cgroup para sa container. Kung ang landas
ay hindi ganap, ang landas ay itinuturing na nauugnay sa mga cgroup na landas ng init
proseso. Gagawa ang mga Cgroup kung wala pa ang mga ito.

--cidfile=""
Isulat ang container ID sa file

--cpu-panahon=0
Limitahan ang panahon ng CPU CFS (Completely Fair Scheduler).

Limitahan ang paggamit ng CPU ng container. Sinasabi ng flag na ito sa kernel na paghigpitan ang CPU ng container
paggamit sa panahon na iyong tinukoy.

--cpuset-cpus=""
Mga CPU kung saan papayagan ang pagpapatupad (0-3, 0,1)

--cpuset-mems=""
Mga memory node (MEM) kung saan papayagan ang pagpapatupad (0-3, 0,1). Effective lang sa NUMA
systems.

Kung mayroon kang apat na memory node sa iyong system (0-3), gamitin --cpuset-mems=0,1 pagkatapos ay iproseso
sa iyong Docker container ay gagamit lamang ng memorya mula sa unang dalawang memory node.

--cpu-quota=0
Limitahan ang quota ng CPU CFS (Completely Fair Scheduler).

Limitahan ang paggamit ng CPU ng container. Bilang default, tumatakbo ang mga container na may buong mapagkukunan ng CPU.
Sinasabi ng flag na ito sa kernel na paghigpitan ang paggamit ng CPU ng container sa quota na iyong tinukoy.

-d, --maghiwalay=totoo|hindi totoo
Detached mode: patakbuhin ang container sa background at i-print ang bagong container ID. Ang
ang default ay hindi totoo.

Sa anumang oras maaari kang tumakbo docker ps sa kabilang shell upang tingnan ang isang listahan ng tumatakbo
mga lalagyan. Maaari mong ikabit muli sa isang nakahiwalay na lalagyan na may docker ikabit. Kung pipiliin mo
magpatakbo ng container sa detached mode, pagkatapos ay hindi mo magagamit ang -rm pagpipilian.

Kapag naka-attach sa tty mode, maaari kang humiwalay sa lalagyan (at iwanan itong tumatakbo)
gamit ang isang na-configure na key sequence. Ang default na sequence ay CTRL-p CTRL-q. I-configure mo
ang key sequence gamit ang --detach-keys opsyon o isang configuration file. Tingnan mo
config-json(5) para sa dokumentasyon sa paggamit ng configuration file.

--detach-keys=""
I-override ang key sequence para sa pagtanggal ng container. Ang format ay isang character [aZ]
or ctrl- saan ay isa sa: az, @, ^, [, , or _.

--aparato=[]
Magdagdag ng host device sa container (hal --device=/dev/sdc:/dev/xvdc:rwm)

--device-read-bps=[]
Limitahan ang rate ng pagbasa mula sa isang device (hal --device-read-bps=/dev/sda:1mb)

--device-read-iops=[]
Limitahan ang rate ng pagbasa mula sa isang device (hal --device-read-iops=/dev/sda:1000)

--device-write-bps=[]
Limitahan ang rate ng pagsulat sa isang device (hal --device-write-bps=/dev/sda:1mb)

--device-write-iops=[]
Limitahan ang write rate aa device (hal --device-write-iops=/dev/sda:1000)

--dns-search=[]
Magtakda ng mga custom na domain sa paghahanap ng DNS (Gamitin ang --dns-search=. kung hindi mo gustong itakda ang paghahanap
domain)

--dns-opt=[]
Magtakda ng mga custom na pagpipilian sa DNS

--dns=[]
Magtakda ng mga custom na DNS server

Maaaring gamitin ang opsyong ito para i-override ang configuration ng DNS na ipinasa sa container.
Kadalasan ito ay kinakailangan kapag ang host DNS configuration ay hindi wasto para sa container
(hal., 127.0.0.1). Kapag ganito ang --dns kailangan ang mga flag para sa bawat pagtakbo.

-e, --env=[]
Magtakda ng mga variable ng kapaligiran

Binibigyang-daan ka ng opsyong ito na tukuyin ang mga arbitrary na variable ng kapaligiran na magagamit para sa
ang proseso na ilulunsad sa loob ng lalagyan.

--pasukan=""
I-overwrite ang default na ENTRYPOINT ng larawan

Binibigyang-daan ka ng opsyong ito na i-overwrite ang default na entrypoint ng imahe na nakatakda sa
Dockerfile. Ang ENTRYPOINT ng isang imahe ay katulad ng isang COMMAND dahil ito ay tumutukoy kung ano
maipapatupad na tumakbo kapag nagsimula ang lalagyan, ngunit ito ay (sinadya) na mas mahirap
override. Ang ENTRYPOINT ay nagbibigay sa isang lalagyan ng default nitong katangian o gawi, upang kapag
nagtakda ka ng ENTRYPOINT maaari mong patakbuhin ang lalagyan na parang binary iyon, kumpleto sa
mga default na opsyon, at maaari kang magpasa ng higit pang mga opsyon sa pamamagitan ng COMMAND. Ngunit, minsan isang
Maaaring gusto ng operator na magpatakbo ng ibang bagay sa loob ng lalagyan, para ma-override mo ang
default na ENTRYPOINT sa runtime sa pamamagitan ng paggamit ng a --pasukan at isang string upang tukuyin ang bago
PASUKAN.

--env-file=[]
Magbasa sa isang line delimited na file ng mga variable ng kapaligiran

--ilantad=[]
Ilantad ang isang port, o isang hanay ng mga port (hal --expose=3300-3310) ipaalam sa Docker na ang
nakikinig ang container sa mga tinukoy na network port sa runtime. Ginagamit ng Docker ang impormasyong ito
upang ikonekta ang mga lalagyan gamit ang mga link at i-set up ang pag-redirect ng port sa host system.

--group-add=[]
Magdagdag ng mga karagdagang pangkat na tatakbo bilang

-h, --hostname=""
Pangalan ng host ng container

Itinatakda ang pangalan ng host ng container na available sa loob ng container.

- Tumulong
I-print ang pahayag ng paggamit

-i, --interactive=totoo|hindi totoo
Panatilihing bukas ang STDIN kahit na hindi nakakabit. Ang default ay hindi totoo.

Kapag nakatakda sa true, panatilihing bukas ang stdin kahit hindi naka-attach. Mali ang default.

--ip=""
Itinatakda ang IPv4 address ng interface ng container (hal. 172.23.0.9)

Maaari lamang itong gamitin kasabay ng --net para sa mga network na tinukoy ng gumagamit

--ip6=""
Itinatakda ang IPv6 address ng interface ng container (hal. 2001:db8::1b99)

Maaari lamang itong gamitin kasabay ng --net para sa mga network na tinukoy ng gumagamit

--ipc=""
Default ay ang gumawa ng pribadong IPC namespace (POSIX SysV IPC) para sa container
'lalagyan: ': muling gumagamit ng isa pang container na ibinahagi
memorya, mga semaphore at mga pila ng mensahe
'host': gamitin ang host shared memory, semaphores at mensahe
mga pila sa loob ng lalagyan. Tandaan: binibigyan ng host mode ang container ng ganap na access sa local
shared memory at samakatuwid ay itinuturing na hindi secure.

--paghihiwalay="default"
Tinutukoy ng paghihiwalay ang uri ng teknolohiya ng paghihiwalay na ginagamit ng mga lalagyan.

-l, --label=[]
Itakda ang metadata sa container (hal, --label com.example.key=value)

--kernel-memorya=""
Limitasyon sa memorya ng kernel (format: [ ], kung saan ang unit = b, k, m o g)

Pinipigilan ang memorya ng kernel na magagamit sa isang lalagyan. Kung ang limitasyon ng 0 ay tinukoy (hindi
paggamit --kernel-memorya), ang kernel memory ng container ay hindi limitado. Kung tinukoy mo ang a
limitasyon, maaari itong i-round up sa isang maramihang laki ng pahina ng operating system at ang
ang halaga ay maaaring napakalaki, milyon-milyong trilyon.

--label-file=[]
Magbasa sa isang line delimited na file ng mga label

--link=[]
Magdagdag ng link sa isa pang lalagyan sa anyo ng :alias o kaya lang sa
kung saan ang alyas ay tutugma sa pangalan

Kung gumagamit ang operator --link kapag sinimulan ang bagong lalagyan ng kliyente, pagkatapos ay ang kliyente
maa-access ng container ang nakalantad na port sa pamamagitan ng pribadong networking interface. Magtatakda ang Docker
ilang mga variable ng kapaligiran sa container ng kliyente upang makatulong na ipahiwatig kung aling interface at
port na gagamitin.

--log-driver="json file|syslog|Talaarawan|si gelf|matatas|awslogs|madulas|wala"
Pag-log driver para sa lalagyan. Ang default ay tinukoy ng daemon --log-driver bandila.
babala: ang docker mga tala gumagana lamang ang utos para sa json file at
Talaarawan mga driver ng pag-log.

--log-opt=[]
Pag-log sa mga partikular na pagpipilian sa driver.

-m, --alaala=""
Limitasyon sa memorya (format: [ ], kung saan ang unit = b, k, m o g)

Binibigyang-daan kang hadlangan ang memorya na magagamit sa isang lalagyan. Kung sinusuportahan ng host ang swap
memorya, pagkatapos ay ang -m Ang setting ng memorya ay maaaring mas malaki kaysa sa pisikal na RAM. Kung ang limitasyon ng 0 ay
tinukoy (hindi ginagamit -m), hindi limitado ang memorya ng lalagyan. Ang aktwal na limitasyon ay maaaring
ni-round up sa isang maramihang laki ng pahina ng operating system (ang halaga ay magiging napaka
malaki, milyon-milyong trilyon iyon).

--memory-reservation=""
Memory soft limit (format: [ ], kung saan ang unit = b, k, m o g)

Pagkatapos magtakda ng reserbasyon ng memorya, kapag nakita ng system ang pagtatalo sa memorya o mababang memorya,
ang mga lalagyan ay napipilitang higpitan ang kanilang pagkonsumo sa kanilang reserbasyon. Kaya dapat
palaging itakda ang halaga sa ibaba --alaala, kung hindi, mauuna ang mahirap na limitasyon. Sa pamamagitan ng
default, ang pagpapareserba ng memorya ay magiging kapareho ng limitasyon ng memorya.

--memory-swap= "LIMIT"
Isang limit na halaga na katumbas ng memory plus swap. Dapat gamitin kasama ng -m (--alaala) bandila. Ang
magpalitan LIMIT dapat palaging mas malaki kaysa sa -m (--alaala) halaga.

Ang format ng LIMIT is [ ]. Unit ay maaaring b (bytes), k (kilobytes), m
(megabytes), o g (gigabytes). Kung hindi ka tumukoy ng unit, b Ginagamit. Itakda ang LIMIT sa -1 sa
paganahin ang walang limitasyong pagpapalit.

--mac-address=""
MAC address ng container (hal. 92:d0:c6:0a:29:33)

Tandaan na ang MAC address sa isang Ethernet network ay dapat na natatangi. Ang IPv6 link-lokal
ibabatay ang address sa MAC address ng device ayon sa RFC4862.

--pangalan=""
Magtalaga ng pangalan sa lalagyan

Maaaring matukoy ng operator ang isang lalagyan sa tatlong paraan:
UUID mahabang identifier
(“f78375b1c487e03c9438c729345e54db9d20cfa2ac1fc3494b6eb60872e74778”)
UUID short identifier (“f78375b1c487”)
Pangalan (“jonah”)

Ang mga tagatukoy ng UUID ay nagmula sa Docker daemon, at kung ang isang pangalan ay hindi itinalaga sa
lalagyan na may --pangalan pagkatapos ang daemon ay bubuo din ng isang random na pangalan ng string. Ang pangalan ay
kapaki-pakinabang kapag tinutukoy ang mga link (tingnan --link) (o anumang lugar na kailangan mong tukuyin ang a
lalagyan). Gumagana ito para sa parehong mga lalagyan ng Docker sa background at foreground.

--net="tulay"
Itakda ang Network mode para sa container
'bridge': lumikha ng network stack sa default na Docker
tulay
'wala': walang networking
'lalagyan: ': muling gamitin ang network ng isa pang container
magtalaksan
'host': gamitin ang Docker host network stack. Tandaan: ang host
mode ay nagbibigay sa lalagyan ng ganap na access sa mga lokal na serbisyo ng system tulad ng D-bus at ay
samakatuwid ay itinuturing na hindi secure.
' | ': kumonekta sa isang tinukoy ng gumagamit
network

--net-alias=[]
Magdagdag ng network-scoped alias para sa container

--oom-kill-disable=totoo|hindi totoo
Kung idi-disable ang OOM Killer para sa container o hindi.

--oom-score-adj=""
I-tune ang mga kagustuhan sa OOM ng host para sa mga container (tinatanggap -1000 hanggang 1000)

-P, --publish-lahat=totoo|hindi totoo
I-publish ang lahat ng nakalantad na port sa mga random na port sa mga interface ng host. Ang default ay hindi totoo.

Kapag nakatakda sa true, i-publish ang lahat ng nakalantad na port sa mga interface ng host. Mali ang default.
Kung ang operator ay gumagamit ng -P (o -p) kung gayon gagawin ng Docker na ma-access ang nakalantad na port sa
host at ang mga port ay magiging available sa sinumang kliyente na makakarating sa host. Kapag gumagamit ng -P,
Ibibigkis ng Docker ang anumang nakalantad na port sa isang random na port sa host sa loob ng isang panandalian port
saklaw tinukoy ng /proc/sys/net/ipv4/ip_local_port_range. Upang mahanap ang pagmamapa sa pagitan ng
host port at ang nakalantad na port, gamitin docker port.

-p, --publish=[]
Mag-publish ng port ng container, o hanay ng mga port, sa host.

Format: ip:hostPort:containerPort | ip::containerPort | hostPort:containerPort |
lalagyanPort Ang parehong hostPort at containerPort ay maaaring tukuyin bilang isang hanay ng mga port. Kailan
pagtukoy ng mga saklaw para sa pareho, ang bilang ng mga container port sa hanay ay dapat tumugma sa
bilang ng mga host port sa hanay. (hal., docker tumakbo -p 1234-1236: 1222-1224 --pangalan
thisWorks -t busybox ngunit hindi docker tumakbo -p 1230-1236: 1230-1240 --pangalan
RangeContainerPortsMalaki KaysaRangeHostPorts -t busybox) Gamit ang ip: docker tumakbo -p
127.0.0.1:$HOSTPORT:$CONTAINERPORT --pangalan CONTAINER -t ilang larawan paggamit docker port upang makita
ang aktwal na pagmamapa: docker port CONTAINER $CONTAINERPORT

--pid=marami
Itakda ang PID mode para sa container
marami: gamitin ang PID namespace ng host sa loob ng container.
Tandaan: ang host mode ay nagbibigay sa container ng ganap na access sa lokal na PID at samakatuwid ay
itinuturing na hindi secure.

--uts=marami
Itakda ang UTS mode para sa lalagyan
marami: gamitin ang UTS namespace ng host sa loob ng container.
Tandaan: binibigyan ng host mode ang container ng access sa pagpapalit ng hostname ng host at ay
samakatuwid ay itinuturing na hindi secure.

--pribilehiyo=totoo|hindi totoo
Bigyan ng mga pinahabang pribilehiyo ang lalagyang ito. Ang default ay hindi totoo.

Bilang default, ang mga container ng Docker ay "walang pribilehiyo" (=false) at hindi maaaring, halimbawa, magpatakbo ng isang
Docker daemon sa loob ng lalagyan ng Docker. Ito ay dahil sa default, ang isang lalagyan ay hindi
pinapayagang ma-access ang anumang device. Ang isang "pribilehiyo" na lalagyan ay binibigyan ng access sa lahat ng mga device.

Kapag nag-execute ang operator docker tumakbo --pribilehiyo, papaganahin ng Docker ang access sa lahat
mga device sa host pati na rin magtakda ng ilang configuration sa AppArmor para payagan ang container
halos lahat ng parehong access sa host bilang mga prosesong tumatakbo sa labas ng isang lalagyan sa
host

--Basahin lamang=totoo|hindi totoo
I-mount ang root filesystem ng container bilang read only.

Bilang default, ang isang container ay magkakaroon ng root filesystem nito na maisusulat na nagpapahintulot sa mga proseso na magsulat
mga file kahit saan. Sa pamamagitan ng pagtukoy sa --Basahin lamang i-flag ang lalagyan ay magkakaroon ng ugat nito
naka-mount ang filesystem bilang read only na nagbabawal sa anumang pagsusulat.

--restart="hindi"
I-restart ang patakaran upang mailapat kapag lumabas ang isang container (hindi, kapag nabigo[:max-retry], palagi,
maliban kung-tumigil).

--rm=totoo|hindi totoo
Awtomatikong alisin ang lalagyan kapag lumabas ito (hindi tugma sa -d). Ang default ay
hindi totoo.

--security-opt=[]
Mga opsyon sa seguridad

"label:user:USER" : Itakda ang label na user para sa container
"label:role:ROLE" : Itakda ang papel ng label para sa lalagyan
"label:type:TYPE" : Itakda ang uri ng label para sa lalagyan
"label:level:LEVEL" : Itakda ang antas ng label para sa lalagyan
"label:disable" : I-off ang pagkulong ng label para sa lalagyan

--stop-signal=TARGET TERM
Signal upang ihinto ang isang lalagyan. Ang default ay SIGTERM.

--shm-laki=""
Sukat ng /dev/shm. Ang format ay .
numero dapat mas malaki kaysa 0. Opsyonal ang unit at maaaring maging b (bytes), k (kilobytes),
m(megabytes), o g (gigabytes).
Kung aalisin mo ang unit, gumagamit ang system ng mga byte. Kung aalisin mo ang laki nang buo, ang system
Gumagamit 64m.

--sig-proxy=totoo|hindi totoo
Nakatanggap ang proxy ng mga signal sa proseso (hindi TTY mode lang). SIGCHLD, SIGSTOP, at
Ang SIGKILL ay hindi na-proxy. Ang default ay totoo.

--memory-swappiness=""
Ibagay ang gawi ng memory swappiness ng isang container. Tumatanggap ng integer sa pagitan ng 0 at 100.

-t, --tty=totoo|hindi totoo
Maglaan ng pseudo-TTY. Ang default ay hindi totoo.

Kapag nakatakda sa true Docker ay maaaring maglaan ng isang pseudo-tty at ilakip sa karaniwang input ng anuman
lalagyan. Ito ay maaaring gamitin, halimbawa, upang magpatakbo ng isang itinapon na interactive na shell. Ang
mali ang default.

Ang -t ang opsyon ay hindi tugma sa isang pag-redirect ng karaniwang input ng docker client.

--tmpfs=[] Gumawa ng tmpfs mount

Mag-mount ng pansamantalang filesystem (tmpfs) i-mount sa isang lalagyan, halimbawa:

$ docker run -d --tmpfs / Tmp:rw,laki=787448k,mode=1777 my_image

Ang utos na ito ay naglalagay ng a tmpfs at / Tmp sa loob ng lalagyan. Ang mga sinusuportahang opsyon sa pag-mount ay
kapareho ng default ng Linux Mount mga watawat. Kung hindi mo tinukoy ang anumang mga pagpipilian, ang mga system
gumagamit ng mga sumusunod na opsyon: rw,noexec,nosuid,nodev,laki=65536k.

-u, --gumagamit=""
Itinatakda ang username o UID na ginamit at opsyonal ang groupname o GID para sa tinukoy
utos.

Ang mga sumusunod na halimbawa ay wasto lahat:
--user [user | user:grupo | uid | uid:gid | user:gid | uid:group ]

Kung wala ang argumentong ito, tatakbo ang command bilang ugat sa lalagyan.

--ulimit=[]
Ulimit ang mga pagpipilian

-v|--volume[=[[HOST-DIR:]CONTAINER-DIR[:OPTIONS]]]
Gumawa ng bind mount. Kung tinukoy mo, -v /HOST-DIR:/CONTAINER-DIR, Docker
bind mounts /HOST-DIR sa host sa /CONTAINER-DIR sa Docker
lalagyan. Kung aalisin ang 'HOST-DIR', awtomatikong gagawa ng bago ang Docker
dami sa host. Ang Opsyon ay isang comma delimited list at maaaring:

· [rw|ro]

· [z|Z]

· [[r]ibinahagi|[r] alipin|[r]pribado]

Ang CONTAINER-DIR dapat ay isang ganap na landas tulad ng /src/docs. ang HOST-DIR maaaring maging isang
ganap na landas o a pangalan halaga. A pangalan ang halaga ay dapat magsimula sa isang alphanumeric na character,
sinundan ng a-z0-9, _ (underscore), . (panahon) o - (gitling). Ang isang ganap na landas ay nagsisimula sa
a / (pasulong na slash).

Kung magsusuplay ka ng a HOST-DIR iyon ay isang ganap na landas, Docker bind-mounts sa landas mo
tukuyin. Kung magsusuplay ka ng a pangalan, Lumilikha si Docker ng pinangalanang volume sa pamamagitan nito pangalan. Halimbawa,
maaari mong tukuyin ang alinman /foo or foo para sa isang HOST-DIR halaga. Kung ibibigay mo ang /foo halaga,
Gumagawa ang Docker ng bind-mount. Kung ibibigay mo ang foo detalye, ang Docker ay lumilikha ng isang pinangalanang
dami.

Maaari mong tukuyin ang maramihang -v mga opsyon upang i-mount ang isa o higit pang mga mount sa isang lalagyan. Upang gamitin
ang parehong mga mount sa iba pang mga lalagyan, tukuyin ang --volume-mula sa opsyon din.

Pwede kang magdagdag :ro or :rw suffix sa isang volume upang i-mount ito read-only o read-write mode,
ayon sa pagkakabanggit. Bilang default, ang mga volume ay naka-mount read-write. Tingnan ang mga halimbawa.

Ang mga sistema ng pag-label tulad ng SELinux ay nangangailangan na ang mga wastong label ay ilagay sa dami ng nilalaman
naka-mount sa isang lalagyan. Kung walang label, maaaring pigilan ng sistema ng seguridad ang mga proseso
tumatakbo sa loob ng lalagyan mula sa paggamit ng nilalaman. Bilang default, hindi nagbabago ang Docker
ang mga label na itinakda ng OS.

Upang baguhin ang isang label sa konteksto ng container, maaari kang magdagdag ng alinman sa dalawang suffix :z or :Z sa
ang dami mount. Sinasabi ng mga suffix na ito sa Docker na i-relabel ang mga object ng file sa nakabahagi
mga volume. Ang z ang opsyon ay nagsasabi sa Docker na dalawang lalagyan ang nagbabahagi ng dami ng nilalaman. Bilang isang
resulta, nilagyan ng label ng Docker ang nilalaman ng isang nakabahaging label ng nilalaman. Pinapayagan ng mga nakabahaging label ng volume
lahat ng lalagyan para magbasa/magsulat ng nilalaman. Ang Z ang opsyon ay nagsasabi sa Docker na lagyan ng label ang nilalaman
isang pribadong hindi nakabahaging label. Ang kasalukuyang container lang ang maaaring gumamit ng pribadong volume.

Bilang default na bind mounted volume ay pribado. Ibig sabihin, anumang pag-mount na ginawa sa loob ng lalagyan
ay hindi makikita sa host at vice-a-versa. Maaaring baguhin ng isa ang pag-uugaling ito sa pamamagitan ng pagtukoy ng a
dami ng mount propagation property. Gumagawa ng volume Nagbahagi mga mount na ginawa sa ilalim ng volume na iyon
sa loob ng lalagyan ay makikita sa host at vice-a-versa. Gumagawa ng volume alipin Binibigyang-daan
isang paraan lamang ng mount propagation at iyon ay ang mga mount na gagawin sa host sa ilalim ng volume na iyon
nakikita sa loob ng lalagyan ngunit hindi sa kabaligtaran.

Upang kontrolin ang pag-aari ng mount propagation ng volume na magagamit ng isa :[r]ibinahagi, :[r] alipin or
:[r]pribado bandila ng pagpapalaganap. Propagation property ay maaari lamang tukuyin para sa bind mounted
volume at hindi para sa panloob na volume o pinangalanang volume. Para gumana ang mount propagation
source mount point (mount point kung saan naka-mount ang source dir) ay dapat may karapatan
mga katangian ng pagpapalaganap. Para sa mga nakabahaging volume, kailangang ibahagi ang source mount point. At para sa
mga volume ng alipin, ang source mount ay kailangang i-share o slave.

paggamit df para malaman ang source mount at pagkatapos ay gamitin findmnt -o
TARGET,PROPAGATION upang malaman ang mga katangian ng pagpapalaganap ng pinagmulan
bundok. Kung findmnt utility ay hindi magagamit, pagkatapos ay maaaring tumingin sa mount entry para sa pinagmulan
mount point in /proc/self/mountinfo. tignan mo opsyonal patlang at tingnan kung may pagpapalaganap
ang mga katangian ay tinukoy. ibinahagi:X ibig sabihin ang bundok ay Nagbahagi, master:X ibig sabihin ang bundok ay alipin
at kung wala doon ibig sabihin ay mount is pribado.

Upang baguhin ang mga katangian ng pagpapalaganap ng isang paggamit ng mount point Mount utos. Halimbawa, kung isa
gustong i-bind ang mount source directory /foo magagawa ng isa Mount --magbigkis /foo /foo at Mount
--gawing pribado --make-shared /foo. Iko-convert nito ang /foo sa isang Nagbahagi Mount point.
Bilang kahalili ay maaaring direktang baguhin ng isa ang mga katangian ng pagpapalaganap ng source mount. Sabihin / is
source mount para sa /foo, pagkatapos ay gamitin Mount --make-shared / upang i-convert / sa isang Nagbahagi pag-mount.

nota: Kapag gumagamit ng systemd upang pamahalaan ang pagsisimula at paghinto ng Docker daemon, sa
systemd unit file mayroong opsyon para makontrol ang mount propagation para sa Docker
daemon mismo, tinatawag MountFlags. Ang halaga ng setting na ito ay maaaring maging sanhi ng Docker na hindi
tingnan ang mga pagbabago sa pagpapalaganap ng mount na ginawa sa mount point. Halimbawa, kung ang halagang ito
is alipin, maaaring hindi mo magamit ang Nagbahagi or rshared pagpapalaganap sa isang volume.

--volume-driver=""
Driver ng volume ng container. Lumilikha ang driver na ito ng mga volume na tinukoy alinman mula sa
isang Dockerfile's VOLUME pagtuturo o mula sa docker tumakbo -v bandila.
Tingnan docker-volume-create(1) para sa buong detalye.

--volume-mula sa=[]
I-mount ang mga volume mula sa tinukoy na (mga) lalagyan

Nag-mount na ng mga naka-mount na volume mula sa pinagmulang lalagyan papunta sa isa pa
lalagyan. Dapat mong ibigay ang container-id ng source. Ipamahagi
isang volume, gamitin ang --volume-mula sa opsyon kapag tumatakbo
ang target na lalagyan. Maaari kang magbahagi ng mga volume kahit na ang source container
ay hindi tumatakbo.

Bilang default, ini-mount ng Docker ang mga volume sa parehong mode (read-write o
read-only) dahil naka-mount ito sa source container. Opsyonal, ikaw
maaaring baguhin ito sa pamamagitan ng paglalagay ng suffix sa container-id sa alinman sa :ro or
:rw keyword

Kung ang lokasyon ng volume mula sa pinagmumulan na lalagyan ay magkakapatong sa
data na naninirahan sa isang target na lalagyan, pagkatapos ay nagtatago ang volume
na data sa target.

-w, --workdir=""
Gumagana na direktoryo sa loob ng lalagyan

Ang default na gumaganang direktoryo para sa pagpapatakbo ng mga binary sa loob ng isang lalagyan ay ang ugat
direktoryo (/). Ang developer ay maaaring magtakda ng ibang default sa Dockerfile WORKDIR
pagtuturo. Maaaring i-override ng operator ang gumaganang direktoryo sa pamamagitan ng paggamit ng -w pagpipilian.

lumabas katayuan

Ang exit code mula sa docker tumakbo nagbibigay ng impormasyon tungkol sa kung bakit nabigong tumakbo ang lalagyan o
bakit ito lumabas. Kailan docker tumakbo paglabas na may non-zero code, ang mga exit code ay sumusunod sa
chroot pamantayan, tingnan sa ibaba:

125 if ang mali is sa Manggagawa sa pantalan demonyo kanyang sarili

$ docker run --foo busybox; echo $?
# flag ang ibinigay ngunit hindi tinukoy: --foo
Tingnan ang 'docker run --help'.
125

126 if ang nakapaloob utos hindi maaari be invoked

$ docker run busybox / atbp; echo $?
# exec: "/ atbp": tinanggihan ang pahintulot
docker: Error na tugon mula sa daemon: Hindi ma-invoke ang Contained command
126

127 if ang nakapaloob utos hindi maaari be natagpuan

$ docker run busybox foo; echo $?
# exec: "foo": hindi nahanap ang executable file sa $PATH
docker: Error na tugon mula sa daemon: Contained command not found or not exist
127

lumabas code of nakapaloob utos kung hindi man

$ docker run busybox / Bin / SH -c 'exit 3'
# 3

HALIMBAWA

Tumatakbo lalagyan in Basahin lamang paraan

Sa panahon ng pagbuo ng imahe ng lalagyan, kadalasang kailangang sumulat ang mga lalagyan sa nilalaman ng larawan.
Pag-install ng mga pakete sa / usr, Halimbawa. Sa produksyon, bihirang kailanganin ng mga aplikasyon
sumulat sa larawan. Ang mga application ng container ay sumusulat sa mga volume kung kailangan nilang magsulat sa file
mga sistema sa lahat. Maaaring gawing mas secure ang mga application sa pamamagitan ng pagpapatakbo ng mga ito sa read-only na mode
gamit ang --read-only switch. Pinoprotektahan nito ang imahe ng mga lalagyan mula sa pagbabago. Basahin
ang mga lalagyan lamang ang maaaring kailanganin pa ring sumulat ng pansamantalang data. Ang pinakamahusay na paraan upang mahawakan ito ay ang
i-mount ang mga direktoryo ng tmpfs sa / patakbuhin at /tmp.

# docker run --read-only --tmpfs / patakbuhin --tmpfs / Tmp -i -t fedora / basahan / bash

Paliwanag mag-log mensahe mula ang lalagyan sa ang ng host mag-log

Kung gusto mong lumabas ang mga mensaheng naka-log in sa iyong container sa host
syslog/journal pagkatapos ay dapat mong itali ang pag-mount sa /dev/log na direktoryo tulad ng sumusunod.

# docker run -v /dev/log:/dev/log -i -t fedora / basahan / bash

Mula sa loob ng lalagyan maaari mong subukan ito sa pamamagitan ng pagpapadala ng mensahe sa log.

(bash)# logger "Hello from my container"

Pagkatapos ay lumabas at suriin ang journal.

# exit

# journalctl -b | grep Hello

Dapat nitong ilista ang mensaheng ipinadala sa logger.

Naglalakip sa isa or mas marami pang mula STDIN, STDOUT, STDERR

Kung hindi mo tukuyin ang -a pagkatapos Docker ay ilakip ang lahat ng bagay (stdin, stdout, stderr) na gusto mo
sa halip ay gustong kumonekta, gaya ng:

# docker run -a stdin -a stdout -i -t fedora / basahan / bash

Pagbabahagi IPC sa pagitan ng lalagyan

Gamit ang shm_server.c na magagamit dito: ⟨https://www.cs.cf.ac.uk/Dave/C/node27.html⟩

Pagsubok --ipc=host mode:

Ang host ay nagpapakita ng isang nakabahaging memory segment na may 7 pids na naka-attach, nagkataong mula sa httpd:

$ sudo ipcs -m

------ Mga Shared Memory Segment --------
key shmid owner perms bytes nattch status
0x01128e25 0 ugat 600 1000 7

Magpatakbo ngayon ng isang regular na lalagyan, at HINDI nito nakikita nang tama ang nakabahaging bahagi ng memorya mula sa
ang nagpadaos:

$ docker run -it shm ipcs -m

------ Mga Shared Memory Segment --------
key shmid owner perms bytes nattch status

Magpatakbo ng isang lalagyan na may bago --ipc=host opsyon, at nakikita na nito ngayon ang nakabahaging bahagi ng memorya
mula sa host httpd:

$ docker run -it --ipc=host shm ipcs -m

------ Mga Shared Memory Segment --------
key shmid owner perms bytes nattch status
0x01128e25 0 ugat 600 1000 7

Pagsubok --ipc=container:CONTAINERID mode:

Magsimula ng isang lalagyan na may isang programa upang lumikha ng isang nakabahaging bahagi ng memorya:

$ docker run -it shm bash
$ sudo shm/shm_server
$ sudo ipcs -m

------ Mga Shared Memory Segment --------
key shmid owner perms bytes nattch status
0x0000162e 0 ugat 666 27 1

Lumikha ng isang 2nd container nang tama ay nagpapakita ng walang nakabahaging memory segment mula sa 1st container:

$ docker run shm ipcs -m

------ Mga Shared Memory Segment --------
key shmid owner perms bytes nattch status

Gumawa ng ika-3 container gamit ang bagong --ipc=container:CONTAINERID na opsyon, ngayon ay ipinapakita nito ang
nakabahaging bahagi ng memorya mula sa una:

$ docker run -it --ipc=container:ed735b2264ac shm ipcs -m
$ sudo ipcs -m

------ Mga Shared Memory Segment --------
key shmid owner perms bytes nattch status
0x0000162e 0 ugat 666 27 1

Pag-uugnay Lalagyan

nota: Inilalarawan ng seksyong ito ang pag-link sa pagitan ng mga lalagyan sa default (tulay)
network, na kilala rin bilang "mga legacy link." Gamit --link sa mga ginagamit ng user-defined network
ang pagtuklas na nakabatay sa DNS, na hindi nagdaragdag ng mga entry sa / Etc / host, at hindi nakatakda
mga variable ng kapaligiran para sa pagtuklas.

Ang tampok na link ay nagbibigay-daan sa maraming container na makipag-ugnayan sa isa't isa. Halimbawa, a
container kung saan ang Dockerfile ay nalantad ang port 80 ay maaaring patakbuhin at pinangalanan bilang sumusunod:

# docker run --name=link-test -d -i -t fedora/httpd

Ang pangalawang container, sa kasong ito ay tinatawag na linker, ay maaaring makipag-ugnayan sa httpd container,
pinangalanang link-test, sa pamamagitan ng pagtakbo gamit ang --link= :

# docker run -t -i --link=link-test:lt --name=linker fedora / basahan / bash

Ngayon ang container linker ay naka-link sa container link-test na may alias lt. Pagpapatakbo ng
env Ang command sa lalagyan ng linker ay nagpapakita ng mga variable ng kapaligiran
na may kontekstong LT (alias) (LT_)

# env
HOSTNAME=668231cb0978
TERM=xterm
LT_PORT_80_TCP=tcp://172.17.0.3:80
LT_PORT_80_TCP_PORT=80
LT_PORT_80_TCP_PROTO=tcp
LT_PORT=tcp://172.17.0.3:80
DAAN=/ usr / local / sbin:/ usr / local / bin:/ usr / sbin:/ usr / bin:/ sbin:/ bin
PWD=/
LT_NAME=/linker/lt
SHLVL=1
HOME=/
LT_PORT_80_TCP_ADDR=172.17.0.3
_=/usr/bin/env

Kapag nagli-link ng dalawang container, gagamitin ng Docker ang mga nakalantad na port ng container upang lumikha ng a
secure na tunnel para ma-access ng magulang.

Kung nakakonekta ang isang lalagyan sa default na bridge network at na naka-link sa iba pang mga
mga lalagyan, pagkatapos ay sa lalagyan / Etc / host Ang file ay na-update sa naka-link na lalagyan
pangalan.

nota Dahil maaaring live na i-update ng Docker ang container / Etc / host file, maaaring mayroong
mga sitwasyon kapag ang mga proseso sa loob ng lalagyan ay maaaring magbasa ng isang walang laman o
hindi kumpleto / Etc / host file. Sa karamihan ng mga kaso, ang muling pagsubok sa pagbasa ay dapat ayusin ang
problema.

Pagma-map ports para panlabas Paggamit

Ang nakalantad na port ng isang application ay maaaring imapa sa isang host port gamit ang -p bandila. Para sa
halimbawa, ang isang httpd port 80 ay maaaring imapa sa host port 8080 gamit ang sumusunod:

# docker run -p 8080:80 -d -i -t fedora/httpd

Paglikha at Kabitan a data Dami Lalagyan

Maraming mga application ang nangangailangan ng pagbabahagi ng patuloy na data sa ilang mga container. Docker
nagbibigay-daan sa iyong gumawa ng Lalagyan ng Dami ng Data kung saan maaaring mag-mount ang iba pang mga container. Para sa
halimbawa, gumawa ng pinangalanang lalagyan na naglalaman ng mga direktoryo /var/volume1 at /tmp/volume2.
Ang imahe ay kailangang maglaman ng mga direktoryo na ito upang ang ilang mga tagubilin sa RUN mkdir
maaaring kailanganin para sa iyong larawan ng fedora-data:

# docker run --name=data -v /var/volume1 -v /tmp/volume2 -i -t fedora-data true
# docker run --volumes-from=data --name=fedora-container1 -i -t fedora bash

Ang maramihang --volume-mula sa mga parameter ay magsasama-sama ng maraming dami ng data mula sa maramihan
mga lalagyan. At posibleng i-mount ang mga volume na nagmula sa DATA container
isa pang lalagyan sa pamamagitan ng fedora-container1 na tagapamagitan na lalagyan, na nagpapahintulot sa
abstract ang aktwal na data source mula sa mga user ng data na iyon:

# docker run --volumes-from=fedora-container1 --name=fedora-container2 -i -t fedora bash

Kabitan panlabas volume

Upang mag-mount ng direktoryo ng host bilang dami ng container, tukuyin ang ganap na landas sa
direktoryo at ang ganap na landas para sa direktoryo ng lalagyan na pinaghihiwalay ng isang tutuldok:

# docker run -v /var/db:/data1 -i -t fedora bash

Kapag gumagamit ng SELinux, magkaroon ng kamalayan na ang host ay walang kaalaman sa patakaran ng container SELinux.
Samakatuwid, sa halimbawa sa itaas, kung ang patakaran ng SELinux ay ipinatupad, ang /var/db ang direktoryo ay
hindi maisusulat sa lalagyan. Isang mensaheng "Tinanggihan ang Pahintulot" ay magaganap at isang avc:
mensahe sa syslog ng host.

Upang malutas ito, sa oras ng pagsulat ng man page na ito, ang sumusunod na utos ay kailangang
tumakbo upang ang wastong label ng uri ng patakaran ng SELinux ay naka-attach sa host
direktoryo:

# chcon -Rt svirt_sandbox_file_t /var/db

Ngayon, papayagan ang pagsulat sa /data1 volume sa container at ang mga pagbabago ay papayagan
makikita rin sa host sa /var/db.

paggamit alternatiba katiwasayan paglalagay ng label

Maaari mong i-override ang default na scheme ng pag-label para sa bawat container sa pamamagitan ng pagtukoy sa
--security-opt bandila. Halimbawa, maaari mong tukuyin ang antas ng MCS/MLS, isang kinakailangan para sa MLS
mga sistema. Ang pagtukoy sa antas sa sumusunod na utos ay nagbibigay-daan sa iyong ibahagi ang pareho
nilalaman sa pagitan ng mga lalagyan.

# docker run --security-opt label:level:s0:c100,c200 -i -t fedora bash

Ang isang halimbawa ng MLS ay maaaring:

# docker run --security-opt label:level:TopSecret -i -t rhel7 bash

Upang i-disable ang pag-label ng seguridad para sa container na ito kumpara sa pagtakbo gamit ang --permissive
flag, gamitin ang sumusunod na command:

# docker run --security-opt label:disable -i -t fedora bash

Kung gusto mo ng mas mahigpit na patakaran sa seguridad sa mga proseso sa loob ng isang container, maaari mong tukuyin
isang kahaliling uri para sa lalagyan. Maaari kang magpatakbo ng isang lalagyan na pinapayagan lamang
makinig sa mga port ng Apache sa pamamagitan ng pagpapatupad ng sumusunod na command:

# docker run --security-opt label:type:svirt_apache_t -i -t centos bash

tandaan:

Kailangan mong magsulat ng patakaran sa pagtukoy ng a svirt_apache_t uri.

Pagtatakda ng aparato timbang

Kung gusto mong itakda / Dev / sda bigat ng device sa 200, maaari mong tukuyin ang timbang ng device sa pamamagitan ng
--blkio-weight-device bandila. Gamitin ang sumusunod na command:

# docker run -it --blkio-weight-device "/dev/sda:200" ubuntu

Tukuyin paghihiwalay teknolohiya para lalagyan (--paghihiwalay)

Kapaki-pakinabang ang opsyong ito sa mga sitwasyon kung saan nagpapatakbo ka ng mga container ng Docker sa Microsoft
Windows. Ang --paghihiwalay ang opsyon ay nagtatakda ng teknolohiya ng paghihiwalay ng lalagyan. Sa Linux,
ang tanging sinusuportahan ay ang default opsyon na gumagamit ng mga namespace ng Linux. Ang dalawang utos na ito
ay katumbas sa Linux:

$ docker run -d busybox top
$ docker run -d --isolation default na busybox sa itaas

Sa Microsoft Windows, maaaring kunin ang alinman sa mga halagang ito:

· default: Gamitin ang value na tinukoy ng Docker daemon's --exec-opt . Kung ang demonyo ang
hindi tumukoy ng teknolohiya ng paghihiwalay, ginagamit ng Microsoft Windows paraan bilang default nito
halaga.

· paraan: Namespace isolation lang.

· hyperv: Hyper-V hypervisor partition-based na paghihiwalay.

Sa pagsasagawa, kapag tumatakbo sa Microsoft Windows nang walang a demonyo hanay ng pagpipilian, ang dalawang ito
ang mga utos ay katumbas:

$ docker run -d --isolation default na busybox sa itaas
$ docker run -d --isolation process busybox top

Kung naitakda mo ang --exec-opt paghihiwalay=hyperv opsyon sa Docker demonyo, kahit ano sa mga ito
nagreresulta din ang mga utos hyperv paghihiwalay:

$ docker run -d --isolation default na busybox sa itaas
$ docker run -d --isolation hyperv busybox top

KASAYSAYAN

Abril 2014, Orihinal na pinagsama-sama ni William Henry (whenry sa redhat dot com) batay sa
docker.com pinagmumulan ng materyal at panloob na gawain. Hunyo 2014, na-update ni Sven Dowideit
⟨[protektado ng email]⟩ Hulyo 2014, na-update ni Sven Dowideit ⟨[protektado ng email]⟩
Nobyembre 2015, na-update ni Sally O'Malley ⟨[protektado ng email]⟩

Gumamit ng docker-run online gamit ang mga serbisyo ng onworks.net