Des articles approfondis sur les technologies qui façonnent l'avenir.

Tests émulateur AWS : 5 mythes qui piquent en production

L'émulateur officiel d'AWS est fiable, mais ses mythes coûtent cher. Découvrez où la fidélité flanche et ce qui doit encore tourner sur AWS réel.

Deux tapis roulants, l'un neuf et l'autre usé, transportant des cartons identiques dont un tombe du côté usé
Une CI verte sur un émulateur et une CI verte sur le vrai service, ce ne sont pas le même vert.

Le pire échec de test d'intégration que j'aie jamais eu à gérer était vert. Tous les contrôles passaient en CI, le déploiement partait, et vingt minutes plus tard, un ingénieur d'astreinte fixait une file pleine de messages empoisonnés parce que le comportement réel de SQS différait du stub sur un point précis que personne n'avait pensé à vérifier. Quand AWS a publié son propre émulateur, un workspace Rust avec un crate par service, généré à partir des mêmes modèles Smithy que les SDK officiels, ma première réaction n'a pas été l'enthousiasme. C'était plutôt : très bien, voyons où il ment. Parce que tout émulateur ment quelque part, et les tests avec émulateur AWS ne fonctionnent que si on connaît ses mensonges.

Mythe 1 : « Des tests verts sur un émulateur AWS signifient que ça marche sur AWS »

C'est la croyance qui fait le plus de dégâts, et la documentation du projet est étonnamment honnête à ce sujet. AWS publie des scores de fidélité par service à chaque version et suit les écarts dans un répertoire issues/things-that-do-not-work/ bien réel dans le dépôt. C'est le premier endroit à lire, avant d'écrire le moindre test. Les premiers adoptants se sont déjà heurtés à des murs : les définitions Step Functions qui utilisent le champ Assign ne fonctionnent pas, et le support de Lambda pour le code Python est assez incomplet pour qu'un workflow qui tourne sans problème sur MiniStack reste bloqué sur l'émulateur officiel. Rien de scandaleux là-dedans : c'est l'état normal d'un émulateur jeune. Le scandale, c'est de considérer une suite verte comme une preuve de quoi que ce soit au-delà de « votre code fonctionne avec l'interprétation que fait l'émulateur de l'API ».

Le bon modèle mental, c'est la couverture, pas la vérité. L'émulateur couvre les formes de requêtes que votre SDK envoie et renvoie des réponses plausibles. Il ne couvre pas le comportement de throttling, les délais de propagation entre services, ni les mille bizarreries non documentées d'un système distribué à l'échelle mondiale. C'est le même écart entre spécification et implémentation que l'on retrouve partout dans l'infrastructure : le modèle Smithy vous dit à quoi ressemble le format sur le fil, mais il ne peut pas vous dire que le vrai SQS délivre parfois un message deux fois dans le délai de visibilité, ni que la propagation réelle d'IAM prend quelques secondes et que votre rôle tout juste créé échouera à ses trois premières invocations. Vos tests sont passés parce que l'émulateur n'a jamais eu l'occasion d'être éventuellement cohérent.

Mythe 2 : « Je peux valider les politiques IAM et les contrôles de sécurité en local »

Non, et AWS le dit en toutes lettres sur la page sécurité de l'émulateur. Ne l'utilisez pas pour tester les politiques IAM ou les limites de permissions, les politiques basées sur les ressources comme les politiques de bucket, les politiques de clés KMS, les accès inter-comptes ou inter-régions, ni aucun autre contrôle de sécurité. Certains services évaluent bien IAM pour les utilisateurs et rôles que vous créez dans l'émulateur, mais pas de la même manière qu'AWS. L'émulateur n'refuse jamais une requête signée avec sa propre clé. Une requête qu'AWS rejetterait peut réussir en local, ce qui signifie que l'émulateur n'est pas seulement inutile pour les tests de sécurité : il induit activement en erreur. Il vous donnera un faux négatif le plus sereinement du monde.

J'ai vu des équipes l'apprendre à leurs dépens. Un développeur resserre une politique de bucket, lance la suite locale, voit du vert, déploie, et le job nocturne sur le compte sandbox meurt parce que la politique bloque désormais le rôle de réplication. Ou le cas inverse, bien pire : la politique est trop permissive, tout passe partout, et vous découvrez des mois plus tard, lors d'un audit, que votre bucket « privé » était lisible par n'importe quel principal authentifié. La logique des politiques fait partie des endroits où l'authentification cloud présente de réels angles morts, et aucun émulateur ne vous en sortira. Si vous voulez vérifier le comportement des politiques, il vous faut une véritable évaluation IAM. Cela suppose un vrai compte, idéalement un sandbox dédié avec des SCP qui verrouillent ce qu'il peut atteindre, et des tests qui vérifient les refus, pas seulement les succès :

import boto3
import pytest
from botocore import UNSIGNED
from botocore.config import Config
from botocore.exceptions import ClientError
def test_private_bucket_denies_anonymous_read():
# Runs only in the nightly job, against a dedicated sandbox account.
s3 = boto3.client("s3")
s3.put_object(Bucket=SANDBOX_BUCKET, Key="probe.txt", Body=b"x")
anon = boto3.client("s3", config=Config(signature_version=UNSIGNED))
with pytest.raises(ClientError) as err:
anon.get_object(Bucket=SANDBOX_BUCKET, Key="probe.txt")
assert err.value.response["Error"]["Code"] == "AccessDenied"

Une dernière chose avant de déployer cet outil sur toute votre flotte CI : la télémétrie est activée par défaut. AWS affirme qu'elle est minimisée et ne contient jamais le contenu des requêtes ni les identifiants. Je n'ai aucune raison d'en douter, mais ma règle est que les outils de développement ne transmettent rien sans que je l'aie demandé. Lancez-le avec --telemetry off ou définissez EMULATOR_TELEMETRY=off dans votre environnement CI, et passez à autre chose.

Mythe 3 : « La fidélité du protocole filaire, c'est la partie difficile »

Iceberg avec une petite pointe nette émergeant de l'eau et une immense masse chaotique cachée sous la surface
La forme de l'API n'est que la pointe. Le comportement sous-jacent est là où vos tests divergent en silence.

Bien respecter le format sur le fil est un minimum, et c'est la partie qu'AWS allait forcément réussir. Leurs SDK sont générés à partir de modèles Smithy, l'émulateur est généré à partir des mêmes modèles, donc chaque opération, chaque champ optionnel et chaque forme d'erreur correspond à l'API documentée. Un commentateur de HN l'a bien résumé : la génération pilotée par la spécification couvre chaque variante de chaque endpoint, alors que les émulateurs communautaires implémentent historiquement le sous-ensemble le plus utilisé et approximent le reste. C'est un véritable avantage de l'outil officiel.

Mais la fidélité du format n'est que la partie facile. La difficulté, c'est la fidélité comportementale, et personne ne l'a vraiment : ni l'émulateur d'AWS, ni LocalStack, ni moto, ni Floci. La fidélité comportementale, c'est tout ce qui ne figure dans aucun modèle : un démarrage à froid de Lambda modifie-t-il le temps observable au point de faire expirer le timeout de votre client ? Le throttling de DynamoDB remonte-t-il comme une erreur réessayable au rythme où votre trafic de production le sollicite réellement ? La suppression d'une pile CloudFormation peut-elle rester bloquée vingt minutes parce que les ressources ont été créées dans un ordre légal mais malheureux ? Un praticien m'a demandé s'il pouvait pointer un projet CDK entier vers l'émulateur pour tester un cdk deploy de bout en bout. Ma réponse : vous le pouvez, et vous devriez, mais seulement pour détecter les erreurs de synthèse et de forme d'API. La dynamique de déploiement (comportement de rollback, ordre de remplacement des ressources, détection de dérive) est justement ce que l'émulateur fait le moins bien, car ce sont des propriétés émergentes du plan de contrôle réel.

  • Fidélité du format : formes des requêtes et réponses, codes d'erreur, sérialisation. Les émulateurs excellent ici, et celui généré par Smithy devrait être le meilleur de sa catégorie.
  • Fidélité de l'état : allers-retours CRUD, listage, filtrage, pagination. Globalement bon chez la plupart des émulateurs, avec des lacunes par service à vérifier.
  • Fidélité comportementale : délais de cohérence, throttling, échecs partiels, particularités du cycle de vie des ressources. Personne ne l'a. Planifiez en conséquence.

Mythe 4 : « Les émulateurs sont interchangeables : il suffit de changer l'endpoint »

Le discours marketing de chaque émulateur tient en « une variable d'environnement et c'est parti ». Pour un petit test de fumée, c'est vrai. Le mode serveur écoute sur 127.0.0.1:9297 en HTTPS avec un certificat auto-signé, et voici comment pointer la CLI vers lui :

export AWS_ENDPOINT_URL=https://localhost:9297
export AWS_ACCESS_KEY_ID=emulator
export AWS_SECRET_ACCESS_KEY=emulator
export AWS_REGION=us-east-1
# self-signed cert: don't disable verification globally, scope it
aws s3 ls --no-verify-ssl

L'argument de l'interchangeabilité s'effondre à l'échelle d'une suite de tests. Les problèmes pratiques que rencontrent les gens dès la première semaine : il n'existe pas de réinitialisation rapide de l'état. Si votre suite a besoin d'une ardoise propre entre chaque test (et les utilisateurs de moto y sont habitués, un simple décorateur et le monde est neuf), votre seule option actuelle est de redémarrer le processus. C'est acceptable pour dix tests et pénible pour dix mille. Il n'y a pas non plus d'émulation multi-comptes ni d'Organizations, ce qui rend impossible tout test modélisant la structure réelle de votre compte. Et si vous êtes tenté par le mode Rust embarqué, une instance isolée dans le processus par test, sans endpoint ni certificat à gérer, ce qui est une conception vraiment agréable, lisez d'abord la section sur le coût de compilation. Le workspace compte un crate par service AWS, une compilation de débogage complète réclame de l'ordre de 100 Go dans target/, et votre premier cargo test compile l'émulateur à côté de votre propre code. Leur conseil de partager un seul CARGO_TARGET_DIR, de mettre en cache target/ en CI et de figer une version de release n'a rien de décoratif. C'est la différence entre un job CI de cinq minutes et un job de cinquante minutes.

use aws_emulator_embedded::{AwsEmulatorEmbedded, EmbeddedOptions, Telemetry};
let emulator = AwsEmulatorEmbedded::new(
EmbeddedOptions::default().telemetry(Telemetry::Off),
);
let http_client = emulator.http_client();
// wire http_client into your SDK client config — no endpoint,
// no env vars, one isolated instance per test

Mythe 5 : « L'émulateur officiel d'AWS va tuer LocalStack, moto et les autres »

J'ai entendu des variantes de cette idée dans les heures qui ont suivi l'annonce, et elle méconnaît ce que vendent réellement les acteurs en place. La valeur de LocalStack n'a jamais été seulement « nous avons réimplémenté l'API S3 ». C'est des années de réglages comportementaux par service, de gestion d'état, d'intégration testcontainers, d'ergonomie CI, et une communauté qui a déjà ouvert le bug que vous êtes sur le point de rencontrer. La réinitialisation d'état par test de moto via des décorateurs est une fonctionnalité de workflow, pas d'API, et l'émulateur d'AWS n'a pas encore de réponse à ce sujet. Les fans de Floci ont souligné qu'il couvre aussi GCP et Azure : si votre parc est multi-cloud, un environnement local unique vaut davantage qu'un outil plus fidèle mais limité à un seul cloud.

Il y a aussi une vraie question de confiance sur la pérennité. Le premier commentaire du fil posait la question que tout le monde se posait : est-ce un vrai produit qu'AWS maintiendra, ou un exercice ? Le dépôt accepte les rapports de bug mais pas les pull requests, un choix défendable pour une base de code pilotée par des spécifications, mais qui signifie aussi que la communauté ne peut pas combler elle-même les lacunes. Si l'équipe est réaffectée, vous vous retrouvez avec un instantané sous licence CC0. Ma position : évaluez-le comme n'importe quelle dépendance à mainteneur unique. Il est raisonnable de l'adopter, imprudent de jouer la boîte dessus. Le même scepticisme vaut pour les commentaires enthousiastes du type « des agents ont écrit ça en Rust, le fossé défensif a disparu ». Le fossé n'a jamais été la surface de l'API ; c'est l'excellence opérationnelle, et imiter l'API a toujours été la partie bon marché. On a vu la même dynamique avec les systèmes SQLite distribués et raft : copier l'interface prend des semaines, faire coïncider la sémantique des pannes prend des années.

Ce qui doit encore tourner sur une véritable infrastructure AWS

Un pont suspendu presque achevé dont la dernière travée est testée sous charge par des poids suspendus au-dessus de l'eau
Les émulateurs construisent l'essentiel du pont. La dernière travée, celle de la sécurité et du comportement face aux pannes, se teste pour de vrai sous charge.

Voici le découpage que j'applique sur mes projets réels, et il ne m'a encore jamais trahi. Tout ce qui est rapide, déterministe et orienté forme s'exécute sur l'émulateur à chaque commit : la sérialisation, la gestion des codes d'erreur documentés, la logique de réessai, les machines à états qui ne dépendent que d'allers-retours CRUD. Cela représente 90 % de votre suite en nombre de tests, et peut-être 10 % en risque.

Les 10 % restants tournent chaque nuit sur un compte sandbox réel et isolé. C'est la partie qui détecte ce qui vous réveille vraiment la nuit :

  • Politiques IAM et de ressources. Vérifiez les refus explicites, pas seulement les chemins autorisés. L'émulateur ne peut structurellement pas le faire : il ne refuse jamais une requête signée avec sa propre clé.
  • Tout ce qui subit un délai de propagation. Nouveaux rôles, changements DNS, octrois KMS. Si votre code crée une ressource et l'utilise aussitôt, seul AWS réel vous dira si une boucle de réessai est nécessaire.
  • Comportement at-least-once et idempotence. Livraisons SQS en double, réessais Lambda sur timeout, échecs partiels de lots. Les émulateurs sont polis ; la production ne l'est pas.
  • Cycle de vie de l'infrastructure. Cycles complets cdk deploy / terraform apply puis destroy, en particulier l'ordre de suppression et les chemins de rollback.
  • Limites de throttling et quotas. Si cela compte à la charge de production, cela n'existe que dans le comportement de l'API de production.

Le compte sandbox a besoin de ses propres garde-fous : des politiques de contrôle de service qui limitent ce qu'il peut faire, des alertes budgétaires, et un nettoyeur qui supprime les ressources restantes, car votre job nocturne finira forcément par laisser des fuites. C'est une charge opérationnelle réelle, et c'est précisément pour cela que l'émulateur a de la valeur : il garde 90 % de votre boucle de feedback rapide et gratuite, ce qui vous permet de vous offrir le luxe de rendre les 10 % restants honnêtes.

Le rôle d'un émulateur est de rendre votre boucle de feedback rapide. Il n'est pas de vous rendre confiant. La confiance coûte toujours de vrais appels API.

L'émulateur officiel d'AWS est un outil vraiment bon : une couverture générée à partir des spécifications, un mode embarqué avec une vraie isolation, et une documentation rafraîchissante d'honnêteté sur ce qu'il ne sait pas faire. Adoptez-le pour ce qu'il est : le moyen le plus rapide d'avoir presque toujours raison. Ensuite, décidez délibérément, et par écrit, quels tests ont le droit de revendiquer l'autre sorte de justesse, celle qui ne vient que d'une infrastructure capable de refuser réellement votre requête, de brider votre client et de livrer votre message deux fois.