Netbird vps reverse proxy

Diese Anleitung beschreibt den Aufbau einer sicheren Infrastruktur, um selbstgehostete Dienste aus dem Heimnetz über einen externen VPS ins Internet zu exponieren – ohne die eigene IP-Adresse preiszugeben und mit maximaler Absicherung aller Komponenten.

Architektur-Überblick:
Internet → VPS (Reverse Proxy) → NetBird-Tunnel (verschlüsselt) → Homeserver → Lokale Dienste

Teil 1: Grundlagen und Konzept

Warum NetBird?

NetBird ist eine Open-Source WireGuard-basierte Mesh-VPN-Lösung mit folgenden Vorteilen:

DSGVO-konform: Europäisches Unternehmen, Self-Hosting möglich
Zero-Config: Automatisches NAT-Traversal, keine Portfreigaben nötig
WireGuard-Basis: Moderne, schnelle und sichere Verschlüsselung
Access Control: Granulare Zugriffsregeln über die Management-Oberfläche
Mesh-Netzwerk: Alle Peers können direkt miteinander kommunizieren

Architektur im Detail

┌─────────────────────────────────────────────────────────────────────────┐
│                              INTERNET                                    │
│                                  │                                       │
│                            ┌─────▼─────┐                                │
│                            │    VPS    │                                │
│                            │ (Hetzner) │                                │
│                            │           │                                │
│                            │ ┌───────┐ │                                │
│                            │ │ Caddy │ │ ← HTTPS (443)                  │
│                            │ └───┬───┘ │                                │
│                            │     │     │                                │
│                            │ ┌───▼───┐ │                                │
│                            │ │NetBird│ │ ← WireGuard (UDP)              │
│                            │ └───┬───┘ │                                │
│                            └─────┼─────┘                                │
│                                  │                                       │
│                    ══════════════╪══════════════                        │
│                     Verschlüsselter NetBird-Tunnel                      │
│                    ══════════════╪══════════════                        │
│                                  │                                       │
│   ┌──────────────────────────────┼──────────────────────────────────┐   │
│   │                         HEIMNETZ                                 │   │
│   │                              │                                   │   │
│   │                        ┌─────▼─────┐                            │   │
│   │                        │ Homeserver│                            │   │
│   │                        │           │                            │   │
│   │                        │ ┌───────┐ │                            │   │
│   │                        │ │NetBird│ │                            │   │
│   │                        │ └───┬───┘ │                            │   │
│   │                        │     │     │                            │   │
│   │              ┌─────────┼─────┼─────┼─────────┐                  │   │
│   │              │         │     │     │         │                  │   │
│   │          ┌───▼───┐ ┌───▼───┐ │ ┌───▼───┐ ┌───▼───┐             │   │
│   │          │ Wiki  │ │Vaultw.│ │ │ Git   │ │  ...  │             │   │
│   │          │:3000  │ │:8080  │ │ │:3001  │ │       │             │   │
│   │          └───────┘ └───────┘ │ └───────┘ └───────┘             │   │
│   │                              │                                   │   │
│   └──────────────────────────────┴──────────────────────────────────┘   │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Voraussetzungen

Komponente	Anforderung
VPS	Debian 12 oder Ubuntu 24.04, mindestens 1 vCPU, 1 GB RAM
Homeserver	Linux-basiert mit Docker (optional), Root-Zugang
Domain	Eigene Domain mit DNS-Zugang
NetBird-Account	Kostenlos unter app.netbird.io oder Self-Hosted

Teil 2: VPS Grundkonfiguration und Härtung

Cloud-Init für automatische Ersteinrichtung

Bei der VPS-Erstellung (z.B. bei Hetzner) kann folgendes Cloud-Init-Script verwendet werden:

Anpassbare Werte:
In dieser Anleitung werden Beispielwerte verwendet, die du an deine Bedürfnisse anpassen solltest:

luna → Dein gewünschter Benutzername
226 → Dein gewünschter SSH-Port (beliebig zwischen 1024-65535)
ssh-ed25519 AAAA... → Dein öffentlicher SSH-Key
Europe/Berlin → Deine Zeitzone
deine-domain.de → Deine eigene Domain
100.64.0.1 → Die NetBird-IP deines Homeservers

#cloud-config

users:
  - name: luna                          # ← Benutzername anpassen
    groups: sudo
    shell: /bin/bash
    sudo: ALL=(ALL) NOPASSWD:ALL
    ssh_authorized_keys:
      - ssh-ed25519 AAAA... DEIN-PUBLIC-KEY    # ← Dein SSH-Key

package_update: true
package_upgrade: true
packages:
  - curl
  - wget
  - vim
  - htop
  - ufw
  - fail2ban
  - unattended-upgrades

write_files:
  - path: /etc/ssh/sshd_config.d/99-hardening.conf
    content: |
      Port 226                          # ← SSH-Port anpassen
      PermitRootLogin no
      PasswordAuthentication no
      PubkeyAuthentication yes
      AllowUsers luna                   # ← Benutzername anpassen
      MaxAuthTries 3
      LoginGraceTime 20
      ClientAliveInterval 300
      ClientAliveCountMax 2
      X11Forwarding no
      AllowTcpForwarding no
      AllowAgentForwarding no
    permissions: '0644'

  - path: /etc/fail2ban/jail.local
    content: |
      [DEFAULT]
      bantime = 3600
      findtime = 600
      maxretry = 3
      
      [sshd]
      enabled = true
      port = 226                        # ← SSH-Port anpassen
      filter = sshd
      logpath = /var/log/auth.log
      maxretry = 3
      bantime = 86400
    permissions: '0644'

runcmd:
  - ufw default deny incoming
  - ufw default allow outgoing
  - ufw allow 226/tcp comment 'SSH'     # ← SSH-Port anpassen
  - ufw --force enable
  - systemctl restart sshd
  - systemctl enable fail2ban
  - systemctl restart fail2ban
  - passwd -l root

timezone: Europe/Berlin                 # ← Zeitzone anpassen

SSH-Härtung im Detail

Falls kein Cloud-Init verwendet wurde, manuell konfigurieren:

# SSH-Konfiguration erstellen
sudo nano /etc/ssh/sshd_config.d/99-hardening.conf

# Inhalt der Datei
Port 226                                # ← SSH-Port anpassen
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
AllowUsers luna                         # ← Benutzername anpassen
MaxAuthTries 3
LoginGraceTime 20
ClientAliveInterval 300
ClientAliveCountMax 2
X11Forwarding no
AllowTcpForwarding no
AllowAgentForwarding no
PermitEmptyPasswords no
Protocol 2

# SSH neustarten
sudo systemctl restart sshd

# WICHTIG: Neue Session in separatem Terminal testen bevor alte geschlossen wird!
ssh luna@SERVER-IP -p 226               # ← Benutzername und Port anpassen

Firewall-Grundkonfiguration mit UFW

# Status prüfen
sudo ufw status verbose

# Defaults setzen
sudo ufw default deny incoming
sudo ufw default allow outgoing

# SSH erlauben (deinen gewählten Port verwenden)
sudo ufw allow 226/tcp comment 'SSH'    # ← SSH-Port anpassen

# Aktivieren
sudo ufw enable

# Status erneut prüfen
sudo ufw status numbered

Fail2ban für Brute-Force-Schutz

# Installation
sudo apt install fail2ban -y

# Konfiguration
sudo nano /etc/fail2ban/jail.local

[DEFAULT]
bantime = 3600
findtime = 600
maxretry = 3
ignoreip = 127.0.0.1/8 ::1

[sshd]
enabled = true
port = 226                              # ← SSH-Port anpassen
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
bantime = 86400

# Starten und aktivieren
sudo systemctl enable fail2ban
sudo systemctl restart fail2ban

# Status prüfen
sudo fail2ban-client status sshd

Automatische Sicherheitsupdates

# Installation
sudo apt install unattended-upgrades apt-listchanges -y

# Konfigurieren
sudo dpkg-reconfigure -plow unattended-upgrades

# Konfiguration prüfen/anpassen
sudo nano /etc/apt/apt.conf.d/50unattended-upgrades

Unattended-Upgrade::Allowed-Origins {
    "${distro_id}:${distro_codename}";
    "${distro_id}:${distro_codename}-security";
    "${distro_id}ESMApps:${distro_codename}-apps-security";
    "${distro_id}ESM:${distro_codename}-infra-security";
};

Unattended-Upgrade::AutoFixInterruptedDpkg "true";
Unattended-Upgrade::Remove-Unused-Kernel-Packages "true";
Unattended-Upgrade::Remove-Unused-Dependencies "true";
Unattended-Upgrade::Automatic-Reboot "true";
Unattended-Upgrade::Automatic-Reboot-Time "04:00";

Teil 3: NetBird Installation und Konfiguration

NetBird auf dem VPS installieren

# NetBird Repository hinzufügen und installieren
curl -fsSL https://pkgs.netbird.io/install.sh | sh

# NetBird starten und mit Account verbinden
sudo netbird up

# Browser öffnet sich zur Authentifizierung
# Falls headless: Setup-Key verwenden (siehe NetBird Dashboard)

Setup mit Setup-Key (headless)

# Im NetBird Dashboard: Setup Keys → Create Setup Key
# Dann auf dem VPS:
sudo netbird up --setup-key DEIN-SETUP-KEY

NetBird auf dem Homeserver installieren

# Installation
curl -fsSL https://pkgs.netbird.io/install.sh | sh

# Mit gleichem Account verbinden
sudo netbird up --setup-key DEIN-SETUP-KEY

# Status prüfen
sudo netbird status

Peers und IPs ermitteln

# Auf beiden Systemen: NetBird-IP anzeigen
sudo netbird status

# Beispielausgabe:
# Peers:
#  homeserver: 100.64.0.1 (connected)
#  vps: 100.64.0.2 (connected)

Wichtig: Notiere dir die NetBird-IPs beider Systeme. Diese werden für die Reverse-Proxy-Konfiguration benötigt.

Network Routes für lokale Dienste (Optional)

Falls deine Dienste auf anderen Geräten im Heimnetz laufen (nicht auf dem Homeserver selbst), kannst du Network Routes einrichten:

NetBird Dashboard öffnen → Network → Routes
"Add Route" klicken
Konfiguration:
- Network: 192.168.1.0/24 (dein Heimnetz)
- Routing Peer: Dein Homeserver
- Distribution Groups: Gruppe mit dem VPS
Speichern

Nun kann der VPS alle Geräte in deinem Heimnetz über die NetBird-Verbindung erreichen.

Access Control Policies

Im NetBird Dashboard unter "Access Control" kannst du granular festlegen, welche Peers miteinander kommunizieren dürfen:

# Empfohlene Regel für dieses Setup:
Source: VPS (oder Gruppe "Reverse-Proxies")
Destination: Homeserver (oder Gruppe "Homelab")
Ports: TCP 3000, 8080, 3001 (deine Dienst-Ports)
Action: Allow

Teil 4: Reverse Proxy mit Caddy

Caddy installieren

# Repository hinzufügen
sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list

# Installieren
sudo apt update
sudo apt install caddy -y

Caddy konfigurieren

# Caddyfile bearbeiten
sudo nano /etc/caddy/Caddyfile

# Globale Optionen
{
    email admin@deine-domain.de
    
    # Optionale Sicherheitsheader global
    servers {
        protocols h1 h2 h3
    }
}

# Wiki
wiki.deine-domain.de {
    reverse_proxy 100.64.0.1:3000 {
        # Health-Check
        health_uri /
        health_interval 30s
        
        # Timeouts
        transport http {
            dial_timeout 5s
            response_header_timeout 30s
        }
    }
    
    # Security Headers
    header {
        X-Content-Type-Options "nosniff"
        X-Frame-Options "SAMEORIGIN"
        Referrer-Policy "strict-origin-when-cross-origin"
        X-XSS-Protection "1; mode=block"
        -Server
    }
    
    # Logging
    log {
        output file /var/log/caddy/wiki.log {
            roll_size 10mb
            roll_keep 5
        }
    }
}

# Vaultwarden (Beispiel)
vault.deine-domain.de {
    reverse_proxy 100.64.0.1:8080 {
        header_up X-Real-IP {remote_host}
    }
    
    header {
        X-Content-Type-Options "nosniff"
        X-Frame-Options "SAMEORIGIN"
        Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
        -Server
    }
}

# GitLab (Beispiel)
git.deine-domain.de {
    reverse_proxy 100.64.0.1:3001
    
    header {
        X-Content-Type-Options "nosniff"
        -Server
    }
}

Wichtig: Ersetze 100.64.0.1 mit der tatsächlichen NetBird-IP deines Homeservers!

Caddy starten und Firewall öffnen

# Konfiguration validieren
sudo caddy validate --config /etc/caddy/Caddyfile

# Caddy neustarten
sudo systemctl restart caddy

# Status prüfen
sudo systemctl status caddy

# Firewall für HTTP/HTTPS öffnen
sudo ufw allow 80/tcp comment 'HTTP'
sudo ufw allow 443/tcp comment 'HTTPS'
sudo ufw allow 443/udp comment 'QUIC/HTTP3'

DNS-Konfiguration

Bei deinem DNS-Provider (oder Hetzner DNS, Netcup DNS, etc.):

Typ	Name	Wert	TTL
A	wiki	VPS-IPv4	3600
AAAA	wiki	VPS-IPv6	3600
A	vault	VPS-IPv4	3600
A	git	VPS-IPv4	3600

Caddy holt sich automatisch Let's Encrypt-Zertifikate sobald die DNS-Einträge aktiv sind.

Teil 5: Server im Internet unsichtbar machen

Konzept: Stealth-Server

Ein "unsichtbarer" Server antwortet nur auf erwarteten Traffic und ignoriert alles andere. Portscanner wie Nmap sehen den Server nicht oder erhalten keine verwertbaren Informationen.

Erweiterte Firewall mit iptables/nftables

# UFW deaktivieren (wir nutzen iptables direkt für mehr Kontrolle)
sudo ufw disable

# iptables-persistent installieren
sudo apt install iptables-persistent -y

Stealth-Firewall-Script erstellen

sudo nano /etc/iptables/rules.v4

*filter
:INPUT DROP [0:0]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [0:0]

# Loopback erlauben
-A INPUT -i lo -j ACCEPT
-A OUTPUT -o lo -j ACCEPT

# Established/Related Verbindungen erlauben
-A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

# ICMP Rate-Limiting (optional: komplett blocken für mehr Stealth)
-A INPUT -p icmp --icmp-type echo-request -m limit --limit 1/s --limit-burst 4 -j ACCEPT
-A INPUT -p icmp --icmp-type echo-request -j DROP

# SSH nur von bestimmten IPs (optional)
# -A INPUT -p tcp --dport 226 -s DEINE-IP/32 -j ACCEPT
# Oder SSH für alle (mit Fail2ban geschützt):
-A INPUT -p tcp --dport 226 -m conntrack --ctstate NEW -m recent --set --name SSH
-A INPUT -p tcp --dport 226 -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 4 --name SSH -j DROP
-A INPUT -p tcp --dport 226 -j ACCEPT

# HTTP/HTTPS
-A INPUT -p tcp --dport 80 -j ACCEPT
-A INPUT -p tcp --dport 443 -j ACCEPT
-A INPUT -p udp --dport 443 -j ACCEPT

# NetBird/WireGuard (wird automatisch gehandhabt, aber zur Sicherheit)
-A INPUT -p udp --dport 51820 -j ACCEPT

# Alles andere: REJECT statt DROP für legitimen Traffic
# Aber DROP für Stealth (Portscanner sehen nichts)
-A INPUT -j DROP

COMMIT

*raw
:PREROUTING ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]

# Ungültige Pakete sofort droppen (vor Connection Tracking)
-A PREROUTING -m conntrack --ctstate INVALID -j DROP

# Schutz vor Port-Scans: TCP-Flags-Checks
-A PREROUTING -p tcp --tcp-flags ALL NONE -j DROP
-A PREROUTING -p tcp --tcp-flags ALL ALL -j DROP
-A PREROUTING -p tcp --tcp-flags ALL FIN,URG,PSH -j DROP
-A PREROUTING -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP
-A PREROUTING -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
-A PREROUTING -p tcp --tcp-flags SYN,FIN SYN,FIN -j DROP

COMMIT

# Regeln laden
sudo iptables-restore < /etc/iptables/rules.v4

# Regeln persistent machen
sudo netfilter-persistent save

IPv6-Firewall

sudo nano /etc/iptables/rules.v6

*filter
:INPUT DROP [0:0]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [0:0]

-A INPUT -i lo -j ACCEPT
-A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

# ICMPv6 (wichtig für IPv6-Funktionalität)
-A INPUT -p ipv6-icmp --icmpv6-type destination-unreachable -j ACCEPT
-A INPUT -p ipv6-icmp --icmpv6-type packet-too-big -j ACCEPT
-A INPUT -p ipv6-icmp --icmpv6-type time-exceeded -j ACCEPT
-A INPUT -p ipv6-icmp --icmpv6-type parameter-problem -j ACCEPT
-A INPUT -p ipv6-icmp --icmpv6-type echo-request -m limit --limit 1/s -j ACCEPT
-A INPUT -p ipv6-icmp --icmpv6-type echo-reply -j ACCEPT
-A INPUT -p ipv6-icmp --icmpv6-type router-advertisement -m hl --hl-eq 255 -j ACCEPT
-A INPUT -p ipv6-icmp --icmpv6-type neighbor-solicitation -m hl --hl-eq 255 -j ACCEPT
-A INPUT -p ipv6-icmp --icmpv6-type neighbor-advertisement -m hl --hl-eq 255 -j ACCEPT

# Dienste
-A INPUT -p tcp --dport 226 -j ACCEPT   # ← SSH-Port anpassen
-A INPUT -p tcp --dport 80 -j ACCEPT
-A INPUT -p tcp --dport 443 -j ACCEPT
-A INPUT -p udp --dport 443 -j ACCEPT

-A INPUT -j DROP

COMMIT

sudo ip6tables-restore < /etc/iptables/rules.v6
sudo netfilter-persistent save

Port Knocking (Optional, maximale Stealth)

Port Knocking versteckt SSH komplett – der Port öffnet sich nur nach einer geheimen Klopfsequenz.

# knockd installieren
sudo apt install knockd -y

# Konfiguration
sudo nano /etc/knockd.conf

[options]
    UseSyslog
    Interface = eth0

[openSSH]
    sequence    = 7000,8000,9000        # ← Klopfsequenz anpassen (geheime Ports)
    seq_timeout = 5
    command     = /sbin/iptables -I INPUT -s %IP% -p tcp --dport 226 -j ACCEPT
    tcpflags    = syn

[closeSSH]
    sequence    = 9000,8000,7000        # ← Umgekehrte Sequenz
    seq_timeout = 5
    command     = /sbin/iptables -D INPUT -s %IP% -p tcp --dport 226 -j ACCEPT
    tcpflags    = syn

# SSH-Regel aus iptables entfernen (wird durch Knocking gesteuert)
sudo iptables -D INPUT -p tcp --dport 226 -j ACCEPT

# knockd aktivieren
sudo nano /etc/default/knockd
# START_KNOCKD=1 setzen

sudo systemctl enable knockd
sudo systemctl start knockd

Verbindung mit Port Knocking

# Auf dem Client:
knock VPS-IP 7000 8000 9000 && ssh luna@VPS-IP -p 226

# Nach der Session:
knock VPS-IP 9000 8000 7000

Achtung: Bei Port Knocking unbedingt einen Backup-Zugang haben (z.B. Hetzner Console), falls man sich aussperrt!

Kernel-Hardening

sudo nano /etc/sysctl.d/99-hardening.conf

# IP Spoofing Schutz
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1

# ICMP Redirects ignorieren
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv6.conf.all.accept_redirects = 0
net.ipv6.conf.default.accept_redirects = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0

# Source Routing deaktivieren
net.ipv4.conf.all.accept_source_route = 0
net.ipv4.conf.default.accept_source_route = 0
net.ipv6.conf.all.accept_source_route = 0
net.ipv6.conf.default.accept_source_route = 0

# SYN Flood Schutz
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_max_syn_backlog = 2048
net.ipv4.tcp_synack_retries = 2
net.ipv4.tcp_syn_retries = 5

# Log Martians (unmögliche Adressen)
net.ipv4.conf.all.log_martians = 1
net.ipv4.conf.default.log_martians = 1

# ICMP Broadcast ignorieren (Smurf Attack)
net.ipv4.icmp_echo_ignore_broadcasts = 1

# Bogus ICMP Responses ignorieren
net.ipv4.icmp_ignore_bogus_error_responses = 1

# IPv6 Router Advertisements ignorieren
net.ipv6.conf.all.accept_ra = 0
net.ipv6.conf.default.accept_ra = 0

# TIME-WAIT Assassination Schutz
net.ipv4.tcp_rfc1337 = 1

# Reverse Path Filtering
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1

# Anwenden
sudo sysctl -p /etc/sysctl.d/99-hardening.conf

Teil 6: Zusätzliche Sicherheitsmaßnahmen

CrowdSec (Community-basierte Threat Intelligence)

CrowdSec ist eine moderne Alternative zu Fail2ban mit Community-geteilten Blocklisten.

# Installation
curl -s https://install.crowdsec.net | sudo sh

# Bouncer für iptables installieren
sudo apt install crowdsec-firewall-bouncer-iptables -y

# Status prüfen
sudo cscli metrics
sudo cscli decisions list

SSH mit 2FA (TOTP)

# Google Authenticator PAM installieren
sudo apt install libpam-google-authenticator -y

# Als dein User (z.B. luna) einrichten
google-authenticator
# Fragen mit y beantworten, QR-Code mit Authenticator-App scannen

# PAM konfigurieren
sudo nano /etc/pam.d/sshd

# Am Anfang hinzufügen:
auth required pam_google_authenticator.so

# SSH-Config anpassen
sudo nano /etc/ssh/sshd_config.d/99-hardening.conf

# Hinzufügen:
ChallengeResponseAuthentication yes
AuthenticationMethods publickey,keyboard-interactive

sudo systemctl restart sshd

Logwatch für tägliche Berichte

# Installation
sudo apt install logwatch -y

# Konfiguration
sudo nano /etc/logwatch/conf/logwatch.conf

Output = mail
MailTo = deine@email.de
MailFrom = logwatch@vps
Detail = Med

Lynis Security Audit

# Installation
sudo apt install lynis -y

# Audit durchführen
sudo lynis audit system

# Empfehlungen durcharbeiten
sudo cat /var/log/lynis-report.dat | grep suggestion

Teil 7: Homeserver-Konfiguration

Firewall auf dem Homeserver

# UFW installieren falls nicht vorhanden
sudo apt install ufw -y

# Defaults
sudo ufw default deny incoming
sudo ufw default allow outgoing

# Nur NetBird-Traffic zu den Diensten erlauben
# NetBird-Interface ist üblicherweise wt0 oder utun*
sudo ufw allow in on wt0 to any port 3000 comment 'Wiki via NetBird'
sudo ufw allow in on wt0 to any port 8080 comment 'Vaultwarden via NetBird'
sudo ufw allow in on wt0 to any port 3001 comment 'GitLab via NetBird'

# Lokales Netzwerk erlauben (optional)
sudo ufw allow from 192.168.1.0/24

# Aktivieren
sudo ufw enable

Docker-Sicherheit (falls verwendet)

# Docker-Container nur an localhost oder NetBird-Interface binden
# docker-compose.yml Beispiel:

version: '3.8'
services:
  bookstack:
    image: lscr.io/linuxserver/bookstack
    ports:
      - "127.0.0.1:3000:80"    # Nur localhost
      # Oder NetBird-IP:
      # - "100.64.0.1:3000:80"
    environment:
      - PUID=1000
      - PGID=1000
    volumes:
      - ./data:/config
    restart: unless-stopped

Lokaler Reverse Proxy (Alternative)

Falls mehrere Container laufen, kann ein lokaler Nginx/Caddy die Anfragen verteilen:

# Caddy auf Homeserver
sudo nano /etc/caddy/Caddyfile

# Nur auf NetBird-Interface lauschen
:3000 {
    bind 100.64.0.1
    reverse_proxy localhost:6875  # BookStack Container
}

:8080 {
    bind 100.64.0.1
    reverse_proxy localhost:8081  # Vaultwarden Container
}

Teil 8: Monitoring und Wartung

NetBird-Verbindung überwachen

# Status prüfen
sudo netbird status

# Detaillierte Peer-Informationen
sudo netbird status -d

# Logs
sudo journalctl -u netbird -f

Uptime-Monitoring mit Healthchecks

# Kostenlos: healthchecks.io
# Cronjob auf VPS:
*/5 * * * * curl -fsS --retry 3 https://hc-ping.com/DEIN-UUID > /dev/null

Caddy-Logs analysieren

# Live-Logs
sudo tail -f /var/log/caddy/wiki.log

# Zugriffe zählen
sudo cat /var/log/caddy/wiki.log | wc -l

# Fehler finden
sudo grep -i error /var/log/caddy/*.log

Backup-Strategie

# VPS: Minimale Konfiguration sichern
sudo tar -czvf /root/vps-config-backup.tar.gz \
    /etc/caddy \
    /etc/ssh/sshd_config.d \
    /etc/fail2ban \
    /etc/iptables \
    /etc/sysctl.d

# Auf externen Speicher kopieren (Port anpassen!)
scp -P 226 luna@VPS:/root/vps-config-backup.tar.gz ./

Teil 9: Troubleshooting

NetBird-Verbindungsprobleme

Problem	Lösung
Peers sehen sich nicht	`sudo netbird down && sudo netbird up`
Keine Verbindung	Firewall prüfen: UDP 51820 muss offen sein
Langsame Verbindung	Relay statt Direct? Prüfen mit `netbird status -d`
DNS-Probleme	NetBird DNS deaktivieren: `netbird up --disable-dns`

Caddy-Probleme

Problem	Lösung
502 Bad Gateway	Backend erreichbar? `curl http://100.64.0.1:3000`
SSL-Fehler	DNS korrekt? `dig wiki.domain.de`
Zertifikat kommt nicht	Port 80 offen? Rate-Limit erreicht?
Config-Fehler	`sudo caddy validate --config /etc/caddy/Caddyfile`

Firewall debuggen

# Alle Regeln anzeigen
sudo iptables -L -v -n --line-numbers

# Traffic live beobachten
sudo watch -n1 'iptables -L -v -n'

# Logging für gedropte Pakete
sudo iptables -A INPUT -j LOG --log-prefix "IPTables-Dropped: " --log-level 4
sudo tail -f /var/log/syslog | grep IPTables

Zusammenfassung: Checkliste

VPS-Sicherheit

☐ SSH auf nicht-standard Port (z.B. 226)
☐ Root-Login deaktiviert
☐ Nur Key-basierte Authentifizierung
☐ Fail2ban aktiv
☐ UFW/iptables konfiguriert
☐ Automatische Updates aktiviert
☐ Kernel-Hardening angewendet
☐ Optional: Port Knocking, 2FA, CrowdSec

NetBird-Setup

☐ NetBird auf VPS installiert und verbunden
☐ NetBird auf Homeserver installiert und verbunden
☐ Peers können sich erreichen (ping NetBird-IP)
☐ Network Routes konfiguriert (falls nötig)
☐ Access Control Policies gesetzt

Reverse Proxy

☐ Caddy installiert und konfiguriert
☐ DNS-Einträge gesetzt
☐ SSL-Zertifikate aktiv
☐ Security Headers konfiguriert
☐ Logging aktiviert

Homeserver

☐ Firewall nur NetBird-Traffic erlaubt
☐ Dienste nicht direkt ans Internet gebunden
☐ Docker-Container sicher konfiguriert

Letzte Aktualisierung: 2025

Pangolin - Newt Agent installieren

Netbird vps reverse proxy

NPM Docker Setup mit NetBird

Dockge + NPM mit Netbird

Netbird vps reverse proxy

Teil 1: Grundlagen und Konzept

Warum NetBird?

Architektur im Detail

Voraussetzungen

Teil 2: VPS Grundkonfiguration und Härtung

Cloud-Init für automatische Ersteinrichtung

SSH-Härtung im Detail

Firewall-Grundkonfiguration mit UFW

Fail2ban für Brute-Force-Schutz

Automatische Sicherheitsupdates

Teil 3: NetBird Installation und Konfiguration

NetBird auf dem VPS installieren

Setup mit Setup-Key (headless)

NetBird auf dem Homeserver installieren

Peers und IPs ermitteln

Network Routes für lokale Dienste (Optional)

Access Control Policies

Teil 4: Reverse Proxy mit Caddy

Caddy installieren

Caddy konfigurieren

Caddy starten und Firewall öffnen

DNS-Konfiguration

Teil 5: Server im Internet unsichtbar machen

Konzept: Stealth-Server

Erweiterte Firewall mit iptables/nftables

Stealth-Firewall-Script erstellen

IPv6-Firewall

Port Knocking (Optional, maximale Stealth)

Verbindung mit Port Knocking

Kernel-Hardening

Teil 6: Zusätzliche Sicherheitsmaßnahmen

CrowdSec (Community-basierte Threat Intelligence)

SSH mit 2FA (TOTP)

Logwatch für tägliche Berichte

Lynis Security Audit

Teil 7: Homeserver-Konfiguration

Firewall auf dem Homeserver

Docker-Sicherheit (falls verwendet)

Lokaler Reverse Proxy (Alternative)

Teil 8: Monitoring und Wartung

NetBird-Verbindung überwachen

Uptime-Monitoring mit Healthchecks

Caddy-Logs analysieren

Backup-Strategie

Teil 9: Troubleshooting

NetBird-Verbindungsprobleme

Caddy-Probleme

Firewall debuggen

Zusammenfassung: Checkliste

VPS-Sicherheit

NetBird-Setup

Reverse Proxy

Homeserver