Docker
Kör containrar

Syntax

• docker run [OPTIONS] IMAGE [COMMAND] [ARG ...]

Köra en container

docker run hello-world

Detta hämtar den senaste hallo-världsbilden från Docker Hub (om du inte redan har den), skapar en ny behållare och kör den. Du bör se ett meddelande om att din installation verkar fungera korrekt.

Kör ett annat kommando i behållaren

docker run docker/whalesay cowsay 'Hello, StackExchange!'

Detta kommando säger Docker att skapa en behållare från docker/whalesay bilden och köra kommandot cowsay 'Hello, StackExchange!' i det. Det bör skriva ut en bild av en val som säger Hello, StackExchange! till din terminal.

Om ingångspunkten i bilden är standard kan du köra alla kommandon som är tillgängliga i bilden:

docker run docker/whalesay ls /

Om det har ändrats under bildbyggnad måste du vända tillbaka det till standard

docker run --entrypoint=/bin/bash docker/whalesay -c ls /

Radera automatiskt en behållare efter att ha kört den

Normalt kvarstår en Docker-behållare efter att den har gått ut. Detta låter dig köra behållaren igen, inspektera dess filsystem och så vidare. Men ibland vill du köra en container och ta bort den omedelbart efter att den har slutat. Till exempel för att köra ett kommando eller visa en fil från filsystemet. Docker tillhandahåller kommandoradsalternativet - --rm för detta ändamål:

docker run --rm ubuntu cat /etc/hosts

Detta skapar en behållare från "ubuntu" -bilden, visar innehållet i / etc / hosts- filen och raderar sedan behållaren omedelbart efter att den har gått ut. Detta hjälper till att förhindra att du behöver städa upp behållare efter att du har gjort experiment.

Obs: --rm flaggan fungerar inte tillsammans med -d (- --detach ) -flaggan i dockaren <1.13.0.

När --rm flagga är inställd, tar Docker också bort volymerna som är associerade med behållaren när behållaren tas bort. Detta liknar köra docker rm -v my-container . Endast volymer som anges utan namn tas bort .

Till exempel med docker run -it --rm -v /etc -v logs:/var/log centos /bin/produce_some_logs kommer volymen av /etc att tas bort, men volymen på /var/log kommer inte. Volymer som ärvts via - volumes-from kommer att tas bort med samma logik - om den ursprungliga volymen anges med ett namn kommer den inte att tas bort.

Ange ett namn

Som standard ges behållare som skapats med docker run ett slumpmässigt namn som small_roentgen eller modest_dubinsky . Dessa namn är inte särskilt användbara för att identifiera syftet med en container. Det är möjligt att ange ett namn för behållaren genom att --name kommandoradsalternativet - --name :

docker run --name my-ubuntu ubuntu:14.04

Namnen måste vara unika; om du skickar ett namn som en annan behållare redan använder, kommer Docker att skriva ut ett fel och ingen ny behållare skapas.

Att ange ett namn kommer att vara användbart när man hänvisar till behållaren i ett Docker-nätverk. Detta fungerar för både bakgrunds- och förgrundsdockerbehållare.

Behållare i standardbronätverket måste vara länkade för att kommunicera med namn.

Binder en containerport till värden

docker run -p "8080:8080" myApp
docker run -p "192.168.1.12:80:80" nginx
docker run -P myApp

För att använda portar på värden har blivit exponerade i en bild (via EXPOSE Dockerfile-direktivet eller - --expose kommandoradsalternativet för docker run ) måste dessa portar vara bundna till värden med kommandot -p eller -P radalternativ. Att använda -p kräver att den specifika porten (och valfritt värdgränssnitt) ska anges. Med hjälp av det stora bokstaven -P kommandorad-alternativet kommer Docker att tvinga att binda alla exponerade portar i en behållares bild till värden.

Policy för omstart av behållare (starta en container vid start)

docker run --restart=always -d <container>

Som standard kommer Docker inte att starta om behållare när Docker-demonet startar om, till exempel efter omstart av ett värdsystem. Docker tillhandahåller en omstartpolicy för dina containrar genom att tillhandahålla kommandoradsalternativet - --restart . Leverera - --restart=always kommer alltid att göra att en behållare startas om efter att Docker-demonet har startats om. Men när den behållaren stoppas manuellt (t.ex. med docker stop <container> ) kommer omstartpolicyn inte att tillämpas på behållaren.

Flera alternativ kan anges för alternativet - --restart baserat på kravet (- --restart=[policy] ). Dessa alternativ påverkar också hur containern startar vid start.

Kör en container i bakgrunden

För att hålla en container igång i bakgrunden, -d alternativet -d kommandorad under containerstart:

docker run -d busybox top

Alternativet -d kör behållaren i fristående läge. Det motsvarar också -d=true .

En behållare i fristående läge kan inte tas bort automatiskt när den stannar, det betyder att man inte kan använda alternativet - rm i kombination med -d-alternativet.

Tilldela en volym till en behållare

En Docker-volym är en fil eller katalog som kvarstår utöver behållarens livslängd. Det är möjligt att montera en värdfil eller katalog i en behållare som en volym (kringgå UnionFS).

Lägg till en volym med -v kommandoraden alternativ:

docker run -d -v "/data" awesome/app bootstrap.sh

Detta skapar en volym och monterar den på sökvägen /data inuti behållaren.

• Obs: Du kan använda flaggan - --rm att automatiskt ta bort volymen när behållaren tas bort.

Montering av värdkataloger

Så här monterar du en värdfil eller katalog i en behållare:

docker run -d -v "/home/foo/data:/data" awesome/app bootstrap.sh

• När du anger en värdkatalog måste en absolut sökväg anges.

Detta kommer att montera värdkatalogen /home/foo/data på /data inuti behållaren. Denna "bindande monterade värdkatalog" -volym är samma sak som en Linux- mount --bind och mount --bind därför tillfälligt värdkatalogen över den angivna behållarvägen under hela behållarens livslängd. Förändringar i volymen från antingen värden eller behållaren återspeglas omedelbart i den andra eftersom de är samma destination på disken.

UNIX-exempel på montering av en relativ mapp

docker run -d -v $(pwd)/data:/data awesome/app bootstrap.sh

Namnge volymer

En volym kan namnges genom att tillhandahålla en sträng istället för en värdkatalogväg, dockaren skapar en volym med det namnet.

docker run -d -v "my-volume:/data" awesome/app bootstrap.sh

När du har skapat en namngiven volym kan volymen sedan delas med andra behållare med det namnet.

Ställa in miljövariabler

$ docker run -e "ENV_VAR=foo" ubuntu /bin/bash

Både -e och --env kan användas för att definiera miljövariabler inuti en container. Det är möjligt att tillhandahålla många miljövariabler med en textfil:

$ docker run --env-file ./env.list ubuntu /bin/bash

Exempel på miljövariabelfil:

# This is a comment
TEST_HOST=10.10.0.127

--env-file tar ett filnamn som ett argument och förväntar sig att varje rad ska vara i VARIABLE=VALUE , vilket efterliknar argumentet som skickas till --env . Kommentarrader behöver bara förinställas med # .

Oavsett --env-file på dessa tre flaggor --env-file först och sedan -e / --env flaggorna. På detta sätt kommer alla miljövariabler som levereras individuellt med -e eller --env att åsidosätta variabler som levereras i --env-var textfilen.

Ange ett värdnamn

Som standard ges behållare skapade med dockarkörning ett slumpmässigt värdnamn. Du kan ge behållaren ett annat värdnamn genom att skicka flaggan - värdnamn:

docker run --hostname redbox -d ubuntu:14.04

Kör en container interaktivt

För att köra en container interaktivt, skicka in -it alternativen:

$ docker run -it ubuntu:14.04 bash
root@8ef2356d919a:/# echo hi
hi
root@8ef2356d919a:/#

-i håller STDIN öppen, medan -t tilldelar en pseudo-TTY.

Kör behållare med minne / växlingsgränser

Ställ in minnesgränsen och inaktivera swap-gränsen

docker run -it -m 300M --memory-swap -1 ubuntu:14.04 /bin/bash

Ställ in både minne och växlingsgräns. I detta fall kan behållaren använda 300M minne och 700M byte.

docker run -it -m 300M --memory-swap 1G ubuntu:14.04 /bin/bash

Skaffa ett skal i en löpande (fristående) behållare

Logga in i en löpande behållare

En användare kan ange en löpande behållare i ett nytt interaktivt bashell med exec kommando.

Säg att en behållare kallas jovial_morse så kan du få en interaktiv, pseudo-TTY bashell genom att köra:

docker exec -it jovial_morse bash

Logga in i en behållare med en specifik användare

Om du vill ange en behållare som en specifik användare kan du ställa in den med -u eller - --user . Användarnamnet måste finnas i behållaren.

-u, --user Användarnamn eller UID (format: <name|uid>[:<group|gid>] )

Detta kommando loggar in i jovial_morse med dockeruser användaren

docker exec -it -u dockeruser jovial_morse bash

Logga in i en löpande behållare som root

Om du vill logga in som root använder du bara -u root parametern. Rotanvändare finns alltid.

docker exec -it -u root jovial_morse bash

Logga in på en bild

Du kan också logga in på en bild med run kommandot, men det kräver en bildnamn i stället för en behållare namn.

docker run -it dockerimage bash

Logga in på en mellanliggande bild (felsökning)

Du kan också logga in på en mellanliggande bild, som skapas under en Dockerfile-konstruktion.

Output från docker build .

$ docker build .
Uploading context 10240 bytes
Step 1 : FROM busybox
Pulling repository busybox
 ---> e9aa60c60128MB/2.284 MB (100%) endpoint: https://cdn-registry-1.docker.io/v1/
Step 2 : RUN ls -lh /
 ---> Running in 9c9e81692ae9
total 24
drwxr-xr-x    2 root     root        4.0K Mar 12  2013 bin
drwxr-xr-x    5 root     root        4.0K Oct 19 00:19 dev
drwxr-xr-x    2 root     root        4.0K Oct 19 00:19 etc
drwxr-xr-x    2 root     root        4.0K Nov 15 23:34 lib
lrwxrwxrwx    1 root     root           3 Mar 12  2013 lib64 -> lib
dr-xr-xr-x  116 root     root           0 Nov 15 23:34 proc
lrwxrwxrwx    1 root     root           3 Mar 12  2013 sbin -> bin
dr-xr-xr-x   13 root     root           0 Nov 15 23:34 sys
drwxr-xr-x    2 root     root        4.0K Mar 12  2013 tmp
drwxr-xr-x    2 root     root        4.0K Nov 15 23:34 usr
 ---> b35f4035db3f
Step 3 : CMD echo Hello world
 ---> Running in 02071fceb21b
 ---> f52f38b7823e

Lägg märke till ---> Running in 02071fceb21b du ---> Running in 02071fceb21b utgången kan du logga in på dessa bilder:

docker run -it 02071fceb21b bash

Skickar stdin till behållaren

I fall som att återställa en databasdump, eller på annat sätt vill driva lite information genom ett rör från värden, kan du använda -i flaggan som ett argument för att docker run eller docker exec .

Om du t.ex. antar att du vill lägga till en containeriserad mariadb-klient en databasdump som du har på värden, i en lokal dump.sql fil, kan du utföra följande kommando:

docker exec -i mariadb bash -c 'mariadb "-p$MARIADB_PASSWORD" ' < dump.sql

I allmänhet,

docker exec -i container command < file.stdin

Eller

docker exec -i container command <<EOF
inline-document-from-host-shell-HEREDOC-syntax
EOF

Ta loss från en behållare

När du är ansluten till en löpande behållare med en tilldelad pty ( docker run -it ... ), kan du trycka på Control P - Control Q för att lossa.

Överträffar bildintrångsdirektivet

docker run --name="test-app" --entrypoint="/bin/bash" example-app

Detta kommando kommer att åsidosätta ENTRYPOINT direktivet för example-app bilden när containertest test-app skapas. CMD direktivet för bilden kommer att förbli oförändrat om inte annat anges:

docker run --name="test-app" --entrypoint="/bin/bash" example-app /app/test.sh

I exemplet ovan har både ENTRYPOINT och CMD för bilden åsidosatts. Denna containerprocess blir /bin/bash /app/test.sh .

Lägg till värdpost i behållaren

docker run --add-host="app-backend:10.15.1.24" awesome-app

Detta kommando lägger till en post i behållarens /etc/hosts fil som följer formatet - --add-host <name>:<address> . I det här exemplet kommer namnet app-backend att lösa till 10.15.1.24 . Detta är särskilt användbart för att binda olika app-komponenter programmatiskt.

Förhindra att behållaren stannar när inga kommandon körs

En behållare stannar om inget kommando körs i förgrunden. Att använda alternativet -t förhindrar behållaren från att stoppa, även om den är frikopplad med alternativet -d .

docker run -t -d debian bash

Stoppa en behållare

docker stop mynginx

Dessutom kan behållar-ID också användas för att stoppa behållaren i stället för dess namn.

Detta kommer att stoppa en löpande behållare genom att skicka SIGTERM-signalen och sedan SIGKILL-signalen om det behövs.

Vidare kan kill-kommandot användas för att omedelbart skicka en SIGKILL eller någon annan specificerad signal med hjälp av -s alternativet.

docker kill mynginx

Specificerad signal:

docker kill -s SIGINT mynginx

Att stoppa en behållare tar inte bort den. Använd docker ps -a att se din stoppade behållare.

Kör ett annat kommando på en behållare som körs

Vid behov kan du be Docker att utföra ytterligare kommandon på en redan körd behållare med exec kommandot. Du behöver behållarens ID som du kan få med docker ps .

docker exec 294fbc4c24b3 echo "Hello World"

Du kan bifoga ett interaktivt skal om du använder alternativet -it .

docker exec -it 294fbc4c24b3 bash

Kör GUI-appar i en Linux-behållare

Som standard kan en Docker-behållare inte köra en GUI-applikation.

Innan detta måste X11-uttaget först vidarebefordras till behållaren så att det kan användas direkt. Miljövariabeln DISPLAY måste också vidarebefordras:

docker run -v /tmp/.X11-unix:/tmp/.X11-unix -e DISPLAY=unix$DISPLAY <image-name>

Detta kommer att misslyckas först, eftersom vi inte angav behörigheterna för X-servervärdet:

cannot connect to X server unix:0

Det snabbaste (men inte säkraste) sättet är att tillåta åtkomst direkt med:

xhost +local:root

Efter avslutad behållare kan vi återgå till det ursprungliga tillståndet med:

xhost -local:root

Ett annat (säkrare) sätt är att förbereda en Dockerfile som kommer att bygga en ny bild som använder våra användaruppgifter för att komma åt X-servern:

FROM <iamge-name>
MAINTAINER <you>

# Arguments picked from the command line!
ARG user
ARG uid
ARG gid

#Add new user with our credentials
ENV USERNAME ${user}
RUN useradd -m $USERNAME && \
        echo "$USERNAME:$USERNAME" | chpasswd && \
        usermod --shell /bin/bash $USERNAME && \
        usermod  --uid ${uid} $USERNAME && \
        groupmod --gid ${gid} $USERNAME

USER ${user}

WORKDIR /home/${user}

När docker build anropar docker build från kommandoraden måste vi passera ARG- variablerna som visas i Dockerfile:

docker build --build-arg user=$USER --build-arg uid=$(id -u) --build-arg gid=$(id -g) -t <new-image-with-X11-enabled-name> -f <Dockerfile-for-X11> .

Innan vi lekar en ny behållare måste vi nu skapa en xauth-fil med åtkomsttillstånd:

xauth nlist $DISPLAY | sed -e 's/^..../ffff/' | xauth -f /tmp/.docker.xauth nmerge -

Denna fil måste monteras i behållaren när du skapar / kör den:

docker run -e DISPLAY=unix$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix -v /tmp/.docker.xauth:/tmp/.docker.xauth:rw -e XAUTHORITY=/tmp/.docker.xauth