Le problème
Le service order expose deux routes très
lues : la liste paginée des commandes et leur détail.
Avant d'ajouter une réplique, nous voulons voir l'API sous
une charge qui monte.
Un test improvisé vit sur un poste puis disparaît ; son
verdict se lit à l'œil. Nous voulons une pile assez petite
pour être copiée vers stock, et un test qui
échoue tout seul.
La solution
Quatre fichiers à côté du service : un fichier Compose, un Caddyfile, un script k6 et une story Foundry. Le projet Compose a son propre nom : la pile de développement reste intacte.
# services/order/compose.load.yaml
name: order-load
services:
database:
image: postgres:18-trixie
# ... identifiants et healthcheck ...
# Une fois : migre, puis remplit la base.
seed:
build: { context: ., target: frankenphp_dev }
command: bin/console foundry:load-fixtures load-test --append
depends_on:
database: { condition: service_healthy }
volumes: ['./:/app']
# ... environnement ...
api:
build: { context: ., target: frankenphp_prod }
depends_on:
seed: { condition: service_completed_successfully }
deploy:
replicas: ${API_REPLICAS:-3}
resources:
limits: { cpus: '1', memory: 1G }
# ... environnement et healthcheck ...
lb:
image: caddy:2-alpine
depends_on:
api: { condition: service_healthy }
ports: ['8480:80']
volumes: ['./load/Caddyfile:/etc/caddy/Caddyfile:ro']
k6:
image: grafana/k6:2.2.0
command: run /load/script.js
environment: { BASE_URL: 'http://lb' }
profiles: [test]
volumes: ['./load:/load:ro']
-
seedpart de l'image de dev, qui contient Foundry. L'entrypoint du gabarit symfony-docker migre la base avant la commande : les répliques ne se disputent pas les migrations. - Sans limite, une réplique prend toute la machine et une deuxième n'apporte rien de visible. Avec 1 CPU chacune, la même courbe sur une puis trois répliques mesure leur apport.
-
k6porte un profil :upne le démarre pas,run k6si.
Avec reverse_proxy api:80, Caddy ne verrait
qu'un upstream, résolu par
le DNS de Docker. Le module dynamic a crée un upstream par
enregistrement A du nom api, donc par réplique.
# services/order/load/Caddyfile
{
auto_https off
admin off
}
:80 {
reverse_proxy {
dynamic a api 80 {
refresh 5s
}
lb_policy round_robin
# Quelle réplique a répondu.
header_down X-Upstream {upstream_hostport}
}
}
Le script k6, seuils compris :
// services/order/load/script.js
import { check, sleep } from 'k6';
import http from 'k6/http';
export const options = {
scenarios: {
ramp: {
executor: 'ramping-vus',
stages: [
{ duration: '1m', target: 50 },
{ duration: '2m', target: 50 },
{ duration: '30s', target: 0 },
],
},
},
thresholds: {
http_req_failed: ['rate<0.01'],
http_req_duration: ['p(95)<800'],
'http_req_duration{name:order-detail}': ['p(95)<300'],
checks: ['rate>0.99'],
},
};
export default function () {
const page = 1 + Math.floor(Math.random() * 500);
const list = http.get(`${__ENV.BASE_URL}/orders?page=${page}`, {
tags: { name: 'order-list' },
});
check(list, { 'liste en 200': (r) => r.status === 200 });
const order = (list.json('member') || [])[0];
if (order) {
const detail = http.get(`${__ENV.BASE_URL}${order['@id']}`, { tags: { name: 'order-detail' } });
check(detail, { 'détail en 200': (r) => r.status === 200 });
}
sleep(1);
}
Le tag name regroupe les URL de détail sous un
seuil propre. Un seuil franchi fait sortir k6, donc la tâche
moon, avec un code non nul. Un check raté ne
change pas ce code : le seuil sur
checks l'y rattache.
Trois tâches moon, avec runInCI: false, lancent
up -d --build --wait,
run --rm k6 et down -v. Pour
stock, nous copions ces fichiers, puis
changeons la story et les requêtes.
Le piège
Ce test compare deux états sur une machine, sans dire ce que la production encaissera.
-
Une seule machine. Les répliques
partagent cœurs, mémoire et disque.
cpus: '1'est un quota, pas un cœur réservé : sur quatre cœurs, trois répliques, PostgreSQL et k6 se gênent. - Le générateur partage le CPU. La documentation de k6 recommande 20 % de CPU libre sur la machine de charge. Sinon, k6 se freine et mesure des temps de réponse trop longs.
- La base n'est pas celle de la production. Une instance sans réplique ni réglages, des données de synthèse, aucune latence réseau entre machines.
Nous comparons un avant et un après, ou une réplique contre trois, avec la même courbe. La capacité de la production se mesure ailleurs : environnement dédié, générateurs sur d'autres machines.
Sources
- k6, Thresholds, ramping-vus, URL grouping, Running large tests et versions (2.2.0 : 10 août 2026).
- Caddy, reverse_proxy, options globales et placeholders.
- Docker, deploy, services, profils, réseau Compose et limites de ressources.
-
Foundry,
fixtures
et
--append; symfony-docker, entrypoint ; API Platform, préfixehydra:; moon,runInCI. - Lychen, pull request 270 : une mise en œuvre open source de cette pile de test de charge, dans un monorepo moon.