铃阅时讯
❌

普通视图

写在 36 岁的最后一天

2026年7月29日 19:08

原创 刘飞Lufy 2026-07-29 19:08 北京

我不能严肃地假定我现在在做梦。

果园

经营果园,而不是出卖劳动力。

春种秋收。种下机会,等待结果。

成功从来不是突然出现的,它只是把过去那些看似不相关的经历,重新串在了一起。

不要想着一下就上大学。粗糙一点没关系,先多读几次小学,再读中学,最后才有机会进入大学。

自由、松弛并且有复利地工作,可能比单纯靠睡后收入休息和娱乐,更加健康且理想。对于相当一部分人。

不是所有的长期主义都是有价值的。要关注未来折现的现金流,不是当期的现金流。这个比长期价值更准确,因为说长期价值没有说大小和做对比。时间长不代表绝对值就是高的。

报道热点是廉价的增长。迈克尔·刘易斯(Michael Lewis)说在 10 Years of Acquired 的一句话。热点制造情绪,时间确认意义。让子弹飞一会儿,才知道它究竟射中了什么。

保持思考。警惕内容同质化。如果所有人都想得一样,那就没人真的在思考。

写作的核心是清晰的思考,而清晰思考本身就是一种稀缺资源。

虚荣是思想的死亡。

今年看了《奥兰多》话剧,记下一句话:「做一棵橡树。」

同时接受笨拙和不完美。「打开水龙头,一开始流出来的水是脏的,你得让它流一阵,干净的水才会来。创作也是一样,你必须先把烂作品排出来。」

所谓运气,很多时候只是机会到来时,你已经在附近待了足够久。

更能改变世界的产品,都有一个共同特征:它必须赶上一个时代,同时又必须和这个时代已有的东西不一样。而这个「不一样」,恰好是下一个时代需要的。

但不执着。

(2025.6 摄于奥斯陆)

执着

佛教里执着也称为染着。这个词真妙,代表内心的欲望和执念是源于从外部沾染的颜色。名利是金,情爱是红,嫉妒是绿,傲慢是灰,仇恨是黑。染色入肌理,很难洗,时时想起,一般浸染更甚。更需要时间漂白,心流冲刷,智识暴晒。颜色褪去,执念才自然消散,所谓不执染着。

萨特说人没有本质、存在先于本质,顺着这个逻辑推,根本就没有一个「剥离了所有社会影响之后的纯粹的你」在那儿等着被发现。

主体不是世界中的一个对象,而是世界的前提和界限;眼睛能看到一切,却看不到自己。

托尔斯泰说。每个人的生活有两个方面:个人的私生活和天然的、群体的生活,前一种生活的需要愈抽象,就愈自由;在后一种生活之中必然要遵循给他规定的规则。

重新认识世界和自己的关系。世界是随机的,我们其实也是随机的。

失败没关系。失败只是一个更聪明地重新开始的机会。

真正的尊严,不是永远不会失败,而是失败以后仍然能够决定下一步做什么。

「生活就是一连串微小的胜利,和巨大的溃败。」而《极乐迪斯科》告诉我们,人类背负恐惧继续前行,这本身很了不起。

摩擦力

维特根斯坦说,光滑的冰面没有摩擦力,因此无法行走;我们需要摩擦力,要回到粗糙的地面。

「世界上没有奇迹,只有你没见过的常态。」

李诞说,我建议每个自媒体博主都应该做的一件事情,是跟你的关注者见面。在保证安全的前提下跟你的关注者吃吃饭、喝喝酒,见见面、聊聊天。

对预测未来心怀恐惧、对市场波动保持敬畏,在追踪数据中随时准备承认错误并改变看法;接受下滑现实,自下而上、埋头苦干。

真正找到一条路,不是照着答案抄一遍,而是一个细致活,一个需要耐心和毅力的活。

技术本身创造不了价值,所有产品都是需求驱动的,有泡沫就说明是在技术飞速发展,但需求还很模糊、存在大量虚假需求的阶段。

遇到不了解的事情,不是先恐惧和焦虑,而是先了解。

不要报课。我发现很多上过 AI 课的人,对 AI 的理解有非常严重的刻板印象。就像学的第一首歌是贝多芬,还是社会摇,是不一样的,会严重影响一个人的音乐审美。

维特根斯坦还说,不要去想,而要去看。

读书是「看」,交朋友也是「看」。

「酒深情不厌,知己话偏长。莫负相钦重,明朝到草堂。」

李诞在跟我录播客的时候提过,有影响力本身也是一种特权。

我去逛北大的时候,请了一位博士生听友带我游览校园。这是一种做自媒体的奖励。

电影也是「看」。

李安讲的是压抑和爆发;杨德昌讲的是现代社会的异化;黑泽明讲的是命运和道德选择;小津讲的是日常生活的失去。我最喜欢的 4 位亚洲导演。

记忆

有两个习惯,比之前可能更有价值了。

一是多记。想法、观察、灵感、困惑,什么都记,不怕散不怕碎。

二是多存。好文章、好观点、好句子,看到就存,不用分类不用整理。

要是从零开始跟 AI 论述,就费劲得多了。况且多数靠自己记忆是根本记不住的。

日记、笔记、文摘、录音、照片、周报、邮件... ... 什么都好,先记下来存下来。富兰克林说,最接近把一个人的生活重新过一遍的事情是回忆那种生活,并用文字记录下来,让这种回忆尽可能地长久。

这是对于每个人很珍贵的 memory.md。

怎么更好地使用 AI,比 AI 本身的性能有多好更加重要。

没有 codex 和 flomo,我怕是都不知道这一年我想了以上这些。

这一年最喜欢的一句话:

我不能严肃地假定我现在在做梦。

跳转微信打开

Jina Reranker v3.5:专注垂直领域的 0.6B 列表式重排器

2026年7月29日 14:00

原创 Jina AI 2026-07-29 14:00 新加坡

0.6B 体量的卷王重排器

今天,我们正式推出 jina-reranker-v3.5。

作为 v3 系列的进阶版,它依旧保持了 0.6B 的参数规模以及标志性的 LBNL( Last but not late,一次前向传播处理整批文档)的列表式架构。在保持轻量化推理优势的同时,v3.5 专门解决了生产环境中最棘手的三个工程痛点:垂直领域适配、结构化记录的逻辑识别,以及长列表下的显存爆炸。

性能预览

维度

nDCG@10 表现

相比 v3 提升

核心亮点

BEIR (通用)63.20

+1.10

超越 4B 规模的 Qwen3-Reranker
MIRACL (多语言)74.11

+2.6%

0.6B 档位的性能标杆

RTEB (行业领域)70.95

+4.3%

覆盖法律/金融/医疗/代码

Struct-IR (结构化)48.3+24.8%

对 JSON 格式,表格,和字段背后的逻辑和规则的理解更清楚

推理速度

——

1.22×–1.56×

列表越长,加速越明显

为什么推出 v3.5?

Jina Reranker v3 的表现已经超出了我们的预期,它证明了 0.6B 参数配合 Listwise 架构,完全有能力在通用基准测试上和大模型掰掰手腕。但当我们将 v3 投入真实的业务时,却发现了一些榜单无法体现的坑。

  1. 垂直领域: 法律条文、临床诊断或金融研报,其语言模式与通用网页截然不同。BEIR 上的冠军模型,在复杂的法律判例面前也可能失效。

  2. 结构化数据: 面对 JSON 或表格数据,Reranker 如果不懂字段间的逻辑约束,比如“价格必须在 100~200 之间”、“必须是 L 码”等,就很容易给出离谱的评分。

  3. 长列表延迟:处理长文档列表时,全自注意力机制带来的显存开销是平方级增长的,延迟根本不可控。

v3.5 的出现,就是为了在保持轻量的同时,把这些工程盲区扫平。

三大核心演进

1. 3L2G 混合注意力架构

为了从根本上降低长列表下的计算开销,我们放弃了传统的全自注意力模式,转而采用 3L2G 混合注意力架构。

模型的大部分层运行 滑动窗口注意力(Sliding Window Attention),窗口大小设为 1024,这直接将计算复杂度从平方级拉到了线性级别。为了不丢失全局信息,我们周期性地 穿插了全局注意力层进行同步,并强制 末层必须全局可见,确保最终打分能吃透整组候选文档的特征。

2. 覆盖失效场景的数据策略

在训练阶段,我们将重点放在补齐 v3 的弱势场景上。

在法律和行业合规领域,我们补充了 EUR-Lex 和 AILA 等权威判例库,涵盖多国法律法规;医疗方面则补充了临床对话与生物医学论文。同时,利用大模型生成了大量极具干扰性的难负样本,逼模型学会区分细微的司法辖区和专业差别。

面对电商或企业系统中的 JSON 记录或者表格数据,传统模型往往只看字面词汇,不懂数字逻辑,比如搜 150 元以下,可能把 160 元的也匹配出来。我们采用 Struct-IR 策略,故意对 JSON 数据的关键字段,如价格、规格做微调或扰动,,逼模型去理解字段背后的约束与逻辑关系。

此外,多语言语料库 也扩展到了 50 多种语言,整体通用性与泛化能力进一步增强。

3. 三阶段自蒸馏流程

直接训练稀疏模型往往性能抖动,我们摸索出了一套迂回战术:

先练一个性能触顶的全注意力教师模型;再让 3L2G 学生模型去适应注意力路径的变化;最后通过 KL 散度和隐状态 MSE 等多维度蒸馏,让学生模型在大幅提速的同时,完美承接教师模型的排序质量。

性能实测

我们对比了 v3.5 与前代版本 v3,以及目前市面上主流的大参数重排模型。数据覆盖了通用搜索、多语言、垂直行业以及结构化数据四个维度。

1. 通用搜索:0.6B 规模超越 4B 模型

Jina Reranker v3.5 BEIR 基准测试结果与 Qwen3 和 Mixedbread rerankers 的比较

在通用的 BEIR 搜索基准测试中,v3.5 的平均分达到 63.20 (nDCG@10)。性能超过了参数量是其 7 倍的 Qwen3-Reranker-4B(62.28)。

2. 垂直行业:法律与金融场景的专项补强

Jina Reranker v3.5 RTEB 特定领域基准测试结果(法律、医疗和金融检索)

针对 法律、金融、医疗和代码 等行业语境(RTEB 基准),v3.5 的综合表现提升了 4.3%。在法律任务 AILA 上,v3.5 的 nDCG 指标相比 v3 猛增了 11 - 14 个点。

3. 结构化数据理解

Jina Reranker v3.5 在 Struct-IR 和 STaRK 上的结构化数据基准测试结果

这是 v3.5 进步最大的地方。在 Struct-IR 测试中,得分从 38.7 提升至 48.3,提升 24.8%。尤其在简历筛选等强约束场景中,Recall@5 指标已经能够与 Qwen-4B 持平。

4. 推理速度

数据集

平均文档长度

jina-reranker-v3

jina-reranker-v3.5

加速

BEIR

 短文档场景

~145 Tokens

371.1 ms

305.3 ms

22%
RTEB

 长文档场景

~1,900 Tokens

16,064.9 ms

10,290.9 ms

56%

混合注意力架构在长文档列表上展现了巨大的优势。以法律判例检索为例,处理速度提升了 56%,这直接解决了长上下文重排时最头疼的显存爆炸和延迟抖动的问题。

如何快速上手?

1. Jina AI API 

已在 Jina AI 官网同步上线,直接把模型名改成 jina_reranker_v3.5即可,代码逻辑不用改动。

curl https://api.jina.ai/v1/rerank \
  -H "Authorization: Bearer $JINA_API_KEY" \
  -d '{
    "model": "jina-reranker-v3.5",
    "query": "有机化学反应机制",
    "documents": ["SN2 亲核取代反应...", "如何烤制酸面包...", "钯催化偶联反应..."]
  }'

2. Elasticsearch 集成

通过 Elastic Inference Service (EIS) 调用,可作为 text_similarity_reranker retriever 接入混合搜索的流水线。

3. 私有化部署

https://github.com/jina-ai/jina-on-prem 支持 Docker 一键部署,适用于内网隔离或受监管的数据环境。

4. 模型已开源

模型权重已发布至 Hugging Face,支持通过 transformers 库直接加载。

model = AutoModel.from_pretrained("jinaai/jina-reranker-v3.5", trust_remote_code=True)

jina-reranker-v3.5 适用 CC BY-NC 4.0 许可协议,如有商业用途需求,请随时联系我们:sales@jina.ai

总结

在 0.6B 这个不挑卡的体量下,我们借由 3L2G 混合注意力架构,降低了长列表的推理门槛,并把对结构化数据的理解能力补齐到了生产可用的水平。

如果你现在的系统正面临长列表响应慢,或者垂直领域的检索,结构化数据的理解差点意思,Jina Reranker v3.5 提供了一个极具性价比的技术选型。

所有的技术细节与实验数据都已同步在技术报告 https://arxiv.org/abs/2607.18152 中公开,欢迎在实际业务中进行压测。

跳转微信打开

【第3734期】告别漫长等待:三步将 Playwright CI 流水线提速 80%

2026年7月29日 09:05

Jakob Norlin 2026-07-29 09:05 日本

无需复杂分片,通过缓存浏览器镜像与并行度优化,轻松将 Playwright CI 运行时间缩短至 5 分钟内。

前言

每次推送干等数分钟,浏览器重复下载,测试逐个串行 —— 问题不在用例而在配置。本文用缓存、并行、按需选浏览器三项改动,把 GitHub Actions 上的 Playwright 从三分钟压到一分钟内,无需分片,一个下午落地。

今日前端早读课文章由 @Jakob Norlin 分享,@飘飘编译。

用于解决我实际工作中的 前端 E2E 自动化测试流水线耗时过长 / 卡顿 问题,最值得借鉴的一点是:“将依赖分为‘二进制大文件’与‘OS 系统包’分层处理”:利用锁文件 Hash 缓存大文件,同时保留极轻量的 install-deps 保证环境完整性,用最小代价消除重复下载。

译文从这开始~~

GitHub Actions 流水线将 Playwright 测试拆分为多个并行的浏览器测试任务,每个任务最终都以成功的对勾结束。

你推送了一个提交,打开 Pull Request,然后等着。Actions 页面在那儿干转三四分钟,一个测试都没跑起来。等测试终于开始了,又是一个接一个地串行执行,整个任务耗费的时间远超你这次改动本身应得的等待。

如果你的流水线就是这副样子,罪魁祸首通常有两个,而且都不是你的测试套件本身。

第一个是浏览器安装。Playwright 自带了 Chromium、Firefox 和 WebKit 的专用构建版本,而默认的工作流每次运行都会把它们全部重新下载一遍。在典型的 GitHub 托管 Runner 上,这通常意味着 300 到 500 MB 的二进制文件,以及大约 30 到 90 秒的等待 —— 每次推送都要重复一遍,而这些文件几乎从不变化。具体数字因 Playwright 版本和 Runner 而异,本文后面的基准测试实测为 42 秒。

第二个是并行度。脚手架生成的配置默认将 CI 限制为单个 Worker,于是测试几乎逐个串行执行,哪怕 Runner 上还有空闲的 CPU 核心在那儿闲着。

这两个都是配置问题,不是套件问题,一个下午就能解决。

而且,你并不需要分片(sharding)。分片是把测试套件分散到多个并行的 CI 任务上跑,确实是个有用的手段,但它解决的是大多数团队尚未遇到的问题。对于一组运行较快的测试,只需缓存浏览器二进制文件并调整并行度,就能在单个 Runner 上将总时间压到五分钟以内,无需分片。当然,测试越慢,触及这个天花板就越快。

本文将完整走一遍这套配置。读完之后,你会清楚时间究竟花在了哪里,拥有一个能在每次 PR 时给出有效反馈的工作流,并且知道什么时候分片才真正值得引入。

基准线:Playwright 默认工作流到底在做什么

运行 npm init playwright@latest 时,它会提示你是否添加一个 GitHub Actions 工作流。大多数人选了 "是",于是 .github/workflows/playwright.yml 里就出现了下面这个文件。几乎所有人的起点都是它,所以在动手改之前,值得仔细看一看。

 name: Playwright Tests
 on:
   push:
     branches: [main, master]
   pull_request:
     branches: [main, master]
 jobs:
   test:
     timeout-minutes: 60
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
           node-version: lts/*
       - name: Install dependencies
         run: npm ci
       - name: Install Playwright Browsers
         run: npx playwright install --with-deps
       - name: Run Playwright tests
         run: npx playwright test
       - uses: actions/upload-artifact@v4
         if: ${{ !cancelled() }}
         with:
           name: playwright-report
           path: playwright-report/
           retention-days: 30

这个配置能跑。它会执行你的测试,交给你一份报告。问题在于,绝大部分时间都耗在了每次推送都重复的相同初始化和串行测试执行上。

下面是这个工作流在一个公开仓库上的真实运行结果,测试套件包含大约 40 个用例。这些都是轻量级测试,跑得比大多数真实项目快,所以请把这些数字当作用来对比各项优化的固定基准,而非对你自己运行时间的预测。

基准运行总耗时:3 分 18 秒。

40 个测试跑了三分多钟。现在来看看时间究竟花在了哪些步骤上:

基准任务各步骤耗时。Checkout、Node 安装和依赖安装各只需约一秒,几乎全部时间集中在两个步骤上。

那些轻量步骤确实很轻。Set up job、checkout、Node 安装、npm ci 都在零到一秒之间,完全不值得去动。整个运行时间全部集中在两个步骤里。

第一个是 Install Playwright Browsers,耗时 42 秒。这一步下载 Chromium、Firefox 和 WebKit,外加浏览器所需的系统依赖库,而且每次运行都会重复,不管这些浏览器有没有变化。展开这一步的日志,你能看到二进制文件一个个被拉下来。

第二个是 Run Playwright tests,耗时 2 分 25 秒。这个数字更大,而对于一个 40 个用例的测试套件来说,实在太久了。原因就是并行度 —— 或者说,缺乏并行度。脚手架生成的 playwright.config.ts 里写着 workers: process.env.CI ? 1 : undefined,意思是在 CI 环境中只用一个 Worker。测试几乎逐个串行执行,哪怕 Runner 上有空闲核心也白搭。

所以,两个瓶颈就这样明晃晃地摆在第二张截图里,而且它们彼此独立。一个是重复的下载开销,通过缓存浏览器二进制文件即可解决;另一个是串行执行,通过开启并行即可解决。接下来两节将按这个顺序逐一攻破。

有一点值得时刻记在心里:大家执着追求的单元测试速度,很少是拖慢流水线的真正元凶。测试外围的初始化和编排才是 —— 而这恰恰是这两项优化所针对的问题。

速度优化一:缓存浏览器二进制文件

基准测试中的安装步骤耗时 42 秒,原因是 Runner 在运行第一个测试之前就要拉取近 400 MB 的浏览器二进制文件。这些文件只有在你更改 Playwright 版本时才会变化,因此每次推送都重新下载纯属无意义的重复劳动。只需缓存一次,此后每次运行都从缓存恢复而非重新下载,这样就能把那 42 秒的步骤缩短为几秒钟 —— 在你升级 Playwright 版本之前,每次 PR 都是如此。

Playwright 将浏览器安装在 ~/.cache/ms-playwright,在 Linux Runner 上对应的实际路径是 /home/runner/.cache/ms-playwright。基准测试截图中每行下载日志的末尾都能看到这个路径。这就是你要缓存的目录。

缓存键使用 package-lock.json 的哈希值。锁文件是 Playwright 版本的一个方便代理 —— 虽然不完美:升级 Playwright 会改变哈希值,从而正确地使缓存失效,但任何不相关的依赖变更也会导致哈希变化,造成一次本不必要的缓存未命中。对大多数仓库来说,偶尔多一次慢运行是一个可以接受的代价,换来的是一行搞定的缓存键。

接下来是大多数教程忽略的细节,也是缓存方案通过代码审查后却在 CI 中翻车的原因。缓存存储的是浏览器二进制文件,而非浏览器运行所需的操作系统级库,因为那些库是通过 apt 安装到系统全局的,根本不会进入 ~/.cache/ms-playwright。所以在缓存命中时,二进制文件是有了,但系统库缺失,测试会报错:Host system is missing dependencies to run browsers。解决办法是在缓存命中时仍然安装那些系统库,只是跳过浏览器下载。

缓存命中时,actions/cache 会在任务开始时自动将 ~/.cache/ms-playwright 恢复到磁盘上,因此在任何安装步骤执行之前,二进制文件就已经就位了。

这就引出了两个条件步骤,它们在每次执行时都会运行,而不是只在第一次运行。缓存未命中时,playwright install --with-deps 在一个步骤中同时下载浏览器和系统库,这个分支只在缓存键变化时才会再次触发。缓存命中时,则每次都改为运行 playwright install-deps,只安装系统库。这不是跑一次就永远跳过的一次性步骤。apt 仍然需要在每个全新的 Runner 上确认包已就位 —— 因为每个任务都从一台干净的机器启动,什么都没装 —— 但速度很快,因为不涉及下载,只是做一次依赖检查,除了那些库本身以外其他条件都已满足。

这里假设 Runner 能正常访问 apt 的软件包镜像;如果是网络受限或自托管的 Runner,请先确认这一点。

 steps:
   - name: Cache Playwright browsers
     id: playwright-cache
     uses: actions/cache@v4
     with:
       path: ~/.cache/ms-playwright
       key: ${{ runner.os }}-playwright-${{ hashFiles('package-lock.json') }}
   - name: Install Playwright browsers and system dependencies
     if: steps.playwright-cache.outputs.cache-hit != 'true'
     run: npx playwright install --with-deps
   - name: Install OS dependencies for browsers
     if: steps.playwright-cache.outputs.cache-hit == 'true'
     run: npx playwright install-deps

缓存步骤上的 id 让两个安装步骤能够读取 cache-hit 的值,从而选择正确的分支。第一次运行时缓存未命中,下载所有内容并填充缓存。之后每次运行都会命中缓存、跳过下载,而由于键绑定了锁文件,当你升级 Playwright 时整个缓存会自动失效 —— 无需手动更新任何东西。

还有一种替代方案完全不用缓存:在 Playwright 官方 Docker 镜像 mcr.microsoft.com/playwright 中运行任务,该镜像预装了浏览器和系统包,不过你仍需自行安装 Playwright npm 包。代价是每次任务都要拉取那个大镜像,所以你只是把浏览器下载换成了镜像拉取,并非真正消除了开销。这在视觉回归测试中比较常见 —— 因为渲染一致性很重要 —— 但它是为可信的测试目标设计的,不适用于不可信的站点。对大多数测试套件来说,缓存方案更轻量。

缓存在首次运行之后就把安装步骤从关键路径上移除了。剩下的是基准测试中那个更大的数字 ——2 分 25 秒的测试执行时间,下一节来解决它。

速度优化二:使用 Worker 并行运行测试

缓存把安装步骤从关键路径上移除了,但基准测试中那个更大的数字还杵在那里:40 个测试跑了 2 分 25 秒,几乎逐个串行执行。这种慢不是 Playwright 本身的问题,而是 Playwright 在严格执行生成配置的指令。

罪魁祸首就是 playwright.config.ts 中的这一行:

 workers: process.env.CI ? 1 : undefined,

脚手架有意这样设置,理由是对于未知的 CI 环境,单 Worker 是最安全的默认值。代价是无论 Runner 实际有多少核心,CI 中的每次运行都被强制压到单个 Worker,这就是基准测试如此缓慢的原因。

在本地环境中,值为 undefined,意思是让 Playwright 使用可用核心的 50%,而非一个固定数字。这只是脚手架对本地机器的默认选择,并非放之四海而皆准的最优值,应该把它当作起点而非一成不变的设定。如果你的本地机器有更多空闲核心,或者测试套件足够轻量、提高并行度也不会出问题,你同样可以在本地将 undefined 覆盖为一个明确的数字或百分比 —— 方式与本节下面为 CI 所做的调整完全一样。

这里有两个关键改动,作用各不相同。第一个是 fullyParallel: true。默认情况下,Playwright 在不同测试文件之间并行,但同一文件内的测试按顺序执行。如果你的测试分散在许多文件中,这个默认行为已经能让 Worker 保持忙碌。但如果测试集中在少数几个大文件里,仅靠文件级并行会让大部分 Worker 闲置,而 fullyParallel 正是解决这个问题的 —— 它允许单个文件内的测试也分配到不同 Worker 上执行。第二个是用基于百分比的 Worker 数量替换硬编码的单 Worker 上限,这样 CI 就能随可用核心数伸缩,而非被钉死在一个上。

 export default defineConfig({
   fullyParallel: true, // 顶层设置,应用于所有 project
   workers: process.env.CI ? "50%" : undefined, // 顶层设置,不要放在 project 内部
   // 你现有的配置项保持不变:
   use: {/* ... */},
   projects: [/* chromium, firefox, webkit */],
 });

这两个配置项都位于 defineConfig 的顶层,与 use 和 projects 平级,不嵌套在任何单个 project 内部,因此它们对整个测试套件生效。

将 CI 设为 50% 而非固定数字,是一个合理的起点,但不是保证最优的值。它能随你实际分配到的 Runner 进行伸缩,而非假定特定的核心数,但正确的数值仍取决于你的 Runner 规格以及测试消耗的内存,所以在调高之前请先实测。这是原始指导中值得放慢脚步仔细斟酌的部分,因为你读到的大多数建议都假设了错误的机器配置。

你会反复看到一个假设:GitHub 的免费 Runner 是 2 核的。对私有仓库确实如此,但公开仓库现在免费获得 4 核 Linux Runner,这个差异完全改变了计算。在 2 核 Runner 上,undefined 解析为 1 个 Worker,意味着默认实际上就是串行的,你必须手动调高才能看到任何并行效果。在 4 核 Runner 上,同样的 undefined 开箱即给你 2 个 Worker,还有继续提升的空间。前面的基准测试运行在公开仓库上,所以那里的慢完全是 process.env.CI ? 1 这个覆盖造成的,而非核心不够。

Runner

核心数

50% 对应

值得尝试

私有仓库,ubuntu-latest

2

1 个 Worker

明确设为 2

公开仓库,ubuntu-latest

4

2 个 Worker

'75%' 或 '100%',然后实测

更大规格的 Runner

8

4 个 Worker

'75%' 及以上,空间更充裕

请把这张表当作起点而一个固定数值。从 50% 开始,观察你的测试套件实际的总耗时,然后逐步提高,直到运行时间不再缩短或测试开始变得不稳定。不存在唯一正确的数字,因为它取决于你的核心数、测试的负载程度,以及每个浏览器实例吃掉多少内存。

最后一点也是不应该做的事。将 Worker 数大幅超出核心数 —— 比如在 2 核 Runner 上设置 workers: 4—— 并不会换来速度提升。每个 Worker 驱动着自己的浏览器实例,一旦它们开始争抢同样的两个核心和同一块内存,你换来的不是更快的运行,而是内存压力和那些在串行执行时根本不存在的间歇性失败。

开启 fullyParallel 并解除 Worker 上限后,4 核 Runner 上的测试执行时间从串行基准线大约减半,加上安装步骤已被缓存,两项优化叠加就是把整个任务压到五分钟以内的关键。下一节将通过精确控制每次推送实际运行哪些浏览器,进一步压缩时间。

速度优化三:只运行你需要的浏览器

基准测试的数字其实藏着一个东西没有明说。npm init 生成的默认配置不只是运行你的测试 —— 它会在 Chromium、Firefox 和 WebKit 三个浏览器上分别跑一遍,因为脚手架为每个浏览器都定义了一个 project。所以那 40 个测试实际上是每次推送执行 120 次,三个浏览器引擎各跑一轮。那 2 分 25 秒的测试时间中,有相当一部分是同样的断言在另外两个浏览器上多执行了两遍 —— 而这些浏览器很少能发现第一个没捕捉到的 bug。

如果你的产品并不需要在每次变更时都保证所有浏览器正常工作,一个务实的做法是按事件类型分层。每次 Pull Request 只跑 Chromium—— 因为这里的反馈循环需要快,而且大多数渲染和逻辑 bug 本来就会在 Chromium 上暴露 —— 然后把完整的三浏览器扫描留给合入 main 或夜间定时任务,那时你负担得起额外的时间,而且确实需要在代码上线前获得跨浏览器信号。Pull Request 保持迅捷,覆盖率并没有丢失,只是挪到了它真正值回票价的时机。

限定为单一浏览器只需一个标志 --project=chromium,然后根据触发运行的事件进行切换:

 on:
   pull_request:
   push:
     branches: [main]
 jobs:
   test:
     runs-on: ubuntu-latest
     steps:
       # checkout、setup-node、缓存和安装步骤沿用前面章节的配置
       - name: Run Playwright tests
         run: |
           if [ "${{ github.event_name }}" = "pull_request" ]; then
             npx playwright test --project=chromium
           else
             npx playwright test
           fi

在 Pull Request 上只运行 Chromium。推送到 main 时则走到 npx playwright test,运行配置中的所有 project。这样所有东西都保持在一个任务里,与本文一贯采用的单 Runner 方案保持一致。

这些都不影响本地运行;条件判断依据的是 CI 事件,所以在你的机器上执行 npx playwright test 仍然照常运行完整的浏览器集合。

如果你希望在 main 上让三个浏览器作为独立的并行任务运行,而非在同一个任务中共享 Worker,可以用条件矩阵来实现:

 jobs:
   test:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
         project: ${{ github.event_name == 'push'
           && fromJSON('["chromium", "firefox", "webkit"]')
           || fromJSON('["chromium"]') }}
     steps:
       # 相同的初始化步骤
       - run: npx playwright test --project=${{ matrix.project }}

推送到 main 时会展开为三个任务,每个浏览器一个;Pull Request 则收缩为单个 Chromium 任务。代价是 main 上消耗更多 CI 分钟数,所以只有当完整扫描慢到并行运行各浏览器能节省可观的实际等待时间时,这才值得。任务数始终限定在三个,不会滑向分片那种开放式的任务拆分。

完整矩阵是否值得运行,最终取决于你的用户构成。如果相当比例的用户在使用 Safari 或 Firefox,或者产品涉及大量布局,就在 main 上保留它。如果用户几乎全部使用基于 Chromium 的浏览器,放到夜间任务就够了。关于 WebKit 有一点需要注意:Playwright 在 Linux 上运行的 WebKit 构建跟踪的是 WebKit 的主开发分支,往往领先于 Apple 在 Safari 中实际发布的版本,而且缺少 Apple 自有的平台集成。Linux 上 WebKit 测试通过是布局和 JavaScript bug 的良好信号,但不能证明页面在 Safari 中显示正确。当这个区别很重要时,你需要 macOS Runner—— 那是独立于本工作流的另一个决策。

在 Pull Request 上仅跑 Chromium,叠加缓存和并行化之后,每次 PR 运行的测试执行量降为原来的三分之一,浏览器来自缓存,跨多个 Worker 并行。这套组合拳就是让百来个测试保持在五分钟以内的关键。接下来要确保的是:当测试失败时,你能看清原因 —— 也就是在 Runner 消失之前把 HTML 报告取出来。

将 HTML 报告作为 GitHub Actions Artifact 上传

Playwright 每次运行都会生成一份 HTML 报告,但在 CI Runner 上,这份报告写入的机器在任务结束的瞬间就会被销毁,所以默认情况下它随 Runner 一起消失,你永远看不到。许多团队是在第一次 CI 失败时才发现这个问题 —— 当他们想找到红叉背后的细节时,发现已经什么都打不开了。解决办法是在任务退出前将报告作为 artifact 上传 —— 基准工作流其实已经在做这件事了 —— 同时再加一个 reporter,让你无需下载任何东西就能直接看到失败信息。

上传本身只需一个步骤,关键路径是 playwright-report/,这是 Playwright 默认写入 HTML 报告的位置:

 steps:
   - name: Upload Playwright report
     uses: actions/upload-artifact@v4
     if: ${{ !cancelled() }}
     with:
       name: playwright-report
       path: playwright-report/
       retention-days: 14

if: ${{ !cancelled() }} 这个条件在这里起着关键作用。没有它的话,这一步只在前面所有步骤都通过时才运行 —— 这完全是反着来的,因为你最需要报告的恰恰是失败的那次运行。这个条件确保无论测试通过还是失败都上传报告,只有在你手动取消任务时才跳过。关于 retention-days,活跃开发中 14 天是合理的默认值,因为你主要查看近期的运行;对于发布分支,设为 30 天比较值得,因为你可能需要在几周后回溯某次构建。无论哪种,artifact 过期后就不再占用存储额度。

Artifact 给了你完整的报告,但需要几次点击:下载 zip 文件、解压、然后在本地启动服务 —— 因为直接打开 HTML 文件是不行的。报告通过 HTTP 加载数据,所以你需要执行 npx playwright show-report path/to/playwright-report,它会启动一个本地服务器并正确打开报告。当你需要深入查看 trace 时这个流程没问题,但对大多数失败来说,这样的摩擦成本过高了。

这就是第二个 reporter 发挥作用的地方。Playwright 自带一个 github reporter,它会将失败信息以内联注解的形式直接写入 GitHub Actions 界面,所以失败的断言会显示在运行摘要中,以及 diff 里对应的那一行旁边,全程无需下载。你把它加在 HTML reporter 旁边而非替换它,这样深入排查时仍有完整报告可用,而日常情况下直接看内联视图即可:

 export default defineConfig({
   reporter: [["html"], ["github"]],
   // ... 其余配置
 });

两者配合之后,失败的运行会在摘要中标注出什么坏了、在哪里坏的,而完整的 HTML 报告仍作为 artifact 附着在那里,供你在某次失败需要查看 trace、截图和步骤时间线时使用。这套组合让失败真正变得可读:大多数时候你根本不用离开 GitHub 页面,而当某个特定失败需要比注解所能展示的更多信息时,那个 zip 文件就在那里等着你。


github reporter 将失败以注解形式展示在运行摘要中,每条注解标明了测试名称及其所在位置。

至此,流水线在每次运行时都能产出可用的失败报告。下一节将把前面所有内容整合进一个完整的工作流文件,可以直接放入你的 GitHub 仓库。

完整的生产就绪工作流

前面四节的所有内容最终落在两个文件里。Worker 数量、fullyParallel 和两个 reporter 属于 playwright.config.ts,而缓存、PR 上只跑 Chromium 的策略以及 artifact 上传则属于工作流 YAML。以下是这两个文件的完整内容,附有行内注释,方便你理解每个部分的作用并适配到自己的仓库。

playwright.config.ts:

 import { defineConfig, devices } from "@playwright/test";
 export default defineConfig({
   testDir: "./tests",
   fullyParallel: true, // 在文件内部也并行执行测试,而不仅仅是跨文件并行
   forbidOnly: !!process.env.CI, // 如果不小心提交了 test.only,直接让构建失败
   retries: process.env.CI ? 2 : 0, // 仅在 CI 中重试不稳定的测试
   workers: process.env.CI ? "50%" : undefined, // 根据 Runner 规格伸缩 Worker 数;从这里开始实测并逐步调高
   reporter: [
     ["html"], // 完整报告,作为 artifact 上传
     ["github"], // 在运行摘要中生成内联注解
   ],
   use: {
     trace: "on-first-retry", // 测试重试时捕获 trace,用于调试失败
   },
   projects: [
     { name: "chromium", use: { ...devices["Desktop Chrome"] } },
     { name: "firefox", use: { ...devices["Desktop Firefox"] } },
     { name: "webkit", use: { ...devices["Desktop Safari"] } },
   ],
 });

.github/workflows/playwright.yml:

 name: Playwright Tests
 on:
   pull_request:
     branches: [main]
   push:
     branches: [main]
 jobs:
   test:
     timeout-minutes: 60
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
           node-version: lts/*
           cache: "npm" # 缓存 ~/.npm(安全的 npm 缓存),而非 node_modules
       - name: Install dependencies
         run: npm ci
       # 缓存浏览器二进制文件。此处假设使用 npm;锁文件作为 Playwright 版本的代理,
       # 因此在你更新 Playwright 时通常会自动失效。
       - name: Cache Playwright browsers
         id: playwright-cache
         uses: actions/cache@v4
         with:
           path: ~/.cache/ms-playwright
           key: ${{ runner.os }}-playwright-${{ hashFiles('package-lock.json') }}
       # 缓存未命中:同时下载浏览器和系统库
       - name: Install browsers and system dependencies
         if: steps.playwright-cache.outputs.cache-hit != 'true'
         run: npx playwright install --with-deps
       # 缓存命中:二进制文件已恢复,但系统库仍需安装
       - name: Install OS dependencies for browsers
         if: steps.playwright-cache.outputs.cache-hit == 'true'
         run: npx playwright install-deps
       # PR 上只跑 Chromium 以获得快速反馈;合入 main 时运行完整的浏览器集合
       - name: Run Playwright tests
         run: |
           if [ "${{ github.event_name }}" = "pull_request" ]; then
             npx playwright test --project=chromium
           else
             npx playwright test
           fi
       # 无论测试通过还是失败都上传报告,确保失败信息不会丢失
       - name: Upload Playwright report
         uses: actions/upload-artifact@v4
         if: ${{ !cancelled() }}
         with:
           name: playwright-report
           path: playwright-report/
           retention-days: 14

把这两个文件放进去,推送,第一次运行会填充缓存,之后每次运行都跳过下载。

如果你的测试需要诸如 base URL 或 API token 之类的配置,通过测试步骤的 env 块传入即可。非敏感值可以直接写在工作流中,而任何机密信息都应存储为仓库 Secret 并引用,而非明文写在文件里:

 steps:
   - name: Run Playwright tests
     env:
       BASE_URL: https://staging.example.com
       API_TOKEN: ${{ secrets.API_TOKEN }}
     run: # ... 同上

这就是全部配置了。对于大约 100 个测试以内的套件,到这里就可以停下。下一节讨论的是如何判断你是否真的已经超出了这套方案的承载力,这样你就能在确实需要时才有意识地引入分片,而非将其当作默认选项。

何时引入分片(何时不必)

分片是把你的测试套件拆分到多个并行运行的 CI 任务上,每个任务处理一个切片,最后再用一个步骤将各自的报告合并为一份。这是应对 Playwright 套件变慢的标准答案,确实有效,但它解决的是一个你尚未遇到的问题 —— 除非单个 Runner 确实已经力不从心。前面所有内容都是在让单个 Runner 跑得足够快,而对大多数测试套件来说,这就是全部。

决策规则很简单。先从 workers 和 fullyParallel 入手,将 Worker 数调到与你的 Runner 匹配,然后测量单 Runner 的最优时间。如果你已经把它调到极限仍然不够快,在分片之前先试试更大的 Runner:一台 8 核或 16 核的 GitHub 托管 Runner 能给你更多 Worker,而不用引入 merge-reports 步骤或维护分片数量。只有当一台 Runner—— 即使是更大规格的 —— 也无法在你的 PR 审查窗口内(通常约五分钟)完成时,才去考虑分片。下面的数字是粗略的起点,不是固定规则。你自己的盈亏平衡点取决于测试时长、Runner 硬件和套件的负载程度,而非仅仅是测试数量。

套件规模

单 Runner 耗时

怎么做

50 个测试以下

远低于 5 分钟

Workers 和 fullyParallel 足矣

50–200 个测试

大约 3 到 5 分钟

先换更大的 Runner,再考虑分片

超过 200 个测试,或 10 分钟以上

超出 PR 审查窗口

分片,或将运行移交给外部基础设施

一组重量级的端到端流程会比同等数量的轻量页面检查更快触及天花板,因为真正起决定作用的是运行时间。

分片换来的是总等待时间的缩短 —— 通过同时运行多个切片。它的代价也很实在:更多的 CI 分钟数(因为每次运行要为多台 Runner 付费)、一个用于拼接各份独立报告的 merge-reports 步骤,以及一个需要随套件增长而定期重审的分片数 —— 上个季度均匀的四路拆分,在套件翻倍后可能就不再均衡了。这些都不是不可逾越的障碍,但它们是你有意识承担的维护成本,而非运行稍慢就该迈出的默认下一步。

还值得了解的是,分片并非突破单 Runner 天花板的唯一途径。你可以完全跳过分片管理的开销,将套件放到专门为你并行化测试的基础设施上运行 —— 用 YAML 复杂度换取一个外部服务。这是否合适,取决于你有多想亲自掌控 CI 管道的每一环。

核心要点是:分片未必总是最佳方案。对绝大多数测试套件而言,一台跑得飞快的单 Runner 才是正确的配置,而引入分片的时机是你自己的数据越过了上面那条线的那一刻 —— 不要更早。当你确实需要时,Playwright 的分片文档详细说明了具体操作。

常见配置错误及如何避免

以下这些问题大多只是浪费你一个下午,而非直接搞崩什么东西,每一个都源于某个看起来合理、实则暗藏陷阱的默认设置。最常见的四个:

安装浏览器时没加 --with-deps。 单独运行 npx playwright install 只会下载二进制文件,不会安装浏览器运行所依赖的系统库,而 GitHub Runner 默认并不自带这些库。测试会报一个 "Host system is missing dependencies" 的错误,却对真正的原因只字不提。按照缓存章节的做法:缓存未命中时用 --with-deps,缓存命中时用 install-deps。

缓存 node_modules 而非 npm 缓存。 这是一个与前面浏览器二进制缓存不同的缓存,针对的是你的 npm 包而非 Playwright。恢复的 node_modules 可能带有特定平台的或构建不完整的依赖,与当前 Runner 不匹配,导致难以追踪的诡异故障。应该缓存 ~/.npm—— 通过在 setup-node 步骤中设置 cache: 'npm'(上面的完整工作流已经这样做了),然后让 npm ci 在每次运行时干净地重建 node_modules。

Worker 数设得超出 Runner 的核心数。 一旦 Worker 数量超过核心数,增加更多就不再有收益。超出之后,浏览器实例争抢同一块 CPU 和内存,速度没换来,反而换来了串行运行时根本不存在的不稳定性。让 Worker 数与 Runner 匹配,只在实测数据保持稳定的前提下才逐步调高。

忘记添加 github reporter。 没有它的话,失败的运行只告诉你有东西坏了,却不说是什么,逼你去下载并解压 artifact 才能一探究竟。在 ['html'] 旁边加上 ['github'],失败信息就会内联显示在运行摘要中,绝大多数情况下根本不需要碰那个 zip 文件。

总结

在 GitHub Actions 上实现快速的 Playwright 流水线并不需要分片。贡献最大的两项优化 —— 缓存浏览器二进制文件和针对 CI Runner 优化并行度 —— 都是一个下午就能完成的配置改动,一旦就位,它们在每一次 PR 上都在持续回报,而不是一次性的收益。这就是优化配置相比追求测试速度的隐性优势:节省的时间在团队此后的每一次运行中复利累积。

完整工作流中的单 Runner 方案在套件增长的相当长时间内都能胜任,而诚实的表述在这里很重要。当一个团队确实超出了这套方案的承载力时,那是一个在数据越线时有意识做出的扩展决策,而非说明之前哪里做错了。过早引入分片本身就是一种错误 —— 为你根本不会损失的时间付出了复杂度的代价。

一切的底层贯穿着一个值得铭记的理念。测试套件存在的意义是在每次推送时给出快速、可信的反馈,而本文中的每一项优化 —— 从缓存键到 Worker 数量再到内联 reporter—— 都是在为此服务。一条能在几分钟内给出清晰答案的流水线,才是人们真正信任并愿意等待的。而一条缓慢或嘈杂的流水线则会被忽视 —— 这悄无声息地辜负了你当初写测试的全部初衷。

如果你的套件已经越过了那条线,而你不想亲自维护分片数量、矩阵任务和报告合并,Endform 可以为你提供同样的并行化能力,无需自己搭建 CI 管道。

关于本文
译者:@飘飘
作者:@Jakob Norlin
原文:https://endform.dev/blog/playwright-github-actions

这期前端早读课
对你有帮助,帮” 
赞 “一下,
期待下一期,帮”
 在看” 一下。

阅读原文

跳转微信打开

❌