Zum Inhalt springen
wavemesh

Selbst betreiben

wave-mesh installieren

Ein Wave besteht aus einem Control-Server mit Relay und Datenbank, die du im eigenen Kubernetes-Cluster betreibst, und dem Client auf jedem Gerät. Diese Anleitung führt durch beides.

Downloads

Aktuelle Releases

Wähle eine Version und lade das Paket für dein System direkt von GitHub herunter.

Synology DSM 7

Für eine DiskStation lädst du oben das passende `.spk` herunter. Die DS920+ braucht Intel/AMD (`x86_64`); bei anderen Modellen richtet sich die Wahl nach der CPU.

  1. Im Paketzentrum unter „Manuelle Installation“ das .spk auswählen und wave starten.
  2. Einmal unter Systemsteuerung → Aufgabenplaner eine benutzerdefinierte Aufgabe als root anlegen, /var/packages/wave/scripts/setup eintragen, ausführen und die Aufgabe danach löschen.
  3. wave im DSM-Hauptmenü öffnen, die Control-Server-Adresse eingeben und die DiskStation über den angezeigten Link freigeben.

Nach einem Paket-Upgrade den Setup-Schritt erneut ausführen, damit der laufende Dienst das neue Binary verwendet.

Vollständige DSM-Anleitung auf GitHub

Schnellstart

In drei Schritten zum ersten Wave

Den Quellcode und die Kubernetes-Overlays findest du auf GitHub.

  1. 1. Server einrichtenProdukt-Repository klonen, Kubernetes-Overlay anpassen und Control-Server, Relay und Datenbank starten.
  2. 2. Client installierenPassendes Archiv oben herunterladen, entpacken und den Dienst installieren.
  3. 3. Gerät verbindenMit deinem Control-Server anmelden und den Wave aktivieren.
  1. Voraussetzungen

    Ein Kubernetes-Cluster; ein einzelner Server mit k3s genügt. Der Cluster braucht einen Ingress-Controller mit TLS und eine öffentliche IP-Adresse, die UDP auf Port 3478 für STUN annimmt.

    Zwei Namen für den Control-Server und das Relay, etwa control.example.com und relay.example.com.

    Optional eine DNS-Zone, die dir gehört, für Gerätenamen und Zertifikate. Unterstützt sind Cloudflare, Hetzner, IONOS und INWX; ohne Zugangsdaten geht es auch, dann legst du TXT-Records selbst an.

  2. Control-Server, Relay und Datenbank

    Kopiere das Overlay prod und passe drei Stellen an, die zusammengehören: die Namen in ingress.yaml, WAVE_BASE_URL und die STUN-Adresse in WAVE_RELAYS. Aus WAVE_BASE_URL entstehen Anmeldelinks und Weiterleitungen, deshalb muss der Name mit dem Ingress übereinstimmen.

    In secret.env stehen das Datenbank-Passwort und die Verbindungsadresse. Sind die Container-Images privat, gehört daneben eine dockerconfig.json mit Lesezugriff auf GHCR. Beide Dateien bleiben außerhalb von Git.

    $ git clone https://github.com/moellenbeck-digital/wave-mesh.git
    $ cd wave-mesh
    $ cp -r deployment/server/overlays/prod deployment/server/overlays/mywave
    $ cd deployment/server/overlays/mywave
    $ cp secret.env.example secret.env # fill in, mode 600
    $ kubectl apply -k .
  3. STUN-Adresse eintragen

    Die STUN-Adresse in WAVE_RELAYS muss eine IP-Adresse sein, kein Name. Sie steht fest, sobald der Service des Relays eine öffentliche Adresse bekommen hat. Trag sie ein und wende das Overlay erneut an.

    $ kubectl -n wave-mesh get svc wave-relay-stun
  4. Erstes Konto anlegen

    Eine Registrierungsseite gibt es absichtlich nicht: Konten legt der Betreiber an. Das Kommando fragt das Passwort zweimal ab, mindestens zwölf Zeichen.

    $ kubectl -n wave-mesh exec -it deploy/wave-control -- \
    bun apps/control/src/admin.ts set-password you@example.com
  5. Client installieren

    Der Client ist ein einzelnes Binary für Linux, macOS und Windows, jeweils für amd64 und arm64. install kopiert es nach /usr/local/bin, legt die Gruppe wave an und startet Dienst und Tray-Icon. Danach braucht der Alltag kein sudo mehr.

    Unter Windows entpackst du das ZIP-Archiv und führst in einer Konsole mit Administratorrechten wave.exe install aus.

    $ tar xzf wave-linux-amd64.tar.gz
    $ sudo ./wave install
  6. Anmelden und verbinden

    wave login nennt deinen Control-Server und zeigt einen Link zum Anmelden. Danach verbindet wave up, und wave status zeigt live, über welchen Pfad jedes Gerät erreicht wird. Ein Gerät kann beliebig vielen Waves beitreten.

    $ wave login https://control.example.com
    $ wave up
    $ wave status
  7. Namen und Zertifikateoptional

    Trägt ein Wave ein DNS-Suffix, das dir gehört, bekommen seine Geräte Namen darunter und auf Wunsch Let's-Encrypt-Zertifikate. Der Provider wird einmal je Wave festgelegt; danach holt wave cert das Zertifikat auf dem Gerät, und der Dienst erneuert es selbst. Der private Schlüssel verlässt das Gerät nie.

    Für einen Provider-Token braucht der Server WAVE_DNS_SECRET (32 Bytes, base64), damit der Token verschlüsselt abgelegt wird. Vorgabe ist das Staging-Verzeichnis von Let's Encrypt; echte Zertifikate gibt es mit WAVE_ACME_DIRECTORY.

    Mit dem Provider manual funktioniert das bei jedem Hoster, dann braucht aber auch jede Erneuerung einen Menschen, der den TXT-Record anlegt.

    $ kubectl -n wave-mesh exec -it deploy/wave-control -- \
    bun apps/control/src/admin.ts set-dns-provider mywave cloudflare
    $ wave cert --hook 'systemctl reload caddy'
  8. Dienste aus einem Kubernetes-Clusteroptional

    Ein Connector bringt interne Dienste eines Clusters in den Wave, ohne eingehenden Port. Er meldet sich mit einem wiederverwendbaren Schlüssel an. Danach genügt ein gewöhnlicher Ingress mit ingressClassName: wave, und jedes Gerät im Wave erreicht den Dienst unter seinem Namen.

    $ kubectl -n wave-mesh exec deploy/wave-control -- \
    bun apps/control/src/admin.ts auth-key mywave connector --reusable
    $ cd deployment/cluster/overlays/example
    $ cp secret.env.example secret.env # paste the key
    $ kubectl apply -k .
  9. Dienste im offenen Netz: der Pieroptional

    Ein Gerät kann einen Namen in der Pier-Zone des Waves (app.pier.wave.example.com) aus dem Internet erreichbar machen, ohne eingehenden Port, feste Adresse oder Portfreigabe. Den Pier-Knoten (Image wave-pier) betreibst du als Betreiber auf einer Maschine oder in einem Cluster mit öffentlicher Adresse; ein Ingress leitet alles auf TCP 443 per SNI-Durchleitung an ihn.

    set-pier schreibt einmal den DNS-Eintrag *.pier.<domain> über die Provider-API deines Waves oder nennt ihn, wenn du die Zone von Hand pflegst. allow-pier erlaubt den Pier je Gerät; erst danach kann dessen Besitzer mit wave expose einen Namen freigeben. Mit deny-pier ist ein Name sofort nicht mehr erreichbar.

    Behandle den Pier-Knoten wie einen Bastion-Host: Er ist Mitglied des Waves und hat eine öffentliche Adresse. Betreibe ihn auf einer eigenen Maschine oder in einem eigenen Cluster, sonst nichts dort.

    $ kubectl -n wave-mesh exec deploy/wave-control -- \
    bun apps/control/src/admin.ts auth-key mywave pier --reusable
    $ cd deployment/pier/overlays/example
    $ cp secret.env.example secret.env # paste the key
    $ kubectl apply -k .
    $ kubectl -n wave-mesh exec deploy/wave-control -- \
    bun apps/control/src/admin.ts set-pier mywave wave-pier-0 --ipv4 <public address>
    $ kubectl -n wave-mesh exec deploy/wave-control -- \
    bun apps/control/src/admin.ts allow-pier mywave laptop
  10. Updates

    Der Dienst aktualisiert sich selbst: Der Control-Server bietet neue Releases an, der Client installiert nur, was mit dem Release-Schlüssel signiert ist, und geht von allein zurück, wenn die neue Fassung keinen Server erreicht. Wer nicht warten will, installiert sofort.

    $ wave version
    $ wave update

Lieber einrichten lassen?

Wir installieren wave-mesh in der Cloud deines Unternehmens, binden Cluster und Geräte an und übernehmen auf Wunsch Updates und Betrieb.

Zu den Preisen