Mental Studio

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]

Ansible贴士二则

Sun, 12 Oct 2025 15:22:55 +0800

避免主机SSH指纹确认

通常在第一次用SSH连接一台远程主机的时候，都会弹出一个SSH指纹警告，需要人工确认后，把这个指纹加到本地.ssh/knwon_hosts文件中。以后要是同一远程主机的指纹变化了（比如被冒充），就会导致SSH报错后断开连接，除非你能确认这种变化，那就需要从known_hosts里把原来的指纹删除：

ssh-keygen -R remote_host:port

然后再次连接并确认记录新指纹。

手工单次连接时顺手确认一下没什么问题，但是用Ansible连接实际上也是走ssh，也要验证指纹，所以也会有这个交互过程。

但这就麻烦了，因为通常用Ansible跑playbook时都是需要处理一堆主机的，每个都这样人工确认就太麻烦了，所以更好的办法是先批量更新一下known_hosts：

# 主机地址列表
HOSTS=(xxx yyy zzz)

for h in "${HOSTS[@]}"
do
    ssh-keyscan -p 22 $h >> ~/.ssh/knwon_hosts
done

使用指定的key连接

通常用ssh连接时，可以通过-i参数指定key文件，比如：

ssh -i /path_to/your_key_file user@host

Ansible里也可以指定，使用ansible_ssh_private_key_file变量：

ansible_ssh_private_key_file: /path_to/your_key_file

外一则

之前在Ansible中创建用户用的生成密码命令：

python3 -c "import crypt; print(crypt.crypt('{{ plain_password }}'))"

现在会报一个警告：

DeprecationWarning: 'crypt' is deprecated and slated for removal in Python 3.13

从Python3.13开始要移除crypt模块了，所以需要换个方式。

一个方式是使用passlib模块：

python3 -c "from passlib.hash import sha512_crypt; print(sha512_crypt.hash('your_password'))"

不过更好的方法是使用Ansible内置的过滤器：

- name: 创建用户
  hosts: all
  vars:
    plain_password: "your_password"
  
  tasks:
    - name: 创建用户（使用过滤器生成哈希）
      user:
        name: youruser
        password: "{{ plain_password | password_hash('sha512') }}"
        state: present
      no_log: true

推送到[go4pro.org]

基于wstunnel的反向隧道配置

Sat, 06 Sep 2025 15:19:00 +0800

需求

因为家里一条宽带换成移动的，没有外网IP了，所以从外面接入不太方便，IPv6虽然也是个方案，但是内网那台arm小机器是很老的Debian7，没有驱动也升级不了系统，还是搞个隧道简单点。

之前《使用docker和wstun实现隧道和反向隧道》，但是这个用Node.js实现的太笨重了，而且debian7上也装不了docker。还好现在有新方案，就是这个用Rust实现的wstunnel。一个可执行文件轻松跑起，还支持32位arm linux。

简单起见这里不再说正向隧道的配置了，参考前文，换成wstunnel即可。下面只说反向隧道的。

服务端

直接运行是最简单的：

wstunnel server ws://[::]:8080

但是这样有个安全风险就是只要能连接到这个websocket服务端就可以任意映射端口，等于绕过了防火墙的检查。

虽然官方建议是可以加上https和随机的path-prefix加以防护，但我觉得还是直接包进docker里更保险一点。

用Rust的好处之一就是这是独立可执行文件，没有依赖，直接用一个最小系统镜像（如alpine:3.22）就能运行：

docker run -d --name wstunnel -v $HOME/opt:/root/opt -p 127.0.0.1:8080:8080 -p 0.0.0.0:8022:8022 alpine:3.22 /root/opt/wstunnel server ws://[::]:8080

这个命令的功能就是用alpine:3.22的镜像来运行wstunnel（放在$HOME/opt下），把websocket端口8080映射到本地，把反向隧道的端口8022映射到外网。这样即使有其它的客户端想到映射别的端口，或者映射服务器的端口都无法实现，因为都是在docker容器里面。

当然为了保险起见，可以继续叠加官方的安全手段。

客户端

因为无法运行docker，就只能直接运行了：

wstunnel client -R 'tcp://[::]:8022:127.0.0.1:22' ws://server:8080

为了保持运行，我实际上是用supervisor加持了一下。

远程的地址实际上也不是这个，而是用https代理过的。

服务端https代理配置

也是使用Nginx的反向代理，如前文：

# 在http段加上全局配置
map $http_upgrade $connection_upgrade {
    default upgrade;
    '' close;
}
# 在server段加上代理配置
    location / {
        proxy_pass http://127.0.0.1:8080;
        
        # 启用WebSocket支持的关键配置
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;

        # 保持连接和代理头信息
        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_read_timeout 86400;
        proxy_send_timeout 86400;
        keepalive_timeout 86400;
    }

这样配置以后，只要服务端和客户端保持运行，就可以通过服务端的8022端口连接到客户机的22。

推送到[go4pro.org]