fatedier/frpUn proxy inverso rápido para ayudarte a exponer un servidor local detrás de un NAT o firewall a Internet.
frp es un proyecto de código abierto cuyo desarrollo continuo es posible gracias al apoyo de nuestros increíbles patrocinadores. Si deseas unirte a ellos, considera patrocinar el desarrollo de frp.
El IDE completo diseñado para desarrolladores profesionales de Go
Si buscas una API de grabación de reuniones, considera consultar Recall.ai,
una API que graba Zoom, Google Meet, Microsoft Teams, reuniones presenciales y más.
frp es un proxy inverso rápido que te permite exponer un servidor local ubicado detrás de una NAT o firewall a Internet. Actualmente soporta los protocolos TCP y UDP, así como HTTP y HTTPS, lo que permite reenviar solicitudes a servicios internos mediante nombres de dominio.
frp también ofrece un modo de conexión P2P.
frp se encuentra actualmente en desarrollo. Puedes probar la última versión estable en la rama master, o usar la rama dev para acceder a la versión actualmente en desarrollo.
Actualmente estamos trabajando en la versión 2 e intentando realizar algunas refactorizaciones y mejoras de código. Sin embargo, ten en cuenta que no será compatible con la versión 1.
Haremos la transición de la versión 0 a la versión 1 en el momento adecuado y solo aceptaremos correcciones de errores y mejoras, no solicitudes de funciones grandes.
La complejidad y dificultad de la versión v2 son mucho mayores de lo anticipado. Solo puedo trabajar en su desarrollo durante períodos de tiempo fragmentados, y las interrupciones constantes perjudican significativamente la productividad. Dada esta situación, continuaremos optimizando e iterando sobre la versión actual hasta que tengamos más tiempo libre para proceder con la renovación de la versión principal.
El concepto detrás de v2 se basa en mis años de experiencia y reflexión en el dominio cloud-native, particularmente en K8s y ServiceMesh. Su núcleo es un proxy modernizado de capa cuatro y capa siete, similar a envoy. Este proxy en sí mismo es altamente escalable, no solo capaz de implementar la funcionalidad de penetración de intranet, sino también aplicable a varios otros dominios. Sobre la base de este núcleo altamente escalable, buscamos implementar todas las capacidades de frp v1, además de abordar las funcionalidades que anteriormente eran imposibles o difíciles de implementar de manera elegante. Además, mantendremos capacidades eficientes de desarrollo e iteración.
Además, imagino que frp en sí mismo se convierta en un sistema y plataforma altamente extensible, similar a cómo podemos proporcionar una gama de capacidades de extensión basadas en K8s. En K8s, podemos personalizar el desarrollo según las necesidades empresariales, utilizando características como CRD, modo controlador, webhook, CSI y CNI. En frp v1, introdujimos el concepto de plugins de servidor, que implementó cierta extensibilidad básica. Sin embargo, depende de un protocolo HTTP simple y requiere que los usuarios inicien procesos independientes y los gestionen por su cuenta. Este enfoque está lejos de ser flexible y conveniente, y las demandas del mundo real varían enormemente. Es poco realista esperar que un proyecto de código abierto sin fines de lucro mantenido por unas pocas personas satisfaga las necesidades de todos.
Finalmente, reconocemos que el diseño actual de módulos como la gestión de configuración, la verificación de permisos, la gestión de certificados y la gestión de API no es lo suficientemente moderno. Si bien podemos llevar a cabo algunas optimizaciones en la versión v1, garantizar la compatibilidad sigue siendo un problema desafiante que requiere una cantidad considerable de esfuerzo para abordar.
Apreciamos sinceramente tu apoyo a frp.
Para comenzar, descarga el último programa para tu sistema operativo y arquitectura desde la página de Release.
A continuación, coloca el binario frps y el archivo de configuración del servidor en el Servidor A, que tiene una dirección IP pública.
Finalmente, coloca el binario frpc y el archivo de configuración del cliente en el Servidor B, que se encuentra en una LAN que no puede ser accedida directamente desde Internet público.
Algunos antivirus marcan incorrectamente frpc como malware y lo eliminan. Esto se debe a que frp es una herramienta de red capaz de crear proxies inversos. Los antivirus a veces marcan los proxies inversos debido a su capacidad para eludir las restricciones de puertos del firewall. Si usas antivirus, es posible que necesites agregar frpc a la lista blanca/exclusiones en la configuración de tu antivirus para evitar su cuarentena/eliminación accidental. Consulta el issue 3637 para más detalles.
frps.toml en el servidor A configurando el bindPort para que los clientes frp se conecten a: ```tomlbindPort = 7000
2. Inicia `frps` en el servidor A:
`./frps -c ./frps.toml`
3. Modifica `frpc.toml` en el servidor B y establece el campo `serverAddr` a la dirección IP pública de tu servidor frps: ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000
[[proxies]]
name = "ssh"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 6000
Nota: el localPort (escuchado en el cliente) y el remotePort (expuesto en el servidor) se utilizan para el tráfico que entra y sale del sistema frp, mientras que el serverPort se utiliza para la comunicación entre frps y frpc.
frpc en el servidor B:./frpc -c ./frpc.toml
test), use el siguiente comando:ssh -oPort=6000 [email protected]
Este ejemplo implementa múltiples servicios SSH expuestos a través del mismo puerto usando un proxy de tipo tcpmux. De manera similar, siempre que el cliente admita el método de conexión proxy HTTP Connect, se puede lograr la reutilización de puertos de esta manera.
2. Despliega frpc en la máquina interna A con la siguiente configuración: ```toml
serverAddr = "x.x.x.x"
serverPort = 7000
[[proxies]]
name = "ssh1"
type = "tcpmux"
multiplexer = "httpconnect"
customDomains = ["machine-a.example.com"]
localIP = "127.0.0.1"
localPort = 22
[[proxies]] name = "ssh2" type = "tcpmux" multiplexer = "httpconnect" customDomains = ["machine-b.example.com"] localIP = "127.0.0.1" localPort = 22
4. Para acceder a la máquina interna A mediante SSH ProxyCommand, asumiendo que el nombre de usuario es "test":
`ssh -o 'proxycommand socat - PROXY:x.x.x.x:%h:%p,proxyport=5002' [email protected]`
5. Para acceder a la máquina interna B, la única diferencia es el nombre de dominio, asumiendo que el nombre de usuario es "test":
`ssh -o 'proxycommand socat - PROXY:x.x.x.x:%h:%p,proxyport=5002' [email protected]`
### Acceso a Servicios Web Internos con Dominios Personalizados en la LAN
A veces necesitamos exponer un servicio web local detrás de una red NAT a otros para fines de prueba con nuestro propio nombre de dominio.
Desafortunadamente, no podemos resolver un nombre de dominio a una IP local. Sin embargo, podemos usar frp para exponer un servicio HTTP(S).
1. Modifica `frps.toml` y establece el puerto HTTP para vhost en 8080: ```toml
# frps.toml
bindPort = 7000
vhostHTTPPort = 8080
Si deseas configurar un proxy https, necesitas establecer el vhostHTTPSPort.
frps:./frps -c ./frps.toml
frpc.toml y establece serverAddr a la dirección IP del servidor frps remoto. Especifica el localPort de tu servicio web: ```tomlserverAddr = "x.x.x.x" serverPort = 7000
[[proxies]] name = "web" type = "http" localPort = 80 customDomains = ["www.example.com"]
4. Inicia `frpc`:
`./frpc -c ./frpc.toml`
5. Asigna el registro A de `www.example.com` a la IP pública del servidor frps remoto o un registro CNAME que apunte a tu dominio original.
6. Visita tu servicio web local usando la URL `http://www.example.com:8080`.
### Reenviar solicitudes de consulta DNS
1. Modifica `frps.toml`: ```toml
# frps.toml
bindPort = 7000
frps:./frps -c ./frps.toml
frpc.toml y establece serverAddr a la dirección IP del servidor frps remoto. Reenvía las solicitudes de consulta DNS al servidor DNS público de Google 8.8.8.8:53: ```tomlserverAddr = "x.x.x.x" serverPort = 7000
[[proxies]] name = "dns" type = "udp" localIP = "8.8.8.8" localPort = 53 remotePort = 6000
4. Inicia frpc:
`./frpc -c ./frpc.toml`
5. Prueba la resolución DNS usando el comando `dig`:
`dig @x.x.x.x -p 6000 www.google.com`
### Reenviar socket de dominio Unix
Expone un socket de dominio Unix (por ejemplo, el socket del daemon de Docker) como TCP.
Configura `frps` como se indicó anteriormente.
1. Inicia `frpc` con la siguiente configuración: ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000
[[proxies]]
name = "unix_domain_socket"
type = "tcp"
remotePort = 6000
[proxies.plugin]
type = "unix_domain_socket"
unixPath = "/var/run/docker.sock"
curl:curl http://x.x.x.x:6000/version
Expón un servidor HTTP de archivos simple para acceder desde Internet público a archivos almacenados en la LAN.
Configura frps como se describió anteriormente, luego:
frpc con la siguiente configuración: ```tomlserverAddr = "x.x.x.x" 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"
2. Visita `http://x.x.x.x:6000/static/` desde tu navegador e introduce el nombre de usuario y la contraseña correctos para ver los archivos en `/tmp/files` de la máquina `frpc`.
### Habilitar HTTPS para un servicio HTTP(S) local
Puedes sustituir `https2https` por el plugin y apuntar `localAddr` a un endpoint HTTPS.
1. Inicia `frpc` con la siguiente configuración: ```toml
# frpc.toml
serverAddr = "x.x.x.x"
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"
https://test.example.com.Para mitigar los riesgos asociados con exponer ciertos servicios directamente a la red pública, el modo STCP (TCP secreto) requiere que se utilice una clave precompartida para acceder al servicio desde otros clientes.
Configura frps igual que arriba.
frpc en la máquina B con la siguiente configuración. Este ejemplo es para exponer el servicio SSH (puerto 22), y ten en cuenta el campo secretKey para la clave precompartida, y que el campo remotePort se elimina aquí: ```tomlserverAddr = "x.x.x.x" serverPort = 7000
[[proxies]] name = "secret_ssh" type = "stcp" secretKey = "abcdefg" localIP = "127.0.0.1" localPort = 22
2. Inicia otro `frpc` (normalmente en otra máquina C) con la siguiente configuración para acceder al servicio SSH con una clave de seguridad (campo `secretKey`): ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000
[[visitors]]
name = "secret_ssh_visitor"
type = "stcp"
serverName = "secret_ssh"
secretKey = "abcdefg"
bindAddr = "127.0.0.1"
bindPort = 6000
ssh -oPort=6000 127.0.0.1
xtcp está diseñado para transmitir grandes cantidades de datos directamente entre clientes. Aún se necesita un servidor frps, ya que P2P aquí solo se refiere a la transmisión real de datos.
Ten en cuenta que puede que no funcione con todos los tipos de dispositivos NAT. Es posible que quieras recurrir a stcp si xtcp no funciona.
frpc en la máquina B y expón el puerto SSH. Ten en cuenta que el campo remotePort se ha eliminado: ```tomlserverAddr = "x.x.x.x" serverPort = 7000
[[proxies]] name = "p2p_ssh" type = "xtcp" secretKey = "abcdefg" localIP = "127.0.0.1" localPort = 22
2. Inicie otro `frpc` (normalmente en otra máquina C) con la configuración para conectarse a SSH mediante el modo P2P: ```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000
# set up a new stun server if the default one is not available.
# natHoleStunServer = "xxx"
[[visitors]]
name = "p2p_ssh_visitor"
type = "xtcp"
serverName = "p2p_ssh"
secretKey = "abcdefg"
bindAddr = "127.0.0.1"
bindPort = 6000
# when automatic tunnel persistence is required, set it to true
keepTunnelOpen = false
ssh -oPort=6000 127.0.0.1
Desde la v0.52.0, admitimos TOML, YAML y JSON para la configuración. Ten en cuenta que INI está obsoleto y se eliminará en futuras versiones. Las nuevas funciones solo estarán disponibles en TOML, YAML o JSON. Los usuarios que quieran estas nuevas funciones deberían cambiar su formato de configuración en consecuencia.
Lee los archivos de configuración de ejemplo completos para descubrir aún más funciones no descritas aquí.
Los ejemplos usan el formato TOML, pero también puedes usar YAML o JSON.
Estos archivos de configuración son solo de referencia. No uses esta configuración directamente para ejecutar el programa, ya que puede tener varios problemas.
Se puede hacer referencia a las variables de entorno en el archivo de configuración, usando el formato estándar de Go:```toml
serverAddr = "{{ .Envs.FRP_SERVER_ADDR }}" serverPort = 7000
[[proxies]] name = "ssh" type = "tcp" localIP = "127.0.0.1" localPort = 22 remotePort = {{ .Envs.FRP_SSH_REMOTE_PORT }}
Con la configuración anterior, las variables se pueden pasar al programa `frpc` de esta manera:```
export FRP_SERVER_ADDR=x.x.x.x
export FRP_SSH_REMOTE_PORT=6000
./frpc -c ./frpc.toml
frpc renderizará la plantilla del archivo de configuración utilizando las variables de entorno del sistema operativo. Recuerda prefijar tu referencia con .Envs.
Puedes dividir múltiples configuraciones de proxy en diferentes archivos e incluirlos en el archivo principal.```toml
serverAddr = "x.x.x.x" serverPort = 7000 includes = ["./confd/*.toml"]
[[proxies]] name = "ssh" type = "tcp" localIP = "127.0.0.1" localPort = 22 remotePort = 6000
### Panel de servidor
Consulta el estado de frp y la información estadística de los proxies mediante el panel.
Configura un puerto para el panel con el fin de habilitar esta función:```toml
# The default value is 127.0.0.1. Change it to 0.0.0.0 when you want to access it from a public network.
webServer.addr = "0.0.0.0"
webServer.port = 7500
# dashboard's username and password are both optional
webServer.user = "admin"
webServer.password = "admin"
Luego visita http://[serverAddr]:7500 para ver el panel de control, con nombre de usuario y contraseña ambos siendo admin.
Además, puedes usar el puerto HTTPS utilizando el certificado SSL comodín o normal de tus dominios:```toml webServer.port = 7500
webServer.user = "admin" webServer.password = "admin" webServer.tls.certFile = "server.crt" webServer.tls.keyFile = "server.key"
Luego visita `https://[serverAddr]:7500` para ver el panel de control en una conexión HTTPS segura, con nombre de usuario y contraseña ambos siendo `admin`.
### Interfaz de Administración del Cliente
La Interfaz de Administración del Cliente te ayuda a revisar y gestionar la configuración y los proxies de frpc.
Configura una dirección para la interfaz de administración para habilitar esta función:```toml
webServer.addr = "127.0.0.1"
webServer.port = 7400
webServer.user = "admin"
webServer.password = "admin"
Luego visita http://127.0.0.1:7400 para ver la interfaz de administración, con nombre de usuario y contraseña ambos siendo admin.
Puedes crear, actualizar y eliminar proxies y visitantes dinámicamente en tiempo de ejecución a través de la interfaz web o la API, sin reiniciar frpc.
Para habilitar esta función, configura store.path para especificar un archivo donde persistir las configuraciones:```toml
[store]
path = "./db.json"
Los proxies y visitantes gestionados a través de la Store se guardan en disco y se restauran automáticamente al reiniciar frpc. Funcionan junto con los proxies definidos en el archivo de configuración: las entradas de la Store tienen prioridad cuando hay conflictos de nombres.
### Monitor
Cuando el servidor web está habilitado, frps guardará los datos del monitor en caché durante 7 días. Se borrarán tras el reinicio del proceso.
También se admite Prometheus.
#### Prometheus
Habilite primero el dashboard y luego configure `enablePrometheus = true` en `frps.toml`.
`http://{dashboard_addr}/metrics` proporcionará los datos del monitor de Prometheus.
### Autenticación del cliente
Hay 2 métodos de autenticación para autenticar frpc con frps.
Puede decidir cuál usar configurando `auth.method` en `frpc.toml` y `frps.toml`; el predeterminado es token.
Configurar `auth.additionalScopes = ["HeartBeats"]` usará el método de autenticación configurado para añadir y validar la autenticación en cada heartbeat entre frpc y frps.
Configurar `auth.additionalScopes = ["NewWorkConns"]` hará lo mismo para cada nueva conexión de trabajo entre frpc y frps.
#### Autenticación por token
Al especificar `auth.method = "token"` en `frpc.toml` y `frps.toml`, se usará la autenticación basada en token.
Asegúrese de especificar el mismo `auth.token` en `frps.toml` y `frpc.toml` para que frpc supere la validación de frps.
##### Origen del token
frp admite la lectura de tokens de autenticación desde fuentes externas mediante la configuración `tokenSource`. Actualmente, se admite el origen de token basado en archivos.
**Origen de token basado en archivos:**```toml
# frpc.toml
auth.method = "token"
auth.tokenSource.type = "file"
auth.tokenSource.file.path = "/path/to/token/file"
El token se leerá del archivo especificado al inicio. Esto es útil para escenarios donde los tokens son gestionados por sistemas externos o necesitan mantenerse separados de los archivos de configuración por razones de seguridad.
Al especificar auth.method = "oidc" en frpc.toml y frps.toml, se utilizará la autenticación basada en OIDC.
OIDC significa OpenID Connect, y el flujo utilizado se denomina Client Credentials Grant.
Para utilizar este tipo de autenticación, configure frpc.toml y frps.toml de la siguiente manera:```toml
auth.method = "oidc" auth.oidc.issuer = "https://example-oidc-issuer.com/" auth.oidc.audience = "https://oidc-audience.com/.default"
nmap, requests, paramiko, colorama, pyfiglet, termcolor, tqdm, python-nmap, scapy, netifaces, ipaddress, socket, subprocess, os, sys, time, datetime, json, re, random, string, hashlib, base64, urllib, http, ftp, telnetlib, smtplib, poplib, imap, ldap, snmp, dns, ntp, dhcp, tftp, rpc, smb, mssql, mysql, postgresql, oracle, mongodb, redis, memcached, cassandra, couchdb, elasticsearch, rabbitmq, kafka, zookeeper, hadoop, spark, storm, flink, samza, beam, kudu, impala, hive, hbase, phoenix, drill, presto, trino, clickhouse, druid, influxdb, timescaledb, citus, greenplum, vertica, exadata, netezza, teradata, snowflake, redshift, bigquery, spanner, firestore, datastore, cosmosdb, dynamodb, couchbase, riak, voldemort, hazelcast, ignite, geode, gemfire, eclipse, apache, nginx, iis, tomcat, jetty, wildfly, glassfish, payara, openliberty, websphere, weblogic, jboss, undertow, resin, caddy, traefik, envoy, haproxy, varnish, squid, polipo, privoxy, tinyproxy, dante, socks, shadowsocks, v2ray, trojan, naiveproxy, hysteria, tuic, wireguard, openvpn, ipsec, pptp, l2tp, sstp, softether, zerotier, tailscale, headscale, nebula, tinc, freelan, n2n, tun2socks, gost, brook, graftcp, redsocks, iptables, nftables, pf, ipfw, shorewall, firewalld, ufw, ferm, arptables, ebtables, ipset, tc, htb, cbq, prio, sfq, red, tbf, netem, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel, cake, pie, codel, fq, qfq, drr, wrr, wred, gred, choke, blue, sfb, codel, pie, fq_codel,```tomlauth.method = "oidc" auth.oidc.clientID = "98692467-37de-409a-9fac-bb2585826f18" # Replace with OIDC client ID auth.oidc.clientSecret = "oidc_secret" auth.oidc.audience = "https://oidc-audience.com/.default" auth.oidc.tokenEndpointURL = "https://example-oidc-endpoint.com/oauth2/v2.0/token"
### Cifrado y compresión
Las funciones están desactivadas por defecto. Puedes activar el cifrado y/o la compresión:```toml
# frpc.toml
[[proxies]]
name = "ssh"
type = "tcp"
localPort = 22
remotePort = 6000
transport.useEncryption = true
transport.useCompression = true
Desde v0.50.0, el valor predeterminado de transport.tls.enable y transport.tls.disableCustomTLSFirstByte se ha cambiado a true, y TLS está habilitado por defecto.
Para la multiplexación de puertos, frp envía un primer byte 0x17 para establecer una conexión TLS. Esto solo tiene efecto cuando configuras transport.tls.disableCustomTLSFirstByte en false.
Para forzar que frps solo acepte conexiones TLS, configura transport.tls.force = true en frps.toml. Esto es opcional.
Configuración TLS de frpc:```toml
transport.tls.enable = true
transport.tls.certFile = "certificate.crt"
transport.tls.keyFile = "certificate.key"
transport.tls.trustedCaFile = "ca.crt"
**`frps` Configuración TLS:**```toml
transport.tls.force = true
transport.tls.certFile = "certificate.crt"
transport.tls.keyFile = "certificate.key"
transport.tls.trustedCaFile = "ca.crt"
Necesitarás un certificado CA raíz y al menos un certificado SSL/TLS. Puede ser autofirmado o regular (como Let's Encrypt u otro proveedor de certificados SSL/TLS).
Si usas frp mediante dirección IP y no mediante nombre de host, asegúrate de establecer la dirección IP adecuada en el área de Subject Alternative Name (SAN) al generar los certificados SSL/TLS.
Dado un ejemplo:
/etc/pki/tls/openssl.cnf en sistemas Linux y en /System/Library/OpenSSL/openssl.cnf en MacOS, y puedes copiarlo a la ruta actual, como cp /etc/pki/tls/openssl.cnf ./my-openssl.cnf. Si no, puedes crearlo tú mismo, como:```
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* compilar certificados de 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
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
* compilar certificados de 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
Los campos webServer son necesarios para habilitar la API HTTP:```toml
webServer.addr = "127.0.0.1" webServer.port = 7400
Luego ejecuta el comando `frpc reload -c ./frpc.toml` y espera unos 10 segundos para que `frpc` cree, actualice o elimine los proxies.
**Ten en cuenta que los parámetros globales del cliente no se modificarán excepto 'start'.**
`start` es una lista blanca global que se evalúa después de que todas las fuentes se fusionen (archivo de configuración/include/store).
Si `start` no está vacío, cualquier proxy o visitor que no esté listado allí no se iniciará, incluidas
las entradas creadas mediante la API de Store.
`start` se mantiene principalmente por compatibilidad y, en general, no se recomienda para nuevas configuraciones.
Prefiere `enabled` por proxy/por visitor, y mantén `start` vacío a menos que quieras explícitamente este
comportamiento de lista blanca global.
Puedes ejecutar el comando `frpc verify -c ./frpc.toml` antes de recargar para comprobar si hay errores de configuración.
### Obtener el estado de los proxies desde el cliente
Usa `frpc status -c ./frpc.toml` para obtener el estado de todos los proxies. Los campos `webServer` son necesarios para habilitar la API HTTP.
### Permitir solo ciertos puertos en el servidor
`allowPorts` en `frps.toml` se utiliza para evitar el abuso de puertos:```toml
# frps.toml
allowPorts = [
{ start = 2000, end = 3000 },
{ single = 3001 },
{ single = 3003 },
{ start = 4000, end = 50000 }
]
vhostHTTPPort y vhostHTTPSPort en frps pueden usar el mismo puerto que bindPort. frps detectará el protocolo de la conexión y lo manejará en consecuencia.
Lo que debes tener en cuenta es que si quieres configurar vhostHTTPSPort y bindPort en el mismo puerto, primero debes establecer transport.tls.disableCustomTLSFirstByte en false.
En el futuro, nos gustaría intentar permitir que múltiples proxies vinculen el mismo puerto remoto con diferentes protocolos.
[[proxies]] name = "ssh" type = "tcp" localPort = 22 remotePort = 6000 transport.bandwidthLimit = "1MB"
Establece `transport.bandwidthLimit` en la configuración de cada proxy para habilitar esta función. Las unidades admitidas son `MB` y `KB`.
Establece `transport.bandwidthLimitMode` en `client` o `server` para limitar el ancho de banda en el lado del cliente o del servidor. El valor predeterminado es `client`.
### Multiplexación de flujos TCP
frp admite la multiplexación de flujos TCP desde la v0.10.0, similar a la multiplexación de HTTP2, en cuyo caso todas las conexiones lógicas al mismo frpc se multiplexan en la misma conexión TCP.
Puedes deshabilitar esta función modificando `frps.toml` y `frpc.toml`:```toml
# frps.toml and frpc.toml, must be same
transport.tcpMux = false
KCP es un protocolo rápido y confiable que puede lograr el efecto de transmisión de una reducción de la latencia promedio del 30% al 40% y una reducción del retraso máximo por un factor de tres, a costa de un 10% al 20% más de ancho de banda desperdiciado que TCP.
El modo KCP utiliza UDP como transporte subyacente. Uso de KCP en frp:
bindPort = 7000
kcpBindPort = 7000
The `kcpBindPort` number can be the same number as `bindPort`, since `bindPort` field specifies a TCP port.
2. Configure `frpc.toml` to use KCP to connect to frps: ```toml
# frpc.toml
serverAddr = "x.x.x.x"
# Same as the 'kcpBindPort' in frps.toml
serverPort = 7000
transport.protocol = "kcp"
QUIC es un nuevo transporte multiplexado construido sobre UDP.
Uso de QUIC en frp:
bindPort = 7000
quicBindPort = 7000
The `quicBindPort` number can be the same number as `bindPort`, since `bindPort` field specifies a TCP port.
2. Configure `frpc.toml` to use QUIC to connect to frps: ```toml
# frpc.toml
serverAddr = "x.x.x.x"
# Same as the 'quicBindPort' in frps.toml
serverPort = 7000
transport.protocol = "quic"
De forma predeterminada, frps crea una nueva conexión frpc al servicio backend cuando un usuario realiza una solicitud. Con la agrupación de conexiones, frps mantiene un cierto número de conexiones preestablecidas, lo que reduce el tiempo necesario para establecer una conexión.
Esta función es adecuada para un gran número de conexiones cortas.
frps.toml: ```tomltransport.maxPoolCount = 5
2. Habilita y especifica el número del pool de conexiones: ```toml
# frpc.toml
transport.poolCount = 1
El balanceo de carga es compatible mediante group.
Esta funcionalidad solo está disponible actualmente para los tipos tcp, http y tcpmux.```toml
[[proxies]] name = "test1" type = "tcp" localPort = 8080 remotePort = 80 loadBalancer.group = "web" loadBalancer.groupKey = "123"
[[proxies]] name = "test2" type = "tcp" localPort = 8081 remotePort = 80 loadBalancer.group = "web" loadBalancer.groupKey = "123"
`loadBalancer.groupKey` se utiliza para la autenticación.
Las conexiones al puerto 80 se enviarán aleatoriamente a los proxies del mismo grupo.
Para el tipo `tcp`, `remotePort` en el mismo grupo debe ser el mismo.
Para el tipo `http`, `customDomains`, `subdomain`, `locations` deben ser los mismos.
### Comprobación de salud del servicio
La función de comprobación de salud puede ayudarte a lograr alta disponibilidad con equilibrio de carga.
Añade `healthCheck.type = "tcp"` o `healthCheck.type = "http"` para habilitar la comprobación de salud.
Con el tipo de comprobación de salud **tcp**, se hará ping al puerto del servicio (TCPing):```toml
# frpc.toml
[[proxies]]
name = "test1"
type = "tcp"
localPort = 22
remotePort = 6000
# Enable TCP health check
healthCheck.type = "tcp"
# TCPing timeout seconds
healthCheck.timeoutSeconds = 3
# If health check failed 3 times in a row, the proxy will be removed from frps
healthCheck.maxFailed = 3
# A health check every 10 seconds
healthCheck.intervalSeconds = 10
Con el tipo de comprobación de salud http, se enviará una solicitud HTTP al servicio y se espera una respuesta HTTP 2xx OK:```toml
[[proxies]] name = "web" type = "http" localIP = "127.0.0.1" localPort = 80 customDomains = ["test.example.com"]
healthCheck.type = "http"
healthCheck.path = "/status" healthCheck.timeoutSeconds = 3 healthCheck.maxFailed = 3 healthCheck.intervalSeconds = 10
### Reescritura del encabezado HTTP Host
Por defecto, frp no modifica en absoluto las solicitudes HTTP tunelizadas, ya que es una copia byte por byte.
Sin embargo, hablando de servidores web y solicitudes HTTP, su servidor web podría depender del encabezado HTTP `Host` para determinar el sitio web al que se accede. frp puede reescribir el encabezado `Host` al reenviar las solicitudes HTTP, con el campo `hostHeaderRewrite`:```toml
# frpc.toml
[[proxies]]
name = "web"
type = "http"
localPort = 80
customDomains = ["test.example.com"]
hostHeaderRewrite = "dev.example.com"
The HTTP request will have the Host header rewritten to Host: dev.example.com when it reaches the actual web server, although the request from the browser probably has Host: test.example.com.
Similar to Host, You can override other HTTP request and response headers with proxy type http.```toml
[[proxies]] name = "web" type = "http" localPort = 80 customDomains = ["test.example.com"] hostHeaderRewrite = "dev.example.com" requestHeaders.set.x-from-where = "frp" responseHeaders.set.foo = "bar"
En este ejemplo, se establecerá la cabecera `x-from-where: frp` en la solicitud HTTP y `foo: bar` en la respuesta HTTP.
### Obtener la IP real
#### HTTP X-Forwarded-For
Esta función es para proxies `http` o proxies con los plugins `https2http` y `https2https` habilitados.
Puede obtener la IP real del usuario desde las cabeceras de solicitud HTTP `X-Forwarded-For`.
#### Protocolo Proxy
frp admite el Protocolo Proxy para enviar la IP real del usuario a los servicios locales.
Aquí hay un ejemplo para el servicio https:```toml
# frpc.toml
[[proxies]]
name = "web"
type = "https"
localPort = 443
customDomains = ["test.example.com"]
# now v1 and v2 are supported
transport.proxyProtocolVersion = "v2"
Puedes habilitar el soporte de Proxy Protocol en nginx para exponer la IP real del usuario en la cabecera HTTP X-Real-IP, y luego leer la cabecera X-Real-IP en tu servicio web para obtener la IP real.
Cualquiera que pueda adivinar la URL de tu túnel puede acceder a tu servidor web local a menos que lo protejas con una contraseña.
Esto aplica Autenticación Básica HTTP en todas las solicitudes con el nombre de usuario y la contraseña especificados en el archivo de configuración de frpc.
Solo se puede habilitar cuando el tipo de proxy es http.```toml
[[proxies]] name = "web" type = "http" localPort = 80 customDomains = ["test.example.com"] httpUser = "abc" httpPassword = "abc"
Visita `http://test.example.com` en el navegador y ahora se te solicita ingresar el nombre de usuario y la contraseña.
### Nombres de Subdominios Personalizados
Es conveniente usar la configuración `subdomain` para los tipos http y https cuando muchas personas comparten un solo servidor frps.```toml
# frps.toml
subDomainHost = "frps.com"
Resuelve *.frps.com a la IP del servidor frps. Esto normalmente se denomina un registro DNS comodín.```toml
[[proxies]] name = "web" type = "http" localPort = 80 subdomain = "test"
Ahora puedes visitar tu servicio web en `test.frps.com`.
Ten en cuenta que si `subdomainHost` no está vacío, `customDomains` no debe ser el subdominio de `subdomainHost`.
### Enrutamiento de URL
frp admite el reenvío de solicitudes HTTP a diferentes servicios web de backend mediante el enrutamiento de URL.
`locations` especifica el prefijo de la URL utilizado para el enrutamiento. frps primero busca la ubicación de prefijo más específica proporcionada por cadenas literales, independientemente del orden en que aparezcan.```toml
# frpc.toml
[[proxies]]
name = "web01"
type = "http"
localPort = 80
customDomains = ["web.example.com"]
locations = ["/"]
[[proxies]]
name = "web02"
type = "http"
localPort = 81
customDomains = ["web.example.com"]
locations = ["/news", "/about"]
Las solicitudes HTTP con prefijo de URL /news o /about se reenviarán a web02 y las demás solicitudes a web01.
frp admite recibir sockets TCP dirigidos a diferentes proxies en un solo puerto en frps, similar a vhostHTTPPort y vhostHTTPSPort.
El único método de multiplexación de puertos TCP compatible disponible actualmente es httpconnect: túnel HTTP CONNECT.
Al configurar tcpmuxHTTPConnectPort con un valor distinto de 0 en frps, frps escuchará en este puerto las solicitudes HTTP CONNECT.
El host de la solicitud HTTP CONNECT se utilizará para hacer coincidir el proxy en frps. Los hosts de proxy se pueden configurar en frpc configurando customDomains y/o subdomain bajo proxies tcpmux, cuando multiplexer = "httpconnect".
Por ejemplo:```toml
bindPort = 7000 tcpmuxHTTPConnectPort = 1337
I need the input content to translate. Please provide the chunk of Markdown content you'd like me to translate from English to Spanish.```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000
[[proxies]]
name = "proxy1"
type = "tcpmux"
multiplexer = "httpconnect"
customDomains = ["test1"]
localPort = 80
[[proxies]]
name = "proxy2"
type = "tcpmux"
multiplexer = "httpconnect"
customDomains = ["test2"]
localPort = 8080
En la configuración anterior, se puede contactar con frps en el puerto 1337 con una cabecera HTTP CONNECT como la siguiente:``` CONNECT test1 HTTP/1.1\r\n\r\n
y la conexión se enrutará a `proxy1`.
### Conexión a frps a través de PROXY
frpc puede conectarse a frps mediante un proxy si se establece la variable de entorno del sistema `HTTP_PROXY`, o si `transport.proxyURL` está configurado en el archivo frpc.toml.
Solo funciona cuando el protocolo es tcp.```toml
# frpc.toml
serverAddr = "x.x.x.x"
serverPort = 7000
transport.proxyURL = "http://user:[email protected]:8080"
Añadido en v0.56.0
Podemos usar la sintaxis de rango de las plantillas de Go combinada con la función integrada parseNumberRangePair para lograr el mapeo de rangos de puertos.
El siguiente ejemplo, al ejecutarse, creará 8 proxies llamados test-6000, test-6001 ... test-6007, cada uno mapeando el puerto remoto al puerto local.```
{{- range $_, $v := parseNumberRangePair "6000-6006,6007" "6000-6006,6007" }}
[[proxies]]
name = "tcp-{{ $v.First }}"
type = "tcp"
localPort = {{ $v.First }}
remotePort = {{ $v.Second }}
{{- end }}
### Complementos de Cliente
frpc solo reenvía solicitudes a puertos TCP o UDP locales de forma predeterminada.
Los complementos se utilizan para proporcionar funciones avanzadas. Hay complementos integrados como `unix_domain_socket`, `http_proxy`, `socks5`, `static_file`, `http2https`, `https2http`, `https2https` y puedes ver [ejemplos de uso](#example-usage).
Usando el complemento **http_proxy**:```toml
# frpc.toml
[[proxies]]
name = "http_proxy"
type = "tcp"
remotePort = 6000
[proxies.plugin]
type = "http_proxy"
httpUser = "abc"
httpPassword = "abc"
httpUser y httpPassword son parámetros de configuración utilizados en el plugin http_proxy.
Lee el documento.
Encuentra más plugins en gofrp/plugin.
añadido en v0.53.0
frp admite escuchar un puerto SSH en el lado de frps y logra el proxy del protocolo TCP a través del protocolo SSH -R, sin depender de frpc.```toml
sshTunnelGateway.bindPort = 2200
Cuando se ejecuta `./frps -c frps.toml`, se creará automáticamente un archivo de clave privada llamado `.autogen_ssh_key` en el directorio de trabajo actual. Este archivo de clave privada generado será utilizado por el servidor SSH en frps.
Al ejecutar el comando```bash
ssh -R :80:127.0.0.1:8080 v0@{frp address} -p 2200 tcp --proxy_name "test-tcp" --remote_port 9090
configura un proxy en frps que reenvía el servicio local 8080 al puerto 9090.```bash frp (via SSH) (Ctrl+C to quit)
User: ProxyName: test-tcp Type: tcp RemoteAddress: :9090
Esto es equivalente a:```bash
frpc tcp --proxy_name "test-tcp" --local_ip 127.0.0.1 --local_port 8080 --remote_port 9090
Consulte este documento para obtener más información.
Funcionalidad alfa añadida en v0.62.0
La funcionalidad VirtualNet permite a frp crear y gestionar conexiones de red virtual entre clientes y visitantes a través de una interfaz TUN. Esto permite el enrutamiento a nivel de IP entre máquinas, ampliando frp más allá del simple reenvío de puertos para admitir conectividad de red completa.
Para obtener información detallada sobre la configuración y el uso, consulte la documentación de VirtualNet.
frp admite feature gates para habilitar o deshabilitar funcionalidades experimentales. Esto permite a los usuarios probar nuevas funcionalidades antes de que se consideren estables.
| Nombre | Etapa | Predeterminado | Descripción |
|---|---|---|---|
| VirtualNet | ALPHA | false | Capacidades de red virtual para frp |
Para habilitar una funcionalidad experimental, agregue el feature gate a su configuración:```toml featureGates = { VirtualNet = true }
### Ciclo de vida de las funciones
Las funciones suelen pasar por tres etapas:
1. **ALPHA**: Deshabilitada por defecto, puede ser inestable
2. **BETA**: Puede estar habilitada por defecto, más estable pero aún en evolución
3. **GA (Disponibilidad General)**: Habilitada por defecto, lista para uso en producción
## Proyectos Relacionados
* [gofrp/plugin](https://github.com/gofrp/plugin) - Un repositorio para plugins de frp que contiene una variedad de plugins implementados basados en el mecanismo de extensión de frp, satisfaciendo las necesidades de personalización de diferentes escenarios.
* [gofrp/tiny-frpc](https://github.com/gofrp/tiny-frpc) - Una versión ligera del cliente frp (alrededor de 3.5MB como mínimo) implementada usando el protocolo ssh, que soporta algunas de las funciones más utilizadas, adecuada para dispositivos con recursos limitados.
## Contribuciones
¿Te interesa participar? ¡Nos gustaría ayudarte!
* Echa un vistazo a nuestra [lista de issues](https://github.com/fatedier/frp/issues) y considera enviar un Pull Request a la **rama dev**.
* Si quieres añadir una nueva función, crea primero un issue para describir la nueva función, así como el enfoque de implementación. Una vez que la propuesta sea aceptada, crea una implementación de las nuevas funciones y envíala como pull request.
* Perdón por mi pobre inglés. Las mejoras para este documento son bienvenidas, incluso correcciones de erratas.
* Si tienes grandes ideas, envía un correo a [email protected].
**Nota: Preferimos que des tu consejo en [issues](https://github.com/fatedier/frp/issues), para que otros con la misma pregunta puedan buscarlo rápidamente y no tengamos que responder repetidamente.**
## Donaciones
Si frp te ayuda mucho, puedes apoyarnos de las siguientes maneras:
### GitHub Sponsors
Apóyanos a través de [Github Sponsors](https://github.com/sponsors/fatedier).
Puedes hacer que el logo de tu empresa aparezca en el archivo README de este proyecto.
### PayPal
Dona dinero a través de [PayPal](https://www.paypal.me/fatedier) a mi cuenta **[email protected]**.