> ## Content Index > Fetch the complete content index at: https://cubem.de/llms.txt > Use this file to discover other available public pages before exploring further. # 05. Tailscale auf dem VPS: Admin-Zugang ohne offene Ports - URL: https://cubem.de/05-tailscale-auf-dem-vps-admin-zugang-ohne-offene-ports/ - Published: 2026-11-14T15:53:46.000Z - Updated: 2026-11-14T15:53:46.000Z - Description: Verwaltungsoberflächen gehören nicht ins offene Internet. Tailscale legt ein privates Netz über den Server, ohne dass dafür ein Port aufgeht – der Zugang für alles, was niemand außer dir sehen soll. - Author: martin - Tags: VPS Edition, Self-Hosting 2027, Infrastruktur, Tailscale, Sicherheit \*Stand: November 2026 Tailscale verbindet deine Geräte zu einem privaten Netzwerk, einem **VPN** (Virtual Private Network): Zwischen Laptop, Handy und Server liegt ein verschlüsselter Tunnel, und die Geräte verhalten sich, als hingen sie im selben lokalen Netz – egal, wo sie gerade stehen. In dieses Netz kommen nur Geräte, die mit deinem Konto angemeldet sind. Auf deinem Server gibt es bisher genau einen Eingang: Port 22 für SSH, öffentlich im Internet sichtbar. Durch Key-Authentifizierung sind Brute-Force-Angriffe chancenlos – aber sichtbar ist sichtbar. Für Admin-Werkzeuge wie Komodo, das in Artikel 06 folgt, reicht das nicht: Sie sollen nur für deine eigenen Geräte erreichbar sein. In diesem Artikel installieren wir Tailscale, leiten `ssh vps` durch das VPN – und schließen anschließend Port 22 im öffentlichen Internet. [ Neu in der Reihe? Hier geht's los ](https://cubem.de/self-hosting/) [ Hardware & Setup dieser Serie ](https://cubem.de/mein-setup) ## Am Ende hast du - Tailscale auf Server und Rechner, beide im selben privaten Netz – der Server heißt darin `vps` - `ssh vps` läuft über das VPN - Port 22 ist im öffentlichen Internet geschlossen - Server bleibt dauerhaft im Tailnet (Anmeldung läuft nicht ab) - Provider-Konsole als Notfallzugang getestet ## Voraussetzungen - Artikel 02 abgeschlossen: `ssh vps` funktioniert, UFW ist aktiv mit OpenSSH-Regel - Ein eigenes Konto bei GitHub, Google, Microsoft oder Apple – darüber meldest du dich bei Tailscale an (kostenlos) - Lokaler Rechner griffbereit – wir installieren auch dort > **Getestet mit:** Debian 13 · Tailscale 1.104.1 auf dem Server · Tailscale-App unter macOS > > **Zuletzt durchgespielt:** November 2026 ## 1\. Warum jetzt – bevor die Admin-Tools kommen? Admin-Oberflächen sind etwas anderes als normale Web-Anwendungen. Ein Blog darf gelesen werden. Eine Verwaltungsoberfläche, mit der jemand Container starten, stoppen oder löschen kann, darf das nicht – auch nicht hinter einem Login. Der Grund: Jedes Login-Formular im öffentlichen Internet wird permanent automatisiert getestet – mit Listen geleakter Passwörter, mit Brute-Force, mit ausgenutzten Bugs im Login-Mechanismus selbst. Bei einem öffentlichen Blog ist das egal. Bei einem Tool, das Container starten und löschen kann, ist es das Risiko nicht wert. Die Lösung: Admin-Werkzeuge sollen im öffentlichen Internet gar nicht erst sichtbar sein. Sie laufen ausschließlich in einem privaten Netzwerk, das nur deine eigenen Geräte sehen. Genau dieses Netzwerk bauen wir jetzt – **bevor** das erste Admin-Werkzeug überhaupt installiert ist. So entsteht kein Zeitraum, in dem etwas ungeschützt online steht. > **Hinweis zu den Zugriffsebenen** > > Welche Apps später über VPN, welche öffentlich mit 2FA und welche frei zugänglich laufen, ist in Artikel 01 im Detail beschrieben (die drei Zugriffsebenen 🔒 / 🔐 / 🌐). Dieser Artikel kümmert sich nur um die Grundlage: das VPN selbst. ## 2\. Warum Tailscale? Ein klassisches VPN selbst aufzusetzen ist möglich – mit WireGuard und etwas Konfiguration sogar relativ schlank. Was bei einem Einzelserver schnell mühsam wird, ist die Geräteverwaltung: jedes Mal Schlüssel verteilen, Port öffnen, Endpunkte konfigurieren, mit NAT umgehen. Tailscale nutzt unter der Haube WireGuard, nimmt dir aber genau diesen Verwaltungsaufwand ab: - Geräte authentifizieren sich über deinen Account (z. B. GitHub), nicht über manuell verteilte Schlüssel - NAT-Traversal funktioniert automatisch – kein Portforwarding nötig - Neue Geräte sind in wenigen Klicks Teil des Netzes Die kostenlose Variante deckt bis zu sechs Nutzer und beliebig viele Nutzergeräte ab – für einen Haushalt deutlich mehr als nötig. Die Verschlüsselung läuft Ende-zu-Ende; Tailscale selbst kann den Datenverkehr nicht mitlesen. Wenn du später lieber alles auf eigener Infrastruktur hosten willst (ohne den Tailscale-Koordinationsdienst): ein Bonus-Artikel zeigt den Umstieg auf Netbird. ## 3\. Tailscale-Account anlegen Bevor Geräte sich verbinden können, brauchst du ein Konto. 1. Öffne im Browser: [https://tailscale.com](https://tailscale.com/?ref=cubem.de) 2. Klicke auf **Get Started** 3. Melde dich mit einem bestehenden Konto an (z. B. GitHub oder Google) Das Konto dient ausschließlich der Zuordnung deiner Geräte. Der eigentliche VPN-Datenverkehr läuft direkt zwischen ihnen, nicht über Tailscale. **Nimm ein Konto, das dir selbst gehört.** Das private Netz – bei Tailscale heißt es **Tailnet** – gehört dauerhaft dem Konto, mit dem es angelegt wurde. Wer dieses Konto kontrolliert, ist Besitzer der Admin Console und kommt damit auf jedes Gerät im Netz. Das Konto eines Familienmitglieds ist dafür die falsche Grundlage: Ein Passwortwechsel oder ein gelöschtes Konto würde deinen Serverzugang mitnehmen. Weitere Personen bekommen später ihren eigenen Zugang, dazu Abschnitt 11. Nach der Anmeldung siehst du die Admin Console mit einer leeren Geräteliste. Hier tauchen gleich Server und Rechner auf. > ⚠️ **Dein VPN ist nur so sicher wie dein Login beim Identity Provider** > > Tailscale hat kein eigenes Passwort – die Anmeldung läuft komplett über deinen Identity Provider (IDP), also den Dienst, mit dem du dich oben angemeldet hast. Wer diesen Account übernimmt, kommt auch in dein Tailscale-Netz und damit auf jedes Gerät darin. > > Falls noch nicht geschehen: Richte beim IDP eine Zwei-Faktor-Anmeldung (2FA) ein. Konkrete Empfehlung: **2FAS Auth** – eine Open-Source-TOTP-App (iOS + Android, EU-Entwickler, kein Account-Zwang). Aegis (Android) oder Bitwarden Authenticator sind ebenfalls solide. ![](https://cubem.de/content/images/2026/11/01-tailscale-com.webp) ![](https://cubem.de/content/images/2026/11/02-tailscale-sign-up.webp) ![](https://cubem.de/content/images/2026/11/03-tailscale-sign-in-to-github.webp) ![](https://cubem.de/content/images/2026/11/04-tailscale-github-authorize-tailscale.webp) ![](https://cubem.de/content/images/2026/11/06-tailscale-connect-device.webp) ![](https://cubem.de/content/images/2026/11/07-tailscale-login-successful.webp) ![](https://cubem.de/content/images/2026/11/08-tailscale-machines.webp) ## 4\. Tailscale auf dem Server installieren Verbinde dich mit deinem VPS: ```bash ssh vps ``` Installiere Tailscale: ```bash curl -fsSL https://tailscale.com/install.sh | sh ``` Das Skript erkennt Debian 13 automatisch, fügt das Tailscale-Repository hinzu und installiert das Paket. Der Dienst `tailscaled` startet automatisch. **Check** *Ausgabe:* Es läuft einiges durch – Paketlisten, rund 40 MB Download, das Anlegen des Dienstes und je nach Serverzustand noch ein Block, der laufende Prozesse und Container auf veraltete Programmteile prüft. Entscheidend sind die letzten beiden Zeilen: ``` Installation complete! Log in to start using Tailscale by running: sudo tailscale up ``` ### Dem Netz beitreten Den Befehl, den das Skript vorschlägt, ergänzt du um zwei Angaben: ```bash sudo tailscale up --accept-dns=false --hostname=vps ``` Im Terminal erscheint eine Anmelde-URL. Öffne sie in deinem Browser, melde dich mit deinem Tailscale-Account an und bestätige, dass dieses Gerät dem Netzwerk beitreten darf. **Check** *Ausgabe:* Nach der Bestätigung im Browser meldet das Terminal `Success.` **`--hostname=vps`** legt fest, unter welchem Namen der Server im VPN erscheint. Ab Abschnitt 6 hängt `ssh vps` an genau diesem Namen, deshalb steht er hier ausdrücklich – auch wenn dein Server aus Artikel 02 ohnehin schon so heißt. > **Wozu `--accept-dns=false`?** Ohne diese Angabe übernimmt Tailscale die Namensauflösung des Servers und leitet sie über seinen eigenen Dienst. Auf deinem Rechner ist das erwünscht – dort willst du den Server über seinen Namen erreichen. Der Server braucht das nicht: Er wird angesprochen, er spricht niemanden im VPN an. Seine Container sollen ihre Namen weiter so auflösen wie bisher, ab Artikel 07 etwa beim Zertifikat für Caddy. Die VPN-IP des Servers anzeigen: ```bash tailscale ip -4 ``` **Check** *Ausgabe:* Eine Adresse aus dem Bereich `100.x.x.x` – das ist Tailscales privater Adressraum. Diese IP ist nur innerhalb deines Tailscale-Netzes erreichbar. **Notiere sie**, Artikel 06 braucht sie für Komodo. ## 5\. Tailscale auf deinem eigenen Rechner installieren Damit du deinen Server über das VPN erreichen kannst, braucht auch dein Computer Tailscale. **macOS oder Windows** 1. Lade die App von [https://tailscale.com/download](https://tailscale.com/download?ref=cubem.de) 2. Installiere und starte sie 3. Klicke auf **Connect** und melde dich mit demselben Account an **Linux** ```bash curl -fsSL https://tailscale.com/install.sh | sh sudo tailscale up ``` Wie beim Server bekommst du eine Anmelde-URL. Anders als dort lässt du die Namensauflösung hier bei Tailscale – genau darüber findet dein Rechner gleich den Namen `vps`. **Check** Unter **macOS und Windows** öffnest du das Tailscale-Symbol in der Menüleiste beziehungsweise im Infobereich der Taskleiste. Dort stehen die Geräte deines Netzes, und neben deinem Rechner muss jetzt `vps` auftauchen – mit der `100.x.x.x`\-Adresse aus Abschnitt 4. Unter **Linux** geht dasselbe im Terminal: ```bash tailscale status ``` ## 6\. Namen statt Zahlen: `ssh vps` über das VPN Tailscale gibt jedem Gerät im Netz einen Namen. Die Funktion heißt **MagicDNS**, und über sie zeigt `ssh vps` gleich auf den Server im VPN statt auf seine öffentliche Adresse. MagicDNS braucht zwei Schalter: **Im Netz:** In der Admin Console unter **DNS** muss **MagicDNS** aktiv sein. Für Konten ab Oktober 2022 ist es das von Anfang an; falls nicht, dort auf **Enable** klicken. ![](https://cubem.de/content/images/2026/11/09-tailscale-magic-dns-1.webp) **Auf deinem Rechner:** In der Tailscale-App muss **Use Tailscale DNS** eingeschaltet sein. Auf macOS und Windows ist es das ab Werk, unter Linux ebenso, solange du beim `tailscale up` nichts anderes angegeben hast. Auf deinem Rechner prüfen, nicht auf dem Server: ```bash ping vps ``` **Check** *Ausgabe:* Dieselbe `100.x.x.x`\-Adresse wie in Abschnitt 4 antwortet. ### Die SSH-Verbindung umstellen In Artikel 02 hast du in `~/.ssh/config` die öffentliche IP deines Servers eingetragen und angekündigt, dass sich an dieser Stelle nur eine Zeile ändert. Jetzt ist es so weit. Auf deinem lokalen Rechner: ```bash nano ~/.ssh/config ``` Die Zeile `HostName` bekommt statt der IP den Namen aus dem VPN: ``` Host vps HostName vps User martin IdentityFile ~/.ssh/id_ed25519_vps AddKeysToAgent yes UseKeychain yes ``` Das doppelte `vps` ist kein Versehen: Die erste Zeile ist der Name, den du beim `ssh`\-Befehl tippst, `HostName` ist die Adresse, die dahinter angewählt wird – jetzt der Name im VPN. Die beiden letzten Zeilen stehen seit Artikel 02 dort und bleiben unverändert; ohne sie fragt SSH wieder bei jeder Verbindung nach deiner Passphrase. Auf einem Rechner ohne macOS fehlt `UseKeychain` – dann bleibt es auch hier dabei. Speichern (**Ctrl+X**, dann **Y**). Läuft noch eine SSH-Sitzung von vorhin, beende sie mit `exit`: Die Datei wird nur beim Verbindungsaufbau gelesen, eine offene Verbindung läuft weiter wie bisher. Dann neu verbinden: ```bash ssh vps ``` Beim ersten Mal erscheint wieder die Host-Key-Abfrage aus Artikel 02 – derselbe Server, aber unter neuer Adresse. Mit `yes` bestätigen. **Check** Auf dem Server: ```bash echo $SSH_CONNECTION ``` *Ausgabe:* Die erste Adresse in der Zeile beginnt mit `100.` – das ist dein Rechner im VPN. Die Verbindung läuft also durch den Tunnel, nicht mehr über das offene Internet. Damit ist die VPN-Verbindung einsatzbereit. Jetzt fehlen noch zwei Schritte, damit der Server dauerhaft erreichbar bleibt – und Port 22 endgültig aus dem öffentlichen Internet verschwindet. ## 7\. Tailscale-Anmeldung des Servers dauerhaft gültig machen Wenn sich ein Gerät bei Tailscale anmeldet, bekommt es einen geräteeigenen Schlüssel – das ist Tailscales interne Anmeldung an deinem Tailnet (technisch ein WireGuard-Schlüssel). Wichtig: **Das hat nichts mit deinen SSH-Keys aus Artikel 02 zu tun.** Die SSH-Keys verschlüsseln den SSH-Login; der Tailscale-Schlüssel ist die VPN-Anmeldung des Geräts. Diese Tailscale-Anmeldung läuft standardmäßig nach 180 Tagen ab. Für einen Laptop ist das sinnvoll – ein verlorenes Gerät fällt automatisch aus dem Netz. Für einen Server, der dauerhaft erreichbar bleiben soll, ist es genau falsch herum: nach 180 Tagen wäre dein VPS plötzlich offline und müsste manuell neu angemeldet werden (über die Provider-Konsole). Für den Server schalten wir den Ablauf deshalb ab. In der Admin Console ([https://login.tailscale.com/admin/machines](https://login.tailscale.com/admin/machines?ref=cubem.de)): 1. Wähle `vps` aus der Geräteliste 2. Klicke rechts auf das Drei-Punkte-Menü (…) 3. Wähle **Disable key expiry** ![](https://cubem.de/content/images/2026/11/10-tailscale-disable-key-expiry.webp) ![](https://cubem.de/content/images/2026/11/11-tailscale-machines-expiry-disbaled.webp) **Check** In der Übersicht steht jetzt **Expiry disabled** neben dem Server. Für den lokalen Rechner lässt du den Ablauf an – wenn der Laptop mal verloren geht, soll er sich nicht ewig im Netz aufhalten. > **Hinweis** > > Diese Einstellung wirkt nur für das ausgewählte Gerät. Für jeden weiteren Server, den du später hinzufügst, machst du den gleichen Schritt. ## 8\. SSH auf das Tailscale-Netzwerk beschränken Jetzt der entscheidende Sicherheitsschritt: Port 22 verlässt das öffentliche Internet. SSH ist danach nur noch über das VPN erreichbar. > ⚠️ **Erst testen, dann scharf schalten** > > Bevor du die alte UFW-Regel entfernst, halte unbedingt eine **funktionierende SSH-Session über das VPN** in einem zweiten Terminal offen. Wenn etwas schiefgeht, hast du dort noch Zugang zum Server. Zweites Terminal öffnen, dort: ```bash ssh vps ``` Login klappt? Seit Abschnitt 6 läuft `ssh vps` über das VPN – diese Session hängt also nicht an Port 22 im Internet. Die folgenden Befehle führst du am besten direkt in ihr aus: ```bash # SSH (und alles andere) über Tailscale erlauben sudo ufw allow in on tailscale0 # Alte öffentliche SSH-Regel entfernen sudo ufw delete allow OpenSSH # Status prüfen sudo ufw status verbose ``` Die ersten beiden Befehle bestätigen jeweils mit `Rule added` beziehungsweise `Rule deleted`, dazu dieselbe Zeile noch einmal mit dem Zusatz `(v6)`. **Check** *Ausgabe:* ``` Status: active Logging: on (low) Default: deny (incoming), allow (outgoing), deny (routed) New profiles: skip To Action From -- ------ ---- Anywhere on tailscale0 ALLOW IN Anywhere Anywhere (v6) on tailscale0 ALLOW IN Anywhere (v6) ``` Kein `OpenSSH ALLOW IN Anywhere` mehr – Port 22 ist im öffentlichen Internet geschlossen. > **Was bedeutet `allow in on tailscale0`?** > > Tailscale legt beim Start ein eigenes Netzwerk-Interface namens `tailscale0` an. Die UFW-Regel erlaubt eingehenden Verkehr ausschließlich auf diesem Interface – also nur, wenn er aus dem VPN kommt. SSH und alles andere, was direkt auf dem Server läuft, ist über die öffentliche IP damit nicht mehr erreichbar. > > Für Container gilt das nicht. Docker trägt veröffentlichte Ports an UFW vorbei in die Firewall ein, die Regeln hier sehen sie gar nicht. Deshalb bindet Artikel 06 Komodo ausdrücklich an die Tailscale-Adresse, statt sich auf diese Regel zu verlassen. ## 9\. Plan B: Provider-Konsole als Notfallzugang Port 22 ist geschlossen, SSH läuft ausschließlich über Tailscale. Bleibt die Frage: **Was, wenn Tailscale ausfällt oder das lokale Setup kaputt geht?** **1\. Bestehende Verbindungen laufen direkt zwischen den Geräten.** Tailscale koordiniert nur den Verbindungsaufbau – der eigentliche Datenverkehr läuft P2P über WireGuard. Ein Tailscale-Outage (Koordinationsserver weg) trennt also keine laufenden Sessions. Was scheitern würde, sind **neue** Anmeldungen. **2\. Die Provider-Konsole bleibt immer erreichbar.** Jeder seriöse VPS-Anbieter bietet eine Web-Konsole (VNC oder KVM), die direkten Bildschirm-Zugriff gibt – komplett unabhängig vom Netzwerk-Setup auf dem Server. Das ist dein echter Notfallzugang. - **Netcup:** SCP → Server auswählen → VNC-Konsole - **Hetzner:** Cloud Console → Server → „Console" **Teste die Konsole einmal, bevor du sie wirklich brauchst.** Login funktioniert mit dem root-Passwort, das dir das Panel nach der Installation angezeigt hat (Artikel 02). Falls vergessen: Jeder Provider bietet ein Rescue-System, mit dem sich das root-Passwort zurücksetzen lässt – aber die fünf Minuten Vorbereitung sparen dir später Stress. > **Zugangsdaten an einem zweiten Ort ablegen** > > Die URL zur Provider-Konsole und das root-Passwort gehören in deinen Passwortmanager, wie in Artikel 02 – nicht auf den Server, der im Notfall gerade nicht erreichbar ist. ## 10\. Optional: Smartphone-Zugriff Tailscale gibt es als App für iOS und Android. Aus dem App Store installieren, mit demselben Account anmelden – fertig. Das Smartphone ist Teil deines Tailnets. Was du damit machen kannst: - Im mobilen Browser Admin-Interfaces öffnen (`http://vps:9120` für Komodo, sobald installiert) - Mit SSH-Apps wie Termius (iOS/Android) auf den Server zugreifen - Dienste von unterwegs verwalten, als wärst du zuhause Achte darauf, dass dein Smartphone selbst gut geschützt ist (PIN/Biometrie, aktuelle Updates). Die VPN-Verbindung ist nur so sicher wie das schwächste Gerät im Netz. ## 11\. Optional: Weitere Personen ins Netz aufnehmen Sobald die ersten Apps laufen, will meist noch jemand im Haushalt darauf zugreifen. Gib dafür weder dein eigenes Konto weiter noch lege ein zweites Tailnet an: Jede Person bekommt einen eigenen Zugang in **deinem** Netz. In der Admin Console unter **Users** eine Einladung an ihre Mailadresse schicken und dabei als Rolle **Member** wählen. Sie bekommt eine Mail mit einem Link, öffnet ihn im Browser und meldet sich dort mit einem Identity Provider ihrer Wahl an. Danach installiert sie die Tailscale-App auf ihren Geräten und meldet sich mit demselben Konto an – ab da erscheinen ihre Geräte in deiner Liste, unter ihrem Namen. Warum ein eigener Zugang statt deines Kontos: Du siehst, welches Gerät wem gehört, und kannst den Zugang einer einzelnen Person entziehen, ohne deinen eigenen anzufassen. Du bleibst Besitzer des Tailnets, sie wird Mitglied. Der Anbieter, den sie beim ersten Mal wählt, bleibt ihr Zugang: Meldet sie sich später über einen anderen an, ist das für Tailscale eine andere Person. Notiere im Passwortmanager, über welchen Dienst sie angemeldet ist. Eine nicht angenommene Einladung verfällt nach 30 Tagen. > ⚠️ **Standardmäßig darf jedes Gerät jedes andere erreichen** > > Mit der Einladung erreicht auch ihr Handy den VPS und damit Komodo. Solange du allein im Netz bist, ist die Voreinstellung in Ordnung; ab der zweiten Person brauchst du eine Zugriffsregel (ACL) in der Admin Console. Die kostenlose Variante erlaubt bis zu drei ACL-Gruppen. ## Wenn es nicht klappt | Was du siehst | Ursache | Weiter | | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------- | | Der Server heißt im Tailnet vps-1 statt vps | In der Geräteliste steht noch ein alter Eintrag namens vps, etwa vom Vorgängerserver | alten Eintrag in der Admin Console löschen, dann sudo tailscale up --hostname=vps erneut | | tailscale: command not found auf dem Mac | Die App bringt das Programm mit, legt es aber nicht in den Suchpfad | über das Symbol in der Menüleiste prüfen → Abschnitt 5 | | ping vps antwortet nicht | MagicDNS ist im Netz aus oder **Use Tailscale DNS** in der App | → Abschnitt 6, beide Schalter | | Nach der Umstellung auf HostName vps fragt SSH wieder nach der Passphrase | Beim Abtippen sind AddKeysToAgent und UseKeychain weggefallen | → Abschnitt 6, Block vollständig übernehmen | ## Und jetzt? Du hast jetzt ein privates Netzwerk zwischen deinen Geräten und dem Server. `ssh vps` läuft darüber, Port 22 ist im öffentlichen Internet geschlossen. Damit steht die Grundlage für alle Admin-Werkzeuge, die jetzt folgen. Im nächsten Artikel installieren wir Komodo – eine Web-Oberfläche für Docker, mit der du Stacks, Container und Konfigurationen bequem im Browser verwaltest, statt jedes Mal `docker compose ...` zu tippen. Komodo wird ausschließlich über das gerade eingerichtete Tailscale-Netz erreichbar sein. Kein offener Port, kein öffentliches Login-Formular. 👉 **Nächster Artikel:** 06\. Komodo: Docker-Container auf dem VPS im Browser verwalten