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.
Étude de cas 1 sur 2 · Mettre à l'échelle les API et les charges de travail d'IAPlan de capacité à partir d'une trace de trafic publique
1. Mesurer avant de mettre à l'échelle
2. Concurrence et limites des services
3. Utiliser le cache sans fausser les résultats
4. Files d'attente et travailleurs en arrière-plan
5. Résilience et mise à l'échelle automatique
6. Valider et justifier les changements
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.
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 main
Ce que vous devez savoir
Cette étude de cas utilise tout le cours. Ces leçons comptent le plus :
- Une charge de travail exprimée en chiffres (taux d’arrivée, pointes, durée des tâches), dans Modèle de charge de travail.
- Les centiles, et pourquoi vous promettez un p95 ou un p99 plutôt qu’une moyenne, dans Latence et capacité.
- Les tâches en attente et en cours, et l’âge de la plus ancienne, dans Cycle de vie d’une tâche.
- La limite de la file,
503 queue_full(file pleine) et Retry-After (délai avant une nouvelle tentative), dans Contre-pression. - L’effet du quota quand on ajoute des processus, dans Signaux de mise à l’échelle.
- Une recommandation qui n’extrapole pas, dans Recommandation de capacité.
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-m06du 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.
La situation
Section intitulée « La situation »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.
Ce que vous allez créer
Section intitulée « Ce que vous allez créer »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
Section intitulée « Les données »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_name2025-01-01 00:00:36 Mobile Street and Sidewalk Cleaning2025-01-01 00:01:08 Mobile Street and Sidewalk Cleaning2025-01-01 00:05:36 Mobile Street and Sidewalk Cleaning2025-01-01 00:00:36 to 2025-12-31 23:58:10Ce 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.
Le dictionnaire de données
Section intitulée « Le dictionnaire de données »| 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 |
Premières vérifications
Section intitulée « Premières vérifications »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_datetimemarch_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 :
sourceMobile 534032Web 181124Phone 147841Integrated Agency 6139NaN 1985Twitter 653Test 512Email 141rows with no source: 1985same time, channel and type as another row: 204462025-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.
Définir le problème
Section intitulée « Définir le problème »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 Januarydesign = 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 monthsCe 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.
Explorer ce qui compte pour la décision
Section intitulée « Explorer ce qui compte pour la décision »La journée et la semaine
Section intitulée « La journée et la semaine »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
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.
Trois échelles de temps
Section intitulée « Trois échelles de temps »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 21per 10 seconds 0.28 0.0 3.0 5.00 13Ce 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.
Les pointes à l’intérieur d’une minute
Section intitulée « Les pointes à l’intérieur d’une minute »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.secondfor 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 requestsMobile: second :45 has 4.0% of the requestsWeb : second :47 has 38.6% of the requestsseconds with 5 or more requests: 1095 holding 6379 requeststhe largest group: 10 requests at 2025-07-15 10:51:47{'Web': 6305, 'Mobile': 61, 'Phone': 13}- Web
- Mobile
- Téléphone
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).
Une référence de base : le calcul de la moyenne
Section intitulée « Une référence de base : le calcul de la moyenne »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.017print(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 smean minute 1.69 requests -> 0.07 job slots busy on averagep99 minute 8.00 requests -> 0.31 job slots busy on averagebusiest minute 21.00 requests -> 0.81 job slots busy on averageCe 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.
Le modèle de file d’attente
Section intitulée « Le modèle de file d’attente »Un comptoir à la boulangerie
Section intitulée « Un comptoir à la boulangerie »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.
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.
Un tout petit exemple
Section intitulée « Un tout petit exemple »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] * 10print("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 4modeleven 0.0 0.0 0.0 0.0random 10.0 3.2 2.3 0.6trace 25.1 11.3 6.9 4.9tickets that waited more than 10 s:slots 1 2 3 4modeleven 0 0 0 0random 1 0 0 0trace 2893 14 0 0Ce 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.
Le point de fonctionnement
Section intitulée « Le point de fonctionnement »Une rafale, seconde par seconde
Section intitulée « Une rafale, seconde par seconde »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
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.
Cinq essais, pas un seul
Section intitulée « Cinq essais, pas un seul »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.
Le choix
Section intitulée « Le choix »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.
La vérification finale, une seule fois
Section intitulée « La vérification finale, une seule fois »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)
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.
Vérifier le modèle sur votre ordinateur
Section intitulée « Vérifier le modèle sur votre ordinateur »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.
-
Téléchargez
replay_trace.pydepuis le dossier de l’étude de cas dans le dépôt des laboratoires. Enregistrez-le dans le dossierscripts/de votre projet. -
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 -
Dans un deuxième terminal, démarrez le fournisseur simulé :
Fenêtre de terminal python -m simulator -
Dans un troisième terminal, démarrez l’API :
Fenêtre de terminal fastapi dev -
Dans un quatrième terminal, démarrez un processus avec une place :
Fenêtre de terminal python -m ticket_api.worker --concurrency 1Vous devriez voir
Worker …: up to 1 job at a time.(processus… : jusqu’à 1 tâche à la fois). -
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 -
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.2Most jobs waiting at once: 10Arrê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, une panne et une limite de file d’attente
Section intitulée « Le quota, une panne et une limite de file d’attente »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 requests4 slots peak 273 waiting, refused 0, longest wait 29.2 min, empty 5.5 min after the outage8 slots peak 269 waiting, refused 0, longest wait 29.2 min, empty 5.5 min after the outage4 slots, quota 200 peak 273 waiting, refused 0, longest wait 29.2 min, empty 3.0 min after the outage4 slots, bound 500 peak 273 waiting, refused 0, longest wait 29.2 min, empty 5.5 min after the outage4 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
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_MAXdans 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.
Le plan sur de nouvelles données, de bout en bout
Section intitulée « Le plan sur de nouvelles données, de bout en bout »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-30per 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é.
La recommandation de capacité
Section intitulée « La recommandation de capacité »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.
Utilisation responsable
Section intitulée « Utilisation responsable »- 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.
Limites et prochaines étapes
Section intitulée « Limites et prochaines étapes »- 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.
Faites-en un projet de portfolio
Section intitulée « Faites-en un projet de portfolio »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.pyet 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
## QuestionHow 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 licenceSan Francisco 311 Cases (DataSF, vw6y-z8j6), 2025 and June 2026: time, channel,type. ODC PDDL 1.0. Test rows removed; local time.
## ApproachArrivals at three time scales; bursts inside the minute (web batches at onesecond 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.
## ResultsTrace model: 3 slots meet 10 s on Jan-Sep (longest 7.0 s); the check monthshad 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).
## LimitsOne city; simulated provider; outage assumed; no extrapolation beyond22 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érification des connaissances
Section intitulée « Vérification des connaissances »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.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
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.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
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.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
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