Prasyarat Langkah 1: Pasang alat yang diperlukan Langkah 2: Menambahkan kode Langkah 3: Bangun dan jalankan kode Langkah 4: Mengatur untuk menggunakan AWS SDK for Java Langkah 5: Atur pengelolaan kredensial AWS di lingkungan Anda Langkah 6: Menambahkan kode AWS SDK Langkah 7: Bangun dan jalankan kode AWS SDK Langkah 8: Membersihkan

Java tutorial untuk AWS Cloud9

penting

Jika Anda menggunakan lingkungan AWS Cloud9 pengembangan yang didukung oleh instans EC2 dengan 2 GiB atau lebih memori, kami sarankan Anda mengaktifkan dukungan Java yang ditingkatkan. Ini menyediakan akses ke fitur produktivitas seperti penyelesaian kode, linting untuk kesalahan, tindakan spesifik konteks, dan opsi debugging seperti breakpoint dan stepping.

Untuk informasi selengkapnya, lihat Peningkatan dukungan untuk pengembangan Java.

Tutorial ini memungkinkan Anda untuk menjalankan beberapa kode Java di lingkungan AWS Cloud9 pengembangan.

Mengikuti tutorial ini dan membuat sampel ini dapat mengakibatkan biaya ke AWS akun Anda. Ini termasuk kemungkinan biaya untuk layanan seperti Amazon EC2 dan Amazon S3. Untuk informasi selengkapnya, lihat Harga Amazon EC2 dan Harga Amazon S3.

Topik

Prasyarat
Langkah 1: Pasang alat yang diperlukan
Langkah 2: Menambahkan kode
Langkah 3: Bangun dan jalankan kode
Langkah 4: Mengatur untuk menggunakan AWS SDK for Java
Langkah 5: Atur pengelolaan kredensial AWS di lingkungan Anda
Langkah 6: Menambahkan kode AWS SDK
Langkah 7: Bangun dan jalankan kode AWS SDK
Langkah 8: Membersihkan

Prasyarat

Sebelum Anda menggunakan sampel ini, pastikan bahwa pengaturan Anda memenuhi persyaratan berikut:

Anda harus memiliki lingkungan pengembangan AWS Cloud9 EC2 yang ada. Contoh ini mengasumsikan bahwa Anda sudah memiliki lingkungan EC2 yang terhubung ke instans Amazon EC2 yang menjalankan Amazon Linux atau Server. Ubuntu Jika Anda memiliki jenis lingkungan atau sistem operasi yang berbeda, Anda mungkin perlu menyesuaikan petunjuk sampel ini untuk menyiapkan alat terkait. Untuk informasi selengkapnya, lihat Menciptakan lingkungan di AWS Cloud9.
Anda memiliki AWS Cloud9 IDE untuk lingkungan yang ada sudah terbuka. Saat Anda membuka lingkungan, AWS Cloud9 membuka IDE untuk lingkungan itu di peramban web Anda. Untuk informasi selengkapnya, lihat Membuka lingkungan di AWS Cloud9.

Langkah 1: Pasang alat yang diperlukan

Pada langkah ini, Anda memasang seperangkat alat developer Java di lingkungan pengembangan AWS Cloud9 Anda. Jika Anda sudah memiliki seperangkat alat developer Java seperti Oracle JDK atau OpenJDK yang terpasang di lingkungan Anda, Anda dapat langsung beralih ke Langkah 2: Menambahkan kode. Sampel ini dikembangkan dengan OpenJDK 8, yang dapat Anda pasang di lingkungan Anda dengan menyelesaikan prosedur berikut.

Konfirmasi apakah OpenJDK 8 sudah terpasang. Untuk melakukan ini, dalam sesi terminal di AWS Cloud9 IDE, jalankan versi baris perintah dari Java runner dengan opsi -version . (Untuk memulai sesi terminal baru, pada bilah menu, pilih Jendela, Terminal Baru.)
```
java -version
```
Berdasarkan output dari perintah sebelumnya, lakukan salah satu hal berikut:
- Jika output menyatakan bahwa perintah java tidak ditemukan, lanjutkan dengan langkah 2 dalam prosedur ini untuk memasang OpenJDK 8.
- Jika output berisi nilai yang dimulai dengan Java(TM), Java Runtime Environment, Java SE, J2SE, atau Java2, OpenJDK tidak dipasang atau tidak diatur sebagai perangkat pengembangan Java default. Lanjutkan dengan langkah 2 dalam prosedur ini untuk memasang OpenJDK 8, dan kemudian beralih menggunakan OpenJDK 8.
- Jika output berisi nilai yang dimulai dengan java version 1.8 dan OpenJDK, lanjutkan ke Langkah 2: Menambahkan kode. OpenJDK 8 dipasang dengan benar untuk sampel ini.
- Jika output berisi java version kurang dari 1.8 dan nilai dimulai dengan OpenJDK, lanjutkan dengan langkah 2 dalam prosedur ini untuk memutakhirkan versi OpenJDK yang dipasang ke OpenJDK 8.
Pastikan pembaruan keamanan terbaru dan perbaikan bug telah terpasang. Untuk melakukan ini, jalankan alat yum (untuk Amazon Linux) atau alat apt (untuk Server Ubuntu) dengan perintah update .

Untuk Amazon Linux:
```
sudo yum -y update
```
Untuk Ubuntu Server:
```
sudo apt update
```
Pasang OpenJDK 8. Untuk melakukannya, jalankan alat yum (untuk Amazon Linux) atau alat apt (untuk Server Ubuntu) dengan perintah install , dengan menentukan paket OpenJDK 8.

Untuk Amazon Linux:
```
sudo yum -y install java-1.8.0-openjdk-devel
```
Untuk Ubuntu Server:
```
sudo apt install -y openjdk-8-jdk
```
Untuk informasi lebih lanjut, lihat Cara mengunduh dan memasang paket OpenJDK yang telah dibangun sebelumnya di situs web OpenJDK.
Ganti atau tingkatkan perangkat pengembangan Java default ke OpenJDK 8. Untuk melakukan ini, jalankan perintah update-alternatives dengan opsi --config . Jalankan perintah ini dua kali untuk beralih atau memutakhirkan versi baris perintah dari Java runner dan compiler.
```
sudo update-alternatives --config java
sudo update-alternatives --config javac
```
Pada setiap prompt, ketik nomor pilihan untuk OpenJDK 8 (yang berisi java-1.8).
Konfirmasikan bahwa versi baris perintah Java runner dan compiler menggunakan OpenJDK 8. Untuk melakukannya, jalankan versi baris perintah dari Java runner dan compiler dengan opsi -version.
```
java -version
javac -version
```
Jika OpenJDK 8 dipasang dan diatur dengan benar, output versi Java runner berisi nilai yang dimulai dengan openjdk version 1.8, dan output versi kompiler Java dimulai dengan nilai javac 1.8.

Langkah 2: Menambahkan kode

Di AWS Cloud9 IDE, buat file dengan kode berikut, dan simpan file dengan nama hello.java. (Untuk membuat file, pada bilah menu, pilih File, File Baru. Untuk menyimpan file, pilih File, Simpan.)


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));
  }
}

Langkah 3: Bangun dan jalankan kode

Gunakan versi baris perintah dari compiler Java untuk mengkompilasi file hello.java ke dalam file hello.class. Untuk melakukan ini, menggunakan terminal di AWS Cloud9 IDE, dari direktori yang sama dengan file hello.java, jalankan kompiler Java, tentukan file hello.java.
```
javac hello.java
```
Gunakan versi baris perintah dari Java runner untuk menjalankan file hello.class. Untuk melakukan ini, dari direktori yang sama dengan file hello.class, jalankan Java runner, tentukan nama kelas hello yang dideklarasikan dalam file hello.java, dengan dua bilangan bulat untuk ditambahkan (misalnya, 5 dan 9).
```
java hello 5 9
```

Bandingkan output Anda.


Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.

Langkah 4: Mengatur untuk menggunakan AWS SDK for Java

Anda dapat meningkatkan sampel ini untuk menggunakan AWS SDK for Java untuk membuat bucket Amazon S3, mencantumkan bucket Anda yang tersedia, lalu menghapus bucket yang baru saja Anda buat.

Pada langkah ini, Anda memasang Apache Maven atau Gradle di lingkungan Anda. Maven dan Gradle adalah sistem otomatisasi bangun yang umum yang dapat digunakan dengan proyek Java. Setelah Anda memasang Maven atau Gradle, Anda menggunakannya untuk menghasilkan proyek Java baru. Dalam proyek baru ini, Anda menambahkan referensi ke AWS SDK for Java. AWS SDK for Java ini menyediakan cara mudah untuk berinteraksi dengan layanan AWS seperti Amazon S3, dari kode Java Anda.

Mengatur dengan Maven

Pasang Maven di lingkungan Anda. Untuk melihat apakah Maven sudah terpasang, menggunakan terminal di AWS Cloud9 IDE, jalankan Maven dengan opsi -version .
```
mvn -version
```
Jika berhasil, output berisi nomor versi Maven. Jika Maven sudah terpasang, lanjutkan ke langkah 4 dalam prosedur ini untuk menggunakan Maven untuk menghasilkan proyek Java baru di lingkungan Anda.
Pasang Maven dengan menggunakan terminal untuk menjalankan perintah berikut.

Untuk Amazon Linux, perintah berikut mendapatkan informasi tentang repositori paket tempat Maven disimpan, lalu menggunakan informasi ini untuk memasang 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
```
Untuk informasi selengkapnya tentang perintah sebelumnya, lihat Paket Ekstra untuk Linux Korporasi (EPEL) di situs web Fedora Project Wiki.

Untuk Server Ubuntu, jalankan perintah berikut sebagai gantinya.
```
sudo apt install -y maven
```
Konfirmasi pemasangan dengan menjalankan Maven dengan opsi -version .
```
mvn -version
```
Gunakan Maven untuk menghasilkan proyek Java baru. Untuk melakukan ini, gunakan terminal untuk menjalankan perintah berikut dari direktori tempat Anda ingin Maven menghasilkan proyek (misalnya, direktori root lingkungan Anda).
```
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```
Perintah sebelumnya membuat struktur direktori berikut untuk proyek di lingkungan Anda.
```
my-app
  |- src
  |   `- main
  |        `- java
  |             `- com
  |                 `- mycompany
  |                      `- app
  |                          `-App.java
  |- test
  |   `- java
  |        `- com
  |            `- mycompany
  |                 `- app
  |                     `- AppTest.java
  `- pom.xml
```
Untuk informasi selengkapnya tentang struktur direktori sebelumnya, lihat Pola Dasar Cepat Maven dan Pengenalan Tata Letak Direktori Standar di situs web Proyek Maven Apache.

Ubah file Project Object Model (POM) untuk proyek tersebut. (File POM mendefinisikan pengaturan proyek Maven.) Untuk melakukan ini, di jendela Lingkungan, buka file my-app/pom.xml. Di editor, ganti konten file saat ini dengan kode berikut, lalu simpan file 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>

File POM sebelumnya menyertakan pengaturan proyek yang menentukan deklarasi seperti berikut ini:

Pengaturan artifactid dari my-app menetapkan nama direktori root proyek, dan pengaturan group-id dari com.mycompany.app menetapkan struktur subdirektori com/mycompany/app dan deklarasi package dalam file App.Java dan AppTest.java.
Pengaturan artifactId dari my-app, dengan pengaturan packaging dari jar, pengaturan version dari 1.0-SNAPSHOT, dan pengaturan descriptorRef dari jar-with-dependencies mengatur nama file JAR output dari my-app-1.0-SNAPSHOT-jar-with-dependencies.jar.
Bagian plugin menyatakan bahwa JAR tunggal, yang mencakup semua dependensi, akan dibuat.
Bagian dependency dengan pengaturan groupId dari com.amazon.aws dan pengaturan artifactId dari aws-java-sdk menyertakan file pustaka AWS SDK for Java. Versi AWS SDK for Java yang akan digunakan dideklarasikan oleh pengaturan version. Untuk menggunakan versi yang berbeda, ganti nomor versi ini.

Lewati ke Langkah 5: Atur pengelolaan kredensial AWS di lingkungan Anda.

Mengatur dengan Gradle

Pasang Gradle di lingkungan Anda. Untuk melihat apakah Gradle sudah terpasang, menggunakan terminal di AWS Cloud9 IDE, jalankan Gradle dengan opsi -version .
```
gradle -version
```
Jika berhasil, output berisi nomor versi Gradle. Jika Gradle sudah terpasang, lanjutkan ke langkah 4 dalam prosedur ini untuk menggunakan Gradle guna menghasilkan proyek Java baru di lingkungan Anda.
Pasang Gradle dengan menggunakan terminal untuk menjalankan perintah berikut. Perintah ini memasang dan menjalankan alat SDKMAN!, dan kemudian menggunakan SDKMAN! untuk memasang versi terbaru Gradle.
```
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle
```
Untuk informasi lebih lanjut tentang perintah sebelumnya, lihat Pemasangan di situs web SDKMAN! dan Pasang dengan pengelola paket di situs web Gradle.
Konfirmasi pemasangan dengan menjalankan Gradle dengan opsi -version .
```
gradle -version
```
Gunakan Gradle untuk membuat proyek Java baru di lingkungan Anda. Untuk melakukannya, gunakan terminal untuk menjalankan perintah berikut untuk membuat direktori proyek, dan kemudian beralih ke direktori itu.
```
mkdir my-app
cd my-app
```

Jalankan perintah berikut agar Gradle membuat proyek aplikasi Java baru di direktori my-app di lingkungan Anda.


gradle init --type java-application

Perintah sebelumnya membuat struktur direktori berikut untuk proyek di lingkungan Anda.


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

Ubah AppTest.java untuk proyek. (Jika Anda tidak melakukan ini, proyek mungkin tidak dibangun atau berjalan seperti yang diharapkan). Untuk melakukan ini, di jendela Lingkungan, buka file my-app/src/test/java/AppTest.java. Di editor, ganti konten file saat ini dengan kode berikut, lalu simpan file 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.");
    }
  }
}
```
Ubah file build.gradle untuk proyek. (File build.gradle mendefinisikan pengaturan proyek Gradle.) Untuk melakukan ini, di jendela Lingkungan, buka file my-app/build.gradle. Di editor, ganti konten file saat ini dengan kode berikut, lalu simpan file 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'
```
File build.gradle sebelumnya menyertakan pengaturan proyek yang menentukan deklarasi seperti berikut ini:
- Plugin io.spring.dependency-management digunakan untuk mengimpor AWS SDK for Java Maven Bill of Materials (BOM) untuk mengelola dependensi AWS SDK for Java untuk proyek tersebut. classpath mendeklarasikan versi yang akan digunakan. Untuk menggunakan versi yang berbeda, ganti nomor versi ini.
- com.amazonaws:aws-java-sdk-s3 menyertakan bagian Amazon S3 dari file pustaka AWS SDK for Java. mavenBom mendeklarasikan versi yang akan digunakan. Jika Anda ingin menggunakan versi lain, ganti nomor versi ini.

Langkah 5: Atur pengelolaan kredensial AWS di lingkungan Anda

Setiap kali Anda menggunakan AWS SDK for Java untuk memanggil layanan AWS, Anda harus memberikan satu set kredensial AWS dengan panggilan tersebut. Kredensial ini menentukan apakah AWS SDK for Java memiliki izin yang sesuai untuk melakukan panggilan tersebut. Jika kredensial tidak mencakup izin yang sesuai, panggilan akan gagal.

Pada langkah ini, Anda menyimpan kredensial Anda di dalam lingkungan. Untuk melakukannya, ikuti petunjuk di Meneleponlayanan AWS dari lingkungan diAWS Cloud9, lalu kembali ke topik ini.

Untuk informasi tambahan, lihat Mengatur Kredensial dan Wilayah AWS untuk Pengembangan di Panduan Developer AWS SDK for Java.

Langkah 6: Menambahkan kode AWS SDK

Pada langkah ini, Anda menambahkan kode untuk berinteraksi dengan Amazon S3 untuk membuat bucket, membuat daftar bucket Anda yang tersedia, lalu menghapus bucket yang baru saja Anda buat.

Dari jendela Lingkungan, buka file my-app/src/main/java/com/mycompany/app/App.java untuk Maven atau file my-app/src/main/java/App.java untuk Gradle. Di editor, ganti konten file saat ini dengan kode berikut, lalu simpan file 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());
        }
    }

}

Langkah 7: Bangun dan jalankan kode AWS SDK

Untuk menjalankan kode dari langkah sebelumnya, jalankan perintah berikut dari terminal. Perintah ini menggunakan Maven atau Gradle untuk membuat file JAR yang dapat dieksekusi untuk proyek tersebut, lalu menggunakan runner Java untuk menjalankan JAR. JAR berjalan dengan nama bucket yang akan dibuat di Amazon S3 (misalnya, my-test-bucket) dan ID Wilayah AWS untuk membuat bucket sebagai input (misalnya, us-east-2).

Untuk Maven, jalankan perintah berikut.


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

Untuk Gradle, jalankan perintah berikut.


gradle build
gradle run -PappArgs="['my-test-bucket', 'us-east-2']"

Bandingkan hasil Anda dengan output berikut.


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:

Langkah 8: Membersihkan

Untuk mencegah tagihan berkelanjutan ke akun AWS Anda setelah Anda selesai menggunakan sampel ini, Anda harus menghapus lingkungan. Untuk instruksi, lihat Menghapus lingkungan di AWS Cloud9.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

WordPresstutorial

C ++ tutorial