Considerações de desempenho

Visão geral

Neste guia, você verá como otimizar o desempenho do driver Rust. Para se conectar ao MongoDB , você deve criar uma instância do Client. Sua instância do Client lida automaticamente com a maioria dos aspectos da conexão, como descobrir a topologia do servidor e monitorar sua conexão. Este guia descreve as melhores práticas para configurar e utilizar a sua instância do Client.

Este guia inclui as seguintes seções:

• OCiclo de vida do cliente descreve as melhores práticas para criar e gerenciar uma Client instância .

• Paralelismo fornece código de amostra para executar tarefas paralelas e assíncronas.

• Otempo de execução descreve como gerenciar tempos de execução usando as funcionalidades das caixas tokio async_std e.

• Informações adicionais fornecem links para recursos e documentação de API para os tipos e métodos mencionados neste guia.

Ciclo de vida do cliente

Recomendamos que você reutilize seu cliente entre sessões e operações. Você pode utilizar a mesma instância do Client para executar múltiplas tarefas, pois o tipo do Client é seguro para uso simultâneo por vários threads. Criar uma nova instância do Client para cada solicitação resulta em desempenho mais lento.

O seguinte código cria um método que aceita um ponteiro para uma instância do Client existente, que permite a você executar muitas solicitações utilizando o mesmo 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

Você pode otimizar o desempenho executando tarefas simultâneas assíncronas para executar operações de dados paralelas. O exemplo a seguir usa o método spawn() do módulo tokio::task para criar tarefas simultâneas separadas para executar operações de inserção:

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
    });
}

Tempo de execução

Uma instância Client está vinculada à instância do tempo de execução tokio ou async-std no qual você a criou. Se você utilizar uma instância do Client para executar operações em um tempo de execução diferente, você poderá enfrentar comportamentos inesperados ou falhas.

Se você usar a macro assistente test da crate tokio ou async_std para testar seu aplicação, poderá executar operações de forma não intencional em um tempo de execução diferente do que a instância Client espera. Isso ocorre porque essas macros assistente criam um novo tempo de execução para cada teste. Você pode usar uma das seguintes estratégias para evitar esse problema:

• Anexe o tempo de execução à instância do Client sem utilizar as macros auxiliares do test .

• Crie uma nova instância Client para cada teste async .

O exemplo a seguir anexa um tempo de execução global a uma instância do Client para teste. O método test_list_dbs() utiliza um cliente que se conecta a este tempo de execução para listar bancos de dados no sistema:

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(())
}

O exemplo a seguir cria uma nova instância Client para cada execução de teste com tokio::test, garantindo que não haja interações não intencionais entre os tempos de execução:

#[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(())
}

Informações adicionais

Para saber mais sobre como se conectar ao MongoDB, consulte o guia Como criar um cliente MongoDB .

Para saber mais sobre os tempos de execução disponíveis para o driver Rust, consulte o guia de APIs assíncronas e síncronas.

Para saber como otimizar o desempenho usando pools de conexões, consulte o guia Gerenciar conexões com pools de conexões.