frp
0.61.0
README | 中文文档
frp ist ein Open-Source-Projekt, dessen kontinuierliche Weiterentwicklung ausschließlich durch die Unterstützung unserer großartigen Sponsoren ermöglicht wird. Wenn Sie sich ihnen anschließen möchten, denken Sie bitte darüber nach, die Entwicklung von frp zu sponsern.
frp ist ein schneller Reverse-Proxy, der es Ihnen ermöglicht, einen lokalen Server, der sich hinter einem NAT oder einer Firewall befindet, dem Internet zugänglich zu machen. Derzeit werden die Protokolle TCP und UDP sowie HTTP und HTTPS unterstützt, sodass Anfragen über den Domänennamen an interne Dienste weitergeleitet werden können.
frp bietet auch einen P2P-Verbindungsmodus.
Entwicklungsstand
Über V2
Architektur
Beispielverwendung
Greifen Sie über SSH auf Ihren Computer in einem LAN-Netzwerk zu
Mehrere SSH-Dienste teilen sich denselben Port
Zugriff auf interne Webdienste mit benutzerdefinierten Domänen im LAN
Leiten Sie DNS-Abfrageanfragen weiter
Unix-Domain-Socket weiterleiten
Machen Sie einen einfachen HTTP-Dateiserver verfügbar
Aktivieren Sie HTTPS für einen lokalen HTTP(S)-Dienst
Stellen Sie Ihren Service privat zur Verfügung
P2P-Modus
Merkmale
HTTP X-Forwarded-For
Proxy-Protokoll
Für jeden Proxy
TLS
Token-Authentifizierung
OIDC-Authentifizierung
Prometheus
Konfigurationsdateien
Umgebungsvariablen verwenden
Split-Konfigurationen in verschiedene Dateien
Server-Dashboard
Client-Administrator-Benutzeroberfläche
Monitor
Authentifizierung des Clients
Verschlüsselung und Komprimierung
Hot-Reloading der Frpc-Konfiguration
Erhalten Sie den Proxy-Status vom Client
Nur bestimmte Ports auf dem Server zulassen
Wiederverwendung von Ports
Bandbreitenbegrenzung
TCP-Stream-Multiplexing
Unterstützt das KCP-Protokoll
Unterstützt das QUIC-Protokoll
Verbindungspooling
Lastausgleich
Dienstzustandsprüfung
Umschreiben des HTTP-Host-Headers
Andere HTTP-Header festlegen
Holen Sie sich echte IP
Für Webdienste ist eine HTTP-Basisauthentifizierung (Passwort) erforderlich
Benutzerdefinierte Subdomain-Namen
URL-Routing
TCP-Port-Multiplexing
Verbindung zu frps über PROXY herstellen
Portbereichszuordnung
Client-Plugins
Serververwaltungs-Plugins
SSH-Tunnel-Gateway
Verwandte Projekte
Mitwirken
Spende
GitHub-Sponsoren
PayPal
frp befindet sich derzeit in der Entwicklung. Sie können die neueste Release-Version im master -Zweig ausprobieren oder über den dev Zweig auf die Version zugreifen, die sich derzeit in der Entwicklung befindet.
Wir arbeiten derzeit an Version 2 und versuchen, einige Code-Refactorings und -Verbesserungen durchzuführen. Bitte beachten Sie jedoch, dass es nicht mit Version 1 kompatibel ist.
Wir werden zu gegebener Zeit von Version 0 auf Version 1 umsteigen und nur Fehlerbehebungen und Verbesserungen akzeptieren, keine großen Funktionswünsche.
Die Komplexität und der Schwierigkeitsgrad der v2-Version sind viel höher als erwartet. Ich kann nur in fragmentierten Zeiträumen an der Entwicklung arbeiten und die ständigen Unterbrechungen beeinträchtigen die Produktivität erheblich. Angesichts dieser Situation werden wir die aktuelle Version weiter optimieren und iterieren, bis wir mehr freie Zeit haben, um mit der umfassenden Überarbeitung der Version fortzufahren.
Das Konzept hinter v2 basiert auf meiner jahrelangen Erfahrung und Reflexion im Cloud-nativen Bereich, insbesondere in K8s und ServiceMesh. Sein Kern ist ein modernisierter vier- und siebenschichtiger Proxy, ähnlich dem Gesandten. Dieser Proxy selbst ist hoch skalierbar und kann nicht nur die Funktionalität der Intranet-Penetration implementieren, sondern ist auch auf verschiedene andere Domänen anwendbar. Aufbauend auf diesem hoch skalierbaren Kern möchten wir alle Funktionen von frp v1 implementieren und gleichzeitig die Funktionalitäten ansprechen, die bisher nicht erreichbar oder nur schwer auf elegante Weise zu implementieren waren. Darüber hinaus werden wir effiziente Entwicklungs- und Iterationsfähigkeiten aufrechterhalten.
Darüber hinaus stelle ich mir vor, dass frp selbst ein hochgradig erweiterbares System und eine Plattform wird, ähnlich wie wir auf Basis von K8s eine Reihe von Erweiterungsmöglichkeiten bereitstellen können. In K8s können wir die Entwicklung an die Unternehmensanforderungen anpassen und dabei Funktionen wie CRD, Controller-Modus, Webhook, CSI und CNI nutzen. In frp v1 haben wir das Konzept der Server-Plugins eingeführt, das einige grundlegende Erweiterbarkeit implementiert. Es basiert jedoch auf einem einfachen HTTP-Protokoll und erfordert, dass Benutzer unabhängige Prozesse starten und diese selbst verwalten. Dieser Ansatz ist alles andere als flexibel und bequem, und die Anforderungen in der Praxis variieren stark. Es ist unrealistisch zu erwarten, dass ein gemeinnütziges Open-Source-Projekt, das von einigen wenigen Einzelpersonen gepflegt wird, die Bedürfnisse aller erfüllt.
Abschließend erkennen wir an, dass das aktuelle Design von Modulen wie Konfigurationsmanagement, Berechtigungsüberprüfung, Zertifikatsmanagement und API-Management nicht modern genug ist. Auch wenn wir in der v1-Version möglicherweise einige Optimierungen vornehmen, bleibt die Sicherstellung der Kompatibilität ein herausforderndes Problem, dessen Lösung einen erheblichen Aufwand erfordert.
Wir freuen uns sehr über Ihre Unterstützung für frp.
Laden Sie zunächst das neueste Programm für Ihr Betriebssystem und Ihre Architektur von der Release-Seite herunter.
Platzieren Sie als Nächstes die frps Binär- und Serverkonfigurationsdatei auf Server A, der über eine öffentliche IP-Adresse verfügt.
Platzieren Sie abschließend die frpc Binär- und Client-Konfigurationsdatei auf Server B, der sich in einem LAN befindet, auf das nicht direkt über das öffentliche Internet zugegriffen werden kann.
Einige Antivirenprogramme markieren frpc fälschlicherweise als Malware und löschen es. Dies liegt daran, dass frp ein Netzwerktool ist, das Reverse-Proxys erstellen kann. Antivirenprogramme kennzeichnen manchmal Reverse-Proxys aufgrund ihrer Fähigkeit, Firewall-Portbeschränkungen zu umgehen. Wenn Sie ein Antivirenprogramm verwenden, müssen Sie frpc möglicherweise in Ihren Antivireneinstellungen auf die Whitelist setzen/ausschließen, um eine versehentliche Quarantäne/Löschung zu vermeiden. Weitere Einzelheiten finden Sie in Ausgabe 3637.
Ändern Sie frps.toml auf Server A, indem Sie den bindPort festlegen, mit dem frp-Clients eine Verbindung herstellen sollen:
# frps.tomlbindPort = 7000
Starten Sie frps auf Server A:
./frps -c ./frps.toml
Ändern Sie frpc.toml auf Server B und setzen Sie das Feld serverAddr auf die öffentliche IP-Adresse Ihres frps-Servers:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "ssh"type = "tcp"localIP = "127.0.0.1"localPort = 22remotePort = 6000
Beachten Sie, dass der localPort (auf dem Client abgehört) und remotePort (auf dem Server verfügbar gemacht) für den Datenverkehr verwendet werden, der in das FRP-System ein- und ausgeht, während der serverPort für die Kommunikation zwischen FrPS und FrPC verwendet wird.
Starten Sie frpc auf Server B:
./frpc -c ./frpc.toml
Um von einem anderen Computer über Server A über SSH auf Server B zuzugreifen (vorausgesetzt, der Benutzername lautet test ), verwenden Sie den folgenden Befehl:
ssh -oPort=6000 test@xxxx
In diesem Beispiel werden mehrere SSH-Dienste über denselben Port mithilfe eines Proxys vom Typ tcpmux implementiert. Solange der Client die Proxy-Verbindungsmethode HTTP Connect unterstützt, kann auf diese Weise auch die Wiederverwendung von Ports erreicht werden.
Stellen Sie frps auf einem Computer mit einer öffentlichen IP bereit und ändern Sie die Datei frps.toml. Hier ist eine vereinfachte Konfiguration:
bindPort = 7000tcpmuxHTTPConnectPort = 5002
Stellen Sie frpc auf der internen Maschine A mit der folgenden Konfiguration bereit:
serverAddr = "xxxx"serverPort = 7000[[proxies]]name = "ssh1"type = "tcpmux"multiplexer = "httpconnect"customDomains = ["machine-a.example.com"]localIP = "127.0.0.1"localPort = 22
Stellen Sie einen weiteren frpc auf der internen Maschine B mit der folgenden Konfiguration bereit:
serverAddr = "xxxx"serverPort = 7000[[proxies]]name = "ssh2"type = "tcpmux"multiplexer = "httpconnect"customDomains = ["machine-b.example.com"]localIP = "127.0.0.1"localPort = 22
So greifen Sie mit SSH ProxyCommand auf die interne Maschine A zu, vorausgesetzt, der Benutzername ist „test“:
ssh -o 'proxycommand socat - PROXY:xxxx:%h:%p,proxyport=5002' [email protected]
Für den Zugriff auf die interne Maschine B besteht der einzige Unterschied im Domänennamen, vorausgesetzt, der Benutzername lautet „test“:
ssh -o 'proxycommand socat - PROXY:xxxx:%h:%p,proxyport=5002' [email protected]
Manchmal müssen wir einen lokalen Webdienst hinter einem NAT-Netzwerk anderen zu Testzwecken mit unserem eigenen Domainnamen zugänglich machen.
Leider können wir einen Domainnamen nicht in eine lokale IP auflösen. Allerdings können wir frp verwenden, um einen HTTP(S)-Dienst verfügbar zu machen.
Ändern Sie frps.toml und setzen Sie den HTTP-Port für vhost auf 8080:
# frps.tomlbindPort = 7000vhostHTTPPort = 8080
Wenn Sie einen https-Proxy konfigurieren möchten, müssen Sie den vhostHTTPSPort einrichten.
frps starten:
./frps -c ./frps.toml
Ändern Sie frpc.toml und setzen Sie serverAddr auf die IP-Adresse des Remote-FRPS-Servers. Geben Sie den localPort Ihres Webdienstes an:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "web"type = "http"localPort = 80customDomains = ["www.example.com"]
frpc starten:
./frpc -c ./frpc.toml
Ordnen Sie den A-Eintrag von www.example.com entweder der öffentlichen IP des Remote-FRPS-Servers oder einem CNAME-Eintrag zu, der auf Ihre ursprüngliche Domäne verweist.
Besuchen Sie Ihren lokalen Webdienst über die URL http://www.example.com:8080 .
Ändern Sie frps.toml :
# frps.tomlbindPort = 7000
frps starten:
./frps -c ./frps.toml
Ändern Sie frpc.toml und setzen Sie serverAddr auf die IP-Adresse des Remote-FRPS-Servers. Leiten Sie DNS-Abfrageanfragen an den Google Public DNS-Server 8.8.8.8:53 weiter:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "dns"type = "udp"localIP = "8.8.8.8"localPort = 53remotePort = 6000
Frpc starten:
./frpc -c ./frpc.toml
Testen Sie die DNS-Auflösung mit dem Befehl dig :
dig @xxxx -p 6000 www.google.com
Stellen Sie einen Unix-Domänen-Socket (z. B. den Docker-Daemon-Socket) als TCP bereit.
Konfigurieren Sie frps wie oben.
Starten Sie frpc mit der folgenden Konfiguration:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "unix_domain_socket"type = "tcp"remotePort = 6000[proxies.plugin]type = "unix_domain_socket"unixPath = "/var/run/docker.sock "
Testen Sie die Konfiguration, indem Sie die Docker-Version mit curl abrufen:
curl http://xxxx:6000/version
Stellen Sie einen einfachen HTTP-Dateiserver bereit, um über das öffentliche Internet auf im LAN gespeicherte Dateien zuzugreifen.
Konfigurieren Sie frps wie oben beschrieben, dann:
Starten Sie frpc mit der folgenden Konfiguration:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "test_static_file"type = "tcp"remotePort = 6000[proxies.plugin]type = "static_file"localPath = "/tmp/files"stripPrefix = " static"httpUser = "abc"httpPassword = "abc"
Besuchen Sie http://xxxx:6000/static/ in Ihrem Browser und geben Sie den richtigen Benutzernamen und das richtige Passwort ein, um Dateien in /tmp/files auf dem frpc Computer anzuzeigen.
Sie können das Plugin durch https2https ersetzen und localAddr auf einen HTTPS-Endpunkt verweisen.
Starten Sie frpc mit der folgenden Konfiguration:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "test_https2http"type = "https"customDomains = ["test.example.com"] [proxies.plugin]type = "https2http"localAddr = "127.0.0.1:80"crtPath = "./server.crt"keyPath = "./server.key"hostHeaderRewrite = "127.0.0.1"requestHeaders.set.x- from-where = "frp"
Besuchen Sie https://test.example.com .
Um die Risiken zu mindern, die mit der direkten Offenlegung bestimmter Dienste im öffentlichen Netzwerk verbunden sind, erfordert der STCP-Modus (Secret TCP) die Verwendung eines vorinstallierten Schlüssels für den Zugriff auf den Dienst von anderen Clients aus.
Konfigurieren Sie frps wie oben.
Starten Sie frpc auf Maschine B mit der folgenden Konfiguration. Dieses Beispiel dient der Offenlegung des SSH-Dienstes (Port 22). Beachten Sie, dass das Feld secretKey für den vorinstallierten Schlüssel vorhanden ist und dass das Feld remotePort hier entfernt wurde:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "secret_ssh"type = "stcp"secretKey = "abcdefg"localIP = "127.0.0.1"localPort = 22
Starten Sie einen weiteren frpc (normalerweise auf einem anderen Computer C) mit der folgenden Konfiguration, um mit einem Sicherheitsschlüssel (Feld secretKey ) auf den SSH-Dienst zuzugreifen:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[visitors]]name = "secret_ssh_visitor"type = "stcp"serverName = "secret_ssh"secretKey = "abcdefg"bindAddr = "127.0.0.1"bindPort = 6000
Stellen Sie auf Maschine C mit dem folgenden Befehl eine Verbindung zu SSH auf Maschine B her:
ssh -oPort=6000 127.0.0.1
xtcp ist für die direkte Übertragung großer Datenmengen zwischen Clients konzipiert. Ein FRPS-Server wird weiterhin benötigt, da sich P2P hier nur auf die eigentliche Datenübertragung bezieht.
Beachten Sie, dass es möglicherweise nicht mit allen Arten von NAT-Geräten funktioniert. Möglicherweise möchten Sie auf stcp zurückgreifen, wenn xtcp nicht funktioniert.
Starten Sie frpc auf Maschine B und machen Sie den SSH-Port frei. Beachten Sie, dass das Feld remotePort entfernt wurde:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000# Richten Sie einen neuen Stun-Server ein, wenn der Standardserver nicht verfügbar ist.# natHoleStunServer = "xxx"[[proxies]]name = "p2p_ssh"type = "xtcp"secretKey = " abcdefg"localIP = "127.0.0.1"localPort = 22
Starten Sie einen weiteren frpc (normalerweise auf einem anderen Computer C) mit der Konfiguration für die Verbindung zu SSH im P2P-Modus:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000# Richten Sie einen neuen Stun-Server ein, wenn der Standardserver nicht verfügbar ist.# natHoleStunServer = "xxx"[[visitors]]name = "p2p_ssh_visitor"type = "xtcp"serverName = " p2p_ssh"secretKey = "abcdefg"bindAddr = "127.0.0.1"bindPort = 6000# Wenn eine automatische Tunnelpersistenz erforderlich ist, setzen Sie sie auf truekeepTunnelOpen = false
Stellen Sie auf Maschine C mit dem folgenden Befehl eine Verbindung zu SSH auf Maschine B her:
ssh -oPort=6000 127.0.0.1
Seit v0.52.0 unterstützen wir TOML, YAML und JSON für die Konfiguration. Bitte beachten Sie, dass INI veraltet ist und in zukünftigen Versionen entfernt wird. Neue Funktionen werden nur in TOML, YAML oder JSON verfügbar sein. Benutzer, die diese neuen Funktionen wünschen, sollten ihr Konfigurationsformat entsprechend ändern.
Lesen Sie die vollständigen Beispielkonfigurationsdateien, um noch mehr Funktionen herauszufinden, die hier nicht beschrieben werden.
Beispiele verwenden das TOML-Format, Sie können jedoch weiterhin YAML oder JSON verwenden.
Diese Konfigurationsdateien dienen nur als Referenz. Bitte verwenden Sie diese Konfiguration nicht direkt zum Ausführen des Programms, da es zu verschiedenen Problemen kommen kann.
Vollständige Konfigurationsdatei für frps (Server)
Vollständige Konfigurationsdatei für frpc (Client)
Umgebungsvariablen können in der Konfigurationsdatei im Standardformat von Go referenziert werden:
# frpc.tomlserverAddr = "{{ .Envs.FRP_SERVER_ADDR }}"serverPort = 7000[[proxies]]name = "ssh"type = "tcp"localIP = "127.0.0.1"localPort = 22remotePort = "{{ .Envs. FRP_SSH_REMOTE_PORT }}" Mit der obigen Konfiguration können Variablen wie folgt an frpc -Programm übergeben werden:
export FRP_SERVER_ADDR=x.x.x.x export FRP_SSH_REMOTE_PORT=6000 ./frpc -c ./frpc.toml
frpc rendert die Konfigurationsdateivorlage mithilfe von Betriebssystemumgebungsvariablen. Denken Sie daran, Ihrer Referenz .Envs voranzustellen.
Sie können mehrere Proxy-Konfigurationen in verschiedene Dateien aufteilen und diese in die Hauptdatei aufnehmen.
# frpc.tomlserverAddr = "xxxx"serverPort = 7000includes = ["./confd/*.toml"]
# ./confd/test.toml[[proxies]]name = "ssh"type = "tcp"localIP = "127.0.0.1"localPort = 22remotePort = 6000
Überprüfen Sie den Frp-Status und die Statistikinformationen der Proxys im Dashboard.
Konfigurieren Sie einen Port für das Dashboard, um diese Funktion zu aktivieren:
# Der Standardwert ist 127.0.0.1. Ändern Sie es auf 0.0.0.0, wenn Sie von einem öffentlichen Netzwerk darauf zugreifen möchten.webServer.addr = "0.0.0.0"webServer.port = 7500# Benutzername und Passwort des Dashboards sind beide optionalwebServer.user = "admin"webServer.password = " Administrator"
Besuchen Sie dann http://[serverAddr]:7500 um das Dashboard anzuzeigen, wobei Benutzername und Passwort jeweils admin lauten.
Darüber hinaus können Sie den HTTPS-Port verwenden, indem Sie den Platzhalter Ihrer Domain oder ein normales SSL-Zertifikat verwenden:
webServer.port = 7500# Benutzername und Passwort des Dashboards sind beide optionalwebServer.user = "admin"webServer.password = "admin"webServer.tls.certFile = "server.crt"webServer.tls.keyFile = "server.key"
Besuchen Sie dann https://[serverAddr]:7500 um das Dashboard in einer sicheren HTTPS-Verbindung anzuzeigen, wobei Benutzername und Passwort beide admin lauten.
Die Client-Administrator-Benutzeroberfläche hilft Ihnen, die Konfiguration von frpc zu überprüfen und zu verwalten.
Konfigurieren Sie eine Adresse für die Admin-Benutzeroberfläche, um diese Funktion zu aktivieren:
webServer.addr = "127.0.0.1"webServer.port = 7400webServer.user = "admin"webServer.password = "admin"
Besuchen Sie dann http://127.0.0.1:7400 , um die Admin-Benutzeroberfläche anzuzeigen, wobei Benutzername und Passwort jeweils admin lauten.
Wenn der Webserver aktiviert ist, speichert frps die Überwachungsdaten 7 Tage lang im Cache. Es wird nach dem Neustart des Prozesses gelöscht.
Prometheus wird ebenfalls unterstützt.
Aktivieren Sie zuerst das Dashboard und konfigurieren Sie dann enablePrometheus = true in frps.toml .
http://{dashboard_addr}/metrics stellt Prometheus-Monitordaten bereit.
Es gibt zwei Authentifizierungsmethoden zur Authentifizierung von frpc mit frps.
Sie können entscheiden, welche Sie verwenden möchten, indem Sie auth.method in frpc.toml und frps.toml konfigurieren. Die Standardmethode ist token.
Durch die Konfiguration auth.additionalScopes = ["HeartBeats"] wird die konfigurierte Authentifizierungsmethode verwendet, um die Authentifizierung bei jedem Heartbeat zwischen frpc und frps hinzuzufügen und zu validieren.
Die Konfiguration von auth.additionalScopes = ["NewWorkConns"] bewirkt dasselbe für jede neue Arbeitsverbindung zwischen frpc und frps.
Bei der Angabe von auth.method = "token" in frpc.toml und frps.toml wird eine tokenbasierte Authentifizierung verwendet.
Stellen Sie sicher, dass Sie in frps.toml und frpc.toml dasselbe auth.token angeben, damit frpc die frps-Validierung besteht
Bei der Angabe von auth.method = "oidc" in frpc.toml und frps.toml wird eine OIDC-basierte Authentifizierung verwendet.
OIDC steht für OpenID Connect und der verwendete Ablauf heißt Client Credentials Grant.
Um diesen Authentifizierungstyp zu verwenden, konfigurieren Sie frpc.toml und frps.toml wie folgt:
# frps.tomlauth.method = "oidc"auth.oidc.issuer = "https://example-oidc-issuer.com/"auth.oidc.audience = "https://oidc-audience.com/.default"
# frpc.tomlauth.method = "oidc"auth.oidc.clientID = "98692467-37de-409a-9fac-bb2585826f18" # Durch OIDC-Client-ID ersetzenauth.oidc.clientSecret = "oidc_secret"auth.oidc.audience = "https: //oidc-audience.com/.default"auth.oidc.tokenEndpointURL = "https://example-oidc-endpoint.com/oauth2/v2.0/token"
Die Funktionen sind standardmäßig deaktiviert. Sie können die Verschlüsselung und/oder Komprimierung aktivieren:
# frpc.toml[[proxies]]name = "ssh"type = "tcp"localPort = 22remotePort = 6000transport.useEncryption = truetransport.useCompression = true
Seit v0.50.0 wurde der Standardwert von transport.tls.enable und transport.tls.disableCustomTLSFirstByte in true geändert und tls ist standardmäßig aktiviert.
Beim Port-Multiplexing sendet frp ein erstes Byte 0x17 um eine TLS-Verbindung herzustellen. Dies wird nur wirksam, wenn Sie transport.tls.disableCustomTLSFirstByte auf false setzen.
Um zu erzwingen, dass frps nur TLS-Verbindungen akzeptiert, konfigurieren Sie transport.tls.force = true in frps.toml . Dies ist optional.
frpc TLS-Einstellungen:
transport.tls.enable = truetransport.tls.certFile = "certificate.crt"transport.tls.keyFile = "certificate.key"transport.tls.trustedCaFile = "ca.crt"
frps TLS-Einstellungen:
transport.tls.force = truetransport.tls.certFile = "certificate.crt"transport.tls.keyFile = "certificate.key"transport.tls.trustedCaFile = "ca.crt"
Sie benötigen ein Root-CA-Zertifikat und mindestens ein SSL/TLS-Zertifikat . Es kann selbstsigniert oder regulär sein (z. B. Let's Encrypt oder ein anderer SSL/TLS-Zertifikatanbieter).
Wenn Sie frp über die IP-Adresse und nicht über den Hostnamen verwenden, stellen Sie sicher, dass Sie beim Generieren von SSL/TLS-Zertifikaten die entsprechende IP-Adresse im Bereich Subject Alternative Name (SAN) festlegen.
Anhand eines Beispiels:
Bereiten Sie die OpenSSL-Konfigurationsdatei vor. Es existiert unter /etc/pki/tls/openssl.cnf im Linux-System und unter /System/Library/OpenSSL/openssl.cnf unter MacOS und Sie können es in den aktuellen Pfad kopieren, z. B. cp /etc/pki/tls/openssl.cnf ./my-openssl.cnf . Wenn nicht, können Sie es selbst erstellen, wie zum Beispiel:
cat > my-openssl.cnf << EOF [ ca ] default_ca = CA_default [ CA_default ] x509_extensions = usr_cert [ req ] default_bits = 2048 default_md = sha256 default_keyfile = privkey.pem distinguished_name = req_distinguished_name attributes = req_attributes x509_extensions = v3_ca string_mask = utf8only [ req_distinguished_name ] [ req_attributes ] [ usr_cert ] basicConstraints = CA:FALSE nsComment = "OpenSSL Generated Certificate" subjectKeyIdentifier = hash authorityKeyIdentifier = keyid,issuer [ v3_ca ] subjectKeyIdentifier = hash authorityKeyIdentifier = keyid:always,issuer basicConstraints = CA:true EOF
CA-Zertifikate erstellen:
openssl genrsa -out ca.key 2048 openssl req -x509 -new -nodes -key ca.key -subj "/CN=example.ca.com" -days 5000 -out ca.crt
FRP-Zertifikate erstellen:
openssl genrsa -out server.key 2048 openssl req -new -sha256 -key server.key -subj "/C=XX/ST=DEFAULT/L=DEFAULT/O=DEFAULT/CN=server.com" -reqexts SAN -config <(cat my-openssl.cnf <(printf "n[SAN]nsubjectAltName=DNS:localhost,IP:127.0.0.1,DNS:example.server.com")) -out server.csr openssl x509 -req -days 365 -sha256 -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -extfile <(printf "subjectAltName=DNS:localhost,IP:127.0.0.1,DNS:example.server.com") -out server.crt
FrPC-Zertifikate erstellen:
openssl genrsa -out client.key 2048 openssl req -new -sha256 -key client.key -subj "/C=XX/ST=DEFAULT/L=DEFAULT/O=DEFAULT/CN=client.com" -reqexts SAN -config <(cat my-openssl.cnf <(printf "n[SAN]nsubjectAltName=DNS:client.com,DNS:example.client.com")) -out client.csr openssl x509 -req -days 365 -sha256 -in client.csr -CA ca.crt -CAkey ca.key -CAcreateserial -extfile <(printf "subjectAltName=DNS:client.com,DNS:example.client.com") -out client.crt
Die webServer Felder sind zum Aktivieren der HTTP-API erforderlich:
# frpc.tomlwebServer.addr = "127.0.0.1"webServer.port = 7400
Führen Sie dann den Befehl frpc reload -c ./frpc.toml aus und warten Sie etwa 10 Sekunden, damit frpc Proxys erstellen, aktualisieren oder entfernen kann.
Beachten Sie, dass globale Client-Parameter außer „start“ nicht geändert werden.
Sie können vor dem Neuladen den Befehl frpc verify -c ./frpc.toml ausführen, um zu überprüfen, ob Konfigurationsfehler vorliegen.
Verwenden Sie frpc status -c ./frpc.toml um den Status aller Proxys abzurufen. Die webServer Felder sind für die Aktivierung der HTTP-API erforderlich.
allowPorts in frps.toml wird verwendet, um den Missbrauch von Ports zu verhindern:
# frps.tomlallowPorts = [
{ Anfang = 2000, Ende = 3000 },
{ single = 3001 },
{ single = 3003 },
{ Anfang = 4000, Ende = 50000 }
] vhostHTTPPort und vhostHTTPSPort in frps können denselben Port mit bindPort verwenden. frps erkennt das Protokoll der Verbindung und behandelt es entsprechend.
Sie müssen darauf achten, dass Sie, wenn Sie vhostHTTPSPort und bindPort für denselben Port konfigurieren möchten, zuerst transport.tls.disableCustomTLSFirstByte auf false setzen müssen.
Wir möchten in Zukunft versuchen, mehreren Proxys die Bindung desselben Remote-Ports mit unterschiedlichen Protokollen zu ermöglichen.
# frpc.toml[[proxies]]name = "ssh"type = "tcp"localPort = 22remotePort = 6000transport.bandwidthLimit = "1MB"
Legen Sie transport.bandwidthLimit in der Konfiguration jedes Proxys fest, um diese Funktion zu aktivieren. Unterstützte Einheiten sind MB und KB .
Legen Sie transport.bandwidthLimitMode auf client oder server fest, um die Bandbreite auf der Client- oder Serverseite zu begrenzen. Der Standardwert ist client .
frp unterstützt TCP-Stream-Multiplexing seit Version 0.10.0 wie HTTP2-Multiplexing. In diesem Fall werden alle logischen Verbindungen zu demselben frpc in dieselbe TCP-Verbindung gemultiplext.
Sie können diese Funktion deaktivieren, indem Sie frps.toml und frpc.toml ändern:
# frps.toml und frpc.toml, müssen sametransport.tcpMux = false sein
KCP ist ein schnelles und zuverlässiges Protokoll, das den Übertragungseffekt einer Reduzierung der durchschnittlichen Latenz um 30 bis 40 % und einer Reduzierung der maximalen Verzögerung um den Faktor drei erzielen kann, allerdings auf Kosten von 10 bis 20 % mehr verschwendeter Bandbreite als TCP.
Der KCP-Modus verwendet UDP als zugrunde liegenden Transport. Verwendung von KCP in frp:
Aktivieren Sie KCP in frps:
# frps.tomlbindPort = 7000# Geben Sie einen UDP-Port für KCP.kcpBindPort = 7000 an
Die kcpBindPort -Nummer kann dieselbe Nummer wie bindPort sein, da bindPort Feld einen TCP-Port angibt.
Konfigurieren Sie frpc.toml so, dass KCP zum Herstellen einer Verbindung zu frps verwendet wird:
# frpc.tomlserverAddr = "xxxx"# Identisch mit 'kcpBindPort' in frps.tomlserverPort = 7000transport.protocol = "kcp"
QUIC ist ein neuer Multiplex-Transport, der auf UDP aufbaut.
Verwendung von QUIC in frp:
Aktivieren Sie QUIC in frps:
# frps.tomlbindPort = 7000# Geben Sie einen UDP-Port für QUIC.quicBindPort = 7000 an
Die quicBindPort -Nummer kann dieselbe Nummer wie bindPort sein, da bindPort Feld einen TCP-Port angibt.
Konfigurieren Sie frpc.toml so, dass QUIC zum Herstellen einer Verbindung zu frps verwendet wird:
# frpc.tomlserverAddr = "xxxx"# Identisch mit 'quicBindPort' in frps.tomlserverPort = 7000transport.protocol = "quic"
Standardmäßig erstellt frps auf Benutzeranfrage eine neue frpc-Verbindung zum Backend-Dienst. Beim Verbindungspooling behält frps eine bestimmte Anzahl vorab eingerichteter Verbindungen bei und reduziert so die für den Verbindungsaufbau erforderliche Zeit.
Diese Funktion eignet sich für eine große Anzahl kurzer Verbindungen.
Konfigurieren Sie die Begrenzung der Poolanzahl, die jeder Proxy in frps.toml verwenden kann:
# frps.tomltransport.maxPoolCount = 5
Aktivieren Sie die Anzahl der Verbindungspools und geben Sie sie an:
# frpc.tomltransport.poolCount = 1
Der Lastausgleich wird von group unterstützt.
Diese Funktion ist jetzt nur für die Typen tcp , http , tcpmux verfügbar.
# frpc.toml[[proxies]]name = "test1"type = "tcp"localPort = 8080remotePort = 80loadBalancer.group = "web"loadBalancer.groupKey = "123"[[proxies]]name = "test2"type = " tcp"localPort = 8081remotePort = 80loadBalancer.group = "web"loadBalancer.groupKey = "123"
loadBalancer.groupKey wird zur Authentifizierung verwendet.
Verbindungen zu Port 80 werden nach dem Zufallsprinzip an Proxys in derselben Gruppe weitergeleitet.
Für den Typ tcp sollte remotePort in derselben Gruppe derselbe sein.
Für die Typen http , customDomains und subdomain sollten die locations identisch sein.
Die Integritätsprüfungsfunktion kann Ihnen dabei helfen, durch Lastausgleich eine hohe Verfügbarkeit zu erreichen.
Fügen Sie healthCheck.type = "tcp" oder healthCheck.type = "http" hinzu, um die Gesundheitsprüfung zu aktivieren.
Beim Health-Check-Typ tcp wird der Service-Port angepingt (TCPing):
# frpc.toml[[proxies]]name = "test1"type = "tcp"localPort = 22remotePort = 6000# TCP-Gesundheitsprüfung aktivierenhealthCheck.type = "tcp"# TCP-Timeout SekundenhealthCheck.timeoutSeconds = 3# Wenn die Gesundheitsprüfung dreimal fehlgeschlagen ist Nacheinander wird der Proxy aus frpshealthCheck.maxFailed = 3# Eine Gesundheitsprüfung alle 10 Sekunden entfernthealthCheck.intervalSeconds = 10
Beim Integritätsprüfungstyp http wird eine HTTP-Anfrage an den Dienst gesendet und eine HTTP 2xx OK-Antwort erwartet:
# frpc.toml[[proxies]]name = "web"type = "http"localIP = "127.0.0.1"localPort = 80customDomains = ["test.example.com"]# HTTP-Zustandsprüfung aktivierenhealthCheck.type = "http" # frpc sendet eine GET-Anfrage an '/status'# und erwartet eine HTTP 2xx OK-AntworthealthCheck.path = "/status"healthCheck.timeoutSeconds = 3healthCheck.maxFailed = 3healthCheck.intervalSeconds = 10
Standardmäßig ändert frp die getunnelten HTTP-Anfragen überhaupt nicht, da es sich um eine Byte-für-Byte-Kopie handelt.
Apropos Webserver und HTTP-Anfragen: Ihr Webserver verlässt sich möglicherweise auf den Host HTTP-Header, um die Website zu bestimmen, auf die zugegriffen werden soll. frp kann den Host -Header beim Weiterleiten der HTTP-Anfragen mit dem Feld hostHeaderRewrite neu schreiben:
# frpc.toml[[proxies]]name = "web"type = "http"localPort = 80customDomains = ["test.example.com"]hostHeaderRewrite = "dev.example.com"
Bei der HTTP-Anfrage wird der Host Header in Host: dev.example.com umgeschrieben, wenn sie den tatsächlichen Webserver erreicht, obwohl die Anfrage vom Browser wahrscheinlich Host: test.example.com lautet.
Ähnlich wie bei Host können Sie andere HTTP-Anforderungs- und Antwortheader mit dem Proxytyp http überschreiben.
# frpc.toml[[proxies]]name = "web"type = "http"localPort = 80customDomains = ["test.example.com"]hostHeaderRewrite = "dev.example.com"requestHeaders.set.x-from-where = "frp"responseHeaders.set.foo = "bar"
In diesem Beispiel wird der Header x-from-where: frp in der HTTP-Anfrage und foo: bar in der HTTP-Antwort gesetzt.
Diese Funktion ist für http -Proxys oder Proxys mit aktivierten https2http und https2https Plugins vorgesehen.
Sie können die echte IP des Benutzers aus den HTTP-Anforderungsheadern X-Forwarded-For abrufen.
frp unterstützt das Proxy-Protokoll, um die echte IP des Benutzers an lokale Dienste zu senden. Es unterstützt alle Typen außer UDP.
Hier ist ein Beispiel für einen https-Dienst:
# frpc.toml[[proxies]]name = "web"type = "https"localPort = 443customDomains = ["test.example.com"]# jetzt werden v1 und v2 unterstützttransport.proxyProtocolVersion = "v2"
Sie können die Unterstützung des Proxy-Protokolls in nginx aktivieren, um die echte IP des Benutzers im HTTP-Header X-Real-IP anzuzeigen und dann X-Real-IP Header in Ihrem Webdienst für die echte IP zu lesen.
Jeder, der Ihre Tunnel-URL erraten kann, kann auf Ihren lokalen Webserver zugreifen, sofern Sie ihn nicht mit einem Passwort schützen.
Dadurch wird HTTP Basic Auth für alle Anfragen mit dem in der Konfigurationsdatei von frpc angegebenen Benutzernamen und Passwort erzwungen.
Es kann nur aktiviert werden, wenn der Proxy-Typ http ist.
# frpc.toml[[proxies]]name = "web"type = "http"localPort = 80customDomains = ["test.example.com"]httpUser = "abc"httpPassword = "abc"
Besuchen Sie http://test.example.com im Browser und Sie werden nun aufgefordert, den Benutzernamen und das Passwort einzugeben.
Es ist praktisch, die subdomain -Konfiguration für die Typen http und https zu verwenden, wenn viele Personen einen FPS-Server gemeinsam nutzen.
# frps.tomlsubDomainHost = "frps.com"
Lösen Sie *.frps.com in die IP des frps-Servers auf. Dies wird normalerweise als Wildcard-DNS-Eintrag bezeichnet.
# frpc.toml[[proxies]]name = "web"type = "http"localPort = 80subdomain = "test"
Jetzt können Sie Ihren Webdienst auf test.frps.com besuchen.
Beachten Sie, dass customDomains nicht die Unterdomäne von subdomainHost sein sollte, wenn subdomainHost “ nicht leer ist.
frp unterstützt die Weiterleitung von HTTP-Anfragen an verschiedene Backend-Webdienste per URL-Routing.
locations geben das Präfix der für das Routing verwendeten URL an. frps sucht zunächst nach der spezifischsten Präfixposition, die durch Literalzeichenfolgen angegeben wird, unabhängig von der aufgelisteten Reihenfolge.
# frpc.toml[[proxies]]name = "web01"type = "http"localPort = 80customDomains = ["web.example.com"]locations = ["/"] [[proxies]]name = "web02"type = "http"localPort = 81customDomains = ["web.example.com"]locations = ["/news", "/about"]
HTTP-Anfragen mit dem URL-Präfix /news oder /about werden an web02 und andere Anfragen an web01 weitergeleitet.
frp unterstützt den Empfang von TCP-Sockets, die an verschiedene Proxys an einem einzelnen Port auf frps gerichtet sind, ähnlich wie vhostHTTPPort und vhostHTTPSPort .
Die einzige unterstützte TCP-Port-Multiplexing-Methode, die derzeit verfügbar ist, ist httpconnect – HTTP CONNECT-Tunnel.
Wenn Sie tcpmuxHTTPConnectPort in frps auf einen anderen Wert als 0 setzen, lauscht frps an diesem Port auf HTTP CONNECT-Anfragen.
Der Host der HTTP CONNECT-Anfrage wird verwendet, um den Proxy in frps abzugleichen. Proxy-Hosts können in frpc konfiguriert werden, indem customDomains und/oder subdomain unter tcpmux Proxys konfiguriert werden, wenn multiplexer = "httpconnect" ist.
Zum Beispiel:
# frps.tomlbindPort = 7000tcpmuxHTTPConnectPort = 1337
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "proxy1"type = "tcpmux"multiplexer = "httpconnect"customDomains = ["test1"]localPort = 80[[proxies]]name = "proxy2 "type = "tcpmux"multiplexer = "httpconnect"customDomains = ["test2"]localPort = 8080
In der obigen Konfiguration kann frps über Port 1337 mit einem HTTP CONNECT-Header wie dem folgenden kontaktiert werden:
CONNECT test1 HTTP/1.1rnrn
und die Verbindung wird an proxy1 weitergeleitet.
frpc kann über einen Proxy eine Verbindung zu frps herstellen, wenn Sie die Betriebssystemumgebungsvariable HTTP_PROXY festlegen oder wenn transport.proxyURL in der Datei frpc.toml festgelegt ist.
Es funktioniert nur, wenn das Protokoll TCP ist.
# frpc.tomlserverAddr = "xxxx"serverPort = 7000transport.proxyURL = "http://user:[email protected]:8080"
Hinzugefügt in v0.56.0
Wir können die Bereichssyntax der Go-Vorlage in Kombination mit der integrierten Funktion parseNumberRangePair verwenden, um eine Portbereichszuordnung zu erreichen.
Wenn das folgende Beispiel ausgeführt wird, werden 8 Proxys mit den Namen test-6000, test-6001 ... test-6007 erstellt, die jeweils den Remote-Port dem lokalen Port zuordnen.
{{- range $_, $v := parseNumberRangePair "6000-6006,6007" "6000-6006,6007" }}
[[proxies]]
name = "tcp-{{ $v.First }}"
type = "tcp"
localPort = {{ $v.First }}
remotePort = {{ $v.Second }}
{{- end }}frpc leitet Anfragen standardmäßig nur an lokale TCP- oder UDP-Ports weiter.
Plugins werden zur Bereitstellung umfangreicher Funktionen verwendet. Es gibt integrierte Plugins wie unix_domain_socket , http_proxy , socks5 , static_file , http2https , https2http , https2https und Sie können Beispielverwendungen sehen.
Verwendung des Plugins http_proxy :
# frpc.toml[[proxies]]name = "http_proxy"type = "tcp"remotePort = 6000[proxies.plugin]type = "http_proxy"httpUser = "abc"httpPassword = "abc"
httpUser und httpPassword sind Konfigurationsparameter, die im http_proxy Plugin verwendet werden.
Lesen Sie das Dokument.
Weitere Plugins finden Sie unter gofrp/plugin.
hinzugefügt in v0.53.0
frp unterstützt das Abhören eines SSH-Ports auf der frps-Seite und erreicht TCP-Protokoll-Proxy über das SSH-R-Protokoll, ohne auf frpc angewiesen zu sein.
# frps.tomlsshTunnelGateway.bindPort = 2200
Beim Ausführen von ./frps -c frps.toml wird automatisch eine private Schlüsseldatei mit dem Namen .autogen_ssh_key im aktuellen Arbeitsverzeichnis erstellt. Diese generierte private Schlüsseldatei wird vom SSH-Server in frps verwendet.
Ausführen des Befehls
ssh -R :80:127.0.0.1:8080 v0@{frp-Adresse} -p 2200 tcp --proxy_name "test-tcp" --remote_port 9090richtet auf frps einen Proxy ein, der den lokalen 8080-Dienst an den Port 9090 weiterleitet.
frp (über SSH) (Strg+C zum Beenden) Benutzer: Proxyname: test-tcp Typ: TCP RemoteAddress: :9090
Dies entspricht:
frpc tcp --proxy_name "test-tcp" --local_ip 127.0.0.1 --local_port 8080 --remote_port 9090
Weitere Informationen finden Sie in diesem Dokument.
gofrp/plugin – Ein Repository für FRP-Plugins, das eine Vielzahl von Plugins enthält, die auf der Grundlage des FRP-Erweiterungsmechanismus implementiert werden und den Anpassungsanforderungen verschiedener Szenarien gerecht werden.
gofrp/tiny-frpc – Eine schlanke Version des frp-Clients (mindestens etwa 3,5 MB), implementiert mit dem SSH-Protokoll, unterstützt einige der am häufigsten verwendeten Funktionen und ist für Geräte mit begrenzten Ressourcen geeignet.
Haben Sie Interesse, sich zu engagieren? Wir helfen Ihnen gerne!
Werfen Sie einen Blick auf unsere Problemliste und erwägen Sie, eine Pull-Anfrage an den Entwicklungszweig zu senden.
Wenn Sie eine neue Funktion hinzufügen möchten, erstellen Sie bitte zunächst ein Problem, um die neue Funktion sowie den Implementierungsansatz zu beschreiben. Sobald ein Vorschlag angenommen wurde, erstellen Sie eine Implementierung der neuen Funktionen und senden Sie diese als Pull-Anfrage.
Entschuldigung für mein schlechtes Englisch. Verbesserungen für dieses Dokument sind willkommen, sogar einige Tippfehlerkorrekturen.
Wenn Sie tolle Ideen haben, senden Sie eine E-Mail an [email protected].
Hinweis: Wir möchten, dass Sie bei Problemen Ihre Ratschläge geben, damit andere mit derselben Frage schnell danach suchen können und wir sie nicht wiederholt beantworten müssen.
Wenn frp Ihnen sehr hilft, können Sie uns unterstützen durch:
Unterstützen Sie uns durch Github-Sponsoren.
Sie können das Logo Ihres Unternehmens in der README-Datei dieses Projekts platzieren lassen.
Spenden Sie Geld per PayPal auf mein Konto [email protected] .
