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.

Programmieren von Amazon DynamoDB mit JavaScript

Dieses Handbuch bietet Programmierern, die Amazon DynamoDB mit verwenden möchten, eine Orientierung. JavaScript Erfahren Sie mehr über die verfügbaren Abstraktionsebenen AWS SDK for JavaScript, die Konfiguration von Verbindungen, den Umgang mit Fehlern, die Definition von Wiederholungsrichtlinien, die Verwaltung von Keep-Alive und mehr.

Über AWS SDK for JavaScript

Das AWS SDK for JavaScript bietet Zugriff auf die AWS -Services Verwendung von Browserskripten oder Node.js. Diese Dokumentation konzentriert sich auf die neueste Version des SDK (V3). Die AWS SDK for JavaScript Version 3 wird von AWS als Open-Source-Projekt verwaltet, das auf GitHub gehostet wird. Probleme und Funktionsanfragen sind öffentlich und Sie können auf der Problemseite des GitHub Repositorys darauf zugreifen.

JavaScript V2 ähnelt V3, enthält jedoch Syntaxunterschiede. V3 ist modularer aufgebaut, was es einfacher macht, kleinere Abhängigkeiten zu versenden, und bietet erstklassigen TypeScript Support. Wir empfehlen, die neueste Version des SDK zu verwenden.

Verwenden von AWS SDK for JavaScript V3

Sie können das SDK mit dem Node Package Manager zu Ihrer Anwendung Node.js hinzufügen. Die folgenden Beispiele zeigen, wie Sie die gängigsten SDK-Pakete für die Arbeit mit DynamoDB hinzufügen.

Durch die Installation von Paketen werden Verweise auf den Abhängigkeitsbereich Ihrer package.json-Projektdatei hinzugefügt. Sie haben die Möglichkeit, die neuere ECMAScript-Modulsyntax zu verwenden. Weitere Informationen zu diesen beiden Ansätzen finden Sie im Abschnitt Überlegungen.

Zugreifen auf die JavaScript Dokumentation

Beginnen Sie mit der JavaScript Dokumentation mit den folgenden Ressourcen:

Abstraktionsebenen

Das SDK für JavaScript V3 hat einen Low-Level-Client (DynamoDBClient) und einen High-Level-Client (DynamoDBDocumentClient).

Low-Level-Client () DynamoDBClient

Der Low-Level-Client bietet keine zusätzlichen Abstraktionen gegenüber dem zugrunde liegenden Wire-Protokoll. Es gibt Ihnen die volle Kontrolle über alle Aspekte der Kommunikation, aber da es keine Abstraktionen gibt, müssen Sie beispielsweise Elementdefinitionen im DynamoDB-JSON-Format bereitstellen.

Wie das folgende Beispiel zeigt, müssen bei diesem Format Datentypen explizit angegeben werden. Ein S steht für einen Zeichenkettenwert und ein N steht für einen Zahlenwert. Zahlen auf der Leitung werden immer als Zeichenketten gesendet, die als Zahlentypen gekennzeichnet sind, um sicherzustellen, dass die Genauigkeit nicht beeinträchtigt wird. Die API-Aufrufe auf niedriger Ebene haben ein Benennungsmuster wie PutItemCommand undGetItemCommand.

Im folgenden Beispiel wird ein Low-Level-Client verwendet, der mithilfe von DynamoDB-JSON Item definiert ist:

const { DynamoDBClient, PutItemCommand } = require("@aws-sdk/client-dynamodb");

const client = new DynamoDBClient({});

async function addProduct() {
  const params = {
    TableName: "products",
    Item: {
      "id": { S: "Product01" },
      "description": { S: "Hiking Boots" },
      "category": { S: "footwear" },
      "sku": { S: "hiking-sku-01" },
      "size": { N: "9" }
    }
  };

  try {
    const data = await client.send(new PutItemCommand(params));
    console.log('result : ' + JSON.stringify(data));
  } catch (error) {
    console.error("Error:", error);
  }
}
addProduct();

High-Level-Client () DynamoDBDocumentClient

Der DynamoDB-Dokumentenclient auf hoher Ebene bietet integrierte Komfortfunktionen, z. B. macht das manuelle Marshalling von Daten überflüssig und ermöglicht direkte Lese- und Schreibvorgänge mithilfe von Standardobjekten. JavaScript Die Dokumentation für lib-dynamodb enthält eine Liste der Vorteile.

Um das zu instanziierenDynamoDBDocumentClient, konstruieren Sie ein Low-Level DynamoDBClient und umschließen Sie es dann mit einem. DynamoDBDocumentClient Die Benennungskonvention für Funktionen unterscheidet sich geringfügig zwischen den beiden Paketen. Beispielsweise verwendet das System auf niedriger Ebene, PutItemCommand während es auf höherer Ebene verwendet PutCommand wird. Durch die unterschiedlichen Namen können beide Funktionssätze im selben Kontext koexistieren, sodass Sie beide in demselben Skript kombinieren können.

const { DynamoDBClient } = require("@aws-sdk/client-dynamodb");
const { DynamoDBDocumentClient, PutCommand } = require("@aws-sdk/lib-dynamodb");

const client = new DynamoDBClient({});

const docClient = DynamoDBDocumentClient.from(client);

async function addProduct() {
  const params = {
    TableName: "products",
    Item: {
      id: "Product01",
      description: "Hiking Boots",
      category: "footwear",
      sku: "hiking-sku-01",
      size: 9,
    },
  };

  try {
    const data = await docClient.send(new PutCommand(params));
    console.log('result : ' + JSON.stringify(data));
  } catch (error) {
    console.error("Error:", error);
  }
}

addProduct();

Das Verwendungsmuster ist konsistent, wenn Sie Elemente mithilfe von API-Operationen wie GetItemQuery, oder Scan lesen.

Verwenden Sie die Marshall-Utility-Funktion

Sie können den Low-Level-Client und Marshall verwenden oder die Datentypen selbst unmarshallisieren. Das Utility-Paket util-dynamodb hat eine marshall() Utility-Funktion, die JSON akzeptiert und DynamoDB-JSON erzeugt, sowie eine unmarshall() Funktion, die das Gegenteil tut. Im folgenden Beispiel wird der Low-Level-Client verwendet, wobei das Datenmarshalling durch den Aufruf abgewickelt wird. marshall()

const { DynamoDBClient, PutItemCommand } = require("@aws-sdk/client-dynamodb");
const { marshall } = require("@aws-sdk/util-dynamodb");

const client = new DynamoDBClient({});

async function addProduct() {
  const params = {
    TableName: "products",
    Item: marshall({
      id: "Product01",
      description: "Hiking Boots",
      category: "footwear",
      sku: "hiking-sku-01",
      size: 9,
    }),
  };

  try {
    const data = await client.send(new PutItemCommand(params));
  } catch (error) {
    console.error("Error:", error);
  }
}
addProduct();

Artikel lesen

Um ein einzelnes Element aus DynamoDB zu lesen, verwenden Sie die GetItem API-Operation. Ähnlich wie beim PutItem Befehl haben Sie die Wahl, entweder den Low-Level-Client oder den High-Level-Document-Client zu verwenden. Das folgende Beispiel zeigt die Verwendung des High-Level-Document-Clients zum Abrufen eines Elements.

const { DynamoDBClient } = require("@aws-sdk/client-dynamodb");
const { DynamoDBDocumentClient, GetCommand } = require("@aws-sdk/lib-dynamodb");

const client = new DynamoDBClient({});

const docClient = DynamoDBDocumentClient.from(client);

async function getProduct() {
  const params = {
    TableName: "products",
    Key: {
      id: "Product01",
    },
  };

  try {
    const data = await docClient.send(new GetCommand(params));
    console.log('result : ' + JSON.stringify(data));
  } catch (error) {
    console.error("Error:", error);
  }
}

getProduct();

Verwenden Sie den Query API-Vorgang, um mehrere Elemente zu lesen. Sie können den Low-Level-Client oder den Document-Client verwenden. Im folgenden Beispiel wird der High-Level-Document-Client verwendet.

const { DynamoDBClient } = require("@aws-sdk/client-dynamodb");
const {
  DynamoDBDocumentClient,
  QueryCommand,
} = require("@aws-sdk/lib-dynamodb");

const client = new DynamoDBClient({});

const docClient = DynamoDBDocumentClient.from(client);

async function productSearch() {
  const params = {
    TableName: "products",
    IndexName: "GSI1",
    KeyConditionExpression: "#category = :category and begins_with(#sku, :sku)",
    ExpressionAttributeNames: {
      "#category": "category",
      "#sku": "sku",
    },
    ExpressionAttributeValues: {
      ":category": "footwear",
      ":sku": "hiking",
    },
  };

  try {
    const data = await docClient.send(new QueryCommand(params));
    console.log('result : ' + JSON.stringify(data));
  } catch (error) {
    console.error("Error:", error);
  }
}

productSearch();

Bedingte Schreibvorgänge

DynamoDB-Schreiboperationen können einen logischen Bedingungsausdruck angeben, der als wahr ausgewertet werden muss, damit der Schreibvorgang fortgesetzt werden kann. Wenn die Bedingung nicht als wahr ausgewertet wird, generiert der Schreibvorgang eine Ausnahme. Mit dem Bedingungsausdruck kann geprüft werden, ob das Element bereits existiert oder ob seine Attribute bestimmten Einschränkungen entsprechen.

ConditionExpression = "version = :ver AND size(VideoClip) < :maxsize"

Wenn der bedingte Ausdruck fehlschlägt, können ReturnValuesOnConditionCheckFailure Sie anfordern, dass die Fehlerantwort das Element enthält, das die Bedingungen nicht erfüllt hat, um das Problem abzuleiten. Weitere Informationen finden Sie unter Behandeln von bedingten Schreibfehlern in Szenarien mit hoher Parallelität mit Amazon DynamoDB.

try {
      const response = await client.send(new PutCommand({
          TableName: "YourTableName",
          Item: item,
          ConditionExpression: "attribute_not_exists(pk)",
          ReturnValuesOnConditionCheckFailure: "ALL_OLD"
      }));
  } catch (e) {
      if (e.name === 'ConditionalCheckFailedException') {
          console.log('Item already exists:', e.Item);
      } else {
          throw e;
      }
  }

Zusätzliche Codebeispiele, die andere Aspekte der Verwendung von JavsScript SDK V3 zeigen, sind in der JavaScript SDK V3-Dokumentation und im GitHub DynamoDB-SDK-Examples Repository verfügbar.

Paginierung

Leseanfragen wie Scan oder geben Query wahrscheinlich mehrere Elemente in einem Datensatz zurück. Wenn Sie ein Scan oder Query mit einem Limit Parameter ausführen, wird, sobald das System so viele Elemente gelesen hat, eine Teilantwort gesendet, und Sie müssen paginieren, um weitere Elemente abzurufen.

Das System liest nur maximal 1 Megabyte an Daten pro Anfrage. Wenn Sie einen Filter Ausdruck angeben, liest das System immer noch maximal ein Megabyte an Daten von der Festplatte, gibt aber die Elemente dieses Megabytes zurück, die dem Filter entsprechen. Der Filtervorgang könnte 0 Elemente für eine Seite zurückgeben, erfordert aber dennoch eine weitere Seitennummerierung, bevor die Suche abgeschlossen ist.

Sie sollten LastEvaluatedKey in der Antwort danach suchen und sie als ExclusiveStartKey Parameter in einer nachfolgenden Anfrage verwenden, um den Datenabruf fortzusetzen. Dies dient als Lesezeichen, wie im folgenden Beispiel angegeben.

Beispiel für die LastEvaluatedKey Verwendung von:

const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb");

const client = new DynamoDBClient({});

async function paginatedScan() {
  let lastEvaluatedKey;
  let pageCount = 0;

  do {
    const params = {
      TableName: "products",
      ExclusiveStartKey: lastEvaluatedKey,
    };

    const response = await client.send(new ScanCommand(params));
    pageCount++;
    console.log(`Page ${pageCount}, Items:`, response.Items);
    lastEvaluatedKey = response.LastEvaluatedKey;
  } while (lastEvaluatedKey);
}

paginatedScan().catch((err) => {
  console.error(err);
});

Verwendung der paginateScan Komfortmethode

Das SDK bietet praktische MethodenpaginateQuery, die aufgerufen werden paginateScan und diese Arbeit für Sie erledigen und die wiederholten Anfragen hinter den Kulissen stellen. Geben Sie mithilfe des Limit Standardparameters die maximale Anzahl von Elementen an, die pro Anfrage gelesen werden sollen.

const { DynamoDBClient, paginateScan } = require("@aws-sdk/client-dynamodb");

const client = new DynamoDBClient({});

async function paginatedScanUsingPaginator() {
  const params = {
    TableName: "products",
    Limit: 100
  };

  const paginator = paginateScan({client}, params);

  let pageCount = 0;

  for await (const page of paginator) {
    pageCount++;
    console.log(`Page ${pageCount}, Items:`, page.Items);
  }
}

paginatedScanUsingPaginator().catch((err) => {
  console.error(err);
});

Konfiguration angeben

Beim Einrichten von können Sie verschiedene Konfigurationsüberschreibungen angebenDynamoDBClient, indem Sie ein Konfigurationsobjekt an den Konstruktor übergeben. Sie können beispielsweise die Region angeben, zu der eine Verbindung hergestellt werden soll, falls sie dem aufrufenden Kontext oder der zu verwendenden Endpunkt-URL noch nicht bekannt ist. Dies ist nützlich, wenn Sie zu Entwicklungszwecken auf eine lokale DynamoDB-Instanz abzielen möchten.

const client = new DynamoDBClient({
  region: "eu-west-1",
  endpoint: "http://localhost:8000",
});

Config für Timeouts

DynamoDB verwendet HTTPS für die Client-Server-Kommunikation. Sie können einige Aspekte der HTTP-Ebene steuern, indem Sie ein Objekt bereitstellen. NodeHttpHandler Sie können beispielsweise die wichtigsten Timeout-Werte connectionTimeout und requestTimeout anpassen. Dies connectionTimeout ist die maximale Dauer in Millisekunden, die der Client beim Versuch, eine Verbindung herzustellen, wartet, bevor er aufgibt.

requestTimeoutDefiniert, wie lange der Client auf eine Antwort wartet, nachdem eine Anfrage gesendet wurde, ebenfalls in Millisekunden. Die Standardwerte für beide sind Null, was bedeutet, dass das Timeout deaktiviert ist und es keine Begrenzung gibt, wie lange der Client wartet, wenn die Antwort nicht eintrifft. Sie sollten die Timeouts auf einen vernünftigen Wert setzen, damit die Anfrage im Falle eines Netzwerkproblems zu einem Fehler wird und eine neue Anfrage initiiert werden kann. Beispielsweise:

import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { NodeHttpHandler } from "@smithy/node-http-handler";

const requestHandler = new NodeHttpHandler({
  connectionTimeout: 2000,
  requestTimeout: 2000,
});

const client = new DynamoDBClient({
  requestHandler
});

Zusätzlich zur Konfiguration von Timeout-Werten können Sie die maximale Anzahl von Sockets festlegen, was eine höhere Anzahl gleichzeitiger Verbindungen pro Ursprung ermöglicht. Das Entwicklerhandbuch enthält Einzelheiten zur Konfiguration des Parameters maxSockets.

Config für Keep-Alive

Bei der Verwendung von HTTPS erfordert die erste Anfrage immer eine gewisse back-and-forth Kommunikation, um eine sichere Verbindung herzustellen. HTTP Keep-Alive ermöglicht es nachfolgenden Anfragen, die bereits hergestellte Verbindung wiederzuverwenden, wodurch die Anfragen effizienter werden und die Latenz verringert wird. HTTP Keep-Alive ist standardmäßig mit V3 aktiviert. JavaScript

Es gibt eine Grenze dafür, wie lange eine inaktive Verbindung aufrechterhalten werden kann. Erwägen Sie, regelmäßig Anfragen zu senden, vielleicht jede Minute, wenn Sie eine inaktive Verbindung haben, aber möchten, dass die nächste Anfrage eine bereits bestehende Verbindung verwendet.

Config für Wiederholungsversuche

Wenn das SDK eine Fehlerantwort erhält und der Fehler, wie vom SDK festgelegt, wieder aufgenommen werden kann, z. B. eine Drosselungsausnahme oder eine temporäre Serviceausnahme, wird es es erneut versuchen. Dies geschieht für Sie als Anrufer unsichtbar, mit der Ausnahme, dass Sie vielleicht feststellen, dass es länger gedauert hat, bis die Anfrage erfolgreich war.

Das SDK für JavaScript V3 stellt standardmäßig insgesamt 3 Anfragen, bevor es aufgibt und den Fehler an den Aufrufkontext weitergibt. Sie können die Anzahl und Häufigkeit dieser Wiederholungen anpassen.

Der DynamoDBClient Konstruktor akzeptiert eine maxAttempts Einstellung, die die Anzahl der Versuche begrenzt. Im folgenden Beispiel wird der Standardwert von 3 auf insgesamt 5 erhöht. Wenn Sie ihn auf 0 oder 1 setzen, bedeutet das, dass Sie keine automatischen Wiederholungen wünschen und alle wiederaufnehmbaren Fehler innerhalb Ihres Catch-Blocks selbst behandeln möchten.

const client = new DynamoDBClient({
  maxAttempts: 5,
});

Sie können den Zeitpunkt der Wiederholungsversuche auch mit einer benutzerdefinierten Wiederholungsstrategie steuern. Importieren Sie dazu das util-retry Utility-Paket und erstellen Sie eine benutzerdefinierte Backoff-Funktion, die die Wartezeit zwischen Wiederholungen auf der Grundlage der aktuellen Anzahl von Wiederholungen berechnet.

Das folgende Beispiel besagt, dass maximal 5 Versuche mit Verzögerungen von 15, 30, 90 und 360 Millisekunden durchgeführt werden sollen, falls der erste Versuch fehlschlägt. Die benutzerdefinierte Backoff-Funktion berechnet die Verzögerungen calculateRetryBackoff, indem sie die Nummer des Wiederholungsversuchs akzeptiert (beginnt mit 1 für den ersten Versuch) und gibt zurück, wie viele Millisekunden auf diese Anfrage gewartet werden müssen.

const { ConfiguredRetryStrategy } = require("@aws-sdk/util-retry");

const calculateRetryBackoff = (attempt) => {
  const backoffTimes = [15, 30, 90, 360];
  return backoffTimes[attempt - 1] || 0;
};

const client = new DynamoDBClient({
  retryStrategy: new ConfiguredRetryStrategy(
    5, // max attempts.
    calculateRetryBackoff // backoff function.
  ),
});

Waiter

Der DynamoDB-Client enthält zwei nützliche Kellnerfunktionen, die beim Erstellen, Ändern oder Löschen von Tabellen verwendet werden können, wenn Sie möchten, dass Ihr Code mit dem Fortfahren wartet, bis die Tabellenänderung abgeschlossen ist. Sie können beispielsweise eine Tabelle bereitstellen und die waitUntilTableExists Funktion aufrufen, und der Code wird blockiert, bis die Tabelle auf AKTIV gesetzt wurde. Der Kellner fragt den DynamoDB-Dienst intern alle 20 Sekunden ab. describe-table

import {waitUntilTableExists, waitUntilTableNotExists} from "@aws-sdk/client-dynamodb";

… <create table details>

const results = await waitUntilTableExists({client: client, maxWaitTime: 180}, {TableName: "products"});
if (results.state == 'SUCCESS') {
  return results.reason.Table
}
console.error(`${results.state} ${results.reason}`);

Die waitUntilTableExists Funktion gibt nur dann die Steuerung zurück, wenn sie einen describe-table Befehl ausführen kann, der den Tabellenstatus AKTIV anzeigt. Dadurch wird sichergestellt, dass Sie waitUntilTableExists auf den Abschluss der Erstellung sowie auf Änderungen wie das Hinzufügen eines GSI-Index warten können, dessen Übernahme einige Zeit in Anspruch nehmen kann, bevor die Tabelle wieder den Status ACTIVE annimmt.

Fehlerbehandlung

In den ersten Beispielen hier haben wir alle Fehler im Großen und Ganzen erfasst. In praktischen Anwendungen ist es jedoch wichtig, zwischen verschiedenen Fehlertypen zu unterscheiden und eine genauere Fehlerbehandlung zu implementieren.

DynamoDB-Fehlerantworten enthalten Metadaten, einschließlich des Namens des Fehlers. Sie können Fehler catch und dann mit den möglichen Zeichenkettennamen von Fehlerbedingungen abgleichen, um zu bestimmen, wie Sie vorgehen sollen. Bei serverseitigen Fehlern können Sie den instanceof Operator mit den vom @aws-sdk/client-dynamodb Paket exportierten Fehlertypen nutzen, um die Fehlerbehandlung effizient zu verwalten.

Es ist wichtig zu beachten, dass diese Fehler erst auftreten, wenn alle Wiederholungsversuche ausgeschöpft sind. Wenn ein Fehler erneut versucht wird und schließlich ein erfolgreicher Aufruf folgt, liegt aus Sicht des Codes kein Fehler vor, sondern nur eine leicht erhöhte Latenz. Wiederholungen werden in den CloudWatch Amazon-Diagrammen als erfolglose Anfragen angezeigt, z. B. Drosselungs- oder Fehleranfragen. Wenn der Client die maximale Anzahl an Wiederholungen erreicht, gibt er auf und generiert eine Ausnahme. Auf diese Weise sagt der Client, dass er es nicht erneut versuchen wird.

Im Folgenden finden Sie einen Ausschnitt, mit dem Sie den Fehler abfangen und je nach Art des zurückgegebenen Fehlers Maßnahmen ergreifen können.

import {
  ResourceNotFoundException
  ProvisionedThroughputExceededException,
  DynamoDBServiceException,
} from "@aws-sdk/client-dynamodb";

try {
  await client.send(someCommand);
} catch (e) {
    if (e instanceof ResourceNotFoundException) {
      // Handle ResourceNotFoundException
    } else if (e instanceof ProvisionedThroughputExceededException) {
      // Handle ProvisionedThroughputExceededException
    } else if (e instanceof DynamoDBServiceException) {
      // Handle DynamoDBServiceException
    } else {
      // Other errors such as those from the SDK
      if (e.name === "TimeoutError") {
        // Handle SDK TimeoutError.
      } else {
        // Handle other errors.
      }
    }
}

Allgemeine Fehlerzeichenfolgen finden Sie Fehlerbehandlung mit DynamoDB im DynamoDB Developer Guide. Die genauen Fehler, die bei einem bestimmten API-Aufruf auftreten können, finden Sie in der Dokumentation zu diesem API-Aufruf, z. B. in den Query-API-Dokumenten.

Die Metadaten von Fehlern enthalten je nach Fehler zusätzliche Eigenschaften. Für a TimeoutError umfassen die Metadaten die Anzahl der Versuche und dietotalRetryDelay, wie unten dargestellt.

{
  "name": "TimeoutError",
  "$metadata": {
    "attempts": 3,
    "totalRetryDelay": 199
  }
}

Wenn Sie Ihre eigene Wiederholungsrichtlinie verwalten, sollten Sie zwischen Drosselungen und Fehlern unterscheiden:

Protokollierung

Aktivieren Sie die Protokollierung, um weitere Informationen darüber zu erhalten, was das SDK tut. Sie können einen Parameter für den festlegen, DynamoDBClient wie im Beispiel unten gezeigt. Weitere Protokollinformationen werden in der Konsole angezeigt und enthalten Metadaten wie den Statuscode und die verbrauchte Kapazität. Wenn Sie den Code lokal in einem Terminalfenster ausführen, werden die Protokolle dort angezeigt. Wenn Sie den Code ausführen und CloudWatch Amazon-Logs eingerichtet haben, wird die Konsolenausgabe dort geschrieben. AWS Lambda

const client = new DynamoDBClient({
  logger: console
});

Sie können sich auch in die internen SDK-Aktivitäten einklinken und bei bestimmten Ereignissen eine benutzerdefinierte Protokollierung durchführen. Das folgende Beispiel verwendet den ClientmiddlewareStack, um jede Anfrage abzufangen, wenn sie vom SDK gesendet wird, und protokolliert sie, während sie passiert.

const client = new DynamoDBClient({});

client.middlewareStack.add(
  (next) => async (args) => {
    console.log("Sending request from AWS SDK", { request: args.request });
    return next(args);
  },
  {
    step: "build",
    name: "log-ddb-calls",
  }
);

Das MiddlewareStack bietet einen leistungsstarken Hook zur Beobachtung und Steuerung des SDK-Verhaltens. Weitere Informationen finden Sie im Blog Introducing Middleware Stack in Modular AWS SDK for JavaScript.

Überlegungen

Bei der Implementierung AWS SDK for JavaScript in Ihrem Projekt sollten Sie folgende weitere Faktoren berücksichtigen.