AWS Cloud9 tidak lagi tersedia untuk pelanggan baru. Pelanggan yang sudah ada AWS Cloud9 dapat terus menggunakan layanan seperti biasa. [Pelajari selengkapnya](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tutorial Java untuk AWS Cloud9
**penting**
Jika Anda menggunakan lingkungan AWS Cloud9 pengembangan yang didukung oleh instans EC2 dengan memori 2 GiB atau lebih, kami sarankan Anda mengaktifkan dukungan Java yang disempurnakan. 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](enhanced-java.md).
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](https://aws.amazon.com/ec2/pricing/) dan [Harga Amazon S3](https://aws.amazon.com/s3/pricing/).
**Topics**
+ [Prasyarat](#sample-java-prerequisites)
+ [Langkah 1: Pasang alat yang diperlukan](#sample-java-install)
+ [Langkah 2: Menambahkan kode](#sample-java-code)
+ [Langkah 3: Bangun dan jalankan kode](#sample-java-run)
+ [Langkah 4: Siapkan untuk menggunakan AWS SDK untuk Java](#sample-java-sdk)
+ [Langkah 5: Siapkan manajemen AWS kredensil di lingkungan Anda](#sample-java-sdk-creds)
+ [Langkah 6: Tambahkan kode AWS SDK](#sample-java-sdk-code)
+ [Langkah 7: Bangun dan jalankan kode AWS SDK](#sample-java-sdk-run)
+ [Langkah 8: Membersihkan](#sample-java-clean-up)
## Prasyarat
Sebelum Anda menggunakan sampel ini, pastikan 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](create-environment.md).
+ **Anda memiliki AWS Cloud9 IDE untuk lingkungan yang ada sudah terbuka.** Saat Anda membuka lingkungan, AWS Cloud9 buka IDE untuk lingkungan itu di browser web Anda. Untuk informasi selengkapnya, lihat [Membuka lingkungan di AWS Cloud9](open-environment.md).
## Langkah 1: Pasang alat yang diperlukan
Pada langkah ini, Anda menginstal satu set alat pengembangan Java di lingkungan AWS Cloud9 pengembangan 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](#sample-java-code). Sampel ini dikembangkan dengan OpenJDK 8, yang dapat Anda pasang di lingkungan Anda dengan menyelesaikan prosedur berikut.
1. Konfirmasi apakah OpenJDK 8 sudah terpasang. Untuk melakukan ini, dalam sesi terminal di AWS Cloud9 IDE, jalankan versi baris perintah dari runner Java dengan **`-version`**opsi. (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](#sample-java-code). 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.
1. 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
```
1. 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](https://openjdk.org/install/) di situs web OpenJDK.
1. 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`).
1. 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
1. 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 `hello.java` file, jalankan kompiler Java, tentukan file. `hello.java`
```
javac hello.java
```
1. 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
```
1. Bandingkan output Anda.
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## Langkah 4: Siapkan untuk menggunakan AWS SDK untuk Java
Anda dapat menyempurnakan sampel ini AWS SDK untuk Java untuk menggunakan bucket Amazon S3, mencantumkan bucket yang tersedia, lalu menghapus bucket yang baru saja Anda buat.
Pada langkah ini, Anda memasang [Apache Maven](https://maven.apache.org/) atau [Gradle](https://gradle.org/) 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 untuk Java. Ini AWS SDK untuk Java menyediakan cara mudah untuk berinteraksi dengan AWS layanan seperti Amazon S3, dari kode Java Anda.
**Topics**
+ [Mengatur dengan Maven](#sample-java-sdk-maven)
+ [Mengatur dengan Gradle](#sample-java-sdk-gradle)
### Mengatur dengan Maven
1. Pasang Maven di lingkungan Anda. Untuk melihat apakah Maven sudah diinstal, 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.
1. 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)](https://docs.fedoraproject.org/en-US/epel/) di situs web Fedora Project Wiki.
Untuk Server Ubuntu, jalankan perintah berikut sebagai gantinya.
```
sudo apt install -y maven
```
1. Konfirmasi pemasangan dengan menjalankan Maven dengan opsi ** `-version` **.
```
mvn -version
```
1. 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](https://maven.apache.org/archetypes/maven-archetype-quickstart/) dan [Pengenalan Tata Letak Direktori Standar](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html) di situs web Proyek Maven Apache.
1. 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`.
```
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
```
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.
+ `dependency`Bagian dengan `groupId` pengaturan `com.amazon.aws` dan `artifactId` pengaturan `aws-java-sdk` termasuk file AWS SDK untuk Java perpustakaan. Versi AWS SDK untuk Java yang akan digunakan dideklarasikan oleh pengaturan `version`. Untuk menggunakan versi yang berbeda, ganti nomor versi ini.
Lewati ke [Langkah 5: Siapkan manajemen AWS kredensil di lingkungan Anda](#sample-java-sdk-creds).
### Mengatur dengan Gradle
1. Pasang Gradle di lingkungan Anda. Untuk melihat apakah Gradle sudah diinstal, 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.
1. Pasang Gradle dengan menggunakan terminal untuk menjalankan perintah berikut. Perintah ini memasang dan menjalankan alat SDKMAN\$1, dan kemudian menggunakan SDKMAN\$1 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](https://sdkman.io/install) di situs web SDKMAN\$1 dan [Pasang dengan pengelola paket](https://gradle.org/install/#with-a-package-manager) di situs web Gradle.
1. Konfirmasi pemasangan dengan menjalankan Gradle dengan opsi ** `-version` **.
```
gradle -version
```
1. 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
```
1. 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
```
1. 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.");
}
}
}
```
1. 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:
+ `io.spring.dependency-management`Plugin ini digunakan untuk mengimpor AWS SDK untuk Java Maven Bill of Materials (BOM) untuk mengelola AWS SDK untuk Java dependensi proyek. `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 untuk Java . `mavenBom` mendeklarasikan versi yang akan digunakan. Jika Anda ingin menggunakan versi lain, ganti nomor versi ini.
## Langkah 5: Siapkan manajemen AWS kredensil di lingkungan Anda
Setiap kali Anda menggunakan AWS SDK untuk Java untuk memanggil AWS layanan, Anda harus memberikan satu set AWS kredensil dengan panggilan tersebut. Kredensil ini menentukan apakah AWS SDK untuk Java memiliki izin yang sesuai untuk melakukan panggilan itu. 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 [Menelepon Layanan AWS dari lingkungan di AWS Cloud9](credentials.md), lalu kembali ke topik ini.
Untuk informasi tambahan, lihat [Mengatur Kredensial dan Wilayah AWS untuk Pengembangan](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials) di *Panduan Developer AWS SDK untuk Java *.
## Langkah 6: Tambahkan 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: \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());
}
}
}
```
## 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 untuk dibuat di Amazon S3 (misalnya,`my-test-bucket`) dan ID AWS Wilayah 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 yang sedang berlangsung ke AWS akun Anda setelah selesai menggunakan sampel ini, Anda harus menghapus lingkungan. Untuk petunjuk, lihat [Menghapus lingkungan di AWS Cloud9](delete-environment.md).