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.

# Bereitstellen der lokalen Version von DynamoDB auf Ihrem Computer
<a name="DynamoDBLocal.DownloadingAndRunning"></a>

**Anmerkung**  
Die lokale Version von DynamoDB ist in drei Versionen verfügbar: v3.x (aktuell), v2.x (Legacy) und v1.x (veraltet).
DynamoDB v3.x wird für Ihre lokalen Test- und Entwicklungszwecke empfohlen.
Die Migration der lokalen Version von DynamoDB V2.x auf V3.x erfordert die Aktualisierung der Importanweisungen von `com.amazonaws.services.dynamodbv2` auf `software.amazon.dynamodb` und die Aktualisierung der Maven-Abhängigkeiten für Maven-Benutzer.
Wenn Sie eine Anwendung zum SDK für Java 2.x migrieren, die das SDK für Java v1.x verwendet, folgen Sie den Schritten unter [AWS -SDK für Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html).

## Herunterladen der lokalen Version von DynamoDB
<a name="DynamoDBLocal.DownloadingAndRunning.V2"></a>

Gehen Sie wie folgt vor, um DynamoDB einzurichten und auf Ihrem Computer auszuführen.

**So richten Sie DynamoDB auf dem Computer ein**

1. Laden Sie die lokale Version von DynamoDB kostenlos von einem der folgenden Speicherorte herunter.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/DynamoDBLocal.DownloadingAndRunning.html)
**Wichtig**  
 Um DynamoDB v2.6.0 oder höher auf Ihrem Computer ausführen zu können, benötigen Sie die Java Runtime Environment (JRE) Version 17.x oder neuer. Die Anwendung kann nicht unter früheren JRE-Versionen ausgeführt werden.

1.  Nachdem Sie das Archiv heruntergeladen haben, extrahieren Sie die Inhalte und kopieren Sie das entpackte Verzeichnis an einen Speicherort Ihrer Wahl. 

1.  Zum Starten von DynamoDB auf Ihrem Computer, öffnen Sie ein Befehlszeilenfenster, gehen Sie zu dem Verzeichnis, in das Sie `DynamoDBLocal.jar` extrahiert haben, und geben Sie den folgenden Befehl ein. 

   ```
   java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb
   ```
**Anmerkung**  
 Wenn Sie Windows verwenden, achten Sie darauf PowerShell, den Parameternamen oder den gesamten Namen und Wert wie folgt einzuschließen:   
 ` java -D"java.library.path=./DynamoDBLocal_lib" -jar DynamoDBLocal.jar `   
 DynamoDB verarbeitet eingehende Anforderungen, bis Sie den Service beenden. Zum Beenden von DynamoDB geben Sie Strg\$1C in die Befehlszeile ein.   
 DynamoDB verwendet standardmäßig Port 8000. Wenn Port 8000 nicht verfügbar ist, wird eine Ausnahme ausgelöst. Um eine vollständige Liste der DynamoDB-Laufzeitoptionen, einschließlich `-port`, zu erhalten, geben Sie folgenden Befehl ein.   
 ` java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -help ` 

1. Bevor Sie programmgesteuert oder über die AWS Command Line Interface (AWS CLI) auf DynamoDB zugreifen können, müssen Sie die Anmeldeinformationen so konfigurieren, dass die Autorisierung für die Anwendungen aktiviert wird. Die herunterladbare Version von DynamoDB benötigt Anmeldeinformationen, um arbeiten zu können, wie in dem folgenden Beispiel gezeigt. 

   ```
   AWS Access Key ID: "fakeMyKeyId"
   AWS Secret Access Key: "fakeSecretAccessKey"
   Default Region Name: "fakeRegion"
   ```

    Sie können die Anmeldeinformationen mit dem  AWS CLI -Befehl `aws configure` einrichten. Weitere Informationen finden Sie unter [Mit dem AWS CLI](AccessingDynamoDB.md#Tools.CLI). 

1.  Beginnen Sie mit dem Schreiben von Anwendungen. Verwenden Sie den Parameter, um auf DynamoDB zuzugreifen AWS CLI, das lokal mit dem ausgeführt wird`--endpoint-url `. Sie können z. B. den folgenden Befehl verwenden, um DynamoDB-Tabellen aufzulisten. 

   ```
   aws dynamodb list-tables --endpoint-url http://localhost:8000
   ```

## Ausführen der lokalen Version von DynamoDB als Docker-Image
<a name="DynamoDBLocal.DownloadingAndRunning.Docker"></a>

 Die herunterladbare Version von Amazon DynamoDB ist als Docker-Image verfügbar. Weitere Informationen finden Sie unter [dynamodb-local](https://hub.docker.com/r/amazon/dynamodb-local). Geben Sie folgenden Befehl ein, um Ihre aktuelle lokale Version von DynamoDB zu sehen:

```
java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -version
```

 Ein Beispiel für die Verwendung von DynamoDB local als Teil einer REST-Anwendung, die auf der AWS Serverless Application Model (AWS SAM) aufbaut, finden Sie unter [SAM DynamoDB-Anwendung](https://github.com/aws-samples/aws-sam-java-rest) zur Verwaltung von Bestellungen. Diese Beispielanwendung demonstriert die Verwendung der lokalen Version von DynamoDB für Testzwecke. 

 Wenn Sie eine Anwendung mit mehreren Containern ausführen möchten, die auch den lokalen DynamoDB-Container nutzt, verwenden Sie Docker Compose, um alle Services in Ihrer Anwendung zu definieren und auszuführen, einschließlich DynamoDB lokal. 

**So gehen Sie vor, um DynamoDB zu installieren und lokal auszuführen:**

1.  Führen Sie Download und Installation von [Docker Desktop](https://www.docker.com/products/docker-desktop) durch. 

1.  Kopieren Sie den folgenden Code in eine Datei, und speichern Sie ihn unter `docker-compose.yml`. 

   ```
   services:
    dynamodb-local:
      command: "-jar DynamoDBLocal.jar -sharedDb -dbPath ./data"
      image: "amazon/dynamodb-local:latest"
      container_name: dynamodb-local
      ports:
        - "8000:8000"
      volumes:
        - "./docker/dynamodb:/home/dynamodblocal/data"
      working_dir: /home/dynamodblocal
   ```

    Wenn sich Ihre Anwendung und DynamoDB lokal in separaten Containern befinden sollen, verwenden Sie die folgende YAML-Datei: 

   ```
   version: '3.8'
   services:
    dynamodb-local:
      command: "-jar DynamoDBLocal.jar -sharedDb -dbPath ./data"
      image: "amazon/dynamodb-local:latest"
      container_name: dynamodb-local
      ports:
        - "8000:8000"
      volumes:
        - "./docker/dynamodb:/home/dynamodblocal/data"
      working_dir: /home/dynamodblocal
    app-node:
      depends_on:
        - dynamodb-local
      image: amazon/aws-cli
      container_name: app-node
      ports:
       - "8080:8080"
      environment:
        AWS_ACCESS_KEY_ID: 'DUMMYIDEXAMPLE'
        AWS_SECRET_ACCESS_KEY: 'DUMMYEXAMPLEKEY'
      command:
        dynamodb describe-limits --endpoint-url http://dynamodb-local:8000 --region us-west-2
   ```

    Dieses docker-compose.yml-Skript erstellt einen `app-node`-Container und einen `dynamodb-local`-Container. Das Skript führt einen Befehl im Container `app-node` aus, der mithilfe der AWS CLI eine Verbindung mit dem `dynamodb-local`-Container herstellt und die Konten- und Tabellenlimits beschreibt. 

    Wenn Sie diesen Vorgang bei Ihrem eigenen Anwendungsimage verwenden möchten, ersetzen Sie den Wert `image` im folgenden Beispiel durch den Wert Ihrer Anwendung. 

   ```
   version: '3.8'
   services:
    dynamodb-local:
      command: "-jar DynamoDBLocal.jar -sharedDb -dbPath ./data"
      image: "amazon/dynamodb-local:latest"
      container_name: dynamodb-local
      ports:
        - "8000:8000"
      volumes:
        - "./docker/dynamodb:/home/dynamodblocal/data"
      working_dir: /home/dynamodblocal
    app-node:
      image: location-of-your-dynamodb-demo-app:latest
      container_name: app-node
      ports:
        - "8080:8080"
      depends_on:
        - "dynamodb-local"
      links:
        - "dynamodb-local"
      environment:
        AWS_ACCESS_KEY_ID: 'DUMMYIDEXAMPLE'
        AWS_SECRET_ACCESS_KEY: 'DUMMYEXAMPLEKEY'
        REGION: 'eu-west-1'
   ```
**Anmerkung**  
 Die YAML-Skripts erfordern, dass Sie einen AWS Zugriffsschlüssel und einen AWS geheimen Schlüssel angeben, aber es müssen keine gültigen AWS Schlüssel sein, damit Sie lokal auf DynamoDB zugreifen können. 

1.  Führen Sie die folgende Befehlzeilen-Befehle aus: 

   ```
   docker-compose up
   ```

## Ausführen der lokalen Version von DynamoDB als Apache Maven-Abhängigkeit
<a name="DynamoDBLocal.DownloadingAndRunning.Maven.v2"></a>

**Anmerkung**  
Wenn Sie eine Anwendung zum SDK für Java 2.x migrieren, die das SDK für Java v1.x verwendet, folgen Sie den Schritten unter [AWS -SDK für Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html).

 Führen Sie die folgenden Schritte aus, um Amazon DynamoDB in Ihrer Anwendung als Abhängigkeit zu verwenden. 

**So stellen Sie DynamoDB als Apache-Maven-Repository bereit**

1.  Laden Sie Apache Maven herunter und installieren Sie es. Weitere Informationen finden Sie unter [Downloading Apache Maven](https://maven.apache.org/download.cgi) und [Installing Apache Maven](https://maven.apache.org/install.html). 

1.  Fügen Sie das DynamoDB-Maven-Repository zur POM-Datei (Project Object Model) Ihrer Anwendung hinzu. 

   ```
   <!--Dependency:-->
   <dependencies>
      <dependency>
         <groupId>software.amazon.dynamodb</groupId>
         <artifactId>DynamoDBLocal</artifactId>
         <version>3.3.0</version>
      </dependency>
   </dependencies>
   ```

    Beispielvorlage zur Verwendung mit Spring Boot 3 and/or Spring Framework 6: 

   ```
   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   
   <groupId>org.example</groupId>
   <artifactId>SpringMavenDynamoDB</artifactId>
   <version>1.0-SNAPSHOT</version>
   
   <properties>
      <spring-boot.version>3.0.1</spring-boot.version>
      <maven.compiler.source>17</maven.compiler.source>
      <maven.compiler.target>17</maven.compiler.target>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
   
      <parent>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-parent</artifactId>
          <version>3.1.0</version>
      </parent>
   
   <dependencies>
      <dependency>
          <groupId>software.amazon.dynamodb</groupId>
          <artifactId>DynamoDBLocal</artifactId>
          <version>3.3.0</version>
      </dependency>
      <!-- Spring Boot -->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter</artifactId>
          <version>${spring-boot.version}</version>
      </dependency>
      <!-- Spring Web -->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
          <version>${spring-boot.version}</version>
      </dependency>
      <!-- Spring Data JPA -->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-jpa</artifactId>
          <version>${spring-boot.version}</version>
      </dependency>
      <!-- Other Spring dependencies -->
      <!-- Replace the version numbers with the desired version -->
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>6.0.0</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>6.0.0</version>
      </dependency>
      <!-- Add other Spring dependencies as needed -->
      <!-- Add any other dependencies your project requires -->
   </dependencies>
   </project>
   ```
**Anmerkung**  
 Sie können auch die URL des [Maven Central Repository](https://mvnrepository.com/artifact/com.amazonaws/DynamoDBLocal?repo=dynamodb-local-release) verwenden. 

## Führen Sie DynamoDB lokal aus in AWS CloudShell
<a name="DynamoDBLocal.DynamoDB.Local.CloudShell"></a>

AWS CloudShell ist eine browserbasierte, vorauthentifizierte Shell, die Sie direkt von der aus starten können. AWS-Managementkonsole Sie können auf verschiedene Arten AWS CloudShell zu ihr navigieren. AWS-Managementkonsole Weitere Informationen finden Sie unter [Erste Schritte mit AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/getting-started.html).

Gehen Sie wie folgt vor, um DynamoDB lokal an Ihrem AWS CloudShell beliebigen Ort in der auszuführen. AWS-Managementkonsole

**Um DynamoDB lokal in Ihrem AWS CloudShell auszuführen AWS-Managementkonsole**

1. Starten Sie AWS CloudShell von der Konsolenoberfläche aus, wählen Sie eine verfügbare AWS-Region aus und wechseln Sie zu Ihrer bevorzugten Shell, z. B. Bash oder PowerShell Z-Shell.

1. Um eine auszuwählen AWS-Region, gehen **Sie zum Menü „Region auswählen**“ und wählen Sie eine [unterstützte AWS-Region](https://docs.aws.amazon.com/cloudshell/latest/userguide/supported-aws-regions.html) aus. (Verfügbare Regionen sind hervorgehoben.)

1. Starten Sie von der aus AWS-Managementkonsole, AWS CloudShell indem Sie eine der folgenden Optionen wählen:

   1. Klicken Sie in der Navigationsleiste auf das **AWS CloudShell**-Symbol.

   1. Geben Sie das Wort in das **Suchfeld** ein CloudShell, und wählen Sie dann **CloudShell**.

   1. Wählen Sie im Widget „**Zuletzt besucht**“ **CloudShell**.

   1. Wählen Sie in der Werkzeugleiste der Konsole **CloudShell**.

1. Um DynamoDB lokal in auszuführen, können AWS CloudShell Sie den `dynamodb-local` Alias verwenden. Sie können zusätzliche Befehlszeilenoptionen zum Ändern der Einstellungen Ihrer lokalen Version von DynamoDB angeben. Die verfügbaren Optionen finden Sie unter [DynamoDB-Local-Nutzungshinweise](DynamoDBLocal.UsageNotes.md).
**Anmerkung**  
Um DynamoDB local im Hintergrund auszuführen, führen Sie DynamoDB local mit: aus. AWS CloudShell `dynamodb-local &`

1. Verwenden Sie den Parameter, um auf DynamoDB zuzugreifen AWS CLI, das lokal AWS CloudShell mit dem ausgeführt wird`--endpoint-url`. Sie können z. B. den folgenden Befehl verwenden, um DynamoDB-Tabellen aufzulisten:

   `aws dynamodb list-tables --endpoint-url http://localhost:8000`

Ein Beispielprojekt, das verschiedene Ansätze zur Einrichtung und Nutzung der lokalen Version von DynamoDB zeigt – darunter das Herunterladen von JAR-Dateien, die Ausführung als Docker-Image und die Einbindung als Maven-Abhängigkeit – finden Sie unter [Java-Beispielprojekt für die lokale Version von DynamoDB](https://github.com/awslabs/amazon-dynamodb-local-samples/tree/main).