Produit

Comment fonctionne le simulateur de trafic

Le simulateur de RodGrid est un modèle de capacité déterministe aux hypothèses publiées — voici comment le modèle fonctionne, chiffres compris, et ce qu'il n'est volontairement pas.

Un simulateur n'est honnête que si ses hypothèses le sont, alors le simulateur de trafic de RodGrid publie les siennes : le modèle est déterministe, ses chiffres de capacité sont affichés dans le produit, et cet article explique son fonctionnement.

Un tableur posé sur le graphe

Aucune IA n'intervient, et il n'a besoin d'aucun serveur. Le simulateur est un calculateur déterministe en régime permanent : vous lui donnez un nombre de requêtes par seconde et il fait passer cette charge dans le diagramme en ordre topologique, en rapportant l'utilisation, la latence et le taux d'erreur de chaque nœud, plus les totaux à l'échelle du Grid. Lancez-le deux fois sur le même Grid et vous obtenez la même réponse — ce qui permet de noter les défis équitablement avec lui.

La capacité vient du type de composant

Chaque nœud reçoit un profil de capacité déterminé par son rôle sémantique — load balancer, cache, service applicatif, base de données relationnelle, file d'attente, API de modèle, etc. Chaque profil tient en quelques nombres : les requêtes par seconde soutenables par instance, la latence de base et un taux d'erreur de référence.

Les valeurs absolues sont volontairement rondes, des repères d'ordre de grandeur. Ce qui enseigne, ce sont les rapports — un cache absorbe environ dix fois ce que supporte une base de données relationnelle : il peut donc encaisser une charge de lecture qui submergerait la base, et avec un bon taux de succès, seuls les défauts de cache l'atteignent. Le tableau « Hypothèses du modèle » du produit est généré en direct à partir du même registre que lit le moteur, si bien que les chiffres publiés ne peuvent jamais s'écarter de ceux réellement utilisés.

Le rapport qui fait du cache un pattern

Diagram components: Application Service, Redis, PostgreSQL.

Activez le simulateur sur un Grid comme celui-ci et augmentez le trafic : le cache absorbe les lectures à ~10× la capacité de la base de données, et les défauts de cache qui passent au travers sont ce que la base doit réellement supporter.

Comment la charge se propage

  • Les nœuds sont classés par rôle dans un petit ensemble de comportements : points d'entrée, répartiteurs (load balancers et passerelles), caches, stockages, canaux asynchrones (files/flux), services et dépendances externes. Les formes et les nœuds d'annotation sont inertes — ils ne sont tout simplement pas simulés.
  • Un nœud ne transmet que ce qu'il peut réellement servir : le minimum entre ce qui arrive et sa capacité multipliée par son nombre de réplicas. Chaque arête peut aussi indiquer des appels par requête amont, de sorte qu'un appel occasionnel à un modèle ne reçoive pas à tort chaque requête. Aucun débit fantôme en aval d'un goulot d'étranglement.
  • Le trafic au-delà de la capacité d'un nœud reste sans réponse, en totalité, et compte contre la disponibilité — sans répartition inventée entre parts en file, rejetées et en erreur. Les files d'attente font exception : ce qu'une file, ou les consommateurs derrière elle, ne peut pas absorber devient un backlog croissant, pas un échec.
  • L'attente dans la file d'un nœud suit une approximation standard multi-serveurs (Sakasegawa), calculée par réplica, où le nombre de serveurs est le nombre de requêtes qu'un réplica sert en même temps. Ce nombre détermine à quel point l'utilisation fait mal. Avec la variabilité par défaut du modèle, à 90 % un grand pool n'a presque pas de file d'attente, alors qu'un service qui traite une requête à la fois attend en moyenne neuf fois son temps de service, si bien qu'une requête prend dix temps de service au total. À 100 % ou plus, l'attente n'a plus de borne, et le simulateur le dit au lieu d'afficher un chiffre.
  • Les caches absorbent leur taux de succès et transmettent les défauts de cache plus les écritures ; les répartiteurs divisent entre cibles équivalentes ; les canaux asynchrones découplent la chaîne de latence.

Les réplicas ne sont qu'une propriété du nœud — réglez un service sur 4 réplicas et sa capacité est multipliée, exactement comme on l'espère, avec pour exception délibérée les services tiers : on ne met pas à l'échelle l'API de quelqu'un d'autre en en dessinant davantage.

Ce qu'il n'est volontairement pas

  • Pas une simulation à événements discrets. Aucun modèle de file d'attente au niveau de la requête, aucune gigue, aucune distribution de latence de queue — une vérification de capacité en régime permanent, par conception.
  • Pas un benchmark de fournisseur. Les chiffres de capacité sont des repères représentatifs pour raisonner, pas des valeurs annoncées pour un type d'instance précis.
  • Pas une facture. L'infrastructure provisionnée utilise des fourchettes d'ordre de grandeur. Les services facturés à l'usage sans prix par défaut, dont les API de modèles et les autres services tiers, ainsi que la part d'usage des bases de données et des autres stockages, affichent « Facturé à l’usage — non estimé » tant que vous ne fournissez pas les heures d'activité et les tarifs unitaires pertinents, et tant qu'il en reste un, le panneau n'affiche aucun total combiné. Les composants qui ne transportent pas de trafic de requêtes, comme la supervision ou la CI/CD, peuvent quand même avoir un coût — le modèle de trafic et la classification de facturation sont deux choses distinctes.
Astuce La meilleure façon d'étalonner votre intuition est de casser une conception : armez un preset de stress (la ruée sur le cache est un classique) et regardez quel composant devient le goulot d'étranglement, et quelle hypothèse l'explique.