La AWS SDK per JavaScript v2 è arrivata. end-of-support [Ti consigliamo di migrare alla AWS SDK per JavaScript v3.](https://docs.aws.amazon.com//sdk-for-javascript/v3/developer-guide/) [Per ulteriori dettagli e informazioni su come effettuare la migrazione, consulta questo annuncio.](https://aws.amazon.com/blogs//developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/)
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo dei servizi nell'SDK per JavaScript
AWS SDK per JavaScript Fornisce l'accesso ai servizi che supporta attraverso una raccolta di classi client. Da queste classi client, si creano oggetti di interfaccia di servizio, comunemente chiamati *oggetti di servizio*. Ogni AWS servizio supportato include una o più classi client che offrono funzionalità e risorse APIs di servizio di basso livello. Ad esempio, Amazon APIs DynamoDB è disponibile tramite la classe. `AWS.DynamoDB`
I servizi esposti tramite l'SDK JavaScript seguono lo schema di richiesta-risposta per lo scambio di messaggi con le applicazioni chiamanti. In questo schema, il codice che richiama un servizio invia una HTTP/HTTPS richiesta a un endpoint per il servizio. La richiesta contiene i parametri necessari per richiamare correttamente la funzionalità specifica chiamata. Il servizio richiamato genera una risposta che viene inviata nuovamente al richiedente. La risposta contiene dati se l'operazione ha avuto esito positivo o informazioni di errore se l'operazione non ha avuto esito positivo.
![\[Il modello del AWS servizio di risposta alla richiesta.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v2/developer-guide/images/request-response.png)
L'invocazione AWS di un servizio include l'intero ciclo di vita della richiesta e della risposta di un'operazione su un oggetto del servizio, inclusi eventuali nuovi tentativi. Una richiesta viene incapsulata nell'SDK dall'oggetto `AWS.Request`. La risposta è incapsulata nell'SDK dall'`AWS.Response`oggetto, che viene fornito al richiedente tramite una delle diverse tecniche, ad esempio una funzione di callback o una promessa. JavaScript
**Topics**
+ [Creazione e chiamata di oggetti di servizio](creating-and-calling-service-objects.md)
+ [Registrazione delle chiamate AWS SDK per JavaScript](logging-sdk-calls.md)
+ [Chiamate asincrone dei servizi](calling-services-asynchronously.md)
+ [Utilizzo dell'oggetto di risposta](the-response-object.md)
+ [Utilizzo di JSON](working-with-json.md)
+ [Riprova la strategia nella v2 AWS SDK per JavaScript](retry-strategy.md)
# Creazione e chiamata di oggetti di servizio
L' JavaScript API supporta la maggior parte dei AWS servizi disponibili. Ogni classe di servizio nell' JavaScript API fornisce l'accesso a tutte le chiamate API del relativo servizio. Per ulteriori informazioni sulle classi di servizio, le operazioni e i parametri dell' JavaScript API, consulta il [riferimento all'API](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/index.html).
Quando utilizzi l'SDK in Node.js, puoi aggiungere il pacchetto SDK alla tua applicazione utilizzando `require`, che fornisce supporto per tutti i servizi correnti.
```
var AWS = require('aws-sdk');
```
Quando si utilizza l'SDK con il browser JavaScript, si carica il pacchetto SDK negli script del browser utilizzando il pacchetto SDK ospitato da AWS. Per caricare il pacchetto SDK, aggiungi il seguente elemento `
```
[Per trovare l'attuale SDK\$1VERSION\$1NUMBER, consulta l'API Reference for the SDK consultabile nella API Reference Guide. JavaScript AWS SDK per JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/)
Il pacchetto SDK ospitato di default fornisce il supporto per un sottoinsieme dei servizi disponibili. AWS Per un elenco dei servizi predefiniti nel pacchetto SDK in hosting per il browser, consulta la sezione relativa ai [servizi supportati](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/#Supported_Services) nella documentazione di riferimento delle API. Puoi utilizzare l'SDK con altri servizi se il controllo di sicurezza della funzionalità CORS è disabilitato. In questo caso, puoi creare una versione personalizzata dell'SDK per includere i servizi aggiuntivi necessari. Per ulteriori informazioni sulla creazione di una versione personalizzata dell'SDK, consulta [Creazione dell'SDK per i browser](building-sdk-for-browsers.md).
## Richiesta di singoli servizi
La richiesta dell'SDK per JavaScript come mostrato in precedenza include l'intero SDK nel codice. In alternativa, puoi scegliere di richiedere solo i singoli servizi utilizzati dal tuo codice. Considera il seguente codice utilizzato per creare un oggetto di servizio Amazon S3.
```
// Import the AWS SDK
var AWS = require('aws-sdk');
// Set credentials and Region
// This can also be done directly on the service client
AWS.config.update({region: 'us-west-1', credentials: {YOUR_CREDENTIALS}});
var s3 = new AWS.S3({apiVersion: '2006-03-01'});
```
Nell'esempio precedente, la funzione `require` specifica l'intero SDK. La quantità di codice da trasportare sulla rete e il sovraccarico di memoria del codice sarebbero notevolmente inferiori se fosse inclusa solo la parte dell'SDK richiesta per il servizio Amazon S3. Per richiedere un singolo servizio, chiama la funzione `require` come illustrato, includendo il costruttore del servizio a lettere minuscole.
```
require('aws-sdk/clients/SERVICE');
```
Ecco come appare il codice per creare il precedente oggetto di servizio Amazon S3 quando include solo la parte Amazon S3 dell'SDK.
```
// Import the Amazon S3 service client
var S3 = require('aws-sdk/clients/s3');
// Set credentials and Region
var s3 = new S3({
apiVersion: '2006-03-01',
region: 'us-west-1',
credentials: {YOUR_CREDENTIALS}
});
```
Puoi comunque accedere al AWS namespace globale senza tutti i servizi ad esso collegati.
```
require('aws-sdk/global');
```
Si tratta di una tecnica utile quando si applica la stessa configurazione su più singoli servizi, ad esempio per fornire le stesse credenziali a tutti i servizi. La richiesta di singoli servizi dovrebbe ridurre il tempo di caricamento e il consumo di memoria in Node.js. Quando la richiesta dei singoli servizi viene eseguita utilizzando uno strumento di raggruppamento come Browserify o webpack, l'SDK sarà una frazione delle dimensioni complete. Ciò è utile in ambienti con limiti di memoria o spazio su disco come un dispositivo IoT o in una funzione Lambda.
## Creazione di oggetti di servizio
Per accedere alle funzionalità del servizio tramite l' JavaScript API, è innanzitutto necessario creare un *oggetto di servizio* tramite il quale accedere a un set di funzionalità fornite dalla classe client sottostante. Generalmente per ciascun servizio viene fornita una classe client; tuttavia, alcuni servizi distribuiscono l'accesso alle loro funzionalità tra più classi client.
Per utilizzare una funzionalità, devi creare un'istanza della classe che fornisce l'accesso a tale funzionalità. L'esempio seguente mostra la creazione di un oggetto servizio per DynamoDB dalla `AWS.DynamoDB` classe client.
```
var dynamodb = new AWS.DynamoDB({apiVersion: '2012-08-10'});
```
Per impostazione predefinita, un oggetto di servizio viene configurato con le impostazioni globali utilizzate anche per configurare l'SDK. Tuttavia, puoi configurare un oggetto di servizio con i dati di configurazione di runtime specifici per l'oggetto di servizio. I dati di configurazione specifici per il servizio vengono applicati dopo aver applicato le impostazioni di configurazione globali.
Nell'esempio seguente, un oggetto di servizio Amazon EC2 viene creato con la configurazione per una regione specifica, ma per il resto utilizza la configurazione globale.
```
var ec2 = new AWS.EC2({region: 'us-west-2', apiVersion: '2014-10-01'});
```
Oltre a supportare la configurazione specifica del servizio applicata a un singolo oggetto di servizio, puoi anche applicare la configurazione specifica del servizio a tutti gli oggetti di servizio appena creati per una determinata classe. Ad esempio, per configurare tutti gli oggetti di servizio creati dalla classe Amazon EC2 per utilizzare la regione US West (Oregon) (`us-west-2`), aggiungi quanto segue all'oggetto di configurazione `AWS.config` globale.
```
AWS.config.ec2 = {region: 'us-west-2', apiVersion: '2016-04-01'};
```
## Blocco della versione API di un oggetto di servizio
Puoi bloccare un oggetto di servizio su una determinata versione API di un servizio specificando l'opzione `apiVersion` durante la creazione dell'oggetto. Nell'esempio seguente, viene creato un oggetto servizio DynamoDB bloccato su una versione API specifica.
```
var dynamodb = new AWS.DynamoDB({apiVersion: '2011-12-05'});
```
Per ulteriori informazioni sul blocco della versione API di un oggetto di servizio, consulta [Blocco delle versioni dell'API](locking-api-versions.md).
## Specifica dei parametri dell'oggetto di servizio
Quando chiami un metodo di un oggetto di servizio, trasferisci i parametri in JSON come richiesto dall'API. Ad esempio, in Amazon S3, per ottenere un oggetto per un bucket e una chiave specificati, passa i seguenti parametri al metodo. `getObject` Per ulteriori informazioni sul trasferimento di parametri JSON, consulta [Utilizzo di JSON](working-with-json.md).
```
s3.getObject({Bucket: 'bucketName', Key: 'keyName'});
```
Per ulteriori informazioni sui parametri di Amazon S3, consulta il riferimento [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html)all'API.
Inoltre, puoi associare valori ai singoli parametri durante la creazione di un oggetto di servizio utilizzando il parametro `params`. Il valore del parametro `params` degli oggetti di servizio è una mappa che specifica uno o più valori del parametro definiti dall'oggetto di servizio. L'esempio seguente mostra il `Bucket` parametro di un oggetto di servizio Amazon S3 associato a un bucket denominato. `amzn-s3-demo-bucket`
```
var s3bucket = new AWS.S3({params: {Bucket: 'amzn-s3-demo-bucket'}, apiVersion: '2006-03-01' });
```
Associando l'oggetto di servizio a un bucket, l'oggetto di servizio `s3bucket` tratta il valore del parametro `amzn-s3-demo-bucket` come un valore predefinito che non deve più essere specificato per le operazioni successive. Tutti i valori del parametro associati vengono ignorati quando si utilizza l'oggetto per operazioni in cui il valore del parametro non è applicabile. Puoi sostituire questo parametro associato quando effettui chiamate sull'oggetto di servizio specificando un nuovo valore.
```
var s3bucket = new AWS.S3({ params: {Bucket: 'amzn-s3-demo-bucket'}, apiVersion: '2006-03-01' });
s3bucket.getObject({Key: 'keyName'});
// ...
s3bucket.getObject({Bucket: 'amzn-s3-demo-bucket3', Key: 'keyOtherName'});
```
I dettagli sui parametri disponibili per ciascun metodo si trovano nella documentazione di riferimento delle API.
# Registrazione delle chiamate AWS SDK per JavaScript
AWS SDK per JavaScript È dotato di un logger integrato in modo da poter registrare le chiamate API effettuate con l'SDK per. JavaScript
Per attivare il logger e stampare le voci di registro nella console, aggiungi la seguente istruzione al tuo codice.
```
AWS.config.logger = console;
```
Di seguito è riportato un esempio di output del log.
```
[AWS s3 200 0.185s 0 retries] createMultipartUpload({ Bucket: 'amzn-s3-demo-logging-bucket', Key: 'issues_1704' })
```
## Utilizzo di un logger di terze parti
Puoi anche utilizzare un logger di terze parti, a condizione che sia dotato di operazioni `write()` o `log()` per la scrittura in un file di log o su un server. È necessario installare e configurare il logger personalizzato come indicato prima di poterlo utilizzare con l'SDK for. JavaScript
Uno di questi logger che è possibile utilizzare in entrambi gli script del browser o in Node.js è logplease. In Node.js, puoi configurare logplease per scrivere le voci di log in un file di log. Puoi anche utilizzarlo con webpack.
Quando utilizzi un logger di terze parti, imposta tutte le opzioni prima di assegnarlo a `AWS.Config.logger`. Ad esempio, quanto segue specifica un file di log esterno e imposta il livello di log per logplease
```
// Require AWS Node.js SDK
const AWS = require('aws-sdk')
// Require logplease
const logplease = require('logplease');
// Set external log file option
logplease.setLogfile('debug.log');
// Set log level
logplease.setLogLevel('DEBUG');
// Create logger
const logger = logplease.create('logger name');
// Assign logger to SDK
AWS.config.logger = logger;
```
Per ulteriori informazioni su logplease, consulta logplease Simple [Logger](https://github.com/haadcode/logplease) su. JavaScript GitHub
# Chiamate asincrone dei servizi
Tutte le richieste effettuate attraverso l'SDK sono asincrone. Questo è importante da tenere a mente quando si scrivono gli script del browser. JavaScript l'esecuzione in un browser Web in genere ha un solo thread di esecuzione. Dopo aver effettuato una chiamata asincrona a un AWS servizio, lo script del browser continua a essere eseguito e durante il processo può provare a eseguire il codice che dipende da quel risultato asincrono prima che venga restituito.
L'esecuzione di chiamate asincrone a un AWS servizio include la gestione di tali chiamate in modo che il codice non tenti di utilizzare i dati prima che i dati siano disponibili. Gli argomenti di questa sezione spiegano la necessità di gestire le chiamate asincrone e illustrano diverse tecniche che è possibile utilizzare per gestirle.
**Topics**
+ [Gestione delle chiamate asincrone](making-asynchronous-calls.md)
+ [Utilizzo di una funzione di callback anonimo](using-a-callback-function.md)
+ [Utilizzo di un listener di eventi oggetto di richiesta](using-a-response-event-handler.md)
+ [Utilizzo di async/await](using-async-await.md)
+ [Usare Promises JavaScript](using-promises.md)
# Gestione delle chiamate asincrone
Ad esempio, la home page di un sito Web di e-commerce consente l'accesso ai clienti registrati. Parte del vantaggio per i clienti che effettuano l'accesso è che, dopo l'accesso, il sito si adatta alle loro preferenze specifiche. Per fare in modo che ciò accada:
1. Il cliente deve accedere ed essere convalidato con le proprie credenziali di accesso.
1. Le preferenze del cliente vengono richieste da un database dei clienti.
1. Il database fornisce le preferenze del cliente che vengono utilizzate per personalizzare il sito prima che la pagina venga caricata.
Se queste attività vengono eseguite in modo sincrono, ognuna deve terminare prima venga avviata quella successiva. La pagina Web non è in grado di completare il caricamento finché le preferenze del cliente non vengono restituite dal database. Tuttavia, dopo che la query del database viene inviata al server, la ricezione dei dati del cliente può essere posticipata o può addirittura fallire a causa di colli di bottiglia della rete, traffico di database eccezionalmente elevato o connessione scadente dei dispositivi mobili.
Per impedire il congelamento del sito Web in tali condizioni, chiama il database in modo asincrono. Dopo l'esecuzione della chiamata al database, inviando la tua richiesta asincrona, il tuo codice continua a essere eseguito come previsto. Se non gestisci correttamente la risposta di una chiamata asincrona, il tuo codice può tentare di utilizzare le informazioni che si aspetta dal database quando tali dati non sono ancora disponibili.
![\[Differenza tra esecuzione sincrona e asincrona.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v2/developer-guide/images/async-vs-sync.png)
# Utilizzo di una funzione di callback anonimo
Ogni metodo dell'oggetto di servizio che crea un oggetto `AWS.Request` può accettare una funzione di callback anonimo come ultimo parametro. La firma di questa funzione di callback è:
```
function(error, data) {
// callback handling code
}
```
Questa funzione di callback viene eseguita quando vengono restituiti una risposta corretta o i dati dell'errore. Se la chiamata al metodo va a buon fine, i contenuti della risposta sono disponibili per la funzione di callback nel parametro `data`. Se la chiamata non va a buon fine, i dettagli sull'errore vengono forniti nel parametro `error`.
In genere il codice all'interno della funzione di callback verifica un errore, che elabora nel caso venga restituito. Se non viene restituito un errore, il codice recupera i dati dalla risposta dal parametro `data`. Il formato di base della funzione di callback è simile al seguente esempio.
```
function(error, data) {
if (error) {
// error handling code
console.log(error);
} else {
// data handling code
console.log(data);
}
}
```
Nell'esempio precedente, i dettagli dell'errore o dei dati restituiti vengono registrati nella console. Ecco un esempio che mostra una funzione di callback trasferita come parte della chiamata a un metodo su un oggetto di servizio.
```
new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances(function(error, data) {
if (error) {
console.log(error); // an error occurred
} else {
console.log(data); // request succeeded
}
});
```
## Accesso agli oggetti di richiesta e risposta
All'interno della funzione di callback, la JavaScript parola chiave `this` si riferisce all'oggetto sottostante per la maggior parte dei servizi. `AWS.Response` Nell'esempio seguente, la proprietà `httpResponse` di un oggetto `AWS.Response` viene utilizzata all'interno di una funzione di callback per registrare i dati e le intestazioni della risposta non elaborati per facilitare il debug.
```
new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances(function(error, data) {
if (error) {
console.log(error); // an error occurred
// Using this keyword to access AWS.Response object and properties
console.log("Response data and headers: " + JSON.stringify(this.httpResponse));
} else {
console.log(data); // request succeeded
}
});
```
Inoltre, poiché l'oggetto `AWS.Response` ha una proprietà `Request` che contiene l'oggetto `AWS.Request` inviato dalla chiamata al metodo originale, puoi accedere anche ai dettagli della richiesta effettuata.
# Utilizzo di un listener di eventi oggetto di richiesta
Se non crei e trasferisci una funzione di callback anonimo come parametro quando chiami un metodo dell'oggetto di servizio, la chiamata al metodo genera un oggetto `AWS.Request` che deve essere inviato manualmente utilizzando il relativo metodo `send`.
Per elaborare la risposta, devi creare un listener di eventi per l'oggetto `AWS.Request` per registrare una funzione di callback per la chiamata al metodo. L'esempio seguente mostra come creare l'oggetto `AWS.Request` per chiamare un metodo dell'oggetto di servizio e il listener di eventi per l'esito positivo.
```
// create the AWS.Request object
var request = new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances();
// register a callback event handler
request.on('success', function(response) {
// log the successful data response
console.log(response.data);
});
// send the request
request.send();
```
Dopo aver chiamato il metodo `send` sul'oggetto `AWS.Request`, viene eseguito il gestore eventi quando l'oggetto di servizio riceve un oggetto `AWS.Response`.
Per ulteriori informazioni sull'`AWS.Request`oggetto, consulta [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)l'API Reference. Per ulteriori informazioni sull'`AWS.Response`oggetto, consulta [Utilizzo dell'oggetto di risposta](the-response-object.md) o [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html)consulta l'API Reference.
## Concatenazione di più callback
Puoi registrare più callback su qualsiasi oggetto di richiesta. È possibile registrare più callback per diversi eventi o per lo stesso evento. Puoi anche concatenare i callback come mostrato nell'esempio seguente.
```
request.
on('success', function(response) {
console.log("Success!");
}).
on('error', function(response) {
console.log("Error!");
}).
on('complete', function() {
console.log("Always!");
}).
send();
```
## Eventi di completamento degli oggetti di richiesta
L'oggetto `AWS.Request` genera questi eventi di completamento in base alla risposta di ciascun metodo dell'operazione di servizio:
+ `success`
+ `error`
+ `complete`
Puoi registrarsi una funzione di callback in risposta a uno qualsiasi di questi eventi. Per un elenco completo di tutti gli eventi relativi all'oggetto della richiesta, [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)consulta l'API Reference.
### Evento success
L'evento `success` viene generato in seguito a una risposta positiva ricevuta dall'oggetto di servizio. Ecco come si registra una funzione di callback per questo evento.
```
request.on('success', function(response) {
// event handler code
});
```
La risposta fornisce una proprietà `data` che contiene i dati di risposta serializzati dal servizio. Ad esempio, la seguente chiamata al `listBuckets` metodo dell'oggetto di servizio Amazon S3
```
s3.listBuckets.on('success', function(response) {
console.log(response.data);
}).send();
```
restituisce la risposta e quindi stampa i seguenti contenuti della proprietà `data` nella console.
```
{ Owner: { ID: '...', DisplayName: '...' },
Buckets:
[ { Name: 'someBucketName', CreationDate: someCreationDate },
{ Name: 'otherBucketName', CreationDate: otherCreationDate } ],
RequestId: '...' }
```
### Evento error
L'evento `error` viene generato in seguito a una risposta di errore ricevuta dall'oggetto di servizio. Ecco come si registra una funzione di callback per questo evento.
```
request.on('error', function(error, response) {
// event handling code
});
```
Quando viene generato l'evento `error`, il valore della proprietà `data` della risposta è `null` e la proprietà `error` contiene i dati dell'errore. L'oggetto `error` associato viene trasferito come primo parametro alla funzione di callback registrata. Ad esempio, il seguente codice:
```
s3.config.credentials.accessKeyId = 'invalid';
s3.listBuckets().on('error', function(error, response) {
console.log(error);
}).send();
```
restituisce l'errore e quindi stampa i seguenti dati dell'errore nella console.
```
{ code: 'Forbidden', message: null }
```
### Evento complete
L'evento `complete` viene generato al termine della chiamata a un oggetto di servizio, indipendentemente dal fatto che la chiamata abbia esito positivo o negativo. Ecco come si registra una funzione di callback per questo evento.
```
request.on('complete', function(response) {
// event handler code
});
```
Utilizza il callback dell'evento `complete` per gestire qualsiasi pulizia delle richieste che deve essere eseguita indipendentemente dall'esito positivo o negativo. Se utilizzi i dati di risposta all'interno di un callback per l'evento `complete`, verifica le proprietà `response.data` o `response.error` prima di tentare di accedervi, come mostrato nell'esempio seguente.
```
request.on('complete', function(response) {
if (response.error) {
// an error occurred, handle it
} else {
// we can use response.data here
}
}).send();
```
## Eventi HTTP degli oggetti di richiesta
L'oggetto `AWS.Request` genera questi eventi HTTP in base alla risposta di ciascun metodo dell'operazione di servizio:
+ `httpHeaders`
+ `httpData`
+ `httpUploadProgress`
+ `httpDownloadProgress`
+ `httpError`
+ `httpDone`
Puoi registrarsi una funzione di callback in risposta a uno qualsiasi di questi eventi. Per un elenco completo di tutti gli eventi relativi all'oggetto della richiesta, consulta [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)l'API Reference.
### Evento httpHeaders
L'evento `httpHeaders` viene generato quando vengono inviate le intestazioni dal server remoto. Ecco come si registra una funzione di callback per questo evento.
```
request.on('httpHeaders', function(statusCode, headers, response) {
// event handling code
});
```
Il parametro `statusCode` della funzione di callback è il codice di stato HTTP. Il parametro `headers` contiene le intestazioni di risposta.
### Evento httpData
L'evento `httpData` viene generato per eseguire lo streaming dei pacchetti di dati di risposta dal servizio. Ecco come si registra una funzione di callback per questo evento.
```
request.on('httpData', function(chunk, response) {
// event handling code
});
```
Questo evento viene in genere utilizzato per ricevere risposte di grandi dimensioni in blocchi quando il caricamento dell'intera risposta in memoria non è una soluzione pratica. Questo evento ha un parametro `chunk` aggiuntivo che contiene una parte dei dati effettivi dal server.
Se registri un callback per l'evento `httpData`, la proprietà `data` della risposta contiene l'intero output serializzato per la richiesta. Devi rimuovere il listener `httpData` predefinito se non disponi dell'overhead di analisi e memoria extra per i gestori incorporati.
### Gli httpUploadProgress ed httpDownloadProgress eventi
L'evento `httpUploadProgress` viene generato quando la richiesta HTTP ha caricato più dati. Allo stesso modo, l'evento `httpDownloadProgress` viene generato quando la richiesta HTTP ha scaricato più dati. Ecco come si registra una funzione di callback per questi eventi.
```
request.on('httpUploadProgress', function(progress, response) {
// event handling code
})
.on('httpDownloadProgress', function(progress, response) {
// event handling code
});
```
Il parametro `progress` della funzione di callback contiene un oggetto con i byte caricati e totali della richiesta.
### Evento httpError
L'evento `httpError` viene generato quando la richiesta HTTP ha esito negativo. Ecco come si registra una funzione di callback per questo evento.
```
request.on('httpError', function(error, response) {
// event handling code
});
```
Il parametro `error` della funzione di callback contiene l'errore che è stato generato.
### Evento httpDone
L'evento `httpDone` viene generato quando il server termina l'invio di dati. Ecco come si registra una funzione di callback per questo evento.
```
request.on('httpDone', function(response) {
// event handling code
});
```
# Utilizzo di async/await
È possibile utilizzare lo `async/await` schema nelle chiamate a AWS SDK per JavaScript. La maggior parte delle funzioni che accettano un callback non restituiscono una promessa. Poiché si utilizzano solo `await` funzioni che restituiscono una promessa, per utilizzare lo `async/await` schema è necessario concatenare il `.promise()` metodo alla fine della chiamata e rimuovere il callback.
L'esempio seguente utilizza async/await per elencare tutte le tabelle Amazon DynamoDB in. `us-west-2`
```
var AWS = require("aws-sdk");
//Create an Amazon DynamoDB client service object.
dbClient = new AWS.DynamoDB({ region: "us-west-2" });
// Call DynamoDB to list existing tables
const run = async () => {
try {
const results = await dbClient.listTables({}).promise();
console.log(results.TableNames.join("\n"));
} catch (err) {
console.error(err);
}
};
run();
```
**Nota**
Non tutti i browser supportano async/await. Vedi [Funzioni asincrone](https://caniuse.com/#feat=async-functions) per un elenco di browser supportati. async/await
# Usare Promises JavaScript
Il metodo `AWS.Request.promise` fornisce un modo per chiamare un'operazione di servizio e gestire il flusso asincrono invece di utilizzare i callback. In Node.js e negli script del browser, viene restituito un oggetto `AWS.Request` quando viene chiamata un'operazione di servizio senza una funzione di callback. Puoi chiamare il metodo `send` della richiesta per effettuare la chiamata di servizio.
Tuttavia, `AWS.Request.promise` avvia immediatamente la chiamata di servizio e restituisce una promessa soddisfatta con la proprietà `data` della risposta o respinta con la proprietà `error` della risposta.
```
var request = new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances();
// create the promise object
var promise = request.promise();
// handle promise's fulfilled/rejected states
promise.then(
function(data) {
/* process the data */
},
function(error) {
/* handle the error */
}
);
```
L'esempio seguente restituisce una promessa soddisfatta con un oggetto `data` o respinta con un oggetto `error`. Utilizzando le promesse, un singolo callback non è responsabile per il rilevamento degli errori. Al contrario, il callback corretto viene chiamato in base all'esito positivo o negativo di una richiesta.
```
var s3 = new AWS.S3({apiVersion: '2006-03-01', region: 'us-west-2'});
var params = {
Bucket: 'bucket',
Key: 'example2.txt',
Body: 'Uploaded text using the promise-based method!'
};
var putObjectPromise = s3.putObject(params).promise();
putObjectPromise.then(function(data) {
console.log('Success');
}).catch(function(err) {
console.log(err);
});
```
## Coordinamento di più promesse
In alcune situazioni, il tuo codice deve effettuare più chiamate asincrone che richiedono un intervento solo quando sono state restituite tutte correttamente. Se gestisci tali chiamate singole al metodo asincrono con le promesse, puoi creare una promessa aggiuntiva che utilizza il metodo `all`. Questo metodo soddisfa questa promessa universale se e quando le promesse che trasferisci al metodo vengono soddisfatte. Alla funzione di callback viene trasferito una matrice dei valori delle promesse trasferite al metodo `all`.
Nell'esempio seguente, una AWS Lambda funzione deve effettuare tre chiamate asincrone ad Amazon DynamoDB, ma può essere completata solo dopo aver soddisfatto le promesse per ogni chiamata.
```
Promise.all([firstPromise, secondPromise, thirdPromise]).then(function(values) {
console.log("Value 0 is " + values[0].toString);
console.log("Value 1 is " + values[1].toString);
console.log("Value 2 is " + values[2].toString);
// return the result to the caller of the Lambda function
callback(null, values);
});
```
## Supporto del browser e di Node.js per le promesse
Il supporto per JavaScript le promesse native (ECMAScript 2015) dipende dal JavaScript motore e dalla versione in cui viene eseguito il codice. Per determinare il supporto per le JavaScript promesse in ogni ambiente in cui il codice deve essere eseguito, consulta la [Tabella ECMAScript di compatibilità](https://compat-table.github.io/compat-table/es6/) su. GitHub
## Utilizzo di altre implementazioni di promesse
Oltre all'implementazione nativa di Promise nel ECMAScript 2015, puoi anche utilizzare librerie di promesse di terze parti, tra cui:
+ [bluebird](http://bluebirdjs.com)
+ [RSVP](https://github.com/tildeio/rsvp.js/)
+ [Q](https://github.com/kriskowal/q)
Queste librerie di promesse opzionali possono essere utili se hai bisogno che il codice venga eseguito in ambienti che non supportano l'implementazione nativa di promise nel ECMAScript 5 e nel ECMAScript 2015.
Per utilizzare una libreria di promesse di terze parti, imposta una dipendenza per le promesse sull'SDK chiamando il metodo `setPromisesDependency` dell'oggetto di configurazione globale. Negli script del browser, assicurati di caricare la libreria di promesse di terze parti prima di caricare l'SDK. Nell'esempio seguente, l'SDK è configurato per utilizzare l'implementazione nella libreria di promesse bluebird.
```
AWS.config.setPromisesDependency(require('bluebird'));
```
Per tornare a utilizzare l'implementazione nativa di promise del JavaScript motore, `setPromisesDependency` richiama, passando un nome di libreria `null` anziché un nome di libreria.
# Utilizzo dell'oggetto di risposta
Una volta chiamato, un metodo dell'oggetto di servizio restituisce un oggetto `AWS.Response` trasferendolo alla tua funzione di callback. Accedi ai contenuti della risposta attraverso le proprietà dell'oggetto `AWS.Response`. Esistono due proprietà dell'oggetto `AWS.Response` che utilizzi per accedere ai contenuti della risposta:
+ Proprietà `data`
+ Proprietà `error`
Quando utilizzi il meccanismo di callback standard, queste due proprietà vengono fornite come parametri sulla funzione di callback anonimo, come illustrato nell'esempio seguente.
```
function(error, data) {
if (error) {
// error handling code
console.log(error);
} else {
// data handling code
console.log(data);
}
}
```
## Accesso ai dati restituiti nell'oggetto di risposta
La proprietà `data` dell'oggetto `AWS.Response` contiene i dati serializzati restituiti dalla richiesta di servizio. Quando la richiesta ha esito positivo, la proprietà `data` include un oggetto contenente una mappa per i dati restituiti. La proprietà `data` può essere null se si verifica un errore.
Ecco un esempio di chiamata al `getItem` metodo di una tabella DynamoDB per recuperare il nome di un file di immagine da utilizzare come parte di un gioco.
```
// Initialize parameters needed to call DynamoDB
var slotParams = {
Key : {'slotPosition' : {N: '0'}},
TableName : 'slotWheels',
ProjectionExpression: 'imageFile'
};
// prepare request object for call to DynamoDB
var request = new AWS.DynamoDB({region: 'us-west-2', apiVersion: '2012-08-10'}).getItem(slotParams);
// log the name of the image file to load in the slot machine
request.on('success', function(response) {
// logs a value like "cherries.jpg" returned from DynamoDB
console.log(response.data.Item.imageFile.S);
});
// submit DynamoDB request
request.send();
```
Per questo esempio, la tabella DynamoDB è una ricerca di immagini che mostrano i risultati del pull di una slot machine come specificato dai parametri in. `slotParams`
Dopo una chiamata riuscita del `getItem` metodo, la `data` proprietà dell'`AWS.Response`oggetto contiene un `Item` oggetto restituito da DynamoDB. Puoi accedere ai dati restituiti in base al parametro `ProjectionExpression` della richiesta, che in questo caso indica il membro `imageFile` dell'oggetto `Item`. Poiché il membro `imageFile` contiene un valore di stringa, puoi accedere al nome file dell'immagine stessa attraverso il valore del membro figlio `S` di `imageFile`.
## Paging tramite dati restituiti
A volte il contenuto della proprietà `data` restituito da una richiesta di servizio si estende su più pagine. Puoi accedere alla successiva pagina di dati chiamando il metodo `response.nextPage`. Questo metodo invia una nuova richiesta. La risposta della richiesta può essere acquisita con un callback o con i listener di errore e di operazione riuscita.
Puoi verificare se i dati restituiti da una richiesta di servizio includono pagine di dati aggiuntive chiamando il metodo `response.hasNextPage`. Questo metodo restituisce un valore booleano per indicare se la chiamata `response.nextPage` restituisce dati aggiuntivi.
```
s3.listObjects({Bucket: 'bucket'}).on('success', function handlePage(response) {
// do something with response.data
if (response.hasNextPage()) {
response.nextPage().on('success', handlePage).send();
}
}).send();
```
## Accesso alle informazioni sugli errori da un oggetto di risposta
La proprietà `error` dell'oggetto `AWS.Response` contiene i dati dell'errore disponibili in caso di errore di servizio o di trasferimento. L'errore restituito presenta il seguente formato.
```
{ code: 'SHORT_UNIQUE_ERROR_CODE', message: 'a descriptive error message' }
```
Se si verifica un errore, il valore della proprietà `data` è `null`. Se gestisci eventi che possono essere in uno stato di errore, controlla sempre se la proprietà `error` è stata impostata prima di tentare di accedere al valore della proprietà `data`.
## Accesso all'oggetto di richiesta originario
La proprietà `request` fornisce l'accesso all'oggetto `AWS.Request` originario. Può essere utile fare riferimento all'oggetto `AWS.Request` originario per accedere ai parametri originali inviati. Nell'esempio seguente, la proprietà `request` viene utilizzata per accedere al parametro `Key` della richiesta di servizio originale.
```
s3.getObject({Bucket: 'bucket', Key: 'key'}).on('success', function(response) {
console.log("Key was", response.request.params.Key);
}).send();
```
# Utilizzo di JSON
JSON è un formato per lo scambio di dati leggibile sia dall'uomo sia da un computer. Sebbene il nome JSON sia l'acronimo di *JavaScript Object Notation*, il formato di JSON è indipendente da qualsiasi linguaggio di programmazione.
L'SDK for JavaScript utilizza JSON per inviare dati agli oggetti di servizio quando si effettuano richieste e riceve dati dagli oggetti di servizio come JSON. Per ulteriori informazioni su JSON, consulta [json.org](https://json.org).
![\[Formato generale e parti di JSON.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v2/developer-guide/images/json-format.png)
JSON rappresenta i dati in due modi:
+ Un *oggetto*, una raccolta non ordinata di coppie nome-valore. Un oggetto viene definito all'interno di parentesi graffe sinistra (`{`) e destra (`}`). Ogni coppia nome-valore inizia con il nome, seguita dai due punti e dal valore. Le coppie nome-valore sono separate da virgole.
+ Una *matrice*, che è un insieme ordinato di valori. Una matrice viene definita all'interno di parentesi quadre sinistra (`[`) e destra (`]`). Gli elementi nella matrice sono separati da virgole.
Ecco un esempio di un oggetto JSON che contiene una matrice di oggetti in cui gli oggetti rappresentano le carte in un gioco di carte. Ogni carta è definita da due coppie nome-valore, una che specifica un valore univoco per identificare quella carta e un'altra che specifica un URL che punta all'immagine della carta corrispondente.
```
var cards = [{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"}];
```
## JSON come parametri dell'oggetto di servizio
Ecco un esempio di JSON semplice utilizzato per definire i parametri di una chiamata a un oggetto del servizio Lambda.
```
var pullParams = {
FunctionName : 'slotPull',
InvocationType : 'RequestResponse',
LogType : 'None'
};
```
L'oggetto `pullParams` è definito da tre coppie nome-valore, separate da virgole e racchiuse fra parentesi graffe sinistra e destra. Quando si forniscono i parametri a una chiamata al metodo dell'oggetto di servizio, i nomi vengono determinati dai nomi dei parametri per il metodo dell'oggetto di servizio che si intende chiamare. Quando si richiama una funzione Lambda`FunctionName`,`InvocationType`, `LogType` e sono i parametri utilizzati per chiamare il metodo su un oggetto `invoke` del servizio Lambda.
Quando si passano parametri a una chiamata al metodo dell'oggetto servizio, fornite l'oggetto JSON alla chiamata al metodo, come illustrato nel seguente esempio di richiamo di una funzione Lambda.
```
lambda = new AWS.Lambda({region: 'us-west-2', apiVersion: '2015-03-31'});
// create JSON object for service call parameters
var pullParams = {
FunctionName : 'slotPull',
InvocationType : 'RequestResponse',
LogType : 'None'
};
// invoke Lambda function, passing JSON object
lambda.invoke(pullParams, function(err, data) {
if (err) {
console.log(err);
} else {
console.log(data);
}
});
```
## Restituzione dei dati come JSON
JSON fornisce un modo standard per trasferire i dati tra le parti di un'applicazione che devono inviare più valori allo stesso tempo. I metodi delle classi client nell'API restituiscono in genere JSON nel parametro `data` trasferito alle relative funzioni di callback. Ad esempio, ecco una chiamata al `getBucketCors` metodo della classe client Amazon S3.
```
// call S3 to retrieve CORS configuration for selected bucket
s3.getBucketCors(bucketParams, function(err, data) {
if (err) {
console.log(err);
} else if (data) {
console.log(JSON.stringify(data));
}
});
```
Il valore di `data` è un oggetto JSON, in questo esempio JSON che descrive la configurazione CORS corrente per un bucket Amazon S3 specificato.
```
{
"CORSRules": [
{
"AllowedHeaders":["*"],
"AllowedMethods":["POST","GET","PUT","DELETE","HEAD"],
"AllowedOrigins":["*"],
"ExposeHeaders":[],
"MaxAgeSeconds":3000
}
]
}
```
# Riprova la strategia nella v2 AWS SDK per JavaScript
Numerosi componenti di una rete, ad esempio server DNS, switch, sistemi di bilanciamento del carico e altri, possono generare errori in qualsiasi fase del ciclo di vita di una richiesta specifica. La tecnica che viene generalmente utilizzata per gestire queste risposte di errore in un ambiente di rete consiste nell'implementare nuovi tentativi nell'applicazione client. Questa tecnica aumenta l'affidabilità dell'applicazione e riduce i costi operativi per lo sviluppatore. AWS SDKs implementa una logica di ripetizione automatica per le tue AWS richieste.
## Comportamento esponenziale dei tentativi basato sul backoff
La AWS SDK per JavaScript v2 implementa la logica di riprova utilizzando il backoff [esponenziale](https://aws.amazon.com/builders-library/timeouts-retries-and-backoff-with-jitter/#Jitter) con jitter completo per un migliore controllo del flusso. L'idea che sottende al backoff esponenziale è di utilizzare attese progressivamente più lunghe tra i tentativi per le risposte di errore consecutive. Il jitter (ritardo randomizzato) viene utilizzato per prevenire collisioni successive.
### Test del ritardo tra tentativi in v2
Per testare il ritardo di ripetizione nella v2, il codice in [node\$1 modules/aws-sdk/lib/event \$1listeners.js](https://github.com/aws/aws-sdk-js/blob/master/lib/event_listeners.js#L588) è stato aggiornato al valore presente `console.log` nella variabile delay come segue:
```
// delay < 0 is a signal from customBackoff to skip retries
if (willRetry && delay >= 0) {
resp.error = null;
console.log('retry delay: ' + delay);
setTimeout(done, delay);
} else {
done();
}
```
#### Ritardi nei tentativi con la configurazione predefinita
Puoi testare il ritardo per qualsiasi operazione sui client SDK AWS. Chiamiamo `listTables` l'operazione su un client DynamoDB utilizzando il seguente codice:
```
import AWS from "aws-sdk";
const region = "us-east-1";
const client = new AWS.DynamoDB({ region });
await client.listTables({}).promise();
```
Per testare i nuovi tentativi, eseguiamo la simulazione disconnettendo Internet `NetworkingError` dal dispositivo su cui è in esecuzione il codice di test. Puoi anche configurare il proxy per restituire un errore personalizzato.
Durante l'esecuzione del codice, puoi vedere il ritardo tra i tentativi utilizzando il backoff esponenziale con jitter come segue:
```
retry delay: 7.39361151766359
retry delay: 9.0672860785882
retry delay: 134.89340825668168
retry delay: 398.53559817403965
retry delay: 523.8076165896343
retry delay: 1323.8789643058465
```
Poiché retry utilizza il jitter, otterrete valori diversi nell'esecuzione del codice di esempio.
#### Ritenta i ritardi con una base personalizzata
La AWS SDK per JavaScript v2 consente di passare un numero base personalizzato di millisecondi da utilizzare nel backoff esponenziale per i nuovi tentativi di operazione. Il valore predefinito è 100 ms per tutti i servizi tranne DynamoDB, dove il valore predefinito è 50 ms.
Testiamo i nuovi tentativi con una base personalizzata di 1000 ms nel modo seguente:
```
...
const client = new AWS.DynamoDB({ region, retryDelayOptions: { base: 1000 } });
...
```
Effettuiamo la simulazione `NetworkingError` disconnettendo Internet dal dispositivo su cui è in esecuzione il codice di test. Si può notare che i valori del ritardo tra tentativi sono più alti rispetto all'esecuzione precedente, in cui l'impostazione predefinita era di 50 o 100 ms.
```
retry delay: 356.2841549924913
retry delay: 1183.5216495444615
retry delay: 2266.997988094194
retry delay: 1244.6948354966453
retry delay: 4200.323030066383
```
Poiché retry utilizza il jitter, otterrete valori diversi nell'esecuzione del codice di esempio.
#### Riprova i ritardi con un algoritmo di backoff personalizzato
La AWS SDK per JavaScript v2 consente inoltre di passare una funzione di backoff personalizzata che accetta un conteggio dei tentativi e un errore e restituisce la quantità di tempo di ritardo in millisecondi. Se il risultato è un valore negativo diverso da zero, non verranno effettuati ulteriori tentativi.
Testiamo la funzione di backoff personalizzata che utilizza un backoff lineare con un valore base di 200 ms come segue:
```
...
const client = new AWS.DynamoDB({
region,
retryDelayOptions: { customBackoff: (count, error) => (count + 1) * 200 },
});
...
```
Effettuiamo la simulazione `NetworkingError` disconnettendo Internet dal dispositivo su cui è in esecuzione il codice di test. Come puoi vedere, i valori del ritardo tra tentativi sono multipli di 200.
```
retry delay: 200
retry delay: 400
retry delay: 600
retry delay: 800
retry delay: 1000
```