Limitation de bande passante et shaping sur proxy : mesurer le plafond et coder pour la saturation
Sommaire de l'article
- Introduction : pourquoi la bande passante sur proxy compte plus qu'on ne le croit
- Les bases : le vocabulaire indispensable pour la suite
- Plongée en profondeur : ce qui se passe au moment de la saturation
- Méthode 1 : mesurer correctement le plafond de bande passante
- Méthode 2 : identifier le type de limiteur et ses paramètres
- Méthode 3 : écrire un client qui s'accorde avec le limiteur
- Méthode 4 : budget de trafic et architecture de la charge
- Erreurs classiques : ce qu'il ne faut absolument pas faire
- Outils et ressources
- Cas concrets et résultats
- Faq : questions pointues sur la bande passante et le shaping
- Conclusion : des suppositions à la bande passante maîtrisée
Introduction : pourquoi la bande passante sur proxy compte plus qu'on ne le croit
La plupart des discussions sur les proxys tournent autour de l'anonymat, de la géolocalisation et de la question « vais-je me faire bannir ». La bande passante, elle, reste dans l'ombre. Pourtant, c'est elle qui détermine en combien d'heures votre scraper va terminer, combien de comptes un canal peut supporter, et pourquoi un script qui tournait parfaitement sur un banc de test se met à cracher des timeouts toutes les dix minutes en production.
On va explorer ensemble un sujet rarement traité de manière systématique : comment fonctionne la limitation de bande passante sur un proxy, ce que sont le shaping et le policing, à quoi ressemble le plafond d'un canal en chiffres réels et, surtout, comment se comporte votre code client quand il touche ce plafond. On ne va pas refaire le tour des méthodes d'évaluation de la qualité d'un proxy en général. Ici, on parle uniquement de bande passante, de sa limite et de ce qui arrive à l'application au moment de la saturation.
Pourquoi c'est particulièrement d'actualité maintenant ? En 2026, une page web moyenne avec ses ressources dépasse les trois mégaoctets, les API renvoient des réponses JSON de plus en plus lourdes, et les canaux mobiles sur lesquels reposent les proxys mobiles partagent physiquement la ressource radio de la cellule avec les abonnés classiques. En parallèle, les opérateurs et les fournisseurs de proxys appliquent de plus en plus souvent du shaping au niveau de la session pour qu'un client ne « mange » pas le canal des autres. Un développeur qui ne comprend pas la mécanique du limiteur est condamné à coder par tâtonnement.
Dans ce guide, vous apprendrez : comment distinguer un shaper d'un policer par la forme du graphe, comment mesurer correctement le plafond d'un flux unique et d'un agrégat, comment estimer la taille du « seau » et la profondeur de la file, pourquoi la latence augmente et l'efficacité chute sous saturation, comment écrire un client avec backpressure et parallélisme adaptatif, et comment planifier un budget de trafic plutôt qu'un nombre de requêtes. À la fin, vous trouverez des checklists, des outils, trois cas concrets chiffrés et une FAQ sur les questions les plus épineuses.
Les bases : le vocabulaire indispensable pour la suite
Bande passante, débit et vitesse utile
On confond souvent ces termes, mais la différence est fondamentale. La bande passante (bandwidth), c'est le plafond nominal d'un canal : combien de bits par seconde il peut faire passer dans l'idéal. Le débit (throughput), c'est combien de bits ont réellement transité par unité de temps, en tenant compte de tous les frais annexes : en-têtes TCP et IP, retransmissions, chiffrement. La vitesse utile (goodput), ce sont uniquement les octets arrivés jusqu'à votre application et effectivement utilisés. Si un fichier de 100 mégaoctets se télécharge en 20 secondes, votre goodput est de 5 mégaoctets par seconde, alors que le canal a pu en faire passer 8 à 12 pour cent de plus en information de service.
En pratique, retenez ceci : les limiteurs sur proxy comptent presque toujours le throughput au niveau des paquets, alors que vous voyez le goodput. Il y aura toujours un écart entre les deux.
Plafond du canal et niveaux de limitation
Le plafond, c'est la vitesse maximale que le limiteur autorise à un niveau d'agrégation donné. Il y a souvent plusieurs niveaux, et ils s'empilent comme des poupées russes :
- par connexion TCP — chaque flux individuel ne peut pas dépasser, disons, 2 mégabits par seconde, mais dix flux donneront vingt ;
- par session ou port proxy — toutes les connexions via un même port partagent la limite globale ;
- par compte — la somme de tous les ports d'un client ;
- par nœud — la limite physique du modem, du serveur, de l'uplink ;
- par canal opérateur — ce que la cellule radio donne à un instant donné, en fonction de la charge du réseau.
Le plafond réel, c'est le minimum de tous ces niveaux. Et ce minimum fluctue au cours de la journée, parce que le niveau du bas, le canal radio, dépend du nombre d'abonnés à proximité du modem.
Token bucket : la mécanique de presque tous les limiteurs
Imaginez un seau dans lequel tombent des jetons à vitesse constante. Chaque octet qui traverse le limiteur prend un jeton. Si le seau est vide, l'octet attend (shaping) ou est jeté (policing). La vitesse d'écoulement des jetons, c'est le rate, la vitesse cible. Le volume du seau, c'est le burst, le pic autorisé. Tant que le seau est plein, vous pouvez envoyer une rafale plus vite que le nominal. Ensuite, la vitesse se lisse au rate.
Ce modèle explique énormément de choses. Pourquoi les deux premières secondes de téléchargement vont plus vite que les suivantes ? Le seau était plein. Pourquoi les requêtes courtes ne tapent presque jamais dans la limite ? Elles tiennent dans le volume du seau. Pourquoi un long téléchargement « chute » soudainement pile à un chiffre ? Le seau s'est vidé, le rate pur s'applique.
Shaping contre policing
Le shaper met les paquets excédentaires en file d'attente et les libère à la vitesse voulue. Le trafic est lissé, peu de pertes, mais la latence augmente : le paquet attend son tour. Le policer ne tient pas de file, il jette simplement tout ce qui dépasse la limite. La latence n'augmente pas, mais TCP voit des pertes, réduit brutalement sa fenêtre, puis ré-accélère, et le graphe de vitesse ressemble à une scie.
Analogie : le shaper, c'est un feu tricolore avec un temps de vert réglable, tout le monde passe, mais plus lentement. Le policer, c'est une dépanneuse qui retire chaque voiture en excès. Le flot de voitures saccade. Pour votre code, la différence est énorme, et on y reviendra.
Spécificité des canaux mobiles
Un proxy mobile se trouve sur un canal d'opérateur cellulaire. Ici, le plafond n'est pas fixé seulement par la configuration du serveur, mais aussi par la physique : catégorie du modem, bande de fréquences, nombre d'abonnés dans la cellule, qualité du signal. En plus, l'opérateur applique lui-même une priorisation du trafic par classe de service. Résultat : la bande passante d'un canal mobile est d'un ordre de grandeur moins stable que celle d'un serveur, et toute méthode de mesure doit tenir compte du facteur temps.
Plongée en profondeur : ce qui se passe au moment de la saturation
Le moment de vérité : la file grandit
Tant que votre trafic reste sous le plafond, le limiteur est pratiquement invisible. Les problèmes commencent quand la somme des flux dépasse le rate. Chez le shaper, la file commence à grandir. Chaque paquet, avant de partir, attend dans le buffer. Si le buffer est profond — et ces buffers sont souvent généreux sur le matériel réseau bon marché et dans les limiteurs logiciels mal réglés — la latence peut passer de 60 millisecondes à une seconde et demie. Ce phénomène s'appelle le bufferbloat : un buffer gonflé transforme un canal rapide en canal lent et pâteux.
Pour l'application, ça se manifeste ainsi : la vitesse de téléchargement semble normale, mais chaque nouvelle requête démarre avec une latence monstrueuse. Les petits appels API qui prenaient 100 millisecondes prennent maintenant une seconde. Les timeouts réglés « avec de la marge » commencent à se déclencher. Et le plus sournois : vous ne verrez aucune perte de paquets, tout est simplement devenu lent.
Réaction de TCP : pourquoi l'algorithme de contrôle de congestion compte
TCP essaie lui-même de trouver le plafond du canal. L'algorithme classique CUBIC accélère sa fenêtre d'envoi jusqu'à voir une perte, puis réduit la vitesse et repart. Avec un policer, CUBIC se comporte mal : les pertes sont fréquentes et brutales, la vitesse moyenne peut être 30 à 40 pour cent en dessous du plafond. Avec un shaper, CUBIC remplit la file jusqu'à saturation, parce qu'il n'y a pas de perte pendant longtemps, et c'est lui le principal responsable du bufferbloat.
L'algorithme BBR, de plus en plus utilisé sur les serveurs, se comporte différemment : il estime le débit et le RTT minimal et évite de remplir la file. À travers un shaper, BBR donne une vitesse régulière et une latence modérée. Mais attention : l'algorithme côté client ne contrôle que le flux sortant. Le flux entrant, du proxy vers vous, dépend de la configuration du serveur proxy et du site cible, sur lesquels vous n'avez aucune prise.
Un tunnel, plusieurs flux : le blocage en tête de file
Quand vous passez par un proxy HTTP en méthode CONNECT ou via SOCKS5, chacune de vos connexions TCP vers le site cible est encapsulée dans une connexion séparée vers le proxy. Si vous utilisez HTTP/2 vers le site cible à l'intérieur d'un même tunnel, toutes les requêtes sont multiplexées dans un seul flux TCP. Sous saturation, cela crée un blocage en tête de file : une réponse lourde occupe la fenêtre, et les requêtes légères attendent derrière. À travers un limiteur par connexion, c'est particulièrement douloureux : tout le multiplexage partage une seule limite.
Conclusion pratique que beaucoup tirent trop tard : le parallélisme via un proxy doit se construire sur plusieurs connexions TCP, pas sur du multiplexage dans une seule. On en tiendra compte dans la partie code.
Équité entre les flux
Comment le limiteur répartit-il la bande passante entre vos dix connexions ? Si la limite est globale et la file unique, les flux les plus agressifs, ceux qui ont le plus de données en vol, raflent la bande passante. Les petites requêtes perdent systématiquement face aux grosses. Si le limiteur utilise une file équitable, chaque flux obtient à peu près sa part. Savoir quel cas vous concerne ne s'obtient qu'expérimentalement, et c'est ce qui détermine s'il faut séparer les gros téléchargements et les petits appels API sur des connexions, voire des ports, différents.
Slow start et requêtes courtes
TCP démarre avec une petite fenêtre et la double à chaque RTT. À travers un canal mobile avec un RTT d'environ 80 millisecondes, la montée à, disons, 20 mégabits prend plusieurs centaines de millisecondes. Une requête de 50 kilo-octets se termine avant que TCP ait eu le temps d'accélérer. C'est pourquoi les requêtes courtes ne tapent jamais dans le plafond de bande passante, mais sont extrêmement sensibles à la latence. Cela divise votre trafic en deux classes aux règles différentes : les flux lourds, où le rate compte, et les flux légers, où le RTT compte. Une seule limitation étouffe les premiers, et le bufferbloat des premiers tue les seconds.
Signatures sur le graphe
Si vous tracez la vitesse seconde par seconde, les limiteurs se trahissent par leur forme :
- un plateau régulier avec une sortie en douceur et un RTT qui monte — shaper avec file profonde ;
- un plateau avec une bosse au début — shaper ou policer avec un seau burst visible ;
- une scie avec des chutes de 30 à 50 pour cent, RTT stable, retransmissions présentes — policer ;
- des oscillations chaotiques sans plateau net — vous n'avez pas touché un limiteur, mais le canal radio ou un nœud surchargé.
Savoir lire ces signatures économise des heures de débogage. Voyons maintenant comment les obtenir correctement.
Méthode 1 : mesurer correctement le plafond de bande passante
Pourquoi il faut une méthode, pas une simple vérification
Lancer un téléchargement et lire un chiffre, tout le monde sait faire. Le problème, c'est qu'un chiffre seul ne veut rien dire : il dépend de l'heure, de la source, de votre propre canal, de la phase de slow start. Il nous faut un protocole reproductible dont les résultats sont comparables entre canaux et entre jours.
Préparer une source de référence
Première règle : pour mesurer la bande passante, il faut une source elle-même plus rapide que n'importe quel proxy. Sinon, vous mesurez la source, pas le proxy. L'idéal : votre propre serveur sur une plateforme avec un uplink gigabit garanti, hébergeant des fichiers de test de 20, 100 et 500 mégaoctets générés à partir de données aléatoires. Les données aléatoires, c'est important : un fichier compressible peut être compressé en chemin, et vous obtiendrez un chiffre gonflé.
Les fichiers de test publics de CDN populaires sont utilisables, avec une réserve : le CDN sert depuis le nœud le plus proche du proxy, et vous mesurez en réalité la bande passante « proxy — CDN », pas « proxy — site quelconque ». Pour estimer le plafond, c'est acceptable ; pour estimer le goodput réel vers vos ressources cibles, non.
Éliminer son propre goulot d'étranglement
La machine depuis laquelle vous mesurez doit avoir un canal au moins trois fois plus large que le plafond attendu du proxy. Vérifiez-le par un téléchargement direct du même fichier. Coupez les téléchargements en arrière-plan, la synchronisation cloud, les mises à jour. Si vous lancez les mesures depuis un conteneur ou une machine virtuelle, assurez-vous que le réseau virtuel ne coupe pas la bande passante lui-même.
Protocole en flux unique
- Vous lancez le téléchargement d'un fichier de 100 mégaoctets via le proxy en une seule connexion, en enregistrant la vitesse chaque seconde. Avec curl, cela se fait via les clés de progression ; il est plus pratique d'écrire un petit script qui lit le corps en streaming et enregistre les octets par seconde.
- Vous jetez les trois premières secondes — slow start et vidage du seau.
- Vous arrêtez la mesure après 40 à 60 secondes ou à la fin du fichier. Moins de 20 secondes, c'est insuffisant pour voir le régime établi.
- Sur les secondes restantes, vous calculez la médiane, le dixième et le quatre-vingt-dixième percentile, le coefficient de variation (écart-type divisé par la moyenne).
- Vous répétez trois fois avec une pause d'une minute.
La médiane, c'est votre plafond établi en flux unique. L'écart entre le dixième et le quatre-vingt-dixième percentile indique la stabilité. Un coefficient de variation inférieur à 0,15 signale un canal régulier ; au-dessus de 0,4, c'est soit un policer, soit un réseau radio surchargé.
Protocole en agrégat
Maintenant, la même chose avec 2, 4, 8 et 16 connexions parallèles vers le même fichier ou plusieurs fichiers. Vous additionnez les vitesses seconde par seconde. Vous obtenez la relation entre vitesse agrégée et nombre de flux. Elle est de trois types :
- croissance linéaire jusqu'à un plateau — limite par connexion, le plafond de l'agrégat est plus haut ; le plateau révèle le niveau de limitation suivant ;
- plateau dès le premier flux — limite globale par session, les flux supplémentaires n'apportent rien et ne font qu'augmenter la latence ;
- croissance puis chute — avec beaucoup de flux, les pertes et les frais augmentent, le canal se dégrade. L'optimum est là où la croissance s'arrête.
Un curl unique pour un repérage rapide ressemble à ceci : curl -x http://user:pass@host:port -o /dev/null -w "%{speed_download} %{time_total}" https://your-server/100mb.bin. Il donne la vitesse moyenne sur tout le fichier, ce qui suffit pour une première estimation, mais pour les signatures, il faut un enregistrement seconde par seconde.
Déploiement temporel
Pour un canal mobile, une mesure sur quatre fenêtres horaires est obligatoire : nuit, matin, jour, soir. Le plafond en soirée dans un quartier résidentiel peut être deux fois plus bas que la nuit. Si vous prévoyez une charge 24 heures sur 24, votre code devra vivre selon le plafond du soir, pas celui de la nuit.
Checklist de mesure du plafond
- Source de référence garantie plus rapide que le proxy, fichiers à données aléatoires.
- Propre canal vérifié séparément et au moins trois fois plus large.
- Enregistrement seconde par seconde des octets, trois premières secondes jetées.
- Durée du régime établi d'au moins 20 secondes.
- Trois répétitions, médiane et percentiles, coefficient de variation.
- Série selon le nombre de flux : 1, 2, 4, 8, 16.
- Quatre fenêtres horaires pour les canaux mobiles.
- Résultats consignés dans un format unique avec heure, port, source.
Méthode 2 : identifier le type de limiteur et ses paramètres
Pourquoi savoir à quoi on a affaire
Un même plafond de 10 mégabits exige un code différent selon qu'il s'agit d'un shaper ou d'un policer, selon qu'il y a un seau burst et de quelle taille, selon que la latence monte ou non sous charge. Cette méthode transforme le graphe de vitesse en un jeu de paramètres qui viendront ensuite dans la config de votre client.
Test de burst : mesurer le seau
- Vous laissez le canal se reposer 30 secondes sans trafic, pour que le seau se remplisse.
- Vous lancez un téléchargement et enregistrez la vitesse avec une résolution de 100 à 200 millisecondes pendant les cinq premières secondes.
- Vous repérez le moment où la vitesse chute à la valeur établie de la Méthode 1.
- Vous estimez le volume du seau comme le total des octets transmis jusqu'à ce moment, moins ce qui serait passé sur la même durée à vitesse établie.
Exemple : les premières 1,5 seconde filent à 40 mégabits, puis pile 10. Le seau fait environ 40 moins 10, fois 1,5 seconde, divisé par 8 — environ 5,6 mégaoctets. Cela signifie que les requêtes jusqu'à 5 mégaoctets, espacées par des pauses, passeront à la vitesse « rapide ». Un excellent outil de planification si votre charge se compose de réponses moyennes.
S'il n'y a pas de burst et que la vitesse atteint le plateau avec une montée en douceur, le seau est petit ou absent, et le limiteur est probablement un shaper à rate strict.
Test de latence sous charge
C'est le test clé pour distinguer shaper et policer. En parallèle d'un long téléchargement, vous lancez une série de requêtes légères via le même port proxy : par exemple, un HEAD vers votre serveur toutes les 500 millisecondes. Vous enregistrez le temps de réponse avant, pendant et après la charge.
- La latence explose, jusqu'à des centaines de millisecondes ou des secondes, alors que la vitesse reste régulière — shaper à file profonde. Notez la profondeur : l'augmentation de latence multipliée par le rate donne la taille approximative du buffer en octets.
- La latence ne change presque pas, mais la statistique de connexion montre des retransmissions et la vitesse est en dents de scie — policer.
- La latence augmente modérément, de 50 à 150 millisecondes, vitesse régulière — shaper à file gérée, le cas le plus confortable.
Sur Linux, les statistiques de retransmission se consultent avec ss -ti sur la connexion concernée : on y trouve les compteurs retrans et le RTT actuel. C'est un moyen gratuit et précis de voir si des paquets sont perdus.
Test d'agrégation : par connexion ou par session
Vous avez déjà obtenu la courbe de la Méthode 1. Affinez-la : lancez une connexion à fond et une seconde limitée côté client à 10 pour cent du plafond. Si la première ne ralentit presque pas — les limites sont séparées par connexion. Si la première perd exactement ce que prend la seconde — la limite est globale. Ce test coûte moins cher qu'une série de 16 flux et donne une réponse sans ambiguïté.
Séparer le limiteur du canal radio
Comment savoir si le plateau est un réglage ou de la physique cellulaire ? Trois signes d'un réglage : le plateau tient à quelques pour cent près à différentes heures, le chiffre est « rond » (5, 10, 20, 50 mégabits), et la forme de montée vers le plateau est identique à chaque répétition. Le canal radio donne des valeurs « non rondes » et fluctuantes selon l'heure. En complément, mesurez un second port du même nœud au même instant : si deux ports donnent en somme plus qu'un seul, la limite est par port, pas par modem.
Cadre de classification
Rassemblez les résultats dans une fiche de canal :
- Plafond d'un flux : médiane, coefficient de variation.
- Plafond d'agrégat : valeur et nombre de flux pour l'atteindre.
- Niveau de la limite : connexion, session, nœud.
- Type : shaper ou policer.
- Seau : volume en mégaoctets ou « aucun ».
- Profondeur de file : augmentation de latence sous charge.
- Profil journalier : plafonds sur les quatre fenêtres.
Cette fiche est l'entrée directe de la configuration du client. Sans elle, vous réglerez les paramètres au feeling.
Méthode 3 : écrire un client qui s'accorde avec le limiteur
Philosophie : ne pas se battre, négocier
Le grand déclic qui vient après une dizaine de systèmes débuggés : un limiteur ne se « perce » pas avec plus de flux. On ne peut que remplir sa file et récolter du bufferbloat, ou provoquer un policer en pertes massives. Un client efficace maintient lui-même sa vitesse un peu sous le plafond pour que la file du limiteur reste presque vide et la latence basse. Un paradoxe qui surprend les débutants : en baissant la vitesse de 10 pour cent, on augmente souvent le goodput, parce que les timeouts et les retransmissions disparaissent.
Composant 1 : le token bucket côté client
Implémentez chez vous le même seau que le limiteur, mais avec un rate à 85–90 pour cent du plafond établi mesuré et un volume de seau ne dépassant pas la moitié du seau mesuré du proxy. Le limiteur s'applique à la lecture du corps de la réponse : avant de lire le prochain chunk, vous demandez au seau autant de jetons que d'octets à lire, et vous attendez s'il n'y en a pas. La logique étape par étape :
- Gardez deux nombres : le stock actuel de jetons et l'heure du dernier remplissage.
- À la demande de N jetons, remplissez d'abord :
tokens = min(burst, tokens + (now - last) * rate). - Si les jetons suffisent, soustrayez et continuez. Sinon, calculez le temps d'attente
(N - tokens) / rateet dormez en asynchrone. - Un seul seau par port proxy, partagé par toutes les connexions via ce port si la limite est par session. Si la limite est par connexion — un seau par connexion plus un global par nœud.
Pourquoi limiter la lecture et non les requêtes ? Parce que c'est la lecture qui détermine à quelle vitesse les données sont tirées de la file du limiteur. Si vous lisez plus lentement que ce que le proxy envoie, TCP signalera lui-même à l'expéditeur de réduire sa fenêtre, et les données cesseront de s'accumuler dans les buffers intermédiaires. C'est exactement ça, la backpressure à l'état pur.
Composant 2 : sémaphore de parallélisme
Limitez le nombre de connexions simultanées par port avec un sémaphore. La valeur de départ vient de la courbe d'agrégat de la Méthode 1 : le nombre de flux où la croissance s'est arrêtée, moins un. Pour un canal mobile typique, c'est 4 à 8. Au-delà, seule la latence augmente.
Composant 3 : lecture en streaming et timeout de progression
Ne mettez jamais un timeout unique pour toute la requête. Un fichier de 50 mégaoctets à un plafond de 5 mégabits se téléchargera honnêtement en 80 secondes, et un timeout de 30 secondes le tuera à la moitié, gaspillant la moitié de la bande passante. La bonne approche : un timeout de connexion (5 à 10 secondes), un timeout sur le premier octet (10 à 20 secondes en tenant compte du bufferbloat possible) et un timeout de progression — l'intervalle maximal entre deux chunks lus avec succès, généralement 15 à 30 secondes. Vous lisez le corps par chunks de 32 à 64 kilo-octets, et après chaque chunk vous mettez à jour la marque de progression.
Composant 4 : parallélisme adaptatif selon AIMD
Le plafond d'un canal mobile fluctue, et un sémaphore statique ne le suit pas. La solution : piloter le parallélisme dynamiquement selon le principe d'augmentation additive et de diminution multiplicative, exactement comme TCP :
- Toutes les 10 secondes, vous calculez le goodput sur la fenêtre et la latence médiane du premier octet.
- Si la latence est inférieure à une fois et demie la latence de base et qu'il n'y a pas d'erreurs — vous augmentez la limite du sémaphore de un, jusqu'à la borne supérieure.
- Si la latence a plus que doublé par rapport à la base ou si des timeouts de progression apparaissent — vous divisez la limite par deux, sans descendre sous un.
- La latence de base se mesure au démarrage avec une seule connexion et se recalcule toutes les heures.
Un tel contrôleur trouve en quelques minutes le point confortable et s'y tient, se resserrant automatiquement le soir et s'élargissant la nuit. On a vu ce mécanisme augmenter le goodput journalier de 20 à 35 pour cent sans toucher au plafond.
Composant 5 : retries avec délai exponentiel et jitter
Un timeout est un signal de congestion, pas une invitation à réessayer immédiatement. Un retry immédiat aggrave la file. Règle : premier retry après 1 à 2 secondes, chaque suivant deux fois plus long, maximum 5 tentatives, avec un jitter aléatoire jusqu'à 50 pour cent ajouté à chaque délai, pour que dix flux ne se réveillent pas en même temps. En cas de timeout de progression sur un gros fichier, il est pertinent de reprendre à l'endroit de la coupure avec une requête munie de l'en-tête Range, si le serveur le supporte : la bande passante dépensée sur la première moitié ne sera pas perdue.
Composant 6 : files prioritaires
Séparez les tâches en classes : interactives (petits appels API, où la latence compte) et de fond (gros téléchargements). Les tâches de fond reçoivent une part du seau, disons 70 pour cent, les interactives une réserve garantie. Si la limite est par connexion et non par session, répartissez les classes sur des connexions différentes. Si possible — sur des ports proxy différents. Ainsi, un gros fichier ne bloquera pas cent petites requêtes.
Composant 7 : compter les octets, pas les requêtes
Comptez chaque octet lu par port, par classe et par domaine cible. Exportez-les en métriques. Ce sont ces chiffres qui montreront où passe la bande passante, et qui permettront de planifier un budget, ce dont on parle dans la méthode suivante.
Mini-squelette en Python
Le schéma d'implémentation sur asyncio et n'importe quel client HTTP asynchrone ressemble à ceci :
- Classe
TokenBucketavec une méthodeasync def take(n)selon la logique du Composant 1. - Classe
Channel: adresse du proxy, seau, sémaphore, compteurs, contrôleur AIMD. - Fonction
async def fetch(channel, url): sous sémaphore, ouvre la requête via le proxy, attend les en-têtes avec un timeout de premier octet, puis lit en bouclechunk = await resp.content.read(65536), en appelant avant celaawait channel.bucket.take(len(chunk)), met à jour la marque de progression et les compteurs d'octets. - Tâche de fond
async def tune(channel): toutes les 10 secondes, lit les métriques et ajuste la taille du sémaphore. - Enveloppe de retry avec délai exponentiel et support de Range.
Détail important pour Python : les clients standards bufferisent par défaut toute la réponse en mémoire. Assurez-vous d'utiliser le mode streaming, sinon il n'y aura pas de backpressure et le limiteur en lecture sera inutile. En Go, l'équivalent se construit sur un io.Reader avec une enveloppe limiteur et golang.org/x/time/rate ; en Node.js — sur pause et reprise du flux de réponse.
Checklist du client
- Seau côté client avec rate à 85–90 pour cent du plafond.
- Lecture en streaming par chunks, limiteur en lecture.
- Trois timeouts séparés : connexion, premier octet, progression.
- Sémaphore à pilotage adaptatif selon la latence.
- Retries avec délai exponentiel, jitter et Range.
- Séparation des tâches interactives et de fond.
- Parallélisme sur plusieurs connexions TCP, pas sur du multiplexage dans un seul tunnel.
- Comptage des octets par port, classe et domaine.
Méthode 4 : budget de trafic et architecture de la charge
Pensez en octets
La plupart des systèmes planifient la charge en requêtes par seconde. Or le limiteur de bande passante compte les octets. Un appel API de 4 kilo-octets et le chargement d'une page de 3 mégaoctets, c'est une différence d'un facteur 750. Première étape de la méthode — traduire votre plan en octets : combien de réponses de quelle taille recevez-vous par heure, et le profil journalier de plafond de la fiche de canal suffit-il ?
Formule simple : la capacité journalière du canal en octets est la somme sur les quatre fenêtres du produit du plafond par la durée de la fenêtre, multipliée par un coefficient de 0,8 pour les frais et la marge. Pour un canal avec un plafond nocturne de 20 mégabits et un plafond du soir de 8 mégabits, la capacité journalière sera de l'ordre de 120 à 130 gigaoctets. Si votre plan en demande 300, aucune optimisation de code n'aidera, il faut d'autres canaux.
Réduire le volume de chaque requête
- Compression : envoyez toujours l'en-tête Accept-Encoding avec gzip et br. Les réponses texte se compressent d'un facteur 4 à 8. Si votre client ne décompresse pas automatiquement les réponses, activez-le.
- Refus des ressources inutiles : en automatisation navigateur, bloquez le chargement des images, polices et médias s'ils ne sont pas nécessaires à la tâche. Cela économise 60 à 80 pour cent du trafic d'une page.
- Requêtes conditionnelles : conservez les ETag et Last-Modified, envoyez If-None-Match. Une réponse 304 pèse quelques centaines d'octets au lieu de mégaoctets.
- HEAD avant GET : s'il faut vérifier la présence ou la taille d'une ressource, ne la téléchargez pas.
- Requêtes Range : quand seule une partie du fichier est nécessaire, par exemple les métadonnées au début, demandez la plage.
- Champs d'API : beaucoup d'API supportent la sélection des champs de réponse. Demandez uniquement le nécessaire.
Répartition entre canaux
S'il y a plusieurs canaux, ne répartissez pas les tâches à parts égales. Répartissez proportionnellement au plafond actuel, que vous mesurez à la volée via le goodput de chaque canal. Le planificateur garde une file de tâches et donne la suivante au canal dont le seau est le plus libre et la latence la plus basse. Un canal en dégradation reçoit automatiquement moins de travail, sans intervention manuelle.
Planification dans le temps
Déplacez les tâches volumineuses de fond vers les fenêtres nocturnes, quand le plafond est plus élevé. Les tâches interactives et urgentes se répartissent uniformément, mais avec une réserve de bande passante. Cela paraît banal, mais en pratique peu de gens construisent un planificateur tenant compte du profil journalier du canal. La différence de goodput journalier avec une telle planification atteint 40 pour cent sur le même ensemble de canaux.
Disjoncteur
Prévoyez dans le client un disjoncteur strict : si le goodput d'un canal sur les deux dernières minutes tombe sous 20 pour cent de la médiane de la fiche et que la latence a plus que quadruplé, le canal est temporairement retiré de la rotation pendant 5 minutes. Cela protège contre la situation où une cellule surchargée ou un nœud défaillant entraîne tout le système dans des retries sans fin.
Checklist du budget
- Le plan est traduit en octets par classe de tâches.
- La capacité journalière des canaux est calculée selon le profil avec une marge de 20 pour cent.
- Compression, blocage des ressources inutiles, requêtes conditionnelles, Range sont appliqués.
- Le planificateur répartit selon le goodput actuel, pas à parts égales.
- Les tâches volumineuses sont décalées vers les fenêtres à plafond élevé.
- Le disjoncteur sur goodput et latence est réglé.
Erreurs classiques : ce qu'il ne faut absolument pas faire
Ajouter des flux jusqu'à ce que ça accélère
L'erreur la plus répandue. Avec une limite globale par session, les flux supplémentaires ne font qu'allonger la file du shaper. La vitesse ne monte pas, la latence monte, les timeouts pleuvent. Avec un policer — les pertes augmentent, et l'agrégat peut même chuter. L'augmentation du parallélisme ne se justifie que jusqu'au point où la courbe d'agrégat atteint le plateau.
Un seul timeout pour toute la requête
Cela tue les gros téléchargements légitimes à mi-parcours et gaspille la bande passante. Utilisez un timeout de progression.
Retries instantanés
Sous congestion, un retry sans pause double la charge sur la file. Dix flux qui réessaient en même temps déclenchent une petite tempête. Délai exponentiel et jitter obligatoires.
Mesurer le plafond en une seule fois
Un chiffre à 14 heures un mardi ne dit rien du comportement du canal à 20 heures un vendredi. Sans profil journalier, vous sous-chargez le canal ou construisez un système sur une bande passante inexistante.
Mesurer contre une source lente
Un serveur public à l'uplink surchargé vous montrera son plafond, pas celui du proxy. Vérifiez la source directement.
Bufferiser toute la réponse
Sans lecture en streaming, pas de backpressure. Le client « avale » tout ce que le proxy donne, et le limiteur côté client ne fonctionne pas. En plus, c'est de la mémoire gaspillée sur les grosses réponses.
Multiplexer tout dans un seul tunnel
HTTP/2 dans un seul CONNECT, avec une limite par connexion, partage la bande passante entre toutes les requêtes et crée un blocage en tête de file. Plusieurs connexions TCP sont presque toujours plus efficaces via un proxy.
Ignorer la compression
Un Accept-Encoding désactivé signifie que vous payez en bande passante pour du texte non compressé. Un facteur cinq pour rien.
Confondre bande passante et latence
Un canal à 50 mégabits avec un RTT de 400 millisecondes est plus lent pour cent petits appels API qu'un canal à 10 mégabits avec un RTT de 60 millisecondes. Évaluez les deux paramètres selon votre profil de trafic.
Compter les requêtes, pas les octets
Planifier en requêtes par seconde ne tient pas compte de la taille des réponses et mène à un mur inattendu.
Outils et ressources
Pour les mesures
- curl — l'outil universel pour les mesures rapides via proxy. La clé d'affichage des variables de temps donne la vitesse moyenne, le temps jusqu'au premier octet, le temps de connexion. Pour l'enregistrement seconde par seconde, dix lignes de Python suffisent.
- iperf3 — pour mesurer la bande passante brute entre votre machine et votre serveur en direct, afin d'éliminer votre propre goulot d'étranglement. Il ne fonctionne pas via un proxy HTTP, mais comme contrôle de source, il est irremplaçable.
- ss avec la clé -ti — statistiques des connexions TCP sous Linux : RTT, fenêtre de congestion, retransmissions, algorithme de contrôle de congestion. Le principal détecteur gratuit de policer.
- tcpdump et Wireshark — quand il faut voir ce qui se passe exactement au niveau des paquets : motifs de pertes, délais d'accusés de réception, comportement de la fenêtre.
- mtr — trace avec pertes par nœud, aide à comprendre où exactement les pertes apparaissent sur le chemin vers le proxy.
Pour l'émulation locale
Avant de tester le code sur un vrai proxy, montez un banc. Sous Linux, l'utilitaire tc avec les disciplines tbf (token bucket filter) et netem permet d'émuler un shaper à rate et burst donnés, un policer, une latence et des pertes. Vous pouvez reproduire la fiche de canal localement et tester le client contre elle autant que vous voulez, sans dépenser de trafic et sans dépendre de l'heure. Les développeurs qui montent un tel banc déboguent le client bien plus vite.
Pour le code
- Python : asyncio, aiohttp ou httpx en mode streaming, votre propre token bucket en 20 lignes. Des bibliothèques de limiteurs existent, mais la plupart limitent les requêtes, pas les octets, donc une implémentation maison est plus fiable.
- Go : le paquet rate de la bibliothèque standard étendue, une enveloppe sur io.Reader pour limiter la lecture, un contexte avec deadlines pour les timeouts.
- Node.js : réponse en streaming avec gestion manuelle de la pause et de la reprise, bibliothèques pour sémaphores et retries.
Pour l'observabilité
Exportez les métriques de goodput, de latence du premier octet, de nombre de connexions actives, de timeouts et de retries par port proxy dans un système de collecte et construisez des tableaux de bord. Les signatures du limiteur se voient sur les graphes en une minute, et les anomalies du canal bien avant qu'elles ne fassent tomber la tâche. Sans observabilité, le contrôleur adaptatif ne peut être ni réglé ni vérifié.
Quoi lire
Les spécifications RFC sur le contrôle de congestion TCP et sur les algorithmes de gestion active de file donnent une compréhension profonde de pourquoi les shapers se comportent ainsi. La documentation Linux sur les disciplines de files tc est un manuel pratique d'émulation. Les articles sur le bufferbloat expliquent pourquoi les buffers profonds nuisent et comment on les combat au niveau du matériel réseau.
Cas concrets et résultats
Cas 1 : un scraper de catalogue de marketplace qui « mourait » le soir
Tâche : parcours quotidien d'un catalogue, environ 400 000 pages, via huit canaux mobiles. Symptômes : la nuit, le système terminait en cinq heures ; le soir, des timeouts à une requête sur trois, le plan journalier n'était pas tenu.
La mesure par la Méthode 1 a montré : plafond nocturne du canal autour de 18 mégabits, plafond du soir 6–7. Méthode 2 : shaper à file profonde, latence sous charge passant de 90 à 1400 millisecondes, limite globale par session. Le client utilisait 32 flux par canal et un timeout unique de 20 secondes.
Ce qui a été fait : introduction d'un seau côté client à 85 pour cent du plafond actuel, réduction du parallélisme initial à 6 avec contrôleur adaptatif, remplacement du timeout par un timeout à trois niveaux, activation de la compression et du blocage des images (les pages sont passées de 1,4 mégaoctet à 180 kilo-octets). Résultat : le taux de timeouts du soir est passé de 33 à 0,4 pour cent, le goodput journalier a augmenté de 41 pour cent avec le même ensemble de canaux, et le parcours tient en 7 heures à toute heure. Le plus révélateur : réduire le parallélisme de 32 à 6 a augmenté la vitesse utile au lieu de la diminuer.
Cas 2 : téléchargement de médias et policer
Tâche : téléchargement de vidéos de 40 à 200 mégaoctets depuis un hébergement public via proxy, environ 2 téraoctets par mois. Symptômes : vitesse en dents de scie, moyenne deux fois inférieure à l'annoncé, coupures fréquentes à mi-fichier.
La mesure a montré une scie classique : chutes de 40 à 50 pour cent toutes les quelques secondes, RTT stable, compteur de retransmissions grimpant à des dizaines par seconde. Policer avec limite par connexion d'environ 12 mégabits, agrégat jusqu'à 4 flux croissant presque linéairement.
Ce qui a été fait : chaque fichier découpé en quatre parties par Range et téléchargé en parallèle sur quatre connexions, chacune avec un seau client à 10 mégabits, juste sous la limite du policer, pour ne pas provoquer de pertes. Ajout de la reprise par Range en cas de timeout de progression. Résultat : la vitesse moyenne par fichier est passée de 5,5 à 36 mégabits, les coupures ne font plus perdre le déjà téléchargé, et le volume mensuel passe en 12 jours au lieu de 30. On ne trompe pas un policer, mais on peut ne pas lui donner de raison de jeter des paquets.
Cas 3 : charge mixte API et téléchargements
Tâche : travail simultané avec l'API d'une plateforme sociale (milliers de petites requêtes) et export de médias en arrière-plan via les mêmes canaux. Symptômes : les appels API tombaient périodiquement à une latence de 3 à 5 secondes, la plateforme commençait à considérer le client comme lent.
Diagnostic : shaper par session, les téléchargements de fond remplissaient la file, les petites requêtes se retrouvaient derrière. Un bufferbloat classique dans une même session.
Ce qui a été fait : séparation des classes sur différents ports proxy d'un même nœud ; sur les ports des téléchargements de fond, seau à 70 pour cent de leur plafond ; sur les ports API, parallélisme maximal de 3 et priorité sur la latence. Résultat : le quatre-vingt-dixième percentile de latence API est passé de 3,8 secondes à 210 millisecondes, les téléchargements de fond ont ralenti de 12 pour cent, ce qui était acceptable. L'efficacité globale du système, mesurée en opérations réussies par heure, a augmenté de 27 pour cent.
FAQ : questions pointues sur la bande passante et le shaping
Pourquoi avec un seul flux j'ai 8 mégabits, et avec dix j'ai toujours 8, mais tout est plus lent ?
La limite est par session, pas par connexion. Dix flux partagent un seul rate et remplissent la file du shaper. La bande passante ne monte pas, la latence monte proportionnellement à la profondeur de la file. Le mieux est de tenir 2 à 4 flux et de limiter la lecture côté client.
Comment savoir que j'ai touché le canal radio et non la configuration du proxy ?
Une configuration donne un plateau stable avec un chiffre « rond » à différentes heures et une forme de montée identique. Le canal radio donne des valeurs fluctuantes non rondes et un coefficient de variation élevé, surtout le soir. En complément, comparez deux ports du même nœud au même instant : si la somme dépasse un seul port, la limite est par port, pas par modem.
Faut-il activer BBR sur son serveur quand on travaille via proxy ?
BBR agit sur le flux sortant de votre serveur. Si vous envoyez des données via un proxy, il aidera à garder la file du shaper vide et réduira la latence. Sur le flux entrant des sites cibles vers vous, il n'agit pas : c'est l'expéditeur qui contrôle. Côté client, c'est le limiteur en lecture qui compte.
De combien en dessous du plafond faut-il maintenir le seau client ?
Pour un shaper — 85 à 90 pour cent du plafond établi : la file reste presque vide, la latence basse, la perte de bande passante minimale. Pour un policer — 80 à 85 pour cent de la limite par connexion, pour ne pas provoquer de rejets. Pour un canal radio instable, mieux vaut confier le point au contrôleur adaptatif et régler le seau sur le profil du soir.
Peut-on utiliser HTTP/2 via un proxy pour accélérer ?
Via un tunnel CONNECT, HTTP/2 vers le site cible fonctionne, mais tous les flux partagent une seule connexion TCP et une seule limite, si elle est par connexion. En plus, le blocage en tête de file sous saturation. Pour les tâches lourdes, plusieurs connexions HTTP/1.1 via le proxy donnent généralement un meilleur goodput et une latence prévisible.
Comment mesurer plus précisément la taille du seau burst ?
Laissez le canal se reposer 30 à 60 secondes, enregistrez les octets avec une résolution de 100 millisecondes, repérez le point de rupture vers la vitesse établie, calculez l'excédent au-dessus de la ligne établie. Répétez cinq fois, prenez la médiane. Une précision d'environ 15 pour cent suffit pour planifier.
Que faire si les timeouts n'apparaissent que sur certains domaines ?
Le goulot d'étranglement n'est probablement pas dans le proxy, mais sur le chemin du proxy vers ce domaine ou sur le domaine lui-même. Mesurez le plafond contre votre source de référence au même moment : s'il est normal, la limitation est externe. Dans le code, attribuez à ce domaine une classe séparée avec moins de parallélisme et un timeout de premier octet plus long.
Comment savoir que le contrôleur adaptatif fonctionne correctement ?
Sur les graphes, le parallélisme doit diminuer doucement le soir et remonter la nuit, la latence du premier octet doit rester dans une à deux fois la valeur de base, et la part de timeouts doit être sous un pour cent. Si le parallélisme oscille entre minimum et maximum chaque minute, la fenêtre d'évaluation est trop courte ou le seuil de réaction trop sensible.
Faut-il tenir compte du chiffrement dans le calcul des octets ?
TLS ajoute 2 à 5 pour cent de frais en en-têtes d'enregistrement et en poignées de main. Pour planifier un budget, un coefficient de 0,8 sur le tout, TCP/IP compris, suffit. Pour un comptage précis, comptez les octets au niveau du socket, pas au niveau du corps de la réponse.
Conclusion : des suppositions à la bande passante maîtrisée
On a parcouru le chemin des concepts de base à l'architecture d'un client qui ne se bat pas contre le limiteur, mais s'accorde avec lui. Résumons l'essentiel.
- Le plafond est le minimum de plusieurs niveaux, et pour les canaux mobiles il fluctue au cours de la journée. Un seul chiffre ne veut rien dire, il faut un profil.
- Shaper et policer exigent un code différent. Le shaper punit par la latence, le policer par les pertes. On les distingue en dix minutes avec un test de latence sous charge et la statistique de retransmissions.
- La saturation, ce n'est pas une question de vitesse, mais de file. Le bufferbloat transforme un canal rapide en canal pâteux et tue les petites requêtes avant même que la vitesse des grosses ne chute.
- Le client doit lire en streaming, limiter la lecture juste sous le plafond, utiliser trois timeouts séparés, piloter le parallélisme de façon adaptative et réessayer avec délai.
- Planifiez des octets, pas des requêtes. La compression, le refus des ressources inutiles et les requêtes conditionnelles donnent souvent plus que n'importe quelle astuce sur les flux.
Que faire ensuite ? Aujourd'hui : monter une source de référence et établir la fiche de canal selon les Méthodes 1 et 2, au moins pour un port. Cette semaine : monter un banc local sous tc, reproduire la fiche et réécrire le client selon la checklist de la Méthode 3. Dans le mois : activer le comptage des octets, construire les tableaux de bord et régler le contrôleur adaptatif, puis recalculer le budget de trafic selon la Méthode 4.
La bande passante cesse d'être une source de surprises exactement au moment où vous commencez à la mesurer et à la respecter. Un code écrit avec la compréhension du limiteur ne fonctionne pas seulement plus vite. Il fonctionne de manière prévisible, et dans les tâches d'infrastructure, la prévisibilité est la principale monnaie.