Programmieren von Amazon DynamoDB mit JavaScript

Dieser Leitfaden bietet eine Einführung für Programmierer, die Amazon DynamoDB mit JavaScript verwenden möchten. Erfahren Sie mehr über AWS SDK für JavaScript, verfügbare Abstraktionsebenen, Verbindungskonfigurierung, den Umgang mit Fehlern, wie Wiederholungsrichtlinien festgelegt werden, die Verwaltung von Keep-Alive und mehr.

Informationen zu AWS SDK für JavaScript

AWS SDK für JavaScript bietet Zugriff auf Webservices in Browser-Skripts oder Node.js. Diese Dokumentation konzentriert sich auf die neueste SDK-Version (V3). AWS SDK für JavaScript-V3 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 für das GitHub-Repository auf sie zugreifen.

JavaScript V2 ähnelt V3, enthält jedoch Syntaxunterschiede. V3 ist modularer aufgebaut, was das Ausliefern kleinerer Abhängigkeiten erleichtert, und bietet erstklassige Unterstützung für TypeScript. Wir empfehlen die neueste SDK-Version zu verwenden.

Verwenden von AWS SDK für JavaScript V3

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

Die Installation von Paketen fügt Verweise im Abschnitt „Abhängigkeiten“ zu Ihrer package.json-Projektdatei hinzu. 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 anhand der 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 bietet Ihnen volle Kontrolle über alle Aspekte der Kommunikation, aber da keine Abstraktionen vorhanden sind, müssen Sie beispielsweise Elementdefinitionen im DynamoDB-JSON-Format bereitstellen.

Wie das folgende Beispiel zeigt, müssen bei diesem Format die Datentypen explizit angegeben werden. Ein S steht für einen Zeichenkettenwert und ein N steht für einen Zahlenwert. Zahlen werden beim Übertragen stets als Zeichenketten gesendet, die als Zahlentypen gekennzeichnet sind, um einen Präzisionsverlust zu vermeiden. Low-Level-API-Aufrufe haben ein Benennungsmuster wie PutItemCommand und GetItemCommand.

Im folgenden Beispiel wird der Low-Level-Client mit einem Item verwendet, das im DynamoDB-JSON-Format 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 High-Level-Dokument-Client in DynamoDB bietet integrierte Komfortfunktionen, wie etwa die Eliminierung der manuellen Datenkonvertierung (Marshalling) und die Möglichkeit, direkt mit Standard-JavaScript-Objekten zu lesen und zu schreiben. Die Dokumentation zu lib-dynamodb enthält eine Liste der Vorteile.

Um den DynamoDBDocumentClient zu instanziieren, erstellen Sie zunächst einen Low-Level-DynamoDBClient und umschließen ihn anschließend mit einem DynamoDBDocumentClient. Die Namenskonventionen der Funktionen unterscheiden sich leicht zwischen den beiden Paketen. Der Low-Level-Client verwendet beispielsweise PutItemCommand, während der High-Level-Client PutCommand verwendet. Durch die unterschiedlichen Namen können beide Funktionssets im selben Kontext koexistieren, sodass Sie sie innerhalb desselben Skripts 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 GetItem, Query oder Scan lesen.

Verwenden der Hilfsfunktion Marshall

Sie können den Low-Level-Client verwenden und die Datentypen selbst mit marshall oder unmarshall konvertieren. Das Hilfspaket util-dynamodb enthält eine marshall()-Hilfsfunktion, die JSON entgegennimmt und DynamoDB-JSON erzeugt, sowie eine unmarshall()-Funktion, die den umgekehrten Vorgang ausführt. Im folgenden Beispiel wird der Low-Level-Client verwendet, wobei die Datenkonvertierung durch den Aufruf von marshall() erfolgt.

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();

Lesen von Elementen

Um ein einzelnes Element aus DynamoDB zu lesen, verwenden Sie die API-Operation GetItem. Ähnlich wie beim PutItem-Befehl haben Sie die Wahl zwischen dem Low-Level-Client und dem High-Level-Dokument-Client. Das folgende Beispiel zeigt, wie Sie mit dem High-Level-Dokument-Client ein Element abrufen.

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 die Query-API-Operation, um mehrere Elemente zu lesen. Sie können den Low-Level-Client oder den Dokument-Client verwenden. Im folgenden Beispiel wird der High-Level-Dokument-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-Schreibvorgänge können eine logische Bedingungsausdruck angeben, der als true ausgewertet werden muss, damit der Schreibvorgang ausgeführt wird. Wenn die Bedingung nicht als wahr ausgewertet wird, erzeugt die Schreiboperation eine Ausnahme. Der Bedingungsausdruck kann überprüfen, ob das Element bereits existiert oder ob seine Attribute bestimmten Beschränkungen entsprechen.

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

Wenn der Bedingungsausdruck fehlschlägt, können Sie ReturnValuesOnConditionCheckFailure verwenden, um anzufordern, dass die Fehlermeldung das Element enthält, das die Bedingungen nicht erfüllt hat. So können Sie leichter nachvollziehen, worin das Problem bestand. 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-Repository DynamoDB-SDK-Examples verfügbar.

Paginierung

Leseanfragen wie Scan oder Query geben wahrscheinlich mehrere Elemente in einem Datensatz zurück. Wenn Sie einen Scan oder eine Query mit einem Limit-Parameter durchführen, sendet das System nach dem Lesen dieser Anzahl von Elementen eine Teilantwort, und Sie müssen die Ergebnisse paginieren, um weitere Elemente abzurufen.

Das System liest pro Anfrage maximal 1 Megabyte an Daten. Wenn Sie einen Filter-Ausdruck verwenden, liest das System weiterhin maximal ein Megabyte von der Festplatte, gibt jedoch nur die Elemente dieses Megabytes zurück, die dem Filter entsprechen. Die Filteroperation kann für eine Seite null Elemente zurückgeben, erfordert aber dennoch eine weitere Paginierung, bevor die Suche abgeschlossen ist.

Sie sollten im Antwortobjekt nach dem LastEvaluatedKey suchen und diesen als ExclusiveStartKey-Parameter in einer nachfolgenden Anfrage verwenden, um die Datenabfrage fortzusetzen. Dies dient als eine Art Lesezeichen, wie im folgenden Beispiel gezeigt.

Beispiel - Verwenden des LastEvaluatedKey:

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);
});

Verwenden der paginateScan-Komfortmethode

Das SDK stellt Komfortmethoden namens paginateScan und paginateQuery bereit, die diese Arbeit für Sie übernehmen und die wiederholten Anfragen im Hintergrund ausführen. Die maximale Anzahl der pro Anfrage zu lesenden Elemente geben Sie über den Standardparameter Limit an.

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);
});

Angeben der Konfiguration

Beim Einrichten des DynamoDBClient können Sie verschiedene Konfigurationsüberschreibungen festlegen, indem Sie ein Konfigurationsobjekt an den Konstruktor übergeben. Beispielsweise können Sie die Region angeben, mit der eine Verbindung hergestellt werden soll, falls sie dem aufrufenden Kontext nicht bereits bekannt ist, oder die zu verwendende Endpunkt-URL. Dies ist besonders nützlich, wenn Sie eine lokale DynamoDB-Instance für Entwicklungszwecke ansprechen 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 NodeHttpHandler-Objekt bereitstellen. Beispielsweise können Sie die wichtigsten Timeout-Werte connectionTimeout und requestTimeout anpassen. connectionTimeout ist die maximale Dauer in Millisekunden, die der Client beim Versuch, eine Verbindung herzustellen, wartet, bevor er aufgibt.

requestTimeout legt fest, wie lange der Client nach dem Senden einer Anfrage auf eine Antwort wartet, ebenfalls in Millisekunden. Die Standardwerte für beide Parameter sind null, was bedeutet, dass kein Timeout aktiviert ist und der Client unbegrenzt auf eine Antwort wartet, falls diese nicht eintrifft. Es ist empfehlenswert, sinnvolle Timeout-Werte zu setzen, damit bei Netzwerkproblemen ein Fehler ausgelöst wird und eine neue Anfrage gestartet werden kann. Zum Beispiel:

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. Der Entwicklerleitfaden enthält Details zur Konfiguration des Parameters maxSockets.

Config für Keepalive

Bei der Verwendung von HTTPS erfordert die erste Anfrage einen gewissen Kommunikationsaustausch, um eine sichere Verbindung aufzubauen. HTTP Keepalive ermöglicht es, dass nachfolgende Anfragen die bereits aufgebaute Verbindung wiederverwenden, wodurch die Effizienz steigt und die Latenz sinkt. HTTP Keepalive ist in JavaScript V3 standardmäßig aktiviert.

Es gibt jedoch eine Begrenzung, wie lange eine inaktive Verbindung aufrechterhalten werden kann. Wenn Sie eine Verbindung im Leerlauf haben, die für die nächste Anfrage wiederverwendet werden soll, sollten Sie in Erwägung ziehen, regelmäßig Anfragen zu senden, z. B. einmal pro Minute.

Config für Wiederholungsversuche

Wenn das SDK eine Fehlermeldung erhält und der Fehler laut SDK als wiederholbar gilt, z. B. bei einer Drosselungsausnahme oder einem temporären Service-Ausnahmefehler, wird automatisch ein erneuter Versuch gestartet. Dies geschieht für den Aufrufer unsichtbar, außer dass die Anfrage möglicherweise etwas länger dauert, bis sie erfolgreich ist.

Das JavaScript-SDK V3 führt standardmäßig bis zu drei Versuche durch, bevor es aufgibt und den Fehler an den aufrufenden Kontext weitergibt. Sie können sowohl die Anzahl als auch die Frequenz dieser Wiederholungen anpassen.

Der Konstruktor des DynamoDBClient akzeptiert die Einstellung maxAttempts, mit der Sie die maximale Anzahl von Versuchen festlegen können. Im folgenden Beispiel wird der Wert von standardmäßig 3 auf insgesamt 5 erhöht. Wenn Sie ihn auf 0 oder 1 setzen, bedeutet das, dass Sie keine automatischen Wiederholungen wünschen und wiederholbare Fehler selbst im catch-Block behandeln möchten.

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

Sie können das Timing der Wiederholungen mit einer benutzerdefinierten Wiederholungsstrategie steuern. Dazu importieren Sie das Hilfspaket util-retry und erstellen eine benutzerdefinierte Backoff-Funktion, die die Wartezeit zwischen den Wiederholungen basierend auf der aktuellen Anzahl der Versuche berechnet.

Im folgenden Beispiel sind maximal 5 Versuche vorgesehen, mit Verzögerungen von 15, 30, 90 und 360 Millisekunden, falls der erste Versuch fehlschlägt. Die benutzerdefinierte Backoff-Funktion calculateRetryBackoff nimmt die Nummer des Wiederholungsversuchs entgegen (beginnend mit 1 für den ersten Wiederholungsversuch) und gibt die Anzahl der Millisekunden zurück, die vor dem nächsten Versuch gewartet werden sollen.

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 außerdem zwei nützliche Waiter-Funktionen, die beim Erstellen, Ändern oder Löschen von Tabellen verwendet werden können, wenn der Code erst fortfahren soll, nachdem die Tabellenoperation abgeschlossen ist. Beispielsweise können Sie eine Tabelle bereitstellen, die Funktion waitUntilTableExists aufrufen, und der Code blockiert dann, bis die Tabelle in den Status ACTIVE wechselt. Der Waiter fragt den DynamoDB-Service alle 20 Sekunden intern über describe-table ab.

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 Funktion waitUntilTableExists gibt die Kontrolle erst dann zurück, wenn ein describe-table-Befehl erfolgreich ausgeführt werden kann, der den Tabellenstatus als ACTIVE bestätigt. Dadurch können Sie waitUntilTableExists nicht nur verwenden, um auf die vollständige Erstellung einer Tabelle zu warten, sondern auch auf Änderungen wie das Hinzufügen eines GSI-Index, dessen Anwendung einige Zeit in Anspruch nehmen kann, bevor die Tabelle wieder den Status ACTIVE erreicht.

Fehlerbehandlung

In den bisherigen Beispielen wurden alle Fehler pauschal abgefangen. In praktischen Anwendungen ist es jedoch wichtig, zwischen verschiedenen Fehlertypen zu unterscheiden und eine präzisere Fehlerbehandlung zu implementieren.

Fehlermeldungen von DynamoDB enthalten Metadaten, darunter den Namen des Fehlers. Sie können Fehler abfangen und anhand der möglichen Fehlerbezeichnungen entscheiden, wie weiter vorzugehen ist. Bei serverseitigen Fehlern können Sie den Operator instanceof zusammen mit den im Paket @aws-sdk/client-dynamodb exportierten Fehlertypen verwenden, um die Fehlerbehandlung effizient zu gestalten.

Beachten Sie, dass diese Fehler erst auftreten, nachdem alle Wiederholungsversuche ausgeschöpft wurden. Wenn ein Fehler erneut versucht und schließlich erfolgreich abgeschlossen wird, erscheint aus Sicht des Codes kein Fehler, sondern nur eine leicht erhöhte Latenz. Wiederholungen werden in Amazon CloudWatch-Diagrammen als fehlgeschlagene Anfragen angezeigt, z. B. als Drosselung oder als Fehleranfragen. Wenn der Client die maximale Anzahl an Wiederholungen erreicht, gibt er auf und löst eine Ausnahme aus. Dies signalisiert, dass keine weiteren Wiederholungen erfolgen werden.

Im Folgenden sehen Sie einen Codeausschnitt, der zeigt, wie Sie einen Fehler abfangen und je nach Fehlertyp entsprechend reagieren 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 unter Fehlerbehandlung mit DynamoDB im DynamoDB-Entwicklerhandbuch. 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 Abfrage-API-Dokumenten.

Die Metadaten von Fehlern enthalten je nach Fehler zusätzliche Eigenschaften. Bei einem TimeoutError enthält die Fehlermeldung Metadaten wie die Anzahl der durchgeführten Versuche und die totalRetryDelay, wie im Folgenden gezeigt.

{
  "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 mehr Details darüber zu erhalten, was das SDK im Hintergrund tut. Sie können dazu einen Parameter im DynamoDBClient setzen, wie im folgenden Beispiel gezeigt. Zusätzliche Protokollinformationen erscheinen in der Konsole und enthalten Metadaten wie den Statuscode und die verbrauchte Kapazität. Wenn Sie den Code lokal in einem Terminalfenster ausführen, erscheinen die Protokolle dort. Wenn Sie den Code in AWS Lambda ausführen und Amazon CloudWatch-Logs eingerichtet haben, wird die Konsolenausgabe dorthin geschrieben.

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

Sie können auch in die internen Aktivitäten des SDK eingreifen und benutzerdefinierte Protokollierung durchführen, sobald bestimmte Ereignisse eintreten. Das folgende Beispiel verwendet den middlewareStack des Clients, um jede Anfrage abzufangen, während sie vom SDK gesendet wird, und sie in Echtzeit zu protokollieren.

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",
  }
);

Der MiddlewareStack bietet eine leistungsstarke Schnittstelle, um das Verhalten des SDK zu beobachten und zu steuern. Weitere Informationen finden Sie im Blog Introducing Middleware Stack in Modular AWS SDK für JavaScript.

Überlegungen

Beim Implementieren des AWS SDK für JavaScript in Ihrem Projekt sollten Sie die folgenden zusätzlichen Aspekte berücksichtigen.