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à.
# Configurazione dell'SDK per JavaScript
Gli argomenti di questa sezione spiegano come installare l'SDK JavaScript per utilizzarlo nei browser Web e con Node.js. Mostra inoltre come caricare l'SDK per poter accedere ai servizi Web supportati dall'SDK.
**Nota**
Gli sviluppatori di React Native dovrebbero AWS Amplify usare per creare nuovi progetti su AWS. Consulta l'[aws-sdk-react-native](https://github.com/amazon-archives/aws-sdk-react-native)archivio per i dettagli.
**Topics**
+ [Prerequisiti](jssdk-prerequisites.md)
+ [Installazione dell'SDK per JavaScript](installing-jssdk.md)
+ [Caricamento dell'SDK per JavaScript](loading-the-jssdk.md)
+ [Aggiornamento dell'SDK dalla versione 1 JavaScript](upgrading-from-v1.md)
# Prerequisiti
Prima di utilizzare il AWS SDK per JavaScript, stabilite se il codice deve essere eseguito in Node.js o nei browser Web. Successivamente, esegui queste operazioni:
+ Per Node.js, installa Node.js sui tuoi server, se non è già installato.
+ Per i browser Web, identifica le versioni del browser che è necessario supportare.
**Topics**
+ [Configurazione di un ambiente AWS Node.js](setting-up-node.md)
+ [Browser Web supportati](browsers-supported.md)
# Configurazione di un ambiente AWS Node.js
Per configurare un ambiente AWS Node.js in cui eseguire l'applicazione, utilizzate uno dei seguenti metodi:
+ Scegli un'Amazon Machine Image (AMI) con Node.js preinstallato e crea un'istanza Amazon EC2 utilizzando quell'AMI. Quando crei la tua istanza Amazon EC2, scegli il tuo AMI tra. Marketplace AWS Marketplace AWS Cerca Node.js e scegli un'opzione AMI che includa una versione di Node.js (32 o 64 bit) preinstallata.
+ Crea un'istanza Amazon EC2 e installa Node.js su di essa. Per ulteriori informazioni su come installare Node.js su un'istanza Amazon Linux, consulta[Tutorial: configurazione di Node.js su un'istanza Amazon EC2](setting-up-node-on-ec2-instance.md).
+ Crea un ambiente serverless utilizzando AWS Lambda to run Node.js come funzione Lambda. Per ulteriori informazioni sull'utilizzo di Node.js all'interno di una funzione Lambda, consulta [Programming Model (Node.js)](https://docs.aws.amazon.com/lambda/latest/dg/programming-model.html) nella *AWS Lambda Developer* Guide.
+ Distribuisci la tua applicazione Node.js su. AWS Elastic Beanstalk*Per ulteriori informazioni sull'utilizzo di Node.js con Elastic Beanstalk[, consulta Deploying Node.js AWS Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_nodejs.html) Applications to nella Developer Guide.AWS Elastic Beanstalk *
# Browser Web supportati
L'SDK for JavaScript supporta tutti i browser Web moderni, incluse queste versioni minime:
****
| Browser | Versione |
| --- | --- |
| Google Chrome | 28.0\$1 |
| Mozilla Firefox | 26.0\$1 |
| Opera | 17.0\$1 |
| Microsoft Edge | 25.10\$1 |
| Windows Internet Explorer | N/D |
| Apple Safari | 5\$1 |
| Browser Android | 4.3\$1 |
**Nota**
I framework come AWS Amplify potrebbero non offrire lo stesso supporto per i browser dell'SDK. JavaScript Controlla la documentazione di ciascun framework per i dettagli.
# Installazione dell'SDK per JavaScript
Se e come installarla AWS SDK per JavaScript dipende dal fatto che il codice venga eseguito nei moduli Node.js o negli script del browser.
Non tutti i servizi sono immediatamente disponibili nell'SDK. [Per scoprire quali servizi sono attualmente supportati da AWS SDK per JavaScript, vedere https://github.com/aws/aws-sdk-js/.md blob/master/SERVICES](https://github.com/aws/aws-sdk-js/blob/master/SERVICES.md)
------
#### [ Node ]
Il modo preferito per installare AWS SDK per JavaScript for Node.js consiste nell'utilizzare [npm, il gestore di pacchetti Node.js](https://www.npmjs.com/). A tale scopo, digita quanto segue nella riga di comando.
```
npm install aws-sdk
```
Se viene visualizzato questo messaggio di errore:
```
npm WARN deprecated node-uuid@1.4.8: Use uuid module instead
```
Digita i seguenti comandi nella riga di comando:
```
npm uninstall --save node-uuid
npm install --save uuid
```
------
#### [ Browser ]
Non è necessario installare l'SDK per utilizzarlo negli script del browser. Puoi caricare il pacchetto SDK ospitato direttamente da Amazon Web Services con uno script nelle tue pagine HTML. Il pacchetto SDK ospitato supporta il sottoinsieme di AWS servizi che applicano la condivisione delle risorse tra le origini (CORS). Per ulteriori informazioni, consulta [Caricamento dell'SDK per JavaScript](loading-the-jssdk.md).
Puoi creare una build personalizzata dell'SDK in cui selezionare le versioni e i servizi Web specifici che desideri utilizzare. Quindi puoi scaricare il pacchetto SDK personalizzato per lo sviluppo locale ed eseguirne l'hosting per l'utilizzo da parte della tua applicazione. Per ulteriori informazioni sulla creazione di una build personalizzata dell'SDK, consulta [Creazione dell'SDK per i browser](building-sdk-for-browsers.md).
Puoi scaricare le versioni distribuibili minimizzate e non minimizzate della versione corrente da: AWS SDK per JavaScript GitHub
[https://github.com/aws/aws-sdk-js/tree/master/dist](https://github.com/aws/aws-sdk-js/tree/master/dist)
------
## Installazione mediante Bower
[Bower](https://bower.io) è un gestore di pacchetti per il Web. Dopo aver installato Bower, puoi utilizzarlo per installare l'SDK. Per installare l'SDK mediante Bower, digita il seguente comando in una finestra del terminale:
```
bower install aws-sdk-js
```
# Caricamento dell'SDK per JavaScript
La modalità di caricamento dell'SDK JavaScript dipende dal fatto che lo si stia caricando per eseguirlo in un browser Web o in Node.js.
Non tutti i servizi sono immediatamente disponibili nell'SDK. Per scoprire quali servizi sono attualmente supportati da AWS SDK per JavaScript, consulta [https://github.com/aws/aws-sdk-js/.md blob/master/SERVICES](https://github.com/aws/aws-sdk-js/blob/master/SERVICES.md)
------
#### [ Node.js ]
Dopo aver installato l'SDK, puoi caricare il AWS pacchetto nell'applicazione node utilizzando. `require`
```
var AWS = require('aws-sdk');
```
------
#### [ React Native ]
Per utilizzare l'SDK in un progetto React Native, installa prima l'SDK mediante npm:
```
npm install aws-sdk
```
Nella tua applicazione, fai riferimento alla versione dell'SDK compatibile con React Native utilizzando il seguente codice:
```
var AWS = require('aws-sdk/dist/aws-sdk-react-native');
```
------
#### [ Browser ]
Il modo più rapido per iniziare a usare l'SDK è caricare il pacchetto SDK ospitato direttamente da Amazon Web Services. A questo scopo, aggiungi un elemento `
```
[Per trovare l'attuale SDK\$1VERSION\$1NUMBER, consulta l'API Reference for the SDK disponibile nella API Reference Guide. JavaScript AWS SDK per JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/)
Una volta caricato nella tua pagina, l'SDK è disponibile dalla variabile globale `AWS` (o `window.AWS`).
Se raggruppi il tuo codice e le dipendenze del modulo mediante [browserify](http://browserify.org), puoi caricare l'SDK utilizzando `require`, in modo analogo a come si fa in Node.js.
------
# Aggiornamento dell'SDK dalla versione 1 JavaScript
Le seguenti note ti aiutano ad aggiornare l'SDK JavaScript dalla versione 1 alla versione 2.
## Conversione automatica dei tipi base64 e timestamp su input/output
L'SDK ora codifica e decodifica automaticamente i valori con codifica base64, nonché i valori timestamp, per conto dell'utente. Questa modifica interessa qualsiasi operazione in cui valori base64 o timestamp sono stati inviati tramite una richiesta o restituiti in una risposta che consente valori con codifica base64.
Il codice utente precedentemente convertito in base64 non è più necessario. I valori codificati come base64 vengono ora restituiti come buffer di oggetti da risposte del server e possono anche essere passati come buffer in entrata, Ad esempio, i seguenti parametri `SQS.sendMessage` della versione 1:
```
var params = {
MessageBody: 'Some Message',
MessageAttributes: {
attrName: {
DataType: 'Binary',
BinaryValue: new Buffer('example text').toString('base64')
}
}
};
```
Possono essere riscritti come segue.
```
var params = {
MessageBody: 'Some Message',
MessageAttributes: {
attrName: {
DataType: 'Binary',
BinaryValue: 'example text'
}
}
};
```
Ecco come viene letto il messaggio.
```
sqs.receiveMessage(params, function(err, data) {
// buf is
var buf = data.Messages[0].MessageAttributes.attrName.BinaryValue;
console.log(buf.toString()); // "example text"
});
```
## Response.data spostato. RequestId a Response.requestId
L'SDK ora archivia la richiesta IDs per tutti i servizi in una posizione coerente sull'`response`oggetto, anziché all'interno della proprietà. `response.data` Ciò migliora la coerenza tra i servizi che espongono la richiesta IDs in modi diversi. Si tratta inoltre di una modifica di rilievo che rinomina la proprietà `response.data.RequestId` in `response.requestId` (`this.requestId` all'interno di una funzione di callback).
Nel tuo codice, modifica quanto segue:
```
svc.operation(params, function (err, data) {
console.log('Request ID:', data.RequestId);
});
```
alla seguente:
```
svc.operation(params, function () {
console.log('Request ID:', this.requestId);
});
```
## Elementi wrapper esposti
Se utilizzi `AWS.ElastiCache`, `AWS.RDS` o `AWS.Redshift`, per alcune operazioni devi accedere alla risposta tramite la proprietà di output di livello superiore della risposta.
Ad esempio, il metodo `RDS.describeEngineDefaultParameters` utilizzato per restituire quanto segue.
```
{ Parameters: [ ... ] }
```
Ora restituisce il codice seguente.
```
{ EngineDefaults: { Parameters: [ ... ] } }
```
L'elenco delle operazioni interessate per ciascun servizio è riportato nella seguente tabella.
****
| Classe client | Operazioni |
| --- | --- |
| `AWS.ElastiCache` | `authorizeCacheSecurityGroupIngress` `createCacheCluster` `createCacheParameterGroup` `createCacheSecurityGroup` `createCacheSubnetGroup` `createReplicationGroup` `deleteCacheCluster` `deleteReplicationGroup` `describeEngineDefaultParameters` `modifyCacheCluster` `modifyCacheSubnetGroup` `modifyReplicationGroup` `purchaseReservedCacheNodesOffering` `rebootCacheCluster` `revokeCacheSecurityGroupIngress` |
| `AWS.RDS` | `addSourceIdentifierToSubscription` `authorizeDBSecurityGroupIngress` `copyDBSnapshot` `createDBInstance` `createDBInstanceReadReplica` `createDBParameterGroup` `createDBSecurityGroup` `createDBSnapshot` `createDBSubnetGroup` `createEventSubscription` `createOptionGroup` `deleteDBInstance` `deleteDBSnapshot` `deleteEventSubscription` `describeEngineDefaultParameters` `modifyDBInstance` `modifyDBSubnetGroup` `modifyEventSubscription` `modifyOptionGroup` `promoteReadReplica` `purchaseReservedDBInstancesOffering` `rebootDBInstance` `removeSourceIdentifierFromSubscription` `restoreDBInstanceFromDBSnapshot` `restoreDBInstanceToPointInTime` `revokeDBSecurityGroupIngress` |
| `AWS.Redshift` | `authorizeClusterSecurityGroupIngress` `authorizeSnapshotAccess` `copyClusterSnapshot` `createCluster` `createClusterParameterGroup` `createClusterSecurityGroup` `createClusterSnapshot` `createClusterSubnetGroup` `createEventSubscription` `createHsmClientCertificate` `createHsmConfiguration` `deleteCluster` `deleteClusterSnapshot` `describeDefaultClusterParameters` `disableSnapshotCopy` `enableSnapshotCopy` `modifyCluster` `modifyClusterSubnetGroup` `modifyEventSubscription` `modifySnapshotCopyRetentionPeriod` `purchaseReservedNodeOffering` `rebootCluster` `restoreFromClusterSnapshot` `revokeClusterSecurityGroupIngress` `revokeSnapshotAccess` `rotateEncryptionKey` |
## Proprietà client interrotte
Le proprietà `.Client` e `.client` sono state rimosse dagli oggetti di servizio. Se utilizzi la proprietà `.Client` su una classe di servizio o una proprietà `.client` su un'istanza dell'oggetto di servizio, rimuovi queste proprietà dal tuo codice.
Il codice seguente utilizzato con la versione 1 dell'SDK per: JavaScript
```
var sts = new AWS.STS.Client();
// or
var sts = new AWS.STS();
sts.client.operation(...);
```
Dovrebbe essere modificato come segue.
```
var sts = new AWS.STS();
sts.operation(...)
```