Tecnología

¿Cuántas conexiones poner en el pool de base de datos?🌎

Actualizado junio de 2026
Calculadora Gratis · Privada
Revisado por: (política editorial ) · Última revisión:

La fórmula clásica de HikariCP y los benchmarks de PostgreSQL demuestran que más conexiones no equivalen a más throughput. Con 8 cores, 10 conexiones dan más TPS que 50. La regla práctica es cores × 2 para OLTP estándar. Esta calculadora toma los cores del servidor de DB y el perfil de carga para devolverte el rango mínimo–máximo recomendado, y avisa cuándo necesitás un pooler externo (PgBouncer, ProxySQL, RDS Proxy).

Última revisión: 03 de junio de 2026 Revisado por Fuente: HikariCP — About Pool Sizing (Brett Wooldridge), PostgreSQL wiki — Number Of Database Connections, AWS — RDS Proxy documentation 100% privado

Cuándo usar esta calculadora

  • Configurás HikariCP/pg-pool en una API Node.js o Java y no sabés qué poner en maxPoolSize.
  • Tu RDS t3.large (2 vCPU) está al 100% de conexiones y la app devuelve 'too many clients already'.
  • Estás migrando de Rails ActiveRecord pool=25 a Postgres y querés saber si PgBouncer te salva.
  • Dimensionar el pool inicial en una arquitectura serverless (Lambda/Cloud Run) que puede escalar a miles de instancias.

Ejemplo real: API Java con RDS db.m5.xlarge (4 vCPU)

  1. Servidor: 4 cores, carga media (ecommerce CRUD)
  2. Pool mínimo = max(2, floor(8/4)) = 2
  3. Pool máximo = 4 × 2 = 8 conexiones
  4. Con 3 instancias de la app: 3 × 8 = 24 conexiones totales — por debajo de cores × 4 = 16, OK sin pooler
Resultado: Pool recomendado: 2–8 conexiones por instancia de app

Cómo funciona

3 min de lectura

Cómo se calcula

Fórmula base (HikariCP, PgTune, PostgreSQL wiki):

Pool = cores × factor_carga

  • Carga baja (API interna, dashboard): factor = 1 → pool mínimo sugerido

  • Carga media (ecommerce, CRUD): factor = 2 → la regla clásica 'cores × 2'

  • Carga alta (high-write OLTP): factor = 3 → requiere monitoreo activo y probablemente pooler externo
  • Esta calculadora devuelve un rango: mínimo = pool_max / 4 (arranque en frío), máximo = el valor calculado.

    Tabla de referencia por tamaño de servidor

    InstanciaCoresPool bajaPool mediaPool alta¿Necesita pooler?
    RDS db.t3.micro2246No (monitorear)
    RDS db.t3.medium2246No
    RDS db.m5.large2246No
    RDS db.m5.xlarge44812No
    RDS db.m5.2xlarge881624Posiblemente
    RDS db.m5.4xlarge16163248Sí (PgBouncer)
    RDS db.r5.8xlarge32326496Sí (PgBouncer)
    Aurora Serverless v2variableautoautoRDS Proxy

    > Regla práctica: si el total de conexiones de todas tus instancias de app supera cores × 4, poné PgBouncer en modo transaction.

    Benchmarks: por qué menos conexiones dan más TPS

    El benchmark publicado por Brett Wooldridge (autor de HikariCP) mostró que en un servidor de 16 cores, la configuración óptima era 16–17 conexiones, no 50 o 100. Con 50 conexiones el throughput bajaba un 20–30% por:

    1. Context switching del OS: cada proceso Postgres consume CPU para cambios de contexto
    2. Contención en shared_buffers: múltiples procesos peleando por el mismo caché
    3. Lock contention en WAL: más conexiones activas = más esperas en el Write-Ahead Log

    Casos reales

  • Lambda + PostgreSQL sin proxy: cada invocación abre conexión → saturas max_connections (100 por defecto). Solución: RDS Proxy o Aurora Serverless con pool proxy.

  • Rails Puma, 10 workers × 5 threads, DB 8 cores: 50 conexiones → 3× el óptimo. Agregar PgBouncer transaction mode.

  • Node.js, 4 instancias, DB 4 cores: pool por instancia = 2 (total 8) — dentro de cores × 2.

  • Java Spring Boot, HikariCP default = 10: suele ser excesivo para una DB pequeña. Ajustar a cores × 2 del servidor.
  • Errores comunes

  • Más conexiones = más throughput: falso. El ORM te deja poner 200 pero eso no acelera la DB.

  • No configurar timeouts: connectTimeout (5-10s), socketTimeout (30-60s), idleTimeout (10 min), maxLifetime (30 min).

  • Olvidar idle_in_transaction_session_timeout en Postgres: transacciones huérfanas bloquean locks eternamente.

  • No monitorear pg_stat_activity: es la fuente de verdad para ver qué conexiones están activas/idle/bloqueadas.
  • Calculadoras relacionadas

  • Tiempo de descarga de archivo

  • Complejidad algorítmica Big O

  • Conversión bytes KB MB GB TB
  • Preguntas frecuentes

    ¿Cuál es la fórmula óptima de pool para PostgreSQL?

    Según HikariCP y los tests de PostgreSQL wiki: pool = cores × 2 para carga estándar OLTP. Con SSD, el factor de discos es 1, por lo que la regla práctica queda en cores × 2. Un servidor de 8 cores debería tener pool de ~16 conexiones por aplicación, no 100.

    ¿Por qué más conexiones no dan más throughput?

    Postgres usa un proceso OS por conexión. Con 8 cores, 50 conexiones simultáneas causan context switching costoso, contención en shared_buffers y esperas en WAL. Los benchmarks muestran que 10–16 conexiones dan más TPS que 50 en un servidor de 8 cores.

    ¿Cuándo necesito PgBouncer o ProxySQL?

    Cuando el total de conexiones activas supera cores × 4, o cuando tenés workloads serverless (Lambda, Cloud Run) que pueden abrir cientos de conexiones. PgBouncer en modo transaction reduce 10–100× las conexiones reales a la DB.

    ¿Qué timeouts debo configurar en el pool?

    connectTimeout: 5–10 s (no bloquear en arranque). socketTimeout/queryTimeout: 30–60 s. idleTimeout: 10 min (libera slots inútiles). maxLifetime: 30 min (fuerza reciclado para evitar leaks de conexión).

    ¿RDS Proxy o PgBouncer? ¿Cuál conviene?

    RDS Proxy es managed por AWS, ideal para Lambda + Aurora, con costo por hora. PgBouncer es self-hosted, gratis, más control. Para arquitecturas serverless en AWS, RDS Proxy. Para ECS/EKS con control sobre la infra, PgBouncer en modo transaction.

    ¿Qué diferencia hay entre pool en Node.js y Java?

    Node.js es single-threaded: un pool de 5–15 conexiones por proceso es habitual. Java con 200 threads de Tomcat podría abrir 200 conexiones (pésimo), por eso HikariCP recomienda 10–20 independientemente del thread count. La regla es dimensionar por cores de DB, no por threads de app.

    ¿Cuántas conexiones tolera Postgres antes de degradarse?

    max_connections default = 100, cada una consume ~10 MB de RAM. Subir a 500 es posible pero a partir de 200–300 simultáneas el rendimiento cae notablemente sin PgBouncer. Arriba de 500 clientes, PgBouncer transaction mode es casi obligatorio.

    ¿Sirve configurar pool mínimo mayor a cero?

    Sí: minIdle > 0 evita la latencia de abrir conexión al primer request (5–50 ms de TLS+auth). Para APIs latency-sensitive, minIdle = 20–30% del max. Para cargas muy irregulares o funciones serverless, minIdle = 0 y dejás que el pool crezca on-demand.

    ¿La fórmula aplica también a MySQL y SQL Server?

    MySQL InnoDB tolera mejor que Postgres las conexiones altas (usa threads, no procesos), pero la regla cores × 2 sigue siendo un buen punto de partida. SQL Server tiene pooling interno y escala hasta ~1000 conexiones activas antes de degradarse. La calculadora sirve como referencia para cualquier RDBMS.

    Fuentes y referencias

    También te puede interesar

    Metodología y confianza

    Editorial

    Contenido revisado por el equipo editorial de Hacé Cuentas, con apego a nuestra política editorial y metodología de cálculo.

    Actualización

    Última revisión: 03 de junio de 2026. Los parámetros fiscales, legales y datos se verifican periódicamente con las fuentes citadas.

    Privacidad

    Los cálculos corren 100% en tu navegador. No guardamos ni transmitimos tus datos. Leé nuestra política de privacidad.

    Limitaciones

    Resultados orientativos. Para decisiones financieras, médicas o legales críticas, consultá con un profesional.