1 Vier Geräte, vier Rollen

Was auf den Server gehört: alles, was ständig erreichbar sein muss, aber wenig rechnet. Koordination des VPN, ein Briefkasten für Aufträge und Dateien, eine Statusseite, Benachrichtigungen. Was nicht auf den Server gehört: Sprachmodelle, Rendern, Videoexport. Ein Server mit Grafikkarte kostet im Monat schnell so viel wie die Grafikkarte selbst.

2 Was geht wohin?

Ordne jede Aufgabe dem Gerät zu, das sie übernehmen sollte. Danach siehst Du die Begründung.

3 Wege zählen, bevor ein neuer dazukommt

Jeder Dienst, über den jemand von außen an Deinen PC kommt, ist ein Weg ins Heimnetz. Viele Haushalte haben mehr davon, als ihnen klar ist: eine Fernwartungs-App von früher, Windows-Remotedesktop, das VPN des Routers, das Tailnet aus Kurs 3. Kreuze an, was bei Dir läuft.

4 Was der Kurs nie tut

• Keine Portfreigabe im Router. Der PC zu Hause bleibt von außen unsichtbar. Alles läuft über Verbindungen, die von innen nach außen aufgebaut werden.
• Geräte, die nicht ins Netz gehören, bleiben ausgesperrt. Ein 3D-Drucker, eine Heizungssteuerung, eine Kamera: nicht im Tailnet, nicht auf dem Pult, nicht in einem Webhook. Wer heizen oder drucken kann, braucht jemanden daneben.
• Keine GPU-Volllast ohne Aufsicht. Ein Render-Auftrag aus der Ferne läuft nur mit einem Wächter, der bei zu hoher Temperatur oder zu langer Laufzeit abbricht, und nicht über Nacht in einem leeren Haus.

✓ Kurz geprüft

1 Rückweg zuerst

2 SSH nur mit Schlüssel

Wie Du einen Schlüssel erzeugst und auf den Server bringst, steht in SSH von Anfang an. Hier geht es nur noch darum, die Passwort-Anmeldung abzuschalten. Auf aktuellen Ubuntu-Versionen legst Du dafür eine eigene Datei an, statt die Hauptdatei zu bearbeiten:

PasswordAuthentication no
KbdInteractiveAuthentication no
PermitRootLogin prohibit-password

3 Firewall mit drei offenen Ports

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status verbose

Automatische Sicherheitsupdates: sudo apt install unattended-upgrades und sudo dpkg-reconfigure -plow unattended-upgrades. Auf vielen Ubuntu-Servern ist das schon aktiv; systemctl status unattended-upgrades zeigt es.

4 Die Falle: Docker umgeht ufw

Startest Du einen Container mit -p 8080:8080 oder ports: - "8080:8080", trägt Docker eigene Regeln in die Firewall des Systems ein, und zwar vor denen von ufw. Der Port ist dann aus dem Internet erreichbar, obwohl ufw status ihn nicht nennt. Probier es aus:

Die Regel daraus: Jeder Container bindet seine Ports an 127.0.0.1 (dann erreicht ihn nur der Reverse Proxy auf demselben Server) oder an die Tailnet-Adresse (Stufe 4). Dienste, die nur andere Container brauchen, bekommen gar keine ports:-Zeile.

5 Übung: von außen scannen

✓ Kurz geprüft

1 Was sich ändert und was nicht

2 Headscale starten

Headscale braucht eine eigene Subdomain mit TLS, etwa vpn.dein-server.example. Lege den DNS-Eintrag an, bevor Du startest.

services:
  headscale:
    image: headscale/headscale:<version>   # feste Version, z. B. die neueste stabile
    container_name: headscale
    command: serve
    restart: unless-stopped
    ports:
      - "127.0.0.1:8085:8080"   # nur für den Reverse Proxy
    volumes:
      - ./config:/etc/headscale
      - ./data:/var/lib/headscale

Die Konfigurationsdatei holst Du Dir als Vorlage aus dem Repository (config-example.yaml passend zu Deiner Version) und speicherst sie als config/config.yaml. Ändern musst Du nur wenige Zeilen:

server_url: https://vpn.dein-server.example
listen_addr: 0.0.0.0:8080

dns:
  magic_dns: true
  base_domain: heim.intern     # darf nicht die Domain von server_url sein

policy:
  mode: file
  path: /etc/headscale/acl.hujson

3 Die Regeln mitnehmen

Die ACL aus Kurs 3 ziehst Du in eine Datei auf dem Server um. Headscale versteht dasselbe Format wie Tailscale (HuJSON: JSON mit Kommentaren). So sieht die Fassung aus, die nur erlaubt, was die Reihe braucht:

{
  "tagOwners": {
    "tag:pc":     ["ich@"],
    "tag:server": ["ich@"],
    "tag:weck":   ["ich@"]
  },
  "acls": [
    // Mac und iPad (Benutzer ich) erreichen am PC: SSH, LM Studio, Moonlight
    { "action": "accept", "src": ["ich@"],
      "dst": ["tag:pc:22,1234,47984,47989,47998-48010"] },
    // Mac und iPad erreichen am Server: SSH und die Verwaltungsoberflächen (Stufe 4)
    { "action": "accept", "src": ["ich@"], "dst": ["tag:server:22,5678,8090"] },
    // Der Server darf den PC per SSH erreichen (Aufträge, Stufe 7) und den Weck-Knoten (Stufe 6)
    { "action": "accept", "src": ["tag:server"], "dst": ["tag:pc:22", "tag:weck:22"] }
  ]
}

4 Die Geräte umziehen

Jedes Gerät meldet sich einmal bei Tailscale ab und bei Headscale an. Fang mit dem Gerät an, an dem Du nicht gerade sitzt, damit Du die Verbindung zum Server behältst.

Die Seite, die sich beim Anmelden öffnet, zeigt einen Befehl der Form headscale nodes register … --key … bzw. headscale auth register …. Den führst Du auf dem Server mit docker exec headscale davor aus. Die genaue Form hängt von der Version ab; nimm die von der Seite.

5 Übung: alle im eigenen Tailnet

✓ Kurz geprüft

1 Zwei Arten von Diensten

Ein Dienst „nur im Tailnet“ bindet seinen Port an die Tailnet-Adresse des Servers statt an 0.0.0.0. Die Adresse zeigt tailscale ip -4 auf dem Server, z. B. 100.64.0.5.

    ports:
      - "100.64.0.5:5678:5678"   # vorher: "5678:5678" oder hinter dem öffentlichen Proxy

2 Übung: eine Oberfläche umziehen

✓ Kurz geprüft

1 Zwei Wege zum PC

Hauptweg in diesem Kurs ist das Tailnet. Den Rückkanal lernst Du trotzdem, weil er ohne VPN auskommt und sich auf den Port genau begrenzen lässt. Beispiel: Ein Container auf dem Server soll das Sprachmodell des PCs nutzen (LM Studio, Port 1234), und sonst nichts vom PC sehen.

2 Ein eigenes Konto ohne Shell

Auf dem Server legst Du ein Konto an, das nichts darf außer diesem einen Rückkanal. Der PC bekommt ein eigenes Schlüsselpaar dafür, nicht Deinen normalen Schlüssel.

restrict,port-forwarding,permitlisten="127.0.0.1:11234" ssh-ed25519 AAAA…Inhalt von rueckkanal.pub… rueckkanal@pc

3 Der PC öffnet den Kanal

ssh -N -i $HOME\.ssh\rueckkanal `
    -o ExitOnForwardFailure=yes -o ServerAliveInterval=15 -o ServerAliveCountMax=3 `
    -R 127.0.0.1:11234:127.0.0.1:1234 rueckkanal@dein-server.example

Damit der Kanal nach einem Neustart oder Abbruch wiederkommt, legst Du in der Windows-Aufgabenplanung eine Aufgabe an: Trigger „Bei Anmeldung“, Aktion ein kleines PowerShell-Skript, das den Befehl oben in einer Schleife mit 30 Sekunden Pause neu startet.

4 Übung: genau ein Dienst, genau ein Empfänger

✓ Kurz geprüft

1 Warum der Server nicht direkt wecken kann

Wake-on-LAN schickt ein Paket an die Broadcast-Adresse des Heimnetzes. Router leiten so etwas nicht ins Internet weiter, und auch das Tailnet transportiert keine Broadcasts. Wer wecken will, muss im selben Netz stehen wie der PC. Dafür gibt es zwei Wege:

Voraussetzung in beiden Fällen ist, was Kurs 3 in der Stufe „PC aufwecken“ eingerichtet hat: Wake-on-LAN im BIOS und im Netzwerkadapter eingeschaltet, Windows-Schnellstart aus.

2 Der Weck-Knoten

Statt AA:BB:CC:DD:EE:FF die MAC-Adresse der Netzwerkkarte des PCs (am PC: getmac /v, die Zeile mit dem Kabel-Adapter). Damit der Server nur wecken und sonst nichts tun darf, bekommt sein Schlüssel auf dem Weck-Knoten einen festen Befehl:

restrict,command="/usr/bin/wakeonlan AA:BB:CC:DD:EE:FF" ssh-ed25519 AAAA…Schlüssel des Servers… wecken@server

Auf dem Server weckst Du dann mit ssh -i ~/.ssh/wecken weck-knoten. Ob der PC wach ist, zeigt tailscale ping pc oder ssh pc echo wach.

3 Übung: über den Server wecken

✓ Kurz geprüft

1 Der Ablauf

2 Der Wächter auf dem PC

Der Wächter ist ein PowerShell-Skript im Übungsordner C:\Nordwerk. Er startet Blender ohne Oberfläche, beobachtet die Grafikkarte und bricht ab, wenn eine von drei Grenzen erreicht ist: Temperatur, Laufzeit oder eine Stopp-Datei, die das Pult anlegen kann (Stufe 10).

param([int]$MaxGrad = 83, [int]$MaxMinuten = 20)
$blender = 'C:\Program Files\Blender Foundation\Blender 5.2\blender.exe'
$stopp   = 'C:\Nordwerk\STOPP'
Remove-Item $stopp -ErrorAction SilentlyContinue
$liste = '-b', 'C:\Nordwerk\figur.blend', '-o', 'C:\Nordwerk\Sync\render\figur_####', '-F', 'PNG', '-f', '1'
$p = Start-Process -FilePath $blender -ArgumentList $liste -PassThru -WindowStyle Hidden
$start = Get-Date
while (-not $p.HasExited) {
  $grad = [int](nvidia-smi --query-gpu=temperature.gpu --format=csv,noheader,nounits)
  $min  = ((Get-Date) - $start).TotalMinutes
  if ($grad -ge $MaxGrad)   { Stop-Process -Id $p.Id -Force; "ABBRUCH Temperatur $grad Grad"; exit 2 }
  if ($min -gt $MaxMinuten) { Stop-Process -Id $p.Id -Force; "ABBRUCH Laufzeit"; exit 3 }
  if (Test-Path $stopp)     { Stop-Process -Id $p.Id -Force; "ABBRUCH Stopp-Datei"; exit 4 }
  Start-Sleep -Seconds 10
}
"FERTIG Exitcode $($p.ExitCode)"

3 Der Auftrag in n8n

Der Workflow besteht aus wenigen Knoten. Bau ihn im n8n-Editor (jetzt im Tailnet, Stufe 4) nach:

1. Webhook, Methode POST, Pfad figur-rendern, Authentifizierung Header Auth mit einem Zugang, dessen Name X-Pult-Token ist und dessen Wert eine lange Zufallszeichenkette (openssl rand -hex 32). Antwortmodus: sofort antworten („Auftrag angenommen“).
2. SSH (Befehl ausführen) auf dem Weck-Knoten, Zugang mit dem Weck-Schlüssel aus Stufe 6. Der Befehl ist egal, ausgeführt wird ohnehin wakeonlan.
3. Wait so lange wie Deine gemessene Aufwachzeit plus eine Minute.
4. SSH auf dem PC (Tailnet-Adresse, Benutzer und Schlüssel aus Kurs 3), Befehl: powershell -NoProfile -ExecutionPolicy Bypass -File C:\Nordwerk\waechter.ps1.
5. IF: Enthält die Ausgabe FERTIG? Ja → Nachricht „fertig“, nein → Nachricht mit dem Abbruchgrund (beides in Stufe 11).

curl -X POST -H "X-Pult-Token: $PULT_TOKEN" http://server:5678/webhook/figur-rendern

4 Übung: Render per Webhook

✓ Kurz geprüft

1 Das Problem aus Kurs 3

Du exportierst unterwegs die Nordwerk-Figur aus Nomad Sculpt und legst sie in den Sync-Ordner auf dem iPad bzw. dem Mac. Der PC zu Hause schläft. Klappst Du den Mac zu, bevor der PC aufwacht, liegt die Datei nirgends außer auf dem Mac. Mit dem Server als drittem Teilnehmer geht sie sofort dorthin, und der PC holt sie ab, sobald er wach ist.

Syncthing nennt das „nicht vertrauenswürdige Geräte“. Das Passwort für die Verschlüsselung kennen nur Mac und PC. Wird der Server übernommen, findet der Angreifer dort nur Datensalat.

2 Syncthing auf dem Server

services:
  syncthing:
    image: syncthing/syncthing:<version>   # feste Version von der Release-Seite
    container_name: syncthing
    restart: unless-stopped
    environment:
      - PUID=1000
      - PGID=1000
    ports:
      - "100.64.0.5:8384:8384"   # Oberfläche nur im Tailnet
      - "22000:22000/tcp"        # Abgleich
      - "22000:22000/udp"
    volumes:
      - ./daten:/var/syncthing

In der Oberfläche unter http://server:8384 zuerst unter „Aktionen → Einstellungen → GUI“ einen Benutzer und ein Passwort setzen.

3 Den Ordner verschlüsselt teilen

1. Auf dem Mac in Syncthing den Server als Gerät hinzufügen (Geräte-ID aus der Server-Oberfläche, „Aktionen → ID anzeigen“).
2. Beim Ordner „Nordwerk-Figur“ auf „Bearbeiten → Teilen“ gehen, den Server anhaken und im Feld daneben ein Verschlüsselungspasswort eintragen. Dieses Passwort gibst Du auf dem PC beim selben Ordner für den Server ebenfalls ein, genau gleich.
3. Auf dem Server erscheint die Anfrage, den Ordner anzunehmen. Als Ordnertyp „Verschlüsselt empfangen“ wählen.

4 Und das iPad?

Syncthing gibt es nicht von den Entwicklern für iPadOS. Zwei Wege, die Datei vom iPad in den Ordner zu bekommen:

5 Übung: abgeben, während der PC schläft

✓ Kurz geprüft

1 Was der Vermittler tut

RustDesk besteht aus zwei Server-Diensten: hbbs vermittelt (welche ID ist gerade wo erreichbar) und hbbr leitet weiter, wenn zwei Geräte nicht direkt zueinander finden. Die Sitzung selbst ist Ende-zu-Ende verschlüsselt; der Vermittler sieht nicht, was auf dem Bildschirm passiert.

2 hbbs und hbbr starten

services:
  hbbs:
    image: rustdesk/rustdesk-server:<version>
    command: hbbs -r 203.0.113.10:21117 -k _
    restart: unless-stopped
    ports:
      - "21115:21115"
      - "21116:21116"
      - "21116:21116/udp"
    volumes:
      - ./data:/root
    depends_on: [hbbr]
  hbbr:
    image: rustdesk/rustdesk-server:<version>
    command: hbbr -k _
    restart: unless-stopped
    ports:
      - "21117:21117"
    volumes:
      - ./data:/root

3 Die Geräte umstellen

In RustDesk auf PC, Mac und iPad unter Einstellungen → Netzwerk (am PC mit „Netzwerkeinstellungen entsperren“) eintragen: ID-Server und Relay-Server rd.dein-server.example (ein DNS-Eintrag auf die Server-IP), API-Server leer, Key der öffentliche Schlüssel aus id_ed25519.pub.

Am PC zusätzlich in den Sicherheitseinstellungen: Dateiübertragung und TCP-Tunnel aus, wenn Du sie nicht brauchst, und ein festes, langes Passwort für den unbeaufsichtigten Zugriff, oder besser gar keinen unbeaufsichtigten Zugriff.

4 Ein Weg weniger

Mit dem eigenen Vermittler brauchst Du eine Fernwartungs-App eines Anbieters nicht mehr. Deinstalliere sie, statt sie nur zu beenden: Viele starten als Dienst bei jedem Hochfahren. Prüfe danach im Weg-Zähler aus Stufe 1, wie viele Wege übrig sind.

✓ Kurz geprüft

1 Vier Tasten

Jeder Webhook bekommt einen eigenen Token. Wer den Token für „GPU-Status“ kennt, kann damit keinen Render starten.

powershell -NoProfile -Command "New-Item -ItemType File -Force C:\Nordwerk\STOPP | Out-Null; 'STOPP gesetzt'"

nvidia-smi --query-gpu=temperature.gpu,utilization.gpu,memory.used --format=csv,noheader

2 Die Tasten auf dem iPad

Das Pult-Programm aus Kurs 2 muss Webhooks aufrufen können. Wenn Deines das nicht kann, nimm die App Kurzbefehle, die auf jedem iPad ist:

1. Neuer Kurzbefehl, Aktion „Inhalte von URL abrufen“.
2. URL http://server:5678/webhook/pc-wecken, Methode POST, unter Header einen Eintrag X-Pult-Token mit dem Token.
3. Danach Aktion „Ergebnis anzeigen“, damit Du die Antwort siehst.
4. Kurzbefehl benennen, Symbol wählen, „Zum Home-Bildschirm“. Das wiederholst Du für die anderen drei Tasten.

3 Was nie aufs Pult kommt

• Nichts, was heizt, druckt oder bewegt. Kein Webhook startet einen 3D-Drucker, eine Heizung, eine Maschine. Ein Fehlklick in der Hosentasche darf nichts Gefährliches auslösen.
• Kein Webhook im öffentlichen Netz. Die Pult-Webhooks gehen nur über die Tailnet-Adresse. Ein Token schützt, aber ein Token, den niemand aus dem Internet erreicht, schützt besser.
• Kein „alles erlaubt“-Knoten. Kein Webhook, der einen beliebigen Befehl aus der Anfrage per SSH ausführt. Jede Taste hat einen festen Befehl.

4 Übung: vier Tasten von unterwegs

✓ Kurz geprüft

1 Die Statusseite

Die einfachste Statusseite ist ein weiterer n8n-Workflow: Ein Webhook mit Methode GET, der per SSH Temperatur und Last abfragt, den letzten Auftrag aus einer Data table liest und als kleine HTML-Seite zurückgibt. Er läuft auf der Tailnet-Adresse wie die Pult-Webhooks.

Auf dem iPad öffnest Du die Seite in Safari und wählst „Teilen → Zum Home-Bildschirm“. Dann liegt sie wie eine App neben dem Pult.

2 Nachrichten aufs iPad

Drei Ereignisse sollen sich von selbst melden: Render fertig, Render abgebrochen (mit Grund) und PC nicht wach geworden. Dafür brauchst Du einen Dienst, der Push-Nachrichten schickt. Zwei übliche Wege:

curl -d "Render fertig: figur_0001.png" https://ntfy.sh/dein-geheimes-thema-7f3a9c

3 Den Server selbst sichern

Auf dem Server liegen jetzt Dinge, deren Verlust weh tut: die Headscale-Datenbank (alle Geräte), der RustDesk-Schlüssel, die n8n-Workflows und Zugänge. Die Syncthing-Daten nicht, die sind auf Mac und PC vollständig.

#!/bin/sh
set -e
ziel=/root/sicherung/$(date +%F)
mkdir -p "$ziel"
tar czf "$ziel/headscale.tgz" -C /opt/headscale config data
tar czf "$ziel/rustdesk.tgz"  -C /opt/rustdesk data
# n8n: Export nach der Anleitung aus dem n8n-Kurs (Workflows, Zugänge, Volume, .env)
find /root/sicherung -maxdepth 1 -type d -mtime +14 -exec rm -rf {} +

4 Übung: Render mit Nachricht

✓ Kurz geprüft

1 Fehlerbilder

Ordne jedem Symptom die wahrscheinlichste Ursache zu.

2 Was es kostet

Preise ändern sich; die Tabelle nennt bewusst keine Beträge, die morgen falsch sind. Der größte Posten ist meist die Zeit für Updates.

3 Alles wieder schließen

Jede Stufe hatte ihren Rückweg. Hier gesammelt, in der richtigen Reihenfolge, falls Du das Viereck wieder abbauen willst:

1. n8n-Workflows für Pult, Aufträge und Status deaktivieren, Tokens löschen, Kurzbefehle auf dem iPad löschen.
2. Rückkanal: Aufgabe am PC löschen, Konto rueckkanal auf dem Server löschen.
3. Weck-Knoten: Schlüssel des Servers entfernen, Knoten aus dem Tailnet nehmen.
4. Syncthing: Server aus dem Ordner entfernen, Container stoppen, ufw-Regel 22000 löschen.
5. RustDesk: Clients zurückstellen oder deinstallieren, Container stoppen, ufw-Regeln 21115–21117 löschen.
6. Headscale: Geräte zurück zu Tailscale oder ganz abmelden, Container stoppen, Proxy- und DNS-Eintrag löschen.
7. Zum Schluss der Scan von außen.

4 Abschluss-Übung: der Scan von außen

5 Rückblick: vier Geräte

Damit ist die Mac-Reihe durch. Wer weiterbauen will: Der Kurs n8n zeigt Freigaben und Sicherungen genauer, Self-Hosting & VPS den Betrieb mehrerer Dienste auf einem Server.

✓ Kurz geprüft

⌨ Befehle

Kein Treffer. Anderes Wort probieren, z. B. „Port“ oder „PC“.

🔌 Ports

🩺 Fehlerbilder