Visão geral
Neste guia, você aprenderá como o driver Rust usa pools de conexões para gerenciar conexões com o MongoDB deployment e como definir as configurações do pool de conexões em seu aplicação.
Um pool de conexões é um cache de conexões de banco de dados abertas mantidas pelo driver. Quando seu aplicação 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 aplicação 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 do 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 seu volume 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 aplicação.
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 |
|---|---|
| Maximum number of concurrent connections that each pool maintains. Default: 10 |
| Maximum number of connections that each pool can establish concurrently. Default: 2 |
| Minimum number of concurrent connections that each pool maintains. Default: 0 |
| Maximum amount of time that a connection can remain idle in the pool before the driver removes and replaces it. Default: 0 (no limit) |
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 aplicação usar o padrão
max_pool_sizee somente ler e gravar no primário, o pool de 16 conexões poderá manter no máximo conexões totais. Esse total consiste em 10 conexões de aplicação e 6 conexões de monitoramento.Se o seu aplicação 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 volumes 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 cair abaixo de min_pool_size, o pool abrirá novas conexões até atingir o mínimo configurado. Isso pode ser útil para volumes 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 aplicação 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 condutor também fecha todas as tomadas restantes quando o processo termina.
Informações adicionais
Para saber mais sobre pools de conexões, consulte Ajustando as configurações do pool de conexões 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: