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']
  • seed part 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.
  • k6 porte un profil : up ne le démarre pas, run k6 si.

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.

Tout tient sur une machine : le test compare, il ne dimensionne pas Une seule machine : cœurs, mémoire et disque partagés compose.load.yaml k6 seuils p(95) lb : Caddy round_robin api : 1 CPU, 1 Go api : 1 CPU, 1 Go api : 1 CPU, 1 Go PostgreSQL une seule base seed : une fois Ce qui le sépare de la production k6 prend du CPU aux répliques cpus : un plafond, pas un cœur une base, des données de synthèse

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