<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:media="http://search.yahoo.com/mrss/">
  <channel>
    <title>Load Testing · 仁才德</title>
    <link>https://jared.lynskey.co.nz/zh-cn/tags/load-testing/</link>
    <description>关于软件工程与研发团队领导力的短文——绩效评估、招聘与团队扩张、CI/CD、DevOps 监控、智能体 AI。写于首尔。</description>
    <generator>Hugo</generator>
    <language>zh-CN</language>
    <copyright>© 2026 仁才德</copyright>
    <lastBuildDate>Sat, 07 Nov 2026 00:00:00 +1300</lastBuildDate>
    <atom:link href="https://jared.lynskey.co.nz/zh-cn/tags/load-testing/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Fly.io 上的 Django 自动扩缩容：先压测出一台小机器的极限</title>
      <link>https://jared.lynskey.co.nz/zh-cn/posts/2026/2026-07-22-my-current-stack/</link>
      <guid isPermaLink="true">https://jared.lynskey.co.nz/zh-cn/posts/2026/2026-07-22-my-current-stack/</guid>
      <pubDate>Wed, 22 Jul 2026 00:00:00 +0000</pubDate>
      <dc:creator>Jared Lynskey</dc:creator>
      <category>Django</category>
      <category>Python</category>
      <category>React Native</category>
      <category>Expo</category>
      <category>Fly.io</category>
      <category>PostgreSQL</category>
      <category>WebSockets</category>
      <category>Scaling</category>
      <category>Load Testing</category>
      <category>Performance</category>
      <category>Tech Stack</category>
      <description>我的两个 Django 应用都跑在 Fly.io 的 shared-cpu-1x 机器上：先把一台做快，用压测找到延迟崩掉的并发点，再把自动扩缩容的阈值设在它前面。</description>
      <content:encoded><![CDATA[<p>想在 Fly.io 上便宜地跑 Django，我的做法是：把一台 shared-cpu-1x 小机器尽量做快，压测到延迟崩掉为止，然后让 Fly 的自动扩缩容在这个点之前启动第二台机器。压测用的是按阶梯加压的 Locust（另一个应用用一个按并发档位逐级跑的小 Python 脚本），盯着 p95 延迟和错误率看。流量回落后 Fly 会自动停掉空闲机器，所以平时的成本就是每个应用一台小虚拟机。</p>
<p>我目前以独立开发者的身份运营着两个产品：一个是面向上门报价的手艺人的<strong>现场估价应用</strong>，另一个是带有信息发布和实时消息的<strong>集市兼社区应用</strong>。</p>
<p>产品完全不同，用户完全不同，但技术栈几乎一模一样——而且两者都只跑在 Fly.io 最便宜的档位 <strong>shared-cpu-1x 机器</strong>上。这个约束是刻意为之的。与其按峰值负载来配置服务器，我选择把一台小机器的性能榨到极限，精确测出它在哪里崩溃，然后让 Fly 的自动扩缩容器围绕这个实测极限来增减机器。这篇文章讲的就是让这一切成为可能的优化、阈值背后的压测数据，以及 Fly.io 上扩容和缩容到底是怎么运作的。</p>

<h2 class="relative group">理念：先测准一台机器，再做乘法
    <div id="理念先测准一台机器再做乘法" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e7%90%86%e5%bf%b5%e5%85%88%e6%b5%8b%e5%87%86%e4%b8%80%e5%8f%b0%e6%9c%ba%e5%99%a8%e5%86%8d%e5%81%9a%e4%b9%98%e6%b3%95" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>两个应用的扩缩容策略都是同样的三步：</p>
<ol>
<li>把一台小机器在合理范围内做到尽可能快。</li>
<li>压测到它崩溃为止，记下延迟塌陷时的并发水平。</li>
<li>配置 Fly 的自动扩缩容器，在临界点之前启动第二台机器，并在流量回落时停掉空闲机器。</li>
</ol>
<p>这样容量就随机器数量近似线性增长，而基线成本是每个应用一台小虚拟机。下面的所有内容，都是为这三步中的某一步服务的。</p>

<h2 class="relative group">让一台小机器变快
    <div id="让一台小机器变快" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e8%ae%a9%e4%b8%80%e5%8f%b0%e5%b0%8f%e6%9c%ba%e5%99%a8%e5%8f%98%e5%bf%ab" aria-label="锚点">#</a>
    </span>
    
</h2>

<h3 class="relative group">Granian：API 走 WSGI，WebSocket 走 uvloop ASGI
    <div id="granianapi-走-wsgiwebsocket-走-uvloop-asgi" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#granianapi-%e8%b5%b0-wsgiwebsocket-%e8%b5%b0-uvloop-asgi" aria-label="锚点">#</a>
    </span>
    
</h3>
<p>两个后端都是 Django 6 + Django REST Framework。API 由基于 Rust 的服务器 <strong>Granian</strong> 提供服务，但跑的是 <strong>带阻塞线程池的 WSGI</strong>，而不是 ASGI：</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">granian --interface wsgi myapp.wsgi:application <span class="se">\
</span></span></span><span class="line"><span class="cl">    --workers <span class="m">1</span> --blocking-threads <span class="m">16</span> <span class="se">\
</span></span></span><span class="line"><span class="cl">    --workers-max-rss <span class="m">1400</span> <span class="se">\
</span></span></span><span class="line"><span class="cl">    --workers-kill-timeout <span class="m">15</span> --respawn-failed-workers</span></span></code></pre></div></div>
<p>我最初用的是 <code>--interface asgi --loop uvloop</code>，事后看是选错了。这些应用里的每个 HTTP 视图都是同步（sync）的，而 Django 的 ASGI 处理器会以 <code>thread_sensitive</code> 方式跑同步视图——每个 worker（工作进程）一次只跑一个。于是 ASGI 把每个 worker 的并发请求实质压到约 1 个，却还把整套 asyncio/uvloop/Channels 栈白白装进内存。带 <code>--blocking-threads</code> 的 WSGI 则把这些同步视图放进一个真正的线程池：1 个 worker × 16 个线程 = 16 个并发的 I/O 密集型请求（数据库读取、S3 预签名），而常驻内存比异步栈更低。</p>
<p>为什么只用一个 worker？因为这台 VM 是 <code>shared-cpu-1x</code>——只有一个核。第二个 worker 在单核上没法并行跑 Python（GIL + 单核），却要白白多占一整个常驻的 Django 进程；Granian 会直接就此发出警告。一个 worker 配 16 个线程，就是单 vCPU 机器在 I/O 密集型工作上诚实的上限。<code>--workers-max-rss 1400</code> 会在 worker 越过内存上限时重启它，于是失控的 PDF 或图片任务会被回收，而不是把机器一路拖向 OOM。</p>
<p>WebSocket 被拆到了它自己的 Granian 进程里——一个用 uvloop 和 <code>--ws</code> 的 <strong>ASGI</strong> 应用，为长连接跑 1 个 worker。同步 API 完全不需要 ASGI 路径：当某个视图想往 socket 推送时，它会经由 Redis 调用 <code>async_to_sync(channel_layer.group_send)</code>，消息照样会跨进程送到 WebSocket 应用。两台服务器，各自跑自己真正擅长的接口。本地 Docker 也跑同样的 WSGI 线程池，因此测试时我的笔记本约等于一台生产机器。</p>

<h3 class="relative group">热路径交给 Rust
    <div id="热路径交给-rust" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e7%83%ad%e8%b7%af%e5%be%84%e4%ba%a4%e7%bb%99-rust" aria-label="锚点">#</a>
    </span>
    
</h3>
<p>只要 Python 热路径上存在 Rust 实现的替代品，我就用它：</p>
<ul>
<li><strong>orjson</strong>（通过 <code>drf-orjson-renderer</code>）——所有 API 响应都经由 Rust 序列化，而不是标准库的 JSON 编码器。</li>
<li><strong>blurhash-rs</strong>——在上传时计算图片占位符。</li>
<li><strong>uuid-utils</strong>——Rust 实现的 UUID 生成。</li>
<li><strong>psycopg 3 (binary)</strong>——C 加速的 Postgres 驱动。</li>
</ul>
<p>这些都不改变架构，只是抬高了一颗 vCPU 在需要第二台机器之前所能承受的上限。</p>

<h3 class="relative group">消灭隐藏的延迟税
    <div id="消灭隐藏的延迟税" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e6%b6%88%e7%81%ad%e9%9a%90%e8%97%8f%e7%9a%84%e5%bb%b6%e8%bf%9f%e7%a8%8e" aria-label="锚点">#</a>
    </span>
    
</h3>
<p>两个代码库里最大的一次性能提升不是算法，而是连接复用。在 Granian 的线程池下，每个新线程都会重新构建一个 boto3 的 S3 客户端，而每个返回照片或 PDF 的接口都在支付这笔开销。我写了一个小小的自定义存储类，改为按进程缓存客户端之后：</p>
<blockquote><p>新线程上生成签名 URL 的耗时从 <strong>约 150ms 降到约 1ms</strong>。</p>
</blockquote><p>同样的教训也适用于数据库：Fly 的 Postgres 位于 PgBouncer 之后，所以应用设置 <code>conn_max_age=0</code>，把连接复用交给连接池，并用 5 秒的 <code>connect_timeout</code> 快速失败，避免 worker 挂在失效的 SSL 连接上。</p>

<h3 class="relative group">把缓存放在真正的瓶颈前面
    <div id="把缓存放在真正的瓶颈前面" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e6%8a%8a%e7%bc%93%e5%ad%98%e6%94%be%e5%9c%a8%e7%9c%9f%e6%ad%a3%e7%9a%84%e7%93%b6%e9%a2%88%e5%89%8d%e9%9d%a2" aria-label="锚点">#</a>
    </span>
    
</h3>
<p>压测社区市集时发现了一个值得记住的事实：<strong>天花板是 Postgres 连接数，而不是 CPU</strong>。浏览流量绝大多数是匿名的、用户之间完全相同，而在高负载下，这些相同的列表查询会在 CPU 闲置的同时把连接池打满。</p>
<p>解决办法是给匿名列表页加一层 Redis 缓存，用按命名空间的版本计数器做失效——一次写操作只需把一个计数器加一（O(1)，无需管理任何键），该资源的所有缓存页面立即失效。再用一个短 TTL 兜底。让浏览页面直接从 Redis 出去，真正的瓶颈就消失了，小机器可以把连接留给已登录的流量。</p>

<h3 class="relative group">不要消息代理的后台任务
    <div id="不要消息代理的后台任务" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e4%b8%8d%e8%a6%81%e6%b6%88%e6%81%af%e4%bb%a3%e7%90%86%e7%9a%84%e5%90%8e%e5%8f%b0%e4%bb%bb%e5%8a%a1" aria-label="锚点">#</a>
    </span>
    
</h3>
<p>两个应用都用 <strong>django-tasks-db</strong>——Django 的数据库后端任务框架——而不是 Celery。一个独立的 <code>db_worker</code> 进程轮询数据库来处理任务：图片处理、PDF 生成、机器翻译、提醒推送。没有消息代理，没有需要额外估算容量和监控的服务，API 进程也永远不会被重活阻塞。这个 worker 甚至绕过 PgBouncer 直连 Postgres，因为长时间运行的任务和事务级连接池合不来。</p>

<h3 class="relative group">内存：jemalloc 和交换空间缓冲
    <div id="内存jemalloc-和交换空间缓冲" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e5%86%85%e5%ad%98jemalloc-%e5%92%8c%e4%ba%a4%e6%8d%a2%e7%a9%ba%e9%97%b4%e7%bc%93%e5%86%b2" aria-label="锚点">#</a>
    </span>
    
</h3>
<p>图片和 PDF 处理造成的内存尖峰，是按稳态估算内存时无法预测的。两个便宜的缓解手段：在 Docker 镜像里预加载 <strong>jemalloc</strong> 来减少内存碎片，以及<strong>给每台机器都配交换空间</strong>（API 机器 2GB，WebSocket 机器 1GB），这样尖峰来临时进程会把内存换出到磁盘，而不是被 OOM 杀掉。交换空间不是性能特性——它是一份保险，让我能把内存配置一直保持在小规格。</p>

<h2 class="relative group">Django 压力测试：找到拐点
    <div id="django-压力测试找到拐点" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#django-%e5%8e%8b%e5%8a%9b%e6%b5%8b%e8%af%95%e6%89%be%e5%88%b0%e6%8b%90%e7%82%b9" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>阈值只有在被实测过之后才站得住脚。每个项目都有自己的压测工具：</p>
<ul>
<li>估价应用有一个小的 Python 压测脚本，扫描各个并发级别并报告 RPS、p50/p95/p99 和错误率；它跑在预先生成的几百条样例数据上，让列表接口在接近真实的数据量下被查询。</li>
<li>社区市集用 <strong>Locust</strong> 以 30 秒为步长从 50 爬升到 500 用户来寻找饱和点，接口权重按真实的浏览为主的流量设定；另有一套更小的独立测试，以 p95 &lt; 2 秒为阈值，对生产环境从 5 爬升到 50 个虚拟用户。</li>
</ul>
<p>估价应用扫描的代表性数据（1 个 Granian worker × 16 个阻塞线程，开发机上的 Docker）：</p>
<table>
	<thead>
			<tr>
					<th>接口</th>
					<th>并发</th>
					<th>RPS</th>
					<th>p95</th>
					<th>错误率</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>health</td>
					<td>25</td>
					<td>602</td>
					<td>52ms</td>
					<td>0%</td>
			</tr>
			<tr>
					<td>重型列表</td>
					<td>25</td>
					<td>309</td>
					<td>260ms</td>
					<td>0%</td>
			</tr>
			<tr>
					<td>轻型列表</td>
					<td>25</td>
					<td>357</td>
					<td>61ms</td>
					<td>0%</td>
			</tr>
			<tr>
					<td>重型列表</td>
					<td>50</td>
					<td>309</td>
					<td>347ms</td>
					<td>0%</td>
			</tr>
	</tbody>
</table>
<p>而决定其他一切的那个数字，来自在<strong>单台 shared-cpu-1x 机器</strong>上对社区市集的压测。在旧的 ASGI 构建里，这曾是一堵硬墙：同步视图被实质串行化到大约<strong>3 个可用槽位</strong>，于是 p95 在约 5 个并发请求以内保持在 300ms 以下，随后当一切都排在 thread_sensitive 锁后面时，超过约 8–10 个并发就塌陷。把拐点往外推的，正是把 API 迁到 WSGI 线程池这件事——每台机器的真实并发槽位从约 3 个变成了 <strong>16 个</strong>，而这个新的上限就是整个自动扩缩容配置的依据。</p>

<h2 class="relative group">Fly.io 上的扩缩容是怎么运作的
    <div id="flyio-上的扩缩容是怎么运作的" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#flyio-%e4%b8%8a%e7%9a%84%e6%89%a9%e7%bc%a9%e5%ae%b9%e6%98%af%e6%80%8e%e4%b9%88%e8%bf%90%e4%bd%9c%e7%9a%84" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>Fly 的模型很简单：你的应用是代理后面的一组相同机器，代理统计每台机器的负载。你只需要声明两个数字：</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-toml" data-lang="toml"><span class="line"><span class="cl"><span class="p">[</span><span class="nx">http_service</span><span class="p">.</span><span class="nx">concurrency</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="nx">type</span> <span class="p">=</span> <span class="s1">&#39;requests&#39;</span>
</span></span><span class="line"><span class="cl">  <span class="nx">soft_limit</span> <span class="p">=</span> <span class="mi">12</span>   <span class="c"># 超过就启动另一台机器</span>
</span></span><span class="line"><span class="cl">  <span class="nx">hard_limit</span> <span class="p">=</span> <span class="mi">24</span>   <span class="c"># 超过就直接卸载负载而不是排队</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">auto_stop_machines</span> <span class="p">=</span> <span class="s1">&#39;stop&#39;</span>
</span></span><span class="line"><span class="cl"><span class="nx">auto_start_machines</span> <span class="p">=</span> <span class="kc">true</span>
</span></span><span class="line"><span class="cl"><span class="nx">min_machines_running</span> <span class="p">=</span> <span class="mi">1</span></span></span></code></pre></div></div>
<p>**扩容：**当一台机器上的在途（in-flight）请求超过软上限（soft limit），代理会启动一台停止中的机器，并把新流量路由过去。WSGI 线程池让每台机器有 16 个真实并发槽位，所以软上限设为 12——约为池子的 75%，于是第二台机器会在线程还有余量时启动，而不是等用户已经在承受数秒延迟之后。硬上限 24（池子的 1.5 倍）是熔断器：短促的突发会在线程上排队，超过它，代理宁可卸载负载，也不让一台机器被压垮。（旧的 ASGI 构建只有约 3 个真实槽位，用的是 8/20；正是把池子拓宽，才让这两个数字都能往上调。）</p>
<p>**缩容：**流量回落时，Fly 自动停掉空闲机器，最低降到 <code>min_machines_running = 1</code>。停止的机器不产生计算费用，只收 rootfs 存储费，所以每个应用的基线成本就是字面意义上的一台小虚拟机，而突发容量随时待命。</p>
<p>我原本在这里写着，停止的机器&quot;冷启动不到一秒&quot;。这是错的，而且错得很贵。当我不再假设、真正去测量之后，一次冷启动要 <strong>25 到 33 秒</strong>，落到一台还在启动的机器上的请求，就得把这段时间整个等完。我一开始把 CDN 面板上 22% 的失败率归咎于这些冷启动，当时健康检查一直是绿的。后来才发现，那个数字是 CDN 自己的 Early Hints 探测请求在源站失败造成的，真实客户端一个 504 都没收到。不过冷启动本身确实存在。</p>
<p>解法不在上面的伸缩数字里，那些数字没问题。解法在于机器启动过程中做了什么，以及让 Fly 挂起机器而不是停止它们——那样唤醒就变成大约 3 秒的内存恢复。我单独写了一篇：<a href="https://jared.lynskey.co.nz/zh-cn/posts/2026/2026-09-09-scale-to-zero-504s/" >缩容到零，于是每次重启都是一次 30 秒的故障</a> 讲了诊断过程和该改什么。如果你在 Fly 上跑着任何用了 <code>auto_stop_machines</code> 的东西，先读那篇，再来相信这一段。</p>
<p>一个微妙之处：并发类型是 <code>requests</code> 而不是 <code>connections</code>。现代客户端会一直保持 keep-alive 连接，所以按连接数统计时数字在真实负载下几乎不动，自动扩缩容永远不会触发。统计在途请求，才能追踪真实的工作量。</p>

<h3 class="relative group">WebSocket 在另一条轴上扩缩
    <div id="websocket-在另一条轴上扩缩" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#websocket-%e5%9c%a8%e5%8f%a6%e4%b8%80%e6%9d%a1%e8%bd%b4%e4%b8%8a%e6%89%a9%e7%bc%a9" aria-label="锚点">#</a>
    </span>
    
</h3>
<p>社区市集把 WebSocket 服务器拆成了<strong>第二个 Fly 应用</strong>，与 API 共享同一个 Docker 镜像。API 应用用 WSGI 跑 1 个 worker × 16 个阻塞线程，按<em>请求</em>计数（软上限 12）；WebSocket 应用在一台 <strong>512MB</strong> 的机器上用 ASGI 配 uvloop 跑 1 个 worker，按<em>连接</em>计数：</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-toml" data-lang="toml"><span class="line"><span class="cl"><span class="p">[</span><span class="nx">http_service</span><span class="p">.</span><span class="nx">concurrency</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="nx">type</span> <span class="p">=</span> <span class="s1">&#39;connections&#39;</span>
</span></span><span class="line"><span class="cl">  <span class="nx">soft_limit</span> <span class="p">=</span> <span class="mi">1500</span>
</span></span><span class="line"><span class="cl">  <span class="nx">hard_limit</span> <span class="p">=</span> <span class="mi">2000</span></span></span></code></pre></div></div>
<p>一条长连接维持起来几乎零成本，却会占用一个槽位好几个小时；而一个 HTTP 请求只占用槽位几毫秒——同一个扩缩容信号无法同时服务两者。拆开之后，每个机群都按对自己诚实的指标扩缩，而空闲的 WebSocket 容量只花 512MB，不是 2GB。在 Channels 这一侧，Redis 层以 <code>capacity: 1500</code>、消息 60 秒过期运行，并每 30 秒发送 socket keepalive——因为 Fly 的 Redis 代理会把 Channels 赖以工作的长时间 BRPOP 连接当作空闲连接掐掉。</p>

<h2 class="relative group">把计算卸载到边缘和客户端
    <div id="把计算卸载到边缘和客户端" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e6%8a%8a%e8%ae%a1%e7%ae%97%e5%8d%b8%e8%bd%bd%e5%88%b0%e8%be%b9%e7%bc%98%e5%92%8c%e5%ae%a2%e6%88%b7%e7%ab%af" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>最便宜的服务器工作，是服务器根本不用做的工作：</p>
<ul>
<li><strong>静态文件和媒体</strong>放在 Fly 的 S3 兼容对象存储上，私有媒体通过签名 URL 走 CDN 分发——图片的每一个字节都不经过 Django 机器。</li>
<li>**AI 推理跑在用户的手机上。**两个应用都内嵌了一个小型本地 LLM（量化的 4B 模型，约 2.7GB），直接在设备上运行。服务端推理成本为零，而且离线也能用。</li>
<li><strong>离线优先的移动端</strong>（设备上的 SQLite 加带重试的同步队列）意味着应用会把写操作攒批、容忍信号盲区，而不是每敲一个键就向 API 发一次琐碎请求。</li>
</ul>

<h2 class="relative group">其余的技术栈，简单说
    <div id="其余的技术栈简单说" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e5%85%b6%e4%bd%99%e7%9a%84%e6%8a%80%e6%9c%af%e6%a0%88%e7%ae%80%e5%8d%95%e8%af%b4" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>认证用托管的身份服务加 WebAuthn 通行密钥（passkey），WebSocket 连接在协议升级完成前就完成认证。生产用 Postgres，开发用 SQLite。后台管理和审计记录用了几个现成的 Django 包。移动端是基于 Expo 的 React Native 和 TypeScript，配 Expo Router 和 Tailwind，OTA 更新由自托管的 Expo Updates 服务器下发，应用内订阅交给一个订阅管理服务。质量关卡：后端 pytest 和 mypy，客户端单元测试和端到端测试。</p>

<h2 class="relative group">值得你拿走的东西
    <div id="值得你拿走的东西" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e5%80%bc%e5%be%97%e4%bd%a0%e6%8b%bf%e8%b5%b0%e7%9a%84%e4%b8%9c%e8%a5%bf" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>可迁移的想法不是某个具体的库，而是这个循环本身：把一台便宜机器做到真正的快（Rust 热路径、连接复用、在真正的瓶颈前面加缓存、能卸给 CDN 和客户端的都卸掉）；压测到找出它到底在哪个并发数崩溃；把自动扩缩容的软上限设在那个拐点上，让空闲机器停机，把最小机群保持在 1。两个生产应用、实时功能、AI 助手——而平时的账单，只是这个平台上最便宜的几台虚拟机。</p>
]]></content:encoded>
      <media:content url="https://jared.lynskey.co.nz/en/posts/2026/2026-07-22-my-current-stack/featured.jpg" medium="image" type="image/jpeg" />
    </item>
  </channel>
</rss>
