frp
0.61.0
BACA SAYA | 中文文档
frp adalah proyek sumber terbuka dengan pengembangan berkelanjutan yang dimungkinkan sepenuhnya berkat dukungan sponsor kami yang luar biasa. Jika Anda ingin bergabung dengan mereka, mohon pertimbangkan untuk mensponsori pengembangan frp.
frp adalah proksi balik cepat yang memungkinkan Anda mengekspos server lokal yang terletak di belakang NAT atau firewall ke Internet. Saat ini mendukung TCP dan UDP , serta protokol HTTP dan HTTPS , memungkinkan permintaan diteruskan ke layanan internal melalui nama domain.
frp juga menawarkan mode koneksi P2P.
Status Pembangunan
Tentang V2
Arsitektur
Contoh Penggunaan
Akses komputer Anda di jaringan LAN melalui SSH
Beberapa layanan SSH berbagi port yang sama
Mengakses Layanan Web Internal dengan Domain Kustom di LAN
Meneruskan permintaan kueri DNS
Meneruskan Soket Domain Unix
Paparkan server file HTTP sederhana
Aktifkan HTTPS untuk layanan HTTP(S) lokal
Ekspos layanan Anda secara pribadi
Modus P2P
Fitur
HTTP X-Diteruskan-Untuk
Protokol Proksi
Untuk Setiap Proksi
TLS
Otentikasi Token
Otentikasi OIDC
Prometheus
File Konfigurasi
Menggunakan Variabel Lingkungan
Pisahkan Konfigurasi Menjadi File Berbeda
Dasbor Server
UI Admin Klien
Memantau
Mengautentikasi Klien
Enkripsi dan Kompresi
Konfigurasi frpc Reload Panas
Dapatkan status proxy dari klien
Hanya mengizinkan port tertentu di server
Penggunaan Kembali Pelabuhan
Batas Bandwidth
Penggandaan Aliran TCP
Mendukung Protokol KCP
Mendukung Protokol QUIC
Pengumpulan Koneksi
Penyeimbangan beban
Pemeriksaan Kesehatan Layanan
Menulis ulang Header Host HTTP
Mengatur Header HTTP lainnya
Dapatkan IP Asli
Memerlukan HTTP Basic Auth (Kata Sandi) untuk Layanan Web
Nama Subdomain Khusus
Perutean URL
Multipleksing Pelabuhan TCP
Menghubungkan ke frps melalui PROXY
Pemetaan jangkauan port
Plugin Klien
Plugin Kelola Server
Gerbang Terowongan SSH
Proyek Terkait
Berkontribusi
Sumbangan
Sponsor GitHub
PayPal
frp sedang dalam pengembangan. Anda dapat mencoba versi rilis terbaru di cabang master , atau menggunakan cabang dev untuk mengakses versi yang sedang dalam pengembangan.
Kami sedang mengerjakan versi 2 dan mencoba melakukan beberapa pemfaktoran ulang dan peningkatan kode. Namun perlu diingat bahwa ini tidak akan kompatibel dengan versi 1.
Kami akan melakukan transisi dari versi 0 ke versi 1 pada waktu yang tepat dan hanya akan menerima perbaikan bug dan peningkatan, bukan permintaan fitur besar.
Kompleksitas dan kesulitan versi v2 jauh lebih tinggi dari yang diperkirakan. Saya hanya dapat mengerjakan pengembangannya selama periode waktu yang terfragmentasi, dan gangguan yang terus-menerus mengganggu produktivitas secara signifikan. Mengingat situasi ini, kami akan terus mengoptimalkan dan mengulangi versi saat ini hingga kami memiliki lebih banyak waktu luang untuk melanjutkan perombakan versi utama.
Konsep di balik v2 didasarkan pada pengalaman dan refleksi saya selama bertahun-tahun di domain cloud-native, khususnya di K8s dan ServiceMesh. Intinya adalah proxy empat lapis dan tujuh lapis yang dimodernisasi, mirip dengan utusan. Proxy ini sendiri sangat scalable, tidak hanya mampu mengimplementasikan fungsi penetrasi intranet tetapi juga dapat diterapkan pada berbagai domain lainnya. Membangun inti yang sangat skalabel ini, kami bertujuan untuk mengimplementasikan semua kemampuan frp v1 sekaligus mengatasi fungsionalitas yang sebelumnya tidak dapat dicapai atau sulit diterapkan dengan cara yang elegan. Selain itu, kami akan mempertahankan kemampuan pengembangan dan iterasi yang efisien.
Selain itu, saya membayangkan frp menjadi sistem dan platform yang sangat dapat diperluas, serupa dengan bagaimana kami dapat menyediakan berbagai kemampuan ekstensi berdasarkan K8. Di K8, kami dapat menyesuaikan pengembangan sesuai kebutuhan perusahaan, memanfaatkan fitur seperti CRD, mode pengontrol, webhook, CSI, dan CNI. Di frp v1, kami memperkenalkan konsep plugin server, yang menerapkan beberapa ekstensibilitas dasar. Namun, ini bergantung pada protokol HTTP sederhana dan mengharuskan pengguna untuk memulai proses independen dan mengelolanya sendiri. Pendekatan ini jauh dari fleksibel dan nyaman, dan tuntutan di dunia nyata sangat bervariasi. Tidaklah realistis untuk mengharapkan proyek sumber terbuka nirlaba yang dikelola oleh beberapa individu untuk memenuhi kebutuhan semua orang.
Terakhir, kami mengakui bahwa desain modul saat ini seperti manajemen konfigurasi, verifikasi izin, manajemen sertifikat, dan manajemen API belum cukup modern. Meskipun kami mungkin melakukan beberapa pengoptimalan di versi v1, memastikan kompatibilitas tetap menjadi masalah menantang yang memerlukan banyak upaya untuk mengatasinya.
Kami dengan tulus menghargai dukungan Anda untuk frp.
Untuk memulai, unduh program terbaru untuk sistem operasi dan arsitektur Anda dari halaman Rilis.
Selanjutnya letakkan file konfigurasi biner frps dan server di Server A yang memiliki alamat IP publik.
Terakhir, letakkan file konfigurasi biner dan klien frpc di Server B yang terletak di LAN yang tidak bisa langsung diakses dari internet publik.
Beberapa antivirus salah menandai frpc sebagai malware dan menghapusnya. Hal ini disebabkan frp menjadi alat jaringan yang mampu membuat proxy terbalik. Antivirus terkadang menandai proxy terbalik karena kemampuannya untuk melewati batasan port firewall. Jika Anda menggunakan antivirus, Anda mungkin perlu memasukkan frpc ke dalam daftar putih/kecualikan dalam pengaturan antivirus Anda untuk menghindari karantina/penghapusan yang tidak disengaja. Lihat edisi 3637 untuk lebih jelasnya.
Ubah frps.toml di server A dengan mengatur bindPort agar klien frp dapat terhubung ke:
#frps.tomlbindPort = 7000
Mulai frps di server A:
./frps -c ./frps.toml
Ubah frpc.toml di server B dan atur kolom serverAddr ke alamat IP publik server frps Anda:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proksi]]nama = "ssh"type = "tcp"localIP = "127.0.0.1"localPort = 22remotePort = 6000
Perhatikan bahwa localPort (didengarkan di klien) dan remotePort (diekspos di server) digunakan untuk lalu lintas masuk dan keluar dari sistem frp, sedangkan serverPort digunakan untuk komunikasi antara frps dan frpc.
Mulai frpc di server B:
./frpc -c ./frpc.toml
Untuk mengakses server B dari mesin lain melalui server A melalui SSH (dengan asumsi nama pengguna adalah test ), gunakan perintah berikut:
ssh -oPort=6000 test@xxxx
Contoh ini mengimplementasikan beberapa layanan SSH yang diekspos melalui port yang sama menggunakan proxy bertipe tcpmux. Demikian pula, selama klien mendukung metode koneksi proxy HTTP Connect, penggunaan kembali port dapat dilakukan dengan cara ini.
Terapkan frps pada mesin dengan IP publik dan ubah file frps.toml. Berikut adalah konfigurasi yang disederhanakan:
bindPort = 7000tcpmuxHTTPConnectPort = 5002
Deploy frpc pada mesin internal A dengan konfigurasi sebagai berikut:
serverAddr = "xxxx"serverPort = 7000[[proksi]]name = "ssh1"type = "tcpmux"multiplexer = "httpconnect"customDomains = ["machine-a.example.com"]localIP = "127.0.0.1"localPort = 22
Deploy frpc lain pada mesin internal B dengan konfigurasi berikut:
serverAddr = "xxxx"serverPort = 7000[[proksi]]name = "ssh2"type = "tcpmux"multiplexer = "httpconnect"customDomains = ["machine-b.example.com"]localIP = "127.0.0.1"localPort = 22
Untuk mengakses mesin internal A menggunakan SSH ProxyCommand, dengan asumsi nama pengguna adalah "test":
ssh -o 'proxycommand socat - PROXY:xxxx:%h:%p,proxyport=5002' [email protected]
Untuk mengakses mesin internal B, satu-satunya perbedaan adalah nama domainnya, dengan asumsi nama penggunanya adalah "test":
ssh -o 'proxycommand socat - PROXY:xxxx:%h:%p,proxyport=5002' [email protected]
Terkadang kita perlu mengekspos layanan web lokal di belakang jaringan NAT kepada orang lain untuk tujuan pengujian dengan nama domain kita sendiri.
Sayangnya, kami tidak dapat mengubah nama domain menjadi IP lokal. Namun, kita dapat menggunakan frp untuk mengekspos layanan HTTP(S).
Ubah frps.toml dan atur port HTTP untuk vhost ke 8080:
# frps.tomlbindPort = 7000vhostHTTPPort = 8080
Jika Anda ingin mengonfigurasi proksi https, Anda perlu menyiapkan vhostHTTPSPort .
Mulai frps :
./frps -c ./frps.toml
Ubah frpc.toml dan atur serverAddr ke alamat IP server frps jarak jauh. Tentukan localPort layanan web Anda:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proksi]]name = "web"type = "http"localPort = 80customDomains = ["www.example.com"]
Mulai frpc :
./frpc -c ./frpc.toml
Petakan data A www.example.com ke IP publik server frps jarak jauh atau data CNAME yang menunjuk ke domain asli Anda.
Kunjungi layanan web lokal Anda menggunakan url http://www.example.com:8080 .
Ubah frps.toml :
#frps.tomlbindPort = 7000
Mulai frps :
./frps -c ./frps.toml
Ubah frpc.toml dan atur serverAddr ke alamat IP server frps jarak jauh. Meneruskan permintaan kueri DNS ke server DNS Publik Google 8.8.8.8:53 :
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proksi]]nama = "dns"type = "udp"localIP = "8.8.8.8"localPort = 53remotePort = 6000
Mulai frpc:
./frpc -c ./frpc.toml
Uji resolusi DNS menggunakan perintah dig :
dig @xxxx -p 6000 www.google.com
Ekspos soket domain Unix (misalnya soket daemon Docker) sebagai TCP.
Konfigurasikan frps seperti di atas.
Mulai frpc dengan konfigurasi berikut:
# 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 "
Uji konfigurasi dengan mendapatkan versi buruh pelabuhan menggunakan curl :
curl http://xxxx:6000/version
Ekspos server file HTTP sederhana untuk mengakses file yang disimpan di LAN dari Internet publik.
Konfigurasikan frps seperti yang dijelaskan di atas, lalu:
Mulai frpc dengan konfigurasi berikut:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxy]]name = "test_static_file"type = "tcp"remotePort = 6000[proxies.plugin]type = "static_file"localPath = "/tmp/files"stripPrefix = " statis"httpUser = "abc"httpPassword = "abc"
Kunjungi http://xxxx:6000/static/ dari browser Anda dan tentukan nama pengguna dan kata sandi yang benar untuk melihat file di /tmp/files di mesin frpc .
Anda dapat mengganti plugin dengan https2https , dan mengarahkan localAddr ke titik akhir HTTPS.
Mulai frpc dengan konfigurasi berikut:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proksi]]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- dari-mana = "frp"
Kunjungi https://test.example.com .
Untuk memitigasi risiko yang terkait dengan pemaparan layanan tertentu secara langsung ke jaringan publik, mode STCP (Secret TCP) memerlukan kunci yang dibagikan sebelumnya untuk digunakan untuk mengakses layanan dari klien lain.
Konfigurasikan frps sama seperti di atas.
Mulai frpc di mesin B dengan konfigurasi berikut. Contoh ini untuk mengekspos layanan SSH (port 22), dan catat kolom secretKey untuk kunci yang dibagikan sebelumnya, dan kolom remotePort dihapus di sini:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proksi]]name = "secret_ssh"type = "stcp"secretKey = "abcdefg"localIP = "127.0.0.1"localPort = 22
Mulai frpc lain (biasanya di komputer lain C) dengan konfigurasi berikut untuk mengakses layanan SSH dengan kunci keamanan (bidang secretKey ):
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[pengunjung]]name = "secret_ssh_visitor"type = "stcp"serverName = "secret_ssh"secretKey = "abcdefg"bindAddr = "127.0.0.1"bindPort = 6000
Di mesin C, sambungkan ke SSH di mesin B, menggunakan perintah ini:
ssh -oPort=6000 127.0.0.1
xtcp dirancang untuk mengirimkan data dalam jumlah besar secara langsung antar klien. Server frps tetap diperlukan, karena P2P di sini hanya mengacu pada transmisi data sebenarnya.
Perhatikan bahwa ini mungkin tidak berfungsi dengan semua jenis perangkat NAT. Anda mungkin ingin kembali ke stcp jika xtcp tidak berfungsi.
Mulai frpc di mesin B, dan buka port SSH. Perhatikan bahwa bidang remotePort dihapus:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000# siapkan server setrum baru jika server default tidak tersedia.# natHoleStunServer = "xxx"[[proxies]]name = "p2p_ssh"type = "xtcp"secretKey = " abcdefg"localIP = "127.0.0.1"localPort = 22
Mulai frpc lain (biasanya di komputer lain C) dengan konfigurasi untuk terhubung ke SSH menggunakan mode P2P:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000# siapkan server setrum baru jika server default tidak tersedia.# natHoleStunServer = "xxx"[[pengunjung]]name = "p2p_ssh_visitor"type = "xtcp"serverName = " p2p_ssh"secretKey = "abcdefg"bindAddr = "127.0.0.1"bindPort = 6000# ketika persistensi terowongan otomatis diperlukan, setel ke truekeepTunnelOpen = false
Di mesin C, sambungkan ke SSH di mesin B, menggunakan perintah ini:
ssh -oPort=6000 127.0.0.1
Sejak v0.52.0, kami mendukung TOML, YAML, dan JSON untuk konfigurasi. Harap dicatat bahwa INI sudah tidak digunakan lagi dan akan dihapus pada rilis mendatang. Fitur baru hanya akan tersedia di TOML, YAML, atau JSON. Pengguna yang menginginkan fitur baru ini harus mengubah format konfigurasinya.
Baca contoh lengkap file konfigurasi untuk mengetahui lebih banyak fitur yang tidak dijelaskan di sini.
Contohnya menggunakan format TOML, namun tetap bisa menggunakan YAML atau JSON.
File konfigurasi ini hanya untuk referensi. Harap jangan menggunakan konfigurasi ini secara langsung untuk menjalankan program karena mungkin terdapat berbagai masalah.
File konfigurasi lengkap untuk frps (Server)
File konfigurasi lengkap untuk frpc (Klien)
Variabel lingkungan dapat direferensikan dalam file konfigurasi, menggunakan format standar Go:
# frpc.tomlserverAddr = "{{ .Envs.FRP_SERVER_ADDR }}"serverPort = 7000[[proxy]]name = "ssh"type = "tcp"localIP = "127.0.0.1"localPort = 22remotePort = "{{ .Envs. FRP_SSH_REMOTE_PORT }}" Dengan konfigurasi di atas, variabel dapat dilewatkan ke dalam program frpc seperti ini:
export FRP_SERVER_ADDR=x.x.x.x export FRP_SSH_REMOTE_PORT=6000 ./frpc -c ./frpc.toml
frpc akan merender templat file konfigurasi menggunakan variabel lingkungan OS. Ingatlah untuk mengawali referensi Anda dengan .Envs .
Anda dapat membagi beberapa konfigurasi proxy ke dalam file berbeda dan memasukkannya ke dalam file utama.
# frpc.tomlserverAddr = "xxxx"serverPort = 7000includes = ["./confd/*.toml"]
# ./confd/test.toml[[proxies]]name = "ssh"type = "tcp"localIP = "127.0.0.1"localPort = 22remotePort = 6000
Periksa status frp dan informasi statistik proxy melalui Dashboard.
Konfigurasikan port untuk dasbor untuk mengaktifkan fitur ini:
# Nilai defaultnya adalah 127.0.0.1. Ubah menjadi 0.0.0.0 bila Anda ingin mengaksesnya dari jaringan publik.webServer.addr = "0.0.0.0"webServer.port = 7500# nama pengguna dan kata sandi dasbor keduanya opsionalwebServer.user = "admin"webServer.password = " admin"
Kemudian kunjungi http://[serverAddr]:7500 untuk melihat dasbor, dengan nama pengguna dan kata sandi keduanya admin .
Selain itu, Anda dapat menggunakan port HTTPS dengan menggunakan wildcard domain atau sertifikat SSL normal:
webServer.port = 7500# nama pengguna dan kata sandi dasbor keduanya opsionalwebServer.user = "admin"webServer.password = "admin"webServer.tls.certFile = "server.crt"webServer.tls.keyFile = "server.key"
Kemudian kunjungi https://[serverAddr]:7500 untuk melihat dasbor dalam koneksi HTTPS yang aman, dengan nama pengguna dan kata sandi keduanya admin .
UI Admin Klien membantu Anda memeriksa dan mengelola konfigurasi frpc.
Konfigurasikan alamat untuk UI admin untuk mengaktifkan fitur ini:
webServer.addr = "127.0.0.1"webServer.port = 7400webServer.user = "admin"webServer.password = "admin"
Kemudian kunjungi http://127.0.0.1:7400 untuk melihat admin UI, dengan nama pengguna dan kata sandi keduanya admin .
Ketika server web diaktifkan, frps akan menyimpan data monitor dalam cache selama 7 hari. Ini akan dihapus setelah proses dimulai ulang.
Prometheus juga didukung.
Aktifkan dashboard terlebih dahulu, lalu konfigurasikan enablePrometheus = true di frps.toml .
http://{dashboard_addr}/metrics akan menyediakan data monitor prometheus.
Ada 2 metode otentikasi untuk mengautentikasi frpc dengan frps.
Anda dapat memutuskan mana yang akan digunakan dengan mengonfigurasi auth.method di frpc.toml dan frps.toml , yang default adalah token.
Mengonfigurasi auth.additionalScopes = ["HeartBeats"] akan menggunakan metode autentikasi yang dikonfigurasi untuk menambahkan dan memvalidasi autentikasi pada setiap detak jantung antara frpc dan frps.
Mengonfigurasi auth.additionalScopes = ["NewWorkConns"] akan melakukan hal yang sama untuk setiap koneksi kerja baru antara frpc dan frps.
Saat menentukan auth.method = "token" di frpc.toml dan frps.toml - otentikasi berbasis token akan digunakan.
Pastikan untuk menentukan auth.token yang sama di frps.toml dan frpc.toml agar frpc dapat lolos validasi frps
Saat menentukan auth.method = "oidc" di frpc.toml dan frps.toml - otentikasi berbasis OIDC akan digunakan.
OIDC adalah singkatan dari OpenID Connect, dan aliran yang digunakan disebut Client Credentials Grant.
Untuk menggunakan jenis otentikasi ini - konfigurasikan frpc.toml dan frps.toml sebagai berikut:
# 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" # Ganti dengan klien OIDC IDauth.oidc.clientSecret = "oidc_secret"auth.oidc.audience = "https: //oidc-audience.com/.default"auth.oidc.tokenEndpointURL = "https://example-oidc-endpoint.com/oauth2/v2.0/token"
Fitur-fiturnya dinonaktifkan secara default. Anda dapat mengaktifkan enkripsi dan/atau kompresi:
# frpc.toml[[proxy]]name = "ssh"type = "tcp"localPort = 22remotePort = 6000transport.useEncryption = truetransport.useCompression = true
Sejak v0.50.0, nilai default transport.tls.enable dan transport.tls.disableCustomTLSFirstByte telah diubah menjadi true, dan tls diaktifkan secara default.
Untuk port multiplexing, frp mengirimkan byte pertama 0x17 untuk menghubungi koneksi TLS. Ini hanya berlaku ketika Anda menyetel transport.tls.disableCustomTLSFirstByte ke false.
Untuk menerapkan frps agar hanya menerima koneksi TLS - konfigurasikan transport.tls.force = true di frps.toml . Ini opsional.
pengaturan TLS frpc :
transport.tls.enable = truetransport.tls.certFile = "certificate.crt"transport.tls.keyFile = "certificate.key"transport.tls.trustedCaFile = "ca.crt"
pengaturan TLS frps :
transport.tls.force = truetransport.tls.certFile = "certificate.crt"transport.tls.keyFile = "certificate.key"transport.tls.trustedCaFile = "ca.crt"
Anda memerlukan sertifikat root CA dan setidaknya satu sertifikat SSL/TLS . Ini bisa ditandatangani sendiri atau biasa (seperti Let's Encrypt atau penyedia sertifikat SSL/TLS lainnya).
Jika Anda menggunakan frp melalui alamat IP dan bukan nama host, pastikan untuk mengatur alamat IP yang sesuai di area Nama Alternatif Subjek (SAN) saat membuat Sertifikat SSL/TLS.
Diberikan contoh:
Siapkan file konfigurasi openssl. Itu ada di /etc/pki/tls/openssl.cnf di Sistem Linux dan /System/Library/OpenSSL/openssl.cnf di MacOS, dan Anda dapat menyalinnya ke jalur saat ini, seperti cp /etc/pki/tls/openssl.cnf ./my-openssl.cnf . Jika belum, Anda bisa membuatnya sendiri, seperti:
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
membangun sertifikat ca:
openssl genrsa -out ca.key 2048 openssl req -x509 -new -nodes -key ca.key -subj "/CN=example.ca.com" -days 5000 -out ca.crt
membuat sertifikat frps:
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
membuat sertifikat frpc：
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
Bidang webServer diperlukan untuk mengaktifkan HTTP API:
# frpc.tomlwebServer.addr = "127.0.0.1"webServer.port = 7400
Kemudian jalankan perintah frpc reload -c ./frpc.toml dan tunggu sekitar 10 detik agar frpc membuat atau memperbarui atau menghapus proxy.
Perhatikan bahwa parameter klien global tidak akan diubah kecuali 'mulai'.
Anda dapat menjalankan perintah frpc verify -c ./frpc.toml sebelum memuat ulang untuk memeriksa apakah ada kesalahan konfigurasi.
Gunakan frpc status -c ./frpc.toml untuk mendapatkan status semua proxy. Bidang webServer diperlukan untuk mengaktifkan HTTP API.
allowPorts di frps.toml digunakan untuk menghindari penyalahgunaan port:
#frps.tomlallowPorts = [
{ awal = 2000, akhir = 3000 },
{ tunggal = 3001 },
{ tunggal = 3003 },
{ awal = 4000, akhir = 50000 }
] vhostHTTPPort dan vhostHTTPSPort di frps dapat menggunakan port yang sama dengan bindPort . frps akan mendeteksi protokol koneksi dan menanganinya sesuai dengan itu.
Yang perlu Anda perhatikan adalah jika Anda ingin mengkonfigurasi vhostHTTPSPort dan bindPort ke port yang sama, Anda harus menyetel transport.tls.disableCustomTLSFirstByte terlebih dahulu ke false.
Kami ingin mencoba mengizinkan beberapa proxy mengikat port jarak jauh yang sama dengan protokol berbeda di masa mendatang.
# frpc.toml[[proxy]]name = "ssh"type = "tcp"localPort = 22remotePort = 6000transport.bandwidthLimit = "1MB"
Tetapkan transport.bandwidthLimit di setiap konfigurasi proxy untuk mengaktifkan fitur ini. Unit yang didukung adalah MB dan KB .
Setel transport.bandwidthLimitMode ke client atau server untuk membatasi bandwidth di sisi klien atau server. Defaultnya adalah client .
frp mendukung multiplexing aliran tcp sejak v0.10.0 seperti HTTP2 Multiplexing, dalam hal ini semua koneksi logika ke frpc yang sama dimultipleks ke dalam koneksi TCP yang sama.
Anda dapat menonaktifkan fitur ini dengan memodifikasi frps.toml dan frpc.toml :
# frps.toml dan frpc.toml, harus sametransport.tcpMux = false
KCP adalah protokol yang cepat dan andal yang dapat mencapai efek transmisi berupa pengurangan latensi rata-rata sebesar 30% hingga 40% dan pengurangan penundaan maksimum sebanyak tiga kali lipat, dengan biaya 10% hingga 20% lebih banyak bandwidth yang terbuang. daripada TCP.
Mode KCP menggunakan UDP sebagai transport yang mendasarinya. Menggunakan KCP di frp:
Aktifkan KCP di frps:
# frps.tomlbindPort = 7000# Tentukan port UDP untuk KCP.kcpBindPort = 7000
Nomor kcpBindPort bisa sama dengan nomor bindPort , karena bidang bindPort menentukan port TCP.
Konfigurasikan frpc.toml agar menggunakan KCP untuk terhubung ke frps:
# frpc.tomlserverAddr = "xxxx"# Sama seperti 'kcpBindPort' di frps.tomlserverPort = 7000transport.protocol = "kcp"
QUIC adalah transportasi multipleks baru yang dibangun di atas UDP.
Menggunakan QUIC di frp:
Aktifkan QUIC di frps:
# frps.tomlbindPort = 7000# Tentukan port UDP untuk QUIC.quicBindPort = 7000
Nomor quicBindPort bisa sama dengan nomor bindPort , karena bidang bindPort menentukan port TCP.
Konfigurasikan frpc.toml untuk menggunakan QUIC untuk terhubung ke frps:
# frpc.tomlserverAddr = "xxxx"# Sama seperti 'quicBindPort' di frps.tomlserverPort = 7000transport.protocol = "quic"
Secara default, frps membuat koneksi frpc baru ke layanan backend berdasarkan permintaan pengguna. Dengan pengumpulan koneksi, frps menyimpan sejumlah koneksi yang telah dibuat sebelumnya, sehingga mengurangi waktu yang diperlukan untuk membuat koneksi.
Fitur ini cocok untuk koneksi pendek dalam jumlah besar.
Konfigurasikan batas jumlah kumpulan yang dapat digunakan setiap proxy di frps.toml :
#frps.tomltransport.maxPoolCount = 5
Aktifkan dan tentukan jumlah kumpulan koneksi:
# frpc.tomltransport.poolCount = 1
Penyeimbangan beban didukung oleh group .
Fitur ini hanya tersedia untuk tipe tcp , http , tcpmux sekarang.
# frpc.toml[[proxy]]name = "test1"type = "tcp"localPort = 8080remotePort = 80loadBalancer.group = "web"loadBalancer.groupKey = "123"[[proxy]]name = "test2"type = " tcp"localPort = 8081remotePort = 80loadBalancer.group = "web"loadBalancer.groupKey = "123"
loadBalancer.groupKey digunakan untuk otentikasi.
Koneksi ke port 80 akan dikirim ke proxy di grup yang sama secara acak.
Untuk tipe tcp , remotePort di grup yang sama harus sama.
Untuk tipe http , customDomains , subdomain , locations harus sama.
Fitur pemeriksaan kondisi dapat membantu Anda mencapai ketersediaan tinggi dengan penyeimbangan beban.
Tambahkan healthCheck.type = "tcp" atau healthCheck.type = "http" untuk mengaktifkan pemeriksaan kesehatan.
Dengan tipe pemeriksaan kesehatan tcp , port layanan akan di-ping (TCPing):
# frpc.toml[[proxies]]name = "test1"type = "tcp"localPort = 22remotePort = 6000# Aktifkan pemeriksaan kesehatan TCPhealthCheck.type = "tcp"# Batas waktu TCPing detikhealthCheck.timeoutSeconds = 3# Jika pemeriksaan kesehatan gagal 3 kali berturut-turut, proxy akan dihapus dari frpshealthCheck.maxFailed = 3# Pemeriksaan kesehatan setiap 10 detikhealthCheck.intervalSeconds = 10
Dengan jenis pemeriksaan kesehatan http , permintaan HTTP akan dikirim ke layanan dan respons HTTP 2xx OK diharapkan:
# frpc.toml[[proxies]]name = "web"type = "http"localIP = "127.0.0.1"localPort = 80customDomains = ["test.example.com"]# Aktifkan pemeriksaan kesehatan HTTPhealthCheck.type = "http" # frpc akan mengirimkan permintaan GET ke '/status'# dan mengharapkan HTTP 2xx OK responhealthCheck.path = "/status"healthCheck.timeoutSeconds = 3healthCheck.maxFailed = 3healthCheck.intervalSeconds = 10
Secara default, frp tidak mengubah permintaan HTTP yang disalurkan sama sekali karena ini adalah salinan byte demi byte.
Namun, berbicara tentang server web dan permintaan HTTP, server web Anda mungkin mengandalkan header HTTP Host untuk menentukan situs web yang akan diakses. frp dapat menulis ulang header Host saat meneruskan permintaan HTTP, dengan bidang hostHeaderRewrite :
# frpc.toml[[proxy]]name = "web"type = "http"localPort = 80customDomains = ["test.example.com"]hostHeaderRewrite = "dev.example.com"
Permintaan HTTP akan membuat header Host ditulis ulang menjadi Host: dev.example.com ketika mencapai server web sebenarnya, meskipun permintaan dari browser mungkin memiliki Host: test.example.com .
Mirip dengan Host , Anda dapat mengganti header permintaan dan respons HTTP lainnya dengan tipe proxy http .
# frpc.toml[[proxy]]name = "web"type = "http"localPort = 80customDomains = ["test.example.com"]hostHeaderRewrite = "dev.example.com"requestHeaders.set.x-from-where = "frp"responseHeaders.set.foo = "bilah"
Dalam contoh ini, ia akan menyetel header x-from-where: frp dalam permintaan HTTP dan foo: bar dalam respons HTTP.
Fitur ini untuk proxy http atau proxy dengan plugin https2http dan https2https diaktifkan.
Anda bisa mendapatkan IP asli pengguna dari header permintaan HTTP X-Forwarded-For .
frp mendukung Protokol Proxy untuk mengirim IP asli pengguna ke layanan lokal. Ini mendukung semua jenis kecuali UDP.
Berikut ini contoh layanan https:
# frpc.toml[[proxies]]name = "web"type = "https"localPort = 443customDomains = ["test.example.com"]# sekarang v1 dan v2 didukungtransport.proxyProtocolVersion = "v2"
Anda dapat mengaktifkan dukungan Protokol Proxy di nginx untuk mengekspos IP asli pengguna di header HTTP X-Real-IP , dan kemudian membaca header X-Real-IP di layanan web Anda untuk IP sebenarnya.
Siapa pun yang dapat menebak URL terowongan Anda dapat mengakses server web lokal Anda kecuali Anda melindunginya dengan kata sandi.
Ini menerapkan HTTP Basic Auth pada semua permintaan dengan nama pengguna dan kata sandi yang ditentukan dalam file konfigurasi frpc.
Ini hanya dapat diaktifkan ketika jenis proxy adalah http.
# frpc.toml[[proxy]]name = "web"type = "http"localPort = 80customDomains = ["test.example.com"]httpUser = "abc"httpPassword = "abc"
Kunjungi http://test.example.com di browser dan sekarang Anda diminta memasukkan nama pengguna dan kata sandi.
Akan lebih mudah untuk menggunakan konfigurasi subdomain untuk tipe http dan https ketika banyak orang berbagi satu server frps.
#frps.tomlsubDomainHost = "frps.com"
Selesaikan *.frps.com ke IP server frps. Ini biasanya disebut catatan DNS Wildcard.
# frpc.toml[[proxy]]name = "web"type = "http"localPort = 80subdomain = "test"
Sekarang Anda dapat mengunjungi layanan web Anda di test.frps.com .
Perhatikan bahwa jika subdomainHost tidak kosong, customDomains tidak boleh menjadi subdomain dari subdomainHost .
frp mendukung penerusan permintaan HTTP ke layanan web backend yang berbeda dengan perutean url.
locations menentukan awalan URL yang digunakan untuk perutean. frps pertama-tama mencari lokasi awalan paling spesifik yang diberikan oleh string literal terlepas dari urutan yang tercantum.
# frpc.toml[[proxy]]name = "web01"type = "http"localPort = 80customDomains = ["web.example.com"]locations = ["/"] [[proksi]]nama = "web02"type = "http"localPort = 81customDomains = ["web.example.com"]lokasi = ["/news", "/about"]
Permintaan HTTP dengan awalan URL /news atau /about akan diteruskan ke web02 dan permintaan lainnya ke web01 .
frp mendukung penerimaan soket TCP yang diarahkan ke proxy berbeda pada satu port di frps, mirip dengan vhostHTTPPort dan vhostHTTPSPort .
Satu-satunya metode multiplexing port TCP yang didukung yang tersedia saat ini adalah httpconnect - terowongan HTTP CONNECT.
Saat mengatur tcpmuxHTTPConnectPort ke selain 0 di frps, frps akan mendengarkan port ini untuk permintaan HTTP CONNECT.
Host permintaan HTTP CONNECT akan digunakan untuk mencocokkan proxy di frps. Host proxy dapat dikonfigurasi di frpc dengan mengonfigurasi customDomains dan/atau subdomain di bawah proxy tcpmux , ketika multiplexer = "httpconnect" .
Misalnya:
# frps.tomlbindPort = 7000tcpmuxHTTPConnectPort = 1337
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxy]]name = "proxy1"type = "tcpmux"multiplexer = "httpconnect"customDomains = ["test1"]localPort = 80[[proxies]]name = "proxy2 "type = "tcpmux"multiplexer = "httpconnect"customDomains = ["test2"]localPort = 8080
Pada konfigurasi di atas - frps dapat dihubungi pada port 1337 dengan header HTTP CONNECT seperti:
CONNECT test1 HTTP/1.1rnrn
dan koneksi akan dialihkan ke proxy1 .
frpc dapat terhubung ke frps melalui proxy jika Anda menyetel variabel lingkungan OS HTTP_PROXY , atau jika transport.proxyURL disetel di file frpc.toml.
Ini hanya berfungsi jika protokolnya adalah tcp.
# frpc.tomlserverAddr = "xxxx"serverPort = 7000transport.proxyURL = "http://user:[email protected]:8080"
Ditambahkan di v0.56.0
Kita dapat menggunakan sintaks rentang templat Go yang dikombinasikan dengan fungsi parseNumberRangePair bawaan untuk mencapai pemetaan rentang port.
Contoh berikut, ketika dijalankan, akan membuat 8 proxy bernama test-6000, test-6001 ... test-6007 , masing-masing memetakan port jarak jauh ke port lokal.
{{- range $_, $v := parseNumberRangePair "6000-6006,6007" "6000-6006,6007" }}
[[proxies]]
name = "tcp-{{ $v.First }}"
type = "tcp"
localPort = {{ $v.First }}
remotePort = {{ $v.Second }}
{{- end }}frpc hanya meneruskan permintaan ke port TCP atau UDP lokal secara default.
Plugin digunakan untuk menyediakan fitur yang kaya. Ada plugin bawaan seperti unix_domain_socket , http_proxy , socks5 , static_file , http2https , https2http , https2https dan Anda dapat melihat contoh penggunaan.
Menggunakan plugin http_proxy :
# frpc.toml[[proxies]]name = "http_proxy"type = "tcp"remotePort = 6000[proxies.plugin]type = "http_proxy"httpUser = "abc"httpPassword = "abc"
httpUser dan httpPassword adalah parameter konfigurasi yang digunakan dalam plugin http_proxy .
Baca dokumennya.
Temukan lebih banyak plugin di gofrp/plugin.
ditambahkan di v0.53.0
frp mendukung mendengarkan port SSH di sisi frps dan mencapai proksi protokol TCP melalui protokol SSH -R, tanpa bergantung pada frpc.
# frps.tomlsshTunnelGateway.bindPort = 2200
Saat menjalankan ./frps -c frps.toml , file kunci pribadi bernama .autogen_ssh_key akan secara otomatis dibuat di direktori kerja saat ini. File kunci pribadi yang dihasilkan ini akan digunakan oleh server SSH di frps.
Menjalankan perintah
ssh -R :80:127.0.0.1:8080 v0@{frp alamat} -p 2200 tcp --proxy_name "test-tcp" --remote_port 9090menyiapkan proxy pada frps yang meneruskan layanan 8080 lokal ke port 9090.
frp (melalui SSH) (Ctrl+C untuk keluar) Pengguna: Nama Proxy: tes-tcp Jenis: tcp Alamat Jarak Jauh: :9090
Ini setara dengan:
frpc tcp --proxy_name "test-tcp" --local_ip 127.0.0.1 --local_port 8080 --remote_port 9090
Silakan merujuk ke dokumen ini untuk informasi lebih lanjut.
gofrp/plugin - Repositori untuk plugin frp yang berisi berbagai plugin yang diimplementasikan berdasarkan mekanisme ekstensi frp, memenuhi kebutuhan penyesuaian berbagai skenario.
gofrp/tiny-frpc - Versi ringan klien frp (minimal sekitar 3,5MB) yang diimplementasikan menggunakan protokol ssh, mendukung beberapa fitur yang paling umum digunakan, cocok untuk perangkat dengan sumber daya terbatas.
Tertarik untuk terlibat? Kami ingin membantu Anda!
Lihatlah daftar masalah kami dan pertimbangkan untuk mengirimkan Permintaan Tarik ke cabang dev .
Jika Anda ingin menambahkan fitur baru, harap buat masalah terlebih dahulu untuk menjelaskan fitur baru tersebut, serta pendekatan penerapannya. Setelah proposal diterima, buat implementasi fitur baru dan kirimkan sebagai permintaan tarik.
Maaf untuk bahasa Inggris saya yang buruk. Perbaikan untuk dokumen ini disambut baik, bahkan beberapa perbaikan kesalahan ketik.
Jika Anda memiliki ide bagus, kirim email ke [email protected].
Catatan: Kami lebih suka Anda memberikan saran Anda dalam suatu masalah, sehingga orang lain yang memiliki pertanyaan yang sama dapat mencarinya dengan cepat dan kami tidak perlu menjawabnya berulang kali.
Jika frp banyak membantu Anda, Anda dapat mendukung kami dengan:
Dukung kami melalui Sponsor Github.
Anda dapat menempatkan logo perusahaan Anda pada file README proyek ini.
Sumbangkan uang melalui PayPal ke akun saya [email protected] .
