As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Configure um projeto Apache Maven que use o AWS SDK for Java 2.x
<a name="setup-project-maven"></a>

O [Apache Maven](https://maven.apache.org/) pode ser usado para configurar e criar projetos do AWS SDK for Java 2.x ou [criar o próprio SDK](https://github.com/aws/aws-sdk-java-v2/tree/master#building-from-source).

## Pré-requisitos
<a name="prerequisitesmaven"></a>

Para usar o SDK para Java 2.x com o Maven, você precisa do seguinte:
+ Java *8.0 ou posterior*. Você pode baixar o software Java SE Development Kit mais recente em [http://www.oracle. com/technetwork/java/javase/downloads](https://www.oracle.com/java/technologies/downloads/)/. O SDK para Java 2.x também funciona com o [OpenJDK](https://openjdk.org/) Amazon Corretto e, uma distribuição do Open Java Development Kit (OpenJDK). Baixe a versão mais recente do OpenJDK em. [https://openjdk.java.net/install/index.html](https://openjdk.org/install/index.html) Baixe a versão Amazon Corretto 8 ou Amazon Corretto 11 mais recente [da Corretto página](https://aws.amazon.com/corretto/).
+  *Apache Maven*. Se você precisar instalar o Maven, acesse [http://maven.apache.org/](https://maven.apache.org/) para baixá-lo.

## Criar um projeto Maven
<a name="create-maven-project"></a>

Para criar um projeto Maven com a linha de comando, execute o seguinte comando em um terminal ou janela de prompt de comando ````.

```
mvn -B archetype:generate \
 -DarchetypeGroupId=software.amazon.awssdk \
 -DarchetypeArtifactId=archetype-lambda -Dservice=s3 -Dregion=US_WEST_2 \
 -DarchetypeVersion=2.X.X \
 -DgroupId=com.example.myapp \
 -DartifactId=myapp
```

**nota**  
Substitua *com.example.myapp* pelo namespace do pacote completo do aplicativo. Substitua *myapp* pelo nome do projeto. Esse será o nome do diretório do projeto.  
Para usar a versão mais recente do arquétipo, *2.X.X* substitua pela [mais recente do Maven](https://central.sonatype.com/artifact/software.amazon.awssdk/archetype-lambda) central.

Esse comando cria um projeto do Maven usando o kit de ferramentas de modelo do arquétipo. O arquétipo gera o andaime para um AWS Lambda projeto de manipulador de funções. Esse arquétipo de projeto é pré-configurado para compilar com Java SE 8 e inclui uma dependência para a versão do SDK para Java 2.x especificada por `-DarchetypeVersion`.

Para obter mais informações sobre como criar e configurar projetos do Maven, consulte o [Maven Getting Started Guide](https://maven.apache.org/guides/getting-started/).

## Configurar o compilador Java para Maven
<a name="configure-maven-compiler"></a>

Se você criou seu projeto usando o arquétipo do AWS Lambda projeto conforme descrito anteriormente, a configuração do compilador Java já foi feita para você.

Para verificar se a configuração está presente, primeiro abra o arquivo `pom.xml` da pasta do projeto que você criou (por exemplo, `myapp`) ao executar o comando anterior. Veja as linhas 11 e 12 para confirmar a configuração da versão do compilador Java desse projeto Maven, e a inclusão necessária do plugin do compilador Maven nas linhas 71-75.

```
<project>
  <properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>${maven.compiler.plugin.version}</version>
      </plugin>
    </plugins>
  </build>
</project>
```

Se você criar seu projeto com um arquétipo diferente ou por outro método, certifique-se de que o plug-in do compilador Maven faz parte da compilação e que suas propriedades de origem e destino estão definidas como **1.8** no `pom.xml` arquivo.

Consulte o snippet anterior para ver uma maneira de definir essas configurações necessárias.

Como opção, você pode configurar o compilador em linha com a declaração do plugin, como a seguir.

```
<project>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>
```

## Declarar o SDK como dependência
<a name="sdk-as-dependency"></a>

Para usar o AWS SDK para Java em seu projeto, você precisa declará-lo como uma dependência no arquivo do `pom.xml` seu projeto.

Se você criou seu projeto usando o arquétipo de projeto conforme descrito anteriormente, a versão mais recente do SDK já está configurada como uma dependência no projeto. 

O arquétipo gera uma dependência de artefato da BOM (lista de materiais) para o ID do grupo `software.amazon.awssdk`. Com uma BOM, você não precisa especificar a versão do Maven para dependências de artefatos individuais que compartilham o mesmo ID de grupo.

Se você criou seu projeto do Maven de maneira diferente, configure a versão mais recente do SDK para seu projeto garantindo que o arquivo `pom.xml` contenha o seguinte.

```
<project>
  <properties>
    <aws.java.sdk.version>2.X.X</aws.java.sdk.version>
  </properties>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>bom</artifactId>
        <version>${aws.java.sdk.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
</project>
```

**nota**  
*2.X.X*Substitua o `pom.xml` arquivo pela [versão mais recente do AWS SDK for Java 2.x](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).

## Definir dependências para módulos do SDK
<a name="modules-dependencies"></a>

Agora que você configurou o SDK, pode adicionar dependências para um ou mais dos AWS SDK para Java módulos para usar em seu projeto.

Como você já declarou a versão do SDK na seção `dependencyManagement` usando o artefato da lista de materiais, não é necessário especificar o número da versão de cada componente. Para carregar uma versão diferente de um módulo, especifique um número de versão para a dependência dele.

Se você criou o projeto usando o arquétipo de projeto conforme descrito anteriormente, ele já está configurado com várias dependências. Isso inclui dependências para manipuladores de funções do AWS Lambda e Amazon S3, conforme a seguir.

```
<project>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>netty-nio-client</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>apache-client</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>url-connection-client</artifactId>
        </dependency>

        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-lambda-java-core</artifactId>
            <version>${aws.lambda.java.version}</version>
        </dependency>
    </dependencies>
</project>
```

**nota**  
No exemplo `pom.xml` acima, as dependências são de `groupId`s diferentes. A dependência `s3` é de `software.amazon.awssdk`, enquanto a dependência `aws-lambda-java-core` é de `com.amazonaws`. A configuração do gerenciamento de dependências da BOM afeta os artefatos para `software.amazon.awssdk`, então é necessária uma versão para o artefato `aws-lambda-java-core`.  
Para o desenvolvimento de *manipuladores de função do Lambda* usando o SDK para Java 2.x, a dependência correta é `aws-lambda-java-core`. No entanto, se seu aplicativo precisar gerenciar recursos do Lambda usando operações como `listFunctions`, `deleteFunction`, `invokeFunction` e `createFunction`, seu aplicativo exigirá a dependência a seguir.   

```
<groupId>software.amazon.awssdk</groupId>
<artifactId>lambda</artifactId>
```

**nota**  
A dependência `s3` exclui as dependências transitivas `netty-nio-client` e `apache-client`. No lugar de qualquer um desses clientes HTTP, o arquétipo inclui a dependência `url-connection-client`, que ajuda a [reduzir a latência de inicialização das funções do AWS Lambda](lambda-optimize-starttime.md#lambda-quick-url).

Adicione os módulos ao seu projeto para obter os recursos AWS service (Serviço da AWS) e os recursos necessários para seu projeto. Os módulos (dependências) que são gerenciados pela BOM do AWS SDK para Java estão listados no [repositório central do Maven](https://central.sonatype.com/artifact/software.amazon.awssdk/bom).

**nota**  
Para determinar quais dependências você precisa para o projeto, veja o arquivo `pom.xml` de um exemplo de código. [Por exemplo, se você estiver interessado nas dependências do serviço DynamoDB, [veja esse](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/dynamodb/pom.xml) exemplo no Repositório de exemplos de AWS código em.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2) GitHub (Procure o arquivo `pom.xml` em [/javav2/example\$1code/dynamodb](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb).)

### Desenvolver todo o SDK no projeto
<a name="build-the-entire-sdk-into-your-project"></a>

Para otimizar o aplicativo, recomendamos que você extraia apenas os componentes de que precisa, em vez de todo o SDK. No entanto, para AWS SDK para Java incorporar tudo em seu projeto, declare-o em seu `pom.xml` arquivo, da seguinte maneira.

```
<project>
  <dependencies>
    <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>aws-sdk-java</artifactId>
      <version>2.X.X</version>
    </dependency>
  </dependencies>
</project>
```

## Compilar o projeto
<a name="build-project"></a>

Depois de configurar o arquivo `pom.xml`, você poderá usar o Maven para desenvolver o projeto.

Para criar o projeto Maven pela linha de comando, abra uma janela de terminal ou prompt de comando, navegue até o diretório dele (por exemplo, `myapp`), insira ou cole o comando abaixo e pressione Enter ou Return.

```
mvn package
```

Isso criará um único arquivo (JAR) `.jar` no diretório `target` (por exemplo, `myapp/target`). Esse JAR conterá todos os módulos SDK especificados como dependências no arquivo `pom.xml`.