第一階段:全局認識

模組 02:整體架構鳥瞰圖在開始細節之前,先看清整個系統的全貌

一、系統的「一句話」總結

NautilusTrader 本質上是一個事件驅動的交易系統框架。它的核心可以用一張圖來理解:

flowchart LR
subgraph external_world["外部世界"]
exchange["交易所"]
data_provider["數據源"]
end

subgraph nautilus["NautilusTrader"]
direction TB
adapter_in["數據適配器"]
adapter_out["執行適配器"]
data_engine["數據引擎"]
exec_engine["執行引擎"]
risk_engine["風控引擎"]
cache["緩存"]
msgbus["消息總線"]
strategy["你的策略"]
portfolio["投資組合"]
end

external_world --> data_provider
external_world --> exchange
data_provider --> adapter_in
exchange --> adapter_in
adapter_in --> data_engine
data_engine --> msgbus
msgbus --> strategy
strategy --> msgbus
msgbus --> risk_engine
risk_engine --> exec_engine
exec_engine --> adapter_out
adapter_out --> exchange
exchange --> adapter_out
adapter_out --> exec_engine
exec_engine --> portfolio
data_engine --> cache
exec_engine --> cache
strategy -.-> cache
圖 1:NautilusTrader 整體數據流 — 從市場數據進入到訂單執行的完整路徑
💡 交易員視角

把這張圖想像成一家交易公司:數據引擎是行情部門收集市場報價,策略是你(交易決策者),風控引擎是合規部門審核你的指令,執行引擎是交易台執行你的訂單,緩存是所有人共享的白板。消息總線是辦公室的內部通訊系統,把所有人連在一起。

二、六大核心組件

系統的核心由 6 個組件組成,它們各司其職,透過消息總線協作:

flowchart LR
            subgraph kernel["🧠 NautilusKernel — 系統內核大腦"]
            direction TB
            msgbus["📡 MessageBus<br/>消息總線"]
            cache["💾 Cache<br/>緩存"]
            msgbus --- cache
            end

            subgraph engines["⚙️ 核心引擎組"]
            direction TB
            data["📊 DataEngine<br/>數據引擎"]
            exec["⚙️ ExecutionEngine<br/>執行引擎"]
            risk["🛡️ RiskEngine<br/>風控引擎"]
            data --- exec --- risk
            end

            subgraph management["💰 資金與策略"]
            direction TB
            port["💰 Portfolio<br/>投資組合"]
            strat["🧩 Strategy<br/>你的策略"]
            port --- strat
            end

            kernel --> engines
            engines --> management

            style kernel fill:#0f1419,stroke:#4fc3f7,stroke-width:2px
            style engines fill:#0f1419,stroke:#ffa726,stroke-width:1px
            style management fill:#0f1419,stroke:#ab47bc,stroke-width:1px
圖 2:六大核心組件及其關係
🧠

NautilusKernel — 系統內核

整個系統的「大腦」。負責初始化所有組件、管理生命週期、配置消息基礎設施。它是所有東西啟動的起點。

📡

MessageBus — 消息總線

組件間的「神經網絡」。所有數據、事件和命令都透過它傳遞。支援發布/訂閱、請求/回應和點對點消息。

💾

Cache — 緩存

高速記憶體「白板」。儲存金融工具、帳戶、訂單、持倉等所有狀態,讓各組件快速查詢共享數據。

📊

DataEngine — 數據引擎

「行情部門」。接收、處理和分發市場數據(報價、成交、K 線、訂單簿),並根據訂閱把數據推送給需要的組件。

⚙️

ExecutionEngine — 執行引擎

「交易台」。管理訂單的完整生命週期,從下單到成交/撤銷,追蹤所有訂單和持倉狀態。

🛡️

RiskEngine — 風控引擎

「合規管理」。在訂單到達執行引擎之前進行風險檢查,確保不會超出風險限制。

三、三種運行環境

同一個系統可以在三種「環境」中工作,而你的策略代碼不需要改動:

flowchart TB
            subgraph common["🔄 通用核心 (NautilusKernel)"]
            kernel["MessageBus + Cache + DataEngine<br/>+ ExecutionEngine + RiskEngine + Portfolio"]
            end

            subgraph bt["📊 回測環境 (Backtest)"]
            bt_data["歷史數據文件"]
            bt_venue["模擬交易所<br/>SimulatedExchange"]
            end

            subgraph sb["🏖️ 沙箱環境 (Sandbox)"]
            sb_data["即時市場數據"]
            sb_venue["模擬交易所<br/>SimulatedExchange"]
            end

            subgraph lv["🔴 實盤環境 (Live)"]
            lv_data["即時市場數據"]
            lv_venue["真實交易所<br/>Live Exchange"]
            end

            bt --> common
            sb --> common
            lv --> common
圖 3:三種環境共享同一個核心
項目📊 回測🏖️ 沙箱🔴 實盤
數據來源歷史數據文件即時市場數據即時市場數據
交易執行內建模擬引擎內建模擬引擎連接真實交易所
風險零風險零風險真實資金風險
速度可以加速回放即時即時
用途驗證策略邏輯驗證即時表現正式交易
策略代碼完全相同 — 不需要修改

四、代碼架構 — 怎麼組織的?

NautilusTrader 的代碼分兩大部分:Rust 核心和 Python/Cython 封裝。

4.1 三層分離 — 全局視角

flowchart LR
            subgraph python_pkg["📦 Python / Cython 層<br/>(nautilus_trader/)"]
            direction TB
            p_logic["交易策略與指標<br/>(trading/ / indicators/)"]
            p_model["領域模型封裝<br/>(model/)"]
            p_engine["引擎介面與配置<br/>(core/ / data/ / exec/)"]
            p_logic --- p_model --- p_engine
            end

            subgraph bridge["🔗 橋接層<br/>(Cython + PyO3)"]
            direction TB
            ffi["C FFI 介面"]
            binding["Python 綁定"]
            ffi --> binding
            binding --> ffi
            end

              subgraph rust_pkg["🦀 Rust 核心層<br/>(crates/)"]
              direction TB
              r_engines["核心引擎組件<br/>(data / execution / risk)"]
              r_base["基礎設施與內核<br/>(core / model / common)"]
              r_infra["底層服務<br/>(network / persistence)"]
              r_engines --- r_base --- r_infra
              end

              python_pkg --> bridge
              bridge --> python_pkg
              bridge --> rust_pkg
              rust_pkg --> bridge

                  style bridge fill:#1a1f2e,stroke:#ab47bc,stroke-width:2px
                  style python_pkg fill:#0f1419,stroke:#4fc3f7,stroke-width:1px
                  style rust_pkg fill:#0f1419,stroke:#ef5350,stroke-width:1px
圖 4:NautilusTrader 的三層分離架構 — 從 Python 策略到底層 Rust 核心

4.2 Rust Crates 依賴圖

⚠️ 進階內容 (選讀)

以下內容涉及底層 Rust 引擎的具體實現結構。如果你是初學者或只打算用 Python 開發策略,這部分可以完全跳過,不影響後續學習。

Rust 側有 23 個 crate,按功能分為五類。下圖展示它們之間的依賴關係:

flowchart LR
            subgraph layer_found["🧱 基礎層"]
            direction TB
            core["core"]
            model["model"]
            common["common"]
            model --> core
            common --> model
            end

            subgraph layer_infra["🏗️ 基建與引擎"]
            direction TB
            serialization["serialization"]
            persistence["persistence"]
            data["data"]
            execution["execution"]
            risk["risk"]
            portfolio["portfolio"]
            serialization --> model
            persistence --> serialization
            data --> common
            execution --> common
            risk --> portfolio
            portfolio --> common
            end

            subgraph layer_runtime["🚀 運行與擴展"]
            direction TB
            system["system"]
            trading["trading"]
            backtest["backtest"]
            live["live"]
            adapters["adapters"]
            pyo3["pyo3"]
            backtest --> system
            live --> system
            live --> trading
            adapters --> live
            pyo3 --> adapters
            end

            layer_found --> layer_infra
            layer_infra --> layer_runtime

            style layer_found fill:#0f1419,stroke:#4fc3f7,stroke-width:1px
            style layer_infra fill:#0f1419,stroke:#ffa726,stroke-width:1px
            style layer_runtime fill:#0f1419,stroke:#ef5350,stroke-width:1px
圖 5:Rust crate 依賴關係 — 箭頭方向表示「依賴於」
類別包含的 Crates用途
基礎層core, model, common, system, trading基本類型、領域模型、內核、策略基類
引擎層data, execution, portfolio, risk核心交易引擎組件
基礎設施層serialization, network, cryptography, persistence編碼、網絡、加密、數據存儲
運行層live, backtest具體環境的節點實現
外部整合adapters/*各交易所和數據源適配器
Python 綁定pyo3將 Rust 暴露給 Python

五、數據流完整路徑

讓我們追蹤一個市場報價(比如 BTC/USDT 的最新價格)是如何在系統中流動的:

sequenceDiagram
            participant Exchange as 🏦 交易所
            participant DC as 📡 DataClient
            participant DE as 📊 DataEngine
            participant Cache as 💾 Cache
            participant MB as 📡 MessageBus
            participant Strategy as 🎯 你的策略

            Exchange->>DC: WebSocket 推送原始報價
            DC->>DC: 轉換為標準格式 (QuoteTick)
            DC->>DE: 傳入標準化數據
            DE->>Cache: 存入緩存
            DE->>MB: 發布數據事件
            MB->>Strategy: 推送給訂閱了該品種的策略
            Strategy->>Strategy: 執行策略邏輯
            Note over Strategy: 決定是否下單
圖 6:市場數據從交易所到策略的完整流程

六、執行流完整路徑

當策略決定下單時,訂單如何從你的策略到達交易所?

sequenceDiagram
            participant Strategy as 🎯 你的策略
            participant MB as 📡 MessageBus
            participant Risk as 🛡️ RiskEngine
            participant EE as ⚙️ ExecutionEngine
            participant EC as 🔌 ExecutionClient
            participant Exchange as 🏦 交易所
            participant Portfolio as 💰 Portfolio
            participant Cache as 💾 Cache

            Strategy->>MB: 發送下單命令 (SubmitOrder)
            MB->>Risk: 風控檢查
            Risk->>Risk: 驗證風險限制
            alt 風控通過
            Risk->>EE: 轉發命令
            EE->>EC: 路由到對應交易所
            EC->>Exchange: 提交訂單 (REST/WS)
            Exchange-->>EC: 訂單確認
            EC->>EE: 回報 OrderAccepted 事件
            EE->>Cache: 更新訂單狀態
            EE->>MB: 發布事件
            Exchange-->>EC: 成交回報
            EC->>EE: 回報 OrderFilled 事件
            EE->>Portfolio: 更新持倉和盈虧
            EE->>Cache: 更新狀態
            EE->>MB: 發布事件
            MB->>Strategy: 通知成交
            else 風控拒絕
            Risk->>MB: 發布 OrderDenied 事件
            MB->>Strategy: 通知被拒絕
            end
圖 7:訂單從策略到交易所的完整執行流程
✅ 關鍵洞察

注意到了嗎?策略從不直接和交易所通訊。所有操作都經過消息總線和引擎層。這是「六角形架構」的設計——策略只關心交易邏輯,不需要知道它連接的是真實交易所還是模擬器。

七、Python 模組地圖

以下是你作為策略開發者最常接觸的 Python 模組:

模組用途你需要了解的程度
trading/Strategy 和 Actor 基類 — 你寫策略的地方⭐⭐⭐ 必須精通
model/訂單、持倉、金融工具等領域對象⭐⭐⭐ 必須熟悉
indicators/技術指標(EMA, SMA, RSI 等)⭐⭐⭐ 常用
config/系統和策略配置⭐⭐ 需要知道
backtest/回測引擎和配置⭐⭐ 需要知道
live/實盤節點配置⭐⭐ 部署時需要
adapters/交易所連接器⭐ 通常不需要修改
data/數據引擎內部⭐ 了解概念即可
execution/執行引擎內部⭐ 了解概念即可
cache/緩存系統⭐ 知道怎麼查詢
core/底層工具和常量⭐ 很少直接使用
risk/風控引擎⭐ 了解配置即可

八、一個完整的交易循環

把所有部分串起來,一個完整的交易循環長這樣:

flowchart TB
            A["1️⃣ 系統啟動<br/>NautilusKernel 初始化所有組件"] --> B["2️⃣ 連接數據源<br/>DataClient 連接交易所 WebSocket"]
            B --> C["3️⃣ 訂閱數據<br/>策略告訴 DataEngine 它需要哪些數據"]
            C --> D["4️⃣ 接收行情<br/>數據到達策略的 on_quote_tick / on_bar 回調"]
            D --> E["5️⃣ 策略決策<br/>策略分析數據、計算指標、生成信號"]
            E --> F{"6️⃣ 是否下單?"}
            F -->|"是"| G["7️⃣ 風控檢查<br/>RiskEngine 驗證訂單"]
            F -->|"否"| D
            G --> H["8️⃣ 執行訂單<br/>ExecutionEngine 透過適配器下單"]
            H --> I["9️⃣ 更新狀態<br/>Cache + Portfolio 更新"]
            I --> D
圖 8:一個完整的交易循環

九、互動練習

🧠 練習 1:組件配對

將以下功能和正確的組件配對:

功能你的答案
A. 存儲訂單狀態___________
B. 接收交易所的即時報價___________
C. 檢查單筆訂單是否超過風險上限___________
D. 把成交事件推送給策略___________
E. 管理訂單的下達和撤銷___________
A → Cache(緩存) B → DataClient / DataEngine(數據適配器 / 數據引擎) C → RiskEngine(風控引擎) D → MessageBus(消息總線) E → ExecutionEngine(執行引擎)
🧠 練習 2:數據追蹤

假設你的策略訂閱了 BTC/USDT 的一分鐘 K 線(Bar)。請描述一根新 K 線從形成到你的策略收到它的完整路徑。

1. 交易所的逐筆成交數據透過 WebSocket 推送到 DataClient 2. DataClient 將原始數據轉換為 NautilusTrader 的標準 TradeTick 格式 3. DataEngine 收集 TradeTick 並內部聚合為 1 分鐘 Bar 4. 當 1 分鐘結束時,Bar 完成聚合 5. DataEngine 將 Bar 寫入 Cache 6. DataEngine 透過 MessageBus 發布 Bar 事件 7. MessageBus 查找所有訂閱了該 Bar 的組件 8. 你的策略的 on_bar() 回調被調用,收到這根 K 線

十、本模組重點回顧

📋 你應該記住的關鍵點
  1. 六大核心組件:Kernel、MessageBus、Cache、DataEngine、ExecutionEngine、RiskEngine
  2. 消息總線是系統的神經中樞,所有組件透過它通訊
  3. 三種環境(回測/沙箱/實盤)共享同一個核心,策略代碼不變
  4. 數據流:交易所 → 適配器 → 數據引擎 → 消息總線 → 策略
  5. 執行流:策略 → 消息總線 → 風控 → 執行引擎 → 適配器 → 交易所
  6. 策略從不直接連接交易所,這是架構解耦的核心設計