# Implantar o DynamoDB localmente no computador
<a name="DynamoDBLocal.DownloadingAndRunning"></a>

**nota**  
O DynamoDB local está disponível em três versões: v3.x (atual), v2.x (legada) e v1.x (obsoleta).
O DynamoDB v3.x é recomendado para seu uso local em testes e desenvolvimento.
A migração do DynamoDB local V2.x para a V3.x requer a atualização das instruções de importação de `com.amazonaws.services.dynamodbv2` para `software.amazon.dynamodb` e a atualização das dependências do Maven para usuários do Maven.
Se você estiver migrando um aplicativo que usa o SDK para Java v1.x para o SDK para Java 2.x, siga as etapas para [AWS SDK para Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html).

## Baixar o DynamoDB local
<a name="DynamoDBLocal.DownloadingAndRunning.V2"></a>

Siga estas etapas para configurar e executar o DynamoDB em seu computador.

**Para configurar o DynamoDB em seu computador**

1. Baixe o DynamoDB local gratuitamente de um dos locais a seguir.  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/DynamoDBLocal.DownloadingAndRunning.html)
**Importante**  
 Para executar o DynamoDB v2.6.0 ou posterior no computador, é necessário ter o Ambiente de Execução Java (JRE) versão 17.x ou mais recente instalado. A aplicação não é executada em versões mais antigas do JRE.

1.  Depois de fazer download do arquivo, extraia o conteúdo e copie o diretório extraído para um local de sua escolha. 

1.  Para iniciar o DynamoDB em seu computador, abra uma janela de prompt de comando, vá para o diretório onde você extraiu o arquivo `DynamoDBLocal.jar` e insira o comando seguir. 

   ```
   java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb
   ```
**nota**  
 Se estiver usando o Windows PowerShell, inclua o nome do parâmetro ou todo o nome e valor da seguinte forma:   
 ` java -D"java.library.path=./DynamoDBLocal_lib" -jar DynamoDBLocal.jar `   
 O DynamoDB processa as solicitações de entrada até que você o interrompa. Para interromper o DynamoDB, pressione Ctrl\+C no prompt de comando.   
 O DynamoDB usa a porta 8000 por padrão. Se a porta 8000 estiver indisponível, este comando lançará uma exceção. Para obter uma lista completa das opções de tempo de execução do DynamoDB, incluindo `-port`, execute este comando.   
 ` java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -help ` 

1. Para poder acessar o DynamoDB por programação ou via AWS Command Line Interface (AWS CLI), você deve configurar suas credenciais para habilitar a autorização para suas aplicações. O DynamoDB para download requer que todas as credenciais funcionem, conforme mostrado no exemplo a seguir. 

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

    Você pode usar o comando `aws configure` da AWS CLI para configurar credenciais. Para obter mais informações, consulte [Como usar o AWS CLI](AccessingDynamoDB.md#Tools.CLI). 

1.  Comece a escrever aplicações. Para acessar o DynamoDB em execução local com a AWS CLI, use o parâmetro `--endpoint-url `. Por exemplo, use o comando a seguir para listar as tabelas do DynamoDB. 

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

## Executar o DynamoDB local como imagem do Docker
<a name="DynamoDBLocal.DownloadingAndRunning.Docker"></a>

 A versão para download do Amazon DynamoDB está disponível como uma imagem do Docker. Para obter mais informações, consulte [dynamodb-local](https://hub.docker.com/r/amazon/dynamodb-local). Para ver a versão do DynamoDB local atual, execute o seguinte comando:

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

 Para obter um exemplo de uso do DynamoDB local como parte de um aplicativo REST criado com a AWS Serverless Application Model (AWS SAM), consulte [Aplicação SAM do DynamoDB para gerenciamento de pedidos](https://github.com/aws-samples/aws-sam-java-rest). Esta aplicação de exemplo demonstra como usar o DynamoDB local para testes. 

 Se você quiser executar uma aplicação de vários contêineres que também use o contêiner local do DynamoDB, use o Docker Compose para definir e executar todos os serviços em sua aplicação, incluindo o DynamoDB local. 

**Para instalar e executar o DynamoDB local com o Docker Compose:**

1.  Baixe e instale a [área de trabalho do Docker](https://www.docker.com/products/docker-desktop). 

1.  Copie o código a seguir em um arquivo e salve-o como `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 desejar que sua aplicação e o DynamoDB local estejam em contêineres separados, use o arquivo yaml a seguir. 

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

    Este script docker-compose.yml cria um contêiner `app-node` e um contêiner `dynamodb-local`. O script executa um comando no contêiner `app-node` que usa a AWS CLI para se conectar ao contêiner `dynamodb-local` e descreve os limites da conta e da tabela. 

    Para usar com sua própria imagem de aplicação, substitua o valor `image` no exemplo abaixo pelo valor da sua aplicação. 

   ```
   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**  
 Os scripts YAML exigem que você especifique uma chave de acesso da AWS e uma chave secreta da AWS, mas elas não precisam ser chaves válidas da AWS para acessar o DynamoDB local. 

1.  Execute o seguinte comando a linha de comando: 

   ```
   docker-compose up
   ```

## Executar o DynamoDB local como dependência do Apache Maven
<a name="DynamoDBLocal.DownloadingAndRunning.Maven.v2"></a>

**nota**  
Se você estiver migrando um aplicativo que usa o SDK para Java v1.x para o SDK para Java 2.x, siga as etapas para [AWS SDK para Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html).

 Siga estas etapas para usar o Amazon DynamoDB em sua aplicação como uma dependência. 

**Para implantar o DynamoDB como um repositório do Apache Maven**

1.  Faça download do Apache Maven e instale-o. Para obter mais informações, consulte [Download do Apache Maven](https://maven.apache.org/download.cgi) e [Instalação do Apache Maven](https://maven.apache.org/install.html). 

1.  Adicione o repositório Maven do DynamoDB ao arquivo Project Object Model (POM) da sua aplicação. 

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

    Exemplo de modelo para uso com o Spring Boot 3 e/ou 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>
   ```
**nota**  
 Também é possível usar o URL do [repositório central do Maven](https://mvnrepository.com/artifact/com.amazonaws/DynamoDBLocal?repo=dynamodb-local-release). 

## Executar o DynamoDB localmente no AWS CloudShell
<a name="DynamoDBLocal.DynamoDB.Local.CloudShell"></a>

AWS CloudShell O é um shell pré-autenticado baseado em navegador que você pode iniciar diretamente do Console de gerenciamento da AWS. Você pode navegar até o AWS CloudShell por meio do Console de gerenciamento da AWS de maneiras diferentes. Para obter mais informações, consulte [Conceitos básicos do AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/getting-started.html).

Siga estas etapas para executar o DynamoDB localmente no AWS CloudShell em qualquer lugar do Console de gerenciamento da AWS. 

**Como executar o DynamoDB localmente no AWS CloudShell por meio do Console de gerenciamento da AWS**

1. Inicie o AWS CloudShell por meio da interface do console, escolhe uma Região da AWS disponível e alterne para o shell de sua preferência; por exemplo, Bash, PowerShell ou shell Z.

1. Para escolher uma Região da AWS para trabalhar, acesse o menu **Selecionar uma região** e escolha uma [Região da AWS compatível](https://docs.aws.amazon.com/cloudshell/latest/userguide/supported-aws-regions.html). (As regiões disponíveis estão em destaque.)

1. Por meio do Console de gerenciamento da AWS, é possível iniciar o AWS CloudShell escolhendo uma das opções a seguir:

   1. Na barra de navegação, escolha o ícone **AWS CloudShell**.

   1. Na caixa **Pesquisar**, insira a palavra CloudShell e escolha **CloudShell**.

   1. No widget **Visitado recentemente**, escolha **CloudShell**.

   1. Na barra de ferramentas do console, escolha **CloudShell**.

1. Para executar o DynamoDB localmente no AWS CloudShell, você pode usar o alias `dynamodb-local`. É possível especificar outras opções de linha de comando para alterar as configurações locais do DynamoDB. Consulte [Observações sobre o uso do DynamoDB local](DynamoDBLocal.UsageNotes.md) para obter as opções disponíveis.
**nota**  
Para executar o DynamoDB localmente em segundo plano, execute o DynamoDB localmente no AWS CloudShell usando `dynamodb-local &`.

1. Para acessar o DynamoDB em execução local no AWS CloudShell, use o parâmetro `--endpoint-url`. Por exemplo, use o seguinte comando para listar tabelas do DynamoDB:

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

Para ver um exemplo de projeto de amostra que mostra várias abordagens para configurar e usar o DynamoDB local, inclusive baixar arquivos JAR, executá-lo como uma imagem do Docker e usá-lo como uma dependência do Maven, consulte [DynamoDB Local Sample Java Project](https://github.com/awslabs/amazon-dynamodb-local-samples/tree/main).