效能調校:pprof 與 benchmark
Performance Tuning in Go: pprof and Benchmarks
先用 testing.B 與 Go 1.24 的 b.Loop 寫出可信的 benchmark,以 benchstat 比較改動前後;再用 pprof 分析 CPU、記憶體、goroutine 與鎖競爭,理解逃逸分析與配置成本,最後調整 GOMAXPROCS、GOGC、GOMEMLIMIT 並套用 PGO。
這篇的步驟
上一篇〈Docker 與 Kubernetes 部署(單一服務)〉我們把訂單服務打包成映像檔,在叢集裡設好資源請求與限制;這篇接著回答那些數字背後的問題:服務到底把 CPU 與記憶體花在哪裡,又該怎麼有根據地讓它變快、變省。
這篇要解決什麼
效能問題最常見的處理方式,是憑直覺改:「這裡用了 fmt.Sprintf,應該很慢」「改成指標傳遞比較省」「加個快取吧」。直覺有時候對,但更多時候改了半天,真正的瓶頸在完全不同的地方;或者改完之後到底有沒有變快,也只是「感覺」。
Go 的工具鏈為效能工作提供了一整套內建工具,原則只有一句話:先量測,再修改,再量測。這篇會依序介紹:
- 用
testing.B寫 benchmark,量測單一函式的耗時與記憶體配置。 - 用
benchstat判斷改動前後的差異是否真實,而不是雜訊。 - 用
pprof找出整個程式裡 CPU、記憶體、goroutine 與鎖的熱點,包括在正式環境的服務上安全地取樣。 - 理解逃逸分析與記憶體配置,知道哪些寫法會讓值跑到堆積上。
- 調整
GOMAXPROCS、GOGC、GOMEMLIMIT這些執行環境參數,以及用 PGO 讓編譯器依據實際負載最佳化。
範例延續 internal/order 的訂單服務:一個把訂單內容組成摘要字串的函式,以及處理下單請求的 HTTP 服務。
第 1 步:用 testing.B 寫 benchmark
benchmark 和測試寫在同一個 _test.go 檔案裡,函式名稱以 Benchmark 開頭,接收 *testing.B。Go 1.24 起推薦使用 for b.Loop() { ... } 的寫法,取代舊的 for i := 0; i < b.N; i++。b.Loop 有幾個好處:迴圈之前的準備工作自動不計時,不需要再呼叫 b.ResetTimer;迴圈主體裡的函式呼叫與它的參數、回傳值不會被編譯器當成無用程式碼刪掉,所以不必再把結果指派給全域變數來「騙過」最佳化;整個 benchmark 函式也只會被執行一次,昂貴的準備工作不會重複進行。
下面是一個完整、可以直接執行的測試檔。它比較兩種組出訂單摘要的寫法:一種用字串相加與 fmt.Sprintf,另一種用預先配置容量的 strings.Builder 與 strconv。
package order
import (
"fmt"
"strconv"
"strings"
"testing"
)
type Item struct {
SKU string
Qty int
Price int64 // 以「分」為單位
}
type Order struct {
ID string
UserID string
Items []Item
Total int64
Status string // pending / paid / cancelled
}
// SummaryNaive 以字串相加與 fmt.Sprintf 組出摘要。
func SummaryNaive(o *Order) string {
s := "order " + o.ID + ":"
for _, it := range o.Items {
s += fmt.Sprintf(" %s x%d", it.SKU, it.Qty)
}
return s
}
// SummaryBuilder 預先估算容量,避免反覆配置與 fmt 的格式化成本。
func SummaryBuilder(o *Order) string {
var b strings.Builder
b.Grow(len("order :") + len(o.ID) + len(o.Items)*16)
b.WriteString("order ")
b.WriteString(o.ID)
b.WriteByte(':')
for _, it := range o.Items {
b.WriteByte(' ')
b.WriteString(it.SKU)
b.WriteString(" x")
b.WriteString(strconv.Itoa(it.Qty))
}
return b.String()
}
func newOrder(n int) *Order {
o := &Order{ID: "A123", UserID: "u-42", Status: "pending"}
for i := range n {
o.Items = append(o.Items, Item{SKU: "SKU-" + strconv.Itoa(i), Qty: i%3 + 1, Price: 1990})
o.Total += int64(i%3+1) * 1990
}
return o
}
// 先確認兩種寫法結果一致,benchmark 才有比較的意義。
func TestSummaryEqual(t *testing.T) {
for _, n := range []int{0, 1, 10, 100} {
o := newOrder(n)
if got, want := SummaryBuilder(o), SummaryNaive(o); got != want {
t.Fatalf("n=%d: got %q, want %q", n, got, want)
}
}
}
func BenchmarkSummary(b *testing.B) {
for _, n := range []int{1, 10, 100} {
o := newOrder(n) // 準備工作:不計入時間
b.Run(fmt.Sprintf("naive/items=%d", n), func(b *testing.B) {
b.ReportAllocs()
for b.Loop() {
SummaryNaive(o)
}
})
b.Run(fmt.Sprintf("builder/items=%d", n), func(b *testing.B) {
b.ReportAllocs()
for b.Loop() {
SummaryBuilder(o)
}
})
}
}這個範例示範了幾個寫 benchmark 的好習慣:
- 先寫測試證明行為相同。最佳化最怕的是「變快了但結果錯了」。
TestSummaryEqual讓重構有安全網,這和〈測試:表格驅動、httptest、整合測試〉的精神一致。 - 用子 benchmark 掃過不同規模。
b.Run讓同一個 benchmark 涵蓋 1、10、100 個品項。兩種寫法在規模小時可能差不多,規模大時差距才拉開;只量一種大小容易得出片面的結論。 b.ReportAllocs()會在結果中加上每次操作的配置次數(allocs/op)與配置位元組數(B/op)。在 Go 裡,記憶體配置往往比純計算更貴,因為它還帶來垃圾回收的負擔。
執行 go test -bench=Summary -benchmem 會看到每個子 benchmark 的 ns/op、B/op、allocs/op。ns/op 是每次操作平均耗時,名稱後面的 -8 之類的數字是執行時的 GOMAXPROCS。
第 2 步:用 benchstat 比較,而不是看一次結果
benchmark 結果天生有雜訊:CPU 頻率調整、其他程式搶資源、作業系統排程,都會讓同一段程式碼每次跑出不同數字。只跑一次就說「快了 5%」,很可能只是運氣。
正確的做法是每個版本都跑多次,再用 benchstat 做統計比較。假設在 benchmark 裡只保留一個 Summary 函式,先用字串相加的寫法量一次,改成 strings.Builder 之後再量一次:
# 安裝 benchstat(golang.org/x/perf 的工具)
go install golang.org/x/perf/cmd/benchstat@latest
# 改動前:跑 10 次存成 old.txt
go test -run '^$' -bench=Summary -benchmem -count=10 ./internal/order > old.txt
# 修改程式後:同樣條件再跑一次
go test -run '^$' -bench=Summary -benchmem -count=10 ./internal/order > new.txt
# 統計比較
benchstat old.txt new.txt-run '^$' 表示不執行任何一般測試,只跑 benchmark。benchstat 的輸出大致如下(數字僅為示意,實際結果依機器而定):
│ old.txt │ new.txt │
│ sec/op │ sec/op vs base │
Summary/items=1-8 410.0n ± 3% 47.0n ± 2% -88.54% (p=0.000 n=10)
Summary/items=10-8 3.10µ ± 2% 0.43µ ± 1% -86.13% (p=0.000 n=10)
Summary/items=100-8 18.40µ ± 4% 1.12µ ± 2% -93.91% (p=0.000 n=10)
geomean 3.03µ 0.28µ -90.14%要看懂三個欄位:± 2% 是變異範圍,太大代表量測環境不穩定;p= 是統計檢定的 p 值,通常小於 0.05 才視為顯著差異;~ 表示兩者沒有顯著差別。上面的示意結果在三種規模下都顯著,而且差距隨品項數擴大。但要記得,這只說明「這個函式」變快了:如果組摘要只占整個請求耗時的一小部分,使用者感受到的改善可能微乎其微。函式層級的進步要放回整體去衡量,這就是下一步要用 profile 看整個程式的原因。
量測時盡量讓環境穩定:關掉其他耗資源的程式、筆電接上電源、新舊版本在同一台機器上交替執行。
第 3 步:用 pprof 找出 CPU 與記憶體熱點
benchmark 回答的是「這個函式多快」,但前提是你已經知道要看哪個函式。真實的服務裡,問題通常是「整個請求為什麼慢」「記憶體為什麼一直長」,這時候要用 profile:在程式執行期間定期取樣,統計時間或記憶體花在哪些函式上。
Go 內建幾種 profile:
| Profile | 回答的問題 | 取樣方式 |
|---|---|---|
| CPU | 哪些函式最耗 CPU 時間? | 每秒約 100 次中斷並記錄當下的呼叫堆疊 |
| heap | 誰配置了記憶體?目前堆積上存活的是什麼? | 依配置量取樣,分 inuse_* 與 alloc_* 兩種檢視 |
| goroutine | 現在有哪些 goroutine、各自卡在哪裡? | 快照所有 goroutine 的堆疊 |
| mutex | 哪些鎖競爭最嚴重? | 需設定取樣率,記錄等待持有者釋放鎖的時間 |
| block | goroutine 在哪裡阻塞(channel、鎖、select)? | 需設定取樣率 |
最簡單的取得方式,是在跑 benchmark 時順便產生 profile:go test -bench=Summary -cpuprofile=cpu.out -memprofile=mem.out。接著用 go tool pprof 分析。pprof 最實用的介面是網頁版,go tool pprof -http=:8081 cpu.out 會開啟瀏覽器,裡面有呼叫圖、火焰圖、原始碼對照等檢視。
閱讀 profile 時有兩個關鍵數字:flat 是函式「自己」花的時間,cum(cumulative)是函式加上它呼叫的所有函式總共花的時間。flat 高的函式是真正在做事的熱點;cum 高但 flat 低的函式,代表它的成本來自底下的呼叫,要往下追。
火焰圖把這些資訊畫成一張圖:橫軸是占用比例(不是時間順序),縱軸是呼叫深度,越寬的方塊越值得注意。
圖:火焰圖的寬度代表占用比例,最上層又寬的方塊是 flat 高的熱點;這個示意中,格式化與記憶體配置占了處理請求的大部分。
heap profile 的兩種檢視用途不同:inuse_space 看的是「現在」堆積上存活的物件,適合追查記憶體洩漏或常駐記憶體過高;alloc_space 看的是「累計」配置了多少,適合找出製造大量短命物件、讓垃圾回收很忙的地方。很多服務的 CPU profile 裡,runtime.mallocgc 與 GC 相關函式占了可觀的比例,這時候降低配置量往往比優化計算更有效。
第 4 步:在執行中的服務上取樣:net/http/pprof
benchmark 與測試裡的 profile 只反映測試資料的情況。真正的負載形狀要在正式環境才看得到,net/http/pprof 讓你透過 HTTP 從執行中的服務取得 profile。它的開銷很低:CPU profile 只在你要求的那 30 秒左右進行取樣,heap 的取樣一直都在進行、成本很小。
但 pprof 端點會洩漏程式內部資訊,CPU profile 也有一定成本,絕對不能對外公開。下面的完整範例把 pprof 掛在只監聽本機的獨立管理埠上,與對外服務的埠分開:
package main
import (
"log/slog"
"net/http"
"net/http/pprof"
"os"
"runtime"
"strconv"
"sync"
)
var (
mu sync.Mutex
stock = map[string]int{"SKU-1": 1_000_000}
)
// reserve 模擬庫存預留:一把全域鎖,負載一高就會出現競爭。
func reserve(sku string, qty int) bool {
mu.Lock()
defer mu.Unlock()
if stock[sku] < qty {
return false
}
stock[sku] -= qty
return true
}
func main() {
// mutex 與 block profile 預設關閉,需要設定取樣率。
runtime.SetMutexProfileFraction(10) // 約每 10 次競爭記錄 1 次
runtime.SetBlockProfileRate(10_000) // 約每阻塞 10µs 取樣一次
// 管理埠:只聽 localhost,透過 kubectl port-forward 存取。
admin := http.NewServeMux()
admin.HandleFunc("/debug/pprof/", pprof.Index) // heap、goroutine、mutex、block 等都由它處理
admin.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
admin.HandleFunc("/debug/pprof/profile", pprof.Profile)
admin.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
admin.HandleFunc("/debug/pprof/trace", pprof.Trace)
go func() {
if err := http.ListenAndServe("127.0.0.1:6060", admin); err != nil {
slog.Error("admin server", "err", err)
}
}()
app := http.NewServeMux()
app.HandleFunc("POST /orders", func(w http.ResponseWriter, r *http.Request) {
qty, _ := strconv.Atoi(r.URL.Query().Get("qty"))
if qty < 1 {
qty = 1
}
if !reserve("SKU-1", qty) {
http.Error(w, "out of stock", http.StatusConflict)
return
}
w.WriteHeader(http.StatusCreated)
_, _ = w.Write([]byte("ok"))
})
slog.Info("listening", "app", ":8080", "admin", "127.0.0.1:6060")
if err := http.ListenAndServe(":8080", app); err != nil {
slog.Error("app server", "err", err)
os.Exit(1)
}
}常見的寫法 import _ "net/http/pprof" 會把這些路徑註冊到 http.DefaultServeMux。如果對外的伺服器剛好也用 DefaultServeMux(例如 http.ListenAndServe(":8080", nil)),pprof 就會意外對外公開。上面的範例明確使用自己的 ServeMux,對外服務完全不會有 /debug/pprof/ 路徑。
取得 profile 的方式:
# 從叢集把管理埠轉到本機
kubectl port-forward deploy/order 6060:6060
# CPU:取樣 30 秒並開網頁介面
go tool pprof -http=:8081 'http://localhost:6060/debug/pprof/profile?seconds=30'
# 記憶體:目前存活的物件;加上 -sample_index=alloc_space 看累計配置
go tool pprof -http=:8081 http://localhost:6060/debug/pprof/heap
# goroutine:數量持續增加時,看它們都卡在哪一行
curl -s 'http://localhost:6060/debug/pprof/goroutine?debug=1' | head -50
# 鎖競爭
go tool pprof -http=:8081 http://localhost:6060/debug/pprof/mutex
# 比較兩個時間點的 heap,找出增長的部分
go tool pprof -http=:8081 -diff_base=heap-1.pb.gz heap-2.pb.gz
# 逃逸分析:看哪些變數被移到堆積上
go build -gcflags='-m' ./internal/order 2>&1 | grep -E 'escapes|moved to heap'goroutine profile 是排查洩漏最直接的工具:〈可觀測性:日誌、指標、追蹤〉提到 go_goroutines 指標只升不降時,用 debug=1 看彙總後的堆疊,通常會發現數千個 goroutine 卡在同一行的 channel 傳送或接收上,再對照〈Goroutine、Channel 與並發模式〉檢查是誰忘了取消或關閉。
mutex profile 會指出像上面 reserve 這種全域鎖的競爭。解法通常是縮小臨界區、依鍵分片(例如依 SKU 分成多把鎖),或改用不需要鎖的設計。範例裡的鎖只是示意,跨執行個體的庫存正確性還是要靠資料庫或〈冪等與分散式鎖〉談的機制。
提示:每種 profile 都只是取樣,數字代表比例,不是精確計數。比較前後兩次 profile 時,負載條件要盡量相同,否則差異可能只是流量不同。
第 5 步:逃逸分析與記憶體配置
Go 的變數可能放在堆疊(stack)或堆積(heap)上。堆疊上的配置幾乎沒有成本,函式回傳時一起釋放;堆積上的配置需要記憶體配置器處理,之後還要由垃圾回收器追蹤與回收。編譯器透過逃逸分析決定每個變數放哪裡:如果編譯器無法證明一個值在函式結束後不再被使用,它就會「逃逸」到堆積上。
用 go build -gcflags='-m' 可以看到編譯器的判斷,輸出會出現像「&Order{...} escapes to heap」「moved to heap: buf」「leaking param: o」這類訊息。常見的逃逸原因有:
- 回傳區域變數的指標。值必須在函式結束後繼續存在,只能放堆積。
- 存進介面。把具體值轉成
any或其他介面(例如傳給fmt.Sprintf的參數),在很多情況下會導致配置。這正是第 1 步SummaryNaive較慢的原因之一。 - 閉包捕獲變數,並且這個閉包的生命週期超出目前函式(例如交給 goroutine)。
- 大小在編譯期未知的切片,例如
make([]byte, n)且n是變數,或大小超過堆疊配置的上限。 - 切片或 map 的元素是指標,被存放的值本身也常會跟著逃逸。
降低配置的常用技巧:
| 技巧 | 說明 |
|---|---|
| 預先配置容量 | make([]T, 0, n)、strings.Builder.Grow、make(map[K]V, n),避免擴容時反覆配置與複製 |
| 重用緩衝區 | 熱路徑上用 sync.Pool 重用暫存物件,例如編碼用的 bytes.Buffer;放回前記得重設 |
| 避免不必要的介面轉換 | 熱路徑用 strconv 取代 fmt,用具體型別取代 any |
| 傳值而非指標 | 小型結構傳值不一定比傳指標慢,還可能避免逃逸;以 benchmark 為準 |
| 減少中間字串 | []byte 與 string 之間的轉換常會配置,處理過程中盡量維持同一種型別 |
但要記得:逃逸分析的輸出是線索,不是目標。只有 profile 顯示配置確實是熱點時,才值得為了減少配置而犧牲可讀性。把每一個 escapes to heap 都消滅,通常只是浪費時間。
第 6 步:GOMAXPROCS、GOGC 與 GOMEMLIMIT
程式碼之外,Go 執行環境本身也有幾個影響效能的參數:
GOMAXPROCS 決定同時執行 Go 程式碼的作業系統執行緒數量上限,預設等於可用的 CPU 數。在容器裡,「可用的 CPU 數」是關鍵:較舊的 Go 版本只看機器的核心數,如果節點有 32 核,而容器的 CPU limit 只有 2 核,Go 會開 32 個執行緒搶 2 核的配額,結果是頻繁被節流、延遲不穩。Go 1.25 起,在 Linux 上的預設值會考慮 cgroup 的 CPU limit,並在 limit 改變時自動調整;使用較舊版本時,常見做法是用社群套件在啟動時依 cgroup 設定,或直接以環境變數指定。
GOGC 控制垃圾回收的頻率,預設為 100,意思是「當堆積相對於上次回收後的存活量成長 100% 時,觸發下一次回收」。調高(例如 200)會讓 GC 次數變少、CPU 用量下降,但記憶體尖峰變高;調低則相反。GOGC=off 會完全關閉以比例觸發的回收。
GOMEMLIMIT(Go 1.19 起)是記憶體的軟上限。當總記憶體接近這個值時,GC 會更積極地執行,盡量不超過它。這解決了單靠 GOGC 很難處理的問題:在容器裡,你在意的其實是「不要超過 memory limit 被 OOM 終止」,而不是成長比例。
圖:GOGC 以比例決定回收時機;設定 GOMEMLIMIT 後,接近上限時回收會提前發生,讓記憶體保持在容器限制之下。
兩者常見的搭配方式:
- 一般服務:保留
GOGC=100,把GOMEMLIMIT設為容器 memory limit 的八、九成左右(上一篇的 Deployment 示範了用resourceFieldRef注入 limit 的方式,實務上可以再乘上一個比例)。 - 記憶體充裕、想省 CPU 的服務:把
GOGC調高或設為off,完全交給GOMEMLIMIT控制,讓 GC 只在接近上限時才頻繁執行。
但要注意一個陷阱:如果存活的資料本身就接近 GOMEMLIMIT,GC 會不停地執行卻回收不了多少,CPU 被 GC 吃光,這種情況稱為 GC 抖動(thrashing)。Go 的執行環境對此有保護機制,會限制 GC 占用的 CPU 比例,此時記憶體可能超過軟上限,最後仍然會被 OOM 終止。也就是說,GOMEMLIMIT 不能取代「給足記憶體」;當 heap profile 顯示存活資料確實很大時,該做的是減少常駐資料或調高 limit。
要觀察 GC 的實際行為,可以設定 GODEBUG=gctrace=1,每次回收都會在標準錯誤輸出一行摘要,包括回收前後的堆積大小與耗時。新版 Go 的垃圾回收器實作也在持續改進,升級 Go 版本本身就可能帶來可量測的改善,這也是升級時值得重跑 benchmark 的原因之一。
第 7 步:PGO:讓編譯器依實際負載最佳化
Profile-Guided Optimization(PGO)自 Go 1.21 起正式可用:把一份代表正式環境負載的 CPU profile 交給編譯器,編譯器會針對熱點函式做更積極的內聯(inlining)與其他最佳化,例如把熱路徑上的介面方法呼叫改成直接呼叫。官方文件提到的典型改善幅度大約在幾個百分點,實際效果依程式而定。
使用方式非常簡單:
- 從正式環境的服務取得 CPU profile(第 4 步的
/debug/pprof/profile?seconds=30),最好能涵蓋具代表性的負載,必要時合併多個執行個體的 profile(go tool pprof -proto a.pprof b.pprof > merged.pprof)。 - 把檔案命名為
default.pgo,放在主套件的目錄,也就是cmd/order/default.pgo。 - 照常
go build。-pgo=auto是預設值,會自動使用主套件目錄下的default.pgo。
default.pgo 應該提交進版本控制,讓建置可重現;〈Docker 與 Kubernetes 部署(單一服務)〉的多階段 Dockerfile 不需要任何修改,COPY . . 會把它一起帶進建置階段。之後定期(例如每次大版本發布前)重新取樣更新即可;用稍舊的 profile 建置新版本程式碼也沒問題,PGO 對程式碼變動有一定的容忍度。
整個效能工作的循環可以畫成下面這樣:
圖:從指標發現問題、用 profile 定位熱點、以 benchmark 驗證修改,再回到正式環境確認效果,每一圈都以量測為依據。
常見陷阱
- 憑直覺最佳化。沒有 profile 就改程式,很可能改到不是瓶頸的地方,還讓程式更難讀。
- 只跑一次 benchmark。雜訊可能大於差異。用
-count多跑幾次,交給benchstat判斷是否顯著。 - benchmark 被編譯器最佳化掉。舊寫法若沒有使用結果,整個呼叫可能被刪除,跑出不合理的超快數字。用
b.Loop(Go 1.24+)可以避免。 - 準備工作被計入時間。在舊寫法裡忘了
b.ResetTimer,建立測試資料的時間被平均進結果。b.Loop會自動排除迴圈之前的準備。 - 測試資料不具代表性。只量 1 個品項,或只量 1 萬個品項,結論都可能與實際負載不符。用子 benchmark 掃過不同規模,並以正式環境的資料分布為準。
- pprof 對外公開。使用
DefaultServeMux又匯入net/http/pprof,等於把內部資訊與一個可以消耗 CPU 的端點交給所有人。掛在獨立的內部埠上。 - 在容器裡忽略 GOMAXPROCS 與 CPU limit。舊版 Go 會依節點核心數開執行緒,造成大量節流。確認版本行為或明確設定。
- 把 GOMEMLIMIT 當成萬靈丹。存活資料本身太大時,GC 只會空轉。先用 heap profile 確認記憶體到底被誰占用。
- 過度最佳化。
sync.Pool、手動緩衝區重用、避免介面,都會增加程式的複雜度。只在 profile 證明值得的熱路徑上使用。
重點整理
- 效能工作的原則是「量測 → 修改 → 再量測」,任何最佳化都要有數據支持。
- benchmark 用
for b.Loop()(Go 1.24+)與b.ReportAllocs(),以子 benchmark 掃過不同規模,並先用測試確認新舊行為一致。 - 用
-count多次執行並以benchstat比較,看變異範圍與 p 值,不要被雜訊誤導。 - pprof 提供 CPU、heap、goroutine、mutex、block 等 profile;分清 flat 與 cum、
inuse與alloc的差別,用火焰圖找寬的方塊。 net/http/pprof掛在只對內的獨立埠上,透過 port-forward 取樣,不要使用預設的DefaultServeMux對外。- 逃逸分析(
-gcflags=-m)解釋配置從哪裡來;減少熱路徑上的配置往往比優化計算更有效。 - 在容器裡留意
GOMAXPROCS與 CPU limit 的關係;以GOMEMLIMIT搭配GOGC控制記憶體,但它不能取代足夠的記憶體。 - PGO 只要把正式環境的 CPU profile 放成主套件目錄下的
default.pgo,就能讓編譯器依實際負載最佳化。
下一篇
到這裡,單一服務已經看得見、關得乾淨、打包得好、也量測過效能;但實際的系統是 api-gateway、order、payment、inventory 加上資料庫與訊息佇列一起運作的。下一部分從〈用 Docker Compose 部署整套微服務〉開始,把整套系統在一台機器上完整跑起來。