Overview
En esta guía, aprenderá cómo el controlador de Rust utiliza grupos de conexiones para gestionar las conexiones a una implementación de MongoDB y cómo configurar los ajustes del grupo de conexiones en su aplicación.
Un grupo de conexiones es una caché de conexiones de base de datos abiertas que mantiene el controlador. Cuando la aplicación necesita realizar una operación, el controlador obtiene una conexión del grupo, la utiliza para ejecutar la operación y la devuelve al grupo para su reutilización. Reutilizar las conexiones ayuda a reducir la latencia de la aplicación y evita la sobrecarga que supone crear nuevas conexiones para cada operación.
Utilice un grupo de conexiones
Para conectarse a MongoDB, debe crear un Client instancia. Cada Client mantiene un grupo de conexiones interno y maneja automáticamente la mayoría de los aspectos de la administración de conexiones, incluido el descubrimiento de la topología del servidor y la supervisión de su implementación.
El siguiente código muestra cómo crear un cliente que utiliza la configuración de conexión predeterminada:
let client_default = Client::with_uri_str(uri).await?;
Si su carga de trabajo tiene requisitos específicos de rendimiento o concurrencia, puede ajustar el grupo de conexiones configurando opciones en ClientOptions antes de construir el Client.
Configurar pool de conexiones
Cada instancia Client tiene un grupo de conexiones integrado para cada servidor en su topología de MongoDB. Si no configura la opción min_pool_size, el controlador abre sockets bajo demanda para admitir solicitudes concurrentes de su aplicación.
Puede configurar el comportamiento del grupo de conexiones estableciendo 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 grupo 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 el número máximo de conexiones que cada grupo mantiene para un servidor determinado. Su valor predeterminado es 10. Cuando el número de conexiones en uso a un servidor alcanza este límite, las solicitudes posteriores que necesiten una conexión de ese grupo deberán esperar hasta que una conexión existente vuelva a estar disponible.
Además de los sockets utilizados para atender las solicitudes de su aplicación, cada Client abre dos sockets adicionales por servidor en su topología para monitorear el estado del servidor. Por ejemplo, un conjunto de réplicas de tres nodos realiza las siguientes acciones:
El controlador abre seis sockets de monitorización, o dos por nodo.
Si su aplicación utiliza el
max_pool_sizevalor predeterminado y solo lee y escribe en el servidor principal, el grupo de conexiones puede contener como 16 máximo conexiones en total. Este total se compone de 10 conexiones de la aplicación y 6 conexiones de monitorización.Si su aplicación utiliza una preferencia de lectura que también apunta a los secundarios, el controlador mantiene grupos para esos nodos también, y puede haber 36 conexiones totales en todos los grupos y sockets de monitoreo.
Para cargas de trabajo que requieren un alto nivel de concurrencia desde un solo proceso, aumente 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 grupos de conexiones limitan la cantidad de conexiones nuevas que 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 predeterminado es 2.
Por ejemplo, cuando max_connecting se establece en 2, la tercera solicitud concurrente que necesita una nueva conexión solo se realiza correctamente 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.Una conexión en uso se devuelve al grupo.
Limitar la velocidad de creación de conexiones de esta manera anima al conductor a reutilizar las 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 tamaño mínimo de grupo
La opción min_pool_size establece el número mínimo de conexiones que cada grupo mantiene para un servidor. Su valor predeterminado es 0. Al establecer un valor positivo min_pool_size, el controlador inicializa el grupo con esa cantidad de conexiones e intenta mantener abiertas al menos esa cantidad de conexiones en todo momento.
Si se cierran las conexiones y el número total de conexiones en uso e inactivas cae por debajo de min_pool_size cero, el grupo abre nuevas conexiones hasta alcanzar el mínimo configurado. Esto puede resultar útil para cargas de trabajo que requieren un grupo de conexiones disponibles cuando se producen picos de tráfico.
Para configurar un tamaño mínimo de grupo, establezca min_pool_size en el número de conexiones deseado cuando cree su 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 grupo antes de que el controlador la elimine y la reemplace. El valor predeterminado es 0, lo que significa que no hay límite de tiempo de inactividad.
Cuando una conexión permanece inactiva durante el tiempo especificado por max_idle_time, el grupo de conexiones la descarta y abre una nueva según sea necesario. Esto evita que la aplicación mantenga conexiones inactivas prolongadas que podrían ser cerradas por cortafuegos o 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 de forma proactiva las conexiones gestionadas por un Client, llame al método Client::shutdown(). Al llamar a este método, el controlador realiza las siguientes acciones:
Cierra todos los sockets inactivos en el grupo.
Cierra los enchufes que están en uso a medida que se devuelven al grupo.
La llamada a Client::shutdown() no interrumpe las operaciones en curso. El controlador solo cierra los sockets una vez que las operaciones asociadas se completan y las conexiones se devuelven al grupo. El controlador también cierra los sockets restantes cuando finaliza el proceso.
Información Adicional
Para obtener más información sobre los grupos de conexiones, consulte Cómo ajustar la configuración del grupo de conexiones en el manual del servidor MongoDB.
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: