Emulatore AWS: 5 miti che ti morderanno in produzione
L'emulatore ufficiale AWS è valido, ma i miti sul test con emulatore AWS ti costeranno cari. Scopri dove la fedeltà cede e cosa deve ancora girare su AWS reale.

Il peggior fallimento di un test di integrazione con cui mi sia mai trovato a lavorare era verde. Ogni controllo passava in CI, il deploy partiva e venti minuti dopo un ingegnere on-call fissava una coda piena di messaggi velenosi, perché il comportamento reale di SQS differiva dallo stub in un unico modo che nessuno aveva pensato di verificare. Quindi, quando AWS ha rilasciato il proprio emulatore, un workspace Rust con un crate per servizio generato dagli stessi modelli Smithy che alimentano gli SDK reali, la mia prima reazione non è stata entusiasmo. È stata: bene, ora scopriamo dove mente. Perché ogni emulatore mente da qualche parte, e il test con emulatore AWS funziona solo se conosci dove sono le bugie.
Mito 1: «Test verdi contro un emulatore AWS significano che funziona su AWS»
È la convinzione che fa più danni, e la documentazione del progetto è insolitamente onesta al riguardo. AWS pubblica un punteggio di fedeltà per servizio a ogni release e tiene traccia dei gap in una directory vera e propria, issues/things-that-do-not-work/, nel repo. Quella directory è la prima cosa da leggere, prima di scrivere un solo test. I primi adottanti hanno già sbattuto contro i muri: le definizioni di Step Functions che usano il campo Assign non funzionano, e il supporto Lambda per il codice Python è abbastanza incompleto da far sì che un workflow che gira senza problemi su MiniStack si blocchi sull'emulatore ufficiale. Niente di scandaloso, è lo stato normale di un emulatore giovane. Lo scandalo è trattare una suite verde come prova di qualcosa di più di «il tuo codice funziona contro l'interpretazione dell'API data dall'emulatore».
Il modello mentale giusto è copertura, non verità. L'emulatore copre le forme delle richieste che il tuo SDK invia e restituisce risposte plausibili. Non copre il comportamento di throttling, i ritardi di propagazione tra servizi né le mille stranezze non documentate di un sistema distribuito globalmente. È lo stesso gap tra specifica e implementazione che si ritrova ovunque nell'infrastruttura: il modello Smithy ti dice qual è il formato sul filo, ma non può dirti che SQS reale a volte consegna un messaggio due volte entro il visibility timeout, o che la propagazione reale di IAM richiede secondi e che il ruolo appena creato fallirà alle prime tre invocazioni. I tuoi test sono passati perché l'emulatore non ha mai avuto l'occasione di essere eventualmente coerente.
Mito 2: «Posso validare le policy IAM e i controlli di sicurezza in locale»
No, e AWS lo dice in modo esplicito nella pagina di sicurezza dell'emulatore. Non usarlo per testare policy IAM o permissions boundary, policy basate sulle risorse come le bucket policy, key policy KMS, accessi cross-account o cross-region, né alcun altro controllo di sicurezza. Alcuni servizi valutano IAM per utenti e ruoli creati dentro l'emulatore, ma non nel modo in cui lo fa AWS. L'emulatore non nega mai una richiesta firmata con la propria chiave. Una richiesta che AWS rifiuterebbe può avere successo in locale, il che significa che l'emulatore non è solo inutile per i test di sicurezza: è attivamente fuorviante. Ti darà un falso negativo con la faccia seria.
Ho visto team imparare questa lezione a caro prezzo. Uno sviluppatore stringe una bucket policy, esegue la suite locale, vede il verde e rilascia. Il job notturno contro l'account sandbox muore perché la policy ora blocca il ruolo di replica. Oppure c'è il caso inverso, molto peggiore: la policy è troppo permissiva, tutto passa ovunque, e scopri mesi dopo, durante un audit, che il tuo bucket «privato» era leggibile da qualsiasi principal autenticato. La logica delle policy è uno dei punti in cui l'autenticazione cloud ha punti ciechi reali, e nessun emulatore ti salverà da questi. Se vuoi verificare il comportamento delle policy, ti servono valutazioni IAM reali. Questo significa un account vero, idealmente un sandbox dedicato con SCP che limitino ciò che può raggiungere, e test che verificano i rifiuti, non solo i successi:
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"
Un'ultima cosa prima di puntare tutta la tua flotta CI su questo strumento: la telemetria è attiva di default. AWS dice che è minimizzata e che non include mai contenuti delle richieste o credenziali, e non ho motivo di dubitarne, ma la mia regola è che gli strumenti di sviluppo non telefonano a casa se non l'ho chiesto io. Eseguilo con --telemetry off oppure imposta EMULATOR_TELEMETRY=off nell'ambiente CI e vai avanti.
Mito 3: «La fedeltà del wire protocol è la parte difficile»

Azzeccare il formato sul filo è il requisito minimo, ed è la parte che AWS avrebbe sempre centrato. I loro SDK sono generati dai modelli Smithy, e l'emulatore è generato dagli stessi modelli, quindi ogni operazione, ogni campo opzionale e ogni forma di errore corrisponde all'API documentata. Un commentatore di HN lo ha detto bene: la generazione guidata dalla specifica copre ogni variante di ogni endpoint, mentre gli emulatori della community storicamente implementano il sottoinsieme più usato e approssimano il resto. È un vantaggio reale dello strumento ufficiale.
Ma la fedeltà del formato è la parte facile. La parte difficile è la fedeltà comportamentale, e nessuno la possiede: né l'emulatore AWS, né LocalStack, né moto, né Floci. La fedeltà comportamentale è ciò che non sta in nessun modello. Un cold start di Lambda cambia i tempi osservabili abbastanza da far scattare il timeout del tuo client? Il throttling di DynamoDB si manifesta come errore ritentabile con la frequenza con cui il traffico di produzione lo colpisce davvero? Il teardown di CloudFormation si blocca per venti minuti quando le risorse sono state create in un ordine legale ma sfortunato? Un professionista ha chiesto se fosse possibile puntare un intero progetto CDK sull'emulatore e testare cdk deploy end to end. La mia risposta è: si può, e si dovrebbe, ma solo per intercettare errori di sintesi e di forma dell'API. Le dinamiche di deployment (comportamento di rollback, ordine di sostituzione delle risorse, rilevamento del drift) sono esattamente le parti in cui un emulatore va peggio, perché sono proprietà emergenti del control plane reale.
- Fedeltà del formato — forme di richiesta e risposta, codici di errore, serializzazione. Gli emulatori sono bravi in questo, e quello generato da Smithy dovrebbe essere il migliore della categoria.
- Fedeltà dello stato — round-trip CRUD, liste, filtri, paginazione. Generalmente buona tra gli emulatori, con lacune per servizio che devi verificare.
- Fedeltà comportamentale — tempi di coerenza, throttling, fallimenti parziali, stranezze del ciclo di vita delle risorse. Nessuno la possiede. Organizzati di conseguenza.
Mito 4: «Gli emulatori sono drop-in: basta cambiare l'endpoint»
Il messaggio di marketing di ogni emulatore è «imposta una variabile d'ambiente e vai». Per un rapido smoke test è vero. La modalità server ascolta su 127.0.0.1:9297 via HTTPS con un certificato self-signed, e puntare la CLI verso di lui appare così:
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
La storia del drop-in crolla alla scala di una suite di test. I problemi pratici che la gente incontra nella prima settimana: non esiste un reset rapido dello stato. Se la tua suite ha bisogno di una lavagna pulita tra un test e l'altro (e gli utenti di moto sono abituati esattamente a questo: un decoratore e il mondo è nuovo), la tua unica opzione è riavviare il processo. Va bene per dieci test e diventa doloroso per diecimila. Manca anche l'emulazione multi-account o di Organizations, il che blocca ogni test che modella la struttura reale del tuo account. E se ti tenta la modalità Rust embedded, un'istanza isolata in-process per test senza endpoint o certificati da gestire, che è un design davvero piacevole, leggi prima la sezione sui costi di build. Il workspace è un crate per servizio AWS, una build di debug completa richiede dell'ordine di 100 GB di spazio in target/, e il tuo primo cargo test compila l'emulatore insieme al tuo codice. Il loro consiglio di condividere un CARGO_TARGET_DIR, mettere in cache target/ in CI e fissare un commit di release non è decorazione opzionale. È la differenza tra un job CI da cinque minuti e uno da cinquanta.
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
Mito 5: «L'emulatore di AWS fa fuori LocalStack, moto e gli altri»
Ne ho sentite versioni entro poche ore dall'annuncio, e fraintende cosa vendano davvero i concorrenti storici. Il valore di LocalStack non è mai stato solo «abbiamo reimplementato l'API S3». È anni di messa a punto comportamentale per servizio, gestione dello stato, integrazione con testcontainers, ergonomia in CI, e una community che ha già segnalato il bug in cui stai per inciampare. Il reset di stato per test di moto tramite decoratori è una funzione di workflow, non di API, e l'emulatore AWS non ha ancora una risposta. I fan di Floci hanno fatto notare che copre anche GCP e Azure: se il tuo parco è multi-cloud, un ambiente locale unico vale più di uno single-cloud con fedeltà superiore.
C'è anche una questione legittima di fiducia sulla longevità. Il primo commento del thread ha posto la domanda che tutti avevano in testa: è un prodotto vero che AWS manterrà, o un esercizio? Il repo accetta segnalazioni di issue ma non pull request, una scelta difendibile per una codebase guidata dalla specifica, ma significa anche che la community non può colmare i gap da sola. Se il team viene riassegnato, ti ritrovi con uno snapshot con licenza CC0. La mia posizione: valutalo come qualsiasi dipendenza con un singolo maintainer. Va bene adottarlo, è sconsiderato scommetterci tutto. Lo stesso scetticismo vale per i commenti euforici del tipo «gli agenti l'hanno scritto in Rust, il fossato è sparito». Il fossato non è mai stata la superficie dell'API: è l'eccellenza operativa, ed emulare l'API è sempre stata la parte economica. Abbiamo visto questa dinamica anche con SQLite distribuito e raft: copiare l'interfaccia richiede settimane, far corrispondere la semantica dei fallimenti richiede anni.
Cosa deve ancora girare su infrastruttura AWS reale

Ecco la suddivisione che uso sui progetti reali, e finora non mi ha mai tradito. Tutto ciò che è veloce, deterministico e orientato alla forma gira contro l'emulatore a ogni commit: serializzazione, gestione degli errori per i codici documentati, logica di retry, macchine a stati che dipendono solo da round-trip CRUD. Questo è il 90% della suite per numero di test e circa il 10% per rischio.
Il restante 10% gira ogni notte contro un account sandbox reale e isolato, ed è la parte che intercetta ciò che ti fa davvero svegliare di notte:
- Policy IAM e policy sulle risorse. Verifica i rifiuti espliciti, non solo i percorsi consentiti. L'emulatore non può farlo strutturalmente: non nega mai una richiesta firmata con la propria chiave.
- Qualsiasi cosa con ritardo di propagazione. Nuovi ruoli, modifiche DNS, grant KMS. Se il tuo codice crea una risorsa e la usa subito, solo AWS reale ti dirà se serve un ciclo di retry.
- Comportamento at-least-once e idempotenza. Consegne duplicate di SQS, retry di Lambda in caso di timeout, fallimenti parziali dei batch. Gli emulatori sono educati; la produzione no.
- Ciclo di vita dell'infrastruttura. Cicli completi di
cdk deploy/terraform applye destroy, soprattutto ordine di teardown e percorsi di rollback. - Throttling e limiti di quota. Se conta al carico di produzione, esiste solo con il comportamento reale delle API di produzione.
Il sandbox deve avere le sue protezioni: service control policy che limitano ciò che può fare, alert di budget e uno sweeper che elimina le risorse residue, perché il job notturno lascerà sempre qualcosa in giro. È un overhead operativo reale, ed è esattamente il motivo per cui l'emulatore è prezioso: mantiene veloce e gratuito il 90% del tuo feedback loop, così puoi permetterti di rendere onesto il restante 10%.
Il compito di un emulatore è rendere veloce il tuo feedback loop. Non è renderti sicuro. La sicurezza costa ancora chiamate API reali.
L'emulatore ufficiale di AWS è uno strumento davvero valido: copertura generata dalle specifiche, una modalità embedded con isolamento reale e una documentazione sorprendentemente onesta su ciò che non sa fare. Adottalo per quello che è: il modo più veloce possibile per essere quasi sempre nel giusto. Poi decidi, deliberatamente e per iscritto, quali test possono rivendicare l'altro tipo di correttezza, quello che arriva solo da infrastrutture che possono davvero negare la tua richiesta, limitare il tuo client e consegnare il tuo messaggio due volte.


