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á. # Conceitos básicos do AWS SDK para Java 2.x As seções deste tópico orientam você pelas etapas essenciais para começar a criar aplicações Java que se conectam ao AWS service (Serviço da AWS). As seções abordam a configuração do ambiente de desenvolvimento com Java e ferramentas de criação, como Maven ou Gradle, a configuração da autenticação segura na AWS e a criação de sua primeira aplicação funcional por meio de um tutorial prático. Esse tópico para iniciantes serve como seu ponto de entrada para o desenvolvimento com Java da AWS, fornecendo a base necessária antes de examinar recursos mais avançados. **Contents** + [ # Configuração do AWS SDK para Java 2.x ](setup.md) + [ ## Visão geral da configuração ](setup.md#setup-overview) + [ # Instale o Java e uma ferramenta de construção para trabalhar com o AWS SDK for Java 2.x ](setup-java-buildtool.md) + [ # Configure um projeto Apache Maven que use o AWS SDK for Java 2.x ](setup-project-maven.md) + [ ## Pré-requisitos ](setup-project-maven.md#prerequisitesmaven) + [ ## Criar um projeto Maven ](setup-project-maven.md#create-maven-project) + [ ## Configurar o compilador Java para Maven ](setup-project-maven.md#configure-maven-compiler) + [ ## Declarar o SDK como dependência ](setup-project-maven.md#sdk-as-dependency) + [ ## Definir dependências para módulos do SDK ](setup-project-maven.md#modules-dependencies) + [ ### Desenvolver todo o SDK no projeto ](setup-project-maven.md#build-the-entire-sdk-into-your-project) + [ ## Compilar o projeto ](setup-project-maven.md#build-project) + [ # Configure um projeto Gradle que use o AWS SDK for Java 2.x ](setup-project-gradle.md) + [ # Configure um projeto GraalVM Native Image que use o AWS SDK for Java 2.x ](setup-project-graalvm.md) + [ ## Pré-requisitos ](setup-project-graalvm.md#setup-graalvmnativeimage-prereq) + [ ## Crie um projeto usando o arquétipo ](setup-project-graalvm.md#setup-graalvmnativeimage-project) + [ ## Crie uma imagem nativa ](setup-project-graalvm.md#build-graalvmnativeimage-project) + [ # Autenticando com o AWS uso do AWS SDK for Java 2.x ](get-started-auth.md) + [ ## Configurar a autenticação ](get-started-auth.md#setup-auth) + [ ### 1. Desenvolvimento local usando credenciais de curto prazo ](get-started-auth.md#setup-login) + [ ### 2. Configurar acesso de autenticação única para o SDK ](get-started-auth.md#setup-credentials) + [ ### 3. Faça login usando o AWS CLI ](get-started-auth.md#setup-login-sso) + [ ## Opções de autenticação adicionais ](get-started-auth.md#setup-additional) + [ # Criando um aplicativo simples usando o AWS SDK for Java 2.x ](get-started-tutorial.md) + [ ## Etapa 1: configurar para este tutorial ](get-started-tutorial.md#get-started-setup) + [ ## Etapa 2: criar o projeto ](get-started-tutorial.md#get-started-projectsetup) + [ ## Etapa 3: escrever o código ](get-started-tutorial.md#get-started-code) + [ ## Etapa 4: compilar e executar o aplicativo ](get-started-tutorial.md#get-started-run) + [ ### Bem-sucedida ](get-started-tutorial.md#get-started-success) + [ ### Limpeza ](get-started-tutorial.md#cleanup) + [ ## Próximas etapas ](get-started-tutorial.md#get-started-next) # Configuração do AWS SDK para Java 2.x Esta seção fornece informações sobre como configurar o ambiente de desenvolvimento e projetos para usar o AWS SDK for Java 2.x. ## Visão geral da configuração Para desenvolver com êxito aplicativos que acessem os Serviços da AWS usando o AWS SDK para Java, as seguintes condições são necessárias: + O Java SDK deve ter acesso às credenciais para [autenticar solicitações](get-started-auth.md#setup-auth) em seu nome. + As [permissões do perfil do IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) configuradas no SDK devem permitir o acesso aos Serviços da AWS que seu aplicativo exige. As permissões associadas à política gerenciada **PowerUserAccess** da AWS são suficientes para a maioria das necessidades de desenvolvimento. + Um ambiente de desenvolvimento com os seguintes elementos: + [Arquivos de configuração compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) que são configurados de pelo menos uma das seguintes formas: + O arquivo `config` contém as [configurações de login único do Centro de Identidade do IAM](get-started-auth.md#setup-credentials) para que o SDK possa obter as credenciais da AWS. + O arquivo `credentials` contém credenciais temporárias. + Uma [instalação do Java 8](setup-java-buildtool.md) ou posterior. + Uma [ferramenta de automação de compilação](setup-java-buildtool.md), como [Maven](https://maven.apache.org/download.cgi) ou [Gradle](https://gradle.org/install/). + Um editor de texto para trabalhar com código. + (Opcional, mas recomendado) Um IDE (ambiente de desenvolvimento integrado), como [IntelliJ IDEA](https://www.jetbrains.com/idea/download/#section=windows), [Eclipse](https://www.eclipse.org/ide/) ou [NetBeans](https://netbeans.apache.org/front/main/download/index.html). Se você usa o IntelliJ IDEA, também pode adicionar o [AWS Toolkit para IntelliJ IDEA](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html) para integrar Serviços da AWS diretamente ao IDE a fim de otimizar o desenvolvimento. + Uma sessão ativa do portal de acesso da AWS quando você estiver pronto para executar seu aplicativo. Use a AWS Command Line Interface para [iniciar o processo de login](get-started-auth.md#setup-login-sso) no portal de acesso do Centro de Identidade do AWS IAM. **Importante** As instruções nesta seção de configuração pressupõem que você ou a organização usam o IAM Identity Center. Se sua organização usa um provedor de identidades externo que funciona independentemente do IAM Identity Center, descubra como você pode obter credenciais temporárias para o SDK para Java usar. Siga [estas instruções](credentials-temporary.md#credentials-temporary-from-portal) para adicionar credenciais temporárias ao arquivo `~/.aws/credentials`. Se seu provedor de identidade adicionar credenciais temporárias automaticamente ao arquivo `~/.aws/credentials`, certifique-se de que o nome do perfil seja `[default]` para que você não precise fornecer um nome de perfil ao SDK ou à AWS CLI. # Instale o Java e uma ferramenta de construção para trabalhar com o AWS SDK for Java 2.x Você precisa dos seguintes requisitos do ambiente de desenvolvimento Java 2.x para trabalhar com o SDK para Java 2.x: + Java 8 ou posterior. AWS SDK para Java [Funciona com o [Oracle Java SE Development Kit](https://www.oracle.com/java/technologies/downloads/) e com distribuições do Open Java Development Kit (OpenJDK) [Amazon Corretto](https://aws.amazon.com/corretto/), como [Red](https://developers.redhat.com/products/openjdk/overview) Hat OpenJDK e Adoptium.](https://adoptium.net/) + Ferramentas de criação compatíveis com o Maven, como Apache Maven, Apache Ant with Ivy, Gradle ou IntelliJ. + Para obter informações sobre como instalar e usar o Maven, consulte [https://maven.apache.org/](https://maven.apache.org/). + Consulte informações sobre como instalar e usar o Apache Ivy em [https://ant.apache.org/ivy/](https://ant.apache.org/ivy/). + Para obter informações sobre como instalar e usar o Gradle, consulte [https://gradle.org/](https://gradle.org/). + Para obter informações sobre como instalar e usar o IntelliJ IDEA, consulte. [https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/) # Configure um projeto Apache Maven que use o AWS SDK for Java 2.x 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 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 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 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. ``` 1.8 1.8 org.apache.maven.plugins maven-compiler-plugin ${maven.compiler.plugin.version} ``` 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. ``` org.apache.maven.plugins maven-compiler-plugin 1.8 1.8 ``` ## Declarar o SDK como dependência 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. ``` 2.X.X software.amazon.awssdk bom ${aws.java.sdk.version} pom import ``` **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 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. ``` software.amazon.awssdk s3 software.amazon.awssdk netty-nio-client software.amazon.awssdk apache-client software.amazon.awssdk url-connection-client com.amazonaws aws-lambda-java-core ${aws.lambda.java.version} ``` **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. ``` software.amazon.awssdk lambda ``` **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 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. ``` software.amazon.awssdk aws-sdk-java 2.X.X ``` ## Compilar o projeto 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`. # Configure um projeto Gradle que use o AWS SDK for Java 2.x Você pode usar o [Gradle](https://gradle.org/) para configurar e criar projetos do AWS SDK for Java 2.x . As etapas iniciais no exemplo a seguir vêm do [Guia de conceitos básicos do Gradle](https://docs.gradle.org/current/samples/sample_building_java_applications.html) para a versão 8.4. O uso de uma versão diferente pode gerar pequenas variações nos resultados. **Para criar um aplicativo Java com o Gradle (linha de comando)** 1. Crie um diretório para armazenar seu projeto. Neste exemplo, o nome do diretório é `demo`. 1. Dentro do diretório `demo`, execute o comando `gradle init` e forneça os valores destacados em vermelho, conforme mostrado na saída da linha de comando a seguir. Para a demonstração, foi escolhido o Kotlin como a linguagem DSL do script de construção, mas um exemplo completo do Groovy também é mostrado no fim deste tópico. ``` > gradle init Starting a Gradle Daemon (subsequent builds will be faster) Select type of project to generate: 1: basic 2: application 3: library 4: Gradle plugin Enter selection (default: basic) [1..4] 2 Select implementation language: 1: C++ 2: Groovy 3: Java 4: Kotlin 5: Scala 6: Swift Enter selection (default: Java) [1..6] 3 Generate multiple subprojects for application? (default: no) [yes, no] no Select build script DSL: 1: Kotlin 2: Groovy Enter selection (default: Kotlin) [1..2] Select test framework: 1: JUnit 4 2: TestNG 3: Spock 4: JUnit Jupiter Enter selection (default: JUnit Jupiter) [1..4] 4 Project name (default: demo): Source package (default: demo): Enter target version of Java (min. 7) (default: 11): Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] > Task :init To learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.4/samples/sample_building_java_applications.html BUILD SUCCESSFUL in 3m 43s 2 actionable tasks: 2 executed ``` 1. Após a conclusão da tarefa `init`, o diretório `demo` conterá a seguinte estrutura em árvore. Examinaremos mais de perto o arquivo de compilação principal `build.gradle.kts` (destacado em vermelho) na próxima seção. ``` ├── app │   ├── build.gradle.kts │   └── src │   ├── main │   │   ├── java │   │   │   └── demo │   │   │   └── App.java │   │   └── resources │   └── test │   ├── java │   │   └── demo │   │   └── AppTest.java │   └── resources ├── gradle │   └── wrapper │   ├── gradle-wrapper.jar │   └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat └── settings.gradle.kts ``` O arquivo `build.gradle.kts` contém o seguinte conteúdo gerado automaticamente. ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. application } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { // Use JUnit Jupiter for testing. testImplementation("org.junit.jupiter:junit-jupiter:5.9.3") testRuntimeOnly("org.junit.platform:junit-platform-launcher") // This dependency is used by the application. implementation("com.google.guava:guava:33.3.0-jre") } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion.set(JavaLanguageVersion.of(11)) } } application { // Define the main class for the application. mainClass.set("demo.App") } tasks.named("test") { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` 1. Use o arquivo de compilação do Gradle em andaime como base para seu projeto. AWS 1. Para gerenciar as dependências do SDK para seu projeto Gradle, adicione a lista de materiais (BOM) do Maven AWS SDK for Java 2.x à `dependencies` seção do arquivo. `build.gradle.kts` ``` ... dependencies { implementation(platform("software.amazon.awssdk:bom:2.27.21")) // With the bom declared, you specify individual SDK dependencies without a version. ... } ... ``` **nota** Neste exemplo de arquivo de compilação, substitua *2.27.21* pela versão mais recente do SDK for Java 2.x. Encontre a versão mais recente disponível no [repositório central do Maven](https://central.sonatype.com/artifact/software.amazon.awssdk/bom/versions). 1. Especifique os módulos do SDK que seu aplicativo precisa na seção `dependencies`. O exemplo a seguir adiciona uma dependência do Amazon Simple Storage Service. ``` ... dependencies { implementation(platform("software.amazon.awssdk:bom:2.27.21")) implementation("software.amazon.awssdk:s3") ... } ... ``` O Gradle corrige automaticamente a versão correta das dependências declaradas usando as informações da BOM. Os exemplos a seguir mostram arquivos de compilação completos do Gradle no Kotlin e no Groovy. DSLs O arquivo de compilação contém dependências para Amazon S3, autenticação, registro e teste. A versão de origem e destino do Java é a versão 11. ------ #### [ Kotlin DSL (build.gradle.kts) ] ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. application } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { implementation(platform("software.amazon.awssdk:bom:2.20.56")) implementation("software.amazon.awssdk:s3") implementation("software.amazon.awssdk:sso") implementation("software.amazon.awssdk:ssooidc") implementation(platform("org.apache.logging.log4j:log4j-bom:2.20.0")) implementation("org.apache.logging.log4j:log4j-slf4j2-impl") implementation("org.apache.logging.log4j:log4j-1.2-api") testImplementation(platform("org.junit:junit-bom:5.10.0")) testImplementation("org.junit.jupiter:junit-jupiter") } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion.set(JavaLanguageVersion.of(11)) } } application { // Define the main class for the application. mainClass.set("demo.App") } tasks.named("test") { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` ------ #### [ Groovy DSL (build.gradle) ] ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. id 'application' } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { implementation platform('software.amazon.awssdk:bom:2.27.21') implementation 'software.amazon.awssdk:s3' implementation 'software.amazon.awssdk:sso' implementation 'software.amazon.awssdk:ssooidc' implementation platform('org.apache.logging.log4j:log4j-bom:2.20.0') implementation 'org.apache.logging.log4j:log4j-slf4j2-impl' implementation 'org.apache.logging.log4j:log4j-1.2-api' testImplementation platform('org.junit:junit-bom:5.10.0') testImplementation 'org.junit.jupiter:junit-jupiter' } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion = JavaLanguageVersion.of(11) } } application { // Define the main class for the application. mainClass = 'demo_groovy.App' } tasks.named('test') { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` ------ Para as próximas etapas, consulte o Guia de Conceitos Básicos no site do Gradle para obter instruções sobre como [criar e executar um aplicativo do Gradle](https://docs.gradle.org/current/samples/sample_building_java_applications.html#run_the_application). # Configure um projeto GraalVM Native Image que use o AWS SDK for Java 2.x Com as versões 2.16.1 e posteriores, ele AWS SDK for Java 2.x fornece out-of-the-box suporte para aplicativos GraalVM Native Image. Use o arquétipo `archetype-app-quickstart` do Maven para configurar um projeto com suporte de imagem nativa integrado. ## Pré-requisitos + Conclua as etapas em [Configurando o AWS SDK para Java 2.x](setup.md). + Instale o [GraalVM Native Image](https://www.graalvm.org/reference-manual/native-image/#install-native-image). ## Crie um projeto usando o arquétipo Para criar um projeto do Maven com suporte de imagem nativa integrado, em uma janela de terminal ou prompt de comando, use o comando a seguir. **nota** Substitua `com.example.mynativeimageapp` pelo namespace do pacote completo do seu aplicativo. Substitua `mynativeimageapp` pelo nome do projeto. Esse será o nome do diretório do projeto. ``` mvn archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-app-quickstart \ -DarchetypeVersion=2.27.21\ -DnativeImage=true \ -DhttpClient=apache-client \ -Dservice=s3 \ -DgroupId=com.example.mynativeimageapp \ -DartifactId=mynativeimageapp \ -DinteractiveMode=false ``` Esse comando cria um projeto Maven configurado com dependências para o AWS SDK para Java Amazon S3, e o cliente `ApacheHttpClient` HTTP. Ele também inclui uma dependência para o [plug-in GraalVM Native Image do Maven](https://graalvm.github.io/native-build-tools/latest/index.html), para que você possa criar imagens nativas usando o Maven. Para incluir dependências de um serviço diferente Amazon Web Services, defina o valor do `-Dservice` parâmetro como o ID do artefato desse serviço. Os exemplos incluem `dynamodb`, `comprehend` e `pinpoint`. Para obter uma lista completa dos artefatos IDs, consulte a lista de dependências gerenciadas para [software.amazon.awssdk](https://mvnrepository.com/artifact/software.amazon.awssdk/bom/latest) no Maven Central. Para usar um cliente HTTP assíncrono, defina o parâmetro `-DhttpClient` como `netty-nio-client`. Para usar `UrlConnectionHttpClient` como cliente HTTP síncrono em vez de `apache-client`, defina o parâmetro `-DhttpClient` como `url-connection-client`. ## Crie uma imagem nativa Depois de criar o projeto, execute o comando seguinte no diretório do projeto, por exemplo, `mynativeimageapp`: ``` mvn package -P native-image ``` Isso cria um aplicativo de imagem nativa no diretório `target`, por exemplo, `target/mynativeimageapp`. # Autenticando com o AWS uso do AWS SDK for Java 2.x Você deve estabelecer como eles AWS SDK for Java 2.x se autenticam AWS quando você desenvolve com AWS os serviços. O SDK gerencia a descoberta de credenciais, a criação de assinaturas e a atualização de credenciais completamente nos bastidores, permitindo que você se concentre na lógica da sua aplicação. ## Configurar a autenticação O tópico [Autenticação e acesso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) no Guia de Referência de Ferramentas AWS SDKs e Ferramentas descreve as diferentes abordagens de autenticação. Para o desenvolvimento local, a abordagem recomendada é usar credenciais de curto prazo fazendo login na AWS CLI com as credenciais de login do console. Recomendado se você usa usuários root, do IAM ou federação com o IAM para acessar a AWS conta. Siga as instruções em [Acesse as credenciais para o trabalho de desenvolvimento interativo usando AWS SDK for Java 2.x](credentials-temporary.md). Depois de seguir as instruções AWS SDKs e o Guia de referência de ferramentas, seu sistema deve ser configurado para permitir que o SDK assine solicitações: ### 1. Desenvolvimento local usando credenciais de curto prazo Para o desenvolvimento local, a abordagem recomendada é usar credenciais de curto prazo fazendo login na AWS CLI com as credenciais de login do console. Recomendado se você usa usuários root, do IAM ou federação com o IAM para acessar a AWS conta. Para obter instruções, consulte [Usando provedores de credenciais no AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-temporary.html). ### 2. Configurar acesso de autenticação única para o SDK Depois de concluir a etapa 2 na [seção de acesso programático](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted) para que o SDK possa usar a autenticação do Centro de Identidade do IAM, o sistema deve conter os elementos a seguir. + O AWS CLI, que você usa para iniciar uma [sessão do portal de AWS acesso](#setup-login-sso) antes de executar seu aplicativo. + Um arquivo `~/.aws/config` que contém um [perfil padrão](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile). O SDK para Java usa as configurações do provedor de token de SSO do perfil para adquirir as credenciais antes de enviar solicitações à AWS. O valor `sso_role_name`, que é um perfil do IAM conectado a um conjunto de permissões do Centro de Identidade do IAM, deve permitir o acesso a Serviços da AWS usado na aplicação. O arquivo `config` de exemplo a seguir mostra um perfil padrão configurado com o provedor de token de SSO. A configuração `sso_session` do perfil se refere à seção chamada `sso-session`. A seção `sso-session` contém configurações para iniciar uma sessão do portal de acesso da AWS . ``` [default] sso_session = my-sso sso_account_id = 111122223333 sso_role_name = SampleRole region = us-east-1 output = json [sso-session my-sso] sso_region = us-east-1 sso_start_url = https://provided-domain.awsapps.com/start sso_registration_scopes = sso:account:access ``` Para obter mais detalhes sobre as configurações usadas na configuração do provedor de token SSO, consulte Configuração do [provedor de token SSO](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) no Guia de referência AWS SDKs de ferramentas. Se seu ambiente de desenvolvimento não estiver configurado para acesso programático conforme mostrado anteriormente, siga a [Etapa 2 no Guia de SDKs referência](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted). ### 3. Faça login usando o AWS CLI Antes de executar um aplicativo que acessa Serviços da AWS, você precisa de uma sessão ativa do portal de AWS acesso para que o SDK use a autenticação do IAM Identity Center para resolver as credenciais. Execute o comando a seguir no AWS CLI para entrar no portal de AWS acesso. ``` aws sso login ``` Como você tem uma configuração de perfil padrão, não precisa chamar o comando com uma opção `--profile`. Se a configuração do provedor de token de SSO estiver usando um perfil nomeado, o comando será `aws sso login --profile named-profile`. Para testar se você já tem uma sessão ativa, execute o comando da AWS CLI a seguir. ``` aws sts get-caller-identity ``` A resposta a esse comando deve relatar a conta do Centro de Identidade do IAM e o conjunto de permissões configurados no arquivo compartilhado `config`. **nota** Se você já tiver uma sessão ativa do portal de AWS acesso e executá-la`aws sso login`, não será necessário fornecer credenciais. No entanto, você verá uma caixa de diálogo solicitando permissão para que o `botocore` acesse suas informações. O `botocore` é a base para a AWS CLI . Selecione **Permitir** para autorizar o acesso às suas informações para o AWS CLI SDK for Java. ## Opções de autenticação adicionais Para obter mais opções de autenticação para o SDK, como o uso de perfis e variáveis de ambiente, consulte o capítulo de [configuração](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) no Guia de referência de ferramentas AWS SDKs e ferramentas. # Criando um aplicativo simples usando o AWS SDK for Java 2.x Este tutorial mostra como usar o [Apache Maven](https://maven.apache.org/) para definir dependências para o SDK para Java 2.x e, em seguida, escrever um código que se conecte ao Amazon S3 para fazer upload de um arquivo. Siga estas etapas para concluir este tutorial: + [Etapa 1: configurar para este tutorial](#get-started-setup) + [Etapa 2: criar o projeto](#get-started-projectsetup) + [Etapa 3: escrever o código](#get-started-code) + [Etapa 4: compilar e executar o aplicativo](#get-started-run) ## Etapa 1: configurar para este tutorial Antes de iniciar este tutorial, é necessário instalar o seguinte: + Permissão para acessar Amazon S3 + Um ambiente de desenvolvimento Java configurado para acessar Serviços da AWS usando login único ao Centro de Identidade do AWS IAM Use as instruções em [Visão geral da configuração](setup.md#setup-overview) para se preparar para este tutorial. Depois de [configurar seu ambiente de desenvolvimento com acesso de logon único](get-started-auth.md#setup-credentials) para o Java SDK e ter uma [sessão ativa do portal de AWS acesso](get-started-auth.md#setup-login-sso), continue com a Etapa 2 deste tutorial. ## Etapa 2: criar o projeto Para criar o projeto para este tutorial, você executa um comando do Maven que solicita informações sobre como configurar o projeto. Depois que todas as informações forem inseridas e confirmadas, o Maven conclui a construção do projeto criando um `pom.xml` e cria arquivos Java stub. 1. Abra uma janela de terminal ou prompt de comando e navegue até um diretório de sua escolha, por exemplo, sua pasta `Desktop` ou `Home`. 1. Insira o seguinte comando no terminal e pressione `Enter`. ``` mvn archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-app-quickstart \ -DarchetypeVersion=2.27.21 ``` 1. Insira o valor listado na segunda coluna para cada solicitação. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/get-started-tutorial.html) 1. Depois que o último valor é inserido, o Maven lista as escolhas que você fez. Confirme informando *`Y`* ou reinsira valores informando *`N`*. O Maven cria a pasta do projeto chamada `getstarted` com base no valor de `artifactId` que você informou. Dentro da pasta `getstarted`, encontre um arquivo `README.md` que você possa revisar, um arquivo `pom.xml` e um diretório `src`. O Maven cria a árvore de diretórios a seguir. ``` getstarted ├── README.md ├── pom.xml └── src ├── main │   ├── java │   │   └── org │   │   └── example │   │   ├── App.java │   │   ├── DependencyFactory.java │   │   └── Handler.java │   └── resources │   └── simplelogger.properties └── test └── java └── org └── example └── HandlerTest.java 10 directories, 7 files ``` O exemplo a seguir mostra o conteúdo do arquivo de projeto `pom.xml`. ### `pom.xml` A seção `dependencyManagement` contém uma dependência do AWS SDK for Java 2.x e a seção `dependencies` tem uma dependência do Amazon S3. O projeto usa o Java 1.8 devido ao valor `1.8` nas propriedades `maven.compiler.source` e `maven.compiler.target`. ``` 4.0.0 org.example getstarted 1.0-SNAPSHOT jar UTF-8 1.8 1.8 3.2.1 3.6.1 1.6.0 2.27.21 <-------- SDK version picked up from archetype version. 1.7.28 5.8.1 software.amazon.awssdk bom ${aws.java.sdk.version} pom import software.amazon.awssdk s3 <-------- S3 dependency software.amazon.awssdk netty-nio-client software.amazon.awssdk apache-client software.amazon.awssdk sso <-------- Required for identity center authentication. software.amazon.awssdk ssooidc <-------- Required for identity center authentication. software.amazon.awssdk apache-client <-------- HTTP client specified. commons-logging commons-logging org.slf4j slf4j-api ${slf4j.version} org.slf4j slf4j-simple ${slf4j.version} org.slf4j jcl-over-slf4j ${slf4j.version} org.junit.jupiter junit-jupiter ${junit5.version} test org.apache.maven.plugins maven-compiler-plugin ${maven.compiler.plugin.version} ``` ## Etapa 3: escrever o código O código a seguir mostra a classe `App` criada pelo Maven. O método `main` é o ponto de entrada no aplicativo, que cria uma instância da classe `Handler` e, em seguida, chama seu método `sendRequest`. ### Classe `App` ``` package org.example; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class App { private static final Logger logger = LoggerFactory.getLogger(App.class); public static void main(String... args) { logger.info("Application starts"); Handler handler = new Handler(); handler.sendRequest(); logger.info("Application ends"); } } ``` A classe `DependencyFactory` criada pelo Maven contém o método de fábrica `s3Client`, que cria e exibe uma instância do [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html). A instância do `S3Client` usa uma instância do cliente HTTP baseado em Apache. Isso ocorre porque você especificou `apache-client` quando o Maven solicitou o cliente HTTP a ser usado. O `DependencyFactory` pode ser visto no código a seguir. ### Classe `DependencyFactory` ``` package org.example; import software.amazon.awssdk.http.apache.ApacheHttpClient; import software.amazon.awssdk.services.s3.S3Client; /** * The module containing all dependencies required by the {@link Handler}. */ public class DependencyFactory { private DependencyFactory() {} /** * @return an instance of S3Client */ public static S3Client s3Client() { return S3Client.builder() .httpClientBuilder(ApacheHttpClient.builder()) .build(); } } ``` A classe `Handler` contém a lógica principal do seu programa. Quando uma instância de `Handler` é criada na classe `App`, a classe `DependencyFactory` fornece o cliente de serviço do `S3Client`. Seu código usa a instância do `S3Client` para chamar o serviço do Amazon S3. O Maven gera a seguinte classe `Handler` com um comentário `TODO`. A próxima etapa do tutorial substitui o *`TODO`* pelo código. ### Classe `Handler`, gerada pelo Maven ``` package org.example; import software.amazon.awssdk.services.s3.S3Client; public class Handler { private final S3Client s3Client; public Handler() { s3Client = DependencyFactory.s3Client(); } public void sendRequest() { // TODO: invoking the api calls using s3Client. } } ``` Para preencher a lógica, substitua todo o conteúdo da classe `Handler` pelo código a seguir. O método `sendRequest` é preenchido e as importações necessárias são adicionadas. ### Classe `Handler`, implementada Primeiro, o código cria um novo bucket do S3 com a última parte do nome gerada usando `System.currentTimeMillis()` para tornar o nome do bucket exclusivo. Depois de criar o bucket no método `createBucket()`, o programa carrega um objeto usando o método [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody)) de`S3Client`. O conteúdo do objeto é uma string simples criada com o método `RequestBody.fromString`. Por fim, o programa exclui o objeto seguido pelo bucket no método `cleanUp`. ``` package org.example; import software.amazon.awssdk.core.sync.RequestBody; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.CreateBucketRequest; import software.amazon.awssdk.services.s3.model.DeleteBucketRequest; import software.amazon.awssdk.services.s3.model.DeleteObjectRequest; import software.amazon.awssdk.services.s3.model.HeadBucketRequest; import software.amazon.awssdk.services.s3.model.PutObjectRequest; import software.amazon.awssdk.services.s3.model.S3Exception; public class Handler { private final S3Client s3Client; public Handler() { s3Client = DependencyFactory.s3Client(); } public void sendRequest() { String bucket = "bucket" + System.currentTimeMillis(); String key = "key"; createBucket(s3Client, bucket); System.out.println("Uploading object..."); s3Client.putObject(PutObjectRequest.builder().bucket(bucket).key(key) .build(), RequestBody.fromString("Testing with the {sdk-java}")); System.out.println("Upload complete"); System.out.printf("%n"); cleanUp(s3Client, bucket, key); System.out.println("Closing the connection to {S3}"); s3Client.close(); System.out.println("Connection closed"); System.out.println("Exiting..."); } public static void createBucket(S3Client s3Client, String bucketName) { try { s3Client.createBucket(CreateBucketRequest .builder() .bucket(bucketName) .build()); System.out.println("Creating bucket: " + bucketName); s3Client.waiter().waitUntilBucketExists(HeadBucketRequest.builder() .bucket(bucketName) .build()); System.out.println(bucketName + " is ready."); System.out.printf("%n"); } catch (S3Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } } public static void cleanUp(S3Client s3Client, String bucketName, String keyName) { System.out.println("Cleaning up..."); try { System.out.println("Deleting object: " + keyName); DeleteObjectRequest deleteObjectRequest = DeleteObjectRequest.builder().bucket(bucketName).key(keyName).build(); s3Client.deleteObject(deleteObjectRequest); System.out.println(keyName + " has been deleted."); System.out.println("Deleting bucket: " + bucketName); DeleteBucketRequest deleteBucketRequest = DeleteBucketRequest.builder().bucket(bucketName).build(); s3Client.deleteBucket(deleteBucketRequest); System.out.println(bucketName + " has been deleted."); System.out.printf("%n"); } catch (S3Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Cleanup complete"); System.out.printf("%n"); } } ``` ## Etapa 4: compilar e executar o aplicativo Depois que o projeto for criado e contiver a classe `Handler` completa, crie e execute o aplicativo. 1. É essencial ter uma sessão ativa do IAM Identity Center. Para fazer isso, execute o AWS Command Line Interface comando `aws sts get-caller-identity` e verifique a resposta. Se você ainda não tiver uma sessão ativa, consulte [esta seção](get-started-auth.md#setup-login-sso) para obter as instruções. 1. Abra uma janela de terminal ou prompt de comando e navegue até o diretório `getstarted` do seu projeto. 1. Use o comando a seguir para compilar seu projeto: ``` mvn clean package ``` 1. Use o comando a seguir para executar o aplicativo. ``` mvn exec:java -Dexec.mainClass="org.example.App" ``` Para visualizar o novo bucket e objeto que o programa cria, execute as etapas a seguir. 1. Em `Handler.java`, comente a linha `cleanUp(s3Client, bucket, key)` no método `sendRequest` e salve o arquivo. 1. Reconstrua o projeto executando `mvn clean package`. 1. Execute `mvn exec:java -Dexec.mainClass="org.example.App"` novamente para carregar o objeto de texto mais uma vez. 1. Faça login no [console do S3](https://console.aws.amazon.com/s3/) para ver o novo objeto no bucket recém-criado. Depois de visualizar o arquivo, exclua o objeto e, em seguida, exclua o bucket. ### Bem-sucedida Se seu projeto Maven foi criado e executado sem erros, parabéns\$1 Você construiu com sucesso o primeiro aplicativo Java usando o SDK for Java 2.x. ### Limpeza Para limpar os recursos que foram criados durante este tutorial, faça o seguinte: + Se você ainda não tiver feito isso, no [console do S3](https://console.aws.amazon.com/s3/), exclua todos os objetos e buckets criados quando você executou o aplicativo. + Exclua a pasta do projeto (`getstarted`). ## Próximas etapas Agora que você entendeu o básico, poderá descobrir mais sobre o seguinte: + [Trabalhando com Amazon S3](examples-s3.md) + [Trabalhando com outros Amazon Web Services](work-with-services.md), como [DynamoDB](examples-dynamodb.md), [Amazon EC2](examples-ec2.md), e [vários serviços de banco de dados](examples-databases.md) + [Usar o SDK](using.md) + [Segurança para o AWS SDK para Java](security.md) **