Consideraciones sobre el rendimiento

Overview

En esta guía, aprenderá a optimizar el rendimiento del controlador de Rust. Para conectarse a MongoDB, debe crear un Client instancia. Tu instancia de Client gestiona automáticamente la mayoría de los aspectos de la conexión, como el descubrimiento de la topología del servidor, la supervisión de tu conexión y el mantenimiento de un pool de conexiones internos. Esta guía describe las mejores prácticas para configurar y utilizar tu instancia Client.

Esta guía incluye las siguientes secciones:

• Ciclo de vida del cliente describe las mejores prácticas para crear y gestionar una instancia Client

• agrupamiento de conexiones describe cómo funciona el pool de conexiones en el driver

• Paralelismo proporciona código de muestra para ejecutar tareas paralelas y asíncronas.

• Tiempo de ejecución describe cómo gestionar los tiempos de ejecución utilizando funcionalidades de las cajas tokio y async_std

• Información adicional proporciona enlaces a recursos y documentación de la API para los tipos y métodos mencionados en esta guía

Ciclo de vida del cliente

Se recomienda reutilizar el cliente en sesiones y operaciones. Puedes utilizar la misma instancia Client para realizar múltiples tareas, ya que el tipo Client es seguro para el uso concurrente de múltiples hilos. Crear una nueva instancia Client para cada solicitud genera un desempeño más lento.

El siguiente código crea un método que acepta un puntero a una instancia Client existente, lo que le permite realizar muchas solicitudes utilizando el mismo cliente:

// ... Create a client earlier in your code
async fn make_request(client: &Client) -> Result<(), Box<dyn Error>> {
    // Use the client to perform operations
    Ok(())
}

Pool de conexiones

Cada instancia de Client tiene un pool de conexiones integrado para cada servidor en tu topología de MongoDB. Los pools de conexiones abren sockets on-demand para admitir solicitudes concurrentes a MongoDB en tu aplicación.

La configuración por defecto para un Client funciona para la mayoría de las aplicaciones. El siguiente código muestra cómo crear un cliente con la configuración de conexión por defecto:

let client = Client::with_uri_str("<connection string>").await?;

Alternativamente, puede ajustar el pool de conexiones para que se adapte mejor a las necesidades de su aplicación y optimice el rendimiento. Para obtener más información sobre cómo personalizar la configuración de conexión, consulte las siguientes subsecciones de esta guía:

• Configurar el tamaño máximo del pool

• Configurar opciones de conexión concurrente

• Configurar tiempo máximo de inactividad

let mut client_options = ClientOptions::parse("<connection string>").await?;
client_options.max_pool_size = Some(20);
let client = Client::with_options(client_options)?;

let mut client_options = ClientOptions::parse("<connection string>").await?;
client_options.max_connecting = Some(3);
client_options.min_pool_size = Some(1);
let client = Client::with_options(client_options)?;

let mut client_options = ClientOptions::parse("<connection string>").await?;
client_options.max_idle_time = Some(Duration::new(90, 0));
let client = Client::with_options(client_options)?;

Paralelismo

Si puedes ejecutar operaciones de datos en paralelo, puedes optimizar el rendimiento ejecutando tareas asíncronas y concurrentes. El siguiente código utiliza el método spawn() del módulo tokio::task para crear tareas independientes y concurrentes con el fin de realizar operaciones de inserción:

let client = Client::with_uri_str("<connection string>").await?;
let data = doc! { "title": "1984", "author": "George Orwell" };
for i in 0..5 {
    let client_ref = client.clone();
    let data_ref = data.clone();
    task::spawn(async move {
        let collection = client_ref
            .database("items")
            .collection::<Document>(&format!("coll{}", i));
        collection.insert_one(data_ref).await
    });
}

Tiempo de ejecución

Una instancia de Client está vinculada a la instancia del entorno de ejecución tokio o async-std en la que se creó. Si utiliza una instancia Client para realizar operaciones en un entorno de ejecución diferente, podría experimentar comportamientos inesperados o errores.

Si usa el macro asistente test de la caja tokio o async_std para probar su aplicación, podría ejecutar operaciones accidentalmente en un entorno diferente al previsto. Esto se debe a que estos macros asistentes crean un nuevo entorno en tiempo de ejecución para cada prueba. Sin embargo, puedes utilizar una de las siguientes estrategias para evitar este problema:

• Adjunta el runtime a la instancia Client sin usar los macros asistentes test.

• Crea una nueva instancia de Client para cada prueba de async.

Este ejemplo sigue la primera estrategia y crea un entorno de ejecución global que se usa solo para pruebas. En el siguiente código, el método test_list_dbs() utiliza un cliente que se conecta manualmente a este entorno de ejecución para listar las bases de datos en la implementación:

use tokio::runtime::Runtime;
use once_cell::sync::Lazy;
static CLIENT_RUNTIME: Lazy<(Client, Runtime)> = Lazy::new(|| {
    let rt = Runtime::new().unwrap();
    let client = rt.block_on(async {
        Client::with_uri_str("<connection string>").await.unwrap()
    });
    (client, rt)
});
#[test]
fn test_list_dbs() -> Result<(), Box<dyn Error>> {
    let (client, rt) = &*CLIENT_RUNTIME;
    rt.block_on(async {
        client.list_database_names().await
    })?;
    Ok(())
}

Al implementar la segunda estrategia, el siguiente código crea una nueva instancia Client para cada ejecución de prueba con tokio::test, asegurando que no haya interacciones no deseadas entre los entornos de ejecución:

#[tokio::test]
async fn test_list_dbs() -> Result<(), Box<dyn Error>> {
    let client = Client::with_uri_str("<connection string>").await?;
    client.list_database_names().await?;
    Ok(())
}

Información Adicional

Para obtener más información sobre cómo conectarse a MongoDB, consulte la Guía de conexión.

Para obtener más información sobre los tiempos de ejecución disponibles para el controlador Rust, consulte la guía sobre API asincrónicas y sincrónicas.