# Docker — Container bauen, ausliefern und betreiben

> Praxis-Guide zu Docker — Container-Lebenszyklus, Images bauen, Volumes, Netzwerke, Compose und Aufräumen auf der Kommandozeile, mit Beispielen.

Source: https://www.jpkc.com/db/cheatsheets/containers/docker/

<!-- PROSE:intro -->
Docker verpackt Anwendungen samt ihren Abhängigkeiten in Container – leichtgewichtige, isolierte Einheiten, die auf jedem System gleich laufen. Statt „funktioniert bei mir" bekommst du reproduzierbare Umgebungen vom Laptop bis zur Produktion. Über die Kommandozeile baust du Images, startest Container, mappst Ports, mountest Volumes und orchestrierst ganze Stacks per Compose. Dieser Guide bündelt die wichtigsten `docker`-Befehle für den Alltag – vom ersten `docker run` bis zum gezielten Aufräumen mit `prune`.
<!-- PROSE:intro:end -->

## Container-Lebenszyklus

`docker run <image>` — Erstellt und startet einen neuen Container aus einem Image.

```bash
docker run nginx
```

`docker run -d <image>` — Startet einen Container im Hintergrund (detached).

```bash
docker run -d nginx
```

`docker run -it <image> <command>` — Startet einen Container interaktiv mit TTY. Praktisch für Shells.

```bash
docker run -it ubuntu bash
```

`docker run --name <name> <image>` — Startet einen Container mit eigenem Namen für leichtere Referenzierung.

```bash
docker run --name my-web -d nginx
```

`docker run --rm <image>` — Entfernt den Container automatisch, sobald er beendet wird.

```bash
docker run --rm alpine echo "Hello"
```

`docker start <container>` — Startet einen gestoppten Container.

```bash
docker start my-web
```

`docker stop <container>` — Stoppt einen laufenden Container sauber (sendet SIGTERM, nach Timeout SIGKILL).

```bash
docker stop my-web
```

`docker restart <container>` — Stoppt einen Container und startet ihn anschließend neu.

```bash
docker restart my-web
```

`docker kill <container>` — Stoppt einen Container sofort per SIGKILL.

```bash
docker kill my-web
```

`docker rm <container>` — Entfernt einen gestoppten Container.

```bash
docker rm my-web
```

`docker rm -f <container>` — Erzwingt das Entfernen eines laufenden Containers (Stoppen + Entfernen).

```bash
docker rm -f my-web
```

## Ports & Umgebungsvariablen

`docker run -p <host_port>:<container_port> <image>` — Bildet einen Host-Port auf einen Container-Port ab.

```bash
docker run -d -p 8080:80 nginx
```

`docker run -p <host_port>:<container_port>/udp <image>` — Bildet einen UDP-Port vom Host auf den Container ab.

```bash
docker run -d -p 5353:53/udp dns-server
```

`docker run -P <image>` — Bildet alle exponierten Ports auf zufällige Host-Ports ab.

```bash
docker run -d -P nginx
```

`docker run -e <KEY>=<value> <image>` — Setzt eine Umgebungsvariable im Container.

```bash
docker run -d -e MYSQL_ROOT_PASSWORD=secret mysql:8
```

`docker run --env-file <file> <image>` — Lädt Umgebungsvariablen aus einer Datei.

```bash
docker run -d --env-file .env my-app
```

`docker run --restart=<policy> <image>` — Setzt die Restart-Policy: no, on-failure, always, unless-stopped.

```bash
docker run -d --restart=unless-stopped nginx
```

## Volumes & Mounts

`docker run -v <host_path>:<container_path> <image>` — Bindet ein Host-Verzeichnis als Bind-Mount in den Container ein.

```bash
docker run -d -v ./html:/usr/share/nginx/html nginx
```

`docker run -v <host_path>:<container_path>:ro <image>` — Bindet ein Host-Verzeichnis schreibgeschützt (read-only) ein.

```bash
docker run -d -v ./config:/etc/app/config:ro my-app
```

`docker run -v <volume_name>:<container_path> <image>` — Bindet ein benanntes Docker-Volume in den Container ein.

```bash
docker run -d -v db-data:/var/lib/mysql mysql:8
```

`docker volume create <name>` — Erstellt ein benanntes Volume für persistente Daten.

```bash
docker volume create db-data
```

`docker volume ls` — Listet alle Docker-Volumes auf.

```bash
docker volume ls
```

`docker volume inspect <name>` — Zeigt detaillierte Informationen zu einem Volume.

```bash
docker volume inspect db-data
```

`docker volume rm <name>` — Entfernt ein Volume. Schlägt fehl, wenn es noch benutzt wird.

```bash
docker volume rm db-data
```

`docker volume prune` — Entfernt alle ungenutzten Volumes und gibt Speicherplatz frei.

```bash
docker volume prune
```

## Auflisten & Inspizieren

`docker ps` — Listet alle laufenden Container auf.

```bash
docker ps
```

`docker ps -a` — Listet alle Container auf, auch gestoppte.

```bash
docker ps -a
```

`docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"` — Listet Container in einem eigenen Ausgabeformat auf.

```bash
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
```

`docker inspect <container>` — Zeigt detaillierte JSON-Informationen zu einem Container.

```bash
docker inspect my-web
```

`docker inspect --format '{{.NetworkSettings.IPAddress}}' <container>` — Extrahiert ein bestimmtes Feld aus den Container-Metadaten per Go-Template.

```bash
docker inspect --format '{{.NetworkSettings.IPAddress}}' my-web
```

`docker port <container>` — Zeigt die Port-Zuordnungen eines Containers.

```bash
docker port my-web
```

`docker stats` — Zeigt CPU-, Speicher-, Netzwerk- und Disk-I/O-Auslastung aller laufenden Container live an.

```bash
docker stats
```

`docker top <container>` — Zeigt die laufenden Prozesse innerhalb eines Containers.

```bash
docker top my-web
```

## Logs & Exec

`docker logs <container>` — Zeigt die Logs (stdout/stderr) eines Containers.

```bash
docker logs my-web
```

`docker logs -f <container>` — Folgt der Log-Ausgabe in Echtzeit (tail).

```bash
docker logs -f my-web
```

`docker logs --tail <n> <container>` — Zeigt nur die letzten N Zeilen der Logs.

```bash
docker logs --tail 50 my-web
```

`docker logs --since <time> <container>` — Zeigt Logs ab einem Zeitstempel oder relativer Zeit.

```bash
docker logs --since 30m my-web
```

`docker exec -it <container> <command>` — Führt einen Befehl interaktiv in einem laufenden Container aus.

```bash
docker exec -it my-web bash
```

`docker exec <container> <command>` — Führt einen Befehl in einem laufenden Container aus (nicht interaktiv).

```bash
docker exec my-web cat /etc/nginx/nginx.conf
```

`docker exec -u <user> <container> <command>` — Führt einen Befehl als bestimmter Benutzer im Container aus.

```bash
docker exec -u root my-web apt-get update
```

## Kopieren & Diff

`docker cp <container>:<path> <host_path>` — Kopiert Dateien aus einem Container auf den Host.

```bash
docker cp my-web:/etc/nginx/nginx.conf ./nginx.conf
```

`docker cp <host_path> <container>:<path>` — Kopiert Dateien vom Host in einen Container.

```bash
docker cp ./index.html my-web:/usr/share/nginx/html/
```

`docker diff <container>` — Zeigt Dateisystem-Änderungen im Container (A=hinzugefügt, C=geändert, D=gelöscht).

```bash
docker diff my-web
```

## Images

`docker images` — Listet alle lokal verfügbaren Images auf.

```bash
docker images
```

`docker pull <image>` — Lädt ein Image aus einer Registry herunter.

```bash
docker pull nginx:alpine
```

`docker pull <image>:<tag>` — Lädt eine bestimmte getaggte Version eines Images herunter.

```bash
docker pull node:22-slim
```

`docker push <image>` — Lädt ein Image in eine Registry hoch.

```bash
docker push myuser/my-app:latest
```

`docker tag <source_image> <target_image>` — Erstellt einen neuen Tag (Alias) für ein vorhandenes Image.

```bash
docker tag my-app:latest myuser/my-app:v1.0
```

`docker rmi <image>` — Entfernt ein lokales Image.

```bash
docker rmi nginx:alpine
```

`docker image prune` — Entfernt alle ungenutzten (dangling/untagged) Images.

```bash
docker image prune
```

`docker image prune -a` — Entfernt alle Images, die von keinem Container genutzt werden.

```bash
docker image prune -a
```

`docker history <image>` — Zeigt die Layer-Historie eines Images.

```bash
docker history nginx:alpine
```

`docker save -o <file> <image>` — Exportiert ein Image in ein Tar-Archiv.

```bash
docker save -o my-app.tar my-app:latest
```

`docker load -i <file>` — Importiert ein Image aus einem Tar-Archiv.

```bash
docker load -i my-app.tar
```

## Images bauen

`docker build -t <name>:<tag> .` — Baut ein Image aus einem Dockerfile im aktuellen Verzeichnis.

```bash
docker build -t my-app:latest .
```

`docker build -t <name> -f <dockerfile> .` — Baut mit einem bestimmten Dockerfile.

```bash
docker build -t my-app -f Dockerfile.prod .
```

`docker build --no-cache -t <name> .` — Baut ohne Layer-Cache. Erzwingt einen frischen Build.

```bash
docker build --no-cache -t my-app:latest .
```

`docker build --build-arg <KEY>=<value> -t <name> .` — Übergibt eine Build-Variable an das Dockerfile.

```bash
docker build --build-arg NODE_ENV=production -t my-app .
```

`docker build --target <stage> -t <name> .` — Baut nur bis zu einer bestimmten Stage in einem Multi-Stage-Dockerfile.

```bash
docker build --target builder -t my-app:build .
```

`docker build --platform <platform> -t <name> .` — Baut für eine bestimmte Plattform-Architektur.

```bash
docker build --platform linux/amd64 -t my-app .
```

## Netzwerke

`docker network ls` — Listet alle Docker-Netzwerke auf.

```bash
docker network ls
```

`docker network create <name>` — Erstellt ein neues Bridge-Netzwerk.

```bash
docker network create my-network
```

`docker network inspect <name>` — Zeigt detaillierte Informationen zu einem Netzwerk inkl. verbundener Container.

```bash
docker network inspect my-network
```

`docker network connect <network> <container>` — Verbindet einen laufenden Container mit einem Netzwerk.

```bash
docker network connect my-network my-web
```

`docker network disconnect <network> <container>` — Trennt einen Container von einem Netzwerk.

```bash
docker network disconnect my-network my-web
```

`docker run --network <name> <image>` — Startet einen Container, der an ein bestimmtes Netzwerk angebunden ist.

```bash
docker run -d --network my-network --name api my-api
```

`docker network rm <name>` — Entfernt ein Netzwerk. Schlägt fehl, wenn noch Container verbunden sind.

```bash
docker network rm my-network
```

`docker network prune` — Entfernt alle ungenutzten Netzwerke.

```bash
docker network prune
```

## Docker Compose

`docker compose up` — Erstellt und startet alle in docker-compose.yml definierten Services.

```bash
docker compose up
```

`docker compose up -d` — Startet alle Services im Hintergrund (detached).

```bash
docker compose up -d
```

`docker compose up --build` — Baut Images neu, bevor die Services gestartet werden.

```bash
docker compose up --build -d
```

`docker compose down` — Stoppt und entfernt alle von up erstellten Container und Netzwerke.

```bash
docker compose down
```

`docker compose down -v` — Stoppt und entfernt Container, Netzwerke und Volumes.

```bash
docker compose down -v
```

`docker compose ps` — Listet die Container des aktuellen Compose-Projekts auf.

```bash
docker compose ps
```

`docker compose logs <service>` — Zeigt die Logs eines bestimmten Services.

```bash
docker compose logs web
```

`docker compose logs -f` — Folgt den Logs aller Services in Echtzeit.

```bash
docker compose logs -f
```

`docker compose exec <service> <command>` — Führt einen Befehl in einem laufenden Compose-Service-Container aus.

```bash
docker compose exec web bash
```

`docker compose run <service> <command>` — Startet einen einmaligen Befehl in einem neuen Container für einen Service.

```bash
docker compose run web npm test
```

`docker compose pull` — Lädt die aktuellen Images für alle Services herunter.

```bash
docker compose pull
```

`docker compose build` — Baut oder baut alle Service-Images neu.

```bash
docker compose build
```

`docker compose restart <service>` — Startet einen bestimmten Service neu.

```bash
docker compose restart web
```

`docker compose config` — Validiert und zeigt die aufgelöste Compose-Konfiguration.

```bash
docker compose config
```

## Aufräumen & System

`docker system df` — Zeigt den Docker-Speicherverbrauch: Images, Container, Volumes und Build-Cache.

```bash
docker system df
```

`docker system df -v` — Zeigt den Speicherverbrauch detailliert mit Einzelgrößen.

```bash
docker system df -v
```

`docker system prune` — Entfernt alle gestoppten Container, ungenutzten Netzwerke, dangling Images und den Build-Cache.

```bash
docker system prune
```

`docker system prune -a` — Entfernt alles Ungenutzte: alle Images, Container, Netzwerke und Cache.

```bash
docker system prune -a
```

`docker system prune -a --volumes` — Vollständiges Aufräumen inkl. ungenutzter Volumes. Gibt maximalen Speicher frei.

```bash
docker system prune -a --volumes
```

`docker container prune` — Entfernt alle gestoppten Container.

```bash
docker container prune
```

`docker system info` — Zeigt systemweite Docker-Informationen (Version, Storage-Driver, OS usw.).

```bash
docker system info
```

`docker version` — Zeigt Versionsdetails von Docker-Client und -Server.

```bash
docker version
```

## Ressourcen-Limits

`docker run -m <memory> <image>` — Setzt ein Speicher-Limit für den Container.

```bash
docker run -d -m 512m nginx
```

`docker run --cpus=<number> <image>` — Begrenzt die Anzahl der CPU-Kerne, die der Container nutzen darf.

```bash
docker run -d --cpus=1.5 my-app
```

`docker run --memory-swap=<limit> <image>` — Setzt das Limit für Speicher + Swap. -1 für unbegrenzten Swap.

```bash
docker run -d -m 512m --memory-swap=1g my-app
```

`docker run --pids-limit=<number> <image>` — Begrenzt die Anzahl der Prozesse im Container.

```bash
docker run -d --pids-limit=100 my-app
```

`docker update --memory <limit> <container>` — Aktualisiert Ressourcen-Limits eines laufenden Containers.

```bash
docker update --memory 1g my-web
```

<!-- PROSE:outro -->
## Fazit

Docker ist aus moderner Entwicklung und DevOps kaum noch wegzudenken: Was als einzelner Container beginnt, wächst schnell zu mehrstufigen Builds, Compose-Stacks und CI/CD-Pipelines. Wenn du die Befehle aus diesem Guide verinnerlicht hast, lohnt der nächste Blick auf schlanke Multi-Stage-Images, benannte Volumes für persistente Daten und regelmäßiges `prune`, damit dir der Speicher nicht zuläuft.

## Weiterführende Links

- [Docker-Dokumentation](https://docs.docker.com/) – offizielle Referenz und Handbücher (englisch)
- [docker CLI-Referenz](https://docs.docker.com/reference/cli/docker/) – alle Befehle und Optionen (englisch)
- [Docker (Software) – Wikipedia](https://de.wikipedia.org/wiki/Docker_(Software)) – Hintergrund und Architektur
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [ddev](https://www.jpkc.com/db/cheatsheets/containers/ddev/) – lokale Docker-Entwicklungsumgebungen für PHP-Projekte
- [docker-compose](https://www.jpkc.com/db/cheatsheets/containers/docker-compose/) – Multi-Container-Anwendungen deklarativ definieren
- [helm](https://www.jpkc.com/db/cheatsheets/containers/helm/) – Paketmanager für Kubernetes-Anwendungen