¿Qué es el backpressure en los streams y cómo lo manejas?

Question

Accepted Answer

El **backpressure** es lo que ocurre cuando los datos se producen **más rápido de lo que pueden consumirse**. En los streams, si una fuente readable rápida empuja datos hacia un destino writable lento, los datos no consumidos se acumulan en memoria, y sin manejo, ese buffer crece hasta agotar la memoria. El backpressure es el mecanismo (y la disciplina) para mantener equilibrados al productor y al consumidor.

## El problema

```text
Fuente rápida ──(1 GB/s)──▶ Destino lento (velocidad de escritura de 10 MB/s)
                            ▲
             La diferencia de 990 MB/s se acumula en un buffer de memoria → crash por OOM
```

Ejemplo: leer un archivo enorme rápidamente y escribirlo en un socket de red o disco lento; si no respetas el ritmo del destino, la memoria se dispara.

## pipe maneja el backpressure automáticamente

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

// ✅ pipe pausa automáticamente la fuente cuando el destino está lleno,
//    y la reanuda cuando el destino se drena — backpressure manejado por ti
createReadStream("huge.file").pipe(createWriteStream("copy.file"));
```

Esta es una razón importante para usar `pipe`/`pipeline`: manejan el backpressure por ti, pausando y reanudando el flujo para que la memoria permanezca acotada sin importar la diferencia de tamaño.

## Manejándolo manualmente con el valor de retorno de write()

```js
// write() devuelve FALSE cuando el buffer interno está lleno — esa es la señal de backpressure
readable.on("data", (chunk) => {
  const ok = writable.write(chunk);
  if (!ok) {
    readable.pause();                       // deja de leer — el destino está lleno
    writable.once("drain", () => readable.resume()); // reanuda cuando se drena
  }
});
```

Si manejas streams manualmente, la regla es: cuando `writable.write()` devuelve `false`, **pausa** el readable y **reanúdalo** en el evento `drain` del writable. Ignorar el retorno `false` es el bug clásico de backpressure.

## Con iteración asíncrona (moderna, limpia)

```js
// for-await respeta el backpressure de forma natural — espera el procesamiento de cada chunk
for await (const chunk of readable) {
  await processSlowly(chunk); // solo extrae el siguiente chunk cuando está listo
}
```

## Prefiere pipeline por seguridad

```js
import { pipeline } from "stream/promises";
await pipeline(source, transform, destination); // backpressure + manejo de errores + limpieza
```

## Por qué es importante

El backpressure es un concepto sutil pero crítico para cualquier servicio Node intensivo en datos (procesamiento de archivos, proxying, streaming, ETL).

Ignorarlo (bufferando todo o ignorando el valor de retorno de `write()`) provoca un crecimiento ilimitado de memoria y crashes bajo carga, a menudo solo en producción con datos grandes.

Comprender que `pipe`/`pipeline` lo manejan automáticamente (la razón principal para preferirlos), y cómo respetarlo manualmente (pausar en `false`, reanudar en `drain`) o mediante `for await`, es lo que te permite construir sistemas de streaming que se mantienen estables en memoria sin importar cuán grandes o rápidos sean los datos.

Es una marca distintiva del uso competente de streams.