AWS Emulator Testing: 5 Mythen, die in Produktion beißen
Der offizielle AWS-Emulator ist echt, aber Mythen rund um AWS Emulator Testing können dich teuer zu stehen kommen. Erfahre, wo die Treue bricht und was weiterhin auf echtem AWS laufen muss.

Der schlimmste Integrationstest-Fehler, den ich je erlebt habe, war grün. Jeder Check lief in der CI durch, das Deployment ging raus, und zwanzig Minuten später starrte ein Bereitschaftsingenieur auf eine Queue voller Poison Messages, weil sich das echte SQS-Verhalten vom Stub in genau einem Punkt unterschied, den niemand geprüft hatte. Als AWS dann seinen eigenen Emulator veröffentlichte, einen Rust-Workspace mit einem Crate pro Service, generiert aus denselben Smithy-Modellen, die auch die echten SDKs antreiben, war meine erste Reaktion keine Begeisterung. Sondern: gut, dann finden wir jetzt heraus, wo er lügt. Denn jeder Emulator lügt irgendwo, und AWS Emulator Testing funktioniert nur, wenn du weißt, wo die Lügen stecken.
Mythos 1: „Grüne Tests gegen einen AWS-Emulator bedeuten, dass es auf AWS funktioniert“
Diese Annahme bringt Leute in Schwierigkeiten, und die eigene Dokumentation des Projekts ist dazu ungewöhnlich ehrlich. AWS veröffentlicht mit jedem Release Fidelity-Werte pro Service und erfasst Lücken in einem buchstäblichen Verzeichnis issues/things-that-do-not-work/ im Repo. Dieses Verzeichnis solltest du als Erstes lesen, bevor du auch nur einen Test schreibst. Early Adopter sind bereits gegen Wände gelaufen: Step-Functions-Definitionen mit dem Feld Assign funktionieren nicht, und die Lambda-Unterstützung für Python-Code ist so unvollständig, dass ein Workflow, der auf MiniStack problemlos läuft, auf dem offiziellen Emulator hängen bleibt. Das ist kein Skandal, sondern der normale Zustand eines jungen Emulators. Der Skandal wäre, eine grüne Suite als Beweis für mehr zu nehmen als „dein Code funktioniert gegen die Interpretation der API durch den Emulator“.
Das richtige mentale Modell heißt Abdeckung, nicht Wahrheit. Der Emulator deckt die Request-Formen ab, die dein SDK sendet, und liefert plausible Antworten. Nicht abgedeckt sind Throttling-Verhalten, Verzögerungen zwischen Services oder die tausend undokumentierten Eigenheiten eines global verteilten Systems. Das ist dieselbe Lücke zwischen Spezifikation und Implementierung, die überall in der Infrastruktur auftaucht: Das Smithy-Modell sagt dir, wie das Wire-Format aussieht, kann dir aber nicht verraten, dass echtes SQS gelegentlich eine Nachricht innerhalb des Visibility Timeouts zweimal zustellt oder dass echte IAM-Propagation Sekunden braucht und deine gerade erstellte Rolle die ersten drei Aufrufe scheitern lässt. Deine Tests sind grün, weil der Emulator nie die Gelegenheit hatte, eventuell konsistent zu sein.
Mythos 2: „Ich kann IAM-Richtlinien und Sicherheitskontrollen lokal validieren“
Nein, und AWS sagt das auf der Sicherheitsseite des Emulators unmissverständlich. Verwende ihn nicht, um IAM-Richtlinien oder Permission Boundaries zu testen, ressourcenbasierte Richtlinien wie Bucket Policies, KMS-Key-Policies, kontoübergreifenden oder regionsübergreifenden Zugriff oder irgendeine andere Sicherheitskontrolle. Einige Services werten IAM für Benutzer und Rollen aus, die du im Emulator erstellst, aber nicht so, wie AWS es tut. Der Emulator verweigert niemals eine Anfrage, die mit seinem eigenen Schlüssel signiert wurde. Eine Anfrage, die AWS ablehnen würde, kann lokal erfolgreich sein. Das macht den Emulator nicht nur für Sicherheitstests nutzlos, sondern aktiv irreführend. Er liefert dir ein falsches Negativ und tut dabei völlig unbeeindruckt.
Ich habe gesehen, wie Teams das auf die teure Art gelernt haben. Ein Entwickler verschärft eine Bucket Policy, die lokale Suite läuft grün, er shippt, und der nächtliche Job gegen den Sandbox-Account stirbt, weil die Richtlinie nun die Replikationsrolle blockiert. Oder der umgekehrte und deutlich schlimmere Fall: Die Richtlinie ist zu permissiv, alles läuft überall durch, und Monate später stellt ein Audit fest, dass dein „privater“ Bucket für jeden authentifizierten Principal lesbar war. Die Policy-Logik gehört zu den Bereichen, in denen Cloud-Authentifizierung echte blinde Flecken hat, und kein Emulator wird dich davon befreien. Wenn du Richtlinienverhalten prüfen willst, brauchst du die echte IAM-Auswertung. Das heißt: ein echter Account, idealerweise ein dedizierter Sandbox-Account mit SCPs, die einschränken, was er erreichen kann, und Tests, die Ablehnungen prüfen, nicht nur Erfolge:
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"
Noch eine Sache, bevor du deine gesamte CI-Flotte auf dieses Tool ausrichtest: Telemetrie ist standardmäßig aktiv. AWS sagt, sie sei minimiert und enthalte niemals Request-Inhalte oder Credentials, und ich habe keinen Grund, daran zu zweifeln. Meine Regel lautet aber: Dev-Tooling telefoniert nicht nach Hause, außer ich habe es ausdrücklich erlaubt. Starte es mit --telemetry off oder setze EMULATOR_TELEMETRY=off in deiner CI-Umgebung, und weiter geht’s.
Mythos 3: „Die Treue des Wire-Protokolls ist der schwierige Teil“

Das Wire-Format korrekt hinzubekommen ist die Grundvoraussetzung, und genau dieser Teil war für AWS immer ein Heimspiel. Ihre SDKs werden aus Smithy-Modellen generiert, der Emulator aus denselben Modellen, also stimmt jede Operation, jedes optionale Feld und jede Fehlerstruktur mit der dokumentierten API überein. Ein HN-Kommentator brachte es gut auf den Punkt: Spezifikationsgetriebene Generierung deckt jede Variante jedes Endpunkts ab, während Community-Emulatoren historisch nur die häufig genutzte Teilmenge implementieren und den Rest annähern. Das ist ein echter Vorteil des offiziellen Tools.
Aber Wire-Treue ist der leichte Teil. Der schwierige ist die Verhaltenstreue, und die hat niemand, weder AWS’ Emulator noch LocalStack, moto oder Floci. Verhaltenstreue steckt in Dingen, die in keinem Modell stehen: Verändert ein Lambda-Cold-Start das beobachtbare Timing so stark, dass der Timeout deines Clients auslöst? Zeigt sich DynamoDB-Throttling als wiederholbarer Fehler in der Rate, mit der dein Produktionsverkehr tatsächlich ankommt? Hängt ein CloudFormation-Teardown zwanzig Minuten fest, wenn Ressourcen in einer zulässigen, aber ungünstigen Reihenfolge erstellt wurden? Ein Praktiker fragte, ob er ein komplettes CDK-Projekt gegen den Emulator laufen lassen und cdk deploy End-to-End testen könne. Meine Antwort: Du kannst es, und du solltest es tun, aber nur, um Synthese- und API-Form-Fehler zu finden. Die Deployment-Dynamik, also Rollback-Verhalten, Reihenfolge beim Ersetzen von Ressourcen und Drift-Erkennung, sind genau die Teile, in denen ein Emulator am schlechtesten ist, weil es emergente Eigenschaften der echten Control Plane sind.
- Wire-Treue – Request-/Response-Formen, Fehlercodes, Serialisierung. Emulatoren sind hier gut, und der Smithy-generierte sollte Klassenbester sein.
- Zustandstreue – CRUD-Roundtrips, Auflisten, Filtern, Paginierung. Meist gut bei allen Emulatoren, mit service-spezifischen Lücken, die du prüfen musst.
- Verhaltenstreue – Konsistenz-Timing, Throttling, Teilausfälle, Eigenheiten des Ressourcenlebenszyklus. Hat niemand. Plane entsprechend.
Mythos 4: „Emulatoren sind Drop-in, einfach den Endpunkt austauschen“
Das Versprechen jedes Emulators lautet: „Setz eine Umgebungsvariable und leg los.“ Für einen schnellen Smoke-Test stimmt das. Der Server-Modus lauscht auf 127.0.0.1:9297 über HTTPS mit einem selbstsignierten Zertifikat, und so sieht es aus, wenn du die CLI darauf richtest:
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
Die Drop-in-Story bricht bei Testsuiten im größeren Maßstab zusammen. Die praktischen Probleme, auf die Leute in der ersten Woche stoßen: Es gibt kein schnelles Zurücksetzen des Zustands. Wenn deine Suite zwischen Tests einen sauberen Stand braucht, und moto-Nutzer sind genau das gewohnt, ein Decorator und die Welt ist frisch, bleibt dir derzeit nur der Neustart des Prozesses. Für zehn Tests ist das okay, für zehntausend schmerzhaft. Außerdem fehlt die Emulation von Multi-Account oder Organizations, was jeden Test killt, der deine reale Kontostruktur abbildet. Und wenn dich der eingebettete Rust-Modus reizt, eine isolierte In-Process-Instanz pro Test ohne Endpunkte oder Zertifikate zu verwalten, ein wirklich schönes Design, lies vorher den Abschnitt zu den Build-Kosten. Der Workspace besteht aus einem Crate pro AWS-Service, ein vollständiger Debug-Build braucht in der Größenordnung von 100 GB Platz für target/, und dein erstes cargo test kompiliert den Emulator zusammen mit deinem eigenen Code. Der Rat, ein gemeinsames CARGO_TARGET_DIR zu nutzen, target/ in der CI zu cachen und auf einen Release-Commit zu pinnen, ist kein optionaler Zierrat. Er entscheidet darüber, ob dein CI-Job fünf oder fünfzig Minuten dauert.
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
Mythos 5: „AWS’ eigener Emulator macht LocalStack, moto & Co. überflüssig“
Ich habe Varianten davon innerhalb weniger Stunden nach der Ankündigung gehört, und sie verkennen, was die etablierten Anbieter eigentlich verkaufen. Der Wert von LocalStack bestand nie nur darin, „die S3-API nachgebaut zu haben“. Es sind Jahre an service-spezifischer Verhaltensfeinabstimmung, Zustandsverwaltung, testcontainers-Integration, CI-Ergonomie und einer Community, die bereits den Bug gemeldet hat, in den du gleich laufen wirst. Moto's Zurücksetzen des Zustands pro Test über Decorators ist ein Workflow-Feature, kein API-Feature, und darauf hat der AWS-Emulator noch keine Antwort. Floci-Fans wiesen darauf hin, dass das Tool auch GCP und Azure abdeckt. Wenn deine Infrastruktur Multi-Cloud ist, ist eine lokale Umgebung aus einem Guss mehr wert als eine Single-Cloud-Lösung mit höherer Treue.
Es gibt außerdem eine berechtigte Vertrauensfrage zur Langlebigkeit. Der erste Kommentar im Thread stellte die Frage, die alle beschäftigte: Ist das ein echtes Produkt, das AWS pflegen wird, oder ein Experiment? Das Repo nimmt Issue-Meldungen an, aber keine Pull Requests. Das ist für eine spezifikationsgetriebene Codebasis eine vertretbare Entscheidung, bedeutet aber auch, dass die Community Lücken nicht selbst schließen kann. Wenn das Team umgewidmet wird, sitzt du auf einem CC0-lizenzierten Snapshot. Meine Haltung: Bewerte es wie jede Abhängigkeit mit einem einzigen Maintainer. Gut zum Einsatz geeignet, leichtsinnig, wenn du alles darauf setzt. Dieselbe Skepsis gilt für das euphorische Gerede à la „Agents haben das in Rust geschrieben, der Burggraben ist weg“. Der Burggraben war nie die API-Oberfläche. Er besteht aus operativer Exzellenz, und die API nachzubauen war immer der billige Teil. Wir haben diese Dynamik auch bei verteiltem SQLite und Raft gesehen: Das Interface zu kopieren dauert Wochen, die Fehlersemantik zu treffen dauert Jahre.
Was weiterhin gegen die echte AWS-Infrastruktur laufen muss

So teile ich es in echten Projekten auf, und bisher hat es mich nicht im Stich gelassen. Alles, was schnell, deterministisch und formorientiert ist, läuft bei jedem Commit gegen den Emulator: Serialisierung, Fehlerbehandlung für dokumentierte Fehlercodes, Retry-Logik, State Machines, die nur von CRUD-Roundtrips abhängen. Das sind etwa 90 % deiner Suite nach Testanzahl und vielleicht 10 % nach Risiko.
Die restlichen 10 % laufen nachts gegen einen echten, isolierten Sandbox-Account. Dieser Teil fängt das auf, was dich tatsächlich aufweckt:
- IAM- und Ressourcenrichtlinien. Prüfe explizite Ablehnungen, nicht nur erlaubte Pfade. Der Emulator kann das strukturell nicht, denn er verweigert nie eine Anfrage, die mit seinem eigenen Schlüssel signiert wurde.
- Alles mit Propagationsverzögerung. Neue Rollen, DNS-Änderungen, KMS-Grants. Wenn dein Code eine Ressource erstellt und sofort nutzt, sagt dir nur echtes AWS, ob du eine Retry-Schleife brauchst.
- At-least-once- und Idempotenzverhalten. Doppelte SQS-Zustellungen, Lambda-Retries bei Timeouts, Teilausfälle bei Batches. Emulatoren sind höflich, Produktion ist es nicht.
- Infrastruktur-Lebenszyklus. Vollständige
cdk deploy- undterraform apply-Zyklen mit Destroy, besonders die Reihenfolge beim Teardown und die Rollback-Pfade. - Throttling- und Quota-Grenzen. Wenn es unter Produktionslast zählt, existiert es nur mit dem Verhalten der Produktions-API.
Der Sandbox-Account braucht eigene Leitplanken: Service Control Policies, die begrenzen, was er tun darf, Budgetwarnungen und einen Sweeper, der übrig gebliebene Ressourcen entfernt, denn dein nächtlicher Job wird Dinge liegen lassen. Das ist echter operativer Aufwand, und genau deshalb ist der Emulator wertvoll. Er hält 90 % deiner Feedback-Schleife schnell und kostenlos, sodass du dir leisten kannst, die letzten 10 % ehrlich zu machen.
Die Aufgabe eines Emulators ist es, deine Feedback-Schleife schnell zu machen. Er soll dich nicht zuversichtlich machen. Zuversicht kostet nach wie vor echte API-Aufrufe.
Der offizielle AWS-Emulator ist ein wirklich gutes Werkzeug: spezifikationsgenerierte Abdeckung, ein eingebetteter Modus mit echter Isolation und erfrischend ehrliche Dokumentation darüber, was er nicht kann. Nutze ihn für das, was er ist: der schnellstmögliche Weg, meistens richtigzuliegen. Entscheide dann bewusst und schriftlich, welche Tests die andere Art von Richtigkeit beanspruchen dürfen, nämlich die, die nur von Infrastruktur kommt, die deine Anfrage tatsächlich ablehnen, deinen Client drosseln und deine Nachricht zweimal zustellen kann.


