Yizong

VPS常用命令/工具

Wed, 30 Dec 2099 00:00:00 GMT

:::important 请注意，以下命令适用于基于Linux的系统。对于其他操作系统，操作命令可能有所不同。 :::

命令类

更新VPS环境

Ubuntu/Debian

apt update -y && apt install -y curl socat wget sudo

Alpine

apk update && apk add curl

Tree命令

sudo apt install tree

vim安装

sudo apt-get install vim

unzip安装

sudo apt install zip

Nginx命令

sudo nginx -t #检查配置文件语法

sudo systemctl start nginx #启动 Nginx

sudo systemctl stop nginx #停止 Nginx

sudo systemctl restart nginx #重启 Nginx

sudo systemctl reload nginx #重新加载配置（不中断服务）

sudo systemctl status nginx #查看状态

工具类

ssh综合工具箱

curl -fsSL https://raw.githubusercontent.com/eooce/ssh_tool/main/ssh_tool.sh -o ssh_tool.sh && chmod +x ssh_tool.sh && ./ssh_tool.sh

bash <(curl -sL kejilion.sh)

IP质量体检脚本

bash <(curl -Ls IP.Check.Place)

老王四协议

bash <(curl -Ls https://raw.githubusercontent.com/eooce/sing-box/main/sing-box.sh)

PORT=11111 CFIP=www.visa.com.tw CFPORT=443 bash <(curl -Ls https://raw.githubusercontent.com/eooce/sing-box/main/sing-box.sh)

甬哥X-ui

bash <(curl -Ls https://raw.githubusercontent.com/yonggekkk/x-ui-yg/main/install.sh)

IPv6专区

warp

wget -N https://gitlab.com/fscarmen/warp/-/raw/main/menu.sh && bash menu.sh

纯IPv6修改DNS64(NAT64)，可访问IPV4地址

vim /etc/resolv.conf
nameserver 2001:67c:2b0::4 
nameserver 2001:67c:27e4::64

从零部署 Emby 媒体服与用户管理

Sat, 09 May 2026 00:00:00 GMT

本文整理自一次完整的 Emby 搭建过程，覆盖 NAT VPS 与独立服务器两种场景。涉及到的 Token、API Key、域名、Telegram ID 请全部替换成你自己的值，不要直接复制示例里的占位符。

0. 最终目标

我们要搭建的是一套完整的个人媒体系统：

Google Drive / OpenList / OneDrive
        ↓ rclone 挂载
/mnt/gdrive 或 /mnt/openlist
        ↓
Emby 读取媒体库
        ↓
Caddy / Cloudflare 提供访问线路
        ↓
客户端播放、网页管理、用户自助注册、统计面板

同时还会额外搭建一个 Telegram 上传机器人：

你把资源发给 Telegram 机器人
        ↓
服务器自动接收文件
        ↓
rclone 上传到网盘指定目录
        ↓
你整理命名后 Emby 扫库

可选管理系统有两个方向：

方案	用途	适合人群
EmbyPulse	Web 面板、统计、用户中心、播放排行、缺集等	想要图形化管理面板
EmbyTGBot	Telegram 管理用户、注册码、续期、查询在线人数	想通过 TG 管理用户

:::warning 不要把机器人 Token、Emby API Key、Google OAuth Secret、rclone.conf 公开到博客或 GitHub。 :::

1. 服务器场景与端口规划

本文覆盖两种服务器。

1.1 NAT VPS 场景

假设只有少量端口，比如：

服务器 IP：176.123.6.17
可用端口：48111-48119

推荐规划：

48111  Emby 反代线路
48112  EmbyPulse 管理后台
48113  EmbyPulse 用户中心
48114  Emby 直连播放线路
48119  SSH，若服务商已经分配给 SSH 就不要占用

NAT VPS 的重点是：服务商面板必须把外部端口映射到 VPS 内部端口。如果外部访问超时，第一优先排查端口映射。

1.2 独立服务器场景

假设服务器有独立公网 IP：

服务器 IP：147.224.40.215
SSH 端口：22700

已有占用端口示例：

80/tcp      caddy
443/tcp     caddy
22700/tcp   sshd
8001/tcp    sing-box
50501/tcp   sing-box
50503/udp   sing-box
50504/udp   sing-box
40823/udp   sing-box
5353/udp    avahi-daemon / openclaw-gateway

新增端口建议：

8096/tcp    Emby 直连播放线路
18080/tcp   可选 Web API，仅监听 127.0.0.1
18081/tcp   可选 Web 前端，仅监听 127.0.0.1
18082/tcp   本地 Telegram Bot API，仅监听 127.0.0.1

独立服务器推荐线路：

https://emby.example.com     Cloudflare 橙云线路，用于网页管理
https://play.example.com     DNS only 灰云线路，用于直连播放
http://147.224.40.215:8096   IP 直连线路，用于调试或客户端播放

:::important 视频播放不建议长期走 Cloudflare 橙云线路。Cloudflare 线路适合网页访问、管理、登录；播放大文件建议走灰云直连域名或 IP:8096。 :::

2. 系统初始化

以下命令以 Debian 12 为例。

ssh root@你的服务器IP -p 你的SSH端口

更新系统并安装基础组件：

apt update && apt upgrade -y
apt install -y ca-certificates curl gnupg lsb-release nano vim unzip fuse3 jq socat openssl git
hostnamectl set-timezone Asia/Shanghai

检查端口占用：

ss -lntup

3. 安装 Docker 和 Docker Compose

for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do
  apt remove -y "$pkg" || true
done

install -m 0755 -d /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc

cat > /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

systemctl enable --now docker

docker version
docker compose version
docker run --rm hello-world

创建 Docker 网络：

docker network create media-net 2>/dev/null || true

4. 配置 rclone 与 Google Drive

4.1 安装 rclone

curl https://rclone.org/install.sh | bash
rclone version

允许 FUSE 挂载被 Docker 容器读取：

grep -qxF 'user_allow_other' /etc/fuse.conf || echo 'user_allow_other' >> /etc/fuse.conf

创建目录：

mkdir -p /mnt/gdrive
mkdir -p /var/cache/rclone-gdrive
mkdir -p /root/.config/rclone
chmod 700 /root/.config/rclone

4.2 给 rclone 配自己的 Google Drive Client ID

不建议长期使用 rclone 默认共享 client_id，容易遇到 Google Drive API 限流：

googleapi: Error 403: Quota exceeded
RATE_LIMIT_EXCEEDED

去 Google Cloud Console 创建项目：

1. 创建项目，例如 rclone-emby-upload
2. APIs & Services -> Library
3. 启用 Google Drive API
4. Google Auth Platform / OAuth consent screen
5. Data Access 添加 scope:
   https://www.googleapis.com/auth/drive
6. Audience 添加自己的 Google 账号为测试用户，或发布到 In production
7. Clients -> Create OAuth client
8. Application type 选择 Desktop app
9. 复制 Client ID 和 Client Secret

然后在服务器配置：

rclone config

按提示填写：

n) New remote
name> gdrive
Storage> drive
client_id> 你的 Client ID
client_secret> 你的 Client Secret
scope> drive
root_folder_id> 直接回车
service_account_file> 直接回车
Edit advanced config? n
Use web browser to automatically authenticate rclone with remote? n

如果服务器没有浏览器，rclone 会要求你在本地电脑执行：

rclone authorize "drive" "一大串配置"

如果本地网络访问 Google 有问题，PowerShell 先设置代理：

$env:HTTP_PROXY="http://127.0.0.1:7890"
$env:HTTPS_PROXY="http://127.0.0.1:7890"

授权成功后，把 JSON token 粘贴回服务器。

测试：

rclone about gdrive:
rclone lsd gdrive:

创建媒体目录：

rclone mkdir "gdrive:媒体/电影"
rclone mkdir "gdrive:媒体/电视剧"
rclone mkdir "gdrive:媒体/动漫"
rclone mkdir "gdrive:TelegramUploads/待整理"

4.3 挂载 Google Drive

创建 systemd 服务：

cat > /etc/systemd/system/rclone-gdrive.service <<'EOF'
[Unit]
Description=Rclone mount Google Drive for Emby
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
ExecStartPre=/bin/mkdir -p /mnt/gdrive /var/cache/rclone-gdrive
ExecStart=/usr/bin/rclone mount gdrive: /mnt/gdrive \
  --config=/root/.config/rclone/rclone.conf \
  --allow-other \
  --read-only \
  --uid=1000 \
  --gid=1000 \
  --umask=002 \
  --dir-cache-time=72h \
  --poll-interval=15s \
  --vfs-cache-mode=full \
  --vfs-cache-max-size=50G \
  --vfs-cache-max-age=6h \
  --buffer-size=64M \
  --cache-dir=/var/cache/rclone-gdrive
ExecStop=/usr/bin/fusermount3 -uz /mnt/gdrive
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

启动：

systemctl daemon-reload
systemctl enable --now rclone-gdrive
systemctl status rclone-gdrive --no-pager
ls -la /mnt/gdrive

5. 可选：通过 OpenList WebDAV 挂载网盘

如果你已经搭好了 OpenList，可以通过 WebDAV 挂到本地。

OpenList WebDAV 地址格式：

https://openlist.example.com/dav/

配置 rclone：

rclone config

示例：

n) New remote
name> openlist
Storage> webdav
url> https://openlist.example.com/dav/
vendor> other
user> OpenList 用户名
password> OpenList 密码
bearer_token> 直接回车

测试：

rclone lsd openlist:

创建挂载：

mkdir -p /mnt/openlist
mkdir -p /var/cache/rclone-openlist

创建 systemd：

cat > /etc/systemd/system/rclone-openlist.service <<'EOF'
[Unit]
Description=Rclone mount OpenList WebDAV for Emby
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
ExecStartPre=/bin/mkdir -p /mnt/openlist /var/cache/rclone-openlist
ExecStart=/usr/bin/rclone mount openlist: /mnt/openlist \
  --config=/root/.config/rclone/rclone.conf \
  --allow-other \
  --read-only \
  --uid=1000 \
  --gid=1000 \
  --umask=002 \
  --dir-cache-time=72h \
  --poll-interval=30s \
  --vfs-cache-mode=full \
  --vfs-cache-max-size=20G \
  --vfs-cache-max-age=6h \
  --buffer-size=32M \
  --cache-dir=/var/cache/rclone-openlist
ExecStop=/usr/bin/fusermount3 -uz /mnt/openlist
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

启动：

systemctl daemon-reload
systemctl enable --now rclone-openlist
ls -la /mnt/openlist

6. 部署 Emby

6.1 判断服务器架构

uname -m
docker info | grep -i architecture

如果是 x86_64 / amd64，用：

emby/embyserver:latest

如果是 aarch64 / arm64，用：

emby/embyserver_arm64v8:latest

:::warning ARM64 服务器如果误用 amd64 镜像，会出现 exec /init: exec format error。 :::

6.2 创建 Compose

mkdir -p /opt/media-stack/emby
mkdir -p /opt/media/emby/config
mkdir -p /opt/media/emby/transcode
chown -R 1000:1000 /opt/media/emby

amd64 示例：

cat > /opt/media-stack/emby/docker-compose.yml <<'EOF'
services:
  emby:
    image: emby/embyserver:latest
    container_name: embyserver
    restart: unless-stopped
    ports:
      - "8096:8096"
    environment:
      UID: "1000"
      GID: "1000"
      GIDLIST: "1000"
      TZ: Asia/Shanghai
    volumes:
      - /opt/media/emby/config:/config
      - /opt/media/emby/transcode:/transcode
      - type: bind
        source: /mnt/gdrive
        target: /mnt/gdrive
        read_only: true
        bind:
          propagation: rslave
    networks:
      - media-net

networks:
  media-net:
    external: true
EOF

ARM64 改成：

image: emby/embyserver_arm64v8:latest
platform: linux/arm64/v8

启动：

cd /opt/media-stack/emby
docker compose pull
docker compose up -d
docker logs --tail=100 embyserver
curl -I http://127.0.0.1:8096

让 Docker 尽量等 rclone 挂载后启动：

mkdir -p /etc/systemd/system/docker.service.d

cat > /etc/systemd/system/docker.service.d/override.conf <<'EOF'
[Unit]
Wants=rclone-gdrive.service
After=rclone-gdrive.service
EOF

systemctl daemon-reload

7. Caddy、Cloudflare 与播放线路

7.1 独立服务器推荐配置

Cloudflare DNS：

A  emby  服务器IP  Proxied / 橙云
A  play  服务器IP  DNS only / 灰云

Caddy 配置：

mkdir -p /etc/caddy/conf.d
cp /etc/caddy/Caddyfile /etc/caddy/Caddyfile.bak.$(date +%F-%H%M%S)

grep -q 'import /etc/caddy/conf.d/\*.caddy' /etc/caddy/Caddyfile || \
  printf '\nimport /etc/caddy/conf.d/*.caddy\n' >> /etc/caddy/Caddyfile

cat > /etc/caddy/conf.d/emby.caddy <<'EOF'
emby.example.com {
  encode zstd gzip
  reverse_proxy 127.0.0.1:8096
}

play.example.com {
  encode zstd gzip
  reverse_proxy 127.0.0.1:8096
}
EOF

caddy fmt --overwrite /etc/caddy/Caddyfile /etc/caddy/conf.d/emby.caddy
caddy validate --config /etc/caddy/Caddyfile
systemctl reload caddy

最终入口：

Cloudflare 代理线路：
https://emby.example.com

直连 HTTPS 线路：
https://play.example.com

IP 直连线路：
http://服务器IP:8096

7.2 NAT VPS 推荐配置

如果只有高端口：

48111 -> Emby 反代线路
48114 -> Emby 直连播放线路

Caddyfile 示例：

{
  auto_https off
}

:48111 {
  encode gzip
  reverse_proxy 127.0.0.1:8096
}

直连播放线路可以用服务商面板直接配置：

外部 48114 -> 内部 8096

如果服务商只能同端口映射，则用 socat：

apt install -y socat

cat > /etc/systemd/system/emby-direct-48114.service <<'EOF'
[Unit]
Description=Direct TCP forward 48114 to Emby 8096
After=network-online.target docker.service
Wants=network-online.target

[Service]
ExecStart=/usr/bin/socat TCP-LISTEN:48114,fork,reuseaddr TCP:127.0.0.1:8096
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable --now emby-direct-48114

访问：

http://服务器IP:48111  Emby 反代线路
http://服务器IP:48114  Emby 直连播放线路

8. 初始化 Emby 与媒体库

浏览器打开：

http://服务器IP:8096

或：

https://play.example.com

首次向导：

语言：中文
创建管理员账号
允许远程访问：开启

添加媒体库：

电影库：
内容类型：电影
路径：/mnt/gdrive/媒体/电影

电视剧库：
内容类型：电视节目
路径：/mnt/gdrive/媒体/电视剧

动漫库：
内容类型：电视节目
路径：/mnt/gdrive/媒体/动漫

9. 媒体库整理规范

Emby 主要根据媒体库类型、文件夹名、文件名和季集编号识别，不会真正理解视频内容。

9.1 电影

媒体/
  电影/
    流浪地球 (2019)/
      流浪地球 (2019).mkv

    Avatar (2009)/
      Avatar (2009).mkv

9.2 电视剧

媒体/
  电视剧/
    庆余年 (2019)/
      Season 01/
        庆余年 S01E01.mkv
        庆余年 S01E02.mkv
      Season 02/
        庆余年 S02E01.mkv

9.3 动漫

媒体/
  动漫/
    葬送的芙莉莲 (2023)/
      Season 01/
        葬送的芙莉莲 S01E01.mkv
        葬送的芙莉莲 S01E02.mkv
      Specials/
        葬送的芙莉莲 S00E01.mkv

9.4 不推荐

电视剧/
  第01集.mkv
  第02集.mkv
  01.mp4

或把所有电影、剧集、动漫混在一个媒体库里。

:::tip Telegram 上传机器人建议只上传到 gdrive:TelegramUploads/待整理，不要直接传到正式媒体库。确认片名、年份、季集后，再移动到正式目录。 :::

10. Telegram 上传网盘机器人

这个机器人负责：

接收 Telegram 文件
自动排队
上传到当前设置的网盘目录
支持 /setdir 切换上传目录
支持 /cancel 中止当前任务
支持 /queue 查看等待队列
支持每 10 秒刷新上传进度

10.1 准备信息

需要：

BOT_TOKEN
TELEGRAM_API_ID
TELEGRAM_API_HASH
你的 Telegram 数字 ID

BOT_TOKEN 从 @BotFather 创建。
TELEGRAM_API_ID 和 TELEGRAM_API_HASH 从 https://my.telegram.org 创建 App 获取。

10.2 创建目录与配置

mkdir -p /opt/tg-bot-uploader/botapi-data
mkdir -p /opt/tg-bot-uploader/downloads
cd /opt/tg-bot-uploader

创建 .env：

cat > /opt/tg-bot-uploader/.env <<'EOF'
BOT_TOKEN=这里填你的BOT_TOKEN
TELEGRAM_API_ID=这里填你的API_ID
TELEGRAM_API_HASH=这里填你的API_HASH

ALLOWED_USER_IDS=

DEST_REMOTE=gdrive:TelegramUploads/待整理
ALLOWED_DEST_PREFIXES=gdrive:

BOT_API_URL=http://127.0.0.1:18082
FILE_API_URL=http://127.0.0.1:18082/file

LOCAL_BOT_API_PATH_PREFIX=/var/lib/telegram-bot-api
HOST_BOT_API_PATH_PREFIX=/opt/tg-bot-uploader/botapi-data

DOWNLOAD_DIR=/opt/tg-bot-uploader/downloads
STATE_FILE=/opt/tg-bot-uploader/state.json
PROGRESS_INTERVAL=10
SKIP_OLD_UPDATES_ON_START=true
EOF

chmod 600 /opt/tg-bot-uploader/.env
vim /opt/tg-bot-uploader/.env

10.3 部署本地 Telegram Bot API Server

cat > /opt/tg-bot-uploader/docker-compose.yml <<'EOF'
services:
  telegram-bot-api:
    image: aiogram/telegram-bot-api:latest
    container_name: telegram-bot-api
    restart: unless-stopped
    ports:
      - "127.0.0.1:18082:8081"
    env_file:
      - /opt/tg-bot-uploader/.env
    environment:
      TELEGRAM_LOCAL: "1"
    volumes:
      - /opt/tg-bot-uploader/botapi-data:/var/lib/telegram-bot-api
EOF

启动：

cd /opt/tg-bot-uploader
docker compose pull
docker compose up -d
docker logs --tail=100 telegram-bot-api

测试：

source /opt/tg-bot-uploader/.env
curl "http://127.0.0.1:18082/bot${BOT_TOKEN}/getMe"

返回 "ok":true 即成功。

给机器人发 /start，然后获取你的 Telegram ID：

curl -s "http://127.0.0.1:18082/bot${BOT_TOKEN}/getUpdates" | jq

把 from.id 写进 .env：

ALLOWED_USER_IDS=123456789

10.4 上传机器人脚本

cat > /opt/tg-bot-uploader/tg_uploader.py <<'PY'
#!/usr/bin/env python3
import os
import re
import time
import json
import shutil
import select
import threading
import subprocess
from pathlib import Path
from collections import deque
from urllib.parse import quote
from urllib.request import urlopen, Request

BOT_TOKEN = os.environ["BOT_TOKEN"]
BOT_API_URL = os.environ.get("BOT_API_URL", "http://127.0.0.1:18082").rstrip("/")
FILE_API_URL = os.environ.get("FILE_API_URL", "http://127.0.0.1:18082/file").rstrip("/")
DEFAULT_DEST_REMOTE = os.environ.get("DEST_REMOTE", "gdrive:TelegramUploads/待整理").rstrip("/")
STATE_FILE = Path(os.environ.get("STATE_FILE", "/opt/tg-bot-uploader/state.json"))
DOWNLOAD_DIR = Path(os.environ.get("DOWNLOAD_DIR", "/opt/tg-bot-uploader/downloads"))
PROGRESS_INTERVAL = int(os.environ.get("PROGRESS_INTERVAL", "10"))
SKIP_OLD = os.environ.get("SKIP_OLD_UPDATES_ON_START", "true").lower() in ["1", "true", "yes", "y"]

ALLOWED_DEST_PREFIXES = [x.strip() for x in os.environ.get("ALLOWED_DEST_PREFIXES", "gdrive:").split(",") if x.strip()]
ALLOWED_USER_IDS = {int(x.strip()) for x in os.environ.get("ALLOWED_USER_IDS", "").split(",") if x.strip()}

LOCAL_PREFIX = os.environ.get("LOCAL_BOT_API_PATH_PREFIX", "")
HOST_PREFIX = os.environ.get("HOST_BOT_API_PATH_PREFIX", "")

DOWNLOAD_DIR.mkdir(parents=True, exist_ok=True)
STATE_FILE.parent.mkdir(parents=True, exist_ok=True)

state_lock = threading.Lock()
queue_cond = threading.Condition()
job_queue = deque()
current_job = None
job_seq = 0

class Cancelled(Exception):
    pass

def load_state_unlocked():
    if not STATE_FILE.exists():
        return {"users": {}, "last_update_id": None}
    try:
        data = json.loads(STATE_FILE.read_text("utf-8"))
    except Exception:
        return {"users": {}, "last_update_id": None}
    data.setdefault("users", {})
    data.setdefault("last_update_id", None)
    return data

def save_state_unlocked(data):
    tmp = STATE_FILE.with_suffix(".tmp")
    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), "utf-8")
    tmp.replace(STATE_FILE)

def get_user_dest(user_id):
    with state_lock:
        state = load_state_unlocked()
        return state["users"].get(str(user_id), {}).get("dest", DEFAULT_DEST_REMOTE)

def set_user_dest(user_id, dest):
    dest = dest.strip().rstrip("/")
    if not dest:
        raise ValueError("目录不能为空")
    if not any(dest.startswith(prefix) for prefix in ALLOWED_DEST_PREFIXES):
        raise ValueError(f"不允许的目录。允许前缀：{', '.join(ALLOWED_DEST_PREFIXES)}")
    with state_lock:
        state = load_state_unlocked()
        state["users"].setdefault(str(user_id), {})
        state["users"][str(user_id)]["dest"] = dest
        save_state_unlocked(state)

def get_last_update_id():
    with state_lock:
        return load_state_unlocked().get("last_update_id")

def set_last_update_id(update_id):
    with state_lock:
        state = load_state_unlocked()
        state["last_update_id"] = update_id
        save_state_unlocked(state)

def api(method, data=None, timeout=300):
    url = f"{BOT_API_URL}/bot{BOT_TOKEN}/{method}"
    if data is None:
        req = Request(url)
    else:
        req = Request(url, data=json.dumps(data).encode("utf-8"), headers={"Content-Type": "application/json"})
    with urlopen(req, timeout=timeout) as r:
        return json.loads(r.read().decode("utf-8"))

def send(chat_id, text):
    try:
        res = api("sendMessage", {"chat_id": chat_id, "text": text})
        if res.get("ok"):
            return res["result"]["message_id"]
    except Exception as e:
        print("sendMessage error:", repr(e), flush=True)
    return None

def edit(chat_id, message_id, text):
    if not message_id:
        return
    try:
        api("editMessageText", {"chat_id": chat_id, "message_id": message_id, "text": text})
    except Exception as e:
        print("editMessageText error:", repr(e), flush=True)

def human_size(num):
    try:
        num = float(num)
    except Exception:
        return "未知"
    units = ["B", "KB", "MB", "GB", "TB"]
    for unit in units:
        if abs(num) < 1024:
            return f"{num:.2f} {unit}"
        num /= 1024
    return f"{num:.2f} PB"

def safe_name(name):
    return name.replace("/", "_").replace("\\", "_").strip() or f"telegram_file_{int(time.time())}"

def rclone_join(remote_dir, file_name):
    remote_dir = remote_dir.strip().rstrip("/")
    return remote_dir + file_name if remote_dir.endswith(":") else remote_dir + "/" + file_name

def ensure_remote_dir(remote_dir):
    subprocess.run(["rclone", "mkdir", remote_dir], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)

def get_media(message):
    for key in ["document", "video", "audio"]:
        if key in message:
            obj = message[key]
            file_id = obj["file_id"]
            file_name = obj.get("file_name") or f"{key}_{message['message_id']}" + (".mp4" if key == "video" else "")
            size = obj.get("file_size", 0)
            return file_id, safe_name(file_name), size
    if "photo" in message:
        obj = message["photo"][-1]
        return obj["file_id"], f"photo_{message['message_id']}.jpg", obj.get("file_size", 0)
    return None, None, None

def get_file_path(file_id):
    info = api("getFile", {"file_id": file_id})
    if not info.get("ok"):
        raise RuntimeError(info)
    return info["result"]["file_path"]

def resolve_local_path(file_path):
    paths = []
    if file_path.startswith("/"):
        paths.append(file_path)
        if LOCAL_PREFIX and HOST_PREFIX and file_path.startswith(LOCAL_PREFIX):
            paths.append(file_path.replace(LOCAL_PREFIX, HOST_PREFIX, 1))
    for p in paths:
        if os.path.exists(p):
            return Path(p)
    return None

def download_via_http(file_path, file_name, job):
    url = f"{FILE_API_URL}/bot{BOT_TOKEN}/{quote(file_path)}"
    local_path = DOWNLOAD_DIR / file_name
    with urlopen(url, timeout=3600) as r, open(local_path, "wb") as f:
        total = r.headers.get("Content-Length")
        total = int(total) if total and total.isdigit() else 0
        done = 0
        last_update = 0
        while True:
            if job["cancel_event"].is_set():
                raise Cancelled("已中止当前任务")
            chunk = r.read(8 * 1024 * 1024)
            if not chunk:
                break
            f.write(chunk)
            done += len(chunk)
            now = time.time()
            if now - last_update >= PROGRESS_INTERVAL:
                if total:
                    percent = done / total * 100
                    text = f"正在从 Telegram 下载到服务器：\n{file_name}\n\n进度：{percent:.2f}%\n已下载：{human_size(done)} / {human_size(total)}\n\n可发送 /cancel 中止当前任务"
                else:
                    text = f"正在从 Telegram 下载到服务器：\n{file_name}\n\n已下载：{human_size(done)}\n\n可发送 /cancel 中止当前任务"
                edit(job["chat_id"], job["progress_message_id"], text)
                last_update = now
    return local_path

def strip_ansi(s):
    return re.sub(r"\x1b\[[0-9;]*[A-Za-z]", "", s).replace("\r", "").replace("\n", "").strip()

def get_queue_size():
    with queue_cond:
        return len(job_queue)

def format_progress_message(job, line):
    line = strip_ansi(line) or "等待 rclone 输出进度..."
    if len(line) > 900:
        line = line[-900:]
    return (
        f"正在上传：\n{job['file_name']}\n\n"
        f"目标目录：\n{job['dest_dir']}\n\n"
        f"rclone 进度：\n{line}\n\n"
        f"队列中等待：{get_queue_size()} 个\n"
        f"可发送 /cancel 中止当前任务"
    )

def terminate_process(proc):
    if not proc:
        return
    try:
        proc.terminate()
        proc.wait(timeout=8)
    except Exception:
        try:
            proc.kill()
        except Exception:
            pass

def upload_with_rclone_progress(src, job):
    src = Path(src)
    dest_path = rclone_join(job["dest_dir"], job["file_name"])
    ensure_remote_dir(job["dest_dir"])

    cmd = [
        "rclone", "copyto", str(src), dest_path,
        "-P",
        "--stats=1s",
        "--stats-one-line",
        "--stats-unit=bytes",
        "--stats-log-level=NOTICE",
        "--transfers=1",
        "--checkers=1",
        "--tpslimit=3",
        "--tpslimit-burst=3",
        "--drive-pacer-min-sleep=200ms",
        "--drive-pacer-burst=10",
        "--retries=20",
        "--retries-sleep=30s",
        "--low-level-retries=20",
        "--log-level=NOTICE"
    ]

    proc = subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=0)
    job["process"] = proc
    job["stage"] = "uploading"

    last_edit = 0
    line_buf = ""
    last_line = "等待 rclone 输出进度..."

    try:
        while True:
            if job["cancel_event"].is_set():
                terminate_process(proc)
                raise Cancelled("已中止当前任务")

            if proc.poll() is not None:
                break

            ready, _, _ = select.select([proc.stdout], [], [], 1.0)
            if not ready:
                continue

            ch = proc.stdout.read(1)
            if not ch:
                continue

            if ch in ["\r", "\n"]:
                clean = strip_ansi(line_buf)
                line_buf = ""
                if clean:
                    last_line = clean
                now = time.time()
                if now - last_edit >= PROGRESS_INTERVAL:
                    edit(job["chat_id"], job["progress_message_id"], format_progress_message(job, last_line))
                    last_edit = now
            else:
                line_buf += ch
                if len(line_buf) > 3000:
                    line_buf = line_buf[-3000:]

        rc = proc.wait()
        if job["cancel_event"].is_set():
            raise Cancelled("已中止当前任务")
        if rc != 0:
            raise RuntimeError(f"rclone 上传失败，退出码：{rc}\n最后输出：{last_line}")

        edit(
            job["chat_id"],
            job["progress_message_id"],
            f"上传完成：\n{job['file_name']}\n\n目标目录：\n{job['dest_dir']}\n\n网盘路径：\n{dest_path}\n\n队列中等待：{get_queue_size()} 个"
        )
        return dest_path
    finally:
        job["process"] = None

def queue_snapshot(limit=10):
    with queue_cond:
        items = list(job_queue)[:limit]
        total = len(job_queue)
    if not items:
        return "当前没有等待中的任务。"
    lines = [f"等待队列：共 {total} 个任务"]
    for i, job in enumerate(items, 1):
        lines.append(f"{i}. #{job['id']} {job['file_name']} -> {job['dest_dir']}")
    if total > limit:
        lines.append(f"... 还有 {total - limit} 个未显示")
    return "\n".join(lines)

def status_text():
    with queue_cond:
        cur = current_job
        total = len(job_queue)
    if cur:
        cur_text = f"当前任务：\n#{cur['id']} {cur['file_name']}\n阶段：{cur.get('stage', '未知')}\n目标目录：{cur['dest_dir']}\n"
    else:
        cur_text = "当前没有正在上传的任务。\n"
    return f"{cur_text}\n等待队列：{total} 个\n\n命令：\n/queue 查看队列\n/cancel 中止当前任务\n/clear 清空等待队列"

def help_text(user_id):
    current = get_user_dest(user_id)
    return (
        "上传机器人使用说明\n\n"
        "直接发送文件、视频或音频给我，我会自动上传到当前网盘目录。\n"
        "多个文件会自动排队，按顺序依次上传。\n\n"
        "目录命令：\n"
        "/dir 查看当前上传目录\n"
        "/setdir gdrive:TelegramUploads/待整理 设置上传目录\n"
        "/setdir gdrive:媒体/电视剧/剧名 (年份)/Season 01 切换到指定目录\n\n"
        "队列命令：\n"
        "/status 查看当前任务和队列数量\n"
        "/queue 查看等待队列\n"
        "/cancel 中止当前正在上传的任务\n"
        "/clear 清空等待队列，不影响当前正在上传的任务\n\n"
        f"当前上传目录：\n{current}\n\n"
        "建议发送时选择“作为文件发送 / Send as File”，不要选择压缩视频。"
    )

def normalize_command(text):
    if not text:
        return "", ""
    parts = text.strip().split(maxsplit=1)
    cmd = parts[0].split("@", 1)[0]
    arg = parts[1].strip() if len(parts) > 1 else ""
    return cmd, arg

def add_job(message, chat_id, user_id):
    global job_seq
    file_id, file_name, size = get_media(message)
    if not file_id:
        send(chat_id, help_text(user_id))
        return

    dest_dir = get_user_dest(user_id)

    with queue_cond:
        job_seq += 1
        job_id = job_seq
        position = len(job_queue) + (1 if current_job else 0) + 1

    progress_message_id = send(
        chat_id,
        f"已加入上传队列：\n#{job_id} {file_name}\n\n"
        f"大小：{human_size(size) if size else '未知'}\n"
        f"目标目录：\n{dest_dir}\n\n"
        f"当前排队位置：{position}\n"
        f"发送 /queue 查看队列，/cancel 中止当前上传。"
    )

    job = {
        "id": job_id,
        "chat_id": chat_id,
        "user_id": user_id,
        "file_id": file_id,
        "file_name": file_name,
        "size": size,
        "dest_dir": dest_dir,
        "progress_message_id": progress_message_id,
        "stage": "queued",
        "cancel_event": threading.Event(),
        "process": None,
    }

    with queue_cond:
        job_queue.append(job)
        queue_cond.notify()

def handle_message(message):
    chat_id = message.get("chat", {}).get("id")
    user_id = message.get("from", {}).get("id")
    if not chat_id or not user_id:
        return

    if ALLOWED_USER_IDS and user_id not in ALLOWED_USER_IDS:
        send(chat_id, "你没有权限使用这个上传机器人。")
        return

    text = (message.get("text") or "").strip()
    cmd, arg = normalize_command(text)

    if cmd in ["/start", "/help"]:
        send(chat_id, help_text(user_id))
        return
    if cmd == "/dir":
        send(chat_id, f"当前上传目录：\n{get_user_dest(user_id)}")
        return
    if cmd == "/setdir":
        if not arg:
            send(chat_id, "用法：\n/setdir gdrive:TelegramUploads/待整理\n/setdir gdrive:媒体/电视剧/剧名 (年份)/Season 01")
            return
        try:
            set_user_dest(user_id, arg)
            ensure_remote_dir(arg)
            send(chat_id, f"已切换上传目录：\n{arg}")
        except Exception as e:
            send(chat_id, f"设置失败：{e}")
        return
    if cmd == "/queue":
        send(chat_id, queue_snapshot())
        return
    if cmd == "/status":
        send(chat_id, status_text())
        return
    if cmd == "/clear":
        with queue_cond:
            count = len(job_queue)
            job_queue.clear()
        send(chat_id, f"已清空等待队列：{count} 个任务。当前正在上传的任务不受影响。")
        return
    if cmd == "/cancel":
        with queue_cond:
            cur = current_job
        if not cur:
            send(chat_id, "当前没有正在上传的任务。")
            return
        cur["cancel_event"].set()
        if cur.get("process"):
            terminate_process(cur["process"])
        send(chat_id, f"已请求中止当前任务：\n#{cur['id']} {cur['file_name']}")
        return

    add_job(message, chat_id, user_id)

def worker_loop():
    global current_job
    while True:
        with queue_cond:
            while not job_queue:
                queue_cond.wait()
            job = job_queue.popleft()
            current_job = job

        src = None
        should_delete = False

        try:
            job["stage"] = "preparing"
            edit(job["chat_id"], job["progress_message_id"], f"开始处理：\n#{job['id']} {job['file_name']}\n\n目标目录：\n{job['dest_dir']}\n\n正在获取 Telegram 文件信息...")

            if job["cancel_event"].is_set():
                raise Cancelled("已中止当前任务")

            file_path = get_file_path(job["file_id"])
            local_path = resolve_local_path(file_path)

            if local_path:
                src = local_path
                should_delete = False
                job["stage"] = "ready"
            else:
                job["stage"] = "downloading"
                src = download_via_http(file_path, job["file_name"], job)
                should_delete = True

            if job["cancel_event"].is_set():
                raise Cancelled("已中止当前任务")

            upload_with_rclone_progress(src, job)

        except Cancelled as e:
            edit(job["chat_id"], job["progress_message_id"], f"任务已中止：\n#{job['id']} {job['file_name']}\n\n{e}\n\n队列中等待：{get_queue_size()} 个")
        except Exception as e:
            edit(job["chat_id"], job["progress_message_id"], f"任务失败：\n#{job['id']} {job['file_name']}\n\n错误：{e}\n\n队列中等待：{get_queue_size()} 个")
            print("worker error:", repr(e), flush=True)
        finally:
            if should_delete and src and Path(src).exists():
                try:
                    Path(src).unlink()
                except Exception:
                    pass
            with queue_cond:
                current_job = None
                queue_cond.notify_all()

def initialize_offset():
    last = get_last_update_id()
    if last is not None:
        return int(last) + 1
    if not SKIP_OLD:
        return 0
    try:
        res = api("getUpdates", {"timeout": 0, "limit": 100}, timeout=30)
        updates = res.get("result", [])
        if updates:
            max_id = max(u["update_id"] for u in updates)
            set_last_update_id(max_id)
            return max_id + 1
    except Exception as e:
        print("initialize_offset error:", repr(e), flush=True)
    return 0

def polling_loop():
    offset = initialize_offset()
    print(f"polling started, offset={offset}", flush=True)
    while True:
        try:
            res = api("getUpdates", {"offset": offset, "timeout": 50, "allowed_updates": ["message"]}, timeout=70)
            for upd in res.get("result", []):
                update_id = upd["update_id"]
                offset = update_id + 1
                set_last_update_id(update_id)
                msg = upd.get("message") or {}
                if msg:
                    handle_message(msg)
        except Exception as e:
            print("polling error:", repr(e), flush=True)
            time.sleep(5)

def main():
    print("tg-uploader started", flush=True)
    worker = threading.Thread(target=worker_loop, daemon=True)
    worker.start()
    polling_loop()

if __name__ == "__main__":
    main()
PY

检查语法：

chmod +x /opt/tg-bot-uploader/tg_uploader.py
python3 -m py_compile /opt/tg-bot-uploader/tg_uploader.py

创建 systemd：

cat > /etc/systemd/system/tg-uploader.service <<'EOF'
[Unit]
Description=Telegram file uploader to rclone remote
After=network-online.target docker.service
Wants=network-online.target

[Service]
Type=simple
EnvironmentFile=/opt/tg-bot-uploader/.env
WorkingDirectory=/opt/tg-bot-uploader
ExecStart=/usr/bin/python3 /opt/tg-bot-uploader/tg_uploader.py
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable --now tg-uploader
journalctl -u tg-uploader -f

10.5 机器人命令

/help
查看帮助

/dir
查看当前上传目录

/setdir gdrive:TelegramUploads/待整理
设置上传目录

/setdir gdrive:媒体/电视剧/剧名 (年份)/Season 01
切换到指定目录

/status
查看当前任务

/queue
查看等待队列

/cancel
中止当前正在上传的任务

/clear
清空等待队列

11. EmbyPulse 管理方案

EmbyPulse 适合需要 Web 管理面板、用户中心、统计、播放排行等功能的场景。

11.1 Emby 里安装 Playback Reporting

Emby 后台：

管理服务器
插件
目录 / Catalog
搜索 Playback Reporting
安装
重启 Emby

11.2 创建 Emby API Key

管理服务器
服务器
API
新增 API Key
名称：EmbyPulse

11.3 部署 EmbyPulse

mkdir -p /opt/embypulse/config
mkdir -p /opt/embypulse/data
mkdir -p /opt/media-stack/embypulse
cd /opt/media-stack/embypulse

.env：

cat > .env <<'EOF'
LOCAL_ADMIN_USERNAME=admin
LOCAL_ADMIN_PASSWORD=这里改成强密码

EMBY_HOST=http://host.docker.internal:8096
EMBY_API_KEY=这里填Emby_API_Key
EOF

chmod 600 .env

docker-compose.yml：

services:
  emby-pulse:
    image: zeyu8023/embypulse-pro:latest
    container_name: emby-pulse
    restart: unless-stopped
    ports:
      - "127.0.0.1:10307:10307"
      - "127.0.0.1:10308:10308"
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - /opt/embypulse/config:/workspace/config
      - /opt/embypulse/data:/workspace/data
    environment:
      TZ: Asia/Shanghai
      PORT: "10307"
      REQUEST_PORT: "10308"
      LOCAL_AUTH_ENABLED: "true"
      LOCAL_ADMIN_USERNAME: "${LOCAL_ADMIN_USERNAME}"
      LOCAL_ADMIN_PASSWORD: "${LOCAL_ADMIN_PASSWORD}"
      EMBY_HOST: "${EMBY_HOST}"
      EMBY_API_KEY: "${EMBY_API_KEY}"

启动：

docker compose pull
docker compose up -d
docker logs --tail=100 emby-pulse

Caddy 反代：

admin.example.com {
  reverse_proxy 127.0.0.1:10307
}

user.example.com {
  reverse_proxy 127.0.0.1:10308
}

12. EmbyTGBot 管理方案

EmbyTGBot 适合通过 Telegram 管理 Emby 用户。

12.1 准备

需要：

Emby API Key
Emby 模板用户 testone
管理员 Bot Token
客户端 Bot Token
管理员 Telegram ID

Emby 创建模板用户：

用户名：testone
用途：新用户复制它的权限和配置

12.2 部署

mkdir -p /opt/emby_tg_admin
cd /opt/emby_tg_admin

git clone https://github.com/sd87671067/EmbyTGBot.git EmbyTGBot
cd /opt/emby_tg_admin/EmbyTGBot

cp .env.example .env
chmod 600 .env

生成密钥：

openssl rand -hex 32

编辑 .env：

APP_NAME=Emby TG 管理中心
APP_ENV=production
APP_PORT=18080
APP_BASE_URL=http://127.0.0.1:18080
APP_TIMEZONE=Asia/Shanghai
APP_MASTER_KEY=这里填openssl生成的字符串

APP_WEB_ADMIN_USERNAME=admin
APP_WEB_ADMIN_PASSWORD=一个强密码

EMBY_BASE_URL=http://host.docker.internal:8096
EMBY_API_KEY=Emby_API_Key

EMBY_SERVER_PUBLIC_URL=http://play1.example.com:8096,https://play2.example.com

EMBY_TEMPLATE_USER=testone
EMBY_IMPORT_IGNORE_USERNAMES=admin,testone
EMBY_SYNC_LOCAL_DEFAULT_PASSWORD=1234

ADMIN_BOT_TOKEN=管理员BotToken
ADMIN_CHAT_IDS=你的Telegram数字ID

CLIENT_BOT_TOKEN=客户端BotToken

ADMIN_CONTACT_TG_USERNAME=@你的TG用户名
ADMIN_CONTACT_TG_USER_ID=你的Telegram数字ID

DEFAULT_USER_EXPIRE_DAYS=90
REGISTER_CODE_LENGTH=16
CODE_BATCH_LIMIT=500
WEB_EXPIRING_SOON_DAYS=3
EXPIRY_CHECK_SECONDS=3600
ONLINE_CHECK_SECONDS=60

修改 docker-compose.yml，给容器访问宿主机 Emby：

extra_hosts:
  - "host.docker.internal:host-gateway"

启动：

docker compose up -d --build
docker logs -f --tail=120 emby_tg_admin

12.3 常见问题

Bot Token 无效

日志：

TokenValidationError: Token is invalid!

检查：

source .env
curl "https://api.telegram.org/bot${ADMIN_BOT_TOKEN}/getMe"
curl "https://api.telegram.org/bot${CLIENT_BOT_TOKEN}/getMe"

ARM64 镜像问题

Emby 本体需要 ARM64 镜像：

image: emby/embyserver_arm64v8:latest
platform: linux/arm64/v8

查询有效用户只显示一个

可以确认 SQLite 数据：

python3 - <<'PY'
import sqlite3
from pathlib import Path

for db in Path("data").rglob("*.db"):
    print(f"\n===== {db} =====")
    conn = sqlite3.connect(db)
    cur = conn.cursor()
    for t in [r[0] for r in cur.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")]:
        cols = [r[1] for r in cur.execute(f'PRAGMA table_info("{t}")')]
        if "username" in cols:
            print(f"\n--- {t} ---")
            cur.execute(f'SELECT * FROM "{t}"')
            for row in cur.fetchall():
                print(row)
    conn.close()
PY

如果数据库里有多个用户，但机器人只显示一个，需要修正 send_users_page 函数或等待项目更新。

服务地址一行显示两个 URL

可以把客户端显示改成：

服务地址：
直连线路：http://play1.example.com:8096
CF线路：https://play2.example.com

核心逻辑是把逗号分隔的 EMBY_SERVER_PUBLIC_URL 格式化成多行。

13. Foam 卸载

如果之前部署过 Foam，可以这样卸载：

cd /opt/media-stack/foam 2>/dev/null || true

if [ -f docker-compose.yml ]; then
  docker compose down --remove-orphans
fi

docker rm -f foam foam-api foam-mysql foam-redis foam-selenium 2>/dev/null || true

mkdir -p /root/backup
if [ -d /opt/media-stack/foam ]; then
  tar -czf /root/backup/foam-backup-$(date +%F-%H%M%S).tar.gz /opt/media-stack/foam
fi

rm -rf /opt/media-stack/foam
docker image prune -f

清理 Caddy 中 Foam 域名反代：

grep -R "foam" -n /etc/caddy 2>/dev/null || true
vim /etc/caddy/conf.d/media-stack.caddy
caddy validate --config /etc/caddy/Caddyfile
systemctl reload caddy

14. 启停与维护

14.1 停止全部服务

docker stop embyserver 2>/dev/null || true
docker stop emby_tg_admin 2>/dev/null || true
docker stop telegram-bot-api 2>/dev/null || true

systemctl stop tg-uploader 2>/dev/null || true

14.2 重启全部服务

systemctl restart rclone-gdrive

cd /opt/media-stack/emby
docker compose up -d --force-recreate

cd /opt/emby_tg_admin/EmbyTGBot
docker compose up -d --force-recreate

cd /opt/tg-bot-uploader
docker compose up -d --force-recreate

systemctl restart tg-uploader
systemctl reload caddy

14.3 查看日志

docker logs -f --tail=100 embyserver
docker logs -f --tail=100 emby_tg_admin
docker logs -f --tail=100 telegram-bot-api
journalctl -u tg-uploader -f
journalctl -u rclone-gdrive -n 100 --no-pager

14.4 更新 Emby

cd /opt/media-stack/emby
docker compose pull
docker compose up -d

14.5 更新 EmbyTGBot

cd /opt/emby_tg_admin/EmbyTGBot
git pull --ff-only
docker compose up -d --build

14.6 更新上传机器人

cd /opt/tg-bot-uploader
docker compose pull
docker compose up -d
systemctl restart tg-uploader

15. 备份

mkdir -p /root/backup

tar -czf /root/backup/media-server-backup-$(date +%F).tar.gz \
  /opt/media-stack \
  /opt/media/emby/config \
  /opt/tg-bot-uploader \
  /opt/emby_tg_admin/EmbyTGBot/.env \
  /opt/emby_tg_admin/EmbyTGBot/data \
  /root/.config/rclone \
  /etc/systemd/system/rclone-gdrive.service \
  /etc/systemd/system/tg-uploader.service \
  /etc/caddy

重点备份：

/opt/media/emby/config
/root/.config/rclone/rclone.conf
/opt/tg-bot-uploader/.env
/opt/tg-bot-uploader/state.json
/opt/emby_tg_admin/EmbyTGBot/.env
/opt/emby_tg_admin/EmbyTGBot/data
/etc/caddy

16. 最终推荐使用流程

日常新增资源：

1. Telegram 上传机器人：
   /setdir gdrive:TelegramUploads/待整理

2. 把资源作为文件发送给机器人

3. 上传完成后，用 rclone moveto 整理到正式目录：
   gdrive:媒体/电影
   gdrive:媒体/电视剧
   gdrive:媒体/动漫

4. Emby 扫描媒体库

5. 如果识别错误，在 Emby 中手动 Identify

用户管理：

方式 A：EmbyPulse Web 面板
方式 B：EmbyTGBot Telegram 管理

播放线路：

首选：直连线路 / 灰云域名
备用：IP:8096
管理：Cloudflare 橙云域名

17. 总结

这套系统的核心原则是：

Emby 只负责播放和刮削
rclone 负责把网盘挂成本地目录
Telegram 上传机器人负责收资源和上传网盘
EmbyPulse 或 EmbyTGBot 负责用户管理
Caddy 和 Cloudflare 负责访问线路

如果想稳定，最重要的是三点：

1. 媒体文件命名规范
2. 播放线路不要长期走 Cloudflare 橙云
3. rclone 使用自己的 Google Drive client_id

把这三点做好，整套 Emby + 网盘媒体库的体验会稳定很多。

使用哪吒面板为 VPS 配置 Cloudflare DDNS

Sun, 03 May 2026 00:00:00 GMT

:::note 本文记录的是：使用哪吒面板把 VPS 的公网 IP 自动同步到 Cloudflare DNS。适合家宽、动态 IP VPS、NAT 后端、经常重装或迁移 IP 的机器。 :::

一、先说结论

如果你想给 VPS 配置 Cloudflare DDNS，目前更推荐使用：

哪吒面板 + Cloudflare API Token

哪吒面板可以在 Agent 上报新 IP 后，由 Dashboard 自动更新 Cloudflare 里的 DNS 记录。

而 Komari 目前更偏向监控面板，并没有像哪吒面板一样内置 Cloudflare DDNS 功能。如果你使用 Komari，可以搭配 ddns-go 或自写脚本来完成 DDNS。

二、准备工作

你需要提前准备好：

一个已经托管到 Cloudflare 的域名
一台已经接入哪吒 Agent 的 VPS
一个 Cloudflare API Token
哪吒 Dashboard 管理员权限

本文假设你的主域名是：

example.com

准备用来指向 VPS 的 DDNS 域名是：

vps.example.com

:::tip 实际操作时，请把 example.com 和 vps.example.com 换成你自己的域名。 :::

三、在 Cloudflare 里准备 DNS 记录

进入 Cloudflare 后，选择你的域名，然后进入：

DNS → Records

如果你只需要 IPv4，添加一条 A 记录：

类型：A
名称：vps
内容：先填当前 VPS IPv4，或者临时填一个占位 IP
代理状态：DNS only / 仅 DNS / 灰云
TTL：Auto 或 1 分钟

如果你还需要 IPv6，再添加一条 AAAA 记录：

类型：AAAA
名称：vps
内容：先填当前 VPS IPv6，或者临时填一个占位 IPv6
代理状态：DNS only / 仅 DNS / 灰云
TTL：Auto 或 1 分钟

:::warning 如果这个域名是用来连接 SSH、VPS 面板、代理服务、游戏服或其他非 HTTP 服务，建议使用灰云，也就是 DNS only。不要开启 Cloudflare 橙云代理，否则可能导致真实端口无法连接。 :::

四、创建 Cloudflare API Token

进入 Cloudflare 账号设置：

右上角头像
→ My Profile
→ API Tokens
→ Create Token

可以使用 Edit zone DNS 模板，也可以自定义 Token。

权限建议设置为：

Zone → Zone → Read
Zone → DNS → Edit

资源范围建议限制到指定域名：

Include → Specific zone → example.com

创建后，Cloudflare 会显示一次 API Token。

:::caution Cloudflare API Token 只会显示一次，请立即复制保存。不要把 Token 发到公开群聊、博客正文、GitHub 仓库或截图里。 :::

五、在哪吒面板添加 DDNS 配置

登录哪吒 Dashboard，进入：

动态域名解析
→ 新配置

按照下面这样填写：

名称：Cloudflare-DDNS
DDNS 供应商：cloudflare
域名：vps.example.com
最大重试次数：3
DDNS 凭据 1：留空
DDNS 凭据 2：填写 Cloudflare API Token
启用 DDNS IPv4：如果需要更新 A 记录就勾选
启用 DDNS IPv6：如果需要更新 AAAA 记录就勾选

:::important 使用 Cloudflare 作为 DDNS 供应商时，DDNS 凭据 1 一般留空，DDNS 凭据 2 填 Cloudflare API Token。 :::

如果你要同时更新多个域名，可以用英文逗号分隔：

vps.example.com,node1.example.com,home.example.com

六、把 DDNS 配置绑定到指定 VPS

添加 DDNS 配置后，还需要把它绑定到具体的服务器。

进入：

服务器
→ 找到目标 VPS
→ 编辑

然后开启：

启用 DDNS

并选择刚才创建的配置：

Cloudflare-DDNS

保存后，哪吒会在 Agent 上报 IP 变化时，自动更新 Cloudflare DNS 记录。

七、检查 DDNS 是否生效

可以先在哪吒面板里看日志：

日志

正常情况下，应该能看到类似内容：

正在尝试更新域名(vps.example.com)DDNS
尝试更新域名(vps.example.com)DDNS成功

也可以在本地终端检查解析结果。

检查 IPv4：

dig vps.example.com A +short

检查 IPv6：

dig vps.example.com AAAA +short

或者使用：

nslookup vps.example.com

如果返回的 IP 和 VPS 当前公网 IP 一致，就说明 DDNS 已经正常工作。

八、哪吒多久检测一次 IP？

哪吒不是秒级实时检测。默认情况下，Agent 的 IP 上报间隔通常是：

1800 秒，也就是 30 分钟

也就是说，默认逻辑大概是：

VPS 公网 IP 变化
→ Agent 下次上报新 IP
→ Dashboard 根据 DDNS 配置更新 Cloudflare DNS

所以默认情况下，IP 变化后可能需要最多约 30 分钟才会被发现。

如果你想让它更及时，可以修改 Agent 的 IP 上报间隔。

例如改成 60 秒：

ip_report_period: 60

修改完成后重启哪吒 Agent：

sudo systemctl restart nezha-agent.service

推荐值：

普通 VPS：300 秒，也就是 5 分钟
希望更快发现 IP 变化：60 秒
不建议长期使用 30 秒，除非确实需要非常快

:::note 哪吒更新 Cloudflare DNS 记录后，客户端实际解析到新 IP 的时间还会受 DNS TTL 和本地 DNS 缓存影响。Cloudflare 里建议把相关记录的 TTL 设置为 Auto 或 1 分钟。 :::

九、IP 变化后可以收到通知吗？

可以。哪吒面板可以配置 IP 变更通知。

大致入口是：

右上角头像
→ 系统设置
→ 系统配置
→ IP 变更提醒

配置项一般包括：

覆盖范围：监控全部服务器，或只监控指定服务器
特定服务器：选择需要包含或排除的服务器
提醒发送至通知分组：选择已经配置好的通知组
启用功能：开启
通知中显示完整 IP 地址：按需开启

在配置 IP 变更提醒之前，需要先配置通知方式。

进入：

通知

然后添加你想使用的推送方式，例如：

Telegram
Bark
Server 酱
企业微信
飞书
Slack
邮件

最终效果大概是：

VPS 公网 IP 变化
→ 哪吒 Agent 检测并上报新 IP
→ 哪吒 Dashboard 更新 Cloudflare DNS
→ 哪吒发送 IP 变更通知

:::tip 如果你找不到 IP 变更提醒，不要只在 通知 页面找。通知页面通常只是创建通知方式和通知组，IP 变更提醒本身一般在 系统设置 → 系统配置 里。 :::

十、为什么我找不到 IP 变更提醒？

如果后台里看不到相关设置，可以按下面几个方向排查。

1. 是否使用管理员账号登录

IP 变更提醒属于系统配置，普通账号可能看不到。

请使用管理员账号登录后台后再查看：

右上角头像
→ 系统设置
→ 系统配置

2. 是否在错误页面查找

很多人会去：

通知

里面找 IP 变更提醒。

但这个页面一般只是用来配置通知方式，例如 Telegram、Bark、邮件等。真正的 IP 变更提醒通常在系统设置里。

3. 是否界面语言不同

如果你使用英文界面，可能会显示为类似：

IP Change Notification

可以在系统设置页面用浏览器搜索：

Ctrl + F

然后搜索：

IP

4. 是否哪吒版本较旧或使用了第三方改版

不同版本、不同主题、不同第三方镜像的菜单位置可能不完全一样。

如果确实找不到，建议先查看当前面板版本，或者更新到官方较新的版本后再看。

十一、Komari 有类似功能吗？

目前 Komari 没有像哪吒面板这样内置 Cloudflare DDNS 的功能。

Komari 更偏向服务器监控，虽然可以配合 Cloudflare Tunnel 暴露面板，也有一些社区工具可以把节点 IP 同步到 Git，但这些都不等于 Cloudflare DDNS。

简单对比：

面板	是否内置 Cloudflare DDNS	适合用途
哪吒面板	支持	监控 + DDNS + 通知
Komari	暂不支持	轻量监控
Komari + ddns-go	支持，靠 ddns-go 实现	监控和 DDNS 分开管理

如果你使用 Komari，但也想做 Cloudflare DDNS，可以使用：

Komari + ddns-go

或者：

Komari + 自写 Cloudflare API 脚本 + cron

:::tip 如果只是为了 VPS 动态解析域名，ddns-go 会更直接；如果你已经在用哪吒面板，则直接用哪吒内置 DDNS 更省事。 :::

十二、常见问题排查

Cloudflare DNS 没有更新

优先检查：

Cloudflare API Token 是否正确
Token 是否有 Zone Read 和 DNS Edit 权限
Token 的资源范围是否包含当前域名
哪吒 DDNS 配置里供应商是否选择 cloudflare
DDNS 凭据 2 是否填写了 Token
目标服务器是否启用了 DDNS

DDNS 日志显示失败

可以先确认 Token 权限：

Zone → Zone → Read
Zone → DNS → Edit

再确认域名确实托管在 Cloudflare，并且 DNS 记录已经存在。

IPv6 没有更新

检查 VPS 是否真的有公网 IPv6：

ip -6 addr

也可以测试公网 IPv6：

curl -6 ip.sb

如果 VPS 没有公网 IPv6，就不要勾选 启用 DDNS IPv6。

更新成功但访问还是旧 IP

这通常是 DNS 缓存问题。

可以尝试：

dig vps.example.com A +short @1.1.1.1
dig vps.example.com A +short @8.8.8.8

如果公共 DNS 已经返回新 IP，但你本地还是旧 IP，可以清理本地 DNS 缓存，或者等待 TTL 过期。

开了橙云后连不上

如果你是用这个域名连接 SSH、代理服务、游戏服或自定义端口，请把 Cloudflare 代理状态改成：

DNS only / 灰云

不要使用橙云代理。

十三、推荐配置总结

我个人比较推荐这样配置：

Cloudflare DNS：灰云
TTL：Auto 或 1 分钟
哪吒 DDNS：启用 IPv4，按需启用 IPv6
Agent IP 上报间隔：300 秒
需要快速通知：改为 60 秒
IP 变更通知：开启

如果你的 VPS IP 经常变动，建议使用：

ip_report_period: 60

如果 IP 很少变化，只是防止偶尔变动，可以使用：

ip_report_period: 300

十四、完整流程回顾

最后把完整流程压缩成一张清单：

1. Cloudflare 中添加 A / AAAA 记录
2. 创建 Cloudflare API Token
3. Token 权限设置为 Zone Read + DNS Edit
4. 哪吒 Dashboard 添加 Cloudflare DDNS 配置
5. DDNS 凭据 2 填写 Cloudflare API Token
6. 到服务器编辑页启用 DDNS
7. 检查日志是否更新成功
8. 根据需要调整 ip_report_period
9. 配置通知方式
10. 开启 IP 变更提醒

这样配置完成后，VPS 公网 IP 变化时，哪吒就可以自动更新 Cloudflare DNS，并在检测到 IP 变化后给你发送通知。

Debian 12 VPS + Modal 部署 Docker 完整教程（免费额度内）

Mon, 27 Apr 2026 00:00:00 GMT

这篇文章基于 Modal 官方文档和官方定价页整理，目标是：用一台全新的 Debian 12 VPS 当作控制端，在 Modal 上部署一个 Docker 镜像，并把费用控制在免费额度内。

先说结论

如果你的目标是：

部署后服务一直可访问
尽量像“常驻”一样保持在线
每月不超过 Modal Starter 的免费额度

那么最稳的方案是：

使用 modal deploy 做持久部署
用 modal.Image.from_registry() 直接引用现成镜像
资源固定为 cpu=0.125 + memory=128
配置 min_containers=1、max_containers=1、buffer_containers=0
不要指定区域，除非你真的有延迟或合规需求

这套配置在 31 天整月 24x7 的最保守口径下，单个常驻热容器大约是：

不指定区域：约 $5.13/月
1.25x 区域：约 $6.41/月
2.5x 区域：约 $12.82/月

而 Modal Starter 当前自带 $30/月 免费 compute credits，所以一个最小规格的常驻热容器是明显在免费额度内的。

你需要知道的 3 个前提

1）你的 Debian 12 VPS 只是“控制端”

Modal 的工作方式不是“在你的 VPS 上一直跑 Docker 守护进程”，而是：

你在 VPS 上安装 Modal CLI
你在 VPS 上执行 modal deploy
真正的容器由 Modal 在云端运行

所以这台 Debian 12 VPS 更像“部署控制台”，不是运行容器的宿主机。

2）“保持运行”不等于“同一个容器永不重启”

@modal.web_server(...) 本质上仍然属于 Modal 的 Web Endpoint，底层是自动扩缩容的容器池。把 min_containers=1 打开后，可以做到：

服务一直有 URL
至少保留 1 个 warm container
空闲时不缩到 0

但它不保证永远是同一个容器。你应该把它理解成“服务持续可用”，而不是“这一台容器永不被替换”。

3）为什么这套方案能控制在免费额度内

Modal 当前公开价格里：

CPU：$0.0000131 / core / sec
Memory：$0.00000222 / GiB / sec
Starter：$30 / month free credits

而默认最小资源请求是：

0.125 CPU
128 MiB 内存

所以只保留 1 个最小规格热容器，即便整月不停，仍然离 $30 免费额度有比较大的安全边际。

一、在全新的 Debian 12 VPS 上安装环境

先登录你的 Debian 12 VPS，执行下面这组命令：

apt update
apt install -y python3 python3-pip python3-venv git curl

然后创建一个 Python 虚拟环境，避免污染系统环境：

python3 -m venv ~/modal-venv
source ~/modal-venv/bin/activate

安装 Modal CLI：

python -m pip install -U pip modal

初始化登录：

python -m modal setup

如果你不方便在浏览器里登录，也可以使用 Token 方式：

python -m modal token set

二、创建项目目录

mkdir -p ~/modal-docker-demo
cd ~/modal-docker-demo

三、准备你的镜像信息

这篇教程使用的是“直接引用现成镜像”的方式，也就是：

你已经有一个公开镜像，例如 Docker Hub 或 GHCR
Modal 直接从镜像仓库拉取这个镜像

最典型的形式是：

Docker Hub: your-user/your-image:latest
GHCR:      ghcr.io/your-user/your-image:latest

如果镜像本身没有合适的 Python 运行时，Modal 官方支持在 from_registry() 里通过 add_python="3.11" 补进去。

四、写一份“免费额度内、尽量常驻”的 `modal_app.py`

下面这份是本文的推荐配置。

你只需要改 4 个地方：

APP_NAME
IMAGE_REF
PORT
START_CMD

把下面内容保存成 modal_app.py：

import os
import subprocess
import modal

APP_NAME = "docker-on-modal-min"
IMAGE_REF = "ghcr.io/your-user/your-image:latest"   # 改成你的镜像
PORT = 3000                                           # 改成你的容器实际监听端口
START_CMD = ["node", "index.js"]                    # 改成你的启动命令

app = modal.App(APP_NAME)

image = modal.Image.from_registry(
    IMAGE_REF,
    add_python="3.11",  # 让现成镜像更容易兼容 Modal Function
)

@app.function(
    image=image,
    cpu=0.125,
    memory=128,
    min_containers=1,
    max_containers=1,
    buffer_containers=0,
    timeout=24 * 60 * 60,
)
@modal.web_server(PORT)
def serve():
    print("provider =", os.environ.get("MODAL_CLOUD_PROVIDER"))
    print("region   =", os.environ.get("MODAL_REGION"))
    subprocess.Popen(START_CMD)

这份配置为什么这样写

`cpu=0.125` + `memory=128`

这是 Modal 当前默认最小资源请求。显式写出来有两个好处：

成本预估更清楚
后面自己回看代码时不会误会

`min_containers=1`

这会让函数至少保留 1 个 warm container，即使没有请求，也不会缩到 0。对于“希望尽量持续在线”的场景，这个参数最关键。

`max_containers=1`

这会把容器上限固定为 1，避免流量稍微高一点就自动扩成多个容器，从而出现意外账单。

`buffer_containers=0`

不预留额外容器。因为我们这篇教程的目标是免费额度内稳定运行，不是极致低延迟。

`timeout=24 * 60 * 60`

Modal Function 默认执行超时是 300 秒。手动拉到 24 小时，是为了尽量减少过早回收带来的不确定性。

为什么这里没有写 `region`

因为只要你显式指定区域，就会触发区域价格乘数：

US / EU / UK / AP：1.25x
CA / SA / ME / MX / AF：2.5x

如果你的目标是“优先稳在免费额度内”，那么不指定区域最省钱。

五、部署到 Modal

确保你当前还在虚拟环境里：

source ~/modal-venv/bin/activate

执行部署：

python -m modal deploy modal_app.py

部署完成后，Modal 会为这个 Web Endpoint 分配可访问的 URL。即使你关闭 SSH 会话，这个部署本身仍然存在。

六、如何查看日志、状态和停止部署

查看 App 列表

python -m modal app list

实时查看日志

python -m modal app logs docker-on-modal-min -f

查看容器列表

python -m modal container list

查看某个容器日志

python -m modal container logs ta-xxxxxxxx -f

停止部署

python -m modal app stop docker-on-modal-min

注意：modal app stop 是永久停止当前部署，后面如果还要跑，需要重新 modal deploy。

七、怎么确认费用不会超出免费额度

方案 A：本文推荐的“常驻热容器版”

配置：

cpu=0.125
memory=128
min_containers=1
max_containers=1
不指定区域

按 31 天整月不停机 来算，约 $5.13/月。

这比 Starter 自带的 $30/月 免费 credits` 低很多，所以长期放 1 个最小规格热容器是安全的。

方案 B：如果你必须指定区域

如果你写：

region="ap"

那么会触发 1.25x 的区域乘数。此时单个最小规格热容器大约 $6.41/月。

如果是 2.5x 的区域类别，则约 $12.82/月。

结论依然是：

1 个最小规格热容器，即便指定区域，仍然通常在免费额度内
不要把 max_containers 调大，否则费用会开始线性上涨

方案 C：如果你更在意费用，而不是“热容器常驻”

把 min_containers=1 去掉：

@app.function(
    image=image,
    cpu=0.125,
    memory=128,
    max_containers=1,
    buffer_containers=0,
    timeout=24 * 60 * 60,
)

这时服务仍然是持久部署，URL 一直有效，但容器在空闲时会缩到 0。这样通常更便宜，不过首次请求会有冷启动。

如果你只是个人项目、低频访问站点，实际上这是最省钱的方案。

八、如何查看本月账单

python -m modal billing report --for "this month"

如果你想看今天的小时级用量：

python -m modal billing report --for today -r h

建议你在刚部署后的前几天每天看一次账单，确认没有因为镜像本身的高负载把 CPU 或内存实际使用拉高。

Modal 官方文档写明：CPU 和内存是按“请求值”和“实际使用值”里更高的那个计费。

九、常见问题

Q1：为什么我已经 `modal deploy` 了，但感觉容器还是会变？

因为 Modal 的核心模型不是传统 VPS，而是服务持续存在、容器由平台调度维护。min_containers=1 只能保证有至少 1 个 warm container，不代表某个容器实例永远不被替换。

Q2：为什么我不推荐一开始就锁到 Tokyo、Seoul 这类更细区域？

因为区域越细，资源池越小；官方也建议优先使用更宽泛的区域，这通常会更有利于可用性和冷启动表现。并且一旦显式指定区域，就会引入价格乘数。

Q3：为什么我不用自己的 Docker 直接在 VPS 上跑？

当然可以，但那是另一条路线。本文这条路的核心价值是：

用 VPS 只做“控制台”
把运行、扩缩容、日志、部署 URL 交给 Modal
省掉自己维护公网服务、进程守护和扩缩容的工作

Q4：如果我想把现成 Dockerfile 直接丢给 Modal 呢？

也可以，Modal 还支持 modal.Image.from_dockerfile("./Dockerfile")。但如果你已经有 GHCR / Docker Hub 镜像，直接 from_registry() 通常更省事。

十、一份可直接复制的完整流程

1）安装环境

apt update
apt install -y python3 python3-pip python3-venv git curl
python3 -m venv ~/modal-venv
source ~/modal-venv/bin/activate
python -m pip install -U pip modal
python -m modal setup

2）创建项目

mkdir -p ~/modal-docker-demo
cd ~/modal-docker-demo

3）写 `modal_app.py`

import os
import subprocess
import modal

APP_NAME = "docker-on-modal-min"
IMAGE_REF = "ghcr.io/your-user/your-image:latest"
PORT = 3000
START_CMD = ["node", "index.js"]

app = modal.App(APP_NAME)

image = modal.Image.from_registry(
    IMAGE_REF,
    add_python="3.11",
)

@app.function(
    image=image,
    cpu=0.125,
    memory=128,
    min_containers=1,
    max_containers=1,
    buffer_containers=0,
    timeout=24 * 60 * 60,
)
@modal.web_server(PORT)
def serve():
    print("provider =", os.environ.get("MODAL_CLOUD_PROVIDER"))
    print("region   =", os.environ.get("MODAL_REGION"))
    subprocess.Popen(START_CMD)

4）部署

source ~/modal-venv/bin/activate
python -m modal deploy modal_app.py

5）看日志

python -m modal app logs docker-on-modal-min -f

6）看账单

python -m modal billing report --for "this month"

最后的建议

如果你只有一个小站点、一个小 API，或者只是想把一个 Docker 镜像稳定挂在公网：

优先用最小资源：0.125 CPU + 128 MiB
优先锁死容器数：max_containers=1
想更像常驻就加：min_containers=1
想更省钱就去掉：min_containers=1
没有强需求就不要指定区域

这样做，基本就能在 Modal 的免费额度内，把一个最小规格的 Docker 服务长期挂住。

参考资料

Modal 官方文档总览：https://modal.com/docs/guide
使用现成镜像：https://modal.com/docs/guide/existing-images
图片与镜像 API：https://modal.com/docs/reference/modal.Image
Web endpoints：https://modal.com/docs/guide/webhooks
modal.web_server：https://modal.com/docs/reference/modal.web_server
部署管理：https://modal.com/docs/guide/managing-deployments
modal app CLI：https://modal.com/docs/reference/cli/app
modal container CLI：https://modal.com/docs/reference/cli/container
资源配置与计费：https://modal.com/docs/guide/resources
自动扩缩容：https://modal.com/docs/guide/scale
冷启动与 warm container：https://modal.com/docs/guide/cold-start
区域选择：https://modal.com/docs/guide/region-selection
Function 超时：https://modal.com/docs/guide/timeouts
Pricing：https://modal.com/pricing

Debian12 VPS 添加 HE IPv6 隧道并保持运行

Sun, 26 Apr 2026 00:00:00 GMT

:::important 请注意，本文适用于 Debian 12 纯 IPv4 VPS。如果你的 VPS 已经自带原生 IPv6，一般不需要使用 HE Tunnelbroker。

本文方案不会接管主网卡，也不会重启主网络服务，目的是尽量避免远程 SSH 断连。 :::

操作环境：Debian 12 KVM VPS / 仅 IPv4 入口
目标：给纯 IPv4 VPS 添加 HE Tunnelbroker IPv6，并在重启后自动恢复
核心方案：ifupdown v4tunnel + systemd timer watchdog

一、准备 HE Tunnelbroker 参数

先到 HE Tunnelbroker 创建一个 Regular Tunnel。

创建完成后，在隧道详情页记录下面 4 个核心参数：

Server IPv4 Address
Client IPv4 Address
Server IPv6 Address
Client IPv6 Address

例如：

Server IPv4 Address: 74.82.46.6
Client IPv4 Address: 162.43.91.133
Server IPv6 Address: 2001:470:23:543::1/64
Client IPv6 Address: 2001:470:23:543::2/64

脚本里填写 IPv6 时，不要带 /64 后缀，例如：

2001:470:23:543::2
2001:470:23:543::1

:::important HE 的 6in4 隧道使用的是 IPv4 protocol 41，不是 TCP 41 端口，也不是 UDP 41 端口。

如果 VPS 服务商或上游网络不放行 protocol 41，隧道接口可能能创建成功，但 IPv6 不会真正通。 :::

二、确认 VPS 当前公网 IPv4

在 VPS 上执行：

ip -4 addr
ip route

如果已经安装 curl，也可以查看公网出口 IP：

curl -4 https://ifconfig.co

确认结果要和 HE 后台的 Client IPv4 Address 一致。

如果不一致，需要先在 HE 后台修改 Client IPv4 Address，否则隧道不会正常回包。

三、一键安装脚本

下面脚本适合全新的 Debian 12 VPS 使用。

它会做这些事情：

安装最小依赖：ifupdown、iproute2、iputils-ping
写入 /etc/network/interfaces.d/he-ipv6
只拉起 he-ipv6 隧道，不重启主网卡
启用 networking，保证重启后自动拉起
创建 systemd timer，每 2 分钟检查一次 IPv6，不通则自动重建隧道

:::important 执行前请先修改脚本开头的 4 个参数：

CLIENT4="你的 Client IPv4"
SERVER4="HE 的 Server IPv4"
CLIENT6="你的 Client IPv6，不带 /64"
SERVER6="HE 的 Server IPv6，不带 /64"

:::

cat > /root/install-he-ipv6.sh <<'EOF'
#!/bin/sh
set -eu

TUN="he-ipv6"

# ====== 请修改下面 4 个参数 ======
CLIENT4="YOUR_CLIENT_IPV4"
SERVER4="YOUR_SERVER_IPV4"
CLIENT6="YOUR_CLIENT_IPV6"
SERVER6="YOUR_SERVER_IPV6"
# =================================

# 用于 watchdog 测试 IPv6 出网，不依赖 DNS
TEST6="2001:4860:4860::8888"

if [ "$(id -u)" != "0" ]; then
    echo "请使用 root 用户执行本脚本。"
    exit 1
fi

echo "[1/9] 检查并安装最小依赖..."
NEED_APT=0
command -v ifup >/dev/null 2>&1 || NEED_APT=1
command -v ifdown >/dev/null 2>&1 || NEED_APT=1
command -v ip >/dev/null 2>&1 || NEED_APT=1
command -v ping >/dev/null 2>&1 || NEED_APT=1

if [ "$NEED_APT" = "1" ]; then
    apt-get update
    apt-get install -y ifupdown iproute2 iputils-ping
fi

echo "[2/9] 备份现有网络配置..."
BACKUP_DIR="/root/he-ipv6-backup-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$BACKUP_DIR"
cp -a /etc/network/interfaces "$BACKUP_DIR/interfaces" 2>/dev/null || true
cp -a /etc/network/interfaces.d "$BACKUP_DIR/interfaces.d" 2>/dev/null || true

echo "[3/9] 开启 IPv6，并关闭 rp_filter 干扰..."
cat > /etc/sysctl.d/99-he-ipv6.conf <<EON
net.ipv6.conf.all.disable_ipv6=0
net.ipv6.conf.default.disable_ipv6=0
net.ipv4.conf.all.rp_filter=0
net.ipv4.conf.default.rp_filter=0
EON
sysctl -p /etc/sysctl.d/99-he-ipv6.conf >/dev/null 2>&1 || true
modprobe sit 2>/dev/null || true

echo "[4/9] 准备 /etc/network/interfaces.d ..."
mkdir -p /etc/network/interfaces.d

if [ ! -f /etc/network/interfaces ]; then
    cat > /etc/network/interfaces <<'EON'
auto lo
iface lo inet loopback

source /etc/network/interfaces.d/*
EON
else
    grep -q '^source /etc/network/interfaces.d/\*' /etc/network/interfaces 2>/dev/null || \
    echo 'source /etc/network/interfaces.d/*' >> /etc/network/interfaces
fi

echo "[5/9] 写入 HE IPv6 隧道配置..."
cat > /etc/network/interfaces.d/he-ipv6 <<EON
auto ${TUN}
iface ${TUN} inet6 v4tunnel
        address ${CLIENT6}
        netmask 64
        endpoint ${SERVER4}
        local ${CLIENT4}
        ttl 255
        gateway ${SERVER6}
        pre-up ip tunnel del ${TUN} 2>/dev/null || true
        post-down ip tunnel del ${TUN} 2>/dev/null || true
EON

echo "[6/9] 创建 watchdog 自恢复脚本..."
cat > /usr/local/sbin/he-ipv6-watchdog.sh <<EON
#!/bin/sh
set -eu

TUN="${TUN}"
TEST6="${TEST6}"

need_restart=0

if ! ip link show "\$TUN" >/dev/null 2>&1; then
    need_restart=1
fi

if ! ip -6 route show default 2>/dev/null | grep -q "dev \$TUN"; then
    need_restart=1
fi

if ! ping -6 -c 1 -W 3 "\$TEST6" >/dev/null 2>&1; then
    need_restart=1
fi

if [ "\$need_restart" = "1" ]; then
    echo "[he-ipv6-watchdog] IPv6 tunnel seems down, rebuilding..."
    ifdown --force "\$TUN" 2>/dev/null || true
    ip tunnel del "\$TUN" 2>/dev/null || true
    ifup "\$TUN" 2>/dev/null || true
else
    echo "[he-ipv6-watchdog] IPv6 tunnel is OK."
fi
EON
chmod +x /usr/local/sbin/he-ipv6-watchdog.sh

echo "[7/9] 创建 systemd timer..."
cat > /etc/systemd/system/he-ipv6-watchdog.service <<'EON'
[Unit]
Description=Check and recover HE IPv6 tunnel

[Service]
Type=oneshot
ExecStart=/usr/local/sbin/he-ipv6-watchdog.sh
EON

cat > /etc/systemd/system/he-ipv6-watchdog.timer <<'EON'
[Unit]
Description=Run HE IPv6 tunnel watchdog periodically

[Timer]
OnBootSec=60
OnUnitActiveSec=120
AccuracySec=15
Persistent=true

[Install]
WantedBy=timers.target
EON

systemctl daemon-reload

echo "[8/9] 拉起 HE IPv6 隧道，只操作 he-ipv6，不重启主网络..."
ip tunnel del "${TUN}" 2>/dev/null || true
ifdown --force "${TUN}" 2>/dev/null || true
ifup "${TUN}"

echo "[9/9] 启用开机自启和 watchdog..."
systemctl enable networking >/dev/null 2>&1 || true
systemctl enable --now he-ipv6-watchdog.timer >/dev/null

echo
echo "[OK] HE IPv6 隧道配置完成。"
echo
echo "===== tunnel ====="
ip tunnel show "${TUN}" || true
echo
echo "===== address ====="
ip -6 addr show dev "${TUN}" || true
echo
echo "===== route ====="
ip -6 route || true
echo
echo "===== test ====="
ping -6 -c 3 "${TEST6}" || true
echo
echo "如果上面的 ping 有回包，可以继续测试："
echo "  getent hosts ipv6.google.com"
echo "  ping -6 -c 3 ipv6.google.com"
echo "  curl -6 https://ifconfig.co"
EOF

chmod +x /root/install-he-ipv6.sh
/root/install-he-ipv6.sh

四、使用示例

假设你的 HE 后台信息如下：

Server IPv4 Address: 74.82.46.6
Client IPv4 Address: 162.43.91.133
Server IPv6 Address: 2001:470:23:543::1/64
Client IPv6 Address: 2001:470:23:543::2/64

那么脚本开头应改成：

CLIENT4="162.43.91.133"
SERVER4="74.82.46.6"
CLIENT6="2001:470:23:543::2"
SERVER6="2001:470:23:543::1"

然后执行：

chmod +x /root/install-he-ipv6.sh
/root/install-he-ipv6.sh

五、测试 IPv6 是否成功

先测试纯 IPv6 地址，不依赖 DNS：

ping -6 -c 3 2001:4860:4860::8888

再测试域名解析与 IPv6 出口：

getent hosts ipv6.google.com
ping -6 -c 3 ipv6.google.com
curl -6 https://ifconfig.co

如果 curl -6 https://ifconfig.co 返回你的 HE Client IPv6，例如：

2001:470:23:543::2

说明 IPv6 已经配置成功。

:::tip 有些情况下，ping -6 HE 的 Server IPv6 可能不回包，但外网 IPv6 是通的。

最终建议以这两个结果为准：

ping -6 -c 3 2001:4860:4860::8888
curl -6 https://ifconfig.co

:::

六、DNS 解析失败时的处理

如果出现这种情况：

ping -6 2001:4860:4860::8888 能通
ping -6 ipv6.google.com 不通
curl -6 https://ifconfig.co 提示 Could not resolve host

说明 IPv6 已经通了，问题只是 DNS。

可以直接写一个静态 /etc/resolv.conf：

rm -f /etc/resolv.conf

cat > /etc/resolv.conf <<'EOF'
nameserver 2001:470:20::2
nameserver 2606:4700:4700::1111
nameserver 2001:4860:4860::8888
nameserver 74.82.42.42
nameserver 1.1.1.1
nameserver 8.8.8.8
options timeout:2 attempts:2
EOF

然后重新测试：

getent hosts ipv6.google.com
ping -6 -c 3 ipv6.google.com
curl -6 https://ifconfig.co

七、查看运行状态

查看隧道：

ip tunnel show he-ipv6
ip -6 addr show dev he-ipv6
ip -6 route

查看 watchdog 定时器：

systemctl status he-ipv6-watchdog.timer --no-pager
systemctl list-timers | grep he-ipv6

查看 watchdog 日志：

journalctl -u he-ipv6-watchdog.service -n 50 --no-pager

手动重建隧道：

ifdown --force he-ipv6 2>/dev/null || true
ip tunnel del he-ipv6 2>/dev/null || true
ifup he-ipv6

八、故障排查

1. 提示 Network is unreachable

说明本机没有 IPv6 默认路由。

检查：

ip -6 route

正常应看到类似：

default via 2001:470:23:543::1 dev he-ipv6

如果没有，重新拉起隧道：

ifdown --force he-ipv6 2>/dev/null || true
ip tunnel del he-ipv6 2>/dev/null || true
ifup he-ipv6

2. IPv6 路由有了，但 ping 外网 100% 丢包

先确认 IPv4 出口是否和 HE 后台一致：

ip route get HE_SERVER_IPV4
curl -4 https://ifconfig.co

例如：

ip route get 74.82.46.6
curl -4 https://ifconfig.co

如果 curl -4 返回的 IPv4 不是 HE 后台的 Client IPv4 Address，需要去 HE 后台更新 Client IPv4。

3. 抓包确认 protocol 41 是否有回包

安装 tcpdump 后可以抓包：

apt install -y tcpdump

tcpdump -ni any 'ip proto 41 or host HE_SERVER_IPV4'

另开一个窗口执行：

ping -6 -c 3 HE_SERVER_IPV6

如果只看到：

Out IP CLIENT_IPV4 > SERVER_IPV4

没有看到：

In IP SERVER_IPV4 > CLIENT_IPV4

通常说明 HE 后台 endpoint 没生效，或者上游网络没有把 protocol 41 回包送回来。

可以尝试在 HE 后台重新保存 Client IPv4 Address，或者删除重建 tunnel。

九、卸载脚本

如果以后不用 HE IPv6，可以执行：

systemctl disable --now he-ipv6-watchdog.timer 2>/dev/null || true
rm -f /etc/systemd/system/he-ipv6-watchdog.service
rm -f /etc/systemd/system/he-ipv6-watchdog.timer
rm -f /usr/local/sbin/he-ipv6-watchdog.sh
rm -f /etc/network/interfaces.d/he-ipv6
systemctl daemon-reload

ifdown --force he-ipv6 2>/dev/null || true
ip tunnel del he-ipv6 2>/dev/null || true

十、关于 Routed /64 和 LXC 容器

HE 一般会给两段 IPv6：

Tunnel /64：用于 he-ipv6 隧道本身
Routed /64：用于分配给网站、Docker、LXC、虚拟机等业务

例如：

Tunnel Client IPv6: 2001:470:23:543::2
Routed /64:         2001:470:24:543::/64

如果以后要给 LXC 容器分配公网 IPv6，建议使用 Routed /64，不要直接使用 tunnel 的 /64。

例如：

宿主机网关：2001:470:24:543::1
容器 101： 2001:470:24:543::101
容器 102： 2001:470:24:543::102

总结

本文方案的核心是：

Debian 12 纯 IPv4 VPS
        ↓
HE Tunnelbroker 6in4
        ↓
/etc/network/interfaces.d/he-ipv6
        ↓
systemd timer 定时检查并自动恢复

它的优点是：

不重启主网络
不接管主网卡
SSH 断连风险低
重启后可自动恢复
隧道异常时会定时自修复

需要注意的是：DD 重装系统会清空系统文件，所以重装后需要重新执行本文的一键脚本。

Linux手动安装3x-ui

Thu, 02 Oct 2025 00:00:00 GMT

:::important 请注意，以下命令适用于基于Linux的系统。对于其他操作系统，操作命令可能有所不同。 <br />本教程适用Alpine、Debian、Ubuntu...... :::

操作环境：Alpine3.20 LXC 1C128M2G/nat-ipv4 <br/>目标：手动安装3x-ui

第一步：更新LXC环境

apk update
apk add curl wget unzip systemd

第二步：安装3x-ui

1. 下载3x-ui包，上传到LXC

下载地址：https://pan.yizong.de/BlogAPP/xui.tar.gz <br/>该3x-ui包为手动编译，不依赖 glibc <br/>下载后通过ssh工具上传到/opt目录

2. 开始安装

解压，并赋予可执行权限

mkdir -p /opt/3x-ui
mkdir -p /opt/3x-ui/bin
tar -xvzf /opt/xui.tar.gz -C /opt/3x-ui
cd /opt/3x-ui
chmod +x x-ui

初始化

cat <<EOF > /opt/3x-ui/bin/config.json
{
  "log": { "loglevel": "info" },
  "inbounds": [
    {
      "port": 1080,
      "protocol": "socks",
      "settings": {
        "auth": "noauth",
        "udp": true,
        "ip": "127.0.0.1"
      }
    }
  ],
  "outbounds": [
    {
      "protocol": "freedom",
      "settings": {}
    }
  ]
}
EOF

更改面板端口

cd /opt/3x-ui
./x-ui setting -port 30000

开始运行3x-ui

cd /opt/3x-ui
./x-ui

后台运行

nohup ./x-ui run > /var/log/x-ui.log 2>&1 &

:::tip 如果你的系统没有systemctl就不用执行下面这两步 :::

开机自启

cat <<EOF > /etc/systemd/system/x-ui.service
[Unit]
Description=3-XUI Panel
After=network.target

[Service]
Type=simple
ExecStart=/opt/3x-ui/x-ui run
WorkingDirectory=/opt/3x-ui
Restart=always

[Install]
WantedBy=multi-user.target
EOF

启用并启动服务

systemctl daemon-reexec
systemctl enable --now x-ui

第三步：访问并设置面板

浏览器访问：http://你的IP:30000 <br/>用户admin/密码admin 请立即修改密码

1.安装xray

点击面板系统状态-xray-后面的版本号，选择一个点击

2.更新geoip.dat

面板系统状态有个扳手，点进去只更新geoip.dat，其余不要更新 <br/>重启xray和面板即可正常使用

VPS DD Windows10精简版

Sat, 16 Aug 2025 00:00:00 GMT

:::important 请注意，以下命令适用于基于Linux的系统。对于其他操作系统，操作命令可能有所不同。 :::

操作环境：Debian12 KVM VPS 2C2G10G/ipv4 目标：dd win10精简版

第一步：更新VPS环境

Ubuntu/Debian

apt update -y && apt install -y curl socat wget sudo

第二步：开始dd win

1. 利用bin456789大佬脚本

国外服务器：

curl -O https://raw.githubusercontent.com/bin456789/reinstall/main/reinstall.sh || wget -O reinstall.sh $_

国内服务器：

curl -O https://cnb.cool/bin456789/reinstall/-/git/raw/main/reinstall.sh || wget -O reinstall.sh $_

2. 选择dd包

功能 1: 安装 Linux(不需要直接看功能2)

用户名 root 默认密码 123@@@

bash reinstall.sh anolis      7|8|23
                  rocky       8|9|10
                  oracle      8|9
                  almalinux   8|9|10
                  opencloudos 8|9|23
                  centos      9|10
                  fedora      41|42
                  nixos       25.05
                  debian      9|10|11|12|13
                  opensuse    15.6|tumbleweed
                  alpine      3.19|3.20|3.21|3.22
                  openeuler   20.03|22.03|24.03|25.03
                  ubuntu      16.04|18.04|20.04|22.04|24.04|25.04 [--minimal]
                  kali
                  arch
                  gentoo
                  aosc
                  fnos
                  redhat      --img="http://access.cdn.redhat.com/xxx.qcow2"

功能 2: DD

支持 raw vhd 格式的镜像（未压缩，或者压缩成 .gz .xz .zst .tar .tar.gz .tar.xz .tar.zst）
DD Windows 镜像时，会自动扩展系统盘，静态 IP 的机器会配置好 IP，可能首次开机几分钟后才生效
DD Linux 镜像时，不会修改镜像的任何内容

镜像网站：https://dd.wx.mk/

bash reinstall.sh dd --img "https://example.com/xxx.xz"

我用的镜像是https://dd.wx.mk/cxthhhhh/Disk_Windows_10_x64_Lite_by_CXT_v1.0.vhd.gz

最后输入reboot开始dd

:::tip 可通过多种方式（SSH、HTTP 80 端口、商家后台 VNC、串行控制台）查看安装进度。 <br />即使安装过程出错，也能通过 SSH 运行 /trans.sh alpine 安装到 Alpine。 :::

最后：dd 成功

利用win远程连接输入用户名Administrator/密码cxthhhhh.com 记得一定要改密码

部署SunPanel到VPS

Sat, 28 Jun 2025 00:00:00 GMT

在Debian12上部署Sunpanel v1.3.0并使用Caddy反向代理

:::important Sunpanel v1.3.0 为最后一个免捐赠版本，如需使用最新版请访问作者GitHub查看 :::

项目位置：https://github.com/hslr-s/sun-panel

第一步：系统环境准备

更新系统软件包并安装必要工具

sudo apt update && sudo apt upgrade -y
sudo apt install -y curl tar vim

第二步：部署 Sunpanel v1.3.0

sudo mkdir -p /opt/sunpanel
cd /opt/sunpanel
sudo rm -rf ./*

下载 Sunpanel v1.3.0 二进制文件

sudo curl -L -o sunpanel.tar.gz https://github.com/hslr-s/sun-panel/releases/download/v1.3.0/sun-panel_v1.3.0_linux_amd64.tar.gz

解压缩二进制包

sudo tar -zxvf sunpanel.tar.gz 
sudo rm sunpanel.tar.gz

ls -l
# 应该能看到一个目录：sun-panel_v1.3.0_linux_amd64

第三步：配置 Systemd 服务

sudo vim /etc/systemd/system/sunpanel.service

粘贴以下内容：

[Unit]
Description=Sunpanel Service
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/opt/sunpanel/sun-panel_v1.3.0_linux_amd64
ExecStart=/opt/sunpanel/sun-panel_v1.3.0_linux_amd64/sun-panel
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

第四步：启动服务并排除端口冲突（大概率不会出现此情况）

启动服务并设置开机自启

sudo systemctl daemon-reload
sudo systemctl start sunpanel
sudo systemctl enable sunpanel

查看运行状态

sudo systemctl status sunpanel

如果运行失败（复制问ChatGPT）：

# 查找是否端口占用
sudo ss -tulnp | grep 3002

# 终止冲突进程
sudo kill -9 <PID>

# 再次启动
sudo systemctl start sunpanel
sudo systemctl status sunpanel

第五步：安装 Caddy

# 安装 Caddy
sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/caddy-stable-archive-keyring.gpg] https://dl.cloudsmith.io/public/caddy/stable/debian any-version main" | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install -y caddy

第六步：配置 Caddy 反向代理

sudo vim /etc/caddy/Caddyfile

清空原内容并填写如下配置（请将 sun.yourdomain.com 替换为你的域名）：

sun.yourdomain.com {
    reverse_proxy localhost:3002
}

重载 Caddy 配置

sudo systemctl reload caddy

🎉 最终访问

利用cloudflare、edgeone等部署域名打开浏览器，访问你的域名，你应该可以看到 Sunpanel 的登录界面

建议定期备份database文件

哪吒面板自动上传GitHub仓库备份

Mon, 16 Jun 2025 00:00:00 GMT

此脚本为 Nezha面板每日自动备份到 GitHub 并通过 Telegram 通知

操作环境：Debian12 VPS nezha非docker安装

目标：每天凌晨 3:00（北京时间）自动

打包 /opt/nezha 为 .tar.gz

上传到 GitHub 仓库

自动清理 7 天前的旧备份

通过 Telegram Bot 推送成功/失败通知

第一步：准备工作

1. 安装所需软件

sudo apt update
sudo apt install git zip curl -y

2. 获取 GitHub Token 并新建仓库

打开 https://github.com/settings/tokens
创建一个 Classic Token
勾选权限：✅ repo
复制 Token（如：ghp_xxxxxxxxxxxxxxxxxxxxxxxx）
新建一个仓库，命名为 nezha-backup（建议私有）
仓库地址形如：https://github.com/<你的GitHub用户名>/nezha-backup.git

3. 获取 Telegram Bot Token 和 Chat ID

创建 Telegram Bot：

搜索 @BotFather，发送 /newbot
设置名称和用户名，获取 Bot Token

获取 Chat ID：

给你的 Bot 发一条消息
访问：

https://api.telegram.org/bot<你的BotToken>/getUpdates

找到 "chat":{"id":xxxxx,...}，这个 id 就是 Chat ID

第二步：创建备份脚本

1. 创建脚本文件

vim /root/nezha_backup.sh

2. 粘贴以下内容（⚠️ 替换标注内容）

#!/bin/bash set -Eeuo pipefail

===== cron 环境修正 =====

export SHELL=/bin/bash export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin export HOME=/root export LANG=C.UTF-8

====== 用户配置 START ======

GITHUB_USER="xxxxxxx" GITHUB_REPO="nezha-backup" GITHUB_TOKEN="ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" BOT_TOKEN="xxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" CHAT_ID="xxxxxxx" BACKUP_DIR="/opt/nezha" KEEP_DAYS=7

====== 用户配置 END ======

WORKDIR="/root/nezha-backup" DATE=$(date +%F) TARFILE="nezha-backup-$DATE.tar.gz"

绝对路径命令

GIT=$(command -v git) CURL=$(command -v curl) FIND=$(command -v find) TAR=$(command -v tar)

send_telegram() { local msg="$1" $CURL -s -X POST "https://api.telegram.org/bot${BOT_TOKEN}/sendMessage"
-d "chat_id=${CHAT_ID}"
-d "parse_mode=Markdown"
-d "text=${msg}" >/dev/null || true }

echo "[INFO] 初始化仓库..." if [ ! -d "$WORKDIR/.git" ]; then rm -rf "$WORKDIR" mkdir -p "$WORKDIR" $GIT clone "https://${GITHUB_USER}:${GITHUB_TOKEN}@github.com/${GITHUB_USER}/${GITHUB_REPO}.git" "$WORKDIR" || { send_telegram "⚠️ Nezha 备份失败：无法克隆仓库" exit 1 } cd "$WORKDIR" || exit 1 $GIT config user.name "$GITHUB_USER" $GIT config user.email "${GITHUB_USER}@users.noreply.github.com" $GIT config --global --add safe.directory "$WORKDIR" || true

# 检查仓库是否为空（忽略 .git 目录）
if [ -z "$($FIND "$WORKDIR" -mindepth 1 -maxdepth 1 -not -name '.git' -print -quit)" ]; then
    echo "# Nezha Backup Repo" > README.md
    $GIT add README.md
    $GIT commit -m "init repo"
    $GIT branch -M main
    $GIT push -u origin main
    echo "[INFO] 已完成 GitHub 仓库初始化"
fi

else cd "$WORKDIR" || exit 1 $GIT config --global --add safe.directory "$WORKDIR" || true $GIT pull origin main >/dev/null 2>&1 || true fi

先确保备份目录存在

if [ ! -d "$BACKUP_DIR" ]; then send_telegram "⚠️ Nezha 备份失败：备份目录不存在：$BACKUP_DIR" exit 1 fi

echo "[INFO] 打包 $BACKUP_DIR..." ERRFILE="/tmp/nezha-tar-$DATE.err"

直接输出到 WORKDIR，避免 /tmp->mv

set +e $TAR --warning=no-file-changed -czf "$WORKDIR/$TARFILE" -C "$BACKUP_DIR" . 2>"$ERRFILE" tar_ec=$? set -e

if [ $tar_ec -ne 0 ]; then if [ $tar_ec -eq 1 ]; then # 1 多为非致命警告（例如文件在读时被改动），忽略并继续 echo "[WARN] tar 返回 1（警告），继续。最后几行：" tail -n 5 "$ERRFILE" || true else # >=2 视为失败 tailmsg=$(tail -n 10 "$ERRFILE" 2>/dev/null || true) send_telegram "⚠️ Nezha 备份失败：打包错误（exit $tar_ec） $tailmsg" exit 1 fi fi

$GIT add .

删除超过 KEEP_DAYS 的旧备份

echo "[INFO] 删除超过 $KEEP_DAYS 天的旧备份..." $FIND "$WORKDIR" -name "nezha-backup-*.tar.gz" -type f -mtime +$KEEP_DAYS -exec $GIT rm -f {} ; >/dev/null 2>&1 || true

提交并推送（只有变更时才提交）

if $GIT diff --cached --quiet; then echo "[INFO] 没有新的备份文件需要提交" else $GIT commit -m "Backup on $DATE" $GIT push origin main || { send_telegram "⚠️ Nezha 备份失败：推送错误" exit 1 } send_telegram "🎉 Nezha 备份成功！ 已保存：$DATE，已自动清理超过 ${KEEP_DAYS} 天的旧备份" echo "[INFO] 备份成功" fi


---

## 第三步：设置权限

```bash
chmod +x /root/nezha_backup.sh

第四步：添加定时任务（每天北京时间凌晨 3 点）

crontab -e

添加以下内容（北京时间凌晨 3 点）：

0 3 * * * env -i HOME=/root /bin/bash /root/nezha_backup.sh >/dev/null 2>&1

保存并退出（vim：:wq；nano：Ctrl+O → Ctrl+X）

第五步：手动运行测试

手动运行

bash /root/nezha_backup.sh

假装corn运行

env -i /bin/bash -c 'HOME=/root /bin/bash /root/nezha_backup.sh'

✔️ 检查点

GitHub 仓库出现 nezha-backup-YYYY-MM-DD.tar.gz

Telegram 收到「备份成功」通知

1秒卸载哪吒探针v1

Sun, 13 Apr 2025 00:00:00 GMT

要卸载 哪吒探针V1 的监控端(Agent)，请按照以下步骤操作：

:::important 请注意，以下命令适用于基于Linux的系统。对于其他操作系统，操作命令可能有所不同。 :::

一. 一键卸载(1s完成)

cd /opt/nezha/agent/ && ./nezha-agent service uninstall && cd /root && rm -rf /opt/nezha/agent/

如果安装了多个服务并想要全部卸载，可以使用 Agent 安装脚本的卸载功能：

./agent.sh uninstall

二. 手动卸载

1. 停止 Agent 服务

首先，停止正在运行的 nezha-agent 服务。

sudo systemctl stop nezha-agent

2. 禁用开机自启

防止服务在系统启动时自动运行。

sudo systemctl disable nezha-agent

3. 删除服务文件

移除 nezha-agent 的服务配置文件。

sudo rm /etc/systemd/system/nezha-agent.service

4. 删除 Agent 文件

删除安装目录中的 Agent 文件。

sudo rm -rf /opt/nezha/agent

5. 重新加载 systemd 配置

确保系统服务管理器加载最新的配置。

sudo systemctl daemon-reload

6. 检查残留进程

确认没有遗留的 nezha-agent 进程在运行。

ps -ef | grep nezha-agent

如果发现仍有相关进程运行，请使用 kill 命令终止。

7. 删除日志文件（可选）

如果需要，您可以删除与 nezha-agent 相关的日志文件。

sudo rm -rf /var/log/nezha

三. 常用指令

停止agent指令

sudo systemctl stop nezha-agent

重启agent指令

sudo systemctl restart nezha-agent

查看agent状态

sudo systemctl status nezha-agent

搭建/卸载哪吒V1(CF-CDN)，适合纯V4/V6的VPS

Sun, 13 Apr 2025 00:00:00 GMT

本文内容整理至Nodeseek论坛与个人实践

:::important 请注意，以下命令适用于基于Linux的系统。对于其他操作系统，操作命令可能有所不同。 :::

一. Cloudflare配置

进入域名里的DNS-记录，添加记录，设置子域名前缀，ipv4添加A记录，ipv6添加AAAA记录，开启小黄云
进入SSL/TLS-概述，将加密模式改成完全(严格)
进入SSL/TLS-源服务器，以域名example.com举例，创建一个*.example.com的证书，将源证书的代码和密钥的代码分别保存好
进入网络，开启Websockets和gRPC

二. 安装哪吒面板

纯v6小鸡必需要warp创建ipv4出站才能下载代码

wget -N https://gitlab.com/fscarmen/warp/-/raw/main/menu.sh && bash menu.sh

执行安装代码，建议端口默认

curl -L https://raw.githubusercontent.com/nezhahq/scripts/refs/heads/main/install.sh -o nezha.sh && chmod +x nezha.sh && sudo ./nezha.sh

三. 安装Caddy

执行安装脚本

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy

创建并保存证书文件，此处的example可以不更改，以下两行代码分别执行，然后将保存的代码粘贴进去，并输入:wq保存退出
```
vim /etc/caddy/example.pem    # 公钥
vim /etc/caddy/example.key    # 私钥
```
配置Caddyfile，执行以下代码打开配置文件
```
vim /etc/caddy/Caddyfile
```
输入%d清空，并粘贴如下代码，其中第一行的nezha.example.com需要替换成实际解析的子域名，证书路径如果第2步保存的文件名没改，这里也不用改，最后输入:wq保存退出
```
nezha.example.com {
    reverse_proxy /proto.NezhaService/* h2c://127.0.0.1:8008
    tls /etc/caddy/example.pem /etc/caddy/example.key
    reverse_proxy /* 127.0.0.1:8008
}
```

启用并启动Caddy:

 systemctl enable caddy
 systemctl start caddy

如果先安装的Caddy后安装的面板，这里需要重启下Caddy:

sudo systemctl reload caddy
systemctl restart caddy
sudo systemctl status caddy

四. 面板设置与添加探针

通过nezha.example.com/dashboard进入后台，默认账号密码都是admin，登录后添加新用户和密码，退出登录并用新账号密码登录，再进入设置删掉admin账号
将nezha.example.com添加在仪表板服务器域名/IP(无 CDN)中并保存
在其他小鸡新增探针时，粘贴的代码里需要修改如下位置，也可以在面板后台设置
```
修改 NZ_SERVER=nezha.example.com:443
开启 NZ_TLS=true
```

五. 面板卸载（仅适用Systemd安装）

1. 使用安装代码卸载

curl -L https://raw.githubusercontent.com/nezhahq/scripts/refs/heads/main/install.sh -o nezha.sh && chmod +x nezha.sh && sudo ./nezha.sh

2. 手动卸载

停止服务：
```
systemctl stop nezha-dashboard
```
禁用开机自启：
```
systemctl disable nezha-dashboard
```

删除服务文件：

rm /etc/systemd/system/nezha-dashboard.service

重新加载 Systemd 配置：
```
systemctl daemon-reload
```
删除程序文件：如果你的面板安装在 /opt/nezha/dashboard：
```
rm -rf /opt/nezha/dashboard
```
删除日志文件（如果有）：如果日志保存在 /var/log/nezha，可以删除：
```
rm -rf /var/log/nezha
```

六. 常用指令

停止panel指令

sudo systemctl stop nezha-dashboard

重启panel指令

sudo systemctl restart nezha-dashboard

查看panel状态

sudo systemctl status nezha-dashboard

Cloudflare CDN 全端口回源设置

Wed, 19 Mar 2025 00:00:00 GMT

准备工作

一个已经转入CloudFlare的，且是全功能的域名，千万不要使用双向解析的域名
一台VPS(IPv6和IPv4都可以)
WebSSH (让没有IPv6环境的小白朋友也可以连上VPS的SSH)

部署开始

1. 通过WebSSH安装X-ui

打开 WebSSH ，Hostname / 主机填入你VPS的IP即可，IPv6无需修改IP格式直接填入即可，
然后填入你VPS的Username / 用户名和Password / 密码后点击Connect连上你的VPS

连上机器后安装X-ui，这里就使用甬哥的X-ui脚本

curl -Ls https://raw.githubusercontent.com/yonggekkk/x-ui-yg/main/install.sh

注意: 如果你的机器未安装BBR，请优先安装BBR后再展开后续的工作。

X-ui面板端口设为2052，CF支持HTTP回源端口如下：80、8080、8880、2052、2082、2086、2095，推荐使用除了80之外的端口

X-ui面板用户名和密码随意即可

注意: 如果机器出口没有IPv4，可通过安装WARP来给机器添加IPv4出口

2. 设置域名

打开 CloudFlare，选中你要使用的域名，以下例子使用google.com域名举例；

2.1. 进入`SSL/TLS` > `概述` > `SSL/TLS 加密模式`为 `完全`

2.2. 进入`SSL/TLS` > `边缘证书` > 关闭 `始终使用 HTTPS` 和 `自动 HTTPS 重写`

2.3. 进入`SSL/TLS` > `源服务器` > 创建证书将`证书`和`密钥` 复制出来！保存好！！！

2.4. 进入`DNS` > `记录` 添加2条 AAAA记录， `xui.google.com`和`vmess.google.com`，地址就填入你的小鸡IPv6即可，其中`xui`必须开启小黄云

注意: vmess.google.com将会作为你VMess节点的伪装域名使用

3. 登录X-ui面板，设置VMess节点

打开 http://xui.google.com:2052，填入你设置的X-ui面板用户名和密码后点击登录即可

3.1. 添加节点VMess-ws noTLS节点

协议: vmess
端口: 随意 复制下来备用
uuid: 复制下来备用
传输协议: ws
TLS: 关闭

点击添加完成

3.2. 添加节点VMess-ws-TLS节点

协议: vmess
端口: 随意 复制下来备用
uuid: 将第3.1步复制下来的uuid粘贴在此处
传输协议: ws
TLS: 开启
证书方式: certificate file content
公钥内容: 填入第2.3步复制下来的证书内容
密钥内容: 填入第2.3步复制下来的密钥内容

点击添加完成

4. 设置CF的Origin Rules回源规则

打开 CloudFlare，选中你要使用的域名

4.1. 进入`规则` > `Origin Rules` > `创建规则`

规则名称: noTLS

字段: 主机名 > 等于 > vmess.google.com > And
字段: SSL/HTTPS > 关闭

目标端口: 重写到 > 填入第3.1步复制下来的noTLS端口内容

点击部署完成

4.2. 进入`规则` > `Origin Rules` > `创建规则`

规则名称: TLS

字段: 主机名 > 等于 > vmess.google.com > And
字段: SSL/HTTPS > 开启

目标端口: 重写到 > 填入第3.2步复制下来的TLS端口内容

点击部署完成

5. 填入你VMess节点信息，完成优选订阅

https://VMess.cmliussss.net/sub?cc=[VMess服务名字]&amp;host=[你的VMess域名]&amp;uuid=[你的UUID]&amp;path=[你的ws路径]&amp;alterid=[额外ID]&amp;security=[加密方式]

host 必填项，你VMess节点的伪装域名
uuid 必填项，你VMess节点的uuid
path 非必填项，你VMess节点的路径，默认\

cc 非必填项，可能会影响使用在线订阅转换,推荐使用地区代号，例如HK、SG、US
alterid 非必填项，默认0
security 非必填项，默认auto

快速订阅方式

https://VMess.cmliussss.net/sub?host=[你的VMess域名]&amp;uuid=[你的UUID]&amp;path=[你的ws路径]

例如: https://VMess.cmliussss.net/sub?host=obdii.cfd&uuid=05641cf5-58d2-4ba4-a9f1-b3cda0b1fb1d&path=/linkws

参考

https://blog.cmliussss.com/p/CM19/

Openwrt防检测固件轻松上手(简略)

Mon, 18 Nov 2024 00:00:00 GMT

Openwrt实现校园网防检测

自编译Xiaomi Redmi Router AC2100路由器固件，可用于STBU校园网防检测等功能。

本文将对新拿到已刷好固件的朋友们出一期简略的PC端配置教程，方便大家使用到基础功能。

:::important 请低调使用本路由器，最好放在不显眼的位置，否则后果自负 :::

如果想要详细的使用教程请点击这里

一. 固件基本使用教程

1.1 路由器启动和接入网线

先连接电源线，不要连接网线，等待路由器灯从蓝变黄闪再变蓝

{% note warning flat %}现在连网线可能会导致校园网被检测哦{% endnote %}

连接WiFi，初始WiFi名为openwrt(有两个二选一)，密码为password(这一步推荐使用电脑)

通过后面1.5的设置完成后，再接入已连接校园网的网线到wan口 （靠近电源线的口）

1.2 进入固件后台管理地址192.168.1.1

推荐使用系统自带的edge浏览器，直接输入192.168.1.1

1.3 授权进入

默认用户名为root

初始密码为password

1.4 进入Openwrt主界面简介

概览含一些路由的基本信息

往下可以看见当前在线的用户数量和连接WiFi的主机名及IP地址

1.5 开始基本设置

网络-无线，初始WiFi名为openwrt有两个，密码为password

设置WiFi名称和密码，上面是2.4G，下面是5G，点基本设置进入

优先使用5G信号，本人300M宽带能跑到340M左右

SSID设置WiFi名，密码栏设置WiFi密码，图片是5G信号设置，2.4G不用也要点基本设置进去设置密码

设置好后就可以重连到你的WiFi啦！！！

1.6 接入校园网

保证1.5的名称和密码设置无误后，再接入已连接校园网的网线到wan口 （靠近电源线的口）

自动弹出或自己1.1.1.1进入认证页面，登陆自己的宽带

宽带有问题请加认证页面左下角群，自行找管理人员解决，本人无法解决

二.注意事项

被检测到五分钟后会自动恢复正常，或者等待五分钟去校园网系统重新登陆

本路由实测最高连接14台设备没被检测，但是100M宽带建议不超过4台设备，200M和300M宽带建议不超过6台设备

多设备同时接入与断开路由有高机率被检测，比如室友集体下课回寝，或集体出去上课时

不建议连接此破解WiFi使用翻墙代理软件，小概率被检测共享

建议将路由器放在通风散热且隐蔽处

后期会整理大家使用当中存在的问题尝试出一期解决方案，有什么问题评论区留言哦！

利用Tampermonkey实现学习通刷课

Thu, 14 Nov 2024 00:00:00 GMT

前言

解决水课学习刷视频一直等着浪费时间的烦恼。

本文使用Windows内置Edge浏览器进行演示，建议刷课就用这个浏览器。

一、安装油猴(Tampermonkey)

可以直接访问 Tampermonkey – Microsoft Edge Addons 安装

如果使用的其它浏览器，可以进入Tampermonkey官网进行下载安装

{% note danger flat %}仅支持Chrome、Microsoft Edge、Safari、Opera Next和Firefox浏览器{% endnote %}

二、安装脚本

1. 取消隐藏Tampermonkey图标

设置在工具栏显示，放在外面这样比较方便脚本开关。

2. 进入脚本网站

脚本网站有很多，我推荐使用Greasy Fork - 安全且实用的用户脚本站，里面可用的脚本比较多。

3. 安装学习通脚本

直接搜索学习通/超星，看见顺眼的点进去安装脚本就行，不过有些可能已经失效了，这里我给大家推荐一个脚本（2024/11/14测试可用）

超星学习通九九助手[一键启动][最小化运行]

直接一直点安装就行

安装完后页面会消失，打开学习通，点击油猴如果是这样显示的，那就恭喜你安装成功啦！

三、开始刷课

1. 打开超星学习通网站

点去进你要刷的课程，会有弹窗出现。

{% note warning flat %}Warning 如果没有出现弹窗，那就再按下面图片的操作试试，如果出现弹窗请直接跳过{% endnote %}

必须要打开开发人员模式，如果没开脚本不能正常运行。

如果已经打开了开发人员模式，刷新网页后还未出现弹窗，那就可以再把下面三个框勾选上。

这样基本上就大功告成啦！

2. 可以根据自己的需求进行点击

作业和考试板块应该是要付费的，有需要的可以自行研究一下。

进入课程，界面大概就长这样，可以自行选择怎么去刷。

{% note danger flat %}视频倍速播放和夜间刷课都有可能导致学习记录被清空哦。{% endnote %}

3. 刷课结束

全部刷好后，叉掉此页面回去检查一下吧，看看进度有没有都已经完成了。

注意事项

不使用刷课的时候右上角可以手动关闭插件。

若脚本失效可在评论区反馈，我再去寻找新的可用方案。

ios17.0+侧载APP

Tue, 12 Nov 2024 00:00:00 GMT

应用介绍

众所周知 iPhone 不能自由安装第三方应用，只能通过 App Store 商店来下载。那么怎么才能在 iPhone 上安装非 App Store 上的应用？

其实可以用苹果签名的方式来实现，一般提供给 APP 内测使用。证书分为个人证书跟企业证书。其中企业证书需要付费，而个人证书虽然免费，但申请注册开发者后，只提供了 7 天有效期，所以需要续签，另外也限制了一个设备最多安装三个应用。

所以为了方便个人证书签名，目前市面上有不少 IPA 签名工具，例如牛蛙、巨魔等等。而今天要分享的是超好用的NB助手。

号称完全免费、无广告，支持在线手机端完成签名和续期。

官网视频安装教程可以参考： <div class="video-container"> <iframe src="//player.bilibili.com/player.html?isOutside=true&aid=113145142248525&bvid=BV1Y54ReTEfn&cid=25878724690&p=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"></iframe> </div>

.video-container iframe { position: absolute; top: 0; left: 0; width: 100%; height: 100%; } </style>

一、前期准备

①Win系统电脑一台，安装成功后续不再使用电脑；

②IOS16以上版本系统请打开手机的开发者模式；

如何打开开发者模式？

操作流程：进入手机的设置-隐私与安全性-滑到底部开发者模式-开启开发者模式即可；

注：如果你再隐私与安全中还是没有找到开发者模式，那只能使用电脑版的爱思助手工具箱中的虚拟定位，位置随意，虚拟定位成功后就再次到手机去找开发者，就可以看到了。

二、电脑操作

①电脑浏览器打开NB助手官网：nbtool8.com、或者直接点后面的链接Win下载链接

②点击下载iTunes，选择最新版本，安装后打开；

③点击下载Windows版，安装后打开；

④当前软件中的UDID是空白的，现在请用你的数据线链接手机到电脑上，普通充电线无反应，最好使用原装线，连接后看软件的UDID是否有值，有代表成功，没有请换线或重启电脑多次尝试；

⑤点击立即安装，此时按钮会变成安装中，当进度条走完后，看进度条右侧，显示安装成功代表成功，如果不成功，还是数据线的问题不稳定；

⑥此时电脑就没用了，以后也不用了，只是安装使用一次电脑，接下来我们打开手机，看桌面，会多出一个软件NB助手，恭喜你，安装成功！

以下为安装NB助手失败的常见问题与解决办法，如果你安装成功，可跳过此解答！

问题1：安装NB助手提示：ipa下载失败？

回答1：在电脑上打开C:\Users(或用户)\Administrator(或你的用户名)\AppData\Roaming\NBTool，里面有个NBTool目录，将它删除，然后用360卫士或腾讯管家清理一下电脑缓存垃圾，重新进入官网nbtool8.com下载NB助手尝试安装。注意：如果未发现AppData文件夹，需要先打开电脑的显示隐藏文件夹选项，具体方法请自行百度。

问题2：安装NB助手时已安装iTunes或爱思助手，缺还提示安装iTunes？

回答2：第一步：手机连接电脑，重新下载iTunes苹果驱动或者爱思助手；等待驱动安装完成；第二步：打开NB助手电脑版，点击安装；（保持手机连接电脑状态，需解锁屏幕并点击信任此电脑）第三步：手机内打开NB助手app，开始使用。

问题3：安装NB助手时显示：请设置锁屏密码？

回答3：更新 iTunes 或苹果驱动，手机重设锁屏密码，apple id设置必须打开双重认证，解锁手机后再插入数据线连接电脑。

问题4：电脑显示下载成功，手机上却没有NB助手的图标？

回答4：请重装安装NB助手或重新启动手机解决，99%的问题重启手机都可以解决。

问题5：手机设置里没有“开发者模式”选项？

开发者模式一般在设置-隐私与安全-开发者内开启。如果手机上没有开发者模式，可将手机连接电脑，重装一下应用。

三、手机操作

1、导入个人ID证书

①手机打开NB助手，提示联网默认选第一个无线局域网与蜂窝网络；

②提示需要VPN功能，点击确定，再次提示添加VPN配置，点击允许；

③自动跳转后，输入锁屏密码进行解锁，输入完密码后会自动返回到NB助手；

④返回桌面，打开设置，点击VPN，查看是否选择NB Tool,没选择请选择，以及顶部开启状态，没开启请手动开启，切记以后每次使用NB助手签名/安装/续签/都要选择与开启；

⑤再次打开NB助手，右下角点击我的，提示使用位置，点击使用APP时允许，点击语言，如果你是大陆用户，选择简体中文，其他地区请自行选择；

⑥点击底部的应用&证书，再点击证书，再点右上角的 + 号，选择导入Apple ID，输入你的苹果ID账号与密码；

填写后如果开启了双重验证，会提示输入验证码，请填写验证码进去

{% note danger flat %}温馨提示{% endnote %}

{% span red, iOS 16体统以上用户，首次登陆时账号大概率会触发安全机制，不要紧张，修改一下自己ID密码即可，以后就不会了登录成功后，会显示出你的苹果ID证书 %}

2、导入iPA文件包

先下载iPA文件包，再导入到NB助手APP中，iPA文件包的下载，可在iPA商店进行下载，每天每个免费用户可以下载3个iPA文件包，里面软件包都能正常使用，本人极力推荐；

导入ipa文件的二种方式：

第一种：找到手机自带的文件APP，找到你下载的ipa包，点击后选择共享，选择NB助手，此时ipa文件包会自动导入到NB助手中，打开NB助手点击底部的应用&证书即可看到；

第二种：在NB助手软件中，点击底部的应用&证书，再点击右上角的 + 号，此时会自动打开手机自带的文件 APP，可以点击右下角的浏览，进行寻找你下载的ipa文件，找到后点击，会自动导入到NB助手中；

①本教程以Spotifyipa文件举例，导入后是这样的，如图所示：

注：底部他有时会显示红色的文字，描述文件过期什么的，不管他，毕竟我们需要重新签名进行使用；

②此时点击你要安装的ipa文件名称，弹出对话框，选择签名安装/导出，进入签名页面；

版本号：默认
Build：默认
最低系统要求：默认不超过你手机的系统
Icon：默认
插件签名：可开启可关闭，如果知道带有越狱或动态依赖库可开启
注入动态库：新手不懂插件可以不选，如果有人告诉你需要注入就选择插件进行注入
移除动态库：新手可以不选，如果有人告诉你需要移除旧选择插件进行移除
证书：选择你前面登录账户的个人ID账号证书

至于左下角的编辑Info.plist新手可以不点，如果有人告诉你需要编辑请根据要求进行编辑；

③全部操作完后，点击右下角的签名&安装，进入黑色的DOS界面，会自动进行签名与安装，提示需要VPN功能，点击确定，再次提示添加VPN配置，点击允许；自动跳转后，输入锁屏密码进行解锁，输入完密码后会自动返回到NB助手；提示安装成功，点击信任 xxxx，这里的xxx显示的是你的个人ID账号，会自动跳转到浏览器，页面显示空白或无法访问此页面，不用去管他，返回桌面，即可看到我们安装的ipa文件包已经成功；

④我们点击安装的应用，是无法打开的，会提示未受信任的开发者，此时打开手机的设置-滑到底部找到VPN与设备管理，找到你签名登录的个人ID账号，点击进去，点击验证即可，此时应用就可以打开；

3、续签重装

首先要知道我们选择的是导入Apple ID，也就是常说的个人ID证书，个人ID证书有效期为7天，过期后你所安装的应用或游戏是打不开的，会提示不可用，或无法验证证书，此时需要续签/重装，重装是自动覆盖安装，数据不会丢失

当你遇到此问题时，需要你打开NB助手，点击底部应用&证书，顶部点击已安装，会显示出你已签名安装的应用，右侧还能看到到期还有几天，此时我们点击快到期/已到期的应用，弹窗对话框选择续签即可；

注：如果你应用多，你也可以点击底部的一键续签不掉数据，进入DOS，直到最后显示All renew complete代表所有应用续签成功；

最后说明：

1、ID自签：一次有效期是7天（这是苹果公司规定的），非常安全且免费，可以无限续签，自己花钱买的证书也会随时掉签

2、ID自签：一个账号可以签名10个软件，但是仅可以同时安装3个软件

3、当已签名中的应用未到期或已到期都是可以提前续签的！

Openwrt防检测固件使用教程(详细)

Fri, 08 Nov 2024 00:00:00 GMT

Openwrt实现校园网防检测

自编译Xiaomi Redmi Router AC2100路由器固件，可用于STBU校园网防检测等功能。

本文将对新拿到已刷好固件的朋友们出一期详细的PC端配置教程，方便大家使用到更多功能。

:::important 请低调使用本路由器，最好放在不显眼的位置，否则后果自负 :::

一. 固件构成

1.1 检测类型

1.基于 IPv4 数据包包头内的 TTL 字段的检测（固定TTL）

2.基于 HTTP 数据包请求头内的 User-Agent 字段的检测(使用UA2F)

3.基于 IPv4 数据包包头内的 Identification 字段的检测（rkp-ipid 设置 IPID）

4.基于网络协议栈时钟偏移的检测技术（统一时间）

本人测试第2、3条检测STBU好像没有，但是以防万一我还是加在里面了。*

1.2 本固件集成的软件包(部分)

luci-app-ttyd luci-app-timedreboot luci-app-argon-config kmod-rkp-ipid iptables-mod-filter iptables-mod-ipopt iptables-mod-u32 iptables-nft ua2f luci-app-ua2f kmod-ipt-u32 kmod-ipt-ipopt ipset iptables-mod-conntrack-extra luci-compat luci-theme-argon

二. 固件基础使用教程

2.1 路由器启动和接入网线

先连接电源线，不要连接网线，等待路由器灯从蓝变黄闪再变蓝

{% note warning flat %}Warning 现在连网线可能会导致校园网被检测哦{% endnote %}

通过后面2.2—2.6的设置完成后，再接入已连接校园网的网线到wan口 （靠近电源线的口）

2.2 进入固件后台管理地址192.168.1.1

推荐使用edge浏览器

2.3 授权进入

默认用户名为root

密码为password

2.4 进入Openwrt主界面简介

概览含一些路由的基本信息

往下可以看见当前在线的用户数量和连接WiFi的主机名及IP地址

2.5 检查基本设置

进入系统，查看本地时间是否和浏览器一致，不一致请同步浏览器时间

管理权可以更改后台登录密码，不建议修改，忘记密码后果自负

可以选择一个特定时间定时重启，让路由器每天可以休息几十秒

后台有重启按钮，可以不用去拔电源了

服务里带有U2F检测开关，实测关了也没有被检测，以防万一还是打开吧

只应用前三个就行

网络-无线，设置WiFi名称和密码，上面是2.4G，下面是5G，点基本设置进入

优先使用5G信号，本人200M宽带能跑到260M左右

SSID设置WiFi名，密码栏设置WiFi密码，图片是5G信号设置，2.4G不用也要进去设置

检查防火墙-自定义规则代码是否一致，修改后重启防火墙

# This file is interpreted as shell script.
# Put your custom iptables rules here, they will
# be executed with each firewall (re-)start.

# Internal uci firewall chains are flushed and recreated on reload, so
# put custom rules into the root chains e.g. INPUT or FORWARD or into the
# special user chains, e.g. input_wan_rule or postrouting_lan_rule.
#
# 通过 rkp-ipid 设置 IPID
iptables -t mangle -N IPID_MOD
iptables -t mangle -A FORWARD -j IPID_MOD
iptables -t mangle -A OUTPUT -j IPID_MOD
iptables -t mangle -A IPID_MOD -d 0.0.0.0/8 -j RETURN
iptables -t mangle -A IPID_MOD -d 127.0.0.0/8 -j RETURN
iptables -t mangle -A IPID_MOD -d 172.16.0.0/12 -j RETURN
iptables -t mangle -A IPID_MOD -d 192.168.0.0/16 -j RETURN
iptables -t mangle -A IPID_MOD -d 255.0.0.0/8 -j RETURN
iptables -t mangle -A IPID_MOD -j MARK --set-xmark 0x10/0x10

# 防时钟偏移检测
iptables -t nat -N ntp_force_local
iptables -t nat -I PREROUTING -p udp --dport 123 -j ntp_force_local
iptables -t nat -A ntp_force_local -d 0.0.0.0/8 -j RETURN
iptables -t nat -A ntp_force_local -d 127.0.0.0/8 -j RETURN
iptables -t nat -A ntp_force_local -d 192.168.0.0/16 -j RETURN
iptables -t nat -A ntp_force_local -s 192.168.0.0/16 -j DNAT --to-destination 192.168.1.1

# 通过 iptables 修改 TTL 值
iptables -t mangle -A POSTROUTING -j TTL --ttl-set 128

2.6 高级功能扩展

附加高级功能可能导致运行不稳定，谨慎使用，不使用请关闭

MentoHUST暂时用不上，保持关闭即可

解锁网易云灰色歌曲打开后连接WiFi可自动解锁，但可能让网易云加载变慢，自行测试使用

UU游戏加速器可登陆自己的账号，自行测试使用

KMS可自动解锁局域网内的Office 365全家桶，自行测试使用

2.7 接入校园网

保证2.2—2.6的设置无误后，再接入已连接校园网的网线到wan口 （靠近电源线的口）

自动弹出或自己1.1.1.1进入认证页面，登陆自己的宽带

宽带有问题请加认证页面左下角群，自行找管理人员解决

三.注意事项

被检测到五分钟后会自动恢复正常，或者等待五分钟去校园网系统重新登陆

本路由实测最高连接14台设备没被检测，但是100M宽带建议****不超过4台设备**，200M宽带建议不超过6台设备

多设备同时接入与断开路由有高机率被检测，比如室友集体下课回寝，或集体出去上课时

不建议连接此破解WiFi使用翻墙代理软件，小概率被检测共享

后期会整理大家使用当中存在的问题尝试出一期解决方案，有什么问题评论区留言哦！

Simple Guides for Fuwari

Mon, 01 Apr 2024 00:00:00 GMT

Cover image source: Source

This blog template is built with Astro. For the things that are not mentioned in this guide, you may find the answers in the Astro Docs.

Front-matter of Posts

---
title: My First Blog Post
published: 2023-09-09
description: This is the first post of my new Astro blog.
image: ./cover.jpg
tags: [Foo, Bar]
category: Front-end
draft: false
---

Attribute	Description
`title`	The title of the post.
`published`	The date the post was published.
`description`	A short description of the post. Displayed on index page.
`image`	The cover image path of the post.<br/>1. Start with `http://` or `https://`: Use web image<br/>2. Start with `/`: For image in `public` dir<br/>3. With none of the prefixes: Relative to the markdown file
`tags`	The tags of the post.
`category`	The category of the post.
`draft`	If this post is still a draft, which won't be displayed.

Where to Place the Post Files

Your post files should be placed in src/content/posts/ directory. You can also create sub-directories to better organize your posts and assets.

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

This Article is a Draft

This article is currently in a draft state and is not published. Therefore, it will not be visible to the general audience. The content is still a work in progress and may require further editing and review.

When the article is ready for publication, you can update the "draft" field to "false" in the Frontmatter:

---
title: Draft Example
published: 2024-01-11T04:40:26.381Z
tags: [Markdown, Blogging, Demo]
category: Examples
draft: false
---

Here, we'll explore how code blocks look using [Expressive Code](https://expressive-code.com/). The provided examples are based on the official documentation, which you can refer to for further details.

## Expressive Code

### Syntax Highlighting

[Syntax Highlighting](https://expressive-code.com/key-features/syntax-highlighting/)

#### Regular syntax highlighting

```js
console.log('This code is syntax highlighted!')

Rendering ANSI escape sequences

ANSI colors:
- Regular: [31mRed[0m [32mGreen[0m [33mYellow[0m [34mBlue[0m [35mMagenta[0m [36mCyan[0m
- Bold:    [1;31mRed[0m [1;32mGreen[0m [1;33mYellow[0m [1;34mBlue[0m [1;35mMagenta[0m [1;36mCyan[0m
- Dimmed:  [2;31mRed[0m [2;32mGreen[0m [2;33mYellow[0m [2;34mBlue[0m [2;35mMagenta[0m [2;36mCyan[0m

256 colors (showing colors 160-177):
[38;5;160m160 [38;5;161m161 [38;5;162m162 [38;5;163m163 [38;5;164m164 [38;5;165m165[0m
[38;5;166m166 [38;5;167m167 [38;5;168m168 [38;5;169m169 [38;5;170m170 [38;5;171m171[0m
[38;5;172m172 [38;5;173m173 [38;5;174m174 [38;5;175m175 [38;5;176m176 [38;5;177m177[0m

Full RGB colors:
[38;2;34;139;34mForestGreen - RGB(34, 139, 34)[0m

Text formatting: [1mBold[0m [2mDimmed[0m [3mItalic[0m [4mUnderline[0m

Editor & Terminal Frames

Code editor frames

console.log('Title attribute example')

<!-- src/content/index.html -->
<div>File name comment example</div>

Terminal frames

echo "This terminal frame has no title"

Write-Output "This one has a title!"

Overriding frame types

echo "Look ma, no frame!"

# Without overriding, this would be a terminal frame
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
New-Alias tail Watch-Tail

Text & Line Markers

Marking full lines & line ranges

// Line 1 - targeted by line number
// Line 2
// Line 3
// Line 4 - targeted by line number
// Line 5
// Line 6
// Line 7 - targeted by range "7-8"
// Line 8 - targeted by range "7-8"

Selecting line marker types (mark, ins, del)

function demo() {
  console.log('this line is marked as deleted')
  // This line and the next one are marked as inserted
  console.log('this is the second inserted line')

  return 'this line uses the neutral default marker type'
}

Adding labels to line markers

// labeled-line-markers.jsx
<button
  role="button"
  {...props}
  value={value}
  className={buttonClassName}
  disabled={disabled}
  active={active}
>
  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Adding long labels on their own lines

// labeled-line-markers.jsx
<button
  role="button"
  {...props}

  value={value}
  className={buttonClassName}

  disabled={disabled}
  active={active}
>

  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Using diff-like syntax

+this line will be marked as inserted
-this line will be marked as deleted
this is a regular line

--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+this is an actual diff file
-all contents will remain unmodified
 no whitespace will be removed either

Combining syntax highlighting with diff-like syntax

  function thisIsJavaScript() {
    // This entire block gets highlighted as JavaScript,
    // and we can still add diff markers to it!
-   console.log('Old code to be removed')
+   console.log('New and shiny code!')
  }

Marking individual text inside lines

function demo() {
  // Mark any given text inside lines
  return 'Multiple matches of the given text are supported';
}

Regular expressions

console.log('The words yes and yep will be marked.')

Escaping forward slashes

echo "Test" > /home/test.txt

Selecting inline marker types (mark, ins, del)

function demo() {
  console.log('These are inserted and deleted marker types');
  // The return statement uses the default marker type
  return true;
}

Word Wrap

Configuring word wrap per block

// Example with wrap
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with wrap=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Configuring indentation of wrapped lines

// Example with preserveIndent (enabled by default)
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with preserveIndent=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Collapsible Sections

// All this boilerplate setup code will be collapsed
import { someBoilerplateEngine } from '@example/some-boilerplate'
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'

const engine = someBoilerplateEngine(evenMoreBoilerplate())

// This part of the code will be visible by default
engine.doSomething(1, 2, 3, calcFn)

function calcFn() {
  // You can have multiple collapsed sections
  const a = 1
  const b = 2
  const c = a + b

  // This will remain visible
  console.log(`Calculation result: ${a} + ${b} = ${c}`)
  return c
}

// All this code until the end of the block will be collapsed again
engine.closeConnection()
engine.freeMemory()
engine.shutdown({ reason: 'End of example boilerplate code' })

Line Numbers

Displaying line numbers per block

// This code block will show line numbers
console.log('Greetings from line 2!')
console.log('I am on line 3')

// Line numbers are disabled for this block
console.log('Hello?')
console.log('Sorry, do you know what line I am on?')

Changing the starting line number

console.log('Greetings from line 5!')
console.log('I am on line 6')

GitHub Repository Cards

You can add dynamic cards that link to GitHub repositories, on page load, the repository information is pulled from the GitHub API.

::github{repo="Fabrizz/MMM-OnSpotify"}

Create a GitHub repository card with the code ::github{repo="<owner>/<repo>"}.

::github{repo="saicaca/fuwari"}

Admonitions

Following types of admonitions are supported: note tip important warning caution

:::note Highlights information that users should take into account, even when skimming. :::

:::tip Optional information to help a user be more successful. :::

:::important Crucial information necessary for users to succeed. :::

:::warning Critical content demanding immediate user attention due to potential risks. :::

:::caution Negative potential consequences of an action. :::

Basic Syntax

:::note
Highlights information that users should take into account, even when skimming.
:::

:::tip
Optional information to help a user be more successful.
:::

Custom Titles

The title of the admonition can be customized.

:::note[MY CUSTOM TITLE] This is a note with a custom title. :::

:::note[MY CUSTOM TITLE]
This is a note with a custom title.
:::

GitHub Syntax

[!TIP] The GitHub syntax is also supported.

> [!NOTE]
> The GitHub syntax is also supported.

> [!TIP]
> The GitHub syntax is also supported.

An h1 header

Paragraphs are separated by a blank line.

2nd paragraph. Italic, bold, and monospace. Itemized lists look like:

this one
that one
the other one

Note that --- not considering the asterisk --- the actual text content starts at 4-columns in.

Block quotes are written like so.

They can span multiple paragraphs, if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all in chapters 12--14"). Three dots ... will be converted to an ellipsis. Unicode is supported. ☺

An h2 header

Here's a numbered list:

first item
second item
third item

Note again how the actual text starts at 4 columns in (4 characters from the left side). Here's a code sample:

# Let me re-iterate ...
for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of indenting the block, you can use delimited blocks, if you like:

define foobar() {
    print "Welcome to flavor country!";
}

(which makes copying & pasting easier). You can optionally mark the delimited block for Pandoc to syntax highlight it:

import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i

An h3 header

Now a nested list:

First, get these ingredients:
- carrots
- celery
- lentils
Boil some water.

Dump everything in the pot and follow this algorithm:

 find wooden spoon
 uncover pot
 stir
 cover pot
 balance wooden spoon precariously on pot handle
 wait 10 minutes
 goto first step (or shut off burner when done)

Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including that last line which continues item 3 above).

Here's a link to a website, to a local doc, and to a section heading in the current doc. Here's a footnote [^1].

[^1]: Footnote text goes here.

Tables can look like this:

size material color

9 leather brown 10 hemp canvas natural 11 glass transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports multi-line tables:

keyword text

red Sunsets, apples, and other red or reddish things.

green Leaves, grass, frogs and other things it's not easy being.

A horizontal rule follows.

Here's a definition list:

apples : Good for making applesauce. oranges : Citrus! tomatoes : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each term/definition pair to spread things out more.)

Here's a "line block":

| Line one | Line too | Line tree

and images can be specified like so:

Inline math equations go in like so: $\omega = d\phi / dt$. Display math should get its own line and be put in in double-dollarsigns:

$$I = \int \rho R^{2} dV$$

$$ \begin{equation*} \pi =3.1415926535 ;8979323846;2643383279;5028841971;6939937510;5820974944 ;5923078164;0628620899;8628034825;3421170679;\ldots \end{equation*} $$

And note that you can backslash-escape any punctuation characters which you wish to be displayed literally, ex.: `foo`, *bar*, etc.

Just copy the embed code from YouTube or other platforms, and paste it in the markdown file.

---
title: Include Video in the Post
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili