Consideraciones sobre el rendimiento

Overview

En esta guía, aprenderás a optimizar el rendimiento del driver de Rust. Para conectarse a MongoDB, debe crear un Client instancia. Tu instancia Client gestiona automáticamente la mayoría de los aspectos de la conexión, como el descubrimiento de la topología del servidor y la supervisión de tu conexión. 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 de Client.

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

• Runtime describe cómo gestionar los runtimes utilizando las funcionalidades de los crates de tokio y async_std.

• Información Adicional proporciona enlaces a recursos y documentación de 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 existente de Client, lo que 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(())
}

Paralelismo

Puedes optimizar el rendimiento ejecutando tareas asíncronas y concurrentes para realizar operaciones de datos en paralelo. El siguiente ejemplo utiliza el método spawn() del módulo tokio::task para crear tareas separadas y concurrentes para 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 utilizas el macro asistente test de la caja tokio o async_std para probar tu aplicación, podrías ejecutar operaciones sin querer en un entorno distinto al que espera la instancia Client. Esto ocurre porque estos macros asistentes crean un nuevo tiempo de ejecución para cada prueba. Puedes usar 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.

El siguiente ejemplo adjunta un runtime global a una instancia de Client para realizar pruebas. El método test_list_dbs() utiliza un cliente que se conecta 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(())
}

El siguiente ejemplo crea una nueva instancia de Client para cada ejecución de prueba con tokio::test, garantizando que no haya interacciones no deseadas entre los tiempos 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 Crear un cliente MongoDB.

Para obtener más información sobre los entornos de ejecución disponibles para el controlador Rust, consulte la guía de APIs asíncronas y síncronas.

Para aprender a optimizar el rendimiento mediante el uso de pool de conexiones, consulte la guía Gestionar conexiones con pool de conexiones.