Docker
Lopende containers

Syntaxis

• Docker uitvoeren [OPTIONS] IMAGE [COMMAND] [ARG ...]

Een container runnen

docker run hello-world

Hiermee haalt u de nieuwste hallo- wereldafbeelding op van de Docker Hub (als u deze nog niet hebt), maakt u een nieuwe container en voert u deze uit. U zou een bericht moeten zien waarin staat dat uw installatie correct lijkt te werken.

Een ander commando uitvoeren in de container

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

Met deze opdracht geeft Docker de opdracht om een container te maken van de afbeelding van de docker/whalesay en de opdracht cowsay 'Hello, StackExchange!' in het. Het moet een afbeelding van een walvis afdrukken met de tekst Hello, StackExchange! naar uw terminal.

Als het beginpunt in de afbeelding het standaard is, kunt u elke opdracht uitvoeren die beschikbaar is in de afbeelding:

docker run docker/whalesay ls /

Als het tijdens het samenstellen van afbeeldingen is gewijzigd, moet u het terugzetten naar de standaardwaarde

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

Verwijder automatisch een container nadat deze is uitgevoerd

Normaal gesproken blijft een Docker-container bestaan nadat deze is afgesloten. Hiermee kunt u de container opnieuw uitvoeren, het bestandssysteem inspecteren, enzovoort. Soms wilt u echter een container uitvoeren en deze onmiddellijk verwijderen nadat deze is afgesloten. Bijvoorbeeld om een opdracht uit te voeren of een bestand van het bestandssysteem te tonen. Docker biedt hiervoor de opdrachtregeloptie --rm :

docker run --rm ubuntu cat /etc/hosts

Hiermee wordt een container gemaakt van de "ubuntu" -afbeelding, wordt de inhoud van het bestand / etc / hosts weergegeven en wordt de container onmiddellijk verwijderd nadat deze is afgesloten. Dit helpt voorkomen dat u containers moet opruimen nadat u klaar bent met experimenteren.

Opmerking: de vlag --rm werkt niet in combinatie met de vlag -d ( --detach ) in docker <1.13.0.

Wanneer de vlag --rm is ingesteld, verwijdert Docker ook de volumes die aan de container zijn gekoppeld wanneer de container wordt verwijderd. Dit is vergelijkbaar met het uitvoeren van docker rm -v my-container . Alleen volumes die zonder een naam zijn opgegeven, worden verwijderd .

Bijvoorbeeld, met docker run -it --rm -v /etc -v logs:/var/log centos /bin/produce_some_logs , wordt het volume van /etc verwijderd, maar het volume van /var/log niet. Volumes die zijn geërfd via --volumes-from worden verwijderd met dezelfde logica - als het oorspronkelijke volume werd opgegeven met een naam, wordt het niet verwijderd.

Een naam opgeven

Standaard krijgen containers die zijn gemaakt met docker run een willekeurige naam zoals small_roentgen of modest_dubinsky . Deze namen zijn niet bijzonder nuttig bij het identificeren van het doel van een container. Het is mogelijk om een naam voor de container op te geven door de opdrachtregeloptie --name door te geven:

docker run --name my-ubuntu ubuntu:14.04

Namen moeten uniek zijn; als u een naam doorgeeft die al door een andere container wordt gebruikt, drukt Docker een fout af en wordt er geen nieuwe container gemaakt.

Het is handig om een naam op te geven als u naar de container in een Docker-netwerk verwijst. Dit werkt zowel voor Docker-containers op de achtergrond als op de voorgrond.

Containers op het standaard bridge-netwerk moeten gekoppeld zijn om op naam te communiceren.

Een containerpoort binden aan de host

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

Om de poorten op de host zijn blootgesteld in een afbeelding (via de EXPOSE Dockerfile richtlijn, of --expose command line optie voor docker run ), moeten deze havens te worden gebonden aan de host met de -p of -P commando lijn opties. Als u -p moet de specifieke poort (en optionele hostinterface) worden opgegeven. Als u de opdrachtregeloptie hoofdletter -P , dwingt Docker alle blootgestelde poorten in de afbeelding van een container te binden aan de host.

Container herstart beleid (starten van een container tijdens het opstarten)

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

Docker start standaard geen containers opnieuw wanneer de Docker-daemon opnieuw start, bijvoorbeeld nadat het hostsysteem opnieuw is opgestart. Docker biedt een herstartbeleid voor uw containers door de opdrachtregeloptie --restart voeren. Leveren van --restart=always zorgt er altijd voor dat een container opnieuw wordt gestart nadat de Docker-daemon opnieuw is gestart. Maar wanneer die container wordt gestopt (bijvoorbeeld met docker stop <container> ), de herstart beleid zal niet worden toegepast op de container.

Er kunnen meerdere opties worden opgegeven voor de optie --restart , op basis van de vereiste ( --restart=[policy] ). Deze opties beïnvloeden ook hoe de container bij het opstarten begint.

Voer een container op de achtergrond uit

Om een container op de achtergrond te laten werken, geeft u de opdrachtregeloptie -d tijdens het opstarten van de container:

docker run -d busybox top

De optie -d voert de container uit in ontkoppelde modus. Het is ook equivalent aan -d=true .

Een container in ontkoppelde modus kan niet automatisch worden verwijderd wanneer deze stopt. Dit betekent dat men de optie --rm niet kan gebruiken in combinatie met de optie -d.

Wijs een volume toe aan een container

Een Docker-volume is een bestand of map die na de levensduur van de container blijft bestaan. Het is mogelijk om een hostbestand of map als een volume in een container te mounten (de UnionFS omzeilen).

Voeg een volume toe met de opdrachtregeloptie -v :

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

Hiermee maakt u een volume en koppelt u dit aan het pad /data in de container.

• Opmerking: U kunt de vlag --rm gebruiken om het volume automatisch te verwijderen wanneer de container wordt verwijderd.

Hostmappen aankoppelen

Een hostbestand of map in een container koppelen:

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

• Bij het opgeven van een hostmap moet een absoluut pad worden opgegeven.

Hiermee wordt de hostmap /home/foo/data op /data in de container geplaatst. Dit "bind-gemonteerde hostmap" -volume is hetzelfde als een Linux mount --bind en mount --bind daarom de hostmap tijdelijk over het opgegeven containerpad gedurende de levensduur van de container. Veranderingen in het volume van de host of de container worden onmiddellijk in de andere weergegeven, omdat ze dezelfde bestemming op schijf zijn.

UNIX-voorbeeld koppelen van een relatieve map

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

Naamgeving volumes

Een volume kan worden benoemd door een string op te geven in plaats van een hostmap, docker maakt een volume met die naam.

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

Nadat u een benoemd volume hebt gemaakt, kan het volume vervolgens worden gedeeld met andere containers met die naam.

Omgevingsvariabelen instellen

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

Zowel -e als --env kunnen worden gebruikt om omgevingsvariabelen in een container te definiëren. Het is mogelijk om veel omgevingsvariabelen te leveren met behulp van een tekstbestand:

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

Voorbeeld omgevingsvariabel bestand:

# This is a comment
TEST_HOST=10.10.0.127

De vlag --env-file neemt een bestandsnaam als argument en verwacht dat elke regel de indeling VARIABLE=VALUE heeft, waarbij het argument wordt doorgegeven dat aan --env doorgegeven. Opmerkingenregels hoeven alleen te worden voorafgegaan door # .

Ongeacht de volgorde van deze drie vlaggen, worden het --env-file eerst verwerkt en vervolgens -e / --env vlaggen. Op deze manier zullen omgevingsvariabelen die afzonderlijk worden geleverd met -e of --env de variabelen vervangen die zijn geleverd in het --env-var tekstbestand.

Een hostnaam opgeven

Standaard krijgen containers die zijn gemaakt met Docker Run een willekeurige hostnaam. U kunt de container een andere hostnaam geven door de vlag --hostname te passeren:

docker run --hostname redbox -d ubuntu:14.04

Voer een container interactief uit

Als u een container interactief wilt uitvoeren, geeft u de opties -it door:

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

-i houdt STDIN open, terwijl -t een pseudo-TTY toewijst.

Lopende container met geheugen / wissellimieten

Stel geheugenlimiet in en schakel swaplimiet uit

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

Stel zowel geheugen als wissellimiet in. In dit geval kan de container 300M geheugen en 700M swap gebruiken.

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

Een schaal in een lopende (losgemaakte) container plaatsen

Log in op een actieve container

Een gebruiker kan een actieve container invoeren in een nieuwe interactieve bash-shell met exec opdracht.

Stel dat een container jovial_morse wordt genoemd jovial_morse dan kun je een interactieve, pseudo-TTY bash-shell krijgen door te draaien:

docker exec -it jovial_morse bash

Meld u aan bij een actieve container met een specifieke gebruiker

Als u een container als een specifieke gebruiker wilt invoeren, kunt u deze instellen met de parameter -u of --user . De gebruikersnaam moet aanwezig zijn in de container.

-u, --user Gebruikersnaam of UID (formaat: <name|uid>[:<group|gid>] )

Dit commando logt in op jovial_morse met de dockeruser gebruiker

docker exec -it -u dockeruser jovial_morse bash

Log in op een actieve container als root

Als je je als root wilt aanmelden, gebruik je gewoon de parameter -u root . Hoofdgebruiker bestaat altijd.

docker exec -it -u root jovial_morse bash

Log in op een afbeelding

U kunt zich ook aanmelden bij een afbeelding met de run commando, maar dit vereist een beeld naam in plaats van een container naam.

docker run -it dockerimage bash

Log in op een tussenliggende afbeelding (debug)

U kunt zich ook aanmelden bij een tussenliggende afbeelding, die wordt gemaakt tijdens een Dockerfile-build.

Output van 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

Let op de ---> Running in 02071fceb21b uitvoer, kunt u zich aanmelden bij deze afbeeldingen:

docker run -it 02071fceb21b bash

Stdin doorgeven aan de container

In gevallen zoals het herstellen van een database-dump, of anderszins wat informatie door een pipe van de host wilt duwen, kunt u de vlag -i als argument voor het docker run een docker run of een docker exec .

Als u bijvoorbeeld in een lokaal dump.sql bestand een database-dump die u op de host wilt plaatsen, in een lokaal dump.sql bestand wilt plaatsen, kunt u de volgende opdracht uitvoeren:

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

In het algemeen,

docker exec -i container command < file.stdin

Of

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

Loskoppelen van een container

Terwijl u verbonden bent met een container met een toegewezen pty ( docker run -it ... ), kunt u op Control P drukken - Control Q om los te maken.

Richtlijn voor het overschrijven van het beeldingangspunt

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

Deze opdracht vervangt de ENTRYPOINT instructie van de afbeelding van de example-app wanneer de test-app de container wordt gemaakt. De CMD richtlijn van de afbeelding blijft ongewijzigd tenzij anders aangegeven:

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

In het bovenstaande voorbeeld zijn zowel het ENTRYPOINT als de CMD van de afbeelding overschreven. Dit containerproces wordt /bin/bash /app/test.sh .

Hostitem toevoegen aan container

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

Deze opdracht voegt een vermelding toe aan het bestand /etc/hosts van de container met de indeling --add-host <name>:<address> . In dit voorbeeld wordt de naam app-backend 10.15.1.24 in 10.15.1.24 . Dit is met name handig voor het programmatisch koppelen van verschillende app-componenten.

Voorkom dat de container stopt wanneer er geen opdrachten worden uitgevoerd

Een container stopt als er geen opdracht op de voorgrond wordt uitgevoerd. Als u de optie -t , voorkomt u dat de container stopt, zelfs wanneer deze wordt losgemaakt met de optie -d .

docker run -t -d debian bash

Een container stoppen

docker stop mynginx

Bovendien kan de container-ID ook worden gebruikt om de container te stoppen in plaats van de naam.

Hiermee wordt een lopende container gestopt door het SIGTERM-signaal en vervolgens het SIGKILL-signaal te verzenden indien nodig.

Verder kan het kill-commando worden gebruikt om onmiddellijk een SIGKILL of een ander gespecificeerd signaal te verzenden met de optie -s .

docker kill mynginx

Gespecificeerd signaal:

docker kill -s SIGINT mynginx

Als u een container stopt, wordt deze niet verwijderd. Gebruik docker ps -a om uw gestopte container te zien.

Voer een andere opdracht uit op een actieve container

Indien nodig kunt u Docker vragen om extra opdrachten uit te voeren op een reeds lopende container met behulp van de opdracht exec . U hebt de ID van de container nodig die u kunt krijgen bij docker ps .

docker exec 294fbc4c24b3 echo "Hello World"

U kunt een interactieve shell koppelen als u de optie -it .

docker exec -it 294fbc4c24b3 bash

GUI-apps uitvoeren in een Linux-container

Standaard wordt een Docker container niet in staat zijn om een GUI toepassing uit te voeren.

Daarvoor moet de X11-aansluiting eerst naar de container worden doorgestuurd, zodat deze direct kan worden gebruikt. De omgevingsvariabele DISPLAY moet ook worden doorgestuurd:

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

Dit zal in het begin mislukken, omdat we de machtigingen voor de X-serverhost niet hebben ingesteld:

cannot connect to X server unix:0

De snelste (maar niet veiligste) manier is om rechtstreeks toegang te verlenen met:

xhost +local:root

Na afwerking met de container kunnen we teruggaan naar de oorspronkelijke staat met:

xhost -local:root

Een andere (veiligere) manier is om een Docker-bestand voor te bereiden dat een nieuwe afbeelding bouwt die de inloggegevens van onze gebruikers gebruikt om toegang te krijgen tot de X-server:

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}

Bij het oproepen van de docker build vanaf de opdrachtregel, moeten we de ARG- variabelen doorgeven die in het Docker-bestand verschijnen:

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> .

Nu moeten we, voordat we een nieuwe container spawnen, een xauth-bestand maken met toegangsmachtiging:

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

Dit bestand moet in de container worden geplaatst bij het aanmaken / uitvoeren:

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