Erste Container starten

Zeit, Docker wirklich zu nutzen. Wir starten Container, schauen rein, stoppen sie und lernen Ports und Volumes kennen.

docker run - der Alleskoenner

docker run hello-world

Was passiert:

1. Docker sucht das Image hello-world lokal
2. Wenn nicht vorhanden: laedt es aus Docker Hub
3. Startet einen Container daraus
4. Container laeuft (gibt “Hello from Docker!” aus) und endet

Ein Container, der nicht sofort endet

docker run -it ubuntu bash

• -i interactive (stdin offen)
• -t tty (ein “richtiges” Terminal)
• bash als Kommando

Du landest in einer Ubuntu-Shell:

root@d8f4e3:/# cat /etc/os-release
PRETTY_NAME="Ubuntu 24.04 LTS"
...
root@d8f4e3:/# exit

exit beendet die Shell und den Container.

Container im Hintergrund

docker run -d --name web nginx

• -d detached - laeuft im Hintergrund
• --name web gibt einen lesbaren Namen

Pruefen:

docker ps
# CONTAINER ID   IMAGE   COMMAND   STATUS   PORTS   NAMES
# 1a2b3c         nginx   ...       Up ...           web

Port-Mapping

Ein Container hat ein eigenes Netzwerk. Damit du vom Host zugreifen kannst, mappst du Ports:

docker run -d -p 8080:80 --name web nginx

• -p 8080:80 - Host-Port 8080 → Container-Port 80

Im Browser: http://localhost:8080 - du siehst die NGINX-Willkommens-Seite.

Kurz: -p HOST:CONTAINER

• -p 3000:3000 - gleicher Port
• -p 0.0.0.0:3000:3000 - an alle Interfaces binden
• -p 127.0.0.1:3000:3000 - nur an Localhost binden (sicherer)

Environment-Variablen

Viele Images konfigurierst du ueber Env-Variablen:

docker run -d \
  --name postgres \
  -e POSTGRES_PASSWORD=secret \
  -e POSTGRES_DB=mein_projekt \
  -p 5432:5432 \
  postgres:16

Test:

docker exec -it postgres psql -U postgres -d mein_projekt

Tipp: Eine laufende Postgres fuer Entwicklung - in drei Zeilen.

docker exec - in einen Container rein

docker exec -it web bash

Du bist in der Shell des laufenden web-Containers. exit verlaesst sie - Container laeuft weiter.

exec ist dein Debug-Freund: Logs, Konfig pruefen, schnell etwas testen.

Logs ansehen

docker logs web
docker logs -f web          # follow (wie tail -f)
docker logs --tail 50 web   # letzte 50 Zeilen

Alles, was der Container auf stdout/stderr schreibt, landet hier.

Stoppen und loeschen

docker stop web          # stoppt, Container bleibt erhalten
docker start web         # startet wieder
docker restart web
docker rm web            # loescht (nur wenn gestoppt)
docker rm -f web         # force: stoppen + loeschen

Tipp: --rm beim run loescht automatisch nach Ende:

docker run --rm -it ubuntu bash
# nach exit ist der Container weg

Ideal fuer einmalige Tests.

docker ps im Detail

docker ps              # laufende Container
docker ps -a           # alle (auch gestoppte)
docker ps -q           # nur IDs
docker ps --filter name=web

Container pruefen und kontrollieren

docker stats             # CPU, Memory live
docker inspect web       # komplette Config als JSON
docker top web           # laufende Prozesse im Container

Images verwalten

docker images            # lokale Images listen
docker pull ubuntu:24.04 # Image holen ohne zu starten
docker rmi ubuntu:22.04  # Image loeschen

Image-Tags

Ein Image hat Name und Tag:

• nginx = nginx:latest (immer die aktuellste Version)
• nginx:1.27-alpine = spezifische Version, Alpine-basiert
• node:22-slim = Node 22, schlanke Variante

Wichtig fuer Produktion: Nimm konkrete Tags, keine latest - sonst deployst du plotzlich andere Versionen.

Volumes - Daten persistieren

Ein Container ist eph(emer - Daten sind weg, wenn er weg ist. Mit Volumes bleiben Daten erhalten.

Bind Mount

Host-Ordner im Container:

docker run -d \
  --name web \
  -p 8080:80 \
  -v $(pwd)/html:/usr/share/nginx/html \
  nginx

Dateien in ./html sind im Container unter /usr/share/nginx/html sichtbar.

Named Volume

Docker verwaltet den Ordner:

docker run -d \
  --name postgres \
  -v postgres-data:/var/lib/postgresql/data \
  -e POSTGRES_PASSWORD=secret \
  postgres:16

Das Volume postgres-data bleibt, auch wenn der Container weg ist. Verwaltung:

docker volume ls
docker volume inspect postgres-data
docker volume rm postgres-data

Interaktiver Kurz-Test

Ein Beispiel, das alle Konzepte vereint:

# Postgres starten
docker run -d \
  --name pg \
  -e POSTGRES_PASSWORD=secret \
  -p 5432:5432 \
  -v pg-data:/var/lib/postgresql/data \
  postgres:16

# Log pruefen
docker logs pg

# In den Container rein
docker exec -it pg psql -U postgres

# In psql:
CREATE TABLE users (id int, name text);
INSERT INTO users VALUES (1, 'Anna');
\q

# Container stoppen und loeschen
docker rm -f pg

# Volume existiert noch - wir starten neu und pruefen
docker run -d \
  --name pg \
  -e POSTGRES_PASSWORD=secret \
  -p 5432:5432 \
  -v pg-data:/var/lib/postgresql/data \
  postgres:16

docker exec -it pg psql -U postgres
SELECT * FROM users;    # Anna ist noch da!

Aufraeumen

Nach einer Zeit sammeln sich Container, Images und Volumes an:

# Alle gestoppten Container loeschen
docker container prune

# Ungenutzte Images
docker image prune
docker image prune -a   # auch benutzte Tags

# Ungenutzte Volumes
docker volume prune

# Alles mit einem Schlag
docker system prune -a --volumes

Vorsicht mit der letzten - sie raeumt alles weg, was gerade nicht benutzt wird.

Haeufige Fehler

Port schon belegt

Error: bind: address already in use

Ein anderer Prozess belegt Port 80/8080. Loesung: anderen Port nehmen oder lsof -i :8080 / netstat -an | grep 8080 zum Finden.

Berechtigung abgelehnt

Got permission denied while trying to connect to the Docker daemon socket

Du bist nicht in der docker-Gruppe. Linux-Loesung:

sudo usermod -aG docker $USER
newgrp docker

Zusammenfassung

• docker run startet Container, mit -d im Hintergrund
• -p HOST:CONTAINER mappt Ports
• -e KEY=VALUE fuer Environment-Variablen
• -v host:container oder -v name:path fuer Volumes
• docker exec -it <name> bash in einen laufenden Container
• docker logs -f fuer Logs
• docker system prune zum Aufraeumen

Im naechsten Kapitel: Eigene Images mit einem Dockerfile bauen.