Overview
En esta guía, puedes aprender cómo el driver Rust utiliza pools de conexiones para gestionar las conexiones a una implementación de MongoDB y cómo configurar los ajustes del pool de conexiones en tu aplicación.
Un pool de conexiones es un caché de conexiones abiertas a la base de datos mantenidas por el controlador. Cuando tu aplicación necesita realizar una operación, el controlador obtiene una conexión del grupo, la utiliza para ejecutar la operación y luego la devuelve al grupo para su reutilización. La reutilización de conexiones ayuda a reducir la latencia de la aplicación y evita la sobrecarga de crear nuevas conexiones para cada operación.
Utiliza un pool de conexiones
Para conectarse a MongoDB, cree un Client instancia. Cada Client mantiene un grupo de conexiones internas y maneja automáticamente la mayoría de los aspectos de la gestión de conexiones, incluyendo el descubrimiento de la topología del servidor y la supervisión de tu implementación.
El siguiente código muestra cómo crear un cliente que utilice configuraciones de conexión por defecto:
let client_default = Client::with_uri_str(uri).await?;
Si tu carga de trabajo tiene requisitos específicos de rendimiento o concurrencia, puede ajustar el pool de conexiones configurando opciones en ClientOptions antes de construir el Client.
Configurar pool de conexiones
Cada instancia de Client tiene un pool de conexiones integrado para cada servidor en su topología de MongoDB. Si no configuras la opción min_pool_size, el driver abrirá sockets on-demand para admitir solicitudes simultáneas de tu aplicación.
Puedes configurar el comportamiento del pool de conexiones configurando las siguientes opciones en una instancia ClientOptions:
Opción | Descripción |
|---|---|
| Maximum number of concurrent connections that each pool maintains. Default: 10 |
| Maximum number of connections that each pool can establish concurrently. Default: 2 |
| Minimum number of concurrent connections that each pool maintains. Default: 0 |
| Maximum amount of time that a connection can remain idle in the pool before the driver removes and replaces it. Default: 0 (no limit) |
El siguiente ejemplo muestra cómo configurar las opciones del pool de conexiones al crear un cliente:
let mut client_options = ClientOptions::parse(uri).await?; client_options.max_pool_size = Some(20); client_options.max_connecting = Some(3); client_options.min_pool_size = Some(1); client_options.max_idle_time = Some(Duration::new(90, 0)); let client_custom = Client::with_options(client_options)?;
Configurar el tamaño máximo del pool
La opción max_pool_size controla la cantidad máxima de conexiones que cada grupo mantiene para un servidor determinado. Por defecto, es 10. Cuando el número de conexiones en uso a un servidor alcanza este límite, las solicitudes posteriores que requieran una conexión de ese grupo deben esperar hasta que una conexión existente vuelva a estar disponible.
Además de los sockets utilizados para atender las solicitudes de tu aplicación, cada Client abre dos sockets adicionales por servidor en tu topología para monitorear el estado del servidor. Por ejemplo, un set de réplicas de tres nodos ejecuta las siguientes acciones:
El driver abre seis sockets de supervisión, o dos por nodo.
Si tu aplicación utiliza el
max_pool_sizepor defecto y solo lee y escribe en el primario, el pool de conexiones puede contener como máximo 16 conexiones totales. Este total consta de 10 conexiones de aplicación y 6 conexiones de supervisión.Si tu aplicación utiliza una preferencia de lectura que también apunte a los secundarios, el driver mantiene pools para esos nodos también y se pueden tener 36 conexiones totales en todos los pools y sockets de supervisión.
Para cargas de trabajo que requieren un alto nivel de concurrencia desde un solo proceso, aumentar max_pool_size para permitir más conexiones concurrentes. El siguiente ejemplo aumenta max_pool_size a 20 conexiones:
let mut client_options = ClientOptions::parse(uri).await?; client_options.max_pool_size = Some(20); let client_max_pool = Client::with_options(client_options)?;
Configurar opciones de conexión concurrente
Los pools de conexiones limitan cuántas conexiones nuevas crean en paralelo. La opción max_connecting controla el número máximo de conexiones que cada grupo puede establecer simultáneamente. El valor por defecto es 2.
Por ejemplo, cuando max_connecting está configurado en 2, la tercera solicitud concurrente que necesita una nueva conexión sólo tendrá éxito después de que ocurra una de las siguientes situaciones:
El pool termina de crear una conexión y el número total de conexiones es menor o igual a
max_pool_size.Se devuelve una conexión en uso al pool.
La limitación de la tasa de creación de conexiones de esta manera fomenta que el controlador reutilice conexiones existentes en lugar de abrir otras nuevas.
Para aumentar el número de conexiones que se pueden crear en paralelo, establezca un valor más alto para max_connecting, como se muestra en el siguiente ejemplo:
let mut client_options = ClientOptions::parse(uri).await?; client_options.max_connecting = Some(3); let client_concurrent = Client::with_options(client_options)?;
Configurar el tamaño mínimo del grupo
La opción min_pool_size establece el número mínimo de conexiones que cada pool mantiene para un servidor. Por defecto, es 0. Cuando se establece un min_pool_size positivo, el controlador inicia el grupo con esa cantidad de conexiones e intenta mantener al menos ese número de conexiones abiertas en todo momento.
Si las conexiones están cerradas y el número total de conexiones en uso e inactivas cae por debajo de min_pool_size, el grupo abre nuevas conexiones hasta alcanzar el mínimo configurado. Esto puede ser útil para cargas de trabajo que necesitan una reserva de conexiones listas cuando el tráfico aumenta repentinamente.
Para configurar un tamaño mínimo del grupo, define min_pool_size al número de conexiones deseado cuando crees tu Client, como se muestra en el siguiente ejemplo:
let mut client_options = ClientOptions::parse(uri).await?; client_options.min_pool_size = Some(1); let client_min_pool = Client::with_options(client_options)?;
Configurar tiempo máximo de inactividad
La opción max_idle_time controla cuánto tiempo puede permanecer inactiva una conexión en el pool antes de que el driver la remueva y la reemplace. El valor por defecto es 0, lo que significa que no hay un límite de tiempo de inactividad.
Cuando una conexión ha estado inactiva por la duración especificada por max_idle_time, el pool descarta esa conexión y abre una de reemplazo según sea necesario. Esto ayuda a evitar que tu aplicación mantenga conexiones inactivas durante mucho tiempo, que podrían ser cerradas por cortafuegos o por la infraestructura de red.
El siguiente ejemplo muestra cómo configurar un tiempo máximo de inactividad de 90 segundos:
let mut client_options = ClientOptions::parse(uri).await?; client_options.max_idle_time = Some(Duration::new(90, 0)); let client_idle = Client::with_options(client_options)?;
Cierre de conexiones
Para cerrar proactivamente las conexiones gestionadas por un Client, llama al método Client::shutdown(). Cuando llames a este método, el driver realizará las siguientes acciones:
Cierra todos los sockets inactivos en la agrupación
Cierra los sockets que están en uso actualmente al ser devueltos al grupo
Llamar a Client::shutdown() no interrumpe las operaciones en curso. El controlador sólo cierra los sockets después de que se completan las operaciones asociadas y las conexiones se regresan a la pool. El controlador también cierra todos los sockets restantes cuando el proceso termina.
Información Adicional
Para obtener más información sobre los pools de conexiones, consulta Configuración de los parámetros de su pool de conexiones en el manual de MongoDB Server.
Documentación de la API
Para obtener más información sobre los métodos y tipos tratados en esta guía, consulta la siguiente documentación de la API: