# Docker

## Was ist Docker

**Docker** ist ein Tool, um eine Anwendung zusammen mit allem, was sie zum Ausführen benötigt (Code, Bibliotheken, Einstellungen), in einer einzigen Einheit namens **Container** zu verpacken.

Ein Container läuft immer auf die gleiche Weise, egal ob auf Ihrem Laptop, dem Rechner eines Teamkollegen oder einem Server in der Cloud. Dies löst das klassische „Auf meinem Rechner funktioniert es“-Problem.

Sie steuern Docker über das Terminal mit dem `docker`-Befehl.

Um zu prüfen, ob Docker verfügbar ist und um die Version anzuzeigen, führen Sie folgenden Befehl aus:

```bash
docker --version
```

Dies gibt die installierte Docker-Version aus und bestätigt, dass das Tool einsatzbereit ist.

## Images und Container

Docker hat zwei Kernkonzepte, die zusammenarbeiten: **Images** und **Container**.

Ein **Image** ist eine schreibgeschützte Vorlage (ein Snapshot eines Dateisystems plus Anweisungen dazu, was ausgeführt werden soll). <mark>Ein **Container** ist eine laufende Instanz</mark>, die aus einem Image erstellt wurde. Ein Image kann viele Container starten, so wie eine Klasse viele Objekte erstellen kann.

Der einfachste Weg, dies zu sehen, besteht darin, einen Container aus dem `hello-world` Image auszuführen:

```bash
docker run hello-world
```

Docker nimmt das `hello-world` Image, startet einen Container daraus, und der Container gibt eine kurze Willkommensnachricht aus, bevor er beendet wird.

## Images pullen

Bevor Sie einen Container ausführen können, benötigt Docker das Image auf Ihrem Rechner. Der Befehl `docker pull` lädt ein Image aus einer Registry (einer öffentlichen Bibliothek von Images) herunter:

```bash
docker pull alpine
```

Docker ruft das Image ab und meldet jede Ebene, sobald sie eintrifft, und schließt mit einer Statuszeile ab. Wenn Sie keine Version angeben, lädt Docker standardmäßig den Tag **latest** herunter.

Sie können eine spezifische Version mit `image:tag` anfordern:

```bash
docker pull alpine:3.20
```

Das Pulling eines bereits vorhandenen Images bestätigt <mark>lediglich</mark>, dass es <mark>aktuell</mark> ist, anstatt es erneut herunterzuladen.

## Images auflisten

Um zu sehen, welche Images lokal verfügbar sind, verwendet man `docker images`:

```bash
docker images
```

Die Ausgabe ist eine Tabelle mit einer Zeile pro Image:

```bash
REPOSITORY   TAG       IMAGE ID       CREATED       SIZE
alpine       latest    c8be21c88f2a   1 day ago     7.34MB
ubuntu       latest    75afc20638b6   4 days ago    81.8MB
```

- **REPOSITORY** und **TAG** benennen das Image
- **IMAGE ID** ist eine kurze eindeutige Kennung
- **SIZE** gibt an, wie viel Speicherplatz das Image belegt

Um die Liste auf ein Repository einzugrenzen, übergibt man dessen Namen: 

`docker images alpine` zeigt nur die `alpine`-Tags an.

## Images taggen

Ein **Tag** ist eine benutzerfreundliche Bezeichnung, die auf ein Image verweist. Der Befehl `docker tag` gibt einem bestehenden Image einen zusätzlichen Namen:

```bash
docker tag alpine:3.21 myalpine:v1
```

Dies kopiert das Image nicht. Es erstellt einen neuen Namen, `myalpine:v1`, der auf dasselbe zugrunde liegende Image verweist wie `alpine:3.21`. Beide erscheinen nun in `docker images`.

Das Format ist `docker tag SOURCE:TAG TARGET:TAG`. Mit Tags geben Sie Ihren eigenen Builds aussagekräftige Versionsnamen wie `v1`, `dev` oder `stable`.

## Einen Befehl ausführen

Man kann einem Container genau sagen, welcher Befehl ausgeführt werden soll, indem man ihn nach dem Imagenamen hinzufügt:

```bash
docker run alpine echo "hello from a container"
```

Docker startet einen Container aus dem `alpine`-Image, führt darin `echo "hello from a container"` aus, gibt die Ausgabe aus und beendet anschließend den Container. Die Struktur lautet:

```bash
docker run IMAGE COMMAND [ARGUMENTS]
```

Dies ist das alltägliche Muster für die Verwendung eines Containers als Wegwerfumgebung: Starten, ausführen eines Befehls und stoppen.

### Echte Ausführung

Befehle innerhalb eines Containers werden tatsächlich ausgeführt und nicht nur als vorgetäuschte Ausgabe wiedergegeben. Du kannst das beweisen, indem du dem Container eine Shell und ein kleines Skript übergibst:

```bash
docker run alpine sh -c "echo abc | tr a-z A-Z"
docker run alpine sh -c "seq 3"
```

Hier führt `sh -c` eine Shell-Befehlszeichenfolge innerhalb des Containers aus. Die Shell leitet `abc` an `tr` weiter, was es in Großbuchstaben umwandelt, sodass die Ausgabe `ABC` ist.

Das bedeutet, dass Sie Pipes, Variablen und die Befehlszeilenwerkzeuge, die Sie bereits kennen, direkt im Container verwenden können.