Pré-requisitos Etapa 1: Instalar as ferramentas necessárias Etapa 2: Adicionar código Etapa 3: Compilar e executar o código Etapa 4: Configurar para usar o AWS SDK for Java Etapa 5: Configurar o gerenciamento de credenciais da AWS no ambiente Etapa 6: Adicionar código do SDK da AWS Etapa 7: Compilar e executar o código SDK da AWS Etapa 8: limpar

Tutorial de Java para AWS Cloud9

Importante

Se estiver usando um ambiente de desenvolvimento do AWS Cloud9 que tenha o apoio de 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.

Este exemplo permite executar um código Java em um ambiente de desenvolvimento do Java no AWS Cloud9.

Seguindo este tutorial e criando 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 Definição de preço do Amazon EC2 e Definição de preço do Amazon S3.

Tópicos

Pré-requisitos
Etapa 1: Instalar as ferramentas necessárias
Etapa 2: Adicionar código
Etapa 3: Compilar e executar o código
Etapa 4: Configurar para usar o AWS SDK for Java
Etapa 5: Configurar o gerenciamento de credenciais da AWS no ambiente
Etapa 6: Adicionar código do SDK da AWS
Etapa 7: Compilar e executar o código SDK da AWS
Etapa 8: limpar

Pré-requisitos

Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.

É necessário ter um ambiente existente de desenvolvimento do AWS Cloud9 EC2 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.
Você tem o IDE do AWS Cloud9 para o ambiente existente já aberto. Ao abrir um ambiente o AWS Cloud9 abre o IDE para esse ambiente em um navegador da Web. Para obter mais informações, consulte Abrir um ambiente no AWS Cloud9.

Etapa 1: Instalar as ferramentas necessárias

Nesta etapa, você instalará um conjunto de ferramentas de desenvolvimento Java no ambiente de desenvolvimento do AWS Cloud9. 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. Esse exemplo foi desenvolvido com o OpenJDK 8, que você pode instalar em seu ambiente, após concluir o procedimento a seguir.

Confirme se o OpenJDK 8 já está instalado. Para fazer isso, em uma sessão de terminal no IDE do AWS Cloud9, execute a versão de linha de comando do executor Java com a opção -version . (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. 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.
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
```
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 (Como baixar e instalar pacotes OpenJDK pré-compilados) no site do OpenJDK.
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).
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 IDE do AWS Cloud9, crie um arquivo com o código a seguir e salve-o 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

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 IDE do AWS Cloud9, no mesmo diretório do arquivo hello.java, execute o compilador Java, especificando o arquivo hello.java.
```
javac hello.java
```
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
```

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 for Java

Você pode aprimorar este exemplo para usar o AWS SDK for Java para criar um bucket do Amazon S3, listar os buckets disponíveis e excluir o bucket que acabou de criar.

Nesta etapa, você instala o Apache Maven ou Gradle 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 for Java. Esse AWS SDK for Java fornece uma forma prática de interagir com os serviços da AWS, como o Amazon S3, em seu código Java.

Configurar com o Maven

Instale o Maven em seu ambiente. Para ver se o Maven já está instalado, usando o terminal no IDE do AWS Cloud9, execute o Maven com a opção -version .
```
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.
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) no site do Wiki Fedora Project.

Para o Ubuntu Server, execute o seguinte comando.
```
sudo apt install -y maven
```
Confirme a instalação executando o Maven com a opção -version .
```
mvn -version
```
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 e Introduction to the Standard Directory Layout no site do Apache Maven Project.

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.


<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mycompany.app</groupId>
  <artifactId>my-app</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>3.6.0</version>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <archive>
            <manifest>
              <mainClass>com.mycompany.app.App</mainClass>
            </manifest>
          </archive>
        </configuration>
        <executions>
          <execution>
            <phase>package</phase>
              <goals>
                <goal>single</goal>
              </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.amazonaws</groupId>
      <artifactId>aws-java-sdk</artifactId>
      <version>1.11.330</version>
    </dependency>
  </dependencies>
</project>

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 seção dependency com a configuração do groupId de com.amazon.aws e a configuração artifactId de aws-java-sdk inclui os arquivos da biblioteca do AWS SDK for Java. A versão do AWS SDK for 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 credenciais da AWS no ambiente.

Configurar com o Gradle

Instale o Gradle em seu ambiente. Para ver se o Gradle já está instalado, usando o terminal no IDE do AWS Cloud9, execute o Gradle com a opção -version .
```
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.
Instale o Gradle usando o terminal para executar os comandos a seguir. Esses comandos instalam e executam a ferramenta SDKMAN! e, em seguida, usam o SDKMAN! 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 no site do SDKMAN! e Instalar com um gerenciador de pacotes no site do Gradle.
Confirme a instalação executando o Gradle com a opção -version .
```
gradle -version
```
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
```

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

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.");
    }
  }
}
```
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 plugin io.spring.dependency-management é usado para importar a Bill of Materials (BOM - Lista de materiais) do Maven do AWS SDK for Java para gerenciar as dependências do AWS SDK for Java para o 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 for 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 credenciais da AWS no ambiente

Toda vez que você usar o AWS SDK for Java para chamar um serviço da AWS, forneça um conjunto de credenciais da AWS com a chamada. Essas credenciais determinam se o AWS SDK for Java tem as permissões apropriadas para realizar a 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 Chamar Serviços da AWS em um ambiente no AWS Cloud9 e retorne a este tópico.

Para mais informações, consulte Set up AWS Credentials and Region for Development no Guia do desenvolvedor do AWS SDK for Java.

Etapa 6: Adicionar código do SDK da AWS

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: <the bucket name> <the AWS Region to use>\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<Bucket> buckets = s3.listBuckets();
        System.out.println("My buckets now are:");

        for (Bucket b : buckets) {
            System.out.println(b.getName());
        }
    }

}

Etapa 7: Compilar e executar o código SDK da AWS

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 região da AWS na qual 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: limpar

Para evitar cobranças contínuas em sua conta da AWS, ao terminar de usar este exemplo, exclua o ambiente. Para obter instruções, consulte Excluir um ambiente no AWS Cloud9.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Tutoriais do WordPress

Tutorial de C++