Mental Studio

将strongswan从旧版迁移到swanctl的新版

Sat, 15 Aug 2026 18:49:20 +0800

需求

之前写过一篇关于strongswan配置的《StrongSwan配置笔记》，因为当时用的系统比较旧，strongswan还是5.7，用的是旧版的starter配置方式，这回是需要在一台新的Debian13上配置，用的是strongswan 6.0.1，要使用新的swanctl方式配置，所以需要迁移一下。

新版的配置方式变化其实只是表面现象，本质上的变化更大。比如后端协议由传统的Stroke协议改为使用现代的VICI协议。更关键的是官方对于旧版的支持已处于维护模式，不再添加新特性，所以还是要切换到更强大且配置灵活的新版。

迁移内容

首先是安装上的区别：

# 首先是移除旧版（如果已经安装了的话）
sudo systemctl disable --now strongswan-starter
sudo systemctl mask strongswan-starter.service
# 然后开始安装新版（注意排除掉旧版）
sudo apt-get update
sudo env DEBIAN_FRONTEND=noninteractive apt-get install -y \
  charon-systemd strongswan-swanctl libcharon-extra-plugins certbot \
  strongswan-starter- strongswan-

需要注意的是，不要同时安装两个版本，更不要同时启动两个版本，否则会有冲突。

其次就是配置文件上的区别：

旧版的配置文件是/etc/ipsec.conf和ipsec.secrets，新版改为/etc/swanctl/swanctl.conf，格式也完全不同。

配置变更

一个可供参考新版配置如下：

connections {
    ikev2-eap {
        version = 2
        local_addrs = %any
        remote_addrs = %any
        proposals = aes256gcm16-prfsha384-ecp384,aes256gcm16-prfsha256-modp2048,aes256-sha256-modp2048,aes256-sha256-ecp256,aes256-sha1-modp2048,aes128-sha1-modp2048
        fragmentation = yes
        mobike = yes
        send_cert = always
        unique = never
        pools = vpn-ipv4
        dpd_delay = 30s
        rekey_time = 0s
        reauth_time = 0s
        local {
            auth = pubkey
            certs = server.pem
            id = <your_domain_name>
        }
        remote {
            auth = eap-mschapv2
            eap_id = %any
        }
        children {
            internet {
                local_ts = 0.0.0.0/0
                remote_ts = dynamic
                esp_proposals = aes256gcm16,aes128gcm16,aes256-sha256,aes128-sha256,aes256-sha1,aes128-sha1
                rekey_time = 1h
                life_time = 90m
                dpd_action = clear
                start_action = none
            }
        }
    }
}
pools {
    vpn-ipv4 {
        addrs = 10.12.0.0/24
        dns = 1.1.1.1, 8.8.8.8
    }
}
include conf.d/*.conf

其中<your_domain_name>要换成你的服务器域名，并且提供相应的TLS证书。

这里的配置中保留 AES/SHA1 + MODP2048 作为部分原生客户端的兼容选项，优先协商 AES-GCM 或 SHA256。Windows 下文提供显式 SHA256 设置。unique = never 允许同一账号在多个设备连接。

域名证书

首先配置好域名解析。这里以Let’s encrypt签署的证书为例。如果现有 Nginx/Apache 的域名匹配及 HTTP challenge 路径可用，不需要停用 Web 服务。

sudo /usr/bin/certbot certonly --webroot \
  -w /path_to/www/challenge \
  --cert-name <your_domain_name> -d <your_domain_name> \
  --key-type rsa --rsa-key-size 3072 --non-interactive

证书目录：/etc/letsencrypt/live/<your_domain_name>/，私钥只存放在服务器。

证书通过 /usr/local/sbin/refresh-swanctl-certs 同步：

cert.pem → /etc/swanctl/x509/server.pem，权限 644。
privkey.pem → /etc/swanctl/private/server.pem，权限 600。
chain.pem 拆分到 /etc/swanctl/x509ca/letsencrypt-chain-*.pem。
服务运行时调用 swanctl --load-creds 热加载，无需重启 VPN。

本次证书链为服务器证书 → Let’s Encrypt YR2 → Root YR → ISRG Root X1。应下发完整的中间证书链，不能只复制叶子证书，也不能假定 chain.pem 永远只有一张证书。

证书自动更新需要启用 Debian 的 certbot.timer，续期命令统一使用绝对路径 /usr/bin/certbot。创建证书续期脚本 /etc/letsencrypt/renewal-hooks/deploy/50-swanctl ：

#!/bin/sh
set -eu
DOMAIN=<your_domain_name>
if [ "${RENEWED_LINEAGE:-}" = /etc/letsencrypt/live/${DOMAIN} ]; then
    /usr/local/sbin/refresh-swanctl-certs
fi
/usr/sbin/nginx -t && /usr/bin/systemctl reload nginx

然后用下面的命令启用：

sudo systemctl enable --now certbot.timer strongswan.service
sudo /usr/bin/certbot renew --cert-name <your_domain_name> \
  --dry-run --run-deploy-hooks --no-random-sleep-on-renew

HTTP-01 续期需要继续保留域名解析、TCP 80 和现有 webroot challenge 路径。

账号配置

原来的账号配置文件 /etc/ipsec.secrets 已经没用了，新文件是 /etc/swanctl/conf.d/90-eap-secrets.conf，root:root、600。密码使用 swanctl 的 0s Base64 格式存储；Base64 不是加密。

参考配置如下：

secrets {
    eap-migrated-1 {
        id = "用户名"
        secret = 0s<密码的Base64>
    }
}

修改账号应编辑新文件，再运行：

sudo swanctl --load-creds

charon-systemd的配置

文件在： /etc/strongswan.d/zz-vpn-systemd.conf

charon-systemd {
    load = random nonce x509 revocation constraints pubkey pkcs1 pkcs7 pem openssl gcm drbg kernel-netlink socket-default vici eap-identity eap-mschapv2
    load_modular = no
    plugins {
        openssl {
            load_legacy = yes
        }
    }
}
swanctl {
    load = random nonce x509 revocation constraints pubkey pkcs1 pkcs7 pem openssl gcm drbg
}

OpenSSL legacy provider 提供 EAP-MSCHAPv2 所需的 MD4/DES 算法；它不代表 IKE/ESP 允许使用 DES，实际隧道套件由上面的 proposals 限定。显式插件列表也避免加载旧 stroke/XAUTH/DHCP/attr 功能，以及 swanctl 对未安装插件的告警。DNS 只由新地址池下发。

网络及防火墙配置

在 /etc/sysctl.conf 里加上：

net.ipv4.ip_forward = 1

然后启用：

sudo sysctl -p

在已有 iptables-nft 规则中现有 INPUT 部分，在 DROP 前放行 UDP 500/4500 和 ESP。FORWARD 调整为同时匹配地址池及 IPsec policy，不需要绑定入站/出站网卡名：

-A FORWARD -s 10.12.0.0/24 -m policy --dir in --pol ipsec -j ACCEPT
-A FORWARD -d 10.12.0.0/24 -m policy --dir out --pol ipsec -j ACCEPT

配置如下 NAT 规则：

-A POSTROUTING -s 10.12.0.0/24 -o eth0 -m policy --dir out --pol ipsec -j ACCEPT
-A POSTROUTING -s 10.12.0.0/24 -o eth0 -j MASQUERADE

以上为规则内容，添加到 iptables.save 后使用 iptables-restore 命令加载，不能直接作为 shell 命令运行。

客户端配置

iOS / iPadOS

设置 → 通用 → VPN 与设备管理 → VPN → 添加 VPN 配置：

类型：IKEv2。
服务器、远程 ID：<your_domain_name>。
本地 ID：留空。
用户鉴定：用户名，填写账号和密码。
代理：关闭。

使用系统信任的 CA 验证服务器证书；无需导入服务器私钥或客户端证书，不要选择共享密钥认证。

macOS

系统设置 → VPN → 添加 VPN 配置 → IKEv2。服务器地址、远程 ID 都填写 <your_domain_name>，本地 ID 留空，认证选择用户名和密码。不同 macOS 版本的菜单位置可能略有不同。

Android

使用 strongSwan VPN Client：

Server：<your_domain_name>。
VPN Type：IKEv2 EAP (Username/Password)。
Username / Password：账号和密码。
CA certificate：自动选择。
若填写 Server identity，设为 <your_domain_name>。

不要选择 Certificate + EAP，也无需安装用户证书。可按需求打开始终开启 VPN、阻止非 VPN 流量。手机厂商内置 IKEv2 配置界面差异较大，此文以 strongSwan App 为准。

Windows 10 / 11

创建 Windows 内置 VPN，服务器 <your_domain_name>，类型 IKEv2，登录信息为用户名和密码。连接名可设为 xxx-IKEv2。

在适用的用户上下文运行 PowerShell（涉及权限时以管理员运行）：

Add-VpnConnection -Name "xxx-IKEv2" `
  -ServerAddress "<your_domain_name>" `
  -TunnelType Ikev2 -AuthenticationMethod Eap `
  -EncryptionLevel Required -SplitTunneling $false

Set-VpnConnectionIPsecConfiguration -ConnectionName "xxx-IKEv2" `
  -EncryptionMethod AES256 -IntegrityCheckMethod SHA256 `
  -DHGroup Group14 -CipherTransformConstants AES256 `
  -AuthenticationTransformConstants SHA256128 -PfsGroup None -Force

如果连接已在界面创建，跳过 Add-VpnConnection。打开 ncpa.cpl → 此 VPN 的属性 → 安全，确认 EAP 方法为 Microsoft: Secured password (EAP-MSCHAP v2)；不要选择智能卡/证书或 PEAP，不要自动使用 Windows 登录账号。连接时输入 VPN 原账号密码。

根证书需受 Windows 信任；正常更新的系统通常已有 ISRG Root X1。若证书验证失败，应检查系统时间、根证书及远程域名，不要禁用服务器证书校验。

Linux 桌面

Debian/Ubuntu 可安装 NetworkManager 的 strongSwan 插件：

sudo apt-get install network-manager-strongswan

在网络设置中新增 IPsec/IKEv2（strongSwan）连接，网关填 <your_domain_name>，认证为 EAP 用户名/密码。指定系统可信根 /etc/ssl/certs/ISRG_Root_X1.pem（其他发行版路径可能不同），如有服务器身份栏填写新域名。要求 IPv4 全隧道时不要勾选“仅用于此网络上的资源”。

Linux 无桌面也可使用 charon-systemd + swanctl 作为客户端。

对比其它平台，再次证明了一个真理：Windows善于制造其它平台上不存在的问题……

使用AI进行旅游规划

Sat, 18 Jul 2026 12:49:20 +0800

这二十多年来，一直以来都是自助游为主，中间也跟过几次团，体验都一言难尽。

以前比较有空，出门前都会看很多帖子（那时都是论坛交流），然后自己做一份详细的攻略再出门。这几年比较忙，所以有时就没法做那么详细了，虽然这么走了几次也没踩太多坑——反正随机应变就是了。但问题在于，即使没那么详细的准备工作，也是需要花不少时间的。

所以自从有了AI以后，就开始用AI来辅助。但是之前的AI你们懂的，过于智障了，导致的坑比不做攻略还多。去年在V站看到一个哥们用RooCode这种AI编码工具加几个MCP做了一个自助游工具，思路挺不错的，但实际使用效果仍然不够理想。

今年以来，AI的发展速度真的是超快，从年初的openclaw到现在各种hardness出来，各模型的智能也快速提高，加上各种工具调用能力和自定义skills，多agent联合工作等，令人应接不暇。

正好七月计划了一次青甘大环线的自驾游，于是拿AI做了一下攻略。主要用到的工具是：cline和openclaw。

整个流程大致是这样：

先定下大概的框架

在VSC里用cline创建一个基本的计划文档，要告诉AI的基本信息有：

出行的起止日期时间（需要精确到时间，以便安排当天的行程）
出行有几人（重点是要说明有没有老人小孩）
计划去哪些景点
有什么需要特别说明的（比如能不能早起，饮食有什么忌口）

让cline创建一个markdown文件来列这个行程计划

根据初步计划进行补充

首先要根据AI排的路线来看是不是符合你的要求，比如你可能需要根据这个路线再次调整要去的景点，比如有些比较绕路的可能就要放弃，有些顺路的可以加上。

然后就是根据路线，AI推荐的住宿城市可能也需要按你自己的想法进行一些调整。

最后还可以让AI补充一些行程细节，比如各景点之间的路程和耗时，各景点的大概到达时间和预计游玩时长等。

这些都可以在cline里通过对话方式让AI来完善文档，相当于一个旅游顾问的功能。

通过技能自动补充

这个cline就差一些，于是我把文档转给openclaw，让它读一下文档再去补充一些信息。

比如：

天气预报
景点营业时间，门票信息，老人儿童优惠信息
甚至调用浏览器登录一些社交媒体账号查看别人的经验等
去OTA查询酒店信息等

回到cline再汇总信息

这时可以再把openclaw补充过的文档再拿回cline里review一下，补充：

各景点的穿搭建议
各地的美食建议
计算每日行程的预估费用
在文档开头总结一份行李清单（根据每天的穿搭建议，天气预报等信息）
总结一份穿衣速查表，各景点穿衣颜色搭配速查
小贴士汇总
避坑汇总
文档最后加上需要采购的物品清单
需要提前预定的门票清单
全程路程和耗时汇总表
总预估费用汇总表

随时补充调整

后续有什么变化也可以随时通过openclaw进行调整，非常方便。

甚至出行时都不用带着文档，直接问openclaw即可。

真是科技改变生活。

AI编程会消灭程序员吗？

Sat, 20 Jun 2026 17:53:39 +0800

这个话题自从有AI编程以来就一直在被讨论，促使我忍不住要说两句的原因是这个：

Cursor 的 CEO Michael Truell 在 Lenny的播客上描述过他眼里编程的未来。他说 Cursor的目标是发明一种新的编程方式，那个世界里，“你对软件逻辑的表示会看起来更像英语”，编程语言会朝伪代码演化，“你把软件的逻辑写下来，在一个高层级上编辑它”，最终的代码"不再是几百万行读不进去的东西，而是更简短、更易懂、更好导航的东西"。

这个说法让我想起早先我也有过一个类似想法：

本质上现在AI就是一种新的高级语言，而以前的高级语言变成一种类似机器码一样的东西。

高级语言的出现消灭了程序员吗？并没有。

回忆一下上古时代的编程方式：

程序员需要先用汇编语言（原始的汇编本质上就是机器码的助记符，都不太能算是一种编程语言）把程序写下来，再通过查指令表（人工或用程序）转成机器码，最后把这个机器码作为目标程序输入到电脑里运行。机器码是什么？是一种电脑用的语言，程序员干的是一种把需求翻译成机器语言的工作。程序员需要直接面对电脑硬件的具体细节：每个字节是如何存取的，每个中断是如何处理的，每个端口是如何操作的……

当高级语言出现以后是什么样的情况呢？是对电脑的抽象。程序员不再需要直接面对电脑硬件，而是通过变量来处理存储，不需要关心它是放在寄存器里还是放在堆栈里，通过文件描述符或设备描述符来操作硬盘或其它设备。后面支持这些的是操作系统、编译器或语言虚拟机等基础设施。

像Basic这样的语言已经离硬件很远了，很多不了解电脑硬件的人也可以学着使用。这个时候，旧时代的程序员被淘汰了吗？并没有。但是因为软件能干的事情更多了，需要更多的人来开发软件。

十几年前因为互联网的发展，程序员行业膨胀得很快，就有人在问，程序员会不会过剩？朋友Virushuo还为此写过一篇文章来论证，结论就是：一方面是软件需求的增长速度太快了，程序员的增长速度虽然已经很快，但还是赶不上。另一方面是实际上市场上靠谱的程序员还是很少的。

AI编程的出现其实也是一样的。它让编程的门槛变低，本质上是大量增加了程序员的供给，但同样也会增加更多的需求。

比如朋友小辛说的：以前因为程序员成本高，一些定制化的需求因为不划算而不做的，现在都可以做起来了。

结果就是AI并没有取代程序员，反而让程序员加更多的班。

朋友MK对此的解释是：

现在公司愿意花更多钱在AI上的项目，都是更难的，内容更多的项目。所以反而会让程序员加班，但，不加工资。主要是AI加速了编程工作，所以让程序员更累了，其实写代码不是最累的，研究新的问题，做出正确决策才累。AI会不停让你进行决策。

就像是卓别林在电影《摩登时代》里的那种情况，程序员就像是流水线上打螺丝的工人，AI就是一台更快的机器，迫使工人打更多的螺丝。

另外，正如MK的观点所说，AI加速了编程工作，但程序员需要在这个工作过程中作出决策，从这个角度上说，能对AI的工作进行决策，还是对程序员有比较高的要求的，而能达到这种要求的程序员，还是少的。

几十年过去了，问题的环境不断在变，但问题结构还是一样的，所以结论也没有本质上的变化。

推送到[go4pro.org]

swapoff很慢问题的优化

Sat, 16 May 2026 17:50:11 +0800

起因

因为现在用的电脑只有24G，然而IDE和浏览器之类的都是内存大户，所以不是很够用，为了避免OOM，我给开了32G的swap，但实际上用到8个G左右就卡得不行了。所以有时我会把这些内存大户暂时关闭，然后执行一次swapoff清理一下内存使用。但是今天居然碰到这个操作需要执行10分钟以上……平时最多几十秒而已。

万事不决问AI

当时实际的情况是：物理内存已经空出来15G左右，swap还有6个G，swapoff的时候CPU空闲得很很，硬盘也是调整SSD，没有理由这么慢。

AI说了一堆理由，然而这个不重要，重点是如何改善。

改进方案

AI提了一堆方案，我挑了一些可能有点效果的：

降低系统对swap的积极性，并且提高系统回收内存的积极性

# 修改/etc/sysctl.conf，增加以下配置：
vm.swappiness=10  # swap积极性，默认是60
vm.watermark_scale_factor=50  # 回收积极性，默认是10
# 立即生效
sudo sysctl -p

开启zswap

# 立即打开
echo 1 | sudo tee /sys/module/zswap/parameters/enabled
# 永久开启，通常需要修改 /etc/default/grub，在 GRUB_CMDLINE_LINUX_DEFAULT 中加入 zswap.enabled=1，然后
sudo update-grub
# 修改压缩算法
echo zstd | sudo tee /sys/module/zswap/parameters/compressor  # 默认是lzo，建议改为zstd或lz4

改用drop_caches来刷新内存

sudo sync && echo 3 | sudo tee /proc/sys/vm/drop_caches

观察一段时间看看。

推送到[go4pro.org]

视频处理工具

Sat, 18 Apr 2026 17:40:38 +0800

需求

以前我是很少拍视频的，主要是拍照，但是自从买了DJI的Action4和Neo2以后，视频内容就多了，转换视频的需求也多了。

GUI工具固然好用，但是操作麻烦效率低下，我需要的功能也没那么复杂，通常就是转个码率分辨率（便于网上发），或者裁剪一下什么的，ffmpeg足矣。

但是用过ffmpeg的人都知道，这玩意儿功能是强大，但是命令行参数也是复杂得一笔，为了省事，我把常用的几个操作都写成shell脚本，时间一长就积累了一堆脚本，用起来也还是不方便。

解决

这几天一怒之下拿AI把这些脚本整合成一个，于是有这个工具脚本：

#!/bin/bash

# mp4tool.sh - 视频处理多功能工具
# 用法: mp4tool.sh [选项] 输入文件
# 选项:
#   -b 码率      指定视频码率 (如 1500K, 3M)
#   -s 分辨率    缩放分辨率 (720p/1080p/2160p/4k)，仅缩小不放大
#   -f           修复模式，使用copy方式不重新编码
#   -cpu         强制使用CPU编码，默认使用GPU
#   -dji         DJI模式，使用轨道映射，默认码率*4
#   -t           竖屏转横屏（可选p参数，如-tp则填充16:9）
#   -cs 时间     开头剪辑位置（秒数或HH:MM:SS格式）
#   -ce 时间     结尾剪辑位置（秒数或HH:MM:SS格式，时间格式表示结束点位置）
#   -p 后缀      输出文件后缀，默认为 "out"
#   -af 音频文件  指定外部音频文件作为视频音轨

# 默认值
BITRATE=""
SCALE=""
FIX_MODE=false
USE_CPU=false
DJI_MODE=false
TRANSPOSE_MODE=""
CUT_START=0
CUT_END=0
SUFFIX="out"
INPUT=""
CUT_END_ARG=""
AUDIO_FILE=""

# 将时间字符串转换为秒数
# 支持格式：纯数字（秒）、SS、MM:SS、HH:MM:SS
parse_time() {
    local time_str="$1"
    
    # 检查是否包含冒号
    if [[ "$time_str" == *":"* ]]; then
        # 时间格式，解析 HH:MM:SS 或 MM:SS
        local IFS=':'
        read -ra parts <<< "$time_str"
        local seconds=0
        local multiplier=1
        
        # 从后往前处理
        for (( i=${#parts[@]}-1; i>=0; i-- )); do
            seconds=$(( seconds + ${parts[i]} * multiplier ))
            multiplier=$(( multiplier * 60 ))
        done
        echo "$seconds"
    else
        # 纯数字，直接返回秒数
        echo "$time_str"
    fi
}

# 解析参数
while [[ $# -gt 0 ]]; do
    case $1 in
        -b)
            BITRATE="$2"
            BITRATE_SPECIFIED=true
            shift 2
            ;;
        -s)
            SCALE="$2"
            shift 2
            ;;
        -f)
            FIX_MODE=true
            shift
            ;;
        -cpu)
            USE_CPU=true
            shift
            ;;
        -dji)
            DJI_MODE=true
            shift
            ;;
        -tp)
            TRANSPOSE_MODE="pad"
            shift
            ;;
        -t)
            TRANSPOSE_MODE="rotate"
            shift
            ;;
        -cs)
            CUT_START=$(parse_time "$2")
            shift 2
            ;;
        -ce)
            CUT_END_ARG="$2"
            shift 2
            ;;
        -af)
            AUDIO_FILE="$2"
            shift 2
            ;;
        -p)
            SUFFIX="$2"
            shift 2
            ;;
        *)
            INPUT="$1"
            shift
            ;;
    esac
done

# 检查输入文件
if [ -z "$INPUT" ]; then
    echo "用法: mp4tool.sh [选项] 输入文件"
    echo "选项:"
    echo "  -b 码率      指定视频码率 (如 1500K, 3M)"
    echo "  -s 分辨率    缩放分辨率 (720p/1080p/2160p/4k)，仅缩小不放大"
    echo "  -f           修复模式，使用copy方式不重新编码"
    echo "  -cpu         强制使用CPU编码，默认使用GPU"
    echo "  -dji         DJI模式，使用轨道映射，默认码率*4"
    echo "  -t           竖屏转横屏（仅旋转）"
    echo "  -tp          竖屏转横屏（旋转并填充16:9）"
    echo "  -cs 时间     开头剪辑位置（秒数或HH:MM:SS格式）"
    echo "  -ce 时间     结尾剪辑位置（秒数或HH:MM:SS格式，时间格式表示结束点位置）"
    echo "  -af 音频文件  指定外部音频文件作为视频音轨"
    echo "  -p 后缀      输出文件后缀，默认为 'out'"
    exit 1
fi

if [ ! -f "$INPUT" ]; then
    echo "错误: 文件 '$INPUT' 不存在"
    exit 1
fi

if [ -n "$AUDIO_FILE" ] && [ ! -f "$AUDIO_FILE" ]; then
    echo "错误: 音频文件 '$AUDIO_FILE' 不存在"
    exit 1
fi

# 输出文件名
OUTPUT="${INPUT%.*}.${SUFFIX}.mp4"

# 获取视频信息
get_video_info() {
    ffprobe -v error -select_streams v:0 -show_entries stream=width,height,duration -of csv=p=0 "$1" 2>/dev/null
}

# 获取原视频码率（返回bps）
get_video_bitrate() {
    ffprobe -v error -select_streams v:0 -show_entries stream=bit_rate -of default=noprint_wrappers=1:nokey=1 "$1" 2>/dev/null
}

# 将码率字符串转换为bps数值
parse_bitrate() {
    local br="$1"
    local num=$(echo "$br" | sed 's/[^0-9.]//g')
    local unit=$(echo "$br" | sed 's/[0-9.]//g' | tr '[:lower:]' '[:upper:]')
    
    case $unit in
        K|KB|KBIT) echo "$(echo "$num * 1000" | bc)" ;;
        M|MB|MBIT) echo "$(echo "$num * 1000000" | bc)" ;;
        G|GB|GBIT) echo "$(echo "$num * 1000000000" | bc)" ;;
        *) echo "$num" ;;
    esac
}

# 分辨率高度映射
get_target_height() {
    case $1 in
        720p)  echo 720 ;;
        1080p) echo 1080 ;;
        2160p|4k) echo 2160 ;;
        *) echo 0 ;;
    esac
}

# 根据分辨率获取默认码率
get_default_bitrate() {
    case $1 in
        720p)  echo "1500K" ;;
        1080p) echo "3000K" ;;
        2160p|4k) echo "10000K" ;;
        *) echo "3000K" ;;
    esac
}

# 处理 -ce 参数（需要在获取视频时长之后）
# 纯数字表示结尾剪掉的秒数，时间格式表示结束点位置
if [ -n "$CUT_END_ARG" ]; then
    if [[ "$CUT_END_ARG" == *":"* ]]; then
        # 时间格式，计算从结尾剪掉的秒数
        CUT_END_TIME=$(parse_time "$CUT_END_ARG")
        # 需要获取视频时长来计算
        DURATION_FOR_CUT=$(ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$INPUT" 2>/dev/null)
        if [ -n "$DURATION_FOR_CUT" ]; then
            CUT_END=$(echo "$DURATION_FOR_CUT - $CUT_END_TIME" | bc)
            CUT_END=$(printf "%.0f" "$CUT_END")
            if [ "$(echo "$CUT_END < 0" | bc)" -eq 1 ]; then
                CUT_END=0
            fi
        fi
    else
        # 纯数字，直接作为剪掉的秒数
        CUT_END="$CUT_END_ARG"
    fi
fi

# 获取原视频分辨率（先获取视频信息用于判断）
VIDEO_INFO=$(get_video_info "$INPUT")
if [ -z "$VIDEO_INFO" ]; then
    echo "错误: 无法获取视频信息"
    exit 1
fi

ORIGINAL_WIDTH=$(echo "$VIDEO_INFO" | cut -d',' -f1)
ORIGINAL_HEIGHT=$(echo "$VIDEO_INFO" | cut -d',' -f2)
VIDEO_DURATION=$(echo "$VIDEO_INFO" | cut -d',' -f3)

echo "原视频: ${ORIGINAL_WIDTH}x${ORIGINAL_HEIGHT}, 时长: ${VIDEO_DURATION}s"

# 确定是否需要缩放
NEED_SCALE=false
TARGET_WIDTH=""
TARGET_HEIGHT=""

if [ -n "$SCALE" ]; then
    TARGET_HEIGHT=$(get_target_height "$SCALE")
    
    if [ "$TARGET_HEIGHT" -eq 0 ]; then
        echo "错误: 不支持的分辨率 '$SCALE'，支持: 720p, 1080p, 2160p, 4k"
        exit 1
    fi
    
    # 转置模式下，宽高互换
    if [ -n "$TRANSPOSE_MODE" ]; then
        # 转置后：宽度=原高度，高度=原宽度
        TRANSPOSED_WIDTH=$ORIGINAL_HEIGHT
        TRANSPOSED_HEIGHT=$ORIGINAL_WIDTH
        
        # 仅缩小，不放大（基于转置后的高度）
        if [ "$TRANSPOSED_HEIGHT" -gt "$TARGET_HEIGHT" ]; then
            NEED_SCALE=true
            # 计算目标宽度（基于转置后的比例）
            TARGET_WIDTH=$(echo "scale=0; $TRANSPOSED_WIDTH * $TARGET_HEIGHT / $TRANSPOSED_HEIGHT" | bc)
            # 确保宽度为偶数
            TARGET_WIDTH=$(echo "scale=0; $TARGET_WIDTH / 2 * 2" | bc)
            echo "转置后将缩放到: ${TARGET_WIDTH}x${TARGET_HEIGHT}"
        else
            echo "转置后高度 ($TRANSPOSED_HEIGHT) <= 目标高度 ($TARGET_HEIGHT)，不缩放"
        fi
    else
        # 仅缩小，不放大
        if [ "$ORIGINAL_HEIGHT" -gt "$TARGET_HEIGHT" ]; then
            NEED_SCALE=true
            # 计算目标宽度（保持宽高比）
            TARGET_WIDTH=$(echo "scale=0; $ORIGINAL_WIDTH * $TARGET_HEIGHT / $ORIGINAL_HEIGHT" | bc)
            # 确保宽度为偶数
            TARGET_WIDTH=$(echo "scale=0; $TARGET_WIDTH / 2 * 2" | bc)
            echo "将缩放到: ${TARGET_WIDTH}x${TARGET_HEIGHT}"
        else
            echo "原视频高度 ($ORIGINAL_HEIGHT) <= 目标高度 ($TARGET_HEIGHT)，不缩放"
        fi
    fi
fi

# 竖屏转横屏模式
if [ -n "$TRANSPOSE_MODE" ]; then
    echo "竖屏转横屏模式: $TRANSPOSE_MODE"
    # 转置操作需要CPU处理，强制使用CPU
    USE_CPU=true
fi

# DJI模式：禁用自动copy模式
if [ "$DJI_MODE" = true ]; then
    echo "DJI模式: 启用轨道映射..."
fi

# 获取原视频码率
ORIGINAL_BITRATE=$(get_video_bitrate "$INPUT")
if [ -n "$ORIGINAL_BITRATE" ] && [ "$ORIGINAL_BITRATE" != "N/A" ]; then
    echo "原视频码率: ${ORIGINAL_BITRATE} bps"
fi

# 判断是否需要处理
NEED_PROCESS=true

# 如果指定了分辨率但不需要缩放，检查码率
if [ -n "$SCALE" ] && [ "$NEED_SCALE" = false ]; then
    TARGET_BITRATE=$(parse_bitrate "$(get_default_bitrate "$SCALE")")
    if [ -n "$ORIGINAL_BITRATE" ] && [ "$ORIGINAL_BITRATE" != "N/A" ]; then
        if [ "$ORIGINAL_BITRATE" -le "$TARGET_BITRATE" ]; then
            echo "原视频码率 ($ORIGINAL_BITRATE) <= 目标码率 ($TARGET_BITRATE)，无需处理"
            NEED_PROCESS=false
        else
            echo "原视频码率 ($ORIGINAL_BITRATE) > 目标码率 ($TARGET_BITRATE)，将转码"
            BITRATE=$(get_default_bitrate "$SCALE")
        fi
    fi
fi

# 如果指定了码率，检查是否低于原视频码率
if [ -n "$BITRATE" ] && [ "$BITRATE_SPECIFIED" = true ] && [ "$NEED_SCALE" = false ]; then
    TARGET_BITRATE=$(parse_bitrate "$BITRATE")
    if [ -n "$ORIGINAL_BITRATE" ] && [ "$ORIGINAL_BITRATE" != "N/A" ]; then
        if [ "$ORIGINAL_BITRATE" -le "$TARGET_BITRATE" ]; then
            echo "原视频码率 ($ORIGINAL_BITRATE) <= 指定码率 ($TARGET_BITRATE)，无需处理"
            NEED_PROCESS=false
        fi
    fi
fi

# 如果不需要处理，直接退出
if [ "$NEED_PROCESS" = false ]; then
    echo "视频无需处理，退出"
    exit 0
fi

# 如果没有指定码率和分辨率，自动使用copy模式（DJI模式除外）
if [ -z "$BITRATE" ] && [ "$NEED_SCALE" = false ] && [ "$DJI_MODE" = false ] && [ -z "$TRANSPOSE_MODE" ]; then
    echo "未指定码率和分辨率，自动使用copy模式..."
    FIX_MODE=true
fi

# 修复模式：使用copy方式
if [ "$FIX_MODE" = true ]; then
    echo "修复模式: 使用copy方式..."
    
    CMD="ffmpeg -i \"$INPUT\""
    
    # 外部音频文件
    if [ -n "$AUDIO_FILE" ]; then
        CMD="$CMD -i \"$AUDIO_FILE\""
        echo "外部音频: $AUDIO_FILE"
    fi
    
    # 添加剪辑参数
    if [ "$CUT_START" -gt 0 ] || [ "$CUT_END" -gt 0 ]; then
        if [ "$CUT_START" -gt 0 ]; then
            CMD="$CMD -ss $CUT_START"
        fi
        if [ "$CUT_END" -gt 0 ]; then
            # 获取视频时长
            DURATION=$(ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$INPUT" 2>/dev/null)
            if [ -n "$DURATION" ]; then
                END_TIME=$(echo "$DURATION - $CUT_END" | bc)
                CMD="$CMD -to $END_TIME"
            fi
        fi
    fi
    
    if [ -n "$AUDIO_FILE" ]; then
        CMD="$CMD -map 0:v:0 -map 1:a:0 -c:v copy -c:a copy -shortest -f mp4 -y \"$OUTPUT\""
    else
        CMD="$CMD -c copy -f mp4 -y \"$OUTPUT\""
    fi
    
    echo "执行: $CMD"
    eval "$CMD"
    exit $?
fi

# 确定码率
if [ -z "$BITRATE" ]; then
    if [ "$NEED_SCALE" = true ]; then
        BITRATE=$(get_default_bitrate "$SCALE")
    else
        BITRATE="3000K"
    fi
fi

# DJI模式：如果未指定码率，默认码率*4
if [ "$DJI_MODE" = true ] && [ "$BITRATE_SPECIFIED" != true ]; then
    # 将码率转换为数字并乘以4
    BITRATE_NUM=$(echo "$BITRATE" | sed 's/[^0-9]//g')
    BITRATE_UNIT=$(echo "$BITRATE" | sed 's/[0-9]//g')
    BITRATE=$((BITRATE_NUM * 4))${BITRATE_UNIT}
fi

echo "码率: $BITRATE"

# 构建ffmpeg命令
build_ffmpeg_cmd() {
    local USE_GPU=$1
    local CMD="ffmpeg"
    
    # GPU加速输入
    if [ "$USE_GPU" = true ]; then
        CMD="$CMD -hwaccel vaapi -hwaccel_device /dev/dri/renderD128 -hwaccel_output_format vaapi"
    fi
    
    # 剪辑参数（放在 -i 前面实现快速定位）
    if [ "$CUT_START" -gt 0 ]; then
        CMD="$CMD -ss $CUT_START"
    fi
    
    CMD="$CMD -i \"$INPUT\""
    
    # 外部音频文件
    if [ -n "$AUDIO_FILE" ]; then
        CMD="$CMD -i \"$AUDIO_FILE\""
    fi
    
    # DJI模式：轨道映射 / 音频映射
    if [ -n "$AUDIO_FILE" ]; then
        CMD="$CMD -map 0:v:0 -map 1:a:0"
    elif [ "$DJI_MODE" = true ]; then
        CMD="$CMD -map 0:v:0 -map 0:a:0"
    fi
    
    # 结尾剪辑
    if [ "$CUT_END" -gt 0 ] && [ -n "$VIDEO_DURATION" ]; then
        END_TIME=$(echo "$VIDEO_DURATION - $CUT_END - $CUT_START" | bc)
        CMD="$CMD -t $END_TIME"
    fi
    
    if [ "$USE_GPU" = true ]; then
        # GPU编码
        if [ "$NEED_SCALE" = true ]; then
            CMD="$CMD -vf 'hwupload,scale_vaapi=w=${TARGET_WIDTH}:h=${TARGET_HEIGHT}:format=nv12'"
        else
            CMD="$CMD -vf 'hwupload,scale_vaapi=w=-1:h=-1:format=nv12'"
        fi
        CMD="$CMD -c:v hevc_vaapi -b:v $BITRATE"
    else
        # CPU编码
        VF_FILTER=""
        
        # 竖屏转横屏处理
        if [ -n "$TRANSPOSE_MODE" ]; then
            if [ "$TRANSPOSE_MODE" = "pad" ]; then
                # 旋转并填充为16:9
                VF_FILTER="transpose=2,pad=ih*16/9:ih:(ow-iw)/2:(oh-ih)/2"
            else
                # 仅旋转
                VF_FILTER="transpose=2"
            fi
            
            # 如果还需要缩放（转置后的分辨率）
            if [ "$NEED_SCALE" = true ]; then
                VF_FILTER="${VF_FILTER},scale=${TARGET_WIDTH}:${TARGET_HEIGHT}"
            fi
        elif [ "$NEED_SCALE" = true ]; then
            VF_FILTER="scale=${TARGET_WIDTH}:${TARGET_HEIGHT}"
        fi
        
        if [ -n "$VF_FILTER" ]; then
            CMD="$CMD -vf '$VF_FILTER'"
        fi
        
        CMD="$CMD -c:v libx265 -b:v $BITRATE"
    fi
    
    # 音频和其他流处理
    if [ -n "$AUDIO_FILE" ]; then
        CMD="$CMD -c:a copy -shortest -f mp4 -y \"$OUTPUT\""
    else
        CMD="$CMD -c:a copy -c:d copy -f mp4 -y \"$OUTPUT\""
    fi
    
    echo "$CMD"
}

# 执行编码
if [ "$USE_CPU" = true ]; then
    echo "使用CPU编码..."
    CMD=$(build_ffmpeg_cmd false)
else
    echo "使用GPU编码..."
    CMD=$(build_ffmpeg_cmd true)
fi

echo "执行: $CMD"
eval "$CMD"

if [ $? -eq 0 ]; then
    echo "编码成功: $OUTPUT"
else
    echo "编码失败"
    exit 1
fi

需要注意的是，因为我是用AMD的，所以GPU加速用的是vaapi，如果你是用nVidia，则需要改一下。

推送到[go4pro.org]

NFS做K8s存储的问题处理

Sat, 07 Mar 2026 11:36:31 +0800

起因

就是之前说的《在K8s上部署Mastodon》，因为web和sidekiq两个pod都需要读写public路径，所以当时用了NFS来配置成RWX模式的PV/PVC给它们用。但实际使用下来发现稳定性不行。

AI的解释是：

NFS 的协议特性、高并发网络 I/O 以及 K8s 的动态编排机制产生了冲突。

推荐的解决方案是：用Ceph这样的云存储方案或Rancher的Local path provisioner这样的本地存储方案。

但是Ceph过于笨重了，我的K8s环境又不是用RKE装的，也懒得再去搞LPP，所以改为最简单的方案hostPath吧。

解决方案

修改mastodon的service配置文件，以web服务为例，如svc_mastodon_web.yml：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mastodon-web
  namespace: mastodon
  labels:
    app: mastodon
    component: web
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mastodon
      component: web
  template:
    metadata:
      labels:
        app: mastodon
        component: web
    spec:
      containers:
      - name: mastodon-web
        image: ghcr.io/mastodon/mastodon:v4.5.2
        command: ["bash", "-c", "rm -f /mastodon/tmp/pids/server.pid; bundle exec puma -C config/puma.rb"]
        ports:
        - containerPort: 3000
        envFrom:
        - secretRef:
            name: mastodon-env
        resources:
          requests:
            cpu: "500m"
            memory: "1Gi"
          limits:
            cpu: "2"
            memory: "2Gi"
        volumeMounts:
        - name: mastodon-data-web
          mountPath: /mastodon/public/system
        livenessProbe:
          exec:
            command:
            - curl
            - -s
            - --noproxy
            - localhost
            - localhost:3000/health
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          exec:
            command:
            - curl
            - -s
            - --noproxy
            - localhost
            - localhost:3000/health
          initialDelaySeconds: 5
          periodSeconds: 10
      volumes:
      - name: mastodon-data-web
        hostPath:
          path: /var/data/mastodon
          type: Directory
---
apiVersion: v1
kind: Service
metadata:
  name: mastodon-web
  namespace: mastodon
  labels:
    app: mastodon
    component: web
spec:
  type: NodePort
  selector:
    app: mastodon
    component: web
  ports:
  - protocol: TCP
    port: 3000
    targetPort: 3000
    nodePort: 30300

其中的关键就是把volumes配置从原来的nfs pvc换成了hostPath。单节点就是这点好，比如那个nodePort也是，外面加个nginx反代一下就好了，也不用什么ingress。

推送到[go4pro.org]

OpenClaw的安装与使用

Sat, 14 Feb 2026 19:30:00 +0800

本文由deepseek提供辅助编写

OpenClaw简介

最近这个龙虾机器人很红，最早是叫ClawBot，后来被Claude告了，改成MoltBot，然后又改成现在的OpenClaw。

主要特性:

支持多个AI模型接入(OpenAI、Claude、等)
多渠道消息推送(Telegram、钉钉、企业微信等)
插件化架构,易于扩展
支持对话上下文管理
Docker部署支持
配置简单,开箱即用

安装OpenClaw

准备工作

需要准备一台配置为2C2G或更高的虚拟机, 确保虚拟机有外网访问权限。系统为Linux，这里以Debian13为例。

安装步骤

使用官方一键安装脚本安装OpenClaw:

curl -fsSL https://openclaw.ai/install.sh | bash

建议使用当前用户安装，如果用root用户安装可以有更大的权限，但也有更大的风险。

安装过程中需要配置AI接口，如果你有OpenAI或Claude的API直接配置上去就好了，早年Deepseek没有在支持列表里，需要后面再配，这里只能先跳过，现在版本已经支持了。

安装过程中如果有问题，可以再次安装

# 完全重装
openclaw setup
# 安装后的设置
openclaw onboard

如果openclaw命令不能使用，可能需要重新登录一下当前用户。如果登录后还不行，则需要再次运行一键安装脚本。

配置DeepSeek API

DeepSeek是国内优秀的AI模型提供商,提供免费和付费的API服务。OpenClaw支持对接DeepSeek API,配置方式与OpenAI类似。

1. 获取DeepSeek API Key

访问DeepSeek官网: https://platform.deepseek.com
注册账号并登录
进入API Keys页面
点击"Create new API Key"创建新的API密钥
保存生成的API Key

2. 配置OpenClaw使用DeepSeek

编辑OpenClaw配置文件:

vim ~/.openclaw/openclaw.json

修改AI配置部分:

"models": {
  "providers": {
    "deepseek": {
      "baseUrl": "https://api.deepseek.com/v1",  # DeepSeek API地址
      "apiKey": "你的DeepSeek API Key",
      "auth": "api-key",
      "api": "openai-completions",
      "models": [
        {
          "id": "deepseek-v4-flase",
          "name": "Deepseek V4 Flash",
          "contextWindow": 1048576,
          "maxTokens": 16384
        }
        {
          "id": "deepseek-v4-pro",
          "name": "Deepseek V4 Pro",
          "contextWindow": 1048576,
          "maxTokens": 16384
        }
      ]
    }
  }
}

4. 测试DeepSeek API

重启OpenClaw服务后,发送测试消息:

systemctl --user restart openclaw
# 或
openclaw gateway restart

在Telegram或钉钉中发送消息,OpenClaw会使用DeepSeek模型进行回复。

5. 使用DeepSeek免费额度

DeepSeek新用户提供免费API额度, 可以在DeepSeek控制台查看使用情况:

登录DeepSeek平台
进入Dashboard页面
查看API使用统计和剩余额度

如果免费额度用完, 可以充值付费使用或换其它的服务商，但目前Deepseek是性价比最高的。

配置Telegram频道

Telegram是OpenClaw最常用的消息推送渠道之一。配置Telegram频道需要创建Bot并获取Bot Token。

1. 创建Telegram Bot

在Telegram中搜索并添加BotFather (@BotFather)
发送命令 /newbot 创建新机器人
按提示设置机器人的名称和用户名
创建成功后,BotFather会返回一个Bot Token,格式如 123456789:ABCdefGHIjklMNOpqrsTUVwxyz
保存这个Token,后续配置需要用到

2. 配置OpenClaw

直接用onboard命令配置即可。

获取Telegram用户ID的方法:

在Telegram中搜索并添加userinfobot (@userinfobot)
点击"Start"按钮
机器人会返回你的用户ID

3. 配置Webhook(可选)

如果你有公网域名,可以配置Webhook来接收Telegram消息:

确保域名可以访问到OpenClaw服务
设置Telegram Webhook:

curl -X POST "https://api.telegram.org/bot你的Bot Token/setWebhook" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://你的域名/webhook/telegram",
    "secret_token": "your-secret-key"
  }'

验证Webhook设置:

curl "https://api.telegram.org/bot你的Bot Token/getWebhookInfo"

4. 重启服务

配置完成后,重启OpenClaw服务使配置生效

5. 测试

在Telegram中找到你的Bot,发送消息"hello",如果配置正确,应该能收到AI的回复。

对接钉钉

OpenClaw可以通过插件对接钉钉,实现消息推送到钉钉群聊。这里使用开源插件 soimy/openclaw-channel-dingtalk。

1. 创建钉钉机器人

在钉钉群设置中选择"智能群助手"
点击"添加机器人" -> “自定义”
设置机器人名称,例如"OpenClaw"
设置安全设置,推荐选择"加签"方式
创建成功后,会获得:
- Webhook地址
- 加签密钥(Secret)

保存这些信息,后续配置需要用到。

2. 安装钉钉插件

直接在配置好的TG或openclaw的webui中把插件链接给它，让它自己配置。

3. 测试钉钉推送

重启OpenClaw服务

直接和钉钉机器人对话，或建个群后在钉钉群中发送包含触发关键词的消息,例如"AI你好",OpenClaw应该会响应并返回AI的回复。

在Docker上安装OpenClaw

Docker部署方式适合快速测试和在容器化环境中使用OpenClaw。

1. 准备工作

确保系统已安装Docker和Docker Compose

2. 创建项目目录

mkdir -p ~/openclaw
cd ~/openclaw

3. 创建docker-compose.yml

创建 docker-compose.yml 文件:

cat > docker-compose.yml << EOF
version: '3.8'

services:
  openclaw:
    image: ghcr.io/openclaw/openclaw:2026.4.22-slim
    container_name: openclaw
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - ~/openclaw:/home/node/.openclaw
    environment:
      - TZ=Asia/Shanghai
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
EOF

5. 启动OpenClaw

# 拉取镜像并启动服务
docker-compose up -d

# 查看日志
docker-compose logs -f

# 查看服务状态
docker-compose ps

6. 管理命令

# 停止服务
docker-compose stop

# 启动服务
docker-compose start

# 重启服务
docker-compose restart

# 查看日志
docker-compose logs -f

# 进入容器
docker-compose exec openclaw sh

# 更新镜像
docker-compose pull
docker-compose up -d

7. 数据持久化

OpenClaw的数据(包括对话历史、配置等)会保存在 ~/.openclaw 目录中。建议定期备份这个目录:

# 备份数据
tar -czf openclaw-backup-$(date +%Y%m%d).tar.gz data/

# 恢复数据
tar -xazf openclaw-backup-20260210.tar.gz

常见问题

1. 服务无法启动

检查日志查看错误信息:

# 系统安装方式
sudo journalctl -u openclaw -n 50

# Docker方式
docker-compose logs -f

常见原因:

配置文件语法错误
端口被占用
权限不足

2. 消息发送失败

检查:

API Key是否正确
网络连接是否正常
渠道配置是否正确(如Bot Token、Webhook地址等)
是否有防火墙限制

3. Docker容器无法访问外网

检查Docker网络配置:

# 检查Docker网络
docker network inspect bridge

# 重启Docker服务
sudo systemctl restart docker

4. 更新OpenClaw

系统安装方式:

openclaw update

Docker方式:

docker-compose pull
docker-compose up -d

总结

本文介绍了OpenClaw的多种安装和使用方式:

系统安装: 使用一键安装脚本在Debian上安装,适合长期运行的服务器环境
Telegram配置: 创建Bot并配置Webhook,实现Telegram消息推送
DeepSeek API配置: 对接国内优秀的AI模型提供商,支持免费和付费API
钉钉对接: 使用开源插件实现钉钉群聊消息推送
Docker部署: 使用Docker Compose快速部署,适合测试和容器化环境

OpenClaw提供了灵活的消息推送解决方案,可以根据实际需求选择合适的安装方式和配置选项。建议在生产环境中使用系统安装方式,并定期备份数据。

参考资源

OpenClaw官方文档: https://openclaw.ai
Telegram Bot API: https://core.telegram.org/bots/api
钉钉机器人开发: https://open.dingtalk.com/document/robots/custom-robot-access
钉钉插件仓库: https://github.com/soimy/openclaw-channel-dingtalk

推送到[go4pro.org]

在K8s上部署Mastodon

Sun, 04 Jan 2026 21:54:21 +0800

准备工作

因为原来用于跑毛象的服务器（参见旧文《Docker下的Mastodon安装笔记》）到期停机了，正好手里有一个高配的arm免费机可以用，于是就打算把服务迁移过来——顺便试试部署到K8s上。

需要：

一台或多台服务器集群，内存至少4G，推荐8G，最好16G或更多，有外网IP，有一个域名
安装Kubernetes集群（可以使用k3s、minikube或云服务商的K8s服务，本文使用一个kubeadm安装的单节点k8s，见《在单机上用kubeadm安装K8s》）
一个SMTP服务——第三方或本地，这里用了第三方服务
创建必要的存储目录（根据实际节点名称调整路径，这里使用/var/data）
拉取Redis/Postgresql/ES/Mastodon镜像

crictl pull redis:7-alpine
crictl pull postgres:17-alpinie
crictl pull elasticsearch:7.10.1
crictl pull ghcr.io/mastodon/mastodon:v4.5.2
crictl pull ghcr.io/mastodon/mastodon-streaming:v4.5.2

配置存储

1. 创建命名空间

首先创建mastodon命名空间：

kubectl apply -f ns_mastodon.yml

ns_mastodon.yml

apiVersion: v1
kind: Namespace
metadata:
  name: mastodon

2. 配置Local PV/PVC（用于有状态服务）

我们使用local PV/PVC为PostgreSQL、Redis和Elasticsearch提供持久化存储：

Redis存储配置

# 创建Redis数据目录（在目标节点上）
sudo mkdir -p /var/data/redis/data
sudo chown 999:999 /var/data/redis/data

# 应用PV/PVC配置
kubectl apply -f local_redis.yml

local_redis.yml

apiVersion: v1
kind: PersistentVolume
metadata:
  name: local-redis-data
  labels:
    type: local
spec:
  capacity:
    storage: 10Gi  # 总容量，根据实际需要调整
  volumeMode: Filesystem
  accessModes:
  - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: local-redis-data
  local:
    path: /var/data/redis/data
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/hostname
          operator: In
          values:
          - myserver  # 替换为实际节点名称
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: redis-data-pvc
  namespace: mastodon
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi  # 主数据存储大小
  storageClassName: local-redis-data
  selector:
    matchLabels:
      type: local

PostgreSQL存储配置

# 创建PostgreSQL数据目录（在目标节点上）
sudo mkdir -p /var/data/pgdata
sudo mkdir -p /var/data/pgbak
sudo chown 70:70 /var/data/pgdata /var/data/pgbak
sudo chmod 700 /var/data/pgdata

# 应用PV/PVC配置
kubectl apply -f local_posgresql.yml  # 内容参考redis，不过需要配置data和bak两个PV/PVC

Elasticsearch存储配置

# 创建Elasticsearch数据目录（在目标节点上）
sudo mkdir -p /var/data/elasticsearch
sudo chown 1000:1000 /var/data/elasticsearch

# 应用PV/PVC配置
kubectl apply -f local_elasticsearch.yml  # 内容参考redis

3. 配置NFS PV/PVC（用于Mastodon Public文件夹）

Mastodon需要共享存储来存储用户上传的媒体文件，因为需要同时给两个服务（web和streaming）使用，所以使用NFS PV/PVC：

# 创建NFS共享目录
sudo mkdir -p /var/data/mastodon
sudo chown 991:991 /var/data/mastodon

# 配置NFS服务器（如果尚未配置）
# 安装NFS服务器
sudo apt-get install nfs-kernel-server

# 配置NFS导出
echo "/var/data/mastodon *(rw,sync,no_subtree_check,no_root_squash,all_squash,anonuid=991,anongid=991)" | sudo tee -a /etc/exports
sudo exportfs -a  # 应用配置
sudo systemctl restart nfs-kernel-server
sudo exportfs -v  # 查看应用结果

# 应用NFS配置
kubectl apply -f nfs_mastodon.yml

nsf_mastodon.yml

apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfs-mastodon-data-web
  labels:
    type: nfs
spec:
  capacity:
    storage: 150Gi  # 总容量，根据实际需要调整
  volumeMode: Filesystem
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  storageClassName: nfs-mastodon-data-web
  nfs:
    server: 10.244.0.1  # flannel的IP
    path: /var/data/mastodon
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mastodon-data-web-pvc
  namespace: mastodon
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 150Gi  # 主数据存储大小
  storageClassName: nfs-mastodon-data-web
  selector:
    matchLabels:
      type: nfs
---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfs-mastodon-data-sidekiq
  labels:
    type: nfs
spec:
  capacity:
    storage: 150Gi  # 总容量，根据实际需要调整
  volumeMode: Filesystem
  accessModes:
  - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  storageClassName: nfs-mastodon-data-sidekiq
  nfs:
    server: 10.244.0.1  # 连同一个NFS
    path: /var/data/mastodon
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mastodon-data-sidekiq-pvc
  namespace: mastodon
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 150Gi  # 主数据存储大小
  storageClassName: nfs-mastodon-data-sidekiq
  selector:
    matchLabels:
      type: nfs

部署有状态服务（Stateful Headless Services）

1. 部署Redis

创建Redis的StatefulSet配置：

kubectl apply -f svc_redis.yml

svc_redis.yml

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redis
  namespace: mastodon
spec:
  serviceName: redis-headless  # 需要一个 Headless Service 管理网络标识
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
      - name: redis
        image: redis:7-alpine
        ports:
        - containerPort: 6379
        volumeMounts:
        - name: redis-data
          mountPath: /data
        livenessProbe:
          exec:
            command: ["redis-cli", "ping"]
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          exec:
            command: ["redis-cli", "ping"]
          initialDelaySeconds: 5
          periodSeconds: 10
      volumes:
      - name: redis-data
        persistentVolumeClaim:
          claimName: redis-data-pvc  # 直接使用现有 PVC
  volumeClaimTemplates: []
---
apiVersion: v1
kind: Service
metadata:
  name: redis-headless
  namespace: mastodon
spec:
  clusterIP: None  # Headless Service，直接解析到 Pod IP
  selector:
    app: redis
  ports:
  - port: 6379
    name: redis

2. 部署PostgreSQL

PostgreSQL使用StatefulSet和Headless Service：

kubectl apply -f svc_postgresql.yml  # 内容参考svc_redis.yml，不过要mount两个卷

3. 部署Elasticsearch

创建Elasticsearch的StatefulSet配置：

kubectl apply -f svc_elasticsearch.yml  # 内容参考svc_redis.yml

4. 验证部署

kubectl get statefulsets -n mastodon
kubectl get pods -n mastodon -l app=postgresql
kubectl get services -n mastodon | grep postgresql

配置Mastodon

1. 准备环境配置文件

编辑 env.production 文件，配置以下关键参数：

# Redis配置
REDIS_HOST=redis-headless.mastodon.svc.cluster.local
REDIS_PORT=6379

# 数据库配置
DB_HOST=postgresql-headless.mastodon.svc.cluster.local
DB_PORT=5432
DB_NAME=mastodon
DB_USER=mastodon
DB_PASS=你的数据库密码

# Elasticsearch配置
ES_ENABLED=true
ES_HOST=es-headless.mastodon.svc.cluster.local
ES_PORT=9200

# 域名配置
LOCAL_DOMAIN=你的域名

2. 创建Secret配置

将环境配置创建为Secret：

kubectl create secret generic mastodon-env --from-env-file=env.production -n mastodon

3. 部署Mastodon服务

注意：除非是全新安装的实例，否则此操作需要在数据库恢复后进行。

创建Mastodon的Deployment配置：

kubectl apply -f svc_mastodon.yml  # 类似svc_redis.yml，不过里面有三个服务：web,streaming,sidekiq

其中mastodon的web和streaming是以NodePort方式输出服务。

恢复数据库

1. 全库备份恢复方式

使用pg_dumpall备份全库再恢复到k8s里。

# 从源docker环境备份整个库
docker exec postgresql pg_dumpall -U postgres | gzip > pgoldbak.sql.gz
# 把备份传输到k8s环境
# 恢复数据
gunzip -c pgoldbak.sql.gz | kubectl exec postgresql -i -n mastodon --command -- psql -U postgres

2. 基于WAL的增量备份恢复方式

备份恢复方式参考《PostgreSQL的连续备份配置》

3. 启动实例

恢复数据库确认无误后即可启动毛象实例。

启动服务

所有服务启动后检查状态：

kubectl get all -n mastodon

如果所有Pod都处于Running状态，说明部署成功。如果有问题，则需要查看日志检查原因。

kubectl logs -f <podname> -nmastodon

配置Nginx反向代理

创建Nginx配置，将流量代理到Mastodon服务：

cat > nginx/mastodon.conf << EOF
upstream backend {
    server <NODE_IP>:3xxxx;  # 替换为节点IP和mastodon-web的NodePort
}

upstream streaming {
    server <NODE_IP>:3yyyy;  # 替换为节点IP和mastodon-streaming的NodePort
}

server {
    listen 80;
    server_name 你的域名;
    return 301 https://\$server_name\$request_uri;
}

server {
    listen 443 ssl http2;
    server_name 你的域名;

    ssl_certificate /etc/ssl/你的域名/fullchain.pem;
    ssl_certificate_key /etc/ssl/你的域名/privkey.pem;

    root /var/data/mastodon/public;
    
    location / {
        try_files \$uri @proxy;
    }

    location @proxy {
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
        proxy_set_header Proxy "";
        proxy_pass_header Server;

        proxy_pass http://backend;
        proxy_buffering off;
        proxy_redirect off;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection "upgrade";

        tcp_nodelay on;
    }

    location /api/v1/streaming/ {
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
        proxy_set_header Proxy "";

        proxy_pass http://streaming;
        proxy_buffering off;
        proxy_redirect off;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection "upgrade";

        tcp_nodelay on;
    }
}
EOF

日常运维

1. 监控服务状态

# 查看所有资源状态
kubectl get all -n mastodon

# 查看Pod日志
kubectl logs -f deployment/mastodon-web -n mastodon
kubectl logs -f deployment/mastodon-streaming -n mastodon
kubectl logs -f deployment/mastodon-sidekiq -n mastodon

# 查看有状态服务日志
kubectl logs -f statefulset/postgresql -n mastodon
kubectl logs -f statefulset/redis -n mastodon
kubectl logs -f statefulset/elasticsearch -n mastodon

2. 定期清理

由于联邦宇宙中的内容会不断增加，需要定期清理过期数据，具体实现与之前docker方式部署一样，只是把docker命令改成相应的kubectl命令。

可以将这些清理任务添加到crontab中定期执行。

3. 备份与恢复

也可以参考前文实现，或者参考pgsql的wal备份那篇用备份wal的方式实现连续备份。

4. 升级Mastodon版本

升级Mastodon需要按顺序进行：

备份数据库
更新镜像版本
重新部署服务

# 更新镜像版本
sed -i 's|ghcr.io/mastodon/mastodon:v4.5.2|ghcr.io/mastodon/mastodon:新版本|g' svc_mastodon.yml
sed -i 's|ghcr.io/mastodon/mastodon-streaming:v4.5.2|ghcr.io/mastodon/mastodon-streaming:新版本|g' svc_mastodon.yml

# 重新部署
kubectl apply -f svc_mastodon.yml

K8s下的rollout升级：

# 不涉及数据库变更的小版本升级可以用rollout方式平稳升级：
kubectl set image deployment/mastodon-streaming streaming=ghcr.io/mastodon/mastodon-streaming:v4.5.4 -nmastodon
kubectl set image deployment/mastodon-sidekiq sidekiq=ghcr.io/mastodon/mastodon:v4.5.4 -nmastodon
kubectl set image deployment/mastodon-web mastodon-web=ghcr.io/mastodon/mastodon:v4.5.4 -nmastodon

kubectl rollout status deployment/mastodon-streaming -nmastodon
kubectl rollout status deployment/mastodon-sidekiq -nmastodon
kubectl rollout status deployment/mastodon-web -nmastodon

升级完成。

故障排除

1. Pod无法启动

检查Pod状态和日志：

kubectl describe pod <pod-name> -n mastodon
kubectl logs <pod-name> -n mastodon

常见问题：

存储卷挂载失败：检查PV/PVC状态 kubectl get pv,pvc -n mastodon
资源配置不足：检查资源限制 kubectl describe pod <pod-name> -n mastodon | grep -A 5 Resources
镜像拉取失败：检查镜像名称和标签

2. 服务无法访问

检查服务状态：

kubectl get services -n mastodon
kubectl describe service <service-name> -n mastodon

确保NodePort在正确范围内（30000-32767）。

3. 数据库连接问题

检查数据库服务：

# 测试数据库连接
kubectl run test-db-connection --rm -i --restart=Never \
  --image=postgres:17-alpine --namespace=mastodon -- \
  psql -h postgresql-headless.mastodon.svc.cluster.local -U postgres -c "\l"

4. 存储问题

检查存储状态：

kubectl get pv,pvc -n mastodon
kubectl describe pvc <pvc-name> -n mastodon

确保本地目录存在且有正确权限。

总结

本指南介绍了如何使用Kubernetes部署Mastodon实例，包括：

存储配置：使用local PV/PVC为有状态服务（PostgreSQL、Redis、Elasticsearch）提供持久化存储
网络配置：使用NFS PV/PVC为Mastodon public文件夹提供共享存储
服务部署：使用StatefulSet和Headless Service部署有状态服务，使用Deployment部署无状态服务
运维管理：包括监控、清理、备份、升级等日常运维操作

相比docker-compose部署方式，Kubernetes部署提供了更好的可扩展性、高可用性和运维便利性。可以根据实际需求调整资源配置和副本数量。

注意事项

安全性：生产环境需要配置更严格的安全策略，如Network Policies、Pod Security Policies等
性能：根据实际负载调整资源限制和副本数量
监控：建议配置Prometheus和Grafana进行监控
备份：定期备份数据库和重要数据
更新：关注Mastodon和安全更新，及时升级

如有问题，请参考Mastodon官方文档或Kubernetes官方文档。

推送到[go4pro.org]

将supervisor迁移到systemd

Sat, 20 Dec 2025 21:58:45 +0800

历史问题

在前systemd时代，要配置一个启动运行的服务还是比较麻烦的，所以才有了supervisor这种服务，但是现在systemd已经很成熟了，不再需要多此一举：

systemd启动supervisord，supervisord再来启动自定义服务

是时候把supervisor的服务迁移到systemd下了。

转换配置文件

首先是把/etc/supervisor/conf.d/下面的服务配置文件改成systemd格式的，然后放到/etc/systemd/system/下。

转换对照表如下：

Supervisor 指令	systemd 指令	说明
command	ExecStart	运行程序的完整路径和参数
directory	WorkingDirectory	程序运行的起始目录
user	User	运行该服务的用户
environment	Environment	环境变量设置
autostart	WantedBy=multi-user.target	是否随系统启动
autorestart	Restart=always	进程退出后是否自动重启
stdout_logfile	StandardOutput	标准输出（通常交给 journald）
stderr_logfile	StandardError	标准错误输出

一个典型的systemd服务单元配置如下：

[Unit]
Description=My Python Application
After=network.target

[Service]
# 基础配置
User=www-data
Group=www-data
WorkingDirectory=/var/www

# 环境变量 (注意语法：空格分隔或多次声明)
Environment=NODE_ENV=production
Environment=PORT=8080

# 启动命令 (必须使用绝对路径)
ExecStart=/usr/bin/python3 /var/www/app.py

# 重启策略
Restart=always
# 启动失败后的等待时间（可选）
RestartSec=5

# 日志处理：默认会发送到 journald
StandardOutput=append:/var/log/my-app.out.log
StandardError=inherit

[Install]
# 允许随系统启动
WantedBy=multi-user.target

管理systemd服务

常用的命令如下：

# 新增或修改配置文件以后需要重新加载，类似 supervisorctl reread && supervisorctl update，或者更粗暴的supervisorctl reload
systemctl daemon-reload
# 查看服务状态
systemctl status [yourservice]
# 设置服务开机自启动
systemctl enable [yourservice]
# 加上--now选项可以在设置后立即启动服务，同理用disable命令可以禁用开机自启动
# 手工启动服务
systemctl start [yourservice]

推送到[go4pro.org]

Linuxmint中蓝牙配对问题的处理

Sat, 08 Nov 2025 17:35:07 +0800

起因

最近常用的这个Linuxmint系统忽然无法添加蓝牙设备了，表现为可以搜索到要添加的设备，但是点击添加后，显示正在连接，很长时间连不上，然后就报错了。有时也可以连接上，但是无法使用，一会之后又断开了。

问AI半天也没有解决方案，什么重启蓝牙服务，重装蓝牙管理器之类的方法都试过了，没一个管用的。甚至还试了改polkit权限配置、重新加载蓝牙内核模块之类的方法，也没用。

解决

自己试了半天后发现问题出在无法弹出配对确认框上，但是这个问题始终没有找到解决方案，最后只能通过手工配对的方式来解决：

# 进入命令行状态：
bluetoothctl
# 在交互界面操作：
power on
agent on
scan on
# 现在开始扫描周围的蓝牙设备，记录一下要添加的设备MAC
# 配对设备
pair <设备MAC>
# 信任设备（就是弹框需要做的操作）
trust <设备MAC>
# 连接设备
connect <设备MAC>

这样配对好以后就可以正常使用蓝牙设备了。

推送到[go4pro.org]