CLI container¶

Auch hier gilt wieder, dass wir nicht alle Befehle bis in die letzte Nutzung aufführen wollen.

Wir starten wieder mit einer tabellarischen Übersicht.

Tabelle: Docker Kommandos für Container ¶

docker container	Funktionalität
… ls \| ps	Laufende Container auflisten - mit `-a` alle Container Klassische Kurzform: `docker ps` (Container = Prozess)
… attach	I/O eines Containers mit Terminal connecten
… commit	neues Image aus Container
… cp	Kopieren von Daten zwischen Container <-> Host
… create	Container erzeugen, aber nicht starten
… diff	veränderte Dateien eines Containers erzeugen
… exec	Kommando in laufendem Container ausführen
… export \| import	Container in Archiv speichern \| aus Archiv erzeugen
… inspect	Konfiguration und Status eines Containers
… kill	Container sofort beenden
… logs	Container-Loggings
… pause \| unpause	Container anhalten \| fortsetzen
… port	Container Ports auflisten
… rename	Container umbenennen
… rm	Container löschen
… run	neuen Container erzeugen und starten
… start \| stop \| restart	Container starten \| stoppen \| neu starten
… top	Container Prozesse anzeigen
… update	Container Optionen anpassen
… wait	Container Ende erwarten

Wie bei den Images wollen wir auch für die Container ein paar Beispiele für Kommandos auflisten und ausführen.

Infos: docker container ls ¶

Filterung mit Kriterium: -f <Kriterium=Wert> - Docker filter

Filter output based on these conditions:
- ancestor=(<image-name>[:tag]|<image-id>| image@digest )
  containers created from an image or a descendant.
- before=(<container-name>|<container-id>)
- expose=(<port>[/<proto>]|<startport-endport>/[<proto>])
- exited=<int> an exit code of <int>
- health=(starting|healthy|unhealthy|none)
- id=<ID> a container's ID
- isolation=(default|process|hyperv) (Windows daemon only)
- is-task=(true|false)
- label=<key> or label=<key>=<value>
- name=<string> a container's name
- network=(<network-id>|<network-name>)
- publish=(<port>[/<proto>]|<startport-endport>/[<proto>])
- since=(<container-name>|<container-id>)
- status=(created|restarting|removing|running|paused|exited)
- volume=(<volume name>|<mount point destination>)

Es gibt weitere Formatierungsmöglichkeiten für die ls-Ausgabe.

# filtere container mit Ports 8080 bis 8083 (tcp)
docker container ls -a --filter publish=8080-8083/tcp

# container ls mit formatierter Tabelle
docker container ls -a --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Labels}}"

# container ls mit manuellem printf Mechanismus
docker container ls -a --format '{{printf "%-30s%-30s" .Names .RunningFor}}'

# auch hier wieder JSON Formatierung möglich:
docker container ls -a --format '{{json . }}' | jq

Die Formatierungs-Schalter (siehe Go-Templates) ann man wieder gerne per Hilfen zu den Tools docker-ps bzw. docker-container-ls|ps nachschlagen. Da findet man auch weitere Aufrufe und Beispiele.

Valid placeholders for the Go template are listed below:
- .ID           - Container ID.
- .Image        - Image ID.
- .Command      - Quoted command.
- .CreatedAt    - Time when the container was created.
- .RunningFor   - Elapsed time since the container was started.
- .Ports        - Exposed ports.
- .Status       - Container status.
- .Size         - Container disk size.
- .Names        - Container names.
- .Labels       - All labels assigned to the container.
- .Label        - Value of a specific label for this container.
                  For example '{{.Label "com.docker.swarm.cpu"}}'.
- .Mounts       - Names of the volumes mounted in this container.
- .Networks     - Names of the networks attached to this container.

Infos: docker container attach ¶

Auf Container die man mit docker run -it oder docker start -a -i gestartet hat, kann man immer über die interaktive Konsole zugreifen.

Andernfalls kann man mit docker attach diese Funktionalität nachholen. Man könnte sagen, dass erzeugte Container die Terminalfähigkeit eingebaut haben. Man muss diese nur noch ankoppeln/attachen.

Infos: docker container exec ¶

Hiermit kann man Befehle in einem laufenden Contaier aufrufen. Der Container muss aktiv sein - also laufen.

Wird eine Shell per exec benutzt und mit exit verlassen, dann läuft der Container weiter!

docker container start ubuntu-container                 # kein Terminal/tty!
docker container ls                                     # Container läuft
docker container exec -i -t ubuntu-container /bin/bash  # Shell mit tty
exit                                                    # exit Bash aus exec
docker container ls                                     # Container läuft noch1

Infos: docker container cp ¶

Manuelle Kopieren von Daten zwischen Container und Host, was normaler Weise automatisch beim Erzeugen von Images genutzt wird.

echo "Testing" > /tmp/testdatei
docker start alpinejoeb
docker container cp /tmp/testdatei alpinejoeb:/
docker exec alpinejoeb cat /testdatei
docker stop alpinejoeb

Infos: docker container inspect ¶

Das inspect-Kommando arbeitet mit Images und Containern und erzeugt Infos im JSON-Format.

Für die Analyse von Containern unterscheidet sich der inspect nach dem Status, also ob der Container läuft oder nicht läuft.

JSON anzeigen:

docker inspect -s mariadb-test5¶

...
...
    {
        "Id": "cd42b1a7c4542f76174f936e5a2060f1f87e3511d3fe5e07bb27e15a1ca74ea5",
        "Created": "2019-01-06T19:56:47.958915783Z",
        "Path": "docker-entrypoint.sh",
        "Args": [
            "mysqld"
        ],
        "State": {
            "Status": "exited",
            "Running": false,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 0,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2019-01-06T19:56:48.881461371Z",
            "FinishedAt": "2019-01-06T20:15:04.192413984Z"
        },
...
...

Analyse über Parameter -f (format)

docker inspect -s -f "{{.State.Status}}" mariadb-test5
docker inspect -s -f "{{.State.FinishedAt}}" mariadb-test5

Infos: docker container start | stop ¶

Mit Parametern -ai (attach) kann man direkt in eine Shell eines Containers starten: docker start -ai containername, wenn der Container die Shell als Prozess bereitstellt.

Tipp

Die Container-Instanz wird mit exit beendet!

Mit der Tastenkombination Strg + P gefolgt von Strg + Q läuft der Container weiter!

Alle vorhandenen Container stoppen: docker stop $(docker ps -a -q)

Alle gestoppten Container entfernen: docker rm $(docker ps --filter "status=exited")

Oder mit einem prune (dt.: stutzen, beschneiden) Schalter: docker container prune

Infos: docker container top ¶

Das Container Kommando ist angelehnt an das top Kommando - hier aber als Einzelausgabe.

Aber der Reihe nach… wir starten erst einmal einen Container: docker start alpine (oder natürlich docker run ...).

CONTAINER ID   IMAGE    COMMAND    CREATED        STATUS        PORTS    NAMES
ba4471eeb783   alpine   "/bin/sh"  10 days ago    Up 17 minutes          alpinejoeb

Analyse auf Docker-Host mit ps axf ergibt (Anm. gekürzt und Umbrüche erzeugt):

1705 ?        Ssl    0:00  \_ docker-containerd
--config /var/run/docker/containerd/containerd.toml
--log-level info

3602 ?        Sl     0:00      \_ docker-containerd-shim -namespace moby
-workdir /var/lib/docker/containerd/daemon/io.containerd.runtime.v1.linux/moby/ba4471eeb783b...

3619 pts/0    Ss+    0:00          \_ /bin/sh

Man erkennt die PIDs für Container und Shell.

Jetzt mal die Prozesse im Container klassisch: docker container exec alpinejoeb ps ax

PID   USER     TIME  COMMAND
  1   root     0:00  /bin/sh
 11   root     0:00  ps ax

Und mit dem docker container top alpinejoeb -x Kommando: (Anm.: -x verkürzte Ausgabe)

PID                 TTY                 STAT                TIME                COMMAND
3619                pts/0               Ss+                 0:00                /bin/sh

Hinweis

Also völlig unterschiedliche Prozess-IDs aus verschiedenen Ansichten! Der erste Prozess im Container hat immer die Container-PID 1.

Prozesse lassen sich jederzeit von außen stoppen (killen).

Exit Status ¶

Informationen zu Exit Status der Ausgaben von docker container ps -a

Die Nummern in Angabe Exited (#) von Spalte STATUS beziehen sich auf Exit-Meldungen beim Verlassen, stoppen oder killen eines Containers.

Eigene Docker Exit Return Code:

125 Docker Daemon hat Fehler
126 Container Kommando kann nicht aufgerufen werden
127 Container Kommando konnte nicht gefunden werden

Ansonsten orientiert sich das Exit-Coding an

Technik chroot (Exit Codes with special Meaning)
Docker run Exit Status (Docker reference run)

Infos: docker (container) run ¶

Der Docker run Befehl kommt in vielen Abhandlungen zu Docker aus verständlichen Gründe sehr früh, da er (siehe docker run hello-world) viele Aufgaben in einem Arbeitsschritt erledigt.

Leider vernebelt sich häufig bei den Anwendern der Blick auf die eigentliche technische Bewandnis und Funktion des Aufrufs.

Im Grunde stelle das Kommando alle Schalter zum Bau - oder besser gesagt zur Bereitstellung - unserer genutzten Container zur Verfügung. Warum besser gesagt? Weil wir beim Bauen besser an den Build-Prozess für eine Image denken sollten.

Docker run Schalter - alle Konfigurationen für Container¶

Der Befehl docker run erledigt die folgenden Schritte in einem Aufruf:

Benötigtes Images lokal checken oder pullen
Container erzeugen
Container starten

Dabei wird also, falls noch kein Image lokal vorhanden ist das entsprechende Image erst gepullt - also lokal bereitgestellt!

Bei Image-Namen ohne Tag wird versucht das image:latest genommen!

Siehe auch Extensives Manual für Kondsolentool docker-run!

Optionen	Funktionalität
`--cpus="1.25"`	maximal 1,25 CPU Cores
`-d \| --detach`	Container im Hintergrund (detached) - für Daemons!
`-e \| --env VAR=value`	Variable für Container setzen
`-h \| --hostname`	Hostname
`-i \| --interactive`	interaktiv ausführen lassen
`-t \| --tty`	Pseudo-Terminal mit Standardausgabe verbinden
`-m \| --memory 512m`	Container-RAM auf 512 MiB limitieren
`--name <container-name>`	Containername
`--network <nw-name>`	Netzwerk verwenden
`-p \| --publish localport:containerport`	Portweiterleitungen zwischen Host und Container
`-P \| --publish-all`	alle Port des Containers mit zufälligen Host-Ports
`--rm`	Container nach Ausführung löschen
`-v \| --volume containerdir`	Containerverzeichnis als Volume `-v vname:cdir` - Volume mit Namen erzeugen `-v /localdir:cdir`- Host-Dir mit Container-Dir verbinden `--volumes-from cname` - Volume eines anderen Containers nutzen

Bemerkung

Enthalten Images keine aktiven Prozesse werden Container-Instanzen nicht am Leben gehalten!

Solche Prozesse (z.B. /bin/bash) müssen natürlich im Image vorhanden sein und direkt und sofort für den Container genutzt werden: also -it und nicht -d!

Infos: diverse Aufrufe ¶

docker container commit

Man sollte besser über Dockerfile und Builds arbeiten, weil sonst die Aufbauten der Images nicht mehr nachvollziehbar sind!

docker container diff

Abweichungen zwischen Container und ursprünglichem Image auflisten.

A (added - hinzugefügt)
C (changed - geändert)
D (deleted - gelöscht)

docker export

Beim Exportieren eines Containers werden alle Layer zusammengefasst! Man spricht vom flatten für Image Layer.

Das ist beim docker save | load für Images gänzlich anders.

Achtung

Daten in Volumes werden nicht berücksichtigt!

Test:

# Endlosschleife im Container exec-uten:
docker container exec -d alpinejoeb /bin/sh \
  -c "while true; do echo palimpalim; sleep 1; done"

# Prozess für Schleife im Container ermitteln
docker container exec alpinejoeb ps ax (hier: Schleife mit PID 16)
# Prozess mit Container-PID 16 stoppen
docker container exec kill 16