frp
0.61.0
LEIA-ME | 中文文档
frp é um projeto de código aberto com seu desenvolvimento contínuo possibilitado inteiramente pelo apoio de nossos incríveis patrocinadores. Se você quiser se juntar a eles, considere patrocinar o desenvolvimento do frp.
frp é um proxy reverso rápido que permite expor um servidor local localizado atrás de um NAT ou firewall para a Internet. Atualmente suporta TCP e UDP , bem como protocolos HTTP e HTTPS , permitindo que solicitações sejam encaminhadas para serviços internos via nome de domínio.
frp também oferece um modo de conexão P2P.
Status de desenvolvimento
Sobre V2
Arquitetura
Exemplo de uso
Acesse seu computador em uma rede LAN via SSH
Vários serviços SSH compartilhando a mesma porta
Acessando serviços Web internos com domínios personalizados na LAN
Encaminhar solicitações de consulta DNS
Encaminhar soquete de domínio Unix
Expor um servidor de arquivos HTTP simples
Habilitar HTTPS para um serviço HTTP(S) local
Exponha seu serviço de forma privada
Modo P2P
Características
HTTP X-Forwarded-For
Protocolo proxy
Para cada proxy
TLS
Autenticação de token
Autenticação OIDC
Prometeu
Arquivos de configuração
Usando variáveis de ambiente
Dividir configurações em arquivos diferentes
Painel do servidor
IU de administração do cliente
Monitor
Autenticando o Cliente
Criptografia e compactação
Configuração frpc de recarga a quente
Obtenha o status de proxy do cliente
Permitindo apenas determinadas portas no servidor
Reutilização de Porta
Limite de largura de banda
Multiplexação de fluxo TCP
Suporte ao protocolo KCP
Suporte ao protocolo QUIC
Pool de conexões
Balanceamento de carga
Verificação de integridade do serviço
Reescrevendo o cabeçalho do host HTTP
Configurando outros cabeçalhos HTTP
Obtenha IP real
Exigir autenticação básica HTTP (senha) para serviços da Web
Nomes de subdomínios personalizados
Roteamento de URL
Multiplexação de porta TCP
Conectando-se ao frps via PROXY
Mapeamento de intervalo de portas
Plug-ins de cliente
Plug-ins de gerenciamento de servidor
Gateway de túnel SSH
Projetos Relacionados
Contribuindo
Doação
Patrocinadores do GitHub
PayPal
frp está atualmente em desenvolvimento. Você pode experimentar a versão mais recente no branch master ou usar o branch dev para acessar a versão atualmente em desenvolvimento.
Atualmente estamos trabalhando na versão 2 e tentando realizar algumas refatorações e melhorias de código. No entanto, observe que não será compatível com a versão 1.
Faremos a transição da versão 0 para a versão 1 no momento apropriado e aceitaremos apenas correções de bugs e melhorias, em vez de grandes solicitações de recursos.
A complexidade e dificuldade da versão v2 são muito maiores do que o previsto. Só posso trabalhar no seu desenvolvimento durante períodos de tempo fragmentados, e as interrupções constantes prejudicam significativamente a produtividade. Dada esta situação, continuaremos a otimizar e iterar na versão atual até que tenhamos mais tempo livre para prosseguir com a revisão da versão principal.
O conceito por trás da v2 é baseado em meus anos de experiência e reflexão no domínio nativo da nuvem, especialmente em K8s e ServiceMesh. Seu núcleo é um proxy modernizado de quatro e sete camadas, semelhante ao enviado. Este proxy em si é altamente escalável, não apenas capaz de implementar a funcionalidade de penetração na intranet, mas também aplicável a vários outros domínios. Com base neste núcleo altamente escalável, pretendemos implementar todos os recursos do frp v1 e, ao mesmo tempo, abordar as funcionalidades que antes eram inatingíveis ou difíceis de implementar de maneira elegante. Além disso, manteremos capacidades eficientes de desenvolvimento e iteração.
Além disso, imagino que o próprio frp se torne um sistema e plataforma altamente extensível, semelhante à forma como podemos fornecer uma gama de recursos de extensão baseados em K8s. No K8s, podemos personalizar o desenvolvimento de acordo com as necessidades da empresa, utilizando recursos como CRD, modo controlador, webhook, CSI e CNI. No frp v1, introduzimos o conceito de plug-ins de servidor, que implementou alguma extensibilidade básica. No entanto, ele depende de um protocolo HTTP simples e exige que os usuários iniciem processos independentes e os gerenciem por conta própria. Esta abordagem está longe de ser flexível e conveniente, e as exigências do mundo real variam muito. Não é realista esperar que um projeto de código aberto sem fins lucrativos, mantido por alguns indivíduos, atenda às necessidades de todos.
Finalmente, reconhecemos que o design atual de módulos como gerenciamento de configuração, verificação de permissão, gerenciamento de certificados e gerenciamento de API não é moderno o suficiente. Embora possamos realizar algumas otimizações na versão v1, garantir a compatibilidade continua sendo um problema desafiador que requer um esforço considerável para ser resolvido.
Agradecemos sinceramente o seu apoio ao frp.
Para começar, baixe o programa mais recente para seu sistema operacional e arquitetura na página Release.
Em seguida, coloque o binário frps e o arquivo de configuração do servidor no Servidor A, que possui um endereço IP público.
Por fim, coloque o binário frpc e o arquivo de configuração do cliente no Servidor B, que está localizado em uma LAN que não pode ser acessada diretamente pela Internet pública.
Alguns antivírus marcam indevidamente o frpc como malware e o excluem. Isso se deve ao fato de o frp ser uma ferramenta de rede capaz de criar proxies reversos. Às vezes, os antivírus sinalizam proxies reversos devido à sua capacidade de contornar as restrições de porta do firewall. Se você estiver usando antivírus, talvez seja necessário colocar/excluir frpc na lista de permissões nas configurações do antivírus para evitar quarentena/exclusão acidental. Consulte a edição 3637 para obter mais detalhes.
Modifique frps.toml no servidor A definindo o bindPort para clientes frp se conectarem:
#frps.tomlbindPort=7000
Inicie frps no servidor A:
./frps -c ./frps.toml
Modifique frpc.toml no servidor B e defina o campo serverAddr para o endereço IP público do seu servidor frps:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "ssh"type = "tcp"localIP = "127.0.0.1"localPort = 22remotePort = 6000
Observe que localPort (escutado no cliente) e remotePort (exposto no servidor) são usados para tráfego que entra e sai do sistema frp, enquanto serverPort é usado para comunicação entre frps e frpc.
Inicie frpc no servidor B:
./frpc -c ./frpc.toml
Para acessar o servidor B de outra máquina através do servidor A via SSH (assumindo que o nome de usuário seja test ), use o seguinte comando:
ssh -oPort=6000 test@xxxx
Este exemplo implementa vários serviços SSH expostos pela mesma porta usando um proxy do tipo tcpmux. Da mesma forma, desde que o cliente suporte o método de conexão proxy HTTP Connect, a reutilização da porta pode ser alcançada dessa forma.
Implante frps em uma máquina com IP público e modifique o arquivo frps.toml. Aqui está uma configuração simplificada:
bindPort = 7000tcpmuxHTTPConnectPort = 5002
Implante o frpc na máquina interna A com a seguinte configuração:
serverAddr = "xxxx"serverPort = 7000[[proxies]]name = "ssh1"type = "tcpmux"multiplexer = "httpconnect"customDomains = ["machine-a.example.com"]localIP = "127.0.0.1"localPort = 22
Implante outro frpc na máquina interna B com a seguinte configuração:
serverAddr = "xxxx"serverPort = 7000[[proxies]]name = "ssh2"type = "tcpmux"multiplexer = "httpconnect"customDomains = ["machine-b.example.com"]localIP = "127.0.0.1"localPort = 22
Para acessar a máquina interna A usando SSH ProxyCommand, assumindo que o nome de usuário seja "test":
ssh -o 'proxycommand socat - PROXY:xxxx:%h:%p,proxyport=5002' [email protected]
Para acessar a máquina interna B, a única diferença é o nome do domínio, assumindo que o nome de usuário seja "teste":
ssh -o 'proxycommand socat - PROXY:xxxx:%h:%p,proxyport=5002' [email protected]
Às vezes, precisamos expor um serviço web local atrás de uma rede NAT para outras pessoas para fins de teste com nosso próprio nome de domínio.
Infelizmente, não podemos resolver um nome de domínio para um IP local. No entanto, podemos usar frp para expor um serviço HTTP(S).
Modifique frps.toml e defina a porta HTTP do vhost como 8080:
# frps.tomlbindPort = 7000vhostHTTPPort = 8080
Se quiser configurar um proxy https, você precisa configurar o vhostHTTPSPort .
Inicie frps :
./frps -c ./frps.toml
Modifique frpc.toml e defina serverAddr como o endereço IP do servidor frps remoto. Especifique o localPort do seu serviço web:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "web"type = "http"localPort = 80customDomains = ["www.example.com"]
Inicie frpc :
./frpc -c ./frpc.toml
Mapeie o registro A de www.example.com para o IP público do servidor frps remoto ou para um registro CNAME apontando para seu domínio original.
Visite seu serviço da web local usando o URL http://www.example.com:8080 .
Modifique frps.toml :
#frps.tomlbindPort=7000
Inicie frps :
./frps -c ./frps.toml
Modifique frpc.toml e defina serverAddr como o endereço IP do servidor frps remoto. Encaminhe solicitações de consulta DNS para o servidor DNS público do Google 8.8.8.8:53 :
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "dns"type = "udp"localIP = "8.8.8.8"localPort = 53remotePort = 6000
Inicie o frpc:
./frpc -c ./frpc.toml
Teste a resolução DNS usando o comando dig :
dig @xxxx -p 6000 www.google.com
Exponha um soquete de domínio Unix (por exemplo, o soquete daemon Docker) como TCP.
Configure frps como acima.
Inicie frpc com a seguinte configuração:
# 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 "
Teste a configuração obtendo a versão do docker usando curl :
curl http://xxxx:6000/version
Exponha um servidor de arquivos HTTP simples para acessar arquivos armazenados na LAN a partir da Internet pública.
Configure frps conforme descrito acima e então:
Inicie frpc com a seguinte configuração:
# 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"
Visite http://xxxx:6000/static/ em seu navegador e especifique o nome de usuário e a senha corretos para visualizar os arquivos em /tmp/files na máquina frpc .
Você pode substituir https2https pelo plugin e apontar o localAddr para um endpoint HTTPS.
Inicie frpc com a seguinte configuração:
# 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- de onde = "frp"
Visite https://test.example.com .
Para mitigar os riscos associados à exposição de determinados serviços diretamente à rede pública, o modo STCP (Secret TCP) exige que uma chave pré-compartilhada seja usada para acesso ao serviço de outros clientes.
Configure frps da mesma forma que acima.
Inicie frpc na máquina B com a seguinte configuração. Este exemplo é para expor o serviço SSH (porta 22) e observe o campo secretKey para a chave pré-compartilhada e que o campo remotePort é removido aqui:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[proxies]]name = "secret_ssh"type = "stcp"secretKey = "abcdefg"localIP = "127.0.0.1"localPort = 22
Inicie outro frpc (normalmente em outra máquina C) com a seguinte configuração para acessar o serviço SSH com uma chave de segurança (campo secretKey ):
# frpc.tomlserverAddr = "xxxx"serverPort = 7000[[visitors]]name = "secret_ssh_visitor"type = "stcp"serverName = "secret_ssh"secretKey = "abcdefg"bindAddr = "127.0.0.1"bindPort = 6000
Na máquina C, conecte-se ao SSH na máquina B, usando este comando:
ssh -oPort=6000 127.0.0.1
O xtcp foi projetado para transmitir grandes quantidades de dados diretamente entre clientes. Um servidor frps ainda é necessário, já que P2P aqui se refere apenas à transmissão real de dados.
Observe que pode não funcionar com todos os tipos de dispositivos NAT. Você pode querer recorrer ao stcp se o xtcp não funcionar.
Inicie frpc na máquina B e exponha a porta SSH. Observe que o campo remotePort foi removido:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000# configure um novo servidor de atordoamento se o padrão não estiver disponível.# natHoleStunServer = "xxx"[[proxies]]name = "p2p_ssh"type = "xtcp"secretKey = " abcdefg"localIP = "127.0.0.1"localPort = 22
Inicie outro frpc (normalmente em outra máquina C) com a configuração para conectar-se ao SSH usando o modo P2P:
# frpc.tomlserverAddr = "xxxx"serverPort = 7000# configure um novo servidor de atordoamento se o padrão não estiver disponível.# natHoleStunServer = "xxx"[[visitors]]name = "p2p_ssh_visitor"type = "xtcp"serverName = " p2p_ssh"secretKey = "abcdefg"bindAddr = "127.0.0.1"bindPort = 6000# quando a persistência automática do túnel for necessária, defina-a como truekeepTunnelOpen = false
Na máquina C, conecte-se ao SSH na máquina B, usando este comando:
ssh -oPort=6000 127.0.0.1
Desde a v0.52.0, oferecemos suporte a TOML, YAML e JSON para configuração. Observe que o INI está obsoleto e será removido em versões futuras. Novos recursos estarão disponíveis apenas em TOML, YAML ou JSON. Os usuários que desejam esses novos recursos devem mudar seu formato de configuração de acordo.
Leia os exemplos completos de arquivos de configuração para descobrir ainda mais recursos não descritos aqui.
Os exemplos usam o formato TOML, mas você ainda pode usar YAML ou JSON.
Esses arquivos de configuração são apenas para referência. Por favor, não use esta configuração diretamente para executar o programa, pois pode haver vários problemas.
Arquivo de configuração completo para frps (servidor)
Arquivo de configuração completo para frpc (cliente)
Variáveis de ambiente podem ser referenciadas no arquivo de configuração, usando o formato padrão do Go:
# 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 }}" Com a configuração acima, variáveis podem ser passadas para o programa frpc assim:
export FRP_SERVER_ADDR=x.x.x.x export FRP_SSH_REMOTE_PORT=6000 ./frpc -c ./frpc.toml
frpc renderizará o modelo do arquivo de configuração usando variáveis de ambiente do sistema operacional. Lembre-se de prefixar sua referência com .Envs .
Você pode dividir várias configurações de proxy em arquivos diferentes e incluí-los no arquivo principal.
# frpc.tomlserverAddr = "xxxx"serverPort = 7000includes = ["./confd/*.toml"]
# ./confd/test.toml[[proxies]]name = "ssh"type = "tcp"localIP = "127.0.0.1"localPort = 22remotePort = 6000
Verifique o status do frp e as informações estatísticas dos proxies pelo Dashboard.
Configure uma porta para o painel para ativar este recurso:
# O valor padrão é 127.0.0.1. Altere para 0.0.0.0 quando quiser acessá-lo de uma rede pública.webServer.addr = "0.0.0.0"webServer.port = 7500# nome de usuário e senha do painel são opcionaiswebServer.user = "admin"webServer.password = " administrador"
Em seguida, visite http://[serverAddr]:7500 para ver o painel, com nome de usuário e senha sendo admin .
Além disso, você pode usar a porta HTTPS usando o curinga do seu domínio ou o certificado SSL normal:
webServer.port = 7500# nome de usuário e senha do painel são opcionaiswebServer.user = "admin"webServer.password = "admin"webServer.tls.certFile = "server.crt"webServer.tls.keyFile = "server.key"
Em seguida, visite https://[serverAddr]:7500 para ver o painel em uma conexão HTTPS segura, com nome de usuário e senha admin .
A UI de administração do cliente ajuda a verificar e gerenciar a configuração do frpc.
Configure um endereço para a UI administrativa para ativar este recurso:
webServer.addr = "127.0.0.1"webServer.port = 7400webServer.user = "admin"webServer.password = "admin"
Em seguida, visite http://127.0.0.1:7400 para ver a interface do administrador, com nome de usuário e senha sendo admin .
Quando o servidor web estiver habilitado, o frps salvará os dados do monitor em cache por 7 dias. Ele será limpo após o reinício do processo.
Prometheus também é compatível.
Habilite o painel primeiro e depois configure enablePrometheus = true em frps.toml .
http://{dashboard_addr}/metrics fornecerá dados do monitor prometheus.
Existem 2 métodos de autenticação para autenticar frpc com frps.
Você pode decidir qual usar configurando auth.method em frpc.toml e frps.toml , o padrão é token.
Configurar auth.additionalScopes = ["HeartBeats"] usará o método de autenticação configurado para adicionar e validar a autenticação em cada pulsação entre frpc e frps.
Configurar auth.additionalScopes = ["NewWorkConns"] fará o mesmo para cada nova conexão de trabalho entre frpc e frps.
Ao especificar auth.method = "token" em frpc.toml e frps.toml - será usada autenticação baseada em token.
Certifique-se de especificar o mesmo auth.token em frps.toml e frpc.toml para que frpc passe na validação de frps
Ao especificar auth.method = "oidc" em frpc.toml e frps.toml - será usada autenticação baseada em OIDC.
OIDC significa OpenID Connect, e o fluxo usado é denominado Client Credentials Grant.
Para usar este tipo de autenticação - configure frpc.toml e frps.toml da seguinte forma:
# 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" # Substitua pelo cliente 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"
Os recursos estão desativados por padrão. Você pode ativar a criptografia e/ou compactação:
# frpc.toml[[proxies]]name = "ssh"type = "tcp"localPort = 22remotePort = 6000transport.useEncryption = truetransport.useCompression = true
Desde a v0.50.0, o valor padrão de transport.tls.enable e transport.tls.disableCustomTLSFirstByte foi alterado para true e tls é habilitado por padrão.
Para multiplexação de portas, o frp envia um primeiro byte 0x17 para discar uma conexão TLS. Isso só entra em vigor quando você configura transport.tls.disableCustomTLSFirstByte como false.
Para impor que frps aceite apenas conexões TLS - configure transport.tls.force = true em frps.toml . Isso é opcional.
Configurações de TLS frpc :
transport.tls.enable = truetransport.tls.certFile = "certificate.crt"transport.tls.keyFile = "certificate.key"transport.tls.trustedCaFile = "ca.crt"
Configurações TLS frps :
transport.tls.force = truetransport.tls.certFile = "certificate.crt"transport.tls.keyFile = "certificate.key"transport.tls.trustedCaFile = "ca.crt"
Você precisará de um certificado CA raiz e de pelo menos um certificado SSL/TLS . Pode ser autoassinado ou regular (como Let's Encrypt ou outro provedor de certificado SSL/TLS).
Se você estiver usando frp por meio de endereço IP e não de nome de host, certifique-se de definir o endereço IP apropriado na área Nome alternativo do assunto (SAN) ao gerar certificados SSL/TLS.
Dado um exemplo:
Prepare o arquivo de configuração do openssl. Ele existe em /etc/pki/tls/openssl.cnf no sistema Linux e /System/Library/OpenSSL/openssl.cnf no MacOS, e você pode copiá-lo para o caminho atual, como cp /etc/pki/tls/openssl.cnf ./my-openssl.cnf . Caso contrário, você pode construí-lo sozinho, 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
construir certificados 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
construir certificados 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
construir certificados 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
Os campos webServer são obrigatórios para ativar a API HTTP:
#frpc.tomlwebServer.addr = "127.0.0.1"webServer.port = 7400
Em seguida, execute o comando frpc reload -c ./frpc.toml e aguarde cerca de 10 segundos para permitir que frpc crie, atualize ou remova proxies.
Observe que os parâmetros globais do cliente não serão modificados, exceto 'start'.
Você pode executar o comando frpc verify -c ./frpc.toml antes de recarregar para verificar se há erros de configuração.
Use frpc status -c ./frpc.toml para obter o status de todos os proxies. Os campos webServer são obrigatórios para ativar a API HTTP.
allowPorts em frps.toml é usado para evitar abuso de portas:
# frps.tomlallowPorts = [
{início = 2.000, fim = 3.000},
{único = 3001},
{único = 3003},
{início = 4.000, fim = 50.000}
] vhostHTTPPort e vhostHTTPSPort em frps podem usar a mesma porta com bindPort . O frps detectará o protocolo da conexão e o tratará de forma correspondente.
O que você precisa prestar atenção é que se quiser configurar vhostHTTPSPort e bindPort para a mesma porta, você precisa primeiro definir transport.tls.disableCustomTLSFirstByte como false.
Gostaríamos de tentar permitir que vários proxies vinculem uma mesma porta remota a protocolos diferentes no futuro.
# frpc.toml[[proxies]]name = "ssh"type = "tcp"localPort = 22remotePort = 6000transport.bandwidthLimit = "1MB"
Defina transport.bandwidthLimit na configuração de cada proxy para ativar esse recurso. As unidades suportadas são MB e KB .
Configure transport.bandwidthLimitMode como client ou server para limitar a largura de banda no lado do cliente ou servidor. O padrão é client .
frp suporta multiplexação de fluxo tcp desde v0.10.0 como multiplexação HTTP2, caso em que todas as conexões lógicas para o mesmo frpc são multiplexadas na mesma conexão TCP.
Você pode desativar esse recurso modificando frps.toml e frpc.toml :
# frps.toml e frpc.toml, devem ser sametransport.tcpMux = false
KCP é um protocolo rápido e confiável que pode alcançar o efeito de transmissão de uma redução da latência média em 30% a 40% e redução do atraso máximo por um fator de três, ao custo de 10% a 20% mais largura de banda desperdiçada que o TCP.
O modo KCP usa UDP como transporte subjacente. Usando KCP em frp:
Habilite KCP em frps:
# frps.tomlbindPort = 7000# Especifique uma porta UDP para KCP.kcpBindPort = 7000
O número kcpBindPort pode ser o mesmo número de bindPort , pois o campo bindPort especifica uma porta TCP.
Configure frpc.toml para usar KCP para conectar-se ao frps:
# frpc.tomlserverAddr = "xxxx"# O mesmo que 'kcpBindPort' em frps.tomlserverPort = 7000transport.protocol = "kcp"
QUIC é um novo transporte multiplexado construído sobre UDP.
Usando QUIC em frp:
Habilite QUIC em frps:
# frps.tomlbindPort = 7000# Especifique uma porta UDP para QUIC.quicBindPort = 7000
O número quicBindPort pode ser o mesmo número de bindPort , pois o campo bindPort especifica uma porta TCP.
Configure frpc.toml para usar QUIC para conectar-se ao frps:
# frpc.tomlserverAddr = "xxxx"# O mesmo que 'quicBindPort' em frps.tomlserverPort = 7000transport.protocol = "quic"
Por padrão, o frps cria uma nova conexão frpc com o serviço de back-end mediante solicitação do usuário. Com o pooling de conexões, o frps mantém um certo número de conexões pré-estabelecidas, reduzindo o tempo necessário para estabelecer uma conexão.
Este recurso é adequado para um grande número de conexões curtas.
Configure o limite de contagem de pool que cada proxy pode usar em frps.toml :
# frps.tomltransport.maxPoolCount = 5
Habilite e especifique o número do pool de conexões:
# frpc.tomltransport.poolCount = 1
O balanceamento de carga é suportado por group .
Este recurso está disponível apenas para os tipos tcp , http , tcpmux agora.
# 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 é usado para autenticação.
As conexões com a porta 80 serão despachadas aleatoriamente para proxies do mesmo grupo.
Para o tipo tcp , remotePort no mesmo grupo deve ser o mesmo.
Para o tipo http , customDomains , subdomain , locations devem ser os mesmos.
O recurso de verificação de integridade pode ajudá-lo a obter alta disponibilidade com balanceamento de carga.
Adicione healthCheck.type = "tcp" ou healthCheck.type = "http" para ativar a verificação de integridade.
Com verificação de integridade do tipo tcp , a porta de serviço receberá ping (TCPing):
# frpc.toml[[proxies]]name = "test1"type = "tcp"localPort = 22remotePort = 6000# Habilitar verificação de integridade do TCPhealthCheck.type = "tcp"# Tempo limite de TCPingsecondhealthCheck.timeoutSeconds = 3# Se a verificação de integridade falhar 3 vezes consecutivamente, o proxy será removido de frpshealthCheck.maxFailed = 3# Uma verificação de integridade a cada 10 segundoshealthCheck.intervalSeconds = 10
Com o tipo de verificação de integridade http , uma solicitação HTTP será enviada ao serviço e uma resposta HTTP 2xx OK é esperada:
# frpc.toml[[proxies]]name = "web"type = "http"localIP = "127.0.0.1"localPort = 80customDomains = ["test.example.com"]# Habilitar verificação de integridade HTTPhealthCheck.type = "http" # frpc enviará uma solicitação GET para '/status'# e esperará um HTTP 2xx OK responsehealthCheck.path = "/status"healthCheck.timeoutSeconds = 3healthCheck.maxFailed = 3healthCheck.intervalSeconds = 10
Por padrão, o frp não modifica as solicitações HTTP em túnel, pois é uma cópia byte por byte.
No entanto, falando em servidores web e solicitações HTTP, seu servidor web pode contar com o cabeçalho Host HTTP para determinar o site a ser acessado. frp pode reescrever o cabeçalho Host ao encaminhar as solicitações HTTP, com o campo hostHeaderRewrite :
# frpc.toml[[proxies]]name = "web"type = "http"localPort = 80customDomains = ["test.example.com"]hostHeaderRewrite = "dev.example.com"
A solicitação HTTP terá o cabeçalho Host reescrito para Host: dev.example.com quando chegar ao servidor web real, embora a solicitação do navegador provavelmente tenha Host: test.example.com .
Semelhante ao Host , você pode substituir outros cabeçalhos de solicitação e resposta HTTP pelo tipo de proxy http .
# 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 = "barra"
Neste exemplo, ele definirá o cabeçalho x-from-where: frp na solicitação HTTP e foo: bar na resposta HTTP.
Este recurso é para proxies http ou proxies com os plug-ins https2http e https2https habilitados.
Você pode obter o IP real do usuário a partir dos cabeçalhos de solicitação HTTP X-Forwarded-For .
frp suporta protocolo proxy para enviar o IP real do usuário para serviços locais. Suporta todos os tipos, exceto UDP.
Aqui está um exemplo de serviço https:
# frpc.toml[[proxies]]name = "web"type = "https"localPort = 443customDomains = ["test.example.com"]# agora v1 e v2 são suportadostransport.proxyProtocolVersion = "v2"
Você pode ativar o suporte ao protocolo proxy no nginx para expor o IP real do usuário no cabeçalho HTTP X-Real-IP e, em seguida, ler o cabeçalho X-Real-IP em seu serviço da web para obter o IP real.
Qualquer pessoa que consiga adivinhar o URL do seu túnel poderá acessar seu servidor web local, a menos que você o proteja com uma senha.
Isso impõe autenticação básica HTTP em todas as solicitações com o nome de usuário e senha especificados no arquivo de configuração do frpc.
Só pode ser habilitado quando o tipo de proxy for http.
# frpc.toml[[proxies]]name = "web"type = "http"localPort = 80customDomains = ["test.example.com"]httpUser = "abc"httpPassword = "abc"
Visite http://test.example.com no navegador e agora você será solicitado a inserir o nome de usuário e a senha.
É conveniente usar a configuração subdomain para os tipos http e https quando muitas pessoas compartilham um servidor frps.
# frps.tomlsubDomainHost = "frps.com"
Resolva *.frps.com para o IP do servidor frps. Isso geralmente é chamado de registro DNS curinga.
# frpc.toml[[proxies]]name = "web"type = "http"localPort = 80subdomain = "test"
Agora você pode visitar seu serviço web em test.frps.com .
Observe que se subdomainHost não estiver vazio, customDomains não deverá ser o subdomínio de subdomainHost .
frp suporta o encaminhamento de solicitações HTTP para diferentes serviços da web de backend por roteamento de URL.
locations especifica o prefixo do URL usado para roteamento. O frps primeiro procura o local de prefixo mais específico fornecido por strings literais, independentemente da ordem listada.
# 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"]
Solicitações HTTP com prefixo de URL /news ou /about serão encaminhadas para web02 e outras solicitações para web01 .
frp suporta o recebimento de soquetes TCP direcionados a diferentes proxies em uma única porta em frps, semelhante a vhostHTTPPort e vhostHTTPSPort .
O único método de multiplexação de porta TCP suportado disponível no momento é httpconnect - túnel HTTP CONNECT.
Ao definir tcpmuxHTTPConnectPort como algo diferente de 0 em frps, o frps escutará nesta porta solicitações HTTP CONNECT.
O host da solicitação HTTP CONNECT será usado para corresponder ao proxy em frps. Os hosts proxy podem ser configurados em frpc configurando customDomains e/ou subdomain em proxies tcpmux , quando multiplexer = "httpconnect" .
Por exemplo:
# 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
Na configuração acima - o frps pode ser contatado na porta 1337 com um cabeçalho HTTP CONNECT como:
CONNECT test1 HTTP/1.1rnrn
e a conexão será roteada para proxy1 .
frpc pode se conectar ao frps por meio de proxy se você definir a variável de ambiente do sistema operacional HTTP_PROXY ou se transport.proxyURL estiver definido no arquivo frpc.toml.
Só funciona quando o protocolo é tcp.
# frpc.tomlserverAddr = "xxxx"serverPort = 7000transport.proxyURL = "http://user:[email protected]:8080"
Adicionado na v0.56.0
Podemos usar a sintaxe de intervalo do modelo Go combinada com a função integrada parseNumberRangePair para obter o mapeamento de intervalo de portas.
O exemplo a seguir, quando executado, criará 8 proxies chamados test-6000, test-6001 ... test-6007 , cada um mapeando a porta remota para a porta local.
{{- range $_, $v := parseNumberRangePair "6000-6006,6007" "6000-6006,6007" }}
[[proxies]]
name = "tcp-{{ $v.First }}"
type = "tcp"
localPort = {{ $v.First }}
remotePort = {{ $v.Second }}
{{- end }}frpc encaminha solicitações apenas para portas TCP ou UDP locais por padrão.
Plugins são usados para fornecer recursos avançados. Existem plug-ins integrados, como unix_domain_socket , http_proxy , socks5 , static_file , http2https , https2http , https2https e você pode ver exemplos de uso.
Usando o plugin http_proxy :
# frpc.toml[[proxies]]name = "http_proxy"type = "tcp"remotePort = 6000[proxies.plugin]type = "http_proxy"httpUser = "abc"httpPassword = "abc"
httpUser e httpPassword são parâmetros de configuração usados no plugin http_proxy .
Leia o documento.
Encontre mais plug-ins em gofrp/plugin.
adicionado na v0.53.0
frp oferece suporte à escuta de uma porta SSH no lado frps e obtém proxy do protocolo TCP por meio do protocolo SSH -R, sem depender de frpc.
#frps.tomlsshTunnelGateway.bindPort=2200
Ao executar ./frps -c frps.toml , um arquivo de chave privada denominado .autogen_ssh_key será criado automaticamente no diretório de trabalho atual. Este arquivo de chave privada gerado será usado pelo servidor SSH em frps.
Executando o comando
ssh -R:80:127.0.0.1:8080 v0@{endereço frp} -p 2200 tcp --proxy_name "test-tcp" --remote_port 9090configura um proxy em frps que encaminha o serviço 8080 local para a porta 9090.
frp (via SSH) (Ctrl+C para sair) Usuário: ProxyName: teste-tcp Tipo: tcp Endereço remoto::9090
Isso é equivalente a:
frpc tcp --proxy_name "test-tcp" --local_ip 127.0.0.1 --local_port 8080 --remote_port 9090
Consulte este documento para obter mais informações.
gofrp/plugin - Um repositório para plugins frp que contém uma variedade de plugins implementados com base no mecanismo de extensão frp, atendendo às necessidades de customização de diferentes cenários.
gofrp/tiny-frpc - Uma versão leve do cliente frp (cerca de 3,5 MB no mínimo) implementada usando o protocolo ssh, suportando alguns dos recursos mais comumente usados, adequado para dispositivos com recursos limitados.
Interessado em se envolver? Gostaríamos de ajudá-lo!
Dê uma olhada em nossa lista de problemas e considere enviar uma solicitação pull para dev branch .
Se você deseja adicionar um novo recurso, crie primeiro um problema para descrever o novo recurso, bem como a abordagem de implementação. Assim que a proposta for aceita, crie uma implementação dos novos recursos e envie-a como uma solicitação pull.
Desculpe pelo meu pobre inglês. Melhorias neste documento são bem-vindas, até mesmo algumas correções de erros de digitação.
Se você tiver ótimas ideias, envie um email para [email protected].
Nota: Preferimos que você dê seu conselho nas questões, para que outras pessoas com a mesma dúvida possam pesquisá-la rapidamente e não precisemos respondê-las repetidamente.
Se o frp te ajuda muito, você pode nos apoiar:
Apoie-nos pelos patrocinadores do Github.
Você pode colocar o logotipo da sua empresa no arquivo README deste projeto.
Doe dinheiro pelo PayPal para minha conta [email protected] .
