Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Distribuzione di DynamoDB in locale sul computer
<a name="DynamoDBLocal.DownloadingAndRunning"></a>

**Nota**  
DynamoDB locale è disponibile in tre versioni: v3.x (Corrente), v2.x (Legacy) e v1.x (Obsoleta).
Si consiglia DynamoDB v3.x per test e sviluppo in locale.
La migrazione della versione di DynamoDB locale da V2.x a V3.x richiede l’aggiornamento delle istruzioni di importazione da `com.amazonaws.services.dynamodbv2` a `software.amazon.dynamodb` e l’aggiornamento delle dipendenze Maven per gli utenti Maven.
Se stai migrando un’applicazione che utilizza l’SDK per Java v1.x all’SDK per Java 2.x, segui la procedura per [SDK AWS per Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html).

## Download di DynamoDB locale
<a name="DynamoDBLocal.DownloadingAndRunning.V2"></a>

Completare la procedura riportata di seguito per configurare ed eseguire DynamoDB sul proprio computer.

**Come configurare DynamoDB sul computer**

1. Scarica DynamoDB locale gratuitamente da una delle seguenti posizioni.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/DynamoDBLocal.DownloadingAndRunning.html)
**Importante**  
 Per eseguire DynamoDB v2.6.0 sul computer è necessaria la versione 17.x o successiva dell’ambiente di runtime Java (JRE). L'applicazione non verrà eseguita nelle versioni di JRE precedenti.

1.  Dopo aver scaricato l'archivio, estrai i contenuti e copia la directory estratta in una ubicazione a scelta. 

1.  Per avviare DynamoDB sul computer, aprire una finestra del prompt dei comandi, spostarsi nella directory in cui è stato estratto `DynamoDBLocal.jar`, quindi immettere il comando seguente. 

   ```
   java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb
   ```
**Nota**  
 Se usi Windows PowerShell, assicurati di includere il nome del parametro o l'intero nome e valore in questo modo:   
 ` java -D"java.library.path=./DynamoDBLocal_lib" -jar DynamoDBLocal.jar `   
 DynamoDB esegue le richieste in arrivo fino al suo arresto. Per arrestare DynamoDB, digitare Ctrl\$1C al prompt dei comandi.   
 DynamoDB utilizza la porta 8000 per impostazione predefinita. Se la porta 8000 non è disponibile, il comando genera un'eccezione. Per un elenco completo delle opzioni di runtime di DynamoDB, incluso `-port`, immettere il comando seguente.   
 ` java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -help ` 

1. Prima di poter accedere a AWS Command Line Interface in modo programmatico o tramite (AWS CLI), è necessario configurare le credenziali per abilitare l'autorizzazione per le applicazioni. Perché possa funzionare, la versione scaricabile di DynamoDB richiede le credenziali, come mostrato nell'esempio seguente. 

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

    È possibile utilizzare il comando `aws configure` di AWS CLI per impostare le credenziali. Per ulteriori informazioni, consulta [Utilizzando il AWS CLI](AccessingDynamoDB.md#Tools.CLI). 

1.  Inizia a scrivere le applicazioni. Per accedere a DynamoDB in esecuzione localmente con, utilizzare AWS CLI il parametro. `--endpoint-url ` Ad esempio, per elencare le tabelle DynamoDB utilizzare il seguente comando: 

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

## Esecuzione di DynamoDB locale come immagine Docker
<a name="DynamoDBLocal.DownloadingAndRunning.Docker"></a>

 La versione scaricabile di Amazon DynamoDB è disponibile come parte dell'immagine Docker. Per ulteriori informazioni, consulta [dynamodb-local](https://hub.docker.com/r/amazon/dynamodb-local). Per visualizzare la versione corrente di DynamoDB locale, immetti il seguente comando:

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

 Per un esempio di utilizzo di DynamoDB local come parte di un'applicazione REST basata su AWS SAM(), consulta Applicazione [SAM DynamoDB](https://github.com/aws-samples/aws-sam-java-rest) per AWS Serverless Application Model la gestione degli ordini. Questa applicazione di esempio mostra come utilizzare DynamoDB locale per i test. 

 Se desideri eseguire un'applicazione multi-container che utilizza anche il container DynamoDB Local, utilizza Docker Compose per definire ed eseguire tutti i servizi nell'applicazione, incluso DynamoDB Local. 

**Per installare ed eseguire DynamoDB in locale con Docker Compose:**

1.  Scarica e installa [Docker Desktop](https://www.docker.com/products/docker-desktop). 

1.  Copiare il codice seguente in un file e salvarlo con nome `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
   ```

    Se vuoi che l'applicazione e DynamoDB locale si trovino in container separati, utilizza il file yaml seguente. 

   ```
   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
   ```

    Lo script docker-compose.yml crea un container `app-node` e un container `dynamodb-local`. Lo script esegue un comando nel container `app-node` che utilizza la AWS CLI per connettersi al container `dynamodb-local` e descrive i limiti di account e tabelle. 

    Per utilizzarlo con la propria immagine dell'applicazione, sostituire il valore `image` nell'esempio seguente con quello dell'applicazione: 

   ```
   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'
   ```
**Nota**  
 Gli script YAML richiedono di specificare una chiave di AWS accesso e una chiave AWS segreta, ma non devono essere AWS chiavi valide per accedere a DynamoDB locale. 

1.  Emettere il seguente comando dalla riga di comando: 

   ```
   docker-compose up
   ```

## Esecuzione di DynamoDB locale come dipendenza Apache Maven
<a name="DynamoDBLocal.DownloadingAndRunning.Maven.v2"></a>

**Nota**  
Se stai migrando un’applicazione che utilizza l’SDK per Java v1.x all’SDK per Java 2.x, segui la procedura per [SDK AWS per Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html).

 Completare la seguente procedura per utilizzare Amazon DynamoDB nell'applicazione come dipendenza. 

**Come distribuire DynamoDB come repository Apache Maven**

1.  Scarica e installa Apache Maven. Per ulteriori informazioni, consulta le pagine relative al [download di Apache Maven](https://maven.apache.org/download.cgi) e all'[installazione di Apache Maven](https://maven.apache.org/install.html). 

1.  Aggiungi il repository Maven DynamoDB al file POM (Project Object Model) dell'applicazione: 

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

    Modello di esempio da utilizzare con Spring Boot 3 Spring Framework 6: and/or 

   ```
   <?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>
   ```
**Nota**  
 Puoi anche utilizzare l'URL di [Maven Central Repository](https://mvnrepository.com/artifact/com.amazonaws/DynamoDBLocal?repo=dynamodb-local-release). 

## Esegui DynamoDB in locale in AWS CloudShell
<a name="DynamoDBLocal.DynamoDB.Local.CloudShell"></a>

AWS CloudShell è una shell preautenticata basata su browser che puoi avviare direttamente da. Console di gestione AWSÈ possibile accedere AWS CloudShell da diversi modi Console di gestione AWS . Per ulteriori informazioni, consulta [Guida introduttiva AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/getting-started.html).

Segui questi passaggi per eseguire DynamoDB localmente ovunque AWS CloudShell nel. Console di gestione AWS

**Per eseguire DynamoDB in locale nel AWS CloudShell Console di gestione AWS**

1. Avvia AWS CloudShell dall'interfaccia della console, scegli una shell disponibile Regione AWS e passa alla shell preferita, come Bash o la shell PowerShell Z.

1. Per sceglierne una Regione AWS, vai al menu **Seleziona una regione** e seleziona una [supportata Regione AWS](https://docs.aws.amazon.com/cloudshell/latest/userguide/supported-aws-regions.html). (Le Regioni disponibili sono evidenziate.)

1. Da Console di gestione AWS, avvia AWS CloudShell scegliendo una delle seguenti opzioni:

   1. Nella barra di navigazione seleziona l’icona **AWS CloudShell**.

   1. Nella casella **Cerca**, inserisci la parola CloudShell, quindi scegli **CloudShell**.

   1. Nel widget **Visitato di recente**, scegli **CloudShell**.

   1. Dalla barra degli strumenti della console, scegli **CloudShell**.

1. Per eseguire DynamoDB AWS CloudShell in locale puoi usare l'alias. `dynamodb-local` È possibile specificare opzioni aggiuntive della riga di comando per modificare le impostazioni di DynamoDB locale. Consulta [Note per l'utilizzo locale di DynamoDB](DynamoDBLocal.UsageNotes.md) per conoscere le opzioni disponibili.
**Nota**  
Per eseguire DynamoDB in locale in background, esegui DynamoDB local utilizzando:. AWS CloudShell `dynamodb-local &`

1. Per accedere a DynamoDB AWS CloudShell in esecuzione localmente con, utilizzare AWS CLI il parametro. `--endpoint-url` Ad esempio, per elencare le tabelle DynamoDB utilizza il seguente comando:

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

Per un esempio di progetto che mostra diversi approcci per configurare e utilizzare DynamoDB locale, tra cui il download di file JAR, l’esecuzione come immagine Docker e l’utilizzo come dipendenza Maven, consulta [DynamoDB Local Sample Java Project.](https://github.com/awslabs/amazon-dynamodb-local-samples/tree/main)