Docker
Uruchamianie kontenerów

Składnia

• Uruchom okno dokowane [OPCJE] OBRAZ [POLECENIE] [ARG ...]

Uruchamianie kontenera

docker run hello-world

Spowoduje to pobranie najnowszego obrazu hello-world z Docker Hub (jeśli jeszcze go nie masz), utworzenie nowego kontenera i uruchomienie go. Powinien zostać wyświetlony komunikat informujący, że instalacja działa poprawnie.

Uruchomienie innego polecenia w kontenerze

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

To polecenie nakazuje Dockerowi utworzyć kontener z obrazu docker/whalesay i uruchomić polecenie cowsay 'Hello, StackExchange!' w tym. Powinien wydrukować zdjęcie wieloryba z napisem Hello, StackExchange! do twojego terminala.

Jeśli punkt wejścia na obrazie jest domyślny, możesz uruchomić dowolne polecenie dostępne na obrazie:

docker run docker/whalesay ls /

Jeśli został zmieniony podczas kompilacji obrazu, musisz przywrócić go do wartości domyślnej

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

Automatycznie usuń kontener po uruchomieniu

Zwykle kontener Docker utrzymuje się po jego wyjściu. Umożliwia to ponowne uruchomienie kontenera, sprawdzenie jego systemu plików i tak dalej. Czasami jednak chcesz uruchomić kontener i usunąć go natychmiast po wyjściu. Na przykład, aby wykonać polecenie lub wyświetlić plik z systemu plików. Docker udostępnia w tym celu opcję wiersza polecenia --rm :

docker run --rm ubuntu cat /etc/hosts

Spowoduje to utworzenie kontenera z obrazu „ubuntu”, wyświetlenie zawartości pliku / etc / hosts , a następnie usunięcie kontenera natychmiast po jego wyjściu. Pomaga to uniknąć konieczności czyszczenia pojemników po zakończeniu eksperymentów.

Uwaga: Flaga --rm nie działa w połączeniu z flagą -d ( --detach ) w oknie dokowanym <1.13.0.

Gdy --rm jest --rm , Docker usuwa również woluminy powiązane z kontenerem, gdy kontener jest usuwany. Jest to podobne do uruchamiania docker rm -v my-container . Usuwane są tylko woluminy określone bez nazwy .

Na przykład, w docker run -it --rm -v /etc -v logs:/var/log centos /bin/produce_some_logs , wolumin /etc zostanie usunięty, ale wolumin /var/log nie. Woluminy odziedziczone przez --volumes-from zostaną usunięte z tą samą logiką - jeśli oryginalny wolumin został określony nazwą, nie zostanie usunięty.

Określanie nazwy

Domyślnie pojemniki utworzone z docker run podano losową nazwę jak small_roentgen lub modest_dubinsky . Te nazwy nie są szczególnie pomocne w określeniu przeznaczenia kontenera. Można podać nazwę kontenera, przekazując opcję wiersza polecenia --name :

docker run --name my-ubuntu ubuntu:14.04

Nazwy muszą być unikalne; jeśli podasz nazwę, której używa już inny kontener, Docker wydrukuje błąd i nie zostanie utworzony żaden nowy kontener.

Podanie nazwy będzie przydatne podczas odwoływania się do kontenera w sieci Docker. Działa to zarówno dla kontenerów Docker w tle, jak i na pierwszym planie.

Kontenery w domyślnej sieci mostowej muszą być połączone, aby komunikować się według nazwy.

Wiązanie portu kontenera z hostem

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

Aby móc korzystać z portów gospodarza zostały wystawione na obrazie (przez EXPOSE dyrektywy Dockerfile lub --expose opcja linii polecenia dla docker run ), te otwory muszą być związane z gospodarzy z zastosowaniem -p lub -P polecenie opcje linii. Użycie -p wymaga podania określonego portu (i opcjonalnego interfejsu hosta). Użycie opcji wiersza polecenia -P wielkimi literami zmusi Docker do powiązania wszystkich odsłoniętych portów obrazu kontenera z hostem.

Zasady restartowania kontenera (uruchamianie kontenera podczas uruchamiania)

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

Domyślnie Docker nie uruchomi ponownie kontenerów po ponownym uruchomieniu demona Docker, na przykład po ponownym uruchomieniu systemu hosta. Docker zapewnia zasady ponownego uruchamiania kontenerów, podając opcję wiersza polecenia --restart . --restart=always zawsze spowoduje ponowne uruchomienie kontenera po ponownym uruchomieniu demona Docker. Jednak gdy ten kontener zostanie ręcznie zatrzymany (np. Z docker stop <container> ), zasady restartu nie zostaną zastosowane do kontenera.

Dla opcji --restart można określić --restart opcji w zależności od wymagań ( --restart=[policy] ). Te opcje wpływają również na sposób uruchamiania kontenera podczas rozruchu.

Uruchom kontener w tle

Aby kontener działał w tle, podczas uruchamiania kontenera podaj opcję -d :

docker run -d busybox top

Opcja -d uruchamia kontener w trybie odłączonym. Jest to również równoważne z -d=true .

Kontenera w trybie odłączonym nie można automatycznie usunąć po zatrzymaniu, co oznacza, że nie można użyć opcji --rm w połączeniu z opcją -d.

Przypisz wolumin do kontenera

Wolumin Docker to plik lub katalog, który utrzymuje się przez cały okres istnienia kontenera. Możliwe jest zamontowanie pliku lub katalogu hosta jako woluminu w kontenerze (z pominięciem UnionFS).

Dodaj wolumin z -v wiersza polecenia -v :

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

Spowoduje to utworzenie woluminu i zamontowanie go na ścieżce /data w kontenerze.

• Uwaga: Możesz użyć flagi --rm aby automatycznie usunąć wolumin po usunięciu kontenera.

Montowanie katalogów hosta

Aby zamontować plik hosta lub katalog w kontenerze:

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

• Podczas określania katalogu hosta należy podać bezwzględną ścieżkę.

Spowoduje to zamontowanie katalogu hosta /home/foo/data na /data wewnątrz kontenera. Ten wolumin „katalogu hosta mount --bind wiązania” jest tym samym, co mount --bind do systemu Linux - mount --bind dlatego tymczasowo montuje katalog hosta na określonej ścieżce kontenera na czas życia kontenera. Zmiany w woluminie z hosta lub kontenera są natychmiast odzwierciedlane w drugim, ponieważ są tym samym miejscem docelowym na dysku.

Przykład UNIX-a instalowania folderu względnego

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

Nazwy woluminów

Wolumin można nazwać, podając ciąg zamiast ścieżki katalogu hosta, doker utworzy wolumin o tej nazwie.

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

Po utworzeniu nazwanego woluminu można go następnie udostępnić innym kontenerom o tej nazwie.

Ustawianie zmiennych środowiskowych

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

Zarówno -e jak i --env mogą być użyte do zdefiniowania zmiennych środowiskowych w kontenerze. Możliwe jest podanie wielu zmiennych środowiskowych za pomocą pliku tekstowego:

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

Przykładowy plik zmiennych środowiskowych:

# This is a comment
TEST_HOST=10.10.0.127

Flaga --env-file przyjmuje nazwę pliku jako argument i oczekuje, że każda linia ma format VARIABLE=VALUE , naśladując argument przekazany do --env . Wiersze komentarza muszą być poprzedzone tylko # .

Niezależnie od kolejności tych trzech flag najpierw przetwarzane są --env-file , a następnie flagi -e / --env . W ten sposób wszelkie zmienne środowiskowe dostarczone indywidualnie z -e lub --env zmienne --env-var pliku tekstowym --env-var .

Określanie nazwy hosta

Domyślnie kontenery utworzone za pomocą okna dokowanego otrzymują losową nazwę hosta. Możesz nadać kontenerowi inną nazwę hosta, przekazując flagę --hostname:

docker run --hostname redbox -d ubuntu:14.04

Uruchom kontener interaktywnie

Aby uruchomić kontener interaktywnie, przekaż opcje -it :

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

-i utrzymuje STDIN otwarty, a -t przydziela pseudo-TTY.

Działający kontener z limitami pamięci / zamiany

Ustaw limit pamięci i wyłącz limit wymiany

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

Ustaw limit pamięci i wymiany. W takim przypadku kontener może używać pamięci 300 mln i wymiany 700 mln.

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

Przenoszenie powłoki do działającego (odłączonego) kontenera

Zaloguj się do działającego kontenera

Użytkownik może wprowadzić działający kontener w nowej interaktywnej powłoce bash za pomocą polecenia exec .

Załóżmy, że kontener nazywa się jovial_morse a następnie możesz uzyskać interaktywną powłokę pseudo-TTY, uruchamiając:

docker exec -it jovial_morse bash

Zaloguj się do działającego kontenera z określonym użytkownikiem

Jeśli chcesz wprowadzić kontener jako określony użytkownik, możesz ustawić go za --user parametru -u lub --user . Nazwa użytkownika musi istnieć w kontenerze.

-u, --user Nazwa użytkownika lub UID (format: <name|uid>[:<group|gid>] )

To polecenie zaloguje się do jovial_morse z użytkownikiem dockeruser

docker exec -it -u dockeruser jovial_morse bash

Zaloguj się do działającego kontenera jako root

Jeśli chcesz zalogować się jako root, po prostu użyj parametru -u root . Użytkownik root zawsze istnieje.

docker exec -it -u root jovial_morse bash

Zaloguj się do obrazu

Możesz również zalogować się do obrazu za pomocą polecenia run , ale wymaga to nazwy obrazu zamiast nazwy kontenera.

docker run -it dockerimage bash

Zaloguj się do obrazu pośredniego (debugowanie)

Możesz także zalogować się do obrazu pośredniego, który jest tworzony podczas kompilacji pliku Dockerfile.

Dane wyjściowe 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

Zwróć uwagę na ---> Running in 02071fceb21b wyjściu ---> Running in 02071fceb21b , możesz zalogować się do tych obrazów:

docker run -it 02071fceb21b bash

Podanie standardowego wejścia do pojemnika

W przypadkach takich jak przywracanie zrzutu bazy danych lub w inny sposób, gdy chcesz przepchnąć niektóre informacje przez potok z hosta, możesz użyć flagi -i jako argumentu do docker run docker exec lub wykonania docker exec .

Na przykład, zakładając, że chcesz umieścić w konteneryzowanym kliencie mariadb zrzut pamięci bazy danych na hoście, w lokalnym pliku dump.sql , możesz wykonać następujące polecenie:

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

Ogólnie,

docker exec -i container command < file.stdin

Lub

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

Odłączanie od pojemnika

Po podłączeniu do działającego kontenera z przypisanym pty ( docker run -it ... ), możesz nacisnąć Control P - Control Q, aby odłączyć.

Przesłanianie dyrektywy punktu wejścia obrazu

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

To polecenie zastąpi dyrektywę ENTRYPOINT obrazu example-app podczas tworzenia test-app kontenera. Dyrektywa CMD obrazu pozostanie niezmieniona, chyba że określono inaczej:

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

W powyższym przykładzie zarówno ENTRYPOINT , jak i CMD obrazu zostały zastąpione. Ten proces kontenerowy staje się /bin/bash /app/test.sh .

Dodaj pozycję hosta do kontenera

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

To polecenie dodaje wpis do /etc/hosts kontenera, który ma format --add-host <name>:<address> . W tym przykładzie nazwa app-backend zostanie rozwiązana do 10.15.1.24 . Jest to szczególnie przydatne do programowego wiązania różnych komponentów aplikacji.

Zapobiegaj zatrzymaniu kontenera, gdy nie są uruchomione żadne polecenia

Kontener zatrzyma się, jeśli na pierwszym planie nie zostanie uruchomione żadne polecenie. Użycie opcji -t zapobiegnie zatrzymaniu kontenera, nawet gdy zostanie odłączony z opcją -d .

docker run -t -d debian bash

Zatrzymywanie pojemnika

docker stop mynginx

Ponadto identyfikator kontenera można również użyć do zatrzymania kontenera zamiast jego nazwy.

Spowoduje to zatrzymanie działającego kontenera poprzez wysłanie sygnału SIGTERM, a następnie sygnału SIGKILL, jeśli to konieczne.

Ponadto komendy kill można użyć do natychmiastowego wysłania SIGKILL lub dowolnego innego określonego sygnału za pomocą opcji -s .

docker kill mynginx

Określony sygnał:

docker kill -s SIGINT mynginx

Zatrzymanie kontenera nie powoduje jego usunięcia. Użyj docker ps -a aby zobaczyć zatrzymany pojemnik.

Wykonaj inne polecenie na działającym kontenerze

W razie potrzeby możesz nakazać Dockerowi wykonanie dodatkowych poleceń na już działającym kontenerze za pomocą polecenia exec . Potrzebujesz identyfikatora kontenera, który możesz uzyskać za pomocą docker ps .

docker exec 294fbc4c24b3 echo "Hello World"

Możesz dołączyć interaktywną powłokę, jeśli użyjesz opcji -it .

docker exec -it 294fbc4c24b3 bash

Uruchamianie aplikacji GUI w kontenerze Linux

Domyślnie kontener Docker nie będzie mógł uruchomić aplikacji GUI.

Wcześniej gniazdo X11 musi zostać najpierw przesłane do kontenera, aby można było z niego korzystać bezpośrednio. Zmienna środowiskowa DISPLAY musi być również przekazana:

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

Na początku się to nie powiedzie, ponieważ nie ustawiliśmy uprawnień do hosta serwera X:

cannot connect to X server unix:0

Najszybszym (ale nie najbezpieczniejszym) sposobem jest umożliwienie dostępu bezpośrednio za pomocą:

xhost +local:root

Po zakończeniu pracy z pojemnikiem możemy wrócić do pierwotnego stanu za pomocą:

xhost -local:root

Innym (bezpieczniejszym) sposobem jest przygotowanie pliku Docker, który zbuduje nowy obraz, który będzie korzystał z naszych poświadczeń użytkownika w celu uzyskania dostępu do serwera X:

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}

Podczas wywoływania docker build z wiersza poleceń musimy przekazać zmienne ARG , które pojawiają się w pliku Docker:

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

Teraz przed spawnowaniem nowego kontenera musimy utworzyć plik xauth z uprawnieniami dostępu:

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

Ten plik należy zamontować w kontenerze podczas jego tworzenia / uruchamiania:

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