# Docker & Docker Compose – Befehls‑Referenz

Eine praktische Übersicht der wichtigsten Befehle für den Alltag – von Container‑Verwaltung über Docker Compose bis zur Netzwerk‑Untersuchung.

> Hinweis: Je nach Installation heißt der Compose‑Befehl `docker compose` (Plugin, neu) oder `docker-compose` (Standalone, alt). Beide Varianten sind unten aufgeführt, wo es relevant ist.

---

## 1. Container – Grundlagen

| Zweck | Befehl |
|-------|--------|
| Laufende Container anzeigen | `docker ps` |
| Alle Container (auch gestoppte) | `docker ps -a` |
| Container starten | `docker start <name\|id>` |
| Container stoppen | `docker stop <name\|id>` |
| Container neu starten | `docker restart <name\|id>` |
| Container pausieren / fortsetzen | `docker pause <name>` / `docker unpause <name>` |
| Container löschen | `docker rm <name\|id>` |
| Laufenden Container zwangsweise löschen | `docker rm -f <name\|id>` |
| Alle gestoppten Container aufräumen | `docker container prune` |

### In einen Container hineingehen

```bash
# Interaktive Shell öffnen (bash oder sh, je nach Image)
docker exec -it <name> bash
docker exec -it <name> sh

# Einzelnen Befehl im Container ausführen
docker exec <name> ls -la /data

# Als bestimmter User (z. B. root)
docker exec -it -u root <name> sh
```

---

## 2. Logs & Diagnose

```bash
# Logs anzeigen
docker logs <name>

# Logs live mitverfolgen (folgen)
docker logs -f <name>

# Nur die letzten 100 Zeilen, mit Zeitstempel
docker logs --tail 100 -t <name>

# Logs seit einem Zeitpunkt
docker logs --since 10m <name>

# Ressourcen-Verbrauch live (CPU, RAM, Netzwerk, I/O)
docker stats

# Prozesse innerhalb eines Containers
docker top <name>

# Vollständige Metadaten (JSON): Mounts, Netzwerk, Env, ...
docker inspect <name>

# Gezielt einen Wert herausfiltern (z. B. IP-Adresse)
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' <name>

# Geänderte Dateien im Container-Dateisystem
docker diff <name>
```

---

## 3. Images

| Zweck | Befehl |
|-------|--------|
| Lokale Images anzeigen | `docker images` |
| Image herunterladen | `docker pull <image>:<tag>` |
| Image löschen | `docker rmi <image>` |
| Ungenutzte Images aufräumen | `docker image prune` |
| Image aus Dockerfile bauen | `docker build -t <name>:<tag> .` |
| Image-Historie / Layer ansehen | `docker history <image>` |

---

## 4. Volumes & Daten

```bash
# Volumes auflisten
docker volume ls

# Volume-Details (z. B. Mountpoint auf dem Host)
docker volume inspect <volume>

# Ungenutzte Volumes aufräumen (VORSICHT: Daten weg!)
docker volume prune

# Datei vom Host in den Container kopieren
docker cp ./datei.txt <name>:/pfad/im/container/

# Datei aus dem Container auf den Host holen
docker cp <name>:/pfad/im/container/datei.txt ./
```

---

## 5. Aufräumen (Speicher freigeben)

```bash
# Alles Ungenutzte entfernen (gestoppte Container, dangling Images, Netzwerke)
docker system prune

# Zusätzlich ungenutzte Images UND Volumes (aggressiv!)
docker system prune -a --volumes

# Speicherverbrauch von Docker anzeigen
docker system df
```

---

## 6. Docker Compose – Grundlagen

Alle Befehle im Verzeichnis mit der `docker-compose.yml` ausführen.

| Zweck | Befehl |
|-------|--------|
| Stack starten (im Hintergrund) | `docker compose up -d` |
| Stack starten + Images neu bauen | `docker compose up -d --build` |
| Stack stoppen & Container entfernen | `docker compose down` |
| Stack stoppen (Container bleiben) | `docker compose stop` |
| Gestoppten Stack wieder starten | `docker compose start` |
| Einen einzelnen Dienst neu starten | `docker compose restart <service>` |
| Status aller Dienste | `docker compose ps` |
| Logs aller Dienste (live) | `docker compose logs -f` |
| Logs eines Dienstes | `docker compose logs -f <service>` |
| In einen Dienst hineingehen | `docker compose exec <service> sh` |
| Images der Dienste aktualisieren | `docker compose pull` |
| Config einlesen & validieren | `docker compose config` |

### Down mit Aufräumen

```bash
# Stack runterfahren UND die zugehörigen Volumes löschen (VORSICHT!)
docker compose down -v

# Zusätzlich auch die gebauten/verwendeten Images entfernen
docker compose down --rmi all
```

### Update-Workflow (typisch)

```bash
docker compose pull        # neue Images holen
docker compose up -d       # Container mit neuen Images neu erstellen
docker image prune -f      # alte, ungenutzte Images aufräumen
```

---

## 7. Netzwerk – Untersuchung & Verwaltung

Der zentrale Teil, wenn Container sich nicht erreichen oder Ports nicht durchkommen.

### 7.1 Netzwerke auflisten & inspizieren

```bash
# Alle Docker-Netzwerke anzeigen
docker network ls

# Details eines Netzwerks: welche Container hängen dran, Subnetz, Gateway
docker network inspect <netzwerk>

# Kompakt: nur die Container-Namen + IPs eines Netzwerks
docker network inspect <netzwerk> \
  -f '{{range .Containers}}{{.Name}} → {{.IPv4Address}}{{println}}{{end}}'
```

Die Standard-Netzwerktypen:

- **bridge** – Standard für einzelne Container auf einem Host.
- **host** – Container teilt sich den Netzwerk-Stack des Hosts (kein Port-Mapping nötig).
- **none** – kein Netzwerk.
- **benutzerdefinierte bridge** – von Compose automatisch pro Projekt angelegt; hier funktioniert DNS-Auflösung über Service-Namen.

### 7.2 Netzwerke anlegen / verbinden

```bash
# Netzwerk erstellen
docker network create <netzwerk>

# Container mit einem Netzwerk verbinden
docker network connect <netzwerk> <container>

# Container von einem Netzwerk trennen
docker network disconnect <netzwerk> <container>

# Ungenutzte Netzwerke aufräumen
docker network prune
```

### 7.3 Ports & Erreichbarkeit prüfen

```bash
# Welche Ports mappt ein Container?
docker port <name>

# Port-Mappings in der Übersicht (Spalte PORTS)
docker ps

# Auf dem Host: lauscht der Port wirklich?
ss -tulpn | grep <port>       # modern
netstat -tulpn | grep <port>  # klassisch
```

### 7.4 Verbindung zwischen Containern testen

Wichtig: In einem benutzerdefinierten Compose-Netzwerk erreichen sich Container über ihren **Service-Namen** als Hostname (z. B. `db`, `gitea`, `redis`).

```bash
# DNS-Auflösung + Erreichbarkeit vom Container A zum Service "db"
docker compose exec app ping -c 3 db

# Falls ping fehlt: mit wget/curl gegen den Ziel-Port testen
docker compose exec app wget -qO- http://db:5432 || echo "nicht erreichbar"
docker compose exec app curl -v http://gitea:3000

# DNS-Auflösung explizit prüfen (nslookup / getent)
docker compose exec app nslookup db
docker compose exec app getent hosts db
```

Wenn Diagnose-Tools im Container fehlen, hilft ein Wegwerf-Container im selben Netzwerk:

```bash
docker run --rm -it --network <netzwerk> nicolaka/netshoot
# darin dann: ping, curl, dig, nslookup, traceroute, tcpdump, nmap ...
```

`nicolaka/netshoot` ist das Standard-Toolbox-Image für Container-Netzwerk-Debugging.

### 7.5 Häufige Netzwerk-Probleme

| Symptom | Prüfen |
|---------|--------|
| Container erreicht anderen nicht über Namen | Hängen beide im **selben** Netzwerk? → `docker network inspect` |
| Port von außen nicht erreichbar | Port-Mapping gesetzt (`-p host:container` / `ports:` in Compose)? Firewall? |
| „Connection refused" | Dienst lauscht evtl. nur auf `127.0.0.1` statt `0.0.0.0` im Container |
| DNS-Name wird nicht aufgelöst | Standard-`bridge` hat kein DNS – benutzerdefiniertes Netzwerk / Compose nutzen |
| Zwei Stacks sollen sich sehen | Gemeinsames externes Netzwerk anlegen und beiden zuweisen |

---

## 8. Nützliche Kombi-Befehle

```bash
# Alle laufenden Container stoppen
docker stop $(docker ps -q)

# Alle Container löschen (gestoppt)
docker rm $(docker ps -aq)

# In den zuletzt gestarteten Container springen
docker exec -it $(docker ps -q -n 1) sh

# Nur Namen + Status + Ports, sauber formatiert
docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}'

# Live-Logs eines Compose-Dienstes ab jetzt (ohne Historie)
docker compose logs -f --tail 0 <service>
```

---

## 9. Schnelle Fehlersuche – Reihenfolge

1. **Läuft der Container überhaupt?** → `docker ps -a` (Status `Exited` / `Restarting`?)
2. **Warum crasht er?** → `docker logs --tail 100 <name>`
3. **Stimmen Mounts / Env / Netzwerk?** → `docker inspect <name>`
4. **Hängt er am Netzwerk?** → `docker network inspect <netzwerk>` + Ping-Test (Abschnitt 7.4)
5. **Ist der Port offen?** → `docker port <name>` + `ss -tulpn` auf dem Host
6. **Platz voll?** → `docker system df` → ggf. `docker system prune`

---

*Erstellt als schnelle Referenz – bei Docker Compose v1 überall `docker compose` durch `docker-compose` ersetzen.*