Aller au contenu
English

File d'attente et cache pour une API de données ouvertes

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

Où nous en sommes

Cette étude de cas applique le cache du module 3, la file d'attente bornée du module 4 et la comparaison juste du module 6 à une vraie API de données ouvertes. Vous la mesurez sous une charge définie, ajoutez un cache et une file d'attente d'exportation en arrière-plan, et indiquez ce qui s'est amélioré et ce qui atteindra sa limite ensuite.

Ce que vous saurez faire

Prenez une vraie API de données ouvertes, appliquez une charge définie et mesurez ses performances. Ajoutez ensuite un cache qui ne donne jamais de résultat erroné après l’arrivée de nouvelles données. Déplacez aussi une exportation CSV lente dans une file d’attente en arrière-plan à capacité limitée. Mesurez de nouveau avec la même charge. Indiquez ce qui s’est amélioré, ce qui n’a pas changé et quelle ressource atteindra sa limite ensuite.

Étude de casPièce de portfolio

Durée
Environ 4 h
S’exécute dans
VS Code, Python 3.12+, Docker
Compétences utilisées
  • Modèle de charge de travail
  • Tests de charge avec Locust
  • Médianes des exécutions
  • Clés de cache avec une version des données
  • Invalidation à l'arrivée de nouvelles données
  • Tâches dans PostgreSQL
  • Clés d'idempotence
  • Contre-pression avec Retry-After

Décompressez le projet de départ, ouvrez le dossier dans VS Code et suivez les étapes ci-dessous. Elles commencent par un nouvel environnement virtuel.

Le projet de départ reprend l’API terminée de l’étude de cas Créer une API de données sur les demandes de service municipal, avec une première exportation CSV. Il est passé d’un fichier SQLite à PostgreSQL, car de nouvelles données doivent arriver pendant que l’API fonctionne. Le projet terminé présente le résultat pour vous aider si vous bloquez. Le code est sous licence MIT.

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

Ce que vous devez savoir

Cette étude de cas utilise tout le cours, avec une API qui n’appartient pas à Larkfield. Elle s’appuie surtout sur Modèle de charge de travail, Travail d’E/S et travail de calcul, Clés et invalidation, Cycle de vie d’une tâche, Contre-pression et Concevoir un test de charge. Vous n’avez pas besoin de l’étude de cas du cours sur les API.

Ce qu’il vous faut sur votre ordinateur

  • Python 3.12 ou une version plus récente, VS Code, curl et Docker Desktop.
  • Environ 300 Mo d’espace disque libre : les paquets, les données (8 Mo à télécharger, 36 Mo décompressées) et PostgreSQL.
  • Environ 4 h, dont environ 30 minutes de tests de charge qui occupent votre ordinateur.

Testé sur macOS (Apple M4, 16 Go, Docker Desktop avec 10 processeurs, PostgreSQL 18.6, Valkey 9.1.2, Python 3.12.13). Les commandes Windows et Linux n’ont pas été testées. Tous les temps viennent de l’ordinateur de l’auteur, qui effectuait aussi d’autres travaux : vos résultats seront différents.

Teresa Okafor dirige l’équipe d’analyse du service des transports d’une ville. L’API de son équipe fournit les demandes 311 nettoyées de réparation des rues à tous les tableaux de bord. Priya Nair crée les tableaux de bord. Les personnes sont fictives; les demandes sont les vraies données ouvertes de New York.

L’API est maintenant populaire, et deux choses inquiètent Teresa :

  • Le lundi à 9 h, environ 30 personnes ouvrent les tableaux de bord et parcourent les vues. Les vues resteront-elles rapides?
  • L’exportation CSV. Les analystes ont demandé un fichier correspondant à un filtre, et l’équipe a ajouté rapidement une première version. GET /v1/exports.csv crée le fichier pendant que le client attend. À la fin de chaque mois, 16 analystes exportent les données pour le rapport mensuel, un fichier après l’autre. Quelqu’un a dit : « Les exportations vont dépasser le délai limite. »

La règle de Teresa : « Mesurez d’abord. Changez une seule chose à la fois. Dites-moi ce qui s’est amélioré, ce qui n’a pas changé et ce qui va tomber en panne ensuite. »

L’objectif. Avec une charge de travail consignée par écrit, il faut atteindre trois objectifs. Le p95 des requêtes des tableaux de bord reste sous 300 ms, même pendant les exportations des analystes. Chaque exportation produit un fichier. Et après le chargement de nouvelles données, aucun ancien chiffre ne s’affiche.

Deux panneaux. À gauche, projet de départ : tout se passe dans la requête. Les tableaux de bord (30 personnes) et les analystes appellent l'API, qui utilise un seul processus. Chaque agrégat est recalculé et un CSV est créé en mémoire pendant que le client attend (GET /v1/exports.csv, en rouge). L'API utilise un pool de 10 connexions à PostgreSQL avec service_requests. Une note rouge : une exportation occupe un fil d'exécution, une connexion et le processeur de l'API jusqu'à l'envoi du fichier. À droite, projet terminé : un cache et une file d'attente. Les tableaux de bord et les analystes appellent l'API, qui utilise un seul processus. Une exportation reçoit immédiatement une réponse 202, puis le fichier plus tard (POST /v1/exports). L'API lit les agrégats dans un cache Valkey vert dont les clés incluent la version des données. Elle utilise PostgreSQL avec service_requests, data_loads et export_jobs. Deux processus orange prennent une tâche avec SKIP LOCKED, traitent chacun un fichier à la fois et écrivent des fichiers CSV export-N.csv. Un chargeur en pointillés ajoute un nouveau mois : les lignes et la version dans une seule transaction.
Le projet de départ fait tout le travail dans la requête. Le projet terminé lit les réponses répétées dans un cache et crée les fichiers dans des processus distincts.
Description textuelle du diagramme

À gauche, un seul processus d’API fait tout. Une exportation occupe un fil d’exécution, une connexion et le processeur jusqu’à l’envoi du fichier. À droite, l’API fournit les agrégats depuis un cache et répond immédiatement aux demandes d’exportation; deux processus écrivent les fichiers.

Partie Ce qui change Mesures après le changement
1 docs/workload.md : la charge de travail, en chiffres –
2 rien : la référence de base trois exécutions
3 un cache Valkey pour les deux points de terminaison d’agrégats trois exécutions
4 l’exportation devient une tâche dans une file à capacité limitée, exécutée par des processus trois exécutions
5 rien : les trois versions côte à côte –
6 de nouvelles données, de bout en bout –

Les données sont les 311 Service Requests de New York pour le service des transports, de janvier à juin 2025. Elles contiennent 109 915 demandes concernant les nids-de-poule, les feux de circulation, l’éclairage public, les trottoirs et les panneaux. NYC Open Data indique : « Il n’y a aucune restriction sur l’utilisation des données ouvertes. » Le cours sur les API a nettoyé les données selon neuf règles, puis les a publiées dans un fichier SQLite avec une somme de contrôle. Le fichier DATASET.md du projet présente les règles et les limites.

Ce projet charge d’abord les données de janvier à mai (90 329 demandes) dans PostgreSQL. Il charge ensuite juin (19 586 demandes) comme nouvelles données. Chaque chargement correspond à une ligne de la table data_loads, et son numéro est la version des données.

Les étapes utilisent VS Code et son terminal. Exécutez chaque commande dans le dossier du projet.

  1. Téléchargez le projet de départ depuis l’encadré en haut de cette page. Décompressez-le dans votre dossier de projets, par exemple ~/projects. Vous obtenez le dossier city-requests-scaling.

  2. Dans VS Code, choisissez File > Open Folder (fichier, ouvrir un dossier), puis ouvrez city-requests-scaling. Ouvrez ensuite un terminal : Terminal > New Terminal (terminal, nouveau terminal).

  3. Créez et activez un environnement virtuel, puis installez les paquets :

    Fenêtre de terminal
    python3 -m venv .venv
    source .venv/bin/activate
    python -m pip install -r requirements.txt

    L’invite commence par (.venv). Les paquets utilisent les versions du cours : FastAPI 0.142.2, psycopg 3.3.6 avec son pool de connexions (pool), Locust 2.46.7, pytest et ruff.

  4. Démarrez PostgreSQL :

    Fenêtre de terminal
    docker compose up -d
  5. Téléchargez les données, vérifiez-les, puis chargez les données de janvier à mai dans PostgreSQL :

    Fenêtre de terminal
    python scripts/get_db.py
    python -m scripts.load
    Sortie
    Downloading https://github.com/Nextia-Intelligence/nextia-learning-labs/raw/main/C16/case-studies/data/service_requests_2025h1.db.gz
    Checked service_requests_2025h1.db.gz: SHA-256 26492959add9... is correct
    Wrote data/service_requests_2025h1.db: 109,915 service requests
    Loaded 90,329 requests created from 2025-01-01 to 2025-06-01 (not included).
    Data version: 1 (0.9 s)
  6. Exécutez les tests :

    Fenêtre de terminal
    python -m pytest
    Sortie (fin)
    ................................................................. [100%]
    65 passed in 1.95s

Ce que cela nous apprend. Le script a vérifié la somme de contrôle SHA-256 du téléchargement. Le chargeur a inséré 90 329 demandes dans PostgreSQL en une seule transaction : version des données 1. Les tests utilisent leur propre petite base de données, city_test, et ne touchent donc jamais à vos données.

Un test de charge répond à une question : « Le service suffit-il pour ce trafic? » Le premier fichier ne contient donc pas de code. C’est docs/workload.md, le Modèle de charge de travail de l’équipe de Teresa. L’API n’a pas encore de journal de trafic. Le modèle contient donc les hypothèses de l’équipe, écrites pour que tout le monde puisse les vérifier :

Qui Combien Ce qu’ils font Fréquence
Utilisateurs des tableaux de bord 30, le lundi à partir de 9 h ouvrent une vue : types de plaintes, deux graphiques quotidiens, une page, la page suivante, une demande (6 requêtes) une vue toutes les 10 s par personne : environ 18 requêtes/s
Analystes, matinée normale 4 demandent un fichier CSV correspondant à un filtre une exportation toutes les 15 s par personne
Analystes, fin de mois 16 demandent des fichiers CSV pour le rapport mensuel sans pause entre les exportations

« Aujourd’hui » correspond au début de juin 2025, et les données de juin arrivent plus tard comme nouvelles données. La plupart des vues affichent mai ou les trois mois jusqu’à mai, et 40 % affichent tous les arrondissements. Les exportations couvrent un arrondissement sur trois mois (environ 17 000 lignes), un type de plainte (32 202 lignes) ou tout (90 329 lignes).

Le fichier définit aussi ce qui est acceptable. Le p95 des tableaux de bord reste sous 300 ms, et le p99 sous 500 ms. Chaque exportation produit un fichier. Aucune ancienne réponse n’arrive après un chargement. Un client abandonne après 30 secondes.

loadtest/locustfile.py transforme le tableau en deux utilisateurs Locust. Deux détails comptent :

loadtest/locustfile.py (part)
class DashboardViewer(FastHttpUser):
"""Opens a dashboard: six requests, then waits for the next visit."""
fixed_count = int(os.environ.get("VIEWERS", "30"))
pace = float(os.environ.get("PACE_SECONDS", "10"))
wait_time = constant_pacing(pace)
network_timeout = TIMEOUT
connection_timeout = TIMEOUT
def on_start(self):
# Start at a random moment of the first pace, so that the viewers do not all
# click in the same second again and again.
time.sleep(_rng.uniform(0, self.pace))
  • constant_pacing(10) crée un taux d’arrivée : chaque utilisateur ouvre une vue toutes les 10 secondes, peu importe la durée de la précédente. C’est ce que font les vraies personnes. Avec PACE_SECONDS=0, l’utilisateur clique de nouveau dès qu’une réponse arrive. Cette boucle fermée trouve le maximum que l’API peut traiter.
  • Le départ aléatoire. La première exécution de l’auteur n’en avait pas : 30 utilisateurs cliquaient à la même seconde, puis l’API restait inactive. Aucune équipe n’a cette charge de travail.

scripts/bench.py exécute la charge trois fois, exclut les 10 premières secondes de chaque exécution et affiche la médiane des exécutions avec l’étendue. Il échantillonne aussi l’utilisation du processeur de l’API et du conteneur de base de données, ainsi que la mémoire de l’API. C’est la méthode de Concevoir un test de charge.

Démarrez l’API en mode production, sans ligne de journal par requête, car cela coûte du temps à 20 requêtes par seconde. Utilisez un deuxième terminal pour le banc d’essai.

Fenêtre de terminal
LOG_LEVEL=WARNING fastapi run

Consignez d’abord les caractéristiques de la machine. Exécutez ensuite les trois charges de travail de docs/workload.md. Chacune prend de trois à quatre minutes :

Fenêtre de terminal
python -m scripts.machine
python -m scripts.bench --label baseline
python -m scripts.bench --label baseline-burst --analysts 16 --export-pace 0
python -m scripts.bench --label baseline-capacity --viewers 32 --pace 0 --analysts 0 --seconds 40
Output of the first command (the author's computer)
Computer: Apple M4, 10 cores, 16.0 GB memory; Darwin 25.6.0 (arm64)
Python 3.12.13; Docker: Engine 29.6.1, 10 CPUs, 7.8 GB
Load average (1 minute): 5.36 (other programs that use the CPU make the numbers worse)

La fin du test de pointe de l’auteur (vos résultats seront différents) :

Sortie (fin)
Median of 3 passes (lowest-highest):
GET /v1/complaint-types | ok_per_s 2.96 (2.83-2.98) | p50_ms 1,440 (1,340-1,454) | p95_ms 2,037 (1,842-2,253) | p99_ms 2,146 (2,046-2,464) | errors 0 (0-0)
GET /v1/exports.csv | ok_per_s 5.66 (5.09-5.75) | p50_ms 2,262 (2,217-2,436) | p95_ms 5,499 (5,126-5,662) | p99_ms 5,984 (5,515-6,195) | errors 0 (0-0)
GET /v1/service-requests | ok_per_s 6.39 (6.16-6.5) | p50_ms 1,299 (1,237-1,394) | p95_ms 1,985 (1,842-2,238) | p99_ms 2,392 (1,957-2,579) | errors 0 (0-0)
GET /v1/service-requests/{id} | ok_per_s 3.28 (3.2-3.33) | p50_ms 1,248 (1,226-1,360) | p95_ms 1,939 (1,781-2,281) | p99_ms 2,058 (1,990-2,476) | errors 0 (0-0)
GET /v1/stats/daily | ok_per_s 6.19 (5.93-6.25) | p50_ms 1,370 (1,351-1,478) | p95_ms 1,975 (1,910-2,173) | p99_ms 2,262 (2,066-2,501) | errors 0 (0-0)
dashboard (all GET requests of a visit) | ok_per_s 18.55 (17.91-18.91) | p50_ms 1,340 (1,289-1,430) | p95_ms 1,970 (1,851-2,242) | p99_ms 2,244 (2,035-2,481) | errors 0 (0-0)
export: click to file | ok_per_s 5.66 (5.09-5.74) | p50_ms 2,262 (2,217-2,436) | p95_ms 5,499 (5,126-5,662) | p99_ms 5,984 (5,516-6,195) | errors 0 (0-0)
  • Lundi matin (4 analystes)
  • Pointe de fin de mois (16 analystes)
Le projet de départ, médianes de 3 exécutions sur l'ordinateur de l'auteur. Pendant la pointe de fin de mois, le p95 des mêmes requêtes de tableaux de bord était plus de dix fois plus élevé.
Description textuelle du graphique

Le lundi matin, les requêtes des tableaux de bord prenaient 29 ms à la médiane, 175 ms au p95 et 289 ms au p99. Pendant la pointe de fin de mois, les mêmes requêtes prenaient 1,340 ms, 1,971 ms et 2,244 ms.

Ce que cela nous apprend. Trois constats et une surprise.

  • Le lundi matin se passe bien. Le p95 des tableaux de bord était de 175 ms, sous la cible de 300 ms, sans erreurs. Les agrégats étaient les plus lents : /v1/stats/daily avait un p95 de 255 ms, contre 41 ms pour une page de la liste.
  • La pointe de fin de mois dépasse la cible pour tout le monde. Avec 16 exportations en cours, une requête de tableau de bord prenait 1,340 ms à la médiane et 1,971 ms au p95. Même la lecture d’une demande par son identifiant passait de 14 ms le lundi à 1,249 ms. Le processus de l’API utilisait un cœur de processeur entier (104 % en moyenne), contre seulement 20 % pour la base de données. Un processus Python exécute le code Python sur un seul cœur à la fois. Le travail CSV obligeait donc toutes les autres requêtes à attendre leur tour.
  • La mémoire. Le processus de l’API atteignait 974 Mo pendant la pointe (1,032 Mo lors d’une exécution), contre 284 Mo le lundi. Chaque exportation garde toutes ses lignes, puis le texte entier, en mémoire. Un conteneur limité à 512 Mo aurait été arrêté.
  • La surprise : aucun dépassement du délai limite. Chaque exportation de chaque exécution a produit une réponse. La plus lente prenait environ 6.3 secondes, loin de la limite de 30 secondes. La crainte « les exportations vont dépasser le délai limite » était fausse pour ces données et cette charge. Les vrais dommages touchaient le reste : les tableaux de bord et la mémoire. Consignez ce constat tel quel. Plus de données ralentiraient les exportations, mais cette exécution ne dit pas quand elles dépasseraient 30 secondes.

Le test de capacité cherchait la charge maximale, avec seulement les tableaux de bord et aucune pause. Le projet de départ traitait 881 requêtes de tableaux de bord par seconde, avec un p95 de 50 ms. La base de données utilisait environ 315 % du processeur (trois cœurs), et l’API 123 %. La moitié des requêtes sont des agrégats, recalculés chaque fois.

Un magasin compte sa caisse chaque fois que quelqu’un demande « combien avons-nous vendu en mai? » Il refait la même somme, même si mai est terminé. L’API fait la même chose. Chaque vue de mai exécute GROUP BY sur les lignes du mois. La plupart des visiteurs demandent les mêmes quelques vues.

L’idée : stocker la réponse et inclure dans la clé tout ce qui la change

Section intitulée « L’idée : stocker la réponse et inclure dans la clé tout ce qui la change »

Un cache conserve une réponse calculée sous une clé. La prochaine requête avec cette clé la lit plutôt que de la recalculer. Les quatre questions de Choisir ce qui peut être mis en cache donnent toutes un oui. Un GROUP BY et une médiane coûtent cher à calculer. Quelques vues représentent la majorité du trafic. Tous les appelants peuvent voir la réponse, et seul un chargement de nouvelles données la change. La clé contient donc les paramètres et la version des données, comme dans Clés et invalidation :

La clé city:v1:stats-daily:data=2:scope=public:17649fd3c61deca6a50459dd4c9448bf, pour GET /v1/stats/daily avec borough brooklyn du 2025-06-01 au 2025-07-01, divisée en cinq parties. city:v1: à qui appartient la clé et le format de la valeur stockée. stats-daily : quelle réponse, les chiffres quotidiens. data=2, en vert : la version des données, augmentée de un à chaque chargement de nouvelles demandes. scope=public, en rouge : qui peut la voir; des données ouvertes, identiques pour tous les appelants. 17649fd3…: les paramètres validés, triés et hachés.
Une vraie clé du projet. La version des données (en vert) donne une nouvelle clé aux nouvelles données. La portée (en rouge) indique qui peut recevoir la réponse.
Description textuelle du diagramme

Cinq parties, séparées par des deux-points : le propriétaire de la clé et la réponse, la version des données, la portée et un hachage des paramètres validés.

Deux parties méritent une explication :

  • scope=public. La règle du cours exige que chaque clé contienne la portée d’identité de l’appelant. Ici, tous les appelants reçoivent la même réponse. La portée est donc public (publique), écrite explicitement. Si l’API affiche un jour des champs réservés au personnel, ces réponses auront une autre portée. Aucune clé publique ne pourra les fournir.
  • data=2. L’invalidation repose sur la version, pas sur la suppression des clés. Le chargeur ajoute les nouvelles lignes et une ligne dans data_loads dans une seule transaction. L’API lit la version la plus récente, puis construit la clé. Après un chargement, chaque requête construit une nouvelle clé. Aucune ancienne réponse n’est donc relue; les anciennes clés expirent après leur durée de vie (TTL) de 1 heure.

Voici un petit exemple où toutes les valeurs sont visibles :

Étape Événement Version la plus récente Fin de la clé Résultat
1 Priya ouvre Brooklyn, juin 1 data=1:…:17649fd3… absence du cache : juin compte 0 demande (pas encore chargé)
2 Elle l’ouvre de nouveau 1 data=1:…:17649fd3… présence dans le cache : toujours 0
3 Le chargeur ajoute juin 1 → 2 – –
4 Elle l’ouvre de nouveau 2 data=2:…:17649fd3… absence du cache : les chiffres de juin

Voici les parties qui concrétisent l’idée; le projet terminé contient tous les fichiers.

  1. Ajoutez le cache à compose.yaml, sous db, et démarrez-le. Il ne conserve rien sur disque, donc un redémarrage le vide. Un cache doit pouvoir supporter cela :

    compose.yaml (part)
    cache:
    image: valkey/valkey:9.1.2-trixie
    command: ["valkey-server", "--save", "", "--appendonly", "no", "--maxmemory", "128mb",
    "--maxmemory-policy", "allkeys-lru"]
    ports:
    - "127.0.0.1:${CACHE_PORT:-6379}:6379"
    Fenêtre de terminal
    docker compose up -d cache
  2. Ajoutez redis==8.1.0 à requirements.txt et à pyproject.toml, puis installez-le : python -m pip install -r requirements.txt. C’est le client pour Valkey.

  3. Ajoutez city_api/cache.py, avec la classe Cache de Pannes et ruée sur le cache. Elle a un délai maximal de 50 ms et laisse passer les requêtes après une erreur. Elle permet à une seule requête de calculer une nouvelle clé. La clé :

    city_api/cache.py (part)
    def answer_key(name: str, data_version: int, params: dict, scope: str = "public") -> str:
    """The key of a cached answer. The same parameters in another order give the same key."""
    text = json.dumps(params, sort_keys=True, default=str, separators=(",", ":"))
    digest = hashlib.sha256(text.encode()).hexdigest()[:32]
    return f"{PREFIX}:v1:{name}:data={data_version}:scope={scope}:{digest}"
  4. Dans city_api/routes.py, les deux routes d’agrégation appellent une même fonction auxiliaire. Elle lit la version des données et rend la connexion avant d’interroger le cache. Ainsi, une requête qui attend le résultat d’une autre ne garde aucune connexion :

    city_api/routes.py (part)
    with app.state.db.connection() as conn:
    version = queries.data_version(conn)
    key = answer_key(name, version, params)
    def compute_with_a_connection():
    with app.state.db.connection() as conn:
    return compute(conn)
    value, how = cache.get_or_compute(
    key, compute_with_a_connection, settings.cache_ttl_seconds, settings.cache_lock_seconds
    )
    response.headers["X-Cache"] = how
    response.headers["X-Data-Version"] = str(version)

    params contient les valeurs validées. Les mêmes paramètres dans un autre ordre produisent donc une seule clé. Une requête invalide n’atteint jamais le cache.

  5. Ajoutez CACHE_URL et les autres paramètres du cache à city_api/config.py et à .env.example. Ouvrez le cache dans main.py et ajoutez tests/test_cache.py. Puis exécutez les tests :

    Fenêtre de terminal
    python -m pytest
    Sortie (fin)
    ........................................................................ [ 94%]
    .... [100%]
    76 passed in 2.66s

Les nouveaux tests vérifient les présences et absences dans le cache, les nouvelles données et un cache arrêté (X-Cache: off, cache désactivé). Ils vérifient aussi la protection contre la ruée : 8 requêtes simultanées pour une nouvelle clé ne la calculent qu’une fois.

Observez maintenant tout le cycle de vie d’une clé. Redémarrez l’API (fastapi dev convient ici), puis demandez Brooklyn en juin deux fois. Juin n’est pas encore chargé :

Fenêtre de terminal
curl -i "http://127.0.0.1:8000/v1/stats/daily?borough=brooklyn&created_from=2025-06-01&created_to=2025-07-01"
Output (headers and the first day; the second call is the same with X-Cache: hit)
HTTP/1.1 200 OK
date: Sat, 10 Oct 2026 15:05:01 GMT
server: uvicorn
content-length: 3671
content-type: application/json
x-cache: miss
x-data-version: 1
x-request-id: d81898d3ceb6
{"items":[{"date":"2025-06-01","opened":0,"closed_within_14_days":0,"share_closed_within_14_days":null,"median_days_to_close":null}, …

Chargez ensuite juin, les nouvelles données, et refaites la demande :

Fenêtre de terminal
python -m scripts.load --month 2025-06
curl -i "http://127.0.0.1:8000/v1/stats/daily?borough=brooklyn&created_from=2025-06-01&created_to=2025-07-01"
Output (the load, then headers and the first day)
Added 19,586 requests created in 2025-06.
Data version: 2 (0.3 s)
HTTP/1.1 200 OK
date: Sat, 10 Oct 2026 15:05:02 GMT
server: uvicorn
content-length: 3809
content-type: application/json
x-cache: miss
x-data-version: 2
x-request-id: 8bf56733c141
{"items":[{"date":"2025-06-01","opened":96,"closed_within_14_days":86,"share_closed_within_14_days":0.896,"median_days_to_close":1.54}, …

Ce que cela nous apprend. La deuxième réponse venait du cache. Ensuite, le chargement a ajouté juin et la version 2 des données dans une seule transaction. La requête suivante a construit une nouvelle clé, absente du cache, et a aussitôt calculé les chiffres de juin. Personne n’a supprimé de clé, et aucun TTL n’a dû prendre fin. L’ancienne réponse expire sans être utilisée dans l’heure qui suit.

Mesurez maintenant les trois mêmes charges de travail (--label cache, et ainsi de suite). L’exportation reste synchrone : un changement à la fois.

Les résultats de l’auteur (médianes de 3 essais; vos chiffres seront différents) :

Charge de travail Mesure Version initiale Avec le cache
Lundi matin p95 du tableau de bord 175 ms 118 ms
Lundi matin p95 de /v1/stats/daily 255 ms 160 ms
Pointe de fin de mois p95 du tableau de bord 1,971 ms 2,213 ms
Capacité requêtes du tableau de bord par seconde 881 1,348
Capacité utilisation du processeur de la base de données (moyenne) 315 % 33 %

Ce que cela nous apprend. Avec seulement des tableaux de bord, l’API a répondu à environ une fois et demie autant de requêtes. L’utilisation du processeur de la base de données est passée de trois cœurs à un tiers de cœur. Le lundi, le p95 a baissé; un nouveau filtre reste absent du cache. Mais la pointe de fin de mois ne s’est pas améliorée. Le travail de calcul des exportations se fait dans le processus de l’API, pas dans la base de données. Un cache élimine le travail répété, rien d’autre. L’exportation est le vrai problème.

Partie 4 : les exportations comme tâches en arrière-plan

Section intitulée « Partie 4 : les exportations comme tâches en arrière-plan »

Le problème : une grosse tâche dans une petite requête

Section intitulée « Le problème : une grosse tâche dans une petite requête »

Dans un magasin de photos, vous pouvez attendre au comptoir pendant que le commis imprime une photo. Pour un album complet, le commis vous donne un billet : « Revenez dans une heure. » S’il imprimait les albums au comptoir, tous les gens derrière vous attendraient aussi.

GET /v1/exports.csv imprime les albums au comptoir. Une exportation complète lit 90 329 lignes et construit environ 15 Mo de texte en mémoire. Jusqu’à l’envoi du fichier, elle occupe un fil d’exécution, une connexion et le processeur de l’API. Ce travail de calcul ralentit toutes les autres requêtes du processus, comme dans Travail d’E/S et travail de calcul. Et rien ne limite le nombre d’exportations simultanées.

L’idée : un billet maintenant, le fichier plus tard

Section intitulée « L’idée : un billet maintenant, le fichier plus tard »

L’API enregistre l’exportation comme une tâche. Elle répond aussitôt 202 Accepted (acceptée), avec Location: /v1/exports/N (emplacement de la tâche). Un processus séparé prend les tâches en attente une à la fois et écrit les fichiers. Le client demande l’état de la tâche jusqu’à ce qu’il indique succeeded (réussie), puis télécharge le fichier. C’est la file d’attente de Cycle de vie d’une tâche, dans PostgreSQL, avec trois protections :

  • Une limite (Contre-pression). Au plus 20 exportations attendent. La 21e reçoit 503 queue_full (file pleine) avec Retry-After (délai avant une nouvelle tentative), et rien n’est enregistré.
  • Une limite de débit par appelant. Au-delà de 10 exportations par minute pour un même X-Client-ID, la réponse est 429 rate_limited (débit limité). Valkey compte les exportations. Un script très actif ne peut pas remplir la file pour tout le monde.
  • Une clé d’idempotence (Livraison et nouvelles tentatives). Un client qui renvoie la même requête avec le même Idempotency-Key reçoit la même tâche, pas une deuxième exportation.
Un flux. POST /v1/exports avec Idempotency-Key k1. Une branche en pointillés : clé déjà vue, la même tâche à nouveau, Idempotent-Replayed. Puis « Plus de 10 par minute pour cet appelant? » : oui mène à 429 rate_limited avec Retry-After. Non mène à « Déjà 20 exportations en attente? » : oui mène à 503 queue_full, Retry-After, rien d'enregistré. Non mène à « INSERT de la tâche, état queued », puis 202 avec Location /v1/exports/N. En dessous, le processus : « Un processus la prend : SKIP LOCKED, bail de 60 s », puis « Écrire .tmp, puis renommer », puis succeeded. Depuis le processus, une erreur mène à « remise en file après un délai d'attente croissant », et après 3 tentatives à dead_letter. Une branche en pointillés : processus arrêté, le bail expire, un autre processus écrit le même fichier. Une ligne en pointillés relie la réponse 202 au client, qui demande GET /v1/exports/N jusqu'à succeeded, puis récupère le fichier.
Le parcours d'une exportation. Les vérifications refusent le travail avant son enregistrement. Le processus crée le fichier; une deuxième livraison réécrit le même fichier.
Description textuelle du diagramme

Deux vérifications précèdent tout enregistrement : la limite de débit de l’appelant, puis la limite de la file. Chaque refus indique quand réessayer. Un processus prend une tâche enregistrée avec un bail et écrit le fichier sous un nom temporaire. Une erreur remet la tâche en file avec un délai d’attente croissant. Après trois tentatives, elle devient une tâche en échec définitif.

Pourquoi écrire deux fois le même fichier est sans danger. Une tâche peut être livrée deux fois. Un processus peut s’arrêter après avoir écrit le fichier, mais avant d’avoir marqué la tâche comme terminée. Le travail doit donc être idempotent. Le nom du fichier est l’identifiant de la tâche. Le processus renomme export-N.csv.tmp seulement à la fin. Une deuxième livraison réécrit le même fichier, et un client ne voit jamais un fichier incomplet.

  1. Ajoutez migrations/002_export_jobs.sql : la table export_jobs, avec l’état, les tentatives, le bail, l’appelant, une clé d’idempotence unique par appelant et les renseignements du fichier. Appliquez la migration :

    Fenêtre de terminal
    python -m city_api.migrate
    Sortie
    Applied 002_export_jobs.sql
  2. Ajoutez city_api/exports.py, qui contient toutes les instructions SQL de la file d’attente. Dans Contre-pression, une file limitée à 100 contenait 107 tâches. Deux requêtes pouvaient compter 99 tâches et insérer chacune une tâche. Ici, un verrou de transaction fait de « compter, puis insérer » une seule étape :

    city_api/exports.py (part)
    conn.execute("SELECT pg_advisory_xact_lock(%s)", (SUBMIT_LOCK,))
    if idempotency_key is not None:
    old = conn.execute(
    f"SELECT {JOB_COLUMNS}, request_sha256 FROM export_jobs"
    " WHERE actor = %s AND idempotency_key = %s",
    (actor, idempotency_key),
    ).fetchone()
    if old is not None:
    if old.pop("request_sha256") != request_sha256:
    raise IdempotencyConflict(idempotency_key)
    return old, True
    queued = queued_count(conn)
    if queued >= queue_max:
    raise QueueFull(queued, retry_after_seconds(conn, queued))

    Le verrou force les soumissions à attendre leur tour. C’est peu coûteux pour quelques exportations par seconde, mais un goulot d’étranglement pour des milliers.

  3. Ajoutez city_api/export_routes.py (POST /v1/exports, GET /v1/exports/{id}, GET /v1/exports/{id}/file, GET /v1/export-queue) et city_api/worker.py. Supprimez city_api/csv_export.py. Le processus lit la version des données et les lignes dans une seule transaction REPEATABLE READ. Un chargement ne peut donc pas mélanger deux versions dans un fichier. Il traite les lignes en flux, 2 000 à la fois. Un gros fichier ne reste donc jamais entièrement en mémoire.

  4. Modifiez l’analyste dans loadtest/locustfile.py : il envoie POST /v1/exports, demande l’état chaque seconde et télécharge le fichier. « export : click to file » (exportation : du clic au fichier) mesure toujours toute l’attente. La comparaison des versions reste donc équitable.

  5. Ajoutez tests/test_exports.py, puis exécutez les tests :

    Fenêtre de terminal
    python -m pytest
    Sortie (fin)
    ........................................................................ [ 80%]
    .................. [100%]
    90 passed in 3.11s

Supprimer GET /v1/exports.csv rend ses clients incompatibles. Ici, le seul client est le tableau de bord de Priya, qui change en même temps. Avec des clients externes, gardez l’ancien point de terminaison jusqu’à leur migration, comme l’indique Conception des ressources et des points de terminaison.

Essayez avec trois terminaux : l’API (fastapi dev), le client et, plus tard, un processus. Demandez Brooklyn en mai, puis renvoyez la même requête avec la même clé :

Fenêtre de terminal
curl -i -X POST http://127.0.0.1:8000/v1/exports -H "Content-Type: application/json" -H "Idempotency-Key: 7f9c2b1e-may-brooklyn" -H "X-Client-ID: priya" -d '{"borough": "brooklyn", "created_from": "2025-05-01T00:00:00", "created_to": "2025-06-01T00:00:00"}'
Output of the first request
HTTP/1.1 202 Accepted
date: Sat, 10 Oct 2026 15:05:11 GMT
server: uvicorn
content-length: 399
content-type: application/json
location: /v1/exports/1
x-request-id: 3864df68e922
{"export_id":1,"state":"queued","filters":{"status":null,"borough":"brooklyn","created_to":"2025-06-01T00:00:00","created_from":"2025-05-01T00:00:00","complaint_type":null},"attempts":0,"created_at":"2026-10-10T15:05:12+00:00","started_at":null,"finished_at":null,"queued_ahead":0,"estimated_wait_seconds":null,"data_version":null,"row_count":null,"file_bytes":null,"download_url":null,"error":null}
Output of the same request again (headers)
HTTP/1.1 202 Accepted
date: Sat, 10 Oct 2026 15:05:11 GMT
server: uvicorn
content-length: 399
content-type: application/json
location: /v1/exports/1
idempotent-replayed: true
x-request-id: 64915a19b0a3

La même clé avec un autre corps ({"borough": "queens"}) reçoit 422 idempotency_key_reused (clé d’idempotence réutilisée). Rien n’a encore créé le fichier : aucun processus ne tourne. Démarrez-en un dans le troisième terminal, python -m city_api.worker, puis demandez l’état :

Worker log, then GET /v1/exports/1
INFO city_api.worker: worker Usmans-Mac-mini.local-26621: waiting for exports
INFO city_api.worker: export 1: 5690 rows in 0.04 s
$ curl -s http://127.0.0.1:8000/v1/exports/1
{"export_id":1,"state":"succeeded","filters":{"status":null,"borough":"brooklyn","created_to":"2025-06-01T00:00:00","created_from":"2025-05-01T00:00:00","complaint_type":null},"attempts":1,"created_at":"2026-10-10T15:05:12+00:00","started_at":"2026-10-10T15:05:12+00:00","finished_at":"2026-10-10T15:05:12+00:00","queued_ahead":null,"estimated_wait_seconds":null,"data_version":2,"row_count":5690,"file_bytes":954422,"download_url":"/v1/exports/1/file","error":null}

Enfin, la limite. Arrêtez le processus (Ctrl+C). Envoyez simultanément 30 exportations complètes, chacune depuis son propre appelant. Ainsi, seule la limite de la file peut les arrêter :

Fenêtre de terminal
python -m scripts.send_exports --count 30
Sortie
30 export requests at once: status codes {202: 20, 503: 10}
Retry-After of the refused ones: 300 s
Queue now: {'queued': 20, 'running': 0, 'dead_letter': 0, 'succeeded_last_minute': 1, 'oldest_queued_seconds': 0.1}

Redémarrez maintenant le processus dans le troisième terminal. Attendez une demi-minute, regardez la file et envoyez 30 autres exportations :

Fenêtre de terminal
python -m city_api.worker
Fenêtre de terminal
curl -s http://127.0.0.1:8000/v1/export-queue
python -m scripts.send_exports --count 30
Worker log (start), then the two commands
INFO city_api.worker: worker Usmans-Mac-mini.local-26640: waiting for exports
INFO city_api.worker: export 2: 109915 rows in 0.59 s
INFO city_api.worker: export 3: 109915 rows in 0.59 s
$ curl -s http://127.0.0.1:8000/v1/export-queue
{"queued":0,"running":0,"dead_letter":0,"succeeded_last_minute":21,"oldest_queued_seconds":0.0}
$ python -m scripts.send_exports --count 30
30 export requests at once: status codes {202: 21, 503: 9}
Retry-After of the refused ones: 58 s
Queue now: {'queued': 20, 'running': 1, 'dead_letter': 0, 'succeeded_last_minute': 21, 'oldest_queued_seconds': 0.1}

Ce que cela nous apprend. La répétition avec la même clé a renvoyé la même tâche, marquée Idempotent-Replayed (réponse idempotente rejouée). Le processus a créé le fichier en 0,04 seconde. Sans processus actif, la file s’est remplie jusqu’à sa limite. Les autres requêtes ont reçu 503 queue_full. Le Retry-After suit le rythme. Avec une exportation terminée dans la dernière minute, 20 exportations en attente nécessitent 20 minutes. L’API a donc indiqué son maximum, 300 secondes. Avec 21 par minute, elle a indiqué 58 secondes. (Sans exportation dans la dernière minute, elle ne peut pas savoir et indique 60.)

Mesurez maintenant les trois charges de travail (--label finished, et ainsi de suite), avec deux processus dans deux terminaux supplémentaires.

Les trois versions ont exécuté les trois mêmes charges de travail sur le même ordinateur. Mêmes utilisateurs, débits, durées en secondes et données, avec trois essais chacune. Voici les résultats de l’auteur côte à côte (médianes de 3 essais; vos chiffres seront différents) :

Charge de travail Mesure Version initiale Cache Cache et file d’attente
Lundi matin p50 / p95 / p99 du tableau de bord 29 / 175 / 289 ms 23 / 118 / 182 ms 23 / 48 / 56 ms
Lundi matin exportation, du clic au fichier, p50 303 ms 306 ms 1,057 ms
Pointe de fin de mois p50 / p95 / p99 du tableau de bord 1,340 / 1,971 / 2,244 ms 1,340 / 2,213 / 2,875 ms 30 / 53 / 68 ms
Pointe de fin de mois erreurs du tableau de bord 0 0 0
Pointe de fin de mois exportation, du clic au fichier, p50 / p95 2,262 / 5,499 ms 2,350 / 5,129 ms 2,025 / 2,256 ms
Pointe de fin de mois fichiers par seconde 5.7 5.6 3.6
Pointe de fin de mois exportations refusées (429), par essai 0 0 75,327
Pointe de fin de mois utilisation du processeur de l’API (moyenne) / mémoire de l’API (max.) 104 % / 974 Mo 104 % / 604 Mo 70 % / 99 Mo
Capacité requêtes du tableau de bord par seconde, p95 881, 50 ms 1,348, 37 ms 1,409, 32 ms
  • Lundi matin
  • Pointe de fin de mois
p95 du tableau de bord, médianes de 3 essais sur l'ordinateur de l'auteur. Seule la file d'attente a ramené la pointe de fin de mois sous la cible de 300 ms.
Description textuelle du graphique

Le lundi matin, le p95 du tableau de bord était de 175 ms pour la version initiale. Il était de 118 ms avec le cache et de 48 ms avec le cache et la file d’attente. Pendant la pointe de fin de mois, il était de 1,971 ms, 2,213 ms et 53 ms.

Mémoire maximale du processus de l'API pendant la pointe, médianes de 3 essais. Les processus traitent les lignes en flux, donc l'API ne conserve aucun fichier.
Description textuelle du graphique

Le processus de l’API utilisait jusqu’à 974 Mo dans la version initiale, 604 Mo avec le cache et 99 Mo avec la file d’attente.

Ce que cela nous apprend. L’objectif est atteint, avec un compromis et une surprise.

  • Les tableaux de bord. Pendant la pointe, le p95 du tableau de bord est passé d’environ deux secondes à 53 ms. Il est sous la cible, sans erreur. Le processus de l’API ne fait plus aucun travail CSV, et sa mémoire est restée près de 99 Mo.
  • Le compromis : une petite exportation attend plus longtemps. Le lundi, la médiane du délai entre le clic et le fichier est passée de 303 ms à 1,057 ms. Le client demande l’état une fois par seconde. Même un fichier produit rapidement attend donc la prochaine question. Pendant la pointe, les fichiers arrivaient plus régulièrement : un p95 de 2,256 ms, contre 5,499 ms.
  • La surprise : 75,327 refus par essai. Moins de fichiers arrivaient par seconde (3.6 contre 5.7), car chaque analyste peut lancer 10 exportations par minute. Les analystes du test réessayaient aussitôt après chaque 429 : ils ignoraient Retry-After. Les refus coûtaient peu et n’enregistraient rien, mais ils occupaient le processeur de l’API. Un vrai client doit attendre comme l’indique Retry-After. Teresa doit décider si 10 par minute convient au rapport mensuel.

La comparaison est-elle équitable? La charge de travail, les données et le test de charge étaient identiques, sauf les nouvelles étapes d’exportation de l’analyste. La machine n’était pas au repos : la charge avant les essais se situait entre 3.3 et 12.1. Ne retenez donc que les différences plus grandes que l’étendue des résultats des essais. Les résultats des tableaux de bord pendant la pointe se chevauchent pour la version initiale et le cache. « Le cache a aggravé la pointe » n’est pas une conclusion.

Suivez juin dans tout le système, avec les sorties que vous avez vues :

Étape Ce que vous avez vu Ce qui le prouve
La ville publie juin scripts.load --month 2025-06 a ajouté 19 586 demandes Data version: 2 (version des données : 2), lignes et version dans une seule transaction
Un tableau de bord demande juin X-Cache: miss (absence du cache), puis les chiffres de juin la clé contient maintenant data=2; l’ancienne réponse n’est jamais lue
Un analyste exporte tout le processus a écrit 109 915 lignes 90 329 + 19 586 : janvier à juin; chaque tâche enregistre sa version des données (exportation 1 : 2)

Un nouveau mois atteint toutes les réponses immédiatement, sans redémarrage, sans suppression de clé et sans fichier périmé.

Le test de capacité, avec les tableaux de bord seulement, traite maintenant 1,409 requêtes par seconde avec un p95 de 32 ms. Le conteneur de base de données utilisait 33 % du processeur, et le processus de l’API, 142 %. La base de données n’est plus la limite : c’est l’unique processus de l’API. Locust fonctionnait sur le même ordinateur et utilisait aussi le processeur.

La prochaine étape consiste à ajouter des processus d’API, par exemple avec fastapi run --workers 4. Le cache, la limite de débit et la file d’attente sont à l’extérieur du processus. Tous les processus les partagent donc. Mais mesurez le résultat, comme dans Comparer les configurations : ne promettez pas un débit quatre fois plus élevé. Ensuite viennent des limites non mesurées ici : le verrou de soumission, le disque pour les fichiers et un accès manqué au cache avec un gros filtre.

N’extrapolez pas. 1,409 requêtes par seconde représente environ 66 fois le débit mesuré du lundi, sur cet ordinateur, avec ces données. Un serveur avec d’autres processeurs, un réseau et trois fois plus de données constitue un autre système. Mesurez-le sur ce système.

  • La charge de travail réelle. Remplacez les hypothèses de docs/workload.md par un journal du trafic : vues, filtres et fréquence des exportations des analystes.
  • Le cache : le taux de succès et la durée des accès manqués par point de terminaison. Mesurez aussi combien de temps prennent les premiers accès manqués après un chargement.
  • La file d’attente : sa longueur, l’âge de la tâche la plus ancienne, les fichiers par minute, les messages non traitables et les nombres de réponses 429 et 503. GET /v1/export-queue fournit la plupart de ces mesures; affichez-les sur un tableau de bord avec des alertes.
  • La mémoire de l’API et de chaque processus, par rapport aux limites des conteneurs.
  • Le générateur de charge sur un autre ordinateur, avec une copie correspondant à la taille réelle des données.
  • Mesurez ce qui vous inquiète. L’équipe craignait les délais d’attente dépassés. Les mesures ont révélé autre chose : des tableaux de bord lents et 1 Go de mémoire. Corrigez ce que vous mesurez.
  • Un changement, un goulot d’étranglement. Le cache a éliminé le travail répété de la base de données. Il n’a pas corrigé la pointe, car son problème venait du travail de calcul dans l’API. La file d’attente l’a corrigé.
  • Une file d’attente déplace l’attente; elle ne supprime pas le travail. Les fichiers demandent le même travail, dans un autre processus, avec des limites. Une petite exportation attend un peu plus longtemps.
  • Limites de cette étude. Un seul portable partagé, le générateur de charge sur ce portable, aucun réseau, 90 329 lignes, une charge fondée sur des hypothèses. Windows et Linux ne sont pas testés.
  • Les données ouvertes concernent aussi des personnes. Les demandes contiennent des lieux, pas des noms. Ne joignez pas une exportation à d’autres données pour découvrir qui a signalé quoi.
  • Une demande n’est pas un problème, et un dossier fermé ne signifie pas que le problème est réparé. Classer les arrondissements par nombre de demandes revient à classer les endroits où les gens utilisent le 311. Affichez les mises en garde de DATASET.md à côté des chiffres.
  • Indiquez la version des données. Affichez X-Data-Version (version des données) et son heure de chargement sur le tableau de bord. Ainsi, personne ne confondra les chiffres de mai avec ceux de juin.
  • Testez la charge seulement sur vos propres services. Ne dirigez jamais Locust vers l’API de la ville ou un service que vous n’exploitez pas. Pour son propriétaire, cela ressemble à une attaque.
  • Les exportations sont des copies. Un fichier téléchargé échappe au contrôle de l’API. Conservez les fichiers peu de temps et indiquez cette durée dans le README.

Ce projet montre ce que les employeurs recherchent chez un ingénieur en développement côté serveur. Il présente une charge de travail définie, des mesures honnêtes et un cache qui ne donne jamais de résultats incorrects. Le travail lent ne fait plus partie du traitement des requêtes.

Quoi mettre dans le dépôt :

city-requests-scaling/
README.md what it is, how to run, check and measure it, the results table
DATASET.md the source, the licence, the checksum, the changes, the limits
LICENSE MIT, for the code
docs/workload.md the workload, with every assumption
docs/results.md your numbers: machine, workload, medians of 3 passes, the next bottleneck
city_api/ the API, the cache, the export queue and the worker
migrations/ 001 the requests and the data versions, 002 the export jobs
loadtest/ the Locust workload
scripts/ get_db, load, bench, percentiles, machine, send_exports
tests/ 90 tests
  1. Créez un dépôt Git à partir du dossier de votre projet et poussez-le vers GitHub. .gitignore exclut le fichier de base de données, les exportations et les résultats.
  2. Remplissez docs/results.md avec vos trois tests et les caractéristiques de votre ordinateur. Ajoutez un lien vers ce fichier dans le README.
  3. Vérifiez que python -m pytest réussit depuis un nouveau clone, avec docker compose up -d, et indiquez-le dans le README.

Vérifiez votre compréhension

Avec le cache, l'utilisation du processeur par la base de données pendant le test de capacité est passée d'environ 315 % à 33 %. Pourtant, pendant la pointe de fin de mois, les tableaux de bord attendaient encore environ deux secondes. Pourquoi?

Afficher la réponse

Le cache élimine le travail répété de la base de données. Le problème de la pointe se trouvait ailleurs. Seize exportations construisaient du texte CSV dans l’unique processus de l’API. Ce travail de calcul faisait attendre toutes les autres requêtes. La base de données était peu occupée pendant la pointe, avec environ 20 % d’utilisation du processeur. Un cache devant elle ne pouvait donc pas aider. Seul le déplacement de l’exportation hors du processus de l’API a corrigé la pointe.

Vérifiez votre compréhension

Après l'ajout de la file d'attente, une petite exportation du lundi prenait environ 1 060 ms du clic au fichier. Avant, elle prenait environ 300 ms. La file d'attente est-elle une erreur?

Afficher la réponse

Non, c’est un compromis. Le client demande l’état une fois par seconde. Même un fichier produit en un dixième de seconde attend donc la prochaine demande. En échange, les exportations ne ralentissent plus les tableaux de bord : leur p95 pendant la pointe est de 53 ms plutôt qu’environ deux secondes. Et la mémoire de l’API reste près de 100 Mo. Si l’attente compte, demandez l’état plus souvent au début, puis mesurez de nouveau.

Vérifiez votre compréhension

Pendant le test de pointe du projet terminé, l'API a refusé environ 75 000 demandes d'exportation à chaque passage. Toutes ont reçu le code 429. Un collègue affirme que la limite de débit a empêché les exportations de fonctionner. Que répondez-vous?

Afficher la réponse

Les refus provenaient du client du test de charge. Chaque analyste peut lancer 10 exportations par minute. Les analystes du test redemandaient immédiatement après chaque réponse 429, sans attendre selon Retry-After (délai avant une nouvelle tentative). Chaque refus prenait quelques millisecondes et n’enregistrait rien. Le p95 des tableaux de bord restait à 53 ms. Faites attendre le client selon Retry-After. Demandez à Teresa si 10 exportations par minute conviennent au rapport mensuel, puis mesurez de nouveau.

Récapitulatif

  • Vous avez d’abord décrit la charge de travail : 30 personnes consultent une vue toutes les 10 secondes, 4 analystes un matin normal, 16 en fin de mois.
  • La référence de base convenait le lundi. Pendant la pointe, le p95 des requêtes de tableau de bord était environ dix fois plus lent. La mémoire de l’API atteignait environ 1 Go. Aucun délai d’attente n’a été dépassé.
  • Un cache dont la clé inclut la version des données a augmenté d’environ la moitié la capacité pour les tableaux de bord seulement. Il n’a jamais donné de résultats incorrects après l’arrivée de nouvelles données. Il n’a pas corrigé la pointe.
  • Les exportations sont devenues des tâches dans une file d’attente bornée, avec des clés d’idempotence, une limite de débit et deux processus. Le p95 des tableaux de bord pendant la pointe est tombé à 53 ms, et la mémoire de l’API à environ 100 Mo. Une petite exportation attend maintenant environ une seconde.
  • Le prochain goulot d’étranglement est l’unique processus de l’API. Mesurez avec plus de processus; n’extrapolez pas.

Ensuite, le travail final : ajoutez une file d’attente bornée à un service de traitement de billets de soutien. Mesurez ses performances sous une charge de travail définie.

Leçon suivante : Travail final