Implante o NautilusTrader na TradingHost
Execute estratégias de código aberto do NautilusTrader a partir do GitHub em runtimes sempre ativos da TradingHost.
O NautilusTrader é uma plataforma de trading algorítmico de alta performance com núcleo em Rust, plano de controle em Python e caminhos de código orientados a eventos idênticos para backtesting e execução em tempo real. A TradingHost fornece o runtime de produção para esse motor.
- Implantação nativa do GitHub
- Núcleo em Rust, plano de controle em Python
- Caminhos de código idênticos para backtest e live
- Precisão de nanossegundos no tempo dos eventos
- Cripto, FX, ações, futuros, opções
- Runtime sempre ativo
- Credenciais criptografadas
- Seleção de região
- Pronto para MCP
Introdução
Novo no NautilusTrader?
O NautilusTrader é uma plataforma de trading algorítmico de código aberto e alta performance. Ele é construído em torno de um núcleo orientado a eventos escrito em Rust, com um plano de controle em Python que permite desenvolver estratégias em Python idiomático enquanto o caminho crítico roda compilado.
A escolha de design que o define é o determinismo. O mesmo código de estratégia é executado tanto no backtest quanto em produção (live), no mesmo message bus orientado a eventos, com precisão de nanossegundos. Não há motores separados para pesquisa e execução real que possam divergir; o que você testa no backtest é exatamente o que você coloca em produção.
A cobertura abrange diversas classes de ativos: cripto em CEX (Binance, Bybit, Coinbase, OKX, BitMEX, Kraken, Deribit) e DEX (dYdX, Hyperliquid, Polymarket), forex e multi-ativos via Interactive Brokers, mercados esportivos via Betfair, além de provedores de dados como Databento e Tardis. O NautilusTrader possui licença LGPL-3.0 e é mantido pela Nautech Systems.
A TradingHost é onde uma estratégia do NautilusTrader roda em produção. Em vez de deixar sua estratégia rodando em um notebook ou em um VPS genérico, você implanta seu repositório do Nautilus em um runtime na nuvem da TradingHost que permanece online, gerencia suas credenciais das plataformas como segredos criptografados e transmite os logs de volta para você.
Seção 01 · Visão geral
Visão geral
- O que é o NautilusTrader
- Plataforma de trading algorítmico de código aberto e alta performance, com licença LGPL-3.0
- Mantido por
- Nautech Systems Pty Ltd (nautechsystems/nautilus_trader no GitHub)
- Arquitetura
- Núcleo em Rust, plano de controle em Python, bindings em Cython; rede assíncrona tokio
- Linguagens
- Desenvolvimento de estratégias em Python; o caminho crítico roda em Rust compilado
- Determinismo
- Caminhos de código orientados a eventos idênticos para backtest e live; precisão de nanossegundos
- Classes de ativos
- Cripto (CEX e DEX), forex, ações, futuros, opções, apostas esportivas
- Provedores de dados
- Databento, Tardis e feeds nativos das plataformas
- Modos
- Backtest, paper trading, live; mesma classe de estratégia
- Origem da implantação
- GitHub
- Papel da TradingHost
- Runtime, implantação, logs, segredos, seleção de região
- Afiliação
- A TradingHost é independente e não é afiliada à Nautech Systems
- Ideal para
- Estratégias multi-ativo de baixa latência, implantação idêntica de pesquisa e produção, equipes profissionais
Seção 02 · Onde o Nautilus se encaixa
Como o NautilusTrader se encaixa na sua infraestrutura de trading
O NautilusTrader é um motor de execução completo, não um framework de estratégia que roda sobre primitivas de terceiros. O núcleo em Rust controla o message bus, o cache, o motor de risco e os adaptadores de conexão. Seu código Python interage com esse motor por meio das classes Strategy e Actor.
Você pode usar o Nautilus de duas formas na TradingHost:
Caminho 01
Classe Strategy
Crie uma subclasse de Strategy em Python. Receba ticks, barras e eventos de ordens do núcleo em Rust; envie ordens que o motor roteia para a conexão configurada. A mesma classe serve para backtest e operações em tempo real.
Caminho 02
Actor / message bus
Para arquiteturas mais sofisticadas, use Actors e o message bus diretamente. Múltiplos Actors podem se coordenar dentro de um único motor enquanto compartilham dados de mercado e o estado de risco.
Ambos os caminhos rodam da mesma forma na TradingHost. Você traz um repositório do GitHub com o Nautilus. Nós o executamos.
- Você
- Suas classes Strategy ou Actor controlam a lógica de trading.
- Nautilus
- Executa o núcleo orientado a eventos, o message bus, o cache e os adaptadores de conexão; o mesmo caminho para backtest e operações em tempo real.
- Conexão
- Sua exchange, corretora ou carteira DEX recebe as ordens.
- TradingHost
- Executa o processo do motor, gerencia credenciais e transmite logs em tempo real.
Seção 03 · Por que na TradingHost
Por que implantar o NautilusTrader na TradingHost
O NautilusTrader é um motor de baixa latência. Ele se beneficia imensamente de um ambiente de execução com caminho de rede estável, CPU previsível e uma região próxima à conexão. Rodar em um notebook, desktop ou VPS genérico introduz gargalos operacionais, incluindo supervisão de processos, reinicializações, logs dispersos e agendamentos imprevisíveis que prejudicam o determinismo que o motor foi projetado para entregar.
A TradingHost oferece ao motor NautilusTrader um ambiente de execução voltado para produção, projetado para processos de trading de longa duração.
O que você recebe
- Implantação nativa via GitHub
- Ambiente de execução em container sempre ativo e otimizado para processos de baixa latência
- Suporte a múltiplas estratégias dentro de um único motor
- Armazenamento criptografado de credenciais para cada conexão
- Seleção de região próxima à sua conexão
- Transmissão de logs em tempo real e monitoramento básico de integridade
- Iniciar, parar, reiniciar e inspecionar no nível da estratégia
- Mesmo ambiente de execução para backtest e operações reais (o motor é idêntico)
- Fluxos de trabalho em IDEs de IA compatíveis com MCP
O que você mantém
- Controle total sobre suas classes Strategy e Actor
- Propriedade direta de suas contas e credenciais nas conexões
- Sua escolha de classes de ativos: cripto, FX, ações, futuros e opções
Seção 04 · Conexões suportadas
Conexões e provedores de dados suportados
O NautilusTrader abrange mais classes de ativos do que os frameworks focados apenas em cripto. Os adaptadores nativos cobrem CEX de cripto, DEX de cripto, corretoras de múltiplos ativos, mercados esportivos e provedores de dados de mercado de primeira linha.
Cinco combinações populares são mostradas abaixo. O diretório completo vem a seguir.
- NautilusTrader
- sua conexão
- ambiente de execução da TradingHost
O Nautilus também vem com adaptadores nativos para as seguintes conexões e provedores de dados:
- CEX de cripto
- BitMEX, Kraken, OKX, Deribit
- DEX de cripto
- dYdX, Polymarket
- Provedores de dados
- Databento, Tardis
- Outros mercados
- Betfair, AX Exchange
Seção 05 · Fluxo de deploy
Como funciona o deploy do NautilusTrader
O motor do NautilusTrader na TradingHost segue o mesmo padrão de deploy de qualquer projeto baseado no GitHub, com uma etapa extra para instalar o núcleo em Rust e quaisquer extensões compiladas.
- PASSO 01
Conecte ou crie um repositório
Faça login com o GitHub e conecte um repositório do Nautilus com suas classes Strategy e Actor, ou crie um a partir de um template do Nautilus na TradingHost.
- PASSO 02
Configure o motor
A TradingHost lê a configuração de runtime do seu projeto para saber como instalar o wheel do Nautilus (com o núcleo em Rust), compilar quaisquer extensões personalizadas em Cython e iniciar o motor.
- PASSO 03
Adicione credenciais criptografadas das plataformas
Adicione chaves de API de exchanges, credenciais da IBKR ou credenciais de carteiras de DEX como segredos na TradingHost. Elas são criptografadas, injetadas no runtime na inicialização e nunca são gravadas no seu repositório.
/platform/secrets/ - PASSO 04
Escolha uma região
Selecione uma região próxima ao matching engine da sua plataforma. Configurações sensíveis à latência se beneficiam ao estarem no mesmo continente que a plataforma e no mesmo provedor que sua região de colocation.
/platform/regions/ - PASSO 05
Deploy
A TradingHost inicia o motor do Nautilus em um container gerenciado. Os logs são transmitidos em tempo real para o painel. O motor trata o backtest e a operação em tempo real (live) como variantes do mesmo runtime, oferecendo um único formato para monitorar.
/platform/observability/
Seção 06 · Determinismo
Backtest = live: núcleo determinístico orientado a eventos
O que torna o NautilusTrader incomum é que o backtest e a operação em tempo real (live) não são produtos diferentes. São entradas diferentes para o mesmo motor. A classe da estratégia, o message bus, o cache e o motor de risco são idênticos; apenas o feed de dados e o roteamento de ordens mudam.
Na prática, isso significa que uma estratégia que passa perfeitamente no backtest tem muito mais chances de operar em tempo real conforme o esperado. Desvios em produção (live drift) são mais difíceis de acontecer quando não existe uma segunda base de código para onde desviar.
Seção 07 · O que não fazemos
O que a TradingHost não faz
- A TradingHost não atua como sua plataforma de negociação.
- A TradingHost não fornece estratégias de trading, sinais ou aconselhamento financeiro.
- A TradingHost não modifica suas classes Strategy ou Actor do Nautilus.
- A TradingHost não realiza a custódia das credenciais da sua plataforma de negociação, exceto pela injeção criptografada em tempo de execução.
- A TradingHost não garante o desempenho da estratégia, a disponibilidade da plataforma ou a conectividade com o mercado.
Seção 08 · FAQ
Perguntas frequentes
Não. A TradingHost é independente. O NautilusTrader é um software de código aberto, licenciado sob a LGPL-3.0, mantido pela Nautech Systems Pty Ltd em nautechsystems/nautilus_trader.
O núcleo em Rust lida com o caminho crítico (hot path) orientado a eventos: message bus, cache, motor de risco, adaptadores de plataforma e rede assíncrona via tokio. O plano de controle em Python é onde você desenvolve as estratégias. O resultado é alta performance com uma interface de desenvolvimento acessível.
Porque a maioria das falhas do tipo "funcionou no backtest, quebrou em produção" vem de desvios entre duas bases de código diferentes. O Nautilus tem um único motor, uma única classe de estratégia e um único message bus. O resultado de um backtest é muito mais representativo do comportamento em tempo real.
As CEX de cripto incluem Binance, Bybit, Coinbase, BitMEX, Kraken, OKX e Deribit. As DEX de cripto incluem dYdX, Hyperliquid e Polymarket. A cobertura multiativos é feita via Interactive Brokers (ações, futuros, opções e FX). Outros mercados incluem Betfair e AX Exchange. Os provedores de dados incluem Databento e Tardis.
Sim, principalmente através da Interactive Brokers, que oferece acesso a FX junto com ações, futuros e opções. Os instrumentos negociáveis dependem das permissões da conta IBKR que você fornecer.
Sim. O motor do NautilusTrader é projetado em torno de um modelo de atores (actor model): várias instâncias de Strategy e Actor podem ser executadas em um único motor, compartilhando dados de mercado, o cache e o motor de risco através do message bus.
Você as adiciona ao TradingHost como segredos criptografados. Elas são injetadas no runtime do Nautilus na inicialização e não são gravadas em seu repositório.
Não. O NautilusTrader executa as operações através das credenciais da sua plataforma de negociação. O TradingHost executa o processo da engine e transmite os logs.
O Backtrader é mais antigo, exclusivo para Python, mais limitado na cobertura de plataformas de negociação e seu repositório original está essencialmente congelado em termos de novos recursos. O NautilusTrader é mais recente, desenvolvido ativamente, possui núcleo em Rust, é multi-ativos e foi projetado para um comportamento idêntico de baixa latência entre backtest e ambiente real.
O tempo de ida e volta (round-trip time) até a matching engine importa mais do que a CPU em uma estratégia de baixa latência. O TradingHost permite que você escolha uma região próxima à sua plataforma de negociação. Consulte /platform/regions/ para ver a lista completa.
Faça o deploy da sua primeira estratégia NautilusTrader
Conecte o GitHub, escolha um template do NautilusTrader ou seu próprio repositório de estratégia, adicione as credenciais da sua plataforma de negociação, escolha uma região e execute em um runtime do TradingHost.