<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by 石南 on Medium]]></title>
        <description><![CDATA[Stories by 石南 on Medium]]></description>
        <link>https://medium.com/@heather_programming?source=rss-613ff406fd78------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*I2k-iW2Fp_4O6fv9b6BpSA.png</url>
            <title>Stories by 石南 on Medium</title>
            <link>https://medium.com/@heather_programming?source=rss-613ff406fd78------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 01:15:23 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@heather_programming/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[[AI Automated Testing -1] AI Testing’s Fatal Flaw: The Player-Referee Trap]]></title>
            <link>https://medium.com/@heather_programming/20260831-cb82b11a7c4b?source=rss-613ff406fd78------2</link>
            <guid isPermaLink="false">https://medium.com/p/cb82b11a7c4b</guid>
            <dc:creator><![CDATA[石南]]></dc:creator>
            <pubDate>Mon, 31 Aug 2026 03:57:01 GMT</pubDate>
            <atom:updated>2026-08-31T04:00:37.135Z</atom:updated>
            <content:encoded><![CDATA[<h4>AI is great at writing test scripts, but it easily confuses the roles of developer and evaluator, making tests look like they all passed when they actually verified nothing.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*z4oXVrFdnoA7eDQ6.jpeg" /></figure><p>After integrating AI collaboration into my workflow, it is now common to go end-to-end from development straight through to generating test reports. Consequently, I started letting AI help write automated tests.</p><p>The initial thought was simple: hand over the features and specifications to it, let it generate Playwright scripts, run the tests, and output a report. But in practice, I discovered quite a few problems. Without a proper methodology, it is easy to produce test reports that are all green but fail to catch any actual issues.</p><p>To be more specific, as developers, we used to be exceptionally cautious when doing integration testing because it is easy to unconsciously test from a developer’s perspective and fall into our own blind spots. I later realized that switching to AI for testing runs into the exact same problem.</p><p>Therefore, from these recent practical experiences, I believe the most fundamental and high-priority issue to prevent in AI automated testing is the “player and referee” problem. I have compiled the practices I figured out during this time into a methodology that can enhance testing effectiveness. This chapter will start with this issue; other problems will be discussed in later chapters.</p><p><strong>What Does It Mean to Be Both the Player and the Referee?</strong></p><p>Testing is meaningful because it uses a criterion independent of the program to verify if the program is correct. A referee must be neutral and cannot simultaneously be a player — meaning you cannot use the very thing being tested as the basis for judging it.</p><p>The problem is that AI is particularly prone to becoming both the player and the referee when writing tests, which manifests in two areas.</p><p><strong>1. Treating the Program’s Behavior as the Correct Answer</strong></p><p>This is the most direct manifestation of being both the player and the referee: the “correct answer” the test holds actually comes from the program being tested. There are two layers of reasons for this:</p><p>The first layer is that seeing the code influences judgment. To write a test script, it must first understand how the system operates: which button is on the screen, what parameters are sent, and how data is queried. But once it sees “how the program calculates it,” it naturally treats “the result calculated by the program” as “the expected result.”</p><p>Take a search feature as an example. To verify if the search results are correct, the test must first have a correct answer to compare against. The easiest way is to copy the backend’s SQL query, run it, and see if the UI matches it. But testing this way only proves that “the UI matches the backend,” not that “the UI matches the spec.” If the backend implemented the spec incorrectly in the first place, this test will never catch it because the answer key it uses is that very same incorrect implementation.</p><p>The second layer is harder to guard against and is related to the nature of AI. The fundamental nature of AI is to find a reasonable explanation for an input and generate a seemingly reasonable output. This tendency is great for writing code, but disastrous for testing: it tends to rationalize the result as a pass. When it encounters a mismatch between the UI and expectations, its first reaction is often not “Is this a bug?”, but rather “Let’s make this phenomenon reasonable.” Consequently, it will adjust the comparison logic, loosen the conditions, or invent a justification for the discrepancy until the test turns green.</p><p>But the ability required for testing is exactly the opposite: discrimination. When seeing a mismatch between the UI and expectations, it should first assume it is wrong, then try to prove or disprove it, rather than rushing to find a plausible excuse for it. A tester eager to rationalize every phenomenon will unknowingly justify real defects away.</p><p>This is also why AI cannot be allowed to decide on its own “what is correct.” The correct answer must come from an external, independent source — the specification. How to hold this boundary is the focus of the next chapter, “Firewall.”</p><p><strong>2. The Urge to Jump In and Fix Bugs After Catching Them</strong></p><p>Another manifestation of being both the player and the referee relates to roles. When a tester catches a program error, they should: record it, report it, and stop. But when AI catches an issue, it naturally switches to a developer’s mindset, starting to think “how should this be fixed to make it right” or chasing it down to investigate “why it is wrong.”</p><p>Doing this comes at a few costs: the direction of the testing deviates. Instead of going through cases one by one, it dives into the root cause of a single issue, consuming a lot of time and tokens. Furthermore, jumping in to make changes will erase the evidence of the defect. Once a tester acts as a developer, they lose their neutrality and revert to being both the player and the referee.</p><p>The correct approach is to simply record the issue when you see it. The root cause and how to fix it have nothing to do with testing; that is the developer’s job. So the boundary I set for AI is: diagnosis only goes as far as distinguishing “is this a program error, or a test script error?” If it is a script error (wrong selector, waiting for the wrong API, improper test data design), then fix it. If it is a program error, record it, report it, and continue testing.</p><p><strong>Other Issues</strong></p><p>Besides the player-referee problem, I encountered two other issues. One is that when test data is needed, I had to continuously supply it based on AI’s feedback (Chapter 3 will cover how to avoid this with upfront planning), meaning it requires a lot of human presence and cannot be fully handed off to AI to free up manpower. The other is that the generated reports lack evidentiary value, leaving them unverifiable when handed over (Chapter 5 will discuss this).</p><p>I placed them later because these two problems, at worst, make the testing process slower. The player-referee problem, however, renders the testing fundamentally meaningless: all scripts pass and the reports look pretty, but it is equivalent to not testing at all. Therefore, this must be prevented first.</p><p><strong>The Structure of This Series</strong></p><p>The following chapters will cover sequentially:</p><ul><li><strong>Chapter 2:</strong> Three boundaries, including testers not modifying code, the database being read-only, and most crucially, “where exactly the expected values should come from.”</li><li><strong>Chapter 3:</strong> A three-stage process that concentrates human effort at the beginning and the end, leaving the AI to run autonomously in the middle.</li><li><strong>Chapter 4:</strong> Implementation details to make AI testing run smoothly and correctly.</li><li><strong>Chapter 5:</strong> How to create reports with evidentiary value.</li><li><strong>Chapter 6:</strong> Using a real feature to tie all the previous practices into a complete workflow.</li><li><strong>Appendix:</strong> Using Claude Code Hooks to restrict AI behavior.</li></ul><p>The next chapter will cover that most crucial boundary: whether the correct answer for testing should come from the specification or the code.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb82b11a7c4b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【AI 自動化測試】附錄：用 Claude Code 的 Hook 限制 AI 行為]]></title>
            <link>https://medium.com/@heather_programming/20260819-0468ec0cb130?source=rss-613ff406fd78------2</link>
            <guid isPermaLink="false">https://medium.com/p/0468ec0cb130</guid>
            <dc:creator><![CDATA[石南]]></dc:creator>
            <pubDate>Wed, 19 Aug 2026 11:51:01 GMT</pubDate>
            <atom:updated>2026-08-19T11:51:01.192Z</atom:updated>
            <content:encoded><![CDATA[<h4>本篇是〈三、三階段流程〉裡「實體鎖」的技術補充。這道鎖是用 Claude Code 的 Hook 機制、搭配一個標記檔實作的；本附錄說明它具體怎麼運作。</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-oQFOgOb60ixW7Mt.jpeg" /></figure><h3><strong>關鍵點</strong></h3><p>我們在 〈三、三階段流程〉 中，禁止 AI 讀程式碼所使用的 `.phase0-lock` <strong>本身不會擋任何東西</strong>，它只是一個「開關」標記；真正動手擋的，是一個叫 hook 的機制。兩者要合起來看。</p><h3><strong>1. 什麼是 hook</strong></h3><p>這套流程跑在 Claude Code 這個 AI 工具上。它有一個功能叫 <strong>hook</strong>：可以指定「在 AI 每次要用工具之前，先自動跑一支腳本」，這支腳本會檢查 AI 想做什麼，然後回答「放行」或「擋下」。</p><p>其中一種叫 <strong>PreToolUse hook</strong>：AI 每次要讀檔（Read）、搜尋（Grep／Glob）、或下 shell 指令（Bash／PowerShell）之前，Claude Code 都會<strong>先把「AI 打算做的這個動作」交給這支腳本審一遍</strong>，腳本說可以才真的做，說不行就直接擋掉，那個動作根本執行不了。</p><p>這支審查腳本就是 `phase0_guard.py`，掛在專案的 `.claude/settings.json` 裡，指定 Read／Grep／Glob／Bash／PowerShell 這幾種工具都要先經過它。</p><h3><strong>2. `.phase0-lock` 的角色</strong></h3><p>`phase0_guard.py` 每次被呼叫時，判斷邏輯大致如下：</p><p>第一步：專案根目錄有沒有 .phase0-lock 這個檔？</p><pre>├─ 沒有 → 代表已經定案解鎖，全部放行，直接結束。<br>└─ 有 → 代表還在階段一（鎖定中），進第二步。</pre><p>第二步（鎖定中才做）：看 AI 這次想碰的路徑／指令是什麼</p><pre>├─ 想讀的是「應用程式源碼」(前端 web 資料夾、後端 Java、.vue 檔…) → 擋下。<br>└─ 想讀的是規格文件、測試專案、工具 這些該讀的 → 放行。</pre><p>所以 `.phase0-lock` 就是一個<strong>開關檔</strong>：它在，鎖就生效；把它刪掉，鎖就解除。檔案本身是空的，每次跑的時候，`phase0_guard.py` 要確認它是否「存在」。</p><h3><strong>3. 一次實際的攔截長怎樣</strong></h3><p>(1) AI 想讀 `frontend/src/components/List.vue`，看某欄怎麼排序，於是發出一個 Read 動作。</p><p>(2) 在真的讀到之前，Claude Code 先把這個動作 `{工具: Read, 路徑: frontend/…/List.vue}` 丟給 `phase0_guard.py`。</p><p>(3) 腳本檢查：`.phase0-lock` 在 → 鎖定中；這路徑是前端源碼 → <strong>回傳「擋下」</strong>（技術上是給一個「拒絕」的結果，例如非 0 的 exit code 帶一段訊息）。</p><p>(4) Claude Code 收到「擋下」，就<strong>不執行</strong>這個 Read，並把「動作被擋、原因是階段一鎖定」回饋給 AI。</p><p>(5) AI 讀不到那個檔，只好回頭照規格推論。</p><h3><strong>4. 為什麼連 shell 繞路也擋得住</strong></h3><p>如果只擋 Read，AI 可能改用 `cat frontend/xxx.vue` 或 `grep` 去翻源碼繞過去。所以這個 hook 不只掛在 Read，也掛在 <strong>Grep、Glob、Bash、PowerShell</strong> 上，這幾條讀取的路都要先過審，把其他路徑一起堵住。</p><h3><strong>5. 為什麼這比 AI 自律更有保障</strong></h3><p>重點在於：<strong>這支審查腳本跑在 Claude Code 的框架裡，在 AI 的控制範圍之外。</strong>AI 沒辦法叫它不要跑、也沒辦法忽略它的否決。就算 AI「想」讀、或有人下指令叫它讀，框架都會在動作真的發生前把它攔掉。所以擋讀碼這件事不靠純粹下指令，而是靠工具層強制執行。</p><h3><strong>6. 生命週期</strong></h3><p>- <strong>階段一開工前</strong>：在專案根目錄建一個空的 `.phase0-lock`（hook 早就掛在 settings 裡）。</p><p>- <strong>階段一進行中</strong>：AI 一切讀源碼的路都被擋，只能讀規格、測試檔、工具；於是預期結果只能從規格＋資料庫推論。</p><p>- <strong>人類下決定、預期凍結後</strong>：把 `.phase0-lock` 刪掉。腳本下次一看檔案不在，就全部放行，進階段二，AI 這才開始讀程式寫腳本。</p><h3><strong>小結</strong></h3><p>總結來說，這道鎖由兩個元件構成：狀態標記檔 `.phase0-lock`，以及掛在 PreToolUse 的審查腳本 `phase0_guard.py`。前者的存在與否代表鎖定狀態，後者在每一次工具呼叫執行前檢查狀態，並在鎖定的期間，攔下所有讀取程式碼的動作。</p><p>由於這道檢查在 AI 的控制範圍之外，並且由框架強制執行，「預期凍結前不讀程式碼」便從一條靠自律遵守的規定，變成工具層保證的結果。這也給了我們一個啟示，<strong>若要有效的限制 AI 的行為，透過系統上不可跨越的硬性限制，或是設定在 AI 能涉及的 Scope 之外，會更具有強制力。</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0468ec0cb130" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【AI 自動化測試】六、實例：一個功能從規劃到報告]]></title>
            <link>https://medium.com/@heather_programming/20260818-4b1f328ce6a9?source=rss-613ff406fd78------2</link>
            <guid isPermaLink="false">https://medium.com/p/4b1f328ce6a9</guid>
            <dc:creator><![CDATA[石南]]></dc:creator>
            <pubDate>Tue, 18 Aug 2026 11:41:01 GMT</pubDate>
            <atom:updated>2026-08-19T06:45:21.000Z</atom:updated>
            <content:encoded><![CDATA[<h4>前五章講的是原則。這一章用一個實際測過的功能，把防火牆、三階段流程、驗證和報告從頭到尾走一遍，看實際上怎麼操作。</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yjHJekjoLyBGPaKZ.jpeg" /></figure><p>前面五章談的是原則：為什麼會有裁判兼球員的問題、怎麼用防火牆和三階段流程擋掉它、怎麼讓 AI 跑得穩又可信、怎麼把結果變成能查驗的報告。這一章換個方式，用一個實際測過的功能，把這五件事從頭到尾走一遍。</p><p>為了不揭露客戶系統的細節，以下把這個功能的領域資訊做了模糊處理，但流程和做法都是真實的。</p><p>這個專案不算小，這裡挑其中一個功能來說。它有一個查詢頁，上面有多個篩選條件；查詢結果可以匯出成 Excel；也可以透過匯入，一次新增多筆資料；而且每一筆資料還帶一份核准文件可以下載。查詢、匯出、匯入、下載四種操作都在裡面，剛好能把前面每一章都用上。</p><h3><strong>階段一：開工前，先把預期結果定死</strong></h3><p>第一步，在還沒讀任何程式碼之前，憑規格把要測的案例和每一筆的預期結果列出來。</p><p>案例大致是：查詢頁的每個篩選條件各測一種代表性的情況、匯出的 Excel 內容、匯入新增資料（包含檢核失敗被擋下的負向案例）、以及核准文件的下載。</p><p>比較關鍵的是查詢類的預期結果怎麼來。這裡沒有去翻後端那段查詢是怎麼寫的，而是照規格，自己寫一份對照用的查詢（第二章的鏡像 SQL），用它算出「照規格，這個條件應該查到哪幾筆」。這一步就是防火牆：預期結果來自規格，不是來自實作。如果後端把某個篩選條件實作錯了，這份依規格算的預期就會跟它對不上，剛好能抓到。</p><p>這個階段全程不讀程式碼，是靠第三章那道鎖強制的：專案裡放著標記檔的時候，AI 根本讀不到前端或後端的原始碼，只能讀規格。等這份案例和預期經過人確認、凍結下來之後，才會把鎖解開。</p><p>測資也在這一步一次備齊，寫成一份 SQL。造測資時直接套用專案共用的擬真詞彙（第四章講的那份），所以不必為了這個功能重新掃一次資料庫，值和格式都跟真實資料對齊。這份測資 SQL 由人執行，不是 AI 自己寫進資料庫，以避免 AI 改動或刪除重要的資料。</p><h3><strong>階段二：解鎖之後，讓 AI 自己跑</strong></h3><p>預期凍結、鎖解開，接下來整段交給 AI：讀前端找到畫面上的元素、寫測試腳本、實際操作、產出每個案例的結果。這一段幾乎不需要人介入，但第四章講過的幾個地方，實際上真的遇到了。</p><p>第一，操作畫面時抓錯元素。這個功能的查詢頁和匯入頁是兩個分頁，兩邊的欄位都在網頁裡。AI 一開始用欄位名稱去抓，抓到的是隱藏那一頁的同名欄位，腳本沒有報錯、卻填錯了地方。改成只鎖定當前顯示的分頁，才正確。</p><p>第二，匯入「成功」不能只看畫面。匯入跑完、畫面顯示成功，這還不算數。AI 要回頭用一條唯讀查詢，確認那幾筆真的寫進了資料庫、每個欄位的值也對，才算通過。</p><p>第三，下載的核准文件要驗到底，因為曾經碰過產出事毀損檔，測試卻顯示通過的情況，所以不是「點了有下載」就算，而是把檔案存下來、確認大小不為零、檔頭是正確的 PDF，並且要跟當初上傳的那份已知檔案逐位元比對，證明下載回來的內容完全正確。</p><h3><strong>階段三：人看報告</strong></h3><p>最後，AI 把每個案例整理成一份報告，人看過之後再調整。</p><p>報告裡每個結論都有截圖佐證。查詢類的案例，附上查詢條件、結果清單和筆數，旁邊是依規格算出的預期筆數，兩邊對得上。匯入這種新增類的案例，走的是第五章那條三段證據鏈：送出前填好的輸入畫面、送出後多出那幾筆的清單、還有資料庫裡查得到的那幾筆，從頭到尾扣在一起。匯出的 Excel 則渲染成表格截進報告，逐欄跟查詢結果比對。</p><p>整份報告走的是共用的樣式和產生引擎，所以它跟這個專案裡其他功能的報告長得一樣、說法也一樣，是一份可以直接交出去的文件。</p><h3><strong>小結</strong></h3><p>把這個功能走完一遍，就能看到前五章其實是同一件事的不同面向：防火牆保證預期結果乾淨、三階段把人力放在對的地方、跑得流暢也檢驗得夠深入，讓 AI 自主執行可信，報告也讓這一切能被別人查驗。</p><p>回到最開始的問題。「叫 AI 寫測試」很容易，難的是不讓它變成裁判兼球員、不讓它把「看起來成功」當成「真的成功」。這一連串的方法，主要的目的就是：<strong>怎麼讓 AI 幫忙做完大量的測試工作，但規避 AI 的特性會造成的盲點，讓測試達成它該有的目標與意義。</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b1f328ce6a9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【AI 自動化測試】五、報告即證據：交付要能被查驗]]></title>
            <link>https://medium.com/@heather_programming/20260817-e1ab31da6232?source=rss-613ff406fd78------2</link>
            <guid isPermaLink="false">https://medium.com/p/e1ab31da6232</guid>
            <dc:creator><![CDATA[石南]]></dc:creator>
            <pubDate>Mon, 17 Aug 2026 02:03:23 GMT</pubDate>
            <atom:updated>2026-08-17T02:03:23.731Z</atom:updated>
            <content:encoded><![CDATA[<h4>一份測試報告如果只寫「查詢正確、新增成功」，讀的人沒辦法查證，只能選擇相信。這一章談怎麼讓報告變成能被查驗的證據。</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Px4ELSucQWB9YJt5.jpeg" /></figure><p>第四章講到，驗證要一路做到資料層。但驗完還有最後一關：這些結果要能<strong>*證明給別人看</strong>。測試報告通常是要交出去的，交給客戶、主管、或稽核。如果報告上只寫「查詢結果正確」或「新增成功」，讀的人其實無從查證，只能選擇相信測試員。</p><p>因此，報告應具備充分的證據力，凡是能用截圖證明的事實，就不要只用文字帶過。（但請注意，測試報告的樣式與要求，因不同公司或客戶而異，所以這裡僅供參考。）</p><h3><strong>一、能用截圖證明的，就不要只用文字</strong></h3><p>一份報告寫「查詢結果正確」並不足夠，因為讀的人看不到「查了什麼、查出幾筆、每一筆長怎樣」。換成截圖就完全不同：查詢條件、結果清單、筆數，全部在畫面上，讀的人自己就能核對。</p><p>所以我給 AI 的指令是，凡是能用截圖證明的事實，一律附截圖，文字只用來標註「這張截圖證明了什麼」。查到的筆數、清單裡的每一列、彈窗的內容、轉導後的頁面、資料庫裡查到的那一筆，都要有畫面佐證。遇到「A 的數字應該等於 B 的數字」這種對照，就兩邊都截，讓讀的人自己比對。</p><h3><strong>二、「成功」要有一條完整的證據鏈</strong></h3><p>新增、修改這類案例，如果只截一張「儲存成功」的提示，就當作證明是不夠的，因為這張截圖什麼都沒證明，它證明不了送出去的是什麼、也證明不了資料真的存下來了（第四章那個「畫面顯示成功、資料庫卻是空的」的假存，就是這樣漏掉的）。</p><p>所以一個「成功」案例，我要求報告裡要有一條<strong>三段相扣的證據鏈</strong>：</p><p>1. <strong>送出前，填好的輸入畫面。</strong>在按下送出之前，把所有填好的欄位截下來，證明「送進去的是這些值」。(若檢核報告的人是資訊單位，也可附上 payload)</p><p>2. <strong>送出後的結果。</strong>送出後的清單或結果頁，而且要看得到新增的那一筆，證明「系統收下了、也顯示出來了」。</p><p>3. <strong>資料庫裡查得到。</strong>回頭查資料庫，證明那一筆真的落地了，每個欄位的值也對。</p><p>有了這三段，讀的人可以從輸入一路追到資料庫，完整看到這件事真的發生了。</p><h3><strong>三、報告要一致，而且足以交付給客戶</strong></h3><p>最後的小細節，關於報告作為交付物的樣子。</p><p>第一，<strong>一致</strong>。同一個專案往往有很多份報告，一個功能一份，如果每一份的外觀、結構、用語都不一樣，看起來就很雜。所以不應讓 AI 每次自由發揮，而是讓所有報告都走同一條產線：一個共用的樣式外殼，加一個共用的產生引擎(如 Python 程式)，連「畫面查到 N 筆、資料庫預期 N 筆」這種句子，都是引擎統一產出的，不是各份報告各寫各的。這樣不管做哪個功能，報告的長相和說法都一致。</p><p>第二，<strong>報告是給客戶的交付物，不是內部的工作紀錄</strong>。因此報告裡不會出現內部的案例編號（例如 Q01、C03）、不會有「這次重跑了哪些」這類執行過程的備註，也不會有環境設定的說明。每個標題都採用功能或情境本身的名稱。讀的人看到的，是一份乾淨、只針對受測功能陳述的文件。</p><p>特別要說明這點，是因為 AI 有紀錄過程的傾向，所以要一開始就定義目標為「交付文件」，且禁止出現歷程文字，僅呈現最終結論。</p><h3><strong>小結</strong></h3><p>把這些加起來，報告才能變成一份能被查驗的證據：每個結論都有畫面為證，且能從輸入追到資料庫，而且樣式上都是正式的交付物。</p><p>到這裡，AI 自動化測試的五個部分就講完了：從最根本的裁判兼球員問題，到防火牆、三階段流程、怎麼讓 AI 跑得順暢又可信，再到報告即證據。下一章，我會用一個實際的功能，把這五件事從頭到尾串成一次完整的測試，讓大家看到它們合在一起實際跑起來是什麼樣子。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e1ab31da6232" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【AI 自動化測試】四、放手讓 AI 用 Playwright 跑，怎麼確保它跑得對]]></title>
            <link>https://medium.com/@heather_programming/20260806-2861dfa26c59?source=rss-613ff406fd78------2</link>
            <guid isPermaLink="false">https://medium.com/p/2861dfa26c59</guid>
            <dc:creator><![CDATA[石南]]></dc:creator>
            <pubDate>Thu, 06 Aug 2026 09:09:50 GMT</pubDate>
            <atom:updated>2026-08-19T06:43:25.605Z</atom:updated>
            <content:encoded><![CDATA[<h4>腳本亮綠燈、畫面顯示成功，不代表 AI 測試真的通過了。關鍵在把驗證做到資料層，並讓測資夠真實、測試範圍夠聚焦。</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*l6YtQkAQYKaxJs4a.jpeg" /></figure><p>上一章的結尾說到，把中間整段放手交給 AI，但這件事的前提是驗證方式是正確的，所以 AI 對成功的判定就格外重要。</p><p>如果 AI 操作畫面時抓錯了元素，或是把「畫面顯示成功」就當成「真的成功」，那麼自動化只會產生無用的報告了。所以這一章前面講：AI 表面的「成功」為什麼不能盡信、驗證又該做到多深；後兩節再談測資和過度測試的問題。</p><h3><strong>一、「測試通過」不代表 AI 操作正確</strong></h3><p>AI 爬畫面做自動化時，會有一個容易被忽略的風險：它可能操作了錯的元素，而測試照樣不會報錯。</p><p>我之前遇過的情況是：我們系統的前端用 Vuetify，畫面上有切換分頁的元件，它會把兩個分頁的內容<strong>都放進網頁裡</strong>，非當前頁只是隱藏起來。AI 一開始用欄位名稱去抓某個輸入框，抓到的卻是<strong>隱藏那一頁</strong>的同名欄位。麻煩的地方在於，這種錯不會拋出任何錯誤：腳本「成功」填了一個欄位、也「成功」跑完，只是它填的是使用者看不到的那個。如果當下只看「腳本有沒有報錯」，會以為一切正常。</p><p>這帶出一個 AI 自動化很重要的問題：<strong>「腳本通過」只代表沒出錯，不代表 AI 的操作真的正確。</strong>表面的成功訊號（沒有例外、跑完了、畫面有反應），在 AI 自動化裡不完全可靠，因為 AI 很擅長讓事情「看起來完成了」。所以真正保證測試有效的，不是這些表面的訊號，而是下一節要講的：資料層的獨立確認。</p><h3><strong>二、「測試通過」不能只看畫面</strong></h3><p>這是這一章最重要的一點。</p><p>我之前遇過一個頁面，按下儲存後，畫面跳出了成功的提示，但資料<strong>根本沒有寫進資料庫</strong>。那個儲存其實只更新了前端畫面上的狀態，沒有真的送到後端。如果測試只看「畫面有沒有顯示成功」，但這種 bug 卻會被當成通過，因為它看起來完全正常。</p><p>所以我後來為新增、修改、設定這類案例定了一條規定：<strong>「成功」不能只看 API 有沒有回成功、畫面有沒有顯示成功，一定要回頭查資料庫，確認那一筆真的寫進去了，而且每個欄位的值都正確。</strong>這件事由 AI 在跑完操作後，用唯讀的查詢去確認（查詢的規範見第二章，只 SELECT、不寫入）。</p><p>下載類的案例也是一樣的：<strong>「點下去有觸發下載」不等於「下載到的檔案是對的」。</strong>我規定 AI 要驗四個層面：第一，檔案真的存下來了，而且大小大於零；第二，檔案類型正確（例如 PDF 就檢查開頭是不是 `%PDF`，證明不是一個毀損檔）；第三，把下載到的檔案，跟當初上傳的那個已知檔案<strong>逐位元比對</strong>，證明下載的檔案完整、沒有損壞、內容正確。</p><p>查詢類則是逐列逐欄比對：拿 AI 依規格算出來的預期結果（第二章講的鏡像查詢），跟畫面實際查到的結果一列一列、一欄一欄對，包括代碼有沒有正確轉成中文、筆數對不對。</p><p>這幾種驗證的共同點是：<strong>不停在「表面上正確」，而是要一路驗證到「資料層面正確」。</strong>這也是後面第五章「報告要有證據力」的基礎。</p><h3><strong>三、擬真的測試資料</strong></h3><p>造測試資料時，值和格式最好盡量跟真實資料對齊，而不要隨意編造。(這一點根據不同的專案，考量到成本或隱私，情況可能不同，所以不一定要這樣做，這裡是以我自己的專案經歷分享。)</p><p>這麼做的原因有兩個。一個比較實際：有些畫面（例如一層扣一層的級聯下拉選單、或需要跨表 join 才查得到的資料）只有在資料是「真實存在的組合」時才會正常運作，隨便填的假資料根本觸發不了。另一個是交付上的：測資會出現在最後交付的報告截圖裡，如果一眼看上去就是假的，說服力會打折。</p><p>具體做法是，造每一筆之前，規定 AI 要先參考同一張表裡既有的資料長什麼樣：代碼類的欄位，值要取自真實存在的選項，不要填一個表裡根本沒有的代碼；格式類的欄位，分段數、分隔符號、長度這些樣式要跟其他列一致。</p><p>至於怎麼標記哪些是測試造的資料、之後怎麼清掉，最好靠<strong>不會顯示的欄位</strong>（例如在「建立者」欄位標一個特定記號、或讓主鍵帶特定前綴），而不要在會被截圖的可見欄位裡塞「TEST」之類的假字串。</p><p>不過，這麼一來就有成本問題要考慮，要讓測資來自真實的資料，得先看到真實資料長什麼樣，也就是去掃過資料庫裡那些參照表，摸清每個欄位實際有哪些值、格式是什麼。但如果每測一個功能就重掃一次、重新摸索一次，會重複花費成本。</p><p>所以最好把它做成一份可以複用的資產：<strong>第一次摸清楚之後，就把這些真實的格式和值域整理成一份「擬真詞彙」，放在整個測試專案共用的地方，而不是塞在某一個功能底下。</strong>裡面記的是像「這個編號是什麼前綴加幾碼數字」「這個型號欄位真實的合法組合有哪些」「這些代碼分別對應什麼中文」這類跨功能都用得到的格式知識。</p><p>之後每測一個新功能，AI 要造測資時，就直接查這份詞彙、套用，不必再重掃一次資料庫。整個專案的功能（不同頁面、不同流程）共用同一份擬真詞彙，就不用測到每個功能時都再花一次 Token。</p><h3><strong>四、不要過度測試</strong></h3><p>這一點在現今的實務上需要稍微注意一下，因為有了 AI 的協助，很容易過度測試，如此一來將會十分消耗時間和 Token，因此判斷出低價值或重複性的案例，讓 AI 不要去測試也是很重要的，這樣才能把力氣花在真正容易有 bug、且會產生實際影響的地方。</p><p>以我自己的案例來說：同一個功能如果有複雜和簡單的邏輯，測複雜的就好，因為複雜度高的會涵蓋複雜度低的情況(比如欄位有「多選」和「單選」，就測「多選」)；一進畫面預設是空白、還沒查詢就沒有資料，這種案例就不測，因為它沒有任何資訊量（本來就該是空的）。</p><p>要記得要求 AI 測試<strong>負向案例</strong>，否則有時候它只會測 Happy Case，但只測<strong>有資訊量</strong>的。意思就是說，這個負向有機會檢查出真正的檢核或防呆問題，例如必填欄位沒填會不會被擋、規格說某欄位要自動轉成大寫但實作到底有沒有轉。至於那種「查一個不存在的值、結果是空」的負向，只是「空的等於空的」，檢查不出任何東西，這種的就略過。</p><p>這一節的重點，是把測試 Agent 的判斷力用在對的地方，而不是機械地把每種組合都跑一遍。</p><h3><strong>小結</strong></h3><p>這四件事加起來，「放手讓 AI 跑」才是可信且有效率的：操作畫面抓對元素、一路驗證至資料層、擬真的測資、範圍控制在會抓到 bug 的地方。</p><p>最後，驗證即使做得再深，這些結果要如何證明給別人看呢？查到的筆數、寫進去的資料、下載回來的檔案，光在報告裡寫「通過」是沒有說服力的。下一章就來談，怎麼把這些驗證變成一份有證據力的報告。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2861dfa26c59" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【AI 自動化測試】三、三階段流程：讓 AI 自主跑，人監督開頭和結尾]]></title>
            <link>https://medium.com/@heather_programming/20260804-49007c1607aa?source=rss-613ff406fd78------2</link>
            <guid isPermaLink="false">https://medium.com/p/49007c1607aa</guid>
            <dc:creator><![CDATA[石南]]></dc:creator>
            <pubDate>Tue, 04 Aug 2026 14:58:32 GMT</pubDate>
            <atom:updated>2026-08-24T02:30:33.683Z</atom:updated>
            <content:encoded><![CDATA[<h4>透過 Claude Code 的 Hook，建立實體鎖，防止 AI 事前讀取程式，污染測試的預期結果；並用 MCP 讓 AI 看畫面而不讀前端碼。</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2lZ7oykwQSJzskn4.jpeg" /></figure><p>上一章講到防火牆的重點：預期結果要先定下來，之後再讀程式，那就有一個問題：這個順序怎麼強制，因為光靠下指令是守不住的。這一章就來說明這點。</p><p>我的做法是把整個測試流程切成三個階段，讓<strong>人只出現在最前面和最後兩個階段</strong>，中間整段放手讓 AI 自己跑。這樣同時解決了第一章講的兩個問題：一個是裁判兼球員（靠「先凍結、後讀碼」擋掉），一個是一路補資料（靠「測資一次規劃到位」擋掉）。</p><h3><strong>階段一：開工前定案</strong></h3><p>第一個階段，在<strong>還沒寫任何一行腳本、還沒讀任何一行程式</strong>之前完成。要做三件事：</p><p>1. <strong>憑規格把案例和預期結果推出來。</strong>要測哪些情況、每個情況畫面該出現什麼，全部依規格（必要時查資料庫）推導，每一筆都掛上規格出處。這一步全程不讀程式碼。</p><p>2. <strong>把測資一次規劃到位。</strong>這次測試需要哪些資料、跑完要怎麼清乾淨，全部讓 AI 盤出來，寫成一份前置的 SQL。第一章提過，遇到缺資料才臨時補、一路救火，是最大的時間黑洞，且讓人必須一直在場；把它一次備齊，就是為了避開這件事。</p><p>3. <strong>交給人定案。</strong>案例、預期、出處都攤開讓人確認。通過之後，這份預期結果就<strong>凍結</strong>下來，成為之後比對的基準，不再回頭改；同時由人運行那份測資 SQL。</p><p>第一件事裡有個實務上的難處：有時候光靠規格，還列不全該測的案例，得看看畫面才知道有哪些東西要測，例如某個查詢表單實際放了哪些篩選欄位、某個下拉選單展開後到底有哪些選項。</p><p>這時候 AI 要「看畫面」。不過重要的是，<strong>不要讓 AI 翻程式碼！而是用瀏覽器自動化工具（我用的是 Playwright 的 MCP 介面）把實際跑起來的頁面開出來，擷取一份畫面快照</strong>。這份快照給的是畫面「呈現出來的內容」：頁面上有哪些欄位、哪些按鈕、下拉展開後有哪些選項，跟一個使用者打開瀏覽器看到的一樣，而不是產生這些畫面的原始碼，否則就回到老問題了。</p><p>兩者的界線是：看「畫面呈現什麼」可以，讀「程式怎麼算出這個呈現」不行。而且畫面只拿來決定「要測什麼」，至於「正確結果該是什麼」，仍然只能回規格拿，不能看畫面現在顯示什麼、就把它當成標準答案。</p><p>這個階段是整個流程裡，人力最關鍵的一次介入。因為後面所有比對要依據的預期結果，都在這一刻定案，而且<strong>是在還沒讀過實作、還沒被它污染之前就定好的。</strong></p><h4><strong>以 Hook 作為實體鎖</strong></h4><p>問題是，光「規定」這個階段不准讀程式，AI 是守不住的（上一章說過，連高優先序的指令都攔不住）。所以我們不靠規定，改用一道實體的鎖。</p><p>做法是這樣：開工前，先在專案裡放一個標記檔，就叫它 `.phase0-lock`；同時掛一個攔截器（技術上是一個 hook，會在 AI 每次動作之前先執行一次，可以擋下這個動作）。只要這個標記檔還在，攔截器就會<strong>擋掉 AI 一切讀應用程式源碼的行為</strong>，不管是前端還是後端的程式碼一律看不到，只放行測試檔、規格文件這些該讀的東西。等預期結果凍結之後，才把 `.phase0-lock` 拿掉，解開鎖。</p><blockquote>詳細做法和原理請見：<a href="https://medium.com/@heather_programming/20260819-0468ec0cb130">【AI 自動化測試】附錄：用 Claude Code 的 Hook 限制 AI 行為</a></blockquote><p>這樣一來，「預期先定、程式後讀」就不再是單靠 AI 自律，而是<strong>機械性的保證</strong>：在定案之前，AI 連看程式的機會都沒有，自然不可能拿實作當預期結果。</p><p>我會這麼做，就是因為有吃過虧。曾經有一次，AI 要判斷某個清單「哪些欄位可以排序」，它跑去看了前端程式碼，看到欄位設定上標著「可排序」，就直接拿這個當預期結果。但正確的做法，是去數規格上寫了哪些欄位該可以排序。這就是典型的拿實作當答案。有了這道鎖，這種事從源頭就不會發生。</p><h3><strong>階段二：AI 自主執行</strong></h3><p>預期結果凍結、鎖也解開之後，進入第二階段。這一段<strong>幾乎不需要人</strong>，整段交給 AI 自己跑：讀程式找到畫面元素、寫測試腳本、實際跑、修掉自己腳本的錯（選擇器抓錯、等錯時機），最後產出報告。</p><p>這裡有一條很重要的規矩：<strong>AI 讀了程式之後，如果發現實作跟凍結的預期結果對不上，預設是程式錯了，不是預期結果錯了。</strong>它該做的是把這個不一致記下來（就是上一章講的「實作對不上」），而<strong>絕對不准回頭去改那個凍結的標準，好讓測試變綠燈</strong>。</p><p>這條規範是防火牆的最後一道防線。因為 AI 讀完程式後，最省力的一件事就是「原來實作是這樣算的，那我把預期改成跟它一樣，不就通過了」，這正好又變回裁判兼球員，所以凍結的預期要設成不可動。</p><h3><strong>階段三：審查</strong></h3><p>最後一個階段，人再次出場，但只做一件事：<strong>看報告。</strong> AI 把每個案例的結果、截圖、對不上的地方整理成報告，人看過之後，該補測的補、該修腳本的修，交給 AI 去調整。</p><h3><strong>小結</strong></h3><p>把流程切成這三段，人只在「開頭定案」和「結尾審查」兩個階段出現，中間整段是 AI 自主跑。好處有三個：</p><p>- <strong>從源頭防止「裁判兼球員」現象</strong>：預期結果在讀程式之前就凍結，而且用實體鎖禁止，不靠自律。</p><p>- <strong>不再一路補資料</strong>：測資在階段一就一次備齊，人不用不停介入。</p><p>- <strong>人力花在關鍵點上</strong>：不是盯著 AI 每一步，而是把關頭尾兩個真正重要的判斷點。</p><p>不過，「階段二放手讓 AI 跑」有一個前提：它跑起來能足夠順暢，包括選擇器會不會抓錯、顯示成功的畫面是不是真的成功、下載的檔案是不是真的對等等。下一章就來談這一點。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=49007c1607aa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【AI 自動化測試】二、防火牆：讓測試的答案只能從規格來]]></title>
            <link>https://medium.com/@heather_programming/20260723-3af2f80455a8?source=rss-613ff406fd78------2</link>
            <guid isPermaLink="false">https://medium.com/p/3af2f80455a8</guid>
            <dc:creator><![CDATA[石南]]></dc:creator>
            <pubDate>Wed, 22 Jul 2026 16:39:29 GMT</pubDate>
            <atom:updated>2026-07-22T16:39:29.645Z</atom:updated>
            <content:encoded><![CDATA[<h4>為了寫測試腳本，AI 一定得先讀懂程式；但測試的「答案」一旦也跟著程式走，測試就失去了意義。這一章講怎麼守住這條界線</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6HlBlGZKHI3O_Y1jPz7p0A.jpeg" /></figure><p>上一章講到，AI 寫測試最根本的問題是「裁判兼球員」，其中最難防的部分，是它會把程式跑出來的行為，當成答案。這一章就來回答上一章結尾留下的問題：測試的答案，到底該從哪裡來。</p><p>我的方式是設立界線，也是這套方法裡最核心的一條規則：<strong>測試的預期結果，只能從規格推導，不能從程式碼推導。</strong>我把它稱為「防火牆」，因為它要在「讀程式」和「決定答案」這兩件事之間，隔出一道不能跨過的牆。</p><h3><strong>為什麼不能拿程式當答案</strong></h3><p>接著上一章那個查詢的例子。要驗證查詢結果對不對，手上得先有一份答案可以比對。最省事的做法，是照抄後端那段查詢的 SQL，自己也跑一次，看畫面和它一不一致。但這樣測出來的，只證明了「畫面和後端一致」，不是「畫面和規格一致」。如果後端本身就把規格實作錯了，這種測試永遠不會發現，因為它拿來當答案的，正是那段錯的實作。</p><p>所以答案不能從程式取得，而要從規格取得。具體做法是：AI 依規格和資料庫結構，寫一份對照用的查詢，拿它算出來的結果當預期，去比對畫面。這份對照查詢（鏡像 SQL）必須能「只憑規格就推導出來」。如果推出來的邏輯，和後端不一樣，那反而是個值得記下來的訊號，因為它很可能就是後端和規格對不上的地方。</p><h3><strong>難點是，寫腳本一定得先讀程式</strong></h3><p>防火牆聽起來簡單，但卻很容易被打破。因為要寫腳本，一定得先讀程式：畫面上哪個按鈕、送出什麼參數、資料怎麼查。而一旦讀了，上一章講的「把實作當答案」的傾向就會跑出來。</p><p>這道牆最難的地方在於，它要求同一個 AI agent，在讀過程式之後，還能假裝沒看過、只照規格決定預期結果。透過實際經驗發現，這是不太可能的，光憑下指令禁止也守不住(即使是高優先序的指令)。所以不能靠 AI「自律」去處理，而是用以下兩個辦法：一個是時序，一個是出處要求。</p><p><strong>時序</strong>：先憑規格把每一筆預期結果定好、凍結起來，之後才准讀程式寫腳本。這樣預期結果是在還沒看過實作時就定的，不會被實作帶著走。而既然光靠指令攔不住，所以直接用一道機械性的鎖：在預期結果定案之前，實體擋住 AI 去讀任何程式碼。這個鎖怎麼運作、順序怎麼在流程裡強制定下，是下一章的主題。</p><p><strong>出處要求</strong>：每一筆預期結果，都要求它標上「出自規格的哪裡」。標得出來，就正常比對；標不出來，就把它記成一筆「待釐清」，繼續往下跑，但絕不拿實作補上去充當預期結果。</p><h3><strong>規格沒寫、或跟實作對不上</strong></h3><p>依規格定預期結果，與實作比對時，會遇到三種狀況：</p><p>- <strong>規格根本沒寫</strong>：某個行為，規格完全沒提。這時不准「去看程式怎麼做、當成預期結果」，而是記一筆「規格沉默」，留待和需求方確認。要注意，沉默不等於不用測，只是預期值先照使用者常識或同類功能的慣例來推，並註明這個推法的來源。</p><p>- <strong>找不到規格依據</strong>：預期結果或案例引不到規格出處。記一筆「查無依據」，可能是規格要補，也可能是案例設計有問題，留給人判斷。</p><p>- <strong>規格有寫、但實作對不上</strong>：這是最重要的一種。照規格推出來的預期結果，和畫面實際跑出來的不一樣。這通常就是一個真正的Bug。在比對失敗後，要特別標記在報告裡。</p><p>這三種情況， AI 都只「記錄」，不停下來判斷對錯，也不因此中斷。判斷留給最後看報告的人。</p><h3><strong>另外兩道界線</strong></h3><p>除了答案來源這道最關鍵的牆，還有兩道比較單純、但一樣重要的界線。</p><p><strong>角色界線</strong>：測試員非開發人員。抓到程式的錯，記錄、回報，不投入修正。</p><p><strong>資料界線</strong>：測試資料庫只能唯讀(只做 SELECT)。需要改資料時，不自己動手寫入，而是把要下的 SQL 交給負責的人執行。這有兩個原因。一是不污染受測環境，並避免誤改、誤刪重要資料；二是保持獨立，避免 AI 去「製造」想看到的資料。唯一的例外，是透過畫面正常操作去新增或修改，因為那本來就是使用者會做的事，也是測試本身要驗的動作，事後 AI 再用 SELECT 確認它真的寫進去了。</p><h3><strong>小結</strong></h3><p>這一章的重點是：測試的預期結果要從規格取得，不從程式取得。這要靠「答案先定、程式後讀」的時序去保證。</p><p>下一章講這個順序怎麼落實：把整個流程切成三個階段，讓人只在流程的頭尾出場，中間放手讓 AI 自動處理。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3af2f80455a8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【AI 自動化測試】一、AI 寫測試最容易犯的錯：裁判兼球員]]></title>
            <link>https://medium.com/@heather_programming/20260722-7362bc744f7a?source=rss-613ff406fd78------2</link>
            <guid isPermaLink="false">https://medium.com/p/7362bc744f7a</guid>
            <dc:creator><![CDATA[石南]]></dc:creator>
            <pubDate>Wed, 22 Jul 2026 12:45:31 GMT</pubDate>
            <atom:updated>2026-08-24T02:28:54.636Z</atom:updated>
            <content:encoded><![CDATA[<h4>AI 擅長寫測試腳本，卻容易混淆開發與判斷的角色，讓測試看起來全通過、其實什麼都沒驗到</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6HlBlGZKHI3O_Y1jPz7p0A.jpeg" /></figure><p>把 AI 協作融入工作流程之後，現在經常是一條龍從開發一路做到產出測試報告，我也因此開始讓 AI 幫忙寫自動化測試。</p><p>一開始的想法很簡單：把功能和規格交給它，讓它產出 Playwright 腳本，跑測試、出報告。但實際做下來才發現問題不少。如果沒有一套對的方法，很容易產出通通綠燈、卻抓不出問題的測試報告。</p><p>說得具體一點，身為開發者，從前我們做整合測試時，都會特別謹慎，因為人很容易不自覺地從開發的角度去測，陷入自己的盲點。但後來發現，其實換成 AI 來測，也會遇到一模一樣的問題。</p><p>因此，從這幾次的實務經驗，我認為 AI 自動化測試最根本、最該優先防的，就是「裁判兼球員」的問題。我把這段時間摸索出來的做法，整理成一套能提升測試效力的方法論。這一章就先從它講起，其他的問題後面章節再談。</p><h3>什麼是裁判兼球員</h3><p>測試之所以有意義，是因為它用一個<strong>獨立於程式之外的判準</strong>，去驗證程式對不對。裁判要中立，不能同時是球員，也就是不能拿被驗的東西本身，回頭當作評判的依據。</p><p>問題是，AI 在寫測試時特別容易變成裁判兼球員，從兩個地方體現出來。</p><h4>一、把程式的行為，當成了正確答案</h4><p>這是裁判兼球員最直接的樣子：測試手上那份「正確答案」，其實是從被測的程式來的。它有兩層原因：</p><p><strong>第一層，是看到程式碼會影響判斷。</strong></p><p>要寫測試腳本，一定得先讀懂系統怎麼運作：畫面上哪個按鈕、送出什麼參數、資料怎麼查。但一旦看過「程式怎麼算」，就會很自然地把「程式算出來的結果」當成「應該要的結果」。</p><p>舉個查詢功能的例子。要驗證查詢結果對不對，測試手上得先有一份正確答案可以比對。最省事的做法，是照抄後端那段查詢的 SQL，自己也跑一次，看畫面和它一不一致。但這樣測出來的，只證明了「畫面和後端一致」，不是「畫面和規格一致」。如果後端本身就把規格實作錯了，這個測試永遠不會發現，因為它拿來當答案的，正是那段錯的實作。</p><p><strong>第二層更難防，跟 AI 的本質有關。</strong></p><p>AI 的本質，是為輸入找一個合理的解釋、產生一個看起來合理的輸出。這個傾向放到寫程式很好用，但放到測試上會出事：它會傾向把結果<strong>解釋成通過</strong>。遇到畫面和預期對不上的地方，它的第一反應往往不是「這是不是一個 bug」，而是「讓這個現象變得合理」，於是它會去調整比對邏輯、放寬條件、或替這個差異想一套說法，直到測試變綠。</p><p>但測試需要的能力剛好相反，是<strong>鑑別力</strong>：看到畫面和預期對不上，先假設它是錯的，再想辦法證實或推翻，而不是急著替它找一個說得通的理由。一個急著把每個現象都解釋通的測試員，會不知不覺把真正的缺陷合理化掉。</p><p>這也是為什麼不能讓 AI 自己決定「什麼叫對」。正確答案必須來自它以外、獨立的來源，也就是規格。怎麼守住這條界線，是下一章「防火牆」的重點。</p><h4>二、抓到 bug 之後，忍不住想下場修</h4><p>裁判兼球員的另一個表現跟角色有關。測試員抓到程式的錯，應該要：記錄、回報，然後停手。但 AI 抓到問題後，很自然會切換成開發者，開始想「這要怎麼改才會對」，或一路追下去研究「它為什麼會錯」。</p><p>這麼做要付幾個代價：測試的方向會偏掉，本來該一個案例接一個往下驗，卻一頭鑽進單一問題的成因，很消耗時間和 token，而且動手改還會抹掉缺陷的證據。測試員一旦下場當開發者，也就失去中立，又變回裁判兼球員。</p><p>正確的做法是，看到有問題記下來就好，成因和怎麼修都與測試無關，那是開發的事。所以我給 AI 立的界線是：診斷只做到分清「這是程式的錯，還是測試腳本自己的錯」為止；是腳本的錯（選擇器抓錯、等錯 API、測資設計不當）才動手修，是程式的錯就記下來、回報，繼續往下測。</p><h3><strong>其他的問題</strong></h3><p>除了裁判兼球員，我還遇過另外兩個問題：一個是需要測資時，跟著 AI 的回饋一路補（第三章會談怎麼用前置規劃避開），導致需要大量的時間在場，無法放手交給 AI，將人力空出來。另一個是報告的證據力不足，交出去也無從查驗（第五章會談）。</p><p>我把它們排在後面，是因為這兩個問題頂多是讓測試做得比較慢，而裁判兼球員會讓測試從根本上失去意義：腳本全通過、報告漂亮，卻等於白測。所以要先防的是它。</p><h3><strong>這一系列的結構</strong></h3><p>後面幾章會依序講：</p><ul><li><a href="https://medium.com/@heather_programming/20260723-3af2f80455a8"><strong>第二章</strong></a>：三道界線，包括測試員不改程式、資料庫只能唯讀，以及最關鍵的「預期值到底該從哪裡來」。</li><li><a href="https://medium.com/@heather_programming/20260804-49007c1607aa"><strong>第三章</strong></a>：三階段流程，把人力集中在開頭和結尾，中間讓 AI 自主跑。</li><li><a href="https://medium.com/@heather_programming/20260806-2861dfa26c59"><strong>第四章</strong></a>：讓 AI 測試跑得流暢與正確的實作細節。</li><li><a href="https://medium.com/@heather_programming/20260817-e1ab31da6232"><strong>第五章</strong></a>：報告怎麼做才有證據力。</li><li><a href="https://medium.com/@heather_programming/20260818-4b1f328ce6a9"><strong>第六章</strong></a>：用一個實際功能，把前面所有做法串成一條完整流程。</li><li><a href="https://medium.com/@heather_programming/20260819-0468ec0cb130"><strong>附錄</strong></a>：用 Claude Code 的 Hook 限制 AI 行為</li></ul><p>下一章會講最關鍵的那道界線：測試的正確答案，該從規格來，還是從程式碼來。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7362bc744f7a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【AI Devops】用 Aider × GitHub Actions 讓 AI 自動維護系統設計文件]]></title>
            <link>https://medium.com/@heather_programming/%E7%94%A8-aider-github-actions-%E8%AE%93-ai-%E8%87%AA%E5%8B%95%E7%B6%AD%E8%AD%B7%E7%B3%BB%E7%B5%B1%E8%A8%AD%E8%A8%88%E6%96%87%E4%BB%B6-cab27cd995c5?source=rss-613ff406fd78------2</link>
            <guid isPermaLink="false">https://medium.com/p/cab27cd995c5</guid>
            <dc:creator><![CDATA[石南]]></dc:creator>
            <pubDate>Tue, 07 Jul 2026 15:23:10 GMT</pubDate>
            <atom:updated>2026-07-22T16:42:31.134Z</atom:updated>
            <content:encoded><![CDATA[<h4>讓 AI 協作工具進駐 CI/CD 流程，從根本解決「文件與程式碼失去同步」的老問題</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cGySNJNhQUjKsykec_pcgQ.jpeg" /></figure><h3>一、為什麼要做這件事：長期累積的「文件債」</h3><p>在多數團隊裡，系統設計文件（System Design Document，以下簡稱 SD 文件）幾乎注定會過時。程式碼每天都在改，但文件往往要等到「有空」或「有人想起」才會被更新(然後經常就不了了之)。最後文件與程式碼之間的落差逐漸擴大，造成長期的文件漂移問題。</p><p>在我之前參與過的專案中，遇過三個具體的痛點：</p><ul><li><strong>文件與程式碼失去同步。</strong> 文件描述的是三個月前的架構，實際實作卻早已改頭換面，讀文件反而會被誤導。</li><li><strong>維護成本高、且容易遺漏。</strong> 手動維護文件是一項枯燥、重複、又不會立即產生價值的工作，在交付壓力下永遠排在最後，於是被無限延後。</li><li><strong>新進工程師無法憑文件理解專案。</strong> 對新人而言，一份可信的設計文件是最好的地圖；當文件不可信，onboarding 的成本就會轉嫁到資深工程師的口頭講解上。</li></ul><p>這些問題，讓我希望可以達到一個目標：</p><p><strong>讓 AI 在程式碼變動的當下，自動維護對應的設計文件</strong>。而要讓這件事真正持續發生，我採取的方式是<strong>把「更新文件」納入 CI/CD 流程，成為與建置、測試、部署並列的一個環節</strong>。當文件更新和程式碼一起被納入自動化管線，它就不再仰賴任何人的自律或記憶力，而是隨每一次提交自動觸發 「更新文件」，這樣就可以將一件老是被延後的人工待辦，轉化為流程中自動發生的一步。</p><p>初步的技術構想，是把 AI 協作工具接進版本發布流程，核心組合為：</p><blockquote><strong><em>GitHub Actions（自動化觸發） + Aider（AI 程式協作工具）</em></strong></blockquote><h3>二、核心工具：Aider</h3><p><a href="https://aider.chat/">Aider</a> 是一套開源的 <strong>AI 結對程式設計（AI Pair Programming）</strong> 工具，直接運行於終端機（CLI）中，比較像是在 Git 儲存庫裡的 AI 工具。之所以選擇它，是因為幾項特性正好切中我的需求：</p><ul><li><strong>自主編輯與提交。</strong> Aider 能直接讀取、修改本地 Git 儲存庫中的檔案，並在每次變更後自動完成 git commit，且附上語意清楚的提交訊息。整段修改歷程都留在 Git 中，可隨時 diff、審查或還原。</li><li><strong>Repo Map（儲存庫地圖）技術。</strong> 它會掃描整個專案，建立一份精確的程式結構圖，讓 LLM 得以理解模組之間的引用與相依關係 — — 這對大型專案尤其關鍵，也是它在跨檔案任務上表現穩定的原因。</li><li><strong>模型與語言不綁定。</strong> Aider 支援絕大多數主流 LLM（Anthropic Claude、OpenAI GPT、Google Gemini、以及可透過 Ollama 運行的本地模型等），並涵蓋一百種以上的程式語言。</li><li><strong>為腳本化與 CI 而生。</strong> 因為它是純 CLI 工具，天然適合放進 Docker 容器、SSH 遠端環境或 CI/CD 流程中自動執行， 這一點正是我想要的。</li></ul><blockquote><em>補充：Aider 近期版本還提供 </em><strong><em>架構師／編輯者模式（architect / editor mode）</em></strong><em>、</em><strong><em>提示快取（prompt caching）</em></strong><em> 與 </em><em>.aider.conf.yml 設定檔等功能，後面談成本控制與品質把關時會再回頭利用它們。</em></blockquote><h3>三、系統運作流程</h3><p>整套機制的設計重點，是「<strong>先建立一份可重複使用的專案地圖，再讓每次更新只針對差異運作</strong>」，藉此節省時間與運算成本，並確保 AI 每一次對專案的理解都保持一致。</p><p>具體做法分為兩個層次：</p><p><strong>（1）建立架構記憶檔（Memory）</strong> 在導入初期，先對整份程式碼做一次完整分析，產出一份 Markdown 檔作為專案架構的基底記憶（memory）。之後每次執行時，AI 不必再從零掃描整個專案，而是以這份記憶為基礎、只處理本次的異動，藉此節省時間與 token 花費，並讓輸出風格保持穩定。</p><p><strong>（2）在每次推送時自動觸發更新</strong></p><blockquote>程式碼 Push 到主分支 (main)<br> ↓<br>GitHub Actions 啟動<br> ↓<br>Aider CLI 掃描本次程式碼異動 (diff)<br> ↓<br>Aider 重新生成「架構記憶檔」與「SD 設計文件」<br> ↓<br>自動 Commit 並推送更新後的文件</blockquote><p>如此一來，文件更新不再依賴任何人記得去做，而是隨著每一次程式碼提交自動完成。</p><h3>四、實作步驟：從零把流程建起來</h3><p>以下以 Anthropic Claude 為例，示範完整的三個階段。若改用 OpenAI，只需替換對應的 API 金鑰與模型名稱即可。</p><h4>第一階段：申請 API 金鑰</h4><p>前往 <a href="https://www.anthropic.com/">Anthropic 官方網站</a> 註冊並申請 ANTHROPIC_API_KEY（若使用 OpenAI，則到 OpenAI 平台申請對應金鑰）。這把金鑰會是 Aider 呼叫 LLM 的憑證，請妥善保管，切勿寫死在程式碼或提交進儲存庫。</p><h4>第二階段：在 GitHub 設定金鑰（Secrets）</h4><p>為了讓自動化流程能安全地取用金鑰，我們把它存進 GitHub 的加密機密（Secrets）中，而非明文放在設定檔裡：</p><ol><li>進入 GitHub 專案頁面，點選 <strong>Settings → Secrets and variables → Actions → New repository secret</strong>。</li><li><strong>Name</strong> 填入 ANTHROPIC_API_KEY，<strong>Secret</strong> 貼上你的金鑰內容。</li></ol><p>存入後，這把金鑰只能在 workflow 執行期間透過環境變數取用，不會顯示於任何日誌中。</p><h4>第三階段：撰寫工作流程設定（Workflow YAML）</h4><p>在專案中建立設定檔 .github/workflows/auto_docs.yml，它定義了「什麼時候、在什麼環境、做哪些事」。以下逐段拆解其組成：</p><ol><li><strong>設定觸發時機（Trigger）</strong> 指定當程式碼推送到 dev 分支時啟動流程：</li></ol><pre>on:<br>  push:<br>    branches: [dev]</pre><p><strong>2. 準備執行環境（Setup）</strong> 由 GitHub 配置一台 Runner（Ubuntu 虛擬執行環境），並安裝 Python。</p><p><strong>3. 安裝 Aider（Installation）</strong></p><pre>pip install aider-chat</pre><blockquote><em>補充：Aider 官方目前更推薦使用獨立環境安裝，避免與專案既有的 Python 相依套件互相干擾，例如透過 </em><em>python -m pip install aider-install &amp;&amp; aider-install。</em></blockquote><p><strong>4. 執行 Aider 指令（核心任務）</strong> 以「單次訊息」模式驅動 Aider 更新文件，並自動確認所有變更：</p><pre>aider --message &quot;請根據本次程式碼異動，更新系統設計文件 SD.md 與架構記憶檔&quot; --yes-always</pre><p><strong>5. 將結果推送回儲存庫（Commit &amp; Push）</strong> 執行 Git 指令，把被 AI 修改過的 SD.md 提交並推送回儲存庫，讓更新後的文件成為儲存庫的最新狀態。</p><p>完成以上三階段後，這套自動化文件維護機制就正式完成了。</p><h3>五、進階考量與最佳實踐</h3><p>上面的流程是簡單作一個模型，但要真正放進正式專案，還有幾個不能忽略的細節和注意事項：</p><h4>1. 防止觸發無限迴圈</h4><p>這是最容易踩到的陷阱：workflow 提交文件 → 產生新的 push → 又觸發 workflow → 再次提交……。</p><p>一般來說，<strong>使用 GitHub 預設的 </strong><strong>GITHUB_TOKEN 所做的 push，並不會再觸發新的 workflow</strong>，這道內建保護恰好幫我們擋掉了迴圈。但如果日後改用個人存取權杖（PAT）來推送，就必須自行加上防護，例如在提交訊息帶入 [skip ci]，或以 paths 過濾只針對程式碼變動觸發。</p><pre>on:<br>  push:<br>    branches: [dev]<br>    paths-ignore:<br>      - &quot;SD.md&quot;<br>      - &quot;memory.md&quot;</pre><h4>2. 用 Pull Request 取代直接提交到 dev</h4><p>讓 AI 直接把文件推上 dev，等於讓未經審查的內容直接進入開發主線。更穩健的做法，是讓流程<strong>開一個 Pull Request</strong>，把 AI 生成的文件變更交給人工快速審閱後再合併。這樣既保留自動化的效率，又守住「文件正確性由人負責」的底線。</p><h4>3. 控制 API 成本</h4><p>在活躍的專案上，每次 push 都呼叫 LLM 掃描並改寫文件，累積起來是一筆可觀的花費。可考慮：</p><ul><li>以 paths 過濾，只有當核心程式碼（而非設定檔、測試檔）變動時才觸發</li><li>文件生成這類任務對推理能力要求不高，可指定較便宜的模型</li><li>善用 Aider 的 <strong>提示快取（prompt caching）</strong>，讓重複的專案背景資訊不必每次重付費用 — — 這與我們前面設計的「架構記憶檔」概念相輔相成</li></ul><h4>5. 建立文件慣例檔</h4><p>若希望 AI 產出的文件維持一致的結構與語氣，可以額外準備一份 template，明確規範章節結構、術語用法與詳略程度，並在每次執行時作為唯讀參考餵給 Aider。這能有效降低不同次生成之間的風格漂移。</p><h3>六、結語</h3><p>「文件與程式碼失去同步」之所以難解，不在於技術，而在於它是一項沒有人願意持續承擔的重複勞動。而重複、規則明確、又依附於程式碼變動的工作，恰恰是自動化與 AI 最擅長的領域。</p><p>透過 GitHub Actions 與 Aider 的組合，我們把「維護文件」從一件需要人記得去做的苦差事，變成流程中自動發生的環節，確保文件<strong>始終存在、且跟得上程式碼</strong> ，這就能解決團隊間的資訊流失與傳承問題。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cab27cd995c5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【Azure Kubernetes Services】如何選擇適合的節點池及調度應用程式]]></title>
            <link>https://medium.com/@heather_programming/azure-kubernetes-services-%E5%A6%82%E4%BD%95%E9%81%B8%E6%93%87%E9%81%A9%E5%90%88%E7%9A%84%E7%AF%80%E9%BB%9E%E6%B1%A0%E5%8F%8A%E8%AA%BF%E5%BA%A6%E6%87%89%E7%94%A8%E7%A8%8B%E5%BC%8F-d2bd4d3cd18a?source=rss-613ff406fd78------2</link>
            <guid isPermaLink="false">https://medium.com/p/d2bd4d3cd18a</guid>
            <dc:creator><![CDATA[石南]]></dc:creator>
            <pubDate>Tue, 05 Nov 2024 09:20:35 GMT</pubDate>
            <atom:updated>2024-11-05T17:36:10.959Z</atom:updated>
            <content:encoded><![CDATA[<h4>新增 node pool 並通過 drain、cordon、label、taint 指令來調度 pod</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Is8kUwhXCtIjeFG1.png" /></figure><p>節點池（Node Pool）是 Azure Kubernetes Service (AKS) 的核心單位，Azure 提供多種規格選擇，讓我們能搭配出最符合需求和預算的組合。在新建 Kubernetes 叢集時，會根據我們選擇的用途自動使用預設的節點池，但還是建議去了解 VM 的詳情及梳理實際的需求，並選擇恰當的方案，否則可能會程式跑太慢，或荷包大失血喔！</p><p>以下依序說明節點池介紹、節點池規格選擇，接著說明實務上如何新增及變更節點池，並重新調度應用程式。</p><h3>Azure 節點池介紹</h3><p>在 Kubernetes 中，節點（Node）是執行工作負載（Pod）的主機，是整個叢集（cluster）的基礎單元。而在 Azure Kubernetes Service 則透過節點池（Node Pool）來提供同種規格的多個節點。</p><p>Azure Kubernetes Service 的節點池是一組具有相同配置的虛擬機（VM），每個 VM 就代表 Kubernetes 中的一個節點。節點池是管理 AKS 節點的核心單位。每個節點池可以用來提供不同的計算能力、區域設置、以及自動擴縮功能，以適應不同的應用程式需求。</p><p>也就是說，在同一個叢集裡，我們可以設置多個不同規格及作業環境的節點池，並根據 Pod 的需求分配到適當的節點池中。比如使用較高規格的節點池運行需要 GPU 資源的深度學習應用，並搭配另一個較低規格的節點池，用於一般應用程式。這無疑大大增加了 AKS 的靈活性和擴充性，並且能搭配出更符合成本效益的方案。</p><h3>節點池選擇</h3><p>在選擇節點池時，要考慮工作負載所需的規格、應用程式的用途、作業系統、CPU 架構以及預算。</p><h4>規格</h4><p>虛擬機的規格包括 vCPUs、RAM、Data disks、Max IOPS（最大每秒I/O操作次數）、Local storage、Premium disk。</p><blockquote><strong>Data disks：</strong>每個節點（VM）允許掛載的最大數據磁碟數量（非實際已掛載的數量）。實務上透過 PV 及 PVC 進行掛載。</blockquote><blockquote><strong>Max IOPS：</strong>最大每秒 I/O 操作次數，在高併發的場景通常需要更大的 IOPS。</blockquote><blockquote><strong>Local storage：</strong>本地儲存的容量，適用於快取及臨時文件頻繁存取、即時數據處理、大型數據庫的索引儲存的應用場景。</blockquote><blockquote><strong>Premium Disk：</strong>是否允許並支持掛載 Premium Disk。<br>Premium Disk -使用 SSD，具有高 IOPS、高吞吐量、低延遲的特性。<br>Standard Disk -使用 HDD 或 SSD，相對較低 IOPS、吞吐量和較高延遲。</blockquote><p>選擇符合需求的節點池來使用吧！</p><p>如果想更換規格，但不確定應用程式的資源需求，可以到 Overview &gt; Resource utilization 確認平時的用量：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DzuDnpFe-9nF5Kbro3p9wg.png" /></figure><h4>處理器架構</h4><p>這點很重要，但也很容易忽略，因為在規格表上沒有直接寫出每個 VM 的CPU 架構。VM 要選擇與應用程式 image 一致的架構，否則會因不相容而無法正常運行。</p><p>可以參考官網中的 VM 名稱詳解：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/882/1*DHqGHgXuwVK68trU3pbLSg.png" /></figure><p>從第 3 點可知，若 VM 名稱中含有 “a” 表示是 AMD 架構，含有 “p” 表示是 ARM 架構，都沒有表示使用 Intel x86–64 CPU。AMD 與 Intel 大部分情況下都可兼容。</p><p>在節點池新增後，也可從 Overview 裡 “beta.kubernetes.io/arch” 的 label 可以確認是否為正確的處理器架構。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sz6w8gMGLFQw-mLiCzKbOA.png" /></figure><p>確定以上事項後，就可以依照需求選出適當的 VM 了。節點池是以月計費，為了避免月底看到帳單時心痛，挑選符合預算的方案就很重要。可參考以下的「Azure VM 價目表」，但要注意價格會因區域而有差異，在計算金額時請選擇正確的區域。</p><p><strong>＊Azure VM 價目表：<br></strong><a href="https://azure.microsoft.com/en-us/pricing/details/virtual-machines/linux/#pricing">https://azure.microsoft.com/en-us/pricing/details/virtual-machines/linux/#pricing</a></p><p><strong>＊Azure VM 規格介紹：<br></strong><a href="https://learn.microsoft.com/zh-tw/azure/virtual-machines/sizes/overview">https://learn.microsoft.com/zh-tw/azure/virtual-machines/sizes/overview</a></p><h3>如何新增節點池</h3><p>如果在叢集建立後，想新增節點池來容納新的應用程式，並將應用程式分派到指定的節點，請根據以下步驟來操作。</p><h4>一、新增節點池</h4><ol><li><strong>在 Settings &gt; Node pools 裡新增節點池：</strong></li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EIN24LXDRwT14GvTS1p9Ww.png" /></figure><p><strong>2. 決定新節點池的規格：</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/1*7plOzAyo8rduGgpMVoNz7g.png" /></figure><blockquote>Mode：取決於節點池的功能。</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/771/1*B-WgkS8VS8QrH4MV-4KOEg.png" /></figure><blockquote>Scale Method： <br>Manual -直接規定固定的 Node count。<br>Autoscale -可以框定 Node count 的上下限，根據負載自動縮放。</blockquote><p><strong>3. 點擊 “Choose a size” 選擇節點池的規格</strong></p><p>可依照所需規格進行篩選，並根據條件或 VM 系列進行排序：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7QE97vxi2rn5qNzitXALeg.png" /></figure><p><strong>4.</strong> <strong>節點池設定</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*KBLhrBnfiCiYsjLXM0qO8Q.png" /></figure><blockquote>Maximum Surge：定義在節點池升級時，可以同時新增的最大節點數量，以確保升級過程的可用性和效率。</blockquote><blockquote>Label、Taints：非必填，方便 Node 的管理和 Pod 的分配。(後面會再說明這兩個名詞)</blockquote><p><strong>5.</strong> <strong>點擊 “Review + Create” 完成新增</strong></p><p>完成新增後需運行一陣子，等 Ready nodes 到了預期數量，表示新增成功。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*pXT-FlZj6Bieu_j5o_ckQA.png" /></figure><p><strong>[補充] 自選初始節點池</strong></p><p>在建立 Kubernetes 叢集時，AKS 會根據我們選擇 Cluster details 給我們一個預設的節點池 VM 選項，但我們也可以自選適合自己的節點池：</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*Nxh7Ll-I0gWauCHFSagIrA.png" /></figure><p>接下來的步驟就跟上面一樣就可以了。</p><h4>二、分派工作負載</h4><p>新增完節點池後，我們要將特定的 Pod 分派到新節點池上，有三種方法可以使用。第一種是利用親和性（Affinity） 將 Pod 優先分派到具有相應標籤（label）的節點。第二種則是利用容忍度（Toleration）來防止某些 Pod 分派到具有相應污點（taint）的節點。第三種則是利用 NodeName 指令欲分派的節點。</p><p>要注意的是，前兩個方法只能使 Pod <strong><em>傾向</em></strong>分配到某節點上，只有第三個方法會<strong><em>強制</em></strong>分配到某節點。</p><ol><li><strong>Node label + Pod affinity</strong></li></ol><p><strong>(1) 用以下指令在 Node 上增加 label：</strong></p><pre>kubectl label node &lt;node&gt; app=myapp</pre><p><strong>(2) 在 Pod 的 YAML 裡增加對應的 affinity：</strong></p><pre>spec:<br>  affinity:<br>    nodeAffinity:<br>      requiredDuringSchedulingIgnoredDuringExecution:<br>        nodeSelectorTerms:<br>        - matchExpressions:<br>          - key: app<br>            operator: In<br>            values:<br>            - myapp</pre><p>請注意，此做法不能保證 Pod 一定會分派到該節點，因為還有其他條件影響調度結果，比如節點的剩餘容量等等。</p><p><strong>2. Node taint + Pod toleration</strong></p><p><strong>(l) 用以下指令在 Node 上增加 taint：</strong></p><pre>kubectl taint node &lt;node&gt; app=myapp:NoSchedule</pre><p><strong>(2) 在 Pod 的 YAML 裡增加對應的 toleration：</strong></p><pre>spec:<br>  tolerations:<br>  - key: &quot;app&quot;<br>    operator: &quot;Equal&quot;<br>    value: &quot;myapp&quot;<br>    effect: &quot;NoSchedule&quot;</pre><p>同樣，此做法只能保證 Pod <strong>不會</strong>調度到某個節點，但不能保證 Pod 一定<strong>會</strong>調度到某個節點。</p><p><strong>3. NodeName：</strong></p><p>在 Pod 的 YAML 裡增加欲分配到的節點 nodeName。這個做法會強制分配到該節點，但風險是若該節點不存在或有問題，Pod 也會無法啟動。</p><pre>spec:<br>  nodeName: &lt;node&gt;</pre><p>因為 Affinity 和 Toleration 蠻複雜的，之後會再寫一篇詳細說明，以上只是簡述方法，有關分派 pod 的詳情，也可參考 <a href="https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/">Kubernetes 官網</a>。</p><h3>如何變更節點池</h3><p>如果在叢集建立後，發現原本的節點池不符合需求，想更換節點池，並遷移應用程式到新節點池，請根據以下實作詳述來操作。</p><h4>一、新增節點池</h4><p>作法與上述「如何新增節點池」的做法一致，故不重述。</p><h4><strong>二、</strong> <strong>遷移</strong>工作負載</h4><p>確定新節點池完成新增後，開始將舊節點上的應用程式遷移到新節點上。（除了 Pod 需遷移之外，Service、Ingress、ConfigMap、Secret 等皆不會變動，因為這些資源皆是跨節點的）</p><ol><li><strong>清空舊節點</strong></li></ol><p>(1) 顯示全部節點，找到舊節點池所包含的節點（此例子有 2 個節點）：</p><pre>kubectl get nodes</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*qPyZ6iK3kcy1IX-At4OxhA.png" /></figure><p>也可以從 UI 介面上確認各節點池包含的節點：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*Lhg9NirrK1nIcnQwOVyjSA.png" /></figure><p>(2) 清空舊節點池裡的全部節點：</p><pre>kubectl drain &lt;node&gt; --ignore-daemonsets --delete-emptydir-data</pre><blockquote>— ignore-daemonsets：忽略daemonsets。（這些daemonsets通常是預設系統元件，每個node上皆有一個，可以先不用理會。）</blockquote><blockquote>— delete-emptydir-data：允許刪除使用 emptyDir 卷的 Pod。(emptyDir 是臨時存儲，會在 Pod 被移除時清空，這類數據沒有持久化需求，所以可以刪掉。)</blockquote><p>Terimal 顯示 “cordoned”，表示此 Node 已被封鎖，不再允許新的 Pod 分配進來：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/490/1*sfaJyMdvoEnGwSTECLu6uQ.png" /></figure><p>最後則顯示 “”drained”，表示此 Node 清空完畢：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/490/1*nyFWO7mWSI9OjhRcaCf70g.png" /></figure><p><strong>2. 確認節點情況</strong></p><p>一旦執行 Drain，舊節點會被封鎖，無法被分配 Pod，且會驅逐所有應用程式的 Pod。這些 Pod 會重新分配至新節點。</p><blockquote>kube-system namespace 中的某些 pod 還是會保留，這是因為剛剛指令包含ignore-daemonsets 的關係，這些都是預設的系統元件。之後刪掉節點池時就會一併刪掉了。</blockquote><p>(1) 顯示全部節點：</p><pre>kubectl get nodes</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*6epat5iOn27QXMW9occB9Q.png" /></figure><p>可以看到舊節點都已被封鎖，顯示 “SchedulingDisabled”。</p><p>UI 介面上也可以發現，舊節點多了 “NoSchedule” 的 Taints：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*W1f8jZmABYLpOdoVPIrj0A.png" /></figure><p>(2) 顯示全部 Pod：</p><pre>kubectl get pods -o wide</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JsnqsxeHIpPfx-9DIVim-A.png" /></figure><p>可以看到全部的 Pod 都轉到新節點上了，一旦全部的 Pod 皆顯示 Running，則遷移成功。</p><p><strong>3. 刪除舊節點池</strong></p><p>確認全部的應用程式都已移到新的節點池，且功能測試無誤後，就可以刪掉舊節點池。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*e3aJ2igQJkN601ga4cp_uw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d2bd4d3cd18a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>