Cogito, ergo sum

Fill and Clean an OSS Bucket

Sat, 14 Mar 2026 14:16:00 +0800

应某种特殊的要求，要快速在 OSS Bucket¹ 中填充 600T 的数据。解决方案记录如下：

准备工作

创建 bucket

登录云端，创建 bucket，此处命名为 test。同时也要创建 credentials，获取 aws_access_key_id 和 aws_secret_access_key 两个凭据。

配置 aws

运行 aws configure, 然后：

输入 aws_access_key_id 和 aws_secret_access_key
配置区域
设置输出格式为 json

填充

如何直接上传 600T 的数据，经简单计算需要近一个月的时间，而且也会消耗大量的流量，因此需要更好的方案。我的总体思路是，先上传一个种子文件，然后在 bucket 内部复制，实习“裂变”，实际操作 2 天半时间就完成了任务。

上传种子

`1`	`dd if=/dev/zero bs=1M count=10240 status=progress \| aws s3 cp - s3://test/seed_10G.img --endpoint-url https://obs-xxxx.cucloud.cn --no-verify-ssl`

此处，由于 CUCloud 不支持通配符，但 endpoint-url 又不支持 http，因此不得不加上 --no-verify-ssl。

分裂种子

`1`	`seq 1 60000 \| xargs -P 20 -I {} aws s3 cp s3://test/seed_10G.img s3://test/copy_{}.img --endpoint-url https://obs-xxxx.cucloud.cn --no-verify-ssl 2>/dev/null`

可以先不加 2>/dev/null 观察一会，确认无误后再加，避免刷屏。

清理

一段时间后风头已过，需要清理无效数据，操作如下：

`1`	`aws s3 rm s3://test/copy_ --recursive --endpoint-url https://obs-xxxx.cucloud.cn --no-verify-ssl`

通过命令检查：

`1`	`aws s3 ls s3://test/copy_ --recursive --endpoint-url https://obs-xxxx.cucloud.cn --no-verify-ssl`

也确实没有文件了，但奇怪的是 bucket 还是不能删除。查了一些资料后，说是是有版本控制，即其内部有文件的历史版本或删除标记，导致 bucket 实际非空。它介绍用 s3api 来处理：

1
2

aws s3api list-object-versions --bucket test --endpoint-url https://obs-xxxx.cucloud.cn --no-verify-ssl --query '{Objects: [Versions[], DeleteMarkers[] | {Key: Key, VersionId: VersionId}]}' > delete.json
aws s3api delete-objects --bucket test --delete file://delete.json --endpoint-url https://obs-xxxx.cucloud.cn --no-verify-ssl

但经操作还是无法删除，最终不得不祭出 Python 大法：

import boto3
from botocore.client import Config
# 1. 抑制 urllib3 的 InsecureRequestWarning
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
# 配置参数
ENDPOINT = "https://obs-xxxx.cucloud.cn"
BUCKET_NAME = "test"
ACCESS_KEY = "ACCESS_KEY"
SECRET_KEY = "SECRET_KEY"
# 初始化 S3 客户端
s3 = boto3.client(
's3',
endpoint_url=ENDPOINT,
aws_access_key_id=ACCESS_KEY,
aws_secret_access_key=SECRET_KEY,
verify=False,
config=Config(signature_version='s3v4')
)
def force_empty_and_delete_bucket(bucket_name):
print(f"--- 开始清空存储桶: {bucket_name} ---")
# 计数器
count = 0
try:
# 使用分页器获取所有版本，处理大容量 Bucket
paginator = s3.get_paginator('list_object_versions')
for page in paginator.paginate(Bucket=bucket_name):
# 处理普通版本和历史版本
versions = page.get('Versions', [])
for v in versions:
key = v['Key']
vid = v['VersionId']
print(f"[删除版本] {key} (ID: {vid})")
s3.delete_object(Bucket=bucket_name, Key=key, VersionId=vid)
count += 1
# 处理删除标记
markers = page.get('DeleteMarkers', [])
for m in markers:
key = m['Key']
vid = m['VersionId']
print(f"[清理标记] {key} (ID: {vid})")
s3.delete_object(Bucket=bucket_name, Key=key, VersionId=vid)
count += 1
# 清理未完成的分段上传碎片
print("正在检查未完成的分段上传碎片...")
uploads = s3.list_multipart_uploads(Bucket=bucket_name)
for u in uploads.get('Uploads', []):
print(f"[中止碎片] {u['Key']}")
s3.abort_multipart_upload(Bucket=bucket_name, Key=u['Key'], UploadId=u['UploadId'])
print(f"--- 清理完成，共处理 {count} 个条目 ---")
# 尝试删除存储桶
try:
s3.delete_bucket(Bucket=bucket_name)
print(f"SUCCESS: 存储桶 {bucket_name} 已成功销毁。")
except Exception as e:
print(f"ERROR: 桶已清空但无法删除，可能是权限或延迟: {e}")
except Exception as e:
print(f"CRITICAL ERROR: {e}")
if __name__ == "__main__":
force_empty_and_delete_bucket(BUCKET_NAME)

至此，Mission Completed!

业务涉及的是 CUCloud，大体与 S3 类似，但细节略有差异，后续涉及差异处详细说明。
^[return]

Backup VPS

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

前不久因 CloudCone VPS 故障¹，导致我的 VPS 无法使用。万幸的是我一直有设置备份，恢复一下数据都还在。看来数据备份的确很重要，按照 3-2-1 原则²，我再增加一个备份方式，增加一层保险。

之前的脚本是从 VPS 推送到备份服务器，这次的脚本是从备份服务器向远程拉取。

准备

先配置无密码 ssh 登录成功。

脚本

#!/bin/bash

set -euo pipefail
REMOTE_SOURCE_DIRS=("/root" "/etc")
LOCAL_DEST_BASE="/mnt/disk/backups"
REMOTE_HOST="remote_host"
SSH_PORT=22
SSH_USER="root"
DEST_DIR="${LOCAL_DEST_BASE}/${REMOTE_HOST}"
TODAY=$(date +'%Y%m%d')
YESTERDAY=$(date -d "yesterday" +'%Y%m%d')
EXPIRED_DAYS=7
echo "## [$(date +'%Y-%m-%d %H:%M:%S')] Starting backup from [${REMOTE_HOST}]..."
mkdir -p "${DEST_DIR}"
for REMOTE_SRC in "${REMOTE_SOURCE_DIRS[@]}"; do
rsync -avzh --ignore-missing-args --delete --link-dest="${DEST_DIR}/${YESTERDAY}/" -e "ssh -p ${SSH_PORT}" "${SSH_USER}@${REMOTE_HOST}:${REMOTE_SRC}" "${DEST_DIR}/${TODAY}/"
done
echo "## [$(date +'%Y-%m-%d %H:%M:%S')] Data transferred. Deleting expired files..."
find "${DEST_DIR}" -maxdepth 1 -daystart -mtime +"${EXPIRED_DAYS}" -exec rm -rvf {} \+
echo "## [$(date +'%Y-%m-%d %H:%M:%S')] Job done!"

https://status.cloudcone.com/incidents/346624
^[return]
即：至少保留 3 份完整的数据副本，至少处于 2 种不同类型的存储介质上，至少 1 份备份要放在异地。
^[return]

Imagine

Thu, 01 Jan 2026 19:00:00 +0800

新年听一曲约翰·列侬（John Lennon）的 Imagine, 愿一起都能如想象中的那般美好。

Imagine there’s no heaven
It’s easy if you try
No hell below us
Above us, only sky
Imagine all the people, living for today (ah)
Imagine there’s no countries
It isn’t hard to do
Nothing to kill or die for
And no religion too
Imagine all the people, living life in peace (yoo-hoo)
You may say I’m a dreamer
But I’m not the only one
I hope someday you’ll join us
And the world will be as one
Imagine no possessions
I wonder if you can
No need for greed or hunger
A brotherhood of man
Imagine all the people, sharing all the world (yoo-hoo)
You may say I’m a dreamer
But I’m not the only one
I hope someday you’ll join us
And the world will live as one

用 SSH 反向代理实现内网穿透

Mon, 08 Dec 2025 19:23:00 +0800

今天折腾了以下用 SSH 反向代理实现内网穿透，这个方法配置简单，修改方便，还能断线自动重连。记录如下：

准备

前提条件是一台内网的机器 A，一台公网的机器 B，A 能访问 B。不安装 FRP 等其他工具，仅仅使用系统内置的 SSH 来实现。
先在 A 机器生成一个密钥，并传送到 B 机器：

1
2

ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_tunnel -C "tunnel-2025"
ssh-copy-id -i ~/.ssh/id_ed25519_tunnel root@B_IP

验证可以不用密码而是通过密钥登录。

配置

编辑配置

在 A 机器上编辑或创建 ~/.ssh/config，权限设 600。

Host ssh-tunnel
# ==================== 基本连接信息 =====================
HostName xx.xx.xx.xx # B机器的 IP 或域名
User root # B机器的 SSH 用户名
Port 22 # B机器的 SSH 端口
IdentityFile ~/.ssh/id_ed25519_tunnel
IdentitiesOnly yes
# ==================== 保活与复用 =======================
ServerAliveInterval 60
ServerAliveCountMax 3
ExitOnForwardFailure no
BatchMode yes
# ==================== 要暴露的所有端口 =================
# 格式：RemoteForward 公网端口 内网机器:内网端口
RemoteForward 2222 localhost:22
RemoteForward xxxx localhost:yyyy
# ......

编辑服务

创建 /etc/systemd/system/tunnel.service

[Unit]
Description=SSH Tunnel Daemon
After=network.target
Wants=network.target
[Service]
User=YOUR_USERNAME
Group=YOUR_GROUP
ExecStart=/usr/bin/ssh -CNT ssh-tunnel # ssh-tunnel 和配置文件中Host定义一致
Restart=always
RestartSec=5s
SuccessExitStatus=255 # 确保能自动重连
[Install]
WantedBy=multi-user.target

然后启动服务：

1
2
3

sudo systemctl daemon-reload
sudo systemctl start tunnel.service
sudo systemctl status tunnel.service

这时，可以在 B 机器上用 netstat -a 看到代理的端口即为正常运行。

作为验证，可以查询 netstat -tupl | grep 2222 端口所在的进程号，然后 kill -9 <PID> 杀掉进程，几秒后再次查看端口，会发现已经重连。在 B 机器上看服务状态也有重连的记录。

比较方便的是，配置完成后 A 机器不需要 root 权限可以直接修改 ~/.ssh/config 配置文件，因为它位于本用户 HOME 目录下。改完后，有 root 权限可以直接重启服务，没 root 权限可以在 B 机器上踢线，会重启服务。

InfluxDB and Grafana over Proxmox

Sat, 01 Nov 2025 13:32:00 +0800

Proxmox 虽然自带系统性能监控，但没法长期保存，故此我采用了 InfluxDB 和 Grafana 的组合来监控 VM 和 LXC。

首先我创建了一台 LXC 来作为基座，使用的是 Alpine Linux，它占用资源非常少，1核+512M 内存足够，实占 3%CPU，60%MEM。

InfluxDB

安装

由于 Alpine Linux 仓库里没有 InfluxDB，而 InfluxDB 官方主推是 3.x 版本，因此需要在 GitHub 自行下载。然后解压并配置可执行文件路径：

1
2
3

tar -zxvf influxdb2-2.7.12_linux_amd64.tar.gz -C /opt
mv /opt/influxdb2-2.7.12/ /opt/influxdb2
ln -s /opt/influxdb2/usr/bin/influxd /usr/local/bin/influxd

创建数据与配置目录

1
2

mkdir -p /var/lib/influxdb
mkdir -p /etc/influxdb

测试启动

1
2
3

influxd --bolt-path /var/lib/influxdb/influxd.bolt \
 --engine-path /var/lib/influxdb/engine \
 --http-bind-address :8086

浏览器访问 http://<服务器ip:8086>, 首次会要求设置用户名、密码、组织和 bucket，并记下密钥。这些信息后面 Proxmox 要用到。

创建服务

测试正常后，在 /etc/init.d/influxdb 写入：

#!/sbin/openrc-run

name="influxdb"
description="InfluxDB time series database"
command="/usr/local/bin/influxd"
command_args="--bolt-path /var/lib/influxdb/influxd.bolt --engine-path /var/lib/influxdb/engine --http-bind-address :8086"
command_background="yes"
pidfile="/run/${RC_SVCNAME}.pid"
depend() {
need net
}

然后赋权并启动服务：

1
2
3

chmod +x /etc/init.d/influxdb
rc-update add influxdb default
rc-service influxdb start

Proxmox

配置信息

在 Proxmox 的 指标服务器 中，添加 InfluxDB，其中：服务器填写 LXC 的地址，端口填 8086，协议是 HTTP，组织、插槽和令牌根据上面信息填写。

Grafana

安装与配置

Alpine Linux 仓库有 Grafana，可以直接安装：

`1`	`apk add grafana`

修改配置

修改 /etc/conf.d/grafana 其中一行，使其能通过外部访问：

`1`	`cfg:server.http_addr=0.0.0.0`

如果要启用 HTTPS 访问，还要修改 /etc/grafana.ini 中的一些参数（密钥文件生成见附 1）：

...
[server]
# Protocol (http, https, h2, socket)
protocol = https
...
# https certs & key file
cert_file = /etc/ssl/grafana.crt
cert_key = /etc/ssl/grafana.key

启动服务

1
2

rc-update add grafana default
rc-service grafana start

浏览器访问 http://<服务器ip:3000>, 默认用户名、密码均为 admin，首次会要求更新密码。

添加数据源

在 Connections - Data sources 选择 InfluxDB，自定义一个名字，URL 设置成http://localhost:3000, 选择 Basic auth，用户名留空，密码设置前述的令牌，Database 设置前述的 bucket。点击 Save&Test 显示绿色即为配置正常。

配置面板

在 Dashboard 中，选择导入模板，ID 为 10048，数据源选上述创建的名字即可。

附 1 生成密钥文件

使用自签名证书来启用 HTTPS 访问，具体步骤如下：

openssl req -x509 -newkey rsa:2048 -keyout grafana.key -out grafana.crt -days 365 -nodes -subj "/C=CN/ST=State/L=City/O=Organization/CN=grafana.local"
chown grafana:grafana grafana.crt grafana.key
chmod 644 grafana.crt
chmod 600 grafana.key

然后放到相应目录，与 /etc/grafana.ini 配置一致。

附 2 使用域名访问

为了避免使用 IP 地址访问，套上了 CloudFlare，具体步骤如下：
首先，创建一条 DNS 记录，为它绑定一个域名；
然后，在规则选项中，创建一条 Origin Rule：当“主机名等于本域名”时，目标端口改写到 3000。

Quadlet

Wed, 01 Oct 2025 13:09:00 +0800

在上一篇遗留了一个问题，查了一些资料后，发现可以用 Quadlet 来处理。

Quadlet 是 Podman 4.4 版本引入的扩展，它用简单的文本文件来定义和启动容器、Pod（容器组）或其他资源。它支持四种主要文件类型：.container、.pod、.volume 和 .network。

以下通过 quanlet 实现一个 wordpress 的应用，它包括一个 Pod，两个容器：mariadb 实现数据库、wordpress 实现前端，以及两个命名卷分别存储对应的容器。

Quadlet 文件，全局配置存储在 /etc/containers/systemd/ 目录，用户级配置在 ~/.config/containers/systemd 目录。

首先定义相应的资源

wordpress.pod

[Unit]
Description=WordPress Pod
[Pod]
PodName=wordpress
PublishPort=8088:80

该文件定义了 pod，其中：

PublishPort= 字段暴露了相应端口，端口映射必须在 pod 级实现，而不是容器级，否则外部无法访问。

wordpress-db.volume

[Unit]
Description=WordPress DB Volume
[Volume]
VolumeName=wordpress-db

该文件定义了一个命名卷，用于存储数据库。

wordpress-ui.volume

[Unit]
Description=WordPress UI Volume
[Volume]
VolumeName=wordpress-ui

该文件定义了另一个命名卷，用于存储前端。

wordpress-db.container

[Unit]
Description=WordPress DB Container
BindsTo=wordpress-pod.service
Requires=wordpress-db-volume.service
After=wordpress-db-volume.service
[Container]
Image=docker.io/library/mariadb:latest
ContainerName=wordpress-db
Pod=wordpress.pod
Environment=MARIADB_DATABASE=wordpress
Environment=MARIADB_USER=wordpress
Environment=MARIADB_PASSWORD=wordpress
Environment=MARIADB_RANDOM_ROOT_PASSWORD=yes
Volume=wordpress-db:/var/lib/mysql
AutoUpdate=registry

该文件定义了 mariadb 数据库容器。其中：

BindsTo= 绑定到对应的 pod
Required= 和 After= 保证了容器的依赖关系和启动顺序
AutoUpdate= 启用了自动更新

wordpress-ui.container

[Unit]
Description=WordPress UI Container
BindsTo=wordpress-pod.service
Requires=wordpress-ui-volume.service
After=wordpress-ui-volume.service
Requires=wordpress-db.service
After=wordpress-db.service
[Container]
Image=docker.io/library/wordpress:latest
ContainerName=wordpress-ui
Pod=wordpress.pod
Environment=WORDPRESS_DB_HOST=wordpress-db
Environment=WORDPRESS_DB_USER=wordpress
Environment=WORDPRESS_DB_PASSWORD=wordpress
Environment=WORDPRESS_DB_NAME=wordpress
Volume=wordpress-ui:/var/www/html
AutoUpdate=registry
[Install]
WantedBy=default.target

该文件定义了 wordpress 前端容器。它依赖于上述资源。其中：

WantedBy= 字段用于实现开机自启动，因为这是最上游的资源，它会拉起其他资源。当然也可以每个资源都加上这一字段。

然后生成相应的服务

先重新加载 systemd 来生成相关服务： systemctl --user daemon-reexec && systemctl --user daemon-reload

再用 systemctl --user list-unit-files | grep wordpress 列出对应的服务，它们位于 /run/user/($UID)/systemd/generator/ 目录。正常的话，会显示如下：

wordpress-db-volume.service generated -
wordpress-db.service generated -
wordpress-pod.service generated -
wordpress-ui-volume.service generated -
wordpress-ui.service generated -

不正常的话，可以使用生成器 /usr/lib/systemd/user-generators/podman-user-generator --user --dryrun ¹尝试生成并查看错误。

然后使用 systemctl --user start wordpress-ui.service 启动服务。因为这个服务处于最上游，它会自动启动依赖服务。最后使用 systemctl --user status wordpress-ui.service 查看服务状态。

使用 podman ps -ap 查看：

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME
0c4238d0ab09 8 hours ago Up 8 hours 0.0.0.0:8088->80/tcp wordpress-infra f5d74fdea66c wordpress
3f943e724192 docker.io/library/mariadb:latest mariadbd 8 hours ago Up 8 hours 0.0.0.0:8088->80/tcp, 3306/tcp wordpress-db f5d74fdea66c wordpress
1d0a81791a2c docker.io/library/wordpress:latest apache2-foregroun... 8 hours ago Up 8 hours 0.0.0.0:8088->80/tcp wordpress-ui f5d74fdea66c wordpress

其中的名称为 wordpress-infra 的容器为自动生成的架构容器，用来提供共享的基础资源。它是 Pod 的核心，名称是自动生成的，不可修改。

此外，对于 rootless 用户，确保已经启用了 linger 功能： loginctl enable-linger $USER 以允许容器在用户登出后继续运行。

实现自动更新容器

Podman 有一个专门的 Systemd 服务来处理自动更新，名为 podman-auto-update.timer。

启用并启动定时器： systemctl --user enable --now podman-auto-update.timer
检查定时器状态: systemctl --user status podman-auto-update.timer
查看定时器服务状态，它会记录自动更新的状态: systemctl --user status podman-auto-update.service

附 1. podman 镜像配置

全局配置在 /etc/containers/registries.conf ，用户配置在 ~/.config/containers/registries.conf ，内容如下：

# 取消默认搜索地址
unqualified-search-registries = ["docker.io"]
# 自定义仓库
[[registry]]
# 仓库前缀
prefix = "docker.io"
# 镜像地址
location = "docker.m.daocloud.io"
# 允许http
insecure = true

使用 podman auto-update --dry-run 命令手工验证。

附 2. podman 卷管理

命名卷是 Podman 管理的独立存储单元，默认存储在 /var/lib/containers/storage/volumes/ (系统级)，或 ~/.local/share/containers/storage/volumes/ (用户级)。

优点是数据更隔离，不直接暴露宿主机文件系统。数据持久化，即使容器删除，卷仍保留。

缺点是不易直接编辑（需 podman volume mount 或容器内访问），备份需用 podman volume export 。

生成器可能在其他位置，通过 find /usr/lib/systemd/ -name "*-user-generator" 2>/dev/null | grep podman 查找。
^[return]

Podman

Fri, 19 Sep 2025 21:14:00 +0800

Podman 是一个开源的容器引擎工具，由 Red Hat 开发，主要用于在 Linux 系统上构建、运行和管理容器镜像。它是 Docker 的一个轻量级替代品，支持 OCI（Open Container Initiative）标准容器格式。

它有以下特点：

无守护进程：不像 Docker 需要一个后台 daemon 进程，Podman 以用户级进程运行，减少了复杂性和安全风险。
Rootless 支持：可以以非 root 用户身份运行容器，提高安全性，避免特权容器带来的潜在问题。
兼容 Docker：Podman 的命令行接口（CLI）与 Docker 高度兼容，许多 docker 命令可以直接用 podman 替换（如 podman run、podman build）。
Pod 支持：受 Kubernetes 启发，可以管理多个容器的“Pod”，便于编排。
其他功能：支持容器镜像构建、推送、拉取；集成 systemd 用于容器服务管理；适用于开发、测试和生产环境。

可以看到：

docker 需要开启 dockerd 的守护进程，与高级容器进行时 containerd 通信，再调用低级容器进行时 runc。
podman 没有守护进程，直接调用 runc，从而与内核交互，管理容器。
k8s 可以与支持 CRI 标准接口的进程通信，如既可以 containerd 通信，也可以与最新的 CRIO 通信。

podman 的大部分命令和 docker 一致¹，甚至可以直接用 alias docker=podman 创建别名。本文记录一些与 docker 不同的特性。

创建 pod

pod 是来自 k8s 的概念，它由若干个相互关联的容器构成。同一个 pod 里的容器，IP 地址相同，共享挂载卷和命名空间。

以下以创建一个多媒体 pod 为例，它包含三个容器：qbittorrent 用于下载，radarr 用于管理电影，sonarr 用于管理剧集。

首先，创建一个 pod：

# 创建
podman pod create --name multimediacenter -p 8988:8988 -p 7878:7878 -p 8989:8989
# 查看
podman pod list
# 停止/启动
podman stop/start multimediacenter

然后，将三个容器加入到 pod（提前创建好相应目录）：

# 加入qbittorrent
podman run -d \
 --pod multimediacenter \
 --name qbittorrent \
 --restart=unless-stopped \
 -e TZ=Asia/Shanghai \
 -e UMASK_SET=022 \
 -e WEBUI_PORT=8988 \
 -v $HOME/config/qbittorrent:/config \
 -v $HOME/Downloads:/downloads \
 docker.io/linuxserver/qbittorrent:latest
# 加入radarr
podman run -d \
 --pod multimediacenter \
 --name radarr \
 --restart=unless-stopped \
 -e TZ=Asia/Shanghai \
 -v $HOME/config/radarr:/config \
 -v $HOME/Downloads:/downloads \
 -v /mnt/disk/Media/movies:/movies \
 docker.io/linuxserver/radarr:latest
# 加入sonarr
podman run -d \
 --pod multimediacenter \
 --name sonarr \
 --restart=unless-stopped \
 -e TZ=Asia/Shanghai \
 -v $HOME/config/sonarr:/config \
 -v $HOME/Downloads:/downloads \
 -v /mnt/disk/Media/series:/tv \
 docker.io/linuxserver/sonarr:latest
# 查看
podman ps --all --pod # 简写成 -ap

保存 pod

podman 可以把配置好的 pod 导出成文件，供后续使用。一般导出成 k8s 兼容的格式，也可以直接用于 k8s。

# 导出
podman generate kube multimediacenter > multimediacenter.yaml
# 导入
podman play kube multimediacenter.yaml

自启动 pod

由于 podman 没有守护进程，如果要实现开机自启动，可以使用以下方式：

# 创建文件
podman generate systemd --new --files --name multimediacenter
# 创建服务
mkdir -p ~/.config/systemd/user/
cp *.service ~/.config/systemd/user/
# 启动服务
systemctl --user daemon-reload
systemctl --user enable --now pod-multimediacenter.service
loginctl enable-linger $(whoami)

自动更新镜像

当镜像有更新时，如果希望运行的容器保持更新，docker 通常需要外部工具来实现，而 podman 有内置的自动更新机制，只要在创建容器时按需加上自动更新标识 --label io.containers.autoupdate=registry ：

# 加上自动更新标识
podman run -d \
 --pod multimediacenter \
 --name qbittorrent \
 --restart=unless-stopped \
 --label io.containers.autoupdate=registry \
 -e TZ=Asia/Shanghai \
 -e UMASK_SET=022 \
 -e WEBUI_PORT=8988 \
 -v $HOME/config/qbittorrent:/config \
 -v $HOME/Downloads:/downloads \
 docker.io/linuxserver/qbittorrent:latest
# 参照上一步生成服务
podman generate systemd --new --files --name multimediacenter
cp *.service ~/.config/systemd/user/
systemctl --user daemon-reload
systemctl --user enable --now pod-multimediacenter.service
# 启用自动更新服务
systemctl --user enable podman-auto-update.timer
systemctl --user start podman-auto-update.timer
# 验证
podman auto-update --dry-run

TODO 一个问题

在创建 systemd 服务文件是， --new 参数的作用是：它根据当前的 pod 被创建时 的命令和参数来生成服务，如镜像名称、端口映射、挂载卷等。而不加 --new 参数，则仅根据 当前正在运行 的 Pod 的状态，如容器名称、镜像、挂载卷等信息来生成一个 systemd 文件，它不会尝试记录或重现创建命令。

即，不加 --new 参数生成的服务文件，对应运行的容器 ID，仅对于运行的容器有效，如果该容器被删除后，则无法启动。然而，对于自动更新时来说，当前运行的容器会被删除，重新创建一个新版本的容器来替代，这时是必须需要 --new 参数的。于是便产生了一个逻辑冲突：

设想这样的场景：从网上找到一个 yaml 配置文件，它配置了自动更新标识。如果用 podman play kube 导入运行，此时由于本地没有相关的创建命令，因此在 podman generate kube 时使用 --new 会报错:

`1`	`Error: cannot use --new on pod "...": no create command found`

那么这样的 pod 如何实现开机自启动呢？

在改写 docker 命令时要注意一点，podman 需要显式调用 dockerhub 镜像，毕竟不是一家子。如果是官方镜像，则 docker.io/library/，非官方镜像加 docker.io/。
^[return]

三分损益法

Sat, 23 Aug 2025 11:56:00 +0800

三分损益法是中国古代音乐理论中用于确定音律的一种数学方法，主要用于生成十二律（十二平均律的基础）和其他音阶音高，是中国传统音乐调律的核心技术之一。其基本原理是通过弦长或管长的三分损益（即增加或减少三分之一）来推算音阶中的音高关系。这种方法最早见于《管子》《吕氏春秋》等文献，战国时期已有系统论述，后在《乐书》《汉书·律历志》等文献中进一步完善。

基本原理

三分损益法的核心是通过对乐器（如琴或律管）的长度进行数学运算，生成不同音高。具体方法是：

三分损一：将弦长或管长分为三等份，去掉一份（即乘以 2/3），得到一个比原音高五度的音（纯五度）。
三分益一：将弦长或管长分为三等份，增加一份（即乘以 4/3），得到一个比原音低五度的音（纯四度）。
通过反复应用“损一”和“益一”，生成一系列音高，形成音阶。

推算过程

以黄钟（基础音，相当于现代的 C4）为起点，假设其律管长度为 81 单位（古代常用 81 作为基数，便于计算）。

律名	长度	频率	对应现代音名
黄钟	81	1	C
林钟	81 × ²⁄₃ = 54	⁸¹⁄₅₄ = 1.5	G
太簇	54 × ⁴⁄₃ = 72	⁸¹⁄₇₂ = 1.125	D
南吕	72 × ²⁄₃ = 48	⁸¹⁄₄₈ = 1.6875	A
姑洗	48 × ⁴⁄₃ = 64	⁸¹⁄₆₄ = 1.265625	E
应钟	64 × ²⁄₃ = ¹²⁸⁄₃ = 42.6667	81/(¹²⁸⁄₃) = 1.8984375	B
蕤宾	¹²⁸⁄₃ × ⁴⁄₃ = ⁵¹²⁄₉ = 56.8889	81/(⁵¹²⁄₉) = ⁷²⁹⁄₅₁₂ = 1.423828125	F#
大吕	⁵¹²⁄₉ × ²⁄₃ = ¹⁰²⁴⁄₂₇ = 37.9259	81/(¹⁰²⁴⁄₂₇) = ²¹⁸⁷⁄₁₀₂₄ = 2.1357421875	C#
夷则	¹⁰²⁴⁄₂₇ × ⁴⁄₃ = ⁴⁰⁹⁶⁄₈₁ = 50.5679	81/(⁴⁰⁹⁶⁄₈₁) = ⁶⁵⁶¹⁄₄₀₉₆ = 1.601806640625	G#
夹钟	⁴⁰⁹⁶⁄₈₁ × ²⁄₃ = ⁸¹⁹²⁄₂₄₃ = 33.7119	81/(⁸¹⁹²⁄₂₄₃) = ¹⁹⁶⁸³⁄₈₁₉₂ = 2.40380859375	D#
无射	⁸¹⁹²⁄₂₄₃ × ⁴⁄₃ = ³²⁷⁶⁸⁄₇₂₉ = 44.9485	81/(³²⁷⁶⁸⁄₇₂₉) = ⁵⁹⁰⁴⁹⁄₃₂₇₆₈ = 1.802032470703125	A#
仲吕	³²⁷⁶⁸⁄₇₂₉ × ²⁄₃ = ⁶⁵⁵³⁶⁄₂₁₈₇ = 29.9657	81/(⁶⁵⁵³⁶⁄₂₁₈₇) = ¹⁷⁷¹⁴⁷⁄₆₅₅₃₆ = 2.703094482421875	F
返回黄钟	⁶⁵⁵³⁶⁄₂₁₈₇ × ⁴⁄₃ = ²⁶²¹⁴⁴⁄₆₅₆₁ = 39.9574	81/(²⁶²¹⁴⁴⁄₆₅₆₁) = ⁵³¹⁴⁴¹⁄₂₆₂₁₄₄ = 2.027286529541015625	C

与十二平均律对比

十二平均律将一个八度（频率比 2:1）均分为 12 个半音，每个半音的频率比为 2^¹⁄₁₂ = 1.059463094359295 。

音名	三分损益法频率	十二平均律频率	偏差（音分，1半音=100 音分）
C（黄钟）	1.0	1.0	0
C#（大吕）	1.06787109375	1.059463094359295	+13.69
D（太簇）	1.125	1.122462048309373	+2.27
D#（夹钟）	1.201904296875	1.189207115002721	+10.65
E（姑洗）	1.265625	1.259921049894873	+4.54
F（仲吕）	1.3515472412109375	1.334839854170034	+12.49
F#（蕤宾）	1.423828125	1.414213562373095	+6.80
G（林钟）	1.5	1.498307076876682	+1.13
G#（夷则）	1.601806640625	1.587401051968199	+9.07
A（南吕）	1.6875	1.681792830507429	+3.40
A#（无射）	1.802032470703125	1.781797436280678	+11.37
B（应钟）	1.8984375	1.887748625363387	+5.66

偏差计算：音分（cents）公式为 1200 × log_2(三分损益频率 / 平均律频率) 。例如，C#的偏差 = 1200 × log_2(1.06787109375 / 1.059463094359295) = 13.69 音分。

编程可视化

# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import font_manager
import warnings
# 动态检查可用字体
available_fonts = [f.name for f in font_manager.fontManager.ttflist]
preferred_fonts = ['Noto Sans CJK SC', 'SimSun', 'Microsoft YaHei', 'PingFang SC', 'WenQuanYi Zen Hei', 'Arial Unicode MS']
# 查找第一个可用的中文字体
selected_font = None
for font in preferred_fonts:
if font in available_fonts:
selected_font = font
break
if selected_font:
plt.rcParams['font.sans-serif'] = [selected_font] + ['sans-serif']
else:
warnings.warn("No Chinese fonts found. Chinese characters may display as boxes. Please install 'Noto Sans CJK SC' or another Chinese font.")
plt.rcParams['font.sans-serif'] = ['sans-serif']
plt.rcParams['axes.unicode_minus'] = False # 解决负号显示问题
# 三分损益法计算律管长度
def triple_division_length(start_length=81, num_notes=12):
lengths = [start_length]
names = ["黄钟"]
for i in range(num_notes):
if i % 2 == 0: # 三分损一：长度 * 2/3
new_length = lengths[-1] * 2 / 3
else: # 三分益一：长度 * 4/3
new_length = lengths[-1] * 4 / 3
# 调整到同一八度（长度在81/2到81之间）
while new_length > start_length:
new_length /= 2
while new_length < start_length / 2:
new_length *= 2
lengths.append(new_length)
# 添加音名（按五度相生顺序）
names.append({
0: "林钟", 1: "太簇", 2: "南吕", 3: "姑洗", 4: "应钟",
5: "蕤宾", 6: "大吕", 7: "夷则", 8: "夹钟", 9: "无射",
10: "仲吕"
}.get(i, "黄钟(循环)"))
return lengths, names
# 计算十二律的律管长度
lengths, names = triple_division_length()
# 绘制柱状图并标记数值
plt.figure(figsize=(12, 6))
bars = plt.bar(names, lengths, color='skyblue', edgecolor='black')
plt.title('三分损益法生成的十二律律管长度', fontsize=14)
plt.xlabel('音名', fontsize=12)
plt.ylabel('律管长度 (单位)', fontsize=12)
plt.xticks(rotation=45)
plt.grid(True, axis='y', linestyle='--', alpha=0.7)
# 在柱子上方添加长度数值标签
for i, bar in enumerate(bars):
height = bar.get_height()
plt.text(bar.get_x() + bar.get_width() / 2, height, f'{height:.4f}',
ha='center', va='bottom', fontsize=10)
plt.tight_layout()
# 保存图表
plt.savefig('triple_division.png')
plt.show()

从外部网络通过远程桌面访问 hyper-V 的虚拟机

Sun, 27 Jul 2025 16:15:00 +0800

因网络安全的要求，一部分软件无法安装在宿主机，于是我用 hyper-V 建了一台虚拟机，将这些软件安装在里面。在宿主机访问虚拟机虽然方便，但外部要访问虚拟机时又不想通过宿主机操作，于是就有了下面的方案。

准备条件

Hyper-V 网络是 NAT Mode，已经得到私网地址，能正确连接到网络。（因为如果 Bridge Mode 有公网地址，就可以直连了，没必要通过宿主机转发。）
虚拟机已启用远程桌面，开启 RDP 服务，默认端口 3389，但也会被限制，后续改成 33389。
在宿主机打开“服务”，确认“IP Helper”服务状态为“正在运行”。
在宿主机选用一个未使用的端口用于转发，如 33389。

对虚拟机的操作

配置防火墙

启用远程桌面后正常情况下，防火墙规则会自动创建，3389 会自动打开。但由于 3389 端口受限，手动调整方法如下：
打开“高级安全 Windows Defender 防火墙”，创建入站规则：

选择“端口” > “TCP” > 指定端口“33389”。
选择“允许连接”。
适用范围包括“专用”和“公用”网络。
命名规则，例如“RDP Access”。

修改注册表

导航到注册表：
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp
找到PortNumber，修改为 33389。

对宿主机的操作

配置转发

使用管理员权限打开终端，输入：

`1`	`netsh interface portproxy add v4tov4 listenaddress=HOST_IP listenport=33389 connectaddress=VM_IP connectport=33389`

检查一下：

`1`	`netsh interface portproxy show v4tov4`

配置防火墙

打开“高级安全 Windows Defender 防火墙”，创建入站规则：

在“入站规则”上右键，选择“新建规则”。
选择“端口” > “TCP” > 指定端口“33389”。
选择“允许连接”。
适用范围选择“公用”网络（因为涉及公网访问）。
命名规则，例如“RDP Port Forwarding”。

uv

Sat, 28 Jun 2025 08:44:00 +0800

uv 是一个 Python 包管理和虚拟环境工具。我用了一下觉得非常方便，特将使用流程记录如下：

创建项目

首先根据需要的项目名称，执行：

`1`	`uv init project_name`

会生成一系列项目文件。包括主程序 maim.py，以及版本控制和环境设置的文件。

创建虚拟环境

为了避免多个项目冲突，把各个项目的库文件隔离，建议创建虚拟环境。执行：

1
2

cd project_name
uv venv

默认路径为 .venv。也可以uv venv --python 3.11，会自动安装并创建相应版本的虚拟环境。

添加/删除包

根据项目需要，添加/删除库文件，执行：

1
2

uv add package_name
uv remove package_name

会把用到的包信息记录在 pyproject.toml 文件中。如果这个包只在开发环境下使用，使用uv add --dev package_name则发布时不会把它打包进去。

处理依赖

要查看包之间的依赖关系，执行：

uv tree

会用树状列出依赖关系。

同步

在其他电脑可以下载该项目后，需要同步用到的库文件等环境，执行：

uv sync

会把相应的包安装到虚拟环境下。

更新

需要更新项目的库文件时，执行：

`1`	`uv sync --upgrade`

会自动修改库文件的版本信息。

运行

在运行时，不再需要进入虚拟环境，只需要执行：

`1`	`uv run main.py`

就会自动调用虚拟环境，无需手动激活。这一步真的非常方便。

工具

对于全局性工具，比如 pytest 所有项目都可能涉及，就最好把它作为工具安装，执行：

uv tool install pytest # 安装
uv tool uninstall pytest # 卸载
uv tool list # 查看
uv tool upgrade pytest # 升级单个包
uv tool upgrade --all # 全部升级

就可以在全局直接运行 pytest。

音程与倍频的关系

Sun, 11 May 2025 10:38:00 +0800

有个说法：某个音的 3 倍频率等于它的纯五，5倍频率等于它的大三度。今天来分析理解一下。

分析计算

频率：声音的音高由频率决定，频率越高，音高越高。频率的单位是赫兹（Hz）。
以 A4（440 Hz）为例：

原始音：A4 = 440 Hz
三倍频率：440 * 3 = 1320 Hz
高一个八度：A5 = 440 * 2 = 880 Hz
高一个纯五度：E6 = 440 * 3 = 1320 Hz

因此，确切地说，是从 A4 出发，先升高一个八度到 A5，再升高一个纯五度到 E6。
原因在于，在音乐中，纯五度的频率比通常是 3:2，即 1.5 倍。容易得出，当频率 f 先做倍频得 2f，再乘以 1.5 倍得 3f，即为它的纯五度音。
即： 泛音列的第 3 谐波（3×基频）始终对应高两个八度的纯五度音。
计算每个音，发现都符合规律：

基音	频率 (Hz)	纯五度音	频率 (Hz)	3 倍频率 (Hz)	对应高两个八度纯五度音	频率 (Hz)
C4	261.63	G4	392.44	784.89	G5	784.89
C#4/D♭4	277.18	G#4/A♭4	415.77	831.54	G#5/A♭5	831.54
D4	293.66	A4	440.49	880.99	A5	880.99
D#4/E♭4	311.13	A#4/B♭4	466.69	933.39	A#5/B♭5	933.39
E4	329.63	B4	494.44	988.89	B5	988.89
F4	349.23	C5	523.84	1047.69	C6	1047.69
F#4/G♭4	369.99	C#5/D♭5	554.99	1109.98	C#6/D♭6	1109.98
G4	392.00	D5	588.00	1176.00	D6	1176.00
G#4/A♭4	415.30	D#5/E♭5	622.95	1245.90	D#6/E♭6	1245.90
A4	440.00	E5	660.00	1320.00	E6	1320.00
A#4/B♭4	466.16	F5	699.24	1398.48	F6	1398.48
B4	493.88	F#5/G♭5	740.82	1481.64	F#6/G♭6	1481.64

同样，可以计算出： 泛音列的第 5 谐波（5×基频）对应大三度高三个八度。

基音	频率 (Hz)	大三度音	频率 (Hz)	5 倍频率 (Hz)	对应的高三个八度大三度音	频率 (Hz)
C4	261.63	E4	327.04	1308.15	E7	1318.51
C#4/D♭4	277.18	F4	346.48	1385.90	F7	1396.91
D4	293.66	F#4/G♭4	367.08	1468.30	F#7/G♭7	1479.98
D#4/E♭4	311.13	G4	388.91	1555.65	G7	1567.98
E4	329.63	G#4/A♭4	412.04	1648.15	G#7/A♭7	1661.22
F4	349.23	A4	436.54	1746.15	A7	1760.00
F#4/G♭4	369.99	A#4/B♭4	462.49	1849.95	A#7/B♭7	1864.66
G4	392.00	B4	490.00	1960.00	B7	1975.53
G#4/A♭4	415.30	C5	519.13	2076.50	C8	2093.00
A4	440.00	C#5/D♭5	550.00	2200.00	C#8/D♭8	2217.46
A#4/B♭4	466.16	D5	582.70	2330.80	D8	2349.32
B4	493.88	D#5/E♭5	617.35	2469.40	D#8/E♭8	2489.02

纯律下严格成立，十二平均律下近似成立。
原因是：纯律的 5:4 是自然泛音列的第 5 谐波，从物理角度共振最和谐，但无法在所有调性中保持一致性。而十二平均律将八度均分为 12 半音，大三度为 4 个半音（2^⁴⁄₁₂），接近但不等于 5:4，牺牲部分和谐性以实现自由转调。

音符笔记

Sat, 12 Apr 2025 08:57:00 +0800

今天整理了一下音乐笔记¹。

十二调式

半音的音名与唱名：


全音	C		D		E	F		G		A		B
半音		C#/Db		D#/Eb			F#/Gb		G#/Ab		A#/Bb
唱名	Do		Re		Mi	Fa		So		La		Ti
唱名		Di/Ra		Ri/Me			Fi/Se		Si/Le		Li/Te

五线谱各种谱号

五度音圈（Circle of Fifths）：

升调看最右侧的升号，增加 1 个半音就是它的大调，再减少 3 个半音（小三度）就是它的关系小调。
举例：
- 2 个升号（F#, C#），最后一个是 C#，加半音是 D，所以是 D 大调。再减 3 个半音到 B，所以关系小调是 B 小调。
- 4 个升号（F#, C#, G#, D#），最后一个是 D#，加半音是 E，所以是 E 大调。再减 3 个半音到 C#，所以关系小调是 C#小调。
降调看右侧倒数第二个降号，就是它的大调，再减少 3 个半音（小三度）就是它的关系小调。（特例：1 个降号时是 F 大调。）
举例：
- 2 个降号（Bb, Eb），倒数第二个是 Bb，所以是 Bb 大调。再减 3 个半音到 G，所以关系小调是 G 小调。
- 4 个降号（Bb, Eb, Ab, Db），倒数第二个是 Ab，所以是 Ab 大调。再减 3 个半音到 F，所以关系小调是 F 小调。
学会推导后，记忆还是靠口径：
一升 G 二升 D
三 A 四 E 五升 B
六个升号是 F
七个升号是升 C
一降 F 二降 B
三 E 四 A 五降 D
六个降号是降 G
七个降号是降 C

为了输入方便，C#表示升 C，Cb 表示降 C。其余类推。
^[return]

pie

Fri, 14 Mar 2025 12:16:00 +0800

今天是 3 月 14 日，π 日。突然想尝试用 Python 来模拟布冯投针实验来计算 π。

原理

实验设定

假设有一组平行线，线间距为 $d$。
将一根长度为 $l$ 的针（通常 $l \leq d$）随机投掷到平面上。
针的中点到最近线的距离 $x$ 在 $[0, d/2]$ 均匀分布。
针与水平线的夹角 $\theta$ 在 $[0, \pi/2]$ 均匀分布。

相交条件

针与某条平行线相交的条件是：针的中点到最近线的距离 $x$ 小于等于针的投影长度，即 $x \leq (l/2) \cdot \sin(\theta)$。
这意味着针的一端跨过了某条线。

概率计算

通过几何概率分析，针与线相交的概率 $P$ 可以推导出为：
\[P = \frac{2l}{\pi d}\]

核心思想

在实验中，通过大量投针，统计针与线相交的次数 $N_{\text{cross}}$ 和总投针次数 $N_{\text{total}}$，计算相交概率的实验值：
\[P_{\text{exp}} = \frac{N_{\text{cross}}}{N_{\text{total}}}\]
根据理论公式 $P = \frac{2l}{\pi d}$，可以反推出 π 的估计值：
\[\pi \approx \frac{2l}{P_{\text{exp}} \cdot d}\]

实现

import random
import math
import matplotlib.pyplot as plt
def buffon_needle_simulation(n, l, d):
"""
 布冯投针实验模拟
 参数:
 n - 投针次数
 l - 针的长度
 d - 平行线之间的距离
 返回:
 估计的 π 值
 """
crossings = 0
needles = [] # 存储针的信息用于可视化
for _ in range(n):
# 随机生成针的中点到最近线的距离 (0 到 d/2)
x = random.uniform(0, d/2)
# 随机生成针的角度 (0 到 π/2)
theta = random.uniform(0, math.pi/2)
# 计算针的中心坐标 (假设在 0 到 d 的范围内随机放置 y 坐标)
y_center = random.uniform(0, d)
# 计算针的端点坐标
dx = (l/2) * math.cos(theta)
dy = (l/2) * math.sin(theta)
x1 = x - dx
y1 = y_center - dy
x2 = x + dx
y2 = y_center + dy
# 检查是否与线相交
intersects = x <= (l/2) * math.sin(theta)
if intersects:
crossings += 1
# 存储针的信息
needles.append((x1, y1, x2, y2, intersects))
# 计算概率和 π 估计值
probability = crossings / n
pi_estimate = (2 * l) / (probability * d) if probability > 0 else float('inf')
# 可视化
if n <= 100: # 限制可视化的针数，避免过于密集
fig, ax = plt.subplots(figsize=(8, 8))
# 绘制平行线
for i in range(int(d * 2)):
ax.axhline(i * d, color='gray', linestyle='--', alpha=0.5)
# 绘制针
for x1, y1, x2, y2, intersects in needles:
color = 'red' if intersects else 'blue'
ax.plot([x1, x2], [y1, y2], color=color, linewidth=1.5)
ax.set_xlim(-d, d)
ax.set_ylim(-d/2, 1.5*d)
ax.set_aspect('equal')
ax.set_title(f"Buffon's Needle Simulation (n={n})")
plt.xlabel("x")
plt.ylabel("y")
plt.show()
return pi_estimate
# 设置参数
n = 1000 # 投针次数（可视化时建议用较小的值）
l = 1.0 # 针的长度
d = 1.5 # 线间距
# 运行模拟
estimated_pi = buffon_needle_simulation(n, l, d)
# 输出结果
print(f"投针次数: {n}")
print(f"针的长度: {l}")
print(f"线间距: {d}")
print(f"估计的 π 值: {estimated_pi}")
print(f"实际的 π 值: {math.pi}")
print(f"误差: {abs(estimated_pi - math.pi)}")

结果

投针次数: 100
针的长度: 1.0
线间距: 1.5
估计的 π 值: 3.1746031746031744
实际的 π 值: 3.141592653589793
误差: 0.03301052101338131

投针次数: 1000
针的长度: 1.0
线间距: 1.5
估计的 π 值: 3.134796238244514
实际的 π 值: 3.141592653589793
误差: 0.006796415345279083

投针次数: 10000
针的长度: 1.0
线间距: 1.5
估计的 π 值: 3.14911037631869
实际的 π 值: 3.141592653589793
误差: 0.007517722728896725

VPS 被挖矿了

Tue, 11 Feb 2025 19:32:00 +0800

本文记载了一次我的 VPS 被攻击的经历。

现象

我的 vps 在使用中感觉很卡，仔细一看，cpu 负载一直在 100%，用 top 查看没有异常进程，但总数明显不正常，应该是相关进程被隐藏了。

处理

由于系统卡得几乎无法操作，也就没法安装杀毒软件或其他工具。正在束手无策之际，突然想起之前有个 glances 的 docker 在运行，打开 glances 的页面，果然发现一个进程占了 70~80% 的 cpu 负荷。

用 systemctl status PID，显示了详细信息，其中包含了文件路径，于是去删除了相关文件，再 kill -9 PID 杀掉进程。

又查了 crontab -l，里面被添加了开机启动（@reboot 开头的行），又相应删了这些文件。

然后又凭感觉连猜带蒙的删了一些相关文件，感觉差不多了，重启。进来后觉得还是卡，但实际 cpu 负荷并不高，可能是心理作用吧，洁癖，还是重装吧。

分析

一直在思考 vps 怎么会被挖矿，平时也没安装乱七八糟的东西，更何况也没怎么跑大型的应用。

然后突然想起，为了监控远程 docker，我开了允许远程访问 docker。具体操作参考¹。

这样带来很危险的后果，只要被扫描到端口，就可以实现攻击，完全不设防。

攻击示例

简单地举个例子：

# 攻击者使用无认证的 2375 端口远程连接 Docker 并修改 /etc/hosts
docker -H tcp://<your-server-ip>:2375 run --rm \
 -v /etc/hosts:/etc/hosts \
 alpine sh -c "echo '1.2.3.4 example.com' >> /etc/hosts"

这样子，还有什么不能改的呢？

整改

有两个方案：

套上 TLS

生成服务器 TLS 证书

sudo mkdir -p /etc/docker/certs
sudo openssl genrsa -aes256 -out /etc/docker/certs/ca-key.pem 4096
sudo openssl req -new -x509 -days 365 -key /etc/docker/certs/ca-key.pem -sha256 -out /etc/docker/certs/ca.pem
sudo openssl genrsa -out /etc/docker/certs/server-key.pem 4096
sudo openssl req -subj "/CN=$(hostname)" -new -key /etc/docker/certs/server-key.pem -out /etc/docker/certs/server.csr
sudo openssl x509 -req -days 365 -sha256 -in /etc/docker/certs/server.csr -CA /etc/docker/certs/ca.pem -CAkey /etc/docker/certs/ca-key.pem -CAcreateserial -out /etc/docker/certs/server-cert.pem
sudo chmod 600 /etc/docker/certs/*

修改 /etc/docker/daemon.json

{
"tls": true,
"tlsverify": true,
"tlscacert": "/etc/docker/certs/ca.pem",
"tlscert": "/etc/docker/certs/server-cert.pem",
"tlskey": "/etc/docker/certs/server-key.pem",
"hosts": [
"unix:///var/run/docker.sock",
"tcp://0.0.0.0:2376"
]
}

重启 docker

1
2

sudo systemctl daemon-reload
sudo systemctl restart docker

生成客户端证书

openssl genrsa -out client-key.pem 4096
openssl req -new -key client-key.pem -sha256 -out client.csr
openssl x509 -req -days 365 -sha256 -in client.csr -CA ca.pem -CAkey ca-key.pem \
-CAcreateserial -out client-cert.pem

客户端连接

docker --tlsverify \
 --tlscacert=/path/to/ca.pem \
 --tlscert=/path/to/client-cert.pem \
 --tlskey=/path/to/client-key.pem \
 -H=tcp://<服务器IP>:2376 info

使用 Docker Socket Proxy

使用 tecnativa/docker-socket-proxy 作为代理，限制 API 权限。

docker run -d \
 --name docker_proxy \
 -p 2375:2375 \
 -v /var/run/docker.sock:/var/run/docker.sock \
 -e CONTAINERS=1 \
 -e IMAGES=1 \
 -e SERVICES=0 \
 tecnativa/docker-socket-proxy

验证

# 使用 curl 进行 API 测试：
curl http://localhost:2375/containers/json
# 仅返回正在运行的容器列表。
# 尝试删除容器：
curl -X DELETE http://localhost:2375/containers/<container-id>
# 提示被拒绝。

总结

以上两个方案，第二个方法更方便也更安全，也是我最后采用的方案。
对于网上的技术资料方案，即使是正规网站，也要切实理解后再实施。

https://docs.docker.com/engine/daemon/remote-access/
^[return]

fail2ban

Wed, 15 Jan 2025 18:40:00 +0800

近日发现很多对于端口的扫描，虽然由于 ufw 的拦截并不能进入，但还是想用 fail2ban 来封禁这些 IP，减少被扫描的次数。因此增加了更多的 jail 配置。

jail

编辑 /etc/fail2ban/jail.d/defaults-debian.conf 文件，定义从哪里读取，以及对应操作：

[DEFAULT]
banaction = ufw
bantime = 10m
banTime.increment = true
[sshd]
enabled = true
[ufw]
enabled = true
filte = ufw
action = iptables-allports
logpath = /var/log/ufw.log
maxretry = 1

filter

编辑 /etc/fail2ban/filter.d/ufw.conf 文件，定义正则表达式模板：

1
2
3

[Definition]
failregex = [UFW BLOCK].+SRC=<HOST> DST
ignoreregex =

action

/etc/fail2ban/action.d/ufw.conf 这个文件是现成的不需要改动，直接拿来用。

屏幕宠物

Sun, 22 Dec 2024 12:22:00 +0800

写了个 Python 程序，用到了 tkinter 和 pillow 模块，实现在桌面播放 gif 图片，给桌面增加一点节日气氛。

Python

具体如下：

import tkinter as tk
from PIL import Image, ImageTk, ImageSequence
class DesktopPet:
def __init__(self, gif_path):
self.root = tk.Tk()
self.is_borderless = True # 初始化为无边框状态
self.root.title("") # 设置窗口标题
self.root.overrideredirect(self.is_borderless) # 去掉边框
self.root.attributes("-topmost", True) # 窗口置顶
self.root.attributes("-transparentcolor", "white") # 设置透明颜色
self.root.attributes("-toolwindow", True) # 去掉最大化最小化
# 禁用窗口最大化、最小化按钮
self.root.resizable(False, False) # 禁止调整窗口大小
# 加载并处理 GIF 图像
self.frames = []
self.width, self.height = 0, 0
self.load_and_process_gif(gif_path)
# 创建一个标签控件来显示GIF
self.label = tk.Label(self.root, image=self.frames[0], bg="white") # 设置白色背景
self.label.pack()
# 设置帧动画
self.frame_index = 0
self.update_frame()
# 初始化宠物的位置
self.x, self.y = 100, 100
self.root.geometry(f"{self.width}x{self.height}+{self.x}+{self.y}")
# 定时器检查鼠标位置
self.check_mouse_position()
def load_and_process_gif(self, gif_path):
gif = Image.open(gif_path)
# 缩小尺寸
original_width, original_height = gif.size
self.width = original_width // 2
self.height = original_height // 2
# 处理每一帧：缩小并去掉黑色背景
for frame in ImageSequence.Iterator(gif):
frame = frame.convert("RGBA") # 转换为 RGBA 模式
# 缩小图片
frame = frame.resize((self.width, self.height), Image.Resampling.LANCZOS)
# 替换黑色背景为透明
datas = frame.getdata()
new_data = []
for item in datas:
if item[:3] == (0, 0, 0): # 如果是黑色
new_data.append((255, 255, 255, 0)) # 替换为透明
else:
new_data.append(item)
frame.putdata(new_data)
# 转换为 ImageTk.PhotoImage 格式
self.frames.append(ImageTk.PhotoImage(frame))
def update_frame(self):
self.frame_index = (self.frame_index + 1) % len(self.frames)
self.label.config(image=self.frames[self.frame_index])
self.root.after(100, self.update_frame) # 每100ms更新一次帧
def check_mouse_position(self):
# 获取鼠标的屏幕位置
mouse_x, mouse_y = self.root.winfo_pointerxy()
# 获取窗口的屏幕范围
x1 = self.root.winfo_x()
y1 = self.root.winfo_y()
x2 = x1 + self.width
y2 = y1 + self.height
# 判断鼠标是否在窗口范围内
if x1 <= mouse_x <= x2 and y1 <= mouse_y <= y2:
if self.is_borderless: # 如果当前是无边框状态
self.is_borderless = False
self.root.overrideredirect(False) # 显示窗口栏
else:
if not self.is_borderless: # 如果当前是有边框状态
self.is_borderless = True
self.root.overrideredirect(True) # 隐藏窗口栏
# 定时器再次检查
self.root.after(200, self.check_mouse_position) # 每200ms检查一次
def run(self):
self.root.mainloop()
if __name__ == "__main__":
pet = DesktopPet("pet.gif") # 替换为你的GIF文件路径
pet.run()

掩耳盗铃

Wed, 20 Nov 2024 15:15:00 +0800

秋去冬来，又到了上级检查组出没的季节。检查项目中有一项是各种系统日志的备份记录，为了应付检查就得无中生有给变出来。按照要求是每天一个文件夹，里面是当天的日志。如果手工复制文件再修改日期，肯定得累死。于是在 linux 和 windows 的电脑上分别用 bash 和 powershell 编了脚本来实现。

linux bash

脚本如下：

#!/bin/bash

# 设置起始和结束日期
start_date="20240101"
end_date="20241031"
# 将日期转换为时间戳
start_ts=$(date -d "$start_date" +%s)
end_ts=$(date -d "$end_date" +%s)
# 开始循环，来生成目录和文件
current_ts=$start_ts
while [ $current_ts -le $end_ts ]; do
# 获取当前日期
current_date=$(date -d "@$current_ts" +%Y%m%d)
# 创建目录
mkdir -p "$current_date"
# 设置文件名和时间戳，对应在每天的00:10:18
timestamp="${current_date}001018"
file1="${timestamp}-operation-log-dateThreshold_info.xml"
file2="${timestamp}-operation-log-dateThreshold.zip"
file3="${timestamp}-system-log-dateThreshold_info.xml"
file4="${timestamp}-system-log-dateThreshold.zip"
# 创建文件并填充随机内容，文件大小也用随机数生成范围
head -c $((RANDOM % 101 + 700)) /dev/urandom > "$current_date/$file1"
head -c $((RANDOM % 10001 + 40000)) /dev/urandom > "$current_date/$file2"
head -c $((RANDOM % 101 + 700)) /dev/urandom > "$current_date/$file3"
head -c $((RANDOM % 1001 + 3000)) /dev/urandom > "$current_date/$file4"
# 将文件生成时间戳修改为指定时间
touch -d "${current_date} 00:10:18" "$current_date/$file1"
touch -d "${current_date} 00:10:18" "$current_date/$file2"
touch -d "${current_date} 00:10:18" "$current_date/$file3"
touch -d "${current_date} 00:10:18" "$current_date/$file4"
# 目录的时间戳也不要忘记设置
touch -d "${current_date} 00:10:18" "$current_date"
# 循环移动到下一个日期继续
current_ts=$(($current_ts + 86400))
done

Windows PowerShell

脚本如下：

# 设置起始和结束日期
$start_date = "20240101"
$end_date = "20241031"
# 将日期转换为时间戳
$start_ts = [datetime]::ParseExact($start_date, "yyyyMMdd", $null).ToFileTimeUtc()
$end_ts = [datetime]::ParseExact($end_date, "yyyyMMdd", $null).ToFileTimeUtc()
# 开始循环，来生成目录和文件
$current_ts = $start_ts
while ($current_ts -le $end_ts) {
# 获取当前日期
$current_date = [datetime]::FromFileTimeUtc($current_ts).ToString("yyyyMMdd")
# 创建目录
New-Item -ItemType Directory -Path $current_date -Force
# 设置文件名和时间戳，对应在每天的00:10:18
$timestamp = "${current_date}001018"
$file1 = "${timestamp}-operation-log-dateThreshold_info.xml"
$file2 = "${timestamp}-operation-log-dateThreshold.zip"
$file3 = "${timestamp}-system-log-dateThreshold_info.xml"
$file4 = "${timestamp}-system-log-dateThreshold.zip"
# 创建文件并填充随机内容，文件大小也用随机数生成范围
$random = New-Object System.Random
$file1_size = $random.Next(700, 800)
$file2_size = $random.Next(40000, 50000)
$file3_size = $random.Next(700, 800)
$file4_size = $random.Next(3000, 4000)
$file1_content = [byte[]]::new($file1_size)
$file2_content = [byte[]]::new($file2_size)
$file3_content = [byte[]]::new($file3_size)
$file4_content = [byte[]]::new($file4_size)
$random.NextBytes($file1_content)
$random.NextBytes($file2_content)
$random.NextBytes($file3_content)
$random.NextBytes($file4_content)
[System.IO.File]::WriteAllBytes("$current_date\$file1", $file1_content)
[System.IO.File]::WriteAllBytes("$current_date\$file2", $file2_content)
[System.IO.File]::WriteAllBytes("$current_date\$file3", $file3_content)
[System.IO.File]::WriteAllBytes("$current_date\$file4", $file4_content)
# 将文件生成时间戳修改为指定时间
$timestamp_date = [datetime]::ParseExact("${current_date} 00:10:18", "yyyyMMdd HH:mm:ss", $null)
(Get-Item "$current_date\$file1").LastWriteTime = $timestamp_date
(Get-Item "$current_date\$file2").LastWriteTime = $timestamp_date
(Get-Item "$current_date\$file3").LastWriteTime = $timestamp_date
(Get-Item "$current_date\$file4").LastWriteTime = $timestamp_date
# 目录的时间戳也不要忘记设置
(Get-Item $current_date).LastWriteTime = $timestamp_date
# 循环移动到下一个日期继续
$current_ts += 864000000000 # 增加一天的时间戳（单位为100纳秒）
}

写完程序，突然发现，古往今来，掩耳盗铃之事从未停止过。

sftp

Sun, 06 Oct 2024 19:56:00 +0800

现要建一个 sftp 服务器，其要求为：

sftp 登录后自动跳转到 /sftp/$USER/upload 目录，直接上传
对应用户 sftp 登录到对应用户目录，不能访问其他用户目录

为实现上述需求，方案如下：

创建用户和组

以创建一个用户组 sftpgrp，以及两个用户 sftp1、 sftp2 为例:

groupadd sftpgrp
adduser sftp1 -G sftpgrp
adduser sftp2 -G sftpgrp
passwd sftp1
passwd sftp2

创建目录

创建相应用户目录，并设置权限

mkdir -p /sftp/sftp{1..2}/upload
chown -R sftp1:sftp1 /sftp/sftp1
chown -R sftp2:sftp2 /sftp/sftp2
chmod -R 770 /sftp/sftp{1..2}

修改配置

编辑 /etc/ssh/sshd_config 文件，注释掉自带的 Subsystem sftp /usr/libexec/openssh/sftp-server 这行，添加以下内容：

1
2
3

Subsystem sftp internal-sftp -d %u/upload
Match Group sftpgrp
ChrootDirectory /sftp

最后重启 sshd 即可。

`1`	`systemctl restart sshd.service`

The Black Friday

Fri, 13 Sep 2024 19:24:00 +0800

写在 9 月 13 日，星期五。一个黑色的日子。

我们生在中国，我们葬在中国
我们所有的不幸，只有这么两个
躺在里面的，再也不必假装死了
留在外面的，还要继续假装活着

xray

Thu, 08 Aug 2024 19:20:00 +0800

Xray 是 V2Ray 的一个分支，具有更高的性能（如大连接情况下）、更多的功能（如 XTLS）。

经过各种组合验证，最后我采用的是“VLESS-Vision-REALITY”的方案来实现，其优势有：

TCP 比 UDP 更稳定；
vless 比 vmess 更轻量简洁，传输效率更高；
reality 相比 tls 无需注册域名，更省事；

记录如下：

server

server 的 config.json：

{
"log": {
"loglevel": "warning"
},
"routing": {
"domainStrategy": "IPIfNonMatch",
"rules": [
{
"type": "field",
"outboundTag": "block",
"ip": [
"geoip:private"
]
}
]
},
"inbounds": [
{
"protocol": "vless",
"listen": "0.0.0.0",
"port": __(1)__,
"settings": {
"clients": [
{
"id": "__(2)__",
"flow": "xtls-rprx-vision"
}
],
"decryption": "none"
},
"streamSettings": {
"network": "tcp",
"security": "reality",
"realitySettings": {
"dest": "__(3)__:443",
"serverNames": [
"__(3)__",
"__(3')__"
],
"privateKey": "__(4)__",
"shortIds": [
"__(5)__"
]
}
},
"sniffing": {
"enabled": true,
"destOverride": [
"http",
"tls",
"quic"
]
}
}
],
"outbounds": [
{
"tag": "direct",
"protocol": "freedom"
},
{
"tag": "block",
"protocol": "blackhole"
}
]
}

其中：

(1) 服务端的侦听端口
(2) UUID，可以用 xray uuid 来生成
(3) 回落的域名，用于伪装¹
(3’) 伪装网站的其他地址²
(4) 长 ID，用 xray x25519 生成一对密钥，填 “Private key” 的值
(5) 短 ID，用 openssl rand -hex 8 生成

client

client 的 config.json：

{
"log": {
"loglevel": "warning"
},
"routing": {
"domainStrategy": "IPIfNonMatch",
"rules": [
{
"type": "field",
"outboundTag": "direct",
"domain": [
"geosite:cn"
]
},
{
"type": "field",
"outboundTag": "direct",
"ip": [
"geoip:cn",
"geoip:private"
]
}
]
},
"inbounds": [
{
"protocol": "socks",
"listen": "0.0.0.0",
"port": __(6)__
},
{
"protocol": "http",
"listen": "0.0.0.0",
"port": __(6')__
}
],
"outbounds": [
{
"tag": "proxy",
"protocol": "vless",
"settings": {
"vnext": [
{
"address": "__(7)__",
"port": __(1)__,
"users": [
{
"id": "__(2)__",
"flow": "xtls-rprx-vision",
"encryption": "none"
}
]
}
]
},
"streamSettings": {
"network": "tcp",
"security": "reality",
"realitySettings": {
"serverName": "__(3)__",
"publicKey": "__(4')__",
"shortId": "__(5)__",
"fingerprint": "chrome"
}
}
},
{
"tag": "direct",
"protocol": "freedom"
}
]
}

其中：

(6) 客户端的侦听端口 socks 协议
(6’) 客户端的侦听端口 http 协议，给某些不支持 socks 的服务用
(7) 服务器地址
(4’) 长 ID，填与服务端对应的 “Public key” 的值

该网站用于伪装，当认证不通过时，会显示该网站，让人以为服务器上运行的是一个网站。网站的选择有一定要求：首先进入待测网页，按下 F12 键，转到“安全性”选项卡，在“连接”下出现“TLS 1.3，X25519”字样即代表网页支持 TLSv1.3 协议、并且使用的是 x25519 证书；其次转到“控制台”选项卡，输入命令 window.chrome.loadTimes()，查看 npnNegotiatedProtocol 的值是否为 h2，如果是的话就代表使用的是 H2 协议。
^[return]
serverName 列表，暂不支持 * 通配符，在 Chrome 里输入待测试的网址，按下 F12 键，转到“安全性”选项卡，刷新一下，查看“主要来源（安全）”，填证书中 SAN 的值，有多条就填多条。
^[return]