3 Min. Lesezeit

Tailscale/Headscale

Ich habe jüngst Tailscale ausprobiert, gehört habe ich davon schon länger, es aber irgendwie immer ignoriert und ich war auch mit meinem Pangolinsetup beschäftigt.

Jetzt hatte ich mal Zeit und habe bei Tailscale vorbeigeschaut, habe mir da auch einen Probeaccount gemacht und gemerkt, dass es eigentlich ganz fluppig läuft und auch in meinem Setup sinnvoll einzusetzen ist.

Nun hat mich zum einen gestört, dass die keine Custom-Email zum Login erlauben, so musste ich meinen (verwaisten) Googleaccount ausgraben, was ich nicht mag und überhaupt, solch einen Server einer externen Firma einzusetzen, entspricht nicht meiner Philosophie.

Hier kommt also Headscale ins Spiel, macht im Prinzip das gleiche wie der Tailscaleserver. Auf jeden Fall für meinen simplen Einsatzzweck ... in einem Enterpriseunternehmen mögen die Anforderungen komplexer sein, aber für privat reicht der Funktionsumfang von Headscale allemal.

Was macht man mit Tailscale eigentlich ?

Tailscale spannt ein privates peer-to-peer Netz auf Basis von Wireguard zwischen allen beteiligten Rechnern auf, d.h. es macht VPN-Tunnel von jedem Knoten zu jedem anderen Knoten auf, damit ist die Kommunikation zwischen den einzelnen Knoten schon mal sicher, und ermöglicht dann die Kommunikation zwischen den beteiligten Knoten in einem eigenen Netzsegment. Somit können alle Rechner, die da mitmachen, untereinander sicher kommunizieren. Durch die spezielle Architektur kann man selbst Rechner hinter einer Firewall und/oder mit NAT oder CGNAT angebundene Rechner in das Netz einbinden und sie so erreichbar machen, ohne explizites Portforwarding machen zu müssen. Ich erhoffe mir damit, den letzten verbliebenen Potforward in mein Heimnetz ersparen zu können.

Durch ein internes DNS System kann man Namen für die einzelnen Knoten vergeben und sie so einfach ansprechen. Auch ssh soll einfacher möglich sein, d.h. das System verwaltet die privaten und öffentlichen Schlüssel, aber das habe ich noch nicht ausprobiert (meine Testrechner hatten sowieso schon Schlüssel ausgetauscht)

Installation

Den Headscaleserver installiert man am einfachsten über docker mit folgendem docker-compose.yml

services:
  headscale:
    container_name: headscale
    image: headscale/headscale:v0.26.0
    restart: unless-stopped
    ports:
      - '8080:8080'
      - '9090:9090'
    volumes:
      - './config:/etc/headscale'
      - './data:/var/lib/headscale'
    environment:
      TZ: 'Europe/Berlin'
    command: serve

Wie bei mir üblich, in einem Incuscontainer (apline) im Verzeichnis /opt/headscale.

Nun muss man noch hier default  eine Beispielkonfigurationsdatei herunterladen, sie in .config/config.yml abspeichern und wie folgt anpassen.

# The url clients will connect to (Anmerkung: hier natürlich eure Domain angeben)
server_url: https://headscale.frischux.de

# Address to listen to / bind to on the server
listen_addr: 0.0.0.0:8080

# Address to listen to /metrics
metrics_listen_addr: 0.0.0.0:9090

database:
  sqlite:
    write_ahead_log: true

policy:
    # The mode can be "file" or "database" that defines
    # where the ACL policies are stored and read from.

    # Allows ACLs to be managed in the Headplane interface
    mode: database 

    # If you want to manage the ACL rules via a file and not Headplane.
    path: "/etc/headscale/acl.hujson" 

 dns:
    magic_dns: true
    base_domain: fx.de # Domain, unter der ihr die Knoten ansprecht, diese hätte ich gerne in echt :-)
    override_local_dns: true
    nameservers:
      global:
        - 1.1.1.1 
        - 9.9.9.9

Man kann da natürlich noch viel mehr anpassen, aber so reicht es erst mal zum ausprobieren.

Dann mit 

docker compose up -d

starten und schon kann es losgehen.

Netzwerk aufbauen

Jeder Knoten muss erst einmal dem Server bekannt sein. Ich will also den Rechner test1 im Netz anmelden, dann geht das mit

docker exec headscale headscale users create test1

Jetzt auf dem Rechner test1 den Tailscaleclient installieren mit:

curl -fsSL https://tailscale.com/install.sh | sh

Wer sich unwohl fühlt, so ein Shellscript aus dem Netz zu installieren, kann es z.Bsp. in einem Debian auch händisch über hinzugefügte Reporitories und dann mit dem Paketmanager installieren, dazu gibt es für nahezu jedes Betriebssystem Anleitungen, das würden Rahmen hier sprengen.

Dann ein:

tailscale up --login-server https://headscale.frischux.de

Dann wird eine URL auf eurem Headscaleserver angezeigt, die dann das Registrierungskommando für den Server anzeigt:

headscale nodes register --key XXXXXXXXXXXXXX --user USERNAME

Hier steht tasächlich USERNAME und man muss das mit dem vorher auf dem Server angelegten User (also test1) ersetzen und ein docker exec ... davorsetzen, also:

docker exec headscale headscale nodes register --key XXXXXXXXXXXXXX --user test1

Wenn alles gut gegangen ist, ist nun der Rechner test1 unter dem Namen test1 registriert und hat eine IP-Adresse im privaten tailnet erhalten und ist ab sofort im ganzen tailnet unter dieser IP-Adresse oder eben mit dem Namen test1.fx.de erreichbar.

Sehr praktisch.

Mit 

tailscale status

kann man sich auf jedem Knoten die anderen Knoten anzeigen lassen.

Es gibt auch ein hübsches Frontend für den Server, das nennt sich Headplane (nicht das einzige, ich weiß, aber wohl das bekannteste/beliebteste), damit beschäftige ich mich in einem der nächsten Posts. Im Moment reicht mir die Kommandozeile.

Fazit

Wird tailscale jetzt pangolin ersetzen? Nein, ich werde einfach beides kombinieren, pangolin da, wo ich Services nach aussen ins Internet anbieten will. Wie z.Bsp. auch den Headlessserver selbst und Tailscale für die Kommunikation meiner Instanzen untereinander.

Patrick Frisch