docker-run - Online în cloud

PROGRAM:

NUME

docker-run - Rulați o comandă într-un container nou

REZUMAT

docher alerga [-a|--atașa[=[],--add-host[=[],--blkio-greutate[=[BLKIO-WEIGHT]]]
[--blkio-greutate-dispozitiv[=[],--cpu-parts[=0,--cap-adăugați[=[],--cap-picare[=[]]]
[--cgroup-parent[=CGROUP-CALEA,--cidfile[=CIDFILE,--cpu-perioada[=0,--cpu-quota[=0]]
[--cpuset-cpus[=CPUSET-CPUS,--cpuset-mems[=CPUSET-MEMS,-d|--desprinde]
[--detașați-cheile[=[],--dispozitiv[=[],--device-read-bps[=[],--device-read-iops[=[]]]
[--device-write-bps[=[],--device-write-iops[=[],--dns[=[],--dns-opt[=[]]]
[--dns-search[=[],-e|--env[=[],--punct de intrare[=PUNCT DE INTRARE,--env-file[=[]]]
[--expune[=[],--grup-adăugați[=[],-h|--hostname[=NOMUL DE GĂȘTARE,--Ajutor] [-i|--interactiv]
[-ip[=ADRESA IPv4,--ip6[=ADRESA IPv6,--ipc[=IPC,--izolare[=lipsă]]
[--kernel-memory[=SĂMBUL-MEMORIE,-l|--eticheta[=[],--label-file[=[],--legătură[=[]]]
[--log-driver[=[],--log-opt[=[],-m|--memorie[=MEMORIE,--Adresa mac[=ADRESA MAC]]
[--rezervare-memorie[=MEMORIA-REZERVARE,--schimb-memorie[=LIMITĂ]]
[--schimbări de memorie[=SCHIMBARE DE MEMORIE,--Nume[=NUME,--net[="pod"]]
[--net-alias[=[],--oom-kill-disable] [--oom-score-adj[=0,-P|--public-toate]
[-p|--publica[=[],--pid[=[],--privilegiat] [--numai citire] [--repornire[=REPORNIRE,--rm]
[--securitate-opt[=[],--semnal-stop[=SEMNAL,--shm-size[=[],--sig-proxy[=adevărat]]
[-t|--tty] [--tmpfs[=[CONTAINER-DIR[: ],-u|--utilizator[=USER,--ulimit[=[]]]
[--uts[=[],-v|--volum[=[[HOST-DIR:]CONTAINER-DIR[:OPTIONS]]]]
[--volum-driver[=DRIVER,--volume-din[=[],-w|--workdir[=WORKDIR]] IMAGINE [COMANDĂ]
[ARG...]

DESCRIERE

Rulați un proces într-un container nou. docher alerga începe un proces cu propriul sistem de fișiere,
propria rețea și propriul arbore de proces izolat. IMAGINEA care începe procesul
poate defini valori implicite legate de procesul care va fi rulat în container, the
networking pentru a expune, și mai mult, dar docher alerga dă controlul final operatorului sau
administrator care pornește containerul din imagine. Pentru acest motiv docher alerga are mai mult
opțiuni decât orice altă comandă Docker.

Dacă IMAGINEA nu este deja încărcată, atunci docher alerga va trage IMAGINE și toată imaginea
dependențe, din depozit în același mod rulând docher trage IMAGINE, înaintea ei
pornește containerul de la acea imagine.

OPŢIUNI

-a, --atașa=[]
Atașați la STDIN, STDOUT sau STDERR.

În modul prim plan (prestabilit când -d nu este specificat), docher alerga poate începe
proces în container și atașați consola la intrarea, ieșirea standard a procesului,
și eroare standard. Poate chiar să pretindă că este un TTY (aceasta este cea mai mare linie de comandă
executabilele se așteaptă) și transmit semnale. The -a opțiunea poate fi setată pentru fiecare dintre stdin,
stdout și stderr.

--add-host=[]
Adăugați o mapare personalizată de la gazdă la IP (gazdă:ip)

Adăugați o linie la /etc/hosts. Formatul este hostname:ip. The --add-host opțiunea poate fi setată
de mai multe ori.

--blkio-greutate=0
Greutatea blocului IO (greutatea relativă) acceptă o valoare a greutății între 10 și 1000.

--blkio-greutate-dispozitiv=[]
Greutatea blocului IO (greutatea relativă a dispozitivului, format: DEVICE_NAME:WEIGHT).

--cpu-parts=0
Acțiuni CPU (greutate relativă)

În mod implicit, toate containerele primesc aceeași proporție de cicluri CPU. Această proporție poate fi
modificat prin modificarea ponderii cotei CPU a containerului în raport cu ponderarea tuturor
alte containere care rulează.

Pentru a modifica proporția de la valoarea implicită de 1024, utilizați --cpu-parts steag pentru a seta
pondere la 2 sau mai mare.

Proporția se va aplica numai atunci când rulează procese care consumă intens CPU. Când sarcinile în
un container este inactiv, alte containere pot folosi timpul rămas de la CPU. Suma reală
timpul CPU va varia în funcție de numărul de containere care rulează pe sistem.

De exemplu, luați în considerare trei containere, unul are o cotă de procesor de 1024 și alți doi au un
CPU-share setare de 512. Când procesele din toate cele trei containere încearcă să utilizeze 100% din
CPU, primul container ar primi 50% din timpul total al procesorului. Dacă adăugați un al patrulea
container cu o cotă de procesor de 1024, primul container primește doar 33% din procesor. The
containerele rămase primesc 16.5%, 16.5% și 33% din CPU.

Pe un sistem multi-core, cotele de timp CPU sunt distribuite peste toate nucleele CPU. Chiar dacă
un container este limitat la mai puțin de 100% din timpul CPU, poate folosi 100% din fiecare individ
Miezul procesorului.

De exemplu, luați în considerare un sistem cu mai mult de trei nuclee. Dacă porniți un container {C0}
cu -c=512 rulează un proces și un alt container {C1} cu -c=1024 alergând doi
proceselor, acest lucru poate duce la următoarea împărțire a părților CPU:

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

--cap-adăugați=[]
Adăugați capabilități Linux

--cap-picare=[]
Renunțați la capabilitățile Linux

--cgroup-parent=""
Calea către cgroups sub care va fi creat cgroup-ul pentru container. Dacă calea
nu este absolută, calea este considerată a fi relativă la calea cgroups a init
proces. Cgroups vor fi create dacă nu există deja.

--cidfile=""
Scrieți ID-ul containerului în fișier

--cpu-perioada=0
Limitați perioada CPU CFS (Completely Fair Scheduler).

Limitați utilizarea procesorului containerului. Acest steag îi spune nucleului să restricționeze CPU-ul containerului
utilizare la perioada pe care o specificați.

--cpuset-cpus=""
CPU-uri în care să se permită execuția (0-3, 0,1)

--cpuset-mems=""
Noduri de memorie (MEM) în care să se permită execuția (0-3, 0,1). Eficient doar pe NUMA
sisteme.

Dacă aveți patru noduri de memorie pe sistemul dvs. (0-3), utilizați --cpuset-mems=0,1 apoi procese
în containerul dvs. Docker va folosi doar memoria din primele două noduri de memorie.

--cpu-quota=0
Limitați cota CPU CFS (Completely Fair Scheduler).

Limitați utilizarea procesorului containerului. În mod implicit, containerele rulează cu resursa CPU completă.
Acest indicator îi spune nucleului să limiteze utilizarea procesorului containerului la cota pe care o specificați.

-d, --desprinde=adevărat|fals
Modul detașat: rulați containerul în fundal și imprimați noul ID de container. The
implicit este fals.

Oricand poti alerga docher ps în celălalt shell pentru a vizualiza o listă a rulării
containere. Puteți reatașa la un container detașat cu docher atașa. Dacă alegeți să
rulați un container în modul detașat, apoi nu puteți utiliza -rm opțiune.

Când este atașat în modul tty, vă puteți detașa din container (și îl puteți lăsa să funcționeze)
folosind o secvență de taste configurabilă. Secvența implicită este CTRL-p CTRL-q. Tu configurați
secvența de taste folosind --detașați-cheile opțiune sau un fișier de configurare. Vedea
config-json(5) pentru documentația despre utilizarea unui fișier de configurare.

--detașați-cheile=""
Ignorați secvența de taste pentru detașarea unui container. Formatul este un singur caracter [aZ]
or ctrl- Unde este unul din: az, @, ^, [, , or _.

--dispozitiv=[]
Adăugați un dispozitiv gazdă la container (de exemplu --device=/dev/sdc:/dev/xvdc:rwm)

--device-read-bps=[]
Limitați rata de citire de pe un dispozitiv (de exemplu --device-read-bps=/dev/sda:1mb)

--device-read-iops=[]
Limitați rata de citire de pe un dispozitiv (de exemplu --device-read-iops=/dev/sda:1000)

--device-write-bps=[]
Limitați rata de scriere la un dispozitiv (de exemplu --device-write-bps=/dev/sda:1mb)

--device-write-iops=[]
Limitați rata de scriere a unui dispozitiv (de exemplu --device-write-iops=/dev/sda:1000)

--dns-search=[]
Setați domenii de căutare DNS personalizate (Utilizați --dns-search=. dacă nu doriți să setați căutarea
domeniu)

--dns-opt=[]
Setați opțiuni DNS personalizate

--dns=[]
Setați servere DNS personalizate

Această opțiune poate fi folosită pentru a suprascrie configurația DNS transmisă containerului.
De obicei, acest lucru este necesar atunci când configurația DNS gazdă este invalidă pentru container
(de exemplu, 127.0.0.1). Când acesta este cazul --dns steagurile sunt necesare pentru fiecare alergare.

-e, --env=[]
Setați variabilele de mediu

Această opțiune vă permite să specificați variabile de mediu arbitrare pentru care sunt disponibile
procesul care va fi lansat în interiorul containerului.

--punct de intrare=""
Suprascrieți ENTRYPOINT-ul implicit al imaginii

Această opțiune vă permite să suprascrieți punctul de intrare implicit al imaginii care este setat în
Dockerfile. ENTRYPOINT-ul unei imagini este similar cu o COMANDĂ deoarece specifică ce
executabil să ruleze atunci când containerul pornește, dar este (intenționat) mai dificil
trece peste. ENTRYPOINT oferă unui container natura sau comportamentul său implicit, astfel încât când
setați un ENTRYPOINT cu care puteți rula containerul ca și cum ar fi acel binar, complet cu
opțiuni implicite și puteți transmite mai multe opțiuni prin COMANDĂ. Dar, uneori un
operatorul poate dori să ruleze altceva în interiorul containerului, astfel încât să puteți suprascrie
ENTRYPOINT implicit la runtime utilizând a --punct de intrare și un șir pentru a specifica noul
PUNCT DE INTRARE.

--env-file=[]
Citiți într-un fișier delimitat de linii de variabile de mediu

--expune=[]
Expune un port sau o serie de porturi (de exemplu --expose=3300-3310) informează Docker că
containerul ascultă pe porturile de rețea specificate în timpul rulării. Docker folosește aceste informații
pentru a interconecta containerele folosind legături și pentru a configura redirecționarea portului pe sistemul gazdă.

--grup-adăugați=[]
Adăugați grupuri suplimentare pentru a rula ca

-h, --hostname=""
Numele gazdă al containerului

Setează numele gazdă al containerului care este disponibil în interiorul containerului.

--Ajutor
Imprimați declarația de utilizare

-i, --interactiv=adevărat|fals
Păstrați STDIN deschis chiar dacă nu este atașat. Valoarea implicită este fals.

Când este setat la true, păstrați stdin deschis chiar dacă nu este atașat. Valoarea implicită este false.

-ip=""
Setează adresa IPv4 a interfeței containerului (de ex. 172.23.0.9)

Poate fi folosit numai împreună cu --net pentru rețele definite de utilizator

--ip6=""
Setează adresa IPv6 a interfeței containerului (de ex. 2001:db8::1b99)

Poate fi folosit numai împreună cu --net pentru rețele definite de utilizator

--ipc=""
Implicit este crearea unui spațiu de nume IPC privat (POSIX SysV IPC) pentru container
„container: ': reutiliza un alt container partajat
memorie, semafore și cozi de mesaje
„gazdă”: utilizați memoria partajată a gazdei, semaforele și mesajul
cozi în interiorul containerului. Notă: modul gazdă oferă containerului acces complet la local
memorie partajată și, prin urmare, este considerată nesigură.

--izolare="lipsă"
Izolarea specifică tipul de tehnologie de izolare utilizată de containere.

-l, --eticheta=[]
Setați metadatele pe container (de exemplu, --label com.example.key=value)

--kernel-memory=""
Limită de memorie kernel (format: [ ], unde unitatea = b, k, m sau g)

Constrânge memoria nucleului disponibilă pentru un container. Dacă este specificată o limită de 0 (nu
folosind --kernel-memory), memoria nucleului containerului nu este limitată. Dacă specificați a
limită, aceasta poate fi rotunjită la un multiplu al dimensiunii paginii sistemului de operare și al
valoarea poate fi foarte mare, de milioane de trilioane.

--label-file=[]
Citiți într-un fișier de etichete delimitat de linii

--legătură=[]
Adăugați link către alt container sub formă de :alias sau doar în
caz în care alias-ul se va potrivi cu numele

Dacă operatorul utilizează --legătură la pornirea noului container client, apoi clientul
containerul poate accesa portul expus printr-o interfață de rețea privată. Docker va seta
unele variabile de mediu din containerul client pentru a ajuta la indicarea ce interfață și
port de utilizat.

--log-driver="fisier-json|syslog|jurnal|gelf|fluentd|awslog-uri|smerit|nici unul"
Driver de logare pentru container. Implicit este definit de daemon --log-driver steag.
avertizare: docher busteni comanda funcționează numai pentru fisier-json și
jurnal drivere de logare.

--log-opt=[]
Opțiuni specifice driverului de înregistrare.

-m, --memorie=""
Limită de memorie (format: [ ], unde unitatea = b, k, m sau g)

Vă permite să restrângeți memoria disponibilă unui container. Dacă gazda acceptă swap
memorie, apoi -m setarea memoriei poate fi mai mare decât memoria RAM fizică. Dacă o limită de 0 este
specificat (nu se utilizează -m), memoria containerului nu este limitată. Limita reală poate fi
rotunjită la un multiplu al dimensiunii paginii sistemului de operare (valoarea ar fi foarte
mare, adică milioane de trilioane).

--rezervare-memorie=""
Limită soft memorie (format: [ ], unde unitatea = b, k, m sau g)

După setarea rezervării de memorie, atunci când sistemul detectează confuzie de memorie sau memorie scăzută,
containerele sunt nevoite să-și limiteze consumul la rezervare. Deci ar trebui
setați întotdeauna valoarea de mai jos --memorie, altfel limita dura va avea prioritate. De
implicit, rezervarea memoriei va fi aceeași cu limita de memorie.

--schimb-memorie="LIMIT"
O valoare limită egală cu memoria plus swap. Trebuie folosit cu -m (--memorie) steag. The
schimba LIMITĂ ar trebui să fie întotdeauna mai mare decât -m (--memorie) valoare.

Formatul LIMITĂ is [ ]. Unitatea poate fi b (octeți), k (kiloocteți), m
(megaocteți) sau g (gigaocteți). Dacă nu specificați o unitate, b este folosit. Setați LIMIT la -1 la
activați schimbul nelimitat.

--Adresa mac=""
Adresa MAC al containerului (de ex. 92:d0:c6:0a:29:33)

Rețineți că adresa MAC într-o rețea Ethernet trebuie să fie unică. Legătura IPv6 locală
adresa se va baza pe adresa MAC a dispozitivului conform RFC4862.

--Nume=""
Atribuiți un nume containerului

Operatorul poate identifica un container în trei moduri:
Identificator lung UUID
(“f78375b1c487e03c9438c729345e54db9d20cfa2ac1fc3494b6eb60872e74778”)
Identificator scurt UUID („f78375b1c487”)
Nume („jonah”)

Identificatorii UUID provin de la demonul Docker, iar dacă un nume nu este atribuit
recipient cu --Nume atunci demonul va genera și un nume de șir aleatoriu. Numele este
util la definirea legăturilor (vezi --legătură) (sau orice alt loc pe care trebuie să îl identificați a
container). Acest lucru funcționează atât pentru containerele Docker în fundal, cât și în prim-plan.

--net="pod"
Setați modul de rețea pentru container
„bridge”: creați o stivă de rețea pe Docker implicit
pod
„niciunul”: fără rețea
„container: ': reutilizați rețeaua altui container
stivui
„gazdă”: utilizați stiva de rețea gazdă Docker. Notă: gazda
modul oferă containerului acces complet la serviciile de sistem local, cum ar fi D-bus și is
deci considerat nesigur.
' | ': conectați-vă la un utilizator definit
reţea

--net-alias=[]
Adăugați un alias în domeniul rețelei pentru container

--oom-kill-disable=adevărat|fals
Dacă să dezactivezi OOM Killer pentru container sau nu.

--oom-score-adj=""
Ajustați preferințele OOM ale gazdei pentru containere (acceptă de la -1000 la 1000)

-P, --public-toate=adevărat|fals
Publicați toate porturile expuse în porturi aleatorii de pe interfețele gazdă. Valoarea implicită este fals.

Când este setată la true, publicați toate porturile expuse la interfețele gazdă. Valoarea implicită este false.
Dacă operatorul folosește -P (sau -p), atunci Docker va face portul expus accesibil pe
gazdă și porturile vor fi disponibile oricărui client care poate ajunge la gazdă. Când utilizați -P,
Docker va lega orice port expus la un port aleatoriu de pe gazdă într-un efemer port
gamă definit de /proc/sys/net/ipv4/ip_local_port_range. Pentru a găsi maparea între
porturile gazdă și porturile expuse, utilizați docher port.

-p, --publica=[]
Publicați portul unui container sau gama de porturi pe gazdă.

Format: ip:hostPort:containerPort | ip::containerPort | hostPort:containerPort |
containerPort Atât hostPort, cât și containerPort pot fi specificate ca o serie de porturi. Când
specificând intervale pentru ambele, numărul de porturi container din interval trebuie să se potrivească cu
numărul de porturi gazdă din interval. (de exemplu, docher alerga -p 1234-1236: 1222-1224 --Nume
asta funcționează -t Busybox dar nu docher alerga -p 1230-1236: 1230-1240 --Nume
RangeContainerPortsBiggerThanRangeHostPorts -t Busybox) Cu ip: docher alerga -p
127.0.0.1:$HOSTPORT:$CONTAINERPORT --Nume CONTAINER -t vreo imagine Utilizare docher port pentru a vedea
maparea propriu-zisă: docher port CONTAINER $CONTAINERPORT

--pid=gazdă
Setați modul PID pentru container
gazdă: utilizați spațiul de nume PID al gazdei în interiorul containerului.
Notă: modul gazdă oferă containerului acces complet la PID local și, prin urmare, este
considerat nesigur.

--uts=gazdă
Setați modul UTS pentru container
gazdă: utilizați spațiul de nume UTS al gazdei în interiorul containerului.
Notă: modul gazdă oferă containerului acces la schimbarea numelui gazdă al gazdei și este
deci considerat nesigur.

--privilegiat=adevărat|fals
Acordați privilegii extinse acestui container. Valoarea implicită este fals.

În mod implicit, containerele Docker sunt „neprivilegiate” (=false) și nu pot, de exemplu, rula un
Daemon Docker în interiorul containerului Docker. Acest lucru se datorează faptului că, implicit, un container nu este
permis să acceseze orice dispozitiv. Un container „privilegiat” are acces la toate dispozitivele.

Când operatorul execută docher alerga --privilegiat, Docker va permite accesul tuturor
dispozitivele de pe gazdă, precum și setați o anumită configurație în AppArmor pentru a permite containerul
aproape tot același acces la gazdă ca și procesele care rulează în afara unui container pe
gazdă.

--numai citire=adevărat|fals
Montați sistemul de fișiere rădăcină al containerului ca doar pentru citire.

În mod implicit, un container va avea sistemul de fișiere rădăcină inscriptibil, permițând proceselor să scrie
fișiere oriunde. Prin specificarea --numai citire flag containerul își va avea rădăcina
Sistemul de fișiere montat ca numai citire interzicând orice scriere.

--repornire="Nu."
Politica de repornire pentru a se aplica la ieșirea unui container (nu, la eșec[:max-retry], întotdeauna,
decât dacă-oprit).

--rm=adevărat|fals
Scoateți automat containerul când iese (incompatibil cu -d). Valoarea implicită este
fals.

--securitate-opt=[]
Opțiuni de securitate

„label:user:USER”: Setați utilizatorul etichetei pentru container
„label:role:ROLE”: setați rolul etichetei pentru container
„label:type:TYPE”: setați tipul de etichetă pentru container
„label:level:LEVEL” : setați nivelul etichetei pentru container
„label:disable”: dezactivați limitarea etichetei pentru container

--semnal-stop=TERMEN ȚINTĂ
Semnal pentru oprirea unui container. Implicit este SIGTERM.

--shm-size=""
Dimensiunea /dev/shm. Formatul este .
număr trebuie să fie mai mare decât 0. Unitatea este opțională și poate fi b (octeți), k (kiloocteți),
m(megaocteți) sau g (gigaocteți).
Dacă omiteți unitatea, sistemul folosește octeți. Dacă omiteți în întregime dimensiunea, sistemul
utilizări 64m.

--sig-proxy=adevărat|fals
Proxy semnale primite către proces (numai în modul non-TTY). SIGCHLD, SIGSTOP și
SIGKILL nu sunt proxy. Valoarea implicită este adevărat.

--schimbări de memorie=""
Reglați comportamentul de schimb de memorie al unui container. Acceptă un număr întreg între 0 și 100.

-t, --tty=adevărat|fals
Alocați un pseudo-TTY. Valoarea implicită este fals.

Când este setat la adevărat, Docker poate aloca un pseudo-tty și se poate atașa la intrarea standard a oricărui
recipient. Aceasta poate fi folosită, de exemplu, pentru a rula un shell interactiv de uz casnic. The
implicit este fals.

-t opțiunea este incompatibilă cu o redirecționare a intrării standard a clientului docker.

--tmpfs=[] Creați o montură tmpfs

Montați un sistem de fișiere temporar (tmpfs) se montează într-un container, de exemplu:

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

Această comandă montează a tmpfs at / tmp în interiorul recipientului. Opțiunile de montare acceptate sunt
la fel ca implicit Linux monta steaguri. Dacă nu specificați nicio opțiune, sistemele
folosește următoarele opțiuni: rw,noexec,nosuid,nodev,size=65536k.

-u, --utilizator=""
Setează numele de utilizator sau UID-ul utilizat și, opțional, numele grupului sau GID-ul specificat
comanda.

Următoarele exemple sunt toate valabile:
--utilizator [utilizator | utilizator:grup | uid | uid:gid | utilizator:gid | uid:grup ]

Fără acest argument, comanda va fi rulată ca root în container.

--ulimit=[]
Ulimitați opțiunile

-v|--volum[=[[HOST-DIR:]CONTAINER-DIR[:OPTIONS]]]
Creați un suport de legătură. Dacă specificați, -v /HOST-DIR:/CONTAINER-DIR, Docker
bind monturi /HOST-DIR în gazdă să /CONTAINER-DIR în Docker
recipient. Dacă „HOST-DIR” este omis, Docker creează automat noul
volum pe gazdă. The OPŢIUNI sunt o listă delimitată prin virgulă și pot fi:

· [rw|ro]

· [z|Z]

· [[r]a distribuit|[r]sclav|[r]privat]

CONTAINER-DIR trebuie să fie o cale absolută precum /src/docs. HOST-DIR poate fi un
cale absolută sau a nume valoare. A nume valoarea trebuie să înceapă cu un caracter alfanumeric,
urmată de a-z0-9, _ (sublinia), . (perioada) sau - (cratimă). O cale absolută începe cu
a / (bară oblică înainte).

Dacă furnizați un HOST-DIR aceasta este o cale absolută, Docker se montează pe calea dvs
specifica. Dacă furnizați un nume, Docker creează un volum numit prin aceasta nume. De exemplu,
puteti specifica fie /foo or foo pentru o HOST-DIR valoare. Dacă furnizați /foo valoare,
Docker creează un bind-mount. Dacă furnizați foo specificație, Docker creează un named
volum.

Puteți specifica mai multe -v opțiuni pentru a monta unul sau mai multe suporturi pe un container. A folosi
aceleași monturi în alte containere, specificați --volume-din varianta de asemenea.

Puteți adăuga :ro or :rw sufix la un volum pentru a-l monta în modul doar citire sau citire-scriere,
respectiv. În mod implicit, volumele sunt montate în citire-scriere. Vezi exemple.

Sistemele de etichetare precum SELinux necesită ca etichetele adecvate să fie plasate pe conținutul de volum
montat într-un container. Fără o etichetă, sistemul de securitate ar putea împiedica procesele
rulează în interiorul containerului de la utilizarea conținutului. În mod implicit, Docker nu se modifică
etichetele stabilite de sistemul de operare.

Pentru a schimba o etichetă în contextul containerului, puteți adăuga oricare dintre cele două sufixe :z or :Z la
suportul de volum. Aceste sufixe îi spun lui Docker să reeticheteze obiectele fișierelor din partajarea
volumele. The z opțiunea îi spune lui Docker că două containere împart conținutul de volum. Ca
rezultat, Docker etichetează conținutul cu o etichetă de conținut partajat. Etichetele de volum partajate permit
toate containerele pentru a citi/scrie conținut. The Z opțiunea îi spune lui Docker să eticheteze conținutul cu
o etichetă privată nedistribuită. Numai containerul actual poate folosi un volum privat.

În mod implicit, volumele montate sunt privat. Asta înseamnă orice montură făcută în interiorul containerului
nu va fi vizibil pe gazdă și vice-versa. Se poate schimba acest comportament prin specificarea a
proprietatea de propagare a montului de volum. Realizarea unui volum comun monturi realizate sub acel volum
interiorul containerului va fi vizibil pe gazdă și vice-versa. Realizarea unui volum sclav permite
propagarea montului într-un singur mod și anume monturile efectuate pe gazdă sub acel volum va fi
vizibil în interiorul containerului, dar nu invers.

Pentru a controla proprietatea de propagare a monturii a volumului se poate folosi :[r]distribuit, :[r]sclav or
:[r]privat steag de propagare. Proprietatea de propagare poate fi specificată numai pentru bind montat
volume și nu pentru volume interne sau volume numite. Pentru ca propagarea monturii să funcționeze
punctul de montare sursă (punctul de montare unde este montat directorul sursă) trebuie să aibă dreptul
proprietăți de propagare. Pentru volume partajate, punctul de montare sursă trebuie să fie partajat. Si pentru
volume slave, montarea sursă trebuie să fie fie partajată, fie slave.

Utilizare df pentru a descoperi montura sursă și apoi utilizați găsimnt -o
ȚINTĂ, PROPAGARE pentru a afla proprietățile de propagare ale sursei
montură. Dacă găsimnt utilitarul nu este disponibil, atunci se poate privi la intrarea de montare pentru sursă
punct de montare în /proc/self/mountinfo. Uita-te la facultativ domenii și vezi dacă există vreo propagare
sunt specificate proprietățile. împărtășit:X înseamnă că montura este comun, maestru:X înseamnă că montura este sclav
iar dacă nu există nimic, înseamnă că montura este privat.

Pentru a modifica proprietățile de propagare ale unui punct de montare utilizați monta comanda. De exemplu, dacă unul
vrea să lege directorul sursă de montare /foo se poate face monta --lega /foo /foo și monta
--face-privat --make-shared /foo. Acest lucru va converti /foo în a comun punctul de montare.
Alternativ, se pot schimba direct proprietățile de propagare ale monturii sursei. Spune / is
montura sursă pentru /foo, apoi folosiți monta --make-shared / a converti / într-o comun montură.

notițe: Când utilizați systemd pentru a gestiona pornirea și oprirea demonului Docker, în
Fișierul unitar systemd există o opțiune pentru a controla propagarea montului pentru Docker
demonul însuși, numit MountFlags. Valoarea acestei setări poate face ca Docker să nu facă acest lucru
vezi modificările de propagare a monturii făcute pe punctul de montare. De exemplu, dacă această valoare
is sclav, este posibil să nu puteți utiliza comun or rshared propagare pe un volum.

--volum-driver=""
Driverul de volum al containerului. Acest driver creează volume specificate fie din
un Dockerfile VOLUM instrucție sau de la docher alerga -v steag.
Vedea docker-volum-create(1) pentru detalii complete.

--volume-din=[]
Montați volume din containerele specificate

Montează volumele deja montate dintr-un container sursă pe altul
recipient. Trebuie să furnizați codul container-id al sursei. Pentru a împărtăși
un volum, utilizați --volume-din opțiune când rulați
containerul țintă. Puteți partaja volume chiar dacă containerul sursă
nu se execută.

Implicit, Docker montează volumele în același mod (citire-scriere sau
numai citire) deoarece este montat în containerul sursă. Opțional, tu
poate schimba acest lucru prin sufixarea container-id-ului fie cu :ro or
:rw cuvinte cheie.

Dacă locația volumului din containerul sursă se suprapune cu
datele care se află pe un container țintă, apoi volumul se ascunde
acele date despre țintă.

-w, --workdir=""
Director de lucru din interiorul containerului

Directorul de lucru implicit pentru rularea binarelor într-un container este rădăcina
directorul (/). Dezvoltatorul poate seta un alt implicit cu Dockerfile WORKDIR
instrucție. Operatorul poate suprascrie directorul de lucru folosind -w opțiune.

Ieşire Stare

Codul de ieșire din docher alerga oferă informații despre motivul pentru care containerul nu a funcționat sau
de ce a ieșit. Când docher alerga ieșiri cu un cod diferit de zero, codurile de ieșire urmează
Chroot. standard, vezi mai jos:

125 if il eroare is cu Docher daemon în sine

$ docker run --foo busybox; eco $?
# steag furnizat, dar nedefinit: --foo
Vedeți „docker run --help”.
125

126 if il conținute comandă nu poti be invocat

$ docker run busybox / Etc; eco $?
# exec: "/ Etc": acces refuzat
docker: Răspuns de eroare de la daemon: Comanda conținută nu a putut fi invocată
126

127 if il conținute comandă nu poti be găsit

$ docker run busybox foo; eco $?
# exec: "foo": fișierul executabil nu a fost găsit în $PATH
docker: Răspuns de eroare de la daemon: Comanda conținută nu a fost găsită sau nu există
127

Ieşire cod of conținute comandă in caz contrar

$ docker run busybox / Bin / sh -c „ieșirea 3”
# 3

EXEMPLE

Alergare recipient in read-only mod

În timpul dezvoltării imaginii containerelor, containerele trebuie adesea să scrie în conținutul imaginii.
Instalarea pachetelor în / usr, de exemplu. În producție, aplicațiile rareori au nevoie
scrie pe imagine. Aplicațiile container scriu pe volume dacă trebuie să scrie în fișier
sisteme la toate. Aplicațiile pot fi securizate prin rularea lor în modul numai citire
folosind comutatorul --read-only. Acest lucru protejează imaginea containerelor de modificări. Citit
numai containerele ar putea avea nevoie să scrie date temporare. Cel mai bun mod de a gestiona acest lucru este să
montați directoarele tmpfs pe / alerga și /tmp.

# docker run --read-only --tmpfs / alerga --tmpfs / tmp -i -t fedora / bin / bash

Expunere log mesaje din il recipient la il ale gazdei log

Dacă doriți ca mesajele care sunt conectate în containerul dvs. să apară în cel al gazdei
syslog/journal, atunci ar trebui să legați mount directorul /dev/log după cum urmează.

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

Din interiorul containerului, puteți testa acest lucru trimițând un mesaj în jurnal.

(bash)# logger „Salut din containerul meu”

Apoi ieșiți și verificați jurnalul.

# Ieșire

# journalctl -b | grep Bună

Acesta ar trebui să listeze mesajul trimis către logger.

atașare la unu or mai mult din STDIN, STDOUT, Stderr

Dacă nu specificați -a, atunci Docker va atașa tot (stdin,stdout,stderr) pe care l-ați
place să se conecteze în schimb, ca în:

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

Partajarea IPC între containere

Folosind shm_server.c disponibil aici: ⟨https://www.cs.cf.ac.uk/Dave/C/node27.html⟩

Testarea --ipc=gazdă mod:

Gazda arată un segment de memorie partajată cu 7 coduri atașate, se întâmplă să fie de la httpd:

$ sudo ipcs -m

------ Segmente de memorie partajată --------
cheie shmid proprietar perms octeți starea nattch
0x01128e25 0 root 600 1000 7

Acum rulați un container obișnuit și acesta NU vede corect segmentul de memorie partajată din
gazda:

$ docker run -it shm ipcs -m

------ Segmente de memorie partajată --------
cheie shmid proprietar perms octeți starea nattch

Rulați un container cu noul --ipc=gazdă opțiunea și acum vede segmentul de memorie partajată
de la gazdă httpd:

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

------ Segmente de memorie partajată --------
cheie shmid proprietar perms octeți starea nattch
0x01128e25 0 root 600 1000 7

Testarea --ipc=container:CONTAINERID mod:

Porniți un container cu un program pentru a crea un segment de memorie partajată:

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

------ Segmente de memorie partajată --------
cheie shmid proprietar perms octeți starea nattch
0x0000162e 0 root 666 27 1

Crearea unui al doilea container nu arată corect niciun segment de memorie partajată din primul container:

$ docker run shm ipcs -m

------ Segmente de memorie partajată --------
cheie shmid proprietar perms octeți starea nattch

Creați un al treilea container folosind noua opțiune --ipc=container:CONTAINERID, acum arată
segment de memorie partajată de la primul:

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

------ Segmente de memorie partajată --------
cheie shmid proprietar perms octeți starea nattch
0x0000162e 0 root 666 27 1

Legarea Containere

notițe: Această secțiune descrie conexiunea între containere în modul implicit (punte)
rețea, cunoscută și sub denumirea de „legături moștenite”. Folosind --legătură pe utilizări ale rețelelor definite de utilizator
descoperirea bazată pe DNS, care nu adaugă intrări la / Etc / hosts, și nu se setează
variabile de mediu pentru descoperire.

Funcția de legătură permite mai multor containere să comunice între ele. De exemplu, a
containerul al cărui fișier Dockerfile are portul expus 80 poate fi rulat și numit după cum urmează:

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

Un al doilea container, în acest caz numit linker, poate comunica cu containerul httpd,
numit link-test, prin rularea cu --link= :

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

Acum linkerul containerului este legat de container link-test cu aliasul lt. Rularea
env comanda din containerul linker arată variabilele de mediu
cu contextul 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
CALEA=/ usr / local / sbin:/ / Local / bin usr:/ usr / sbin:/ usr / bin:/ sbin:/ cos
PWD=/
LT_NAME=/linker/lt
SHLVL=1
ACASA=/
LT_PORT_80_TCP_ADDR=172.17.0.3
_=/usr/bin/env

Când conectați două containere, Docker va folosi porturile expuse ale containerului pentru a crea un
tunel securizat pentru accesul părintelui.

Dacă un container este conectat la rețeaua de punte implicită și legate de cu alte
containere, apoi al containerului / Etc / hosts fișierul este actualizat cu containerul legat
nume.

notițe Deoarece Docker poate actualiza în direct containerul / Etc / hosts dosar, poate exista
situații în care procesele din interiorul containerului pot ajunge să citească un gol sau
incomplet / Etc / hosts fişier. În cele mai multe cazuri, reîncercarea citirii din nou ar trebui să remedieze
problemă.

Maparea porturile pentru Extern Folosire

Portul expus al unei aplicații poate fi mapat la un port gazdă folosind -p steag. Pentru
de exemplu, un port httpd 80 poate fi mapat la portul gazdă 8080 folosind următoarele:

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

Crearea și Montare a Date Volum Recipient

Multe aplicații necesită partajarea datelor persistente în mai multe containere. Docher
vă permite să creați un container de volum de date din care să se monteze alte containere. Pentru
de exemplu, creați un container numit care conține directoarele /var/volume1 și /tmp/volume2.
Imaginea va trebui să conțină aceste directoare, așa că câteva instrucțiuni RUN mkdir
ar putea fi necesar pentru imaginea dvs. de date fedora:

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

Parametrii multipli --volumes-from vor reuni mai multe volume de date din multiple
containere. Și este posibil să montați volumele care au venit din containerul DATE în
încă un container prin intermediul containerului intermediar fedora-container1, permițând
extrageți sursa reală de date de la utilizatorii respectivelor date:

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

Montare Extern volumele

Pentru a monta un director gazdă ca volum container, specificați calea absolută către
director și calea absolută pentru directorul containerului, separate prin două puncte:

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

Când utilizați SELinux, rețineți că gazda nu cunoaște politica SELinux a containerului.
Prin urmare, în exemplul de mai sus, dacă politica SELinux este aplicată, /var/db directorul este
nu poate fi scris în container. Va apărea un mesaj „Permisiune refuzată” și un avc:
mesaj în syslogul gazdei.

Pentru a rezolva acest lucru, la momentul scrierii acestei pagini de manual, trebuie să fie următoarea comandă
rulați pentru ca eticheta de tip de politică SELinux adecvată să fie atașată gazdei
director:

# chcon -Rt svirt_sandbox_file_t /var/db

Acum, scrierea în volumul /data1 din container va fi permisă și modificările vor fi
se reflectă și pe gazdă în /var/db.

Utilizarea alternativă securitate etichetarea

Puteți suprascrie schema de etichetare implicită pentru fiecare container specificând
--securitate-opt steag. De exemplu, puteți specifica nivelul MCS/MLS, o cerință pentru MLS
sisteme. Specificarea nivelului în următoarea comandă vă permite să partajați același nivel
conținutul dintre recipiente.

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

Un exemplu MLS ar putea fi:

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

Pentru a dezactiva etichetarea de securitate pentru acest container față de rularea cu --permisiv
flag, utilizați următoarea comandă:

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

Dacă doriți o politică de securitate mai strictă asupra proceselor dintr-un container, puteți specifica
un tip alternativ pentru container. Ai putea rula un container căruia îi este permis doar
ascultați pe porturile Apache executând următoarea comandă:

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

Notă:

Ar trebui să scrieți o politică care să definească a svirt_apache_t tip.

reglaj dispozitiv greutate

Dacă doriți să setați / dev / sda greutatea dispozitivului la 200, puteți specifica greutatea dispozitivului prin
--blkio-greutate-dispozitiv steag. Utilizați următoarea comandă:

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

Specifica izolare tehnologie pentru recipient (--izolare)

Această opțiune este utilă în situațiile în care rulați containere Docker pe Microsoft
Windows. The --izolare opțiunea setează tehnologia de izolare a containerului. Pe Linux,
singurul suportat este lipsă opțiunea care utilizează spații de nume Linux. Aceste două comenzi
sunt echivalente pe Linux:

$ docker run -d busybox top
$ docker run -d --isolation default busybox top

Pe Microsoft Windows, poate lua oricare dintre aceste valori:

· lipsă: Folosiți valoarea specificată de demonul Docker --exec-opt . Dacă daemon face
nu specifica o tehnologie de izolare, Microsoft Windows foloseste proces ca implicit
valoare.

· proces: Numai izolarea spațiului de nume.

· hiperv: Izolare bazată pe partiții hypervisor Hyper-V.

În practică, atunci când rulați pe Microsoft Windows fără a daemon set de opțiuni, acestea două
comenzile sunt echivalente:

$ docker run -d --isolation default busybox top
$ docker run -d --proces de izolare busybox top

Dacă ați setat --exec-opt izolare=hiperv opțiunea din Docker daemon, oricare dintre acestea
comenzile au ca rezultat, de asemenea hiperv izolare:

$ docker run -d --isolation default busybox top
$ docker run -d --isolation hyperv busybox top

ISTORIE

Aprilie 2014, compilat inițial de William Henry (whenry at redhat dot com) pe baza
material sursă docker.com și lucrări interne. iunie 2014, actualizat de Sven Dowideit
⟨[e-mail protejat]⟩ iulie 2014, actualizat de Sven Dowideit ⟨[e-mail protejat]⟩
Noiembrie 2015, actualizat de Sally O'Malley ⟨[e-mail protejat]⟩

Utilizați docker-run online folosind serviciile onworks.net