Logo
Nuevos usuarios de RPC: 35% de descuento el primer mesVer oferta
OnFinality Learn
Infraestructura y Operaciones11 min de lectura

Mejores proveedores de nodos RPC: un marco de evaluación práctico para equipos Web3

Un método reproducible para comparar proveedores de nodos RPC según el costo de carga de trabajo, la latencia, la confiabilidad y la capacidad, en lugar de depender de listas de marketing.

TL;DR

No existe un único mejor proveedor de nodos RPC; la elección correcta depende de qué cadenas necesita, qué métodos JSON-RPC dominan su tráfico y cómo se comporta su aplicación bajo límites de velocidad. Este artículo le ofrece un marco de evaluación repetible: defina un perfil de carga de trabajo, mida la latencia y el comportamiento de errores desde sus regiones de implementación reales, verifique el soporte de métodos y archivo, y normalice los precios a costo por millón de llamadas representativas. Terminará con una lista corta que puede defender con datos en lugar de un directorio de nombres.

Qué significa 'mejor' para un proveedor de nodos RPC

El mejor proveedor de nodos RPC para un proyecto es el que cubre las redes que necesita, maneja su patrón de tráfico real, expone suficiente comportamiento de solicitudes para depurar problemas y se mantiene dentro del presupuesto con el volumen esperado. Los directorios de proveedores que enumeran docenas o cientos de proveedores son útiles para el descubrimiento, pero no pueden decirle qué endpoint mantendrá su billetera, indexador o bot de trading receptivo a las 3 a. m. en la región de sus usuarios.

Esta guía trata la selección de proveedores como una evaluación de ingeniería. Definirá un perfil de carga de trabajo, ejecutará diagnósticos contra endpoints candidatos y comparará resultados en costo, latencia, confiabilidad y capacidad. Las recomendaciones concretas de endpoints y redes las maneja por separado el Asistente de RPC; úselo una vez que haya reducido sus requisitos.

  • Carga de trabajo: qué métodos dominan, cuántas solicitudes por segundo, en ráfagas o constantes.
  • Confiabilidad: latencia p95/p99, tasas de error, encabezados de límite de velocidad, estabilidad de websocket.
  • Capacidad: profundidad de archivo, métodos debug/trace, límites de logs y filtros, soporte de websocket y suscripciones.
  • Comerciales: unidad de precios (solicitudes, unidades de cómputo, créditos), comportamiento de exceso, límites del nivel gratuito.

Supuestos y requisitos previos

Este procedimiento asume que puede ejecutar comandos desde al menos una región cercana a su implementación de producción, que tiene URL de RPC candidatas (a menudo con una clave API incrustada) y que puede enviar solicitudes de solo lectura representativas. Evite enviar transacciones durante las pruebas de rendimiento; use eth_call, eth_blockNumber, eth_getLogs y métodos de lectura similares.

También debe conocer su volumen mensual de solicitudes y la combinación de métodos. Si no lo sabe, instrumente su aplicación primero. Una comparación de proveedores basada en tráfico supuesto producirá estimaciones de costos engañosas.

  • Un shell con curl, jq y, opcionalmente, python3 o Node.js.
  • Dos o más URL de RPC candidatas almacenadas como variables de entorno, como RPC_URL_A y RPC_URL_B.
  • Un rango de bloques representativo para consultas de logs y una dirección de contrato conocida para pruebas de llamadas.
  • Acceso a la misma región o regiones donde se ejecutan sus usuarios o backend.

Creación de un perfil de carga de trabajo antes de comparar proveedores

La mayoría de las páginas de precios de proveedores citan una cuota destacada, pero la factura depende de qué métodos llame. Una carga de trabajo dominada por eth_getLogs, llamadas de trace o lecturas de archivo puede costar mucho más que una dominada por eth_blockNumber. Anote el porcentaje de cada familia de métodos en su tráfico y luego use esa combinación de manera consistente entre proveedores.

Un perfil simple podría ser 40% eth_call, 25% consultas de recibos, 15% número de bloque, 10% eth_getLogs pequeños, 5% lecturas de saldo y 5% envíos de transacciones. Ajústelo para que coincida con su aplicación. El punto es comparar proveedores con la misma combinación en lugar de con cuotas mensuales destacadas.

cat > workload.json <<'EOF'
{
  "methods": {
    "eth_call": 0.40,
    "eth_getTransactionReceipt": 0.25,
    "eth_blockNumber": 0.15,
    "eth_getLogs": 0.10,
    "eth_getBalance": 0.05,
    "eth_sendRawTransaction": 0.05
  },
  "monthly_requests": 50000000,
  "peak_rps": 200
}
EOF

Medición de latencia y comportamiento de errores con curl

Comience con una verificación simple de latencia y corrección. El siguiente bucle envía una solicitud eth_blockNumber a cada endpoint candidato y registra el estado HTTP, el tiempo total y el número de bloque devuelto. Ejecútelo desde cada región que le interese y repítalo suficientes veces para ver una distribución, no una sola muestra.

No trate una única respuesta rápida como prueba de baja latencia. Desea p50, p95 y p99 en muchas solicitudes, además de la tasa de error bajo carga sostenida. Un proveedor que es rápido en reposo pero devuelve respuestas 429 bajo ráfagas no es adecuado para producción.

for url in "$RPC_URL_A" "$RPC_URL_B"; do
  echo "== $url =="
  for i in $(seq 1 20); do
    curl -s -o /tmp/body.json -w "%{http_code} %{time_total}\n" \
      -X POST "$url" \
      -H 'Content-Type: application/json' \
      -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
    jq -r '.result // .error.message' /tmp/body.json
  done
done

Prueba de cobertura de métodos y profundidad de archivo

Un proveedor puede admitir la cadena pero no todos los métodos que su aplicación necesita. Pruebe explícitamente los métodos que le importan: eth_getLogs con un rango de bloques realista, debug_traceTransaction si usa trazado, eth_getStorageAt en un bloque antiguo si necesita datos de archivo, y suscripciones websocket si depende de eventos en tiempo real.

Registre qué métodos devuelven un resultado, cuáles devuelven un error de método no encontrado y cuáles están limitados por velocidad. Esta matriz de capacidades a menudo elimina proveedores más rápido que las pruebas de latencia.

curl -s -X POST "$RPC_URL_A" \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_getLogs","params":[{"fromBlock":"0x1000000","toBlock":"0x1000064","address":"0x0000000000000000000000000000000000000000"}]}' | jq .

curl -s -X POST "$RPC_URL_A" \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"debug_traceTransaction","params":["0x0000000000000000000000000000000000000000000000000000000000000000"]}' | jq .

Registro de resultados en una tabla comparativa

Mantenga una tabla con una fila por proveedor y una columna por métrica. Complétela solo con valores que realmente midió o leyó de la documentación actual del proveedor. Marque las celdas no medidas como pendientes en lugar de adivinar.

ProveedorRegión probadap50 msp95 msTasa de errorArchivoTraceWebsocketUnidad de precios
Proveedor Aeu-westmedidomedidomedidosí/nosí/nosí/nosolicitudes/CU
Proveedor Beu-westmedidomedidomedidosí/nosí/nosí/nocréditos

La tabla es una ayuda para la decisión, no un marcador. Un proveedor con una latencia ligeramente mayor pero precios predecibles y cobertura completa de métodos puede ser la mejor opción operativa.

Normalización de precios a costo por millón de llamadas representativas

Los proveedores fijan precios de manera diferente: algunos cobran por solicitud, otros por unidad de cómputo, otros por crédito y algunos ofrecen planes mensuales fijos. Para compararlos, convierta cada plan en un costo mensual estimado para su perfil de carga de trabajo. Utilice los multiplicadores publicados por el proveedor para métodos costosos como logs, traces y lecturas de archivo.

Si un proveedor no publica multiplicadores, pregunte al soporte o realice una pequeña prueba paga e inspeccione el panel de uso. No asuma que una cuota destacada se traduce directamente en su combinación de métodos.

python3 - <<'PY'
workload = {
    "eth_call": 0.40,
    "eth_getTransactionReceipt": 0.25,
    "eth_blockNumber": 0.15,
    "eth_getLogs": 0.10,
    "eth_getBalance": 0.05,
    "eth_sendRawTransaction": 0.05,
}
monthly = 50_000_000
# Replace multipliers with values from the provider's current documentation.
multipliers = {"eth_call": 1, "eth_getTransactionReceipt": 1, "eth_blockNumber": 1,
               "eth_getLogs": 5, "eth_getBalance": 1, "eth_sendRawTransaction": 1}
weighted = sum(workload[m] * multipliers[m] for m in workload)
print("weighted units per request:", round(weighted, 3))
print("estimated monthly units:", int(monthly * weighted))
PY

Interpretación del comportamiento de límites de velocidad y conmutación por error

Los límites de velocidad son parte del producto. Verifique si el proveedor devuelve HTTP 429 con encabezados Retry-After, si los límites son por segundo o por método, y si el tráfico en ráfagas se absorbe o se rechaza. Un proveedor que falla cerrado bajo carga causará errores visibles para el usuario incluso si su latencia mediana es excelente.

Pruebe la conmutación por error enviando una ráfaga por encima de su pico esperado y observando cómo se comporta su cliente. Si utiliza varios proveedores, documente el orden de respaldo y verifique que el endpoint secundario admita los mismos métodos. Para patrones de producción, consulte la guía sobre endpoints RPC multicadena y alojamiento de nodos blockchain.

Solución de problemas comunes en comparaciones

Las comparaciones a menudo fallan por razones predecibles. Una prueba ejecutada desde una laptop en un continente diferente al de producción clasificará mal a los proveedores. Un benchmark que solo llama a eth_blockNumber pasará por alto el costo de logs y traces. Un nivel gratuito probado con poco volumen no revelará el comportamiento de los límites de velocidad en el pico.

Cuando los resultados parezcan sorprendentes, vuelva a ejecutar desde la región de producción, use la misma combinación de métodos y verifique si el proveedor cambió recientemente los precios o los límites. Los precios desactualizados son la razón más común por la que una tabla comparativa se vuelve engañosa.

  • Probar desde la región incorrecta infla la latencia para todos los proveedores.
  • Ignorar los multiplicadores de unidades de cómputo subestima el costo de cargas de trabajo con muchos logs.
  • Tratar una sola solicitud exitosa como prueba de soporte del método.
  • Comparar niveles gratuitos sin verificar los límites de velocidad de los niveles pagos.

Limitaciones y compensaciones

Ningún benchmark es universal. La latencia depende de la región, el emparejamiento y la hora del día. Los precios cambian. Un proveedor que es mejor para un indexador de alto volumen puede ser incorrecto para una billetera que necesita envío de transacciones de baja latencia. Documente los supuestos detrás de su lista corta para poder revisarlos cuando cambien el tráfico o los precios.

Los proveedores gestionados también difieren en transparencia operativa: el historial de incidentes, las páginas de estado y la capacidad de respuesta del soporte importan, pero son difíciles de medir en una prueba corta. Para equipos que necesitan aislamiento y rendimiento predecible, un nodo dedicado puede ser preferible a los endpoints compartidos.

Próximos pasos: de la lista corta al endpoint de producción

Una vez que tenga una lista corta, valídela con una implementación canaria que envíe un pequeño porcentaje del tráfico de producción a cada candidato. Monitoree la tasa de error, la latencia p95 y el costo por día. Luego elija un primario y un respaldo, y documente el procedimiento de conmutación por error.

Para recomendaciones concretas de endpoints y redes, use el Asistente de RPC. Para obtener contexto más amplio sobre el diseño de endpoints, consulte la guía de endpoints RPC, y revise precios de RPC y redes compatibles antes de comprometerse con un plan.

Nunca te preocupes por la infraestructura nuevamente

OnFinality elimina la carga pesada de DevOps para que puedas construir de forma más inteligente y rápida.

Comenzar