Die AWS SDK für JavaScript Version 2 ist erreicht end-of-support. Wir empfehlen Ihnen, auf [AWS SDK für JavaScript Version 3](https://docs.aws.amazon.com//sdk-for-javascript/v3/developer-guide/) zu migrieren. Weitere Einzelheiten und Informationen zur Migration finden Sie in dieser [Ankündigung](https://aws.amazon.com/blogs//developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/).
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Arbeiten mit Diensten im SDK für JavaScript
Das AWS SDK für JavaScript bietet Zugriff auf Dienste, die es über eine Sammlung von Client-Klassen unterstützt. Von diesen Client-Klassen erstellen Sie Service-Schnittstellenobjekte, die allgemein als *Service-Objekte* bezeichnet werden. Jeder unterstützte AWS Dienst verfügt über eine oder mehrere Clientklassen, die eine einfache Nutzung APIs von Servicefunktionen und Ressourcen ermöglichen. Amazon DynamoDB ist beispielsweise über APIs die `AWS.DynamoDB` Klasse verfügbar.
Die über das SDK bereitgestellten Dienste JavaScript folgen dem Anfrage-Antwort-Muster, um Nachrichten mit aufrufenden Anwendungen auszutauschen. In diesem Muster sendet der Code, der einen Dienst aufruft, eine HTTP/HTTPS Anfrage an einen Endpunkt für den Dienst. Die Anforderung enthält die erforderlichen Parameter für einen erfolgreichen Aufruf der spezifischen Funktion. Der Service, der aufgerufen wird, generiert eine Antwort, die an den Anforderer zurückgesendet wird. Die Antwort enthält Daten, wenn die Operation erfolgreich war, oder Fehlerinformationen, wenn sie nicht erfolgreich war.
![\[Das Dienstmuster für die Antwort auf AWS Anfragen.\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v2/developer-guide/images/request-response.png)
Das Aufrufen eines AWS Dienstes umfasst den gesamten Anforderungs- und Antwortzyklus eines Vorgangs an einem Dienstobjekt, einschließlich aller Wiederholungsversuche. Eine Anforderung wird durch das `AWS.Request`-Objekt im SDK gekapselt. Die Antwort wird im SDK durch das `AWS.Response` Objekt gekapselt, das dem Anforderer über eine von mehreren Techniken zur Verfügung gestellt wird, z. B. durch eine Callback-Funktion oder eine Zusage. JavaScript
**Topics**
+ [Erstellen und Aufrufen von Service-Objekten](creating-and-calling-service-objects.md)
+ [AWS SDK für JavaScript Aufrufe protokollieren](logging-sdk-calls.md)
+ [Asynchrones Aufrufen von Services](calling-services-asynchronously.md)
+ [Verwenden des Response-Objekts](the-response-object.md)
+ [Arbeiten mit JSON](working-with-json.md)
+ [Strategie in der Version 2 wiederholen AWS SDK für JavaScript](retry-strategy.md)
# Erstellen und Aufrufen von Service-Objekten
Die JavaScript API unterstützt die meisten verfügbaren AWS Dienste. Jede Serviceklasse in der JavaScript API bietet Zugriff auf jeden API-Aufruf in ihrem Dienst. Weitere Informationen zu Serviceklassen, Vorgängen und Parametern in der JavaScript API finden Sie in der [API-Referenz](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/index.html).
Wenn Sie das SDK in Node.js verwenden, fügen Sie Ihrer Anwendung das SDK-Paket mit `require` hinzu, das Unterstützung für alle aktuellen Services bietet.
```
var AWS = require('aws-sdk');
```
Wenn Sie das SDK mit einem Browser verwenden JavaScript, laden Sie das SDK-Paket mithilfe des von AWS gehosteten SDK-Pakets in Ihre Browserskripte. Fügen Sie das folgende `
```
[Die aktuelle SDK\$1VERSION\$1NUMBER finden Sie in der API-Referenz für das SDK im API-Referenzhandbuch. JavaScript AWS SDK für JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/)
Das standardmäßige gehostete SDK-Paket bietet Unterstützung für eine Teilmenge der verfügbaren Dienste. AWS Eine Liste der Standard-Services im gehosteten SDK-Paket für den Browser finden Sie im Abschnitt über [Unterstützte Services](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/#Supported_Services) in der API-Referenz. Sie können das SDK mit anderen Services verwenden, wenn die CORS-Sicherheitsüberprüfung deaktiviert ist. In diesem Fall können Sie eine benutzerdefinierte Version des SDKs erstellen, um die von Ihnen benötigten zusätzlichen Services einzuschließen. Weitere Informationen zum Erstellen einer benutzerdefinierten Version des SDKs finden Sie unter [Erstellen des SDK für Browser](building-sdk-for-browsers.md).
## Laden einzelner Services mit der require-Funktion
Wenn Sie das SDK für JavaScript wie zuvor beschrieben benötigen, wird das gesamte SDK in Ihren Code aufgenommen. Sie können aber auch nur die einzelnen Services mit der require-Funktion laden, die von Ihrem Code verwendet werden. Betrachten Sie den folgenden Code, der verwendet wurde, um ein Amazon S3 S3-Serviceobjekt zu erstellen.
```
// 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'});
```
Im vorherigen Beispiel gibt die `require`-Funktion das gesamte SDK an. Die Menge an Code, die über das Netzwerk übertragen werden muss, sowie der Speicheraufwand Ihres Codes wären erheblich geringer, wenn nur der Teil des SDK enthalten wäre, den Sie für den Amazon S3 S3-Service benötigen. Um einen einzelnen Service zu laden, rufen Sie die `require`-Funktion wie beschrieben auf, einschließlich des Service-Konstruktors in Kleinbuchstaben.
```
require('aws-sdk/clients/SERVICE');
```
So sieht der Code zum Erstellen des vorherigen Amazon S3 S3-Serviceobjekts aus, wenn er nur den Amazon S3 S3-Teil des SDK enthält.
```
// 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}
});
```
Sie können immer noch auf den globalen AWS Namespace zugreifen, ohne dass jeder Service damit verbunden ist.
```
require('aws-sdk/global');
```
Dies ist eine nützliche Technik, wenn dieselbe Konfiguration auf mehrere individuelle Services angewendet werden soll, um z. B. dieselben Anmeldeinformationen allen Services bereitzustellen. Das Laden einzelner Services mit der require-Funktion sollte die Ladezeit und die Speichernutzung in Node.js verringern. Wenn Sie diesen Vorgang mit einem Bündelungs-Tool wie z. B. Browserify oder Webpack abgeschlossen haben, weist das SDK nur einen Bruchteil der vollständigen Größe auf, weil nur einzelne Service-Ergebnisse mit der require-Funktion geladen wurden. Dies hilft in Umgebungen mit begrenztem Speicher oder Festplattenspeicher, wie z. B. bei einem IoT-Gerät oder bei einer Lambda-Funktion.
## Erstellen von Service-Objekten
Um über die JavaScript API auf Servicefunktionen zuzugreifen, erstellen Sie zunächst ein *Serviceobjekt, über das* Sie auf eine Reihe von Funktionen zugreifen, die von der zugrunde liegenden Clientklasse bereitgestellt werden. In der Regel wird für jeden Service eine Client-Klasse bereitgestellt. Manche Services verteilen den Zugriff auf ihre Funktionen jedoch auf mehrere Client-Klassen.
Zum Verwenden einer Funktion müssen Sie eine Instance der Klasse erstellen, die Zugriff auf diese Funktion bietet. Das folgende Beispiel zeigt die Erstellung eines Serviceobjekts für DynamoDB aus der `AWS.DynamoDB` Client-Klasse.
```
var dynamodb = new AWS.DynamoDB({apiVersion: '2012-08-10'});
```
Standardmäßig wird ein Service-Objekt mit den globalen Einstellungen konfiguriert, mit denen auch das SDK konfiguriert wird. Sie können jedoch ein Service-Objekt mit Laufzeit-Konfigurationsdaten konfigurieren, die für das Service-Objekt spezifisch sind. Service-spezifische Konfigurationsdaten werden nach den globalen Konfigurationseinstellungen angewendet.
Im folgenden Beispiel wird ein Amazon EC2-Serviceobjekt mit einer Konfiguration für eine bestimmte Region erstellt, verwendet aber ansonsten die globale Konfiguration.
```
var ec2 = new AWS.EC2({region: 'us-west-2', apiVersion: '2014-10-01'});
```
Es werden nicht nur servicespezifische Konfigurationen unterstützt, die auf einzelne Service-Objekte angewendet werden. Sie können auch servicespezifische Konfigurationen auf alle neu erstellten Service-Objekte einer bestimmten Klasse anwenden. Um beispielsweise alle Serviceobjekte, die mit der Amazon EC2 EC2-Klasse erstellt wurden, für die Verwendung der Region USA West (Oregon) (`us-west-2`) zu konfigurieren, fügen Sie dem `AWS.config` globalen Konfigurationsobjekt Folgendes hinzu.
```
AWS.config.ec2 = {region: 'us-west-2', apiVersion: '2016-04-01'};
```
## Sperren der API-Version eines Service-Objekts
Sie können ein Service-Objekt fest an eine bestimmte API-Version eines Service binden, indem Sie die `apiVersion`-Option beim Erstellen des Objekts angeben. Im folgenden Beispiel wird ein DynamoDB-Dienstobjekt erstellt, das an eine bestimmte API-Version gebunden ist.
```
var dynamodb = new AWS.DynamoDB({apiVersion: '2011-12-05'});
```
Weitere Informationen zum Sperren der API-Version eines Service-Objekts finden Sie unter [Schützen der API-Versionen](locking-api-versions.md).
## Angeben von Service-Objektparametern
Wenn Sie eine Methode eines Service-Objekts aufrufen, übergeben Sie die JSON-Parameter wie für die API erforderlich. Um beispielsweise in Amazon S3 ein Objekt für einen bestimmten Bucket und Schlüssel abzurufen, übergeben Sie die folgenden Parameter an die `getObject` Methode. Weitere Informationen zum Übergeben von JSON-Parametern finden Sie unter [Arbeiten mit JSON](working-with-json.md).
```
s3.getObject({Bucket: 'bucketName', Key: 'keyName'});
```
Weitere Informationen zu Amazon S3 S3-Parametern finden Sie [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html)in der API-Referenz.
Darüber hinaus können Sie Werte an einzelne Parameter binden, wenn ein Service-Objekt mit dem `params`-Parameter erstellt wird. Der Wert des `params`-Parameters von Service-Objekten ist eine Zuordnung, mit der mindestens ein durch das Service-Objekt definierter Parameterwert angegeben wird. Das folgende Beispiel zeigt den `Bucket` Parameter eines Amazon S3 S3-Serviceobjekts, das an einen Bucket mit dem Namen gebunden ist`amzn-s3-demo-bucket`.
```
var s3bucket = new AWS.S3({params: {Bucket: 'amzn-s3-demo-bucket'}, apiVersion: '2006-03-01' });
```
Indem das Service-Objekt an einen Bucket gebunden wird, behandelt das `s3bucket`-Service-Objekt den `amzn-s3-demo-bucket`-Parameterwert als Standardwert, der nicht länger für nachfolgende Operationen angegeben werden muss. Alle gebundenen Parameterwerte werden ignoriert, wenn das Objekt für Operationen verwendet wird, bei denen der Parameterwert nicht anwendbar ist. Sie können diesen gebundenen Parameter beim Aufrufen des Service-Objekts überschreiben, indem Sie einen neuen Wert angeben.
```
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'});
```
Detaillierte Informationen zu den verfügbaren Parametern für die einzelnen Methoden finden Sie in der API-Referenz.
# AWS SDK für JavaScript Aufrufe protokollieren
Der AWS SDK für JavaScript ist mit einem integrierten Logger ausgestattet, sodass Sie API-Aufrufe protokollieren können, die Sie mit dem SDK für JavaScript tätigen.
Fügen Sie Ihrem Code die folgende Anweisung hinzu, um den Logger zu aktivieren und die Protokolleinträge in der Konsole zu drucken.
```
AWS.config.logger = console;
```
Hier finden Sie ein Beispiel für die Protokollausgabe.
```
[AWS s3 200 0.185s 0 retries] createMultipartUpload({ Bucket: 'amzn-s3-demo-logging-bucket', Key: 'issues_1704' })
```
## Verwenden eines Drittanbieter-Loggers
Sie können auch einen Drittanbieter-Logger verwenden, sofern dieser über `log()`- oder `write()`-Operationen verfügt, um Daten in eine Protokolldatei oder auf einen Server zu schreiben. Sie müssen Ihren benutzerdefinierten Logger gemäß den Anweisungen installieren und einrichten, bevor Sie ihn mit dem SDK für verwenden können. JavaScript
Ein Logger, den Sie entweder in Browser-Skripts oder in Node.js nutzen können, ist logplease. In Node.js können Sie logplease so konfigurieren, dass Protokolleinträge in einer Protokolldatei geschrieben werden. Sie können ihn auch mit webpack verwenden.
Legen Sie bei Verwendung eines Drittanbieter-Loggers alle Optionen fest, bevor Sie ihn `AWS.Config.logger` zuweisen. Der folgende Beispiel-Code gibt eine externe Protokolldatei an und legt die Protokollebene für logplease fest.
```
// 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;
```
Weitere Informationen zu Logplease finden Sie im [Logplease Simple JavaScript Logger on](https://github.com/haadcode/logplease). GitHub
# Asynchrones Aufrufen von Services
Alle über das SDK ausgeführten Anforderungen sind asynchron. Dies ist wichtig, wenn Sie Browserskripte schreiben. JavaScript Die Ausführung in einem Webbrowser hat normalerweise nur einen einzigen Ausführungsthread. Nach einem asynchronen Aufruf eines AWS Dienstes wird das Browserskript weiter ausgeführt und kann dabei versuchen, Code auszuführen, der von diesem asynchronen Ergebnis abhängt, bevor er zurückkehrt.
Zu asynchronen Aufrufen eines AWS Dienstes gehört die Verwaltung dieser Aufrufe, sodass Ihr Code nicht versucht, Daten zu verwenden, bevor die Daten verfügbar sind. Die Themen in diesem Abschnitt erklären, wie wichtig es ist, asynchrone Aufrufe zu verwalten, und erläutern die verschiedenen Verwaltungstechniken im Detail.
**Topics**
+ [Verwalten von asynchronen Aufrufen](making-asynchronous-calls.md)
+ [Verwenden einer anonymen Callback-Funktion](using-a-callback-function.md)
+ [Verwenden eines Anforderungsobjektereignis-Listeners](using-a-response-event-handler.md)
+ [Verwenden von async/await](using-async-await.md)
+ [Promises verwenden JavaScript](using-promises.md)
# Verwalten von asynchronen Aufrufen
Beispiel: Die Startseite einer E-Commerce-Website bietet wiederkehrenden Kunden die Möglichkeit, sich anzumelden. Die Kunden, die sich anmelden, profitieren u. a. davon, dass sich die Website nach der Anmeldung an ihre besonderen Präferenzen anpasst. Dafür ist Folgendes erforderlich:
1. Der Kunde muss sich anmelden und mit seinen Anmeldedaten validiert werden.
1. Die Präferenzen des Kunden werden von einer Kundendatenbank angefordert.
1. Die Datenbank stellt die Präferenzen des Kunden bereit, mit denen die Website angepasst wird, bevor die Seite geladen wird.
Wenn diese Aufgaben synchron ausgeführt werden, muss jede abgeschlossen sein, bevor die nächste starten kann. Die Webseite kann nicht vollständig geladen werden, bis die Präferenzen des Kunden von der Datenbank zurückgegeben wurden. Nachdem die Datenbankabfrage an den Server gesendet wurde, kann der Empfang der Kundendaten jedoch aufgrund von Netzwerkengpässen, besonders hohem Datenverkehr oder einer schlechten Verbindung eines Mobilgeräts sich verzögern oder sogar fehlschlagen.
Rufen Sie die Datenbank asynchron auf, um zu verhindern, dass die Website unter solchen Bedingungen einfriert. Nachdem der Datenbankaufruf ausgeführt und Ihre asynchrone Anforderung gesendet wurde, wird Ihr Code wie erwartet weiter ausgeführt. Wenn Sie die Antwort eines asynchronen Aufrufs nicht ordnungsgemäß verwalten, versucht Ihr Code möglicherweise im Fall, dass diese Daten noch nicht verfügbar sind, Informationen zu verwenden, die er von der Datenbank zurückerwartet.
![\[Darstellung des Unterschieds zwischen synchroner und asynchroner Ausführung\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v2/developer-guide/images/async-vs-sync.png)
# Verwenden einer anonymen Callback-Funktion
Jede Service-Objektmethode, die ein `AWS.Request`-Objekt erstellt, kann eine anonyme Callback-Funktion als letzten Parameter annehmen. Die Signatur dieser Callback-Funktion lautet:
```
function(error, data) {
// callback handling code
}
```
Diese Callback-Funktion wird ausgeführt, wenn entweder eine erfolgreiche Antwort oder Fehlerdaten zurückgegeben werden. Wenn der Methodenaufruf erfolgreich war, wird der Callback-Funktion der Inhalt der Antwort im `data`-Parameter bereitgestellt. Wenn der Aufruf nicht erfolgreich war, werden die Details über den Fehler im `error`-Parameter angegeben.
In der Regel prüft der Code innerhalb der Callback-Funktion, ob ein Fehler vorliegt, den er verarbeitet, wenn ein Fehler zurückgegeben wird. Wenn kein Fehler zurückgegeben wird, ruft der Code die Antwortdaten vom `data`-Parameter ab. Die grundlegende Form der Callback-Funktion sieht wie folgt aus.
```
function(error, data) {
if (error) {
// error handling code
console.log(error);
} else {
// data handling code
console.log(data);
}
}
```
Im vorherigen Beispiel werden die Details zum Fehler oder die zurückgegebenen Daten in der Konsole protokolliert. Hier finden Sie ein Beispiel für eine Callback-Funktion, die als Teil des Aufrufs einer Methode in einem Service-Objekt zurückgegeben wird.
```
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
}
});
```
## Zugreifen auf die Anforderungs- und Antwortobjekte
Innerhalb der Callback-Funktion `this` bezieht sich das JavaScript Schlüsselwort auf das zugrunde liegende `AWS.Response` Objekt für die meisten Dienste. Im folgenden Beispiel wird die `httpResponse`-Eigenschaft eines `AWS.Response`-Objekts innerhalb einer Callback-Funktion für die Protokollierung der unformatierten Antwortdaten und -Header verwendet, um das Debugging zu erleichtern.
```
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
}
});
```
Da das `AWS.Response`-Objekt über eine `Request`-Eigenschaft verfügt, die das `AWS.Request`-Objekt enthält, das vom ursprünglichen Methodenaufruf gesendet wurde, können Sie außerdem auf die Details der Anforderung zugreifen.
# Verwenden eines Anforderungsobjektereignis-Listeners
Wenn Sie keine anonyme Callback-Funktion erstellen und als Parameter übergeben, wenn Sie eine Service-Objektmethode aufrufen, generiert der Methodenaufruf ein `AWS.Request`-Objekt, das mit dessen `send`-Methode manuell gesendet werden muss.
Zum Verarbeiten der Antwort müssen Sie einen Ereignis-Listener für das `AWS.Request`-Objekt erstellen, um eine Callback-Funktion für den Methodenaufruf zu registrieren. Das folgende Beispiel zeigt, wie das `AWS.Request`-Objekt zum Aufrufen einer Service-Objektmethode und der Ereignis-Listener für die erfolgreiche Rückgabe erstellt werden.
```
// 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();
```
Nachdem die `send`-Methode im `AWS.Request`-Objekt aufgerufen wurde, wird der Ereignis-Handler ausgeführt, wenn das Service-Objekt ein `AWS.Response`-Objekt erhält.
Weitere Informationen zu dem `AWS.Request` Objekt finden Sie [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)in der API-Referenz. Weitere Informationen über das `AWS.Response` Objekt finden Sie unter [Verwenden des Response-Objekts](the-response-object.md) oder [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html)in der API-Referenz.
## Verketten von mehreren Callbacks
Sie können mehrere Callbacks für jedes Anforderungsobjekt registrieren. Mehrere Callbacks können für verschiedene Ereignisse oder dasselbe Ereignis registriert werden. Sie können Callbacks auch verketten, wie im folgenden Beispiel gezeigt wird.
```
request.
on('success', function(response) {
console.log("Success!");
}).
on('error', function(response) {
console.log("Error!");
}).
on('complete', function() {
console.log("Always!");
}).
send();
```
## Anforderungsobjekt-Fertigstellungsereignis
Das `AWS.Request`-Objekt löst diese Fertigstellungsereignisse basierend auf der Antwort der einzelnen Service-Operationsmethoden aus:
+ `success`
+ `error`
+ `complete`
Sie können eine Callback-Funktion als Reaktion auf jedes dieser Ereignisse registrieren. Eine vollständige Liste aller Ereignisse mit Anforderungsobjekten finden Sie [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)in der API-Referenz.
### Das Erfolgsereignis
Das `success`-Ereignis wird ausgelöst, wenn eine erfolgreiche Antwort vom Service-Objekt erhalten wird. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('success', function(response) {
// event handler code
});
```
Die Antwort enthält eine `data`-Eigenschaft mit den serialisierten Antwortdaten vom Service. Zum Beispiel der folgende Aufruf der `listBuckets` Methode des Amazon S3-Serviceobjekts
```
s3.listBuckets.on('success', function(response) {
console.log(response.data);
}).send();
```
gibt die Antwort zurück. Anschließend wird der folgende Inhalt der `data`-Eigenschaft an die Konsole ausgegeben.
```
{ Owner: { ID: '...', DisplayName: '...' },
Buckets:
[ { Name: 'someBucketName', CreationDate: someCreationDate },
{ Name: 'otherBucketName', CreationDate: otherCreationDate } ],
RequestId: '...' }
```
### Das error-Ereignis
Das `error`-Ereignis wird ausgelöst, wenn eine Fehlerantwort vom Service-Objekt erhalten wird. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('error', function(error, response) {
// event handling code
});
```
Wenn das `error`-Ereignis ausgelöst wird, ist der Wert der `data`-Eigenschaft der Antwort `null` und die `error`-Eigenschaft enthält die Fehlerdaten. Das zugehörige `error`-Objekt wird als erster Parameter an die registrierte Callback-Funktion übergeben. Der folgende Code beispielsweise:
```
s3.config.credentials.accessKeyId = 'invalid';
s3.listBuckets().on('error', function(error, response) {
console.log(error);
}).send();
```
gibt den Fehler zurück. Anschließend werden die folgenden Fehlerdaten an die Konsole ausgegeben.
```
{ code: 'Forbidden', message: null }
```
### Das complete-Ereignis
Das `complete`-Ereignis wird ausgelöst, wenn ein Service-Objektaufruf unabhängig davon, ob der Aufruf erfolgreich war oder nicht, abgeschlossen wurde. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('complete', function(response) {
// event handler code
});
```
Verwenden Sie den `complete`-Ereignis-Callback, um die einzelnen Anforderungsbereinigungen zu verarbeiten, die unabhängig von Erfolg oder Fehlern ausgeführt werden müssen. Wenn Sie Antwortdaten in einer Callback-Funktion für das `complete`-Ereignis verwenden, überprüfen Sie zuerst die Eigenschaften `response.data` oder `response.error`, bevor Sie versuchen, auf eine der beiden zuzugreifen. Dies wird in folgendem Beispiel gezeigt.
```
request.on('complete', function(response) {
if (response.error) {
// an error occurred, handle it
} else {
// we can use response.data here
}
}).send();
```
## HTTP-Ereignisse für Anforderungsobjekte
Das `AWS.Request`-Objekt löst die folgenden HTTP-Ereignisse basierend auf der Antwort der einzelnen Service-Operationsmethoden aus:
+ `httpHeaders`
+ `httpData`
+ `httpUploadProgress`
+ `httpDownloadProgress`
+ `httpError`
+ `httpDone`
Sie können eine Callback-Funktion als Reaktion auf jedes dieser Ereignisse registrieren. Eine vollständige Liste aller Ereignisse mit Anforderungsobjekten finden Sie [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)in der API-Referenz.
### Das httpHeaders-Ereignis
Das `httpHeaders`-Ereignis wird ausgelöst, wenn Header vom Remote-Server gesendet werden. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('httpHeaders', function(statusCode, headers, response) {
// event handling code
});
```
Der `statusCode`-Parameter der Callback-Funktion ist der HTTP-Statuscode. Der `headers`-Parameter enthält die Antwort-Header.
### Das httpData-Ereignis
Das `httpData`-Ereignis wird ausgelöst, um Antwortdatenpakete vom Service zu streamen. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('httpData', function(chunk, response) {
// event handling code
});
```
Dieses Ereignis wird in der Regel für den Empfang großer Antwortblöcke verwendet, wenn das Laden der gesamten Antwort in den Arbeitsspeicher nicht praktikabel ist. Dieses Ereignis verfügt über einen zusätzlichen `chunk`-Parameter, der einen Teil der eigentlichen Daten vom Server enthält.
Wenn Sie einen Callback für das `httpData`-Ereignis registrieren, enthält die `data`-Eigenschaft der Antwort die gesamte serialisierte Ausgabe für die Anforderung. Sie müssen den standardmäßigen `httpData`-Listener entfernen, wenn Sie nicht über den zusätzlichen Analyse- und Speichermehraufwand für die integrierten Handler verfügen.
### Die httpUploadProgress und httpDownloadProgress Ereignisse
Das `httpUploadProgress`-Ereignis wird ausgelöst, wenn die HTTP-Anforderung mehr Daten hochgeladen hat. Entsprechend wird das `httpDownloadProgress`-Ereignis ausgelöst, wenn die HTTP-Anforderung mehr Daten heruntergeladen hat. Hier sehen Sie, wie Sie eine Callback-Funktion für diese Ereignisse registrieren.
```
request.on('httpUploadProgress', function(progress, response) {
// event handling code
})
.on('httpDownloadProgress', function(progress, response) {
// event handling code
});
```
Der `progress`-Parameter der Callback-Funktion enthält ein Objekt mit den geladenen und gesamten Bytes der Anforderung.
### Das httpError-Ereignis
Das `httpError`-Ereignis wird ausgelöst, wenn die HTTP-Anforderung fehlschlägt. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('httpError', function(error, response) {
// event handling code
});
```
Der `error`-Parameter der Callback-Funktion enthält die Fehler, die ausgelöst wurden.
### Das httpDone-Ereignis
Das `httpDone`-Ereignis wird ausgelöst, wenn der Server das Senden von Daten abgeschlossen hat. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('httpDone', function(response) {
// event handling code
});
```
# Verwenden von async/await
Sie können das `async/await` Muster in Ihren Aufrufen an die verwenden AWS SDK für JavaScript. Die meisten Funktionen, die einen Rückruf annehmen, geben kein Versprechen zurück. Da Sie nur `await` Funktionen verwenden, die ein Versprechen zurückgeben, müssen Sie, um das `async/await` Muster zu verwenden, die `.promise()` Methode bis zum Ende Ihres Aufrufs verketten und den Callback entfernen.
Das folgende Beispiel verwendet async/await , um all Ihre Amazon DynamoDB-Tabellen in aufzulisten. `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();
```
**Anmerkung**
Nicht alle Browser unterstützen Async/Await. Eine Liste der Browser, die Unterstützung bieten, finden Sie unter [Async-Funktionen](https://caniuse.com/#feat=async-functions). async/await
# Promises verwenden JavaScript
Mit der `AWS.Request.promise`-Methode haben Sie die Möglichkeit, eine Service-Operation aufzurufen und asynchrone Flows zu verwalten, anstatt Callbacks zu verwenden. In Node.js und Browser-Skripts wird ein `AWS.Request`-Objekt zurückgegeben, wenn eine Service-Operation ohne eine Callback-Funktion aufgerufen wird. Sie können die `send`-Methode der Anforderung aufrufen, um den Service aufzurufen.
`AWS.Request.promise` startet jedoch sofort den Service-Aufruf und gibt ein Promis zurück. Dieses wird entweder mit der `data`-Eigenschaft der Antwort erfüllt oder mit der `error`-Eigenschaft der Antwort abgelehnt.
```
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 */
}
);
```
Das nächste Beispiel gibt ein Promis zurück, das mit einem `data`-Objekt erfüllt oder mit einem `error`-Objekt abgelehnt wird. Beim Verwenden von Promises ist ein einzelner Callback nicht dafür zuständig, Fehler zu erkennen. Stattdessen wird der richtige Callback basierend auf dem Erfolg oder Misserfolg einer Anforderung aufgerufen.
```
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);
});
```
## Koordinieren mehrerer Promises
In einigen Fällen muss Ihr Code mehrere asynchrone Aufrufe ausführen, die nur dann eine Aktion erfordern, wenn alle erfolgreich zurückgegeben wurden. Wenn Sie diese einzelnen asynchronen Methodenaufrufe mit Promises verwalten, können Sie ein zusätzliches Promise erstellen, das die `all`-Methode verwendet. Diese Methode erfüllt dieses übergeordnete Promise-Objekt, falls und wenn das an die Methode übergebene Array der Promises erfüllt ist. Die Callback-Funktion wird als Array von Werten der Promises übergeben, die an die `all`-Methode übergeben werden.
Im folgenden Beispiel muss eine AWS Lambda Funktion drei asynchrone Aufrufe an Amazon DynamoDB tätigen, kann aber erst abgeschlossen werden, nachdem die Zusagen für jeden Aufruf erfüllt wurden.
```
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);
});
```
## Browser- und Node.js-Unterstützung für Promises
Die Support für native JavaScript Promises (ECMAScript 2015) hängt von der JavaScript Engine und Version ab, in der Ihr Code ausgeführt wird. Informationen zur Unterstützung von JavaScript Promises in den einzelnen Umgebungen, in denen Ihr Code ausgeführt werden muss, finden Sie in der [ECMAScriptKompatibilitätstabelle unter.](https://compat-table.github.io/compat-table/es6/) GitHub
## Verwenden anderer Promise-Implementierungen
Zusätzlich zur systemeigenen Promise-Implementierung im ECMAScript Jahr 2015 können Sie auch Promise-Bibliotheken von Drittanbietern verwenden, darunter:
+ [Bluebird](http://bluebirdjs.com)
+ [RSVP](https://github.com/tildeio/rsvp.js/)
+ [Q](https://github.com/kriskowal/q)
Diese optionalen Promise-Bibliotheken können nützlich sein, wenn Sie Ihren Code in Umgebungen ausführen möchten, die die native Promise-Implementierung in ECMAScript 5 und ECMAScript 2015 nicht unterstützen.
Wenn Sie die Promise-Bibliothek eines Drittanbieters verwenden möchten, legen Sie eine Promise-Abhängigkeit im SDK fest, indem Sie die `setPromisesDependency`-Methode des globalen Konfigurationsobjekts aufrufen. Stellen Sie in Browser-Skripts sicher, dass die Promise-Drittanbieterbibliothek vor dem SDK geladen wird. Im folgenden Beispiel wird das SDK so konfiguriert, dass es die Implementierung in der Bluebird-Promise-Bibliothek verwendet.
```
AWS.config.setPromisesDependency(require('bluebird'));
```
Um wieder die native Promise-Implementierung der JavaScript Engine zu verwenden, rufen Sie `setPromisesDependency` erneut auf und übergeben Sie `null` statt eines Bibliotheksnamens einen.
# Verwenden des Response-Objekts
Nachdem eine Service-Objektmethode aufgerufen wurde, gibt diese ein `AWS.Response`-Objekt zurück, indem es an Ihre Callback-Funktion übergeben wird. Sie greifen auf den Inhalt der Antwort über die Eigenschaften des `AWS.Response`-Objekts zu. Für den Zugriff auf den Inhalt der Antwort gibt es zwei Eigenschaften des `AWS.Response`-Objekts:
+ `data` Eigenschaft
+ `error` Eigenschaft
Wenn Sie den standardmäßigen Callback-Mechanismus verwenden, werden diese beiden Eigenschaften als Parameter in der anonymen Callback-Funktion bereitgestellt, wie das folgende Beispiel zeigt.
```
function(error, data) {
if (error) {
// error handling code
console.log(error);
} else {
// data handling code
console.log(data);
}
}
```
## Zugreifen auf im Response-Objekt zurückgegebene Daten
Die `data`-Eigenschaft des `AWS.Response`-Objekts enthält die serialisierten Daten, die von der Service-Anforderung zurückgegeben werden. Wenn die Anforderung erfolgreich ist, enthält die `data`-Eigenschaft ein Objekt mit einer Zuordnung zu den zurückgegebenen Daten. Die `data`-Eigenschaft kann Null sein, wenn ein Fehler auftritt.
Hier ist ein Beispiel für den Aufruf der `getItem` Methode einer DynamoDB-Tabelle, um den Dateinamen einer Bilddatei abzurufen, die als Teil eines Spiels verwendet werden soll.
```
// 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();
```
In diesem Beispiel ist die DynamoDB-Tabelle eine Suche nach Bildern, die die Ergebnisse eines Spielautomaten-Pulls zeigen, wie durch die Parameter in angegeben. `slotParams`
Bei einem erfolgreichen Aufruf der `getItem` Methode enthält die `data` Eigenschaft des `AWS.Response` Objekts ein von DynamoDB zurückgegebenes `Item` Objekt. Auf die zurückgegebenen Daten wird gemäß dem `ProjectionExpression`-Parameter der Anforderung zugegriffen, in diesem Fall also dem `imageFile`-Mitglied des `Item`-Objekts. Da das `imageFile`-Mitglied einen Zeichenfolgenwert enthält, können Sie auf den Dateinamen des Bildes über den Wert des untergeordneten Mitglieds `S` von `imageFile` zugreifen.
## Durchblättern von zurückgegebenen Daten
Manchmal umfasst der Inhalt der von einer Service-Anforderung zurückgegebenen `data`-Eigenschaft mehrere Seiten. Sie können auf die nächste Datenseite mit dem Aufruf der `response.nextPage`-Methode zugreifen. Diese Methode sendet eine neue Anforderung. Die Antwort auf die Anforderung kann entweder mit einem Callback oder einem Listener für Erfolg oder Fehler erfasst werden.
Sie können prüfen, ob die von einer Service-Anforderung zurückgegebenen Daten zusätzliche Datenseiten haben, indem Sie die `response.hasNextPage`-Methode aufrufen. Diese Methode gibt einen booleschen Wert zurück, der angibt, ob der Aufruf von `response.nextPage` zusätzliche Daten zurückgibt.
```
s3.listObjects({Bucket: 'bucket'}).on('success', function handlePage(response) {
// do something with response.data
if (response.hasNextPage()) {
response.nextPage().on('success', handlePage).send();
}
}).send();
```
## Zugreifen auf Fehlerinformationen aus einem Antwortobjekt
Die `error`-Eigenschaft des `AWS.Response`-Objekts enthält die verfügbaren Fehlerdaten bei einem Service-Fehler oder einem Übertragungsfehler. Der zurückgegebene Fehler hat das folgende Format.
```
{ code: 'SHORT_UNIQUE_ERROR_CODE', message: 'a descriptive error message' }
```
Im Fall eines Fehlers ist der Wert der `data`-Eigenschaft gleich `null`. Wenn Sie Ereignisse verarbeiten, die sich in einem Fehlerzustand befinden können, überprüfen Sie immer, ob die `error`-Eigenschaft festgelegt wurde, bevor Sie versuchen, auf den Wert der `data`-Eigenschaft zuzugreifen.
## Zugreifen auf das ursprüngliche Anforderungsobjekt
Die `request`-Eigenschaft bietet Zugriff auf das ursprüngliche `AWS.Request`-Objekt. Es kann nützlich sein, Bezug auf das ursprüngliche `AWS.Request`-Objekt zu nehmen, um auf die ursprünglichen Parameter zuzugreifen, die es gesendet hat. Im folgenden Beispiel wird die `request`-Eigenschaft verwendet, um auf den `Key`-Parameter der ursprünglichen Service-Anforderung zuzugreifen.
```
s3.getObject({Bucket: 'bucket', Key: 'key'}).on('success', function(response) {
console.log("Key was", response.request.params.Key);
}).send();
```
# Arbeiten mit JSON
JSON ist sowohl visuell lesbares als auch ein maschinenlesbares Format für den Datenaustausch. Der Name JSON ist zwar eine Abkürzung für *JavaScript Object Notation*, das Format von JSON ist jedoch unabhängig von jeder Programmiersprache.
Das SDK für JavaScript verwendet JSON, um bei Anfragen Daten an Serviceobjekte zu senden, und empfängt Daten von Serviceobjekten als JSON. Weitere Informationen über JSON finden Sie auf der Website [json.org](https://json.org).
![\[Darstellen des Formats und der Bestandteile von JSON\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v2/developer-guide/images/json-format.png)
JSON stellt Daten auf zwei Arten dar:
+ Ein *Objekt*, bei dem es sich um eine ungeordnete Sammlung von Name-Wert-Paaren handelt. Ein Objekt wird innerhalb von zwei Klammern (`{` und `}`) definiert. Jedes Name-Wert-Paar beginnt mit dem Namen, gefolgt von einem Doppelpunkt und dem Wert. Name-Wert-Paare werden durch Kommas voneinander getrennt.
+ Ein *Array*, bei dem es sich um eine geordnete Sammlung von Werten handelt. Ein Array wird innerhalb von zwei Klammern (`[` und `]`) definiert. Elemente im Array werden durch Kommas voneinander getrennt.
Hier sehen Sie ein Beispiel für ein JSON-Objekt mit einem Array von Objekten, in dem die Objekte Karten in einem Kartenspiel darstellen. Jede Karte wird durch zwei Namen-Wert-Paare definiert. Eines davon gibt einen eindeutigen Wert an, um die Karte zu identifizieren, und das andere gibt die URL an, die auf das Kartenbild verweist.
```
var cards = [{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"}];
```
## JSON als Service-Objektparameter
Hier ist ein Beispiel für einfaches JSON, das verwendet wird, um die Parameter eines Aufrufs eines Lambda-Serviceobjekts zu definieren.
```
var pullParams = {
FunctionName : 'slotPull',
InvocationType : 'RequestResponse',
LogType : 'None'
};
```
Das `pullParams`-Objekt wird durch drei Name-Wert-Paare definiert, die durch Kommas innerhalb einer linken und einer rechten Klammer getrennt sind. Beim Bereitstellen von Parametern für einen Service-Objektmethodenaufruf werden die Namen durch die Parameternamen für die Service-Objektmethode bestimmt, die Sie aufrufen möchten. Beim Aufrufen einer Lambda-Funktion sind,, und die Parameter `FunctionName``InvocationType`, die verwendet `LogType` werden, um die `invoke` Methode für ein Lambda-Serviceobjekt aufzurufen.
Wenn Sie Parameter an einen Methodenaufruf eines Serviceobjekts übergeben, stellen Sie das JSON-Objekt für den Methodenaufruf bereit, wie im folgenden Beispiel für den Aufruf einer Lambda-Funktion gezeigt.
```
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);
}
});
```
## Zurückgeben von Daten als JSON
JSON bietet eine standardisierte Methode, um Daten zwischen Teilen eine Anwendung zu übermitteln, die mehrere Werte gleichzeitig senden müssen. Die Methoden von Client-Klassen in der API geben gewöhnlich JSON im `data`-Parameter zurück, der an ihre Callback-Funktionen übergeben wird. Hier ist zum Beispiel ein Aufruf der `getBucketCors` Methode der Amazon S3 S3-Clientklasse.
```
// 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));
}
});
```
Der Wert von `data` ist ein JSON-Objekt, in diesem Beispiel JSON, das die aktuelle CORS-Konfiguration für einen angegebenen Amazon S3 S3-Bucket beschreibt.
```
{
"CORSRules": [
{
"AllowedHeaders":["*"],
"AllowedMethods":["POST","GET","PUT","DELETE","HEAD"],
"AllowedOrigins":["*"],
"ExposeHeaders":[],
"MaxAgeSeconds":3000
}
]
}
```
# Strategie in der Version 2 wiederholen AWS SDK für JavaScript
Zahlreiche Komponenten im Netzwerk, wie z. B. DNS-Server, Switches und Load Balancer, können irgendwann im Lebenszyklus einer Anforderung Fehler generieren. Die übliche Methode zum Umgang mit diesen Fehlermeldungen in einer vernetzten Umgebung besteht darin, Wiederholversuche in der Client-Anwendung zu implementieren. Diese Technik erhöht die Zuverlässigkeit der Anwendung und senkt die Betriebskosten für den Entwickler. AWS SDKs implementieren Sie eine automatisierte Wiederholungslogik für Ihre AWS Anfragen.
## Exponentielles Backoff-basiertes Wiederholungsverhalten
Die AWS SDK für JavaScript Version v2 implementiert eine Wiederholungslogik, die [exponentielles Backoff mit vollem Jitter verwendet, um den Datenfluss besser kontrollieren](https://aws.amazon.com/builders-library/timeouts-retries-and-backoff-with-jitter/#Jitter) zu können. Die Idee hinter dem exponentiellen Backoff ist, bei aufeinander folgenden Fehlermeldungen progressiv längere Wartezeiten zwischen den Wiederholversuchen zu verwenden. Der Jitter (randomisierte Verzögerung) wird verwendet, um aufeinanderfolgende Kollisionen zu verhindern.
### Die Verzögerung beim erneuten Versuch wird in Version 2 getestet
Um die Wiederholungsverzögerung in v2 zu testen, wurde der Code in [node\$1 modules/aws-sdk/lib/event \$1listeners.js](https://github.com/aws/aws-sdk-js/blob/master/lib/event_listeners.js#L588) wie folgt auf `console.log` den Wert aktualisiert, der in der variablen Verzögerung vorhanden ist:
```
// 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();
}
```
#### Verzögerungen bei Wiederholungsversuchen mit der Standardkonfiguration
Sie können die Verzögerung für jeden Vorgang auf AWS-SDK-Clients testen. Wir rufen `listTables` Operation auf einem DynamoDB-Client mit dem folgenden Code auf:
```
import AWS from "aws-sdk";
const region = "us-east-1";
const client = new AWS.DynamoDB({ region });
await client.listTables({}).promise();
```
Um Wiederholungen zu testen, simulieren wir, `NetworkingError` indem wir die Internetverbindung von dem Gerät trennen, auf dem der Testcode ausgeführt wird. Sie können den Proxy auch so einrichten, dass er einen benutzerdefinierten Fehler zurückgibt.
Wenn Sie den Code ausführen, können Sie die Verzögerung beim erneuten Versuch mithilfe eines exponentiellen Backoffs mit Jitter wie folgt feststellen:
```
retry delay: 7.39361151766359
retry delay: 9.0672860785882
retry delay: 134.89340825668168
retry delay: 398.53559817403965
retry delay: 523.8076165896343
retry delay: 1323.8789643058465
```
Da Retry Jitter verwendet, erhalten Sie bei der Ausführung des Beispielcodes unterschiedliche Werte.
#### Wiederholungsverzögerungen mit benutzerdefinierter Basis
Die AWS SDK für JavaScript Version v2 ermöglicht die Übergabe einer benutzerdefinierten Basiszahl von Millisekunden, die im exponentiellen Backoff für Wiederholungsversuche verwendet werden kann. Der Standardwert ist 100 ms für alle Dienste außer DynamoDB, wo der Standardwert 50 ms beträgt.
Wir testen Wiederholungen mit einer benutzerdefinierten Basis von 1000 ms wie folgt:
```
...
const client = new AWS.DynamoDB({ region, retryDelayOptions: { base: 1000 } });
...
```
Wir simulieren, `NetworkingError` indem wir das Internet von dem Gerät trennen, auf dem der Testcode ausgeführt wird. Sie können sehen, dass die Werte für die Wiederholungsverzögerung höher sind als bei der vorherigen Ausführung, bei der die Standardeinstellung 50 oder 100 ms betrug.
```
retry delay: 356.2841549924913
retry delay: 1183.5216495444615
retry delay: 2266.997988094194
retry delay: 1244.6948354966453
retry delay: 4200.323030066383
```
Da bei der Wiederholung Jitter verwendet wird, erhalten Sie bei der Ausführung des Beispielcodes unterschiedliche Werte.
#### Wiederholungsverzögerungen mit benutzerdefiniertem Backoff-Algorithmus
Die AWS SDK für JavaScript Version v2 ermöglicht auch die Übergabe einer benutzerdefinierten Backoff-Funktion, die Zählung und Fehler bei Wiederholungsversuchen akzeptiert und die Dauer der Verzögerung in Millisekunden zurückgibt. Wenn das Ergebnis ein negativer Wert ungleich Null ist, werden keine weiteren Wiederholungsversuche unternommen.
Wir testen die benutzerdefinierte Backoff-Funktion, die einen linearen Backoff mit einem Basiswert von 200 ms verwendet, wie folgt:
```
...
const client = new AWS.DynamoDB({
region,
retryDelayOptions: { customBackoff: (count, error) => (count + 1) * 200 },
});
...
```
Wir simulieren, `NetworkingError` indem wir das Internet von dem Gerät trennen, auf dem der Testcode ausgeführt wird. Sie können sehen, dass die Werte für die Verzögerung beim erneuten Versuch ein Vielfaches von 200 sind.
```
retry delay: 200
retry delay: 400
retry delay: 600
retry delay: 800
retry delay: 1000
```