Docker-Frp

没有公网时需要访问群辉，可以使用Frp来实现
这个的优势是在有动态公网时，DDNS可能没有及时解析成功，或是无法访问时，提供一个补充式连接方案

相关链接：
---
- GitHub：https://github.com/fatedier/frp/tags
- Docker_frp：https://registry.hub.docker.com/r/fatedier/frp
  - Docker_frps：https://registry.hub.docker.com/r/fatedier/frps
  - Docker_frpc：https://registry.hub.docker.com/r/fatedier/frpc
- 配置文件示例：
  - frps配置文件：https://github.com/fatedier/frp/blob/dev/conf/frps_full_example.toml
  - frpc配置文件：https://github.com/fatedier/frp/blob/dev/conf/frpc_full_example.toml
- ⭐frpc_客户端(简单好用)：https://github.com/luckjiawei/frpc-desktop

# [Docker 部署](https://registry.hub.docker.com/r/fatedier/frpc)
官方的不好用，故自行构建
为了方便使用构建为 服务器+客户端，根据变量来选择启动模式

## GitHub Actions 构建
目前未解决源项目更新自动更新构建镜像问题，可以手动更新然后再构建
1. 从 [fatedier/frp](https://github.com/fatedier/frp) 进行 [Fork(分叉)](https://github.com/fatedier/frp/fork) 到自己账号
2. 设置 [Docker Hub](https://registry.hub.docker.com/) 帐号，没有的自行申请
项目界面——Settings(设置)——Secrets(秘密)——Actions(行动)——点击 `New repository secret`(新建储存库机密)
   - `DOCKERHUB_USERNAME`，你的 Docker 用户名
   - `DOCKERHUB_PASSWORD`，你的 Docker 令牌
3. 添加 `.github/workflows/docker.yml`，[Actions 自动化脚本](#添加的脚本)
4. 添加 `dockerfiles/Dockerfile-for-frp`，[dockerfile 镜像构建脚本](#添加的脚本)
5. 在 Actions 下运行 `编译Docker镜像` 工作流
等待执行完成，完成后会邮件通知
推荐测试时仅构建测试平台对应平台的镜像，生产时再构建多平台，多平台速度较慢
6. 去 [Docker Hub](https://registry.hub.docker.com/) 下就可以查看到构建并上传过来的 Frp 镜像了

### Docker镜像 使用说明
这里使用我已经 [构建好的镜像](https://hub.docker.com/r/918178/frp)，frps.toml 参考配置 [查看此处](#Frps%20服务端配置)
```bash
nano docker-compose.yml  # docker-compose 配置文件
nano frps.toml  # 服务器端配置文件(必须挂载否则会无法运行)
docker-compose up -d
```
`docker-compose.yml`
```yaml
services:
  frp:
    container_name: frps  # 容器名称
    restart: always  # 自动重启
    network_mode: host  # host 模式(和ports二选一)
    # ports:  # 开放端口模式(和host二选一)
    #   - 7000:7000  # 绑定端口(不可省略)
    #   - 7500:7500  # Web仪表盘端口
    #   - 20000-20050:20000-20050  # 可用服务端口(tcp,自定义)
    #   - 20000-20050:20000-20050/udp  # 可用服务端口(udp,自定义)
    environment:
      - mode=frps  # 运行在 frps模式(frps/frpc)
    volumes:
      # 必须挂载对应的配置文件否则是无法运行的
      - ./frps.toml:/frp/frps.toml  # 挂载 frps配置文件
      # - ./frpc.toml:/frp/frpc.toml  # 挂载 frpc配置文件
    image: 918178/frp:latest  # 使用自构建镜像
```

### 添加的脚本
`.github/workflows/docker.yml`
```bash
name: 编译Docker镜像  # Actions 脚本名称

# 定义触发工作流的事件
on:
  release:
    types: [ published ]  # 当发布新的GitHub release时触发
  workflow_dispatch:
    inputs:
      tag:
        description: 'Image tag'  # 手动触发时输入的标签描述
        required: true  # 必须输入
        default: 'test'  # 默认标签为'test'
  workflow_run:
    workflows: ["GoReleaser Workflow"]  # 指定工作流完成时触发
    types: [completed]  # 当goreleaser工作流完成时触发

permissions:
  contents: read  # 工作流需要读取仓库内容的权限

jobs:
  image:
    name: 从 Dockerfile 构建映像  # 工作流作业名称
    runs-on: ubuntu-latest  # 在最新的Ubuntu环境中运行
    steps:
      # 检出代码
      - name: Checkout
        uses: actions/checkout@v4
        with:
          fetch-depth: '0'  # 检出所有分支的历史记录

# 设置QEMU，用于构建多平台镜像
      - name: 设置 QEMU
        uses: docker/setup-qemu-action@v3

# 设置Docker Buildx，用于构建和推送多平台镜像
      - name: 设置 Docker Buildx
        uses: docker/setup-buildx-action@v3

# 获取镜像标签名称
      - name: 获取 Image Tag
        # 注意 | 后注释会有问题故放在这
        # 如果没有提供标签，则使用GitHub Ref作为标签
        # 如果提供了标签，则使用提供的标签
        run: |
          if [ x${{ github.event.inputs.tag }} == x"" ]; then
            echo "TAG_NAME=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
          else
            echo "TAG_NAME=${{ github.event.inputs.tag }}" >> $GITHUB_ENV
          fi

# 登录到Docker Hub
      - name: 登录 DockerHub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}  # Docker Hub用户名
          password: ${{ secrets.DOCKERHUB_PASSWORD }}  # Docker Hub密码

# 准备镜像标签
      - name: 设置 Image Tags
        # 注意 | 后注释会有问题故放在这
        # 设置Dockerfile路径
        # 设置镜像标签(修改成自己DockerHub用户名)(版本标签+latest)
        run: |
          echo "DOCKERFILE_FRP_PATH=dockerfiles/Dockerfile-for-frp" >> $GITHUB_ENV
          echo "TAG_FRP=918178/frp:${{ env.TAG_NAME }}" >> $GITHUB_ENV
          echo "TAG_FRP_LATEST=918178/frp:latest" >> $GITHUB_ENV

# 构建并推送frp镜像
      - name: 编译并推送 Frp镜像
        uses: docker/build-push-action@v5
        with:
          context: .  # 构建上下文
          file: ./dockerfiles/Dockerfile-for-frp  # 构建Dockerfile所在路径
          # 设置构建平台,注意:使用的镜像都需要有该对应平台的才可以正常构建
          platforms: linux/amd64  # 构建的平台(测试构建,少一些快一点)
          # platforms: linux/amd64,linux/386,linux/arm64,linux/arm/v7  # 构建的平台(正式构建)
          push: true  # 推送到仓库
          # 注意 | 后注释会有问题故放在这
          # 推送的镜像标签(版本标签+latest)
          tags: |
            ${{ env.TAG_FRP }}
            ${{ env.TAG_FRP_LATEST }}
```

`dockerfiles/Dockerfile-for-frp`
```bash
# 第一阶段：构建阶段，使用golang:1.23作为基础镜像
FROM golang:1.23 AS building
# 将当前目录(包含Dockerfile的目录)下的文件复制到容器中的/building目录
COPY . /building
# 设置工作目录为/building
WORKDIR /building
# 在/building目录下执行make命令，构建frps和frpc二进制文件
RUN make frps && make frpc

# 第二阶段：构建基础镜像，使用alpine:3
FROM alpine:3
# 设置工作目录为/frp
WORKDIR /frp
# 使用apk(Alpine Linux的包管理器)添加tzdata包，用于提供时区数据，但不缓存
RUN apk add --no-cache tzdata
# 从第一阶段构建的镜像中复制frps二进制文件到当前镜像的/frp目录
COPY --from=building /building/bin/frps /frp/frps
# 从第一阶段构建的镜像中复制frpc二进制文件到当前镜像的/frp目录
COPY --from=building /building/bin/frpc /frp/frpc
# 设置环境变量mode，用于选择启动frps(服务端)还是frpc(客户端)
ENV mode=frps
# ENTRYPOINT ["/frp/$mode -c /frp/$mode.toml"]  # ENTRYPOINT 无法使用变量，不能作为启动命令，故使用 CMD
# 设置容器启动时执行的默认命令，根据mode变量来决定启动文件+配置文件
CMD ["/bin/sh", "-c", "./$mode -c $mode.toml"]
# 注意，必须挂载配置文件才能启动
# 在启动命令指定了配置文件，但这个配置文件在构建时并未放入，直接启动会找不到配置文件而报错
# 当然也可以在构建的时候加载一个通用配置文件来解决这个问题
```

## Docker 自构建
`Dockerfile`
```Dockerfile
# 基础镜像 alpine
FROM alpine
# FROM arm64v8/alpine  # arm64v8 内核
WORKDIR /frp
# 复制 FRP 和 配置文件 到内部(复制前可以先把配置文件修改好)
COPY ./frp /frp
# 环境变量,用来选择启动 frps|frpc(服务端|客户端)
ENV mode=frps
# 运行容器执行的命令(通过变量确定启动服务端|客户端并加载对应的配置文件)
CMD ["/bin/sh", "-c", "./$mode -c $mode.toml"]
# 最新配置文件后缀改成.toml了,并且配置文件标志名称中的_要改成-
```
```bash
docker build -t 918178/frp .  # 构建镜像
docker run -d --name frps --restart=always --net=host -e mode=frps -v $PWD/frps.toml:/frp/frps.toml 918178/frp  # frps模式 运行镜像
```
Frps WebUI：http://\<IP\>:7500

## docker-compose
frps.toml 参考配置 [查看此处](#Frps%20服务端配置)
```bash
nano docker-compose.yml  # docker-compose 配置文件
nano frps.toml  # 服务器端配置文件
docker-compose up -d
```
`docker-compose.yml`
```yaml
services:
  frp:
    container_name: frps  # 容器名称
    restart: always  # 自动重启
    network_mode: host  # host 模式(和ports二选一)
    # ports:  # 开放端口模式(和host二选一)
    #   - 7000:7000  # 绑定端口(不可省略)
    #   - 7500:7500  # Web仪表盘端口
    #   - 20000-20050:20000-20050  # 可用服务端口(tcp,自定义)
    #   - 20000-20050:20000-20050/udp  # 可用服务端口(udp,自定义)
    environment:
      - mode=frps  # 运行在 frps模式
    volumes:
      - ./frps.toml:/frp/frps.toml  # 挂载配置文件
    image: 918178/frp  # 使用自构建镜像
```

# 常规部署
## Frpc 客户端
### 下载Frp
[Frp Github地址](https://github.com/fatedier/frp/tags)
```bash
#查看架构
uname -a
dpkg --print-architecture
```
1. 在线下载
```bash
sudo -i		#登录root用户
wget https://ghproxy.com/https://github.com/fatedier/frp/releases/download/v0.36.2/frp_0.36.2_linux_386.tar.gz		#在线下载
tar -zxvf frp_0.36.2_linux_386.tar.gz frp		#解压到frp文件夹中
```
>可以去Github上找最新的，一般X86架构的群辉选择linux_386这个版本就行
2. 本地下载
对于网络不好的，可以在Github上下载后上传到群辉
`如：这里我下载后放到共享文件夹nas中
```bash
sudo -i		#登录root用户
cd /volume1/nas/		#进入放Frp的文件夹
tar -zxvf frp_*.tar.gz frp		#解压(解压过放共享的省略这一步)
cp -r /volume1/nas/frp_*	/root/frp	#复制文件夹到内部文件夹，防止共享误删
```

### 编辑Frp
```bash
cd /root/frp		#进入frp文件夹
rm frps*		#删除frps服务端文件，防止无法区分(如果需要，可以保留)
vi frpc.ini		#编辑Frp配置文件
```
配置如下(也可在共享中编辑好了复制过来)，`最新配置文件后缀改成.toml了,并且配置文件标志名称中的_要改成-`
```bash
# 注释不能放在配置后面，特别是token，会被误当初内容
serverAddr = "<提供Frp服务的IP>"
serverPort = <服务端口>
auth.token = "<密码，如果没有可删除>"
user = "Synology"  # 名称，方便区分，配置项不多可省略

# 客户端管理WebUI
webServer.addr = "127.0.0.1"  # 允许访问WebUI的IP
webServer.port = 7400  # 访问端口
webServer.user = "admin"
webServer.password = "admin"

# 日志
# log.to = "./frpc.log"  # 启用后会输出日志到指定文件而不是控制台
# log.level = "trace"  # 日志级别 trace,debug,info,warn,error
# log.maxDays = 3  # 日志最大存储天数

[[proxies]]  # 群辉SSH，使用的是TCP协议
name = "NAS"
type = "tcp"
localIP = "127.0.0.1"  # 因为是搭建在群辉上的，直接使用127.0.0.1即可
localPort = 22  # 本地端口(如果当前端口没开启是不能写的)
remotePort = 6001  # 服务器代理端口，远程就靠这端口访问

[[proxies]]  # 群辉Web，需要跟其他端口分开创建
name = "NAS-Web"
type = "tcp"
localIP = "127.0.0.1"
localPort = 5000
remotePort = 6002
```
`Frp可以做到局域网下一个机器给所有的设备解析，只需要在local_ip中填写其设备ip`
>如果有解析域名，Web可以使用http协议，具体查看官方说明frpc_full.ini

### 测试Frp
>先测试是否可以正常运行，可以的话再做成自启
```bash
./frpc -c ./frpc.toml		#测试，Ctrl+C可以结束
nohup ./frpc -c ./frpc.toml &		#后台运行，Linux都可用
```
穿透成功在web中测试

### Frp添加开启自启
群辉Web——控制面板——任务计划——新建——触发的任务——用户定义的脚本

取个名字，用户账户root，开机自启
任务设置中，用户定义脚本填写：
```bash
sleep 600     #等待10分钟，群晖刚开机的时候iKuai还没有加载好

nohup /root/frp/frpc -c /root/frp/frpc.toml &
```

>有的是使用创建脚本的方案，过于繁琐，但是也收录以下吧
```bash
vi /root/frp/frpc.sh		#创建个脚本，并插入以下
	cd /root/frp
	nohup ./frpc -c ./frpc.toml &
chmod 755 /root/frp/frpc.sh	#设置权限

#然后在群辉自定义脚本中插入
sleep 600
/root/frp/frpc.sh
```

## Frps 服务端
本质和 frpc 类似，这里只放示例，其他参考 frpc

### Frps 服务端配置
`frps.toml`，新版配置文件
```bash
# 注释不能放在配置后面，特别是token，会被误当初内容
# 绑定端口
bindPort = 7000
kcpBindPort = 7000
# 密钥，双方一致
auth.token = "12356789"
# 仪表板可访问IP
webServer.addr = "0.0.0.0"
# 仪表板端口
webServer.port = 7500
# 仪表板用户名
webServer.user = "zwzw"
# 仪表板密码
webServer.password = "ai773203918"
```

# 官方完整配置文件示例
现在官方已经即将弃用 .ini 格式的配置文件，采用 .toml 格式
frps：https://github.com/fatedier/frp/blob/dev/conf/frps_full_example.toml
frpc：https://github.com/fatedier/frp/blob/dev/conf/frpc_full_example.toml

## frpc.toml 官网完整配置文件
```bash
# 你的代理名称将被更改为 {user}.{proxy}
user = "your_name"

# 对于IPv6的字面地址或主机名，必须用方括号括起来，如 "[::1]:80", "[ipv6-host]:http" 或 "[ipv6-host%zone]:80"
# 对于单个 serverAddr 字段，不需要方括号，如 serverAddr = "::"。
serverAddr = "0.0.0.0"
serverPort = 7000

# STUN 服务器帮助穿透 NAT 洞。
# natHoleStunServer = "stun.easyvoip.com:3478"

# 决定如果第一次登录失败就退出程序，否则会不断重新登录到 frps，默认为 true
loginFailExit = true

# 控制台或实际日志文件路径，如 ./frpc.log
log.to = "./frpc.log"
# 追踪，调试，信息，警告，错误
log.level = "info"
log.maxDays = 3
# 当 log.to 是控制台时，禁用日志颜色，默认为 false
log.disablePrintColor = false

auth.method = "token"
# auth.additionalScopes 指定包含身份验证信息的额外范围。
# 可选值是 HeartBeats, NewWorkConns。
# auth.additionalScopes = ["HeartBeats", "NewWorkConns"]

# 身份验证 token
auth.token = "12345678"

# oidc.clientID 指定在 OIDC 身份验证中用于获取令牌的客户 ID。
# auth.oidc.clientID = ""
# oidc.clientSecret 指定在 OIDC 身份验证中用于获取令牌的客户密钥。
# auth.oidc.clientSecret = ""
# oidc.audience 指定 OIDC 身份验证中令牌的受众。
# auth.oidc.audience = ""
# oidc.scope 指定 OIDC 身份验证中令牌的权限，如果 AuthenticationMethod == "oidc"。默认值为 ""。
# auth.oidc.scope = ""
# oidc.tokenEndpointURL 指定实现 OIDC Token Endpoint 的 URL。
# 它将被用来获取 OIDC 令牌。
# auth.oidc.tokenEndpointURL = ""

# oidc.additionalEndpointParams 指定要发送到 OIDC Token Endpoint 的额外参数。
# 例如，如果你想指定 "audience" 参数，你可以这样设置。
# frp 将添加 "audience=<value>" "var1=<value>" 到额外参数。
# auth.oidc.additionalEndpointParams.audience = "https://dev.auth.com/api/v2/&#34; 
# auth.oidc.additionalEndpointParams.var1 = "foobar"

# 设置管理员地址，通过 http api 控制 frpc 的行为，如重新加载
webServer.addr = "127.0.0.1"
webServer.port = 7400
webServer.user = "admin"
webServer.password = "admin"
# 管理员资源目录。默认情况下，这些资源与 frpc 捆绑在一起。
# webServer.assetsDir = "./static"

# 在管理员监听器中启用 golang pprof 处理程序。
webServer.pprofEnable = false

# 拨号到服务器的连接完成等待的最大时间。默认值为 10 秒。
# transport.dialServerTimeout = 10

# dialServerKeepalive 指定 frpc 和 frps 之间活动网络连接的保持活动探针间隔。
# 如果为负值，则禁用保持活动探针。
# transport.dialServerKeepalive = 7200

# 预先建立的连接数，默认值为零
transport.poolCount = 5

# 如果使用 tcp 流复用，默认为 true，它必须与 frps 相同
# transport.tcpMux = true

# 指定 tcp mux 的保持活动间隔。
# 仅当 tcpMux 启用时有效。
# transport.tcpMuxKeepaliveInterval = 30

# 用于连接到服务器的通信协议
# 现在支持 tcp, kcp, quic, websocket 和 wss，默认为 tcp
transport.protocol = "tcp"

# 设置客户端在连接服务器时绑定的 ip，默认为空。
# 仅当协议为 tcp 或 websocket 时，该值将被使用。
transport.connectServerLocalIP = "0.0.0.0"

# 如果你想要通过 http 代理或 socks5 代理或 ntlm 代理连接 frps，你可以在这里设置 proxyURL 或在全局环境变量中设置
# 它仅在协议为 tcp 时工作
# transport.proxyURL = "http://user:passwd@192.168.1.128:8080&#34; 
# transport.proxyURL = "socks5://user:passwd@192.168.1.128:1080"
# transport.proxyURL = "ntlm://user:passwd@192.168.1.128:2080"

# quic 协议选项
# transport.quic.keepalivePeriod = 10
# transport.quic.maxIdleTimeout = 30
# transport.quic.maxIncomingStreams = 100000

# 如果 tls.enable 为 true，则 frpc 将通过 tls 连接 frps。
# 自 v0.50.0 起，默认值已更改为 true，默认启用 tls。
transport.tls.enable = true

# transport.tls.certFile = "client.crt"
# transport.tls.keyFile = "client.key"
# transport.tls.trustedCaFile = "ca.crt"
# transport.tls.serverName = "example.com"

# 如果 disableCustomTLSFirstByte 设置为 false，则 frpc 在启用 tls 时将使用
# 第一个自定义字节与 frps 建立连接。
# 自 v0.50.0 起，默认值已更改为 true，默认禁用第一个自定义字节。
# transport.tls.disableCustomTLSFirstByte = true

# 心跳配置，不建议修改默认值。
# 默认的心跳间隔为 10，心跳超时为 90。设置负值以禁用它。
# transport.heartbeatInterval = 30
# transport.heartbeatTimeout = 90

# 指定一个 dns 服务器，因此 frpc 将使用这个而不是默认的
# dnsServer = "8.8.8.8"

# 要启动的代理名称。
# 默认为空，意味着所有代理。
# start = ["ssh", "dns"]

# 指定 udp 数据包大小，单位为字节。如果不设置，默认值为 1500。
# 此参数应在客户端和服务器之间保持一致。
# 它影响 udp 和 sudp 代理。
udpPacketSize = 1500

# 客户端的额外元数据。
metadatas.var1 = "abc"
metadatas.var2 = "123"

# 包含其他配置文件中的代理。
# includes = ["./confd/*.ini"]

[[proxies]]
# 'ssh' 是唯一的代理名称
# 如果全局用户不为空，它将被更改为 {user}.{proxy} 这样的 'your_name.ssh'
name = "ssh"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
# 限制此代理的带宽，单位是 KB 和 MB
transport.bandwidthLimit = "1MB"
# 限制带宽的位置，可以是 'client' 或 'server'，默认为 'client'
transport.bandwidthLimitMode = "client"
# 如果为 true，则此代理的流量将被加密，默认为 false
transport.useEncryption = false
# 如果为 true，则流量将被压缩
transport.useCompression = false
# frps 监听的远程端口
remotePort = 6001
# frps 将为同一组中的代理进行负载均衡
loadBalancer.group = "test_group"
# 组应该有相同的组密钥
loadBalancer.groupKey = "123456"
# 启用后端服务的健康检查，现在支持 'tcp' 和 'http'。
# frpc 将连接本地服务的端口以检测其健康状态
healthCheck.type = "tcp"
# 健康检查连接超时
healthCheck.timeoutSeconds = 3
# 如果连续失败 3 次，代理将从 frps 中移除
healthCheck.maxFailed = 3
# 每 10 秒进行一次健康检查
healthCheck.intervalSeconds = 10
# 为每个代理添加额外的元信息。它将传递到服务器端插件以供使用。
metadatas.var1 = "abc"
metadatas.var2 = "123"
# 你可以通过注释为代理添加一些额外的信息。
# 这些注释将在 frps 仪表板上显示。
[proxies.annotations]
key1 = "value1"
"prefix/key2" = "value2"

[[proxies]]
name = "ssh_random"
type = "tcp"
localIP = "192.168.31.100"
localPort = 22
# 如果 remotePort 为 0，则 frps 将为你分配一个随机端口
remotePort = 0

[[proxies]]
name = "dns"
type = "udp"
localIP = "114.114.114.114"
localPort = 53
remotePort = 6002

# 将你的域名解析到 [serverAddr]，这样你就可以使用 http://web01.yourdomain.com 浏览 web01 和 http://web02.yourdomain.com 浏览 web02
[[proxies]]
name = "web01"
type = "http"
localIP = "127.0.0.1"
localPort = 80
# http 用户名和密码是 http 协议的安全认证
# 如果不设置，你可以在没有认证的情况下访问这个 customDomains
httpUser = "admin"
httpPassword = "admin"
# 如果 frps 的域名是 frps.com，那么你可以访问 [web01] 代理通过 URL http://web01.frps.com
subdomain = "web01"
customDomains = ["web01.yourdomain.com"]
# locations 仅适用于 http 类型
locations = ["/", "/pic"]
# 如果 http 基本自动用户是 abc，则路由请求到此服务
# routeByHTTPUser = abc
hostHeaderRewrite = "example.com"
requestHeaders.set.x-from-where = "frp"
responseHeaders.set.foo = "bar"
healthCheck.type = "http"
# frpc 将向本地 http 服务发送 GET http 请求 '/status'
# 当它返回 2xx http 响应码时，http 服务是活跃的
healthCheck.path = "/status"
healthCheck.intervalSeconds = 10
healthCheck.maxFailed = 3
healthCheck.timeoutSeconds = 3
# 设置健康检查头部
healthCheck.httpHeaders=[
    { name = "x-from-where", value = "frp" }
]

[[proxies]]
name = "web02"
type = "https"
localIP = "127.0.0.1"
localPort = 8000
subdomain = "web02"
customDomains = ["web02.yourdomain.com"]
# 如果不为空，frpc 将使用代理协议将连接信息传输到你的本地服务
# v1 或 v2 或空
transport.proxyProtocolVersion = "v2"

[[proxies]]
name = "tcpmuxhttpconnect"
type = "tcpmux"
multiplexer = "httpconnect"
localIP = "127.0.0.1"
localPort = 10701
customDomains = ["tunnel1"]
# 如果 http 基本自动用户是 user1

[[proxies]]
name = "plugin_unix_domain_socket"
type = "tcp"
remotePort = 6003
# 如果定义了插件，localIP 和 localPort 是无用的
# 插件将处理从 frps 得到的连接
[proxies.plugin]
type = "unix_domain_socket"
unixPath = "/var/run/docker.sock"

[[proxies]]
name = "plugin_http_proxy"
type = "tcp"
remotePort = 6004
[proxies.plugin]
type = "http_proxy"
httpUser = "abc"
httpPassword = "abc"

[[proxies]]
name = "plugin_socks5"
type = "tcp"
remotePort = 6005
[proxies.plugin]
type = "socks5"
username = "abc"
password = "abc"

[[proxies]]
name = "plugin_static_file"
type = "tcp"
remotePort = 6006
[proxies.plugin]
type = "static_file"
localPath = "/var/www/blog"
stripPrefix = "static"
httpUser = "abc"
httpPassword = "abc"

[[proxies]]
name = "plugin_https2http"
type = "https"
customDomains = ["test.yourdomain.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"

[[proxies]]
name = "plugin_https2https"
type = "https"
customDomains = ["test.yourdomain.com"]
[proxies.plugin]
type = "https2https"
localAddr = "127.0.0.1:443"
crtPath = "./server.crt"
keyPath = "./server.key"
hostHeaderRewrite = "127.0.0.1"
requestHeaders.set.x-from-where = "frp"

[[proxies]]
name = "plugin_http2https"
type = "http"
customDomains = ["test.yourdomain.com"]
[proxies.plugin]
type = "http2https"
localAddr = "127.0.0.1:443"
hostHeaderRewrite = "127.0.0.1"
requestHeaders.set.x-from-where = "frp"

[[proxies]]
name = "plugin_http2http"
type = "tcp"
remotePort = 6007
[proxies.plugin]
type = "http2http"
localAddr = "127.0.0.1:80"
hostHeaderRewrite = "127.0.0.1"
requestHeaders.set.x-from-where = "frp"

[[proxies]]
name = "plugin_tls2raw"
type = "tcp"
remotePort = 6008
[proxies.plugin]
type = "tls2raw"
localAddr = "127.0.0.1:80"
crtPath = "./server.crt"
keyPath = "./server.key"

[[proxies]]
name = "secret_tcp"
# 如果类型是 secret tcp，remotePort 是无用的
# 想要连接本地端口的应该部署另一个带有 stcp 代理和访问者角色的 frpc
type = "stcp"
# secretKey 用于访问者的认证
secretKey = "abcdefg"
localIP = "127.0.0.1"
localPort = 22
# 如果不为空，只有指定用户的访问者可以连接。
# 否则，来自同一用户的访问者可以连接。'*' 表示允许所有用户。
allowUsers = ["*"]

[[proxies]]
name = "p2p_tcp"
type = "xtcp"
secretKey = "abcdefg"
localIP = "127.0.0.1"
localPort = 22
# 如果不为空，只有指定用户的访问者可以连接。
# 否则，来自同一用户的访问者可以连接。'*' 表示允许所有用户。
allowUsers = ["user1", "user2"]

# frpc 角色访问者 -> frps -> frpc 角色服务器
[[visitors]]
name = "secret_tcp_visitor"
type = "stcp"
# 你想要访问的服务器名称
serverName = "secret_tcp"
secretKey = "abcdefg"
# 连接这个地址以访问 stcp 服务器
bindAddr = "127.0.0.1"
# bindPort 可以小于 0，这意味着不要绑定到端口，只接收从
# 其他访问者重定向的连接。（目前 SUDP 不支持）
bindPort = 9000

[[visitors]]
name = "p2p_tcp_visitor"
type = "xtcp"
# 如果服务器用户未设置，默认为当前用户
serverUser = "user1"
serverName = "p2p_tcp"
secretKey = "abcdefg"
bindAddr = "127.0.0.1"
# bindPort 可以小于 0，这意味着不要绑定到端口，只接收从
# 其他访问者重定向的连接。（目前 SUDP 不支持）
bindPort = 9001
# 当需要自动隧道持久性时，将其设置为 true
keepTunnelOpen = false
# 当 keepTunnelOpen 设置为 true 时有效，每小时尝试穿透的次数
maxRetriesAnHour = 8
minRetryInterval = 90
# fallbackTo = "stcp_visitor"
# fallbackTimeoutMs = 500
```

## frps.toml 官网完整配置文件
```bash
# 对于IPv6的字面地址或主机名，必须用方括号括起来，如 "[::1]:80", "[ipv6-host]:http" 或 "[ipv6-host%zone]:80"
# 对于单个 "bindAddr" 字段，不需要方括号，如 `bindAddr = "::"`。
bindAddr = "0.0.0.0"
bindPort = 7000

# kcp协议使用的udp端口，可以与 'bindPort' 相同。
# 如果不设置，frps中将禁用kcp。
kcpBindPort = 7000

# quic协议使用的udp端口。
# 如果不设置，frps中将禁用quic。
# quicBindPort = 7002

# 指定代理将监听的地址，默认值与bindAddr相同
# proxyBindAddr = "127.0.0.1"

# quic协议选项
# transport.quic.keepalivePeriod = 10
# transport.quic.maxIdleTimeout = 30
# transport.quic.maxIncomingStreams = 100000

# 心跳配置，不建议修改默认值
# 默认的心跳超时时间是90。设置负值以禁用它。
# transport.heartbeatTimeout = 90

# 每个代理中保持的池计数不超过maxPoolCount。
transport.maxPoolCount = 5

# 如果使用tcp流复用，默认为true
# transport.tcpMux = true

# 指定tcp mux的保持活动间隔。
# 仅当tcpMux为true时有效。
# transport.tcpMuxKeepaliveInterval = 30

# tcpKeepalive指定frpc和frps之间活动网络连接的保持活动探针间隔。
# 如果为负值，则禁用保持活动探针。
# transport.tcpKeepalive = 7200

# transport.tls.force指定是否只接受TLS加密连接，默认值为false。
transport.tls.force = false

# transport.tls.certFile = "server.crt"
# transport.tls.keyFile = "server.key"
# transport.tls.trustedCaFile = "ca.crt"

# 如果你想要支持虚拟主机，你必须设置用于监听的http端口（可选）
# 注意：http端口和https端口可以与bindPort相同
vhostHTTPPort = 80
vhostHTTPSPort = 443

# vhost http服务器的响应头超时（秒），默认为60秒
# vhostHTTPTimeout = 60

# tcpmuxHTTPConnectPort指定服务器监听TCP HTTP CONNECT请求的端口。如果值为0，则服务器不会在单个端口上复用TCP请求。如果不是0，则服务器将在此值上监听HTTP CONNECT请求。默认值为0。
# tcpmuxHTTPConnectPort = 1337

# 如果tcpmuxPassthrough为true，frps不会对流量进行任何更新。
# tcpmuxPassthrough = false

# 配置web服务器以启用frps的仪表板。
# 只有当webServer.port设置时，仪表板才可用。
webServer.addr = "127.0.0.1"
webServer.port = 7500
webServer.user = "admin"
webServer.password = "admin"
# webServer.tls.certFile = "server.crt"
# webServer.tls.keyFile = "server.key"
# 仪表板资源目录（仅用于调试模式）
# webServer.assetsDir = "./static"

# 在仪表板监听器中启用golang pprof处理程序。
# 必须首先设置仪表板端口
webServer.pprofEnable = false

# enablePrometheus将在webServer的/metrics api上导出prometheus指标。
enablePrometheus = true

# 控制台或实际日志文件路径，如./frps.log
log.to = "./frps.log"
# 追踪，调试，信息，警告，错误
log.level = "info"
log.maxDays = 3
# 当log.to是控制台时，禁用日志颜色，默认为false
log.disablePrintColor = false

# DetailedErrorsToClient定义是否将具体错误（带有调试信息）发送给frpc。默认值为true。
detailedErrorsToClient = true

# auth.method指定用于验证frpc与frps之间身份验证的方法。
# 如果指定"token"，则token将读入登录消息。
# 如果指定"oidc"，则将使用OIDC设置颁发OIDC（Open ID Connect）令牌。默认值为"token"。
auth.method = "token"

# auth.additionalScopes指定包含身份验证信息的额外范围。
# 可选值是HeartBeats，NewWorkConns。
# auth.additionalScopes = ["HeartBeats", "NewWorkConns"]

# auth token
auth.token = "12345678"

# oidc issuer指定用于验证OIDC令牌的发行者。
auth.oidc.issuer = ""
# oidc audience指定验证时OIDC令牌应包含的受众。
auth.oidc.audience = ""
# oidc skipExpiryCheck指定是否跳过检查OIDC令牌是否过期。
auth.oidc.skipExpiryCheck = false
# oidc skipIssuerCheck指定是否跳过检查OIDC令牌的发行者声明是否与OidcIssuer中指定的发行者匹配。
auth.oidc.skipIssuerCheck = false

# userConnTimeout指定等待工作连接的最大时间。
# userConnTimeout = 10

# 只允许frpc绑定你列出的端口。默认情况下，不会有任何限制。
allowPorts = [
  { start = 2000, end = 3000 },
  { single = 3001 },
  { single = 3003 },
  { start = 4000, end = 50000 }
]

# 每个客户端可以使用的最大端口数，默认值为0表示无限制
maxPortsPerClient = 0

# 如果subDomainHost不为空，你可以在frpc的配置文件中设置子域名，当类型为http或https时
# 当子域名为test时，路由使用的主机是test.frps.com
subDomainHost = "frps.com"

# 自定义HTTP请求的404页面
# custom404Page = "/path/to/404.html"

# 指定udp数据包大小，单位为字节。如果不设置，默认值为1500。
# 此参数应在客户端和服务器之间保持一致。
# 它影响udp和sudp代理。
udpPacketSize = 1500

# NAT打洞策略数据的保留时间。
natholeAnalysisDataReserveHours = 168

# ssh隧道网关
# 如果你想要启用此功能，需要bindPort参数，而其他参数是可选的。
# 默认情况下，此功能是禁用的。如果bindPort大于0，则将启用它。
# sshTunnelGateway.bindPort = 2200
# sshTunnelGateway.privateKeyFile = "/home/frp-user/.ssh/id_rsa"
# sshTunnelGateway.autoGenPrivateKeyPath = ""
# sshTunnelGateway.authorizedKeysFile = "/home/frp-user/.ssh/authorized_keys"

[[httpPlugins]]
name = "user-manager"
addr = "127.0.0.1:9000"
path = "/handler"
ops = ["Login"]

[[httpPlugins]]
name = "port-manager"
addr = "127.0.0.1:9001"
path = "/handler"
ops = ["NewProxy"]
```

### Frps 服务运行
```bash
./frps -c frps.ini			# 测试运行
nohup ./frps -c frps.ini &		# 后台运行
```