Considerações de desempenho

Visão geral

Neste guia, você verá como otimizar o desempenho do driver do 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, monitorar sua conexão e manter um pool de conexões interno. Este guia descreve as melhores práticas para configurar e utilizar sua instância do Client .

Este guia inclui as seguintes seções:

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

• O Pool de conexões descreve como o pool de conexões funciona no driver

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

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

• Informações adicionais fornecem links para recursos e documentação da 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(())
}

Pool de Conexões

Cada instância Client tem um pool de conexões integrado para cada servidor em sua topologia do MongoDB. Os pools de conexões abrem soquetes sob demanda para oferecer suporte a solicitações simultâneas ao MongoDB em seu aplicativo.

A configuração padrão de um Client funciona para a maioria dos aplicativos. O seguinte código mostra como criar um cliente com configurações de conexão padrão:

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

Como alternativa, você pode ajustar o pool de conexões para melhor atender às necessidades do seu aplicativo e otimizar o desempenho. Para obter mais informações sobre como personalizar suas configurações de conexão, consulte as seguintes subseções deste guia:

• Configurar tamanho máximo do pool

• Configurar opções de conexão simultânea

• Configurar tempo máximo de inatividade

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

Se você puder executar operações de dados paralelas, poderá otimizar o desempenho executando tarefas simultâneas e assíncronas. O código abaixo 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 usar a macro auxiliar test da caixa tokio ou async_std para testar seu aplicativo, você poderá executar acidentalmente as operações em um tempo de execução diferente do pretendido. Isso ocorre porque essas macros auxiliares criam um novo tempo de execução para cada teste. No entanto, 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 .

Este exemplo segue a primeira estratégia e cria um tempo de execução global usado apenas para testes. No código a seguir, o método test_list_dbs() usa um cliente que se conecta manualmente a esse tempo de execução para listar os reconhecimento de data center na implantação:

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

Implementando a segunda estratégia, o código a seguir cria uma nova instância Client para cada teste executado 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 oGuia de Conexão .

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