Gerencie conexões com pools de conexões

Visão geral

Neste guia, você aprenderá como o driver Rust usa pools de conexões para gerenciar conexões com o MongoDB implantação e como definir as configurações do pool de conexões em seu aplicativo.

Um pool de conexões é um cache de conexões de banco de dados abertas mantidas pelo driver. Quando seu aplicativo precisa executar uma operação, o driver verifica uma conexão do pool, usa-a para executar a operação e retorna a conexão ao pool para reutilização. A reutilização de conexões ajuda a reduzir a latência do aplicativo e evita a sobrecarga de criar novas conexões para cada operação.

Usar um pool de conexões

Para se conectar ao MongoDB, crie uma instância Client . Cada Client mantém um pool de conexões internas e lida automaticamente com a maioria dos aspectos do gerenciamento de conexões, incluindo a descoberta da topologia do servidor e o monitoramento de sua implantação.

O código a seguir mostra como criar um cliente que usa as configurações de conexão padrão:

let client_default = Client::with_uri_str(uri).await?;

Se sua carga de trabalho tiver requisitos específicos de desempenho ou simultaneidade, você poderá ajustar o pool de conexões definindo opções em ClientOptions antes de construir o Client.

Configurar pools de conexões

Cada instância Client tem um pool de conexões integrado para cada servidor em sua topologia do MongoDB . Se você não configurar a opção min_pool_size, o driver abrirá soquetes sob demanda para dar suporte a solicitações simultâneas do seu aplicativo.

Você pode configurar o comportamento do pool de conexões definindo as seguintes opções em uma instância do ClientOptions :

Opção	Descrição
`max_pool_size`	Número máximo de conexões simultâneas que cada pool mantém. Padrão: `10`
`max_connecting`	Número máximo de conexões que cada pool pode estabelecer simultaneamente. Padrão: `2`
`min_pool_size`	Número mínimo de conexões simultâneas que cada pool mantém. Padrão: `0`
`max_idle_time`	Quantidade máxima de tempo que uma conexão pode permanecer inativa no pool antes que o driver a remova e a substitua. Padrão: `0` (sem limite)

O exemplo a seguir mostra como configurar as opções do pool de conexões ao criar um cliente:

let mut client_options = ClientOptions::parse(uri).await?;
    client_options.max_pool_size = Some(20);
    client_options.max_connecting = Some(3);
    client_options.min_pool_size = Some(1);
    client_options.max_idle_time = Some(Duration::new(90, 0));
let client_custom = Client::with_options(client_options)?;

Configurar tamanho máximo do pool

A opção max_pool_size controla o número máximo de conexões que cada pool mantém para um determinado servidor. O padrão é 10. Quando o número de conexões em uso com um servidor atingir esse limite, as solicitações subsequentes que precisam de uma conexão desse pool devem aguardar até que uma conexão existente faça novamente o check-in.

Além dos soquetes usados para atender às solicitações do seu aplicativo, cada Client abre dois soquetes extras por servidor em sua topologia para monitorar o estado do servidor . Por exemplo, um conjunto de réplicas de três nós executa as seguintes ações:

O driver abre seis soquetes de monitoramento, ou dois por nó.
Se o seu aplicativo usar o max_pool_size padrão e somente ler e gravar no primário, o pool de conexões poderá manter no máximo 16 conexões totais. Esse total consiste em 10 conexões de aplicativo e 6 conexões de monitoramento.
Se o seu aplicativo usar uma preferência de leitura que também tenha como alvo os secundários, o driver também manterá pools para esses nós, e poderá haver 36 conexões totais em todos os pools e soquetes de monitoramento.

Para cargas de trabalho que exigem um alto nível de simultaneidade de um único processo, aumente max_pool_size para permitir mais conexões simultâneas. O exemplo a seguir aumenta max_pool_size para 20 conexões:

let mut client_options = ClientOptions::parse(uri).await?;
    client_options.max_pool_size = Some(20);
let client_max_pool = Client::with_options(client_options)?;

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

Os pools de conexões limitam o número de novas conexões que criam em paralelo. A opção max_connecting controla o número máximo de conexões que cada grupo pode estabelecer simultaneamente. O valor padrão é 2.

Por exemplo, quando max_connecting é definido como 2, a terceira solicitação simultânea que precisa de uma nova conexão será bem-sucedida somente após ocorrer uma das seguintes situações:

O grupo termina de criar uma conexão e o número total de conexões é menor ou igual a max_pool_size.
Uma conexão em uso é retornada ao pool.

Dessa forma, a criação de conexões com limitação de taxa incentiva o driver a reutilizar as conexões existentes em vez de abrir novas.

Para aumentar o número de conexões que podem ser criadas em paralelo, defina um valor mais alto para max_connecting, como mostrado no exemplo a seguir:

let mut client_options = ClientOptions::parse(uri).await?;
    client_options.max_connecting = Some(3);
let client_concurrent = Client::with_options(client_options)?;

Configurar tamanho mínimo do pool

A opção min_pool_size define o número mínimo de conexões que cada pool mantém para um servidor. O padrão é 0. Quando você define um min_pool_size positivo, o driver inicializa o pool com esse número de conexões e tenta manter pelo menos esse número de conexões abertas o tempo todo.

Se as conexões forem fechadas e o número total de conexões em uso e ociosas descartar abaixo de min_pool_size, o pool abrirá novas conexões até atingir o mínimo configurado. Isso pode ser útil para cargas de trabalho que precisam de um pool de conexões prontas quando o tráfego aumenta.

Para configurar um tamanho mínimo de pool, defina min_pool_size para o número desejado de conexões ao criar seu Client, conforme mostrado no exemplo a seguir :

let mut client_options = ClientOptions::parse(uri).await?;
    client_options.min_pool_size = Some(1);
let client_min_pool = Client::with_options(client_options)?;

Configurar tempo máximo de inatividade

A opção max_idle_time controla por quanto tempo uma conexão pode permanecer inativa no pool antes que o driver a remova e a substitua. O valor padrão é 0, o que significa que não há limite de tempo ocioso.

Quando uma conexão fica inativa pelo período especificado por max_idle_time, o pool descarta essa conexão e abre uma substituição conforme necessário. Isso ajuda a evitar que seu aplicativo mantenha conexões há muito tempo ociosas que podem ser fechadas por firewalls ou infraestrutura de rede.

O exemplo a seguir mostra como configurar um tempo ocioso máximo de 90 segundos:

let mut client_options = ClientOptions::parse(uri).await?;
    client_options.max_idle_time = Some(Duration::new(90, 0));
    
let client_idle = Client::with_options(client_options)?;

Fechando conexões

Para fechar proativamente as conexões gerenciadas por um Client, chame o método Client::shutdown(). Quando você chama esse método, o driver executa as seguintes ações:

Fecha todos os soquetes ociosos no pool
Fecha os soquetes que estão atualmente em uso à medida que são retornados ao pool

A chamada de Client::shutdown() não interrompe as operações em andamento. O driver só fecha os soquetes depois que as operações associadas são concluídas e as conexões são verificadas novamente no pool. O driver também fecha todas as tomadas restantes quando o processo termina.

Informações adicionais

Para saber mais sobre pools de conexões,consulte Tuting Your Connection Pool Settings no manual do MongoDB Server .

Documentação da API

Para saber mais sobre os métodos e tipos discutidos neste guia, consulte a seguinte documentação da API:

Voltar

Stable API

Considerações de desempenho