Zum Inhalt springen
Gespräch buchenBlueprint herunterladen
← Alle Folgen

Folge 3

Server (optional)

Das Video wird erst per Klick von YouTube (youtube-nocookie.com) geladen. Vorher werden keine Daten an YouTube übertragen. Datenschutzerklärung

In dieser Folge (≈ 90 Min. zum Umsetzen)

  • Einen eigenen Server, nur über dein privates Tailscale-Netz erreichbar.
  • Claude Code in einem abgeschotteten Container, ohne offene Ports.
  • Eine Session, die weiterläuft, gesteuert von deinem Handy.

Dein Schritt

Füge das vor dem Bestellen in Claude Code auf deinem Laptop ein. Claude geht die Checkliste mit dir durch und hält überall an, wo Geld oder deine Konten im Spiel sind.

Geh mit mir ~/ailoopwise-blueprint/course/examples/server-checklist.md durch, Punkt für Punkt und in dieser Reihenfolge. Ich bin kein Entwickler, erkläre jeden Punkt in einem einfachen Satz.
1. Zeig mir zu jedem Punkt den passenden Befehl oder Klickweg aus ~/ailoopwise-blueprint/course/03-server-optional.md und warte, bis ich dir das Ergebnis sage, bevor du weitermachst.
2. HALT vor allem, was Geld kostet oder in einem meiner Konten passiert (Server bestellen, Hetzner, Hostinger, Tailscale, GitHub). Sag mir, was ich dort selbst tun muss, und warte, bis ich sage, dass es erledigt ist.
3. Lass mich ufw erst einschalten, wenn der Login über die Tailscale-Adresse (100.x.y.z) klappt, sonst sperre ich mich aus.
4. Ändere selbst nichts, weder in diesem Ordner noch außerhalb. Befehle, die nur etwas anzeigen, darfst du auf diesem Rechner ausführen, nachdem du sie erklärt hast. Alles andere tippe ich selbst.
5. Öffne oder zeig nie den privaten Schlüssel ~/.ssh/id_ed25519 (weitergegeben wird nur die .pub-Datei), und zeig nie Passwörter, Tokens oder Login-Codes an.
6. Führ nie git commit oder git push aus, ohne dass ich darum bitte. Nenne mir zum Schluss die Punkte, die noch offen sind.

Dateien zu dieser Folge

Fragen zu dieser Folge? Eine kurze Mail genügt: hello@ailoopwise.com

Schritt-für-Schritt-Anleitung

Worum es in dieser Folge geht

Diese Folge ist ein Extra. Ist sie dir zu technisch, überspring sie. Die Folgen 4 bis 6 brauchen keinen Server.

Du mietest einen kleinen virtuellen Server (Hetzner oder Hostinger) und lässt Claude Code dort in einem abgeschotteten Docker-Container laufen. Tailscale macht den Server von außen unsichtbar. Auf dem Handy öffnest du Termius, hängst dich an eine tmux-Session, damit nichts abreißt, und mit /remote-control steuerst du die Session auch aus der Claude-App. Der Laptop kann zu bleiben.

Die Wand: Ein Server heißt auch Updates, Backups und Zugriffsrechte, dauerhaft, nicht einmalig.

Was du brauchst
Schritt für Schritt
  1. SSH-Schlüssel auf dem Laptop erzeugen (Enter für den Standardpfad, dann eine Passphrase setzen): 
    ssh-keygen -t ed25519 -C "laptop"
cat ~/.ssh/id_ed25519.pub
    Nur diese .pub-Zeile gibst du weiter. Die Datei ohne .pub bleibt auf dem Laptop.
  2. Server bestellen. Hetzner: im Projekt Servers → Add server, Image Ubuntu, Typ mit mindestens 4 GB RAM, unter SSH key die .pub-Zeile einfügen. Das geht bei Hetzner nur beim Anlegen (Anleitung). Hostinger: Schlüssel beim Einrichten oder später unter VPS → Manage → Settings → SSH keys (Anleitung). Kein Passwort-Login.
  3. Einloggen: ssh root@<öffentliche-IP>
  4. Tailscale auf dem Server: installieren nach https://tailscale.com/kb/1031/install-linux (Befehl von dort), dann: 
    sudo tailscale up
tailscale ip -4
    Öffne die angezeigte URL und melde dich mit demselben Konto an wie auf Laptop und Handy. Notiere die Adresse 100.x.y.z.
  5. Neu einloggen über Tailscale (exit, dann ssh root@100.x.y.z) und erst dann alles andere sperren (Schritte aus https://tailscale.com/kb/1077/secure-server-ubuntu): 
    sudo ufw allow in on tailscale0
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw enable
sudo ufw status verbose
    Test vom Laptop: ssh root@<öffentliche-IP> läuft ins Timeout, ssh root@100.x.y.z klappt.
  6. Docker nach https://docs.docker.com/engine/install/ubuntu/ installieren, dann tmux: sudo apt install tmux
  7. Container starten und jq hineinlegen (die Blueprint-Hooks brauchen es): 
    sudo docker run -dit --name claude-box --restart unless-stopped \
  --user node -w /home/node -v claude-home:/home/node node:22 bash
sudo docker exec -u root claude-box apt-get update
sudo docker exec -u root claude-box apt-get install -y jq
    Claude läuft dort als Nutzer node, nicht als root. Das Home-Verzeichnis liegt im Volume claude-home, Login und Projekte überstehen also einen Neustart. Kein -p: Kein Port des Containers ist von außen erreichbar.
  8. Blueprint auf den Server (erste Zeile auf dem Laptop, die anderen auf dem Server): 
    scp -r ~/ailoopwise-blueprint root@100.x.y.z:/root/
sudo docker cp /root/ailoopwise-blueprint claude-box:/home/node/
sudo docker exec -u root claude-box chown -R node:node /home/node/ailoopwise-blueprint
  9. tmux-Session öffnen und in den Container wechseln: 
    tmux new -As claude
sudo docker exec -it claude-box bash
    Installiere Claude Code im Container mit dem Linux-Befehl von https://code.claude.com/docs/de/setup und prüfe mit claude --version.
  10. Anmelden: claude starten. Auf dem Server öffnet sich kein Browser: Drücke c, öffne die kopierte URL auf Laptop oder Handy, melde dich an und füge den angezeigten Code bei Paste code here if prompted ein.
  11. Projekt einrichten wie in Folge 2, nur im Terminal: cd ~/ailoopwise-blueprint, claude, den Prompt aus Folge 2 einfügen. Danach cd ~/<dein-projekt> und claude. Den Vertrauensdialog bestätigst du einmal.
  12. Termius auf dem Handy: Keychain → Generate Key (Ed25519), Host anlegen mit 100.x.y.z, Nutzer root, diesem Schlüssel. Dann den Schlüssel per Export to host auf den Server bringen (Anleitung). Verbinden und: 
    tmux attach -t claude
  13. Remote Control einschalten, im Terminal auf dem Handy in der laufenden Session: 
    /remote-control
    Bestätige Enable Remote Control. In der Claude-App tippst du auf Code und findest die Sitzung mit Computer-Symbol und grünem Punkt.
  14. Loslassen: Ctrl+b, dann d trennt dich, Claude läuft weiter. Die Doku sagt dazu: „To keep a session running on a remote machine after you disconnect from SSH, start it inside tmux or screen.“ (Remote Control)

Sicherheit, ohne Ausnahme: SSH-Schlüssel statt Passwörter. Nach Schritt 5 ist Port 22 öffentlich zu. Veröffentliche keine Container-Ports: Mit -p freigegebene Ports umgehen ufw (Docker-Doku). Nie API-Schlüssel ins Image oder Dockerfile, nie ~/.ssh oder Cloud-Zugangsdaten in den Container mounten (Claude-Code-Doku). Solange Remote Control verbunden ist, liegt das Transkript der Sitzung auf Anthropics Servern; ausgeführt wird alles auf deinem Server.

Beispiel zum Kopieren

Die komplette Reihenfolge zum Abhaken: examples/server-checklist.md. Der Kern:

- [ ] ufw: `allow in on tailscale0`, eingehend alles andere gesperrt, aktiviert
- [ ] Container `claude-box` läuft als Nutzer `node`, ohne veröffentlichte Ports (`-p`)
- [ ] Kein API-Schlüssel im Image, keine `~/.ssh` oder Cloud-Zugangsdaten gemountet
Bevor du zur nächsten Folge gehst

Klapp den Laptop zu, verbinde dich per Termius, tippe tmux attach -t claude und sieh nach, ob deine Session noch läuft.

Wenn etwas hakt

Gratis per E-Mail

Neue Anleitungen ins Postfach, dazu das komplette Blueprint-Paket

Zu jedem neuen Video bekommst du die vollständige Anleitung mit dem fertig formulierten KI-Auftrag. Sobald du deine Adresse bestätigt hast, schicken wir dir als Erstes das komplette Blueprint-Paket.

Kostenlos. Abmeldung jederzeit.

Weiter: Folge 4 →
Folge 3: Server (optional) | Claude-Code-Kurs von AILoopwise