Aller au contenu
English

Plan de capacité à partir d'une trace de trafic publique

  • Étude de cas 1
  • 150 min
  • Facultative · 1 étude de cas requise pour le certificat

Où nous en sommes

Cette étude de cas applique le modèle de charge de travail, la file d'attente et la recommandation de capacité de ce cours à un vrai journal de requêtes du service 311 d'une ville. Vous trouvez les pointes qu'une moyenne cache, choisissez le nombre de processus pour un délai d'attente cible et précisez où le plan s'arrête.

Ce que vous saurez faire

Transformez un journal public de requêtes réelles en plan de capacité pour le travail d’IA. Vous trouverez les pointes qu’une moyenne cache. Vous les rejouerez dans une file d’attente avec les durées de tâches mesurées dans le cours. Vous choisirez le nombre de processus pour un délai d’attente cible. Vous testerez ce choix une seule fois sur des mois gardés de côté. Ensuite, vous rédigerez une recommandation qui précise ses hypothèses et ses limites.

Étude de casPièce de portfolio

Durée
Environ 2 h 30
S’exécute dans
Colab, Kaggle ou VS Code
Compétences utilisées
  • Modèle de charge de travail à partir d'une trace
  • Centiles à trois échelles de temps
  • Détection des pointes
  • Simulation de file d'attente
  • Point de dimensionnement
  • Vérification sur des données gardées de côté
  • Quota et panne
  • Recommandation de capacité

Les carnets sont en anglais. Colab et Kaggle ouvrent votre propre copie. Pour utiliser VS Code, téléchargez le carnet depuis GitHub. Vous êtes bloqué ? Consultez le carnet de solution.

Cette étude de cas est un carnet (notebook) Jupyter, pas un dossier de projet. Le travail consiste à analyser : lire une année d’horodatages, compter, simuler et comparer. Un carnet montre chaque étape et sa sortie. Il s’exécute sur Colab gratuit en environ 2 minutes, sans Docker ni base de données. Une partie facultative, Vérifier le modèle sur votre ordinateur, rejoue quelques minutes de la trace sur votre propre ticket-api. Un modèle de file d’attente devrait rencontrer une vraie file au moins une fois.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 150 minutes

Ce que vous devez savoir

Cette étude de cas utilise tout le cours. Ces leçons comptent le plus :

Cette page enseigne une chose absente du cours : une simulation de file d’attente qui rejoue les heures d’arrivée réelles.

Ce qu’il vous faut sur votre ordinateur

  • Pour le carnet : rien. Il s’ouvre dans Colab ou Kaggle, installe pandas 3.0.6 et télécharge les données (environ 4,4 Mo). Dans VS Code ou Jupyter, utilisez un environnement virtuel avec pandas 3.0.6, numpy et matplotlib. Le carnet travaille dans un nouveau dossier capacity-plan; pour recommencer, supprimez ce dossier.
  • Pour le rejeu facultatif seulement : le projet du cours à la fin de Recommandation de capacité, avec PostgreSQL et Valkey en cours d’exécution. Si le vôtre ne fonctionne plus, téléchargez l’instantané end-of-m06 du cours et suivez son README.

Testé sur macOS avec Python 3.12.13, pandas 3.0.6, numpy 2.5.3 et matplotlib 3.11.2, dans Jupyter depuis un démarrage propre. Le rejeu a fonctionné sur macOS (Apple silicon) avec le projet à la fin du module 6. Windows et Linux n’ont pas été testés; les commandes sont celles du cours.

Nadia dirige l’équipe numérique du service 311 d’une ville. Les résidents appellent, utilisent une application ou remplissent un formulaire Web pour signaler un nid-de-poule, des graffitis ou un trottoir bloqué. Chaque signalement devient une demande de service, que les agents acheminent au bon service municipal.

Nadia veut appliquer le travail d’IA de ce cours à chaque nouvelle demande. Le service la classe, rédige une réponse pour l’agent et calcule un plongement (embedding) pour trouver des demandes semblables. C’est la conception de ticket-api de Larkfield : une demande est un billet de soutien, et son travail d’IA est une tâche dans la file. Elle pose deux questions à son ingénieur, Leo :

  • « Combien de processus nous faut-il pour qu’aucune demande n’attende plus de 10 secondes avant le début de son travail d’IA? »
  • « Que se passe-t-il quand le fournisseur d’IA tombe en panne pendant un certain temps? »

Leo n’a pas encore de trafic à lui, mais San Francisco publie chaque demande au 311 avec son heure. Il planifie donc avec cette trace et le précise : la ville de Nadia doit vérifier ses propres chiffres avant de s’appuyer sur le plan.

Vous créerez un plan de capacité à partir d’une trace réelle. Vous vérifierez les données, mesurerez les arrivées à trois échelles de temps et trouverez les pointes. Un modèle de file d’attente rejouera les arrivées avec les durées de tâches d’IA enregistrées dans le cours. Vous choisirez un nombre de places de traitement pour la cible de 10 secondes. Vous testerez ce choix une seule fois sur des mois gardés de côté. Vous ajouterez une panne et une limite de file, puis exécuterez la méthode sur de nouvelles données avec plan().

Les données proviennent de 311 Cases, sur DataSF, le portail de données ouvertes de la ville et du comté de San Francisco. Ce jeu de données contient une ligne par demande depuis 2008. L’étude de cas utilise les 872 427 demandes de 2025. À la fin, les demandes de juin 2026 servent de nouvelles données d’entrée.

Leo a comparé deux autres traces ouvertes. Les données du 311 de Boston ont la même licence. Mais leur volume représente environ le tiers de celui de San Francisco. En 2025, Boston a changé de système. L’année est donc répartie entre deux fichiers aux colonnes différentes. Le journal du serveur Web de la NASA de 1995 est une trace de trafic classique. Mais il n’indique aucune licence, et ses lignes représentent des accès Web, pas des billets. Chaque ligne contient aussi le nom d’hôte d’un visiteur. La prochaine étude de cas utilise les données du 311 de New York : File d’attente et cache pour une API de données ouvertes.

La cellule de préparation du carnet télécharge les fichiers et vérifie leurs sommes de contrôle. Leo charge le fichier de 2025 :

raw = pd.read_csv("sf311_2025_arrivals.csv.gz", parse_dates=["requested_datetime"],
keep_default_na=False, na_values=[""])
print(raw.shape)
print(raw.head(3).to_string(index=False))
print(raw.requested_datetime.min(), "to", raw.requested_datetime.max())

La sortie :

(872427, 3)
requested_datetime source service_name
2025-01-01 00:00:36 Mobile Street and Sidewalk Cleaning
2025-01-01 00:01:08 Mobile Street and Sidewalk Cleaning
2025-01-01 00:05:36 Mobile Street and Sidewalk Cleaning
2025-01-01 00:00:36 to 2025-12-31 23:58:10

Ce que cela nous apprend. Une ligne représente une demande : son heure d’enregistrement par le système municipal, son canal et son type. Les heures sont précises à la seconde. Cette copie ne contient ni noms, ni adresses, ni descriptions. On ne peut donc y retrouver aucune personne.

Colonne Signification Utilisation
requested_datetime Heure d’enregistrement de la demande par le système municipal, en heure locale de San Francisco, à la seconde près Heure d’arrivée d’un billet
source Canal : Phone (téléphone), Mobile (application), Web, Integrated Agency (organisme intégré), Twitter, Email (courriel) ou Test (test) Vérifications et recherche des pointes
service_name Type, par exemple Graffiti Public (graffitis publics) ou Street and Sidewalk Cleaning (nettoyage des rues et trottoirs) Explication d’une pointe

Avant de compter, Leo vérifie les canaux, les valeurs vides, les répétitions et une journée avec un changement d’heure :

print(raw.source.value_counts(dropna=False).to_string())
print("rows with no source:", raw.source.isna().sum())
print("same time, channel and type as another row:", raw.duplicated().sum())
t = raw.requested_datetime
march_9 = raw[t.dt.date == pd.Timestamp("2025-03-09").date()]
print("2025-03-09, requests per hour 0-4:", march_9.groupby(march_9.requested_datetime.dt.hour).size().head(4).to_dict())

La sortie :

source
Mobile 534032
Web 181124
Phone 147841
Integrated Agency 6139
NaN 1985
Twitter 653
Test 512
Email 141
rows with no source: 1985
same time, channel and type as another row: 20446
2025-03-09, requests per hour 0-4: {0: 21, 1: 23, 3: 9, 4: 9}

Ce que cela nous apprend. Chaque constat change une étape ultérieure :

  • 512 lignes Test. Quelqu’un a testé le système; aucun résident ne les a envoyées. Elles n’atteindraient jamais une vraie file, alors Leo les retire.
  • 1 985 lignes sans canal. Ce sont de vraies demandes de tous les types, réparties sur toute l’année. Une étiquette manquante ne rend pas une demande moins réelle, alors elles restent.
  • 20 446 lignes répètent l’heure, le canal et le type d’une autre ligne. Ce ne sont pas des copies : deux demandes sur des graffitis peuvent arriver à la même seconde. Ces groupes sont les pointes que cette étude de cas examine, alors ils restent.
  • Aucune heure 2 le 9 mars. Cette nuit-là, les horloges ont avancé d’une heure. Les heures sont locales et n’ont pas de fuseau horaire. En novembre, une heure se répète et contient donc deux heures de demandes. Ce sont des heures de nuit avec environ 20 demandes chacune. Leo conserve donc l’heure locale et le note.

L’unité. Une demande correspond à un billet et à une tâche d’IA. La question. Combien de temps une tâche attend-elle dans la file avant qu’un processus la prenne? Ce délai est le chiffre à contrôler. L’âge de la tâche la plus ancienne, le signal de Signaux de mise à l’échelle, exprime la même idée du côté de la file. Il atteint son maximum juste avant le démarrage de la tâche la plus ancienne. L’âge maximal égale donc le délai d’attente le plus long.

La cible. Aucun billet n’attend plus de 10 secondes. Une tâche prend ensuite environ 2 à 3 secondes de plus. L’agent voit donc la catégorie et le brouillon de réponse en environ 13 secondes.

Une séparation dans le temps. Un plan établi sur une période doit fonctionner dans la suivante. Leo utilise donc janvier à septembre, les mois de conception, pour choisir le plan. Il garde octobre à décembre pour une seule vérification finale. C’est comme tester un modèle une seule fois sur des données qu’il n’a jamais vues. Une séparation aléatoire serait incorrecte ici : les pointes se suivent, et le plan doit affronter des mois qu’il n’a pas vus.

df = raw[raw.source != "Test"].copy()
T0 = pd.Timestamp("2025-01-01")
df["sec"] = (df.requested_datetime - T0).dt.total_seconds() # seconds since 1 January
design = df[df.requested_datetime < "2025-10-01"]
check = df[df.requested_datetime >= "2025-10-01"]
sec = design.sec.to_numpy()
print(len(df), "requests:", len(design), "design months,", len(check), "check months")

La sortie :

871915 requests: 663926 design months, 207989 check months

Ce que cela nous apprend. Leo dispose de 273 jours pour planifier et de 92 jours pour vérifier. Les 512 lignes de test ont disparu. À partir d’ici, tous les chiffres concernent les mois de conception, jusqu’à la vérification finale.

days = design.groupby(design.requested_datetime.dt.date).size()
print(f"per day: mean {days.mean():.0f}, lowest {days.min()} ({days.idxmin()}), highest {days.max()} ({days.idxmax()})")
per day: mean 2432, lowest 1375 (2025-07-04), highest 3750 (2025-07-23)

Le carnet calcule aussi la moyenne des demandes pour chaque heure de la journée, séparément pour la semaine et la fin de semaine :

  • Jours de semaine
  • Fins de semaine
San Francisco 311, janvier à septembre 2025 : nombre moyen de demandes pour chaque heure de la journée. En semaine, le maximum atteint environ 239 par heure à 9 h; la nuit, il descend à environ 9.
Description textuelle du graphique

Un graphique à deux courbes couvrant les 24 heures de la journée. En semaine, les demandes passent d’environ 9 par heure à 3 h à un maximum d’environ 239 par heure à 9 h. Elles restent au-dessus de 150 par heure jusqu’à environ 16 h. À 22 h, elles descendent à environ 40 par heure. La fin de semaine, la courbe a la même forme, mais reste plus basse : son maximum atteint environ 188 par heure à 10 h.

Ce que cela nous apprend. Une heure chargée d’un matin de semaine contient environ 25 fois plus de demandes qu’une heure de nuit. La moyenne, environ 1,7 demande par minute, ne décrit donc aucune minute réelle.

Un point de dimensionnement est la charge pour laquelle vous planifiez. La moyenne est un mauvais choix, car elle cache les pointes. Latence et capacité l’a montré pour les durées des requêtes. Mais quelle pointe choisir, et à quelle échelle de temps? Leo compte les demandes par heure, par minute et par tranche de 10 secondes des mois de conception, fenêtres vides comprises :

def per_window(seconds, width):
"""How many requests arrived in each window of `width` seconds (empty windows count too)."""
start = np.floor(seconds.min() / 86400) * 86400
return np.bincount(((seconds - start) // width).astype(int))
rows = []
for name, width in [("per hour", 3600), ("per minute", 60), ("per 10 seconds", 10)]:
counts = per_window(sec, width)
rows.append([name, counts.mean(), *np.percentile(counts, [50, 99, 99.9]), counts.max()])
print(pd.DataFrame(rows, columns=["window", "mean", "p50", "p99", "p99.9", "max"]).round(2).to_string(index=False))

La sortie :

window mean p50 p99 p99.9 max
per hour 101.33 94.0 310.0 397.84 572
per minute 1.69 1.0 8.0 12.00 21
per 10 seconds 0.28 0.0 3.0 5.00 13

Ce que cela nous apprend. Chaque échelle de temps raconte une histoire différente. L’heure la plus chargée comptait 572 demandes, environ 5,6 fois la moyenne horaire. La minute la plus chargée en comptait 21, environ 12 fois la moyenne par minute. Les 10 secondes les plus chargées en comptaient 13, environ 46 fois la moyenne. Plus la fenêtre est courte, plus la pointe s’éloigne de la moyenne. Quelle fenêtre compte donc? Celle qui correspond au travail et à la cible. Une tâche prend environ 2,3 secondes et la cible est de 10 secondes. Une file se remplit et se vide donc en quelques secondes. Les fenêtres de 10 secondes sont la bonne échelle. Un plan horaire ne verrait jamais le problème.

Si les résidents agissaient indépendamment, chaque seconde de la minute recevrait environ 1/60 des demandes : 1,7 %. Leo vérifie chaque canal :

second = design.requested_datetime.dt.second
for source in ["Phone", "Mobile", "Web"]:
counts = second[design.source == source].value_counts()
print(f"{source:6}: second :{counts.idxmax():02d} has {counts.max() / counts.sum():.1%} of the requests")
same = design.groupby("requested_datetime").size()
print("seconds with 5 or more requests:", (same >= 5).sum(), "holding", same[same >= 5].sum(), "requests")
print("the largest group:", same.max(), "requests at", same.idxmax())
print(design[design.requested_datetime.isin(same[same >= 5].index)].source.value_counts().to_dict())

La sortie :

Phone : second :31 has 1.8% of the requests
Mobile: second :45 has 4.0% of the requests
Web : second :47 has 38.6% of the requests
seconds with 5 or more requests: 1095 holding 6379 requests
the largest group: 10 requests at 2025-07-15 10:51:47
{'Web': 6305, 'Mobile': 61, 'Phone': 13}
  • Web
  • Mobile
  • Téléphone
San Francisco 311, toute l'année 2025 : part des demandes de chaque canal enregistrées à chaque seconde de la minute. La courbe du téléphone est plate; celle du Web présente une forte pointe à la seconde 47.
Description textuelle du graphique

Un graphique à trois courbes couvrant les secondes 0 à 59. La courbe du téléphone est plate, à environ 1,7 % pour chaque seconde. La courbe du mobile est presque plate, avec une légère hausse à environ 3,5 % entre les secondes 44 et 49. La courbe du Web reste autour de 1 % pour la plupart des secondes. Elle bondit à environ 30 % à la seconde 47 sur l’ensemble de l’année. Des hausses plus petites apparaissent aux secondes 46, 48 et 51.

Ce que cela nous apprend. Les demandes téléphoniques sont réparties uniformément : les gens appellent quand ils veulent. Ce n’est pas le cas des demandes Web. Durant les mois de conception, 38,6 % portent la seconde 47 de leur minute. Le système municipal semble enregistrer beaucoup de demandes Web une fois par minute, en lot. L’effet est ce qui compte : un tiers des demandes Web arrivent ensemble, jusqu’à 10 à la même seconde. Pour la file d’IA, le lot est l’arrivée. Les tâches commencent quand le système enregistre les demandes, pas quand les résidents appuient sur « send » (envoyer).

La référence de base la plus simple est un calcul : demandes par seconde multipliées par secondes par tâche donnent les tâches en cours en moyenne. Une tâche comprend trois appels successifs (classer, rédiger une réponse, calculer un plongement). Chaque durée est tirée des 100 durées enregistrées pour cet appel dans le cours. On ajoute 17 ms de travail en base de données :

lat = {task: np.array(ms) / 1000 for task, ms in calibration["latency_ms"].items()}
rng = np.random.default_rng(21)
job = sum(rng.choice(lat[task], 100_000) for task in ["classify", "draft_reply", "embed"]) + 0.017
print(f"one job: median {np.median(job):.2f} s, p95 {np.percentile(job, 95):.2f} s, max {job.max():.2f} s, mean {job.mean():.2f} s")
per_minute = per_window(sec, 60)
for name, rate in [("mean minute", per_minute.mean()), ("p99 minute", np.percentile(per_minute, 99)),
("busiest minute", per_minute.max())]:
print(f"{name:15} {rate:5.2f} requests -> {rate / 60 * job.mean():.2f} job slots busy on average")

La sortie :

one job: median 2.25 s, p95 3.08 s, max 4.63 s, mean 2.32 s
mean minute 1.69 requests -> 0.07 job slots busy on average
p99 minute 8.00 requests -> 0.31 job slots busy on average
busiest minute 21.00 requests -> 0.81 job slots busy on average

Ce que cela nous apprend. Une place de traitement correspond à une tâche en cours. Dans le projet du cours, le nombre de places égale le nombre de processus multiplié par WORKER_CONCURRENCY. Un processus avec la valeur par défaut de 4 a donc 4 places. Le calcul indique que même la minute la plus chargée occupe moins d’une place. Tomás dirait : « Un processus, c’est largement assez, peut-être même trop. » C’est la référence de base. Les prochaines sections la testent avec les arrivées réelles.

Une boulangerie a une seule personne au comptoir, et chaque commande prend environ deux minutes. Si trente clients arrivent en une heure, un toutes les deux minutes, personne n’attend. Si ces mêmes trente clients arrivent avec leur classe à 8 h, le dernier enfant attend une heure. Le nombre par heure est le même; l’attente ne l’est pas. L’attente dépend de la façon dont les arrivées se regroupent, et du temps que prend chaque commande.

Le calcul de la moyenne ne voit pas ces regroupements. Leo utilise donc une simulation de file d’attente : un court programme qui rejoue chaque arrivée dans l’ordre chronologique. Il l’attribue à une place libre ou la met en file d’attente, puis note son temps d’attente. Ce modèle représente la file d’attente du cours, avec les quatre parties du schéma.

Quatre boîtes de gauche à droite, reliées par des flèches. 1, Arrivées : la trace réelle, un billet de soutien par demande au 311. 2, La file d'attente : attente dans l'ordre; une limite refuse les billets quand elle est pleine, avec une flèche vers le bas vers refusés : 503 queue_full. 3, Places de traitement : processus multipliés par WORKER_CONCURRENCY, ici de 1 à 8. 4, Le fournisseur : quota de 100 appels de clavardage par minute, 2 par tâche, avec une flèche vers le haut depuis : une panne, aucun nouvel appel ne démarre avant sa fin. En dessous : une tâche comprend classify (0,91 s), puis draft_reply (1,10 s), puis embed (0,20 s), dans cet ordre. Les durées sont tirées des 100 appels enregistrés pour chaque tâche : médiane de 2,25 s, p95 de 3,08 s. Ce que le modèle mesure : l'attente de chaque billet avant qu'une place le prenne, donc l'âge de la tâche la plus ancienne, les tâches en attente et les billets refusés.
Le modèle de capacité de cette étude de cas : des arrivées réelles, une file d'attente avec une limite facultative, un nombre de places de traitement et le fournisseur avec son quota. Les durées des tâches viennent des enregistrements du cours.
Description textuelle du diagramme

Le modèle a quatre parties qui se suivent. Les arrivées viennent de la trace réelle, un billet par demande. Elles entrent dans la file d’attente, qui les garde dans l’ordre. Si la file a une limite et qu’elle est pleine, le billet est refusé avec 503 queue_full. Une place de traitement libre prend le billet le plus ancien. Le nombre de places correspond au nombre de processus multiplié par WORKER_CONCURRENCY. Chaque tâche appelle le fournisseur trois fois de suite : classify, draft_reply et embed. Les durées sont tirées des 100 appels enregistrés pour chaque tâche dans le cours. Les deux appels de clavardage comptent dans le quota de 100 appels de clavardage par minute; une fois épuisé, l’appel attend. Pendant une panne, aucun nouvel appel ne démarre avant la fin de la panne. Le modèle note l’attente de chaque billet, les tâches en attente et les billets refusés.

La fonction simulate() du carnet (notebook) Jupyter compte environ 70 lignes de Python. Elle garde une horloge et une liste des prochains événements : « un billet arrive », « un appel se termine », « le quota a de nouveau de la place ». Elle traite toujours l’événement le plus proche en premier. Son quota utilise un seau à jetons, comme le fournisseur simulé du cours. Le seau contient 100 appels de clavardage et se remplit à raison de 100 par minute. Chaque appel de clavardage prend un jeton.

Deux simplifications rendent le modèle un peu optimiste. Quand le seau est vide, l’appel attend un jeton. Le vrai processus reçoit d’abord un 429, ce qui coûte environ 0,13 seconde et un délai d’attente croissant. Le modèle n’inclut pas non plus de délai de base de données ou de réseau, à part les 17 ms. La réexécution sur votre ordinateur mesure ce que ces simplifications omettent.

Leo essaie le modèle sur des cas qu’il peut vérifier à la main. D’abord, quatre billets espacés de 30 secondes. Puis dix billets dans la même seconde, avec une place et avec deux :

calm = [0, 30, 60, 90]
burst = [0] * 10
print("calm, 1 slot :", np.round(simulate(calm, 1, calibration)["wait"], 1))
for slots in [1, 2]:
print(f"burst, {slots} slot(s):", np.round(simulate(burst, slots, calibration)["wait"], 1))

La sortie :

calm, 1 slot : [0. 0. 0. 0.]
burst, 1 slot(s): [ 0. 2.3 5.6 7.7 10. 12.6 14.9 17.2 19.7 22.4]
burst, 2 slot(s): [ 0. 0. 2.3 3.3 4.4 5.6 7. 7.8 9.4 10.3]

Ce que cela nous apprend. Les billets espacés n’attendent jamais : chaque tâche se termine bien avant l’arrivée du billet suivant. Dans la rafale avec une place, chaque billet attend toutes les tâches précédentes, environ 2,3 secondes chacune. Le dixième attend donc 22,4 secondes. Deux places réduisent cette attente de moitié. Vous pouvez le vérifier à la main : 9 tâches devant × environ 2,3 s ÷ 2 places donnent environ 10 s. Dix billets en une seconde tiennent facilement dans une minute moyenne, mais ils dépassent quand même la cible.

Trois modèles de charge de travail, une file d’attente, une mesure

Section intitulée « Trois modèles de charge de travail, une file d’attente, une mesure »

Voici maintenant la vraie question : quelle description des arrivées donne la bonne réponse? Leo compare trois modèles de charge de travail. Tous les trois passent par la même file d’attente, avec les mêmes durées de tâche et la même graine aléatoire. Une mesure les départage : l’attente maximale pendant les mois de conception, et le nombre de billets qui dépassent 10 secondes.

  • Uniforme. Les mêmes 663 926 demandes, espacées régulièrement. C’est le calcul de la moyenne, sous forme de simulation.
  • Aléatoire. Des arrivées aléatoires, avec la moyenne des mois de conception pour chaque heure de la semaine. Un lundi à 9 h a donc sa propre moyenne. Des arrivées aléatoires et indépendantes comme celles-ci forment un processus de Poisson, le modèle classique d’une file d’attente.
  • Trace. Les heures réelles, y compris tous les lots.
TARGET = 10 # seconds: the longest a ticket may wait before a slot takes it
def summary(result):
wait = result["wait"][~result["refused"]]
return {"p99": np.percentile(wait, 99), "max": wait.max(), "over": int((wait > TARGET).sum())}
models = {"even": np.linspace(sec.min(), sec.max(), len(sec)),
"random": random_arrivals(T0, 273, seed=21), "trace": sec}
rows = [{"model": name, "slots": slots, **summary(simulate(arrivals, slots, calibration))}
for slots in [1, 2, 3, 4] for name, arrivals in models.items()]

Le carnet définit random_arrivals() juste avant cette cellule, puis affiche deux tableaux :

longest wait (s):
slots 1 2 3 4
model
even 0.0 0.0 0.0 0.0
random 10.0 3.2 2.3 0.6
trace 25.1 11.3 6.9 4.9
tickets that waited more than 10 s:
slots 1 2 3 4
model
even 0 0 0 0
random 1 0 0 0
trace 2893 14 0 0

Ce que cela nous apprend. Les trois modèles donnent trois plans différents :

  • Uniforme indique une place, et aucun billet n’attend jamais. Il ne voit pas les pointes, donc ce n’est pas un véritable plan.
  • Aléatoire indique qu’une place fonctionne presque toujours (un billet dépasse 10 secondes en neuf mois), et que deux suffisent largement. Il connaît le profil quotidien. Mais il suppose que les résidents agissent seuls, donc il ne produit jamais un lot de 10 en une seconde.
  • Trace indique qu’une place échoue 2 893 fois, et que deux places dépassent encore la cible 14 fois. L’attente maximale atteint 11,3 secondes. Trois places respectent la cible.

La différence entre le modèle aléatoire et la trace vient des lots. Le modèle classique est un bon départ, mais ici il est trop favorable. Ses attentes maximales sont environ la moitié des attentes réelles, ou moins. Utilisez les arrivées réelles quand vous les avez.

Les attentes les plus longues viennent des lots. Leo rejoue le plus grand : 10 demandes à 10 h 51 min 47 s le 15 juillet. Il inclut les deux minutes avant et après, puis trace l’âge de la tâche la plus ancienne :

  • 1 place
  • 2 places
  • 4 places
Le modèle de file d'attente rejoue le plus grand lot des mois de conception : 10 demandes à 10 h 51 min 47 s le 15 juillet 2025. Il utilise 1, 2 et 4 places de traitement (graine 21). L'âge de la tâche la plus ancienne augmente pendant que le lot attend, puis diminue quand sa dernière tâche démarre. La cible est de 10 secondes.
Description textuelle du graphique

Un graphique à courbes, de 10 secondes avant le lot à 60 secondes après. Avant le lot, rien n’attend et toutes les courbes sont à 0. À la seconde 0, dix billets arrivent. Avec 1 place, l’âge de la tâche la plus ancienne monte à environ 21.2 secondes avant le démarrage du dernier billet, environ 21 secondes après le lot. Avec 2 places, il atteint environ 10.1 secondes, exactement à la cible. Avec 4 places, il atteint 4.5 secondes. (Avec 3 places, non représentées, le maximum est de 6.5 secondes.) Toutes les courbes reviennent à 0 en environ 25 secondes.

Ce que cela nous apprend. Une place fait attendre le lot environ 21 secondes. Deux places atteignent tout juste la cible; trois et quatre gardent une marge.

Les durées des tâches sont tirées au hasard. Une exécution est donc un échantillon, comme un essai de test de charge. Leo exécute chaque configuration cinq fois avec différentes graines et garde la médiane, comme dans Comparer les configurations :

for slots in [2, 3, 4]:
print(f"design months, {slots} slots:", passes(sec, slots))
design months, 2 slots: {'median max': 11.3, 'max range': (10.5, 11.6), 'median over': 12}
design months, 3 slots: {'median max': 7.0, 'max range': (6.8, 7.4), 'median over': 0}
design months, 4 slots: {'median max': 4.9, 'max range': (4.7, 5.1), 'median over': 0}

Ce que cela nous apprend. La réponse est stable : deux places dépassent la cible à chaque essai. Trois la respectent à chaque essai avec environ 3 secondes de marge, et quatre laissent environ 5 secondes.

Trois places sont le nombre minimal qui respecte la cible. Leo recommande quatre, pour deux raisons :

  • Une place coûte peu ici. Un processus attend surtout le fournisseur. Quatre places occupent environ quatre connexions à la base de données. Elles ne coûtent rien de plus chez le fournisseur, car les mêmes demandes font les mêmes appels.
  • Neuf mois sont un échantillon, pas l’avenir. Les mois de conception contiennent les rafales qui ont eu lieu, pas toutes celles qui peuvent survenir. Une marge protège à peu de frais.

Dans le projet, quatre places peuvent correspondre à un processus avec la valeur par défaut WORKER_CONCURRENCY=4. Elles peuvent aussi correspondre à deux processus avec WORKER_CONCURRENCY=2. Leo préfère deux processus. Quand l’un est remplacé, comme dans Arrêt en douceur, l’autre garde deux places actives. Deux places ont dépassé la cible 12 fois en neuf mois. C’est acceptable pour les quelques minutes d’un remplacement.

Leo ouvre maintenant les données d’octobre à décembre pour la première fois et exécute le plan, une seule fois :

check_sec = check.sec.to_numpy()
check_ten = per_window(check_sec, 10)
print("check months: busiest 10 seconds", check_ten.max(), "requests (design months: 13)")
for slots in [2, 3, 4]:
print(f"check months, {slots} slots:", passes(check_sec, slots))

La sortie :

check months: busiest 10 seconds 22 requests (design months: 13)
check months, 2 slots: {'median max': 16.8, 'max range': (15.6, 16.9), 'median over': 10}
check months, 3 slots: {'median max': 9.0, 'max range': (8.4, 9.6), 'median over': 0}
check months, 4 slots: {'median max': 5.5, 'max range': (5.2, 5.7), 'median over': 0}
  • Mois de conception (janvier à septembre)
  • Mois de vérification (octobre à décembre)
Le modèle de file d'attente avec 2, 3 et 4 places de traitement : l'attente maximale pendant les mois de conception et de vérification. La cible est de 10 secondes. Trois places ont tout juste tenu pendant les mois de vérification; quatre ont gardé une marge.
Description textuelle du graphique

Un graphique à colonnes avec six colonnes, trois pour les mois de conception et trois pour les mois de vérification. Mois de conception : 2 places 11.3 secondes, 3 places 7 secondes, 4 places 4.9 secondes. Mois de vérification : 2 places 16.8 secondes, 3 places 9 secondes, 4 places 5.5 secondes. Chaque colonne des mois de vérification est plus haute que la colonne correspondante des mois de conception.

Ce que cela nous apprend. Les mois de vérification contenaient une rafale plus grande que toutes celles des mois de conception : 22 demandes en 10 secondes, contre 13. Elle est survenue le samedi 6 décembre à 14 h 54, et ce n’était pas un lot Web. En 9 secondes, 22 signalements General Request (demande générale) sont arrivés de l’application. Les données ne permettent pas de dire s’il s’agissait d’une personne, d’un groupe ou d’une application qui renvoyait les demandes. Avec cette rafale, trois places ont atteint 9,0 secondes, juste sous la cible, et deux places ont largement échoué. Quatre places, choisies avec une marge, ont gardé 4,5 secondes de réserve. Voilà pourquoi la vérification finale s’exécute une seule fois, sur des mois que le plan n’a jamais vus. Si Leo avait ajusté le plan sur les douze mois, il ne lui resterait aucun test honnête.

Il faut confronter un modèle à une vraie file d’attente au moins une fois. Cette partie facultative est la seule qui exécute le projet du cours. Elle rejoue quatre minutes de la trace, autour du plus grand lot, sur votre ticket-api locale. Elle compare les attentes mesurées à celles du modèle. Le fournisseur est le fournisseur simulé du cours, avec le quota activé. Exécutez-la seulement sur les services de votre propre ordinateur.

  1. Téléchargez replay_trace.py depuis le dossier de l’étude de cas dans le dépôt des laboratoires. Enregistrez-le dans le dossier scripts/ de votre projet.

  2. Dans le dossier du projet, activez l’environnement virtuel. Démarrez PostgreSQL, Azurite et Valkey s’ils ne sont pas déjà actifs :

    Fenêtre de terminal
    docker compose up -d db azurite cache
  3. Dans un deuxième terminal, démarrez le fournisseur simulé :

    Fenêtre de terminal
    python -m simulator
  4. Dans un troisième terminal, démarrez l’API :

    Fenêtre de terminal
    fastapi dev
  5. Dans un quatrième terminal, démarrez un processus avec une place :

    Fenêtre de terminal
    python -m ticket_api.worker --concurrency 1

    Vous devriez voir Worker …: up to 1 job at a time. (processus… : jusqu’à 1 tâche à la fois).

  6. Videz le cache pour qu’aucun plongement (embedding) ne provienne d’une exécution précédente :

    Fenêtre de terminal
    python -m scripts.cache flush
  7. Rejouez les quatre minutes. La première exécution télécharge la trace (environ 4 Mo) :

    Fenêtre de terminal
    python -m scripts.replay_trace --start "2025-07-15 10:49:47" --minutes 4

L’exécution de l’auteur, essai 1 sur 3 (vos chiffres seront différents) :

Replaying 44 requests from 2025-07-15 10:49:47 for 4 minutes (largest same-second group: 10 at 10:51:47) ...
Sent: status codes {202: 44}
Jobs: {'succeeded': 44}
Wait before a worker took the job (s): median 7.5, p95 19.1, max 22.2
Most jobs waiting at once: 10

Arrêtez ensuite le processus (Ctrl+C), redémarrez-le avec --concurrency 2, videz le cache et rejouez les mêmes quatre minutes. L’auteur a exécuté chaque configuration trois fois. Il a comparé les médianes des essais aux médianes du modèle obtenues avec cinq graines :

Attentes des mêmes 44 billets 1 place : mesurée 1 place : modèle 2 places : mesurée 2 places : modèle
Médiane 7.9 s 7.8 s 2.8 s 2.5 s
p95 19 s 17.9 s 8.9 s 8.5 s
Maximale 21 s 20 s 9.5 s 9.2 s

Ce que cela nous apprend. Le modèle et la vraie file d’attente concordent à environ une seconde près. La vraie file est un peu plus lente à chaque fois. Sa médiane, son p95 et son attente maximale dépassent ceux du modèle de 0,1 à 1,1 seconde. Cela correspond à ce que le modèle omet. Un processus inactif cherche de nouvelles tâches toutes les 0,5 secondes (WORKER_POLL_SECONDS). Chaque tâche passe aussi du temps dans l’API et la base de données. Le modèle est donc légèrement optimiste, et la marge de la quatrième place couvre cet écart. Notez une limite de cette vérification : la vraie file utilisait le fournisseur simulé. Elle confirme donc la file d’attente, pas le fournisseur.

Le quota. La minute la plus chargée des mois de conception nécessite 2 × 21 = 42 appels de clavardage. Le compte en permet 100. Lors d’une journée normale, le quota ne limite donc jamais le plan. La marge est de 100 ÷ 42, soit environ 2,4 fois la minute la plus chargée observée. Ce nombre marque aussi la limite de ce plan.

Une panne. Pour la deuxième question de Nadia, Leo suppose une panne de 30 minutes dès le début de l’heure la plus chargée (27 août, 9 h, 572 demandes). C’est un scénario déclaré, pas une mesure. Pendant la panne du fournisseur, les tâches attendent; le processus du cours les remet en file sans consommer de tentative. Ensuite, la file se vide aussi vite que le quota le permet : 100 appels de clavardage par minute, soit 50 billets.

for name, slots, kw in [("4 slots", 4, {}), ("8 slots", 8, {}), ("4 slots, quota 200", 4, {"rpm": 200}),
("4 slots, bound 500", 4, {"bound": 500}), ("4 slots, bound 100", 4, {"bound": 100})]:
result = simulate(win, slots, calibration, outage=outage, **kw)
...

La sortie :

busiest hour: 2025-08-27 09:00:00 with 572 requests
4 slots peak 273 waiting, refused 0, longest wait 29.2 min, empty 5.5 min after the outage
8 slots peak 269 waiting, refused 0, longest wait 29.2 min, empty 5.5 min after the outage
4 slots, quota 200 peak 273 waiting, refused 0, longest wait 29.2 min, empty 3.0 min after the outage
4 slots, bound 500 peak 273 waiting, refused 0, longest wait 29.2 min, empty 5.5 min after the outage
4 slots, bound 100 peak 100 waiting, refused 177, longest wait 29.2 min, empty 1.5 min after the outage
  • Quota 100
  • Quota 200
  • Limite
Le modèle de file d'attente avec 4 places de traitement pendant une panne de 30 minutes dès 9 h le 27 août 2025, l'heure la plus chargée (un scénario déclaré). La file grandit pendant la panne du fournisseur; ensuite, le quota détermine sa vitesse de vidage. Une limite de 100 (Limite) maintient la file à ce niveau et refuse le reste.
Description textuelle du graphique

Un graphique à courbes, de 5 minutes avant l’heure à 50 minutes après. Avant la panne, rien n’attend. De la minute 0 à 30, la file grandit régulièrement avec les arrivées, jusqu’à environ 273 tâches à la minute 30, pour les deux quotas. Après la panne, avec un quota de 100, elle descend à 0 environ 5.5 minutes plus tard. Avec un quota de 200, elle descend plus vite et se vide environ 3 minutes après la panne. Avec une limite de 100, la courbe monte à 100 et reste horizontale jusqu’à la fin de la panne, tandis que 177 demandes sont refusées. Elle se vide environ 1.5 minutes après la panne.

Ce que cela nous apprend.

  • Plus de processus n’aident pas après une panne. Quatre places et huit places vident la file dans les mêmes 5,5 minutes. Le quota est la limite, pas les places. C’est encore la leçon de Signaux de mise à l’échelle : ajoutez ce dont le goulot d’étranglement a besoin. Ici, c’est un quota plus élevé : avec 200 appels par minute, la file se vide en 3,0 minutes.
  • Une limite basse transforme l’attente en refus. La valeur par défaut de QUEUE_MAX dans le cours, 500, ne refuse rien : la file atteint 273. Une limite de 100 garde la file courte, mais refuse 177 demandes. Dans la conception du cours, 503 queue_full (file pleine) signifie que le billet n’est pas enregistré.

Ce dernier point compte davantage pour une ville que pour un magasin. Une demande au 311 refusée est le signalement d’un résident, perdu parce que le travail d’IA avait pris du retard. La leçon Contre-pression présentait l’autre option : enregistrer le billet, puis omettre ou retarder son traitement par l’IA quand la file est pleine. Pour un service public, c’est la conception à choisir. Le travail d’IA aide les agents; il ne doit jamais causer la perte d’un signalement.

Un plan doit fonctionner sur des données qu’il n’a pas vues, et indiquer quand il ne le peut pas. La fonction plan() du carnet applique toute la méthode à un nouveau fichier. Elle exécute les vérifications, les trois échelles de temps, le quota, cinq essais avec les places choisies, puis donne un verdict. Elle refuse d’extrapoler. Le plan a été vérifié sur des rafales allant jusqu’à 22 demandes en 10 secondes et 22 en une minute. Si la nouvelle trace contient une rafale plus grande ou nécessite plus d’appels de clavardage que le quota, plan() indique « mesurer de nouveau » et ne donne aucun nombre.

Leo l’exécute sur juin 2026, un mois survenu après toute l’analyse :

june = plan("sf311_2026_06_arrivals.csv.gz")

La sortie :

73719 requests, 2026-06-01 to 2026-06-30
per minute: mean 1.71, p99 8, max 21 (checked up to 22)
per 10 seconds: max 12 (checked up to 22)
busiest minute: 42 chat calls (quota 100)
4 slots: {'median max': 4.0, 'max range': (3.5, 4.2), 'median over': 0}
Verdict: 4 slots meets the 10 s target on this input.

Ce que cela nous apprend. Juin 2026 ressemble à 2025, avec des rafales dans la plage vérifiée. Quatre places maintiennent l’attente maximale à environ 4 secondes. Un détail a changé : le lot Web arrive maintenant à la seconde 53, pas à la seconde 47. Un plan fondé sur la « seconde 47 » aurait échoué; un plan fondé sur les arrivées mesurées n’a pas échoué.

Leo l’écrit pour Nadia, selon le format de Recommandation de capacité :

  • Recommandation. Utilisez deux processus avec WORKER_CONCURRENCY=2 : quatre places pour les tâches. Dans le modèle, avec les arrivées de San Francisco, l’attente maximale était de 4,9 secondes pendant les mois de conception. Elle était de 5,5 secondes pendant les mois réservés et de 4,0 secondes en juin 2026 (médianes de cinq passages).
  • Les hypothèses.
    • Les arrivées ressemblent à celles de San Francisco en 2025 et en juin 2026 : jusqu’à 22 requêtes en 10 secondes et 22 en une minute.
    • La tâche est celle du cours : trois appels consécutifs, avec les durées enregistrées (médiane de 2,25 s, p95 de 3,08 s). Le fournisseur réel ralentissait sous la charge (le cours a mesuré +7 % avec 16 appels en cours). Avec quatre places, cet effet est faible, et le modèle ne l’inclut pas.
    • Le quota est de 100 appels de clavardage par minute, et rien d’autre n’utilise le même compte.
    • Le système de la ville limite ses lots à environ 10 requêtes ou moins.
  • Ce que la recommandation ne couvre pas. Les pointes de plus de 22 requêtes en 10 secondes; plus de 50 requêtes par minute (le quota); le trafic d’une autre ville; une panne du fournisseur, qu’aucun nombre de processus ne peut résoudre.
  • La panne. Une panne de 30 minutes à l’heure la plus chargée laisse environ 273 tâches en attente. Le quota permet de les traiter en environ 5,5 minutes. Gardez QUEUE_MAX à 500 ou plus. Remplacez la réponse quand la file est pleine par « enregistrer la requête, ne pas faire le travail d’IA ». Pour récupérer plus vite, demandez un quota plus élevé, pas davantage de processus.
  • Les prochaines mesures. Exécutez plan() dans ce carnet (notebook) Jupyter sur les arrivées de la ville de Nadia. Ensuite, testez la charge du service réel en rejouant la pire pointe, comme dans Concevoir un test de charge. En production, utilisez l’âge de la tâche la plus ancienne pour déclencher une alarme.
  • Les données concernent de vrais résidents. La copie ne contient aucun nom, adresse ou description, et la méthode n’en a pas besoin. Ne la joignez pas au jeu de données complet pour étudier des personnes. Les 22 signalements faits dans l’application le 6 décembre pourraient venir d’une seule personne. Traitez-les comme un profil de charge, pas comme une personne à examiner.
  • Un modèle de San Francisco n’est pas un modèle d’une autre ville. Réutilisez la méthode ailleurs, pas les chiffres.
  • Ne laissez jamais la file d’attente d’IA perdre un signalement. Un service public doit enregistrer chaque requête, même quand le travail d’IA ne peut pas suivre.
  • Indiquez ce qui est simulé. Le fournisseur utilisé pour rejouer les arrivées est simulé, et la panne est un scénario. Indiquez-le pour les deux.
  • Une ville, une année et un mois. Les saisons, les tempêtes et les événements d’autres années peuvent produire des pointes absentes de 2025. Exécutez plan() sur chaque nouveau mois, et déclenchez une alarme selon l’âge de la tâche la plus ancienne.
  • Les horodatages sont ceux du système, pas ceux des résidents. Les lots montrent que l’heure enregistrée est parfois postérieure au moment de l’envoi. Pour la file d’attente, c’est la bonne heure. Pour étudier le comportement des résidents, ce ne l’est pas.
  • Le modèle omet certains éléments : les réponses 429 et le délai d’attente croissant quand le quota limite les appels, l’intervalle d’interrogation du processus, la base de données et le ralentissement du fournisseur sous la charge. La reprise locale mesure certains de ces éléments; un test de charge du service réel mesure les autres.
  • La panne est une hypothèse. Utilisez l’historique réel des incidents du fournisseur si vous l’avez.

Cette étude de cas montre à un employeur que vous pouvez transformer une question vague (« combien de processus? ») en chiffre défendable. Elle montre aussi que vous connaissez les limites de ce chiffre. Personnalisez-la avec un changement : les données ouvertes 311 d’une autre ville (vérifiez d’abord leur licence) ou une autre cible.

Quoi mettre dans le dépôt :

  • README.md (modèle ci-dessous).
  • Le carnet, exécuté du début à la fin, avec ses sorties et ses graphiques.
  • CAPACITY.md : la recommandation, avec chaque hypothèse et ce qu’elle ne couvre pas.
  • replay_trace.py et vos résultats de reprise, si vous avez fait la vérification locale.
  • La source des données et la licence. PDDL n’exige aucune attribution, mais mentionnez quand même DataSF et donnez la somme de contrôle de votre copie.

Un modèle de README :

# Capacity plan for AI triage of 311 requests
## Question
How many job slots keep every request's wait before its AI work under 10 s,
and what happens when the AI provider is down?
## Data and licence
San Francisco 311 Cases (DataSF, vw6y-z8j6), 2025 and June 2026: time, channel,
type. ODC PDDL 1.0. Test rows removed; local time.
## Approach
Arrivals at three time scales; bursts inside the minute (web batches at one
second of each minute). A queue simulation with recorded AI job times
(median 2.25 s) and a 100-calls-per-minute quota. Three workload models
(even, random, trace) compared on Jan-Sep; final check once on Oct-Dec.
## Results
Trace model: 3 slots meet 10 s on Jan-Sep (longest 7.0 s); the check months
had a bigger burst (22 in 10 s): 3 slots 9.0 s, 4 slots 5.5 s. Recommended:
4 slots. A 30-minute outage: 273 waiting, empty 5.5 min after (quota-bound).
## Limits
One city; simulated provider; outage assumed; no extrapolation beyond
22 requests in 10 s or 50 a minute.

Comment le décrire en entrevue, en deux phrases : « J’ai planifié les processus d’IA d’un service 311 à partir d’une année d’heures réelles de requêtes : la moyenne indiquait une place, mais les pointes réelles en exigeaient trois, et j’en ai recommandé quatre. Un trimestre réservé avec une pointe plus forte a montré l’importance de la marge, et un scénario de panne a montré que le quota, pas les processus, détermine le temps de récupération. »

Allez plus loin :

  • Rejouez la pointe du 6 décembre sur votre ordinateur avec quatre places, et comparez les résultats au modèle.
  • Ajoutez des lots au modèle aléatoire (un processus de Poisson « composé »). Vérifiez s’il prédit mieux les mois de vérification.

Vérifiez votre compréhension

La minute la plus chargée des mois de conception comptait 21 requêtes, soit moins d'une place occupée en moyenne. Pourquoi une seule place a-t-elle quand même dépassé la cible de 10 secondes 2 893 fois?

Afficher la réponse

La moyenne sur une minute masque la façon dont les requêtes se regroupent pendant cette minute. Jusqu’à 10 requêtes arrivaient dans la même seconde. Le système de la ville enregistre en effet plusieurs requêtes Web dans un lot une fois par minute. Avec une seule place, la dixième tâche d’un lot attend neuf tâches d’environ 2,3 secondes chacune : environ 21 secondes. L’échelle de temps du point de conception doit correspondre au travail et à la cible. Une tâche prend quelques secondes, et la cible est de 10 secondes. Il faut donc compter les arrivées par période de 10 secondes, ou rejouer les arrivées réelles.

Vérifiez votre compréhension

Trois places respectaient la cible pendant les mois de conception. Pourquoi Leo en a-t-il recommandé quatre, et qu'a montré la vérification finale?

Afficher la réponse

Neuf mois de données représentent un échantillon des pointes survenues, pas toutes les pointes possibles. Une place coûte peu ici, car un processus passe surtout son temps à attendre le fournisseur. Leo a donc choisi une marge. Les mois de vérification, examinés une seule fois, contenaient une pointe plus forte que toutes celles des mois de conception : 22 requêtes en 10 secondes, contre 13. Avec trois places, l’attente atteignait 9,0 secondes, juste sous la cible; avec quatre places, elle atteignait 5,5 secondes. Sans la marge, le plan aurait tenu seulement grâce à la chance.

Vérifiez votre compréhension

Après une panne de 30 minutes, Nadia veut doubler le nombre de processus pour vider la file plus vite. Que répondez-vous?

Afficher la réponse

Cela n’aidera pas. Dans le modèle, 4 places et 8 places vident toutes deux la file 5,5 minutes après la panne. La limite est le quota du fournisseur : 100 appels de clavardage par minute (50 billets), pas les processus. Un quota plus élevé aide : avec 200 appels par minute, la file se vide en 3,0 minutes. Gardez aussi une limite de file assez élevée : 500 ne refuse rien ici, tandis que 100 refuserait 177 requêtes. Et enregistrez chaque requête, même si son travail d’IA doit attendre.

Récapitulatif

  • Vous avez vérifié une trace réelle : lignes de test retirées, canaux manquants conservés, heure locale avec ses changements d’heure et groupes d’une même seconde qui étaient en fait des lots.
  • Vous avez mesuré les arrivées à trois échelles de temps. Vous avez choisi celle qui correspond à la tâche et à la cible : 10 secondes, pas des minutes ou des heures.
  • Vous avez comparé trois modèles de charge de travail avec un seul modèle de file d’attente. La moyenne indiquait une place, le modèle aléatoire classique en indiquait deux, et les arrivées réelles en indiquaient trois.
  • Vous avez choisi quatre places pour garder une marge. L’unique vérification finale sur les mois réservés a montré pourquoi elle était nécessaire.
  • Après une panne, le quota détermine la récupération, et une limite de file trop basse refuse les signalements des résidents. plan() refuse d’extrapoler au-delà des conditions dans lesquelles le plan a été vérifié.

Ensuite, l’autre étude de cas : une API de données ouvertes sous charge, avec un cache et une tâche d’exportation en arrière-plan.

Leçon suivante : File d'attente et cache pour une API de données ouvertes