frp

Patrocinadores

frp é um projeto de código aberto cujo desenvolvimento contínuo é possível inteiramente pelo apoio dos nossos incríveis patrocinadores. Se você gostaria de se juntar a eles, considere patrocinar o desenvolvimento do frp.

Patrocinadores Ouro

A IDE completa criada para desenvolvedores Go profissionais

# frpc.toml auth.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" ``` ### Encriptação e Compressão Os recursos estão desativados por padrão. Você pode ativar a encriptação e/ou a compressão:```toml # frpc.toml [[proxies]] name = "ssh" type = "tcp" localPort = 22 remotePort = 6000 transport.useEncryption = true transport.useCompression = true ``` #### TLS Desde a v0.50.0, o valor padrão de `transport.tls.enable` e `transport.tls.disableCustomTLSFirstByte` foi alterado para true, e o TLS está habilitado por padrão. Para multiplexação de portas, o frp envia um primeiro byte `0x17` para estabelecer uma conexão TLS. Isso só tem efeito quando você define `transport.tls.disableCustomTLSFirstByte` como false. Para **forçar** o `frps` a aceitar apenas conexões TLS - configure `transport.tls.force = true` no `frps.toml`. **Isso é opcional.** **Configurações de TLS do `frpc`:**```toml transport.tls.enable = true transport.tls.certFile = "certificate.crt" transport.tls.keyFile = "certificate.key" transport.tls.trustedCaFile = "ca.crt" ``` **Configurações TLS do `frps`:**```toml transport.tls.force = true transport.tls.certFile = "certificate.crt" transport.tls.keyFile = "certificate.key" transport.tls.trustedCaFile = "ca.crt" ``` Você precisará de **um certificado de CA raiz** e **pelo menos um certificado SSL/TLS**. Ele **pode** ser autoassinado ou regular (como Let's Encrypt ou outro provedor de certificados SSL/TLS). Se você estiver usando `frp` via endereço IP e não hostname, certifique-se de definir o endereço IP apropriado na área Subject Alternative Name (SAN) ao gerar os 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`. Se não, você pode criá-lo por conta própria, 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 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 ``` * compilar 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 ``` ### Recarregamento a quente da configuração do frpc Os campos `webServer` são necessários para habilitar a API HTTP:```toml # frpc.toml webServer.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 que o `frpc` crie, atualize ou remova proxies. **Observe que os parâmetros globais do cliente não serão modificados, exceto 'start'.** `start` é uma lista de permissões global avaliada após todas as fontes serem mescladas (arquivo de configuração/include/store). Se `start` não estiver vazio, qualquer proxy ou visitor não listado ali não será iniciado, incluindo entradas criadas via Store API. `start` é mantido principalmente por compatibilidade e geralmente não é recomendado para novas configurações. Prefira `enabled` por proxy/por visitor e mantenha `start` vazio, a menos que você queira explicitamente esse comportamento de lista de permissões global. Você pode executar o comando `frpc verify -c ./frpc.toml` antes de recarregar para verificar se há erros de configuração. ### Obter status do proxy a partir do cliente Use `frpc status -c ./frpc.toml` para obter o status de todos os proxies. Os campos `webServer` são necessários para habilitar a API HTTP. ### Permitir apenas determinadas portas no servidor `allowPorts` em `frps.toml` é usado para evitar o abuso de portas:```toml # frps.toml allowPorts = [ { start = 2000, end = 3000 }, { single = 3001 }, { single = 3003 }, { start = 4000, end = 50000 } ] ``` ### Reutilização de Portas `vhostHTTPPort` e `vhostHTTPSPort` no frps podem usar a mesma porta que `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` na mesma porta, primeiro é necessário definir `transport.tls.disableCustomTLSFirstByte` como false. No futuro, gostaríamos de tentar permitir que vários proxies vinculem a mesma porta remota com protocolos diferentes. ### Limite de Largura de Banda #### Para Cada Proxy```toml # frpc.toml [[proxies]] name = "ssh" type = "tcp" localPort = 22 remotePort = 6000 transport.bandwidthLimit = "1MB" ``` Defina `transport.bandwidthLimit` na configuração de cada proxy para habilitar esse recurso. As unidades suportadas são `MB` e `KB`. Defina `transport.bandwidthLimitMode` como `client` ou `server` para limitar a largura de banda no lado do cliente ou do servidor. O padrão é `client`. ### Multiplexação de Stream TCP O frp suporta multiplexação de stream TCP desde a v0.10.0, como a 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 desabilitar esse recurso modificando `frps.toml` e `frpc.toml`:```toml # frps.toml and frpc.toml, must be same transport.tcpMux = false ``` ### Suporte ao Protocolo KCP O 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% a mais de largura de banda desperdiçada em comparação com o TCP. O modo KCP usa UDP como transporte subjacente. Usando KCP no frp: 1. Habilite o KCP no frps: ```toml # frps.toml bindPort = 7000 # Specify a UDP port for KCP. 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" ``` ### Suporte ao Protocolo QUIC QUIC é um novo transporte multiplexado construído sobre UDP. Usando QUIC no frp: 1. Habilite o QUIC no frps: ```toml # frps.toml bindPort = 7000 # Specify a UDP port for QUIC. 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" ``` ### Connection Pooling Por padrão, o frps cria uma nova conexão frpc para o serviço de backend a cada solicitação do usuário. Com o connection pooling, o frps mantém um certo número de conexões pré-estabelecidas, reduzindo o tempo necessário para estabelecer uma conexão. Esse recurso é adequado para um grande número de conexões curtas. 1. Configure o limite da contagem do pool que cada proxy pode usar em `frps.toml`: ```toml # frps.toml transport.maxPoolCount = 5 ``` 2. Ative e especifique o número do pool de conexões: ```toml # frpc.toml transport.poolCount = 1 ``` ### Balanceamento de carga O balanceamento de carga é suportado por `group`. Este recurso está disponível apenas para os tipos `tcp`, `http`, `tcpmux` por enquanto.```toml # frpc.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` é usado para autenticação. Conexões à porta 80 serão distribuídas aleatoriamente para proxies no 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. ### Verificação de Saúde do Serviço O recurso de verificação de saúde pode ajudá-lo a alcançar alta disponibilidade com balanceamento de carga. Adicione `healthCheck.type = "tcp"` ou `healthCheck.type = "http"` para habilitar a verificação de saúde. Com o tipo de verificação de saúde **tcp**, a porta do serviço será verificada (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 ``` Com o tipo de verificação de saúde **http**, uma solicitação HTTP será enviada ao serviço e uma resposta HTTP 2xx OK é esperada:```toml # frpc.toml [[proxies]] name = "web" type = "http" localIP = "127.0.0.1" localPort = 80 customDomains = ["test.example.com"] # Enable HTTP health check healthCheck.type = "http" # frpc will send a GET request to '/status' # and expect an HTTP 2xx OK response healthCheck.path = "/status" healthCheck.timeoutSeconds = 3 healthCheck.maxFailed = 3 healthCheck.intervalSeconds = 10 ``` ### Reescrita do Cabeçalho HTTP Host Por padrão, o frp não modifica as solicitações HTTP tuneladas, pois elas são uma cópia byte a byte. No entanto, falando de servidores web e solicitações HTTP, o seu servidor web pode depender do cabeçalho HTTP `Host` para determinar qual site está sendo acessado. O frp pode reescrever o cabeçalho `Host` ao encaminhar as solicitações HTTP, usando o campo `hostHeaderRewrite`:```toml # frpc.toml [[proxies]] name = "web" type = "http" localPort = 80 customDomains = ["test.example.com"] hostHeaderRewrite = "dev.example.com" ``` O pedido HTTP terá o cabeçalho `Host` reescrito para `Host: dev.example.com` quando chegar ao servidor web real, embora o pedido do navegador provavelmente tenha `Host: test.example.com`. ### Definindo outros cabeçalhos HTTP Semelhante ao `Host`, você pode substituir outros cabeçalhos de solicitação e resposta HTTP com o tipo de proxy `http`.```toml # frpc.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" ``` Neste exemplo, ele definirá o cabeçalho `x-from-where: frp` na requisição HTTP e `foo: bar` na resposta HTTP. ### Obter IP Real #### HTTP X-Forwarded-For Este recurso é para proxies `http` ou proxies com os plugins `https2http` e `https2https` habilitados. Você pode obter o IP real do usuário a partir dos cabeçalhos de requisição HTTP `X-Forwarded-For`. #### Proxy Protocol O frp suporta Proxy Protocol para enviar o IP real do usuário aos serviços locais. Aqui está um exemplo para o serviço https:```toml # frpc.toml [[proxies]] name = "web" type = "https" localPort = 443 customDomains = ["test.example.com"] # now v1 and v2 are supported transport.proxyProtocolVersion = "v2" ``` Podes ativar o suporte a Proxy Protocol no nginx para expor o IP real do utilizador no cabeçalho HTTP `X-Real-IP` e, em seguida, ler o cabeçalho `X-Real-IP` no teu serviço web para obter o IP real. ### Exigir HTTP Basic Auth (Palavra-passe) para Serviços Web Qualquer pessoa que consiga adivinhar o URL do teu túnel pode aceder ao teu servidor web local, a menos que o protejas com uma palavra-passe. Isto aplica HTTP Basic Auth em todos os pedidos com o nome de utilizador e palavra-passe especificados no ficheiro de configuração do frpc. Só pode ser ativado quando o tipo de proxy é http.```toml # frpc.toml [[proxies]] name = "web" type = "http" localPort = 80 customDomains = ["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. ### Nomes de Subdomínio Personalizados É conveniente usar a configuração `subdomain` para os tipos http e https quando muitas pessoas compartilham um único servidor frps.```toml # frps.toml subDomainHost = "frps.com" ``` Resolva `*.frps.com` para o IP do servidor frps. Isso geralmente é chamado de registro DNS curinga.```toml # frpc.toml [[proxies]] name = "web" type = "http" localPort = 80 subdomain = "test" ``` Agora você pode visitar seu serviço web em `test.frps.com`. Observe que, se `subdomainHost` não estiver vazio, `customDomains` não deve ser um subdomínio de `subdomainHost`. ### Roteamento de URL O frp suporta o encaminhamento de requisições HTTP para diferentes serviços web de backend por meio do roteamento de URL. `locations` especifica o prefixo da URL usado para o roteamento. O frps primeiro busca o local de prefixo mais específico fornecido por strings literais, independentemente da ordem listada.```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"] ``` Requisições HTTP com prefixo de URL `/news` ou `/about` serão encaminhadas para **web02** e outras requisições para **web01**. ### Multiplexação de Porta TCP O frp suporta receber sockets TCP direcionados a diferentes proxies em uma única porta no frps, semelhante a `vhostHTTPPort` e `vhostHTTPSPort`. O único método de multiplexação de porta TCP suportado atualmente é `httpconnect` - túnel HTTP CONNECT. Ao definir `tcpmuxHTTPConnectPort` para qualquer valor diferente de 0 no frps, o frps escutará nesta porta por requisições HTTP CONNECT. O host da requisição HTTP CONNECT será usado para corresponder ao proxy no frps. Os hosts de proxy podem ser configurados no frpc configurando `customDomains` e/ou `subdomain` em proxies `tcpmux`, quando `multiplexer = "httpconnect"`. Por exemplo:```toml # frps.toml bindPort = 7000 tcpmuxHTTPConnectPort = 1337 ``` ``` ## 🛡️ Recursos - **Detecção de malware**: Detecta e bloqueia malware conhecido e desconhecido usando análise heurística e comportamental. - **Proteção em tempo real**: Monitora o sistema continuamente para detectar e bloquear ameaças em tempo real. - **Análise de arquivos**: Analisa arquivos em busca de conteúdo malicioso usando múltiplos mecanismos de detecção. - **Quarentena**: Isola arquivos suspeitos ou infectados para evitar danos adicionais ao sistema. - **Atualizações automáticas**: Mantém as definições de vírus e o mecanismo de detecção atualizados automaticamente. - **Relatórios detalhados**: Gera relatórios abrangentes sobre ameaças detectadas e ações tomadas. - **Interface amigável**: Interface de linha de comando simples e intuitiva para fácil uso. - **Baixo consumo de recursos**: Projetado para operar com uso mínimo de CPU e memória. - **Suporte multiplataforma**: Funciona em Windows, macOS e Linux. - **Código aberto**: Totalmente open-source, permitindo auditoria e personalização. ``````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 ``` Na configuração acima - o frps pode ser contactado na porta 1337 com um cabeçalho HTTP CONNECT como:``` CONNECT test1 HTTP/1.1\r\n\r\n ``` e a conexão será roteada para `proxy1`. ### Conectando-se ao frps via PROXY O frpc pode se conectar ao frps através 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. Isso só funciona quando o protocolo é tcp.```toml # frpc.toml serverAddr = "x.x.x.x" serverPort = 7000 transport.proxyURL = "http://user:[email protected]:8080" ``` ### Mapeamento de faixa de portas *Adicionado na v0.56.0* Podemos usar a sintaxe de intervalo do template Go combinada com a função integrada `parseNumberRangePair` para realizar o mapeamento de faixa de portas. O exemplo a seguir, quando executado, criará 8 proxies nomeados `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 }} ``` ### Plugins do Cliente O frpc apenas encaminha pedidos para portas TCP ou UDP locais por padrão. Os plugins são usados para fornecer funcionalidades avançadas. Existem plugins integrados, como `unix_domain_socket`, `http_proxy`, `socks5`, `static_file`, `http2https`, `https2http`, `https2https`, e você pode ver [exemplos de uso](#example-usage). Usando o plugin **http_proxy**:```toml # 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`. ### Plugins de Gerenciamento do Servidor Leia o [documento](https://github.com/fatedier/frp/blob/HEAD/doc/server_plugin.md). Encontre mais plugins em [gofrp/plugin](https://github.com/gofrp/plugin). ### Gateway de Túnel SSH *adicionado na v0.53.0* O frp suporta escutar uma porta SSH no lado do frps e alcança o proxy do protocolo TCP através do protocolo SSH -R, sem depender do frpc.```toml # frps.toml sshTunnelGateway.bindPort = 2200 ``` Quando executar `./frps -c frps.toml`, um arquivo de chave privada chamado `.autogen_ssh_key` será criado automaticamente no diretório de trabalho atual. Este arquivo de chave privada gerado será usado pelo servidor SSH no frps. Executando o comando```bash ssh -R :80:127.0.0.1:8080 v0@{frp address} -p 2200 tcp --proxy_name "test-tcp" --remote_port 9090 ``` configura um proxy no frps que encaminha o serviço local 8080 para a porta 9090.```bash frp (via SSH) (Ctrl+C to quit) User: ProxyName: test-tcp Type: tcp RemoteAddress: :9090 ``` Isto é equivalente a:```bash frpc tcp --proxy_name "test-tcp" --local_ip 127.0.0.1 --local_port 8080 --remote_port 9090 ``` Consulte este [documento](https://github.com/fatedier/frp/blob/HEAD/doc/ssh_tunnel_gateway.md) para obter mais informações. ### Rede Virtual (VirtualNet) *Recurso alfa adicionado na v0.62.0* O recurso VirtualNet permite que o frp crie e gerencie conexões de rede virtual entre clientes e visitantes por meio de uma interface TUN. Isso possibilita o roteamento em nível de IP entre máquinas, estendendo o frp além do simples encaminhamento de portas para suportar conectividade de rede completa. Para informações detalhadas sobre configuração e uso, consulte a [documentação do VirtualNet](https://github.com/fatedier/frp/blob/HEAD/doc/virtual_net.md). ## Feature Gates O frp suporta feature gates para habilitar ou desabilitar recursos experimentais. Isso permite que os usuários testem novos recursos antes de serem considerados estáveis. ### Feature Gates Disponíveis | Nome | Estágio | Padrão | Descrição | |------|---------|--------|-----------| | VirtualNet | ALPHA | false | Capacidades de rede virtual para o frp | ### Habilitando Feature Gates Para habilitar um recurso experimental, adicione o feature gate à sua configuração:```toml featureGates = { VirtualNet = true } ``` ### Ciclo de Vida de Funcionalidades As funcionalidades normalmente passam por três estágios: 1. **ALPHA**: Desativadas por padrão, podem ser instáveis 2. **BETA**: Podem ser ativadas por padrão, mais estáveis, mas ainda em evolução 3. **GA (Disponibilidade Geral)**: Ativadas por padrão, prontas para uso em produção ## Projetos Relacionados * [gofrp/plugin](https://github.com/gofrp/plugin) - Um repositório para plugins do frp que contém uma variedade de plugins implementados com base no mecanismo de extensão do frp, atendendo às necessidades de personalização de diferentes cenários. * [gofrp/tiny-frpc](https://github.com/gofrp/tiny-frpc) - Uma versão leve do cliente frp (cerca de 3,5MB no mínimo) implementada usando o protocolo ssh, suportando alguns dos recursos mais comumente usados, adequada para dispositivos com recursos limitados. ## Contribuindo Interessado em participar? Nós gostaríamos de ajudar você! * Dê uma olhada na nossa [lista de issues](https://github.com/fatedier/frp/issues) e considere enviar um Pull Request para o **branch dev**. * Se você quiser adicionar um novo recurso, crie uma issue primeiro para descrever o novo recurso, bem como a abordagem de implementação. Uma vez que a proposta for aceita, crie uma implementação dos novos recursos e envie-a como um pull request. * Desculpe pelo meu inglês ruim. Melhorias para este documento são bem-vindas, até mesmo correções de erros de digitação. * Se você tiver ótimas ideias, envie um e-mail para [email protected]. **Nota: Preferimos que você dê sua opinião em [issues](https://github.com/fatedier/frp/issues), para que outros com a mesma dúvida possam pesquisar rapidamente e não precisemos responder repetidamente.** ## Doação Se o frp ajuda você muito, você pode nos apoiar por: ### Patrocinadores do GitHub Apoie-nos por meio do [Github Sponsors](https://github.com/sponsors/fatedier). Você pode ter o logotipo da sua empresa colocado no arquivo README deste projeto. ### PayPal Doe dinheiro por meio do [PayPal](https://www.paypal.me/fatedier) para a minha conta **[email protected]**.

frp

Mais Populares

Recall.ai - API para gravações de reuniões

O que é o frp?

Índice

Status de Desenvolvimento

Sobre a V2

Arquitetura

Exemplo de Uso

Acesse seu computador em uma rede LAN via SSH

frps.toml

Vários serviços SSH compartilhando a mesma porta

frpc.toml

frpc.toml

Expor um servidor HTTP de arquivos simples

frpc.toml

Exponha seu serviço de forma privada

frpc.toml

Modo P2P

frpc.toml

set up a new stun server if the default one is not available.

natHoleStunServer = "xxx"

Recursos

Arquivos de Configuração

Usando Variáveis de Ambiente

frpc.toml

Dividir Configurações em Arquivos Diferentes

frpc.toml

Server Dashboard

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.

dashboard's username and password are both optional

Interface de Administração do Cliente

Monitor

Prometheus

Autenticando o Cliente

Autenticação por Token

Fonte do Token

frpc.toml

Configuração

Uso Básico