alexle135 Animiertes Logo
• 8 Min. Lesezeit

Docker Container einfach erklärt - Warum Container die IT vereinfachen

Was Docker-Container sind, warum jeder DevOps-Einsteiger sie kennen sollte und wie du in 15 Minuten deinen ersten Container startest

Docker Container einfach erklärt - Warum Container die IT vereinfachen

Warum dieser Beitrag?

Docker ist mittlerweile überall zu finden: In Stellenanzeigen, Tutorials und DevOps-Diskussionen. Als FISI-Umschüler kommst du schlichtweg nicht mehr drum herum.

Das Problem ist jedoch: Die meisten Erklärungen sind viel zu theoretisch.

Hier zeige ich dir, was Docker wirklich ist – ohne unnötige Buzzwords, dafür mit echten Praxisbeispielen.

Was ist Docker? (Ohne Fachchinesisch)

Die kurze Antwort: Docker verpackt deine App mit allem, was sie zum Laufen braucht, in einen sogenannten “Container”.

Die etwas längere Antwort: Stell dir vor, du entwickelst eine Webanwendung. Diese hat spezifische Anforderungen:

  • Sie braucht Python 3.11
  • Sie benötigt eine PostgreSQL-Datenbank
  • Sie ist auf bestimmte Python-Pakete angewiesen
  • Sie läuft eigentlich nur auf Linux

Ohne Docker: Du sagst: “Funktioniert auf meinem Laptop”. Aber auf dem Server passiert dann das: “Package not found”, “Python version mismatch”, “Database connection failed”. Das klassische “It works on my machine”-Problem.

Mit Docker: Alles (Python, Pakete, Datenbank) ist im Container verpackt. Das bedeutet: Es läuft überall exakt gleich – egal ob auf deinem Laptop, dem Server oder in der Cloud.

Container vs. Virtuelle Maschinen

Das wird oft verglichen, ist aber nicht dasselbe. Hier der Unterschied:

Virtuelle MaschineDocker Container
Startet in30-60 Sekunden1-2 Sekunden
Größe5-20 GB100-500 MB
RessourcenEigenes BetriebssystemTeilt Host-OS
IsolationKomplett isoliertProzess-Isolation
EinsatzKomplette UmgebungenEinzelne Apps

Beispiel:

  • VM: Ein ganzes Haus (mit Fundament, Wänden, Dach).
  • Container: Ein Zimmer (nutzt das Haus mit).

Warum Docker lernen?

1. Es ist Standard in der IT

Die Zahlen sprechen für sich:

  • 83% der Unternehmen nutzen Container (Stand 2025).
  • Docker steht in über 60% der DevOps-Stellenanzeigen.
  • Kubernetes (das auf Containern basiert) ist einer der Top-Skills 2025.

(Quelle: IT-Schulungen.com, DataCamp)

2. Entwicklung wird einfacher

Ohne Docker: Du musst auf deinem Laptop Python 3.11 installieren, PostgreSQL einrichten und alle Pakete manuell laden. Auf dem Server hast du dann vielleicht Python 3.9 und eine falsche Datenbank-Version – und schon bricht die App ab. Das führt zu stundenlanger Fehlersuche.

Mit Docker: Du führst einfach docker-compose up aus. Sowohl auf deinem Laptop als auch auf dem Server. Fertig. Es läuft.

3. Testen wird schneller

Szenario: Du willst eine App mit Python 3.11, 3.10 und 3.9 testen.

Ohne Docker: Du müsstest dreimal Python installieren, hin und her wechseln und hättest am Ende Chaos auf deinem System.

Mit Docker: Du startest einfach für jede Version einen Container:

docker run python:3.11 python app.py
docker run python:3.10 python app.py
docker run python:3.9 python app.py

Keine Installation nötig. Jeder Test ist komplett isoliert.

Die wichtigsten Docker-Begriffe

Image

Was ist das? Eine Vorlage für Container. Wie ein Bauplan oder Blueprint.

Beispiel: python:3.11 ist ein Image. Es enthält Python 3.11 und das nötige Betriebssystem (Linux).

Wo kommen Images her? Meistens von Docker Hub - das ist wie GitHub, nur für Container.

Container

Was ist das? Ein laufendes Image. Die tatsächliche, ausgeführte App.

Beispiel:

docker run python:3.11
# → Container startet
# → Python 3.11 läuft

Dockerfile

Was ist das? Das Rezept zum Bauen eines Images.

Beispiel:

FROM python:3.11
COPY app.py /app/
CMD ["python", "/app/app.py"]

Was passiert hier:

  1. Nimm das Python 3.11 Image als Basis.
  2. Kopiere app.py in den Container.
  3. Starte python app.py.

Docker Compose

Was ist das? Ein Tool zum Starten mehrerer Container gleichzeitig.

Beispiel: Deine App braucht eine Python-App (Container 1), eine PostgreSQL-Datenbank (Container 2) und einen Redis-Cache (Container 3).

Ohne Docker Compose: Du müsstest jeden Container einzeln starten (docker run app, docker run postgres, …) und sie manuell vernetzen.

Mit Docker Compose: Du definierst alles in einer Datei:

version: '3'
services:
  app:
    image: python:3.11
  db:
    image: postgres:16
  cache:
    image: redis:7

Und startest alles mit einem Befehl: docker-compose up. Alle Container starten und sind automatisch vernetzt.

Dein erster Docker-Container in 15 Minuten

Schritt 1: Docker installieren

Ubuntu/Debian:

sudo apt update
sudo apt install docker.io -y
sudo systemctl start docker
sudo systemctl enable docker

Prüfen:

docker --version

Du solltest eine Ausgabe wie Docker version 24.0.7 sehen.

Schritt 2: Ersten Container starten

docker run hello-world

Was passiert:

  1. Docker sucht das Image hello-world lokal.
  2. Falls nicht gefunden, lädt es das Image von Docker Hub.
  3. Es startet den Container.
  4. Der Container gibt eine Nachricht aus (“Hello from Docker!”).
  5. Der Container stoppt automatisch.

Schritt 3: Nginx-Webserver starten

docker run -d -p 8080:80 nginx

Was bedeutet das?

  • docker run: Starte Container
  • -d: Im Hintergrund (detached)
  • -p 8080:80: Leite Port 8080 (Host) auf Port 80 (Container) um
  • nginx: Der Name des Images

Prüfen: Öffne deinen Browser und gehe auf http://localhost:8080. Du solltest die “Welcome to nginx!” Seite sehen.

Schritt 4: Container verwalten

Laufende Container anzeigen:

docker ps

Container stoppen: Nimm die Container ID aus dem vorherigen Befehl und führe aus:

docker stop <CONTAINER_ID>

Container löschen:

docker rm <CONTAINER_ID>

Alle gestoppten Container aufräumen:

docker container prune

Praxisbeispiel: Python-App mit Datenbank

Die App (app.py)

from flask import Flask
import psycopg2

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello from Docker!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Das Dockerfile

FROM python:3.11-slim

WORKDIR /app

COPY app.py .
RUN pip install flask psycopg2-binary

CMD ["python", "app.py"]

Die docker-compose.yml

version: '3.8'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
    environment:
      DATABASE_URL: postgresql://user:pass@db:5432/mydb

  db:
    image: postgres:16
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: mydb
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Starten

docker-compose up

Was passiert: Docker baut das web-Image, startet die Datenbank und den Web-Container, vernetzt beide und macht die App auf Port 5000 verfügbar.

Häufige Fehler (die ich gemacht habe)

Fehler 1: “Permission denied”

Wenn du docker ps ausführst und einen Permission-Fehler bekommst: Lösung: Füge deinen User zur Docker-Gruppe hinzu:

sudo usermod -aG docker $USER

Danach musst du dich einmal ab- und wieder anmelden.

Fehler 2: Container läuft nicht

Du startest einen Container (docker run my-app), aber er stoppt sofort wieder. Ursache: Der Container hat nichts zu tun (kein dauerhafter Prozess). Lösung: Starte einen Webserver oder nutze -it für den interaktiven Modus.

Fehler 3: Port bereits belegt

Fehlermeldung: Error: port is already allocated. Lösung: Nutze einfach einen anderen Port auf deinem Host, z.B. 8081:

docker run -p 8081:80 nginx

Nützliche Docker-Befehle

BefehlWas es macht
docker psLaufende Container anzeigen
docker ps -aAlle Container (auch gestoppte) anzeigen
docker imagesAlle heruntergeladenen Images anzeigen
docker logs <container>Logs eines Containers anzeigen
docker exec -it <container> /bin/bashIn einen laufenden Container einsteigen
docker stop <container>Container stoppen
docker rm <container>Container löschen
docker rmi <image>Image löschen
docker system prune -aAlles aufräumen (Platz freigeben)

Docker vs. Kubernetes - Was ist der Unterschied?

Docker ist für einzelne Container auf einem Server gedacht und einfach zu lernen. Kubernetes hingegen ist für hunderte Container auf vielen Servern (Clustern) ausgelegt und deutlich komplexer.

Faustregel:

  • 1-10 Container: Docker Compose reicht völlig.
  • 10-100 Container: Docker Swarm (oder Kubernetes).
  • 100+ Container: Kubernetes.

Für Einsteiger gilt: Fang mit Docker an. Kubernetes kommt später.

Best Practices

  1. Nutze offizielle Images: Verwende FROM python:3.11-slim statt irgendwelcher User-Images.
  2. Halte Images klein: Nutze slim oder alpine Varianten, um Speicherplatz zu sparen.
  3. Eine App pro Container: Trenne Dienste. Web-App in einen Container, Datenbank in einen anderen.
  4. Nutze .dockerignore: Verhindere, dass unnötige Dateien (wie node_modules oder .git) im Image landen.

Fazit

Docker ist kein Hexenwerk.

Was Docker kann: ✅ Apps konsistent ausführen (überall gleich) ✅ Entwicklung vereinfachen ✅ Ressourcen sparen (im Vergleich zu VMs) ✅ Schnelles Testen ermöglichen

Was Docker nicht kann: ❌ Automatisch deine App optimieren ❌ Komplexität komplett eliminieren ❌ Alle Sicherheitsprobleme lösen

Mein Tipp: Fang einfach an. Installier Docker, starte ein paar Container und experimentiere.

Zeitaufwand: 1-2 Stunden Schwierigkeitsgrad: Anfänger Lohnt sich? Definitiv. Docker ist absoluter Standard.

Bei Fragen schreib mir gerne: schneider@alexle135.de

Quellen:

Das könnte dich auch interessieren

← Zurück zur Übersicht