git ist das meistgenutzte Versionsverwaltungssystem der Welt. Es protokolliert jede Änderung an Dateien, ermöglicht paralleles Arbeiten im Team und macht fehlerhafte Änderungen rückgängig. Ein Repository (Repo) ist der Ordner, in dem git den gesamten Verlauf speichert.

Erste Schritte: Repository anlegen

git init

Macht das aktuelle Verzeichnis zu einem git-Repository. Alternativ ein bestehendes Projekt kopieren: git clone https://github.com/benutzer/projekt.git.

Der Grundzyklus: Status, Staging, Commit

git status
git add datei.txt
git commit -m "Nachricht"

• git status — zeigt geänderte Dateien und den aktuellen Zustand
• git add — Dateien in die Staging-Area legen („vorbereiten"); git add . nimmt alle Änderungen
• git commit -m "..." — Änderungen mit Nachricht dauerhaft im Verlauf speichern
• git log --oneline — kompakte Liste aller Commits
• git diff — zeigt ungestagete Änderungen im Detail

Branches: parallele Entwicklungslinien

git branch feature
git checkout feature

Ein Branch ist eine eigene Arbeitskopie des Projekts. Neue Features entstehen auf eigenen Branches, ohne den Hauptzweig (main) zu stören. Komfortabler als das alte git checkout ist git switch feature (Branch wechseln) und git switch -c neu (Branch anlegen und wechseln).

Mit Remote-Repositories arbeiten

git push origin main
git pull

git push lädt lokale Commits auf den Server (z.B. GitHub), git pull holt Änderungen der anderen und führt sie zusammen. git fetch holt nur, ohne zusammenzuführen.

• git remote -v — zeigt die eingerichteten Remote-Adressen
• git merge branch — einen Branch in den aktuellen Zweig übernehmen
• git revert <commit> — einen Commit rückgängig machen, ohne die Geschichte umzuschreiben
• git reset --hard HEAD — alle uncommitteten Änderungen verwerfen (Vorsicht!)

Praxis-Tipp

Commits klein und verständlich halten, .gitignore für Build-Artefakte und Passwörter nutzen, und vor dem Pushen immer git status prüfen. Bei Konflikten zeigt git merge die betroffenen Dateien mit Markern (<<<<<<<), die man manuell auflöst.

Verwandte Grundlagen: ssh, scp und rsync und curl und wget.

docker verpackt Anwendungen samt aller Abhängigkeiten in sogenannte Container — leichtgewichtige, isolierte Umgebungen, die auf jedem System gleich laufen. Ein Image ist die Vorlage, ein Container die laufende Instanz davon.

Images und erste Container

docker pull nginx
docker run -d -p 8080:80 nginx

docker pull lädt ein Image aus der Docker Hub Registry. docker run startet daraus einen Container: -d (detached) im Hintergrund, -p 8080:80 leitet den Host-Port 8080 auf den Container-Port 80 um.

• docker images — alle lokal vorhandenen Images
• docker ps — laufende Container (-a auch gestoppte)
• docker stop <name> / docker start <name> — Container stoppen und wieder starten
• docker rm <name> — Container endgültig löschen
• docker rmi <image> — Image löschen

In Container hineinschauen

docker exec -it <name> bash

Öffnet eine Shell im laufenden Container (-it = interaktiv mit Terminal). Nützlich zum Debuggen. Logs zeigt docker logs <name>.

Docker Compose: mehrere Container definieren

docker compose up -d

Mit einer docker-compose.yml lassen sich mehrere Dienste (Webserver, Datenbank, Cache) zusammen definieren und mit einem Befehl starten. docker compose down stoppt alles, docker compose logs -f zeigt die Logs aller Dienste.

Praxis-Tipp

Container sind standardmäßig wegwerfbar — Daten gehören in Volumes: docker run -v mein_volume:/var/lib/mysql .... Mit docker system df sieht man, wie viel Speicher Images und Container belegen, und docker system prune entfernt ungenutzte Objekte.

Verwandte Grundlagen: Dienste mit systemctl verwalten und Prozesse mit ps, top und kill.

npm (Node Package Manager) und pip sind die Paketverwaltungen der beiden populärsten Programmier-Ökosysteme: npm für JavaScript/Node.js, pip für Python. Beide installieren fertige Bibliotheken, verwalten Abhängigkeiten und halten Projekte reproduzierbar.

npm: JavaScript-Bibliotheken installieren

npm init -y
npm install express

npm init erzeugt die package.json (Projektbeschreibung + Abhängigkeiten). npm install <paket> lädt das Paket in node_modules und trägt es in die package.json ein.

• npm install — installiert alle in package.json gelisteten Abhängigkeiten (im frisch geklonten Projekt)
• npm install -g <paket> — global installieren (z.B. CLI-Werkzeuge)
• npm uninstall <paket> — Paket entfernen
• npm run <skript> — Skript aus package.json ausführen (z.B. npm run dev)
• npm audit — Sicherheitslücken in Abhängigkeiten melden

pip: Python-Bibliotheken installieren

pip install requests
pip install -r requirements.txt

Die requirements.txt listet alle Abhängigkeiten eines Python-Projekts — mit pip install -r werden sie komplett installiert. Das Gegenstück zu package.json.

• pip install --upgrade <paket> — Paket aktualisieren
• pip uninstall <paket> — Paket entfernen
• pip freeze — alle installierten Pakete mit Versionsnummern anzeigen
• pip list — installierte Pakete auflisten
• pip show <paket> — Details zu einem Paket (Version, Abhängigkeiten, Homepage)

Virtuelle Umgebungen: Der saubere Weg in Python

python3 -m venv .venv
source .venv/bin/activate

Pip installiert standardmäßig systemweit — auf modernen Systemen (PEP 668) oft blockiert. Eine virtuelle Umgebung kapselt die Pakete pro Projekt: python3 -m venv .venv anlegen, dann aktivieren. Node.js löst dasselbe Problem projektlokal mit node_modules und package-lock.json (exakte Versionen).

Praxis-Tipp

Immer die Lock-Dateien versionieren (package-lock.json, alternativ pip freeze > requirements.txt), damit alle Teammitglieder exakt dieselben Versionen bekommen. Vor dem Deployment npm audit bzw. pip list --outdated laufen lassen.

Verwandte Grundlagen: git: Versionierung und Teamarbeit und YAML, TOML und JSON.

kubectl ist das Kommandozeilen-Werkzeug für Kubernetes (K8s), die Plattform zur Verwaltung von Container-Anwendungen im Cluster. Mit kubectl startet man Pods, skaliert Dienste, prüft Logs und behebt Probleme — alles über die Kubernetes-API.

Grundlagen: Cluster und Pods anzeigen

kubectl get nodes
kubectl get pods

kubectl get nodes listet die Maschinen (Nodes) des Clusters, kubectl get pods die laufenden Pods im aktuellen Namespace. Mit kubectl get all sieht man Pods, Dienste und Deployments auf einen Blick.

• kubectl get pods -A — Pods in allen Namespaces
• kubectl get services — die Dienste (Service) mit ihren Cluster-IPs
• kubectl get deployments — die Deployments (gewünschter Zustand der Anwendung)

Arbeit mit Deployments

kubectl create deployment nginx --image=nginx
kubectl scale deployment nginx --replicas=3

kubectl create deployment legt ein Deployment an — Kubernetes hält daraufhin immer die gewünschte Anzahl Replicas am Leben. kubectl scale erhöht oder verringert die Anzahl der Pods.

• kubectl rollout status deployment/nginx — Fortschritt eines Updates (Rollout) anzeigen
• kubectl rollout undo deployment/nginx — zum letzten funktionierenden Stand zurück
• kubectl set image deployment/nginx nginx=nginx:1.27 — Image eines Deployments aktualisieren

Mit Manifesten arbeiten (empfohlen)

kubectl apply -f deployment.yaml
kubectl delete -f deployment.yaml

Statt Befehle zu tippen, beschreibt man den gewünschten Zustand in einer YAML-Datei und übergibt sie an kubectl apply — genau wie bei terraform wird der Soll-Zustand deklarativ festgelegt. kubectl delete -f entfernt alle in der Datei beschriebenen Ressourcen.

Diagnose: Logs, Shell und Ports

kubectl logs <pod>
kubectl exec -it <pod> -- bash
kubectl port-forward <pod> 8080:80

• kubectl logs <pod> — die Ausgabe des Containers (Logs) anzeigen
• kubectl exec -it <pod> -- bash — eine Shell im laufenden Container öffnen (ähnlich docker exec)
• kubectl describe pod <pod> — Details und Ereignisse zu einem Pod, wichtig beim Debuggen
• kubectl port-forward <pod> 8080:80 — einen lokalen Port auf den Container weiterleiten

Context und Konfiguration

kubectl config get-contexts
kubectl config use-context mein-cluster

Ein Context bündelt Cluster, Benutzer und Namespace. Mit kubectl config use-context wechselt man zwischen mehreren Clustern (z.B. Entwicklung und Produktion).

Praxis-Tipp

Für die tägliche Arbeit: kubectl get pods -w beobachtet Pods live, kubectl delete pod <pod> startet einen Pod neu (das Deployment erzeugt automatisch einen neuen). Kubernetes-Ressourcen gehören in Git versioniert — dazu passen git-Befehle und die Grundlagen zu docker.