Saika's Blog

跨越10年又回归免流

2025-08-21T19:20:35.641Z

早在大概 2014 年 -2015 年时，我还没有用上 4G 网络（主要是因为手机不支持），手机还在用着小米 2s，我就第一次接触到了免流。当时并不是特别懂其中的原理，只知道按照网上大佬们发的什么 Tiny、Hap、扫地僧防跳等等教程一步一步跟着做。当时很简单就成功用上了免流，实现了流量自由。没多久我又更换了支持 4G 的手机，配合 HTTP Injector，畅玩免流开热点，顺带还买了台 z8300 的 windows 寨板，简单玩玩游戏看看电影，在那个年代一个月能跑七八十 G 流量。再后来上大学，开始办各种流量卡，就再也没用过免流了。

因为各种流量卡的优惠期有限，各种过筛后我只保留了两张 5R 月租的联通卡进行保号，因为这两张卡也都可以日租无限流量包，于是我也就凑合用。用了几年的日租，我觉得这极其不值得。我是一个软路由用户，我平常更愿意也更多使用宽带 wifi 进行上网，本身流量用的也不多，但是即便一天只使用几百MB流量，也会被运营商开一天的日租包，综合下来一个月开销 30+，用的流量却才不到 10G。正当我在研究携号转网想换个套餐的时候，意外发现我的其中一张卡——星粉卡，支持百度直连免流和头条系混淆免流，于是时隔 10 年，我又开始研究免流了。

原理分析

首先我找到了不良林的介绍视频：不良林的介绍视频

我认为这个视频做得很好，讲的挺透彻，也让我明白了如今的定向流量免流和我当年使用的免流有着不小的区别——定向流量免流是有专属定向流量的代理服务器的，并不都是根据 Host 判断。

初步尝试

那么接下来，就是在酷安找了一个 Magisk 模块，同时进行 Clnc 和 V2Ray 的分流，来进行国内外流量分流进行免流。国内流量使用百度的代理服务器进行代理，国外的流量使用 V2ray 中的海外服务器部署的云免配置进行代理，使得不仅流量不要钱，而且还能魔法上网。

这个方案是使用 Clnc 的 TUN 来接管的整机流量，所以分流也是由 Clnc 来做的，而我找到的模块配置也好，Clnc 的 Github 上的示例配置也好，做流量分流都只能根据目标 IP 来判断，只能一次性把国内 IP 段全都丢进配置文件，规则让其走百度直连，剩余的走 V2Ray 走海外云免。

这个分流让我十分不满意，因为习惯性使用 Sing-box 和 Mihomo，我更乐意使用现成的 GEOSITE 和 GEOIP 数据库来进行流量分流，配置方便而且支持自动更新。

尝试改进

我发现 Clnc 可以只启动一个 Socks5 代理而不占用 TUN 时，我想到是不是可以用 Clnc 只配置百度直连，开放一个 Socks5 端口用于给 Mihomo 接入，由 Mihomo 进行国内外分流。随机我就去酷安发帖问了，毕竟我一个时隔这么久才回来研究免流的人都想得到，那么一直在使用免流的人应该早就想到过了。很快就有大佬指点我，百度直连可以直接写成 HTTP 代理出站，配置相应的 Header 信息就好了。

配置文件

刚好，之前自己写过 Mihomo 的配置文件，再拿出来改一改，这不就完美了吗：

rule-providers:
  AWAvenue-Ads:
    type: http
    behavior: domain
    format: yaml
    url: "https://ghfast.top/https://raw.githubusercontent.com/TG-Twilight/AWAvenue-Ads-Rule/refs/heads/main/Filters/AWAvenue-Ads-Rule-Clash-Classical.yaml"
    interval: 600

mode: rule
ipv6: true
log-level: info
allow-lan: true
mixed-port: 7890
redir-port: 7891
tproxy-port: 1536
unified-delay: true
tcp-concurrent: true
external-controller: :9090
external-ui: /data/adb/box/mihomo/ui

geodata-mode: true

geox-url:
  geoip: "https://ghfast.top/https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geoip.dat"
  geosite: "https://ghfast.top/https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geosite.dat"
  mmdb: "https://ghfast.top/https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/country.mmdb"
  
geo-auto-update: true
geo-update-interval: 72

find-process-mode: always

keep-alive-interval: 1800

global-client-fingerprint: random 

profile:
  store-selected: true
  store-fake-ip: true

ntp:
  enable: true
  write-to-system: false
  server: time.apple.com
  port: 123
  interval: 30

sniffer:
  enable: true
  sniff:
    TLS:
      ports: [443, 8443]
    HTTP:
      ports: [80, 8080-8880]
      override-destination: true

tun:
  enable: true
  stack: system
  device: Meta
  dns-hijack:
    - "any:53"
    - "tcp://any:53"
  auto-route: true
  auto-detect-interface: true

dns:
  enable: true
  listen: :1053
  ipv6: true
  enhanced-mode: fake-ip
  fake-ip-range: 28.0.0.1/8
  fake-ip-filter:
    - '*'
    - '+.lan'
    - '+.local'
    # （不要写 '*'，否则 fake-ip 等于白配）
  default-nameserver:
    - 1.1.1.1
    - 8.8.8.8
    - 114.114.114.114
    - 119.29.29.29
    - 223.5.5.5
    - '[2402:4e00::]'
    - '[2400:3200::1]'
  nameserver:
    - 'https://dns.google/dns-query'
    - 'https://1.1.1.1/dns-query'
    - 'https://dns.alidns.com/dns-query'
    - 'tls://dns.google'
    - 'tls://one.one.one.one'
    - 'tls://8.8.4.4#dns'
    - 'tls://1.0.0.1#dns'
    - 'tls://[2001:4860:4860::8844]#dns'
    - 'tls://[2606:4700:4700::1001]#dns'
  fallback:
    - 'tls://8.8.8.8#dns'
    - 'tls://1.1.1.1#dns'
    - 'https://dns.cloudflare.com/dns-query'
  proxy-server-nameserver:
    - https://doh.pub/dns-query
    - https://dns.alidns.com/dns-query
  nameserver-policy:
    'geosite:cn,private':
      - https://doh.pub/dns-query
      - https://dns.alidns.com/dns-query
    "geosite:!cn,!private": 
      - "tls://dns.google"
      - "tls://cloudflare-dns.com"

proxies:
  - name: Baidu_HTTP_NanJing
    type: http
    server: 153.3.237.117
    port: 443
    udp: false
    ip-version: ipv4
    headers:
      X-T5-Auth: "683556433"
      Host: 153.3.236.22:443
      With-At: "dm.toutiao.com"
      User-Agent:
        "okhttp/3.11.0 Dalvik/2.1.0 (Linux; U; Android 11; Redmi K30 5G Build/RKQ1.200826.002)
        baiduboxapp/11.0.5.12 (Baidu; P1 11)"

  - name: Baidu_HTTP_SuZhou
    type: http
    server: 157.0.146.158
    port: 443
    udp: false
    ip-version: ipv4
    headers:
      X-T5-Auth: "683556433"
      Host: 153.3.236.22:443
      With-At: "dm.toutiao.com"
      User-Agent:
        "okhttp/3.11.0 Dalvik/2.1.0 (Linux; U; Android 11; Redmi K30 5G Build/RKQ1.200826.002)
        baiduboxapp/11.0.5.12 (Baidu; P1 11)"

  - name: Baidu_HTTP_BaoDing_1
    type: http
    server: 110.242.70.69
    port: 443
    udp: false
    ip-version: ipv4
    headers:
      X-T5-Auth: "683556433"
      Host: 153.3.236.22:443
      With-At: "dm.toutiao.com"
      User-Agent:
        "okhttp/3.11.0 Dalvik/2.1.0 (Linux; U; Android 11; Redmi K30 5G Build/RKQ1.200826.002)
        baiduboxapp/11.0.5.12 (Baidu; P1 11)"

  - name: Baidu_HTTP_BaoDing_2
    type: http
    server: 110.242.70.68
    port: 443
    udp: false
    ip-version: ipv4
    headers:
      X-T5-Auth: "683556433"
      Host: 153.3.236.22:443
      With-At: "dm.toutiao.com"
      User-Agent:
        "okhttp/3.11.0 Dalvik/2.1.0 (Linux; U; Android 11; Redmi K30 5G Build/RKQ1.200826.002)
        baiduboxapp/11.0.5.12 (Baidu; P1 11)"

  - name: 🇺🇸US_VL_Reality_Obfuscated
    type: vless
    server: 1.1.1.1
    port: 443
    uuid: 90000000-0000-0000-0000-0000000000ae
    network: tcp
    udp: true
    tls: true
    flow: xtls-rprx-vision
    servername: dm.toutiao.com
    headers:
      Host: dm.toutiao.com
    reality-opts:
      public-key: GQ0006SR00001xdK9J500000V_Ws000001Z0000TNg0
      short-id: "f00000f0"
    client-fingerprint: chrome

  - name: 🇳🇱NL_VM_Ws_Obfuscated
    type: vmess
    server: 1.1.1.1
    port: 443
    uuid: 90000000-0000-0000-0000-0000000000ae
    alterId: 0
    cipher: auto
    udp: true
    tls: false
    network: ws
    servername: www.cloudflare.com
    ws-opts:
      path: "90000000-0000-0000-0000-0000000000ae-vm"                         
      headers:
        Host: dm.toutiao.com

proxy-groups: 
  - {
      name: "🇨🇳 国内免流",
      type: select,
      proxies:
        [
          "♻️ 自动选择(国内免流)",
          "♻️ 自动选择(海外免流)",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
          DIRECT,
          REJECT,
        ],
    }
  - {
      name: "🌍 国外免流",
      type: select,
      proxies:
        [
          "♻️ 自动选择(海外免流)",
          "♻️ 自动选择(国内免流)",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
          DIRECT,
          REJECT,
        ],
    }
  - {
      name: "🚀 手动切换",
      type: select,
      proxies:
        [
          "🇨🇳 国内免流",
          "🌍 国外免流"
          "♻️ 自动选择(国内免流)",
          "♻️ 自动选择(海外免流)",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "♻️ 自动选择(国内免流)",
      type: url-test,
      proxies:
        [
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
        ],
      url: "https://www.baidu.com",
      interval: 86400,
    }
  - {
      name: "♻️ 自动选择(海外免流)",
      type: url-test,
      proxies:
        [
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
      url: "http://cp.cloudflare.com",
      interval: 86400,
    }
  # - {
  #     name: "🇧 哔哩哔哩",
  #     type: select,
  #     proxies:
  #       [
  #         "🚀 节点选择",
  #         DIRECT,
  #         "reality",
  #         "hy2",
  #         "tuic5",
  #       ],
  #   }
  # - {
  #     name: "🇧 哔哩东南亚",
  #     type: select,
  #     proxies:
  #       [
  #         "🚀 节点选择",
  #         DIRECT,
  #         "reality",
  #         "hy2",
  #         "tuic5",
  #       ],
  #   }
  - {
      name: "🌍 国外媒体",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🇳 Netflix",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🇹 Tiktok",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🇧 巴哈姆特",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }

  - {
      name: "🆂 Spotify",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🇦 Abema",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🆂 Steam",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🇫 Facebook",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "📲 电报信息",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🇽 推特消息",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🖥 ChatGPT",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🅿️ Pixiv",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🇪 E-Hentai",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🖴 OneDrive",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "Ⓜ️ 微软服务",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🍎 苹果服务",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🇬 谷歌服务",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🇬 GitHub",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🇨 Cloudflare",
      type: select,
      proxies:
        [
          "🌍 国外免流"
          "🇨🇳 国内免流",
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  # - {
  #     name: "🇨 Cloudfront",
  #     type: select,
  #     proxies:
  #       [
  #         DIRECT,
  #         "🚀 节点选择",
  #         "♻️ 自动选择",
  #         "reality",
  #         "hy2",
  #         "tuic5",
  #       ],
  #   }
  - {
      name: "🎯 全球直连",
      type: select,
      proxies:
        [
          "🇨🇳 国内免流",
          "🌍 国外免流"
          "🚀 手动切换",
          DIRECT,
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🛑 全球拦截",
      type: select,
      proxies:
        [
          REJECT,
          DIRECT,
          "🇨🇳 国内免流",
          "🌍 国外免流"
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🍃 应用净化",
      type: select,
      proxies:
        [
          REJECT,
          DIRECT,
          "🇨🇳 国内免流",
          "🌍 国外免流"
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
        ],
    }
  - {
      name: "🐟 漏网之鱼",
      type: select,
      proxies:
        [
          "🇨🇳 国内免流",
          "🌍 国外免流"
          "🚀 手动切换",
          "Baidu_HTTP_NanJing",
          "Baidu_HTTP_SuZhou",
          "Baidu_HTTP_BaoDing_1",
          "Baidu_HTTP_BaoDing_2",
          "🇺🇸US_VL_Reality_Obfuscated",
          "🇳🇱NL_VM_Ws_Obfuscated",
          REJECT,
          DIRECT,
        ],
    }

rules:
  # 若需禁用 QUIC 请取消注释 QUIC 两条规则
  # 防止 YouTube 等使用 QUIC 导致速度不佳, 禁用 443 端口 UDP 流量（不包括国内）

  # - AND,(AND,(DST-PORT,443),(NETWORK,UDP)),(NOT,((GEOSITE,cn))),REJECT # quic
  - RULE-SET,AWAvenue-Ads,🍃 应用净化
  - DST-PORT,53,🌍 国外免流
  # - DST-PORT,6653,🌍 国外免流
  # - DST-PORT,1053,🌍 国外免流
  - NETWORK,udp,🌍 国外免流
  - IP-CIDR6,::/0,🌍 国外免流
  # - GEOSITE,biliintl,🇧 哔哩东南亚
  # - GEOSITE,bilibili,🇧 哔哩哔哩

  # 可在下方加入自己特需的规则
  # - DOMAIN-SUFFIX,libvio.fun,🎯 全球直连
  # - DOMAIN-KEYWORD,admarvel,🛑 全球拦截
  # - DOMAIN-SUFFIX,kajicam.com,🌍 国外媒体
  # - DOMAIN,s3-ap-southeast-1.amazonaws.com,🌍 国外媒体
  # - IP-CIDR,69.53.224.0/19,🌍 国外媒体,no-resolve
  - DOMAIN-SUFFIX,libvio.fun,🎯 全球直连
  - DOMAIN-SUFFIX,dcg.microsoft.com,🎯 全球直连
  - DOMAIN-SUFFIX,windowsphone.com,🎯 全球直连
  - DOMAIN-SUFFIX,windowsphone-int.com,🎯 全球直连
  - DOMAIN-SUFFIX,kajicam.com,🌍 国外媒体
  - DOMAIN-SUFFIX,fanmingming.com,🌍 国外媒体
  - DOMAIN-SUFFIX,xn--sss604efuw.com,🌍 国外媒体
  - DOMAIN-SUFFIX,mayiyingshi.net,🌍 国外媒体
  - DOMAIN-SUFFIX,reddit.com,🌍 国外媒体
  - DOMAIN-SUFFIX,greasyfork.org,🌍 国外媒体
  - DOMAIN-SUFFIX,nodeseek.com,🌍 国外媒体
  - DOMAIN-SUFFIX,missav.ws,🌍 国外媒体
  - DOMAIN-SUFFIX,missav.ai,🌍 国外媒体
  - DOMAIN-SUFFIX,xhamster.com,🌍 国外媒体
  - DOMAIN-SUFFIX,xhcdn.com,🌍 国外媒体
  - DOMAIN-SUFFIX,ahcdn.com,🌍 国外媒体
  - DOMAIN-SUFFIX,nodeloc.com,🌍 国外媒体
  - DOMAIN-SUFFIX,nodeseek.com,🌍 国外媒体
  - DOMAIN-SUFFIX,hostloc.com,🌍 国外媒体
  - DOMAIN-SUFFIX,linux.do,🌍 国外媒体
  - DOMAIN-SUFFIX,discord.gg,🌍 国外媒体
  - DOMAIN-SUFFIX,ipify.org,🌍 国外媒体
  - DOMAIN-SUFFIX,ip.sb,🌍 国外媒体
  - DOMAIN-SUFFIX,winget.run,🌍 国外媒体
  - DOMAIN-SUFFIX,hmoegirl.com,🌍 国外媒体
  - DOMAIN-SUFFIX,wikipedia.org,🌍 国外媒体
  - DOMAIN-SUFFIX,moegirl.uk,🌍 国外媒体
  - DOMAIN-SUFFIX,hmoegirl.com,🌍 国外媒体
  - DOMAIN-SUFFIX,hmoegirl.cyou,🌍 国外媒体
  - DOMAIN-SUFFIX,cursor.sh,🖥 ChatGPT
  - DOMAIN-SUFFIX,cursor.com,🖥 ChatGPT

  - GEOSITE,CATEGORY-AI-CHAT-!CN,🖥 ChatGPT
  - GEOSITE,category-scholar-!cn,🖥 ChatGPT
  - GEOSITE,apple,🍎 苹果服务
  - GEOSITE,apple-cn,🍎 苹果服务
  - GEOSITE,ehentai,🇪 E-Hentai
  - GEOSITE,github,🇬 GitHub
  - GEOSITE,twitter,🇽 推特消息
  - GEOSITE,youtube,🇬 谷歌服务
  - GEOSITE,google,🇬 谷歌服务
  - GEOSITE,google-cn,🇬 谷歌服务
  - GEOSITE,telegram,📲 电报信息
  - GEOSITE,abema,🇦 Abema
  - GEOSITE,netflix,🇳 Netflix
  - GEOSITE,tiktok,🇹 Tiktok
  - GEOSITE,bahamut,🇧 巴哈姆特
  - GEOSITE,spotify,🆂 Spotify
  - GEOSITE,pixiv,🅿️ Pixiv
  - GEOSITE,steam@cn,DIRECT
  - GEOSITE,steam,🆂 Steam
  - GEOSITE,onedrive,🖴 OneDrive
  - GEOSITE,microsoft,Ⓜ️ 微软服务
  - GEOSITE,geolocation-!cn,🐟 漏网之鱼
  # - AND,(AND,(DST-PORT,443),(NETWORK,UDP)),(NOT,((GEOIP,CN))),REJECT # quic
  - GEOIP,google,🇬 谷歌服务
  - GEOIP,netflix,🇳 Netflix
  - GEOIP,facebook,🇫 Facebook
  - GEOIP,telegram,📲 电报信息
  - GEOIP,twitter,🇽 推特消息
  - GEOSITE,cloudflare,🇨 Cloudflare
  - GEOIP,cloudflare,🇨 Cloudflare
  # - GEOIP,cloudfront,🇨 Cloudfront
  - GEOSITE,CN,🎯 全球直连
  - GEOIP,CN,🎯 全球直连
  # 绕过局域网地址
  - IP-CIDR,10.0.0.0/8,DIRECT
  - IP-CIDR,172.16.0.0/12,DIRECT
  - IP-CIDR,192.168.0.0/16,DIRECT
  - IP-CIDR,100.64.0.0/10,DIRECT
  - IP-CIDR,127.0.0.0/8,DIRECT
  - MATCH,🐟 漏网之鱼。

配置详解

百度直连的几个 HTTP 出站，其 IP 地址是使用全国地区 Ping 工具解析百度代理服务器 cloudnproxy.n.shifen.com 的 IP 地址并去除掉广东地区的剩余结果。必须携带相应的 Header 才可以连接。其 Header 应该是抓包百度的某款 APP 所得，由于不知道是哪一个 APP，故我没有自行抓包了。

海外免流的代理需要满足以下条件：1,使用 80\443 端口；2,能够自定义连接时的 Header 信息以填入混淆域名。经我自测，Vmess-ws 以及 Vless-Reality均可使用，此外，根据查到的信息，Vless-tcp 和 Vmess-tcp 也可以。考虑到数据安全和防封两方面，我推荐使用 Reality 代理，正好 dm.toutiao.com 这个伪装域名的解析结果也是国外 IP，有一定心理作用上的防封效果。

分流规则上，由于百度直连的 HTTP 代理不能代理 UDP 和 IPv6 流量，所以需要将 UDP 和 IPv6 分流到海外免流。如果没有使用 IPv6 的需求，最好是关闭 IPv6 的相关功能，以免出现异常。我写的分流规则比较详细，适合拥有多台不同 IP 的 VPS 玩家，以便针对不同 IP 要求（如 NetFlix、ChatGPT 等等）进行分流。

实战使用

推荐使用 Box4Magisk，下载好 Releases 中打包好的模块，将 Mihomo 最新的核心文件丢进去，再把写好的配置文件丢进去，再根据自己的需求修改模块配置文件，最后刷入即可。我选择不使用 Box4Magisk 的透明代理，而直接使用 Mihomo 自带的 TUN 来接管。由于 Mihomo 本身不具备配置绕过 WiFi 的功能，所以我在 Xposed Edge Pro 中配置了触发器，连接 WiFi 时自动关闭 Box4Magisk，而断开 WiFi 连接时自动启动 Box4Magisk。命令如下：

启动服务：
/data/adb/box/scripts/box.service start
停止服务：
/data/adb/box/scripts/box.service stop

这样代理也不会和我软路由上的 OpenClash 有所冲突，而断开 WiFi 时又能享受到免流。唯一缺点就是断开 WiFi 后到 Mihomo 启动成功前的几百毫秒可能会跑一些通用流量。因为我的星粉卡有每月 1G 通用流量，也够这点消耗，所以也在能够接受的范围了。如果没有任何通用流量的卡想要使用这个方法尝试免流，我建议使用透明代理的方式，并在透明代理中配置绕过 WLAN。

Clash 配置文件备份

2025-03-18T02:04:58.505Z

rule-providers:
  AWAvenue-Ads:
    type: http
    behavior: domain
    format: yaml
    url: "https://ghfast.top/https://raw.githubusercontent.com/TG-Twilight/AWAvenue-Ads-Rule/refs/heads/main/Filters/AWAvenue-Ads-Rule-Clash-classical.yaml"
    interval: 600

mode: rule
ipv6: true
log-level: info
allow-lan: true
mixed-port: 7890
unified-delay: true
tcp-concurrent: true
external-controller: :9090

geodata-mode: true

geox-url:
  geoip: "https://ghfast.top/https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geoip.dat"
  geosite: "https://ghfast.top/https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/geosite.dat"
  mmdb: "https://ghfast.top/https://github.com/MetaCubeX/meta-rules-dat/releases/download/latest/country.mmdb"

find-process-mode: strict

keep-alive-interval: 1800

global-client-fingerprint: random 

profile:
  store-selected: true
  store-fake-ip: true

ntp:
  enable: true
  write-to-system: false
  server: time.apple.com
  port: 123
  interval: 30

sniffer:
  enable: true
  sniff:
    TLS:
      ports: [443, 8443]
    HTTP:
      ports: [80, 8080-8880]
      override-destination: true

tun:
  enable: false
  stack: system
  dns-hijack:
    - "any:53"
    - "tcp://any:53"
  auto-route: true
  auto-detect-interface: true

dns:
  enable: true
  listen: :1053
  ipv6: true
  enhanced-mode: redir-host
  fake-ip-range: 28.0.0.1/8
  fake-ip-filter:
    - '*'
    - '+.lan'
    - '+.local'
  default-nameserver:
    - 223.5.5.5
    - 119.29.29.29
    - 114.114.114.114
    - '[2402:4e00::]'
    - '[2400:3200::1]'
  nameserver:
    - 'tls://8.8.4.4#dns'
    - 'tls://1.0.0.1#dns'
    - 'tls://[2001:4860:4860::8844]#dns'
    - 'tls://[2606:4700:4700::1001]#dns'
  proxy-server-nameserver:
    - https://doh.pub/dns-query
  nameserver-policy:
    "geosite:cn,private":
      - https://doh.pub/dns-query
      - https://dns.alidns.com/dns-query
    "geosite:!cn,!private": 
      - "tls://dns.google"
      - "tls://cloudflare-dns.com"

proxies:
# 按照格式把代理一个个贴进来
  - name: reality
    type: vless
    server: 1.1.1.1
    port: 80
    uuid: 00000000-0000-0000-0000-000000000000
    network: tcp
    udp: true
    tls: true
    flow: xtls-rprx-vision
    servername: www.yahoo.com
    reality-opts:
      public-key: 0000000000
      short-id: "00000000"
    client-fingerprint: chrome

  - name: hy2
    type: hysteria2
    server: 1.1.1.1
    port: 80
    password: 00000000-0000-0000-0000-000000000000
    alpn:
      - h3
    sni: www.cloudflare.com
    skip-cert-verify: false
    fast-open: true

  - name: tuic5
    server: 1.1.1.1
    port: 80
    type: tuic
    uuid: 00000000-0000-0000-0000-000000000000
    password: 00000000-0000-0000-0000-000000000000
    alpn: [h3]
    disable-sni: true
    reduce-rtt: true
    udp-relay-mode: native
    congestion-controller: bbr
    sni: www.cloudflare.com
    skip-cert-verify: false

proxy-groups:
  - {
      name: "🚀 节点选择",
      type: select,
      proxies:
        [
          "♻️ 自动选择",
          "🚀 手动切换",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🚀 手动切换",
      type: select,
      proxies:
        [
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "♻️ 自动选择",
      type: url-test,
      proxies:
        [
          "reality",
          "hy2",
          "tuic5",
        ],
      url: "https://cp.cloudflare.com",
      interval: 86400,
    }
  # - {
  #     name: "🇧 哔哩哔哩",
  #     type: select,
  #     proxies:
  #       [
  #         "🚀 节点选择",
  #         DIRECT,
  #         "reality",
  #         "hy2",
  #         "tuic5",
  #       ],
  #   }
  # - {
  #     name: "🇧 哔哩东南亚",
  #     type: select,
  #     proxies:
  #       [
  #         "🚀 节点选择",
  #         DIRECT,
  #         "reality",
  #         "hy2",
  #         "tuic5",
  #       ],
  #   }
  - {
      name: "🌍 国外媒体",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🇳 Netflix",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🇹 Tiktok",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🇧 巴哈姆特",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          "♻️ 自动选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
    }
  - {
      name: "🆂 Spotify",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🇦 Abema",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🆂 Steam",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🇫 Facebook",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "📲 电报信息",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🇽 推特消息",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🖥 ChatGPT",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🅿️ Pixiv",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🇪 E-Hentai",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🖴 OneDrive",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "Ⓜ️ 微软服务",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🍎 苹果服务",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🇬 谷歌服务",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🇬 GitHub",
      type: select,
      proxies:
        [
          "🚀 节点选择",
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🇨 Cloudflare",
      type: select,
      proxies:
        [
          DIRECT,
          "🚀 节点选择",
          "♻️ 自动选择",
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  # - {
  #     name: "🇨 Cloudfront",
  #     type: select,
  #     proxies:
  #       [
  #         DIRECT,
  #         "🚀 节点选择",
  #         "♻️ 自动选择",
  #         "reality",
  #         "hy2",
  #         "tuic5",
  #       ],
  #   }
  - {
      name: "🎯 全球直连",
      type: select,
      proxies:
        [
          DIRECT,
          "🚀 节点选择",
          "♻️ 自动选择",
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🛑 全球拦截",
      type: select,
      proxies:
        [
          REJECT,
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🍃 应用净化",
      type: select,
      proxies:
        [
          REJECT,
          DIRECT,
          "reality",
          "hy2",
          "tuic5",
        ],
    }
  - {
      name: "🐟 漏网之鱼",
      type: select,
      proxies:
        [
          "🎯 全球直连",
          "🚀 节点选择",
          "♻️ 自动选择",
          "reality",
          "hy2",
          "tuic5",
        ],
    }

rules:
  # 若需禁用 QUIC 请取消注释 QUIC 两条规则
  # 防止 YouTube 等使用 QUIC 导致速度不佳, 禁用 443 端口 UDP 流量（不包括国内）

  # - AND,(AND,(DST-PORT,443),(NETWORK,UDP)),(NOT,((GEOSITE,cn))),REJECT # quic
  - RULE-SET,AWAvenue-Ads,🍃 应用净化
  # - GEOSITE,biliintl,🇧 哔哩东南亚
  # - GEOSITE,bilibili,🇧 哔哩哔哩

  # 可在下方加入自己特需的规则
  # - DOMAIN-SUFFIX,libvio.fun,🎯 全球直连
  # - DOMAIN-KEYWORD,admarvel,🛑 全球拦截
  # - DOMAIN-SUFFIX,kajicam.com,🌍 国外媒体
  # - DOMAIN,s3-ap-southeast-1.amazonaws.com,🌍 国外媒体
  # - IP-CIDR,69.53.224.0/19,🌍 国外媒体,no-resolve
  - DOMAIN-KEYWORD,libvio,🎯 全球直连
  - DOMAIN-SUFFIX,dcg.microsoft.com,🎯 全球直连
  - DOMAIN-SUFFIX,windowsphone.com,🎯 全球直连
  - DOMAIN-SUFFIX,windowsphone-int.com,🎯 全球直连
  - DOMAIN-SUFFIX,argotunnel.com,🇨 Cloudflare
  - DOMAIN-SUFFIX,cftunnel.com,🇨 Cloudflare
  - DOMAIN-SUFFIX,cloudflareaccess.com,🇨 Cloudflare
  - DOMAIN-SUFFIX,cloudflareresearch.com,🇨 Cloudflare
  - DOMAIN-SUFFIX,dmmiku.net,🌍 国外媒体
  - DOMAIN-SUFFIX,hfyrw.com,🌍 国外媒体
  - DOMAIN-SUFFIX,kajicam.com,🌍 国外媒体
  - DOMAIN-SUFFIX,apkcombo.com,🌍 国外媒体
  - DOMAIN-SUFFIX,winudf.com,🌍 国外媒体
  - DOMAIN-SUFFIX,fanmingming.com,🌍 国外媒体
  - DOMAIN-SUFFIX,xn--sss604efuw.com,🌍 国外媒体
  - DOMAIN-SUFFIX,mayiyingshi.net,🌍 国外媒体
  - DOMAIN-SUFFIX,reddit.com,🌍 国外媒体
  - DOMAIN-SUFFIX,greasyfork.org,🌍 国外媒体
  - DOMAIN-SUFFIX,nodeseek.com,🌍 国外媒体
  - DOMAIN-SUFFIX,vercel.com,🌍 国外媒体
  - DOMAIN-SUFFIX,vercel.app,🌍 国外媒体
  - DOMAIN-SUFFIX,missav.ws,🌍 国外媒体
  - DOMAIN-SUFFIX,missav.ai,🌍 国外媒体
  - DOMAIN-SUFFIX,xhamster.com,🌍 国外媒体
  - DOMAIN-SUFFIX,xhcdn.com,🌍 国外媒体
  - DOMAIN-SUFFIX,ahcdn.com,🌍 国外媒体
  - DOMAIN-SUFFIX,nodeloc.com,🌍 国外媒体
  - DOMAIN-SUFFIX,nodeseek.com,🌍 国外媒体
  - DOMAIN-SUFFIX,hostloc.com,🌍 国外媒体
  - DOMAIN-SUFFIX,linux.do,🌍 国外媒体
  - DOMAIN-SUFFIX,discord.gg,🌍 国外媒体
  - DOMAIN-SUFFIX,ipify.org,🌍 国外媒体
  - DOMAIN-SUFFIX,ip.sb,🌍 国外媒体
  - DOMAIN-SUFFIX,winget.run,🌍 国外媒体
  - DOMAIN-SUFFIX,hmoegirl.com,🌍 国外媒体
  - DOMAIN-SUFFIX,wikipedia.org,🌍 国外媒体
  - DOMAIN-SUFFIX,moegirl.uk,🌍 国外媒体
  - DOMAIN-SUFFIX,hmoegirl.com,🌍 国外媒体
  - DOMAIN-SUFFIX,hmoegirl.cyou,🌍 国外媒体
  - DOMAIN-SUFFIX,segfault.net,🌍 国外媒体
  - DOMAIN-SUFFIX,yahoo.com,🌍 国外媒体
  - DOMAIN-SUFFIX,whatsapp.com,🌍 国外媒体
  - DOMAIN-SUFFIX,wa.me,🌍 国外媒体
  - DOMAIN-SUFFIX,whatsapp.net,🌍 国外媒体
  - DOMAIN-SUFFIX,wl.co,🌍 国外媒体
  - DOMAIN-SUFFIX,whatsappbrand.com,🌍 国外媒体
  - DOMAIN-SUFFIX,whatsapp.cc,🌍 国外媒体
  - DOMAIN-SUFFIX,whatsapp.info,🌍 国外媒体
  - DOMAIN-SUFFIX,whatsapp.org,🌍 国外媒体
  - DOMAIN-SUFFIX,whatsapp-plus.info,🌍 国外媒体
  - DOMAIN-SUFFIX,whatsapp-plus.me,🌍 国外媒体
  - DOMAIN-SUFFIX,whatsapp-plus.net,🌍 国外媒体
  - DOMAIN-SUFFIX,whatsapp.tv,🌍 国外媒体
  - DOMAIN-SUFFIX,xingliu.art,🌍 国外媒体
  - DOMAIN-SUFFIX,jsdelivr.net,🌍 国外媒体
  - DOMAIN-SUFFIX,prodregistryv2.org,🌍 国外媒体
  - DOMAIN-SUFFIX,cursor.sh,🖥 ChatGPT
  - DOMAIN-SUFFIX,flowith.io,🖥 ChatGPT
  - DOMAIN-SUFFIX,flowith.com,🖥 ChatGPT
  - DOMAIN-SUFFIX,lovart.ai,🖥 ChatGPT
  - DOMAIN-SUFFIX,lmarena.ai,🖥 ChatGPT
  - DOMAIN-SUFFIX,easemate.ai,🖥 ChatGPT
  - DOMAIN-SUFFIX,cursor.com,🖥 ChatGPT
  - DOMAIN-SUFFIX,codeium.com,🖥 ChatGPT
  - DOMAIN-SUFFIX,windsurf.com,🖥 ChatGPT
  - DOMAIN-SUFFIX,warp.dev,🖥 ChatGPT

  - GEOSITE,category-ai-!cn,🖥 ChatGPT
  - GEOSITE,apple,🍎 苹果服务
  - GEOSITE,apple-cn,🍎 苹果服务
  - GEOSITE,ehentai,🇪 E-Hentai
  - GEOSITE,github,🇬 GitHub
  - GEOSITE,twitter,🇽 推特消息
  - GEOSITE,youtube,🇬 谷歌服务
  - GEOSITE,google,🇬 谷歌服务
  - GEOSITE,google-cn,🇬 谷歌服务
  - GEOSITE,telegram,📲 电报信息
  - GEOSITE,abema,🇦 Abema
  - GEOSITE,netflix,🇳 Netflix
  - GEOSITE,tiktok,🇹 Tiktok
  - GEOSITE,bahamut,🇧 巴哈姆特
  - GEOSITE,spotify,🆂 Spotify
  - GEOSITE,pixiv,🅿️ Pixiv
  - GEOSITE,steam@cn,DIRECT
  - GEOSITE,steam,🆂 Steam
  - GEOSITE,onedrive,🖴 OneDrive
  - GEOSITE,microsoft,Ⓜ️ 微软服务
  - GEOSITE,geolocation-!cn,🐟 漏网之鱼
  # - AND,(AND,(DST-PORT,443),(NETWORK,UDP)),(NOT,((GEOIP,CN))),REJECT # quic
  - GEOIP,google,🇬 谷歌服务
  - GEOIP,netflix,🇳 Netflix
  - GEOIP,facebook,🇫 Facebook
  - GEOIP,telegram,📲 电报信息
  - GEOIP,twitter,🇽 推特消息
  - GEOSITE,cloudflare,🇨 Cloudflare
  - GEOIP,cloudflare,🇨 Cloudflare
  # - GEOIP,cloudfront,🇨 Cloudfront
  - GEOSITE,CN,🎯 全球直连
  - GEOIP,CN,🎯 全球直连
  # 绕过局域网地址
  - IP-CIDR,10.0.0.0/8,DIRECT
  - IP-CIDR,172.16.0.0/12,DIRECT
  - IP-CIDR,192.168.0.0/16,DIRECT
  - IP-CIDR,100.64.0.0/10,DIRECT
  - IP-CIDR,127.0.0.0/8,DIRECT
  - MATCH,🐟 漏网之鱼

另外某些敏感时期，海外的 DoT/DoH 等服务可能会被阻断，需要在 Clash 的覆写设置中设置 DNS 的 fallback 组。可以在公共 DNS 大全地址汇总中寻找国内的 DNS 服务：公共DNS大全地址汇总|去广告DNS服务器|公共DNS服务器|DNS地址 - dns.iui.im

Clash 官方提供的 GEO 数据库：MetaCubeX/meta-rules-dat

Clash GEO 数据库引用的原 v2fly 提供的部分 GEOSITE 数据：v2fly/domain-list-community

如果要在代理网络下使用 Cloudflared 客户端，最好将 Cloudflare 策略组设置为直连，否则可能无法正常连接。如果需要代理 Cloudfalred 的网络，请参考：Cloudflare Tunnel速度慢？尝试给它加个前置代理提高速度

RAX3000Me 带 USB 款免拆刷机

2025-03-12T01:32:22.352Z

废话不多说，前段时间在拼多多看到的路由器，中国移动 RAX3000Me，网上看了一圈信息很少，但是恩山里看到了有人成功刷入 OpenWRT 的，刚好手上有一张满 100-50 的券，遂以￥54 的价格购入。

外观评价

基本和 RAX3000M 一致，但是底部增加了两个挂钩母座，且天线的旋转限位从 90 度增加到了 180 度，更方便挂墙使用。

配置方面和 RAX3000M 相差并不大，基本上只有闪存、内存芯片的型号不一样，但是大小和 RAX3000M NAND 版是保持一致的。同样的，MT7981、512 M 内存，128 M 闪存，1 WAN 3 LAN，1 个 USB 3.0。

刷入 uboot

开启 Telnet

相比于 RAX3000M，这款路由器的配置是加密的，而且其加密是根据每台机器的 SN 码进行的，所以不能像 RAX3000M 那样便利的开启 SSH 进行刷机。在恩山大佬的教程中，提供了解密和二次加密的方法，但是因为其必须在 Linux 环境下进行，有一定的门槛。为了更加方便的获取适用于自己的 SN 码的配置文件，我写了一个 Shell 脚本托管在 Replit 平台，可以通过注册这个平台并复制我的项目，以供生成自己的配置文件。

以下是链接，注册并登录 Replit 后，按照其 README 进行操作即可。

Rax3000Me-telnet-conf - Replit

刷写uboot

登录进入 Telnet 后，需要把 uboot 文件下载到路由器的内存里。

如果路由器有网，可以直接下载，在 telnet 中使用命令：

1	wget -P /tmp https://github.com/QiYueYiya/OpenWrt-Actions/releases/download/RAX3000Me_Files/mt7981_cmcc_rax3000m-fip-fixed-parts.bin

如果路由器没有联网，那么需要在内网开启一个 http 服务器提供文件下载服务：

可以参考 QiYueYiya 大佬的方法，使用 HTTP File Server 软件在 Windows 电脑上启动一个 HTTP 文件分享服务器，然后在 telnet 中使用命令：
1
wget -P /tmp http://192.168.10.2/mt7981_cmcc_rax3000m-fip-fixed-parts.bin
将 uboot 文件下载到路由器内存里。实操中我发现使用内网设备（甚至 Android 手机）运行一个 AList 客户端也可以起到相同的效果。

接着继续在 telnet 中使用命令刷入 uboot：

1	mtd write /tmp/mt7981_cmcc_rax3000m-fip-fixed-parts.bin FIP

刷入第三方固件

首先将路由器断电，并用牙签等物品插入路由器的 Reset 按键的小孔，按住 Reset 键，再给路由器通电，等到指示灯变绿，则路由器已经进入了 uboot。

接着将路由器的 LAN 口与电脑的网线接口相连，并将电脑的以太网的 IP 分配方法改为手动，IPv4 地址改为 192.168.1.2，子关掩码为 255.255.255.0，网关为 192.168.1.1。

接着电脑打开浏览器，在地址栏输入 http://192.168.1.1 即可进入 uboot 的操作界面，刷写 factory 固件并等待路由器重启即可。刷机完毕后，将电脑的 IP 分配方法改回 DHCP 自动获取。

如果刷的是 QiYueYiya 大佬的固件，则刷机后的后台地址为 http://192.168.5.1。

在 OpenWRT 中升级固件时，使用 sysupgrade 固件。

JetBrains 系 IDE 激活工具 Ja-netfilter 的使用方法

2024-12-26T02:27:06.997Z

近来打算从 VS Code 换到 JetBrains 家的 IDE 试试看，结果看到网上不少对 ja-netfilter 二次打包压缩包进行微信公众号引流的垃圾帖子，以及很多不明真相不知道如何激活 Clion、PyCharm、‌‌WebStorm 等 IDE 的求助。于是，记录一下使用 ja-netfilter 激活各种 JetBrains 软件的方法。

首先，需要挂一个代理，然后访问 https://jetbra.in/s ，选择进入其列表中任意一个可用的页面，在顶端下载 jetbra.zip ，下载完成后，解压到任意位置，作永久保存。

接着，去 JetBrains 官网下载安装最新版本的 IDE 软件。安装完成后，在刚刚解压的文件中找到 scripts 文件夹，一般来讲对于普通的 Windows 用户来说，运行 install-current-user.vbs 这个脚本即可。等待 30 秒左右，脚本提示 Done 即代表运行成功。

最后打开刚刚安装的 IDE 软件，选择使用激活码激活，在刚刚下载 jetbra.zip 压缩包的网页上，鼠标左键单击自己安装的 IDE 的图标，即可复制一个可用的激活码，粘贴到 IDE 内进行激活即可。一般激活码激活后显示有效期为 1-2 年，但是实际上是永久激活。

Azure spot 虚拟机自启

2024-11-07T01:47:23.122Z

最近跟风用上了 Azure for Students 的 100 美元赠金，大致看了一下 Azure 提供的服务，其中虚拟机和 AI 服务比较有吸引力。我粗略查看下，Azure 的 AI 服务似乎只能使用 OpenAI 的模型，但是已经把 Chat2API 反复使用，甚至自行修改使用后，基本上相当于已经手持用不完的 GPT-4o 模型了，且多模态用惯了之后，对新出的 o1-mini 等针对特定领域特化的纯文本模型又不是特别感兴趣，于是我就直接放弃了使用 Azure 的 AI 服务。

于是我的目光盯上了虚拟机。在群友的提醒下，得知勾选 “Spot” 规格，可以获得接近 90% 的折扣，于是，在并未搞明白有什么区别的时候，就直接开了一台 “Spot” 规格的机器。心想大厂服务器肯定靠谱，顺手就部署了一个 Chat2API 以及 ChatGPT 镜像站，以供群友使用。

不出意外的话，意外就出现了。没过两天，OAIFREE 的服务突然宕机，我想着我还有自己的镜像站能用，于是打开网页查看，发现服务掉线了。然后我登上 Azure 一看，被关机了。我才知道这个 “Spot” 规格到底是什么意思。简而言之，你可以选择两种前置条件：

当数据中心的资源不充裕时；
当数据中心的资源不充裕或者账户余额不足时。

当满足前置条件时的处理也有两种选择：

关机；
删除机器。

还好，我当时稀里糊涂之下选择的是当资源不充裕时关机，所以手动开机之后又一切正常了。但是这样动不动就需要手动登录面板开机的话，实在是太难用了，于是我开始寻找关机后自动开机的方法。于是我找到了：教你稳定1折使用Azure的服务器，让Azure不在那么贵不可及

按照这篇帖子的操作，我自己折腾了半天，拉不起来。后来才发现是自己没正确理解原贴中文字描述而不带图片的几个步骤，所以没能成功拉起。后来我又找到了一篇英文的说明，也是参考上述 Hostloc 的帖子，而博主又自行添加了一些说明以及截图，结合两篇说明外加自行摸索了好一会儿，我才完全弄明白。附上那篇英文博文的地址：Auto Start Stopped Spot Instance to Get Your VM Running Again。

设置 Spot 规格虚拟机自动启动

跳过创建虚拟机的部分，直接来说 Spot 规格的虚拟机如何自启的方法。首先，原理是利用 Azure 自带的监控功能，监控虚拟机状态，并发出警报。已知警报可以触发自动化流程，故编写一个自动化流程以开启虚拟机，即可完成自动启动。

因为 Azure 面板即便设置中文，也会中英文掺杂，而且很多机翻，会误导用户，故以下展示在讲面板语言设置为英文的状态下进行。

创建自动化账户

首先新建一个 Automation Accounts，直接在 Azure 面板的搜索栏里搜索 Automation 即可找到：

切记创建 Automation Accounts 时，订阅要和你的虚拟机所在的订阅相同（绑卡用户使用 Pay as you go，edu 订阅使用 Azure for Students）资源组最好也选择和虚拟机相同的资源组。随便键入一个名字即可。其他选项全部默认，一路 Next 直到创建。

添加启动脚本为 Runbooks

接下来在这个自动化账户内，侧边栏里找到 Processing Automation，点击其中的 Runbooks，再点击 Create a runbook。

类型选择 PowerShell，Runtime Version 选择 5.1，随便取个名字，然后直接创建。

在编辑内粘贴以下脚本，不要做其他修改，直接点击 Public 发布。

param (

    [Parameter(Mandatory=$true)]  
    [String] $Action,

    [Parameter(Mandatory=$true)]  
    [String] $TagName,

    [Parameter(Mandatory=$true)]
    [String] $TagValue
) 

Write-Output ""
Write-Output "------------------------ Authentication ------------------------"
Write-Output "Logging into Azure ..."

try {
    "Logging in to Azure..."
    Connect-AzAccount -Identity
}
catch {
    Write-Error -Message $_.Exception
}
$SubscriptionId = ""
Select-AzContext -name ((Get-AzContext -ListAvailable).Name -match $SubscriptionId)[0]
try {
    if ($Action -eq "Start" -or $Action -eq "Stop") {
        Write-Output "Action Selected"
    }
    else { 
        Write-Output "Wrong Action Selection. It should be Start or Stop"
        Exit 
    }
} catch {
    Write-Error -Message $_.Exception
}

try {
Write-Output ""
Write-Output ""
Write-Output "---------------------------- Status ----------------------------"
Write-Output "Getting all virtual machines with Tags ..."

    $myvms = Get-AzVM | Where-Object { $_.Tags[$TagName] -eq $TagValue }

    Write-Output "Total of VMs: $($myvms.Length)"

    foreach ($vm in $myvms) {
        Write-Output $vm.Name
        $status = Get-AzVM -Name $vm.Name -Status
        Write-Output "VM $($vm.Name) status: $($status.PowerState)"

        if ($Action -eq "Start") {
            if ($status.PowerState -eq "VM deallocated") {
                Write-Output "Starting VM: $($vm.Name)"
                try {
                    Start-AzVM -Name $vm.Name -ResourceGroupName $vm.ResourceGroupName -NoWait
                } catch {
                    Write-Error -Message $_.Exception
                }
            
            } else {
                Write-Output "VM: $($vm.Name) is already started"
            }  
        } 

        if ($Action -eq "Stop") {
            if ($status.PowerState -eq "VM running") {
                Write-Output "Stopping VM: $($vm.Name)"
                try {                    
                    Stop-AzVM -Name $vm.Name -ResourceGroupName $vm.ResourceGroupName -Force -NoWait
                } catch {
                    Write-Error -Message $_.Exception
                }
            
            } else {
                Write-Output "VM: $($vm.Name) is already stopped"
            }  
        }

    }
}
catch {
    Write-Error -Message $_.Exception
}

回到自动化账户的 Runbooks 下，看到刚刚新建的 Runbooks 已经显示为 Published 则成功添加了自启脚本。

为自动化账户添加权限

在搜索栏内搜索 Subscription，并进入订阅页：

选择你的订阅（绑卡用户使用 Pay as you go，edu 订阅使用 Azure for Students）并进入：

然后在侧边栏 Access control (IAM) 中，点击 Add role assignment：

Role 选项的设置中，选择 Privileged administrator roles 中的 Owner 角色：

Member 选项中，Assign access to 选择 Managed identity，依次选择 Automation Accounts，以及刚刚创建的自动化账户：

Conditions 选项中，What user can do 选择第三项，然后直接 Review + assign：

添加完订阅的权限后，再到搜索栏搜索 vm，并进入虚拟机管理的页面：

然后找到需要设置自动启动的 Spot 虚拟机，为重复上述操作，再次添加权限：

顺带给这台虚拟机添加一个标签，可以随意填写，我这里填写的是 1000:100：

为虚拟机添加监控警报

找到侧边栏中的 Monitoring，进入其中的 Alerts，点击 Alerts rules（我这里已经添加过规则了所以显示不太一样，入口是一样的）：

新建一个警报规则：

在 Condition 选项中选择信号时不要点下拉栏，直接点击 see all signals，并在弹窗中搜索 availability，选择 VM Availability Metric (Preview)：

在 Actions 选项中新建一个 action group：

新建 action group 时，订阅和资源组最好与需要自启的虚拟机以及自动化账户相同，随便取个名字就好：

Notifications 可设置也可不设置，只是一个提醒，能发邮件或者发短信什么的，发短信需要额外收费，有需要的可以自行设置。

Actions 中 Action type 选择 Automation Runbook，弹出的窗口中 Runbook source 选择 User，Automation account 选择刚刚创建的自动化账户，Runbook 选择刚刚新建并发布的 Runbook，再点击 Parameters 填入变量：

第一个填 Start，切记首字母大写，第二三个按照刚刚给虚拟机添加的标签进行填写，比如刚刚我添加的标签为 1000:100，那么我第二个填 1000，第三个填 100。

然后点击 OK 保存，再点击侧边弹窗的 OK 保存，然后直接点击 Review + create 创建 action group。

创建完 action group 后回到创建 alerts rule 的页面，当然 Actions 选择刚刚创建的 action group，而 Condition 中，Aggregation type 选择 Minimum，Operator 选择 Less than，Unit 选择 Count，Threshold 选择 1：

然后 Review + create 创建警报规则即可。

测试自动启动

完成了以上步骤，自动启动就已经设置好了，你可以在 Overview 中手动停止虚拟机进行测试，大概 5-6 分钟即可完成自动启动。

Serv00 进程保活最终解决方案

2024-08-15T04:01:16.557Z

这个方案已经写出来差不多一个月了，Github 上也开了源，论坛里、群里也都介绍了使用方法，但是，目前除了我重构之后的 X-for-serv00 以及 Sb-for-serv00 以外，还没有哪个项目已经用上了的。遂在博客里对于这个方案进行进一步的介绍。

首先几个大前提，似乎还有很多人搞不清：

Serv00 不是 VPS，是一台独立服务器，新建了很多用户，按照用户进行隔离，并没有虚拟化一个完整的 FreeBSD Server 给用户，所以没有 Root 权限，但是内置了很多独立服务器自带的软件包、服务等等，可以说是有利有弊；
Serv00 不是 Linux 系统，是 FreeBSD 系统，虽说 Unix like 使用起来总是相似的，但是总归还是不一样的；
Serv00 自带了一个 Web 服务器——Apache。Apache 与 Nginx 功能相似但是使用方法是不一样的，而且在没有 Root 权限的情况下，很多东西你无法进行设置；
每个用户能够最多预留三个端口的使用权，而且端口范围在 1024-64000；
因为是独立服务器按照用户进行隔离，所以你不能对其进行重启、重装等操作，机器的重启与重装会影响这台 Server 上的一万名用户
And so on…

Serv00 的 Apache 服务器附带了一个插件——Phusion Passenger，利用其特性，我们能够在 Serv00 上实现访问网页即对进行实现保活。已知 WWW websites 在被访问时会按照其类型被唤醒，而且通过 Phusion Passenger 托管的 Django / NodeJS / Ruby on Rails 等类型的应用是可以端口复用，在 80 /443 端口提供 Web 服务的，所以只需要在这样一个脚本或者应用内写入进程的检测与唤醒即可通过网页对进程保活。

但是这样做还有一个问题，一个网站需要两个域名，一个用来保活，一个用来提供 Web 服务，很是不方便，但是，在 JavaScript 中，可以通过引入 chimurai/http-proxy-middleware 这个中间件将其合二为一，实现真正的访问即保活，访问即唤醒。

示例

app.js的内容如下：

const express = require("express");
const app = express();
const port = 3000;
var exec = require("child_process").exec;
const { createProxyMiddleware } = require("http-proxy-middleware");
const path = require('path');
const fs = require('fs');

const currentDir = __dirname;
process.chdir(currentDir);

app.use('/', createProxyMiddleware({
  target: 'http://127.0.0.1:PORT', //改成 Web 应用实际运行端口
  changeOrigin: true,  //如果应用有基于 websocket 的连接，请把此处改为 false
  ws: true, 
  onError: (err, req, res) => {
    res.writeHead(500, {
      'Content-Type': 'text/plain',
    });
    res.end('Please wait for a while and try to refresh the page.');
  },
}));

function keep_web_alive() {
    exec("pgrep -laf PROCESS", function (err, stdout, stderr) { //改成进程名，如：alist
      if (stdout.includes("PROCESS_COMMAND")) {  //改成进程实际运行命令，如：alist server
        console.log("web 正在运行");
      } else {
        exec(
          "START_COMMAND", // 改成启动脚本或者启动命令，如：chmod +x start.sh && ./start.sh 或者 ./alist server
          function (err, stdout, stderr) {
            if (err) {
              console.log("保活-调起web-命令行执行错误:" + err);
            } else {
              console.log("保活-调起web-命令行执行成功!");
            }
          }
        );
      }
    });
  }
  setInterval(keep_web_alive, 10 * 1000);

app.listen(port, () => console.log(`Example app listening on port ${port}!`));

package.json的内容如下：

{
    "name": "example",
    "version": "1.0.0",
    "description": "A simple Express.js server",
    "author": "k0baya",
    "main": "app.js",
    "license": "MIT",
    "private": false,
    "scripts": {
      "start": "node app.js"
    },
    "dependencies": {
      "express": "^4.19.2",
      "http-proxy-middleware": "^3.0.0"
    },
    "engines": {
      "node": "22"
    },
    "keywords": [
      "node"
    ]
  }

目录结构为：

/home/LOGIN/domains/DOMAIN/public_nodejs/
    ├──app.js
    ├──package.json
    └──其它应用所需文件（比如二进制文件、配置文件、启动脚本等）

先执行 npm22 install，再访问网页即可唤醒应用。监控网页即可对应用进行保活。

此外，自动续期直接去 Serv00 自带的 Cron job 内添加每个月一次的 sshpass 命令即可，滥用 GitHub Actions 是很差劲且没有必要的行为。

两种使用 Serv00 部署代理服务器的方法

2024-07-06T08:29:39.989Z

项目已经重构，部署流程已经尽可能简单化，该篇博客不再适用，请按照 readme 进行部署。

好久没写博客，用最近自己写的两个仓库水一篇博客。

由于此前博客记录的在 Serv00 平台上部署 Vless 的两种方法都存在较为严重的安全隐患，且速度也并不理想，所以为了兼顾安全性和连接速率，我自己做了两个仓库，两个仓库分别是 X-for-Serv00 和 SB-for-Serv00。两个仓库分别采用 Cloudflare CDN 加速、基于 UDP 暴力发包的连接协议提供更为理想的连接速率，且都加入了 TLS 加密 / SNI 伪装，提升其安全性。

由于这两个仓库都需要占用 2 个端口，且在连接速率较高时，占用内存会比较大，故这两个仓库都建议单独一个账号部署，而不要在账号内安装/部署其他应用，以尽可能把内存留给核心使用。所以，我也尽可能把此前在 Serv00 部署应用时一直在使用的 PM2 给尽可能省略了，采用了 nohup >/dev/null 2>&1 & 挂后台，然后自己写了一个循环运行的 JavaScript 函数对进程进行监控并在进程掉线后拉起。

先介绍部署方法，首先当然是注册 Serv00 账号，然后是登录 Panel，并将 Run your own applications 设置为 enabled，再开放两个端口。不同的是，X-for-serv00 需要开放的端口类型为 TCP，而 SB-for-Serv00 需要开放的端口类型为 UDP。

接着直接 ssh 登录你的 Serv00 账号，开始进行代理服务器本身的部署。

X-for-Serv00

首先将远程仓库 Clone 到本地：

1	git clone https://github.com/k0baya/X-for-serv00 ~/xray && cd ~/xray

然后回到面板中，进入 File manager，找到 ~/xray/start.sh 这个文件，右键点击 start.sh 文件，选择 View/Edit > Source Editor ，进行编辑，在 1 - 18 行修改环境变量：

变量名	是否必须	默认值	备注
WEBPORT	是		网页端口，查看代理配置、获取订阅链接等等功能需要
VMPORT	是		Vmess 协议监听端口
UUID	是	de04add9-5c68-8bab-950c-08cd5320df18
WSPATH	是	serv00	勿以 / 开头，协议路径为 /WSPATH-协议，如 /serv00-vmess
ARGO_AUTH	否		Argo 的 Token 值，ey 开头的一串，获取方法可以参考群晖套件：Cloudflare Tunnel 内网穿透中文教程支持DSM6、7 （如果需要填写，请删除单引号再填写，不填则保持原样。）
ARGO_DOMAIN	否		Argo 的域名，须与 ARGO_DOMAIN 必需一起填了才能生效
WEB_USERNAME	否	admin	网页的用户名
WEB_PASSWORD	否	password	网页的密码

固定 Argo 隧道

如果你填入了ARGO_AUTH 和 ARGO_DOMAIN 环境变量，想用于固定 Argo 隧道，那么就需要执行此步。否则可以跳过。

在 Cloudflare Argo Tunnel 的面板中，给这条隧道添加一个域名，域名为刚刚填写的 ARGO_DOMAIN ，协议为 HTTP ，地址为localhost:加上刚刚填写的 VMPORT （如 localhost:54321 ）。

启动并获取配置

直接执行启动脚本即可：

1	chmod +x start.sh && bash start.sh

最后等待一分钟左右，等程序完全启动，再直接使用 IP 访问 WEBPORT ，并进入/list路径（如http://1.2.3.4:54321/list）获取代理配置。（IP 可在 Panel 的 SSL 选项卡中，点击 WWW websites 后看到，一般有两个 IP ，任选其一即可。）

自动启动

在 Panel 中找到 Cron jobs 选项卡，使用 Add cron job 功能添加任务，Specify time 选择 After reboot，即为重启后运行。Form type 选择 Advanced，Command 写 start.sh 文件的绝对路径，比如：

1	/home/username/xray/start.sh >/dev/null 2>&1

务必按照你的实际路径进行填写。

SB-for-Serv00

更新后需要额外放行一个 TCP 端口供 Trojan 协议使用。

在 Panel 中点击左侧菜单栏中的 SSL ，然后点击上方菜单栏中的 WWW websites ，点击第一个 IP Address 最右侧的 Manage 按钮，再点击上方菜单栏中的 Add certificate 按钮，Type 选择 Generate Let’s Encrypt certificate， Domain任选一个即可，最后点击下方的 Add 按钮进行生成。请至少保证自己的 Serv00 账号下有一个 Let’s Encrypt 的证书。

为确保安全，当账号下没有 Let’s Encrypt 证书时，会拒绝生成配置，直接停止运行。

接着将远程仓库 Clone 到本地：

1	git clone https://github.com/k0baya/sb-for-serv00 ~/sing-box && cd sing-box

然后回到面板中，进入 File manager，找到 ~/sing-box/start.sh 这个文件，右键点击 start.sh 文件，选择 View/Edit > Source Editor ，进行编辑，在 1 - 7 行修改环境变量：

变量名	是否必须	默认值	备注
HY2PORT	是		Hysteria2 协议监听端口
TUIC5PORT	是		Tuic5 协议监听端口
SERV00PASSWORD	是		你的 Serv00 账号的密码，用于获取 SSL 证书
UUID	否	de04add9-5c68-8bab-950c-08cd5320df18

启动并获取配置

直接执行启动脚本即可：

1	chmod +x start.sh && bash start.sh

等待程序完成启动，会在 Terminal 中直接打印出 Hysteria2 和 Tuic5 的配置链接。

自动启动

1	/home/username/sing-box/start.sh >/dev/null 2>&1

务必按照你的实际路径进行填写。

仓库特点

由于 X-for-Serv00 的代理服务器核心是 Xray ，SB-for-Serv00 的代理服务器核心是 Sing-box，故下文将 X-for-Serv00 简称为 X，将 SB-For-Serv00 简称为 SB。

X 的特点是，这种模式可以在任意无公网 IP 的环境下使用。可以通过任意 Cloudflare edge （Cloudflare CDN）接入，再通过 SNI 指示器回源到 Xray，出站规则判断特定网站以及 IPv6 走 Wireguard 连接 Warp，其他直接出站。所以就算在你的地区 Serv00 被“墙”了，你依旧可以使用这种方法连上 Serv00 的代理，Serv00 本身的带宽大概是千兆，上下行同宽，所以在此范围内，你的代理连接速率基本上只取决于你的本地网络和 Cloudflare edge （Cloudflare CDN）之间的连接速率。

我使用移动宽带自测 X-for-Serv00 的连接带宽大概在 200Mbps，有群友测速达到 400Mbps 以上。至少我认为这是在 Serv00 上部署使用 CDN 加速的代理服务器的最佳方案吧。

S 的特点是，使用了 Hysteria2 和 Tuic5 这两种协议，所以主要的优势和特点无非也就是这两种协议的特点，比如 UDP暴力发包，Hy2 抢占带宽等等。仓库的主要作用是提供了 FreeBSD 的 Sing-box 构建，并简化了证书获取、配置文件编写等等繁琐步骤，实现“一键式”部署。可惜我在测试中发现使用 Wireguard 出站时，Sing-box 很容易出现闪退情况，翻看 Sing-box 的 issues，发现这个问题已经存在了几个月，并非个例，故 S 暂未启用 IPv6 的支持。

虽然 Hysteria2 备受好评，但是我使用移动宽带的测速情况实在是不太理想，有群友使用商用宽带测速效果不错。但是至少我认为这是在 Serv00 上部署直连的代理服务器的最佳方案吧。

另外，针对 UDP 被阻断的现象，除了 Sb-for-Serv00 添加了 Trojan 协议外，我做了 X-for-Serv00 的直连版本，采用 Vless-reality-vision、Vmess-ws-tls、Trojan-tls 三个协议，部署简单。仓库地址：X-for-Serv00 direct branch
部署方法也是非常的简单：与 Sb-for-Serv00 一样，需要账号内有一个 Let’s Encrypt 的证书，然后将远程仓库 Clone 到本地：
1
git clone -b direct https://github.com/k0baya/x-for-serv00 ~/direct-xray
然后回到面板中，进入 File manager，找到 ~/direct-xray/start.sh 这个文件，右键点击 start.sh 文件，选择 View/Edit > Source Editor ，进行编辑，在 1 - 5 行修改环境变量：
变量名是否必须默认值备注
SERV00PASSWORD 是你的 Serv00 账号的密码，用于获取 SSL 证书
UUID 否 de04add9-5c68-8bab-950c-08cd5320df18 可在Online UUID Generator 生成
WSPATH 否 serv00 勿以 / 开头，协议路径为 /WSPATH-协议，如 /serv00-vmess
SSH 登录 Serv00 ，直接执行启动脚本即可启动。
1
chmod +x ~/direct-xray/start.sh && bash ~/direct-xray/start.sh
等待程序完成启动，会在 Terminal 中直接打印出 Vless-reality-vision、Vmess-ws-tls、Trojan-tls 的配置链接。

变量名	是否必须	默认值	备注
SERV00PASSWORD	是		你的 Serv00 账号的密码，用于获取 SSL 证书
UUID	否	de04add9-5c68-8bab-950c-08cd5320df18	可在Online UUID Generator 生成
WSPATH	否	serv00	勿以 / 开头，协议路径为 /WSPATH-协议，如 /serv00-vmess

shell 脚本的一种混淆方式

2024-04-22T16:48:57.249Z

灵感来源于：rwkgyg/sing-box-yg

目前各种 PaaS、SaaS、BaaS 等等平台，在用来托管一些常用的应用——如 Xray、Alist 等等应用时，经常会提示违规，不允许部署。在经过大量的测试后，我发现此类平台多以关键字检测作为封禁的因素，所以只要做到日志、文件名、文本文件内容不含此类关键字，就能继续部署，正常使用。

多数情况下，部署此类应用都是通过一个功能完善的 Shell 程序自动化进行，在其中把文件名和日志做好处理即可，但是最后 shell 脚本本身的内容又不可避免的会出现 Xray、Alist 等应用的下载链接，导致 Shell 脚本本身被平台查处封禁。当然通过多个变量拆分构造下载链接避开关键字也是一种处理方法，但是无疑这增加了脚本的编写复杂度，所以在通过查看 rwkgyg/sing-box-yg 时我获取了灵感，编写了一个 Python 脚本专门用于混淆 Shell 脚本：

import os
import uuid
import base64

# 读取你的脚本
with open('script.sh', 'r') as f:
    script = f.read()

# 使用 base64 对你的脚本进行编码
encoded_script = base64.b64encode(script.encode()).decode()

# 定义每个字符串段的大小
chunk_size = 4

# 将编码后的脚本分割成多个小段
chunks = [encoded_script[i:i+chunk_size]
          for i in range(0, len(encoded_script), chunk_size)]

# 创建一个新的文件来存储最终的脚本
with open('final_script.sh', 'w') as f:
    # 输出每个变量赋值语句
    variable_names = []
    for chunk in chunks:
        while True:
            var_name = str(uuid.uuid4()).replace('-', '')  # 生成一个 UUID 作为变量名
            if not var_name.startswith('0') and not var_name.startswith('1') and not var_name.startswith('2') and not var_name.startswith('3') and not var_name.startswith('4') and not var_name.startswith('5') and not var_name.startswith('6') and not var_name.startswith('7') and not var_name.startswith('8') and not var_name.startswith('9'):
                break
        variable_names.append(var_name)
        f.write(f'{var_name}=\'{chunk}\'\n')

    # 输出连接所有变量的语句
    f.write('eval "$(echo -n "')
    for var_name in variable_names:
        f.write(f'${var_name}')
    f.write('" | base64 --decode)"')

# 修改文件权限，使其可执行
os.chmod('final_script.sh', 0o755)

这个 Python 脚本的原理很简单，就是先把原 Shell 脚本使用 Base64 编码，然后分割成很多个字符串，再使用 UUID 作为变量名，把每个字符串都存储在一个变量中，最后把 UUID 变量全都连起来，使用 eval 命令执行。

简单粗暴，效果很好，用了的都说好。

第二个版本：

import base64
import uuid
import re

def generate_var_names():
    chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
    for first in chars:
        for second in chars:
            yield f"{first}{second}"
    while True:
        var_name = str(uuid.uuid4()).replace('-', '')
        if re.match(r'^[a-zA-Z]', var_name):
            yield var_name

with open('your_script.sh', 'r') as file:
    script_content = file.read()

first_encoded = base64.b64encode(script_content.encode('utf-8')).decode('utf-8')
first_eval_command = f'eval "$(echo -n "{first_encoded}" | base64 --decode)"'

second_encoded = base64.b64encode(first_eval_command.encode('utf-8')).decode('utf-8')

var_names = generate_var_names()
var_assignments = []
eval_parts = []
for i in range(0, len(second_encoded), 4):
    chunk = second_encoded[i:i+4]
    var_name = next(var_names)
    var_assignments.append(f'{var_name}="{chunk}"')
    eval_parts.append(f'${var_name}')

final_eval_command = f'eval "$(echo -n "{"".join(eval_parts)}" | base64 --decode)"'

var_assignment_line = ';'.join(var_assignments)

with open('obfuscated_script.sh', 'w') as file:
    file.write(var_assignment_line + '\n')
    file.write(final_eval_command + '\n')

print("原脚本已混淆为 obfuscated_script.sh")

配套解码：

import os
import re

def decode_script(script_content):
    decoded_script = script_content

    while True:
        eval_match = re.search(r'eval\s*"\$\(\s*echo\s+-n\s+"([^"]+)"\s*\|\s*base64\s+--decode\s*\)"', decoded_script)
        
        if not eval_match:
            break
        
        base64_string = eval_match.group(1)
        
        modified_script = decoded_script.replace('eval', 'echo', 1)

        result = os.popen(f'bash -c \'{modified_script}\'').read()

        print("Decoded part:", result)

        decoded_script = re.sub(r'eval\s*"\$\(\s*echo\s+-n\s+"([^"]+)"\s*\|\s*base64\s+--decode\s*\)"', result, decoded_script, count=1)
    
    return result.strip()

with open('obfuscated_script.sh', 'r') as file:
    obfuscated_script_content = file.read()

deobfuscated_script_content = decode_script(obfuscated_script_content)

with open('deobfuscated_script.sh', 'w') as file:
    file.write(deobfuscated_script_content)

print("混淆脚本已逆向生成 deobfuscated_script.sh")

在Glitch上部署Microsoft365_E5_Renew_X

2024-04-05T04:16:53.770Z

直接上传了一个仓库：k0baya/e5_renew_x-on-glitch

按照 README 的介绍操作即可，一键部署。

相关链接：
使用文档：E5 调用API续订服务：Microsoft 365 E5 Renew X
官方网站：MS365 E5 Renew Plus

同理，休眠需要保活，建议自建 Uptime-Kuma。

Glitch 部署应用的思路：

使用 http-proxy-middleware 将其他端口上运行的应用反向代理到 Glitch 默认监听的 3000 端口。

示例：

server.js ：

const express = require("express");
const app = express();
const port = 3000;
const PROJECT_DOMAIN = process.env.PROJECT_DOMAIN;
var exec = require("child_process").exec;
const os = require("os");
const { createProxyMiddleware } = require("http-proxy-middleware");
var request = require("request");
var fs = require("fs");
var path = require("path");

//获取系统进程表
app.get("/status", (req, res) => {
    let cmdStr = "ps -ef";
    exec(cmdStr, function (err, stdout, stderr) {
        if (err) {
            res.type("html").send("命令行执行错误：\n" + err + "
");
        } else {
            res.type("html").send("命令行执行结果：\n" + stdout + "
");
        }
    });
});

// 获取系统监听端口
app.get("/listen", function (req, res) {
    let cmdStr = "ss -nltp";
    exec(cmdStr, function (err, stdout, stderr) {
      if (err) {
        res.type("html").send("命令行执行错误：\n" + err + "
");
      } else {
        res.type("html").send("获取系统监听端口：\n" + stdout + "
");
      }
    });
  });

//获取系统版本、内存信息
app.get("/info", (req, res) => {
    let cmdStr = "cat /etc/*release | grep -E ^NAME";
    exec(cmdStr, function (err, stdout, stderr) {
        if (err) {
            res.send("命令行执行错误：" + err);
        } else {
            res.send(
                "命令行执行结果：\n" +
                "Linux System:" +
                stdout +
                "\nRAM:" +
                os.totalmem() / 1000 / 1000 +
                "MB"
            );
        }
    });
});

//文件系统只读测试
app.get("/test", (req, res) => {
    fs.writeFile("./test.txt", "这里是新创建的文件内容!", function (err) {
        if (err) res.send("创建文件失败，文件系统权限为只读：" + err);
        else res.send("创建文件成功，文件系统权限为非只读：");
    });
});

app.use(
    "/" + "*",
    createProxyMiddleware({
        target: "http://127.0.0.1:端口号/", // 需要跨域处理的请求地址
        changeOrigin: false, // 默认false，是否需要改变原始主机头为目标URL
        ws: true,
        logLevel: "error",
        onProxyReq: function onProxyReq(proxyReq, req, res) { }
    })
);

exec("启动指令", function (err, stdout, stderr) {
    if (err) {
      console.error(err);
      return;
    }
    console.log(stdout);
  });

app.listen(port, () => console.log(`Example app listening on port ${port}!`));

package.json ：

{
    "name": "glitch-mvp-node",
    "version": "0.1.1",
    "description": "A simple Node app built on fastify, instantly up and running.",
    "main": "server.js",
    "scripts": {
      "start": "node server.js"
    },
    "dependencies": {
      "express": "^4.18.2",
      "http-proxy-middleware": "^2.0.6",
      "request": "^2.88.2"
    },
    "engines": {
      "node": "16.x"
    },
    "repository": {
      "url": "https://glitch.com/edit/#!/glitch-mvp-node"
    },
    "license": "MIT",
    "keywords": [
      "node",
      "glitch"
    ]
  }

使用免费美国IP部署FreeGPT35

2024-04-02T21:48:51.444Z

今天群友又发了个好玩的仓库：missuo/FreeGPT35 ，我一看，原来是 OpenAI 的 ChatGPT-3.5 免登录使用已经开放使用了，不再是灰度测试了。然后这个仓库的功能就是对目前的 ChatGPT 网页免登录版本进行逆向，并提供 OpenAI 标准格式的 API 转换。

随即就喊群友进行测试，发现似乎美国以外的 IP 都不行，而原本在美国的 IP ，即便前段时间出 CF 五秒盾的 IP 也已经不会再出盾了，可以直接使用。我一看，美国 IP ，运行 Nodejs ，这不是妥妥的第一时间想到大善人Glitch 么。

我稍微改动了一点点，在 Glitch 上测试运行，果然成功了，现将部署步骤记录如下：

进入 Glitch 的主页，点击右上角的 New Project > Import from GitHub ，填入 https://github.com/missuo/FreeGPT35 。

导入完成后删掉除了 app.js、package.json 、 package-lock.json 的所有文件夹/文件，然后点击最下方的 TERMINAL 打开终端，输入命令修改端口为 3000：

1	sed -i 's/3040/3000/g' app.js

然后编辑 package.json ，用以下内容覆盖其内容：

{
  "name": "glitch-mvp-node",
  "version": "0.1.1",
  "description": "A simple Node app built on fastify, instantly up and running.",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "axios": "^1.6.8",
    "express": "^4.19.2"
  },
  "engines": {
    "node": "16.x"
  },
  "repository": {
    "url": "https://glitch.com/edit/#!/glitch-mvp-node"
  },
  "license": "MIT",
  "keywords": [
    "node",
    "glitch"
  ]
}

到这里就部署完成了，如果此时 Glitch 卡住没能正确加载，你可以点击右上角的 Remix 按钮强行重新加载。

Glitch 的每月免费使用时间高达 1000 小时，足够单个项目运行覆盖整月，但是其休眠也很难缠——Glitch 屏蔽了 Uptime-Robot 等各种监控平台的 IP 访问，并且还屏蔽了自身的 IP 访问自身。这里建议使用自行搭建的网站监控：Uptime-Kuma。

当然群内我提供了公用的，部署在 Serv00 上的 Uptime-Kuma 供群友使用，欢迎自取。

目前此仓库并未提供自定义 API Key 的功能，会接受一切 API Key 的请求，有可能被批量扫描滥用。

杂谈（其一）

2024-03-24T23:55:44.090Z

最近在几个仓库的使用上遇到了一点点小的问题，在解决问题的过程中，顿感 GitHub 的搜索功能之好用与强大，现来记一笔流水账。

本来放着不需要管的 New-API-FreeBSD 仓库突然 workflow 运行失败了，我一检查，有如下错误：

/home/runner/work/new-api-freebsd/new-api-freebsd/new-api/web/node_modules/rollup/dist/native.js:38
  throw new Error(
        ^

  Error: Your current platform "freebsd" and architecture "x64" combination is not yet supported by the native Rollup build. Please use the WASM build "@rollup/wasm-node" instead.

  The following platform-architecture combinations are supported:
  android-arm
  android-arm64
  darwin-arm64
  darwin-x64
  linux-arm
  linux-arm64
  linux-arm64 (musl)
  linux-riscv64
  linux-x64
  linux-x64 (musl)
  win32-arm64
  win32-ia32
  win32-x64

  If this is important to you, please consider supporting Rollup to make a native build for your platform and architecture available.

然后我便去查看了 New-API 的源仓库，发现其前端从 React 换成了 Vite 。而 Vite 在构建时需要使用 Rollup ，而 Rollup在构建时就有了如上报错。当然， Rollup 很贴心的给出了替代的解决方案——使用 @rollup/wasm-node 。

但是很不巧的是，我对 JavaScript 一窍不通，我根本不知道如何使用 @rollup/wasm-node 。即便我去其仓库看 README ，也完全摸不着头脑。

于是我直接在 GitHub 搜索报错信息，然后在 Nuxt 的 issue 里发现了解决办法——荷兰开发者 pi0 给出了可行的解决办法：

You can use resolutions field in package.json (works with pnpm, yarn and recent npm, alternatively you can use overrides if not works) to pin to use wasm version of SWC:
1
2
3
4
5
6
"resolutions": {
"rollup": "npm:@rollup/wasm-node"
},
"overrides": {
"rollup": "npm:@rollup/wasm-node"
},

于是我尝试使用 jq 命令直接在前端部分的 package.json 中添加上述字段：

1	cp package.json package.json.bak && jq '.resolutions = {"rollup": "npm:@rollup/wasm-node"} \| .overrides = {"rollup": "npm:@rollup/wasm-node"}' package.json.bak > package.json

然后重新构建并测试，完全正常。

由于 GitHub Copilot 的审查愈发严格，转 API 使用下封号速度越来越快，而 OpenAI 方的反逆向也愈演愈烈，不论是 Cloudflare 的五秒盾还是 OpenAI 的 Arkose Token 的加入，方便免费的使用 ChatGPT 变得愈加困难。

~~病急乱投医下~~我希望增加一些能够继续便利使用 GPT API 的渠道，然后我发现了deanxv/coze-discord-proxy。简单看下来（主要是看 Dockerfile 和 docker-compose.yaml ），在 Linux 上的使用，问题最大的应该是 Discord 和 Coze 机器人的账号，应用本体的部署是非常的简单易用的，等我真的要部署的时候再来看也不急，那么先折腾一下 FreeBSD 版本吧。

又由于其 Dockerfile 内的构建本体的步骤异常的简洁，于是我很快就写好了 workflow ，构建好了 FreeBSD 的版本（实际上如果作者愿意也可以直接使用 go build 的交叉编译啦，但是我不好意思打扰人家）。

然后就丢给论坛里的热佬去测试了。但是很快，就传来了在 Serv00 上因为权限不足不能访问 /tmp 目录，无法运行的消息：

1
2

[烫烫烫烫@s2]:<\~/domains/coze2api>\$ ./start.sh
[FATAL] 2024/03/25 - 09:46:37 | [open /tmp/data-gym-cache/9b5ad71b2ce5302211f9c61530b329a4922fc6a4.1d1adbda-d03c-46cc-b006-7353d3de07b3.tmp: permission denied]

我一看，第一想法是在源仓库内搜索 data-gym-cache 字段，看看具体的代码是怎么写的，此路径是否可以通过变量调整。结果当然是什么也没搜到。

虽然我不会 golang ，但是也用了不少 golang 写的应用，没见过猪跑也吃过猪肉是不是，我当然知道 golang 在构建前要先 go mod download ，即下载 go.mod 文件中标明的依赖项。

也就是说，/tmp/data-gym-cache 路径并非 deanxv/coze-discord-proxy 规定的，而是其依赖规定的。但是 go.mod 中又有那么多的依赖，我该怎么查找呢？

幸运的是，deanxv/coze-discord-proxy 的所有依赖项都是 GitHub 上的，所以我直接在 GitHub 搜索 data-gym-cache ，查看 code type ，看到了原本的依赖中，是用 DATA_GYM_CACHE_DIR 为变量名设置缓存目录的，而 /tmp/data-gym-cache 是其默认值。所以我告诉论坛热佬，设置这个变量为他有权限访问的路径，然后就运行成功了。

同理，我尝试在 Serv00 上使用 WarpGPT，也遇到了这个无权限访问 /tmp 路径的问题，根据其具体文件名称查询，是 eddycjy/fake-useragent 这个六年前就停止维护的库的问题，通过更改变量名 TMPDIR 的值可以更换其缓存目录，以达到在 Serv00 上正常使用的目的。

以上经历令我对 GitHub 的搜索功能有了进一步的认识，不得不说这也是一个解决问题的重要工具，因为其搜索范围涵盖 Code、Repositories、Issues、Pull requests、Discussions、Users、Commits、Packages、Wikis、Topics、Marketplace 等多个方面，可以使用任意一点已知信息获取到许许多多的相关信息，不仅仅是仓库功能的介绍，还包括问题的解决方法和代码的实现方法等等。在此我作一个暴论：用好 GitHub 的搜索引擎，能够极大地提高学习效率。

一个免费的使用 GPT-4 API 的方案

2024-02-07T03:36:20.046Z

先自锤标题党，本文介绍的 GPT-4 API 目前还只能调用 /v1/chat/completions 以及 /v1/models 和 v1/embeddings 接口。至于 v1/audio/speech 、 v1/fine_tuning 、 v1/files 、 v1/images 、 v1/moderations 等接口是不支持的。但是胜在免费，而且其文字能力确实强大而又出众。

本文只需要用到一个仓库，是 Yanyutin753 开发的 gpt4-copilot-java ，目前还没有放出源码，只能在 Release 中下载打包好的 fat jar 包运行或者直接 docker 运行使用。

感谢始皇提供的 Cocopilot 以及公车 ghu_ThisIsARealFreeCopilotKeyByCoCopilot （已失效）。

部署

docker 运行过于简单，这里不再赘述。大致说明一下 fat jar 直接运行的方法：

# 下载 fat jar 包
curl -L -o gpt4-copilot-java.jar "https://github.com/Yanyutin753/gpt4-copilot-java/releases/download/v0.0.3/gpt4-copilot-java-0.0.3.jar"
# 测试运行，把 PORT 改为自己喜欢的端口，最后的 server.servlet.context-path 参数可以改成自己喜欢的尾缀
java -jar gpt4-copilot-java.jar --server.port=PORT --server.servlet.context-path=/
# 加入 pm2 管理
pm2 start java --name gpt4-copilot-java -- -jar gpt4-copilot-java.jar --server.port=PORT --server.servlet.context-path=/

使用

不妨设 gpt4-copilot-java 运行的地址为 https://your_gpt4-copilot-java.com 。使用公车作为 API Key 进行请求：

# 请求 /v1/chat/comletions 接口
curl --location 'https://your_gpt4-copilot-java.com/cocopilot/v1/chat/completions' \
  --header "Content-Type: application/json" \
  --header "Authorization: Bearer ghu_ThisIsARealFreeCopilotKeyByCoCopilot" \
  --data '{
    "model": "gpt-4",
    "messages": [
      {
        "role": "system",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "鲁迅打周树人"
      }
    ]
  }'

# 请求 v1/embeddings 接口
curl --location 'https://your_gpt4-copilot-java.com/cocopilot/v1/embeddings' \
  --header "Authorization: Bearer ghu_ThisIsARealFreeCopilotKeyByCoCopilot" \
  --header "Content-Type: application/json" \
  --data '{
    "input": "鲁迅打周树人...",
    "model": "text-embedding-ada-002",
    "encoding_format": "float"
  }'

1
2
3

# 请求 /v1/models 接口
curl --location 'https://your_gpt4-copilot-java.com/cocopilot/v1/models' \
  --header "Authorization: Bearer ghu_ThisIsARealFreeCopilotKeyByCoCopilot"

即为 https://your_gpt4-copilot-java.com/cocopilot 做 API BASE URL ，再使用 ghu_ThisIsARealFreeCopilotKeyByCoCopilot 做 API Key 请求即可。为了使用方便，可以与上一篇博客一样接入 One-api 进行使用。

lvguanjun/copilot_to_chatgpt4

如果你需要同时薅很多家 copilot 中转商，又不希望同时搭多个 gpt4-copilot-java ，那么可以使用 lvguanjun/copilot_to_chatgpt4 这个仓库。

首先，为了防止被人白嫖，也为了自己的IP安全，可以先搭建一个 HTTP 代理：

{
  "rewrites": [
    { "source": "/proxy/:match/:url*", "destination": "https://:match/:url*" },
    { "source": "/proxy/:match/:url*/", "destination": "https://:match/:url*/" },
    { "source": "/httpproxy/:match/:url*", "destination": "http://:match/:url*" },
    { "source": "/httpproxy/:match/:url*/", "destination": "http://:match/:url*/" }
  ]
}

在 GitHub 中新建一个仓库，仓库中新建名为 vercel.json 的文件，并填入以上内容。再去 Vercel 中新建 Project ，选择刚刚新建的这个仓库即可。这样你就获得了一个由 Vercel 提供的通用 HTTP 代理，只需要在你需要访问的地址前加上https://your-vercel-project.vercel.app/proxy/即可通过 Vercel 代理访问目标地址，如https://proxy-nineninesix.vercel.app/proxy/www.google.com即为通过 Vercel 访问https://www.google.com。

接下来，我以 Serv00 免费 FreeBSD 主机为例记录 lvguanjun/copilot_to_chatgpt4 的部署过程：

首先在 Panel 中放行一个端口，然后将仓库代码克隆到 Serv00 上：

1	git clone -b endpoint https://github.com/lvguanjun/copilot_to_chatgpt4 c2g4 && cd c2g4

接着按照源仓库的README准备虚拟环境：

python3 -m venv venv
source venv/bin/activate
# 由于 Serv00 免费用户的使用限制，在这里必须使用cpuset命令进行依赖安装，不然装不上。
cpuset -l 0 pip install -r requirements.txt
cp config.py.sample config.py

接着使用 Panel 自带的编辑器或者 vim 编辑 config.py 的内容，主要修改WHITE_TOKEN_URLS的值：

1 2	# 切记不要带 /proxy 路径，该仓库不支持识别此路径，直接用 /* 覆盖全路径即可。 WHITE_TOKEN_URLS = "https://your-vercel-project.vercel.app/*"

保存后，新建一个启动脚本，方便使用 pm2 管理：

cat > run.sh << EOF
#!/bin/bash
source venv/bin/activate
# 记得将下一行的 PORT 替换为自己放行的端口
uvicorn main:app --host 0.0.0.0 --port PORT
deactivate
EOF

测试运行：

1	chmod +x run.sh && bash run.sh

使用pm2管理运行：

1	chmod +x run.sh && ~/.npm-global/bin/pm2 start ./run.sh --name copilot_to_chatgpt4

拼接Key的规则：https://your-vercel-project.app/proxy/地址||秘钥，如https://your-vercel-project.app/proxy/1.1.1.1/copilot_internal/v2/token||mxY5Oc8i8qUHoaiyfgeiuqgefoufmdZwyUqJmlz+MVIXNOabdfkhdaqL0tkQyajSOihkkP/tXbvBUMZhQE08GTfGW4p9GdSHRaNLijJCNVc=.kJfupjFfQeriLXvBDGiA7g==

一个免费的使用 ChatGPT 3.5 API 的方案

2024-02-04T17:38:48.385Z

自从 Pandora-Next 的作者 pengzhile （始皇）宣布 Pandora-Next 停止运营，愉快的享受免费不限量高并发的 ChatGPT 3.5 API 的日子也就结束了。虽然现在很多第三方 API 提供商也提供很多免费额度使用，甚至多的不一定用得完，但是这究其根本在中国大陆的法律上应该是违法行为，也不一定能保证这些第三方提供商的服务就一直稳定，就像始皇停止运营来的那么突然一样。靠谁都不如靠自己，自己部署一个 server 才更靠谱。

经过我的一段时间探索和使用，目前总算是找到了一套差不多算是可以平替的方案，使用到了三个开源仓库：

ninja

ninja 用于和 OpenAI 进行中转，把 chat 的接口转换 api 的接口，不过由于 ninja 作者开发 ninja 的理念是服务端不存储用户数据，所以 ninja 的 ChatGPT-to-API 接口需要使用 access_Token 做 API Keys ，受限于 access_Token 的有效时间太短以及 access_Token 过长的问题，并不能很愉快的使用。但是 ninja 有使用 refresh_token 获取 access_Token 的接口，因为 refresh_token 的长度很短，且永久有效，所以我在 ninja 的 issue 中提议，使用 refresh_token 当做 API Keys 进行请求，但是被作者因为与其不存储用户数据的理念相悖而被否决。

refresh-gpt-chat

refresh-gpt-chat 用于把 ninja 的 api 接口转换成使用 refresh_token 作为 API Keys 进行请求。实际上是 refresh-gpt-chat 先使用 refresh_token 请求 access_Token ，再使用获取到的 access_Token 请求 API ，并把这个 access_Token 存储下来，反复使用。当 access_Token 过期时，再重新使用 refresh_token 请求 access_Token 。

one-api

one-api 用于存储多个 refresh_token ，提高并发量。因为 ninja 提供的 API 功能还是基于 OpenAI 的 chat 的 web ，而 web 又无法并发，必须等一句话说完，才能响应下一次请求，所以对于某些需要高并发的使用场景来讲， ninja 配合 refresh-gpt-chat 是不够的。但是在 one-api 内新建多个渠道，每个都存放一个 refresh_token ，用于请求 refresh-gpt-chat ，再使用 one-api 提供的接口，就能解决高并发的问题，愉快使用。而且 refresh_token 如果泄露也不好， one-api 二次分发就能避免 refresh_token 泄露的问题，让我无后顾之忧的把自己的 API Keys 提供给他人使用。

部署

部署上述服务，需要准备：
1、一台在 OpenAI 封锁之外的 VPS ；
2、一定的智慧和解决问题的能力。

部署步骤也并不复杂，特别是 ninja 和 one-api ，几乎是开箱即用，refresh-gpt-chat只要部署好了 Java 环境，运行也很简单。当然如果 VPS 能够支持 Docker ，甚至只需要 docker-compose.yaml 直接跑就行了。

Docker compose

以下是我写的，把上述三个仓库的服务一口气跑起来的docker-compose.yaml，只需要修改最末 refresh-gpt-chat 部分的 getAccessTokenUrl和chatUrl 两个参数配置即可直接 docker compose up -d 使用。

version: '3.4'

services:
  ninja:
    image: gngpp/ninja:latest
    container_name: ninja
    restart: unless-stopped
    environment:
      - TZ=Asia/Shanghai
    command: run
    ports:
      - "8080:7999"
  
  watchtower:
    container_name: watchtower
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: --interval 3600 --cleanup
    restart: unless-stopped

  one-api:
    image: justsong/one-api:latest
    container_name: one-api
    restart: always
    command: --log-dir /app/logs
    ports:
      - "3000:3000"
    volumes:
      - /project/sandbox/data/oneapi:/data
      - /project/sandbox/logs:/app/logs
    environment:
      - SQL_DSN=oneapi:123456@tcp(db:3306)/one-api  # 修改此行，或注释掉以使用 SQLite 作为数据库
      - REDIS_CONN_STRING=redis://redis
      - SESSION_SECRET=random_string  # 修改为随机字符串
      - TZ=Asia/Shanghai
#      - NODE_TYPE=slave  # 多机部署时从节点取消注释该行
#      - SYNC_FREQUENCY=60  # 需要定期从数据库加载数据时取消注释该行
#      - FRONTEND_BASE_URL=https://openai.justsong.cn  # 多机部署时从节点取消注释该行
    depends_on:
      - redis
      - db
    healthcheck:
      test: [ "CMD-SHELL", "wget -q -O - http://localhost:3000/api/status | grep -o '\"success\":\\s*true' | awk -F: '{print $2}'" ]
      interval: 30s
      timeout: 10s
      retries: 3

  redis:
    image: redis:latest
    container_name: redis
    restart: always

  db:
    image: mysql:8.2.0
    restart: always
    container_name: mysql
    volumes:
      - /project/sandbox/data/mysql:/var/lib/mysql  # 挂载目录，持久化存储
    ports:
      - '3306:3306'
    environment:
      TZ: Asia/Shanghai   # 设置时区
      MYSQL_ROOT_PASSWORD: 'OneAPI@justsong' # 设置 root 用户的密码
      MYSQL_USER: oneapi   # 创建专用用户
      MYSQL_PASSWORD: '123456'    # 设置专用用户密码
      MYSQL_DATABASE: one-api   # 自动创建数据库

  refresh-gpt-chat:  
    # 该服务使用的 Docker 镜像
    image: yangclivia/refresh-gpt-chat:latest  
    # Java 的环境变量 （可适当调节，用copilot可以适当调大点，具体可问gpt了解）
    environment:  
      - JAVA_OPTS=-XX:+UseParallelGC -Xms64m -Xmx64m -XX:MaxMetaspaceSize=64m  
    # 为该服务创建的容器的名称
    container_name: refresh-gpt-chat
    # 容器总是重新启动
    restart: always  
    # 容器运行的用户
    user: root  
    # 容器的网络模式
    ports:
      - "8082:8082"
    command:  
      - --log=info
      #自定义端口号 
      - --server.port=8082
      #自定义前缀
#       - --server.servlet.context-path=/tokensTool
      # ninja获取accessToken的Url
      - --getAccessTokenUrl=http(s)://ninja的外部访问地址/auth/refresh_token
      # ninja或者chat2api API接口
      - --chatUrl=http(s)://ninja的外部访问地址/v1/chat/completions

手动部署

ninja 和 one-api 都可以直接下载可执行文件直接启动，无需配置其他环境，这里不做过多介绍，仅仅记录一下启动的命令。

ninja：

在仓库中直接下载对应自己的 VPS 系统的可执行二进制文件即可。

# 添加可执行权限
chmod +x ninja
# 启动ninja
./ninja run
# 后台启动ninja
./ninja start
# 停止后台ninja
./ninja stop
# pm2管理启动ninja
pm2 start ./ninja --name ninja -- run

one-api

在仓库中直接下载对应自己的 VPS 系统的可执行二进制文件即可。

# 添加可执行权限
chmod u+x one-api
# 设置缓存路径为当前路径（适合无root用户）
export TIKTOKEN_CACHE_DIR="$PWD" 
# 启动one-api（把PORT改成自己想用的端口）
./one-api --port PORT --logs-dir ./logs
# pm2管理启动one-api
pm2 start ./one-api --name one-api -- --port PORT --logs-dir ./logs

refresh-gpt-chat

需要配置 OpenJDK ，前文在 hax 的免费主机上已经安装过 OpenJDK ，这里不再赘述。在仓库中下载 .jar 结尾的 fat jar 包即可直接启动：

# 直接启动（把 PORT 替换成自己希望的端口，并填写ninja的访问地址， jar 包文件名替换成自己下载的文件名）
java -jar refresh-gpt-chat-0.0.1-SNAPSHOT.jar --server.port=PORT --server.servlet.context-path=/ --getAccessTokenUrl=http(s)://ninja的访问地址/url/auth/refresh_token --chatUrl=http(s)://ninja的访问地址/v1/chat/completions
# 使用pm2管理启动
pm2 start java --name refresh-gpt-chat -- -jar refresh-gpt-chat-0.0.1-SNAPSHOT.jar --server.port=PORT --server.servlet.context-path=/ --getAccessTokenUrl=http(s)://ninja的访问地址/url/auth/refresh_token --chatUrl=http(s)://ninja的访问地址/v1/chat/completions

使用

进入 one-api 渠道选项卡中，添加新的渠道，类型选择自定义渠道， Base URL 填写 refresh-gpt-chat 的地址，模型选择 gpt-3.5 相关的全部模型。模型重定向中填入以下内容：

{
  "gpt-3.5-turbo-0301": "gpt-3.5-turbo",
  "gpt-3.5-turbo-0613": "gpt-3.5-turbo",
  "gpt-3.5-turbo-16k": "gpt-3.5-turbo",
  "gpt-3.5-turbo-16k-0613": "gpt-3.5-turbo",
  "gpt-3.5-turbo-1106": "gpt-3.5-turbo",
  "gpt-3.5-turbo-instruct": "gpt-3.5-turbo"
}

勾选中秘钥下方的批量创建，然后在秘钥中填入 refresh_token ，一行一个，最后点击提交。再去令牌选项卡中添加新的令牌，按照自己的喜好填写并提交即可。

再使用 one-api 生成的令牌作为 API Keys ， one-api 的地址作为端点即可。

有多高并发取决于有多少 refresh_token 被存储在 one-api 中，如果需要使用沉浸式翻译这样的高并发应用，建议存入 20-100 个 refresh_token 进行请求。
获取 refresh_token 的网址：xyhelper、freegpts（这两个都是第三方服务，不能保证账号数据安全，也不能保证其服务一直有效，酌情使用，后果自负）
亦或者可以使用 Apple 设备抓包获取 refresh_token ，具体可以自己搜索。不过这种方式容易导致 Apple 设备被 OpenAI 封禁，请酌情使用。

Serv00搭建各种服务

2024-01-27T03:55:23.612Z

这个平台是个 Virtual Host ，没有 Root ，还是 FreeBSD 的系统，不是 Linux ，不太好用。但是优点是隔离性差， Memory 和 vCPU 能短时间内超过 100% 进行调用。

已经玩了不少时间了，起初看到 Github 上有使用 Serv00 搭建 Vless 节点的仓库，就上手玩了一下，后来发现极其不稳， screen 运行的进程总是过一段时间就掉了（后经网友讨论确认为Serv00有时候会重启宿主机），又得ssh上去启动，相当不友好，且后来又发现了 Hax 这样的玩具，就对 Serv00 视如敝履了。

但是这两天有群友突然提醒我才想起，我在 Hax 上用的很舒服的 pm2 也可以在 Serv00 上使用，这个十年有效期的玩具突然显得有用了起来。

经过我的尝试，成功在 Serv00 上部署了一些服务，接下来进行记录：

面板自带功能

域名

Serv00 上如果想要使用自己的域名，有两种方式，一种是通过 Cloudflare 提供的 Argo 隧道，不仅能绑域名，免配置 ssl ，还可以享受 Cloudflare 的免费 CDN 提速。第二种就是直接使用面板内自带的 DNS 服务器功能绑定自己的域名。

在 Panel 中进入 DNS zones 选项卡，使用 Add new zone 功能添加自己的域名或者自己的域名的子域，然后在 Zone list 中找到刚刚添加的域名，点击 Edit 查看 DNS 记录，把当中列出的全部记录添加到自己的域名的 DNS 记录中即可完成域名的绑定。

Serv00 本身对于绑定在其上的域名提供了许多的服务支持，这里所说的绑定在Serv00上的域名包括自己绑定的自己的域名，以及 Serv00 在注册账户时赠送的域名 USERNAME.serv00.net ，其服务包括免费的一键申请式的 SSL 证书、域名邮箱、 DNS 管理等多种功能。

SSL证书申请

在 Panel 中进入 WWW websites 选项卡，点击 Manage SSL certificates ，在你需要申请 SSL 证书的域名的 A 记录指向的那个 IP 地址右侧点击 Manage ，再点击 Add certificate ， Type 选择 Generate Let’s Encrypt certificate ，Domain 选择要申请 SSL 证书的域名，再点击 Add 即可。

域名邮箱

Panel 中进入 E-mail 选项卡，注册账号后会自动注册一个域名邮箱，用户名是 USERNAME@USERNAME.serv00.net 是 Serv00 的账户密码。可以使用 Add new e-mail 功能新建邮箱账户。

也可以在 Add new alias 功能中新建别名邮箱，其别名邮箱功能也提供了和 Cloudflare 一样的 Catch-all 的 Advanced settings 选项，用来批量注册东西十分方便。

目前我的测试中，似乎没有在 Manage whitelist 中添加进白名单的域名邮箱发来的邮件全部都会被识别为垃圾邮件。所以有需要的话可以在 Manage whitlist 中添加你需要接受邮件的邮箱的域名，比如 qq.com 、 gmail.com 等等。

如果绑定了自己的域名，想要使用自己的域名配置域名邮箱的话，要在 Domain list 中找到自己的域名，点击最右边的 DKIM ， action 选择 Add DNS record automatically ，然后 Sign domain 以注册域名，使得新的域名邮箱能够通过一些邮件接收服务器的验证。

Open web client 功能就可以进入邮箱的登录页面了，其使用方法与大多数的邮箱相同，不再赘述。

DNS管理

DNS zones 选项卡中在自己绑定的域名右侧点击 Edit ，即可查看当前域名的所有 DNS 记录，在 Add new record 中可以手动添加新的 DNS 记录，与大多数的域名服务商提供的 DNS 管理的功能类似。

Proxy

WWW websites 选项卡中可以根据语言不同添加多种网站，其中 PHP 的 eval() function 和 exec() function 都要在添加完网站后，在Manage > Details 中打开。不同类型的网页其 Details 中的选项也都有差异，可以按需查看配置，这里重点讲一下 Proxy 类型指向自己的应用程序监听端口的配置。

Add new website 功能中， Domain 填写自己的域名或者 serv00 分配的域名，或者它们的子域，展开 Advanced settings， Website type 选择 Proxy ，Proxy target 选择 localhost ， Proxy port 选择自己的应用监听的端口，其他选项留空或者保持默认，点击 Add 即可。接下来就能使用刚刚填写的域名访问自己部署的对应端口的应用了。如果需要 https 访问，再按前文的步骤去申请 SSL 证书即可。

运行自己的应用

Additional services 选项卡中找到 Run your own applications 项目，将其设置为 Enabled 即可。如果不开启这一项，自己的用户目录下的所有文件都无法添加可执行权限。

File manager

文件管理，有一定的在线编辑和预览的功能，兼具文件的上传下载，删除新建等各种管理功能，十分便利。

Port reservation

需要使用端口都得在这申请。

数据库

Serv00 提供了 MySQL 、 PostgreSQL 、 MongoDB 三种数据库，可以按需新建数据库、数据库用户。同时， Serv00 还提供了三种数据库的 webui ，十分便利。

需要注意的是，所有数据库在新建时，其用户名和数据库名都有一个 mxxx_ 的前缀，在使用时容易被忽视。

Cron jobs

Cron jobs 选项卡提供了一些计划性任务的设置功能，在这里可以设置开机自启任务，或者定时循环任务，当然常用的还是开机自启任务的设定， Specify time 选择 After reboot 即为开机自启。

部署应用前的一些准备工作

在部署自己的应用之前，我建议提前安装好 pm2 以及 Cloudflared （可选）。前者是进程管理工具，用来方便开机自启，以及程序崩溃后自启，查阅进程运行情况等等。后者是 Cloudflare 的 Argo 隧道客户端，用它也可以给自己部署的应用加域名。特别是 Uptime Kuma ，更加推荐使用 Cloudflared 加域名，而不建议使用面板自带的 Proxy 。

Pm2

这个是重中之重，如果不是成功安装了 pm2 ，我甚至不会尝试探索 Serv00 这个玩具有什么用，所以 pm2 的安装方法记录在开头。

在 SSH 连接 serv00 之后，直接使用一键脚本安装 pm2 ：

1	bash <(curl -s https://raw.githubusercontent.com/k0baya/alist_repl/main/serv00/install-pm2.sh)

如果安装完成后执行 pm2 提示命令未找到，你可以断开 SSH 连接，再重新连接，即可。

Cloudflared

Cloudflared 官方仓库并没有构建 FreeBSD 系统上能够使用的二进制文件，但是同样的，我找到了第三方的构筑。使用第三方构筑的二进制文件，就能愉快的使用隧道了。

关于 Cloudflared 是什么，有什么用，ARGO_TOKEN 如何获取等部分，这里不再赘述，详细可以查看我的关于 CodeSandbox 和 Hax 的文章。

创建并进入Cloudflared 的工作目录：

1	mkdir -p ~/domains/cloudflared && cd ~/domains/cloudflared

下载 Cloudflared：

1	wget https://cloudflared.bowring.uk/binaries/cloudflared-freebsd-latest.7z && 7z x cloudflared-freebsd-latest.7z && rm cloudflared-freebsd-latest.7z && mv -f ./temp/* ./cloudflared && rm -rf temp

测试运行：

1	./cloudflared tunnel --edge-ip-version auto --protocol http2 --heartbeat-interval 10s run --token ARGO_TOKEN

其中 ARGO_TOKEN 要替换成自己的。确定运行没有问题后，按 Ctrl+c即可停止运行。

使用 pm2 启动 Cloudflared：

1	pm2 start ./cloudflared -- tunnel --edge-ip-version auto --protocol http2 --heartbeat-interval 10s run --token ARGO_TOKEN

其中 ARGO_TOKEN 要替换成自己的。

接着去 CLoudflare 的面板中设置域名对应端口，即可使用域名访问自己搭建的服务了。

安装 go1.22

如果你有安装自己使用 go build 构建的需求，你可以选择安装最新的 go1.22 ，这里记录其安装过程。

由于 Serv00 服务器上并未提供 go1.22 ，只提供了 go1.20.3 ，无法正常进行构建工作，所以需要手动安装 go1.22 环境。

# 创建安装目录
mkdir -p ~/local/soft && cd ~/local/soft
# 下载编译好的 go1.22 的程序包
wget https://dl.google.com/go/go1.22.0.freebsd-amd64.tar.gz
# 解压
tar -xzvf go1.22.0.freebsd-amd64.tar.gz
# 删除压缩文件
rm go1.22.0.freebsd-amd64.tar.gz
# 修改 .profile 文件
echo 'export PATH=~/local/soft/go/bin:$PATH' >> ~/.profile
# 使 .profile 的修改生效
source ~/.profile
# 检查 go 版本
go version

部署自己的应用

关于设定 PHP 版本、插件、参数等配置均可参考文档的 .htaccess 部分进行配置，由于 PHP 的应用部署实在是太简单，故本文不会过多介绍。

WordPress

实际上在 serv00 的文档中有搭建网站的示例，没错，示例就有 WordPress ，实际上 WordPress 确实可以搭建，十分简单好用。这里不做过多介绍，按照文档一步步操作即可。

除了 WordPress 外，文档中还详细介绍了 Redis、Memcached、Imapsync、WP-CLI、Tomcat 等服务的搭建方法，有需求的都可以照着抄。

KodBox

虽然 Serv00 能够部署 KodBox，但是实在是不太好用。最直观的感受就是卡，因为 KodBox 运行期间需要调用多个 PHP 组件，而 Serv00 限制同时处理三个 PHP 进程，所以显得特别慢。其次， Serv00 没有 Root 权限，部分 PHP 插件没有安装，也无法安装，导致有一些 KodBox 的插件无法正常运行。

当然如果只是图新奇搭一个玩玩，也是可以的。下面是步骤：

首先在 Panel 中 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	PHP

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着SSH登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

1 2	# 安装KodBox bash <(curl -s https://pan.rappit.site/d/shell/kodbox1.49/serv00-kodbox-install.sh)

然后去 Panel 中的 MySQL 选项卡，新建数据库和用户，用以接入 KodBox 。再去 WWW Websites 选项卡中找到用户名.serv00.net ，点击右侧的 Manage > Details 进入设置，把 GZIP compression、Allow PHP eval() function、Allow PHP exec() function 三个功能打开。

然后使用浏览器访问你的 KodBxo 的域名，进行安装配置即可。初次启动需要较长的时间，请耐心等待。

Lsky-Pro

一开始看兰空图床的文档没看到 webdav 功能的相关介绍，只看到几个我都不用的存储介质，遂不感兴趣的搁置了，然而群友近日又提起，我打开 GitHub 才发现首页有个 Commit 的标题就是 webdav 相关，即兰空图床支持 webdav 。于是我便部署了一下，体验感觉还不错，简单易用。

本来无意在本篇文章再多写 PHP 相关的站点部署，因为过于简单。但是奈何群友有需求，遂做个简单的步骤记录：

首先在 Panel 中 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	PHP

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着SSH登入，并进入刚刚你新建的域名目录下：

# 下载图床应用
release_info=$(curl -s https://api.github.com/repos/lsky-org/lsky-pro/releases/latest)
asset_url=$(echo "$release_info" | jq -r '.assets[] | select(.name != "source code") | .browser_download_url')
curl -L -o temp.zip "$asset_url" && unzip -q temp.zip && rm -f temp.zip
rm -rf public_html && ln -s "$PWD/public" "$PWD/public_html"

接着在 Panel 中 WWW websites 选项卡内，点击自己刚刚创建的用于部署 Lsky-Pro 的域名的 Manage > Details ，在 Open Basedir directories 的最末添加：

1	:/usr/home/用户名/domains/xxx.USERNAME.serv00.net

记得把用户名和最末的域名换成自己的。

然后把 GZIP compression 、Allow PHP eval() function 、Allow PHP exec() function 都打开，点击 save changes 保存。

然后去 Panel 中的 MySQL 选项卡，新建数据库和用户，用以接入 Lsky-Pro 。

然后使用浏览器访问你的 Lsky-Pro 的域名，进行安装配置即可。

上面的应用不需要占用端口。

下面的应用每一个都能够 / 需要占用端口。

Vless

这个肯定是第一时间部署的，每次遇到这样的平台，第一时间总是想着能不能搭建节点。

①

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的 USERNAME.serv00.net 删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Vless 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着SSH登入，并进入刚刚你新建的域名目录下：

1 2	# 克隆源仓库 rm -rf public_html && git clone https://github.com/qwer-search/serv00-vless public_html && cd public_html && rm -f README.md

使用vim编辑或者直接去 Panel 中的 File Manager 选项卡在线编辑 app.js 文件，修改端口为刚刚放行的端口。

安装依赖：

1	npm install

安装完毕后，使用pm2启动并守护vless进程：

1	pm2 start app.js --name vless

接着去你的代理客户端软件中手动添加 vless 配置即可：

Key	Value
地址	Panel中WWW Websites 选项卡里的你的 Domain name
端口	你放行的端口
用户 id	37a0bd7c-8b9f-4693-8916-bd1e2da0a817
传输协议	ws
伪装域名	同地址
ws path	/

上表没有给出的可以不填。

②

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的 USERNAME.serv00.net 删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Vless 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着SSH登入，并进入刚刚你新建的域名目录下的 public_html 路径下，再使用 npm 命令安装 @3Kmfi6HP/nodejs-proxy ：

1	npm install @3Kmfi6HP/nodejs-proxy

被删库了可以自己换个源安装，比如：
1
npm --registry http://r.cnpmjs.org install @3Kmfi6HP/nodejs-proxy
这个源如果也不行了请自己找其他源替换。

再使用 pm2 启动：

1 2	# 记得把 PORT 替换成自己放行的端口。 pm2 start npx --name vless -- nodejs-proxy -p PORT

接着访问这个刚刚添加的站点，即可在网页上直接获取配置。
哦对，有个小 bug ，端口需要改成 443 ，而网页中默认给的配置是 80 。

之所以说这个 npm 包不安全，是因为其配置在网页上都可以看到，而且网页设计不太合理，有一个不带 uuid 的中转页面，所以可以使用 fofa 、 shodan 等网络空间扫描工具批量扫出来，而且不止 Serv00 一个平台有人使用，如果你感兴趣，你可以去搜搜看，可以收获一大批 Vless 节点。
这里放一个 Serv00 上的，我在 fofa 上搜到的页面作为部署示例：https://pclwgdwv.serv00.net/

Alist

Alist 官方仓库没有构筑 FreeBSD 系统下能够运行的 Alist 可执行文件，但是我在 Github 上发现了一个使用 Github Workflow 自动构筑 FreeBSD 适用的 Alist 的仓库，使用这个仓库就可以很便利的在Serv00上部署 Alist。

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的 USERNAME.serv00.net 删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Alist 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着 SSH 登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

1 2	# 使用一键命令安装 Alist wget -O alist-freebsd.sh https://raw.githubusercontent.com/k0baya/alist_repl/main/serv00/alist-freebsd.sh && sh alist-freebsd.sh

在 Panel 中进入 MySQL 选项卡，使用 Add database 功能新建一个数据库。

密码要求含有大写字母、小写字母和数字三种字符，且长度必须超过6个字符。

接下来进入 File manager 选项卡，进入 ~/domains/xxx.USERNAME.serv00.net/public_html/data 路径，可以看到一个名为 config.json 的文件，右键点击，选择 View/Edit > Source Editor ，进行编辑：

我主要修改了 CDN、database、scheme 三个部分，其中CDN可以在 Alist 的官方文档找到，请选择你本地网络连接速度最快的一个。

scheme 部分，我选择修改 adress 为 127.0.0.1本地回环，是为了避免被他人使用 http://ip:port的方式进行访问。至于自己怎么访问，我在本文后面的部分会进行介绍。port 要改成自己前面放行的端口。

database 部分，type 需要改成 mysql ，host 填写你在注册邮件中看到的 mysql 的地址， port 是默认的 3306，用户名、密码、数据库名则按照你创建的情况进行填写。

最新版本的 Alist 如果不想开启 S3 Server，请把对应的配置文件中的端口配置为 0 。

改完之后，点击 save 保存，接着回到 SSH 窗口中进行操作：

测试启动 Alist：

1	./alist server

确定运行没有问题后，按 Ctrl+c即可停止运行。

使用 pm2 启动并管理 alist：

1	pm2 start ./alist -- server

同样的，你还可以使用 Cloudflared 隧道添加域名，而不选择使用 Proxy 。

Synctv

群友仿照 alist-freebsd 的仓库的 workflow 进行构筑的。部署简单，与 alist 类似。首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的 USERNAME.serv00.net 删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Synctv 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着 SSH 登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

# 下载可执行文件
release_info=$(curl -s https://api.github.com/repos/shangskr/synctv-freebsd/releases/latest)
asset_url=$(echo "$release_info" | jq -r '.assets[] | select(.name != "source code") | .browser_download_url')
curl -L -o synctv "$asset_url" && chmod +x synctv

新建启动脚本：

cat > start.sh << EOF
#!/bin/sh
# 如果不希望被使用 http://ip:port 的方式访问，取消注释下一行
# export SYNCTV_SERVER_LISTEN=127.0.0.1
# 把下一行的最末的PORT改成自己放行的端口
export SYNCTV_SERVER_PORT=PORT
exec ./synctv server --data-dir ./
EOF

添加可执行权限：

1	chmod +x start.sh

测试运行：

1	./start.sh

确定运行没有问题后，按 Ctrl+c即可停止运行。

使用pm2启动并管理：

1	pm2 start ./start.sh --name synctv

同样的，你还可以使用 Cloudflared 隧道添加域名，而不选择使用 Proxy 。

One-api

~~源仓库没有提供freebsd平台的二进制文件，需要自己构建，但是很简单~~。我已经写了一个仓库用于自动化构建 freebsd 版本的 one-api 二进制文件，可以直接下载使用。

如果你想使用 New-API ，可以使用这个仓库k0baya/new-api-freebsd，用法与本节介绍的 One-API 基本一致，对比One-API添加了一些更方便的功能。也许之后 One-API 也会加入这些功能。

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 One-API 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着 SSH 登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

# 下载 one-api
release_info=$(curl -s https://api.github.com/repos/k0baya/one-api-freebsd/releases/latest)
asset_url=$(echo "$release_info" | jq -r '.assets[] | select(.name != "source code") | .browser_download_url')
curl -L -o one-api "$asset_url" && chmod +x one-api

新建启动脚本：

cat > start.sh << EOF
#!/bin/sh
# 如果你有设置主题的需要，可以取消注释下一行，然后按照自己的需求设置。
# export THEME="berry"
export TIKTOKEN_CACHE_DIR="$PWD"
# 把下一行的 PORT 改为自己放行的端口
exec ./one-api --port PORT --log-dir ./logs
EOF

添加可执行权限：

1	chmod +x start.sh

保存后回到 terminal 中，测试运行：

1	./start.sh

确定运行没有问题后，按 Ctrl+c即可停止运行。

使用pm2启动并管理：

1	pm2 start ./start.sh --name one-api

同样的，你还可以使用 Cloudflared 隧道添加域名，而不选择使用 Proxy 。

Uptime-Kuma

受限于 FreeBSD 的平台限制，1.23版本内置了 PlayWright ，无法运行，所以只能安装 1.22 版本。切记先去 Panel 中放行 TCP 端口。

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Uptime-Kuma 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着 SSH 登入，并进入刚刚你新建的域名目录下：

1
2

# 下载 v1.22.1 版本的源代码
cd ~/domains && wget https://github.com/louislam/uptime-kuma/archive/refs/tags/1.22.1.zip && unzip 1.22.1.zip && rm -rf public_html && mv -f uptime-kuma-1.22.1 public_html && rm -f 1.22.1.zip && cd public_html

设置生产模式：

1	npm ci --production

下载dist文件：

1	wget https://github.com/louislam/uptime-kuma/releases/download/1.22.1/dist.tar.gz && tar -xzvf dist.tar.gz && rm dist.tar.gz

安装补充依赖：

1	npm install

安装过程中多少会有报错，无视就好，实际上最后可以正常运行。内置的Cloudflared反向代理在FreeBSD平台上无法使用，但是可以使用上述的外置的Cloudflared进行反代，使用自己的域名。

测试运行：

1	node server/server.js --port=PORT

记得把PORT替换成你放行的端口。确定运行没有问题后，按 Ctrl+c即可停止运行。

使用pm2管理后台运行：

1	pm2 start server/server.js --name uptime-kuma -- --port=PORT

记得把PORT替换成你放行的端口。

如果你不希望自己的Uptime-Kuma被人使用 http://IP:PORT的方式访问，你可以在最后的执行命令添加 --host=127.0.0.1的尾缀，这样就只能通过反向代理的域名进行访问了:
1
pm2 start server/server.js --name uptime-kuma -- --port=PORT --host=127.0.0.1

同样的，你还可以使用 Cloudflared 隧道添加域名，而不选择使用 Proxy 。

Bingo（暂时无法正常使用）

先放行一个端口。在 Panel 中进入 File manager 选项卡，点击左侧的 My Files 进入你的用户根目录，找到 .profile文件，右键选择 View/Edit > Choose other >Source Editor 进行编辑，在最末加上以上两行并保存：

1 2	alias node='node20' alias npm='npm20'

应用更改：

1	source ~/.profile

先新建一个目录用于存放 Bingo 的相关文件，进入目录后执行下述操作。

下载源码：

1	git clone https://github.com/weaigc/bingo

进入源码所在目录：

cd bingo

安装依赖：

1	npm20 install

下载build好的 .next资源：

1	wget -O next.tar.gz https://pan.saika.free.hr/d/local/next.tar.gz && tar -xzvf next.tar.gz && rm next.tar.gz

添加环境变量文件：

1	cp .env.example .env

接着在 Panel 中进入 File manager 选项卡，进入Bingo 源码所在的目录，找到 server.js文件，右键选择 View/Edit > Choose other >Source Editor 进行编辑，修改第7行中的端口为你放行的端口。再编辑 .env文件，添加你的 BING_HEADER。

测试启动：

1	npm20 run start

确定运行没有问题后，按 Ctrl+c即可停止运行。

使用pm2启动并管理：

1	pm2 start npm --name bingo -- run start

Refresh-gpt-chat

用来对接 ninja、warpgpt 等能够使用 access_Token 作为 API Key 请求 GPT 的工具，以使用永久有效期的 Refresh_token 来获取更好的体验。

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的 USERNAME.serv00.net 删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Refresh-gpt-chat 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着 SSH 登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

1 2	# 下载 refresh-gpt-chat wget -O refresh-gpt-chat.jar https://github.com/Yanyutin753/refresh-gpt-chat/releases/download/v0.0.3/refresh-gpt-chat-0.0.3-SNAPSHOT.jar

使用 pm2 启动：

pm2 start java19 --name refresh-gpt-chat -- -jar refresh-gpt-chat.jar --server.port=端口 --server.servlet.context-path=/ --getAccessTokenUrl=https://你的ninja地址/auth/refresh_token --chatUrl=https://你的ninja地址/v1/chat/completions

再套域名，接下来就可以直接使用 https://你套的域名/v1/chat/completions/ 当作API端点，使用 refresh_token 做 API_Keys ，使用 ChatGPT 了。

然后在 one-api 中添加自定义渠道， Base URL 填写你 https://你套的域名，模型填入你的 refresh_token 对应的账号所支持的模型，如果和我一样手持大把 3.5 的账号想用来做 API 用，可以选择全部 GPT3.5 的相关模型，然后在 模型重定向中填入以下内容：

{
  "gpt-3.5-turbo-0301": "gpt-3.5-turbo",
  "gpt-3.5-turbo-0613": "gpt-3.5-turbo",
  "gpt-3.5-turbo-16k": "gpt-3.5-turbo",
  "gpt-3.5-turbo-16k-0613": "gpt-3.5-turbo",
  "gpt-3.5-turbo-1106": "gpt-3.5-turbo",
  "gpt-3.5-turbo-instruct": "gpt-3.5-turbo"
}

密钥填写你的 refresh_token即可，如果你有多个账号，可以将批量勾选上，然后一行写一个 refresh_token。

同样的，你还可以使用 Cloudflared 隧道添加域名，而不选择使用 Proxy 。

Gpt4-copilot-java

支持 cocopilot 的 ccu 和 copilot 的 ghu 调用 copilot 转 GPT-4 的接口转换工具。 Java 写的，可以在 Serv00 运行。

目前更推荐这个方法：lvguanjun/copilot-to-chatgpt4
比起 Gpt4-copilot-java 更轻量更强大。

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Gpt4-copilot-java 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着 SSH 登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

# 下载 fat jar 包
RELEASE_INFO=$(curl -s "https://api.github.com/repos/Yanyutin753/gpt4-copilot-java-sh/releases/latest")
JAR_DOWNLOAD_URL=$(echo "$RELEASE_INFO" | jq -r '.assets[] | select(.name|test(".jar$")) | .browser_download_url')
curl -L -o gpt4-copilot-java.jar "$JAR_DOWNLOAD_URL"

测试运行：

1
2

# 把PORT改为自己放行的端口，最后的server.servlet.context-path参数可以改成自己喜欢的尾缀
java19 -jar gpt4-copilot-java.jar --server.port=PORT --server.servlet.context-path=/

测试没有问题之后，按 Ctrl+c即可停止运行。

使用 pm2 启动并管理：

1	pm2 start java19 --name gpt4-copilot-java -- -jar gpt4-copilot-java.jar --server.port=PORT --server.servlet.context-path=/

始皇的公车：ghu_ThisIsARealFreeCopilotKeyByCoCopilot （已失效）

免费公车白嫖请求示例：

curl --location 'http(s)://ip:port_or_URL/cocopilot/v1/chat/completions' 
--header 'Content-Type: application/json' 
--header 'Authorization: Bearer ghu_ThisIsARealFreeCopilotKeyByCoCopilot' 
--data '{
"model": "gpt-4",
"messages": [{"role": "user", "content": "鲁迅打周树人"}]
}'

同样的，你还可以使用 Cloudflared 隧道添加域名，而不选择使用 Proxy 。

Zfile

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Zfile 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着 SSH 登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

1 2	# 下载 fat jar 包 wget --no-check-certificate -O zfile.jar https://c.jun6.net/ZFILE/zfile-release.jar

测试运行：

1	java19 -jar -Duser.timezone=Asia/Shanghai zfile.jar --zfile.log.path=$PWD/logs --zfile.db.path=$PWD/zfile --server.port=PORT

记得把端口改成自己的。测试没有问题之后，按 Ctrl+c即可停止运行。

使用pm2启动并管理：

1	pm2 start java19 --name zfile -- -jar -Duser.timezone=Asia/Shanghai zfile.jar --zfile.log.path=$PWD/logs --zfile.db.path=$PWD/zfile --server.port=PORT

同样的，你还可以使用 Cloudflared 隧道添加域名，而不选择使用 Proxy 。

Halo

慎重部署，内存会超100%，不知道会不会封号

halo 自从升级 2.0 版本开始，很长时间内都没有提供构筑好的 jar 包，甚至于在GitHub上都出现了第三方的，使用 GitHub workflow 自动化构筑 jar 包的仓库。但是，自从2.12.0-alpha.1版本开始，halo 的官方仓库又开始提供构筑好的 jar 包了，刚好这些天在玩 Serv00 ，遂尝试部署了一下，成功。现记录一下：

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的 USERNAME.serv00.net 删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Halo 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

并在 MySQL 选项卡中中新建 MySQL 数据库，用于填入接入 Halo 。

接着 SSH 登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

# 下载jar包
release_info=$(curl -s https://api.github.com/repos/halo-dev/halo/releases/latest)
jar_url=$(echo "$release_info" | jq -r '.assets[] | select(.name | endswith(".jar")) | .browser_download_url')
curl -L "$jar_url" -o halo.jar

在 halo.jar 所在路径下新建 .halo2 文件夹，进入其中，新建文件 application.yaml 然后并配置其内容：

# 新建文件夹
mkdir -p .halo2
# 新建并填入配置
cat > .halo2/application.yaml << EOF
server:
  port: 你在面板中放行的端口
  # Response data gzip.
  compression:
    enabled: false
spring:
  #sql:
  #  init.platform: mysql
  r2dbc:
    url: r2dbc:pool:mysql://数据库地址:3306/数据库名
    username: 数据库用户名
    password: 数据库密码
halo:
  # Your admin client path is https://your-domain/{admin-path}
  admin-path: admin
  # memory or level
  cache: level
EOF

在 halo.jar 所在路径下新建 run.sh 运行脚本：

cat > run.sh << EOF
#!/bin/bash
export HALO_WORK_DIR="$PWD/.halo2"
export HALO_EXTERNAL_URL="https://你的域名"
exec java17 -server -Xms128m -Xmx256m -jar -Duser.timezone=Asia/Shanghai $PWD/halo.jar --spring.config.additional-location=$PWD/.halo2/application.yaml
EOF

测试运行：

1	chmod +x run.sh && ./run.sh

确定运行没有问题后，按 Ctrl+c即可停止运行。

使用pm2管理运行：

1	chmod +x run.sh && pm2 start ./run.sh --name halo

同样的，你还可以使用 Cloudflared 隧道添加域名，而不选择使用 Proxy 。

Go-proxy-bingai

这个仓库是 Bingo 的前身，当初玩 Replit 时我便有在使用，只可惜作者早已弃坑，所以当初我才找到了当时还能用的 Bingo 使用。

在 Bingo 也长期未更新，无法正常使用的如今，我的目光转向了另一个二改仓库。Harry-zklcdc 维护的 Go-proxy-bingai 的分支仓库目前还能够正常使用。而且在与开发者反馈了几个 bug 之后，开发者都会花时间认真复现，并快速修复，其体验实在是不错。

~~虽然原仓库的 Release 中并未提供 FreeBSD 系统适用的二进制文件，但是我们能够自己构建。我已经构建了一份放在这篇博客底部的QQ群的群文件中~~。~~我写了一个仓库用于自动化构建 FreeBSD 版本的 go-proxy-bingai ，可以从我的仓库下载使用。~~ 作者已经开始提供 FreeBSD 的构建，故我的仓库已经存档。

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的 USERNAME.serv00.net 删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Go-proxy-bingai 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着 SSH 登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

# 下载可执行文件
release_info=$(curl -s https://api.github.com/repos/Harry-zklcdc/go-proxy-bingai/releases | jq -r '[.[] | select(.prerelease==false)][0]')
download_url=$(echo "$release_info" | jq -r '.assets[] | select(.name=="go-proxy-bingai-freebsd-amd64.tar.gz") | .browser_download_url')
curl -L "$download_url" -o go-proxy-bingai-freebsd-amd64.tar.gz&& tar -xzf go-proxy-bingai-freebsd-amd64.tar.gz && rm go-proxy-bingai-freebsd-amd64.tar.gz && chmod +x go-proxy-bingai

新建启动脚本：

cat > entrypoint.sh << EOF
#!/bin/bash
# 被注释的环境变量请根据自己的需求，按照原仓库的 wiki 中的介绍进行填入。
export BYPASS_SERVER="https://bypass.zklcdc.xyz"  # 作者本人的公共bypass服务，可用性未知。
# export Go_Proxy_BingAI_USER_TOKEN_1="xxx"
# export Go_Proxy_BingAI_USER_TOKEN_2="xxx"
# export USER_KievRPSSecAuth="xxx"
# export USER_RwBf="xxx"
# export USER_MUID="xxx"
# export APIKEY="sk-xxx"
# export BING_BASE_URL="https://www.bing.com"
# export SYDNEY_BASE_URL="https://sydney.bing.com"
# export HTTP_PROXY="http://172.17.0.1:18080"
# export HTTPS_PROXY="http://172.17.0.1:18080"
# export Go_Proxy_BingAI_AUTH_KEY="xxx"
# 请把下一行双引号中的内容替换成你放行的端口。
export PORT="xxx"
chmod +x go-proxy-bingai && exec ./go-proxy-bingai
EOF

运行：

# 测试运行
chmod +x entrypoint.sh && ./entrypoint.sh
# 使用 pm2 管理运行
pm2 start ./entrypoint.sh --name go-proxy-bingai

请注意，如果你需要使用其 web 功能，而不仅仅是 api 功能，请务必使用 https 访问，不然无法打开。你可以选择使用面板自带的 proxy 添加域名并申请 ssl 证书，亦或者直接使用 cloudflared 隧道。

同样的，你还可以使用 Cloudflared 隧道添加域名，而不选择使用 Proxy 。

Pentaract

不建议使用，目前 Bug 众多，而且对 Telegram 账号有一定要求，目前暂不清楚 Telegram 限制账号的评定标准。

可以自行构建或者使用使用我构建的成品。由于该应用需要使用具有超级管理员权限的 PostgreSQL ，故不可使用 Serv00 自带的 PostgreSQL ，需要远程连接。

编译成品下载地址：pentaract-freebsd_X64.tar.gz

前端构建简单，这里不再赘述，而且由于其 Dockerfile 内构建前端使用的是 Node.js 21 而目前 FreeBSD Port 最高只有 Node.js 20 ，故不推荐在 FreeBSD 上直接构建，可以使用 GItHub Actions 进行构建，或是自己在 Node.js 21 的环境下构建再复制，甚至干脆直接从作者预构建的 Docker 镜像内打包出来使用。（经过测试，使用 Nodejs20 构建也可以正常使用。）

Serv00 上的构建法：

# 切换 Node.js 版本为 Nodejs20
alias node=node20
alias npm=npm20
# 全局安装 pnpm
npm install -g pnpm
source ~/.bashrc
# 构建前端
pnpm install
VITE_API_BASE='/api' pnpm run build
# 移动构建产物到工作目录
mkdir -p ~/pentaract/ui && cp -R ./dist/* ~/pentaract/ui

后端的构建，可以使用 GItHub Actions ，或者本地 FreeBSD 虚拟机，甚至直接在 Serv00 上构建。这里记录一下在 Serv00 上构建的方法：

# 克隆仓库到 Serv00 上
git clone https://github.com/Dominux/Pentaract && cd Pentaract/pentaract
# 构建
LIBCLANG_PATH=/usr/local/llvm16/lib cpuset -l 0 cargo build --release
# 移动构建产物到工作目录
mkdir -p ~/pentaract && cp ./target/release/pentaract ~/pentaract/pentaract

然后去 supabase 注册一个免费的PostgreSQL ，记录下数据库的用户名、密码、数据库名、地址，用于后续填入环境变量。

接着在 ~/pentaract 路径下新建一个启动脚本，按照要求填入所有的环境变量：

cat > start.sh << EOF
#!/bin/bash
export PORT=xxxx
export WORKERS=4
export CHANNEL_CAPACITY=32
export SUPERUSER_EMAIL=xxxx@xxxx.com
export SUPERUSER_PASS=xxxx
export ACCESS_TOKEN_EXPIRE_IN_SECS=1800
export REFRESH_TOKEN_EXPIRE_IN_DAYS=14
export SECRET_KEY=xxx
export TELEGRAM_API_BASE_URL=https://api.telegram.org
export DATABASE_USER=xxxx
export DATABASE_PASSWORD=xxxx
export DATABASE_NAME=xxxx
export DATABASE_HOST=xxxx
export DATABASE_PORT=5432
chmod +x pentaract && exec ./pentaract
EOF

给启动脚本赋权：

1	chmod +x start.sh

前端的 index-22eec6d1.js 文件内的 http://localhost:8000 需要更改为 serv00 的 url 或者 ip:port 。你可以去文件管理中编辑，查找替换即可，也可以使用sed命令简单更改一下：已经重新构建前端并替换，现无需此步。

测试运行：

1	./start.sh

使用 pm2 管理：

1	pm2 start ./start.sh --name pentaract

OneList

原作者似乎已经弃坑，故我的仓库没有做自动检测构建。但是体验还不错，有 Emby 既视感了，配合小雅的 Alist 岂不美哉。

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 OneList 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着SSH登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

# 下载 OneList
wget https://github.com/k0baya/onelist-freebsd/releases/download/v2.0.5/onelist
# 初始化配置
chmod +x onelist && ./onelist -run config

接着回到 Panel 中，进入File manager选项卡，进入 OneList 所在路径，可以看到一个名为 config.env 的文件，右键点击，选择View/Edit > Source Editor，进行编辑：

# 服务设置
# 注意要改为未被占用的端口
API_PORT=5245
FaviconicoUrl=https://wework.qpic.cn/wwpic/818353_fizV30xbQCGPQRP_1677394564/0
API_SECRET=fRVvjcNd11gYGI85StVaeCtPVSmJTRRE

# Env有两种模式，Debug及Release，主要用在数据库为mysql时候，需要注意修改Env环境和mysql密码对应
Env=Debug

# 管理员账户设置，用于初始化管理员账户
UserEmail=xxxx.@qq.com
UserPassword=xxxxx

# 数据库设置
DB_DRIVER=sqlite
DB_USER=root
DbName=onelist

# 如果上面DB_DRIVER类型为mysql，就需要正确填下以下参数
DB_PASSWORD_Debug=123456
DB_PASSWORD_Release=123456

# TheMovieDb Key
# 在https://www.themoviedb.org网站申请
KeyDb=22f10ca52f109158ac7fe064ebbcf697

你可以按照自己的需求配置端口、管理员账户、数据库。 MySQL 性能更好哦~

测试运行：

1	./onelist -run server

使用 pm2 管理：

1	pm2 start ./onelist -- -run server

WarpGPT

这个没什么多说的，可以使用 access_Token 作为 API Key 请求 ChatGPT 接口，也就是所谓的 chat2api 。配合前文的 Refresh-gpt-chat 就可以把永久有效期的 Refresh_token 作为 API Key 来使用，十分的好用。

源仓库没有 Release ，故我的仓库没有做自动检测构建。如果有更新需求需要手动触发 workflow 。你有需要也可以自己fork一份然后手动触发 workflow 。

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 WarpGPT 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着SSH登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

1 2	# 下载二进制文件 wget https://github.com/k0baya/warpgpt-freebsd/releases/download/latest/warpgpt && chmod +x warpgpt

添加启动脚本：

cat > start.sh << EOF
#!/bin/bash
export TMPDIR="$PWD"
chmod +x warpgpt && exec ./warpgpt
EOF

给启动脚本赋权：

1	chmod +x start.sh

配置环境变量：

cat > .env << EOF
proxy = "http://127.0.0.1:10809"   #代理地址 （选填）
port = 5000                        #程序运行端口
host = '127.0.0.1'                 #可访问ip，0.0.0.0允许所有ip
verify = false                     #是否对访问进行验证
auth_key = ""                      #若开启访问验证，则需要在Header中添加AuthKey字段，且值为auth_key的值才能访问 （选填）
arkose_must = false                #是否强行gpt3.5进行验证
OpenAI_HOST = "chat.openai.com"    #openai网页api接口地址 （选填）
openai_api_host = "api.openai.com" #openai官方api接口 （选填）
proxy_pool_url=""                  #ipidea代理池链接 （选填）
#示例http://api.proxy.ipidea.io/getProxyIp?num=10&return_type=json&lb=1&sb=0&flow=1®ions=us&protocol=http，根据访问频次设置num值
log_level = "debug"                #日志等级

redis_address = "127.0.0.1:6379"   #redis地址（若不开启代理池可选填）
redis_passwd = ""                  #redis密码
redis_db = 0                       #选择的redis数据库
EOF

如果有 redis 需求，可以查阅官方文档：Redis

使用 pm2 管理运行：

1	pm2 start bash --name warpgpt -- start.sh

Coze-discord-proxy

代理 Discord 对话 Coze-Bot ，实现以 API 形式请求 GPT4 模型，提供对话、文生图、图生文、知识库检索等功能。功能不多赘述，详细去源仓库查看。

同样的，我写了一个用于构建 FreeBSD 版本的仓库。在这里感谢论坛用户 Reno 的测试，没有测试人员的测试，也不会有部署的过程记录了。

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Coze-discord-proxy 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着SSH登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

# 下载二进制文件
release_info=$(curl -s https://api.github.com/repos/k0baya/coze-discord-proxy-freebsd/releases/latest)
asset_url=$(echo "$release_info" | jq -r '.assets[] | select(.name != "source code") | .browser_download_url')
curl -L -o coze-discord-proxy "$asset_url" && chmod +x coze-discord-proxy

添加启动脚本：

cat > start.sh << EOF
#!/bin/bash
# 根据你的需求自行填入环境变量
export PORT="PORT"
export USER_AUTHORIZATION="XXXXXX"
export BOT_TOKEN="XXXXXX"
export GUILD_ID="XXXXXX"
export COZE_BOT_ID="XXXXXX"
export PROXY_SECRET="XXXXXX"
export CHANNEL_ID="XXXXXX"
export TZ="Asia/Shanghai"
export DATA_GYM_CACHE_DIR="$PWD"
chmod +x coze-discord-proxy && exec ./coze-discord-proxy
EOF

给启动脚本赋权：

1	chmod +x coze-discord-proxy

添加多机器人配置文件：

1 2	mkdir -p app/coze-discord-proxy/data/config touch app/coze-discord-proxy/data/config/bot_config.json

然后回到 Panel 中，进入File manager选项卡，进入 bot_config.json 所在路径，右键点击它，选择View/Edit > Source Editor，进行编辑：

[
  {
    "proxySecret": "123", // 接口请求密钥(PROXY_SECRET)(注意:此密钥在环境变量PROXY_SECRET中存在时该Bot才可以被匹配到!)
    "cozeBotId": "12***************31", // coze托管的机器人ID
    "model": ["gpt-3.5","gpt-3.5-16k"], // 模型名称(数组格式)(与请求参数中的model对应,如请求中的model在该json中未匹配到则会抛出异常)
    "channelId": "12***************56"  // [可选]discord频道ID(机器人必须在此频道所在的服务器)(目前版本下该参数仅用来活跃机器人)
  },
  {
    "proxySecret": "456",
    "cozeBotId": "12***************64",
    "model": ["gpt-4","gpt-4-16k"],
    "channelId": "12***************78"
  },
  {
    "proxySecret": "789",
    "cozeBotId": "12***************12",
    "model": ["dall-e-3"],
    "channelId": "12***************24"
  }
]

使用 pm2 管理运行：

1	pm2 start bash --name coze-discord-proxy -- start.sh

Memos

一款开源、轻量级的笔记服务。轻松捕捉并分享您的精彩想法。

这个仓库比较难受的是，其在源码的这个位置强制要求其 gRPC 服务的端口为 Memos 监听端口+1，故这个应用需要占用两个端口，而且必须是两个连续的端口。

同样的，我写了一个用于构建 FreeBSD 版本的仓库。

首先在 Panel 中放行两个相邻的端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	刚刚放行的两个相邻的端口中小的那一个
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着SSH登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

API_URL="https://api.github.com/repos/k0baya/memos-binary/releases/latest"
DOWNLOAD_URL=$(curl -s $API_URL | jq -r ".assets[] | select(.name == \"memos-freebsd-amd64.tar.gz\") | .browser_download_url")
curl -L $DOWNLOAD_URL -o memos-freebsd-amd64.tar.gz
tar -xzvf memos-freebsd-amd64.tar.gz && rm memos-freebsd-amd64.tar.gz && chmod +x memos

关于运行，有两种方式进行：

① SQLite

如果选择使用 SQLite 作为数据库运行，则可以直接运行：

# 假定你的数据文件打算存储在 /home/username/domains/xxx.USERNAME.serv00.net/public_html/data
# 新建数据文件夹
mkdir -p /home/username/domains/xxx.USERNAME.serv00.net/public_html/data
# 测试运行
./memos --mode prod --port PORT --data /home/username/domains/xxx.USERNAME.serv00.net/public_html/data
# 使用 pm2 管理
pm2 start ./memos --name memos -- --mode prod --port PORT --data /home/username/domains/xxx.USERNAME.serv00.net/public_html/data

② 外接 MySQL / PostgreSQL

你可以使用面板自带的 MySQL / PostgreSQL 新建数据库，或者使用其他平台提供的远程数据库：

# 假定你的数据文件打算存储在 /home/username/domains/xxx.USERNAME.serv00.net/public_html/data
# 新建数据文件夹
mkdir -p /home/username/domains/xxx.USERNAME.serv00.net/public_html/data
# 测试运行（MySQL）（MySQL需要管理员权限，你可以选择远程连接）
./memos --mode prod --port PORT --data /home/username/domains/xxx.USERNAME.serv00.net/public_html/data --driver mysql --dsn mysql://root:password123@localhost:3306/mydb
# 测试运行（PostgreSQL）
./memos --mode prod --port PORT --data /home/username/domains/xxx.USERNAME.serv00.net/public_html/data --driver postgres --dsn postgresql://user:password123@localhost:5432/mydb?sslmode=disable
# 使用 pm2 管理（MySQL）（MySQL需要管理员权限，你可以选择远程连接）
pm2 start ./memos --name memos -- --mode prod --port PORT --data /home/username/domains/xxx.USERNAME.serv00.net/public_html/data --driver mysql --dsn mysql://root:password123@localhost:3306/mydb
# 使用 pm2 管理（PostgreSQL）
pm2 start ./memos --name memos -- --mode prod --port PORT --data /home/username/domains/xxx.USERNAME.serv00.net/public_html/data --driver postgres --dsn postgresql://user:password123@localhost:5432/mydb?sslmode=disable

Frps

内网穿透嘛，懂的都懂，这里只做服务端的部署记录，客户端可以查看 Frp 的官方文档自行配置。感谢群友的率先测试：youyi

首先在 Panel 中放行两个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来映射转发内网服务的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

同样的，你可以设置多个域名使用 Proxy 指向同一个端口，在 Frpc 客户端配置中使用域名分发不同的服务。具体可以查阅官方文档。

接着SSH登入，并进入刚刚你新建的域名目录下的 public_html 路径下

release_info=$(curl -s https://api.github.com/repos/fatedier/frp/releases/latest)
download_url=$(echo "$release_info" | jq -r '.assets[] | select(.name | contains("freebsd_amd64.tar.gz")) | .browser_download_url')
curl -L "$download_url" -o frp_freebsd_amd64.tar.gz 
tar -xzvf frp_freebsd_amd64.tar.gz --strip-components=1
rm -rf frp_freebsd_amd64.tar.gz

接着编辑配置文件：

# 按照自己的实际情况和需求进行配置，这里只做最简单的http转发配置示例
cat > frps.toml << EOF
bindPort = 监听端口
vhostHTTPPort = 映射转发端口
auth.token = "密码"
EOF

运行：

1	pm2 start ./frps -- -c frps.toml

客户端配置示例：

serverAddr = "x.x.x.x"
serverPort = Frps 的监听端口
auth.token = "密码"

[[proxies]]
name = "web"
type = "http"
localPort = 80
customDomains = ["www.yourdomain.com"]

[[proxies]]
name = "web2"
type = "http"
localPort = 8080
customDomains = ["www.yourdomain2.com"]

Rclone

Rclone 是一款管理云存储文件的命令行程序。它功能丰富，可替代云供应商的网络存储界面。超过 70 种云存储产品支持 Rclone，包括 S3 对象存储、企业和消费者文件存储服务以及标准传输协议。

具体用法与配置请查阅其官方文档。

如果你需要使用 Rclone 的 web ui ，你可以按照前文所述的大多数应用一样，先放行端口，添加域名，申请好 SSL 证书，并进入其目录下的 public_html 路径下再进行程序本体的下载部署。

下载最新版 Rclone：

release_info=$(curl -s https://api.github.com/repos/rclone/rclone/releases/latest)
download_url=$(echo "$release_info" | jq -r '.assets[] | select(.name | contains("-freebsd-amd64.zip")) | .browser_download_url')
curl -L "$download_url" -o rclone-freebsd-amd64.zip
outer_folder=$(unzip -l rclone-freebsd-amd64.zip | grep '/' | sed -n '1p' | sed 's#^.* \([^/]*\)/.*$#\1#')
unzip rclone-freebsd-amd64.zip
mv "$outer_folder"/* . && rm -rf "$outer_folder" rclone-freebsd-amd64.zip

经我测试，目前 v1.63.1 之后的版本的 FreeBSD 版的构建都有无法识别 mount 命令的问题，在我查阅其 issue —— #7432 、 #5843 后，确定这个 bug 已经好几个月没有修复了。所以我建议在此 bug 修复前，使用 v1.63.1 版本。

下载 v1.63.1 版本 Rclone ：

curl -L https://github.com/rclone/rclone/releases/download/v1.63.1/rclone-v1.63.1-freebsd-amd64.zip -o rclone-freebsd-amd64.zip
outer_folder=$(unzip -l rclone-freebsd-amd64.zip | grep '/' | sed -n '1p' | sed 's#^.* \([^/]*\)/.*$#\1#')
unzip rclone-freebsd-amd64.zip
mv "$outer_folder"/* . && rm -rf "$outer_folder" rclone-freebsd-amd64.zip

配置 Rclone 的存储：

1	./rclone config

启动 web ui：

1	./rclone rcd --rc-web-gui --rc-user 用户名 --rc-pass 密码 --rc-addr :端口

pm2 管理 web ui：

1	pm2 start ./rclone -- rcd --rc-web-gui --rc-user 用户名 --rc-pass 密码 --rc-addr :端口

Cloudreve

Cloudreve 可助你即刻构建出兼备自用或公用的网盘服务，通过多种存储策略的支持、虚拟文件系统等特性实现灵活的文件管理体验。

同样的，我编写了一个用于自动化构建 FreeBSD 版本的 Cloudreve 的仓库：k0baya/cloudreve-freebsd 前后端分离构建，前端静态文件在 Cloudreve 本体同路径下的 static 文件夹内。

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 Cloudreve 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着SSH登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

release_info=$(curl -s https://api.github.com/repos/k0baya/cloudreve-freebsd/releases/latest)
download_url=$(echo "$release_info" | jq -r '.assets[] | select(.name | contains("freebsd-amd64.tar.gz")) | .browser_download_url')
curl -L "$download_url" -o cloudreve-freebsd-amd64.tar.gz 
tar -xzvf cloudreve-freebsd-amd64.tar.gz
rm -rf cloudreve-freebsd-amd64.tar.gz

Cloudreve 在首次启动时，会创建初始管理员账号，请注意保管管理员密码，此密码只会在首次启动时出现。如果您忘记初始管理员密码，需要删除同级目录下的 cloudreve.db ，重新启动主程序以初始化新的管理员账户。

Cloudreve 默认会监听 5212 端口。首次启动时，Cloudreve 会在同级目录下创建名为 conf.ini 的配置文件，你可以修改此文件进行一些参数的配置（比如端口），保存后需要重新启动 Cloudreve 生效。

一个完整的配置文件示例如下：

[System]
; 运行模式
Mode = master
; 监听端口
Listen = :5212
; 是否开启 Debug
Debug = false
; Session 密钥, 一般在首次启动时自动生成
SessionSecret = 23333
; Hash 加盐, 一般在首次启动时自动生成
HashIDSalt = something really hard to guss
; 呈递客户端 IP 时使用的 Header
ProxyHeader = X-Forwarded-For

; SSL 相关
[SSL]
; SSL 监听端口
Listen = :443
; 证书路径
CertPath = C:\Users\i\Documents\fullchain.pem
; 私钥路径
KeyPath = C:\Users\i\Documents\privkey.pem

; 启用 Unix Socket 监听
[UnixSocket]
Listen = /run/cloudreve/cloudreve.sock
; 设置产生的 socket 文件的权限
Perm = 0666

; 数据库相关，如果你只想使用内置的 SQLite 数据库，这一部分直接删去即可
[Database]
; 数据库类型，目前支持 sqlite/mysql/mssql/postgres
Type = mysql
; MySQL 端口
Port = 3306
; 用户名
User = root
; 密码
Password = root
; 数据库地址
Host = 127.0.0.1
; 数据库名称
Name = v3
; 数据表前缀
TablePrefix = cd_
; 字符集
Charset = utf8mb4
; SQLite 数据库文件路径
DBFile = cloudreve.db
; 进程退出前安全关闭数据库连接的缓冲时间
GracePeriod = 30
; 使用 Unix Socket 连接到数据库
UnixSocket = false

; 从机模式下的配置
[Slave]
; 通信密钥
Secret = 1234567891234567123456789123456712345678912345671234567891234567
; 回调请求超时时间 (s)
CallbackTimeout = 20
; 签名有效期
SignatureTTL = 60

; 跨域配置
[CORS]
AllowOrigins = *
AllowMethods = OPTIONS,GET,POST
AllowHeaders = *
AllowCredentials = false
SameSite = Default
Secure = lse

; Redis 相关
[Redis]
Server = 127.0.0.1:6379
Password =
DB = 0

; 从机配置覆盖
[OptionOverwrite]
; 可直接使用 `设置名称 = 值` 的格式覆盖
max_worker_num = 50

你可以使用 vim 或者 Panel 中的 File manager 选项卡，进入 conf.ini 所在路径路径，右键点击，选择 View/Edit > Source Editor ，进行编辑。

修改完配置文件后，测试启动：

1	./cloudreve

使用 pm2 管理：

1	pm2 start ./cloudreve

PanIndex

一个简易的网盘目录列表。

同样的，我编写了一个用于自动化构建 FreeBSD 版本的 PanIndex 的仓库：k0baya/panindex-freebsd。

后台地址（默认）：http://ip:port/admin
默认账号：admin
默认密码：PanIndex

首先在 Panel 中放行一个端口，接着按照下表 Add a New Website ：

Key	Value
Domain	`xxx.USERNAME.serv00.net`（也可以把原有的USERNAME.serv00.net删掉后重新添加）
Website Type	proxy
Proxy Target	localhost
Proxy URL	留空
Proxy port	你准备用来部署 PanIndex 的端口
Use HTPPS	False
DNS support	True

添加完新站点后，继续点击上方的 Manage SSL certificates ，接着在出口 IP 的右侧点击 Manage ，再点击 Add certificate ：

Type	Domain
Generate Let’s Encrypted certificate	与刚刚添加的站点域名保持一致（如果是原有的`USERNAME.serv00.net` ，可以省略此步）

接着SSH登入，并进入刚刚你新建的域名目录下的 public_html 路径下：

1
2
3

release_info=$(curl -s https://api.github.com/repos/k0baya/panindex-freebsd/releases/latest)
asset_url=$(echo "$release_info" | jq -r '.assets[] | select(.name != "source code") | .browser_download_url')
curl -L -o panindex "$asset_url" && chmod +x panindex

创建配置文件：

cat > config.json << EOF
{
  "host": "0.0.0.0",
  "port": 5238,
  "log_level": "info",
  "data_path": "",
  "cert_file": "",
  "key_file": "",
  "config_query": "",
  "db_type": "",
  "dsn": "",
  "ui": ""
}
EOF

数据库支持 sqlite (默认)、mysql、postgres ，如果需要接入 MySQL 或者 PostgreSQL ，请写成数据库链接的方式填入 dsn 。注意，如果是 Serv00 自带的 PostgreSQL ，请在数据库链接最末加上 ?sslmode=disable 以禁用 SSL 连接。

编写好配置文件后，测试运行：

1	./panindex -c=config.json

使用 pm2 管理：

1	pm2 start ./panindex -- -c=config.json

Artalk

似乎有几个群友在用这个，为方便查阅统一收录在本文，具体内容可以去群友的博客查看：

点击图片进入

收尾工作

听说 Serv00 会不定时重启机器，所以我们把 pm2 添加开机自启，可以保证每次重启都能由 pm2 调动 Alist 和 Cloudflared 。而且 Serv00 每三个月内必须要有一次登录面板或者 SSH 连接，不然会删号，也可以通过一个脚本解决问题，接下来我会详细说明。

自动续期

可以用青龙面板的自动任务定期登录SSH解决。在青龙面板中添加Linux依赖 sshpass，然后添加定时任务：名称随意，命令/脚本 sshpass -p '密码' ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -tt 用户名@地址 "exit"，定时规则 1 1 1 * *。这样就会每个月自动ssh连接一次，实现续期。

你还可以使用自身 SSH 自身的方式进行自动续期，操作如下：
进入一个自己喜欢的路径，使用 cat 命令新建 auto-renew.sh 脚本：
1
2
3
4
5
6
7
8
cat > auto-renew.sh << EOF
#!/bin/bash

while true; do
  sshpass -p '密码' ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -tt 用户名@地址 "exit" &
  sleep 259200  #30天为259200秒
done
EOF
记得把其中的密码、用户名、ssh的地址修改为你自己的。
给 auto-renew.sh添加可执行权限：
1
chmod +x auto-renew.sh
使用pm2启动：
1
pm2 start ./auto-renew.sh
这样就会每隔一个月自动执行一次SSH连接，自己SSH自己进行续期。

上述自动续期脚本，在当时写的时候，犯了两个错误：
第一是时间写错了，30 天不是 259200 秒，是 2592000 秒，经群友发现后，就成了一个防伪标志，因为本文在网络上大量被复制粘贴却不标明出处，让太多人赚了流量却不知道真正码字的是谁。抄袭可耻，这样的抄袭行为只会让真正有能力创作的人失去继续创作的热情。
第二是不应该在脚本内写成 while 循环配合 sleep 定时，这样导致大量的 sleep 进程把进程数占满而出现异常。正确的做法应该是：
使用下述命令新建 auto_renew.sh 脚本：
1
2
3
4
5
cat > auto_renew.sh << EOF
#!/bin/bash

sshpass -p '密码' ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -tt 用户名@地址 "exit" &
EOF
记得把其中的密码、用户名、ssh的地址修改为你自己的。
给 auto_renew.sh添加可执行权限：
1
chmod +x auto_renew.sh
再去 Panel 中找到 Cron jobs 选项卡，使用 Add cron job 功能添加任务，Specify time 选择 Monthly，Form type 选择 Advanced。Command 写 auto_renew.sh 脚本文件的绝对路径，如 /home/username/auto_renew.sh >/dev/null 2>&1 即可。

自动启动

听说 Serv00 的主机会不定时重启，所以需要添加自启任务。

在 Panel 中找到 Cron jobs 选项卡，使用 Add cron job 功能添加任务，Specify time 选择 After reboot，即为重启后运行。Form type 选择 Advanced，Command 写：

1	/home/你的用户名/.npm-global/bin/pm2 resurrect >/dev/null 2>&1 && /home/你的用户名/.npm-global/bin/pm2 restart all >/dev/null 2>&1

记得把你的用户名改为你的用户名

添加完之后，在 SSH 窗口保存 pm2 的当前任务列表快照：

pm2 save

这样每次 serv00 不定时重启任务时，都能自动调用 pm2 读取保存的任务列表快照，恢复任务列表。如果在保存了任务列表快照后又改变了任务 pm2 的任务列表，需要重新执行 pm2 save 以更新任务列表。

检测启动情况

由于自从 S2 开始的新的 Server 推出后屡屡出现使用 Cron Job 的 After reboot 无法恢复任务列表的情况，而过了好几个月也并没有人找到令人满意的解决方案，循环监控网页状态码并在出错时尝试拉起任务是可行的，只可惜我只看到了 Python 脚本，而此等简单的功能在我看来实在没必要使用 Python ，毕竟如果要在没有 Python 环境的情况下运行又成了一种麻烦，所以我决定通过 Shell 实现此功能。

#!/bin/bash

USERNAME=''
PASSWORD=''
SSH_ADDRESS=''
SERVER_ADDRESS=''
SMTP_SERVER_ADDRESS=''
SMTP_SERVER_PORT=''
SMTP_EMAIL=''
SMTP_PASSWORD=''
TARGET_EMAIL=''

check_health() {
    local CODE=$(curl -o /dev/null -s -w "%{http_code}\n" --connect-timeout 10 --max-time 30 ${SERVER_ADDRESS})
    if [ "$CODE" != "200" ]; then
        echo 'Server is down!'
        return 1
    fi
    return 0
}

send_mail() {
    if [ -n "${SMTP_SERVER_ADDRESS}" ] && [ -n "${SMTP_SERVER_PORT}" ] && [ -n "${SMTP_EMAIL}" ] && [ -n "${SMTP_PASSWORD}" ] && [ -n "${TARGET_EMAIL}" ]; then
        curl --ssl-reqd \
          --url "smtps://${SMTP_SERVER_ADDRESS}:${SMTP_SERVER_PORT}" \
          --user "${SMTP_EMAIL}:${SMTP_PASSWORD}" \
          --mail-from "${SMTP_EMAIL}" \
          --mail-rcpt "${TARGET_EMAIL}" \
          -T - <<EOF
From: ${SMTP_EMAIL}
To: ${TARGET_EMAIL}
Subject: ${EMAIL_TITLE}

${EMAIL_DATA}
EOF
    else
        echo 'Cancel send email due to missing or empty configuration.'
    fi
}

restart_server() {
    echo 'Trying to restart server...'
    local REMOTE_COMMAND1="/home/${USERNAME}/.npm-global/bin/pm2 resurrect && exit" \
    && sshpass -p "${PASSWORD}" ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -tt ${USERNAME}@${SSH_ADDRESS} "$(eval echo $REMOTE_COMMAND1)" \
    && local REMOTE_COMMAND2="/home/${USERNAME}/.npm-global/bin/pm2 restart all && exit" \
    && sshpass -p "${PASSWORD}" ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -tt ${USERNAME}@${SSH_ADDRESS} "$(eval echo $REMOTE_COMMAND2)" 
}

check_health
EXIT_CODE=$?
if [ ${EXIT_CODE} -eq 1 ]; then
    EMAIL_TITLE='Server is down!'
    EMAIL_DATA="${SERVER_ADDRESS} is down, trying to restart server..."
    send_mail

    while [ ${EXIT_CODE} -eq 1 ]; do
        restart_server
        sleep 120
        check_health
        EXIT_CODE=$?
    done

    if [ ${EXIT_CODE} -eq 0 ]; then
        EMAIL_TITLE='Server is up!'
        EMAIL_DATA="${SERVER_ADDRESS} has been restarted successfully."
        send_mail
    fi
fi

在脚本开头处填好所有的环境变量即可使用：

变量名	是否必须	备注
USERNAME	是	Serv00 的账户用户名
PASSWORD	是	Serv00 的账户密码
SSH_ADDRESS	是	Serv00 的账户 SSH 连接的地址（如`s4.serv00.com`）
SERVER_ADDRESS	是	需要检测的 Web 服务地址（如`https://xxx.username.serv00.net`）
SMTP_SERVER_ADDRESS	否	发送通知邮件的 SMTP 服务器地址（如`mail4.serv00.com`、`smtp.163.com`）
SMTP_SERVER_PORT	否	发送通知邮件的 SMTP 服务器端口，必须使用 SSL（如`465`、`995`）
SMTP_EMAIL	否	用于发送通知邮件的邮箱
SMTP_PASSWORD	否	用于发送通知邮件的邮箱的密码或秘钥
TARGET_EMAIL	否	用于接收通知邮件的邮箱

在你的用户目录下任意路径新建一个名为 check_health.sh 的文件，把上述脚本填好环境变量后粘贴进去，并在 Console 中使用 chmod +x check_health.sh 命令为脚本添加可执行权限。

再去 Panel 中找到 Cron jobs 选项卡，使用 Add cron job 功能添加任务，Specify time 选择 Special manually，Form type 选择 Advanced，然后把下方的 Minute、Hour、Day of month、Month、Day of week 都改成 Every ，然后在 Minute 后填入 5（即每 5 分钟一次），其他的都填 1。Command 写 check_health.sh 脚本文件的绝对路径，如 /home/username/check_health.sh >/dev/null 2>&1 即可。你也可以根据你的需求自由修改定时。

还有一个加入了循环的版本，有需求的可以移植到其他服务使用：

# 各功能函数与前文一致，主函数加入循环，只展示主函数部分
while true; do
    check_health
    EXIT_CODE=$?
    if [ ${EXIT_CODE} -eq 1 ]; then
        EMAIL_TITLE='Server is down!'
        EMAIL_DATA="${SERVER_ADDRESS} is down, trying to restart server..."
        send_mail

        while [ ${EXIT_CODE} -eq 1 ]; do
            restart_server
            sleep 120
            check_health
            EXIT_CODE=$?
        done

        if [ ${EXIT_CODE} -eq 0 ]; then
            EMAIL_TITLE='Server is up!'
            EMAIL_DATA="${SERVER_ADDRESS} has been restarted successfully."
            send_mail
        fi
    fi
    sleep 300
done

常用指令

# Enables the ability to run your own software
devil binexec on
# Set Devil and shell language to English
devil lang set english
# Get a list of all available IP addresses owned by Serv00.com
devil vhost list public
# Display the list of reserved ports
devil port list
# 伪重置（删除用户所有文件）
chmod -R 755 ~/*
chmod -R 755 ~/.*
rm -rf ~/*
rm -rf ~/.*
# 关闭用户所有进程
killall -u $(whoami)

欢迎进群讨论，一起学习探讨：受虐滑稽

CodeSandbox-Blog备份

2024-01-03T23:39:10.537Z

在CodeSandBox上部署docker并使用Cloudflare Tunnel打通自己的域名——以青龙面板为例

前言

长期以来白嫖Replit已经成为习惯，突然Replit的政策改变让人猝不及防。

虽然此前就已经知道了CodeSandBox这个平台，但苦于其公开性质，以及不可更换的会直接暴露公开容器的域名分配，一直以来对CodeSandBox的使用也是离不开Replit的——在CodeSandBox部署好服务之后，在Replit部署NGINX服务反代CodeSandBox提供的域名，一定程度上避免CodeSandBox容器的暴露。

那么Replit即将无法白嫖的现状下，怎么快乐的使用CodeSandBox呢？第一时间我想到的是Cloudflare的Workers。但是Workers对于免费用户来讲额度太少，就此浪费掉未免也太可惜，那怎么办呢？

虽说家中的软路由一直以来都使用Cloudflared打通Tunnel进行穿透，但是还得是fscarman2的各种PaaS平台搭建代理的仓库给了我灵感，可以在PaaS平台使用Cloudflared，像家里的软路由内网穿透一样，使用自己的域名。

经过我反复尝试，总算找到了在CodeSandBox上能够比较稳定搭建各种服务的办法。如果你会操作，也可以自行构筑各种镜像进行部署，只需要在 docker-compose.yaml文件末添加Cloudflared部分即可。

这里就以青龙面板为例，讲述一下CodeSandBox的白嫖方法。

部署过程

注册CodeSandBox

CodeSandBox支持Google、Github等多种方式登录，任意方式注册登录即可，这里不再赘述。

编写docker-compose文件

以青龙面板为例，在这里可以找到其docker-compose文件：

version: '2'
services:
  web:
    # alpine 基础镜像版本
    image: whyour/qinglong:latest
    # debian-slim 基础镜像版本
    # image: whyour/qinglong:debian  
    volumes:
      - ./data:/ql/data
    ports:
      - "0.0.0.0:5700:5700"
    environment:
      # 部署路径非必须，以斜杠开头和结尾，比如 /test/
      QlBaseUrl: '/'
    restart: unless-stopped

稍作修改：

version: '2'
services:
    qinglong:
      image: whyour/qinglong:latest
      volumes:
        - /project/sandbox/ql/data:/ql/data
      ports:
       - "0.0.0.0:5700:5700"
      environment:
        QlBaseUrl: '/'
      restart: always

主要修改了其 volumes的部分，因为CodeSandBox的文件目录在 /project/sandbox/下，所以我在此路径下创建 ./ql/data来存储青龙面板的数据，实现数据持久化。

而Cloudflared部分，我是这样写的：

cloudflared:
      restart: always
      network_mode: host
      environment:
          - TZ=Asia/Shanghai
      command: tunnel --edge-ip-version auto --protocol quic --heartbeat-interval 10s run --token [ARGO_TOKEN]
      container_name: cloudflared
      image: cloudflare/cloudflared:latest

其中的 [ARGO_TOKEN]要替换成自己的token，后文将附上详细教程。

所以整个 docker-compose.yaml的内容如下：

version: '2'
services:
    qinglong:
      image: whyour/qinglong:latest
      volumes:
        - /project/sandbox/ql/data:/ql/data
      ports:
       - "0.0.0.0:5700:5700"
      environment:
        QlBaseUrl: '/'
      restart: always

    cloudflared:
      restart: always
      network_mode: host
      environment:
          - TZ=Asia/Shanghai
      command: tunnel --edge-ip-version auto --protocol quic --heartbeat-interval 10s run --token [ARGO_TOKEN]
      container_name: cloudflared
      image: cloudflare/cloudflared:latest

获取[ARGO_TOKEN]

详见群晖套件：Cloudflare Tunnel 内网穿透中文教程支持DSM6、7。

此处需要的[ARGO_TOKEN]就是ey开头的那一串。

然后在Cloudflare中设置好相应的域名和本地端口对应，一般协议用http即可。像此处，按照我的 docker-compose.yaml来看，我应该映射5700端口，所以我填的是 0.0.0.0:5700。

创建Devbox

在CodeSandBox中进入dashboard，然后点击”Create a Devbox”

选择docker

进入Devbox之后，在左侧的文件管理EXPLORER中可以看到有 .codesandbox和 .devcontainer两个文件夹

先修改 .codesandbox中的 tasks.json文件，在 setupTasks中添加部署命令：

"setupTasks": [
    {
      "name": "Deploy",
      "command": "cd /project/sandbox/.devcontainer/ && docker compose up -d"
    }
  ],

然后在 .devcontainer文件夹下新建 docker-compose.yaml文件，把上述的 docker-compose.yaml内容全部复制进去。

最后点击左上角的方框打开菜单，选择”Restart Devbox”，等待容器重启后，你就可以看到青龙运行好了。再试一下刚刚在Cloudflare中映射的域名，也可以用了。

一些问题

不知道为什么，当我使用http2模式运行Cloudflared时，隧道断连后并不会重新连接，auto模式在quic模式断连后自动切换http2模式，再断连又会出现http2模式一样的问题。所以我只能指定其使用quic模式进行运行。原因未知，希望有人能找到原因。

然后，必须保持容器活跃，Cloudflared掉线后才会重连，为保证其活跃，得使用网站监控器监控CodeSandBox自带的映射域名，形同 https://t6a4m-8080.csb.app/的那个。至于网站监控器，Uptime-Kuma、cron-job、UptimeRobot之类的都行。

注意，有些PaaS平台（比如Glitch）已经禁止了自身服务器ip、公用网站监控器ip进行访问，所以上述的cron-job和UptimeRobot是否能行请自行测试，更加建议自己搭建Uptime-Kuma。

后话

在CodeSandBox上我已经尝试使用此方法部署了Alist、qinglong、Halo（本站就是）、Pandora_Next以及自己构筑的个别镜像等多个应用，尽数成功。可玩性还是很高的。

但是不得不提醒，这种方法只是避免了从域名上找到自己的容器而已，并不能确保自己的数据不会泄露，毕竟使用的是公共容器，请注意信息安全，不要存储私密信息，否则后果自负。

另，宣传一下QQ群：受虐滑稽

一些可以在CodeSandBox上配合Cloudflared使用的docker-compose

以下任何一个配置，如果不需要Cloudflared打隧道，就把cloudflared部分删掉。

另外，除了Cloudflared打隧道，现在有新的使用自己的域名的方法，详见仓库：k0baya/reserve-vercel。
现在已经将Cloudflared部分从各配置中删除，如有需要请自行添加：
1
2
3
4
5
6
7
8
9
10
version: '3.3'
services:
   cloudflared:
     restart: always
     network_mode: host
     environment:
         - TZ=Asia/Shanghai
     command: tunnel --edge-ip-version auto --protocol quic --heartbeat-interval 10s run --token [ARGO_TOKEN]
     container_name: cloudflared
     image: cloudflare/cloudflared:latest

Qinglong

映射5700端口

version: '2'
services:
    qinglong:
      image: whyour/qinglong:latest
      volumes:
        - /project/sandbox/ql/data:/ql/data
      ports:
       - "0.0.0.0:5700:5700"
      environment:
        QlBaseUrl: '/'
      restart: always

Alist

映射5244端口
如果需要使用Aria2实现离线下载，把第14行的 image指定的镜像更改为 xhofe/alist-aria2:main即可

version: '3.3'
services:
    alist:
        restart: always
        volumes:
            - '/project/sandbox/alist:/opt/alist/data'
        ports:
            - '5244:5244'
        environment:
            - PUID=0
            - PGID=0
            - UMASK=022
        container_name: alist
        image: 'xhofe/alist:latest'

Halo

映射8090端口

version: "3"
services:
  halo:
    image: halohub/halo:2.11
    container_name: halo
    restart: on-failure:3
    depends_on:
      halodb:
        condition: service_healthy
    networks:
      halo_network:
    volumes:
      - /project/sandbox/data/halo2:/root/.halo2
    ports:
      - "8090:8090"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8090/actuator/health/readiness"]
      interval: 30s
      timeout: 5s
      retries: 5
      start_period: 30s      
    command:
      - --spring.r2dbc.url=r2dbc:pool:postgresql://halodb/halo
      - --spring.r2dbc.username=halo
      # PostgreSQL 的密码，请保证与下方 POSTGRES_PASSWORD 的变量值一致。
      - --spring.r2dbc.password=12345678
      - --spring.sql.init.platform=postgresql
      # 外部访问地址，请根据实际需要修改
      - --halo.external-url=http://localhost:8090/
  
  halodb:
    image: postgres:15.4
    container_name: halodb
    restart: on-failure:3
    networks:
      halo_network:
    volumes:
      - /project/sandbox/data/db:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    healthcheck:
      test: [ "CMD", "pg_isready" ]
      interval: 10s
      timeout: 5s
      retries: 5
    environment:
      - POSTGRES_PASSWORD=12345678
      - POSTGRES_USER=halo
      - POSTGRES_DB=halo
      - PGUSER=halo

networks:
  halo_network:

Microsoft_365_E5_RenewX

映射端口1066

version: '3.5'
services:
  renewx:
    image: gladtbam/ms365_e5_renewx:latest
    container_name: renewx
    environment:
      - TZ=Asia/Shanghai
    volumes:
      - /project/sandbox/E5RenewX/Deploy:/renewx/Deploy
      - /project/sandbox/E5RenewX/Appdata:/renewx/appdata
    ports:
      - "1066:1066"
    restart: unless-stopped

需要新建 Config.xml文件放在 Deploy内，默认的 Config.xml文件内容如下：






1066

12345678

true





https://beian.miit.gov.cn




https://cdn.staticfile.org/bootstrap/5.1.3/css/bootstrap.min.css

https://cdn.staticfile.org/bootstrap/5.1.3/js/bootstrap.bundle.min.js





false









false









587

true






true








true









false







1

30

Pandora-Next

映射端口8181

version: '3.3'
services:
    pandora-next:
        image: pengzhile/pandora-next
        container_name: PandoraNext
        network_mode: bridge
        restart: always
        ports:
            - "8181:8181"
        volumes:
            - /project/sandbox/pandora-next/data:/data
            - /project/sandbox/pandora-next/sessions:/root/.cache/PandoraNext

Uptime-Kuma

映射端口3001

version: '3.8'
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    volumes:
      - /project/sandbox/uptimekuma:/app/data
    ports:
      - "3001:3001"  # :
    restart: always

KodBox

映射端口8080

version: '3.5'
services:
  db:
    image: mariadb
    command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW
    volumes:
      - "/project/sandbox/db:/var/lib/mysql"   
    environment:
      - "TZ=Asia/Shanghai"
      - "MYSQL_ROOT_PASSWORD=jiehdo!25165n"
      - "MYSQL_DATABASE=kodbox"
      - "MYSQL_USER=bodbox"
      - "MYSQL_PASSWORD=jiehdo!25165n"
    restart: always
  
  app:
    image: kodcloud/kodbox
    ports:
      - 8080:80                
    links:
      - db
      - redis
    volumes:
      - "/project/sandbox/site:/var/www/html"  
    restart: always

  redis:
    image: redis:alpine
    environment:
      - "TZ=Asia/Shanghai"
    restart: always

如果照搬上面的设置，初始化时数据库和redis的设置应该如图填写
数据库类型：MySQL
服务器：db
用户名：root
密码：jiehdo!25165n
数据库：kodbox
存储引擎：InnoDB
系统缓存类型：Redis
服务器：redis

Zfile

映射端口8080

version: '3.3'
services:
    zfile:
        container_name: zfile
        restart: always
        ports:
            - '8080:8080'
        volumes:
            - '/project/sandbox/zfile/db:/root/.zfile-v4/db'
            - '/project/sandbox/zfile/logs:/root/.zfile-v4/logs'
            - '/project/sandbox/zfile/file:/data/file'
        image: zhaojun1998/zfile

PanIndex

映射端口5238

version: '3.3'
services:
    panindex:
        container_name: panindex
        restart: always
        ports:
            - '5238:5238'
        volumes:
            - '/project/sandbox/PanIndex/data:/app/data'
        environment:
            - "PORT=5238"
        image: iicm/pan-index:latest

ShareList

映射端口33001

version: '3.3'
services:
    sharelist:
        container_name: sharelist
        restart: always
        ports:
            - '33001:33001'
        volumes:
            - '/project/sandbox/sharelist:/sharelist/cache'
        image: reruin/sharelist:next

Cloudreve

映射端口5212
进入容器需要先手动创建几个文件，在Terminal中输入以下指令即可：
1
2
3
4
5
6
7
mkdir -p cloudreve && cd cloudreve \
&& mkdir -vp cloudreve/{uploads,avatar} \
&& touch cloudreve/conf.ini \
&& touch cloudreve/cloudreve.db \
&& mkdir -p aria2/config \
&& mkdir -p data/aria2 \
&& chmod -R 777 data/aria2

version: "3.8"
services:
  cloudreve:
    container_name: cloudreve
    image: cloudreve/cloudreve:latest
    restart: unless-stopped
    ports:
      - "5212:5212"
    volumes:
      - /project/sandbox/cloudreve/data:/data
      - /project/sandbox/cloudreve/cloudreve/uploads:/cloudreve/uploads
      - /project/sandbox/cloudreve/cloudreve/conf.ini:/cloudreve/conf.ini
      - /project/sandbox/cloudreve/cloudreve/cloudreve.db:/cloudreve/cloudreve.db
      - /project/sandbox/cloudreve/cloudreve/avatar:/cloudreve/avatar
    depends_on:
      - aria2
  aria2:
    container_name: aria2
    image: p3terx/aria2-pro
    restart: unless-stopped
    environment:
      - RPC_SECRET=jif1568dw87
      - RPC_PORT=6800
    volumes:
      - /project/sandbox/cloudreve/aria2/config:/config
      - /project/sandbox/cloudreve/data:/data

Aria2的token默认为 jif1568dw87，如有需要自行修改
初始账号和密码，请在Terminal中输入命令 docker logs cloudreve后在日志中查找。

Typecho

映射端口8080

version: '3.7'
services:
  typecho:
    image: joyqi/typecho:nightly-php7.4-apache
    container_name: typecho-server
    restart: always
    environment:
      - TIMEZONE=Asia/Shanghai
    ports:
      - 8080:80
    volumes:
      - /project/sandbox/typecho:/app/usr
    depends_on:
      - mariadb

  mariadb:
    image: mariadb
    container_name: mariadb
    command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW
    volumes:
      - "/project/sandbox/db:/var/lib/mysql"   
    environment:
      - "TZ=Asia/Shanghai"
      - "MYSQL_ROOT_PASSWORD=jiehdo!25165n"
      - "MYSQL_DATABASE=typecho"
      - "MYSQL_USER=typecho"
      - "MYSQL_PASSWORD=jiehdo!25165n"
    restart: always

如果照搬此docker-compose.yaml，初始设置数据库时应该如此填写：
数据库适配器：Mysql 原生函数适配器
数据库前缀：typecho_
数据库地址：mariadb
数据库用户名：root
数据库密码：jiehdo!25165n
数据库名：typecho

Baota_Panel

端口8888为面板，2022为SSH端口，2021为FTP端口，2080和2443为网页服务预留端口，2888是官方给的，不知道作用。

version: '3'
services:
  baota:
    image: gettionhub/baota-docker:ltd
    container_name: baota
    volumes:
      - /project/sandbox/www/website_data:/www/wwwroot 
      - /project/sandbox/www/mysql_data:/www/server/data
      - /project/sandbox/www/vhost:/www/server/panel/vhost 
    ports:
      - "8888:8888"
      - "2022:22"
      - "2021:21"
      - "2443:443"
      - "2080:80"
      - "2888:888"
    restart: unless-stopped

面板入口为8888端口的那个网址后面加上 /baota，形同 https://t6a4m-8888.csb.app/baota。
初始用户名、密码都为baota
容器内root用户的ssh密码也是baota

WordPress

映射端口8080

version: '3.1'
services:
  wordpress:
    image: wordpress
    restart: always
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: exampleuser
      WORDPRESS_DB_PASSWORD: examplepass
      WORDPRESS_DB_NAME: exampledb
    volumes:
      - /project/sandbox/wordpree/app:/var/www/html

  db:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_DATABASE: exampledb
      MYSQL_USER: exampleuser
      MYSQL_PASSWORD: examplepass
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - /project/sandbox/wordpree/db:/var/lib/mysql

Memos

映射端口5230

version: "3.0"
services:
  memos:
    image: neosmemo/memos:latest
    container_name: memos
    volumes:
      - /project/sandbox/memos/:/var/opt/memos
    ports:
      - 5230:5230

Ghost

映射端口8080
首次启动会反复重启几次等待数据库创建文件，是正常的。

version: '3.1'
services:
  ghost:
    image: ghost:4-alpine
    restart: always
    ports:
      - 8080:2368
    environment:
      database__client: mysql
      database__connection__host: db
      database__connection__user: root
      database__connection__password: example
      database__connection__database: ghost
      url: http://localhost:8080
    volumes:
      - /project/sandbox/ghost/app:/var/lib/ghost/content

  db:
    image: mysql:8.0
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: example
    volumes:
      - /project/sandbox/ghost/db:/var/lib/mysql

NGINX-ui

面板端口为8080。网页服务端口预留为8443。

version: '3.3'
services:
    nginx-ui:
        stdin_open: true
        tty: true
        container_name: nginx-ui
        restart: always
        environment:
            - TZ=Asia/Shanghai
        volumes:
            - '/project/sandbox/appdata/nginx:/etc/nginx'
            - '/project/sandbox/appdata/nginx-ui:/etc/nginx-ui'
            - '/project/sandbox/www:/var/www'
        ports:
            - 8080:80
            - 8443:443
        image: 'uozi/nginx-ui:latest'

继续补充ing……

在CodeSandBox中部署其他应用——以小雅为例

对小雅容器的一些分析

相信部署过小雅的朋友都一直苦恼于小雅的更新频繁，以及阿里网盘更新后的容量限制，给日常观影带来了很不好的体验。随着xiaoyakeeper的诞生，才迎来了转机——自动更新容器+自动清理转存文件，解决了小雅日常使用的痛点。

但是，不论是小雅本身还是xiaoyakeeper，其部署方式都是一键式的脚本，而且部署方式限制的死死的——指定了端口、挂载卷等应该容许自定义的参数，使得其难以部署在各种PaaS平台上。

此前我曾有过最简单的把小雅部署在PaaS平台上的方法构思——基于小雅原镜像进行修改。直接查看小雅的一键部署脚本不难发现，是通过提前创建 /etc/xiaoya路径，再把需要使用到的各项token、id等参数储存为TXT文本文件，放入 /etc/xiaoya后，使用 volume挂载进容器的 /data路径进行读取的。所以只要在原有镜像上进行修改，准备好自己的这些token、id后，将其全部复制到小雅镜像的/data路径,就应当可以在不使用volume挂载的情况下直接部署一个能够正常使用的小雅容器。

但是，首先这个方案比起一键脚本操作复杂太多，而且在我仔细查看了xiaoyakeeper的脚本后，我发现这样操作会使得xiaoyakeeper无法读取docker命令的 -v项，就需要对xiaoyakeeper的脚本进行修改了。但是xiaoyakeeper的脚本又自带自动更新功能，如果一个更新覆盖了我的修改，又不得偿失；如果删掉自动更新的功能，那么如果阿里网盘的政策出现了改变，还得重新手动修改最新的xiaoyakeeper脚本进行替换，难以做到一劳永逸。

通过观察xiaoyakeeper的脚本内容，其更新小雅容器的方法并不是运行小雅的一键更新脚本，而是读取当前小雅容器的各项参数之后，重新进行 docker pull、docker run，也就是说，小雅容器被安装好之后，通过xiaoyakeeper进行更新就能完全摆脱小雅一键脚本。而且，如果小雅容器没有被启动的话，xiaoyakeeper运行之后就会直接启动小雅容器。

对CodeSandBox的分析

摸索暂时比较少，Devbox（Docker）大概理解为一个 Ubuntu为底的，zsh为默认shell执行器的，有root权限的，预装了Docker的虚拟机。在 /project/sandbox/路径下的文件，即便重启也不会丢失。

在CodeSandBox上部署小雅、xiaoyakeeper、Cloudflared

部署小雅

通过上述的分析，不难得出，可以修改小雅的一键部署脚本，然后直接在CodeSandBox的Devbox的Terminal中运行部署脚本，以将小雅部署到CodeSandBox上。小雅的一键脚本功能很简答，无非就是要求你输入 token、opentoken、folder_id，然后把他们储存在一个路径，再 Docker run，把这个路径挂载进容器。基本上不需要什么修改，唯一需要修改的就是把创建文件和挂载卷的路径改成在CodeSandBox中能够永久储存的路径，操作如下：

下载小雅的部署脚本并替换其中的路径然后执行

在Terminal中运行以下命令：

1	wget -O update.sh http://docker.xiaoya.pro/update_new.sh && sed -i 's\|/etc/xiaoya\|/project/sandbox/xiaoya\|g' update.sh && chmod +x update.sh && bash update.sh && rm update.sh

按照提示输入各种要求的变量即可。运行完毕后可以看到右侧弹窗窗口中对应5678端口的那个就是小雅了。

注意，如果你遇到了运行后小雅路径下内没有 mytoken.txt、myopentoken.txt、temp_transfer_folder_id.txt，请不要一个劲重试浪费时间，自己把这三个文件建好并填入应有的内容再放入xiaoya路径下即可。小雅的配置文档中本身就有好几个文件需要手动建立并填入内容。

部署xiaoyakeeper

经我尝试，xiaoyakeeper部署在CodeSandBox上，如果使用Docker模式，会有很多问题，大概与CodeSandBox的 docker.sock配置有关，所以只能使用模式0：

1	bash -c "$(curl -s https://xiaoyahelper.zengge99.eu.org/aliyun_clear.sh \| tail -n +2)" -s 0 -tg

如果需要TG推送，先把上述命令在Terminal中运行一遍，会要求接入TG推送，按照要求操作即可。接入完成后使用 Ctrl+c结束脚本。

如果你不需要TG推送，或者已经运行了刚刚的命令接入了TG，那么就在左侧文件中新建一个名为”clear.sh”的文件，把上述命令最后的 -tg参数删除，粘贴进去，即为：

1	bash -c "$(curl -s https://xiaoyahelper.zengge99.eu.org/aliyun_clear.sh \| tail -n +2)" -s 0

然后把执行这个脚本添加进容器启动时的任务中，即修改 .codesandbox下的 tasks.json中的 tasks部分：

"tasks": {
    "xiaoyakeeper": {
      "name": "aliyun_clear",
      "command": "bash /project/sandbox/clear.sh",
      "runAtStart": true
    }
  }

这样，当Devbox启动时，xiaoyakeeper就会启动，而xiaoyakeeper启动时就会启动小雅容器。

部署Cloudflared

如果你就个人使用，实际上没有必要加Cloudflared了，只要 .csb.app的域名和容器名不泄露，就和使用Cloudflared加自己的域名也没太大区别。

这里就简单偷个懒，虽然也可以直接运行Cloudflared客户端解决，但是可以用docker，而且又早都写好了 docker-compose.yaml，那就继续用docker-compose部署吧：

version: '3'
services:

    cloudflared:
      restart: always
      network_mode: host
      environment:
          - TZ=Asia/Shanghai
      command: tunnel --edge-ip-version auto --protocol quic --heartbeat-interval 10s run --token [ARGO_TOKEN]
      container_name: cloudflared
      image: cloudflare/cloudflared:latest

docker-compose.yaml文件放在.devcontainer路径下，详细的设置请参考之前写的文章。

这里依旧是修改 .codesandbox下的 tasks.json文件进行启动，加上启动xiaoyakeeper的修改，最终的的 task.json为：

{
  // These tasks will run in order when initializing your CodeSandbox project.
  "setupTasks": [
    {
      "name": "Deploy",
      "command": "cd /project/sandbox/.devcontainer/ && docker compose up -d"
    }
  ],

  // These tasks can be run from CodeSandbox. Running one will open a log in the app.
  "tasks": {
    "xiaoyakeeper": {
      "name": "aliyun_clear",
      "command": "bash /project/sandbox/clear.sh",
      "runAtStart": true
    }
  }
}

注意，只有5678端口需要映射出来，另外两个端口是配合一些TV软件使用，这里用不上。如果你确实有需求且自己会配置，请自行研究，这里不做探讨。

到这里就全部部署完成了，只需要Restart Devbox检查一下是否正常运行即可。

附上Cloudflared的可执行文件使用命令行直接建立Tunnel的命令：

1	./cloudflared tunnel --edge-ip-version auto --protocol quic --heartbeat-interval 10s run --token [ARGO_TOKEN]

其他应用的部署

通过以上的捣鼓可以发现，.codesandbox下的 tasks.json文件实际上与Replit的 replit.nix和 .replit两个文件的功能相近。

在 setupTasks部分中你可以使用 apt-get install、npm install或者 pip install等命令进行软件包的安装，亦或者其他的部署指令。

在 tasks部分你可以添加一些快捷命令，需要在启动时自动运行的，就把 runAtStart设置为 true即可。

上述命令，无论是 setupTasks还是 tasks，都是在Terminal中直接运行的命令，区别是，如果 setupTasks没有执行完，Devbox不会启动，而 tasks只有在启动完成之后才能执行。

那么就可以很简单的把Replit上之前部署的应用搬到CodeSandBox上了，replit.nix里需要的软件包，就去 setupTasks添加命令安装，.replit里定义的 Run的行为，添加到 tasks里去，并且把 runAtStart设置为 true，其他的文件照搬一下，原本使用 ${REPL_SLUG}、${REPL_OWNER}之类的变量确定的文件路径，统一修改为 /project/sandbox/下的任意路径即可。

当然不建议直接照搬，因为CodeSandBox配置比Replit高不少而且支持docker，这里建议能用docker的都用docker部署，源仓库不提供用docker部署的，写dockerfile构筑docker部署。实在不会用docker，再考虑这样的照搬或者直接运行的方法。

在CodeSandBox中使用Mirai-Console-Loader

刚好发现了ttyd和filebrowser两款神器，感觉使用这两个工具就可以愉快便利的在CodeSandBox上使用Mirai-Console-Loader，遂试了一下，果然可行，记录一下部署过程。

部署过程

下载Mirai-Console-Loader

Terminal中运行一行命令解决：

1	wget -O mcl.zip https://github.com/iTXTech/mirai-console-loader/releases/download/v2.1.2/mcl-2.1.2.zip && unzip -o mcl.zip && rm mcl.zip && chmod +x mcl

如果和我一样有强迫症，看着时区不对很烦，毕竟CodeSandBox的服务器并不在UTC+8区，所以通过手动修改其启动脚本，即名为 mcl的那个文件，在执行jar包的命令前添加时区参数，即把最后一行改成：

1	$JAVA_BINARY -jar -Duser.timezone=Asia/Shanghai mcl.jar $*

修改Devbox的启动任务

修改 .codesandbox路径下的 tasks.json文件，添加软件包的安装与所需工具的下载与运行命令，修改后的 tasks.json文件如下：

{
  // These tasks will run in order when initializing your CodeSandbox project.
  "setupTasks": [
    {
      "name": "Installing java",
      "command": "apt-get update && echo | apt-get install openjdk-21-jre"
    },
    {
      "name": "Downloading ttyd",
      "command": "mkdir -p /project/sandbox/ttyd && cd /project/sandbox/ttyd && wget -O ttyd https://github.com/tsl0922/ttyd/releases/download/1.7.4/ttyd.x86_64 && chmod +x ttyd"
    },
    {
      "name": "Downloading filebrowser",
      "command": "mkdir -p /project/sandbox/filebrowser && cd /project/sandbox/filebrowser && wget -O filebrowser.tar.gz https://github.com/filebrowser/filebrowser/releases/download/v2.26.0/linux-amd64-filebrowser.tar.gz && tar -xzvf filebrowser.tar.gz && chmod +x filebrowser && rm -f filebrowser.tar.gz"
    },
    {
      "name": "Downloading Cloudflared",
      "command": "wget -O cloudflared https://github.com/cloudflare/cloudflared/releases/download/2023.10.0/cloudflared-linux-amd64 && chmod +x cloudflared"
    }
  ],

  // These tasks can be run from CodeSandbox. Running one will open a log in the app.
  "tasks": {
    "ttyd": {
      "name": "ttyd",
      // 在21022端口打开ttyd终端，用户名为admin，密码为password，可以自行修改。
      "command": "./ttyd/ttyd -p 21022 -c admin:password -W zsh",
      "runAtStart": true
    },
    "filebrowser": {
      "name": "filebrowser",
      // 在21021端口打开filebrowser，默认用户名和密码都为admin，登入后请自行在设置中修改用户名和密码，确保安全。
      "command": "./filebrowser/filebrowser -p 21021",
      "runAtStart": true
    },
    "Cloudflared": {
      "name": "Cloudflared",
      // 运行Cloudflare Tunnels，请把最后的[ARGO_TOKEN]替换成自己的。
      "command": "./cloudflared tunnel --edge-ip-version auto --protocol quic --heartbeat-interval 10s run --token [ARGO_TOKEN]",
      "runAtStart": true
    }
  }
}

请不要直接复制粘贴，务必看一眼我写的批注，改成自己的信息后再复制粘贴。接着Restart Devbox，等待重启完毕即可。

记得在Cloudflare面板里设置相应的端口对应，这里我使用的是21021和21022两个端口。

接着打开自己映射的域名，输入自己设置的用户名和密码即可开始畅玩。

后话

Mirai-Console-Loader是目前最为成熟的QQ机器人使用方法之一了，其插件生态之完善带来了很高的可玩性，不论是之前部署的ChatGPT机器人、New Bing机器人，在Mirai-Console-Loader中基本都有相应的插件实现。也是得益于CodeSandBox比起Replit更为强大的机能，才使得Mirai-Console-Loader能够在平台上流畅的运行。

关于Mirai-Console-Loader的使用方法、插件安装、登录问题等，其官方文档和论坛也已经记录的非常详细了，这里不多作讨论，只说这一点：

我大概尝试发现的可行的登录方法就是在本地电脑也安装一个Mirai-Console-Loader，通过手表协议扫码登录之后能够获得一个登录记录的文件夹，把整个文件夹上传到CodeSandBox上的相应位置即可。原理和go-cqhttp通过上传 session.token文件进行登录是类似的。

讨论群：738386033

在CodeSandBox上搭建代理服务器

使用的是3Kmfi6HP/nodejs-proxy这个仓库。

部署方法

新建Node.js为Template的Devbox，然后使用以下 tasks.json的内容覆盖原本的 tasks.json：

{
  // These tasks will run in order when initializing your CodeSandbox project.
  "setupTasks": [
    {
      "name": "Install Dependencies",
      "command": "npm i -g @3kmfi6hp/nodejs-proxy"
    }
  ],
  // These tasks can be run from CodeSandbox. Running one will open a log in the app.
  "tasks": {
    "dev": {
      "name": "Start Dev Server",
      "command": "npx @3kmfi6hp/nodejs-proxy",
      "runAtStart": true,
      "preview": {
        "port": 7860
      },
      "restartOn": {
        "files": ["./package-lock.json"]
      }
    }
  }
}

然后Restart Devbox，等待网页弹出即可。

使用注意

有个Bug，实际端口应该是443而不是80，所以要在导出的代理配置中把服务端口从80改为443才能正常连接，不然连不上。

在CodeSandBox上模拟健康码

仓库是health-code-simulator。

听说健康码要回来了，咱提前做好准备，有备无患。

部署流程

下载源码

新建Template为Node.js的Devbox。在Terminal中输入以下命令把源码下载到Devbox中：

wget -O repo.zip https://codeberg.org/mito/health-code-simulator/archive/main.zip && unzip repo.zip && rm repo.zip && mv -b health-code-simulator/* ./ && mv -b health-code-simulator/.[^.]* ./ && rm -rf *~ && rm -rf health-code-simulator

修改启动任务

修改.codesandbox路径下的tasks.json文件，加入依赖安装和启动的任务：

{
  // These tasks will run in order when initializing your CodeSandbox project.
  "setupTasks": [
    {
      "name": "Install Dependencies",
      "command": "npm install"
    },
    {
      "name": "Building",
      "command": "npm build"
    }
  ],

  // These tasks can be run from CodeSandbox. Running one will open a log in the app.
  "tasks": {
    "start": {
      "name": "start",
      "command": "node build.mjs --serve",
      "runAtStart": true
    }
  }
}

接着Restart Devbox即可。

在一个容器内同时运行PandoraNext和TokensTool

在ChatGPT的辅助下，我写了一个Dockerfile，用以构筑PandoraNext和TokensTool二合一的镜像。

该Dockerfile在构筑时会自动从PandoraNext和TokensTool的release中检测最新且符合当前系统架构的版本进行下载，省去了很多麻烦。

FROM debian:11.8-slim

WORKDIR /app

# 安装所需的工具
RUN apt-get update && apt-get install -y openjdk-11-jdk curl jq && rm -rf /var/lib/apt/lists/*

# 下载 PandoraNext 的最新版本
FROM debian:11.8-slim

WORKDIR /app

# 安装所需的工具
RUN apt-get update && apt-get install -y openjdk-11-jdk curl jq wget && rm -rf /var/lib/apt/lists/*

# 下载 PandoraNext 的最新版本
RUN ARCH=$(dpkg --print-architecture) && \
    VERSION=$(curl -s https://api.github.com/repos/pandora-next/deploy/releases/latest | jq -r ".tag_name") && \
    DOWNLOAD_URL=$(curl -s https://api.github.com/repos/pandora-next/deploy/releases/latest | jq -r ".assets[] | select(.name | contains(\"linux-${ARCH}\")) | .browser_download_url") && \
    curl -sL ${DOWNLOAD_URL} -o pandoranext.tar.gz && \
    tar -xzf pandoranext.tar.gz --strip-components=1 && \
    chmod +x /app/PandoraNext && \
    rm pandoranext.tar.gz tokens.json config.json

# 下载 PandoraNext-TokensTool 的最新版本
RUN JAR_URL=$(curl -s https://api.github.com/repos/Yanyutin753/PandoraNext-TokensTool/contents/simplyDeploy?ref=main | \
    jq -r ".[] | select(.name | endswith(\".jar\")) | .download_url"); \
    echo "Download URL: $JAR_URL"; \
    wget -O tokenstool.jar "$JAR_URL"

# 创建一个脚本来同时运行 PandoraNext 和 tokenstool.jar，并处理配置文件
RUN echo '#!/bin/sh\nln -sf /data/config.json /app/config.json\nln -sf /data/tokens.json /app/tokens.json\njava -jar tokenstool.jar --server.port=8081 --deployWay=releases --deployPosition=/app --hotReload=true --pandora_Ip=127.0.0.1 &\nsleep 10\n./PandoraNext' > start.sh && \
    chmod +x start.sh

EXPOSE 8081 8181

ENTRYPOINT ["/app/start.sh"]

使用方法——以CodeSandBox为例

构筑镜像

在DevBox中新建一个Dockerfile，并且把上述内容粘贴进去。接着在Terminal中输入命令：

1	docker build -t pandoranext:latest .

运行容器

准备好已经填好的 config.json和 tokens.json（TokensTool.json可以先不修改，之后在TokensTool提供的页面内进行操作也可以。），新建一个名为 pandora的文件，将这两个文件放入其中。

接着新建 docker-compose.yaml文件，并填入以下内容：

version: '3.3'
services:
    pandora-next:
        image: pandoranext:latest
        container_name: PandoraNext
        network_mode: bridge
        restart: always
        ports:
            - "8181:8181"
            - "8081:8081"
        volumes:
            - /project/sandbox/pandora:/data
            - /project/sandbox/sessions:/root/.cache/PandoraNext

再去Terminal中执行命令：

1	docker compose up -d

容器即可完成启动。

使用我构筑的镜像

如果你嫌麻烦，也可以直接使用我构筑的镜像，省去自己构筑的时间。同理，新建pandora文件夹后放入已经填好的 config.json和 tokens.json文件，然后把 docker-compose.yaml的内容改成如下内容：

version: '3.3'
services:
    pandora-next:
        image: saika2077/pandoranext:latest
        container_name: PandoraNext
        network_mode: bridge
        restart: always
        ports:
            - "8181:8181"
            - "8081:8081"
        volumes:
            - /project/sandbox/pandora:/data
            - /project/sandbox/sessions:/root/.cache/PandoraNext

然后直接 docker compose up -d即可。我构筑的镜像截止到这篇博客成文为止，PandoraNext的版本号为 0.5.2，TokensTool的版本号为 0.4.8.2。

注意事项

该容器的使用注意事项与上一篇博客是完全一样的，只是更新方式发生了改变。如果你是自己构筑的方式使用的，docker compose down然后执行 docker build --no-cache -t pandoranext:latest .再 docker compose up -d即可。如果你使用的是我构筑的镜像，在我的镜像更新后，你只需要 docker compose down && docker compose pull && docker compose up -d即可完成升级。

Hax免费VPS的使用记录

2023-12-31T05:07:58.940Z

前些日子申请了一台Hax的IPv6_only的VPS，本来只搭了一个hysteria2协议的代理，因为只能使用IPv6连入，基本处于放置不用的状态，但是看到后来大家都开始抢注册，又舍不得把机器放出，于是一直在续期。

近些天，在这台机器上部署了一些应用，感觉用起来还比较舒服，于是做个记录。

一些常用程序包的安装

我选择的是Debian11的系统，因为免费的VPS只有1500MB的内存，为了尽可能部署更多的服务，我没有选择安装Docker。与之相对应，我安装了Python和Node.js还有OpenJDK，以便运行目前和之后我需要部署在VPS上的服务。

现得知，由于Hax目前使用的OpenVZ虚拟化技术的原因，docker相关功能无法使用，所以只能使用手动部署的方式对应用进行部署。

前置需求：
因为Hax只有IPv6网络，甚至于有时dns服务器的默认设置是一个IPv4地址，根本无法解析，需要先配置使用DNS64才能正常联网。配置DNS64可以使用此命令：
1
echo "nameserver   2a01:4f9:c010:3f02::1" > /etc/resolv.conf
然后再使用fscarmen大佬的Warp脚本：
1
wget -N https://gitlab.com/fscarmen/warp/-/raw/main/menu.sh && bash menu.sh
即可获得Cloudflare提供的IPv4地址，正常访问IPv4的网络资源。
另外，可以在Warp+ bot处生成Warp+的秘钥，提升Warp的网络速度。

Python

我就是喜欢追新，所以这里我没有直接使用 apt-get安装Python，而是选择了编译安装目前最新的Release版本——Python-3.12.1。编译安装并不难，只是略微有些慢：

先安装一些环境依赖：

apt-get update && apt-get install build-essential gdb lcov pkg-config libbz2-dev libffi-dev libgdbm-dev libgdbm-compat-dev liblzma-dev libncurses5-dev libreadline6-dev libsqlite3-dev libssl-dev lzma lzma-dev tk-dev uuid-dev zlib1g-dev

接着编译安装Python：

cd /usr/local          #进入/usr/local路径
mkdir -p soft && mkdir -p source          #创建soft、source路径
cd source && wget https://www.python.org/ftp/python/3.12.1/Python-3.12.1.tgz          #进入source路径并下载Python-3.12.1源码
tar -xzvf Python-3.12.1.tgz && rm Python-3.12.1.tgz && cd Python-3.12.1          #解压
./configure --prefix=/usr/local/soft/python3.12 --enable-optimizations          #检测安装环境，配置安装参数，生成供编译用的Makefile
make && make install          #编译安装

再创建软链接：

1
2
3

rm -f /usr/bin/python3          #删除原有软链接
ln -s /usr/local/soft/python3.12/bin/python3.12 /usr/bin/python3          #新建软链接python3
ln -s /usr/local/soft/python3.12/bin/pip3.12 /usr/bin/pip          #新建软链接pip

检查安装是否成功：

1 2	python3 --version pip --version

Node.js

同理追新，我选择安装Node.js-v21.5.0：

1 2	curl -fsSL https://deb.nodesource.com/setup_21.x \| bash - &&\ apt-get install -y nodejs

检测安装是否成功：

1 2	node --version npm --version

OpenJDK

用得不多，所以偷个懒，直接 apt-get安装：

1	apt-get install openjdk-17-jdk

检测安装是否成功：

1	java -version

如果要安装新一点的版本，以OpenJDK 21为例：
1
2
3
4
5
6
7
mkdir -p /usr/local/soft
cd /usr/local/soft
wget https://download.java.net/java/GA/jdk21.0.1/415e3f918a1f4062a0074a2794853d0d/12/GPL/openjdk-21.0.1_linux-x64_bin.tar.gz
tar -xzvf openjdk-21.0.1_linux-x64_bin.tar.gz
rm openjdk-21.0.1_linux-x64_bin.tar.gz
ln -s /usr/local/soft/jdk-21.0.1/bin/java /usr/bin/java
ln -s /usr/local/soft/jdk-21.0.1/bin/jar /usr/bin/jar
然后修改 /etc/profile，在最末添加一些环境变量：
1
2
export JAVA_HOME=/usr/local/soft/jdk-21.0.1
export PATH=${JAVA_HOME}/bin:$PATH
可以使用sftp上传覆盖修改，也可以使用vim、nano之类的工具在线修改。
修改完后应用环境变量：
1
source /etc/profile

PHP

这里我选择了安装PHP8.2，debian11的 apt-get源里只搜得到低版本，同Node.js一样，稍作处理即可用 apt-get直接安装：

apt-get update && apt-get install lsb-release ca-certificates curl -y
curl -sSLo /usr/share/keyrings/deb.sury.org-php.gpg https://packages.sury.org/php/apt.gpg && sh -c 'echo "deb [signed-by=/usr/share/keyrings/deb.sury.org-php.gpg] https://packages.sury.org/php/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/php.list'
apt-get update
apt-get install php

如果在执行第二条命令时报错：

Traceback (most recent call last):
  File "/usr/bin/lsb_release", line 25, in 
    import lsb_release
ModuleNotFoundError: No module named 'lsb_release'

则通过这个办法解决：

1	cp /usr/lib/python3/dist-packages/lsb_release.py /usr/bin/

MySQL

创建自己的数据库，再也不用到处找免费的数据库白嫖！充分利用Hax的15G硬盘。安装方法如下：

wget https://repo.mysql.com//mysql-apt-config_0.8.29-1_all.deb
dpkg -i mysql-apt-config_0.8.29-1_all.deb
rm mysql-apt-config_0.8.22-1_all.deb
apt-get update
apt-get install mysql-server

MySQL默认监听3306端口，安装过程中会有一些自定义选项，还会要求你设置数据库root用户的密码。使用查看版本号的命令检查MySQL是否安装正常：

1	mysql --version

Redis

默认监听6379端口，主要用于缓存提速，部分应用可用，不详细介绍，只记录安装方法：

1
2
3

curl https://packages.redis.io/gpg | apt-key add -
echo "deb https://packages.redis.io/deb \$(lsb\_release -cs) main" | tee /etc/apt/sources.list.d/redis.list
apt-get update -y && apt-get install redis-server -y

连接测试，会进入到127.0.0.1:6379的实例中：

redis-cli

pm2

推荐一个很好用的进程管理工具：pm2，安装简单，功能强大。具体功能不细说，源仓库介绍很详细，安装方法也很简单，直接用 npm就能安装：

1	npm install pm2 -g

常用指令：

1 2	pm2 ls #查看目前pm2管理的所有进程的简易列表 pm2 monit #查看pm2管理的所有进程的详细信息

一些应用的部署

我首先部署的代理在此就不做介绍了，Hysteria2和tuic协议目前在Hax上的表现都还不错，GitHub和Gitlab上也都有不少一键部署的脚本。如果希望在本地没有IPv6的情况下代理到Hax，则需要选择使用Cloudflare隧道的代理方式，上述的fscarmen大佬也有提供，这里不再赘述。

我目前已经在Hax上部署了PandoraNext、TokensTool、One-API、Bingo四项服务，并通过Cloudflared隧道链接到了自己的域名，通过Cloudflare提供的服务，使得没有IPv6的网络情况下也可以访问我部署的服务。以上服务均用 pm2启动，以便管理，防止崩溃。

Bingo

通过源码部署的方式进行部署。将Bingo的代码下载到本地，并测试运行：

git clone https://github.com/weaigc/bingo.git          #下载源码到本地
cd bingo
npm install
npm run build          #构筑
npm run start          #运行

其默认端口配置在 server.js文件的第7行，默认为 3000。运行成功后可以访问http://[IPv6]:PORT查看是否正常运行。
正常运行的话，使用 Ctrl+c停止运行，如果你希望设置内置账号，可以设置环境变量：

1	echo "BING_HEADER=Your_Header" > .env #把Your_Header改成转换的HEADER

再使用pm2启动：

1	pm2 start npm -- run start

至此，Bingo就部署完毕了，如果需要修改 BING_HEADER然后重启应用的话，修改后直接使用 ps -ef命令找到原本运行的Bingo，接着使用 kill将其停止即可。pm2会自启Bingo。

One-API

因为源仓库提供了可执行文件，所以部署起来非常简单，下载，赋权，运行即可：

1
2
3

wget -O one-api https://github.com/songquanpeng/one-api/releases/download/v0.5.10/one-api          #下载可执行文件并重命名为one-api
chmod 777 one-api          #赋权
./one-api --port 1333 --log-dir ./logs          #在1333端口运行One-API并将日志输出到当前路径下的logs路径下

接着检查一下1333端口上one-api是否正常运行，运行正常的话，使用 Ctrl+c停止运行。再使用pm2启动One-API：

1	pm2 start ./one-api -- --port 1333 --log-dir ./logs

至此，One-API部署完毕。如果需要升级，与Bingo同理，下载覆盖后，使用kill停止原本的任务即可，pm2会自启One-API。

PandoraNext

与One-API相同，PandoraNext提供了可执行文件，部署简单。需要注意的是，PandoraNext并不是一个服务端，只是一个客户端，而且并不开源，但是其功能非常强大，且免费使用。以下是部署步骤：

1
2
3

wget https://github.com/pandora-next/deploy/releases/download/v0.6.1/PandoraNext-v0.6.1-linux-amd64-e1cae28.tar.gz
tar -xzvf PandoraNext-v0.6.1-linux-amd64-e1cae28.tar.gz --strip-components=1
chmod 777 PandoraNext

接着修改 config.json文件，填入自己的配置，再启动PandoraNext进行测试运行：

1	./PandoraNext

接着检查一下你在 config.json中设置的端口上PandoraNext是否正常运行，运行正常的话，使用 Ctrl+c停止运行。再使用pm2启动PandoraNext：

1	pm2 start ./PandoraNext

至此，PandoraNext部署完毕。如果需要升级，与Bingo同理，下载覆盖后，使用kill停止原本的任务即可，pm2会自启PandoraNext。

需要注意的是，PandoraNext的License是绑定IPv4的，实际上Hax的IPv6_only的VPS都在相近的机房，其套用Warp获得的IPv4地址数量非常有限，大多数都是共用相同的IPv4地址。按照PandoraNext的规则来讲，就是先到先得，部署晚的有可能会无法绑定License。

TokensTool

TokensTool是配合PandoraNext使用的tokens管理工具，能把刷新tokens、推流one-api等工作自动化进行，而且配备了UI页面，使用简单方便。目前TokensTool还在不断更新中，如今已经支持了cocopilot转OpenAI API的功能，越来越多的功能将会被添加进去。TokensTool是用Java写的，提供了打包好的Jar包，只需要下载Jar包运行即可：

1
2

wget -O tokenstool.jar https://github.com/Yanyutin753/PandoraNext-TokensTool/releases/download/v0.5.9/pandoraNext-0.5.9-SNAPSHOT.jar          #下载jar包并重命名为tokenstool.jar
java -jar tokenstool.jar --server.port=8081 --deployWay=releases --deployPosition=/root/app --hotReload=true --pandora_Ip=127.0.0.1          #测试运行

接着检查一下8081端口上TokensTool是否正常运行，运行正常的话，使用 Ctrl+c停止运行。再使用pm2启动TokensTool：

1	pm2 start java -- -jar tokenstool.jar --server.port=8081 --deployWay=releases --deployPosition=/root/app --hotReload=true --pandora_Ip=127.0.0.1

至此，TokensTool部署完毕。如果需要升级，与Bingo同理，下载覆盖后，使用kill停止原本的任务即可，pm2会自启TokensTool。

Cloudflared

为了便利的给上述服务添加域名，并使得没有IPv6的网络环境下也能访问上述服务，我使用了Cloudflare提供的隧道，其使用方法也是非常简单便利：

1
2
3

wget -O cloudflared https://github.com/cloudflare/cloudflared/releases/download/2023.10.0/cloudflared-linux-amd64          #下载Cloudflared客户端
chmod 777 cloudflared          #赋权
./cloudflared tunnel --edge-ip-version auto --protocol http2 --heartbeat-interval 10s run --token ARGO_TOKEN          #测试运行，我选择使用http2协议，ARGO_TOKEN应该替换为自己创建的隧道的那一串ey开头的TOKEN

在Cloudflare的面板中看到隧道上线，则运行正常。再使用 Ctrl+c停止运行，并使用pm2启动Cloudflared：

1	pm2 start ./cloudflared -- tunnel --edge-ip-version auto --protocol http2 --heartbeat-interval 10s run --token ARGO_TOKEN

至此，Cloudflared部署完毕。如果需要升级，与Bingo同理，下载覆盖后，使用kill停止原本的任务即可，pm2会自启Cloudflared。

在Cloudflare的面板中给上述服务添加对应域名即可，比如3000端口的bingo，只要添加 HTTP协议的地址 localhost:3000即可。

一些我没有部署但可以部署的应用

在Warp和Cloudflared的加持下，Hax的IPv6_only的VPS的使用基本上已经和有IPv4的服务器无异，仅仅在需要进行SSH或者SCP连接的时候必须要求本地有IPv6网络。而实际上，通过使用File Browser和TTYD并使用Cloudflared隧道穿透出来，就变相实现了这两个协议所实现的功能在没有IPv6网络的情况下的使用。

上述的两个仓库都是单个可执行文件即可实现部署，这里不再赘述部署方式，仅仅记录运行命令，以便查找：

1
2
3

# ttyd运行指令
./ttyd -p 21022 -c admin:password -W bash          #在21022端口运行ttyd，用户名为admin，密码为password，连接的命令行解释器为bash
pm2 start ./ttyd -- -p 21022 -c admin:password -W bash          #使用pm2运行

1
2
3

# filebrowser运行指令
./filebrowser -p 21021          #在21021端口运行filebrowser，默认用户名和密码都为admin，登录后可以修改密码
pm2 start ./filebrowser -- -p 21021          #使用pm2运行

此外，各种QQ机器人、Blog框架（如 jar4halo）、文件目录程序（如 alist）、图床程序等等。因为此前已经把Python、Node.js、OpenJDK、PHP都安装好了，主流应用的环境问题都很好解决，多数只需要按照文档部署即可。

# jar4halo需要设置环境变量运行
export HALO_WORK_DIR="/root/halo/.halo2"          #halo的工作目录设置为/root/halo/.halo2
export HALO_EXTERNAL_URL="https://Your_Domain"          #设置halo的对外域名
java -jar -Duser.timezone=Asia/Shanghai halo.jar          #使用UTC+8时区

文件的备份与转移

如果你需要将服务器上的文件快速地下载到本地，亦或者是传输到另一台服务器上，可以使用ShareList。
这是一个一键脚本，用以在当前路径直接启动sharelist，并且把当前路径挂载到sharelist中：

1	bash <(curl -s https://raw.githubusercontent.com/k0baya/sharelist_repl/main/hax/share.sh)

上述命令只能在AMD64架构的Linux机器上使用。sharelist固定运行在33001端口，因为其监听的是127.0.0.1所以无法使用ip:port进行访问，你可以选择用nginx或者直接用Cloudflared绑定33001端口到一个域名进行访问。进入sharelist的页面后，你可以直接把打包好的文件下载到本地或者在另外一台机器使用wget -O 文件名 '链接'的命令进行下载。

另外把打包和解压的命令做个备份，我喜欢使用tar命令，这里只记录tar：
**打包：tar -czvf 文件名.tar.gz 路径**，比如打包整个/root/app路径，命名为archive.tar.gz，即为tar -czvf archive.tar.gz /root/app
**解压：tar -xzvf 文件名**，比如解压刚刚打包的archive.tar.gz即为tar -xzvf archive.tar.gz

未完待续……

qexo编辑器测试

2023-12-27T05:28:31.541Z

这是一个标题

这是小标题

1	bash start.sh

main.js文件

注意：这只是测试。

真的只是测试

不信你加群

number	username
1	admin