Como você otimiza o desempenho do MongoDB?

Question

Accepted Answer

A otimização do desempenho do MongoDB se concentra em **indexação** (a maior vitória), **design de schema** para padrões de acesso, **queries** eficientes e uso de ferramentas como **`explain()`** para encontrar gargalos. Como sempre: meça primeiro, depois corrija o problema real — geralmente índices ausentes ou design de schema inadequado.

## Indexação é a maior vitória

```js
// use explain() to check if a query uses an index
db.users.find({ email: "ann@x.com" }).explain("executionStats");
// → look for: COLLSCAN (collection scan = BAD, no index) vs IXSCAN (index = GOOD)

db.users.createIndex({ email: 1 });   // add the missing index → fast
```

```text
✓ Index fields used in queries, sorts, and filters (the #1 optimization)
✓ Compound indexes for multi-field queries (mind the field order)
✓ explain() to verify queries use indexes (COLLSCAN = problem)
✓ Don't over-index (slows writes); index what's actually queried
```

## Design de schema para padrões de acesso

```text
✓ EMBED data accessed together → single-query reads (no joins)
✓ Reference large/unbounded/shared data appropriately
✓ Design around your QUERIES (the access-pattern principle) → most reads = one document
→ Poor schema design (e.g. needing many $lookups, huge documents) hurts performance
  more than almost anything else in MongoDB.
```

## Otimização de queries

```text
✓ Use PROJECTION — return only needed fields (less data transferred)
✓ Filter early; use covered queries (all fields from the index → no document fetch)
✓ In aggregation pipelines, put $match (and $limit) EARLY to reduce data through the pipeline
✓ Avoid querying without the shard key on sharded collections (scatter-gather)
✓ Use limit/pagination; prefer range-based over deep skip()
```

## Outras técnicas

```text
✓ Working set in RAM — frequently-accessed data + indexes should fit in memory
  (MongoDB caches in RAM; disk access is much slower)
✓ Connection pooling (drivers pool by default)
✓ Monitor: explain(), MongoDB profiler, Atlas Performance Advisor (suggests indexes)
✓ Avoid large/unbounded arrays; consider the bucket pattern for time-series
```

## Por que isso importa

A otimização de desempenho do MongoDB é conhecimento valioso de nível sênior para manter aplicações MongoDB rápidas, e entender a abordagem correta — orientada por medição, com indexação e design de schema como os maiores diferenciais — é importante para otimização eficaz.

A **maior vitória é a indexação** (igual a bancos de dados relacionais): índices ausentes causam **collection scans** (COLLSCAN — verificando cada documento, catastrophicamente lento conforme os dados crescem), e adicionar índices apropriados em campos consultados/ordenados/filtrados transforma isso em scans de índice rápidos — usar **`explain()`** para verificar que queries usam índices (identificando problemas COLLSCAN) é a habilidade diagnóstica chave. **Design de schema para padrões de acesso** é potencialmente ainda mais impactante no MongoDB do que em SQL: projetar ao redor de queries (incorporar dados acessados juntos para leituras em uma única query, referenciar apropriadamente) para que a maioria das leituras acesse um documento, enquanto design inadequado (precisando de muitos `$lookup`s, documentos enormes) prejudica significativamente o desempenho — tornando design de schema uma das principais alavancas de otimização única à flexibilidade do MongoDB. **Otimização de queries** (projection para retornar apenas campos necessários, covered queries, colocar `$match`/`$limit` no início de pipelines de agregação para reduzir fluxo de dados, evitar scatter-gather em coleções sharded, paginação eficiente) e garantir que o **working set caiba em RAM** (dados frequentemente acessados e índices em cache na memória, já que disco é muito mais lento) completam o toolkit.

A **disciplina orientada por medição** (usando explain(), o profiler e o Atlas Performance Advisor para encontrar e corrigir gargalos reais — geralmente índices ausentes ou schema inadequado) é essencial.

Como o desempenho do MongoDB é crítico para aplicações e otimização adequada (indexação, design de schema, eficiência de query, working set em RAM) é o que o mantém rápido em escala, entender otimização de desempenho do MongoDB — especialmente indexação (verificada com explain()) e design de schema orientado por padrões de acesso como as maiores alavancas — é conhecimento valioso de nível sênior para operar aplicações MongoDB com desempenho, uma preocupação frequentemente relevante e um tópico que demonstra a capacidade de otimizar MongoDB sistematicamente.