<?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>Tech Stack · Nhân Tài Đức</title>
    <link>https://jared.lynskey.co.nz/vi/tags/tech-stack/</link>
    <description>Những câu chuyện ngắn về kỹ thuật phần mềm và lãnh đạo đội ngũ kỹ sư — performance review, tuyển dụng và mở rộng team, CI/CD, giám sát DevOps và AI agent. Viết từ Seoul.</description>
    <generator>Hugo</generator>
    <language>vi</language>
    <copyright>© 2026 Nhân Tài Đức</copyright>
    <lastBuildDate>Sat, 07 Nov 2026 00:00:00 +1300</lastBuildDate>
    <atom:link href="https://jared.lynskey.co.nz/vi/tags/tech-stack/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Giám sát Django trên Fly.io: những công cụ DevOps tôi giữ lại và đã bỏ</title>
      <link>https://jared.lynskey.co.nz/vi/posts/2026/2026-10-22-monitoring-tools-two-products/</link>
      <guid isPermaLink="true">https://jared.lynskey.co.nz/vi/posts/2026/2026-10-22-monitoring-tools-two-products/</guid>
      <pubDate>Thu, 22 Oct 2026 00:00:00 +1300</pubDate>
      <dc:creator>Jared Lynskey</dc:creator>
      <category>DevOps</category>
      <category>Monitoring</category>
      <category>Observability</category>
      <category>Site Reliability</category>
      <category>Fly.io</category>
      <category>Django</category>
      <category>Cloudflare</category>
      <category>Sentry</category>
      <category>Crash Reporting</category>
      <category>Small Teams</category>
      <category>Tech Stack</category>
      <description>Cách tôi giám sát hai ứng dụng Django nhỏ trên Fly.io với khoảng 2 đô la mỗi tháng: lỗi gửi vào chat, nhật ký lưu trên S3 truy vấn bằng DuckDB, chỉ số của Fly, báo cáo crash, và những gì tôi đã bỏ.</description>
      <content:encoded><![CDATA[<p>Tôi có hai sản phẩm nhỏ: một ứng dụng sàn giao dịch kiêm cộng đồng mà tôi đang làm, và một ứng dụng báo giá cho thợ làm nghề phải đo đạc, báo giá ngay tại nhà khách. Cả hai đều chạy trên loại máy rẻ nhất của Fly.io. Hệ thống giám sát DevOps của tôi rốt cuộc gói gọn trong năm thứ: một kênh chat nhận mọi nhật ký (log) mức ERROR, toàn bộ nhật ký được lưu vào object storage và truy vấn bằng DuckDB, bộ chỉ số (metric) Prometheus có sẵn của Fly, báo cáo sự cố ứng dụng trên điện thoại gửi qua SDK mã nguồn mở của Sentry về API của chính tôi, và một bản tóm tắt mỗi sáng.</p>
<p>Không có APM thuê ngoài, không có truy vết (tracing) trên production, cũng không có bảng điều khiển (dashboard) nào mà tôi phải nhớ để mở ra xem. Thứ duy nhất tốn thêm tiền là kho nhật ký, khoảng 2 đô la Mỹ mỗi tháng. Dưới đây là danh sách đầy đủ, cùng những thứ tôi đã bỏ hoặc thôi tin tưởng, trong đó có một thứ khiến tôi mất mấy ngày đuổi theo một sự cố mà chưa từng có người dùng nào gặp phải.</p>

<h2 class="relative group">Giám sát ở đây nghĩa là gì, và quy mô nhỏ đến mức nào
    <div id="giám-sát-ở-đây-nghĩa-là-gì-và-quy-mô-nhỏ-đến-mức-nào" 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="#gi%c3%a1m-s%c3%a1t-%e1%bb%9f-%c4%91%c3%a2y-ngh%c4%a9a-l%c3%a0-g%c3%ac-v%c3%a0-quy-m%c3%b4-nh%e1%bb%8f-%c4%91%e1%ba%bfn-m%e1%bb%a9c-n%c3%a0o" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Khi nói giám sát DevOps, ý tôi là hai việc: biết có gì đó hỏng trước khi có người báo cho mình, và tìm ra nguyên nhân mà không phải đoán mò. Mọi công cụ dưới đây đều được đánh giá theo đúng hai tiêu chí đó.</p>
<p>Năm ngoái tôi có viết bài <a href="https://jared.lynskey.co.nz/vi/posts/2025/2025-10-13-devops-monitoring/" >Dựng hệ thống giám sát mà lập trình viên thật sự dùng tới</a>, chủ yếu nghĩ cho các đội: đội nhỏ thì dùng công cụ giám sát có sẵn của nhà cung cấp đám mây, khi đã có hàng trăm dịch vụ thì dùng một APM thuê ngoài. Bài này là đầu nhỏ nhất của cùng một cách nghĩ. Cả hai sản phẩm đều là Django chạy trên máy shared-cpu-1x của Fly, như tôi đã kể trong <a href="https://jared.lynskey.co.nz/vi/posts/2026/2026-07-22-my-current-stack/" >Bộ công nghệ hiện tại của tôi</a>, và cả hai đều chỉ có một lập trình viên là tôi. Nếu coi giám sát là một sản phẩm và lập trình viên là người dùng của nó, thì hệ thống của tôi chỉ có đúng một người dùng: người đọc cảnh báo cũng chính là người sửa lỗi. Khi tôi lấy số liệu nền từ chỉ số của Fly vào tháng Chín, API của sàn giao dịch dùng trung bình 1% CPU. Đây không phải bộ công nghệ cho doanh nghiệp lớn, và tôi cũng không định tô vẽ nó thành như vậy.</p>
<p>Trong ba trụ cột quen thuộc là chỉ số, nhật ký và truy vết, tôi có hai. Cả hai sản phẩm đều không có truy vết phân tán (distributed tracing), vì mỗi sản phẩm chỉ là một codebase Django và một cơ sở dữ liệu, không có ranh giới dịch vụ nào để một trace phải đi qua. Dữ liệu truy vết duy nhất tôi xem là của reverse proxy trên <a href="https://jared.lynskey.co.nz/vi/posts/2026/2026-10-01-cloudflare-warp-dev-network/" >máy trạm của tôi</a>.</p>

<h2 class="relative group">Danh sách
    <div id="danh-sách" 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="#danh-s%c3%a1ch" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<table>
	<thead>
			<tr>
					<th>Công cụ</th>
					<th>Theo dõi cái gì</th>
					<th>Giữ hay bỏ, và vì sao</th>
					<th>Chi phí</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Kênh chat của đội, nhận dữ liệu từ một logging handler của Django</td>
					<td>Mọi lỗi ERROR từ API, máy chủ WebSocket và worker; các lần triển khai; nhập sai mã đăng nhập dồn dập</td>
					<td>Giữ. Đây là nơi duy nhất tôi tự xem mà không cần ai nhắc</td>
					<td>Miễn phí</td>
			</tr>
			<tr>
					<td>Log shipper của Fly đẩy sang một bucket tương thích S3, truy vấn bằng DuckDB</td>
					<td>Mọi dòng nhật ký của các ứng dụng thuộc sàn giao dịch</td>
					<td>Giữ. Bộ đệm của Fly chỉ giữ vài phút; chỗ này giữ tất cả, lại truy vấn được bằng SQL</td>
					<td>Khoảng 2 đô la/tháng, cộng phí lưu trữ</td>
			</tr>
			<tr>
					<td>Chỉ số có sẵn của Fly (Prometheus API)</td>
					<td>CPU, bộ nhớ, hạn mức burst, số phản hồi; exporter của Postgres được quản lý</td>
					<td>Giữ. Nó cho thấy các lần cơ sở dữ liệu bị treo không phải do code của tôi</td>
					<td>Có sẵn trong Fly</td>
			</tr>
			<tr>
					<td>Kiểm tra tình trạng (health check) của Fly trên <code>/api/health/</code> (cả hai ứng dụng)</td>
					<td>Một máy có nên nhận lưu lượng hay không</td>
					<td>Giữ để định tuyến. Bỏ, nếu coi nó là bằng chứng người dùng vẫn ổn</td>
					<td>Có sẵn trong Fly</td>
			</tr>
			<tr>
					<td>SDK của Sentry, với DSN trỏ về API của tôi</td>
					<td>Ứng dụng bị crash trên điện thoại</td>
					<td>Giữ SDK. Chưa bao giờ đăng ký sentry.io</td>
					<td>Không tốn thêm gì ngoài API</td>
			</tr>
			<tr>
					<td>Bản tóm tắt buổi sáng trong kênh chat của đội</td>
					<td>Lỗi, mức sử dụng, tìm kiếm, tin nhắn và bảng công việc của hôm trước</td>
					<td>Giữ. Chuyển từ một tác vụ cron trên CI sang máy Mac của tôi</td>
					<td>Miễn phí</td>
			</tr>
			<tr>
					<td>SDK phân tích ứng dụng (cả hai ứng dụng), và công cụ quản trị trang web của công cụ tìm kiếm</td>
					<td>Mức sử dụng trên web, iOS và Android; công cụ tìm kiếm nhìn trang web ra sao</td>
					<td>Giữ, đọc qua API</td>
					<td>Miễn phí</td>
			</tr>
			<tr>
					<td>Phân tích GraphQL của Cloudflare</td>
					<td>Ai đứng sau một mã trạng thái hay một đường dẫn</td>
					<td>Giữ, nhưng gom nhóm theo user agent trước khi tin</td>
					<td>Gói miễn phí, mỗi truy vấn một ngày</td>
			</tr>
			<tr>
					<td>Dashboard của một dịch vụ cập nhật OTA thuê ngoài</td>
					<td>Điện thoại đang chạy bản phát hành OTA nào; các lần tự quay lui khi crash</td>
					<td>Chuyển sang đây từ một danh sách trong trang quản trị chẳng cho biết gì</td>
					<td>Nằm trong dịch vụ cập nhật</td>
			</tr>
			<tr>
					<td>Một script thăm dò nhỏ</td>
					<td>Các yêu cầu bị lỗi trong lúc triển khai hoặc khởi động lại</td>
					<td>Giữ. Nó gọi thẳng vào origin nên bộ nhớ đệm không che được khoảng hở</td>
					<td>Miễn phí</td>
			</tr>
			<tr>
					<td><code>flyctl logs</code></td>
					<td>Vài phút đầu ra gần nhất của một ứng dụng</td>
					<td>Giữ để xem trực tiếp. Bỏ, nếu dùng làm nơi lưu trữ</td>
					<td>Có sẵn trong Fly</td>
			</tr>
			<tr>
					<td>Cloudflare Early Hints</td>
					<td>Không theo dõi gì cả; đây là tính năng tăng tốc</td>
					<td>Giữ lại, sau khi origin gửi header <code>Link</code>. Các lần cache miss của nó chính là toàn bộ lỗi 504 của zone</td>
					<td>Miễn phí</td>
			</tr>
	</tbody>
</table>
<p>Những dòng không ghi &ldquo;cả hai ứng dụng&rdquo; đều là của sàn giao dịch. Ứng dụng báo giá có ít hơn: health check, nhật ký và chỉ số của Fly, phân tích ứng dụng trên iOS, và một tác vụ xuất cơ sở dữ liệu ra tệp Parquet mỗi ngày để tôi truy vấn bằng DuckDB. Nó chưa có báo cáo crash, cũng chưa có kênh cảnh báo, và đó là chỗ hổng lớn nhất trong bài này. (Xin nói rõ về dòng dịch vụ cập nhật: công ty làm ra dịch vụ đó trả tiền cho tôi để viết bài trên blog của họ.)</p>

<h2 class="relative group">Lỗi: một logging handler gửi vào kênh chat
    <div id="lỗi-một-logging-handler-gửi-vào-kênh-chat" 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="#l%e1%bb%97i-m%e1%bb%99t-logging-handler-g%e1%bb%adi-v%c3%a0o-k%c3%aanh-chat" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Trước tháng Chín, một lỗi 500 chưa được xử lý, một thông báo đẩy (push notification) gửi thất bại hay một frame WebSocket bị hỏng chỉ xuất hiện ở đúng một chỗ là <code>flyctl logs</code>, mà luồng đó thì chẳng ai tự giác ngồi đọc. Giờ đây một logging handler gửi mọi bản ghi từ mức ERROR trở lên vào một kênh chat, dù nó đến từ API, máy chủ WebSocket hay worker chạy nền. Cảnh báo mức WARNING thì tôi cố ý không gửi.</p>
<p>Handler gửi tin từ một luồng nền, nên không bao giờ làm chậm một yêu cầu. Bên trong nó không ghi nhật ký gì, nên không thể tự gọi đệ quy. Và cùng một lỗi chỉ được gửi tối đa mười phút một lần, giới hạn 30 cảnh báo mỗi giờ, nên khi có sự cố bạn chỉ đọc một tin nhắn chứ không phải một nghìn.</p>
<p>Kênh này cũng chứa những thứ tôi muốn đặt cạnh lỗi để đối chiếu: các lần triển khai đều báo lúc bắt đầu, lúc chạy xong và chỗ bị hỏng, kèm commit và người chạy; các bản cập nhật OTA và <a href="https://jared.lynskey.co.nz/vi/posts/2026/2026-09-14-web-releases-without-redeploying/" >các lần phát hành giao diện web</a> cũng vậy. Khi một tài khoản bị nhập sai mã đăng nhập dồn dập, hệ thống cũng ghi ở mức ERROR, nên ai đó đang dò mã sẽ hiện ra ngay cạnh các sự cố.</p>
<p>Hồi tháng Mười có một cảnh báo đến mà không khớp với dòng nào trong bất kỳ nhật ký nào. Từ đó, mỗi cảnh báo mang theo một id ngẫu nhiên ngắn, tên máy và lệnh khởi động tiến trình, đồng thời ghi đúng dòng đó vào nhật ký của tiến trình. Nếu tôi không tìm thấy id ở đâu cả, thì cảnh báo đến từ một tiến trình không ghi nhật ký vào đó, chẳng hạn một phiên SSH. Mọi thứ vào kênh cũng được đẩy vào một luồng dữ liệu mà agent lập trình tôi làm việc cùng đọc được, nên agent đang làm việc với code cũng thấy lỗi cùng lúc với tôi.</p>

<h2 class="relative group">Nhật ký: log shipper của Fly đẩy lên S3, truy vấn bằng DuckDB
    <div id="nhật-ký-log-shipper-của-fly-đẩy-lên-s3-truy-vấn-bằng-duckdb" 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="#nh%e1%ba%adt-k%c3%bd-log-shipper-c%e1%bb%a7a-fly-%c4%91%e1%ba%a9y-l%c3%aan-s3-truy-v%e1%ba%a5n-b%e1%ba%b1ng-duckdb" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Bộ đệm nhật ký của Fly chỉ giữ vài phút đầu ra, khoảng một trăm dòng gần nhất, đủ để theo dõi một lần triển khai nhưng vô dụng với chuyện của ngày hôm qua. Vì vậy một ứng dụng Fly thứ ba chạy log shipper của Fly, tức là Vector đăng ký nghe luồng nhật ký của cả tổ chức, và tôi chỉ đổi một chỗ ở sink S3 của nó:</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">sinks</span><span class="p">.</span><span class="nx">aws_s3</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="nx">type</span> <span class="p">=</span> <span class="s2">&#34;aws_s3&#34;</span>
</span></span><span class="line"><span class="cl">  <span class="nx">bucket</span> <span class="p">=</span> <span class="s2">&#34;myapp-logs&#34;</span>
</span></span><span class="line"><span class="cl">  <span class="nx">compression</span> <span class="p">=</span> <span class="s2">&#34;gzip&#34;</span>
</span></span><span class="line"><span class="cl">  <span class="nx">key_prefix</span> <span class="p">=</span> <span class="s2">&#34;logs/{{fly.app.name}}/%F/&#34;</span>   <span class="c"># one folder per app per day</span>
</span></span><span class="line"><span class="cl">  <span class="nx">batch</span><span class="p">.</span><span class="nx">timeout_secs</span> <span class="p">=</span> <span class="mi">300</span>                  <span class="c"># a quiet app still lands its lines</span></span></span></code></pre></div></div>
<p>Mọi dòng nhật ký của các ứng dụng thuộc sàn giao dịch đều được ghi vào một bucket tương thích S3 dưới dạng JSON nén gzip. Shipper chạy trên một máy shared-cpu-1x 256 MB, khoảng 2 đô la mỗi tháng, phí lưu trữ chỉ vài xu. DuckDB đọc thẳng các tệp tại chỗ thông qua một macro, và dữ liệu của một ngày trả về trong khoảng một giây:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sql" data-lang="sql"><span class="line"><span class="cl"><span class="k">CREATE</span><span class="w"> </span><span class="n">MACRO</span><span class="w"> </span><span class="n">logs</span><span class="p">(</span><span class="n">app</span><span class="p">,</span><span class="w"> </span><span class="k">day</span><span class="w"> </span><span class="p">:</span><span class="o">=</span><span class="w"> </span><span class="s1">&#39;*&#39;</span><span class="p">)</span><span class="w"> </span><span class="k">AS</span><span class="w"> </span><span class="k">TABLE</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="k">SELECT</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="k">FROM</span><span class="w"> </span><span class="n">read_json_auto</span><span class="p">(</span><span class="s1">&#39;s3://myapp-logs/logs/&#39;</span><span class="w"> </span><span class="o">||</span><span class="w"> </span><span class="n">app</span><span class="w"> </span><span class="o">||</span><span class="w"> </span><span class="s1">&#39;/&#39;</span><span class="w"> </span><span class="o">||</span><span class="w"> </span><span class="k">day</span><span class="w"> </span><span class="o">||</span><span class="w"> </span><span class="s1">&#39;/*.log.gz&#39;</span><span class="p">,</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                               </span><span class="n">union_by_name</span><span class="w"> </span><span class="p">:</span><span class="o">=</span><span class="w"> </span><span class="k">true</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="k">SELECT</span><span class="w"> </span><span class="k">timestamp</span><span class="p">,</span><span class="w"> </span><span class="n">message</span><span class="w"> </span><span class="k">FROM</span><span class="w"> </span><span class="n">logs</span><span class="p">(</span><span class="s1">&#39;myapp-api&#39;</span><span class="p">,</span><span class="w"> </span><span class="s1">&#39;2026-09-06&#39;</span><span class="p">)</span><span class="w"> </span><span class="k">WHERE</span><span class="w"> </span><span class="n">message</span><span class="w"> </span><span class="k">LIKE</span><span class="w"> </span><span class="s1">&#39;% 500 %&#39;</span><span class="p">;</span></span></span></code></pre></div></div>
<p>Tôi đã dùng chính macro này để đo thời gian khởi động nguội (cold start) trong <a href="https://jared.lynskey.co.nz/vi/posts/2026/2026-09-09-scale-to-zero-504s/" >bài về scale to zero</a>: script khởi động báo từng giai đoạn, dòng nào cũng mang id của máy, phần còn lại chỉ là một câu <code>GROUP BY</code>.</p>
<p>Nói gọn lại, đó là ba tầng của cùng một luồng, chia theo người đọc: kho lưu trữ giữ mọi thứ từ INFO trở lên (cũng là lý do các ứng dụng ghi nhật ký ở mức INFO trên production), một script xem trực tiếp chỉ hiện cảnh báo và lỗi, còn kênh chat nhận mức ERROR. Có điều, cả ba đều không biết ai là người gọi. Nhật ký truy cập không có IP hay user agent của client, nên muốn biết điều đó tôi phải sang Cloudflare.</p>

<h2 class="relative group">Chỉ số: Prometheus có sẵn của Fly
    <div id="chỉ-số-prometheus-có-sẵn-của-fly" 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="#ch%e1%bb%89-s%e1%bb%91-prometheus-c%c3%b3-s%e1%ba%b5n-c%e1%bb%a7a-fly" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Fly chạy sẵn một Prometheus được quản lý cho mỗi tổ chức, nên tôi không phải vận hành hệ thống chỉ số riêng. Khi có câu hỏi, tôi gọi thẳng API của nó: bộ nhớ, CPU và hạn mức burst theo từng máy (trên CPU dùng chung thì <code>fly_instance_cpu_balance</code> rất quan trọng), số phản hồi và số yêu cầu đồng thời theo từng ứng dụng. Có hai điều tôi ước mình biết sớm hơn. Token tạo bằng <code>fly tokens create</code> phải gửi dưới dạng <code>Authorization: FlyV1 &lt;token&gt;</code>; <code>Bearer</code> chỉ dùng được với token cá nhân từ <code>flyctl auth token</code>, còn token chỉ đọc sẽ nhận về &ldquo;something went wrong resolving organization&rdquo;. Và dữ liệu chỉ được giữ khoảng hai tuần (Fly nói là khoảng 15 ngày).</p>
<p>Nó chứng minh giá trị của mình vào tháng Chín, khi nhật ký xuất hiện &ldquo;Could not open a database connection&rdquo; vài lần mỗi ngày, trông y hệt một lỗi của ứng dụng. Cụm Postgres được quản lý cũng nằm trong cùng Prometheus đó, và ở mỗi phút có lỗi, thời gian scrape của máy chủ chính (primary) nhảy từ khoảng 80 mili giây lên một đến mười giây, trong khi bản sao (replica) vẫn bình thường và thời điểm khởi động của Postgres không hề đổi. Tức là Postgres không khởi động lại; chính máy chủ vật lý bên dưới bị treo. Tôi gửi các mốc thời gian cho bộ phận hỗ trợ của Fly, và sau một lần khởi động lại để bảo trì vào đầu tháng Mười đưa primary sang máy khác, tình trạng treo hằng ngày đã chấm dứt.</p>

<h2 class="relative group">Báo cáo crash: SDK của Sentry, trỏ về API của chính tôi
    <div id="báo-cáo-crash-sdk-của-sentry-trỏ-về-api-của-chính-tôi" 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="#b%c3%a1o-c%c3%a1o-crash-sdk-c%e1%bb%a7a-sentry-tr%e1%bb%8f-v%e1%bb%81-api-c%e1%bb%a7a-ch%c3%adnh-t%c3%b4i" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Trước đây, khi ứng dụng crash trên điện thoại thì tôi không thấy dấu vết gì ở bất cứ đâu. Câu trả lời hiển nhiên là Sentry, và tôi lấy một nửa của nó: ứng dụng dùng SDK mã nguồn mở của Sentry, nhưng DSN trỏ vào một endpoint trong chính API Django của tôi. Endpoint này nhận định dạng envelope của Sentry, gom nhóm các lần crash và cảnh báo qua đúng handler gửi vào kênh chat ở trên. Truy vết, phiên (session) và replay đều tắt; chỉ nhận lỗi.</p>
<p>Tôi không đăng ký sentry.io vì với vài báo cáo mỗi ngày, làm vậy nghĩa là thêm một nhà cung cấp nắm dữ liệu người dùng, thêm một dòng trong chính sách quyền riêng tư và thêm một hóa đơn. Cái giá phải trả là symbolication (giải mã stack trace về mã nguồn), thứ tôi vẫn chưa thay thế được. Stack trace hoặc là JavaScript đã bị rút gọn (minify), hoặc là địa chỉ native thô, nên một issue cho tôi biết cái gì crash, trên bản phát hành và thiết bị nào, người dùng vừa làm gì ngay trước đó, nhưng không cho biết lỗi nằm ở đâu trong mã nguồn.</p>

<h2 class="relative group">Bảng điều khiển duy nhất là một tin nhắn
    <div id="bảng-điều-khiển-duy-nhất-là-một-tin-nhắn" 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="#b%e1%ba%a3ng-%c4%91i%e1%bb%81u-khi%e1%bb%83n-duy-nh%e1%ba%a5t-l%c3%a0-m%e1%bb%99t-tin-nh%e1%ba%afn" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Tôi không dựng bảng điều khiển cho ứng dụng nào cả. Bài năm ngoái có một phép thử cho dashboard: nếu không ai tự mở nó ra, nó chưa chứng minh được giá trị. Một tin nhắn tự gửi đến thì không cần ai mở, nên thứ gần với dashboard nhất mà tôi có là một bài đăng trong kênh chat của đội mỗi sáng.</p>
<p>Phần đầu là các lỗi production trong 24 giờ qua, đọc từ kho nhật ký chứ không phải từ kênh chat, vì cảnh báo đã bị giới hạn tần suất nên không thể cho biết một chuyện xảy ra bao nhiêu lần. Số, id và địa chỉ được che đi trước khi gom nhóm, nên một trăm lần cùng một lỗi chỉ là một dòng kèm số lần, và không địa chỉ email nào lọt vào kênh.</p>
<p>Tiếp theo là các lần health check thất bại, mức sử dụng hôm qua so với cùng thứ đó của tuần trước (Chủ nhật thì không bao giờ giống thứ Hai), lượt truy cập từ tìm kiếm của tuần gần nhất, các cuộc trò chuyện đang chờ trả lời, bảng công việc và khoản chi tiêu. Phần nào không tải được thì ghi rõ như vậy, còn bài đăng vẫn được gửi đi.</p>
<p>Đọc số liệu phân tích ứng dụng qua API dạy bạn nghi ngờ con số một chút. Tháng Tám có 121 lượt mở ứng dụng Android lần đầu từ Azerbaijan, kéo theo 119 lượt gỡ cài đặt, và tôi đọc tổng số Android của tháng đó sau khi đã trừ chúng ra.</p>
<p>Các bản phát hành có màn hình riêng. Hồi bản cập nhật OTA còn được phát từ máy chủ của tôi, cách duy nhất để xem một bản phát hành là một danh sách trong trang quản trị có ô &ldquo;is active&rdquo;, và tôi hoàn toàn không biết có bao nhiêu điện thoại đã nhận bản cập nhật. Dashboard của dịch vụ mới cho thấy các thiết bị thật sự đang chạy bản nào, việc cài đặt diễn ra ra sao, và cả lần quay lui khi một bundle lỗi bị crash và SDK đưa bản trước đó quay lại. Tôi đã viết riêng về <a href="https://jared.lynskey.co.nz/vi/posts/2026/2026-09-13-moving-to-codemagic-patch/" >việc chuyển sang một dịch vụ cập nhật thuê ngoài</a>.</p>

<h2 class="relative group">Những thứ tôi đã bỏ, hoặc thôi tin
    <div id="những-thứ-tôi-đã-bỏ-hoặc-thôi-tin" 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="#nh%e1%bb%afng-th%e1%bb%a9-t%c3%b4i-%c4%91%c3%a3-b%e1%bb%8f-ho%e1%ba%b7c-th%c3%b4i-tin" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Không có thứ nào trong số này là công cụ trả phí. Phần lớn là những thứ tôi vẫn coi là tín hiệu nhưng hóa ra không phải, và một tác vụ chạy sai chỗ.</p>

<h3 class="relative group">Tỷ lệ 504 của Cloudflare, cho tới khi tôi gom nhóm theo user agent
    <div id="tỷ-lệ-504-của-cloudflare-cho-tới-khi-tôi-gom-nhóm-theo-user-agent" 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="#t%e1%bb%b7-l%e1%bb%87-504-c%e1%bb%a7a-cloudflare-cho-t%e1%bb%9bi-khi-t%c3%b4i-gom-nh%c3%b3m-theo-user-agent" aria-label="Cọc dấu">#</a>
    </span>
    
</h3>
<p>Tháng Chín, dashboard của Cloudflare cho thấy có vẻ như 22% số yêu cầu trong một ngày thất bại với lỗi 504, dồn vào các endpoint mà ứng dụng thăm dò (poll) mỗi 30 giây, trong khi health check vẫn xanh hết và nhật ký của chính ứng dụng cho thấy các yêu cầu đó được xử lý rất nhanh. Tôi mất mấy ngày với nó, phát hiện máy cần 25 đến 33 giây để khởi động nguội và phải làm thế 92 lần mỗi ngày, sửa xong, rồi viết trong <a href="https://jared.lynskey.co.nz/vi/posts/2026/2026-09-09-scale-to-zero-504s/" >bài về scale to zero</a> rằng đó là nguyên nhân.</p>
<p>Sáng hôm sau tôi gom nhóm chính những lỗi 504 đó theo user agent. Toàn bộ 7,344 lỗi từ ngày 5 đến ngày 9 tháng Chín đều đến từ các lượt tra cứu cache Early Hints của chính Cloudflare (user agent là <code>bastion early hints</code> và <code>nginx-ssl early hints</code>); chúng không bao giờ đi tới origin, và mã 504 trên những dòng đó ghi lại một lần cache miss chứ không phải timeout. Chúng bắt chước đường dẫn của yêu cầu thật, nên rơi đúng vào những endpoint bận nhất và trông y như người dùng đang gặp lỗi. Ứng dụng, trình duyệt, curl và trình thu thập dữ liệu của công cụ tìm kiếm không có lấy một lỗi nào. Origin khi đó không gửi header <code>Link</code>, nên Early Hints thực ra chẳng làm được gì, và tôi đã tắt nó; về sau tôi <a href="https://jared.lynskey.co.nz/vi/posts/2026/cloudflare-504-early-hints/" >làm cho nó hoạt động thật sự</a>.</p>
<p>Công sức tối ưu khởi động nguội vẫn có ích, vì triển khai và đánh thức máy đều nhanh hơn, nhưng sự cố mà tôi tưởng mình đang sửa thì chưa từng chạm tới người dùng nào.</p>
<p>Vì thế, quy tắc tôi muốn chia sẻ nhất là: trước khi tin vào tỷ lệ lỗi của CDN, hãy gom nhóm theo user agent và kiểm tra xem đó có phải do chính cơ chế của CDN sinh ra không. Trên gói miễn phí của Cloudflare, đó là một truy vấn GraphQL vào <code>httpRequestsAdaptiveGroups</code>, mỗi lần một ngày. Lần hoảng tiếp theo cũng được giải quyết bằng đúng truy vấn đó, khi một endpoint thăm dò tăng từ 70–260 yêu cầu mỗi ngày lên 2,880. Không phải công cụ cào dữ liệu (scraper) nào cả. Đó là chính máy Mac của tôi, với ứng dụng vẫn đang chạy trong trình giả lập iOS sau khi kiểm thử.</p>

<h3 class="relative group">Một health check báo xanh
    <div id="một-health-check-báo-xanh" 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="#m%e1%bb%99t-health-check-b%c3%a1o-xanh" aria-label="Cọc dấu">#</a>
    </span>
    
</h3>
<p>Fly kiểm tra <code>/api/health/</code> của cả hai ứng dụng mỗi 30 giây và dùng kết quả để quyết định máy nào được nhận lưu lượng, và nó làm việc này tốt. Nhưng health check chạy trên một máy đã khởi động xong, nên nó không thấy những gì xảy ra trước đó: một lần khởi động nguội, một hàng đợi ở proxy, một yêu cầu không bao giờ tới nơi. Giờ tôi chỉ nhờ nó định tuyến.</p>
<p>Khi triển khai, tôi dùng script thăm dò thay thế: nó gọi vào origin suốt quá trình và thoát với mã 1 nếu có bất kỳ yêu cầu nào lỗi. Script này đã bắt được một lần <code>flyctl deploy</code> thông thường để lại khoảng hở 7.3 giây, rồi ghi nhận không lỗi nào trong 2,514 yêu cầu khi chạy qua script triển khai, vốn đánh thức một máy dự phòng trước.</p>
<p>Bản thân health check cũng từng gây ra hai sự cố. Tháng Bảy, thiết lập <code>SECURE_SSL_REDIRECT</code> của Django trả lời yêu cầu thăm dò HTTP thường của Fly bằng mã 301, mọi máy đều trượt kiểm tra, và ai cũng nhận về lỗi 503. Tháng Tám, việc thu hẹp một <code>except Exception</code> trong view health check khiến lỗi &ldquo;connection already closed&rdquo; lọt ra thành 500, và Fly gỡ máy ra đúng trong trường hợp mà cơ chế thử lại của view được viết ra để xử lý. Giờ health check chỉ hỏi một câu: tiến trình này có phục vụ được yêu cầu không, và khi cơ sở dữ liệu bị treo thì cả hai ứng dụng không còn bị gỡ khỏi định tuyến nữa.</p>
<p>Bản tóm tắt buổi sáng cũng phải học bài học tương tự về cách đếm. Sàn giao dịch tạm ngưng (suspend) các máy đang rảnh, nên một máy bị đánh thức bởi yêu cầu sẽ trượt lần kiểm tra đầu tiên vài trăm mili giây sau khi khởi động và qua ở lần kế tiếp. Đếm cả những lần đó khiến sáng nào đọc cũng như có sự cố, nên giờ lỗi nào qua lại được trong vòng một phút sẽ được liệt kê riêng, ghi là máy thức dậy và các lần triển khai.</p>

<h3 class="relative group">Một tác vụ định kỳ trên CI
    <div id="một-tác-vụ-định-kỳ-trên-ci" 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="#m%e1%bb%99t-t%c3%a1c-v%e1%bb%a5-%c4%91%e1%bb%8bnh-k%e1%bb%b3-tr%c3%aan-ci" aria-label="Cọc dấu">#</a>
    </span>
    
</h3>
<p>Bản tóm tắt buổi sáng ban đầu là một workflow CI chạy theo lịch cron, và chỉ trong vòng một ngày đã phải chuyển đi. Khi nó cần đọc số liệu phân tích và tìm kiếm, khóa cần dùng là khóa tài khoản dịch vụ (service account) của dự án phân tích, thứ làm được mọi việc trong dự án đó, và tôi không muốn để nó trong secrets của CI. Giờ một trình lập lịch trên máy Mac của tôi chạy nó mỗi 20 phút, và nó chỉ đăng bài khi đã qua tám giờ sáng theo giờ Auckland mà bài của hôm nay chưa được gửi, nên một chiếc Mac đang ngủ lúc tám giờ sẽ đăng khi nó thức dậy. Workflow vẫn được giữ làm phương án dự phòng chạy tay, chỉ thiếu hai phần phân tích và tìm kiếm.</p>

<h2 class="relative group">Nếu được bắt đầu lại
    <div id="nếu-được-bắt-đầu-lại" 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="#n%e1%ba%bfu-%c4%91%c6%b0%e1%bb%a3c-b%e1%ba%aft-%c4%91%e1%ba%a7u-l%e1%ba%a1i" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Tôi sẽ dựng ba thứ trước khi có người dùng đầu tiên, chứ không đợi tới sau sự cố đầu tiên: gửi lỗi vào một kênh chat mà đội vốn đã đọc, có giới hạn tần suất; một kho nhật ký trên object storage truy vấn được bằng SQL; và những chỉ số mà nền tảng vốn đã thu thập sẵn. Tất cả chỉ tốn vài đô la mỗi tháng. Báo cáo crash thì thêm vào đúng tuần ứng dụng lên điện thoại, vì nếu không, một lần crash trên điện thoại chẳng báo cho ai biết điều gì. Bản tóm tắt buổi sáng thì thêm vào khi số chỗ phải kiểm tra đã nhiều tới mức tôi sắp chẳng buồn kiểm tra chỗ nào nữa.</p>
<p>Truy vết thì tôi để dành cho tới khi có dịch vụ thứ hai để một yêu cầu phải đi qua, còn APM dạng dịch vụ thuê ngoài thì đợi tới khi có một đội cần dashboard dùng chung, lịch trực (on-call) và ngân sách để trả hóa đơn cho người khác. Đó là lúc những công cụ trong bài năm ngoái bắt đầu đáng đồng tiền. Trước lúc đó, thói quen hữu ích nhất lại miễn phí: khi một con số trông đáng sợ, hãy tìm xem cái gì tạo ra nó trước khi kết luận cái gì bị hỏng. Không ít lần hoảng hốt trong bài này đến từ chính hệ thống giám sát, chứ không phải từ sản phẩm.</p>
]]></content:encoded>
      <media:content url="https://jared.lynskey.co.nz/en/posts/2026/2026-10-22-monitoring-tools-two-products/featured.jpg" medium="image" type="image/jpeg" />
    </item>
    <item>
      <title>Django trên Fly.io: kiểm thử tải và tự động co giãn với tài nguyên tối thiểu</title>
      <link>https://jared.lynskey.co.nz/vi/posts/2026/2026-07-22-my-current-stack/</link>
      <guid isPermaLink="true">https://jared.lynskey.co.nz/vi/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>Tôi chạy hai ứng dụng Django trên máy shared-cpu-1x của Fly.io: tối ưu một máy cho nhanh, kiểm thử tải để tìm điểm độ trễ tăng vọt, rồi đặt ngưỡng tự động co giãn ngay trước đó.</description>
      <content:encoded><![CDATA[<p>Để chạy Django trên Fly.io với chi phí thấp, tôi tối ưu một máy shared-cpu-1x nhỏ cho thật nhanh, kiểm thử tải (load testing) đến khi độ trễ tăng vọt, rồi cấu hình bộ tự động co giãn (autoscaling) của Fly khởi động máy thứ hai ngay trước điểm đó. Phần kiểm thử tải Django tôi dùng Locust với tải tăng theo từng bậc (còn ứng dụng kia dùng một script Python nhỏ quét qua các mức đồng thời), và theo dõi độ trễ p95 cùng tỉ lệ lỗi. Khi lưu lượng giảm, Fly tự dừng các máy rảnh, nên chi phí nền chỉ là một VM nhỏ cho mỗi ứng dụng.</p>
<p>Hiện tại, với vai trò là một lập trình viên độc lập (solo developer), tôi đang vận hành đồng thời hai sản phẩm:</p>
<ul>
<li>một <strong>ứng dụng ước tính và báo giá tại hiện trường (field estimation)</strong> dành cho các kỹ thuật viên/thợ dịch vụ, giúp họ tính chi phí và báo giá công việc ngay tại chỗ;</li>
<li>và một <strong>ứng dụng chợ mua bán kiêm cộng đồng (marketplace)</strong>, với các tính năng như đăng tin và nhắn tin thời gian thực.</li>
</ul>
<p>Hai sản phẩm khác nhau, nhóm người dùng cũng khác nhau, nhưng bộ công nghệ (tech stack) gần như giống hệt nhau — và cả hai đều đang chạy hoàn toàn trên các <strong>máy shared-cpu-1x</strong>, gói rẻ nhất mà Fly.io cung cấp.</p>
<p>Đây là một giới hạn được tôi chủ động lựa chọn.</p>
<p>Thay vì chọn cấu hình máy chủ theo mức tải đỉnh (peak load), tôi cố gắng khai thác tối đa hiệu năng của một máy nhỏ, đo chính xác ngưỡng mà hệ thống bắt đầu gặp điểm nghẽn (bottleneck) hoặc sụp đổ khi tải cao, rồi để bộ tự động co giãn (autoscaler) của Fly.io tự mở rộng hoặc thu hẹp theo chiều ngang (scale out / scale in), thêm hoặc bớt máy dựa trên chính ngưỡng đã đo đó.</p>
<p>Bài viết này sẽ đi vào các kỹ thuật tối ưu hóa giúp mô hình đó khả thi, các số liệu kiểm thử tải (load testing) dùng để xác định ngưỡng mở rộng (scaling threshold), và cách việc tăng, giảm số máy thực tế diễn ra trên Fly.io.</p>

<h2 class="relative group">Triết lý: đo một máy, rồi nhân lên
    <div id="triết-lý-đo-một-máy-rồi-nhân-lên" 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="#tri%e1%ba%bft-l%c3%bd-%c4%91o-m%e1%bb%99t-m%c3%a1y-r%e1%bb%93i-nh%c3%a2n-l%c3%aan" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Chiến lược mở rộng quy mô của cả hai ứng dụng đều gồm ba bước giống nhau:</p>
<ol>
<li>Tối ưu một máy nhỏ cho nhanh nhất trong khả năng hợp lý.</li>
<li>Kiểm thử tải cho đến khi máy gãy, rồi ghi lại số yêu cầu đồng thời (concurrency) mà tại đó độ trễ (latency) bắt đầu vọt lên.</li>
<li>Cấu hình bộ tự động co giãn của Fly để bật máy thứ hai ngay trước điểm đó, và dừng các máy đang rảnh khi lưu lượng truy cập (traffic) giảm.</li>
</ol>
<p>Khi đó, năng lực xử lý tăng gần như tuyến tính theo số máy, còn chi phí nền chỉ là một máy ảo (VM) nhỏ cho mỗi ứng dụng. Mọi thứ trong phần còn lại của bài đều phục vụ một trong ba bước này.</p>

<h2 class="relative group">Tối ưu cho một máy nhỏ chạy nhanh
    <div id="tối-ưu-cho-một-máy-nhỏ-chạy-nhanh" 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="#t%e1%bb%91i-%c6%b0u-cho-m%e1%bb%99t-m%c3%a1y-nh%e1%bb%8f-ch%e1%ba%a1y-nhanh" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>

<h3 class="relative group">Granian: WSGI cho API, ASGI với uvloop cho WebSocket
    <div id="granian-wsgi-cho-api-asgi-với-uvloop-cho-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="#granian-wsgi-cho-api-asgi-v%e1%bb%9bi-uvloop-cho-websocket" aria-label="Cọc dấu">#</a>
    </span>
    
</h3>
<p>Phía máy chủ (backend) của cả hai sản phẩm đều là Django 6 + Django REST Framework. API chạy trên <strong>Granian</strong>, một máy chủ viết bằng Rust, nhưng dùng <strong>WSGI với nhóm luồng chặn (blocking thread pool)</strong> chứ không phải 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>Lúc đầu tôi dùng <code>--interface asgi --loop uvloop</code>, và đó là một quyết định sai. Mọi view HTTP trong hai ứng dụng này đều là đồng bộ (sync), mà trình xử lý ASGI của Django lại chạy view đồng bộ ở chế độ <code>thread_sensitive</code>, tức mỗi tiến trình worker chỉ xử lý được một view tại một thời điểm. Kết quả là với ASGI, mỗi worker chỉ xử lý được khoảng một yêu cầu đồng thời, <em>lại còn</em> phải nạp nguyên bộ asyncio/uvloop/Channels vào RAM mà chẳng được lợi gì. Còn WSGI với <code>--blocking-threads</code> thì chạy chính những view đồng bộ đó trong một nhóm luồng thực thụ: một worker × 16 luồng = 16 yêu cầu nặng về I/O chạy đồng thời (đọc cơ sở dữ liệu, tạo URL ký trước (presigned URL) cho S3), mà bộ nhớ thường trú lại còn thấp hơn bản bất đồng bộ.</p>
<p>Tại sao chỉ dùng một worker? Vì máy ảo là <code>shared-cpu-1x</code>, tức chỉ có một nhân. Thêm worker thứ hai cũng không chạy Python song song được trên một nhân (GIL cộng với chỉ một CPU), nhưng lại tốn thêm nguyên một tiến trình Django thường trú trong bộ nhớ; chính Granian cũng cảnh báo đúng chuyện này. Với các tác vụ nặng về I/O, mười sáu luồng trên một worker là mức trần thực tế của một máy 1 vCPU. Tham số <code>--workers-max-rss 1400</code> sẽ khởi động lại worker nếu nó phình quá giới hạn bộ nhớ, nên nếu một tác vụ tạo PDF hay xử lý ảnh chạy mất kiểm soát thì worker sẽ được thay mới, thay vì kéo cả máy đến chỗ cạn bộ nhớ (OOM).</p>
<p>WebSocket được tách ra chạy trong một tiến trình Granian riêng: một ứng dụng <strong>ASGI</strong> dùng uvloop và <code>--ws</code>, với một worker chuyên giữ các kết nối dài hạn. Phần API đồng bộ hoàn toàn không cần tới ASGI: khi một view cần đẩy dữ liệu xuống socket, nó gọi <code>async_to_sync(channel_layer.group_send)</code> qua Redis, và thông điệp vẫn đến được tiến trình WebSocket. Hai máy chủ, mỗi cái chạy đúng giao diện (interface) mà nó làm tốt nhất. Docker trên máy cục bộ cũng chạy cùng nhóm luồng WSGI đó, nên khi kiểm thử, laptop của tôi mô phỏng khá sát một máy trong môi trường production.</p>

<h3 class="relative group">Dùng Rust ở các đường xử lý nóng
    <div id="dùng-rust-ở-các-đường-xử-lý-nóng" 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="#d%c3%b9ng-rust-%e1%bb%9f-c%c3%a1c-%c4%91%c6%b0%e1%bb%9dng-x%e1%bb%ad-l%c3%bd-n%c3%b3ng" aria-label="Cọc dấu">#</a>
    </span>
    
</h3>
<p>Ở đường xử lý nóng (hot path) nào của Python mà có sẵn một thư viện viết bằng Rust thay thế được ngay, tôi đều dùng:</p>
<ul>
<li><strong>orjson</strong> qua <code>drf-orjson-renderer</code>: mọi phản hồi của API đều được tuần tự hóa bằng Rust thay vì bộ mã hóa JSON của thư viện chuẩn.</li>
<li><strong>blurhash-rs</strong>: tạo ảnh giữ chỗ (placeholder) ngay lúc ảnh được tải lên.</li>
<li><strong>uuid-utils</strong>: sinh UUID bằng Rust.</li>
<li><strong>psycopg 3 (binary)</strong>: trình điều khiển (driver) Postgres được tăng tốc bằng C.</li>
</ul>
<p>Không thư viện nào trong số này làm thay đổi kiến trúc; chúng chỉ nâng mức trần của một vCPU lên, để bạn chưa phải thêm máy thứ hai sớm.</p>

<h3 class="relative group">Loại bỏ những độ trễ ẩn
    <div id="loại-bỏ-những-độ-trễ-ẩn" 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="#lo%e1%ba%a1i-b%e1%bb%8f-nh%e1%bb%afng-%c4%91%e1%bb%99-tr%e1%bb%85-%e1%ba%a9n" aria-label="Cọc dấu">#</a>
    </span>
    
</h3>
<p>Cải thiện lớn nhất trong mã nguồn của cả hai ứng dụng không đến từ thuật toán nào cả, mà từ việc tái sử dụng kết nối. Trong nhóm luồng của Granian, mỗi luồng mới lại tạo một đối tượng client S3 của boto3 mới toanh, và endpoint nào trả về ảnh hay PDF cũng phải gánh chi phí đó. Tôi viết một lớp lưu trữ (storage) nhỏ tùy chỉnh để lưu đệm (cache) client theo từng tiến trình:</p>
<blockquote><p>Thời gian tạo URL có chữ ký trên các luồng mới giảm từ <strong>~150ms xuống ~1ms</strong>.</p>
</blockquote><p>Với cơ sở dữ liệu cũng vậy: Postgres trên Fly nằm sau PgBouncer, nên ứng dụng chạy với <code>conn_max_age=0</code> và để bộ gộp kết nối (pooler) lo phần tái sử dụng kết nối, kèm <code>connect_timeout</code> 5 giây để khi gặp kết nối SSL đã chết thì báo lỗi ngay, chứ không làm treo cả worker.</p>

<h3 class="relative group">Đặt bộ nhớ đệm đúng chỗ đang thực sự nghẽn
    <div id="đặt-bộ-nhớ-đệm-đúng-chỗ-đang-thực-sự-nghẽn" 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="#%c4%91%e1%ba%b7t-b%e1%bb%99-nh%e1%bb%9b-%c4%91%e1%bb%87m-%c4%91%c3%bang-ch%e1%bb%97-%c4%91ang-th%e1%bb%b1c-s%e1%bb%b1-ngh%e1%ba%bdn" aria-label="Cọc dấu">#</a>
    </span>
    
</h3>
<p>Đợt kiểm thử tải phía chợ mua bán cho tôi một bài học đáng nhớ: <strong>mức trần nằm ở số kết nối Postgres, không phải CPU</strong>. Phần lớn lưu lượng duyệt tin đến từ người dùng ẩn danh, và nội dung họ xem giống hệt nhau. Khi tải lên cao, những truy vấn danh sách giống hệt nhau đó làm đầy nhóm kết nối, trong khi CPU vẫn ngồi chơi.</p>
<p>Cách sửa là thêm một lớp bộ nhớ đệm Redis cho các trang danh sách mà người dùng ẩn danh xem, và vô hiệu hóa bộ nhớ đệm bằng bộ đếm phiên bản theo từng không gian tên (namespace): mỗi thao tác ghi chỉ cần tăng một bộ đếm (O(1), không phải theo dõi từng khóa), thế là mọi trang đã lưu đệm của tài nguyên đó lập tức hết hiệu lực. Một thời gian sống (TTL) ngắn làm lưới an toàn cho những trường hợp bị sót. Trả trang duyệt tin thẳng từ Redis gỡ được đúng điểm nghẽn thật, và để cái máy nhỏ dành kết nối cơ sở dữ liệu cho người dùng đã đăng nhập.</p>

<h3 class="relative group">Chạy tác vụ nền mà không cần trình trung gian
    <div id="chạy-tác-vụ-nền-mà-không-cần-trình-trung-gian" 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="#ch%e1%ba%a1y-t%c3%a1c-v%e1%bb%a5-n%e1%bb%81n-m%c3%a0-kh%c3%b4ng-c%e1%ba%a7n-tr%c3%acnh-trung-gian" aria-label="Cọc dấu">#</a>
    </span>
    
</h3>
<p>Cả hai ứng dụng đều dùng <strong>django-tasks-db</strong>, framework tác vụ của Django lưu hàng đợi trong cơ sở dữ liệu, thay cho Celery. Một tiến trình <code>db_worker</code> riêng liên tục thăm dò cơ sở dữ liệu để lấy việc: xử lý ảnh, tạo PDF, dịch máy, gửi nhắc nhở. Không cần trình trung gian thông điệp (broker), không phải dựng và giám sát thêm dịch vụ nào, và tiến trình API không bao giờ bị những việc nặng chặn lại. Worker còn kết nối thẳng tới Postgres, bỏ qua PgBouncer, vì các tác vụ chạy lâu không hợp với chế độ gộp kết nối theo giao dịch (transaction pooling).</p>

<h3 class="relative group">Bộ nhớ: jemalloc và bộ nhớ hoán đổi để dự phòng
    <div id="bộ-nhớ-jemalloc-và-bộ-nhớ-hoán-đổi-để-dự-phòng" 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="#b%e1%bb%99-nh%e1%bb%9b-jemalloc-v%c3%a0-b%e1%bb%99-nh%e1%bb%9b-ho%c3%a1n-%c4%91%e1%bb%95i-%c4%91%e1%bb%83-d%e1%bb%b1-ph%c3%b2ng" aria-label="Cọc dấu">#</a>
    </span>
    
</h3>
<p>Xử lý ảnh và PDF làm bộ nhớ tăng vọt theo những cách mà khi tính toán cấu hình cho trạng thái ổn định bạn không lường trước được. Tôi dùng hai cách giảm thiểu rẻ tiền: nạp sẵn <strong>jemalloc</strong> trong Docker image để giảm phân mảnh bộ nhớ, và bật <strong>bộ nhớ hoán đổi (swap) trên mọi máy</strong> (2GB trên máy API, 1GB trên máy WebSocket), để khi bộ nhớ tăng vọt thì dữ liệu được đẩy xuống đĩa chứ tiến trình không bị hệ thống buộc dừng vì cạn bộ nhớ. Bộ nhớ hoán đổi không phải tính năng giúp tăng hiệu năng; nó là một khoản bảo hiểm, cho phép tôi giữ mức cấp phát bộ nhớ ở mức nhỏ.</p>

<h2 class="relative group">Kiểm thử tải Django: tìm điểm gãy
    <div id="kiểm-thử-tải-django-tìm-điểm-gãy" 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="#ki%e1%bb%83m-th%e1%bb%ad-t%e1%ba%a3i-django-t%c3%acm-%c4%91i%e1%bb%83m-g%c3%a3y" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Một ngưỡng chỉ đáng tin khi nó đã được đo thực tế. Mỗi dự án có bộ công cụ kiểm thử riêng:</p>
<ul>
<li>Ứng dụng báo giá tại hiện trường có một script kiểm thử sức chịu tải nhỏ viết bằng Python, chạy lần lượt qua các mức yêu cầu đồng thời và báo cáo số yêu cầu mỗi giây (RPS), p50/p95/p99 cùng tỉ lệ lỗi. Script chạy trên vài trăm bản ghi mẫu được sinh sẵn, để các endpoint danh sách được truy vấn trên khối lượng dữ liệu sát thực tế.</li>
<li>Chợ mua bán dùng <strong>Locust</strong> với kiểu tải bậc thang, tăng từ 50 → 500 người dùng theo từng bậc 30 giây để tìm điểm bão hòa, với trọng số các endpoint khớp với lưu lượng thực tế (phần lớn là duyệt tin). Ngoài ra còn một bộ kiểm thử nhỏ hơn, tăng từ 5 → 50 người dùng ảo, chạy thẳng vào môi trường production với ngưỡng p95 &lt; 2s.</li>
</ul>
<p>Vài con số tiêu biểu từ lượt đo của ứng dụng báo giá tại hiện trường (một worker Granian × 16 luồng chặn, chạy Docker trên máy phát triển của tôi):</p>
<table>
	<thead>
			<tr>
					<th>Endpoint</th>
					<th>Số yêu cầu đồng thời</th>
					<th>RPS</th>
					<th>p95</th>
					<th>Lỗi</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>health</td>
					<td>25</td>
					<td>602</td>
					<td>52ms</td>
					<td>0%</td>
			</tr>
			<tr>
					<td>danh sách nặng</td>
					<td>25</td>
					<td>309</td>
					<td>260ms</td>
					<td>0%</td>
			</tr>
			<tr>
					<td>danh sách nhẹ</td>
					<td>25</td>
					<td>357</td>
					<td>61ms</td>
					<td>0%</td>
			</tr>
			<tr>
					<td>danh sách nặng</td>
					<td>50</td>
					<td>309</td>
					<td>347ms</td>
					<td>0%</td>
			</tr>
	</tbody>
</table>
<p>Còn con số quyết định mọi thứ khác đến từ đợt kiểm thử tải chợ mua bán trên <strong>một máy shared-cpu-1x duy nhất</strong>. Với bản ASGI cũ, đây là một bức tường cứng: các view đồng bộ bị xếp hàng tuần tự, chỉ còn khoảng <strong>ba suất xử lý (slot) dùng được</strong>, nên p95 giữ dưới 300ms cho đến khoảng 5 yêu cầu đồng thời, rồi sụp hẳn khi vượt <strong>~8–10</strong>, vì mọi yêu cầu đều phải xếp hàng sau cái khóa thread-sensitive. Chính việc chuyển API sang nhóm luồng WSGI đã đẩy điểm gãy đó ra xa: <strong>16 suất đồng thời thực sự</strong> trên mỗi máy thay vì ~3, và mức trần mới này là nền tảng cho toàn bộ cấu hình tự động co giãn.</p>

<h2 class="relative group">Cơ chế co giãn trên Fly.io
    <div id="cơ-chế-co-giãn-trên-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="#c%c6%a1-ch%e1%ba%bf-co-gi%c3%a3n-tr%c3%aan-flyio" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Mô hình của Fly khá đơn giản: ứng dụng của bạn là một nhóm máy giống hệt nhau đứng sau một proxy, và proxy đếm tải trên từng máy. Bạn chỉ cần khai báo hai con số:</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"># past this, start another machine</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"># past this, shed load instead of queueing</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><strong>Khi tải tăng:</strong> khi số yêu cầu đang xử lý trên một máy vượt giới hạn mềm (soft limit), proxy sẽ bật một máy đang dừng và chuyển lưu lượng mới sang đó. Nhóm luồng WSGI cho mỗi máy 16 suất đồng thời thực sự, nên tôi đặt giới hạn mềm ở 12, tức khoảng 75% nhóm luồng, để máy số 2 khởi động khi các luồng vẫn còn dư sức, thay vì đợi đến lúc người dùng phải chờ tới vài giây. Giới hạn cứng (hard limit) đặt ở 24, gấp 1.5 lần nhóm luồng, đóng vai trò cầu dao: những đợt tăng vọt ngắn thì xếp hàng chờ luồng, còn vượt quá mức đó thì proxy sẽ từ chối bớt tải, thay vì để một máy bị quá tải tới mức sập. (Bản ASGI cũ chạy 8/20, tính theo ~3 suất thực của nó; chính việc nới rộng nhóm luồng mới cho phép nâng cả hai con số lên.)</p>
<p><strong>Khi tải giảm:</strong> khi lưu lượng giảm, Fly tự động dừng các máy đang rảnh, xuống tới <code>min_machines_running = 1</code>. Máy đã dừng không tốn đồng tiền tính toán nào, chỉ tốn phần lưu trữ rootfs, nên chi phí nền của mỗi ứng dụng đúng nghĩa đen là một máy ảo nhỏ, mà lúc nào cũng có sẵn năng lực dự phòng cho những đợt tăng tải.</p>
<p>Ban đầu, ở đoạn này tôi có viết rằng một máy đã dừng &ldquo;khởi động nguội (cold start) mất chưa tới một giây&rdquo;. Câu đó sai, và cái sai ấy khá đắt. Đến khi chịu đo thực tế thay vì đoán, tôi mới thấy một lần khởi động nguội mất <strong>25 đến 33 giây</strong>, và yêu cầu nào rơi vào một máy còn đang khởi động thì phải chờ trọn khoảng thời gian đó. Lúc đầu tôi đổ cho chính những lần khởi động nguội này tỉ lệ lỗi 22% trên bảng điều khiển của CDN, trong khi mọi lần kiểm tra tình trạng (health check) vẫn báo xanh. Hóa ra con số đó là các yêu cầu thăm dò Early Hints của chính CDN bị lỗi ở máy chủ gốc (origin); không có client thật nào nhận lỗi 504 cả. Dù vậy, chuyện khởi động nguội thì vẫn là thật.</p>
<p>Cách sửa không nằm ở mấy con số co giãn phía trên; chúng vẫn ổn. Vấn đề nằm ở những gì máy làm trong lúc khởi động, và ở việc yêu cầu Fly tạm ngưng (suspend) máy thay vì dừng hẳn (stop), để mỗi lần đánh thức máy chỉ còn là một lần khôi phục bộ nhớ mất khoảng 3 giây. Tôi đã viết riêng một bài về chuyện này: <a href="https://jared.lynskey.co.nz/vi/posts/2026/2026-09-09-scale-to-zero-504s/" >Thu về 0, và mỗi lần khởi động lại là một lần sập 30 giây</a>, nói về cách tôi chẩn đoán và những gì cần thay đổi. Nếu bạn đang chạy bất cứ thứ gì trên Fly với <code>auto_stop_machines</code>, hãy đọc bài đó trước khi tin vào đoạn này.</p>
<p>Có một điểm tinh tế: kiểu đếm tải là <code>requests</code>, không phải <code>connections</code>. Máy khách hiện đại giữ kết nối duy trì (keep-alive) luôn mở, nên nếu đếm theo kết nối thì con số gần như đứng yên dù tải thực tế tăng, và bộ tự động co giãn sẽ không bao giờ được kích hoạt. Đếm số yêu cầu đang xử lý mới phản ánh đúng khối lượng công việc thực.</p>

<h3 class="relative group">WebSocket co giãn theo một trục khác
    <div id="websocket-co-giãn-theo-một-trục-khác" 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-co-gi%c3%a3n-theo-m%e1%bb%99t-tr%e1%bb%a5c-kh%c3%a1c" aria-label="Cọc dấu">#</a>
    </span>
    
</h3>
<p>Chợ mua bán tách máy chủ WebSocket ra thành một <strong>ứng dụng Fly thứ hai</strong>, dùng chung Docker image. Ứng dụng API chạy một worker × 16 luồng chặn dưới WSGI và đếm theo <em>yêu cầu</em> (giới hạn mềm 12). Ứng dụng WebSocket thì chạy 1 worker dưới ASGI với uvloop, trên một máy <strong>512MB</strong>, và đếm theo <em>kết nối</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>Giữ một socket sống lâu gần như không tốn gì, nhưng nó chiếm một suất hàng giờ liền, trong khi một yêu cầu HTTP chỉ chiếm suất vài mili giây, nên không thể dùng chung một tín hiệu co giãn cho cả hai. Tách riêng ra thì mỗi nhóm máy co giãn theo đúng thước đo phản ánh tải thật của nó, và năng lực WebSocket lúc rảnh chỉ tốn 512MB chứ không phải 2GB. Về phía Channels, lớp Redis chạy với <code>capacity: 1500</code>, thông điệp hết hạn sau 60 giây, cộng thêm cơ chế duy trì kết nối cho socket mỗi 30 giây, vì proxy Redis của Fly sẽ tự đóng các socket BRPOP sống lâu mà Channels cần tới khi chúng không hoạt động.</p>

<h2 class="relative group">Đẩy việc tính toán ra tầng biên và sang phía máy khách
    <div id="đẩy-việc-tính-toán-ra-tầng-biên-và-sang-phía-máy-khách" 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="#%c4%91%e1%ba%a9y-vi%e1%bb%87c-t%c3%adnh-to%c3%a1n-ra-t%e1%ba%a7ng-bi%c3%aan-v%c3%a0-sang-ph%c3%ada-m%c3%a1y-kh%c3%a1ch" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Việc rẻ nhất cho máy chủ là việc máy chủ không bao giờ phải làm:</p>
<ul>
<li><strong>Tệp tĩnh và tệp đa phương tiện (media)</strong> nằm trên dịch vụ lưu trữ đối tượng tương thích S3 của Fly, được phân phối qua CDN, với URL có chữ ký cho tệp đa phương tiện riêng tư. Không một byte ảnh nào phải đi qua các máy Django.</li>
<li><strong>Suy luận AI chạy trên điện thoại của người dùng.</strong> Cả hai ứng dụng đều nhúng một LLM nhỏ chạy cục bộ ngay trên thiết bị (mô hình 4B đã lượng tử hóa, khoảng 2.7GB). Phía máy chủ không tốn đồng nào cho suy luận, và tính năng này chạy được cả khi ngoại tuyến.</li>
<li><strong>Ứng dụng di động ưu tiên ngoại tuyến (offline-first)</strong> (SQLite trên thiết bị và một hàng đợi đồng bộ có cơ chế thử lại) giúp ứng dụng gom các thao tác ghi lại thành từng đợt và chịu được những vùng mất sóng, thay vì dội vào API hàng loạt yêu cầu lắt nhắt theo từng lần gõ phím.</li>
</ul>

<h2 class="relative group">Phần còn lại của bộ công nghệ, điểm nhanh
    <div id="phần-còn-lại-của-bộ-công-nghệ-điểm-nhanh" 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="#ph%e1%ba%a7n-c%c3%b2n-l%e1%ba%a1i-c%e1%bb%a7a-b%e1%bb%99-c%c3%b4ng-ngh%e1%bb%87-%c4%91i%e1%bb%83m-nhanh" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Xác thực dùng một dịch vụ định danh (identity provider) có sẵn cộng với khóa truy cập (passkey) WebAuthn, và kết nối WebSocket được xác thực trước khi nâng cấp giao thức. Postgres cho môi trường production, SQLite khi phát triển, cùng vài gói Django có sẵn cho trang quản trị và lịch sử kiểm toán (audit trail). Phía di động là React Native và TypeScript chạy trên Expo, với Expo Router và Tailwind, cập nhật OTA qua một máy chủ Expo Updates tự vận hành, còn gói thuê bao trong ứng dụng thì giao cho một dịch vụ quản lý thuê bao. Khâu kiểm soát chất lượng: pytest và mypy ở phía máy chủ, kiểm thử đơn vị và kiểm thử đầu-cuối (end-to-end) ở phía máy khách.</p>

<h2 class="relative group">Những gì bạn nên &ldquo;học lỏm&rdquo;
    <div id="những-gì-bạn-nên-học-lỏm" 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="#nh%e1%bb%afng-g%c3%ac-b%e1%ba%a1n-n%c3%aan-h%e1%bb%8dc-l%e1%bb%8fm" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Điều đáng mang về không nằm ở một thư viện cụ thể nào, mà ở cả vòng lặp. Tối ưu cho một máy rẻ tiền chạy thật nhanh (dùng Rust ở đường xử lý nóng, tái sử dụng kết nối, đặt bộ nhớ đệm chắn trước điểm nghẽn thật, đẩy được gì sang CDN và máy khách thì đẩy). Kiểm thử tải cho đến khi tìm ra chính xác mức yêu cầu đồng thời mà máy gãy. Đặt giới hạn mềm của bộ tự động co giãn ngay tại điểm gãy đó, để các máy rảnh tự dừng, và giữ tối thiểu một máy luôn chạy. Hai ứng dụng đang chạy production, có tính năng thời gian thực, có trợ lý AI, mà hóa đơn hằng tháng lúc bình thường chỉ là vài máy ảo rẻ nhất trên nền tảng.</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>
