Mantener un proceso en segundo plano ejecutándose de forma ininterrumpida durante semanas o meses en la nube no es simplemente envolver un script en un bucle while True:. En mercados financieros volátiles, donde las conexiones de red sufren latencia variable, los proveedores de APIs imponen límites estrictos (rate limits) y los reinicios de contenedores son inevitables, la resiliencia del software se convierte en el factor crítico de éxito.
En este artículo detallo la arquitectura implementada en Arbitrage Monitor Perú, un motor cuantitativo en producción diseñado para identificar diferenciales de cotización (spreads) en soles peruanos (PEN) y dólares estadounidenses (USD) a través de múltiples mercados de liquidez.
1. Desafíos de un Monitor Financiero Desatendido
Un motor de monitoreo desatendido se enfrenta continuamente a cuatro escenarios adversos:
- Rate Limiting & Banning: Consultas demasiado agresivas provocan códigos de estado HTTP 429 (Too Many Requests) o bloqueos temporales de IP.
- Caídas Transitorias de Red: Microcortes de conexión o errores HTTP 502/503 en los servidores remotos.
- Condiciones de Carrera en Memoria: Fugas de memoria por acumulación de datos en estructuras locales no limpiadas.
- Fallas en la Base de Datos: Desconexiones del pool de PostgreSQL tras períodos de inactividad o reinicios del proveedor de base de datos.
2. Arquitectura de Cuatro Capas del Motor
Para garantizar un código mantenible y tolerante a fallos, dividimos el sistema en cuatro capas con responsabilidades delimitadas:
┌────────────────────────────────────────────────────────┐
│ 1. CAPA DE INGESTA (HTTP Concurrency & Backoff) │
│ - Async Client (httpx) │
│ - Reintentos con Exponential Backoff + Jitter │
└───────────────────────────┬────────────────────────────┘
│ Datos JSON Crudos
▼
┌────────────────────────────────────────────────────────┐
│ 2. CAPA ANALÍTICA & NORMALIZACIÓN │
│ - Descuento de comisiones operativas (Maker/Taker) │
│ - Cálculo de Spread Neto: [(Ask_B - Bid_A)/Bid_A] │
│ - Filtrado de liquidez mínima requerida │
└───────────────────────────┬────────────────────────────┘
│ Oportunidades Filtradas
▼
┌────────────────────────────────────────────────────────┐
│ 3. CAPA DE PERSISTENCIA (PostgreSQL) │
│ - Inserción por lotes (Batch Upsert) │
│ - Series temporales indexadas por timestamp │
└───────────────────────────┬────────────────────────────┘
│ Spread > Umbral Objetivo
▼
┌────────────────────────────────────────────────────────┐
│ 4. CAPA DE NOTIFICACIÓN & ALERTAS (Telegram Webhook) │
│ - Anti-Spam Cooldown Timer │
│ - Enlace directo a ejecución │
└────────────────────────────────────────────────────────┘
3. Implementación de Ingesta Resiliente con Python 3.11
3.1. Reintentos Exponenciales con Jitter
Cuando una API falla, reintentar de inmediato con intervalos fijos provoca el fenómeno de estampida (thundering herd). La solución es aplicar Exponential Backoff con Jitter aleatorio:
import asyncio
import random
import logging
from typing import Optional, Dict, Any
import httpx
logger = logging.getLogger("ArbitrageIngestion")
async def fetch_orderbook(
client: httpx.AsyncClient,
endpoint: str,
max_retries: int = 4
) -> Optional[Dict[str, Any]]:
"""
Consume el libro de órdenes con reintentos exponenciales y jitter.
"""
base_delay = 1.0
for attempt in range(1, max_retries + 1):
try:
response = await client.get(endpoint, timeout=5.0)
if response.status_code == 200:
return response.json()
elif response.status_code == 429:
# Si alcanzamos rate limit, respetamos el header Retry-After si existe
retry_after = float(response.headers.get("Retry-After", base_delay * (2 ** attempt)))
logger.warning(f"Rate limited en {endpoint}. Esperando {retry_after}s")
await asyncio.sleep(retry_after)
else:
logger.warning(f"Respuesta inesperada {response.status_code} en intento {attempt}")
except (httpx.ConnectError, httpx.ReadTimeout) as exc:
logger.warning(f"Falla de red en intento {attempt}: {exc}")
# Cálculo de backoff exponencial con variabilidad aleatoria (Jitter)
sleep_time = (base_delay * (2 ** (attempt - 1))) + random.uniform(0.1, 0.5)
await asyncio.sleep(sleep_time)
logger.error(f"Agotados los {max_retries} intentos para el endpoint: {endpoint}")
return None3.2. Modelo Cuantitativo de Spread Neto
En el mercado peruano, un arbitraje teórico de 1.5% puede convertirse en una pérdida real si no se descuentan las comisiones bancarias, comisiones de retiro y tarifas de trading (taker fees):
from dataclasses import dataclass
from decimal import Decimal
@dataclass(frozen=True)
class ArbitrageOpportunity:
asset: str
buy_exchange: str
sell_exchange: str
buy_price: Decimal
sell_price: Decimal
net_spread_pct: Decimal
estimated_net_profit_pen: Decimal
def calculate_net_spread(
buy_price: Decimal,
sell_price: Decimal,
buy_fee_pct: Decimal = Decimal("0.001"), # 0.1% Taker
sell_fee_pct: Decimal = Decimal("0.001"), # 0.1% Taker
capital_pen: Decimal = Decimal("5000.00")
) -> Optional[ArbitrageOpportunity]:
"""
Calcula el spread real neto después de descontar comisiones en ambas puntas.
"""
effective_buy = buy_price * (Decimal("1") + buy_fee_pct)
effective_sell = sell_price * (Decimal("1") - sell_fee_pct)
if effective_sell <= effective_buy:
return None
net_spread = ((effective_sell - effective_buy) / effective_buy) * Decimal("100")
net_profit = (capital_pen * net_spread) / Decimal("100")
return ArbitrageOpportunity(
asset="USDT/PEN",
buy_exchange="Exchange A",
sell_exchange="Exchange B",
buy_price=buy_price,
sell_price=sell_price,
net_spread_pct=net_spread.quantize(Decimal("0.01")),
estimated_net_profit_pen=net_profit.quantize(Decimal("0.01"))
)4. Persistencia Eficiente en PostgreSQL
Para almacenar miles de lecturas diarias sin degradar el rendimiento, utilizamos un pool de conexiones con psycopg o SQLAlchemy e insertamos mediante lotes con manejo de duplicados:
-- Estructura de tabla optimizada para series temporales
CREATE TABLE IF NOT EXISTS arbitrage_snapshots (
id BIGSERIAL PRIMARY KEY,
pair VARCHAR(20) NOT NULL,
buy_market VARCHAR(50) NOT NULL,
sell_market VARCHAR(50) NOT NULL,
buy_price NUMERIC(12, 4) NOT NULL,
sell_price NUMERIC(12, 4) NOT NULL,
net_spread_pct NUMERIC(6, 3) NOT NULL,
created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP NOT NULL
);
-- Índice compuesto para consultas analíticas de alta velocidad
CREATE INDEX IF NOT EXISTS idx_arbitrage_pair_created
ON arbitrage_snapshots (pair, created_at DESC);5. Despliegue en Producción con Docker y Railway
Para garantizar que el proceso se mantenga activo continuamente, lo encapsulamos en una imagen liviana de Docker basada en python:3.11-slim:
# Multi-stage / lightweight production container
FROM python:3.11-slim as base
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
TZ=America/Lima
WORKDIR /app
# Instalar dependencias del sistema mínimas
RUN apt-get update && apt-get install -y --no-install-recommends \
curl \
&& rm -rf /var/lib/apt/lists/*
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
# Usuario no privilegiado para máxima seguridad
RUN useradd -m appuser && chown -R appuser:appuser /app
USER appuser
# Healthcheck que verifica la vida del proceso
HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
CMD python -c "import os; exit(0 if os.path.exists('/tmp/heartbeat.ok') else 1)"
CMD ["python", "main.py"]En Railway, configuramos la variable de reinicio automático RESTART_POLICY=always y conectamos la base de datos PostgreSQL mediante su red privada interna para tener latencia menor a 1 ms entre el contenedor del bot y la base de datos.
6. Monitoreo y Métricas en Producción
Tras meses de operación continua en Arbitrage Monitor Perú, los resultados demuestran la efectividad de la arquitectura:
- Disponibilidad (Uptime): 99.85% de ejecución ininterrumpida.
- Tasa de Errores de Red: Menor al 0.02% gracias a la política de backoff.
- Alertas Efectivas: Filtrado de falsos positivos eliminando spreads fantasma sin liquidez en el libro de órdenes.
Conclusiones
La automatización confiable no radica en crear scripts rápidos, sino en diseñar sistemas conscientes de que la infraestructura externa fallará. Implementar timeouts rigurosos, backoff exponencial, cálculos matemáticos con Decimal (evitando errores de punto flotante) y contenerización con Docker transforma un script casual en un activo empresarial robusto.
Si buscas desarrollar sistemas de automatización de datos, web scraping o plataformas backend de misión crítica en Perú o de forma remota, estos principios son la base de un software profesional de alto impacto.