AWS Cloud9 não está mais disponível para novos clientes. Os clientes atuais do AWS Cloud9 podem continuar usando o serviço normalmente. [Saiba mais](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/) 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á. # Tutorial de Java para AWS Cloud9 **Importante** Se você estiver usando um ambiente de AWS Cloud9 desenvolvimento apoiado por uma instância do EC2 com 2 GiB ou mais de memória, recomendamos que você ative o suporte aprimorado a Java. Isso fornece acesso a recursos de produtividade como preenchimento de código, linting de erros, ações específicas por contexto e opções de depuração, como pontos de interrupção e passo a passo. Para obter mais informações, consulte [Suporte aprimorado para desenvolvimento em Java](enhanced-java.md). Este tutorial permite que você execute alguns códigos Java em um ambiente de AWS Cloud9 desenvolvimento. Seguir este tutorial e criar este exemplo pode gerar cobranças em sua conta da AWS . Isso inclui possíveis cobranças por serviços como o Amazon EC2 e Amazon S3. Para obter mais informações, consulte [Preço do Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Preço do Amazon S3](https://aws.amazon.com/s3/pricing/). **Topics** + [Pré-requisitos](#sample-java-prerequisites) + [Etapa 1: Instalar as ferramentas necessárias](#sample-java-install) + [Etapa 2: Adicionar código](#sample-java-code) + [Etapa 3: Compilar e executar o código](#sample-java-run) + [Etapa 4: configurar para usar o AWS SDK para Java](#sample-java-sdk) + [Etapa 5: configurar o gerenciamento de AWS credenciais em seu ambiente](#sample-java-sdk-creds) + [Etapa 6: adicionar código AWS SDK](#sample-java-sdk-code) + [Etapa 7: criar e executar o código do AWS SDK](#sample-java-sdk-run) + [Etapa 8: Limpeza](#sample-java-clean-up) ## Pré-requisitos Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir. + **Você deve ter um ambiente de desenvolvimento AWS Cloud9 EC2 existente.** Este exemplo pressupõe que você já tem um ambiente do EC2 conectado a uma instância do Amazon EC2 que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para obter mais informações, consulte [Criando um ambiente em AWS Cloud9](create-environment.md). + **Você tem o AWS Cloud9 IDE para o ambiente existente já aberto.** Quando você abre um ambiente, AWS Cloud9 abre o IDE desse ambiente em seu navegador da web. Para obter mais informações, consulte [Abrindo um ambiente em AWS Cloud9](open-environment.md). ## Etapa 1: Instalar as ferramentas necessárias Nesta etapa, você instala um conjunto de ferramentas de desenvolvimento Java em seu ambiente de AWS Cloud9 desenvolvimento. Se você já tiver um conjunto de ferramentas de desenvolvimento Java, como o Oracle JDK ou o OpenJDK instalado em seu ambiente, avance para [Etapa 2: Adicionar código](#sample-java-code). Esse exemplo foi desenvolvido com o OpenJDK 8, que você pode instalar em seu ambiente, após concluir o procedimento a seguir. 1. Confirme se o OpenJDK 8 já está instalado. Para fazer isso, em uma sessão de terminal no AWS Cloud9 IDE, execute a versão da linha de comando do executor Java com a **`-version`**opção. (Para iniciar uma nova sessão de terminal, na barra de menus, selecione **Janela**, **Novo terminal**.) ``` java -version ``` Com base na saída do comando anterior, siga um destes procedimentos: + Se a saída afirmar que o comando `java` não foi encontrado, vá para a etapa 2 deste procedimento para instalar o OpenJDK 8. + Se a saída tiver valores começando com `Java(TM)`, `Java Runtime Environment`, `Java SE`, `J2SE` ou `Java2`, o OpenJDK não está instalado ou não foi definido como o conjunto de ferramentas de desenvolvimento Java padrão. Continue na etapa 2 deste procedimento para instalar o OpenJDK 8 e, em seguida, mude para usar o OpenJDK 8. + Se o resultado contiver valores que começam com `java version 1.8` e `OpenJDK`, avance para [Etapa 2: Adicionar código](#sample-java-code). O OpenJDK 8 está instalado corretamente para este exemplo. + Se a saída tiver um `java version` menor que `1.8` e valores começando com `OpenJDK`, vá para a etapa 2 deste procedimento para atualizar a versão do OpenJDK instalado para o OpenJDK 8. 1. Verifique se as últimas atualizações de segurança e correções de bugs estão instaladas. Para fazer isso, execute a ferramenta yum (para Amazon Linux) ou a ferramenta apt (para Ubuntu Server) com o comando ** `update` **. Para Amazon Linux: ``` sudo yum -y update ``` Para Ubuntu Server: ``` sudo apt update ``` 1. Instale o OpenJDK 8. Para fazer isso, execute a ferramenta yum (para Amazon Linux) ou a ferramenta apt (para Ubuntu Server) com o comando ** `install` **, especificando o pacote OpenJDK 8. Para Amazon Linux: ``` sudo yum -y install java-1.8.0-openjdk-devel ``` Para Ubuntu Server: ``` sudo apt install -y openjdk-8-jdk ``` Para obter mais informações, consulte [How to download and install prebuilt OpenJDK packages](https://openjdk.org/install/) (Como baixar e instalar pacotes OpenJDK pré-compilados) no site do OpenJDK. 1. Alterne ou atualize o conjunto de ferramentas de desenvolvimento Java padrão para o OpenJDK 8. Para fazer isso, execute o comando ** `update-alternatives` ** com a opção ** `--config` **. Execute esse comando duas vezes para alternar ou atualizar as versões de linha de comando do executor e do compilador Java. ``` sudo update-alternatives --config java sudo update-alternatives --config javac ``` Em cada prompt, digite o número da seleção para o OpenJDK 8 (o que contém `java-1.8`). 1. Confirme se as versões de linha de comando do executor e do compilador Java estão usando o OpenJDK 8. Para fazer isso, execute as versões de linha de comando do executor e do compilador Java com a opção `-version`. ``` java -version javac -version ``` Se o OpenJDK 8 estiver instalado e configurado corretamente, a saída da versão do executor Java terá um valor que começa com `openjdk version 1.8`, e a saída da versão do compilador Java começará com o valor `javac 1.8`. ## Etapa 2: Adicionar código No AWS Cloud9 IDE, crie um arquivo com o código a seguir e salve o arquivo com o nome`hello.java`. (Para criar um arquivo, na barra de menus, selecione **File** (Arquivo), **New File** (Novo arquivo). Para salvar o arquivo, selecione **File** (Arquivo), **Save** (Salvar).) ``` public class hello { public static void main(String []args) { System.out.println("Hello, World!"); System.out.println("The sum of 2 and 3 is 5."); int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]); System.out.format("The sum of %s and %s is %s.\n", args[0], args[1], Integer.toString(sum)); } } ``` ## Etapa 3: Compilar e executar o código 1. Use a versão de linha de comando do compilador Java para compilar o arquivo `hello.java` em um arquivo `hello.class`. Para fazer isso, usando o terminal no AWS Cloud9 IDE, no mesmo diretório do `hello.java` arquivo, execute o compilador Java, especificando o `hello.java` arquivo. ``` javac hello.java ``` 1. Use a versão de linha de comando do executor Java para executar o arquivo `hello.class`. Para fazer isso, no mesmo diretório do arquivo `hello.class`, execute o executor Java, especificando o nome da classe `hello` que foi declarada no arquivo `hello.java`, com dois números inteiros para adicionar (por exemplo, `5` e `9`). ``` java hello 5 9 ``` 1. Compare a saída. ``` Hello, World! The sum of 2 and 3 is 5. The sum of 5 and 9 is 14. ``` ## Etapa 4: configurar para usar o AWS SDK para Java Você pode aprimorar essa amostra para usar o AWS SDK para Java para criar um bucket do Amazon S3, listar seus buckets disponíveis e, em seguida, excluir o bucket que você acabou de criar. Nesta etapa, você instala o [Apache Maven](https://maven.apache.org/) ou [Gradle](https://gradle.org/) no seu ambiente. Maven e Gradle são sistemas de automação de compilação comuns que podem ser usados com projetos Java. Após instalar Maven ou Gradle, você pode usá-lo para gerar um novo projeto Java. Neste novo projeto, você adiciona uma referência ao AWS SDK para Java. Isso AWS SDK para Java fornece uma maneira conveniente de interagir com AWS serviços como o Amazon S3, a partir do seu código Java. **Topics** + [Configurar com o Maven](#sample-java-sdk-maven) + [Configurar com o Gradle](#sample-java-sdk-gradle) ### Configurar com o Maven 1. Instale o Maven em seu ambiente. Para ver se o Maven já está instalado, usando o terminal no AWS Cloud9 IDE, execute o Maven com a **`-version`**opção. ``` mvn -version ``` Se sim, a saída contém o número da versão do Maven. Se o Maven já estiver instalado, passe para a etapa 4 deste procedimento para usar o Maven para gerar um novo projeto Java no seu ambiente. 1. Instale o Maven usando o terminal para executar os comandos a seguir. Para o Amazon Linux, os seguintes comandos obtêm informações sobre o repositório de pacotes no qual o Maven está armazenado e usam essas informações para instalar o Maven. ``` sudo wget http://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo sudo yum install -y apache-maven ``` Para obter mais informações sobre os comandos anteriores, consulte [Extra Packages for Enterprise Linux (EPEL)](https://docs.fedoraproject.org/en-US/epel/) no site do Wiki Fedora Project. Para o Ubuntu Server, execute o seguinte comando. ``` sudo apt install -y maven ``` 1. Confirme a instalação executando o Maven com a opção ** `-version` **. ``` mvn -version ``` 1. Use o Maven para gerar um novo projeto Java. Para fazer isso, use o terminal para executar o comando a seguir no diretório onde você deseja que o Maven gere o projeto (por exemplo, o diretório raiz do seu ambiente). ``` mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false ``` O comando anterior cria a seguinte estrutura de diretório para o projeto no seu ambiente. ``` my-app |- src | `- main | `- java | `- com | `- mycompany | `- app | `-App.java |- test | `- java | `- com | `- mycompany | `- app | `- AppTest.java `- pom.xml ``` Para obter mais informações sobre a estrutura de diretórios anterior, consulte [Maven Quickstart Archetype](https://maven.apache.org/archetypes/maven-archetype-quickstart/) e [Introduction to the Standard Directory Layout](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html) no site do Apache Maven Project. 1. Modifique o arquivo Project Object Model (POM) para o projeto. Um arquivo POM define configurações do projeto Maven. Para fazer isso, na janela **Ambiente**, abra o arquivo `my-app/pom.xml`. No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo `pom.xml`. ``` 4.0.0 com.mycompany.app my-app jar 1.0-SNAPSHOT org.apache.maven.plugins maven-assembly-plugin 3.6.0 jar-with-dependencies com.mycompany.app.App package single junit junit 3.8.1 test com.amazonaws aws-java-sdk 1.11.330 ``` O arquivo POM anterior inclui configurações do projeto que especificam declarações como as seguintes: + A configuração `artifactid` de `my-app` define o nome do diretório raiz do projeto, e a configuração `group-id` de `com.mycompany.app` define a estrutura de subdiretório `com/mycompany/app` e a declaração `package` nos arquivos `App.Java` e `AppTest.java`. + A configuração `artifactId` de `my-app`, com a configuração `packaging` de `jar`, a configuração `version` de `1.0-SNAPSHOT` e a configuração `descriptorRef` de `jar-with-dependencies` definem o nome do arquivo JAR de saída de `my-app-1.0-SNAPSHOT-jar-with-dependencies.jar`. + A seção `plugin` declara que um único JAR, que inclui todas as dependências, será criado. + A `dependency` seção com a `groupId` configuração de `com.amazon.aws` e a `artifactId` configuração de `aws-java-sdk` inclui os arquivos da AWS SDK para Java biblioteca. A versão do AWS SDK para Java a ser usada é declarada pela configuração de `version`. Para usar uma versão diferente, substitua esse número de versão. Avance para [Etapa 5: configurar o gerenciamento de AWS credenciais em seu ambiente](#sample-java-sdk-creds). ### Configurar com o Gradle 1. Instale o Gradle em seu ambiente. Para ver se o Gradle já está instalado, usando o terminal no AWS Cloud9 IDE, execute o Gradle com a **`-version`**opção. ``` gradle -version ``` Se sim, a saída contém o número da versão do Gradle. Se o Gradle já estiver instalado, passe para a etapa 4 deste procedimento para usar o Gradle para gerar um novo projeto Java no seu ambiente. 1. Instale o Gradle usando o terminal para executar os comandos a seguir. Esses comandos instalam e executam a ferramenta SDKMAN\$1 e, em seguida, usam o SDKMAN\$1 para instalar a versão mais recente do Gradle. ``` curl -s "https://get.sdkman.io" | bash source "$HOME/.sdkman/bin/sdkman-init.sh" sdk install gradle ``` Para obter mais informações sobre comandos anteriores, consulte [Instalação](https://sdkman.io/install) no site do SDKMAN\$1 e [Instalar com um gerenciador de pacotes](https://gradle.org/install/#with-a-package-manager) no site do Gradle. 1. Confirme a instalação executando o Gradle com a opção ** `-version` **. ``` gradle -version ``` 1. Use o Gradle para gerar um novo projeto Java no seu ambiente. Para fazer isso, use o terminal para executar os comandos a seguir para criar um diretório para o projeto e, em seguida, mude para esse diretório. ``` mkdir my-app cd my-app ``` 1. Execute o comando a seguir para que o Gradle gere um novo projeto de aplicação Java no diretório `my-app` em seu ambiente. ``` gradle init --type java-application ``` O comando anterior cria a seguinte estrutura de diretório para o projeto no seu ambiente. ``` my-app |- .gradle | `- (various supporting project folders and files) |- gradle | `- (various supporting project folders and files) |- src | |- main | | `- java | | `- App.java | `- test | `- java | `- AppTest.java |- build.gradle |- gradlew |- gradlew.bat `- settings.gradle ``` 1. Modifique o `AppTest.java` para o projeto. Se você não fizer isso, o projeto poderá não ser criado ou executado como esperado. Para fazer isso, na janela **Ambiente**, abra o arquivo `my-app/src/test/java/AppTest.java`. No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo `AppTest.java`. ``` import org.junit.Test; import static org.junit.Assert.*; public class AppTest { @Test public void testAppExists () { try { Class.forName("com.mycompany.app.App"); } catch (ClassNotFoundException e) { fail("Should have a class named App."); } } } ``` 1. Modifique o arquivo `build.gradle` para o projeto. Um arquivo `build.gradle` define configurações do projeto Gradle. Para fazer isso, na janela **Ambiente**, abra o arquivo `my-app/build.gradle`. No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo `build.gradle`. ``` apply plugin: 'java' apply plugin: 'application' repositories { jcenter() mavenCentral() } buildscript { repositories { mavenCentral() } dependencies { classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE" } } apply plugin: "io.spring.dependency-management" dependencyManagement { imports { mavenBom 'com.amazonaws:aws-java-sdk-bom:1.11.330' } } dependencies { compile 'com.amazonaws:aws-java-sdk-s3' testCompile group: 'junit', name: 'junit', version: '4.12' } run { if (project.hasProperty("appArgs")) { args Eval.me(appArgs) } } mainClassName = 'App' ``` O arquivo `build.gradle` anterior inclui configurações do projeto que especificam declarações como as seguintes: + O `io.spring.dependency-management` plug-in é usado para importar a Lista de Materiais (BOM) do AWS SDK para Java Maven para gerenciar AWS SDK para Java dependências do projeto. `classpath`declara a versão a ser usada. Para usar uma versão diferente, substitua esse número de versão. + `com.amazonaws:aws-java-sdk-s3` inclui a parte do Amazon S3 dos arquivos da biblioteca do AWS SDK para Java . O `mavenBom` declara a versão a ser usada. Se quiser usar uma versão diferente, substitua esse número de versão. ## Etapa 5: configurar o gerenciamento de AWS credenciais em seu ambiente Cada vez que você usa o AWS SDK para Java para ligar para um AWS serviço, você deve fornecer um conjunto de AWS credenciais com a chamada. Essas credenciais determinam se ele AWS SDK para Java tem as permissões apropriadas para fazer essa chamada. Se as credenciais não cobrirem as permissões apropriadas, a chamada falhará. Nesta etapa, você armazenará as credenciais no ambiente. Para fazer isso, siga as instruções em [Chamando Serviços da AWS de um ambiente em AWS Cloud9](credentials.md) e retorne a este tópico. Para mais informações, consulte [Set up AWS Credentials and Region for Development](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials) no *Guia do desenvolvedor do AWS SDK para Java *. ## Etapa 6: adicionar código AWS SDK Nesta etapa, adicione código para interagir com o Amazon S3 para criar um bucket, listar os buckets disponíveis e excluir o bucket que você acabou de criar. Na janela **Environment (Ambiente)**, abra o arquivo `my-app/src/main/java/com/mycompany/app/App.java` para o Maven ou o arquivo `my-app/src/main/java/App.java` para o Gradle. No editor, substitua o conteúdo atual do arquivo pelo seguinte código e, em seguida, salve o arquivo `App.java`. ``` package com.mycompany.app; import com.amazonaws.auth.profile.ProfileCredentialsProvider; import com.amazonaws.services.s3.AmazonS3; import com.amazonaws.services.s3.AmazonS3ClientBuilder; import com.amazonaws.services.s3.model.AmazonS3Exception; import com.amazonaws.services.s3.model.Bucket; import com.amazonaws.services.s3.model.CreateBucketRequest; import java.util.List; public class App { private static AmazonS3 s3; public static void main(String[] args) { if (args.length < 2) { System.out.format("Usage: \n" + "Example: my-test-bucket us-east-2\n"); return; } String bucket_name = args[0]; String region = args[1]; s3 = AmazonS3ClientBuilder.standard() .withCredentials(new ProfileCredentialsProvider()) .withRegion(region) .build(); // List current buckets. ListMyBuckets(); // Create the bucket. if (s3.doesBucketExistV2(bucket_name)) { System.out.format("\nCannot create the bucket. \n" + "A bucket named '%s' already exists.", bucket_name); return; } else { try { System.out.format("\nCreating a new bucket named '%s'...\n\n", bucket_name); s3.createBucket(new CreateBucketRequest(bucket_name, region)); } catch (AmazonS3Exception e) { System.err.println(e.getErrorMessage()); } } // Confirm that the bucket was created. ListMyBuckets(); // Delete the bucket. try { System.out.format("\nDeleting the bucket named '%s'...\n\n", bucket_name); s3.deleteBucket(bucket_name); } catch (AmazonS3Exception e) { System.err.println(e.getErrorMessage()); } // Confirm that the bucket was deleted. ListMyBuckets(); } private static void ListMyBuckets() { List buckets = s3.listBuckets(); System.out.println("My buckets now are:"); for (Bucket b : buckets) { System.out.println(b.getName()); } } } ``` ## Etapa 7: criar e executar o código do AWS SDK Para executar o código da etapa anterior, execute os seguintes comandos do terminal. Esses comandos usam Maven ou Gradle para criar um arquivo JAR executável para o projeto e, em seguida, usam o executor Java para executar o JAR. O JAR é executado com o nome do bucket a ser criado no Amazon S3 (por exemplo,`my-test-bucket`) e o ID da AWS região para criar o bucket como entrada (por exemplo,`us-east-2`). Para o Maven, execute os comandos a seguir. ``` cd my-app mvn package java -cp target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar com.mycompany.app.App my-test-bucket us-east-2 ``` Para o Gradle, execute os comandos a seguir. ``` gradle build gradle run -PappArgs="['my-test-bucket', 'us-east-2']" ``` Compare os resultados com a seguinte saída. ``` My buckets now are: Creating a new bucket named 'my-test-bucket'... My buckets now are: my-test-bucket Deleting the bucket named 'my-test-bucket'... My buckets now are: ``` ## Etapa 8: Limpeza Para evitar cobranças contínuas em sua AWS conta depois de terminar de usar esse exemplo, você deve excluir o ambiente. Para instruções, consulte [Excluindo um ambiente no AWS Cloud9](delete-environment.md).