NautilusTrader Docs · ภาษาไทย
Deep Dive: ลงมือสร้างระบบจริง

Deep Dive: จากแนวคิดสู่การใช้งานจริง

สร้างระบบเทรดด้วย NautilusTrader และ Rust ตั้งแต่โปรเจกต์ว่าง จนถึง backtest, test และรันบน testnet

บทอื่นในเอกสารชุดนี้อธิบายทีละส่วน เช่น actor, order, cache หรือ backtest engine บทนี้มีเป้าหมายสองข้อ:

  1. เข้าใจสถาปัตยกรรม ว่าข้อมูลและคำสั่งเดินผ่าน component ไหนบ้าง ตามลำดับอะไร และการออกแบบนั้นบังคับให้โค้ดของเรา ต้องเขียนอย่างไร
  2. นำไปใช้และต่อเข้ากับระบบของเรา แยก logic เป็น component ที่คุยกันผ่าน message bus, ส่ง event ออกไปยังระบบภายนอก, รันกับ exchange จริง และเข้าใจว่า adapter อย่าง Hyperliquid และ Lighter ต่อเข้ากับ node อย่างไร

ทั้งหมดอธิบายผ่านโปรเจกต์ Rust จริงที่สร้างตั้งแต่ศูนย์ ตั้งแต่ตั้งโปรเจกต์ เตรียมข้อมูล เขียน strategy, backtest, test แยก component ไปจนถึงรันบน testnet

บทนี้ไม่ได้แปลจากต้นฉบับ

เนื้อหาบท Deep Dive เขียนขึ้นใหม่สำหรับเอกสารฉบับภาษาไทย ไม่มีในเอกสาร NautilusTrader ต้นฉบับ โค้ดทุกบรรทัดในบทนี้ build และรันได้จริงกับ NautilusTrader ที่ commit 04f766b4 (เวอร์ชัน workspace 0.67.0) ซึ่งเป็น commit เดียวกับที่ใช้แปลเอกสารชุดนี้

สิ่งที่จะสร้าง

strategy แบบ mean reversion ด้วย Bollinger Bands บนแท่งเทียน 1 นาที:

  • เมื่อราคาปิดหลุด band ล่าง ให้ buy โดยตั้ง take profit ที่เส้นกลาง (middle band)
  • เมื่อราคาปิดทะลุ band บน ให้ sell โดยตั้ง take profit ที่เส้นกลางเช่นกัน
  • วาง stop loss ห่างจากราคาปิดเป็นจำนวนเท่าของ ATR (Average True Range)
  • ส่ง entry, take profit และ stop loss พร้อมกันเป็น bracket order
  • คำนวณขนาด position ให้ถ้าโดน stop แล้วเสียเงินเท่ากับสัดส่วนคงที่ของ equity
  • มีเกราะป้องกัน: เคารพขนาด order ขั้นต่ำ/สูงสุดของ instrument, rate limit ของ risk engine และพักการเทรดหลัง order ถูกปฏิเสธ

strategy นี้เลือกมาเพราะใช้ API ของ Nautilus ครบหลายส่วนในโค้ดไม่ยาว ไม่ได้เลือกเพราะทำกำไร หน้า Backtest จะแสดงให้เห็นว่า strategy นี้ ขาดทุน ในตลาดที่ไม่มีพฤติกรรม mean reversion

เนื้อหาบทนี้มีไว้เพื่อการเรียนรู้การใช้งาน framework ไม่ใช่คำแนะนำการลงทุน ผล backtest ในบทนี้มาจากข้อมูลสังเคราะห์ ซึ่งพิสูจน์ได้แค่ว่าโค้ดทำงานถูกต้อง ไม่ได้บอกอะไรเกี่ยวกับตลาดจริง

การไหลของข้อมูลและคำสั่ง

flowchart TD
    Bars["Bar 1 นาที"] --> Ind["BollingerBands + ATR"]
    Ind --> Sig["evaluate()<br/>pure function"]
    Sig -->|Long / Short| Size["units_for_risk()<br/>pure function"]
    Size --> Bracket["bracket order<br/>entry + TP + SL"]
    Bracket --> Risk["RiskEngine"]
    Risk -->|ผ่าน| Venue["Venue<br/>(simulated หรือ Bybit)"]
    Risk -->|OrderDenied| Strat["MeanReversion<br/>(cooldown)"]
    Venue -->|OrderFilled / PositionClosed / OrderRejected| Strat

ส่วนที่เป็นการตัดสินใจ (evaluate และ units_for_risk) แยกออกมาเป็น pure function ที่ไม่รู้จัก Nautilus เลย จึง test ได้ทันทีโดยไม่ต้องสร้าง engine ส่วน strategy มีหน้าที่แค่เชื่อมข้อมูลจาก engine เข้ากับฟังก์ชันเหล่านี้ และส่ง order ออกไป

โครงสร้างโปรเจกต์

โค้ดฉบับเต็มอยู่ใน repository นี้ที่ examples/nautilus-meanrev

nautilus-meanrev/
├── Cargo.toml            dependency ที่ pin ไว้กับ commit ของ NautilusTrader
├── rust-toolchain.toml   Rust 1.99.1 ตามที่ NautilusTrader ต้องการ
├── src/
│   ├── lib.rs
│   ├── signal.rs         กฎการเข้าเทรด (pure)
│   ├── sizing.rs         การคำนวณขนาด position (pure)
│   ├── data.rs           ตัวสร้างข้อมูล bar สังเคราะห์แบบ deterministic
│   ├── execution.rs      ส่ง bracket order ตามความเสี่ยง ใช้ร่วมกันทุก strategy
│   ├── strategy.rs       MeanReversion: strategy ตัวเดียวทำทุกอย่าง
│   ├── components.rs     BandSignalActor + SignalExecutor: แบบแยก component
│   ├── exporter.rs       FillExporter: ส่ง fill ออกนอก node ผ่าน channel
│   ├── backtest.rs       ประกอบ BacktestEngine ตาม RunOptions
│   ├── main.rs           CLI: run, sweep, compare, export
│   └── bin/live.rs       รันบน Bybit testnet (feature `live`)
└── tests/
    ├── backtest.rs       integration test ผ่าน engine จริง
    └── integration.rs    ความเท่ากันของสองแบบ และการส่ง fill ออก

ลำดับการอ่าน

หน้าเนื้อหา
เข้าใจสถาปัตยกรรมติดตาม bar และ order ผ่านทุก component, ใครเป็นเจ้าของ state, กฎสำหรับโค้ดของเรา
ตั้งค่าโปรเจกต์toolchain, การ pin dependency, feature flag และการวางโมดูล
ข้อมูลbar type, precision, timestamp, price type ที่ risk engine ใช้ได้ และข้อมูลสังเคราะห์
เขียน strategyโครงสร้าง strategy, indicator, lifecycle และ hook
Order และความเสี่ยงbracket order, position sizing, ข้อจำกัดของ instrument และ risk engine
Backtestประกอบ engine, fill/fee model, อ่านผล, parameter sweep และ control market
Testingunit test, integration test และการตรวจว่าผลซ้ำได้
Apply และ integrateแยก component ผ่าน message bus, ส่ง event ออก, รับข้อมูลเข้า, หลาย strategy, persistence
Adapter ทำงานอย่างไรผ่าตัด adapter ของ Hyperliquid และ Lighter: ชั้นต่าง ๆ, trait, การส่ง order, reconciliation
ไปสู่ liveต่อ Bybit testnet, credential และ reconciliation
Production checklistสิ่งที่ต้องเตรียมก่อนใช้เงินจริง

สิ่งที่ต้องมี

  • Rust toolchain ผ่าน rustup (โปรเจกต์ล็อกไว้ที่ 1.99.1 ผ่าน rust-toolchain.toml)
  • พื้นที่ดิสก์สำหรับ build ราว 5–10 GB และเวลา build ครั้งแรกหลายนาที เพราะต้อง compile crate ของ Nautilus ทั้งหมด
  • พื้นฐาน Rust ระดับเขียน trait, enum และ Result ได้
  • ควรอ่าน Actors, Strategies และ Orders มาก่อน หรือเปิดคู่กันไประหว่างอ่าน

บทเรียนจากการลงมือจริง

ระหว่างเขียนบทนี้ โค้ดเวอร์ชันแรกเจอปัญหาจริงหลายข้อ ทุกข้อถูกเก็บไว้ในหน้าที่เกี่ยวข้องพร้อมวิธีแก้:

  • order ทุกตัวถูกปฏิเสธด้วย MARKET_PRICE_UNAVAILABLE เพราะใช้ bar แบบ MID (ข้อมูล)
  • strategy ส่ง order ที่ถูก deny ซ้ำทุกแท่งหลายพันครั้ง เพราะขนาดเกิน max_quantity ของ instrument (Order และความเสี่ยง)
  • test ของ position sizing พังเพราะ floating point (Testing)
  • ตั้ง log level เป็น Off แล้ว log ยังออกมาเต็มจอ เพราะ logger เป็นของทั้ง process (Backtest)
  • ผล backtest ดีเกินจริง และวิธีพิสูจน์ว่ากำไรมาจากข้อมูล ไม่ใช่จากบั๊ก (Backtest)
  • thread ที่เขียนไฟล์ fill ค้างไม่จบ เพราะ engine ไม่ dispose component ให้เอง (Integration)
  • จำนวน fill ไม่เท่ากับจำนวน order เพราะ partial fill เกิดขึ้นแม้ใน backtest (Integration)

แปลจาก เอกสาร NautilusTrader © Nautech Systems Pty Ltd และผู้ร่วมพัฒนา เผยแพร่ภายใต้ LGPL-3.0 ฉบับแปลนี้ตัดเนื้อหาเฉพาะ Python ออกและเน้น Rust