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. # 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.