MetaTrader e Planilhas Google via PythonAnywhere: Guia para um fluxo seguro de dados

Introdução

O acesso aos dados de negociação e sua análise são fundamentais para os traders que utilizam o MetaTrader, pois ajudam a evitar erros e a tomar decisões mais fundamentadas nas operações futuras. A plataforma oferece ferramentas e recursos nativos para exportação de dados, mas não permite exportá-los diretamente para serviços em nuvem. A exportação automática de gráficos, históricos e logs para esses serviços pode desempenhar um papel importante na tomada de decisões de negociação.

Existem diferentes métodos e ferramentas para transferir dados do MetaTrader para soluções em nuvem, como as Planilhas Google. Algumas opções são gratuitas, mas oferecem menor segurança, enquanto outras são mais seguras, porém pagas ou com acesso gratuito limitado. Encontrar uma solução adequada e de baixo custo para exportar dados para a nuvem pode ser um desafio para traders que desejam aproveitar a análise de seus dados de negociação para orientar operações futuras.

Os traders frequentemente perdem informações importantes sobre suas operações e outros dados úteis, pois o MetaTrader não dispõe de um recurso nativo de backup automático em serviços de nuvem. Isso também dificulta o aproveitamento das ferramentas de visualização e análise de dados já disponíveis nesses ambientes. O objetivo deste artigo é mostrar como automatizar a transferência de dados do MetaTrader para as Planilhas Google sem custos adicionais, com alto nível de segurança e utilizando soluções acessíveis que possam contribuir para melhorar a rentabilidade das operações futuras.

Este artigo é destinado a traders e desenvolvedores que procuram maneiras de transferir seus dados para soluções ou serviços de armazenamento em nuvem. Explicarei como utilizar ferramentas gratuitas e seguras, como as chaves de contas de serviço do Google e um servidor proxy hospedado no PythonAnywhere, uma plataforma web gratuita e segura.

Por que utilizar as Planilhas Google e uma chave de conta de serviço?

As Planilhas Google são especialmente úteis por funcionarem na nuvem, permitindo acessar os dados armazenados a qualquer momento e de qualquer lugar. Assim, os traders podem consultar os dados de negociação e outras informações relacionadas, exportados para as Planilhas Google, e realizar análises adicionais para orientar suas futuras operações, independentemente de onde estejam. Podemos utilizar os recursos de análise de dados das Planilhas Google e até integrá-las a outras ferramentas, como Google Data Studio ou TradingView. Além disso, outros traders e assistentes podem colaborar nas planilhas, contribuindo com suas próprias análises e perspectivas.

Publiquei no Mercado MQL5 o aplicativo utilitário Info Exporter MT5, que pode ser baixado e utilizado gratuitamente. Ele utiliza os recursos do Google Apps Script para transferir dados do MetaTrader para as Planilhas Google.

Embora o Apps Script seja gratuito e fácil de usar, ele não oferece segurança suficiente: o URL publicado é acessível publicamente, permitindo que qualquer pessoa que tenha o endereço envie solicitações de leitura e gravação ao script e, consequentemente, acesse os dados das planilhas. Existem outras alternativas, como a federação de identidade da carga de trabalho (Workload Identity Federation) e a Google Sheets API, mas elas são complexas de configurar, pagas ou oferecem acesso gratuito limitado.

A utilização de uma chave de conta de serviço é uma alternativa mais segura, gratuita e que exige menos conhecimentos técnicos para sua configuração.

Você pode assistir ao vídeo sobre o acesso às Planilhas Google por meio de uma chave de conta de serviço em um servidor proxy para entender melhor como configurar uma chave de conta de serviço do Google e utilizá-la em seu aplicativo.

Por que utilizar um servidor proxy no pythonanywhere.com?

O MetaTrader não oferece integração direta com as Planilhas Google nem com sua API. Por isso, utilizar um servidor proxy é a melhor alternativa para transferir dados para as Planilhas Google. Uma solução em nuvem como o PythonAnywhere oferece disponibilidade, escalabilidade, segurança e confiabilidade. A disponibilidade permite acessar o serviço mesmo quando nossos computadores estão desligados. A escalabilidade permite que qualquer usuário com o link utilize o serviço, desde que forneça um identificador válido de planilha. A segurança decorre do fato de a plataforma ser amplamente testada e administrada por engenheiros qualificados. Já a confiabilidade significa que podemos contar com seus serviços continuamente, mesmo na versão gratuita.

O PythonAnywhere oferece um plano gratuito com recursos suficientes para criar um servidor proxy simples para aplicações desse tipo. Na versão gratuita, o URL do servidor proxy permanece ativo por três meses, mas esse período pode ser renovado continuamente, desde que a renovação seja feita antes do término de cada ciclo de três meses.

No plano gratuito, recebemos um URL que dá acesso ao endpoint da API do servidor proxy, permitindo acessar as Planilhas Google e executar outras operações necessárias, como ler dados das planilhas, exibir páginas estáticas com informações e muito mais. Também temos acesso a consoles para executar comandos de terminal, utilizados principalmente para instalar as bibliotecas necessárias, gerenciar arquivos, realizar operações de rede, editar arquivos de log de erros, entre outras tarefas.

Também temos acesso a um banco de dados MySQL, que pode ser utilizado em conjunto com nosso serviço de API para armazenar informações ou mantê-las em cache. Além disso, a plataforma oferece recursos de agendamento de tarefas, permitindo criar tarefas cron que serão executadas em horários específicos do dia, sem necessidade de iniciá-las manualmente. Temos ainda à disposição ferramentas para criar, editar e excluir arquivos, uma interface web para consultar logs de erros, recursos de segurança para o site, ferramentas para criar ambientes virtuais (virtualenv) e diversas outras funcionalidades.

Procurei reunir todas as informações necessárias sobre a criação, edição e hospedagem de um servidor proxy no pythonanywhere.com em um vídeo no qual desenvolvo um servidor proxy idêntico ao utilizado neste artigo.

Diagrama do fluxo de dados

O fluxo de dados desse processo de transferência é relativamente simples. O MetaTrader funciona como fonte dos dados necessários para realizar análises detalhadas e tomar decisões de negociação que favoreçam a obtenção de lucros. Esses dados são enviados a um servidor proxy hospedado na plataforma em nuvem pythonanywhere.com. O servidor proxy grava os dados recebidos em uma planilha do Google à qual a conta de serviço tem acesso autorizado, utilizando os pacotes de autenticação do Google e as credenciais geradas a partir da chave dessa conta. O diagrama a seguir ilustra esse fluxo com mais clareza.

Essa é uma das maneiras gratuitas e seguras de transferir dados do MetaTrader para as Planilhas Google. O servidor proxy acessa apenas as planilhas para as quais possui autorização, independentemente de estar hospedado localmente ou em uma plataforma de nuvem confiável e segura, como o PythonAnywhere.

Processo de criação da chave de conta de serviço

O Google Cloud Console oferece diversos recursos gratuitos e bastante úteis. As contas de serviço do Google (Google Service Accounts) são um desses recursos. A seção Service Accounts está localizada em IAM & Admin, conforme mostrado abaixo:

Antes de acessar o gerenciamento de contas de serviço, certifique-se de ter criado um projeto ou selecionado um projeto existente. A página de contas de serviço é exibida conforme a imagem abaixo, com o botão Create service account na barra superior.

Conclua as etapas necessárias para criar a conta de serviço. Ao final, será gerado um endereço de e-mail para essa conta, que será utilizado posteriormente para conceder acesso às planilhas. O campo Key ID estará vazio. Para criar uma chave, acesse a página de detalhes da conta de serviço recém-criada, conforme mostrado abaixo:

O botão Add key permite criar uma chave e baixar as credenciais nos formatos JSON ou P12. Selecione o formato JSON. O arquivo será baixado automaticamente e, posteriormente, utilizado pelo servidor proxy para autenticação.

A próxima etapa é habilitar a Sheets API para o projeto. Para isso, acesse a seção APIs & Services, conforme mostrado abaixo, localize a Google Sheets API e habilite-a.

Apresentei um vídeo detalhado sobre esse procedimento na seção anterior, dedicada às Planilhas Google e à chave de conta de serviço.

Programa do servidor proxy

Se você assistiu aos vídeos que compartilhei na seção sobre o servidor proxy no pythonanywhere.com, será mais fácil compreender o código que explicarei a seguir. Desenvolveremos uma aplicação Flask simples que atualizará uma planilha do Google utilizando os recursos do pacote Google Auth e as credenciais da chave de conta de serviço.

Primeiro, importaremos para o programa as funções necessárias das bibliotecas.

from flask import Flask, request, jsonify
from google.oauth2 import service_account
from googleapiclient.discovery import build

As bibliotecas mencionadas acima devem ser instaladas com pip, caso ainda não estejam disponíveis no sistema ou no ambiente virtual. Também expliquei esse procedimento nos meus vídeos.

Em seguida, criaremos uma instância da aplicação Flask, que permitirá definir posteriormente endpoints de API (GET, POST, PUT, DELETE), rotas e outros recursos. A linha de código a seguir realiza essa inicialização.

app = Flask(__name__)

O próximo passo é informar o caminho do arquivo JSON de credenciais, baixado durante a criação da chave de conta de serviço. Também podemos definir um escopo de acesso (scope) para restringir as permissões aos recursos necessários, neste caso, às planilhas. Em seguida, criaremos o objeto credentials com as credenciais e o escopo definidos, que será utilizado para inicializar o cliente da API do Google.

SERVICE_ACCOUNT_FILE = 'service_account.json'
SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
credentials = service_account.Credentials.from_service_account_file(
    SERVICE_ACCOUNT_FILE, scopes=SCOPES
)

Agora, definiremos um endpoint de API do tipo POST chamado "update-sheet".

@app.route('/update-sheet', methods=['POST'])
def update_sheet():

Normalmente, o método POST é utilizado para enviar dados a um servidor. Também enviamos cabeçalhos HTTP com informações sobre os dados, facilitando sua extração pelo servidor.

data = request.json
sheet_id = data['sheet_id']
data_range = data['range']
values = data['values'] 

No código acima, request é um objeto do Flask que contém as informações enviadas pelo cliente na requisição POST, incluindo os dados em formato JSON. O código extrai o identificador da planilha, o intervalo de células e os valores que devem ser gravados nela.

Em seguida, inicializaremos o cliente da API do Google, passando o objeto credentials criado anteriormente.

service = build('sheets', 'v4', credentials=credentials)

O objeto service será utilizado para atualizar os dados da planilha identificada pelo sheet_id informado anteriormente.

result = service.spreadsheets().values().update(spreadsheetId=sheet_id, range=data_range, valueInputOption='RAW', body={'values': values}).execute()

O código acima instrui o cliente da API do Google a atualizar as células do intervalo especificado com os valores recebidos. O código completo, que também inclui uma API para adicionar dados, está disponível em anexo para consulta. Nele, você encontrará um endpoint adicional para acrescentar dados, além da lógica para verificar o nome da aba e criá-la caso ainda não exista. Se necessário, você também poderá implementar outros endpoints de API, como um para exclusão de dados (DELETE), entre outras operações.

Programa MetaTrader

O programa .mq5 propriamente dito permite exportar informações do terminal, dados da conta, histórico de negociações e histórico de ordens. Ele também inclui um conjunto de parâmetros de entrada que permite ao usuário selecionar quais informações deseja transferir. Explicarei apenas o código responsável pelos dados da conta. A função apresentada abaixo utiliza o arquivo de cabeçalho AccountInfo.mqh para obter as informações da conta e organizá-las em um array de strings. Em seguida, esse array é utilizado pela função StringToCharArray para gerar um array de caracteres (char), necessário para a função de comunicação pela rede WebRequest.

#include <Trade\AccountInfo.mqh>
string GetAccountInfo() {
   CAccountInfo accountInfo;
   string account_info = "[\"symbol\", \"name\", \"currency\", \"company\", \"balance\", \"credit\", " +
      "\"profit\", \"equity\", \"margin\", \"login\", \"trade_mode\", \"leverage\", \"limit_orders\", \"margin_mode\"]";
   StringAdd(account_info, StringFormat(
      ", [\"%s\", \"%s\", \"%s\", \"%s\", \"%f\", \"%f\", \"%f\", \"%f\", \"%f\", \"%d\", \"%d\", \"%d\", \"%d\", \"%d\"]",
      Symbol(),
      accountInfo.Name(), accountInfo.Currency(), accountInfo.Company(),
      accountInfo.Balance(), accountInfo.Credit(), accountInfo.Profit(), accountInfo.Equity(), accountInfo.Margin(),
      accountInfo.Login(), accountInfo.TradeMode(), accountInfo.Leverage(), accountInfo.LimitOrders(),
      accountInfo.MarginMode()
   ));
   return account_info;
}

A função acima prepara apenas os dados da conta. O código completo, disponível no arquivo anexo ProxyExport.mq5, contém outras três funções responsáveis por preparar as informações do terminal, o histórico de negociações e o histórico de ordens. Após essa preparação, passamos os dados para a função WriteToGoogleSheet, que realiza outras operações com strings e chama a função SheetExporter.

void WriteToGoogleSheet(string terminalInfos, string historicalDeals, string historicalOrders, string accountInfos) {
   if(terminalInfos != NULL) {
      StringReplace(terminalInfos, "\\", "/");
      SheetExporter(terminalInfoName, terminalInfos);
   }
   if(historicalDeals != NULL) {
      SheetExporter(historyDealsName, historicalDeals);
   }
   if(historicalOrders != NULL) {
      SheetExporter(historyOrdersName, historicalOrders);
   }
   if(accountInfos != NULL) {
      SheetExporter(accountInfoName, accountInfos);
   } 
}

void SheetExporter(string sheetName, string data) {
   string headers = "Content-Type: application/json\r\n";
   char postData[], result[];
   string responseHeaders;
   string jsonDataWithSheetName = StringFormat("{\"spreadSheetId\": \"%s\", \"sheetName\": \"%s\", \"data\": [%s]}", spreadSheetId, sheetName, data);
  
   // Convert to char array
   StringToCharArray(jsonDataWithSheetName, postData, 0, StringLen(jsonDataWithSheetName), CP_UTF8);
   
   // Send POST request
   int res = WebRequest("POST", proxyServerUrl, headers, 5000, postData, result, responseHeaders);
   
   // Check response
   if(res != 200) {
     Alert("Account Infos not exported to Google Sheets returned error ", res, " and get last error is ", GetLastError());
   }
}

A função SheetExporter acrescenta spreadSheetId e sheetName aos dados em uma string JSON, que será enviada ao servidor proxy. É importante adicionar o URL do servidor proxy à lista "Permitir WebRequest para as seguintes URLs:", disponível no menu Ferramentas -> Opções. O mesmo URL do servidor proxy também deve ser inserido no campo de parâmetros de entrada indicado a seguir.

Demonstração do fluxo de dados

Siga o procedimento descrito anteriormente na seção "Processo de criação da chave de conta de serviço" para criar a chave e baixar o arquivo JSON para que o servidor proxy se autentique como a conta de serviço e acesse a planilha autorizada para a exportação dos dados do MetaTrader. Em seguida, você pode configurar seu próprio servidor proxy ou utilizar o pythonanywhere.com ou qualquer outra plataforma de sua preferência para executar o código service_accounts_proxy.py e hospedar o endpoint da API de atualização. Lembre-se de que o código pode ser adaptado conforme suas necessidades.

A última etapa consiste em compilar o código ProxyExport.mq5 e executar o arquivo EX5 no gráfico. Serão exibidos os parâmetros para selecionar os dados que deseja exportar, além dos campos para informar o endereço da API e o identificador da planilha. Sem essas informações, a exportação não funcionará.

Procurei demonstrar todo o procedimento de criação das credenciais da chave de conta de serviço, habilitação da Google Sheets API no projeto do Google Cloud utilizado pela conta de serviço e concessão de acesso à planilha do Google por meio do endereço de e-mail dessa conta.

Na animação GIF a seguir, procurei demonstrar todas as etapas necessárias para configurar o serviço no pythonanywhere.com.

Também procurei demonstrar todas as etapas necessárias no MetaEditor e no MetaTrader para que a exportação funcione. A animação GIF a seguir mostra a transferência automática, em tempo real, das informações do MetaTrader para uma planilha do Google.

Análise de dados de negociação com as Planilhas Google

Tenho os seguintes dados históricos de negociação exportados para uma planilha do Google. Para este exemplo, incluí apenas 9 linhas.

O valor de Pips é calculado pela diferença entre o preço de saída e o preço de entrada (Exit Price - Entry Price), multiplicada por um fator (multiplier) de 100 para pares com JPY e de 10000 para os demais pares. O valor de Profit é calculado multiplicando Pips por Lot Size e por 10. Já Cumulative Profit corresponde à soma do lucro acumulado anterior (previous Cumulative Profit) com o lucro da operação atual (current Profit).

Na implementação apresentada, a aba acima recebe o nome History_Deals, mas você pode alterá-lo conforme suas necessidades. Em seguida, podemos criar outra aba, chamada "Métricas", e adicionar os rótulos e as fórmulas apresentados abaixo.

Vou explicar brevemente as métricas utilizadas na tabela acima.

• Total de operações: corresponde ao número total de operações encerradas, incluindo as lucrativas e as com prejuízo. Quanto maior esse número, mais confiáveis e precisas tendem a ser as estatísticas.
• Operações lucrativas: representa a quantidade de operações encerradas com lucro. Esse número indica quantas decisões de negociação foram acertadas.
• Operações com prejuízo: representa a quantidade de operações encerradas com perda. Esse número indica quantas decisões de negociação não produziram o resultado esperado.
• Percentual de operações lucrativas: representa a proporção de operações encerradas com lucro, enquanto o percentual de operações com prejuízo corresponde à proporção de operações encerradas com perda. É importante lembrar que uma taxa de acerto (Win Rate) elevada nem sempre significa que a estratégia é lucrativa. Com uma relação retorno/risco adequada, os traders podem obter resultados positivos mesmo com uma taxa de acerto de apenas 30% a 40%.
• Lucro médio e prejuízo médio: indicam quanto você ganha nas operações bem-sucedidas e quanto perde nas operações malsucedidas. A estratégia deve ser estruturada para manter o prejuízo médio sempre baixo.
• Relação retorno/risco: corresponde à razão entre o lucro médio e o valor absoluto do prejuízo médio. O objetivo do trader é manter essa relação acima de 1. Uma regra amplamente utilizada é buscar uma relação entre 1,5:1 e 2:1.
• Expectativa matemática: representa o resultado médio esperado por operação. Por exemplo, se esse valor for 20, o resultado esperado após 100 operações será de 2000.
• Lucro total: corresponde à soma de todos os lucros e prejuízos das operações.
• Fator de lucro: é um indicador da rentabilidade geral da estratégia. Os traders devem procurar mantê-lo acima de 1,5.
• Drawdown máximo: representa a maior queda do lucro acumulado em relação ao seu pico anterior. Os traders devem procurar mantê-lo o mais baixo possível.

Após aplicar todas as fórmulas, obtemos a seguinte tabela.

Podemos avaliar a estabilidade e a consistência dos resultados das nossas operações criando um gráfico de linhas do lucro acumulado, conforme mostrado abaixo. Para isso, acesse Insert → Chart → Line Chart, selecione o lucro acumulado para o eixo vertical e a data de fechamento das operações para o eixo horizontal.

Também podemos comparar a quantidade de operações lucrativas e com prejuízo por meio de um gráfico de pizza, conforme mostrado abaixo.

Além disso, podemos analisar o desempenho por par de moedas utilizando um gráfico de barras, conforme ilustrado a seguir.

As Planilhas Google permitem realizar diversas outras análises desse tipo.

Conclusão

Com essa solução, os traders podem transferir seus dados do MetaTrader para as Planilhas Google de maneira simples e segura, aproveitando os recursos de visualização disponíveis na ferramenta. A solução permite exportar dados do MetaTrader para as Planilhas Google, utilizando ferramentas gratuitas, tanto para manter um registro das operações quanto para realizar análises posteriores. Neste artigo, demonstramos como configurar e hospedar um servidor proxy próprio, inclusive em plataformas de nuvem como o pythonanywhere.com. As soluções em nuvem oferecem segurança e escalabilidade. Também procuramos estruturar o programa MetaTrader de forma modular, proporcionando maior flexibilidade na seleção dos dados e facilitando a implementação de novas funcionalidades. Entre as possíveis extensões está a exportação de dados dos logs do Testador de Estratégias para análises posteriores, além de diversas outras possibilidades.

Em resumo, este artigo apresenta mais uma ferramenta que traders e desenvolvedores podem utilizar para transferir dados do MetaTrader, realizar análises adicionais e tomar decisões de negociação mais fundamentadas.

Disponibilizei em anexo o código-fonte do servidor proxy e do script MetaTrader.