268 lines
6.9 KiB
Markdown
268 lines
6.9 KiB
Markdown
# 🧭 Crumbpage 24: Docker - Der Wal im Wald
|
|
|
|
**Subtitle:** *Warum Tupperware dein Leben verändert*
|
|
**Pfad:** 24 von X (Der neue Horizont)
|
|
**Schwierigkeit:** ⭐⭐⭐ (3/5)
|
|
**Zeit:** ~2-3 Stunden
|
|
**Voraussetzungen:** [Pfad 10: Services](crumbpage-10-services-ports.md), [Pfad 17: Workstation](crumbpage-17-workstation.md)
|
|
|
|
> *"Es läuft auf meinem Rechner!" - "Dann liefern wir deinen Rechner mit aus!"* - Die Geburtsstunde von Docker 🐳
|
|
|
|
---
|
|
|
|
## 📋 Was du in diesem Pfad lernst
|
|
|
|
```
|
|
✓ Was ist ein Container? (Tupperware-Theorie)
|
|
✓ Unterschied: VM vs. Container
|
|
✓ Installation auf Linux (Der Server-Weg)
|
|
✓ Docker Desktop (Der bequeme Mac/Windows-Weg)
|
|
✓ Hello World (Der erste Wal)
|
|
✓ Wichtige Befehle (ps, logs, exec)
|
|
✓ Docker Compose (Das Rezeptbuch)
|
|
```
|
|
|
|
---
|
|
|
|
## 🎯 Lernziele
|
|
|
|
Nach diesem Pfad kannst du:
|
|
|
|
- [ ] Verstehen, warum wir Dinge in Boxen packen
|
|
- [ ] Einen Webserver starten, ohne ihn zu installieren
|
|
- [ ] Container debuggen, wenn sie "Ups" machen
|
|
- [ ] Eine komplette Umgebung mit einem Befehl starten (`docker compose up`)
|
|
|
|
---
|
|
|
|
## 🍱 Die Tupperware-Theorie (Konzepte)
|
|
|
|
Stell dir vor, du kochst Lasagne.
|
|
|
|
**Ohne Docker (Bare Metal):**
|
|
Du schmierst die Lasagne direkt in den Rucksack. Wenn du danach Kuchen transportieren willst, schmeckt der nach Lasagne. Und der Rucksack ist ruiniert.
|
|
|
|
**Mit Docker (Container):**
|
|
Du packst die Lasagne in eine Tupperdose. Den Kuchen in eine andere.
|
|
- Beide sind im gleichen Rucksack (Server).
|
|
- Sie berühren sich nicht.
|
|
- Du kannst die Dosen stapeln.
|
|
- Du kannst die Dose einfach jemand anderem geben, und die Lasagne bleibt Lasagne.
|
|
|
|
**Das ist Docker.**
|
|
- **Image:** Das Rezept & die Zutaten (Read-only).
|
|
- **Container:** Die gefüllte Tupperdose (Running instance).
|
|
- **Volume:** Der Teller, auf dem du isst (Daten, die bleiben, wenn die Dose weg ist).
|
|
|
|
---
|
|
|
|
## 🐳 Installation
|
|
|
|
### Auf dem Server (Linux / Debian / Ubuntu)
|
|
|
|
Der "echte" Weg für dein Rechenzentrum.
|
|
|
|
```bash
|
|
# 1. Alte Versionen entfernen (Hausputz)
|
|
sudo apt remove docker docker-engine docker.io containerd runc
|
|
|
|
# 2. Repo hinzufügen & Installieren (Faulheits-Script von Docker)
|
|
curl -fsSL https://get.docker.com -o get-docker.sh
|
|
sudo sh get-docker.sh
|
|
|
|
# 3. User zur Docker-Gruppe (WICHTIG!)
|
|
# Sonst musst du immer 'sudo' tippen. Das nervt.
|
|
sudo usermod -aG docker $USER
|
|
|
|
# 4. Neu einloggen!
|
|
logout
|
|
# (Und wieder rein ssh-en)
|
|
```
|
|
|
|
### Auf dem Mac (Docker Desktop)
|
|
|
|
Der "bequeme" Weg für deine Workstation.
|
|
|
|
Wir sind im Wald, aber manchmal darf man auch gemütlich auf der Veranda sitzen.
|
|
**Docker Desktop** ist eine App. Sie startet eine kleine Linux-VM im Hintergrund und gibt dir eine schicke GUI.
|
|
|
|
1. Lade **Docker Desktop for Mac** herunter.
|
|
2. Installiere es (Drag to Applications).
|
|
3. Starte es.
|
|
4. Warte, bis der Wal sich beruhigt hat.
|
|
|
|
**Vorteil:** Du siehst deine Container bunt und klickbar.
|
|
**Nachteil:** Es zieht Akku wie ein hungriger Bär.
|
|
|
|
---
|
|
|
|
## 👋 Hello World
|
|
|
|
Der erste Test. Ob Linux oder Mac, ab hier ist alles gleich (dank Tupperware!).
|
|
|
|
```bash
|
|
$ docker run hello-world
|
|
```
|
|
|
|
**Was passiert hier?**
|
|
1. Docker sucht das Image `hello-world` lokal.
|
|
2. Findet es nicht ("Unable to find image...").
|
|
3. Lädt es aus dem Internet (Docker Hub).
|
|
4. Startet einen Container daraus.
|
|
5. Der Container sagt "Hallo!", gibt Text aus und beendet sich.
|
|
|
|
---
|
|
|
|
## 🛠️ Grundbefehle (Deine Werkzeuge)
|
|
|
|
### 1. Was läuft hier eigentlich? (`ps`)
|
|
|
|
```bash
|
|
docker ps # Zeigt NUR laufende Container
|
|
docker ps -a # Zeigt ALLE (auch die toten)
|
|
```
|
|
|
|
### 2. Der Container lebt, aber was tut er? (`logs`)
|
|
|
|
Wenn dein Webserver schweigt, schau in sein Tagebuch.
|
|
|
|
```bash
|
|
docker logs <container_id_oder_name>
|
|
docker logs -f my-web-server # -f wie "follow" (live zuschauen)
|
|
```
|
|
|
|
### 3. Ich muss da rein! (`exec`)
|
|
|
|
Manchmal musst du in die Tupperdose klettern.
|
|
|
|
```bash
|
|
# Öffnet eine Shell IM Container
|
|
docker exec -it <container_name> /bin/bash
|
|
# Oder wenn es minimal ist:
|
|
docker exec -it <container_name> /bin/sh
|
|
```
|
|
*Tipp: `exit` bringt dich wieder raus. Keine Sorge, du warst nur zu Besuch.*
|
|
|
|
### 4. Weg damit! (`stop`, `rm`, `rmi`)
|
|
|
|
```bash
|
|
docker stop <name> # Halt an!
|
|
docker rm <name> # Wirf die Dose weg (Daten sind weg!)
|
|
docker rmi <image_name> # Wirf das Rezept weg (Platz sparen)
|
|
|
|
# Der "Alles muss raus" Befehl (VORSICHT!):
|
|
docker system prune -a
|
|
```
|
|
|
|
---
|
|
|
|
## 🎼 Docker Compose - Das Orchester
|
|
|
|
Einzelne Container starten (`docker run ...`) ist wie Kochen mit nur einer Hand. Mühsam.
|
|
Wir wollen **Infrastruktur als Code**.
|
|
|
|
Dafür gibt es `docker-compose.yml` (oder `compose.yaml`).
|
|
|
|
**Beispiel: Ein Webserver**
|
|
|
|
Erstelle eine Datei `docker-compose.yml`:
|
|
|
|
```yaml
|
|
version: '3.8' # Egal, nimm einfach was aktuelles
|
|
|
|
services:
|
|
webseite:
|
|
image: nginx:alpine
|
|
ports:
|
|
- "8080:80" # Außen 8080 -> Innen 80
|
|
volumes:
|
|
- ./html:/usr/share/nginx/html # Mein Ordner -> Server Ordner
|
|
restart: always
|
|
```
|
|
|
|
**Erstelle eine index.html:**
|
|
```bash
|
|
mkdir html
|
|
echo "<h1>Hallo aus der Dose!</h1>" > html/index.html
|
|
```
|
|
|
|
**Starte das Orchester:**
|
|
```bash
|
|
docker compose up -d
|
|
```
|
|
*(`-d` heißt Detached: "Lauf im Hintergrund, nerv mich nicht")*
|
|
|
|
**Besuche:** http://localhost:8080
|
|
|
|
**Stoppe alles:**
|
|
```bash
|
|
docker compose down
|
|
```
|
|
|
|
---
|
|
|
|
## 🎓 Hands-On Übung: Dein eigener kleiner Dienst
|
|
|
|
**Aufgabe:** Starte einen Python-Webserver, der dir Dateien serviert.
|
|
|
|
1. Erstelle ein Verzeichnis `mein-fileserver`.
|
|
2. Erstelle eine `docker-compose.yml`.
|
|
3. Nutze das Image `python:3.9-slim`.
|
|
4. Der Befehl (`command`) soll sein: `python -m http.server 8000`.
|
|
5. Mappe Port 9000 (außen) auf 8000 (innen).
|
|
6. Mappe das aktuelle Verzeichnis als Volume.
|
|
|
|
<details>
|
|
<summary>Lösung (Nicht spicken!)</summary>
|
|
|
|
```yaml
|
|
services:
|
|
files:
|
|
image: python:3.9-slim
|
|
ports:
|
|
- "9000:8000"
|
|
volumes:
|
|
- .:/data
|
|
working_dir: /data
|
|
command: python -m http.server 8000
|
|
```
|
|
</details>
|
|
|
|
---
|
|
|
|
## 🔍 Troubleshooting
|
|
|
|
**Problem: "Permission denied"**
|
|
*Lösung:* Hast du `sudo` vergessen? Oder bist du nicht in der `docker` Gruppe? (siehe Installation)
|
|
|
|
**Problem: "Port already in use"**
|
|
*Lösung:* Irgendwas blockiert den Port. `docker ps` checken, oder laufen alte Dienste nativ?
|
|
Ändere den Port in der Config (z.B. `"9999:80"`).
|
|
|
|
**Problem: Docker Desktop startet nicht**
|
|
*Lösung:* Neustart. Ernsthaft. Manchmal verschluckt sich der Wal an einem Apfel.
|
|
|
|
---
|
|
|
|
## 📚 Weiterführende Links
|
|
|
|
- [Docker Hub](https://hub.docker.com/) (Der Supermarkt für Images)
|
|
- [Compose File Reference](https://docs.docker.com/compose/compose-file/) (Die Bibel)
|
|
- [Portainer](https://www.portainer.io/) (Eine GUI für den Browser, wenn du kein Desktop hast)
|
|
|
|
---
|
|
|
|
## 💭 Reflexion
|
|
|
|
Container ändern alles.
|
|
Früher: "Installiere PHP, dann Apache, dann MySQL, oh Konflikt mit Version X..."
|
|
Heute: `docker compose up`.
|
|
|
|
Du hast jetzt die Macht, komplexe Software in Sekunden zu starten und wieder rückstandsfrei zu entfernen.
|
|
Nutze sie weise.
|
|
|
|
---
|
|
|
|
**Navigation:**
|
|
[← Zurück: Philosophie](crumbpage-23-ai-vektor-philosophie.md) | [Weiter: Postfix →](crumbpage-25-postfix.md)
|