Como Monitorar o Desempenho do MongoDB

O autor selecionou o Fundo de Internet Aberta/Liberdade de Expressão para receber uma doação como parte do programa Escreva para Doações.

Introdução

A monitorização é uma parte fundamental da administração de bases de dados, pois permite compreender o desempenho e o estado geral da sua base de dados. Ao monitorizar o desempenho da sua base de dados, pode ter uma melhor noção da sua capacidade atual, observar como a sua carga de trabalho muda ao longo do tempo e planear antecipadamente para dimensionar a base de dados assim que começar a aproximar-se dos seus limites. Também pode ajudar a identificar problemas de hardware subjacentes ou comportamentos anormais, como um pico inesperado no uso da base de dados. Por último, a monitorização pode ajudar a diagnosticar problemas com aplicações que utilizam a base de dados, como consultas de aplicações que causam gargalos.

O MongoDB vem instalado com uma variedade de ferramentas e utilitários que pode utilizar para observar o desempenho da sua base de dados. Neste tutorial, aprenderá como monitorizar métricas de base de dados sob demanda utilizando comandos e ferramentas integradas. Também ficará familiarizado com o perfilador de base de dados do MongoDB, que pode ajudar a detetar consultas mal otimizadas.

Pré-requisitos

Para seguir este tutorial, você precisará de:

• A server with a regular, non-root user with sudo privileges and a firewall configured with UFW. This tutorial was validated using a server running Ubuntu 20.04, and you can prepare your server by following this initial server setup tutorial for Ubuntu 20.04.
• O MongoDB instalado no seu servidor. Para configurar isso, siga nosso tutorial sobre Como Instalar o MongoDB no Ubuntu 20.04.
• A instância do MongoDB do seu servidor precisa estar segura, ativando a autenticação e criando um usuário administrativo. Para proteger o MongoDB dessa forma, siga nosso tutorial sobre Como Proteger o MongoDB no Ubuntu 20.04.
• Familiaridade com a consulta de coleções do MongoDB e filtragem de resultados. Para aprender como usar consultas do MongoDB, siga nosso guia sobre Como Criar Consultas no MongoDB.

Passo 1 — Preparando os Dados de Teste

Para explicar como você pode monitorar o desempenho do MongoDB, esta etapa descreve como abrir o shell do MongoDB para se conectar à sua instância do MongoDB instalada localmente e criar uma coleção de exemplo dentro dela.

Para criar a coleção de amostra usada neste guia, conecte-se ao shell do MongoDB como seu usuário administrativo. Este tutorial segue as convenções do tutorial de segurança do MongoDB pré-requisito e assume que o nome deste usuário administrativo é AdminSammy e seu banco de dados de autenticação é admin. Certifique-se de alterar esses detalhes no comando a seguir para refletir sua própria configuração, se diferente:

mongo -u AdminSammy -p --authenticationDatabase admin

Insira a senha definida durante a instalação para obter acesso ao shell. Após fornecer a senha, você verá o sinal de prompt >.

use database_name

O monitoramento do banco de dados não é muito prático ou útil ao trabalhar com um conjunto de dados pequeno, já que o sistema do banco de dados só precisará escanear alguns registros para qualquer consulta dada. Para ilustrar os recursos de monitoramento de desempenho do MongoDB, você precisará de um banco de dados com dados suficientes para que o MongoDB leve um tempo significativo para executar consultas.

Para esse fim, os exemplos ao longo deste guia referem-se a uma coleção de amostra chamada contas contendo um grande número de documentos. Cada documento representa uma conta bancária individual com um saldo de conta gerado aleatoriamente. Cada documento na coleção terá uma estrutura como esta:

{
    "number": "1000-987321",
    "currency": "USD",
    "balance": 431233431
}

Este documento de exemplo contém as seguintes informações:

• número: Este campo representa o número da conta para a conta fornecida. Nesta coleção, cada número de conta terá um prefixo de 1000- seguido de um identificador numérico crescente.
• moeda: Este campo indica em que tipo de moeda o saldo de cada conta é armazenado. O valor de moeda de cada conta será ou USD ou EUR.
• saldo: Isso mostra o saldo para cada conta bancária fornecida. Neste banco de dados de amostra, o campo saldo de cada documento terá um valor gerado aleatoriamente.

Em vez de inserir manualmente um grande número de documentos, você pode executar o seguinte código JavaScript para criar simultaneamente uma coleção chamada contas e inserir um milhão desses documentos nela:

for (let i = 1; i <= 1000000; ++i) {
    db.accounts.insertOne({
        "number": "1000-" + i,
        "currency": i > 500000 ? "USD" : "EUR",
        "balance": Math.random() * 100000
    })
}

Este código executa um loop for que roda um milhão de vezes seguidas. Cada vez que o loop itera, ele executa um método insertOne() na coleção de contas para inserir um novo documento. Em cada iteração, o método atribui um valor ao campo number composto pelo prefixo 1000- com o valor mantido no valor i para essa iteração. Isso significa que na primeira vez que este loop itera, o valor do campo number será definido como 1000-1; na última vez que itera, será definido como 1000-1000000.

A moeda é sempre representada como USD para contas com números maiores que 500000 e como EUR para contas com números menores que isso. O campo de saldo usa a função Math.random() para gerar um número aleatório entre 0 e 1, e então multiplica o número aleatório por 100000 para fornecer valores maiores.

A saída informará sobre o sucesso e retornará o ObjectId do último documento inserido:

Output
{
        "acknowledged" : true,
        "insertedId" : ObjectId("61a38a4beedf737ac8e54e82")
}

Você pode verificar se os documentos foram inseridos corretamente executando o método count() sem argumentos, que recuperará a contagem de documentos na coleção:

db.accounts.count()

Output
1000000

Nesta etapa, você criou com sucesso a lista de documentos de exemplo que servirão como dados de teste usados neste guia para explicar as ferramentas que o MongoDB fornece para monitoramento de desempenho. Na próxima etapa, você aprenderá como verificar as estatísticas básicas de uso do servidor.

Passo 2 — Verificação das Estatísticas de Uso do Servidor

O MongoDB acompanha automaticamente uma série de estatísticas de desempenho úteis, e verificar regularmente essas estatísticas é uma maneira fundamental de monitorar seu banco de dados. Esteja ciente de que essas estatísticas não oferecerão insights em tempo real sobre o que está acontecendo com seu banco de dados, mas podem ser úteis para determinar como o banco de dados está se comportando e se há problemas iminentes.

use admin

Output
switched to db admin

db.grantRolesToUser(
"AdminSammy",
[
"clusterMonitor",
{ role : "dbAdmin", db : "test" }
]
)

db.createUser(
{
user: "MonitorSammy",
pwd: passwordPrompt(),
roles: [ { role : "dbAdmin", db : "test" }, "clusterMonitor", "readWriteAnyDatabase" ]
}
)

use test

Output
switched to db test

Comece verificando as estatísticas gerais do banco de dados executando o método stats():

db.stats(1024*1024)

O argumento deste método (1024*1024) é o fator de escala e informa ao MongoDB para retornar informações de armazenamento em megabytes. Se você omitir isso, os valores serão apresentados em bytes.

O método stats() retorna uma saída curta e concisa com algumas estatísticas importantes relacionadas ao banco de dados atual:

Output
{
        "db" : "test",
        "collections" : 3,
        "views" : 0,
        "objects" : 1000017,
        "avgObjSize" : 80.8896048767171,
        "dataSize" : 77.14365005493164,
        "storageSize" : 24.109375,
        "indexes" : 4,
        "indexSize" : 9.9765625,
        "totalSize" : 34.0859375,
        "scaleFactor" : 1048576,
        "fsUsedSize" : 4238.12109375,
        "fsTotalSize" : 24635.703125,
        "ok" : 1
}

Esta saída fornece uma visão geral dos dados que esta instância do MongoDB está armazenando. As seguintes chaves retornadas nesta saída podem ser particularmente úteis:

• A chave objects mostra o número total de documentos no banco de dados. Você pode usar isso para avaliar o tamanho do banco de dados e, quando observado ao longo do tempo, seu crescimento.
• avgObjectSize mostra o tamanho médio desses documentos, fornecendo insights sobre se o banco de dados está operando com documentos grandes e complexos ou pequenos. Este valor é sempre mostrado em bytes, independentemente de você especificar um fator de escala.
• As chaves collections e indexes indicam quantas coleções e índices estão atualmente definidos no banco de dados.
• A chave totalSize indica quanto armazenamento o banco de dados ocupa no disco.

Essas informações retornadas pelo método stats() podem ajudar a dar uma ideia de quantos dados estão atualmente armazenados no seu banco de dados, mas não fornecem insights sobre seu desempenho ou problemas existentes. Para isso, o método serverStatus(), muito mais detalhado, vem a calhar:

db.serverStatus()

A saída deste método é extensa e fornece uma grande quantidade de informações sobre o uso do servidor:

Output
{
        "host" : "ubuntu-mongo-rs",
        "version" : "4.4.6",
        "process" : "mongod",
        "pid" : NumberLong(658997),
        "uptime" : 976,
        . . .
        "ok" : 1
}

Embora todas essas informações possam ser potencialmente úteis, este guia se concentrará em três seções em particular. Primeiro, encontre a seção connections desta saída:

Output
        . . .
        "connections" : {
                "current" : 4,
                "available" : 51196,
                "totalCreated" : 4,
                "active" : 2,
                "exhaustIsMaster" : 1,
                "exhaustHello" : 0,
                "awaitingTopologyChanges" : 1
        },
        . . .

Cada servidor de banco de dados pode suportar apenas um certo número de conexões simultâneas. A chave current mostra o número de clientes atualmente conectados ao banco de dados, enquanto available é o número de conexões não utilizadas restantes que o banco de dados tem disponíveis. O valor totalCreated mantém o número de conexões usadas desde o início do servidor.

A maioria das aplicações é projetada para reutilizar conexões existentes e não abrir várias conexões com frequência. Assim, um alto número de conexões, se não previsto, pode ser um sinal alarmante de uma má configuração de como os clientes estão acessando o servidor.

Se o alto número de conexões for previsto pelo tipo de cargas de trabalho realizadas, você pode considerar adicionar um ou mais fragmentos a um cluster fragmentado para distribuir o tráfego entre várias instâncias do MongoDB.

Em seguida, localize a seção globalLock da saída. Esta seção está relacionada a travas globais em todo o servidor de banco de dados:

Output
        . . .
        "globalLock" : {
                "totalTime" : NumberLong(975312000),
                "currentQueue" : {
                        "total" : 0,
                        "readers" : 0,
                        "writers" : 0
                },
                "activeClients" : {
                        "total" : 0,
                        "readers" : 0,
                        "writers" : 0
                }
        },

O MongoDB usa travas para garantir a consistência dos dados ao executar múltiplas operações, garantindo que duas consultas não modifiquem os mesmos dados ao mesmo tempo. Em servidores muito utilizados, há uma chance de que travas possam resultar em gargalos, com uma ou mais consultas aguardando a liberação das travas antes que possam ser executadas.

O valor currentQueue.total mostra o número de consultas aguardando as travas serem liberadas para que possam ser executadas. Se este valor for alto, significa que o desempenho do banco de dados está sendo afetado e as consultas levarão mais tempo para serem concluídas.

Isso geralmente decorre de muitas consultas longas mantendo os bloqueios e pode ser indicativo de um uso ineficaz de índices ou consultas mal projetadas, entre outras possibilidades.

Por último, encontre a seção opcounters:

Output
        "opcounters" : {
                "insert" : NumberLong(10000007),
                "query" : NumberLong(6),
                "update" : NumberLong(6),
                "delete" : NumberLong(0),
                "getmore" : NumberLong(0),
                "command" : NumberLong(1298)
        },

Esta seção da saída serverStatus() pode ajudá-lo a ter uma ideia se o servidor de banco de dados é usado principalmente para leituras ou gravações, ou se seu uso é bem equilibrado. Neste exemplo, após a inserção dos documentos de teste, o contador para operações de insert é muito maior do que para operações de query. Em um cenário da vida real, esses valores provavelmente seriam diferentes.

Bancos de dados com muita escrita podem se beneficiar sendo escalados horizontalmente através de sharding. Da mesma forma, bancos de dados MongoDB com muita leitura geralmente se beneficiarão de replicação.

Essas estatísticas podem dar uma ideia geral de como o servidor é usado e se há problemas de desempenho, como filas de bloqueio longas no momento de acessá-las. No entanto, elas não fornecem informações em tempo real sobre como o servidor é usado. Para isso, os comandos mongostat e mongotop são ferramentas úteis.

Passo 3 — Utilizando mongostat e mongotop para Obter Estatísticas do Banco de Dados em Tempo Real

Enquanto os comandos usados para acessar as estatísticas do servidor MongoDB podem fornecer insights sobre como o servidor é utilizado em retrospecto, eles não podem fornecer informações em tempo real sobre quais coleções estão sendo mais usadas no momento ou que tipo de consultas estão sendo executadas.

O MongoDB fornece duas ferramentas de sistema úteis para monitoramento em tempo real que analisam a atividade do banco de dados e atualizam continuamente as informações que fornecem: mongostat e mongotop. O mongostat fornece uma visão geral breve do estado atual da instância do MongoDB, enquanto o mongotop rastreia quanto tempo a instância gasta em operações de leitura e escrita. Ambas as ferramentas são executadas a partir da linha de comando, em vez do shell do MongoDB.

Para usar o mongostat, mantenha sua conexão atual do shell do MongoDB e abra outra janela de terminal para acessar o shell do seu servidor. No segundo shell do servidor, execute o comando mongostat:

mongostat -u AdminSammy --authenticationDatabase admin

Como mencionado anteriormente, o mongostat requer privilégios avançados. Se você habilitou a autenticação em sua instância do MongoDB e configurou um usuário com as funções apropriadas, então você terá que autenticar como esse usuário fornecendo seu nome de usuário e banco de dados de autenticação (como mostrado neste exemplo) e depois inserir sua senha quando solicitado.

Em uma configuração padrão, o mongostat imprime os contadores das consultas atualmente executadas em intervalos de um segundo:

Output
insert query update delete getmore command dirty  used flushes vsize  res qrw arw net_in net_out conn                time
    *0    *0     *0     *0       0     1|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   223b   84.4k    7 Nov 28 15:40:40.621
    *0    *0     *0     *0       0     2|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   224b   84.8k    7 Nov 28 15:40:41.619
    *0    *0     *0     *0       0     1|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   223b   84.5k    7 Nov 28 15:40:42.621
    *0    *0     *0     *0       0     3|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   365b   85.0k    7 Nov 28 15:40:43.619

Se a saída do mongostat mostrar um valor de 0 para um determinado tipo de consulta, isso indica que o banco de dados não está executando nenhuma operação desse tipo. Esta saída de exemplo mostra 0 para cada tipo de consulta, significando que atualmente não há consultas sendo executadas.

Você ainda deve ter sua primeira janela de terminal aberta e conectada ao shell do MongoDB. Insira mais alguns documentos de teste na coleção accounts e verifique se o mongostat irá notar a atividade:

for (let i = 1; i <= 10000; ++i) {
    db.accounts.insertOne({
        "number": "2000-" + i,
        "currency": "USD",
        "balance": Math.random() * 100000
    })
}

Este é um for-loop semelhante ao que você executou na Etapa 1. Desta vez, porém, o loop insere apenas 10000 entradas. Os números de conta são prefixados com 2000 e a moeda é sempre USD.

Enquanto os novos documentos estão sendo inseridos, verifique a saída do mongostat:

Output
. . .
    *0    *0     *0     *0       0     1|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   112b   42.5k    4 Nov 28 15:50:33.294
    *0    *0     *0     *0       0     0|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   111b   42.2k    4 Nov 28 15:50:34.295
   755    *0     *0     *0       0     1|0  0.1% 38.8%       0 1.54G 210M 0|0 1|0   154k   79.4k    4 Nov 28 15:50:35.294
  2853    *0     *0     *0       0     0|0  0.4% 39.1%       0 1.54G 211M 0|0 1|0   585k    182k    4 Nov 28 15:50:36.295
  2791    *0     *0     *0       0     1|0  0.7% 39.4%       0 1.54G 212M 0|0 1|0   572k    179k    4 Nov 28 15:50:37.293
  2849    *0     *0     *0       0     0|0  1.0% 39.7%       0 1.54G 213M 0|0 1|0   584k    182k    4 Nov 28 15:50:38.296
   745    *0     *0     *0       0     2|0  1.1% 39.8%       0 1.54G 213M 0|0 1|0   153k   79.2k    4 Nov 28 15:50:39.294
    *0    *0     *0     *0       0     0|0  1.1% 39.8%       0 1.54G 213M 0|0 1|0   111b   42.2k    4 Nov 28 15:50:40.295
    *0    *0     *0     *0       0     2|0  1.1% 39.8%       0 1.54G 213M 0|0 1|0   167b   42.7k    4 Nov 28 15:50:41.293
. . .

Enquanto a consulta é executada, as novas linhas retornadas pelo mongostat começam a mostrar valores diferentes de 0. Na coluna insert que mostra o número de consultas que estão inserindo novos dados no banco de dados, os valores foram maiores por vários segundos. Como o mongostat mostra dados em intervalos de um segundo, você pode encontrar não apenas a proporção de inserções em relação a outros tipos de operações de banco de dados, mas também quão rápido o banco de dados insere os novos dados. Neste exemplo, o servidor alcançou quase 3000 inserções por segundo.

Você pode usar o mongostat para monitorar a carga de trabalho atual do servidor de banco de dados, agrupada por tipos de consulta. A segunda ferramenta que o MongoDB envia junto — mongotop — mostra a atividade do servidor de banco de dados agrupada por coleções.

Pare o mongostat de ser executado na sua segunda janela de terminal pressionando CTRL + C. Em seguida, execute o mongotop na mesma terminal. Novamente, se você tiver a autenticação ativada, precisará autenticar como um usuário com privilégios adequados:

mongotop -u AdminSammy --authenticationDatabase admin

O mongotop produz uma lista de todas as coleções no banco de dados, acompanhadas pelo tempo gasto em leituras, escritas e total dentro da janela de tempo. Similarmente ao mongostat, a saída é atualizada a cada segundo:

Output
2021-11-28T15:54:42.290+0000    connected to: mongodb://localhost/

                    ns    total    read    write    2021-11-28T15:54:43Z
    admin.system.roles      0ms     0ms      0ms
  admin.system.version      0ms     0ms      0ms
config.system.sessions      0ms     0ms      0ms
   config.transactions      0ms     0ms      0ms
  local.system.replset      0ms     0ms      0ms
         test.accounts      0ms     0ms      0ms

. . .

Tente inserir mais documentos no banco de dados para ver se a atividade é registrada no mongotop. No shell do MongoDB, execute o seguinte laço for; após fazer isso, observe a janela do terminal com o mongotop em execução:

for (let i = 1; i <= 10000; ++i) {
    db.accounts.insertOne({
        "number": "3000-" + i,
        "currency": "USD",
        "balance": Math.random() * 100000
    })
}

Desta vez, a atividade será visível nas estatísticas do mongotop:

Output
. . .
                    ns    total    read    write    2021-11-28T15:57:27Z
         test.accounts    127ms     0ms    127ms
  admin.$cmd.aggregate      0ms     0ms      0ms
    admin.system.roles      0ms     0ms      0ms
  admin.system.version      0ms     0ms      0ms
config.system.sessions      0ms     0ms      0ms
   config.transactions      0ms     0ms      0ms
  local.system.replset      0ms     0ms      0ms

                    ns    total    read    write    2021-11-28T15:57:28Z
         test.accounts    130ms     0ms    130ms
  admin.$cmd.aggregate      0ms     0ms      0ms
    admin.system.roles      0ms     0ms      0ms
  admin.system.version      0ms     0ms      0ms
config.system.sessions      0ms     0ms      0ms
   config.transactions      0ms     0ms      0ms
  local.system.replset      0ms     0ms      0ms
. . .

Aqui, mongotop mostra que toda a atividade do banco de dados ocorreu na coleção accounts no banco de dados test e que todas as operações no intervalo de tempo foram operações de escrita. Tudo isso deve estar alinhado com a operação de loop for que você executou.

Assim como com mongostat, você pode parar mongotop de ser executado pressionando CTRL + C.

Ao ser observado durante a carga de pico, você pode usar mongotop para monitorar como a atividade do banco de dados se espalha por diferentes coleções para ajudá-lo a entender melhor seu esquema e planejar a escalabilidade. Ele também fornece insights sobre se o uso de uma coleção é mais voltado para leitura ou escrita.

Passo 4 — Usando o Perfilador de Banco de Dados do MongoDB para Identificar Consultas Lentas

Os gargalos de desempenho do banco de dados podem vir de muitas fontes. Embora a escalabilidade do banco de dados (horizontal ou vertical) seja frequentemente a solução para gargalos de desempenho, sua causa pode não ser realmente os limites do banco de dados, mas problemas com o esquema ou design da consulta.

Se as consultas demorarem muito, a causa pode ser um uso ineficaz de índices ou erros na própria consulta. Consultas que demoram muito muitas vezes passam despercebidas durante o desenvolvimento de aplicativos, geralmente porque os conjuntos de dados de teste são muito pequenos ou as condições são diferentes das de produção.

Você poderia potencialmente encontrar o culpado executando manualmente consultas de teste e verificando quais delas têm desempenho inferior, embora isso seja muito tedioso. Felizmente, a ferramenta de perfil do banco de dados do MongoDB pode fazer isso automaticamente.

O profiler do banco de dados do MongoDB pode registrar consultas e estatísticas sobre sua execução quando elas correspondem a certas condições. A mais importante dessas condições é o tempo de execução da consulta: se uma consulta levar mais tempo do que um determinado período de tempo especificado para ser executada, o profiler automaticamente sinalizará essa consulta como problemática. Usando o profiler, você pode identificar quais consultas têm desempenho ruim e então focar em corrigir esses problemas específicos.

Antes de usar o profiler, execute a seguinte consulta. Esta consulta irá recuperar uma das contas que você inseriu, embora não seja tão simples quanto pode parecer à primeira vista:

db.accounts.find({"number": "1000-20"})

O comando irá recuperar a conta exata que você solicitou:

Output
{ "_id" : ObjectId("61a38fd5eedf737ac8e54e96"), "number" : "1000-20", "currency" : "EUR", "balance" : 24101.14770458518 }

Você pode ter notado que a consulta não foi executada imediatamente, e levou um momento ou dois para o MongoDB encontrar a conta. Em uma aplicação do mundo real, pode haver muitos tipos de consultas que têm desempenho ruim, e você pode não notar o seu desempenho abaixo do esperado na prática.

Você pode configurar o MongoDB para ajudá-lo a identificar quais consultas levam mais tempo do que o esperado. Para fazer isso, primeiro habilite o profiler executando o seguinte comando:

db.setProfilingLevel(1, { slowms: 100 })

O método setProfilingLevel() recebe dois argumentos. O primeiro é o nível de perfil, que pode ser 0, 1 ou 2:

• 0 desabilita o profiler
• 1 habilita o profiler apenas em consultas lentas que satisfazem a condição
• 2 habilita o profiler para todas as consultas.

Neste exemplo, o profiler analisará as consultas que demoram mais de 100 milissegundos, conforme definido pelo segundo argumento, { slowms: 100 }.

Este método retornará uma mensagem de sucesso:

Output
{ "was" : 0, "slowms" : 100, "sampleRate" : 1, "ok" : 1 }

A partir de agora, o perfilamento do banco de dados estará ativado e o MongoDB monitorará ativamente cada consulta que você executar para encontrar aquelas que levam mais de 100 milissegundos para serem concluídas.

Tente isso executando algumas consultas diferentes. Primeiro, use o comando count para encontrar o número de documentos na coleção accounts:

db.accounts.count()

Este comando retornará rapidamente o número de documentos na coleção:

Output
1020000

Depois, tente procurar os três primeiros contas bancárias que aparecem na coleção:

db.accounts.find().limit(3)

Novamente, o banco de dados retornará os resultados rapidamente:

Output
{ "_id" : ObjectId("61ef40640f2ba52efc56ee17"), "number" : "1000-1", "currency" : "EUR", "balance" : 25393.132960293842 }
{ "_id" : ObjectId("61ef40640f2ba52efc56ee18"), "number" : "1000-2", "currency" : "EUR", "balance" : 63629.42056192393 }
{ "_id" : ObjectId("61ef40640f2ba52efc56ee19"), "number" : "1000-3", "currency" : "EUR", "balance" : 75602.12331602155 }

Por fim, execute novamente a consulta de busca para a conta bancária específica:

db.accounts.find({"number": "1000-20"})

Esta consulta retornará o resultado, mas, como antes, levará um momento ou dois a mais do que as operações anteriores:

Output
{ "_id" : ObjectId("61a38fd5eedf737ac8e54e96"), "number" : "1000-20", "currency" : "EUR", "balance" : 24101.14770458518 }

O perfilador não produz nenhuma saída própria, mesmo que a consulta seja visivelmente mais lenta. Em vez disso, os detalhes sobre operações lentas são registrados em uma coleção especial dentro do banco de dados chamada system.profile. Esta coleção é uma coleção limitada que nunca excede 1 MB de tamanho. Isso significa que sempre conterá uma lista apenas das consultas mais recentes.

Para recuperar informações sobre consultas identificadas pelo perfilador, você precisa consultar a coleção system.profile de forma semelhante a esta:

db.system.profile.find().sort({ "ts" : -1 }).pretty()

Esta consulta usa o método find(), como de costume. Também inclui uma cláusula sort que contém { "ts" : -1 } como argumento. Isso ordenará o conjunto de resultados com as consultas mais recentes primeiro. Por último, o método pretty() no final exibirá a saída em um formato mais legível.

Cada consulta lenta é representada como um documento regular, e system.profile é como qualquer coleção regular. Isso significa que você pode filtrar os resultados, ordená-los e até usá-los em pipelines de agregação para estreitar ainda mais ou analisar a lista de consultas identificadas pelo perfilador.

Observe que o resultado consiste apenas em um único documento. As outras duas consultas foram executadas rápido o suficiente para não acionar o perfilador:

Output
{
        "op" : "query",
        "ns" : "test.accounts",
        "command" : {
                "find" : "accounts",
                "filter" : {
                        "number" : "1000-20"
                },
                . . .
        },
        "nreturned" : 1,
        "keysExamined" : 0,
        "docsExamined" : 1030000,
        . . .
        "millis" : 434,
        "planSummary" : "COLLSCAN",
        . . .
}

Esta saída fornece uma série de detalhes sobre a execução da consulta lenta:

• A chave op mostra que tipo de operação essa informação representa. Aqui, é uma consulta, pois representa uma operação na qual você usou o find() para recuperar dados do banco de dados.
• A chave ns indica qual banco de dados e coleção estavam envolvidos na operação. Como a saída mostra, esta operação consultou a coleção accounts no banco de dados test.
• A chave command fornece informações adicionais sobre a própria consulta. Neste caso, o sub-chave filter contém todo o documento de filtro. Usando as informações provenientes dos campos op e command, você pode reconstruir a consulta em questão.
• No campo millis, você encontrará o tempo exato que levou para concluir a consulta. Neste exemplo, quase meio segundo.
• O campo docsExamined fornece o número de documentos examinados para retornar o conjunto de resultados.
• nreturned representa o número de documentos que a consulta retornou. Neste exemplo, apenas um único documento foi retornado de mais de um milhão examinados.
• O planSummary mostra o método que o MongoDB usou para executar a consulta. COLLSCAN corresponde a uma varredura completa da coleção, o que significa que ele navegou por cada documento na coleção um por um para encontrar a conta bancária correspondente.

Todas juntas, estas informações destacam a necessidade de um índice que possa ajudar o MongoDB a executar esta consulta mais rapidamente. O banco de dados teve que percorrer toda a coleção para encontrar um único documento, como indicado pela grande diferença entre o número de documentos examinados e retornados, bem como a estratégia de execução.

Neste exemplo específico, criar um índice para suportar consultas que filtram dados com base no campo number forneceria um impulso imediato ao desempenho desses tipos de consultas. Em cenários reais, as soluções para consultas lentas podem diferir e depender da consulta exata que está causando problemas.

Para finalizar a sessão de perfilamento, você pode desativar o perfilador definindo o nível de perfilamento como zero:

db.setProfilingLevel(0)

A operação será bem-sucedida com uma mensagem de confirmação:

Output
{ "was" : 1, "slowms" : 100, "sampleRate" : 1, "ok" : 1 }

Agora o banco de dados retorna à operação normal sem perfilamento acontecendo nos bastidores.

Sempre que você suspeitar que consultas lentas possam estar tendo um impacto negativo no desempenho do seu banco de dados, você pode usar o perfilador do banco de dados para encontrá-las e entender melhor sua estrutura e como são executadas. Com estas informações, você estará melhor equipado para ajustá-las e melhorar seu desempenho.

Conclusão

Seguindo este guia, você aprendeu como encontrar as estatísticas do servidor MongoDB e como usar ferramentas de diagnóstico como mongotop, mongostat, bem como o mecanismo de perfil do banco de dados do MongoDB. Você pode usar essas ferramentas para ter uma melhor noção da carga de trabalho do seu banco de dados, determinar quais coleções são as mais ativas e se o servidor realiza predominantemente gravações ou leituras. Você também pode identificar consultas lentas que estão impactando o desempenho do MongoDB para substituí-las por consultas mais eficientes.

Essas são apenas uma seleção de ferramentas e técnicas que você pode usar para monitorar a saúde e o desempenho da sua instalação do MongoDB e agir sobre isso. Cada uma dessas ferramentas pode ser configurada e personalizada ainda mais para fornecer insights mais direcionados sobre o desempenho do servidor. Encorajamos você a estudar a documentação oficial do MongoDB para aprender mais sobre técnicas que você pode usar para monitorar o desempenho do servidor e agir sobre ele.