Perguntas frequentes

Por que estou recebendo erros ao conectar ao MongoDB?

Se você tiver problemas para se conectar a um sistema do MongoDB, consulte o Guia de Solução de Problemas de Conexão para obter possíveis soluções.

Como funciona o pool de conexões no driver do nó?

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

O tamanho máximo de cada conjunto de conexões é definido pela opção maxPoolSize, que padroniza para 100. Se o número de conexões em uso com um servidor atingir o valor de maxPoolSize, a próxima solicitação para esse servidor aguardará até que uma conexão fique disponível.

Além dos soquetes necessários para suportar as solicitações do seu aplicativo, cada instância do MongoClient abre mais dois soquetes por servidor na topologia do MongoDB para monitorar o estado do servidor. Por exemplo, um cliente conectado a um conjunto de réplicas de três nós abre seis soquetes de monitoramento. Se o aplicativo usar a configuração padrão para maxPoolSize e consultar apenas o nó primário (padrão), poderá haver no máximo 106 conexões totais no pool de conexões. Se o aplicativo usar umapreferência de leitura para executar query dos nós secundários, essas pools de conexões crescerão e poderá haver um total 306 conexões.

Para dar suporte a um grande número de solicitações simultâneas do MongoDB em um processo, você pode aumentar maxPoolSize.

Os pools de conexões têm taxa limitada. A opção maxConnecting determina o número de conexões que o grupo pode criar em paralelo a qualquer momento. Por exemplo, se o valor de maxConnecting for 2, a terceira solicitação que tenta fazer check-out simultâneo de uma conexão será bem-sucedida somente quando ocorrer um dos seguintes casos:

• O pool de conexões termina de criar uma conexão e há menos de maxPoolSize conexões no pool.

• Uma conexão existente é verificada novamente no pool.

• A capacidade do driver de reutilizar conexões existentes melhora devido aos limites de taxa na criação de conexões.

Você pode configurar o número mínimo de conexões simultâneas para cada servidor com a opção minPoolSize, que padroniza para 0. O condutor inicia o pool de ligações com este número de tomadas. Se os soquetes forem fechados, fazendo com que o número total de soquetes (em uso e ociosos) caia abaixo do mínimo, mais soquetes serão abertos até que o mínimo seja atingido.

Você pode definir o número máximo de milésimos de segundo em que uma conexão pode permanecer ociosa no pool definindo a opção maxIdleTimeMS. Depois que uma conexão fica inativa por maxIdleTimeMS, o pool de conexões a remove e a substitui. O padrão desta opção é 0 (sem limite).

A seguinte configuração padrão para um MongoClient funciona para a maioria dos aplicativos:

const client = new MongoClient("<connection string>");

MongoClient suporta várias solicitações simultâneas. Para cada processo, crie um cliente e reutilize-o para todas as operações de um processo. Essa prática é mais eficiente do que criar um cliente para cada solicitação.

O driver não limita o número de solicitações que podem aguardar a disponibilidade de soquetes, e é responsabilidade do aplicativo limitar o tamanho de seu pool para limitar o enfileiramento durante um pico de carga. Os pedidos aguardam a quantidade de tempo especificada na opção waitQueueTimeoutMS, que padroniza para 0 (sem limite).

Uma solicitação que aguarda mais do que o período de tempo definido por waitQueueTimeoutMS para um soquete gera um erro de conexão. Use essa opção se for mais importante limitar a duração das operações durante um pico de carga do que concluir cada operação.

Quando MongoClient.close() é chamado por qualquer solicitação, o driver fecha todos os soquetes ociosos e fecha todos os soquetes que estão em uso à medida que são retornados ao pool. A chamada MongoClient.close() fecha apenas os soquetes inativos e não encerra diretamente nenhuma operação em andamento. O driver fecha quaisquer soquetes em uso somente quando as operações associadas são concluídas. No entanto, o método MongoClient.close() fecha sessões e transações existentes, o que pode afetar indiretamente o comportamento de operações em andamento e abrir cursores.

Qual é a diferença entre "connectTimeoutMS", "socketTimeoutMS" e "maxTimeMS"?

Para especificar as configurações opcionais para seu MongoClient, declare uma ou mais configurações disponíveis no objeto options do construtor como segue:

const client = new MongoClient(uri, {
  connectTimeoutMS: <integer value>,
  socketTimeoutMS: <integer value>
});

Para ver todas as configurações disponíveis, consulte a documentação da API MongoClientOptions.

Para especificar maxTimeMS, agrupe o método maxTimeMS() com uma especificação de tempo limite para uma operação que retorna um Cursor:

const cursor = myColl.find({}).maxTimeMS(50);

O que acontece com operações em execução se o cliente desconectar?

A partir da versão 4.2 do MongoDB Server , o servidor encerra as operações em execução, como agregações e operações de localização, se o cliente se desconectar. Para ver uma lista completa de operações afetadas por esse comportamento, consulte as notas de versão do Servidor MongoDB versão 4.2 no manual do Servidor MongoDB.

Outras operações, como operações de gravação, continuam a ser executadas no MongoDB Server mesmo se o cliente se desconectar. Esse comportamento pode causar inconsistências de dados se seu aplicativo tenta novamente a operação depois que o cliente se desconecta.

Como posso confirmar se o driver fechou soquetes inutilizáveis?

Se você enfrentar um comportamento de rede inesperado ou se um processo do MongoDB falhar com um erro, talvez você não receba a confirmação de que o driver fechou corretamente o soquete correspondente.

Para garantir que o driver feche corretamente o soquete nesses casos, defina a opção socketTimeoutMS. Quando um processo MongoDB expirar, o driver fechará o soquete. Recomendamos que você selecione um valor de socketTimeoutMS que seja duas a três vezes maior que a duração esperada da operação mais lenta executada pelo seu aplicativo.

Como posso evitar que os soquetes expirem antes de se tornarem ativos?

Ter um grande pool de conexões nem sempre reduz as solicitações de reconexão. Considere o seguinte exemplo:

Um aplicativo tem um tamanho de pool de conexões de 5 soquetes e tem a opção socketTimeoutMS definida como 5000 milésimos de segundo. As operações ocorrem, em média, a cada 3000 milésimos de segundo, e as solicitações de reconexão são frequentes. Cada soquete atinge o tempo limite após 5000 milésimos de segundo, o que significa que todos os soquetes devem fazer algo durante esses 5000 milésimos de segundo para evitar o fechamento.

Uma mensagem a cada 3.000 milésimos de segundo não é suficiente para manter os soquetes ativos, de modo que vários soquetes atingirão o tempo limite após 5.000 milésimos de segundo. Para evitar tempos limite excessivos de soquete, reduza o número de conexões que o driver pode manter no pool de conexões especificando a opção maxPoolSize.

Para especificar a configuração opcional do maxPoolSize para seu MongoClient, declare no objeto options do construtor como segue:

const client = new MongoClient(uri, {
  maxPoolSize: <integer value>,
});

O que significa um valor de "0" para "connectTimeoutMS" e "socketTimeoutMS"?

Se você definir o valor de connectTimeoutMS ou socketTimeoutMS como 0, seu aplicativo usará o valor de tempo limite de soquete padrão do sistema operacional.

Como posso evitar que operações de longa duração tornem o servidor lento?

Você pode evitar que operações de longa duração reduzam a velocidade do servidor especificando um valor de tempo limite. Você pode encadear o método maxTimeMS() a uma operação que retorna Cursor para definir um tempo limite para uma ação específica.

O exemplo a seguir mostra como você pode encadear o método maxTimeMS() a uma operação que retorna Cursor:

// Execute a find command
await collection
  .find({ $where: "sleep(100) || true" })
  .maxTimeMS(50);

O que a opção KeepAlive faz?

A keepAlive opção de conexão especifica se deve ativar o protocolo de controle de transmissão (TCP) keepalives em um soquete TCP. Se você habilitar o keepalives, o driver verificará se a conexão está ativa enviando pings periódicos para seu sistema do MongoDB. Esta funcionalidade só funciona se o seu sistema operativo suportar a opção de soquete SO_KEEPALIVE .

A opção keepAliveInitialDelay especifica o número de milésimos de segundo que o condutor espera antes de iniciar uma manutenção.

O lançamento da versão 5.3 do driver desativou essas opções. A partir da versão 6.0 do driver, a opção keepAlive é definida permanentemente como true e a keepAliveInitialDelay é definida como 300.000 milissegundos (300 segundos).

O que posso fazer se eu estiver enfrentando um comportamento inesperado na rede?

Você pode experimentar um comportamento inesperado na rede se o firewall entre seu aplicativo e o MongoDB estiver configurado incorretamente. Esses firewalls podem ser excessivamente agressivos na remoção de conexões, o que pode causar erros inesperados.

Confirme se o firewall exibe o seguinte comportamento:

• O firewall envia um pacote FIN ao fechar uma conexão, informando ao driver que o soquete está fechado.

• O firewall permite a manutenção de atividade de mensagens.

Como posso evitar que uma operação lenta atrase outras operações?

Quando você utiliza a mesma instância do MongoClient para executar múltiplas operações MongoDB simultaneamente, uma operação lenta pode causar atrasos para outras operações. Operações lentas mantêm a conexão com o MongoDB ocupada, o que pode fazer com que outras operações esperem até que uma conexão adicional seja disponibilizada.

Se você suspeitar que as operações lentas do MongoDB estão causando atrasos, poderá verificar o desempenho de todas as operações em andamento usando os seguintes métodos:

• Habilite o criador de perfil de banco de dados em seu sistema. Para saber mais, consulte Database Profiler no manual do servidor MongoDB.

• Execute o comando db.currentOp() do MongoDB Shell. Para saber mais, consulte a documentação db.currentOp() no manual do servidor.

• Habilite o monitoramento do pool de conexões. Para saber mais, consulte Monitoramento de pool de conexão.

Depois de determinar quais operações estão causando atrasos, tente melhorar o desempenho dessas operações. Leia o Guia de melhores práticas para o desempenho do MongoDB para ver possíveis soluções.

Se você implementar práticas recomendadas de desempenho, mas ainda enfrentar atrasos, poderá modificar suas configurações de conexão para aumentar o tamanho do pool de conexões. Um pool de conexões é o grupo de conexões ao servidor que o driver mantém a qualquer momento.

Para especificar o tamanho máximo de um pool de conexões, você pode definir a opção maxPoolSize nas opções de conexão da instância MongoClient. O valor padrão de maxPoolSize é 100. Se o número de conexões em uso com um servidor atingir maxPoolSize, a próxima operação enviada ao servidor será pausada até que uma conexão com o driver fique disponível. O seguinte código define maxPoolSize como 150 ao criar um novo MongoClient:

const client = new MongoClient(uri, { maxPoolSize: 150 });

Como posso garantir que minha cadeia de conexão seja válida para um conjunto de réplicas?

A string de conexão passada para o driver deve usar nomes de host exatos para os servidores, conforme definido na configuração do conjunto de réplicas. Dadas as seguintes definições de configuração para seu conjunto de réplicas, para que a descoberta e o failover do conjunto de réplicas funcionem, o driver deve ter acesso a server1, server2 e server3.

{
  "_id": "testSet",
  "version": 1,
  "protocolVersion": 1,
  "members": [
    {
      "_id": 1,
      "host": "server1:31000"
    },
    {
      "_id": 2,
      "host": "server2:31001"
    },
    {
      "_id": 3,
      "host": "server3:31002"
    }
  ]
}

Se você não conseguir encontrar a resposta para sua pergunta aqui, experimente nossos fóruns e canais de suporte listados na seção Problemas e Ajuda.