有一天，一个叫 Alice 的六岁小女孩打来电话问了一个问题。

她问，我是个好孩子，我弟弟是个坏孩子。爸爸妈妈要求我们每晚 9 点上床睡觉，每一次我都很听话，按时上床。

可弟弟却不听话，每次要一个苹果才肯上床，而他居然每次都能得逞。我也想要一个苹果，但父母从来不给我。

为什么弟弟是个坏孩子，他总能得到苹果，而我是个好孩子，却总得不到苹果？

坏孩子虽然得到了苹果，但其实你得到了上帝最好的礼物，就是你是个好孩子。成为好孩子本身就是奖励。

我一直觉得这是一个奇怪的寓言故事，感觉像是废话一样。

最近读了不少书，时常会有一些功利的想法，有些书看着虽然很有趣，但总会觉得似乎也不能用来换钱。 今天坐在马桶上突然想到这个故事，才明白过来——读书本来就是一种乐趣，这就是读书最大的奖励。

作为技术员工，你的一部分工作就是培训周围的非技术人员，讲解开发过程。

在软件开发过程中，如果需求被污染了，那么他就会污染架构，而架构又会污染构建。这样会导致 程序员脾气暴躁、营养失调；开发出的程序具有放射性污染，而且周身都是缺陷。

发现错误的时间要尽可能接近引入错误的时间。

问题定义应该用客户的语言来书写，而且应该从客户的角度来描述问题。最好的解决方案未必是一个计算机程序。

明确的需求免得你去猜测用户想要的是什么。开发过程能够帮助用户更好地理解自己的需求，这是需求变更的主要来源。平均下来，开发过程中有 25% 的需求变化会导致返工量的 75% 以上。

如何怒怼需求

1. 确保每个人都知道需求变更的代价。“进度”和“成本”这两个字眼比咖啡和冷水澡都要提神，许多“必须要有（must have）”的功能很快就会变成 “有了最好（nice to have）”
2. 建立一套变更控制系统
3. 使用能够适应变更的开发方法
4. 放弃这个项目。如果需求特别糟糕，或者极不稳定，而上 main 的意见没有一条能够奏效，那就取消这个项目。即使你真的无法取消这个项目，也设想一下取消它之后回事怎样的情况。
5. 注意项目的商业案例、有些需求作为功能特色来看是不错的注意，但是当你评估“增加的商业价值”时就会觉得它是个糟糕透了的主意。

架构的典型组成部分

1. 服务划分
2. 业务规则
3. 用户界面设计
4. 资源管理
5. 安全性
6. 性能
7. 可伸缩性
8. 互用性
9. 国际化、本地化
10. 错误处理
11. 关于买还是造的决策
12. 如何复用
13. 变更策略

优秀的架构往往适合机器和语言无关的。

第一章 欢迎进入软件构建的世界

没啥可记录的

第二章 用隐喻更充分地理解软件开发

软件开发最大的挑战还是将问题概念化，编程中的很多错误都是概念性的错误。

应该先做出一个尽可能简单、但能运行的版本。一点点在其上附上肌肉和皮肤，一次增加一部分代码，直到得到一个可以完全工作的系统。

第三章 三思而后行：前期准备

第五章

软件的首要技术使命——管理复杂度

低效的设计往往来自：

1. 用复杂的方法解决简单的问题
2. 用简单但错误的方法解决复杂的问题
3. 用不恰当的复杂方法解决复杂的问题

理想的设计特征

1. 高扇入：大量的类使用某一个固定的类，也就是有很好的复用。
2. 低扇出：让一个类尽量少地使用其他的类，否则会过于复杂。
3. 使用标准技术：要尽量使用标准化、常用的方法，让整个系统给人一种熟悉的感觉。

对子系统之间的通信应该加以限制，越少越好。尤其不要有环向的依赖。

类应该像冰山：八分之七都是位于水面之下，而你能看到的只是水面之上的八分之一。

常用的设计模式：

1. 抽象工厂模式。通过制定对象组的种类而非单个对象的类型来支持创建一组相关的对象
2. 适配器。把一个类的接口转换成另一个接口
3. 桥接。把接口和实现分开，使他们可以独立地变化
4. 组合。创建一个包含了其他同类对象的对象，是的客户端可以与最上层对象交互而无需考虑过多的细节对象。
5. 装饰器。给一个对象动态的添加职责，而不去创建新的类
6. 外观。为没有一致接口的代码提供一个一致的接口
7. 工厂方法。
8. 迭代器。提供一个服务来顺序访问一族元素中的每一个
9. 观察者。当一个对象变化时，把这个变化通知其他元素。
10. 单例。有且只有一个实例
11. 策略。定义一组行为或算法，使得他们可以动态地相互替换
12. 模板方法。定义一个操作的算法结构，但是把部分实现的细节留给子类（派生类）

蛮力也是一种强大的方法。画图是另一种强大的启发式方法。图能在另一个更高的抽象层次上表达问题。不要卡在单一问题上，可以去散散步。

实际开发中的问题和学校作业的区别是，实际开发中的问题可能经常在你提交代码之后需求已经变了，需要再次开发

第六章

不懂 ADT 的程序员开发出来的类只是名义上的“类”而已——实际上这种“类”只不过是把一些稍微有点关系的数据和子程序堆在一起。

YN: 使用 ADT 隐藏实现细节，但是也可能是过早优化，比如 JAVA 中讨厌的 getter、setter

使用类的好处是，你可以像在现实世界中

第十章

隐式变量声明

隐式变量声明是一项非常危险的行动。

BAD

account_no = xxx
account_number = 123456 // 记错变量名了
target_account = account_no 

GOOD

Python 中无法强制声明变量，可以使用 pylint 等工具

可以通过以下几个方面改善

1. 关闭隐式变量声明
2. 遵循某种命名规则
3. 使用 lint 等工具检查变量名

初始化

在需要第一次使用变量的地方声明变量，在变量声明的时候初始化，并且尽量声明为 const 或者 final。

尤其要注意 i，j 这些变量在再次使用的时候有没有再次初始化。

对于 C++ 等语言，要在构造函数中初始化所有变量，并且在析构函数中释放内存。

作用域

介于统一变量多个引用点之间的代码称为“攻击窗口”。跨度指的是两次访问同一个变量的间隔，生存时间指的是变量的第一次使用和最后一次使用的间隔。应该尽量减少变量的存活时间和跨度，比如说全局变量的跨度和生存时间都很长，所以他们不好。

持续性

在程序中加入断言来验证关键变量的合理取值 在需要删除变量的时候赋值为不合法数值，比如 null

绑定时间

越晚越好

1. 编码时 titleBar.color = 0xfff
2. 编译时 titleBar.color = WHITE
3. 加载时，也就是程序初始化的时候 titleBar.color =

第十四章

语句一般也分为有副作用的语句和没有副作用的语句，如果前后两个语句都在更新同一个变量，那这样是不好的。至少我们要减少有副作用的语句。这样可以使代码的依赖变得更加明显。代码是按照顺序执行的，对于后一句依赖前一句的代码

比如：

BAD:

ComputeMarketingExpense()
ComputeSaleExpense()
ComouteTravelExpense()
ComputePersonalExpense()
DispalyExpenseSummary()

Good:

market = ComputeMarkingExpense()
sale = ComputeSaleExpense()
travle = ComputeTravelExpense()
personal = ComputePersonalExpense()
Dispaly(ExpenseSummery(market, sale, travle, personal)

对于没有依赖关系的代码，应该让他们尽可能分组，方便自上而下的阅读。最好做到相关代码构成的语句块之间不要有重叠

BAD：

MarketingData marketingData;
SalesData salesData;
TravelData travelData;

travelData.ComputeDuarerly()
salesData.ComputeQuarterly()
maketingData.ComputeQuarterly()

salesData.Print()
travelData.Print()
marketingData.Print()

Good:

MarketingData marketingData;
marketingData.ComputeQuarterly()
marketingData.Print()

TravelData travelData;
travelData.ComputeQuarterly()
travelData.Print()

SalesData salesData
salesData.ComputeQuerterly()
salesData.Print()

第十五章 使用条件语句

书中写到应该优先处理正常情况，但是这样的话可能造成箭头形的代码，个人认为还是有限处理错误并返回比较好。不过如果是正常情况的分支的话，应该优先处理常见情况。对于 switch 语句，应该在 default 字句中处理错误

对于大长串的 and 判断条件建议写一个 is_XXX 函数来封装一下。

第十六章 控制循环

循环的种类：

1. 计数循环，按照规定的次数执行多次
2. 连续求值的循环，预先并不知道需要运行多少次，每次迭代都检查是否需要结束（比如用户选择退出，或者遇到了错误）
3. 无限循环，比如内核，事件循环
4. 迭代器循环，对容器类中的每一个元素执行一次操作

研究显示下面这种代码比传统的 while 或者 do-while 代码更容易理解，以为如果把退出条件强行放到开始或者结尾，那么很难避免重复代码。

while (true) {
    // ...
    if (xxx) break
   // ...
}

像是 for 和 foreach 循环最好用在简单的控制条件，不要在循环体内做改动下标等操作。

安全计数器

对于可能无法终止的循环，可以考虑添加一个安全计数器来保证不会出现死循环。

BAD:

do {
    node = node->Next;
} while (node-Next != NULL);

Good:

safeCounter = 0;
do {
    node = node->Next;
    ...
    safeCounter++;
    if (safeCounter >= SATETY_LIMITE) {
        Assert(false, "Internal Error: safe counter violation")
    }
    ...
} while (node->Next != NULL);

continue 和 break

continue 语句就相当于一个 else 语句，和之前所述一样，尽量在循环开始的地方使用 continue 语句。对于 return 语句也是一样的。

需要特别注意的是 switch 中也允许 break 语句，所以很可能导致潜在的 bug

// BAD：
network code()    
{    
    switch(line)   
    {    
        case  THING1:   
            doit1();   
            break;    
        case  THING2:   
            if(x==STUFF)   
            {    
                do_first_stuff();    
                if(y==OTHER_STUFF)    
                    break;    
                do_later_stuff();    
            }    
            /*代码的意图是跳转到这里… …*/    
            initialize_modes_pointer();   
            break;    
        default :    
            processing();    
    }   
    /*… …但事实上跳到了这里。*/    
    use_modes_pointer(); /*致使 modes_pointer 指针未初始化*/    
}

把循环控制在 3 级以内，否则人类就不能理解。把长循环的内容移到子程序中。

可以由内而外的构建循环，也就是说先写出循环体要处理的内容，再去构建循环条件。

第十七章 其他控制结构

递归，首先要写终止语句，并且要尽量避免迭代次数过多的递归，因为每次递归都会产生一个调用栈，可以使用安全计数器来避免无限递归

第十八章 表驱动法

表驱动法把复杂的条件分支语句转化成通过查表语句。表驱动法还有一个好处就是可以把解析的逻辑放到外部文件中。表驱动的两个问题：

1. 使用什么 key，如果对应的条件不能直接做 key，可以使用一个函数转化成 enum
2. 使用什么 value

BAD:

if month == 1:
    days = 31
elif month == 2:
    days = 28
elif month == 3:
    days = 31
...
else month == 12:
    days = 31

GOOD:

days_per_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
days = days_per_month[month -1]

阶梯访问表

比如根据分数来确定学生的评级

range_limit = [50.0, 65.0, 75.0, 90.0, 100.0]
grades = ['F', 'D', 'C', 'B', 'A']
max_grade_level = len(grade) - 1

grade_level = 0
student_grade = 'A'
while student_grade == 'A' and grade_level < max_grade_level:
    if student_score < range_limit[grade_level]:
        student_grade = grades[grade_level]
    grade_level += 1

第十九章 一般控制问题

if 语句

对于复杂的 if 语句来说，也可以考虑使用决策表来简化操作。 对于 if 语句中的判断，按照书中的顺序来编写数值表达式：if 1 < a and a < 3

度量复杂度的 Tom McCabe 方法，根据决策点来测试：

1. 从 1 开始
2. 遇到 if、while、repeat、for、and、or 复杂度加 1
3. 遇到 case 语句，每种情况 +1

0-5， 函数还不错 6-10，需要改进 10+，必须改进

第二十章

没啥可记得

第二十一章

没啥可记得

第二十二章 开发者测试

• 单元测试 一个程序员或者一个团队的代码的测试
• 组件测试 被测代码涉及到多个程序或团队
• 集成测试 对两个或多个包进行测试，通常应该尽早开始
• 回归测试 重复执行以前的测试，以便查找是否有 bug 复发
• 系统测试 在最终配置下运行整个软件

推荐的测试方法

1. 对每项需求进行测试，最好在需求阶段就准备好测试用例
2. 对每一个设计的关注点进行测试
3. 基础测试
4. 测试已经犯过的错误

基础测试

目标是覆盖每一个路径，采用的方法和之前计算代码复杂度的方法一样。

第三十章

如果你发现自己每天多次键入某个长度超过 5 个字母的命令，那么应该用一个脚本

第三十一章

没啥值得记录的

第三十二章 自说明代码

IBM 的研究显示：平均每十行一个注释的代码可读性最高。

代码注释应该着眼于 why 而不是 how

BAD

// if acccount flag is zero
if (accountFlag == 0) ...

GOOD 
// if establishing a new acccount
if (accountFlag == 0) ...

BETTER

if (account.type == AccountType.NewAccount) ...

对于非常规的行为要给与注释

第三十三章 个人性格

你越是谦虚，进步就越快。

1. 将系统“分解”，是为了使之更易于理解
2. 进行 review 和 test 是为了减少人为失误（egoless programming）
3. 将子程序编写的短小，以减轻大脑的负担
4. 基于问题而不是底层实现细节来编程，从而减少工作量
5. 通过各种各样的规范，将思路从相对繁琐的编程事务中解放出来。

求知欲

如果分配给你的工作净是些不能提高自身技能的短期任务，你理应表示不满。如果正处于竞争激烈的软件市场，则目前工作用到的一半的知识将在三年后过期。假如不持续学习，你就会落伍。

如果在工作中学不到什么，就找一份新的工作吧。

如果不了解所用语言的某一特性是怎么回事，可编写一个小程序来检验，看看它是如何工作的。请在调试器中观察程序的执行情况。用一个小程序来检验某一概念，总比编写大程序时运用不太了解的特性要好。

如果小程序表现的特性与你设想的不一样，怎么办呢？那正是你要研究的问题。最好通过小程序找出答案，而不要用大程序。有效编程的关键之一就是要学会迅速制造错误，并且每次都能从中有所收获。犯错不是罪过，从中学不到什么才是罪过。

阅读解决问题的有关方法。解决问题是软件创作过程中的核心行为。就算你想再发明个车轮，也不会注定成功，你发明的也许是方车轮。

在行动之前作出分析和计划。在分析和行动直接有着矛盾关系，然而多数程序员的问题不在于分析过度。

学习成功项目的开发经验。Jon Bentley 认为你应该坐下来，准备一杯白兰地，点一根上好的雪茄，想看优秀小说一样来阅读程序。至少应该研究高层设计，并有选择地去研究某些地方的细节源代码。

Thomas Kuhn 指出，凡是成熟的学科都是从解决问题发展起来的。

不仅要阅读别人的代码，还应渴望了解专家对你的代码的看法。

诚实

偷懒的三个境界

1. 拖延不喜欢的任务
2. 迅速做完不喜欢的任务，以摆脱
3. 编写某个工具来完成不喜欢的任务，以便再也不会做这些事

理论上当然是这样的，然而经常会遇到的讨厌的事情并不是重复性的，而是每次都是不同的恶心事情，或者 lead 催很紧，没有时间做类似的工具。

坚持

不要坚持，如果花了 15 分钟调试仍然没有进展，就该放弃排错过程，让潜意识仔细品品。和计算机错误斗气是不明智的，更好的方法是避开他们。

经验

人们还荒唐地强调程序员有多少经验。“我们需要有五年以上 C 语言编程经验的程序员”就是愚蠢的说法。如果程序员过了前一两年还没有学好 C 语言，那么再过个三年也没有什么意义。

最后一个问题，如果你工作十年，你会得到十年经验还是一年经验的十次重复？必须检讨自己的行为，才能获得真正的经验。只有坚持不懈地学习，才能获取经验；如果不这样做，无论你工作多少年，都无法获得经验。

Gonzo Programming

彻夜编程让你感觉像是世界上最好的程序员，却要花上几个星期去纠正你在短暂辉煌时埋下的错误。可以热爱编程，但是热情不能代替熟练的能力，请想明白什么更重要。

习惯

不能用“没有习惯”来代替“坏习惯”，只能用“新习惯”代替“坏习惯”

第三十四章

基于问题域编程，最顶层代码不要关心实现细节。

1. tar.gz 或者 tgz 文件
2. zip 文件
3. rar 文件，Linux 下几乎没有
4. 7z 文件

tar.gz 文件

压缩

tar cvzf FILES...

解压

tar xvzf TARBALL

zip 文件

zip -r ZIPFILE DIRECTORY to zip a directory

zip -r ZIPFILE DIRECTORY -x "*.git*" exclude the .git directory

zip -l ZIPFILE list the files

7z 文件

安装对应工具

apt-get install p7zip-full

解压缩

7z x some.7z

• 没有 daemon，默认不使用 root
• 可以导出 k8s 部署配置
• 可以一键停止删除所有容器，stop -a, rm -a, rmi -a 等
• 增加了 -l、--latest 选项，直接操作上一个 container，而不需要找到 id 然后再操作。

Podman 最贴心的的部分在于命令行更加人性化。

比如说：

podman stop -l
podman rm -a

podman-compose

pip3 install podman-compose

podman play

坑

podman 有个 bug，默认不会打开 cache，需要使用 --layers 手动打开.

podman build --layers .

Use podman on macOS

虽然在 mac 上，可以用 podman 自己带的虚拟机，但是这个虚拟机是 CentOS 的系统，不太习惯， 所以还是用 multipass 起一个 ubuntu 的机器来用吧。

multipass launch -c 2 -m 8G -d 64G -n podman
multipass mount $HOME podman:/home/ubuntu/host
multipass shell podman

Install latest podman on Ubuntu

#!/bin/sh

ubuntu_version='22.04'
key_url="https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/unstable/xUbuntu_${ubuntu_version}/Release.key"
sources_url="https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/unstable/xUbuntu_${ubuntu_version}"

echo "deb $sources_url/ /" | tee /etc/apt/sources.list.d/devel:kubic:libcontainers:unstable.list
curl -fsSL $key_url | gpg --dearmor | tee /etc/apt/trusted.gpg.d/devel_kubic_libcontainers_unstable.gpg > /dev/null
apt update
apt install podman

build amd64 image on ARM64/M1

apt-get install -y qemu-user-static
reboot
podman build --platform linux/amd64

参考

1. https://developers.redhat.com/blog/2019/02/21/podman-and-buildah-for-docker-users/
2. https://cloud.redhat.com/blog/crictl-vs-podman
3. https://podman.io/getting-started/
4. https://askubuntu.com/questions/1414446/whats-the-recommended-way-of-installing-podman-4-in-ubuntu-22-04
5. https://dev.to/tkral/podman-build-amd64-images-on-m1-294g

连接

import sqlite3

db = sqlite3.connect("database.db")  # connections
db.execute("CREATE TABLE books (id int primary key, name text)")
db.execute("INSERT INTO books (name) VALUES ('war and peace')")
db.execute("INSERT INTO books (name) VALUES ('the bible')")
db.commit()  # always remember to commit
db.execute("SELECT * FROM books")

db.close()

# 或者使用 with 语句
with sqlite3.connect("db") as db:
    # cursor executes

虽然 Python 的 DB API 2.0 规范是要求使用 db.cursor() 获得一个 cursor 来执行 execute, 但是 对 sqlite 来说完全没有必要，直接用 db.execute 这种快捷方式就好了。

构建语句

不要用 Python 自带的字符串格式化，可能有 sql 注入的风险，要使用问号或者冒号格式化。

# fabricating statement
db.execute("select from books where name = ?", ["the bible"]) 
# NOTE the param must be a sequence

# You could also use named placeholders
db.execute("insert into books (name) values (:name)", {name: "the bible"})

获取数据

有两种方式：

使用 fetchone, fetchmany(n), fetchall

r = db.execute("SELECT id FROM stocks WHERE name = 'MSFT'")
id = r.fetchone()[0]

直接迭代返回结果

for row in db.execute("SELECT * FROM stocks ORDER BY price"):
    print row[0], row[1]

注意结果每行是一个 tuple，即使 select 了一个元素，结果也是 tuple。

如果我们想要返回一个字典，需要更改一下 row_factory, 推荐使用 sqlite3.Row

db.row_factory = sqlite3.Row

lastrowid 属性。This read-only attribute provides the rowid of the last modified row. It is only set if you issued a INSERT statement using the execute()method. For operations other than INSERT or when executemany() is called, lastrowid is set to None.

加载拓展

Python 的 sqlite 可能没有加载任何拓展（咋想的？), 想要加载拓展，需要手动加载：

db.enable_load_extension(True)
db.load_extension("fts5")
db.enable_load_extension(False)

自定义类型

sqlite 中只包含了有限的几种数据类型，甚至连 datetime 都没有。在 Python 中可以自定义数据 类型，而且已经内置了 date 和 timestamp 两个类型的转换。

只需要在创建连接的时候指定对应的 flag, 然后在创建表的时候指定好数据类型是 date 和 timestamp 就好了，sqlite 内部使用数字存储，但是在 Python 中会自动转换。

db = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)
db.execute("create table test(d date, ts timestamp)")
today = datetime.date.today()
now = datetime.datetime.now()

db.execute("insert into test(d, ts) values (?, ?)", (today, now))
cur = db.execute("select d, ts from test")
row = cur.fetchone()
print(today, "=>", row[0], type(row[0]))
print(now, "=>", row[1], type(row[1]))

事务

默认情况下，sqlite 本身是在 autocommit 模式执行的，也就是说语句提交了就自动 commit 了。 但是在 Python 中，默认不是在 autocommit 模式下的，而且会隐式插入一条 begin 语句 开启一个事务，这样的好处是可以使用 with 语句，当抛出异常的时候直接回滚。也可以关闭这种 模式，直接使用 sqlite 自己的 autocommit 模式，这样也不用手工 commit 了或者使用 with 语句了。

# 使用事务
with db:
  for _ in range(10):
    db.execute("inset into books (name) values (1)")

# 直接 autocommit
db.isolation_level=None

备份

相当于 sqlite3 的 .backup 命令

target = sqlite3.connect("backup.db")
db.backup(target)

异常

分为两类：

sqlite3.Warning
sqlite3.Error
  - sqlite3.DatabaseError
  - sqlite3.IntegrityError
  - sqlite3.ProgrammingError
  - sqlite3.OperationalError
  - sqlite3.NotSupportedError

多线程

默认情况下，sqlite3 禁止多线程使用同一个链接，可以使用 check_same_thread 参数来控制该行为

db = sqlite3.connect("sample.db", check_same_thread=False)

不过这时候就需要自己来保证序列顺序了。

使用最新版本的 sqlite3

要想使用最新版本的 sqlite3, 要么在编译的时候已经安装了，要么就需要指定一下链接的路径。

export CFLAGS="-DSQLITE_ENABLE_FTS3 \
  -DSQLITE_ENABLE_FTS3_PARENTHESIS \
  -DSQLITE_ENABLE_FTS4 \
  -DSQLITE_ENABLE_FTS5 \
  -DSQLITE_ENABLE_JSON1 \
  -DSQLITE_ENABLE_LOAD_EXTENSION \
  -DSQLITE_ENABLE_RTREE \
  -DSQLITE_ENABLE_STAT4 \
  -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT \
  -DSQLITE_SOUNDEX \
  -DSQLITE_TEMP_STORE=3 \
  -DSQLITE_USE_URI \
  -O2 \
  -fPIC"
export PREFIX="/usr/local"
LIBS="-lm" ./configure --disable-tcl --enable-shared --enable-tempstore=always --prefix="$PREFIX"
make
sudo make install  # Install system-wide.

这时候还要在指定一下链接路径：

export LD_LIBRARY_PATH=/usr/local/lib

不过如果 prefix 直接使用了 /usr 就不需要了。

参考

1. https://docs.python.org/3/library/sqlite3.html

fork 复制的是整个进程的空间，锁也会被复制。

可能会引起问题的地方：如果在 fork 之前的进程中有锁，而且是被其他的线程持有的，那么 fork 之后的进程中，这个锁永远不会有人来释放了，导致新的进程中的线程永远处于等待锁的状态。

fork 还会把所有打开的文件，socket 等描述符都复制一份。

即使在单线程环境中，这也可能引起问题，因为两个进程可能开始争抢同一个资源。所以合理的方式 总是在新的子进程中打开资源（比如数据库），而不是打开资源之后再 fork 出子进程。

在 Python 中，multiprocessing 默认使用的是 fork, 但是还好我们可以选择使用 spawn. 参见参考 文献 3 和 4.

在 web server 和 rpc 中，多进程模式下 fork 是何时执行的呢？使用的 fork 还是 spawn? 全局 变量尤其是数据库链接会不会每次初始化？

在 RPC 服务中，有一种常见的模式，我们创建了一个 Handler 类，在脚本里面直接实例化了一个类， 在这个类的构造函数中初始化了数据库等资源的链接，然后把 my_hanlder.handle 函数交给框架来 作为入口函数，这样合理吗？

Google 的 gRPC 在这方面显然是一个反面的例子，本身他不是一个 Python 的库，内部使用了各种 奇奇怪怪的技术，在 Python 中使用的时候就遇到了各种问题，以至于没有一个很好的多进程模式。

在 web server 中，uwsgi/gunicorn 这些 process runner 又是怎样处理的呢？

• uwsgi 默认会先 load 再 fork, 这样就会有一些问题，比如全局的数据库链接等等，但是也 可以改成 fork 之后再加载。
• gunicorn 和 uwsgi 恰恰相反，默认会先 fork 再 load.

不管怎样，这两个都使用了非常简洁的 prefork 模型，而且在文档中明确说明了会采用那种模式， 非常优秀。

参考

1. https://stackoverflow.com/questions/39890363/what-happens-when-a-thread-forks/39890957
2. https://stackoverflow.com/questions/46439740/safe-to-call-multiprocessing-from-a-thread-in-python
3. 还没看完
4. 还没看完
5. https://github.com/grpc/grpc/issues/16001
6. https://eleme.github.io/blog/2016/eleme-python-soa/
7. https://uwsgi-docs.readthedocs.io/en/latest/ThingsToKnow.html
8. https://stackoverflow.com/questions/42439553/how-to-share-in-memory-resources-between-flask-methods-when-deploying-with-gunic
9. https://instagram-engineering.com/copy-on-write-friendly-python-garbage-collection-ad6ed5233ddf

在 SQLite 的新版本中已经支持了 json 函数 (json_extract)，我们完全可以把它当做一个文档 数据库使用。而且更妙的是，还可以直接添加"合成列"(generated column), 也就是使用 json 中的 字段作为虚拟的列。最牛逼的是，这些"生成列"上还可以加索引，包括 unique 索引。

之前用 MongoDB 的时候，最爽的地方就是可以随便往里面插入东西，不用纠结先创建表；最不爽的 就是加索引的语法太难记了，而且好像得先把表创建出来。另一方面，SQL 的 select 语法已经像 思想钢印一样打进了每个程序员的大脑，使用 MongoDB 的查询语法多少有些不适应。而从刚刚提到 的 sqlite 的新功能来看，sqlite 甚至比 MongoDB 用起来还能更爽一些。可以按照以下几步操作：

我们可以预先不定义表的具体结构，只留一个 body 字段：create table my_data(body text);, 有什么数据，先直接往里面插入就好了。

需要插入数据的时候，可以直接插入 json:

sqlite> insert into my_data (body) values ('{"id": 1, "text": "foo"}');
sqlite> insert into my_data (body) values ('{"id": 2, "text": "bar"}');

需要一些 ad hoc 的查询的时候，可以使用 json_extract 函数直接查询：

select json_extract(body, '$.id') from my_data;

或者可以创建一个"合成列"(generate column), 这样就可以查询了：

alter table my_data add column id int generated always as (json_extract(body, '$.id')) virtual;
select * from data where id = 2;

当然也可以在创建表的时候就加上需要的列

create table my_data(
    body text,
    id int generated always as (json_extract(body, '$.id')) virtual
);

为了个给查询加速，我们可以创建索引，合成列支持索引

create index idx_id on my_data(id);
explain query plan select id from my_data where id=1;
QUERY PLAN
--SEARCH TABLE my_data USING INDEX idx_id (id=?)

我们可以看到，查询时确实使用了索引。

如果我们在数据插入过程中发现有一些重复数据，那很简单，直接把索引改成 unique 所有就好了， 就像普通的 sql 数据库一样。

create unique index uniq_id on my_data(id);

如何验证插入的 json 是否合法呢？其实刚刚我们已经加上了，generated always 表示的是总是 生成这个字段，既然能抽取这个字段了，那么这个 json 显然是合法的。当插入一个非法的 json 的 时候就会报错。

如果要保证某个字段一定存在，那么还是用 SQL 的语法，加上一个 not null 就可以了。

sqlite> insert into x values('');
Error: malformed JSON
sqlite> insert into x values('{}');
Error: NOT NULL constraint failed: my_data.id

现在，我们来看一下 virtual 关键字。上面的 virtual 表示这个字段总是查询的时候抽取，对 应的另一种模式叫做 stored, 也就是缓存下这个字段。使用 stored 的好处是每次避免的了 json 解析的消耗，但是缺点是只能在 create table 的时候添加 stored 字段，不能使用 alter table 添加。实际上 virtual 是默认模式，也就是我们可以省略 virtual.

以上就是主要内容了，再提一些小技巧：

json 函数验证字符串是否是合法的 json, 并且返回一个压缩过后（也就是去除了无用的空格换行） 的 json. 所以可以在插入的时候使用 json 函数过滤一下文档。

参考

1. https://dgl.cx/2020/06/sqlite-json-support
2. https://www.sqlite.org/gencol.html
3. https://www.sqlite.org/json1.html

• 构建 C 工程
• 运行具有依赖关系的任务

而由于 make 的时代太过久远，导致现在用起来会有几个坑爹之处：

• 声明变量语法奇怪
• 每次都加 .PHONY 很麻烦
• 配置 SHELL 也很反直觉
• 多行命令不在同一个 shell 中运行
• 必须用 \t 缩进

另一方面，我也只需要运行任务的功能，并不需要编译 c 代码这部分功能。所以就想找一个现代版的 任务执行工具。

Just

Justfile 的语法和 Makefile 基本类似，下面是主要功能的介绍

# 加载 .env 文件
set dotenv-load  #
# 所有变量导出为环境变量，在下面的任务中使用
set export
# 指定 shell
set shell := ["fish", "-c"]

# 变量
tmpdir := `mktemp`  # 读取 shell 命令的结果
version := "0.1"    # 字符串变量
# 使用 / 可以直接组合路径，相当于 a + "/" + "b"
# 使用 + 可以连接字符串
tarball := tmpdir / "awesome" + version + ".tar.gz"
# 直接使用 export 也可以导出环境变量
export http_proxy := localhost:8080

# 函数
# 使用 env_var 函数读取外部环境变量
home_dir := env_var('HOME')
# justfile_directory 读取 justfile 所在路径
# 其他的函数还有 lower_case/trim/uppercase/extension/uuid 等

# 多行字符串
long_string := 'very
long
string
'

# alias
alias b:= build

# 依赖按照顺序执行
all: lint test build

# 命令按照顺序执行，如果一个失败，下一个不会执行
publish:
    # 使用双大括号表示变量
    rm -rf {{tarball}}
    tar cvzf {{tarball}}
    # 用前缀可以忽略该行命令的错误
    -curl -X POST {{tarball}} {{endpoint}}

# 每一行都是一个新的 shell，所以直接 cd 是没用的
foo:
    pwd    # This `pwd` will print the same directory…
    cd bar
    pwd    # …as this `pwd`!

# 不过添加 shebang 之后，就会当作一整个脚本执行
foo:
    #!/usr/bin/env bash
    set -euxo pipefail
    cd bar
    pwd

# 还可以使用 shell 之外的语言！
python:
    #!/usr/bin/env python3
    print("hello world")

echo_home:
    # 可以直接读取外部环境变量
    echo "Home is ${HOME}"

build:
    cargo build

lint:
    cargo lint

# 使用 @ 做前缀可以不打印命令本身
clean:
    @rm -rf build/

使用 just -l 可以按字母顺序列出所有任务，使用 just -u/--unsorted 可以按定义顺序列出，更秒 的是，任务上方的注释也会一并列出。

变量可以在调用的时候重载：

just name=value
just --set name value

just 命令会向上查找到包含 justfile 根目录，就像 git 一样，所以可以在子目录中运行 just.

Just 的缺点

just 不支持按照文件的修改日期来构建项目，也就是说很多时候都要从头构建，这样可用度就大幅 降低了。如果这点也支持的话，真的可以迁移到 just 了。

参考

1. https://github.com/go-task/task
2. https://github.com/casey/just

# 名字
name: hello-world-example
# 环境变量
env:
  FOO: bar
# 触发条件
on:
  # 最常用的是 push 条件，如果留空，表示每次 push 都执行。
  # 任意满足这里列出的一个条件即会匹配。也就是 master 或者 v tag 都会执行。
  push:
    # 表示在这些分支推送的时候执行
    branches:
      - master
      - feature/*
    # 在这些 tag 推送的时候执行
    tags:
      - v*
  # 在有人提交 PR 时运行
  pull_request:
    branches:
      - master
  # 定时运行
  schedule:
    - cron: '*/15 * * * *'
# 要运行的任务
jobs:
  # 任务名字
  say-hello:
    # 也可以在这里设置环境变量
    env:
      FOO: bar
    # 运行环境
    runs-on: ubuntu-latest
    steps:
      # 可以使用一些现成的操作，比如 checkout 当前仓库
      - uses: actions/checkout@v2
      # 安装 node
      - uses: actions/setup-node@v1
        # actions 的参数
        with:
          node-version: '15.8.0'
      - name: Say Hello
        env:
          FOO: bar
        run: echo "Hello $FOO"
      - name: Do stuff
        run: |
          echo "Step 1..."
          echo "Step 2..."
          echo "Step 3..."
      - name: Say Goodbye
        run: echo "Goodbye!"
  # 任务之间默认是并发执行的
  another-job:
    # 依赖另一个 job
    needs: say-hello
    strategy:
      # CI 的常见应用是在不同的环境下测试，使用 matrix 来定义一组环境
      matrix:
        os: [ubuntu-16.04, ubuntu-18.04]
        node: [16, 18, 20]
        # 排除掉某个环境
        exclude:
          - os: ubuntu-16.04
            node: 16
        # 额外包含某个环境
        include:
          - os: macos-latest
            node: 16
    # 使用变量
    runs-on: ${{matrix.os}}
    steps:
      # 读取密钥
      - name: use secrets
        run: echo ${{secrets.ACCESS_KEY}}
      # 条件执行
      - name: Run only for pulls
        if: ${{ github.event == 'pull'}}
        run: echo pulling

常见问题

如何调试？

可以使用 tmate ssh 进机器，查看情况

name: CI
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Setup tmate session
      uses: mxschmitt/action-tmate@v3

Windows 上遇到 OOM 问题

调大虚拟内存（PageFile）就行了

- name: configure Pagefile
  uses: al-cheb/configure-pagefile-action@v1.2
  with:
      minimum-size: 16GB
      maximum-size: 16GB
      disk-root: "C:"

References

1. https://www.actionsbyexample.com
2. https://github.com/marketplace/actions/debugging-with-tmate
3. https://github.com/actions/runner-images/issues/2642

# views/users.py
from fastapi import APIRouter

router = APIRouter()

@router.get("/me")
def myinfo():
    ...

# main.py
from fastapi import FastAPI
from views import users

app = FastAPI()

app.include_router(users.router, prefix="/users")

文件组织

模块化之后，自然需要考虑文件是怎么组织的。一般情况下，我会这么做：

|-- app.py
|-- views/
|   |-- __init__.py
|   |-- users.py
|   |-- tasks.py
|-- depends/
|   |-- __init__.py
|   |-- db.py
|   |-- users.py
|-- sql/
|   |-- __init__.py
|   |-- users.py
+-- schemas/
    |-- __init__.py
    |-- users.py

其中 app.py 存放 app实例，views 存放对应的 routers 文件，sql 存放 sqlalchemy 模型文件， schemas 存放对应的 pydantic 类型文件，depends 存放一些依赖文件，后面的章节会讲到。

一些文件的代码如下：

app.py

from fastapi import FastAPI
from views import users, tasks, ...

app = FastAPI()
app.include_router(users.router, prefix="/users", tags=["User"])
app.include_router(tasks.router, prefix="/tasks", tags=["Task"])

views/users.py

from fastapi import APIRouter
from pydantic import BaseModel
from schemas import UserModel

router = APIRouter()

class UserListOut(BaseModel):
    users: list[UserModel]

@router.get("", response_model=UserListOut)
def list_users():
    ...

@router.get("/{user_id}", response_model=UserModel)
def get_user(user_id: int):
    ...

sql/users.py

from sqlalchemy import Boolean, Text, String, Column
from sqlalchemy.orm import declarative_base

Base = declarative_base()

class UserTable(Base):
    __tablename__ = "users"
    # 如果不是 sqlite，请使用 BIGINT
    id = Column(Integer, autoincrement=True, primary_key=True)
    ...

schemas/users.py

from pydantic import BaseModel

class UserModel(BaseModel):
    id: int
    ...

    class Config:
        orm_mode = True

depends/db.py

def dep_db():
    db: Session = SessionLocal()
    try:
        yield db
    except Exception:
        db.rollback()
        raise
    finally:
        db.close()

还有一个更搞笑的说法，说什么创业公司最大的财富都是在最后一个阶段产生的，所以任何时候上车 都不晚，实际上这纯属扯淡。你在第一年加入，以后可能是一万倍的收益，而在最后一年可能只有十 倍的收益。冒着猝死的风险，只博最后一点收益，喝一点别人的残羹冷炙，实在不值得的。

下面讲点实际的缺点：

精益创业的弊端

所谓的精益创业，小步迭代不一定能产生预期的结果：

• 在小范围试验可行的产品不一定能推广到更大的市场。
• 容易自我洗脑并陶醉，逐渐优化到一个自嗨的市场。
• 天天改需求，而不产生最终产品，甚至自以为是快速迭代。

小公司的沟通效率反而是低下的

原因大概有几方面：

其一是水平不足。很简单的技术选型问题，在大公司可能使用业界主流做法就很好了，着实没有讨论 的必要，马上执行即可。然而在小公司，可能因为水平不足，需要反复沟通和普及一些基础知识， 甚至需要反复确认主流方案是不是业界最佳实践。

其二是政治原因。不要以为只有在大公司才有办公室政治，小公司同样会有，所谓：庙小妖风大， 池浅王八多是也。融资、重组、股权分配都可能带来派系的纷争。

其三是流程不规范。大公司标准化的流程虽然会扼杀一部分创新，但是也尤其强大之处。由于流程 已经固定，就可以把注意力全都放在具体要解决的事情上。而在小公司，由于还没有固定的沟通流程， 在交流之中，每个人可能都有不同的预期，导致精力耗散在了扯皮之中，而不是具体业务。

小公司技术可能很乱

举些亲身经历的例子：

1. 数据库表中没有 id 字段。数据库要加 id 字段就像每天要吃饭一样天经地义吧...
2. 拼音变量名。不是难以表达的业务术语，而是有精确惯用词的普通变量。
3. 代码没有打印任何日志。这怎么 debug？
4. if xxx == False 这种代码都很常见...

为了快速迭代，当然可以上一些快糙猛的的方式，但是以上代码早已超出了可以容忍的技术债范围。

小公司的个人成长

小公司并不是更快的成长之路。在小公司因为各种基础设施都没有，所以你可能需要建设的是一些没 有实际意义的 trivial 的烦事，以至于无法陷入深入思考之中。人的成长最好是“十”字形的人才， 根深才能叶茂，在某一方面有深厚的内功是很重要的。

而在大公司，也不一定是螺丝钉，相反更可能是站在巨人的肩膀上，在更高的平台做更有挑战的事儿。

另外，你本身的能力很有可能高于岗位要求，降薪做一些技术能力无法成长的事情。退回了工作两年 时候做的事情，基本上都是繁琐的业务研发，已经完全没有什么所谓的技术问题了

无论是在金钱上、时间上，创业都是一种巨大的投入，还冒着高度的失败风险，很可能让人患得患失。

公司自身的成长挑战

并不是每一个公司都能够指数增长，大多数的创业公司都会遭遇成长瓶颈。

期权并不值那么多钱，要考虑到货币的时间价值，以及最后老板稀释期权的风险，还有交给国家的 45% 的个税等等。

即使开始时很顺利，还要面临的一个风险是：创始团队的成长赶不上公司的成长。管理 1000 个人和 管理 20 个人需要的是完全不一样的技能。

另一个不易察觉的事实是，有不少公司，尤其是 SaaS，其实是在假装创业罢了，实质上就是小型的 「技术外包」公司罢了，不要被光鲜的外表蒙蔽了。

脉脉上的总结

以下这几点缺陷是从脉脉上看到的，个人认为总结的也挺好。

1. 公司管理体系不完善，福利惨淡，工作界限不明晰
2. 一人多用，没有话语权，过分强调 KPI
3. 形式化严重，工作流程复杂，沟通成本高，人员流动频繁
4. 公司实力不足，资源有限，盈利模式单一，融资困难
5. 公司用人疑心重，不放权，中层不作为
6. 人少，无流程无规章，老板说了算，想一出是一出

什么样的创业公司才靠谱呢？

谈了这么多不靠谱的地方，那么什么的公司才值得加入呢？我认为符合 Sam Altman 在 How to start a startup 课程中描述的公司大概才是靠谱的。如果你不知道 Sam Altman 和 YC，那就更想都别想 创业这件事了，先去了解一下吧～

最后，阅读本文纯属浪费时间，因为本文探讨的这些问题在可预见的未来都不存在了。由于北京当局 出台的《反间谍法》《App 备案》等等各种法律法规，实际上相当于完全抹杀了互联网行业创业的 任何可能，再加上拜登政府不失时机颁布的禁止美国 VC 投资中国高科技行业法案，更是雪上加霜。 还想创业的话，只有一个途径了：

润。

参考

1. https://news.ycombinator.com/item?id=21868022
2. https://blog.harrison.dev/2018/11/25/twenty-questions-to-ask-before-joining-a-startup.html
3. https://www.1point3acres.com/bbs/thread-757861-1-1.html

TLS 指纹

首先来回顾一下什么是 TLS 指纹。如果已经了解，可以直接跳到后边的 curl_cffi 部分。

现在绝大多数的网站都已经使用了 HTTPS，要建立 HTTPS 链接，服务器和客户端之间首先要进行 TLS 握手，在握手过程中交换双方支持的 TLS 版本，加密算法等信息。不同的客户端之间的差异 很大，而且一般这些信息还都是稳定的，所以服务端就可以根据 TLS 的握手信息来作为特征，识别 一个请求是普通的用户浏览器访问，还是来自 Python 脚本等的自动化访问。

JA3 是生成 TLS 指纹的一个常用算法。它的工作原理也很简单，大概就是把以上特征拼接并求 md5。

有证据表明，阿里云、华为云、Akamai 和 Cloudflare 都在使用 TLS 指纹技术来识别机器访问流量。 Akamai 更是直接在宣传稿中说明了在通过 TLS 指纹技术检测非法请求。

在真正发现 Cipher Stunting 之前，Akamai 观察到的 TLS 指纹大概有数万个。在初步发现后不久， TLS 指纹数量激增至数百万，最近跃升至数十亿。 https://www.akamai.com/blog/security/bots-tampering-with-tls-to-avoid-detection

查看 tls 指纹的网站有：

• https://tls.browserleaks.com/json
• https://tls.peet.ws/
• https://kawayiyi.com/tls

不同网站的生成的指纹可能有差异，但是多次访问同一个网站生成的指纹是稳定的，而且能区分开 不同客户端。下文以第一个网站为例。

浏览器的指纹：53ff64ddf993ca882b70e1c82af5da49

httpx 的指纹：44423a0e34badcd72364f09ff481fcc9

Python 3.10.9 (main, Jan 11 2023, 15:21:40) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import httpx
>>> r = httpx.get("https://tls.browserleaks.com/json")
>>> r.json()
{'ja3_hash': '44423a0e34badcd72364f09ff481fcc9', 'ja3_text': '772,4866

curl 的指纹：0ef95c8302480557fbc3cd8a7c87973c

$ curl --version

curl 7.81.0 (x86_64-pc-linux-gnu) libcurl/7.81.0 OpenSSL/3.0.2 zlib/1.2.11 brotli/1.0.9 zstd/1.4.8 libidn2/2.3.2 libpsl/0.21.0 (+libidn2/2.3.2) libssh/0.9.6/openssl/zlib nghttp2/1.43.0 librtmp/2.3 OpenLDAP/2.5.11
Release-Date: 2022-01-05
Protocols: dict file ftp ftps gopher gophers http https imap imaps ldap ldaps mqtt pop3 pop3s rtmp rtsp scp sftp smb smbs smtp smtps telnet tftp 
Features: alt-svc AsynchDNS brotli GSS-API HSTS HTTP2 HTTPS-proxy IDN IPv6 Kerberos Largefile libz NTLM NTLM_WB PSL SPNEGO SSL TLS-SRP UnixSockets zstd

$ curl https://tls.browserleaks.com/json

{"ja3_hash":"0ef95c8302480557fbc3cd8a7c87973c","ja3_text":"772,4866-4867-4865

可以看到，每个客户端的指纹都是不一致的，服务端也就可以据此防御异常流量。显然，防御等级分 两个层次。

非法指纹黑名单

这个思路很直接，把常用的爬虫工具的指纹收集起来，然后全都屏蔽了就好了。比如说：curl, requests, golang 访问时，直接 403。当然，突破也很简单，别用默认的指纹，直接随便改一下 tls hello 包的值就行了。

比如，修改 httpx 的 TLS 协议。以 httpx 为例:

# 默认 cipher 在这里定义：https://github.com/encode/httpx/blob/master/httpx/_config.py
import ssl
import httpx

# create an ssl context
ssl_context = ssl.SSLContext(protocol=ssl.PROTOCOL_TLS)
CIPHERS = 'ECDH+AESGCM:ECDH+CHACHA20:DH+AESGCM:DH+CHACHA20:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+HIGH:DH+HIGH:RSA+AESGCM:RSA+AES:RSA+HIGH'
ssl_context.set_ciphers(CIPHERS)

r = httpx.get('https://tls.browserleaks.com/json', verify=ssl_context)
print(r.json())

# {'ja3_hash': 'cc8fc04d55d8c9c318409384eee468b6'

可以看到 JA3 指纹已经变了。

合法指纹白名单

既然指纹可以随便改，那就直接只认常用浏览器的指纹好了。这时候如果爬虫或者其他脚本再想要 突破防御，需要把每一个值都改成和浏览器都完全相同，难度还是挺大的。尤其是考虑到大多数 语言的标准库都是直接使用系统的 SSL 库，很多底层的东西直接没提供接口，所以这种防御还是非常 有效的。

例如，Python 使用了 OpenSSL，而 Chrome 则使用了 BoringSSL，这两者的细节差异很多。所以， 纯 Python 的库，比如 requests 和 httpx，再怎么改也不可能改成和 Chrome 一样的指纹，必须 使用第三方的 C 扩展库，才能够实现完美模拟浏览器指纹。

此外，还又一个小细节，可以由 TLS 指纹反推出客户端是从哪些操作系统或者软件来的，如果和 User-Agent 互相矛盾，那也说明有问题。不过实际中，我还没有遇到这种情况。

curl_cffi

为了完美模拟浏览器，国外有大佬给 curl 打了一些 patch，把相应组件全部都替换成了浏览器使用 库，连版本都保持一致，这样就得到了和浏览器完全一样的指纹，这个库是：curl-impersonate

Python 中早就有 curl 的 binding -- pycurl，但是非常难用，安装的时候总是出现编译错误；接口 也很低级，相比 requests，甚至 urllib，用起来都比较费劲。curl-impersonate 的作者提出使用 环境变量 + 替换 libcurl 来在不同语言中使用 curl-impersonate，但是似乎 pycurl 没法工作。 于是乎，我直接另起炉灶，写了一个 curl(-impersonate) 的 Python binding.

相比 pycurl，有以下优点：

• 原生支持 curl-impersonate
• pip install 直接是二进制包，无需编译，也就不会有编译错误
• 提供了一个简单的 requests-like 接口

废话少说，看代码吧！

pip install curl_cffi

使用起来也很简单

from curl_cffi import requests

# 注意这个 impersonate 参数，指定了模拟哪个浏览器
r = requests.get("https://tls.browserleaks.com/json", impersonate="chrome101")

print(r.json())
# output: {'ja3_hash': '53ff64ddf993ca882b70e1c82af5da49'

我们可以看到，输出的 JA3 指纹和浏览器中的指纹一模一样！

代理也支持：

>>> proxies={"http": "http://localhost:7777", "https": "http://localhost:7777"}

>>> r = requests.get("http://baidu.com", 
        proxies=proxies,
        allow_redirects=False,
        impersonate="chrome101"
    )
>>> r.text
'<html>\r\n<head><title>302 Found</title></head>\r\n<body bgcolor="white">\r\n<center><h1>302 Found</h1></center>\r\n<hr><center>bfe/1.0.8.18</center>\r\n</body>\r\n</html>\r\n'
>>> r = requests.get("https://tls.browserleaks.com/json",
        proxies=proxies,
        impersonate="chrome101"
    )
>>> r.json()
{'ja3_hash': '53ff64ddf993ca882b70e1c82af5da49'

同样的功能，也可以用底层一点的 Curl 对象：

from curl_cffi import Curl, CurlOpt
from io import BytesIO

buffer = BytesIO()
c = Curl()
c.setopt(CurlOpt.URL, b'https://tls.browserleaks.com/json')
c.setopt(CurlOpt.WRITEDATA, buffer)

c.impersonate("chrome101")

c.perform()
c.close()
body = buffer.getvalue()
print(body.decode())

仓库在这里：https://github.com/yifeikong/curl_cffi

其他指纹技术概览

1. HTTP Header 指纹。通过浏览器发送的 header 的顺序和值的组合来判断是合法用户还是爬虫
2. DNS 指纹。参考：http://dnscookie.com
3. 浏览器指纹。通过 canvas，webgl 等计算得到一个唯一指纹，Cookie 禁用时监视用户的主流技术
4. TCP 指纹。也是根据 TCP 的一些窗口、拥塞控制等参数嗅探、猜测用户的系统版本

总结一下，指纹技术就是通过不同的设备和客户端在参数上的微妙差异来识别用户。本来按照规范， 这些值都是应该任意选取的，但是，现实世界中，服务端反而对不同值采取了区别对待。指纹技术 可以说应用到了 OSI 网络模型中所有可能的层，基于 HTTP header 顺序的指纹工作在第七层应用层， SSL/TLS 指纹工作在传输层和应用层之间，TCP 指纹在第四层传输层。而在 TCP 之下的 IP 层和物理 层，因为建立的不是端到端的链路，所以只能收集上一跳的指纹，没有任何意义。

对于爬虫来说，User-Agent 相当于自报门户。除了初学者以外，没有人会顶着 Python/3.9 requests 这样的 UA 去爬的，而指纹则是很难更改的内部特征。通过指纹技术可以防御一大批爬虫，而使用 能够模拟指纹的 http client 则轻松突破这道防线。

对于普通用户来说，各种指纹造成了极大的隐私泄露风险。即使按照 GDPR 等监管政策的要求，用户 拒绝使用 Cookie 时，互联网公司依然可以通过各种指纹来定位追踪用户，乃至于区别对待。平等、 匿名、自由地使用个人数据和公开数据应该是一项基本人权。在立法赶不上技术更新的时代，我们 应该用技术手段捍卫自己的权利。

参考

科普

1. 2020 - JA3 的一篇科普
2. 又一篇 JA3 的介绍
3. 什么是 C2 架构
4. 操作系统识别工具 xprobe2 p0f 简介
5. p0f - 被动探测操作系统工具
6. Browser fingerprints: the basics and protection options

案例

1. 2019 - Akamai 检测到随机化 TLS 指纹突破 WAF
2. 2021 - V 站网友遇到 Cloudflare 指纹检测
3. 2021 - 为什么随机 IP、随机 UA 也逃不掉被反爬虫的命运
4. 2021 - Python Requests 会被阿里云识别 TLS 特征
5. 2020 - Requests being fingerprinted
6. https://security.stackexchange.com/questions/236947/how-to-spoof-ja3-signature
7. 如何更改 Requests 的 TLS 选项
8. 2019 - Reddit discussion on SSL/TLS Fingerprinting
9. Adwords 会检查 TCP 指纹
10. https://stackoverflow.com/questions/30787664/can-servers-use-http-headers-order-to-catch-a-browser-signature
11. TCP 指纹甚至可以用来识别 V2R
12. SSL 指纹识别和绕过

工具

1. 查看自己的浏览器指纹
2. JA3 指纹数据库
3. 查看自己 IP 泄露的信息，包括 TCP 指纹
4. 查看浏览器指纹
5. utls
6. 查看各种指纹
7. DNS Cookie

原始研究

1. 2016 - TLS Fingerprinting - a method for identifying a TLS client without decrypting
2. JA3 的原始文章
3. JA3 GitHub
4. p0f3 - OS fingerprinting
5. p0f3 应用
6. TCP 指纹
7. https://en.wikipedia.org/wiki/Device_fingerprint
8. https://sansec.io/research/http-header-order-is-important
9. 一篇非常全的指纹综述

伪装

1. Golang 伪装 JA3 指纹的例子
2. 又一篇伪装 JA3 指纹的例子
3. 在 Requests 中伪造 TLS 的一个例子
4. Go ja3transport
5. httpx header order
6. golang header order
7. 用 Cloudflare worker 突破 Cloudflare 反爬

应用

1. 专门做客户端指纹的公司
2. Cloudflare MITMEngine - Malcolm 背后算法
3. Cloudflare malcolm
4. Incapsula WAF 使用 http header 顺序作为指纹

其他

1. 苏联笑话
2. https://github.com/niespodd/browser-fingerprinting
3. https://github.com/JonasCz/How-To-Prevent-Scraping
4. https://www.scrapingbee.com/blog/web-scraping-without-getting-blocked/
5. https://incolumitas.com/2021/03/13/tcp-ip-fingerprinting-for-vpn-and-proxy-detection/
6. https://incolumitas.com/2021/05/20/avoid-puppeteer-and-playwright-for-scraping/
7. https://fingerprintjs.com/blog/disabling-javascript-wont-stop-fingerprinting/
8. https://news.ycombinator.com/item?id=30237846
9. https://news.ycombinator.com/item?id=29060272
10. https://news.ycombinator.com/item?id=29117022
11. https://news.ycombinator.com/item?id=28827509

在我刚接触 React 时，看到的教程一般都推荐 redux，在经历过无数次的尝试之后，我发现以我的 智商理解不了 redux 神奇的设计，也接受不了 redux 冗长的 boilerplate 代码。不过幸运的是， 有了 React 内置的 useReducer + useContext，完全可以不用 redux。

useReducer

首先来开下 useReducer 的 API.

const [state, dispatch] = useReducer(reducerFn, initialState [, init]);

useReducer 通常放在一组状态的根元素层级，如一个页面。dispatch 函数触发事件，reducer 函数用来处理事件，更新 state.

当单独使用 reducer 的时候，其实就相当于一个高级的 useState，dispatch 写起来要比 setState 更清晰一些。

const initialState = {count: 0};

function reducer(state, action) {
  switch (action.type) {
    case 'increment':
      return {...state, count: state.count + 1};
    case 'decrement':
      return {...state, count: state.count - 1};
    default:
      throw new Error(`action type ${action.type} not found`);
  }
}

function Counter() {
  const [state, dispatch] = useReducer(reducer, initialState);
  return (
    <>
      Count: {state.count}
      <button onClick={() => dispatch({type: 'decrement'})}>-</button>
      <button onClick={() => dispatch({type: 'increment'})}>+</button>
    </>
  );
}

useReducer 的 reducer 函数和 redux 不同，不需要 state=initialState 参数。 默认参数在调用 useReducer 的时候已经给出了。

Context API

Context 用来向所有后代元素广播状态，可以跳跃组件树层级，而不需要层层传递。

1. 首先需要通过 React.createContext 定义一个高层次 Context
2. 然后在最外层使用 <MyContext.Provider /> 来包裹需要接受这个 context 的所有组件
3. 在需要使用状态的元素中调用 <MyContext.Consumer />, 访问 Context 中的值

例子：

const AppContext = createContext()

function App({children}) {
  return <AppContext.Provider value={42}>
    {children}
  </AppContext.Provider>
}

function Page() {
  return <AppContext.Consumer>
    <span>{value}</span>
  </AppContext.Consumer>
}

useContext

除了使用使用 <Consumer/> 以外，还可以使用 useContext 钩子来读取 Context 中的值。这样就 不用额外再嵌套一层 Consumer 了。

function Page() {
  // 注意这里的参数是 Context
  const value = useContext(AppContext);
  return <span>{value}</span>;
}

组合起来

用 Context.Provider 把 state 和 dispatch 这两个变量广播给所有元素，这样每个组件都可以使用 useContext(Context) 访问到 state 和 dispatch 和两个函数，从而可以使用或者更新全局状态。 也就实现了 redux 的核心功能。

首先定义 store.js

import React, { useContext, useReducer } from 'react';

// 初始状态
const initialState = {
  user: { name: "", },
  sidebar: { showToolbox: false, }
};

// 用来组合不同的 reducer
function combineReducers(reducers) {
  return function(state, action) {
    const newState = {};
    for (let key in reducers)
      newState[key] = reducers[key](state[key], action);
    return newState;
  }
}

// 处理用户状态的 reducer
function userReducer(state, action) {
  switch (action.type) {
    case "user.updateName":
      return { ...state, name: action.data.name }
    default:
      return state;
  }
}

// 处理 sidebar 的 reducer
function sidebarReducer(state, action) {
  switch (action.type) {
    case "sidebar.toggleToolbox":
      return { ...state, showToolbox: !state.showToolbox }
    default:
      return state;
  }
}

// 组合起来
const reducer = combineReducers({
  user: userReducer,
  ui: uiReducer,
})

const Context = createContext(initialState)

export function Store({ children }) {
  // useReducer 实际上只在这里调用了一次
  const [state, dispatch] = useReducer(reducer, initialState);
  // 把 state 和 dispatch 传递给所有元素
  return <Context.Provider value={[state, dispatch]}> {children} </Context.Provider>
}

// 自定义钩子 useStore 调用 useContext，读取 state 和 dispatch
export function useStore() { return useContext(Context); }

在 app.js 或者 index.js 中用 Context.Provider 包裹所有元素。

import {Store, useStore} from "./store.js"

export default function App({children}) {
    return <Store>{children}</Store>
}

在组件中就可以使用 state 和 dispatch 和其他组件通信了。

// page.js
import {useStore} from './store'

export default function Page() {
    const [state, dispatch] = useStore()
    return <>
        <p>Hello, {state.user.name}</p>
        <SomeComponent />
    </>
}

// some-component.js
export default function SomeComponent() {
    const [state, dispatch] = useStore()
    return <>
        <button
            onClick={dispatch({type: "user.updateName", data: {name: "Sheldon"})}
        >Login</button>
    </>
}

怎么请求数据？redux-thunk 呢？

看到这里你可能会问，useReducer 看起来不错，那怎么实现 redux-thunk 这种数据请求功能呢？

我的回答可能有些争议——不要实现 redux-thunk 的功能，用 swr 或者 ReactQuery 来请求数据。

UI 状态和数据状态是两个东西，然而人们总是把这两个东西混淆在一起。Redux 等工具实际上是 一个 UI 状态工具，但是人们总用它（通过 thunk) 来请求数据，这是错误的。

在 Redux 等工具的 readme 中一般都是提供的 Counter 或者 TODO list 这个 demo, 这是非常误导 人的，因为这两个 demo 只是本地的 UI 状态管理。到了实际使用的过程中，大多数状态是数据状态， 需要使用 thunk 等 middleware 来获取后端数据并管理，非常丑陋。

UI 状态指的是前端的一些状态，比如说是否使用暗黑模式，某个状态栏是否显示等等，和后端的 数据库无关。数据状态指的是从后端数据库中加载的一些数据，比如说用户名，当前的文章，评论 等等。如果前端进行了更新，也需要写回到后端数据库中。

• 对于 UI 状态管理来说，redux, mobx, 甚至包括 useReducer 等工具都是非常合适的，但是他们 真的不是数据状态管理工具。
• 对于服务端数据的获取和缓存，需要使用单独的网络请求工具，而不是所谓的状态管理工具， useSWR 和 ReactQuery 是非常适合的工具。

按照前面的划分，实际上 SWR 也算一个（隐式）状态管理工具，它相当于使用了 API 的路径作为了 key, 然后把整个状态存储到了一个类似 kv 字典的结构当中。

一旦把 UI 状态和（后端）数据状态这两个概念分清了，那么解决起来就一下子开朗了。我们可以 使用 useReducer 管理前端程序自身的状态，而获取数据都通过 SWR 来实现。

关于 swr，可以参考我的另一篇文章：SWR 才是真正的数据状态管理工具

1. 明确最小单元，以及单元的功能点都有哪些。如果在写代码之前都没有明确功能有哪些，或者编写 功能已经跑偏了，那么测试究竟测些什么呢？
2. 确定方案能够解决问题，然后再写测试，否则是徒劳的。

编写测试的基本原则

• 每一个测试单元必须完全独立。每一个必须能够独立运行，以及在其他的测试组中组合运行，不管 他们的顺序如何。加载和清空数据应该使用 setup() 和 teardown() 方法。
• Sans-IO。也就是把逻辑和 IO 分开来，这样在测试的时候方便指定输入，以及捕获输出。
• 尽量让测试跑的快一点。如果一个测试在几毫秒之内跑不完的话，开发就会慢下来，以至于没有人 再去跑这些测试了。如果实在有很耗费时间的测试，把他们单独放在一起定期执行。
• 使用有描述性的长名字。实际代码中你可能使用 square() 这样的名字，但是在测试用你要用 test_square_of_number_2 这样的名字。
• 如果你在开发某样东西的过程中被打断，可以写一个测试，这样当你回过头来的时候还能很快想 起来需要做什么。
• 测试代码的另一个用途是作为新手的介绍。让别人来看你的代码的时候，看看测试就知道代码是干 什么的了。

如何测试包含 IO 的函数

1. 使用依赖注入；
2. 把 IO 操作放在单独的地方，在测试的时候 mock 这个类或者方法；
3. 在 pytest 中还可以使用 fixture 提供依赖；
4. 搭建一个测试用的数据库等服务器。

IO 依赖主要包括依赖文件和外部数据库。对于依赖文件名作为参数的函数，甚至可以认为是一个非常 差的实践。而且根据单一职责原则，一个方法也不应该做两件事，要么做计算，要么做 IO, 而接受 文件名作为参数就隐含了既要负责打开文件，又要负责处理文件中的数据。

但是不用文件名的话，有时候对于用户来说又不是很方便。建议把分成两个函数，一个只做计算， 另一个既打开文件，又做计算。

虽然使用 mock 的方式可能会提高速度或者更方便一些，但是这样的话又可能和实际生产环境的差异 过大，而且 mock 库也不是那么好找的。

编写测试的思路

从软件可靠性的角度，测试当然是越完备越好，但是不是每一个软件都是核弹控制器，还是要根据 实际情况折中一下。

追求功能测试

只需要按照功能点，把正常和常见的异常情况测试一下就好了。重点还是要先明确功能点有哪些。

追求 100% 覆盖度

按照代码逻辑分支测试，把代码的每一个分支的

1. 入口参数是什么
2. 出口参数是什么
3. 副作用是什么
4. 产生的异常是什么

都测试到。

测试的粒度

在每个 endpoint 上做集成测试。

不要过度测试。给门添加第二把锁会让门更安全一点，但是添加一百道锁并没有任何用，和两把锁是 一样的。加一百把锁的话，抢劫犯可能直接破门而入或者选择走窗户了。但是一百把锁反倒会让主人 进入更加复杂。单元测试也是同样的道理，不可或缺，但是要适可而止。

所以，总的来说，应该添加单元测试，但是要确保：

1. 单元测试提供了价值，
2. 单元测试比集成测试更适合这件事。

References

1. https://tyrrrz.me/blog/unit-testing-is-overrated

获取各种资源列表：

# -o 指定范围格式，`-o wide` 用来显示更详细信息
kubectl get node/pod/deploy/node/svc -o wide/yaml/name

描述详细信息：

# -n 指定命名空间
kubectl describe node/pod/deploy/svc

其他一些操作

# 显示当前节点的一些信息
kubectl top node/pod
# 本地 5000 端口转发到 pod 6000
kubectl port-forward my-pod 5000:6000
# 编辑 kubernetes 的配置文件
kubectl edit deployment/my-nginx

资源名称缩写

kubectl create & apply

用来创建或更新资源，使用 -f 参数来制定配置文件。实际使用中，几乎不会用到 create。

kubectl apply -f file.yml

kubectl delete

用来删除节点上的 pod, deployment 等信息

kubectl run

类似于 docker run, 但是由 kubernetes 接管，直接运行在集群上。比如运行 hello world

kubectl logs

类似于 docker logs, 用来显示打印到 stdout 的日志

复制文件

可以复制文件到 Pod 中。

kubectl cp -h

port-forward 临时访问集群中的服务

例如：

k port-forward svc/elasticsearch 9200:9200

把集群中 elasticsearch 服务映射到本地 9200 端口，非常方便测试。

列出当前集群的 API version

kubectl api-resources # List the API resources that are available.
kubectl api-versions  # List the API versions that are available.

for kind in `kubectl api-resources | tail +2 | awk '{ print $1 }'`; do
    kubectl explain $kind;
done | grep -e "KIND:" -e "VERSION:"

重启一个服务

kubectl rollout restart deployment <name>

进入 pod 的 shell

kubectl exec -it POD-NAME -n NAMESPACE -- bash

代理

使用代理可能会带来一些问题，一定要把集群内的地址设置为不用代理：

https://github.com/jetstack/cert-manager/issues/2640

切换集群

kubernetes 支持在一个配置文件中存储多个集群的配置，并且可以使用 kubectl config 切换。

如果多个集群分散在不同文件中，首先我们需要合并一下这些文件：

# 把所有文件都加到 KUBECONFIG 路径中
export KUBECONFIG=/path/to/conf1:/path/to/conf2...
# 合并
kubectl config view --flatten > $HOME/.kube/all-in-one-kubeconfig.yaml
# 验证下是否可用
kubectl config get-contexts --kubeconfig=$HOME/.kube/all-in-one-kubeconfig.yaml
# 把合并后的文件放到默认位置
mv $HOME/.kube/all-in-one-kubeconfig.yaml $HOME/.kube/config
export KUBECONFIG=

列出当前的 contexts

$ k config get-contexts

CURRENT   NAME              CLUSTER           AUTHINFO          NAMESPACE
*         docker-desktop    docker-desktop    docker-desktop
          rancher-desktop   rancher-desktop   rancher-desktop
          us-east-1a        us-east-1a        us-east-1a

切换 context

$ k config use-context rancher-desktop
Switched to context "rancher-desktop".

删除 context

$ k config delete-context rancher-desktop
warning: this removed your active context, use "kubectl config use-context" to select a different one
deleted context rancher-desktop from /Users/yifei/.kube/config

重命名 context

k config rename-context OLD NEW

参考

1. https://akhilsharma.work/kubectl-get-resource-short-names/
2. https://kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster/
3. https://blog.pipetail.io/posts/2020-05-04-most-common-mistakes-k8s/
4. https://stackoverflow.com/a/52711746/1061155

我们知道一个病毒的传播能力可以用 R0 来表示，即每个患者传染的新患者的数量。我们又知道，社会上除了占大多数的遵纪守法好公民，还有目无法纪的奸商、涣散烂漫的小市民和一小撮玩忽职守的领导干部。因此，当局制定的政策的传达效力是有限的，我们只能指望其中的好公民去 100% 的执行，而剩下的几类人不仅不能执行，甚至会带来负效果。设当局政策的有效力为 E，理想情况下 E = 100%。

当病毒在自然状态下自由传播的时候，它的传播速率就是 R0，只要 R0 大于 1，那就肯定会指数传播，无非是快慢问题。当有人为干预的时候，传播速率就变成了 R0 * (1 - E)，只要我们使这个值小于 1，就能控制病毒的扩散。

回到现在的疫情，delta 变种 R0 是 5，这时候只要在发生疫情的地区，政策的有效率高于 80% 即可：5 * (1 - 0.8) = 1。显然，在我们国家是可以做到的，而国外做不到。所以 20 和 21 年我们这边风景独好，国外水深火热。omicron BA.2 的 R0 是 12，这时候要做到控制病毒，政策的有效率需要达到：12 * (1 - E) = 1 即 E = 92%。就目前来看，这个数字是很难的。我们已经有了三个实验数据：

1. 深圳和现在的上海，封城可以达到 92% 以上的人都阻断了病毒传播；
2. 上海早期，对 delta 起作用的精准防控措施显然达不到 92% 的有效率；
3. 北京，全城半封不封，半死不活，可以把有效率大致维持在 92%。

那么问题来了，北京就这样永远半封下去吗？或者一爆发就封城吗？上海真的能解封吗？解封了疫情就不会再起来吗？

每天的新闻发布会都会通报一些违反防控措施的单位和个人，有的案件甚至采取了刑事处罚。然后呢？我们现在可能把所有的不法分子都抓起来，把所有群众的素质都提到最高，把所有尸餐素位的干部都撤换掉吗？做不到的话，以 omicron 的 R0 值，怎么能指望不会隔三差五有一个新的隐匿传播呢？更何况，一鼓作气，再而衰，三而竭。随着不设限的封城持续下去，怠惰疲乏而不再遵守防疫规定的人只会越来越多。

引用最近看到的一句话：

有人不遵守规定不是决策者的问题，但是做决定时候没有考虑到这些人就是决策者的问题了。

现在的防控措施已经是社会极限了，这是结构性的问题。我们当前的社会组织能力，当前的科学技术手段，能做到的防疫有效率已经不可能阻止 omicron 的传播了。这也不是当局能力的问题，一代人做一代人的事儿，只希望他们能早日认清。现在唯一的能做的就是思考怎样更好地和病毒共存了。

附：「安居乐业」的城市列表

开始看到了一个 reindex 的 API，想着直接从老集群 reindex 过去就好了，结果发现不行。直接 reindex 会丢掉类型信息。

首先尝试了一个搜到的工具：ElasticDump, 然而速度太慢了。后来发现 ES 有原生的 snapshot API，只需要使用这个 API 备份好，然后导入新的集群即可，而且再这个过程中还可以升级版本，简直 完美。具体操作如下：

1. 创建 5.5 的 snapshot 到本地硬盘
2. 下载 snapshot 到 6.8 集群机器上
3. 在 6.8 集群中导入 snapshot

本来想通过 6.8 中再导出然后升级到 7.x，结果发现导出的版本显示还是 5.x 版本的索引，放弃了

因为我的集群中没有安装任何插件，所以插件的兼容性和升级也不用考虑。

查看集群的恢复状态：

GET _cat/recovery?v&pretty

查看 snapshot 的状态

GET /_snapshot/my_backup/snapshot_1

查看 snapshot 详情

GET /_snapshot/my_backup/snapshot_1/_status

参考

1. https://www.elastic.co/cn/blog/moving-from-types-to-typeless-apis-in-elasticsearch-7-0
2. Migration API
3. https://www.elastic.co/guide/en/elasticsearch/reference/7.17/removal-of-types.html
4. https://www.elastic.co/guide/en/elasticsearch/reference/7.17/snapshot-restore.html

Like what stackoverflow said in their blog:

Have you been saying “we don’t need Kubernetes because we don’t have product market fit yet”? Take a closer look, and maybe you’ll find yourself saying “we need Kubernetes because we don’t have product market fit yet.”

Operating systems are complex, but few one would building their apps on top of bare metal. You probably have not read Linux's source code, but you can use it to host your app as long as you understand the basic concepts of threads and processes etc. You don't even have to know all the features of Linux. How many of you are masters of shiny new stuff like eBPF or WireGuard? You can just learn them when you really need to use them.

The same goes with kubernetes. It's complex indeed, but you don't need to understand every bit of it before using it. The concepts of k8s is actually very simple -- host an app on a distributed environment. It almost the same idea as running your app locally.

So, basically, as other people says, kubernetes is the OS of distributed systems. The analog in details:

Why did people migrate from bare metal to operating systems? Because the benefits of OSes outweighs the costs. So what are the problems kubernetes would solve by simply using it?

• Easily add more machines, you can just expand your cluster whatever you like.
• Easily scale up and down your apps.
• Automatic rollout strategy, which means almost no down time.
• Centralize credentials and configuration management.
• Monitoring and dashboards are out there, just install one.

At the very start, you may not need all of them, but manually planing the machines needed and to decide which db on which machine is exhausting enough, unless you can put all your services on a single machine forever.

The problem here is: Using a single machine is no longer possible nowadays. Making topology for your services is inevitable, you have to do it manually, which is tedious and error-phone, or just use k8s.

With k8s, you can forget about machines or nodes and how your services communicate, just write a yaml deployment file, and your service is up and running. It makes a distributed system feel like a single node.

References

1. https://stackoverflow.blog/2021/07/21/why-you-should-build-on-kubernetes-from-day-one/
2. https://mp.weixin.qq.com/s?__biz=MzUzMzU5Mjc1Nw==&mid=2247484759&idx=1&sn=25df16461d0ea9f49fd5c36101f8b2ea
3. https://v2ex.com/t/780960
4. https://queue.acm.org/detail.cfm?id=2898444

用到的工具

• multipass 是 Ubuntu 背后的厂商 Canonical 推出的一款虚拟机工具，可以在本地快速搭建起一个 Ubuntu 集群用于开发和测试。
• k3s 是 Rancher 推出的一个轻量级 k8s 发行版。
• autok3s 是 Rancher 中国推出的一款自动部署 k3s 集群的工具。
• arkade 是一个快速安装 k8s 相关 cli 和 helm package 的命令行工具。
• podman 是一个开源的 docker 替代工具。

我们可以结合以上工具在 macOS 或 Linux 上快速搭建一个本地的 k8s 集群。

安装集群

# Ubuntu 官方提供的虚拟机工具
brew install multipass

# 创建几个节点，分别是2核2G和2核4G，我的机器是 32G/2T，创建这几个节点还是绰绰有余的
multipass launch -c 2 -m 2G -d 40G -n primary
multipass launch -c 2 -m 4G -d 40G -n worker1
multipass launch -c 2 -m 4G -d 40G -n worker2

# 为了方便，把宿主机的家目录 mount 到虚拟机上
# 因为 primary 机器默认已经 mount 了，只需要 mount worker 节点
multipass mount $HOME worker1:/home/ubuntu/Home
multipass mount $HOME worker2:/home/ubuntu/Home

# 这时候我们已经可以登录了
multipass shell primary/worker1/worker2

# 为了方便，把宿主机默认的 ssh key 复制过去
# 在每个虚拟机中都执行
cat Home/.ssh/id_rsa.pub >> .ssh/authorized_keys

# 回到宿主机，安装 arkade + autok3s. Arkade 是一个 kubernetes 相关工具的快捷安装包
brew install arkade
arkade get autok3s  # 可能需要按照提示把 autok3s 加入 PATH

# 首先 看一下机器的 IP
mulitpass ls
# Name                    State             IPv4             Image
# primary                 Running           192.168.64.2     Ubuntu 20.04 LTS
# worker1                 Running           192.168.64.3     Ubuntu 20.04 LTS
# worker2                 Running           192.168.64.4     Ubuntu 20.04 LTS

# 测试一下 ssh
ssh ubuntu@182.168.63.3

# 开始创建集群，这里我选择的名字是 imac，因为我是在自己的 iMac 上创建的集群。
# native provider 指的是使用普通的 Linux 节点，因为 autok3s 还支持众多云厂商。
autok3s -d create \
    --provider native \
    --name imac \
    --ssh-user ubuntu \
    --ssh-key-path $HOME/.ssh/id_rsa \
    --master-ips 192.168.64.2 \
    --worker-ips 192.168.64.3,192.168.64.4

# 稍等片刻，可以看到集群已经创建成功了
# 按照日志中的提示，切换配置到这个集群
autok3s kubectl config use-context imac
# 然后就可以使用了~
autok3s kubectl get pods -A
# NAMESPACE     NAME                                      READY   STATUS              RESTARTS   AGE
# kube-system   local-path-provisioner-84bb864455-qg76v   1/1     Running             0          2m24s
# kube-system   coredns-96cc4f57d-6mq9f                   1/1     Running             0          2m24s
# kube-system   helm-install-traefik-crd--1-2b7cc         0/1     Completed           0          2m24s
# kube-system   helm-install-traefik--1-5k4lg             0/1     Completed           1          2m24s
# kube-system   metrics-server-ff9dbcb6c-r7tzn            1/1     Running             0          2m24s
# kube-system   svclb-traefik-9sc9z                       2/2     Running             0          104s
# kube-system   traefik-56c4b88c4b-xmffz                  1/1     Running             0          104s
# kube-system   svclb-traefik-cvk8w                       2/2     Running             0          56s
# kube-system   svclb-traefik-hj8cs                       0/2     ContainerCreating   0          20s

# 万一中途因为网络或者 ssh 配置错误等原因失败了，可以删掉有问题的集群重来
autok3s list
autok3s -d delete --provider native --name imac
# 如果还有没清理干净的残留，可以登录到虚拟机上使用 k3s-uninstall 脚本继续清理

# 安装后的 kubeconfig 文件默认在 ~/.autok3s/.kube/config 中，复制出来可以直接使用 kubectl
mkdir -p ~/.kube
cp ~/.autok3s/.kube/config ~/.kube/config
kubectl get pods -A

# 使用 arkade 安装 portainer 管理面板
arkade install portainer
kubectl port-forward -n default svc/portainer 9000:9000

# 打开 localhost:9000 就可以看到 portainer 的界面啦~

到这里，集群就部署好啦，接下来我们部署一个 demo app 上去！

部署应用

搭建 docker registry

因为我的目的只是在本地做实验，所以没必要上传镜像到外部的 registry 上。但是本地的镜像也 不能在集群中直接使用。为了解决这个问题，我们在集群内部搭建一个 docker registry，用于把 镜像上传到集群中。为了把 registry 暴露到宿主机，我们还需要安装 ingress-nginx，并且在本地 和每个虚拟机的 /etc/hosts 中添加对应的域名。

这里，我们使用 docker.imac.local 作为本地仓库的域名。

# 删除 k3s 自带的 traefik
kubectl delete svc/traefik -n kube-system
kubectl delete deploy/traefik -n kube-system

# 安装 ingress nginx
arkade install ingress-nginx

# 在 k8s 内部安装 docker registry
arkade install docker-registry --email you@example.com --domain docker.imac.local
# 在日志最后会输出密码，先记下来，不要丢了。本地的密码，亮出来也无所谓。
# export PASSWORD=zZPFqGO73IE26823434g

# 在宿主机为我们的 registry 添加域名 docker.imac.local
echo '192.168.64.2 docker.imac.local' >> /etc/hosts
# 如果是在 mac 上，还需要登录 podman 虚拟机，执行同样的操作
podman machine ssh
echo '192.168.64.2 docker.imac.local' >> /etc/hosts
# 登录 multipass 的虚拟机，执行同样的操作
mulitpass shell primary/worker1/worker2
echo '192.168.64.2 docker.imac.local' >> /etc/hosts
# 让 k3s 集群忽略 tls 错误, 同样需要在每台虚拟机上执行
cat >> /etc/rancher/k3s/registries.yaml << EOF
configs:
  "docker.imac.local":
    auth:
      username: admin
      password: zZPFqGO73IE26823434g  # 上面打印出的密码
    tls:
      insecure_skip_verify: true
EOF
# 在每台虚拟机，依次重启 k3s
sudo systemctl restart k3s  # master
sudo systemclt restart k3s-agent  # worker

# 宿主机上，使用 curl 验证一下，因为集群中使用的是自签名证书，这里使用 -k/--insecure 选项
# 忽略证书错误。
# 可以看到 404，说明 ingress controller 安装成功。但是集群还不知道这个域名该路由到哪个服务，
# 所以返回了 404 Not Found
curl -k https://docker.imac.local
# <html>
# <head><title>404 Not Found</title></head>
# <body>
# <center><h1>404 Not Found</h1></center>
# <hr><center>nginx</center>
# </body>
# </html>

# 安装 registry ingress
arkade install docker-registry-ingress

# 登录，同样忽略证书错误
podman login docker.imac.local --tls-verify=false
# Username: admin
# Password:
# Login Succeeded!

registry 部署好之后，就可以打包推送镜像上去了。

部署服务

写一个简单的页面来演示如何部署服务。

mkdir test
cd test

# 这是最后要验证的结果
cat >> index.html << EOF
<p>Hello from Test App.</p>
EOF

# 基于 nginx 镜像，把这个文件拷进去
cat >> Dockerfile << EOF
FROM nginx

COPY index.html /usr/share/nginx/html/
EOF

# 构建镜像
podman build . -t docker.imac.local/test-app
# push 到我们的私有 registry 中
podman push docker.imac.local/test-app --tls-verify=false

我们打算部署到 test-app.imac.local 这个域名，所以还需要在本机添加 DNS：

echo '192.168.64.2 test-app.imac.local' >> /etc/hosts

下面是要部署的服务的配置文件，都是最基础的配置，不再展开赘述。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-app
spec:
  selector:
    matchLabels:
      app: test-app
  template:
    metadata:
      labels:
        app: test-app
    spec:
      containers:
      - name: test-app
        # 使用刚刚打包的镜像
        image: docker.imac.local/test-app
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: test-service
spec:
  selector:
    app: test-app
  ports:
  - name: http
    port: 80
    protocol: TCP
    targetPort: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
  - host: test-app.imac.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: test-service
            port:
              number: 80

部署：

kubectl apply -f app.yaml

然后测试一下：

curl -k https://test-app.imac.local

<p>Hello from Test App.</p>

浏览器打开：

大功告成啦！如果要部署新的服务，只需要部署时在本机 /etc/hosts 中添加对应的域名就可以啦！

附录 - k3s 简介

k3s 是 rancher 出品的一个 Kubernetes 发行版，特点是单二进制文件，小巧且不吃资源，甚至可以 在树莓派上部署。虽然它对许多组件做了替换，如把 etcd 替换成了 sqlite3，但是依然是一个 通过了官方认证的 Kubernetes 发行版。

除了 k3s 以外，还有一些其他的精简 k8s 发行版，比如 microk8s, kind, minikube 等等，但是 都远远没有 k3s 轻量。

• autok3s 类似工具还有 - k3sup, 它主要面向国外云厂商，而 autok3s 主要面向国内云厂商。
• k3s 默认带了自己的 local-path provider，可以直接创建 PV.
• k3s 安装后会利用 iptables 规则拦截 80 端口的流量
• k3s 默认在监听 0.0.0.0，可以使用安全组禁用 API 端口了。

参考

1. https://docs.rancher.cn/docs/k3s/autok3s/native/_index
2. https://web.archive.org/web/20201124123950/https://www.portainer.io/2020/04/portainer-for-kubernetes-in-less-than-60-seconds/
3. https://stackoverflow.com/questions/51511547/empty-address-kubernetes-ingress
4. k3s 官方文档
5. https://www.reddit.com/r/kubernetes/comments/be0415/k3s_minikube_or_microk8s/
6. https://brennerm.github.io/posts/minikube-vs-kind-vs-k3s.html
7. 非常全的一份文档
8. https://github.com/k3s-io/k3s/issues/2403
9. https://blog.oddbit.com/post/2018-02-27-listening-for-connections-on-a/
10. k3s with external etcd

还可以使用依赖来做插件，如在依赖中做一些 Token 的验证等等。所以，在 FastAPI 中，不需要 插件系统，只要把要复用的逻辑实现为一个依赖就好了。

定义一个依赖

依赖的定义是一个 callable, 也就是说函数或者类都可以。依赖的参数和每一个 handler 的参数都 一样，所以 GET/POST/Cookie/Header 等参数都可以以相同的方式使用。

# 使用函数作为依赖
from fastapi import Depends

async def pagination(page: int, size: int):
    return {"page": page, "size": size}

@app.get("/users")
def get_users(pagination: dict=Depends(pagination)):
    users = user_model.get(**pagination)
    return users

@app.get("/items")
def get_items(pagination: dict=Depends(pagination)):
    items = items_model.get(**pagination)
    return items

使用类有一个好处，你可以把这个类作为类型注释，这样和其他的参数使用方式更加一致。但是也有 一个缺点，那就是函数的 __init__ 必须是 sync 的，可能会在线程池中执行。

class Pagination:
    def __init__(self, page: int, size: int):
        self.page = page
        self.size = size

@app.get("/users")
def get_users(pagination: Pagination=Depends(Pagination)):
    users = user_model.get(**pagination)
    return users

# 比较巧妙的一点，我们可以省掉 Depends 的参数
def get_users(pagination: Pagination=Depends()):
    ...

Pydantic 的 model 也可以作为依赖直接使用，这样就相当于把 GET 参数作为一个 model 了。

class Pagination(BaseModel):
    page: int
    page_size: int

@app.get("/items")
def list_items(pagination: Pagination = Depends()):
    ...

添加依赖

依赖可以在三个地方添加：handler 函数参数，路径装饰器，全局 app 实例。如果在 handler 函数的 参数中添加，那么依赖的返回值会作为参数传递进去，就像其他参数一样。其他两种方式返回值都会被丢弃。

from fastapi import FastAPI, APIRouter, Depends

class Dependable:
    def __init__(self, ...):
        ...

# 全局依赖
app = FastAPI(dependencies=[Depends(Dependable), ...])

# 在路径装饰器中添加一个依赖数组
@app.get("/", dependencies=[Depends(Dependable), ...])
def home(param: Dependable = Depends()):   # 在 handler 参数中使用
    ...

# 在 Router 中使用
router = APIRouter(dependencies=[Depends(Dependable)])

依赖依赖依赖

依赖还可以有依赖，也就是依赖的参数也可以是 Depends

def get_user(username: int, token: str = Depends(verify_token)):
    ...

例子

读取固定参数

见前边 pagination 的例子

验证 Token

from fastapi import Depends, FastAPI, Header, HTTPException

async def verify_token(x_token: str = Header(...)):
    if x_token != "fake-super-secret-token":
        raise HTTPException(status_code=400, detail="X-Token header invalid")

app = FastAPI(dependencies=[Depends(verify_token)])

这个例子可以进一步扩展成使用 session.

加载数据库连接

我们需要使用 yield 来返回创建的实例，当 handler 函数执行完毕之后，yield 后边的语句才会 继续执行（关闭数据库）。请特别注意，不要在这里执行 commit，应该由业务代码在 return 之前 执行，否则可能会造成给前端返回的数据不一致的问题。

async def get_db():
    db = DBSession()
    try:
        yield db
    except Exception:
        db.rollback()
        raise
    finally:
        db.close()

如果是 redis，可以这样：

REDIS_URL = "redis://localhost:6379/0"
redis_pool = ConnectionPool.from_url(REDIS_URL)

def get_redis():
    return Redis(connection_pool=redis_pool)

依赖去重

当依赖之间有依赖关系的时候，可能会出现有两个依赖同时调用同一个上级依赖的问题，有点类似 继承中的多继承关系。

参考

1. https://stackoverflow.com/questions/65243587/fastapi-async-class-dependencies
2. Session 相关 Issue
3. https://stackoverflow.com/questions/18022767/python-redis-connection-should-be-closed-on-every-request-flask