Qu'est-ce que la backpressure dans les streams et comment la gérez-vous ?

Question

Accepted Answer

**La backpressure** est ce qui se produit lorsque les données sont produites **plus vite qu'elles ne peuvent être consommées**. Dans les streams, si une source de lecture rapide pousse les données vers une destination d'écriture lente, les données non consommées sont mises en buffer en mémoire — et sans traitement, ce buffer grandit jusqu'à épuisement de la mémoire. La backpressure est le mécanisme (et la discipline) pour maintenir l'équilibre entre producteur et consommateur.

## Le problème

```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
```

Exemple : lire rapidement un énorme fichier et l'écrire vers un socket réseau lent ou un disque — si vous ne respectez pas le rythme de la destination, la mémoire enfle de façon incontrôlée.

## pipe gère la backpressure automatiquement

```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"));
```

C'est une raison majeure d'utiliser `pipe`/`pipeline` : ils gèrent la backpressure pour vous, en mettant en pause et en reprenant le flux pour que la mémoire reste bornée indépendamment du décalage de taille.

## La gérer manuellement avec la valeur de retour 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
  }
});
```

Si vous gérez les streams manuellement, la règle est : quand `writable.write()` retourne `false`, **interrompez** la source de lecture, et **reprenez-la** sur l'événement `drain` de l'écriture. Ignorer la valeur de retour `false` est le bug de backpressure classique.

## Avec async iteration (moderne, propre)

```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
}
```

## Préférez pipeline pour la sécurité

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

## Pourquoi c'est important

La backpressure est un concept subtil mais critique pour tout service Node intensive en données (traitement de fichiers, mandataire, streaming, ETL).

L'ignorer — en mettant tout en buffer ou en ignorant la valeur de retour de `write()` — provoque une croissance mémoire non bornée et des crashes sous charge, souvent uniquement en production avec de grandes données.

Comprendre que `pipe`/`pipeline` la gèrent automatiquement (la raison principale de les préférer), et comment la respecter manuellement (interrompre sur `false`, reprendre sur `drain`) ou via `for await`, c'est ce qui vous permet de construire des systèmes de streaming qui restent stables en mémoire peu importe la taille ou la vitesse des données.

C'est une marque distinctive d'une utilisation compétente des streams.