Skip to content

Docker Tutorial fuer Anfaenger 2026 – Container verstehen

4. März 2026 Tutorial By MetinC

Docker Tutorial fuer Anfaenger 2026: Container-Grundlagen, Dockerfile schreiben, Docker Compose fuer Multi-Container-Apps. Praktische Beispiele Schritt fuer Schritt.

Einleitung

Docker hat die Art wie wir Software entwickeln und deployen revolutioniert. Container machen deine App ueberall lauffaehig – egal ob auf deinem Laptop, im CI/CD-System oder in der Cloud.

In diesem Tutorial lernst du Docker von Grund auf: Was sind Container? Wie schreibst du ein Dockerfile? Wie nutzt du Docker Compose fuer Multi-Container-Apps? Alles mit praktischen Beispielen.

Inhaltsverzeichnis

  1. Was ist Docker?
  2. Installation
  3. Erste Container starten
  4. Dockerfile schreiben
  5. Images bauen und verwalten
  6. Volumes & Persistenz
  7. Docker Networking
  8. Docker Compose
  9. Best Practices
  10. Naechste Schritte

1. Was ist Docker?

Somit kannst du direkt mit der Umsetzung beginnen.

Docker packt deine Anwendung zusammen mit allen Abhaengigkeiten in einen Container. Dieser Container laeuft ueberall identisch – kein „Works on my machine“ mehr.

  • Image: Die Vorlage (Bauplan) fuer einen Container
  • Container: Eine laufende Instanz eines Images
  • Dockerfile: Das Rezept zum Bauen eines Images
  • Registry: Speicherort fuer Images (Docker Hub, GitHub Container Registry)

Docker vs. Virtuelle Maschinen

Folglich profitierst du von einem besseren Verständnis dieser Konzepte.

EigenschaftDockerVM
Start-ZeitSekundenMinuten
SpeicherMBsGBs
OSTeilt Host-KernelEigenes OS
IsolationProzess-LevelHardware-Level
PerformanceNah an nativOverhead

2. Docker installieren

Windows & macOS

Im Grunde vereinfacht dieser Ansatz den gesamten Workflow erheblich.

Installiere Docker Desktop von docker.com. Enthaelt Docker Engine, CLI und Docker Compose.

Linux (Ubuntu)

Tatsächlich ist dieser Bereich besonders wichtig für Entwickler.

# Docker installieren
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Docker ohne sudo nutzen
sudo usermod -aG docker $USER

# Version pruefen
docker --version
docker compose version

Dementsprechend ist eine manuelle Überprüfung empfehlenswert.

3. Erste Container starten

Allerdings gibt es einige wichtige Unterschiede zu beachten.

# Hello World – teste ob Docker funktioniert
docker run hello-world

# Nginx Webserver starten
docker run -d -p 8080:80 --name mein-nginx nginx
# Oeffne http://localhost:8080 im Browser

# Laufende Container anzeigen
docker ps

# Alle Container anzeigen (auch gestoppte)
docker ps -a

# Container stoppen und entfernen
docker stop mein-nginx
docker rm mein-nginx

# In einen Container "reingehen"
docker run -it ubuntu bash
# Du bist jetzt in einem Ubuntu-Container!
# exit zum Verlassen

Folglich erhältst du mit diesem Ansatz deutlich bessere Resultate.

Wichtige Docker-Befehle

Natürlich gibt es dabei verschiedene Herangehensweisen.

# Images auflisten
docker images

# Image herunterladen
docker pull python:3.12

# Container-Logs anzeigen
docker logs mein-nginx

# Container-Details
docker inspect mein-nginx

# Alle gestoppten Container entfernen
docker container prune

# Alle ungenutzten Images entfernen
docker image prune -a

Natürlich solltest du den generierten Code vor dem Einsatz testen.

4. Dockerfile schreiben

Grundsätzlich gibt es dabei einige Punkte zu beachten.

Ein Dockerfile definiert wie dein Image gebaut wird. Hier ein Beispiel fuer eine Python Flask App:

# Dockerfile
FROM python:3.12-slim

# Arbeitsverzeichnis setzen
WORKDIR /app

# Dependencies zuerst kopieren (Docker Layer Caching)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# App-Code kopieren
COPY . .

# Port freigeben
EXPOSE 5000

# App starten
CMD ["python", "app.py"]

Und fuer eine Node.js Express App:

# Dockerfile
FROM node:20-alpine

WORKDIR /app

# Package Files zuerst (Caching!)
COPY package*.json ./
RUN npm ci --only=production

COPY . .

EXPOSE 3000

# Non-Root User (Security!)
USER node

CMD ["node", "server.js"]

Grundsätzlich kannst du diesen Prompt an deine Bedürfnisse anpassen.

Image bauen und starten

Dennoch solltest du einige Besonderheiten beachten.

# Image bauen
docker build -t meine-app:1.0 .

# Container starten
docker run -d -p 3000:3000 --name app meine-app:1.0

# Image taggen und pushen
docker tag meine-app:1.0 username/meine-app:1.0
docker push username/meine-app:1.0

Außerdem kannst du den Prompt für verschiedene Programmiersprachen anpassen.

5. Volumes – Daten persistent speichern

Darüber hinaus bietet dieser Abschnitt konkrete Beispiele und Tipps.

Container sind ephemeral – wenn du sie loeschst, sind die Daten weg. Volumes speichern Daten ausserhalb des Containers:

# Named Volume erstellen
docker volume create app-daten

# Container mit Volume starten
docker run -d \
  -v app-daten:/data \
  --name db \
  postgres:16

# Bind Mount (lokaler Ordner)
docker run -d \
  -v $(pwd)/src:/app/src \
  -p 3000:3000 \
  meine-app:1.0

# Volumes auflisten
docker volume ls

Dabei zeigt dieses Beispiel den grundlegenden Ansatz.

6. Docker Networking

Weiterhin ist es wichtig, die Grundlagen zu verstehen.

# Netzwerk erstellen
docker network create mein-netzwerk

# Container im gleichen Netzwerk
docker run -d --network mein-netzwerk --name api meine-api
docker run -d --network mein-netzwerk --name db postgres:16

# Container "api" kann jetzt "db" per Hostname erreichen:
# postgres://db:5432/mydb

7. Docker Compose – Multi-Container-Apps

Insbesondere für den Einstieg sind die folgenden Informationen hilfreich.

Docker Compose definiert Multi-Container-Apps in einer YAML-Datei. Hier ein komplettes Beispiel:

# docker-compose.yml
version: '3.8'

services:
  # Frontend (React)
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    depends_on:
      - api
    environment:
      - REACT_APP_API_URL=http://localhost:5000

  # Backend API (Python Flask)
  api:
    build: ./backend
    ports:
      - "5000:5000"
    depends_on:
      - db
      - redis
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
      - REDIS_URL=redis://redis:6379
    volumes:
      - ./backend:/app  # Hot Reload fuer Development

  # Datenbank
  db:
    image: postgres:16
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - postgres-data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  # Cache
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres-data:

Weiterhin ist es ratsam, die Ergebnisse immer kritisch zu prüfen.

Docker Compose Befehle

Ebenfalls relevant sind die praktischen Anwendungsbeispiele.

# Alle Services starten
docker compose up -d

# Logs anzeigen
docker compose logs -f

# Status anzeigen
docker compose ps

# Alle Services stoppen
docker compose down

# Stoppen und Volumes loeschen
docker compose down -v

# Nur einen Service neustarten
docker compose restart api

# Images neu bauen
docker compose build

Somit sparst du Zeit und erhältst qualitativ hochwertigeren Output.

8. Docker Best Practices

Ebenso wichtig ist es, die Best Practices zu kennen.

  • Kleine Base Images: Nutze -alpine oder -slim Varianten
  • Multi-Stage Builds: Zusätzlich trenne Build- und Runtime-Umgebung
  • Non-Root User: Ebenfalls fuehre Container nie als Root aus
  • Layer Caching: Besonders cOPY package.json VOR dem App-Code
  • .dockerignore: Schliesse node_modules, .git, .env aus
  • Health Checks: Definiere HEALTHCHECK im Dockerfile
  • Keine Secrets im Image: Nutze Environment Variables oder Docker Secrets

Multi-Stage Build Beispiel

Außerdem gibt es hilfreiche Tools, die dich dabei unterstützen.

# Stage 1: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Deshalb empfiehlt es sich, den Prompt schrittweise zu verfeinern.

Ergebnis: Ein winziges Nginx-Image mit nur den statischen Build-Dateien statt eines grossen Node.js-Images.

9. Naechste Schritte

Deshalb lohnt es sich, dieses Thema genauer zu betrachten.

Profi-Tipp: Nutze AI-Tools wie ChatGPT Plus um Dockerfiles und docker-compose.yml Dateien zu generieren. Beschreibe einfach deinen Tech-Stack und du bekommst eine optimierte Konfiguration.