O que é backpressure em streams e como você trata isso?

Question

Accepted Answer

**Backpressure** é o que acontece quando dados são produzidos **mais rapidamente do que podem ser consumidos**. Em streams, se uma fonte readable rápida envia dados para um destino writable lento, os dados não consumidos são armazenados em buffer na memória — e sem tratamento, esse buffer cresce até a memória se esgotar. Backpressure é o mecanismo (e disciplina) para manter produtor e consumidor em equilíbrio.

## O problema

```text
Fast source ──(1 GB/s)──▶ Slow destination (10 MB/s write speed)
                          ▲
             The 990 MB/s difference piles up in a memory buffer → OOM crash
```

Exemplo: ler um arquivo gigante rapidamente e escrever para um socket de rede lento ou disco — se você não respeitar o ritmo do destino, a memória dispara.

## pipe trata backpressure automaticamente

```js
import { createReadStream, createWriteStream } from "fs";

// ✅ pipe automatically pauses the source when the destination is full,
//    and resumes it when the destination drains — backpressure handled for you
createReadStream("huge.file").pipe(createWriteStream("copy.file"));
```

Este é um motivo importante para usar `pipe`/`pipeline`: eles gerenciam backpressure para você, pausando e retomando o fluxo para que a memória permaneça limitada independentemente da diferença de tamanho.

## Tratando manualmente com o valor de retorno de write()

```js
// write() returns FALSE when the internal buffer is full — that's the backpressure signal
readable.on("data", (chunk) => {
  const ok = writable.write(chunk);
  if (!ok) {
    readable.pause();                       // stop reading — destination is full
    writable.once("drain", () => readable.resume()); // resume when it drains
  }
});
```

Se você trata streams manualmente, a regra é: quando `writable.write()` retorna `false`, **pause** o readable e **retome** em caso do evento `drain` do writable. Ignorar o retorno `false` é o bug clássico de backpressure.

## Com iteração assíncrona (moderno, limpo)

```js
// for-await respects backpressure naturally — it awaits each chunk's processing
for await (const chunk of readable) {
  await processSlowly(chunk); // only pulls the next chunk when ready
}
```

## Prefira pipeline para segurança

```js
import { pipeline } from "stream/promises";
await pipeline(source, transform, destination); // backpressure + error handling + cleanup
```

## Por que isso importa

Backpressure é um conceito sutil mas crítico para qualquer serviço Node intensivo em dados (processamento de arquivos, proxy, streaming, ETL).

Ignorá-lo — ao armazenar tudo em buffer ou ignorar o valor de retorno de `write()` — causa crescimento ilimitado de memória e falhas sob carga, frequentemente apenas em produção com dados grandes.

Compreender que `pipe`/`pipeline` tratam isso automaticamente (a razão principal para preferir), e como respeitá-lo manualmente (pausar em `false`, retomar em `drain`) ou via `for await`, é o que permite você construir sistemas de streaming que mantêm a memória estável não importa o quão grande ou rápido os dados sejam.

É uma marca definidora de uso competente de streams.