1. What

frp 是一款高性能的反向代理应用，专注于内网穿透。它支持多种协议，包括 TCP、UDP、HTTP、HTTPS 等，并且具备 P2P 通信功能。使用 frp，您可以安全、便捷地将内网服务暴露到公网，通过拥有公网 IP 的节点进行中转。

• 多种协议支持：客户端服务端通信支持 TCP、QUIC、KCP 和 Websocket 等多种协议。
• TCP 连接流式复用：在单个连接上承载多个请求，减少连接建立时间，降低请求延迟。
• 代理组间的负载均衡。
• 端口复用：多个服务可以通过同一个服务端端口暴露。
• P2P 通信：流量不必经过服务器中转，充分利用带宽资源。
• 客户端插件：提供多个原生支持的客户端插件，如静态文件查看、HTTPS/HTTP 协议转换、HTTP、SOCKS5 代理等，以便满足各种需求。
• 服务端插件系统：高度可扩展的服务端插件系统，便于根据自身需求进行功能扩展。
• 用户友好的 UI 页面：提供服务端和客户端的用户界面，使配置和监控变得更加方便。

2. 安装

git clone git@github.com:fatedier/frp.git
cd frp
make

cd frps/ 
yum install npm
npm install npm-run-all --save-dev
npm i npm-run-all -g
make
npm install
npm audit fix
npm run dev

3. 搭建测试环境

大部分场景可以通过 一台centos7 + docker组网隔离 测试：

RDP协议需要 两台windows 测试：

// 测试的centos7 dockerfile制作
FROM centos7:alirepo
ADD frpDevKit /
WORKDIR /
RUN  chmod 777 frps frpc \
     && yum install -y passwd openssl openssh-server openssh-clients \
     && yum install -y iproute iproute-doc initscripts

// Makefile
IMAGE_NAME := centos7-frp
COMPILE_TIME = $(shell date +"%Y%m%d%H%M%S")

image:
        docker build -t $(IMAGE_NAME):$(COMPILE_TIME) -t $(IMAGE_NAME):latest .

.PHONY: image

ssh-keygen -t ecdsa -f /etc/ssh/ssh_host_ecdsa_key

// 模拟访问者内网的主机，比如堡垒机和syslog server
docker network create -d bridge --subnet 10.10.10.0/24 --gateway 10.10.10.1 secpoolZone
docker run -itd --name jumpserver  --net=secpoolZone  --privileged=true centos7-frp:latest /sbin/init
docker run -itd --name syslogserver  --net=secpoolZone  --privileged=true centos7-frp:latest /sbin/init

// 模拟被访问者的内网，比如中石油分支1的办公网
docker network create -d bridge --subnet 169.168.10.0/24 --gateway 169.168.10.1 CNCP1
docker run -itd --name CNCP1-host1  --net=CNCP1  --privileged=true centos7-frp:latest /sbin/init
docker run -itd --name CNCP1-host2  --net=CNCP1  --privileged=true centos7-frp:latest /sbin/init

// 模拟被访问者的内网，比如中石油分支2的办公网
docker network create -d bridge --subnet 169.178.10.0/24 --gateway 169.178.10.1 CNCP2
docker run -itd --name CNCP2-host1  --net=CNCP2  --privileged=true centos7-frp:latest /sbin/init

// 模拟被访问者的内网，比如中石化分支1的办公网，并且与中石油分支1的办公网私网ip重叠，采用新建网卡实现
docker network create -d bridge --subnet 169.188.10.0/24 --gateway 169.188.10.1 SINOPEC1
docker run -itd --name SINOPEC1-host1  --net=SINOPEC1  --privileged=true centos7-frp:latest /sbin/init

// 模拟有公网暴露面的FRPS
docker network create -d bridge --subnet 122.245.248.0/24 --gateway 122.245.248.1 publicNet
docker run -itd --name FRPS --net=publicNet --privileged=true centos7-frp:latest  /sbin/init


// 模拟多个内网的主机可以通公网
docker network connect publicNet CNCP1-host1
docker network connect publicNet CNCP1-host2
docker network connect publicNet jumpserver
docker network connect publicNet syslogserver
docker network connect publicNet CNCP2-host1
docker network connect publicNet SINOPEC1-host1

// 一些必要的前置操作
ssh-keygen -t ecdsa -f /etc/ssh/ssh_host_ecdsa_key
systemctl start sshd
passwd root
yum install telnet xinetd telnet-server.x86_64 -y
systemctl start telnet.socket
systemctl start xinetd

// 租户内网重叠场景构造
yum install net-tools -y
ifconfig eth0:0 169.168.10.2 netmask 255.255.255.0 up

// 清理现场
docker stop/rm FRPS CNCP1-host2 CNCP1-host1 syslogserver jumpserver

公网暴露的，代理网关FRPS：

访问者的私网主机，堡垒机和syslog服务器：

中石油分支一，主机1和主机2：

中石油分支二，主机1

中石油分支一，主机1

4. 测试场景

4.1. 堡垒机访问中石油分支1的任意主机

# frps.toml
bindPort = 7000

# CNCP1-host2
serverAddr = "122.245.248.2"
serverPort = 7000

[[proxies]]
name = "CNCP1-host2"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 6000



# CNCP1-host1
serverAddr = "122.245.248.2"
serverPort = 7000

[[proxies]]
name = "CNCP1-host1"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 6001

# 源神启动
./frpc -c ./frpc.toml
./frps -c ./frps.toml

# 登入到jumpserver进行内网主机纳管：
ssh -oPort=6001 root@122.245.248.2
ssh -oPort=6000 root@122.245.248.2

服务端纳管所有proxy:

中石油分支1，host1连上server：

中石油分支1,host2连上server：

登录到jumpserver通过frps代理去访问中石油分支1的主机1和主机2：

4.2. 堡垒机访问中石油分支2的任意主机

# CNCP2-host1
serverAddr = "122.245.248.2"
serverPort = 7000

[[proxies]]
name = "CNCP2-host1"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 6003

# 源神启动
./frpc -c ./frpc.toml

# 登入到jumpserver进行内网主机纳管：
ssh -oPort=6003 root@122.245.248.2

proxy注册上来了：

4.3. 堡垒机访问不同租户但内网ip重叠场景

# SINOPEC1-host1
serverAddr = "122.245.248.2"
serverPort = 7000

[[proxies]]
name = "SINOPEC1-host1"
type = "tcp"
localIP = "169.168.10.2"
localPort = 22
remotePort = 6004

# 源神启动
./frpc -c ./frpc.toml

# 登入到jumpserver进行内网主机纳管：
ssh -oPort=6004 root@122.245.248.2

这个私网ip是重叠的：

4.4. RDP，TELNET，FTP协议测试

4.4.1. RDP协议测试

首先，我们需要设置一下被控 PC 端（也就是希望被远程控制的设备）在 frp 的 GitHub 下载页面 中下载对应的执行包，这里因为内网目标被控主机是 Windows 10，因此需要下载 Windows 版本。

解压缩之后，将其中的 frpc.exe 以及 frpc.ini 拷贝到 C:\ftp 这个目录下面，然后使用编辑器对 frpc.ini 文件进行编辑。

frpc.ini 文件中主要分为两个部分，最上面[common]是和云端服务器通信的部分，因此server_addr填写的是对应的云服务器的 ip 地址，而下面这个server_port则是刚才我们在服务端所设置的bind_port，两者需要保持一致。

下面部分是针对需要内网穿透的服务，比如针对 RDP 的代码写法如下：

[RDP]
type = tcp
local_ip = 127.0.0.1
local_port = 3389
remote_port = 7002

完成之后点击保存，接着我们需要对电脑的远程进行设置。右键点击「此电脑」-「属性」，找到「远程设置」，在「远程桌面」中勾选「允许远程连接到此计算机」，同时取消「仅允许运行使用网络级别身份验证的远程桌面的计算机连接」的勾选，然后点击「确定」。

最后，我们需要打开 Windows 防火墙给以上服务予以放行，在控制面板\所有控制面板项\Windows Defender 防火墙\允许的应用中点击「更改设置」，然后在下面找到「远程桌面」和「远程桌面（webSocket）」并分别勾选上「专用」和「公用」。

之后我们打开c:\frp目录，按住键盘上的shift键后右键选择「在此处打开 Powershell 窗口」，执行以下命令来开启 frp 客户端：

.\frpc.exe -c frpc.ini

如果下面的终端输入显示有[RDP] start proxy success 则表示实际上服务已经成功开启，使用控制端的「微软远程桌面」应该就可以实现远程控制了。

接下来我们就可以用控制端的 PC 测试一下，打开「远程桌面连接」，然后在「计算机」这一栏中输入云主机的公网 IP 后映射的端口号，比如我设置的 7002，然后点击连接。

然后在弹出的警告中选择「是」。

4.4.2. TELNET协议测试

# CNCP2-host1
serverAddr = "122.245.248.2"
serverPort = 7000


webServer.addr = "127.0.0.1"
webServer.port = 7400
webServer.user = "admin"
webServer.password = "admin"

[[proxies]]
name = "CNCP2-host1"
type = "tcp"
localIP = "127.0.0.1"
localPort = 23
remotePort = 6003

// 开启telnet服务
yum install telnet xinetd telnet-server.x86_64 -y
systemctl start telnet.socket
systemctl start xinetd

提前要搞个非root用户名，因为telnet不是很安全：

4.4.3. 【不满足，但可以用SFTP】FTP协议测试

4.5. Agent自身状态监控

使用健康检查类型tcp，服务端口将被 ping (TCPing)：

# frpc.toml

# frpc.toml
webServer.addr = "127.0.0.1"
webServer.port = 7400
webServer.user = "admin"
webServer.password = "admin"

[[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

对于健康检查类型http，HTTP 请求将发送到服务，并且预期得到 HTTP 2xx OK 响应：

# 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

# frps.tmol
# 默认为 127.0.0.1，如果需要公网访问，需要修改为 0.0.0.0。
webServer.addr = "0.0.0.0"
webServer.port = 7500
# dashboard 用户名密码，可选，默认为空
webServer.user = "admin"
webServer.password = "admin"

client测上报的状态：

curl -u admin:admin http://127.0.0.1:7400/api/status

server测收集所有状态：

curl -u admin:admin http://127.0.0.1:7500/api/proxy/tcp

curl -u admin:admin http://127.0.0.1:7500/api/serverinfo

4.6. P2P 2G大文件传输

sftp双向传输大文件，truncate一个大文件发过去：

# CNCP1-host2
serverAddr = "122.245.248.2"
serverPort = 7000


[[proxies]]
name = "p2p_ssh"
type = "xtcp"
# 只有共享密钥 (secretKey) 与服务器端一致的用户才能访问该服务
secretKey = "abcdefg"
localIP = "127.0.0.1"
localPort = 22

[[visitors]]
name = "p2p_ssh_visitor"
type = "xtcp"
# 要访问的 P2P 代理的名称
serverName = "p2p_ssh1"
secretKey = "abcdefg"
# 绑定本地端口以访问 SSH 服务
bindAddr = "127.0.0.1"
bindPort = 6000
# 如果需要自动保持隧道打开，将其设置为 true
keepTunnelOpen = false


# CNCP1-host1
serverAddr = "122.245.248.2"
serverPort = 7000

[[proxies]]
name = "p2p_ssh1"
type = "xtcp"
# 只有共享密钥 (secretKey) 与服务器端一致的用户才能访问该服务
secretKey = "abcdefg"
localIP = "127.0.0.1"
localPort = 22

[[visitors]]
name = "p2p_ssh_visitor"
type = "xtcp"
# 要访问的 P2P 代理的名称
serverName = "p2p_ssh"
secretKey = "abcdefg"
# 绑定本地端口以访问 SSH 服务
bindAddr = "127.0.0.1"
bindPort = 6000
# 如果需要自动保持隧道打开，将其设置为 true
keepTunnelOpen = false

5. 与同类代理工具比对

我搂一眼v2ray的内网穿透配置，有这功夫strongswan也能跑起来了：

{  
  "reverse":{ 
    // 这是 A 的反向代理设置，必须有下面的 bridges 对象
    "bridges":[  
      {  
        "tag":"bridge", // 关于 A 的反向代理标签，在路由中会用到
        "domain":"private.cloud.com" // A 和 B 反向代理通信的域名，可以自己取一个，可以不是自己购买的域名，但必须跟下面 B 中的 reverse 配置的域名一致
      }
    ]
  },
  "outbounds":[
    {  
      //A连接B的outbound  
      "tag":"tunnel", // A 连接 B的 outbound 的标签，在路由中会用到
      "protocol":"vmess",
      "settings":{  
        "vnext":[  
          {  
            "address":"serveraddr.com", // B 地址，IP 或 实际的域名
            "port":16823,
            "users":[  
              {  
                "id":"b831381d-6324-4d53-ad4f-8cda48b30811",
                "alterId":64
              }
            ]
          }
        ]
      }
    },
    // 另一个 outbound，最终连接私有网盘    
    {  
      "protocol":"freedom",
      "settings":{  
      },
      "tag":"out"
    }
  ],
  "routing":{  
    "rules":[  
      {  
      // 配置 A 主动连接 B 的路由规则
        "type":"field",
        "inboundTag":[  
          "bridge"
        ],
        "domain":[  
          "full:private.cloud.com"
        ],
        "outboundTag":"tunnel"
      },
      {  
      // 反向连接访问私有网盘的规则
        "type":"field",
        "inboundTag":[  
          "bridge"
        ],
        "outboundTag":"out"
      }
    ]    
  }
}


{  
  "reverse":{  //这是 B 的反向代理设置，必须有下面的 portals 对象
    "portals":[  
      {  
        "tag":"portal",
        "domain":"private.cloud.com"        // 必须和上面 A 设定的域名一样
      }
    ]
  },
  "inbounds":[
    {  
      // 接受 C 的inbound
      "tag":"tunnel", // 标签，路由中用到
      "port":11872,
      "protocol":"vmess",
      "settings":{  
        "clients":[  
          {  
            "id":"a26efdb8-ef34-4278-a4e6-2af32cc010aa",
            "alterId":64
          }
        ]
      }
    },
    // 另一个 inbound，接受 A 主动发起的请求  
    {  
      "tag": "interconn",// 标签，路由中用到
      "port":16823,
      "protocol":"vmess",
      "settings":{  
        "clients":[  
          {  
            "id":"b831381d-6324-4d53-ad4f-8cda48b30811",
            "alterId":64
          }
        ]
      }
    }
  ],
  "routing":{   
    "rules":[  
      {  //路由规则，接收 C 的请求后发给 A
        "type":"field",
        "inboundTag":[  
          "external"
        ],
        "outboundTag":"portal"
      },
      {  //路由规则，让 B 能够识别这是 A 主动发起的反向代理连接
        "type":"field",
        "inboundTag":[  
          "tunnel"
        ],
        "domain":[  
          "full:private.cloud.com"
        ],
        "outboundTag":"portal"
      }
    ]
  }
}

Reference

https://github.com/fatedier/frp/blob/dev/README_zh.md

https://cloud.tencent.com/developer/article/1837482

https://juejin.cn/post/7042486792011907086

https://doc.itopcms.com/docs/go-project/go-project-1e54jq1c088tb

https://docs.jumpserver.org/zh/v3/architecture/#3

https://github.com/fatedier/frp?tab=readme-ov-file#prometheus

https://blog.csdn.net/qq_46490950/article/details/118978635

https://blog.51cto.com/chengdumeiyouni/2815244

https://blog.csdn.net/a20251839/article/details/113871215

https://alianga.com/articles/nas-contrast

https://jiajunhuang.com/articles/2019_06_11-frpc_source_code_part1.md.html

https://sspai.com/post/60852