AWS Emulator ist der offizielle lokale Emulator von AWS. Er stellt auf Ihrem eigenen Rechner einen HTTPS-Endpoint bereit, und die AWS CLI, die AWS SDKs und Coding-Agents rufen ihn mit denselben APIs auf wie in der Cloud. Sie brauchen kein AWS-Konto, und nichts, was er anlegt, ist eine echte Cloud-Ressource. Laut AWS News Blog ist er seit dem 11. November 2026 (US-Zeit) allgemein verfügbar (GA), also seit etwa 2:00 Uhr am 12. November Pekinger Zeit.
Am 13. November 2026 (Pekinger Zeit, UTC+8) haben wir AWS Emulator 1.0.322, die damalige Version im LTS-Kanal, auf einem Debian-13-Rechner (x86_64) installiert. Mit AWS CLI 2.40.1 haben wir einen S3-Bucket, eine DynamoDB-Tabelle, eine SQS-Queue und eine Lambda-Funktion angelegt. Danach haben Claude Code 2.1.319 und Codex CLI 0.167.0 jeweils Code gegen den Emulator geschrieben und Tests ausgeführt. Alle Befehle, Zeiten und Ausgaben unten stammen aus diesem Lauf.
Die kurze Antwort
| Frage | Antwort |
|---|---|
| Was ist AWS Emulator? | Der offizielle lokale Emulator der AWS-APIs, in Rust geschrieben, ohne grafische Oberfläche. Laut AWS basiert er auf mehr als 400 API-Modellen und deckt mehr als 200 AWS-Services ab. |
| Gibt es eine Gebühr? Brauche ich ein AWS-Konto? | Laut AWS fällt keine zusätzliche Servicegebühr an, und ein AWS-Konto ist nicht nötig. Der Quellcode liegt auf GitHub unter der Public-Domain-Widmung CC0. |
| Wie installiere ich ihn? | Unter Linux das RPM- oder Debian-Paket installieren. Unter macOS und Windows ein Image aus dem Dockerfile der offiziellen Doku bauen (AWS veröffentlicht kein fertiges Image). Rust-Projekte können auch den Embedded-Modus nutzen. |
| Wie benutze ich ihn? | aws-emulator starten. Er lauscht standardmäßig auf https://127.0.0.1:9297. Ein paar Umgebungsvariablen setzen, damit AWS CLI und SDKs auf ihn zeigen; Ihr Anwendungscode bleibt unverändert. |
| Ergebnis unseres Tests | Download plus Installation dauerten etwa 6 Sekunden, der Health Check meldete etwa 0,3 Sekunden nach dem Start ok. S3, DynamoDB, SQS und Lambda funktionierten. Claude Code erledigte dieselbe Aufgabe „S3 + DynamoDB + pytest“ in etwa 32 Sekunden, Codex in etwa 81 Sekunden, beide mit 2 passed. |
| Worauf man achten muss | IAM-Richtlinien werden nicht wie bei AWS ausgewertet, und emuliert wird ein einzelnes Konto in einer einzelnen Region. Berechtigungen und Sicherheit vor der Produktion auf echtem AWS testen. |
Was AWS Emulator ist
Laut AWS News Blog erzeugt AWS Emulator beim Start eigene Zugangsdaten, eine Konfigurationsdatei und ein Zertifikat und schreibt sie nach ~/.aws/emulator/9297/. Sobald die Umgebungsvariablen Ihres SDK dorthin zeigen, gehen Anfragen an Ihren Rechner statt an AWS. Er basiert auf denselben API-Modellen wie die AWS SDKs, deshalb haben Daten und Fehler dieselbe Form wie in der Cloud.
Der Hauptanwendungsfall sind Coding-Agents. Laut @AWSNewsroom wurde jede Zeile des AWS-Emulator-Codes von autonomen KI-Agents geschrieben, die auf Amazon Bedrock AgentCore laufen: Hunderte Agents in drei Teams schreiben Tests, implementieren Funktionen und prüfen Änderungen. Laut Swami Sivasubramanian von AWS in seinem Gastbeitrag auf All Things Distributed schreiben die Agents zuerst „Fidelity-Tests“ und bringen sie gegen echtes AWS zum Laufen; danach bauen sie den Emulator, bis er dieselben Tests besteht. AWS-CTO @Werner schreibt, er sei vollständig von Agents geschrieben und getestet worden und biete eine Testumgebung mit hoher Wiedergabetreue für mehr als 200 AWS-Services.
Der Launch fand viel Beachtung. Laut den öffentlichen X-Kennzahlen hatte der Launch-Post von @AWSNewsroom Anfang 13. November (Pekinger Zeit) etwa 111.000 Aufrufe, 705 Likes und 206 Reposts, der Launch-Post von @awsdevelopers etwa 78.000 Aufrufe, 1.203 Likes und 758 Lesezeichen. Das GitHub-Repository aws/aws-emulator hatte zur selben Zeit etwa 4.400 Sterne.
Zeitlinie
| Zeit (Pekinger Zeit) | Ereignis |
|---|---|
| 11. November | 1.0.322 veröffentlicht (aws-emulator -v zeigt das Release-Datum 2026.11.10) |
| 12. November, gegen 02:00 | AWS News Blog, Werner und die offiziellen AWS-Accounts verkünden GA |
| 13. November, 00:16 | Das heruntergeladene LTS/latest-Paket war noch 1.0.322; gleichzeitig erschien v1.0.336 auf GitHub Releases |
AWS Emulator erscheint sehr häufig in neuen Versionen, und der offizielle Skill verlangt, immer die neueste zu nutzen. Ihre Versionsnummer ist also wahrscheinlich neuer als unsere.
AWS Emulator installieren
Die offizielle Doku nennt vier Wege (siehe Getting started): einen KI-Coding-Agent installieren lassen, das Linux-Paket, Docker oder den Rust-Embedded-Modus.
Linux: RPM- oder Debian-Paket
# Debian / Ubuntu (x86_64)
curl -fsSLo aws-emulator.deb https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator_amd64.deb
sudo apt-get install -y ./aws-emulator.deb
# Amazon Linux / Fedora / RHEL (x86_64)
sudo dnf install -y https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator-x86_64.rpm
# Version prüfen
aws-emulator -v
Auf ARM-Rechnern aws-emulator_arm64.deb oder aws-emulator-aarch64.rpm verwenden. Das Paket installiert nach /opt/aws-emulator/ und legt den Befehl aws-emulator in /usr/bin/ ab.
Unsere Ausgabe:
Version: 1.0.322
Release date: 2026.11.10
Commit: 7753983c6e495ec3612695b1336bf4936fc7b7fd
Das deb-Paket ist etwa 171 MB groß. Der Download dauerte 1,7 Sekunden, Download plus apt-get install insgesamt etwa 6 Sekunden. Die Doku beschreibt außerdem eine GPG-Prüfung: Neben jedem Paket liegt eine .sig-Datei, und nach dem Import von https://downloads.aws.com/keys/gpg/current.asc muss der Fingerabdruck 98BC F336 A3BE 53B7 34E9 67C5 2E5B F49B D940 F624 lauten. Wir sind den Schritten gefolgt und erhielten Good signature from "SSM Publishing <ssm-publishing@amazon.com>".
macOS / Windows: Image aus dem Dockerfile bauen
Laut Docker-Anleitung veröffentlicht AWS kein fertiges Image; Sie bauen es mit diesem Dockerfile. Auf Apple Silicon x86_64.rpm durch aarch64.rpm ersetzen:
FROM public.ecr.aws/amazonlinux/amazonlinux:2023-minimal
ADD https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator-x86_64.rpm /tmp/aws-emulator.rpm
RUN rpm -i /tmp/aws-emulator.rpm && rm /tmp/aws-emulator.rpm \
&& mkdir -p /home/emulator && chown 1000 /home/emulator
USER 1000
ENV HOME=/home/emulator
EXPOSE 9297
ENTRYPOINT ["aws-emulator", "-b", "0.0.0.0"]
docker build -t aws-emulator .
mkdir -p ~/.aws/emulator
PORT=9297
docker run --rm --memory=2g --memory-swap=2g -p 127.0.0.1:$PORT:$PORT \
-e HOME="$HOME" -v "$HOME/.aws/emulator:$HOME/.aws/emulator" \
aws-emulator -p $PORT
Den Port als -p 127.0.0.1:9297:9297 freigeben, nicht als -p 9297:9297; die Kurzform öffnet den Emulator für alle Rechner im Netzwerk. Unser Testrechner hat kein Docker; den Docker-Weg haben wir aus der offiziellen Doku übernommen, aber nicht ausgeführt.
Starten und die AWS CLI darauf richten
Im ersten Terminal den Emulator starten (-t off schaltet die standardmäßig aktive anonyme Telemetrie ab):
aws-emulator -t off
Das Log ist im JSON-Lines-Format. Eine Zeile nennt Endpoint, Konfiguration und Zertifikat:
"endpoint_url":"https://127.0.0.1:9297","health_check_url":"https://127.0.0.1:9297/__admin/health","config_file":"/home/box/.aws/emulator/9297/config","ca_file":"/home/box/.aws/emulator/9297/ca.pem"
Im zweiten Terminal die Umgebungsvariablen setzen. Diese Liste stammt aus dem AWS News Blog; die letzte Zeile entfernt echte AWS-Zugangsdaten:
export AWS_ENDPOINT_URL=https://127.0.0.1:9297
export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials
export AWS_CONFIG_FILE=~/.aws/emulator/9297/config
export AWS_EC2_METADATA_DISABLED=true
export AWS_DISABLE_HOST_PREFIX_INJECTION=true
export AWS_REGION=us-east-1
export AWS_DEFAULT_REGION=us-east-1
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE
Zuerst prüfen, dass Sie wirklich mit dem Emulator sprechen:
curl --cacert ~/.aws/emulator/9297/ca.pem https://127.0.0.1:9297/__admin/health
aws sts get-caller-identity
Bei uns meldete der Health Check etwa 0,27 Sekunden nach dem Start ok. get-caller-identity lieferte das feste Konto des Emulators, 000000000000, mit der ARN arn:aws:iam::000000000000:user/emulator. Sehen Sie dieses Konto, gehen Ihre Anfragen nicht an echtes AWS. Im Leerlauf belegte der Emulator etwa 283 MB Arbeitsspeicher.
Testlauf: S3, DynamoDB, SQS, Lambda
aws s3 mb s3://aicodewith-emu-demo
echo "hello from the emulator" > hello.txt
aws s3 cp hello.txt s3://aicodewith-emu-demo/
aws s3 ls s3://aicodewith-emu-demo/
aws dynamodb create-table --table-name notes \
--attribute-definitions AttributeName=id,AttributeType=S \
--key-schema AttributeName=id,KeyType=HASH --billing-mode PAY_PER_REQUEST
aws dynamodb wait table-exists --table-name notes
aws dynamodb put-item --table-name notes --item '{"id":{"S":"n1"},"msg":{"S":"hello"}}'
aws dynamodb get-item --table-name notes --key '{"id":{"S":"n1"}}'
| Vorgang | Ergebnis | Zeit pro Befehl |
|---|---|---|
| s3 mb / s3 cp / s3 ls | make_bucket: aicodewith-emu-demo, 24 Byte hochgeladen, hello.txt gelistet | etwa 0,55–0,6 s |
| dynamodb create-table | Status CREATING | etwa 0,5 s |
| put-item direkt nach dem Anlegen der Tabelle | ResourceNotFoundException: Requested resource not found | etwa 0,5 s |
| put-item / get-item nach wait table-exists | Schreiben erfolgreich; zurückgelesen {"id":"n1","msg":"hello"} | etwa 0,5 s |
| sqs create-queue / send-message / receive-message | Nachrichtentext "hi" empfangen | etwa 0,5 s |
| lambda create-function (Python 3.13) + invoke | StatusCode: 200; die Funktion lieferte {"ok": true, "echo": {"a": 1}} | etwa 0,6 s |
Den Großteil der rund 0,5 Sekunden pro Befehl braucht die AWS CLI für ihren eigenen Start; der Emulator selbst antwortet schnell.
Zwei Verhaltensweisen sollte man kennen, beide entsprechen echtem AWS:
- In eine neue DynamoDB-Tabelle kann man nicht sofort schreiben. Nach dem Anlegen ist ihr Status
CREATING, und ein sofortigesput-itemscheitert mitResourceNotFoundException. Vor dem Schreibenaws dynamodb wait table-existsausführen oder im Code einen Waiter verwenden. Genau hier stolpern von Agents geschriebene Tests am häufigsten. - Lambda prüft die Vertrauensrichtlinie der Rolle. Unser erster Versuch nutzte eine Rolle mit leerem Statement und scheiterte mit
The role defined for the function cannot be assumed by Lambda. Nachdem wirsts:AssumeRolefürlambda.amazonaws.comin die Vertrauensrichtlinie aufgenommen hatten, wurde die Funktion angelegt.
Claude Code, Codex und Cursor gegen den Emulator arbeiten lassen
Option 1: den offiziellen aws-emulator-Skill installieren
Laut Anleitung für KI-Coding-Agents installiert AWS CLI ab 2.35.0 den offiziellen Skill mit einem Befehl. Danach können Sie Ihrem Agent einfach sagen: „Install AWS Emulator and point my project at it“:
aws agent-toolkit add-skill --skill-name aws-emulator --region us-east-1
Der Befehl installiert den Skill für jeden Agent, den er auf dem Rechner findet, und braucht kein AWS-Konto. Mit AWS CLI 2.40.1 dauerte jeder Lauf etwa 0,6 Sekunden und schrieb in das Verzeichnis jedes gefundenen Agents:
- Claude Code:
~/.claude/skills/aws-emulator/ - Codex:
~/.agents/skills/aws-emulator/ - Cursor:
~/.cursor/skills/aws-emulator/
Achtung: Diesen Befehl nicht in einer Shell ausführen, in der AWS_ENDPOINT_URL gesetzt ist. Unser erster Versuch lief in einem Terminal, das schon auf den Emulator zeigte, und scheiterte mit UnknownService ... GetLatestSkillVersion, weil auch die Download-Anfrage für den Skill an den Emulator ging. Ein sauberes Terminal löste das Problem.
Der Skill enthält nur Dokumente, keine Skripte: Installationsschritte für Linux, Docker und den Rust-Embedded-Modus, die Anbindung der einzelnen SDKs, eine Fehlertabelle und eine Prüfung „läuft mein Projekt auf dem Emulator“. Wie Skills allgemein funktionieren, steht in Agent Skills verwenden.
Option 2: Umgebungsvariablen setzen und dem Agent eine Aufgabe geben
Die Agents in Claude Code, Codex und Cursor führen Befehle alle in einem Terminal aus. Am einfachsten setzen Sie also die Variablen aus dem vorigen Abschnitt in dem Terminal, in dem Sie den Agent starten. Die aws-Befehle und boto3-Tests des Agents gehen dann automatisch an den Emulator, und selbst wenn der Agent etwas falsch macht, kann er kein echtes Konto berühren. Das Terminal von Cursor liest dieselben Variablen; in diesem Test haben wir für Cursor nur den Skill installiert und dort keine Aufgabe ausgeführt.
Claude Code und Codex bekamen dieselbe Aufgabe. Das Projekt war ein leeres Python-Repository mit boto3 1.44.1 und pytest 9.2.0, vorinstalliert in .venv:
The shell already points the AWS CLI and SDKs at a local AWS Emulator (AWS_ENDPOINT_URL=https://127.0.0.1:9297); never use a real AWS account.
1. Write notes.py with save_note(bucket, table, note_id, text): put the text in S3 at notes/<note_id>.txt and put an item {id, s3_key} in the DynamoDB table; and get_note(bucket, table, note_id) that returns the text by reading the item and then the S3 object.
2. Write tests/test_notes.py with pytest: create a uniquely named bucket and table (string key "id", PAY_PER_REQUEST, wait until the table exists) against the emulator, then test save/get round trip and that get_note of a missing id raises KeyError.
3. Run .venv/bin/pytest -q until it passes, then verify with the aws CLI that the object and item exist. Finish with a 3-line summary.
| Client | Modell | Laufzeit | Ergebnis |
|---|---|---|---|
| Claude Code 2.1.319 (claude -p) | claude-opus-5-5 | etwa 32,3 s, 5 Runden | Schrieb notes.py und tests/test_notes.py, 2 passed; bestätigte Objekt notes/n1.txt und Eintrag mit der aws CLI |
| Codex CLI 0.167.0 (codex exec) | gpt-6.1-sol | etwa 80,9 s | Schrieb notes.py und tests/test_notes.py und fügte eine pytest.ini hinzu; 2 passed in 3.36s, danach Objekt und Eintrag per Skript bestätigt |
Beide Agents nutzten von sich aus get_waiter("table_exists") und umgingen die Falle „direkt nach dem Anlegen schreiben“. Anschließend haben wir .venv/bin/pytest -q im Verzeichnis von Claude Code selbst erneut ausgeführt und wieder 2 passed in 3.24s erhalten; aws s3 ls zeigte die notes-test-*-Buckets beider Läufe. Lesen Sie die Zusammenfassung des Agents, aber verlassen Sie sich auf Ihren eigenen Testlauf.
Beide liefen nicht interaktiv: Claude Code mit --permission-mode bypassPermissions, Codex mit --dangerously-bypass-approvals-and-sandbox. Das passt nur für ein Wegwerf-Testverzeichnis. In einem echten Repository gefährliche Befehle mit Hooks blockieren; siehe Agent Hooks für Claude Code / Codex / Cursor einrichten. Wer Claude Code und Codex aus einer Oberfläche steuern will, siehe T3 Code mit Claude Code und Codex.
Claude Code und Codex mit einem AICodeWith API Key verbinden
In den Tests oben nutzten beide Clients einen AICodeWith API Key. Wenn Sie sich nicht mit einem offiziellen Abo anmelden möchten, schreiben Sie die globale Konfiguration jeder CLI.
Für Claude Code ~/.claude/settings.json schreiben (vollständige Anleitung: Drittanbieter-API in Claude Code einrichten):
{
"env": {
"ANTHROPIC_BASE_URL": "https://api.aicodewith.ai",
"ANTHROPIC_AUTH_TOKEN": "Ihr AICodeWith API Key"
}
}
Für Codex ~/.codex/config.toml schreiben (Download und Installation: Codex herunterladen; Felder: Codex config.toml Leitfaden):
model_provider = "aicodewith"
model = "gpt-6.1-sol"
[model_providers.aicodewith]
name = "aicodewith"
base_url = "https://api.aicodewith.ai/chatgpt/v1"
wire_api = "responses"
experimental_bearer_token = "Ihr AICodeWith API Key"
Jeden zuerst einzeln prüfen: claude -p "Reply with exactly: pong" und codex exec --skip-git-repo-check "Reply with exactly: pong". Bei uns lieferten beide pong, Claude Code in etwa 4,3 Sekunden, Codex in etwa 4,8 Sekunden.
Halten Sie die beiden Zugangsdaten auseinander. Der AICodeWith Key dient nur dem Agent zum Aufruf des Modells. Auf AWS-Seite nutzt der Emulator temporäre Schlüssel, die mit EMULATOR... beginnen und bei jedem Start neu erzeugt werden; mit Ihrem Modell-Key haben sie nichts zu tun.
In die CI einbauen
Laut Doku hält der Emulator seinen Zustand nur im Speicher, und /__admin/health gibt es, damit Skripte und Container auf die Bereitschaft warten können. Hier ein GitHub-Actions-Beispiel; die Installations- und Startbefehle sind die, die wir oben unter Debian ausgeführt haben:
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Install and start AWS Emulator
run: |
curl -fsSLo aws-emulator.deb https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator_amd64.deb
sudo apt-get install -y ./aws-emulator.deb
aws-emulator -t off &
until curl -sf --cacert ~/.aws/emulator/9297/ca.pem https://127.0.0.1:9297/__admin/health; do sleep 0.2; done
- name: Run tests against the emulator
run: |
export AWS_ENDPOINT_URL=https://127.0.0.1:9297
export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials
export AWS_CONFIG_FILE=~/.aws/emulator/9297/config
export AWS_EC2_METADATA_DISABLED=true AWS_DISABLE_HOST_PREFIX_INJECTION=true
export AWS_REGION=us-east-1 AWS_DEFAULT_REGION=us-east-1
pytest -q
Keine echten AWS-Zugangsdaten in die Umgebung von CI-Jobs legen; das empfiehlt auch AWS.
Grenzen: was er nicht kann
Laut AWS News Blog und der Fidelity-Doku:
- Keine Auswertung von IAM-Richtlinien. Eine Anfrage, die AWS ablehnen würde, kann im Emulator gelingen. Nutzen Sie ihn also nicht für Sicherheitstests.
- Ein Konto, eine Region. Kein kontoübergreifendes oder regionsübergreifendes Verhalten.
- Noch nicht implementierte Operationen liefern HTTP 501 (`NotImplemented`). Ihr Test scheitert sofort, statt still durchzulaufen.
- Die Wiedergabetreue hängt vom Service ab. Control-Plane-APIs (Ressourcen anlegen, beschreiben, löschen) kommen AWS am nächsten; Data-Plane-APIs und IaC-Werkzeuge wie CloudFormation, Terraform und das CDK schwanken stärker je Service. Fidelity-Scores pro Service erscheinen zu jedem Release auf GitHub Releases, die Tests liegen öffentlich im Repository aws-emulator-evaluation-suite.
- Ein Neustart löscht alles. Nach Stopp und Neustart waren die vorherigen Buckets und Tabellen weg, und der Access Key in
emulator_credentialswechselte vonEMULATORC3...zuEMULATOR1D.... Lesen Sie die Datei mit den Zugangsdaten nach jedem Neustart neu ein.
Häufige Fehler und Lösungen
| Fehler / Symptom | Ursache | Lösung |
|---|---|---|
| AccessDenied: Sign the request with the emulator credentials | Mit anderen Schlüsseln signiert, etwa mit echten AWS-Schlüsseln in Umgebungsvariablen (bei uns mit einem Fake-Key aufgetreten) | unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE und AWS_SHARED_CREDENTIALS_FILE auf die emulator_credentials dieses Laufs richten |
| ResourceNotFoundException direkt nach dem Anlegen einer DynamoDB-Tabelle | Die Tabelle ist noch CREATING (bei uns aufgetreten) | aws dynamodb wait table-exists oder ein Waiter im Code |
| UnknownService: could not resolve a target service | Eine nicht für ihn bestimmte Anfrage ging an den Emulator, etwa die Skill-Installation in einem Terminal mit gesetztem AWS_ENDPOINT_URL (bei uns aufgetreten) | In einem Terminal ohne AWS_ENDPOINT_URL ausführen |
| SSL: CERTIFICATE_VERIFY_FAILED | Der Client vertraut der ca.pem dieses Laufs nicht | AWS_CONFIG_FILE setzen; für Node NODE_EXTRA_CA_CERTS, für Java truststore.p12; die Zertifikatsprüfung nie abschalten |
| sts get-caller-identity zeigt ein echtes Konto | Der Befehl lief ohne AWS_ENDPOINT_URL und ging an AWS | Im Terminal oder Skript mit gesetzten Variablen ausführen |
| Address already in use | Der Port ist belegt | Anderen Port nehmen, etwa aws-emulator -p 9300, und den Port auch in den Variablen ändern |
| NotImplemented / HTTP 501 | Die installierte Version implementiert diese Operation noch nicht | Auf das neueste Release aktualisieren, dann den Fidelity-Score des Service auf Releases prüfen |
FAQ
Sind die APIs von AWS Emulator dieselben wie bei echtem AWS?
Laut AWS basiert er auf denselben Smithy-API-Modellen wie die AWS SDKs, daher haben Anfragen und Fehler dieselbe Form wie bei AWS. Ob das Verhalten übereinstimmt, hängt vom Fidelity-Score des jeweiligen Service ab. Der CREATING-Status bei DynamoDB und die Prüfung der Lambda-Vertrauensrichtlinie, auf die wir gestoßen sind, entsprachen AWS.
Kann ich ihn direkt auf macOS installieren?
Nein, dafür nutzen Sie Docker. AWS veröffentlicht nur Linux-Pakete; unter macOS und Windows bauen Sie ein Image aus dem offiziellen Dockerfile.
Kann ich ihn für Produktion oder Sicherheitstests nutzen?
Nein. AWS sagt klar, dass er nur zum Entwickeln und Testen gedacht ist. Er wertet keine IAM-Richtlinien aus und ist nicht für Produktionslasten gedacht.
Kann der Agent versehentlich meine echten AWS-Ressourcen ändern?
Solange im Terminal, in dem Sie den Agent starten, AWS_ENDPOINT_URL gesetzt und echte Zugangsdaten entfernt sind, gehen Anfragen nur an Ihren Rechner. Außerdem akzeptiert der Emulator nur Anfragen, die mit den von ihm erzeugten EMULATOR...-Schlüsseln signiert sind. Führen Sie vor dem Start einmal aws sts get-caller-identity aus und prüfen Sie, dass das Konto 000000000000 ist.
Was eignet sich besser: Claude Code, Codex oder Cursor?
Alle drei funktionieren: Jeder kann den offiziellen Skill installieren und übernimmt die Umgebungsvariablen seines Terminals. In diesem Test haben Claude Code und Codex dieselbe Aufgabe beide im ersten Anlauf erledigt. Nehmen Sie den, den Sie ohnehin nutzen.
Quellen
- AWS News Blog: Test your applications against AWS locally with AWS Emulator
- Swami Sivasubramanian: AWS Emulator and the engineer's job when agents write the code
- GitHub: aws/aws-emulator
- AWS Emulator Benutzerhandbuch: Getting started
- Getting started on Linux
- Getting started with Docker
- Fidelity in AWS Emulator
- Launch-Post von @AWSNewsroom
- Launch-Post von @awsdevelopers
- Post von @Werner



