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.
Migrazione da DynamoDB local V2.x a V3.x richiede l'aggiornamento delle dichiarazioni di importazione da `com.amazonaws.services.dynamodbv2` a `software.amazon.dynamodb` e l'aggiornamento delle dipendenze di 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.



<table>
<thead>
  <tr><th>Collegamenti per il download</th><th>Checksum</th></tr>
</thead>
<tbody>
  <tr><td> <a href="https://d1ni2b6xgvw0s0.cloudfront.net/v2.x/dynamodb_local_latest.tar.gz">.tar.gz</a> | <a href="https://d1ni2b6xgvw0s0.cloudfront.net/v2.x/dynamodb_local_latest.zip">.zip</a> </td><td> <a href="https://d1ni2b6xgvw0s0.cloudfront.net/v2.x/dynamodb_local_latest.tar.gz.sha256">.tar.gz.sha256</a> | <a href="https://d1ni2b6xgvw0s0.cloudfront.net/v2.x/dynamodb_local_latest.zip.sha256">.zip.sha256</a> </td></tr>
</tbody>
</table>

**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 utilizzi Windows PowerShell, assicurati di racchiudere il nome del parametro o l'intero nome e valore in questo modo:   
 ` java "-Djava.library.path=./DynamoDBLocal_lib" -jar DynamoDBLocal.jar `   
 DynamoDB esegue le richieste in arrivo fino al suo arresto. Per arrestare DynamoDB, digitare Ctrl\+C 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 [Utilizzo di AWS CLI](AccessingDynamoDB.md#Tools.CLI). 

1.  Inizia a scrivere le applicazioni. Per accedere a DynamoDB in esecuzione localmente con AWS CLI, usa `--endpoint-url ` parametro. 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 Serverless Application Model (AWS SAM), vedi [Applicazione SAM DynamoDB per la gestione degli ordini](https://github.com/aws-samples/aws-sam-java-rest). 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. 

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

   ```
   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 un AWS chiave di accesso e un AWS chiave segreta, ma non è necessario che siano valide AWS chiavi per accedere a DynamoDB in 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.2</version>
      </dependency>
   </dependencies>
   ```

    Modello di esempio da utilizzare con 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.2</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 localmente 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. Puoi navigare su AWS CloudShell dal Console di gestione AWS alcuni modi diversi. Per ulteriori informazioni, vedere [Guida introduttiva con AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/getting-started.html).

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

**Per eseguire DynamoDB localmente nel tuo AWS CloudShell nel Console di gestione AWS**

1. Avviare AWS CloudShell dall'interfaccia della console, scegli una disponibile Regione AWS e passa alla tua shell preferita, come Bash, PowerShello shell Z.

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

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

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

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

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

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

1. Per eseguire DynamoDB localmente in AWS CloudShell puoi usare `dynamodb-local` alias. È 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 local in background, esegui DynamoDB local in AWS CloudShell utilizzando: `dynamodb-local &`.

1. Per accedere a DynamoDB in esecuzione localmente in AWS CloudShell con AWS CLI, usa il `--endpoint-url` parametro. 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)