Developer Tools10 min di lettura

Quali test AWS puoi spostare dal cloud al portatile?

AWS Emulator esegue in locale le chiamate supportate alle API AWS. Un test di scrittura e lettura in DynamoDB mostra dove si risparmia tempo e quando serve ancora un account reale.

K
Ken Jo

Immagina una modifica al codice apparentemente banale. Un'applicazione deve salvare un ordine in DynamoDB e rileggere lo stesso ordine. Puoi controllare in pochi secondi gli argomenti passati a un client simulato, oppure distribuire l'applicazione in un account di sviluppo e osservare l'intero flusso. Tra queste due opzioni c'è un test utile, e AWS fornisce ora l'endpoint necessario.

L'11 novembre 2026 Amazon Web Services ha annunciato la disponibilità generale di AWS Emulator. Lo strumento open source permette alla CLI e agli SDK di AWS di inviare le richieste supportate a un emulatore sul tuo computer. AWS non applica tariffe aggiuntive per l'emulatore. Il comportamento varia a seconda dell'API e AWS continua a raccomandare di eseguire le verifiche di sicurezza e provare l'intera applicazione su AWS prima di passare in produzione. Annuncio di AWS

L'esempio di DynamoDB rende chiara la divisione del lavoro. A ogni modifica verifica che l'applicazione scriva e legga i dati giusti. Dedica una quota più piccola delle risorse di test nel cloud a controllare che il ruolo distribuito, le risorse e il comportamento del servizio corrispondano alle tue aspettative. Mantieni entrambe le verifiche nel processo di rilascio.

Un test di integrazione può partire da un solo record

Parti da un requisito concreto. Un ordine con identificativo order-123 entra nell'applicazione di prova con stato pending. L'applicazione lo salva attraverso il client DynamoDB. Una nuova lettura attraverso il repository dell'applicazione restituisce lo stesso identificativo e lo stesso stato. Il test intercetta errori come scrivere in una tabella e leggere da un'altra, serializzare un attributo con il nome sbagliato o dare per scontata una struttura diversa della chiave. Un mock può riprodurre quegli errori se lo configuri appositamente, ma devi prima prevederli.

L'articolo di lancio di AWS mostra una sequenza simile. Crea una tabella con una chiave di partizione di tipo stringa, inserisce un elemento di prova e lo rilegge. L'articolo presenta un esempio con la CLI e un altro con l'SDK di Rust all'interno del processo. Il client abituale mantiene l'esempio vicino al codice di integrazione che usi già. Verificare il valore restituito dà più informazioni che verificare la chiamata a un metodo dell'SDK. Esempi del lancio di AWS

Un test di DynamoDB invia una scrittura e una lettura all'endpoint locale tramite l'SDK

Il ciclo locale passa dallo stesso client per la scrittura e la lettura. Illustrazione originale di Telli.sh.

Su Linux AWS fornisce pacchetti RPM e Debian. Per Windows e macOS le istruzioni ufficiali spiegano come creare ed eseguire un'immagine Docker. Per impostazione predefinita, l'emulatore autonomo apre un endpoint HTTPS su 127.0.0.1:9297 e genera una configurazione locale, un certificato e credenziali separate. Il controllo di disponibilità e l'identità del chiamante aiutano a verificare che il terminale sia collegato all'emulatore prima di creare risorse. AWS documenta anche una modalità integrata nell'SDK di Rust che esegue un'istanza di test isolata all'interno del processo. Guida di AWS Emulator

Tieni la configurazione del client nell'ambiente di test. Il terminale di prova deve contenere l'endpoint, le impostazioni del certificato e le credenziali dell'emulatore. Le credenziali AWS reali devono rimanerne fuori. Usa lo stesso codice applicativo nell'ambiente distribuito. In questo modo puoi verificare dove passa il confine. Se l'emulatore non è disponibile, il job locale dovrebbe fallire con un errore esplicito di connessione o configurazione. Un test che raggiunge in silenzio un altro ambiente può invalidare il risultato e sorprendere chi gestisce l'account.

Secondo AWS, le richieste, le risposte e i dati salvati dall'emulatore rimangono sul computer locale. Separatamente, l'emulatore autonomo invia per impostazione predefinita dati anonimi di utilizzo ed errore. Puoi disattivare la telemetria nelle sue impostazioni. Documentazione di lancio di AWS

Ogni test dimostra una cosa diversa

Ci sono tre livelli utili. Il primo è un test unitario del comportamento di cui è responsabile l'applicazione, per esempio il rifiuto di un ordine con campi incompleti prima della chiamata al servizio. Il secondo verifica insieme la configurazione del client, la codifica e l'operazione supportata. Il terzo controlla le risorse distribuite, i ruoli e il comportamento del servizio in un ambiente AWS reale. Puoi ripartire diversamente il lavoro dopo aver visto quali errori emergono da ciascun livello.

LivelloEsempio di verificaEvidenza che offre
Test unitarioL'applicazione rifiuta un identificativo vuoto prima di chiamare il clientL'applicazione applica la propria regola
Emulatore localeL'SDK permette di scrivere e leggere un ordine validoQuesto client e queste operazioni supportate funzionano con l'emulatore
Integrazione su AWSIl ruolo distribuito può aggiornare la tabella consentita e riceve un diniego sulla risorsa vietataLa configurazione reale applica il limite di accesso

Inizia con un caso locale positivo e aggiungi il guasto che più interessa al gruppo. Se una richiesta duplicata deve lasciare intatto l'ordine, puoi aggiungere una seconda chiamata e verificare il risultato atteso. Se il problema dipende da scritture condizionali o transazioni, conferma che le operazioni specifiche si comportino come assume il test. La domanda è se l'emulatore esercita l'operazione e la semantica che servono al prodotto. Constatare che un elemento esiste dice poco su una condizione di concorrenza che non hai mai simulato.

Un esempio basato su una coda rende visibile la differenza. Un processo legge un lavoro, salva il risultato e conferma il lavoro. Se le operazioni necessarie sono supportate, puoi costruire un test locale per l'ordine in cui le svolge. Fai fallire il salvataggio del risultato e verifica che l'applicazione lasci il lavoro disponibile per un nuovo tentativo, secondo il contratto previsto. Usa il cloud per verificare la consegna degli eventi gestita dal servizio, i permessi del ruolo distribuito e le tempistiche rilevanti sotto carico. Il test locale dà evidenza sul percorso che ha effettivamente esercitato.

L'elenco delle operazioni dice più del nome del servizio

AWS pubblica i risultati di fedeltà per servizio come numero di test superati sul totale. Nell'articolo di lancio usa 40 su 50 come esempio del formato. La cifra mostra come si legge il punteggio. Il gruppo deve comunque esaminare i casi di valutazione relativi alle chiamate che usa. Il punteggio può scendere quando una versione aggiunge test più difficili, anche se migliora il supporto alle funzionalità esistenti. AWS indica che l'emulatore restituisce HTTP 501 per le operazioni non ancora implementate. Suite di valutazione di AWS

Un gruppo che usa tre chiamate DynamoDB può elencare le operazioni e i dettagli che contano. Potrebbe indicare una scrittura, una lettura a consistenza forte e un aggiornamento condizionale che impedisce a un utente di sovrascrivere l'azione di un altro. Annota se ogni comportamento è coperto da una valutazione del progetto, da un test del gruppo, da una verifica nel cloud o da una combinazione. Ricontrolla le operazioni richieste quando aggiorni l'emulatore. La fedeltà diventa così un criterio per scegliere quale versione della dipendenza adottare.

Un piano di test assegna all'emulatore il comportamento delle richieste supportate e ad AWS i permessi distribuiti

I due ambienti rispondono a domande diverse sulla stessa applicazione. Illustrazione originale di Telli.sh.

Quando un test restituisce HTTP 501, individua l'operazione prima di cambiare l'applicazione. Spostare quel caso tra i test nel cloud consente di conservare il requisito. Se l'API è disponibile ma la risposta locale differisce da AWS, isola l'input minimo che riproduce la discrepanza con dati sintetici e, se utile, segnalalo al progetto. Una discrepanza può anche mettere in luce un presupposto del codice client. Tieni il guasto visibile finché non sai dove correggerlo.

Secondo l'annuncio, il progetto usa agenti IA per confrontare il comportamento dell'emulatore con le risposte dei servizi reali e con i modelli delle API pubblicati. Le modifiche vengono esaminate e verificate dalla pipeline di rilascio. Questo è parte del processo con cui AWS mantiene il progetto e rende disponibili le valutazioni. Ogni gruppo deve comunque verificare le operazioni da cui dipende. Lancio e processo di sviluppo di AWS

Permessi e distribuzione si verificano in un account reale

Lo strumento locale usa richieste firmate e credenziali specifiche dell'emulatore. Questi controlli hanno uno scopo diverso dalla valutazione completa delle policy AWS. AWS dice che l'emulatore non valuta le policy IAM e quelle basate sulle risorse nello stesso modo. Al lancio rappresenta inoltre un solo account e non riproduce comportamenti tra account o tra regioni. Una risposta riuscita dall'emulatore dà evidenza per un test funzionale. Un test nel cloud con l'identità distribuita dà evidenza su una decisione di accesso. Limiti di AWS Emulator al lancio

Fai un passo in più con l'esempio dell'ordine. Il processo in produzione dovrebbe aggiornare una sola tabella specifica. Nell'account AWS di sviluppo, invocalo con il ruolo effettivo e verifica l'operazione sulla tabella consentita. Prova la stessa operazione su una risorsa controllata per cui quel ruolo deve ricevere un diniego. Il caso negativo conta perché un test che verifica solo le scritture consentite può passare anche quando il ruolo ha privilegi eccessivi. Usa risorse di test sintetiche e rimuovile secondo le regole del gruppo per gli ambienti di prova.

In un altro esempio, un'applicazione legge file caricati in un bucket in un account separato. La distribuzione può dipendere dal ruolo dell'app, dalla policy del bucket e dalla relazione fra le risorse. Esegui una verifica mirata nel cloud per quella relazione, con la configurazione di account e regioni pertinente. Usa l'emulatore per la validazione degli input, i nomi degli oggetti o i passaggi che dipendono da chiamate supportate in una sola istanza locale. Questa divisione permette agli sviluppatori di proseguire e verifica il contratto che governa la connessione reale.

Metti i test rapidi sul ramo e misura l'intero ciclo

Un emulatore può ridurre il tempo necessario per ottenere un riscontro, ma il risultato dipende dal lavoro che oggi richiede più tempo. Una distribuzione di tre minuti per provare una modifica API offre un'opportunità diversa rispetto a una lunga suite che gira già in un ambiente condiviso economico. Misura preparazione, esecuzione e pulizia nel flusso attuale. Poi prova la stessa modifica rappresentativa con un job di integrazione locale e registra quali casi rimangono nel cloud e quando vengono eseguiti.

Misura il tempo effettivo dall'inizio della modifica al primo risultato su cui puoi agire. Un job più veloce può rallentare il flusso se gli sviluppatori passano dieci minuti a diagnosticare certificati mancanti o errori dovuti allo stato condiviso. Fissa la versione dell'emulatore nella CI, isola i dati di prova e attendi che sia pronto prima di eseguire la suite. Distingui nei log gli errori di avvio dai controlli falliti. AWS descrive istanze integrate isolate per i test Rust. Per chi usa un servizio autonomo, processi separati o risorse con nomi univoci possono impedire a un test di vedere i dati di un altro.

  1. Scegli un test riproducibile che chiami un servizio AWS e scriva dati sintetici.
  2. Fissa la versione dell'emulatore e avvia un'istanza temporanea o un ambiente locale isolato.
  3. Imposta credenziali ed endpoint solo per i test. Verifica identità e disponibilità prima di scrivere.
  4. Esegui il caso atteso e un caso negativo. Salva gli input e le osservazioni relative ai controlli falliti.
  5. Mantieni un test essenziale su AWS per l'integrazione distribuita e le policy IAM. Registra perché quel test va eseguito lì.

Un agente di programmazione può aiutarti a iterare sull'applicazione in questo ciclo. Dagli l'endpoint di prova e un controllo circoscritto per fare un esperimento rapido senza predisporre ampie risorse nel cloud. Chiedi un test che fallisca in presenza del difetto e passi dopo la correzione. Mantieni la stessa revisione umana della copertura e dei permessi che useresti per qualsiasi altra modifica. La velocità dell'agente nell'eseguire il test è utile quando restituisce un risultato più specifico.

Se i costi fanno parte della decisione, registra il consumo effettivo di risorse nel cloud. AWS non applica una tariffa separata per l'emulatore, e anche la CI locale consuma risorse di calcolo. Le verifiche eseguite su AWS possono comportare addebiti per le risorse usate. Il confronto significativo è quanto il gruppo spende per mantenere una copertura affidabile lungo un ciclo di rilascio. Un job locale che trova presto gli errori di contratto, insieme a un insieme mirato di verifiche nel cloud, può ridurre le distribuzioni ripetute senza indebolire il controllo prima del rilascio.

La divisione migliore indica come intervenire dopo un errore

Se l'ordine locale non torna correttamente, lo sviluppatore può partire dalla richiesta e dal codice del repository applicativo. Se fallisce la prova dei permessi nel cloud, il responsabile può partire dalla configurazione di distribuzione e dalle policy. È il vantaggio di avere due endpoint per i test. Un riscontro più rapido serve quando indica anche la prossima modifica da fare.

Fonti


Per raccogliere le decisioni di integrazione e le note dei test in un archivio consultabile, crea un account Telli.sh.


← Torna al blog