KI Tutorials

Warum ein eigenes Homelab?

Cloud-Dienste sind bequem, aber ein eigener Server gibt dir volle Kontrolle über deine Daten, keine monatlichen Kosten und unbegrenzte Möglichkeiten zum Lernen. Mit Proxmox VE als Hypervisor kannst du mehrere virtuelle Maschinen auf einem einzigen Rechner betreiben — ideal für Entwicklung, Tests und Produktiv-Systeme.

Was du brauchst

Schritt 1: Proxmox VE installieren

1. Proxmox ISO von proxmox.com herunterladen
2. Mit Rufus (Windows) oder dd (Linux) auf USB-Stick schreiben
3. Vom USB-Stick booten, Installationsassistent durchlaufen
4. Nach dem Neustart: https://<IP>:8006 im Browser öffnen

# USB-Stick unter Linux erstellen
sudo dd if=proxmox-ve_9.1.iso of=/dev/sdX bs=4M status=progress
sync

Schritt 2: Ubuntu Server VM erstellen

1. Im Proxmox Web-UI: Create VM klicken
2. Ubuntu Server 24.04 ISO hochladen und auswählen
3. Ressourcen zuweisen: 4 CPU-Kerne, 8 GB RAM, 64 GB Disk
4. Netzwerk: vmbr0 (Bridge zum LAN)
5. VM starten, Ubuntu Server installieren (minimale Installation)

Schritt 3: Claude Code installieren

# Node.js installieren (v22 LTS)
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs

# Claude Code installieren
npm install -g @anthropic-ai/claude-code

# Starten und mit Anthropic-Konto verbinden
claude

Schritt 4: Tailscale für sicheren Remote-Zugriff

# Tailscale installieren
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

# Jetzt erreichbar über Tailscale-IP (100.x.x.x)
# Von überall sicher per SSH verbinden:
ssh user@100.x.x.x

Ergebnis

Du hast jetzt einen Proxmox-Server mit einer Ubuntu-VM, auf der Claude Code läuft. Du kannst von überall über Tailscale darauf zugreifen und KI-gestützt arbeiten — Code schreiben, Server verwalten, Deployments automatisieren.

Tipp: Erstelle regelmäßig Snapshots deiner VM in Proxmox, bevor du größere Änderungen vornimmst. So kannst du jederzeit zurückrollen.

Warum Absicherung Pflicht ist

Ein Server im Netzwerk wird sofort angegriffen. Automatisierte Bots scannen rund um die Uhr nach offenen Ports, Standard-Passwörtern und bekannten Schwachstellen. Ohne Absicherung ist es nur eine Frage der Zeit, bis jemand einbricht.

1. SSH absichern

SSH ist der Haupteingang zu deinem Server. Hier gelten strenge Regeln:

# /etc/ssh/sshd_config
PermitRootLogin prohibit-password
PasswordAuthentication no
PubkeyAuthentication yes
KbdInteractiveAuthentication no
AllowUsers dein-user
MaxAuthTries 3
LoginGraceTime 30

# Nur moderne Algorithmen
KexAlgorithms sntrup761x25519-sha512@openssh.com,curve25519-sha256
HostKeyAlgorithms ssh-ed25519
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com
MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com

# SSH-Key generieren (auf deinem Rechner)
ssh-keygen -t ed25519 -C "dein-name@server"

# Key auf den Server kopieren
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@server-ip

# Dienst neu starten
sudo systemctl restart sshd

2. Firewall mit UFW

Prinzip: Alles verbieten, nur Erlaubtes zulassen (Zero-Trust).

# UFW installieren und konfigurieren
sudo apt install ufw
sudo ufw default deny incoming
sudo ufw default deny outgoing

# Nur das Nötigste erlauben
sudo ufw allow in on tailscale0     # Tailscale-Traffic
sudo ufw allow out 443/tcp          # HTTPS
sudo ufw allow out 80/tcp           # HTTP
sudo ufw allow out 53               # DNS

# Aktivieren
sudo ufw enable
sudo ufw status verbose

3. Fail2ban gegen Brute-Force

# Fail2ban installieren
sudo apt install fail2ban

# Konfiguration erstellen
sudo tee /etc/fail2ban/jail.local <<EOF
[sshd]
enabled = true
port = ssh
filter = sshd
maxretry = 3
bantime = 3600
findtime = 600
EOF

sudo systemctl enable --now fail2ban

4. Monitoring mit Telegram-Alerts

Werde sofort benachrichtigt, wenn sich jemand einloggt oder ein Login fehlschlägt:

# Login-Benachrichtigung in /etc/profile.d/login-notify.sh
#!/bin/bash
TITLE="SSH Login"
MSG="User: $(whoami) | Host: $(hostname) | IP: $(echo $SSH_CLIENT | awk '{print $1}')"
curl -s "https://api.telegram.org/bot<TOKEN>/sendMessage" \
  -d "chat_id=<CHAT_ID>" \
  -d "text=$TITLE: $MSG" >/dev/null 2>&1

5. Claude Code als Security-Assistent

Mit Claude Code kannst du deine Sicherheitskonfiguration prüfen und verbessern lassen:

• Audit: „Prüfe meine sshd_config auf Schwachstellen“
• Firewall: „Zeige mir alle offenen Ports und ob sie nötig sind“
• Logs: „Analysiere /var/log/auth.log auf verdächtige Aktivitäten“
• Updates: „Prüfe ob Sicherheitsupdates ausstehen“

Nie blind Befehle ausführen, die du nicht verstehst — auch nicht von einer KI. Lies immer zuerst, was ein Befehl tut, bevor du ihn mit sudo ausführst.

Die Proxmox API

Proxmox VE bietet eine vollständige REST-API, die du per Kommandozeile oder Skript ansprechen kannst. Statt im Web-UI zu klicken, automatisierst du alles.

API-Token erstellen

1. Proxmox Web-UI → Datacenter → Permissions → API Tokens
2. Neuen Token erstellen (z.B. user@pve!claude-code)
3. Token-Secret sicher speichern

VM-Status abfragen

# Alle VMs auflisten
curl -s -k \
  -H "Authorization: PVEAPIToken=user@pve!token=SECRET" \
  "https://proxmox:8006/api2/json/nodes/pve/qemu" \
  | python3 -m json.tool

# Status einer einzelnen VM (VMID 100)
curl -s -k \
  -H "Authorization: PVEAPIToken=user@pve!token=SECRET" \
  "https://proxmox:8006/api2/json/nodes/pve/qemu/100/status/current"

Monitoring-Skript mit Claude Code

Lass dir ein Monitoring-Skript erstellen, das regelmäßig prüft:

#!/bin/bash
# monitor.sh - VM Health Check
API="https://proxmox:8006/api2/json"
TOKEN="PVEAPIToken=user@pve!token=SECRET"

for VMID in 100 103 108; do
  STATUS=$(curl -s -k -H "Authorization: $TOKEN" \
    "$API/nodes/pve/qemu/$VMID/status/current" \
    | python3 -c "import sys,json; print(json.load(sys.stdin)['data']['status'])")

  if [ "$STATUS" != "running" ]; then
    echo "WARNUNG: VM $VMID ist $STATUS!"
    # Telegram-Alert senden
  fi
done

Backup-Strategie

Automatischer Datenbank-Backup

#!/bin/bash
# backup.sh - Verschlüsselter DB-Backup
BACKUP_DIR="/opt/backups"
DATE=$(date +%Y-%m-%d_%H%M)
DB_NAME="meine_app"

# Dump erstellen und verschlüsseln
docker exec db-container pg_dump -U postgres $DB_NAME \
  | gzip \
  | openssl enc -aes-256-cbc -salt -pbkdf2 \
    -pass file:/opt/backups/.backup-key \
  > "$BACKUP_DIR/${DB_NAME}_${DATE}.sql.gz.enc"

# Alte Backups aufräumen (7 Tage behalten)
find "$BACKUP_DIR" -name "*.enc" -mtime +7 -delete

Backups sind nur nützlich, wenn du sie auch testest. Stelle mindestens einmal im Monat einen Backup wieder her und prüfe, ob die Daten vollständig sind.

Warum Docker?

Docker isoliert Anwendungen in Containern: Deine App läuft überall gleich — egal ob auf dem Entwicklungsrechner oder dem Produktiv-Server. Keine „bei mir funktioniert es aber“-Probleme mehr.

Dockerfile mit Claude Code erstellen

# Beispiel: Node.js-App
FROM node:22-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000
CMD ["node", "server/index.js"]

Docker Compose für App + Datenbank

# docker-compose.yml
services:
  app:
    build: .
    ports:
      - "127.0.0.1:3000:3000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:17-alpine
    ports:
      - "127.0.0.1:5433:5432"
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=myapp
    volumes:
      - pgdata:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  pgdata:

Multi-VM Deployment

Wenn dein Dev-Server und Prod-Server verschiedene VMs sind:

# 1. Auf dem Dev-Server bauen
docker build -t meine-app:latest .
docker save meine-app:latest | gzip > meine-app.tar.gz

# 2. Zum Prod-Server transferieren
scp meine-app.tar.gz user@prod-server:/tmp/

# 3. Auf dem Prod-Server laden und starten
ssh user@prod-server
docker load < /tmp/meine-app.tar.gz
cd /opt/meine-app
docker compose up -d

Cloudflare Tunnel für sichere Exposition

Statt Ports direkt zu öffnen, nutze einen Cloudflare Tunnel. Dein Server ist nie direkt aus dem Internet erreichbar.

# Cloudflare Tunnel installieren
curl -L --output cloudflared.deb \
  https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb
sudo dpkg -i cloudflared.deb

# Tunnel erstellen und konfigurieren
cloudflared tunnel login
cloudflared tunnel create mein-tunnel
cloudflared tunnel route dns mein-tunnel app.meine-domain.de

# Als Systemdienst installieren
sudo cloudflared service install

Container-Monitoring

# Health Check per Skript
#!/bin/bash
CONTAINER="meine-app"
if ! docker ps --format '{{.Names}}' | grep -q "^${CONTAINER}$"; then
  echo "$CONTAINER ist gestoppt! Starte neu..."
  cd /opt/meine-app && docker compose up -d
  # Telegram-Alert senden
fi

Verwende immer 127.0.0.1 statt 0.0.0.0 für Port-Bindings. So ist der Dienst nur lokal erreichbar — der Cloudflare Tunnel leitet den Traffic sicher weiter.