Installation

Node64 ist ein einzelner Docker-Container. Du startest ihn mit einem Befehl oder einer kleinen Compose-Datei – auf einem Linux-Server, einer VM, deinem NAS oder einem Raspberry Pi.

Voraussetzungen

• Docker Engine unter Linux. Für die Compose-Beispiele zusätzlich Docker Compose (docker compose).
• Architektur: amd64 (x86-64), arm64 (aarch64) oder armv7 (32-Bit-ARM).
• Ein Volume für /data. Darin liegen Datenbank, Schlüssel und Zertifikate. Der Rest des Containers kann schreibgeschützt laufen.
• Port 8080 auf dem Host frei. Für DNS64 kommen Port 53 (und je nach Verschlüsselung 443/853) dazu, für PROXY64 die Ports 80 und 443.
• Kein ipv64.net-Account nötig. Node64 läuft komplett standalone. Was ein Account zusätzlich bringt, steht unter Mit ipv64.net verknüpfen.

Plattformen

Das Image wird als Multi-Arch-Image für linux/amd64, linux/arm64 und linux/arm/v7 gebaut. Docker holt automatisch die passende Variante.

Installation mit docker run

Der schnellste Weg. Ein Befehl, fertig:

docker run -d --name node64 \
  -p 8080:8080 \
  -v node64-data:/data \
  --restart unless-stopped \
  ghcr.io/ipv64net/node64:latest

Installation mit docker compose

Für den Dauerbetrieb empfehlen wir eine compose.yaml. Wähle die Variante, die zu deinen Modulen passt. Gestartet wird immer mit docker compose up -d im Ordner der Datei.

• Minimal
• Empfohlen (Host-Netz für DNS64/CDN64)
• Mit Docker-Socket für Container-Checks

services:
  node:
    image: ghcr.io/ipv64net/node64:latest
    container_name: node64
    restart: unless-stopped
    ports:
      - "8080:8080"
      # - "8443:8443"   # optional reiner HTTPS-Port, dazu NODE64_HTTPS_PORT=8443
    volumes:
      - node64-data:/data
    environment:
      NODE64_LOG_LEVEL: info
    read_only: true
    tmpfs:
      - /tmp
    sysctls:
      - net.ipv4.ping_group_range=0 65535   # ICMP-Checks ohne Root
volumes:
  node64-data:

services:
  node:
    image: ghcr.io/ipv64net/node64:latest
    container_name: node64
    restart: unless-stopped
    network_mode: host        # statt ports: – Oberfläche auf NODE64_HTTP_PORT (8080)
    volumes:
      - node64-data:/data
    environment:
      NODE64_LOG_LEVEL: info
    read_only: true
    tmpfs:
      - /tmp
    cap_add:
      - NET_RAW               # ICMP-Checks (sysctls sind im Host-Netz nicht möglich)
volumes:
  node64-data:

services:
  node:
    image: ghcr.io/ipv64net/node64:latest
    container_name: node64
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - node64-data:/data
      - /var/run/docker.sock:/var/run/docker.sock:ro
    group_add:
      - "996"   # Gruppe des Sockets: stat -c %g /var/run/docker.sock
    environment:
      NODE64_LOG_LEVEL: info
    read_only: true
    tmpfs:
      - /tmp
    sysctls:
      - net.ipv4.ping_group_range=0 65535
volumes:
  node64-data:

stat -c %g /var/run/docker.sock

Alle Umgebungsvariablen findest du unter Konfiguration.

Was im Volume /data liegt

/data ist das einzige Verzeichnis, in das Node64 schreibt. Sicherst du dieses Volume, hast du alles.

Ports

Im Bridge-Modus gibst du jeden benötigten Port mit -p bzw. ports: frei, zum Beispiel für DNS64:

    ports:
      - "8080:8080"
      - "53:53/udp"
      - "53:53/tcp"
      - "443:443/tcp"     # DoH (nur wenn eingeschaltet)
      - "853:853/tcp"     # DoT
      - "853:853/udp"     # DoQ

Unter Einstellungen → Ports siehst du, welche Ports Oberfläche, DNS64 und der gemeinsame Eingang belegen oder belegen wollen – inklusive Überschneidungen.

Rechte und Härtung

Node64 ist von Haus aus sparsam mit Rechten:

• Minimales Image: gebaut FROM scratch – kein Betriebssystem, keine Shell, nur das Binary und die CA-Zertifikate. Zeitzonen sind im Binary eingebettet.
• Kein Root: Der Prozess läuft als Benutzer und Gruppe 65532.
• read_only: true: Das Root-Dateisystem kann schreibgeschützt laufen. Nur /data muss beschreibbar sein.
• tmpfs: /tmp: ein Arbeitsbereich im Arbeitsspeicher für temporäre Dateien.
• sysctls: net.ipv4.ping_group_range=0 65535: erlaubt unprivilegiertes Ping für ICMP-Checks. Gilt trotz des Namens auch für ICMPv6. Alternative: cap_add: NET_RAW.
• Ports unter 1024 ohne Root: Das Binary bekommt cap_net_bind_service und cap_net_raw nur als „erlaubt“ und schaltet sie beim Start selbst scharf – für Port 53, 80, 443 und ICMP. Fehlen sie (z. B. durch cap_drop oder unter Podman), startet Node64 trotzdem; nur diese Funktionen gehen dann nicht.

HTTPS direkt am Node

Du brauchst keinen eigenen HTTPS-Port: Node64 erkennt am ersten Byte der Verbindung, ob der Browser TLS spricht. http://<host>:8080 und https://<host>:8080 funktionieren also beide.

• Zertifikat: Beim ersten Start erzeugt Node64 ein selbstsigniertes Zertifikat – der Browser warnt deshalb beim ersten Aufruf. Später wählst du unter Zertifikate ein richtiges Zertifikat für die Oberfläche (z. B. von Let's Encrypt). Alternativ bindest du eigene Dateien über NODE64_TLS_CERT und NODE64_TLS_KEY ein.
• Mindestens TLS 1.2.
• Extra-Port: Wer einen getrennten reinen HTTPS-Port möchte, setzt NODE64_HTTPS_PORT=8443 und gibt 8443 frei.

Passkeys brauchen HTTPS mit einem Hostnamen (nicht nur eine IP-Adresse) – Details unter Anmeldung & Sicherheit.

IPv6 im Container

Node64 ist durchgehend Dual-Stack. Docker gibt Containern im Bridge-Netz aber standardmäßig kein IPv6. Damit Checks und DNS auch über IPv6 laufen, gib dem Netz IPv6 (Docker 27 oder neuer) – oder nutze network_mode: host:

networks:
  default:
    enable_ipv6: true
    ipam:
      config:
        - subnet: fd00:64::/64   # ULA, Docker übernimmt NAT66

Fehlt IPv6 im Container, meldet Node64 das nicht als Störung deiner Ziele, sondern prüft vorher, ob die Adressfamilie überhaupt erreichbar ist.

Erster Aufruf

1. Öffne http://<host>:8080 im Browser.
2. Der Setup-Assistent erscheint, solange noch kein Benutzer existiert. Du legst Sprache, Admin-Konto (Passwort mindestens 10 Zeichen), Zeitzone, Namen und Standort der Node fest.
3. Nach dem Absenden bist du direkt angemeldet. Weiter geht es mit den ersten Schritten.

Prüfen, ob Node64 läuft

Das Image hat einen eingebauten Docker-Healthcheck (/node64 healthcheck, alle 30 Sekunden). In docker ps steht daher nach kurzer Zeit (healthy):

docker ps --filter name=node64

Die Logs zeigen dir, was beim Start passiert:

docker logs -f node64

Der Endpunkt /api/health antwortet ohne Anmeldung mit Status, Version und Uhrzeit:

curl http://localhost:8080/api/health
# {"status":"ok","version":…,"time":…}

Die installierte Version gibt das Binary auch direkt aus:

docker exec node64 /node64 version

Klappt etwas nicht? Typische Ursachen und Lösungen stehen unter FAQ & Fehlerbehebung.

Etwas unklar, fehlt etwas oder hast du eine Frage zu Node64? Frag im offiziellen Forum v64.tech.