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. Su instancia Client gestiona automáticamente la mayoría de los aspectos de la conexión, como el descubrimiento de la topología del servidor, la monitorización de la conexión y el mantenimiento de un grupo de conexiones interno. Esta guía describe las prácticas recomendadas para configurar y usar su instancia Client.

Esta guía incluye las siguientes secciones:

• El ciclo devida del Client cliente describe las mejores prácticas para crear y administrar una instancia

• Elpool de conexiones describe cómo funciona el pool de conexiones en el controlador

• Parallelism proporciona código de muestra para ejecutar tareas paralelas y asincrónicas

• Eltiempo de ejecución describe cómo administrar los tiempos de ejecución mediante el uso de las funcionalidades de las cajas 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 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 Client tiene un grupo de conexiones integrado para cada servidor de su topología de MongoDB. Los grupos de conexiones abren sockets bajo demanda para admitir solicitudes simultáneas a MongoDB en su 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?;

Como alternativa, puede ajustar el grupo 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 grupo

• Configurar opciones de conexión concurrente

• Configurar el 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 puede ejecutar operaciones de datos en paralelo, puede optimizar el rendimiento ejecutando tareas asincrónicas y simultáneas. El siguiente código utiliza el método spawn() del módulo tokio::task para crear tareas independientes y simultáneas que realizan 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 Client está vinculada a la instancia del entorno de ejecución tokio o async-std en el que la creó. Si usa una instancia Client para realizar operaciones en un entorno de ejecución diferente, podría experimentar comportamientos inesperados o fallos.

Si usa la macro auxiliar test del paquete tokio o async_std para probar su aplicación, podría ejecutar operaciones accidentalmente en un entorno de ejecución distinto al previsto. Esto se debe a que estas macros auxiliares crean un nuevo entorno de ejecución para cada prueba. Sin embargo, puede usar una de las siguientes estrategias para evitar este problema:

• Adjunte el entorno de ejecución a la instancia Client sin utilizar las macros auxiliares test.

• Crea una nueva instancia Client para cada prueba 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, lo que garantiza 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 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.