5. Docker Kommandos

Auflistung von Docker Befehlen: Docker Befehle

Wir haben schon einigen Docker CLI Kommandos genutzt. Jetzt sollen komplettere Aufstellungen folgen.

Die Aufrufe sind nach Kategorien gegliedert. Die Aufrufe lassen sich teilweise in langer und kurzer Schreibung aufrufen:

docker container ps -a     # oder auch kürzer
docker ps -a

Das hat auch mit historischen Entwicklungen innerhalb der Docker-Versionen zu tun! Eine neue und saubere Kommanostruktur wurde mit Version 1.13 eingeführt.

Tipp

Paket docker-bash-completion in der Shell nutzen: also fleißig mit Tab-Tab vervollständigen!

Wir beginnen aber wie immer mit der eingebauten Hilfe…

5.1. docker help

Onlineportal für Docker CLI:

https://docs.docker.com/engine/reference/commandline/cli/

Tipp

Die Befehle (z.B. docker events) lassen sich einfach in URL an Stelle von cli ersetzen!

Und natürlich kann man auch jederzeit mal die interaktive Docker Hilfe nutzen.

docker help (teilweise Zeilen gekürzt)
Usage:	docker [OPTIONS] COMMAND

A self-sufficient runtime for containers

Options:
      --config string      Location of client config files (default "/home/joeb/.docker")
  -D, --debug              Enable debug mode
  -H, --host list          Daemon socket(s) to connect to
  -l, --log-level string   Set the logging level ("debug"|"info"|"warn"|"error"|"fatal") ...info
      --tls                Use TLS; implied by --tlsverify
      --tlscacert string   Trust certs signed only by this CA (default ".../.docker/ca.pem")
      --tlscert string     Path to TLS certificate file (default ".../.docker/cert.pem")
      --tlskey string      Path to TLS key file (default "/home/joeb/.docker/key.pem")
      --tlsverify          Use TLS and verify the remote
  -v, --version            Print version information and quit

Management Commands:
  builder     Manage builds
  config      Manage Docker configs
  container   Manage containers
  engine      Manage the docker engine
  image       Manage images
  network     Manage networks
  node        Manage Swarm nodes
  plugin      Manage plugins
  secret      Manage Docker secrets
  service     Manage services
  stack       Manage Docker stacks
  swarm       Manage Swarm
  system      Manage Docker
  trust       Manage trust on Docker images
  volume      Manage volumes

Commands:
  attach      Attach local standard input, output, and error streams to a running container
  build       Build an image from a Dockerfile
  commit      Create a new image from a container's changes
  cp          Copy files/folders between a container and the local filesystem
  create      Create a new container
  diff        Inspect changes to files or directories on a container's filesystem
  events      Get real time events from the server
  exec        Run a command in a running container
  export      Export a container's filesystem as a tar archive
  history     Show the history of an image
  images      List images
  import      Import the contents from a tarball to create a filesystem image
  info        Display system-wide information
  inspect     Return low-level information on Docker objects
  kill        Kill one or more running containers
  load        Load an image from a tar archive or STDIN
  login       Log in to a Docker registry
  logout      Log out from a Docker registry
  logs        Fetch the logs of a container
  pause       Pause all processes within one or more containers
  port        List port mappings or a specific mapping for the container
  ps          List containers
  pull        Pull an image or a repository from a registry
  push        Push an image or a repository to a registry
  rename      Rename a container
  restart     Restart one or more containers
  rm          Remove one or more containers
  rmi         Remove one or more images
  run         Run a command in a new container
  save        Save one or more images to a tar archive (streamed to STDOUT by default)
  search      Search the Docker Hub for images
  start       Start one or more stopped containers
  stats       Display a live stream of container(s) resource usage statistics
  stop        Stop one or more running containers
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
  top         Display the running processes of a container
  unpause     Unpause all processes within one or more containers
  update      Update configuration of one or more containers
  version     Show the Docker version information
  wait        Block until one or more containers stop, then print their exit codes

Run 'docker COMMAND --help' for more information on a command.

Mit der Hilfe kann man sich auch weiter in die Kommando-Hierarchien begeben:

docker container ps –help
Usage:	docker container ls [OPTIONS]

List containers

Aliases:
  ls, ps, list

Options:
  -a, --all             Show all containers (default shows just running)
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print containers using a Go template
  -n, --last int        Show n last created containers (includes all states) (default -1)
  -l, --latest          Show the latest created container (includes all states)
      --no-trunc        Don't truncate output
  -q, --quiet           Only display numeric IDs
  -s, --size            Display total file sizes

Und ja: es handelt sich bei der Textausgabe der Hilfe nicht um einen Fehler - es wurde docker container ps --help aufgerufen - man erkennt dann die Aliase.

Und zuletzt wurden auch klassische Man-Pages für die docker-Kommandos implementiert, die man einfach über mit „-“ (Bindestrich) zusammengesetzte Aufrufe erhält: man docker-start

5.2. docker

Allgemeine Docker Kommandos:

Kommandos

Funktionalität

docker container

Hauptbefehl: Container verwalten

docker events

laufend (!) Aktionen des Docker-Systems anzeigen

docker info

Status Docker-System

docker image

Hauptbefehl: Images verwalten

docker login/logout

am Docker-Account an-/abmelden

docker network

Hauptbefehl: Docker-Networking verwalten

docker node

Haupbefehl: Docker Swarm Knoten verwalten

docker search

Images (unter docker.io) suchen

docker secret

Hauptbefehl: Secrets für Services

docker service

Hauptbefehl: Services verwalten (siehe Cluster)

docker stack

Hauptbefehl: Stack (Gruppe von Services) verwalten

docker stats

laufend (!) CPU, MEM anzeigen lassen

docker swarm

Haupbefehl: Swarm einrichten / verwalten

docker system

Haupbefehl: Infos zu Docker System

docker version

Docker Version(en) anzeigen lassen

docker volume

Hauptbefehl: Volumes verwalten

Es folgen ein paar individuelle Anmerkungen zu einzelnen docker-Kommandos.

docker events

Eine laufende Konsole - also gerne wieder mit mehreren Terminalfenstern arbeiten (siehe Tilix).

# Alle Events in einem bestimmten Zeitraum:
docker events --since '2019-01-01' --until '2019-01-10'
# in den letzten 50 Minuten
docker events --since '50m'
# für ein bestimmtes Image (oder auch 'container=...')
docker events --since '40m' --filter 'image=alpine'
# Event types filtern:
docker events --since '2019-01-01' --filter 'container=alpinejoeb' --filter 'event=start'

Die Ausgaben können formatiert (Parameter --format) ausgegeben werden (auch JSON).

Anm.: Linux Kernel verteilen Privilegien (Capabilities)

Hier: Docker Prozess im Host finden und CapEff finden: cat /proc/PID/status | grep CapEff

Die Hex-Kodierung CapEff des Prozesse analyisieren: capsh --decode=<hexcode>

Tools capsh in Paket libcap-progs (Suse) oder libcap (CentOS).

docker info

Die Infos zum laufenden Docker-System.

Die Anzahl der laufenden Container anzeigen mit docker info | grep Running.

docker search

Einfache Suche: docker search ubuntu

Anzahl Images (hier: ubuntu): docker search ubuntu | grep "\/ubuntu\ " | wc -l

Filtern: docker search --filter=stars=7 --filter=is-official=true ubuntu

docker stats

Entspricht dem Linux-Klassiker top für die Shell.

docker system

Speichernutzung anzeigen lassen mit docker system df

Aufräumen / „Echt Alles ;-) Tabularasa“ mit `` docker system prune`` (--all --force)

docker network …

Hauptbefehl für Docker-Networking (siehe auch wieder docker network --help)

Kurze Befehlsliste: docker network ...

  • create (Netzwerk erstellen)

  • connect <nwid> <cname/cid>

  • inspect <nwname/nwid>

  • ls (Netzwerke auflisten)

  • prune (ungenutzte Netzwerke löschen; siehe docker-compose)

Online: Infoseite Docker Networking

5.3. docker image

Docker Kommandos für Images:

Kommandos

Funktionalität

docker image

Hauptbefehl: Images verwalten

docker build

neues Image mit Dockerfile

docker images

Images auflisten: docker image ls

docker history

Build-History eines Images

docker inspect

lokale Images analysieren

docker pull

Image herunterladen / aktualisieren

docker push

Image in Docker Repo hochladen

docker rmi

Image löschen

docker save / load

aus Images einen Tarball erzeugen

docker tag

Image-Namen bzw. -Tag anpassen

docker pull

Wenn nur ein Imagename angegeben wird, dann wird das Image mit Tag :latest gepullt!

Images mit Tag:latest müssen nicht immer die aktuellsten Images sein!

Kompletter Aufruf: docker pull [OPTIONS] REGISTRY:REG-PORT/IMAGE:TAG|@DIGEST

Optionen: -a | --all-tags um alle Images(:tags) mit einem Imagenamen zu pullen (gesamtes Image-Repository)

docker images oder auch docker image ls

Mit Option --no-trunc komplettere Ausgaben und -q für quiet, was einfach die (kurzen) IDs ausgibt!

Alle Images auflisten:

docker images -a

REPOSITORY                 TAG                 IMAGE ID            CREATED             SIZE
mariadb                    <none>              2bdd97ca79d9        6 days ago          366MB
joebrandes/testwebserver   latest              9ff70d3871d4        7 days ago          183MB
<none>                     <none>              7c54877665f7        7 days ago          183MB
<none>                     <none>              6a247201e8a3        7 days ago          183MB
<none>                     <none>              aef9419d7b92        7 days ago          183MB
<none>                     <none>              c21c0c4fe351        7 days ago          183MB
<none>                     <none>              a3ff1c7635da        7 days ago          183MB
<none>                     <none>              2bd50cd1f5b1        7 days ago          86.7MB
<none>                     <none>              86e536f3da5c        7 days ago          86.7MB
hello-world                latest              fce289e99eb9        2 weeks ago         1.84kB
wordpress                  latest              9ec2fcdda9ef        2 weeks ago         420MB
mariadb                    latest              4f2e75647d2a        2 weeks ago         366MB
ubuntu                     18.10               d4452947e3fa        2 weeks ago         73.7MB
ubuntu                     18.04               1d9c17228a9e        2 weeks ago         86.7MB
alpine                     latest              3f53bb00af94        3 weeks ago         4.41MB

Die hier aufgelisteten none:none Images enstehen durch das Layersystem von Images und belegen und verschwenden keinen Platz im System!

Problematisch sind Image die mit none:none bei normalem docker images (ohne -a) auftauchen:

Dangling Images - verwaiste Einträge

Finden von Dangling Images: docker images -f "dangling=true"

Löschen / Aufräumen: per Filtern oder mit docker image prune

docker images -f "dangling=true" -q | xargs -n1 docker rmi -f
# oder einfach mit:
docker image prune

docker inspect oder auch docker image inspect

Formatierte Ausgaben mit Parameter --format

docker inspect --format='{{.Config.Cmd}}' alpine:latest
[/bin/sh]
# oder einfacher mit:
docker inspect alpine:latest | grep -i Cmd

Das lässt sich auch wieder aufbereiten (Tool jq):

docker image inspect alpine:latest | jq -CS                       # C Color; S sortiert
docker image inspect alpine:latest | jq -CS .[0].Config.Cmd       # Zugriff auf Array
[
"/bin/sh"
]

Die Ausgabe von Docker Kommandos ist auch über Go-Templates möglich: (Go Templates )

docker image inspect alpine:latest --format '{{.Config.Cmd}}'
[/bin/sh]
docker image inspect alpine:latest --format '{{json .Config.Env}}' | jq
[
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
]

Diese Ausgabeformate lassen sich auch bei anderen cmd-Techniken nutzen (siehe docker container ls ...).

docker save | load

Speichert Images in einem Tarball - nicht mit dem Export / Import von Containern verwechseln

docker save -o ~/alpine-out.tar alpine
tar -tvf alpine-out.tar

-rw-r--r-- 0/0            1511 2018-12-21 01:21 3f53bb00af943dfdf81...129d57d5991.json
drwxr-xr-x 0/0               0 2018-12-21 01:21 a21b1050952cdc06771...57cae64904b/
-rw-r--r-- 0/0               3 2018-12-21 01:21 a21b1050952cdc06771...57cae64904b/VERSION
-rw-r--r-- 0/0            1184 2018-12-21 01:21 a21b1050952cdc06771...57cae64904b/json
-rw-r--r-- 0/0         4672000 2018-12-21 01:21 a21b1050952cdc06771...57cae64904b/layer.tar
-rw-r--r-- 0/0             202 1970-01-01 01:00 manifest.json
-rw-r--r-- 0/0              89 1970-01-01 01:00 repositories

In layer.tar befindet sich das eigentliche Image mit den Ordnerstrukturen /, /bin, /usr, …

Diese Sicherung lässt sich dann auf einem anderen Rechner wieder loaden.

5.4. docker container

Docker Kommandos für Container:

Kommandos

Funktionalität

docker container

Hauptbefehl: Container verwalten

docker attach

I/O eines Containers mit Terminal connecten

docker commit

neues Image aus Container

docker cp

Kopieren von Daten zwischen Container <-> Host

docker create

Container erzeugen, aber nicht starten

docker diff

veränderte Dateien eines Containers erzeugen

docker exec

Kommando in laufendem Container ausführen

docker export

Container in Archiv speichern

docker import

Container aus Archiv erzeugen

docker inspect

Konfiguration und Status eines Containers

docker kill

Container sofort beenden

docker logs

Container-Loggings

docker pause/unpause

Container anhalten/fortsetzen

docker port

Container Ports auflisten

docker ps

Container auflisten

docker rename

Container umbenennen

docker restart

Container neu starten

docker rm

Container löschen

docker run

neuen Container erzeugen und starten

docker start

Container starten

docker stop

Container anhalten

docker top

Container Prozesse anzeigen

docker update

Container Optionen anpassen

docker wait

Container Ende erwarten

docker attach

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

Andernfalls kann man mit docker attach diese Funktionalität nachholen.

docker commit

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

docker 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

docker diff

Abweichungen zwischen Container und ursprünglichem Image auflisten.

  • A (added - hinzugefügt)

  • C (changed - geändert)

  • D (deleted - gelöscht)

docker exec

Befehle in einem laufenden Contaier aufrufen. Der Container muss aktiv sein / laufen.

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

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.

Anm.: Daten in Volumes werden nicht berücksichtigt!

docker images

Bitte auf Plural achten! Tipp: docker images -q listet nur die IDs auf und kann somit gut zum Pipeling für andere Docker-Aufrufe genutzt werden!

docker inspect

Arbeitet mit Images und Containern und erzeugt Infos im JSON-Format.

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

docker ps (kurz für: docker container ps)

Filterung mit Kriterium: -f <Kriterium=Wert>

Filterungs-Schalter aus Hilfen zu den Tools docker-ps bzw. docker-container-ls|ps

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

Formatierte / tabellarische Ausgaben mit Schalter --format:

docker container ls -a --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Labels}}"
docker container ls -a --format '{{printf "%-30s%-30s" .Names .RunningFor}}'
# auch hier wieder JSON Formatierung möglich:
docker container ls -a --format '{{json . }}' | jq

Formatierungs-Schalter (siehe Go-Templates) gerne wieder per Hilfen zu den Tools docker-ps bzw. docker-container-ls|ps

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.

Exit Status aus Aufruf 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

docker run

Erzeugt und startet einen neuen Container. Dabei wird, falls noch kein Image lokal vorhanden 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

Container im Hintergrund (detached)

-e VAR=value

Variable für Container setzen

-h

Hostname

-i

interaktiv ausführen lassen

-m 512m

Container-RAM auf 512 MiB limitieren

–name cname

Containername

–network nwname

Netzwerk verwenden

-p localport:containerport

Portweiterleitungen zwischen Host und Container

-P

alle Port des Containers mit zufälligen Host-Ports

–rm

Container nach Ausführung löschen

-t

Pseudo-Terminal mit Standardausgabe verbinden

-v 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!

docker start | stop

Mit Parameter -ai (attach) direkt in eine Shell eines Containers starten: docker start -ai containername

Tipp

Die Container-Instanz wird mit exit beendet! Mit Strg+P Strg+Q läuft 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 neuem prune (dt.: stutzen, beschneiden) Schalter: docker container prune

docker top

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

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