Skip to content

title: Chapter 14: Live Deployment

Chapter 14: Live Deployment

This chapter covers deploying, monitoring, and managing live trading.

14.1 Starting Live Trading

14.1.1 Starting with the Lean CLI

# 启动实盘交易(模拟盘同样使用该命令,指定 Paper Trading 券商)
lean live deploy "MyStrategy" --brokerage "Paper Trading"

# 数据提供商、输出目录等其他选项的完整列表见:
lean live deploy --help

14.1.2 Live Configuration File

{
  "live-mode": true,
  "live-mode-brokerage": "InteractiveBrokersBrokerage",
  "algorithm-type-name": "MyStrategy",
  "algorithm-language": "Python",
  "algorithm-location": "./MyStrategy.py",

  "environments": {
    "live-paper": {
      "live-mode": true,

      // Paper 券商(与 Launcher/config.json 的 live-paper 环境一致)
      "live-mode-brokerage": "PaperBrokerage",

      "setup-handler": "QuantConnect.Lean.Engine.Setup.BrokerageSetupHandler",
      "data-feed-handler": "QuantConnect.Lean.Engine.DataFeeds.LiveTradingDataFeed",
      "data-queue-handler": [ "QuantConnect.Lean.Engine.DataFeeds.Queues.LiveDataQueue" ],
      "transaction-handler": "QuantConnect.Lean.Engine.TransactionHandlers.BacktestingTransactionHandler"
    }
  }
}

14.2 Live Monitoring

14.2.1 Checking Real-Time Status

# 查看云端实盘项目状态
lean cloud status

# 查看本地实盘项目日志(项目名为位置参数)
lean logs "MyStrategy"

14.2.2 Metrics to Monitor

Metrics that require continuous monitoring:

Metric Description Normal Range
Connection status Connection to the brokerage Connected
Order status Order execution state Filled/Rejected
Position value Current holdings As expected
Unrealized P&L Unrealized profit and loss Within stop-loss limits
Account balance Available cash > minimum requirement
System latency Order execution latency < 1 second

14.2.3 Live Monitoring Strategy

class LiveMonitoringStrategy(QCAlgorithm):
    """
    带完整监控的实盘策略
    """

    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2099, 12, 31)  # 实盘使用很远的结束日期
        self.SetCash(100000)

        self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol

        # 指标
        self.sma_fast = self.SMA(self.spy, 20)
        self.sma_slow = self.SMA(self.spy, 50)

        self.SetWarmUp(TimeSpan.FromDays(60))

        # 监控变量
        self.start_value = None
        self.high_value = None
        self.low_value = None
        self.orders_today = 0
        self.last_date = None

        # 每日初始化
        self.Schedule.On(
            self.DateRules.EveryDay(self.spy),
            self.TimeRules.BeforeMarketOpen(self.spy, 30),
            self.DailyInit
        )

        # 每日收盘后报告
        self.Schedule.On(
            self.DateRules.EveryDay(self.spy),
            self.TimeRules.AfterMarketClose(self.spy, 5),
            self.DailyReport
        )

    def DailyInit(self):
        """每日初始化"""
        self.orders_today = 0
        self.last_date = self.Time.date()

        current_value = self.Portfolio.TotalPortfolioValue
        if self.start_value is None:
            self.start_value = current_value
        self.high_value = current_value
        self.low_value = current_value

    def OnData(self, data):
        # 更新高低点
        current_value = self.Portfolio.TotalPortfolioValue
        if current_value > self.high_value:
            self.high_value = current_value
        if current_value < self.low_value:
            self.low_value = current_value

        # 交易逻辑
        if self.sma_fast.IsReady:
            if self.sma_fast.Current.Value > self.sma_slow.Current.Value:
                if not self.Portfolio[self.spy].IsLong:
                    self.SetHoldings(self.spy, 1)
            else:
                if self.Portfolio[self.spy].IsLong:
                    self.Liquidate(self.spy)

    def DailyReport(self):
        """生成每日报告"""
        current_value = self.Portfolio.TotalPortfolioValue
        daily_return = (current_value / self.start_value - 1) if self.start_value else 0

        # 计算日内高低点
        intraday_range = (self.high_value / self.low_value - 1) if self.low_value > 0 else 0

        self.Debug("\n" + "="*60)
        self.Debug(f"DAILY REPORT - {self.Time.date()}")
        self.Debug("="*60)
        self.Debug(f"Starting Value: ${self.start_value:,.2f}")
        self.Debug(f"Ending Value: ${current_value:,.2f}")
        self.Debug(f"Daily Return: {daily_return:.2%}")
        self.Debug(f"High: ${self.high_value:,.2f}")
        self.Debug(f"Low: ${self.low_value:,.2f}")
        self.Debug(f"Range: {intraday_range:.2%}")
        self.Debug(f"Orders Today: {self.orders_today}")
        self.Debug("="*60)

    def OnOrderEvent(self, orderEvent):
        """记录订单"""
        if orderEvent.Status == OrderStatus.Filled:
            self.orders_today += 1

            # 记录交易详情(OrderEvent 直接提供 Symbol/Direction 等成员)
            self.Debug(f"[ORDER] {self.Time} | {orderEvent.Symbol} | "
                      f"{orderEvent.Direction} | "
                      f"Qty: {orderEvent.FillQuantity} | "
                      f"Price: ${orderEvent.FillPrice:.2f}")

        elif orderEvent.Status == OrderStatus.Canceled:
            self.Log(f"[CANCELED] {orderEvent.Symbol} | {orderEvent.OrderId}")

        elif orderEvent.Status == OrderStatus.Invalid:
            self.Error(f"[INVALID] {orderEvent.Symbol} | {orderEvent.Message}")

    def OnEndOfAlgorithm(self):
        """结束时报告"""
        self.Debug("\n" + "="*60)
        self.Debug("LIVE TRADING SUMMARY")
        self.Debug("="*60)

14.3 Exception Handling

14.3.1 Connection Exceptions

class RobustLiveStrategy(QCAlgorithm):
    """
    带异常处理的实盘策略
    """

    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2099, 12, 31)
        self.SetCash(100000)

        self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol

        # 连接检查
        self.last_connection_check = self.Time
        self.connection_issues = 0

        # 每5分钟检查连接
        self.Schedule.On(
            self.DateRules.EveryDay(),
            self.TimeRules.Every(TimeSpan.FromMinutes(5)),
            self.CheckConnection
        )

    def CheckConnection(self):
        """检查连接状态"""
        try:
            # 检查数据是否更新
            if self.Securities[self.spy].HasData:
                # 检查数据时间
                data_time = self.Securities[self.spy].LocalTime
                time_diff = (self.Time - data_time).total_seconds()

                if time_diff > 300:  # 5分钟无数据
                    self.Log(f"No data for {time_diff} seconds")
                    self.connection_issues += 1
                else:
                    self.connection_issues = 0

            self.last_connection_check = self.Time

        except Exception as e:
            self.Error(f"Connection check failed: {str(e)}")
            self.connection_issues += 1

        # 连接问题过多时停止交易
        if self.connection_issues > 3:
            self.Error("Too many connection issues. Stopping trading.")
            self.Liquidate()

    def OnData(self, data):
        # 检查数据可用性
        if not data.ContainsKey(self.spy) or data[self.spy] is None:
            self.Log(f"No data for {self.spy} at {self.Time}")
            return

        # 检查价格有效性
        price = data[self.spy].Price
        if price <= 0:
            self.Log(f"Invalid price: {price}")
            return

        # 正常交易逻辑
        # ...

14.3.2 Order Exception Handling

def OnOrderEvent(self, orderEvent):
    """处理订单异常"""
    # 订单被拒绝
    if orderEvent.Status == OrderStatus.Invalid:
        self.Error(f"Order invalid: {orderEvent.Symbol} | {orderEvent.Message}")

        # 常见原因:
        # - 资金不足
        # - 市场关闭
        # - 持仓限制
        # - API 限制

    # 订单取消
    elif orderEvent.Status == OrderStatus.Canceled:
        self.Log(f"Order canceled: {orderEvent.Symbol} | ID: {orderEvent.OrderId}")

    # 部分成交
    elif orderEvent.Status == OrderStatus.PartiallyFilled:
        remaining = orderEvent.Quantity - orderEvent.FillQuantity
        self.Log(f"Partial fill: {orderEvent.Symbol} | Filled: {orderEvent.FillQuantity}, Remaining: {remaining}")

        # 可以选择取消剩余部分(OrderEvent 没有 Cancel 方法,需通过 OrderTicket 取消)
        # self.Transactions.GetOrderTicket(orderEvent.OrderId).Cancel()

14.4 Live Trading Maintenance

14.4.1 Routine Maintenance Tasks

Task Frequency Description
Check logs Daily Look for errors and warnings
Review trades Daily Confirm trades match expectations
Performance evaluation Weekly Compare actual vs expected performance
Parameter review Monthly Check whether adjustments are needed
System updates As needed Update the system and dependencies

14.4.2 Log Management

class LoggingStrategy(QCAlgorithm):
    """
    带日志管理的策略
    """

    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2099, 12, 31)
        self.SetCash(100000)

        self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol
        self.sma_fast = self.SMA(self.spy, 20)
        self.sma_slow = self.SMA(self.spy, 50)

        self.SetWarmUp(TimeSpan.FromDays(60))

        # 日志级别(QCAlgorithm 没有 Warn 方法,WARN 级别也使用 Log)
        self.log_types = {
            'DEBUG': self.Debug,
            'INFO': self.Log,
            'WARN': self.Log,
            'ERROR': self.Error
        }

    def LogTrade(self, message, level="INFO"):
        """
        记录交易日志

        Args:
            message: 日志消息
            level: 日志级别
        """
        log_func = self.log_types.get(level, self.Log)

        # 添加时间戳和上下文
        full_message = f"[{self.Time}] {message}"
        log_func(full_message)

    def OnData(self, data):
        if not self.sma_fast.IsReady:
            return

        # 使用结构化日志
        if self.sma_fast.Current.Value > self.sma_slow.Current.Value:
            if not self.Portfolio[self.spy].IsLong:
                self.LogTrade(f"BUY Signal | Fast: {self.sma_fast.Current.Value:.2f} > Slow: {self.sma_slow.Current.Value:.2f}")
                self.SetHoldings(self.spy, 1)

    def OnOrderEvent(self, orderEvent):
        """记录订单事件"""
        if orderEvent.Status in [OrderStatus.Filled, OrderStatus.Canceled, OrderStatus.Invalid]:
            self.LogTrade(
                f"Order {orderEvent.Status} | "
                f"{orderEvent.Symbol} | "
                f"Qty: {orderEvent.FillQuantity} | "
                f"Price: ${orderEvent.FillPrice:.2f}",
                level="INFO" if orderEvent.Status == OrderStatus.Filled else "WARN"
            )

14.5 Stopping Live Trading

14.5.1 Normal Shutdown

# 停止本地实盘项目
lean live stop "MyStrategy"

# 或按 Ctrl+C

14.5.2 Emergency Stop

class EmergencyStopStrategy(QCAlgorithm):
    """
    带紧急停止功能的策略
    """

    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2099, 12, 31)
        self.SetCash(100000)

        # Portfolio 没有 StartingCash 属性,在此保存初始资金
        self.starting_cash = self.Portfolio.TotalPortfolioValue

        self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol

        # 紧急停止条件
        self.emergency_stop = False
        self.max_loss_pct = 0.15  # 亏损15%紧急停止

        # 每30分钟检查
        self.Schedule.On(
            self.DateRules.EveryDay(),
            self.TimeRules.Every(TimeSpan.FromMinutes(30)),
            self.CheckEmergencyStop
        )

    def CheckEmergencyStop(self):
        """检查是否需要紧急停止"""
        if self.emergency_stop:
            self.Liquidate()
            self.Quit("Emergency stop activated")

        # 检查亏损
        total_return = (self.Portfolio.TotalPortfolioValue /
                       self.starting_cash - 1)

        if total_return < -self.max_loss_pct:
            self.Error(f"Emergency stop triggered! Loss: {total_return:.2%}")
            self.emergency_stop = True
            self.Liquidate()

    def OnData(self, data):
        if self.emergency_stop:
            return

        # 正常交易逻辑
        # ...

14.6 Complete Example: A Production-Grade Live Strategy

from AlgorithmImports import *

class ProductionLiveStrategy(QCAlgorithm):
    """
    生产级实盘策略

    特点:
    - 完整的风险管理
    - 异常处理
    - 日志记录
    - 监控告警
    """

    def Initialize(self):
        """初始化"""
        # 时间设置(实盘使用很远未来日期)
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2099, 12, 31)
        self.SetCash(100000)

        # 添加证券
        self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol
        self.Securities[self.spy].SetDataNormalizationMode(
            DataNormalizationMode.Adjusted
        )

        # 指标
        self.sma_fast = self.SMA(self.spy, 20)
        self.sma_slow = self.SMA(self.spy, 50)
        self.atr = self.ATR(self.spy, 14)

        self.SetWarmUp(TimeSpan.FromDays(60))

        # ========== 风险参数 ==========
        self.max_position = 0.2
        self.stop_loss = 0.03
        self.take_profit = 0.06
        self.daily_loss_limit = 0.02
        self.max_drawdown = 0.10

        # 状态变量
        self.entry_price = None
        self.entry_time = None
        self.daily_start_value = None
        self.peak_value = None
        self.connection_issues = 0

        # ========== 调度 ==========
        self.Schedule.On(
            self.DateRules.EveryDay(self.spy),
            self.TimeRules.BeforeMarketOpen(self.spy, 30),
            self.DailyInit
        )

        self.Schedule.On(
            self.DateRules.EveryDay(self.spy),
            self.TimeRules.AfterMarketClose(self.spy, 5),
            self.DailyReport
        )

        # ========== 启动日志 ==========
        self.Log("Production Live Strategy Started")
        self.Log(f"Risk limits: MaxPos={self.max_position}, "
               f"StopLoss={self.stop_loss}, DailyLoss={self.daily_loss_limit}")

    def DailyInit(self):
        """每日初始化"""
        self.daily_start_value = self.Portfolio.TotalPortfolioValue

        if self.peak_value is None:
            self.peak_value = self.daily_start_value

        self.Log(f"=== Trading Day {self.Time.date()} ===")
        self.Log(f"Starting Value: ${self.daily_start_value:,.2f}")

    def DailyReport(self):
        """每日报告"""
        current_value = self.Portfolio.TotalPortfolioValue
        daily_return = (current_value / self.daily_start_value - 1)

        self.Log(f"\n[DAILY REPORT]")
        self.Log(f"Date: {self.Time.date()}")
        self.Log(f"Starting: ${self.daily_start_value:,.2f}")
        self.Log(f"Ending: ${current_value:,.2f}")
        self.Log(f"Return: {daily_return:.2%}")
        self.Log(f"Peak: ${self.peak_value:,.2f}")

    def OnData(self, data):
        """主数据处理"""
        # 风险检查
        if not self.CheckRiskLimits():
            return

        # 数据检查
        if not self.ValidateData(data):
            return

        # 检查止损止盈
        if self.Portfolio[self.spy].Invested:
            if self.CheckExitConditions(data[self.spy].Price):
                return

        # 交易逻辑
        if self.sma_fast.IsReady and self.atr.IsReady:
            fast = self.sma_fast.Current.Value
            slow = self.sma_slow.Current.Value

            if fast > slow and not self.Portfolio[self.spy].IsLong:
                self.OpenPosition(data[self.spy].Price)
            elif fast < slow and self.Portfolio[self.spy].IsLong:
                self.ClosePosition("Signal Change")

    def ValidateData(self, data):
        """验证数据有效性"""
        if not data.ContainsKey(self.spy) or data[self.spy] is None:
            return False

        price = data[self.spy].Price
        if price <= 0 or price > 1000000:  # 价格合理性检查
            self.Log(f"Invalid price: ${price}")
            return False

        return True

    def CheckRiskLimits(self):
        """检查风险限制"""
        current = self.Portfolio.TotalPortfolioValue

        # 更新峰值
        if current > self.peak_value:
            self.peak_value = current

        # 每日亏损限制
        if self.daily_start_value:
            daily_pnl = (current / self.daily_start_value - 1)
            if daily_pnl < -self.daily_loss_limit:
                self.Error(f"Daily loss limit: {daily_pnl:.2%}")
                self.Liquidate()
                return False

        # 最大回撤限制
        drawdown = (current / self.peak_value - 1)
        if drawdown < -self.max_drawdown:
            self.Error(f"Max drawdown: {drawdown:.2%}")
            self.Liquidate()
            return False

        return True

    def OpenPosition(self, price):
        """开仓"""
        atr = self.atr.Current.Value
        risk_amount = self.Portfolio.Cash * 0.02
        shares = int(risk_amount / (atr * 2))

        max_shares = int((self.Portfolio.TotalPortfolioValue * self.max_position) / price)
        shares = min(shares, max_shares)

        if shares > 0:
            self.MarketOrder(self.spy, shares)
            self.entry_price = price
            self.entry_time = self.Time
            self.Log(f"[BUY] {shares} shares at ${price:.2f}")

    def ClosePosition(self, reason=""):
        """平仓"""
        if self.Portfolio[self.spy].Invested:
            price = self.Securities[self.spy].Price
            self.Liquidate(self.spy)
            self.Log(f"[SELL] {reason} at ${price:.2f}")
            self.entry_price = None

    def CheckExitConditions(self, price):
        """检查退出条件"""
        if self.entry_price:
            pnl = (price / self.entry_price - 1)

            # 止损
            if pnl <= -self.stop_loss:
                self.ClosePosition(f"Stop Loss ({pnl:.2%})")
                return True

            # 止盈
            if pnl >= self.take_profit:
                self.ClosePosition(f"Take Profit ({pnl:.2%})")
                return True

        return False

    def OnOrderEvent(self, orderEvent):
        """订单事件"""
        if orderEvent.Status == OrderStatus.Filled:
            self.Log(f"[ORDER FILLED] {orderEvent.Symbol} | "
                   f"Qty: {orderEvent.FillQuantity} | "
                   f"Price: ${orderEvent.FillPrice:.2f}")
        elif orderEvent.Status == OrderStatus.Invalid:
            self.Error(f"[ORDER INVALID] {orderEvent.Symbol} | {orderEvent.Message}")
        elif orderEvent.Status == OrderStatus.Canceled:
            self.Log(f"[ORDER CANCELED] {orderEvent.Symbol}")