Jak optimalizujete výkon NestJS?

Question

Accepted Answer

Optimalizace výkonu NestJS zahrnuje výběr **HTTP adaptéru** (Express vs Fastify), efektivitu databáze, cachování a obecné postupy Node.js. Jako vždy: **profilujte, abyste našli skutečné úzké místo** — které je obvykle databáze nebo I/O, ne NestJS samotný.

## Přejděte na Fastify pro vyšší propustnost

```ts
// NestJS supports Fastify as an alternative to the default Express adapter
import { FastifyAdapter } from "@nestjs/platform-fastify";

const app = await NestFactory.create(AppModule, new FastifyAdapter());
// Fastify is significantly faster than Express (~2x in benchmarks) with the SAME NestJS code
```

Protože je NestJS **platformě-agnostický**, můžete nahradit Express za **Fastify** — často zhruba 2x rychlejší pro HTTP propustnost — obvykle bez změny kódu aplikace. Snadné zlepšení pro API s vysokou propustností.

## Databáze je obvykle skutečným úzkým místem

```ts
// ❌ N+1 queries — fetching related data in a loop (the most common perf killer)
for (const user of users) {
  user.posts = await postsRepo.findByUser(user.id);   // 1 query per user!
}

// ✅ eager load / join / batch in ONE query
const users = await usersRepo.find({ relations: ["posts"] });
```

```text
Database optimizations (the biggest real wins for most APIs):
  ✓ Fix N+1 queries (use joins/relations/DataLoader)
  ✓ Add indexes for slow queries
  ✓ Select only needed columns; paginate large result sets
  ✓ Use connection pooling
```

## Cachování drahých operací

```ts
@UseInterceptors(CacheInterceptor)   // cache read-heavy endpoints (in-memory or Redis)
// or manual caching of expensive queries/computations
```

Cachování (s Redis pro více instancí) vyhýbá se opakování drahé práce — jedno z nejvyšších dopadů na optimalizaci.

## Async/souběžnost a offloading

```ts
// parallelize independent async operations
const [users, products] = await Promise.all([getUsers(), getProducts()]);

// offload heavy CPU work to a queue/worker (don't block the event loop)
await this.queue.add("process-image", data);
```

Paralelizujte nezávislé I/O s `Promise.all` a offloadujte CPU-intenzivní práci na background fronty/workery, aby neblokoval single-threaded event loop Node.js.

## Další techniky

```text
✓ Enable compression (gzip/brotli) for responses
✓ Use streaming for large payloads/files
✓ Scale horizontally (multiple instances + load balancer; cluster/PM2)
  — keep the app STATELESS (sessions/cache in Redis, not process memory)
✓ Lazy-load modules where appropriate; minimize startup work
✓ Profile with clinic.js / node --prof to find actual hotspots
```

## Nejdříve měřte

```text
Don't guess. Profile (clinic.js, autocannon for load testing) to find the REAL
bottleneck — for most APIs it's the database or external I/O, not Nest/Node code.
```

## Proč na tom záleží

Optimalizace výkonu je cenná pro budování škálovatelných NestJS služeb a pochopení možností je důležité znalosti na úrovni senior vývojáře — ale musí být **řízena měřením** (profilováním, aby se našlo skutečné úzké místo, které pro většinu API tvoří databáze nebo I/O spíše než NestJS samotný).

Několik NestJS-specifických a obecných technik je důležitých: **Fastify adaptér** nabízí snadné, významné zlepšení HTTP propustnosti (zhruba 2x) díky platformě-agnostickému NestJS, obvykle bez změn kódu; **optimalizace databáze** (oprava N+1 dotazů, indexování, stránkování, pooling) přináší největší zisky v reálném světě, protože databáze je typicky skutečným úzkým místem; **cachování** (v paměti nebo Redis) vyhýbá se opakované drahé práci; **paralelizace** nezávislých async operací a **offloading CPU-intenzivní práce na fronty** udržuje Node.js single-threaded event loop responsivní; a **horizontální škálování** (se stateless aplikací a Redis-backed sdíleným stavem) zvládá vysokou zátěž.

Znalost tohoto soupravy nástrojů — a zejména disciplína profilovat nejdříve, zaměřit se na skutečné úzké místo (obvykle DB) a aplikovat správnou opravu místo hádání nebo předčasné micro-optimalizace — je to, co vám umožní budovat rychlé, škálovatelné NestJS aplikace.

Odráží zralý, systematický přístup k výkonu, který rozlišuje senior vývojáře, a je to běžné, prakticky důležité téma pro produkční back-end práci.