rathole-org/ratholeEin leichtgewichtiger und leistungsstarker Reverse-Proxy für NAT-Traversal, geschrieben in Rust. Eine Alternative zu frp und ngrok.
Englisch | Vereinfachtes Chinesisch
Ein sicherer, stabiler und leistungsstarker Reverse-Proxy für NAT-Traversal, geschrieben in Rust
rathole kann, ähnlich wie frp und ngrok, dabei helfen, den Dienst auf einem Gerät hinter dem NAT über einen Server mit einer öffentlichen IP ins Internet zu bringen.
Ein vollwertiges rathole kann von der Release-Seite bezogen werden. Oder aus dem Quellcode erstellen für andere Plattformen und zum Minimieren der Binärdatei. Ein Docker-Image ist ebenfalls verfügbar.
Die Verwendung von rathole ist frp sehr ähnlich. Wenn Sie Erfahrung mit letzterem haben, ist die Konfiguration sehr einfach. Der einzige Unterschied besteht darin, dass die Konfiguration eines Dienstes in Client- und Server-Seite aufgeteilt ist und ein Token obligatorisch ist.
Um rathole zu verwenden, benötigen Sie einen Server mit einer öffentlichen IP und ein Gerät hinter dem NAT, auf dem einige Dienste laufen, die ins Internet freigegeben werden sollen.
Angenommen, Sie haben ein NAS zu Hause hinter dem NAT und möchten dessen SSH-Dienst ins Internet freigeben:
Erstellen Sie server.toml mit folgendem Inhalt und passen Sie ihn entsprechend an.
# server.toml
[server]
bind_addr = "0.0.0.0:2333" # `2333` gibt den Port an, auf dem rathole auf Clients hört
[server.services.my_nas_ssh]
token = "use_a_secret_that_only_you_know" # Token zur Authentifizierung des Clients für den Dienst. Ändern Sie es auf einen beliebigen Wert.
bind_addr = "0.0.0.0:5202" # `5202` gibt den Port an, der `my_nas_ssh` für das Internet freigibt
Dann ausführen:
./rathole server.toml
Erstellen Sie client.toml mit folgendem Inhalt und passen Sie ihn entsprechend an.
# client.toml
[client]
remote_addr = "myserver.com:2333" # Die Adresse des Servers. Der Port muss mit dem Port in `server.bind_addr` übereinstimmen
[client.services.my_nas_ssh]
token = "use_a_secret_that_only_you_know" # Muss mit dem Server übereinstimmen, um die Validierung zu bestehen
local_addr = "127.0.0.1:22" # Die Adresse des Dienstes, der weitergeleitet werden soll
Dann ausführen:
./rathole client.toml
myserver.com auf Port 2333 zu verbinden, und jeglicher Datenverkehr zu myserver.com:5202 wird an den Client-Port 22 weitergeleitet.Sie können also ssh myserver.com:5202 verwenden, um sich per SSH mit Ihrem NAS zu verbinden.
Um rathole als Hintergrunddienst unter Linux auszuführen, finden Sie die systemd-Beispiele.
rathole kann automatisch erkennen, ob es im Server- oder Client-Modus ausgeführt werden soll, basierend auf dem Inhalt der Konfigurationsdatei, wenn nur einer der Blöcke [server] und [client] vorhanden ist, wie im Beispiel im Schnellstart.
Die Blöcke [client] und [server] können jedoch auch in einer Datei zusammengefasst werden. Führen Sie dann auf der Serverseite rathole --server config.toml und auf der Clientseite rathole --client config.toml aus, um rathole den Ausführungsmodus explizit mitzuteilen.
Bevor Sie zur vollständigen Konfigurationsspezifikation übergehen, empfiehlt es sich, die Konfigurationsbeispiele zu überfliegen, um ein Gefühl für das Format der Konfiguration zu bekommen.
Weitere Details zur Verschlüsselung und zum transport-Block finden Sie unter Transport.
Hier ist die vollständige Konfigurationsspezifikation:
[client]
remote_addr = "example.com:2333" # Notwendig. Die Adresse des Servers
default_token = "default_token_if_not_specify" # Optional. Das Standard-Token für Dienste, falls diese kein eigenes definieren
heartbeat_timeout = 40 # Optional. Auf 0 setzen, um den Heartbeat-Test auf Anwendungsebene zu deaktivieren. Der Wert muss größer als `server.heartbeat_interval` sein. Standard: 40 Sekunden
retry_interval = 1 # Optional. Das Intervall zwischen erneuten Verbindungsversuchen zum Server. Standard: 1 Sekunde
[client.transport] # Der gesamte Block ist optional. Gibt an, welcher Transport verwendet werden soll
type = "tcp" # Optional. Mögliche Werte: ["tcp", "tls", "noise"]. Standard: "tcp"
[client.transport.tcp] # Optional. Wirkt sich auch auf `noise` und `tls` aus
proxy = "socks5://user:[email protected]:1080" # Optional. Der Proxy, der zur Verbindung mit dem Server verwendet wird. `http` und `socks5` werden unterstützt.
nodelay = true # Optional. Legt fest, ob TCP_NODELAY aktiviert werden soll, falls zutreffend, um die Latenz zu verbessern, aber die Bandbreite zu verringern. Standard: true
keepalive_secs = 20 # Optional. Gibt `tcp_keepalive_time` in `tcp(7)` an, falls zutreffend. Standard: 20 Sekunden
keepalive_interval = 8 # Optional. Gibt `tcp_keepalive_intvl` in `tcp(7)` an, falls zutreffend. Standard: 8 Sekunden
[client.transport.tls] # Notwendig, wenn `type` "tls" ist
trusted_root = "ca.pem" # Notwendig. Das Zertifikat der CA, die das Serverzertifikat signiert hat
hostname = "example.com" # Optional. Der Hostname, den der Client zur Validierung des Zertifikats verwendet. Wenn nicht gesetzt, wird auf `client.remote_addr` zurückgegriffen
[client.transport.noise] # Noise-Protokoll. Siehe `docs/transport.md` für eine genauere Erklärung
pattern = "Noise_NK_25519_ChaChaPoly_BLAKE2s" # Optional. Standardwert wie gezeigt
local_private_key = "key_encoded_in_base64" # Optional
remote_public_key = "key_encoded_in_base64" # Optional
[client.transport.websocket] # Notwendig, wenn `type` "websocket" ist
tls = true # Wenn `true`, werden die Einstellungen in `client.transport.tls` verwendet
[client.services.service1] # Ein Dienst, der weitergeleitet werden soll. Der Name `service1` kann beliebig geändert werden, solange er mit dem Namen in der Serverkonfiguration übereinstimmt
type = "tcp" # Optional. Das Protokoll, das weitergeleitet werden soll. Mögliche Werte: ["tcp", "udp"]. Standard: "tcp"
token = "whatever" # Notwendig, wenn `client.default_token` nicht gesetzt ist
local_addr = "127.0.0.1:1081" # Notwendig. Die Adresse des Dienstes, der weitergeleitet werden soll
nodelay = true # Optional. Überschreibt `client.transport.nodelay` pro Dienst
retry_interval = 1 # Optional. Das Intervall zwischen erneuten Verbindungsversuchen zum Server. Standard: erbt die globale Konfiguration
[client.services.service2] # Mehrere Dienste können definiert werden
local_addr = "127.0.0.1:1082"
[server]
bind_addr = "0.0.0.0:2333" # Notwendig. Die Adresse, auf der der Server auf Clients hört. In der Regel muss nur der Port geändert werden.
default_token = "default_token_if_not_specify" # Optional
heartbeat_interval = 30 # Optional. Das Intervall zwischen zwei Heartbeats auf Anwendungsebene. Auf 0 setzen, um das Senden von Heartbeats zu deaktivieren. Standard: 30 Sekunden
[server.transport] # Gleich wie `[client.transport]`
type = "tcp"
[server.transport.tcp] # Gleich wie beim Client
nodelay = true
keepalive_secs = 20
keepalive_interval = 8
[server.transport.tls] # Notwendig, wenn `type` "tls" ist
pkcs12 = "identify.pfx" # Notwendig. pkcs12-Datei des Serverzertifikats und des privaten Schlüssels
pkcs12_password = "password" # Notwendig. Passwort der pkcs12-Datei
[server.transport.noise] # Gleich wie `[client.transport.noise]`
pattern = "Noise_NK_25519_ChaChaPoly_BLAKE2s"
local_private_key = "key_encoded_in_base64"
remote_public_key = "key_encoded_in_base64"
[server.transport.websocket] # Notwendig, wenn `type` "websocket" ist
tls = true # Wenn `true`, werden die Einstellungen in `server.transport.tls` verwendet
[server.services.service1] # Der Dienstname muss mit der Clientseite identisch sein
type = "tcp" # Optional. Gleich wie beim Client `[client.services.X.type]
token = "whatever" # Notwendig, wenn `server.default_token` nicht gesetzt ist
bind_addr = "0.0.0.0:8081" # Notwendig. Die Adresse, unter der der Dienst freigegeben wird. In der Regel muss nur der Port geändert werden.
nodelay = true # Optional. Gleich wie beim Client
[server.services.service2]
bind_addr = "0.0.0.1:8082"
rathole verwendet, wie viele andere Rust-Programme, Umgebungsvariablen, um die Protokollierungsebene zu steuern. Verfügbar sind info, warn, error, debug, trace.
RUST_LOG=error ./rathole config.toml
führt rathole nur mit Fehlerprotokollierung aus.
Wenn RUST_LOG nicht gesetzt ist, ist die Standard-Protokollierungsebene info.
Ab Version 0.4.7 aktiviert rathole standardmäßig TCP_NODELAY, was die Latenz und interaktive Anwendungen wie RDP oder Minecraft-Server verbessern sollte. Es verringert jedoch leicht die Bandbreite.
Wenn die Bandbreite wichtiger ist, kann TCP_NODELAY mit nodelay = false deaktiviert werden.
rathole hat eine ähnliche Latenz wie frp, kann aber mehr Verbindungen verarbeiten, eine größere Bandbreite bieten und dabei weniger Speicher verbrauchen.
Weitere Details finden Sie auf der separaten Seite Benchmark.
Allerdings sollte man daraus nicht schließen, dass rathole Ihren weitergeleiteten Dienst auf magische Weise um ein Vielfaches schneller machen kann. Der Benchmark wurde auf dem lokalen Loopback durchgeführt und zeigt die Leistung, wenn die Aufgabe CPU-gebunden ist. Man kann eine deutliche Verbesserung erzielen, wenn das Netzwerk nicht der Engpass ist. Leider trifft das für viele Benutzer nicht zu. In diesem Fall liegt der Hauptvorteil im geringeren Ressourcenverbrauch, während die Bandbreite und die Latenz möglicherweise nicht signifikant verbessert werden.
Nicht im Umfang listet Funktionen auf, deren Implementierung nicht geplant ist, und erklärt warum.