

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Memulai Layanan Terkelola Amazon untuk Apache Flink (API) DataStream
<a name="getting-started"></a>

Bagian ini memperkenalkan Anda pada konsep dasar Managed Service untuk Apache Flink dan mengimplementasikan aplikasi di Java menggunakan API. DataStream Ini menjelaskan opsi yang tersedia untuk membuat dan menguji aplikasi Anda. Ini juga memberikan petunjuk untuk menginstal alat yang diperlukan untuk menyelesaikan tutorial dalam panduan ini dan untuk membuat aplikasi pertama Anda. 

**Topics**
+ [

## Tinjau komponen Layanan Terkelola untuk aplikasi Apache Flink
](#getting-started-components)
+ [

## Memenuhi prasyarat untuk menyelesaikan latihan
](#setting-up-prerequisites)
+ [

# Siapkan AWS akun dan buat pengguna administrator
](setting-up.md)
+ [

# Mengatur AWS Command Line Interface (AWS CLI)
](setup-awscli.md)
+ [

# Membuat dan menjalankan Managed Service untuk aplikasi Apache Flink
](get-started-exercise.md)
+ [

# Bersihkan AWS sumber daya
](getting-started-cleanup.md)
+ [

# Jelajahi sumber daya tambahan
](getting-started-next-steps.md)

## Tinjau komponen Layanan Terkelola untuk aplikasi Apache Flink
<a name="getting-started-components"></a>

**catatan**  
Amazon Managed Service untuk Apache Flink mendukung semua Apache Flink APIs dan berpotensi semua bahasa JVM. Untuk informasi lebih lanjut, lihat [Flink's. APIs](https://nightlies.apache.org/flink/flink-docs-release-1.20/docs/concepts/overview/#flinks-apis)  
Bergantung pada API yang Anda pilih, struktur aplikasi dan implementasinya sedikit berbeda. Tutorial Memulai ini mencakup implementasi aplikasi menggunakan DataStream API di Java.

Untuk memproses data, Managed Service untuk aplikasi Apache Flink Anda menggunakan aplikasi Java yang memproses input dan menghasilkan output menggunakan runtime Apache Flink. 

Layanan Terkelola khas untuk aplikasi Apache Flink memiliki komponen-komponen berikut:
+ **Properti runtime:** Anda dapat menggunakan *properti runtime* untuk meneruskan parameter konfigurasi ke aplikasi Anda untuk mengubahnya tanpa memodifikasi dan menerbitkan ulang kode. 
+ **Sumber:** Aplikasi mengkonsumsi data dari satu atau lebih *sumber*. Sumber menggunakan [konektor](https://nightlies.apache.org/flink/flink-docs-release-1.20/docs/connectors/table/overview/) untuk membaca data dari sistem eksternal, seperti aliran data Kinesis, atau ember Kafka. Untuk informasi selengkapnya, lihat [Tambahkan sumber data streaming](how-sources.md).
+ **Operators** (Operator): Aplikasi memproses data menggunakan satu atau beberapa *operator*. Operator dapat mengubah, memperkaya, atau menggabungkan data. Untuk informasi selengkapnya, lihat [Operator](how-operators.md).
+ **Tenggelam:** Aplikasi mengirimkan data ke sumber eksternal melalui *sink*. Wastafel menggunakan [konektor](https://nightlies.apache.org/flink/flink-docs-release-1.20/docs/connectors/table/overview/) v untuk mengirim data ke aliran data Kinesis, topik Kafka, Amazon S3, atau database relasional. Anda juga dapat menggunakan konektor khusus untuk mencetak output hanya untuk tujuan pengembangan. Untuk informasi selengkapnya, lihat [Tulis data menggunakan sink](how-sinks.md).

Aplikasi Anda memerlukan beberapa *dependensi eksternal*, seperti konektor Flink yang digunakan aplikasi Anda, atau berpotensi pustaka Java. Untuk berjalan di Amazon Managed Service untuk Apache Flink, aplikasi harus dikemas bersama dengan dependensi dalam toples *lemak dan diunggah ke* bucket Amazon S3. Anda kemudian membuat Layanan Terkelola untuk aplikasi Apache Flink. Anda melewati lokasi paket kode, bersama dengan parameter konfigurasi runtime lainnya. 

Tutorial ini menunjukkan bagaimana menggunakan Apache Maven untuk mengemas aplikasi, dan bagaimana menjalankan aplikasi secara lokal di IDE pilihan Anda.

## Memenuhi prasyarat untuk menyelesaikan latihan
<a name="setting-up-prerequisites"></a>

Untuk menyelesaikan langkah-langkah di panduan ini, Anda harus memiliki hal-hal berikut:
+ [Klien Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git). Instal klien Git, jika Anda belum melakukannya.
+ [Java Development Kit (JDK) versi 11](https://www.oracle.com/java/technologies/downloads/#java11). Instal Java JDK 11 dan atur variabel `JAVA_HOME` lingkungan untuk menunjuk ke lokasi instalasi JDK Anda. Jika Anda tidak memiliki JDK 11, Anda dapat menggunakan [Amazon Coretto 11](https://docs.aws.amazon.com/corretto/latest/corretto-11-ug/what-is-corretto-11.html) atau JDK standar pilihan Anda lainnya. 
  + Untuk memverifikasi bahwa Anda telah menginstal JDK dengan benar, jalankan perintah berikut. Outputnya akan berbeda jika Anda menggunakan JDK selain Amazon Corretto. Pastikan versinya 11.x.

    ```
    $ java --version
    
    openjdk 11.0.23 2024-04-16 LTS
    OpenJDK Runtime Environment Corretto-11.0.23.9.1 (build 11.0.23+9-LTS)
    OpenJDK 64-Bit Server VM Corretto-11.0.23.9.1 (build 11.0.23+9-LTS, mixed mode)
    ```
+ [Apache Maven](https://maven.apache.org/). Instal Apache Maven jika Anda belum melakukannya. Untuk mempelajari cara menginstalnya, lihat [Menginstal Apache Maven](https://maven.apache.org/install.html).
  + Untuk menguji instalasi Apache Maven Anda, masukkan hal berikut:

  ```
  $ mvn -version
  ```
+ IDE untuk pengembangan lokal. Kami menyarankan Anda menggunakan lingkungan pengembangan seperti [Eclipse Java Neon atau](https://www.eclipse.org/downloads/packages/release/neon/3) [IntelliJ IDEA](https://www.jetbrains.com/idea/) untuk mengembangkan dan mengkompilasi aplikasi Anda.
  + Untuk menguji instalasi Apache Maven Anda, masukkan hal berikut:

  ```
  $ mvn -version
  ```

Untuk memulai, buka [Siapkan AWS akun dan buat pengguna administrator](setting-up.md).

# Siapkan AWS akun dan buat pengguna administrator
<a name="setting-up"></a>

Sebelum Anda menggunakan Managed Service untuk Apache Flink untuk pertama kalinya, selesaikan tugas-tugas berikut:

## Mendaftar untuk Akun AWS
<a name="sign-up-for-aws"></a>

Jika Anda tidak memiliki Akun AWS, selesaikan langkah-langkah berikut untuk membuatnya.

**Untuk mendaftar untuk Akun AWS**

1. Buka [https://portal.aws.amazon.com/billing/pendaftaran.](https://portal.aws.amazon.com/billing/signup)

1. Ikuti petunjuk online.

   Bagian dari prosedur pendaftaran melibatkan menerima panggilan telepon atau pesan teks dan memasukkan kode verifikasi pada keypad telepon.

   Saat Anda mendaftar untuk sebuah Akun AWS, sebuah *Pengguna root akun AWS*dibuat. Pengguna root memiliki akses ke semua Layanan AWS dan sumber daya di akun. Sebagai praktik keamanan terbaik, tetapkan akses administratif ke pengguna, dan gunakan hanya pengguna root untuk melakukan [tugas yang memerlukan akses pengguna root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS mengirimi Anda email konfirmasi setelah proses pendaftaran selesai. Kapan saja, Anda dapat melihat aktivitas akun Anda saat ini dan mengelola akun Anda dengan masuk [https://aws.amazon.com.rproxy.goskope.comke/](https://aws.amazon.com/) dan memilih **Akun Saya**.

## Buat pengguna dengan akses administratif
<a name="create-an-admin"></a>

Setelah Anda mendaftar Akun AWS, amankan Pengguna root akun AWS, aktifkan AWS IAM Identity Center, dan buat pengguna administratif sehingga Anda tidak menggunakan pengguna root untuk tugas sehari-hari.

**Amankan Anda Pengguna root akun AWS**

1.  Masuk ke [Konsol Manajemen AWS](https://console.aws.amazon.com/)sebagai pemilik akun dengan memilih **pengguna Root** dan memasukkan alamat Akun AWS email Anda. Di laman berikutnya, masukkan kata sandi.

   Untuk bantuan masuk dengan menggunakan pengguna root, lihat [Masuk sebagai pengguna root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) di *AWS Sign-In Panduan Pengguna*.

1. Mengaktifkan autentikasi multi-faktor (MFA) untuk pengguna root Anda.

   Untuk petunjuk, lihat [Mengaktifkan perangkat MFA virtual untuk pengguna Akun AWS root (konsol) Anda](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) di Panduan Pengguna *IAM*.

**Buat pengguna dengan akses administratif**

1. Aktifkan Pusat Identitas IAM.

   Untuk mendapatkan petunjuk, silakan lihat [Mengaktifkan AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) di *Panduan Pengguna AWS IAM Identity Center *.

1. Di Pusat Identitas IAM, berikan akses administratif ke pengguna.

   Untuk tutorial tentang menggunakan Direktori Pusat Identitas IAM sebagai sumber identitas Anda, lihat [Mengkonfigurasi akses pengguna dengan default Direktori Pusat Identitas IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) di *Panduan AWS IAM Identity Center Pengguna*.

**Masuk sebagai pengguna dengan akses administratif**
+ Untuk masuk dengan pengguna Pusat Identitas IAM, gunakan URL masuk yang dikirim ke alamat email saat Anda membuat pengguna Pusat Identitas IAM.

  Untuk bantuan masuk menggunakan pengguna Pusat Identitas IAM, lihat [Masuk ke portal AWS akses](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) di *Panduan AWS Sign-In Pengguna*.

**Tetapkan akses ke pengguna tambahan**

1. Di Pusat Identitas IAM, buat set izin yang mengikuti praktik terbaik menerapkan izin hak istimewa paling sedikit.

   Untuk petunjuknya, lihat [Membuat set izin](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) di *Panduan AWS IAM Identity Center Pengguna*.

1. Tetapkan pengguna ke grup, lalu tetapkan akses masuk tunggal ke grup.

   Untuk petunjuk, lihat [Menambahkan grup](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) di *Panduan AWS IAM Identity Center Pengguna*.

## Memberikan akses programatis
<a name="setting-up-access"></a>

Pengguna membutuhkan akses terprogram jika mereka ingin berinteraksi dengan AWS luar. Konsol Manajemen AWS Cara untuk memberikan akses terprogram tergantung pada jenis pengguna yang mengakses AWS.

Untuk memberi pengguna akses programatis, pilih salah satu opsi berikut.


****  

| Pengguna mana yang membutuhkan akses programatis? | Untuk | Oleh | 
| --- | --- | --- | 
| IAM | (Disarankan) Gunakan kredenal konsol sebagai kredensil sementara untuk menandatangani permintaan terprogram ke,, atau. AWS CLI AWS SDKs AWS APIs |  Mengikuti petunjuk untuk antarmuka yang ingin Anda gunakan. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/managed-flink/latest/java/setting-up.html)  | 
|  Identitas tenaga kerja (Pengguna yang dikelola di Pusat Identitas IAM)  | Gunakan kredensi sementara untuk menandatangani permintaan terprogram ke AWS CLI,, AWS SDKs atau. AWS APIs |  Mengikuti petunjuk untuk antarmuka yang ingin Anda gunakan. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/managed-flink/latest/java/setting-up.html)  | 
| IAM | Gunakan kredensi sementara untuk menandatangani permintaan terprogram ke AWS CLI,, AWS SDKs atau. AWS APIs | Mengikuti petunjuk dalam [Menggunakan kredensil sementara dengan AWS sumber daya](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) di Panduan Pengguna IAM. | 
| IAM | (Tidak direkomendasikan)Gunakan kredensi jangka panjang untuk menandatangani permintaan terprogram ke AWS CLI,, AWS SDKs atau. AWS APIs |  Mengikuti petunjuk untuk antarmuka yang ingin Anda gunakan. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/managed-flink/latest/java/setting-up.html)  | 

## Langkah Selanjutnya
<a name="setting-up-next-step-2"></a>

[Mengatur AWS Command Line Interface (AWS CLI)](setup-awscli.md)

# Mengatur AWS Command Line Interface (AWS CLI)
<a name="setup-awscli"></a>

Pada langkah ini, Anda mengunduh dan mengonfigurasi AWS CLI untuk digunakan dengan Managed Service for Apache Flink.

**catatan**  
Latihan memulai dalam panduan ini mengasumsikan Anda menggunakan kredensial administrator (`adminuser`) di akun Anda untuk melakukan operasi.

**catatan**  
Jika Anda sudah AWS CLI menginstal, Anda mungkin perlu meningkatkan untuk mendapatkan fungsionalitas terbaru. Untuk informasi selengkapnya, lihat [ Menginstal AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) dalam *Panduan Pengguna AWS Command Line Interface *. Untuk memeriksa versi AWS CLI, jalankan perintah berikut:  

```
aws --version
```
Latihan dalam tutorial ini memerlukan AWS CLI versi berikut atau yang lebih baru:  

```
aws-cli/1.16.63
```

**Untuk mengatur AWS CLI**

1. Unduh dan konfigurasikan AWS CLI. Untuk instruksi, lihat topik berikut di *AWS Command Line Interface Panduan Pengguna*: 
   + [Menginstal AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html)
   + [Mengonfigurasi AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)

1. Tambahkan profil bernama untuk pengguna administrator dalam AWS CLI `config` file. Anda dapat menggunakan profil ini saat menjalankan perintah AWS CLI . Untuk informasi selengkapnya tentang profil yang diberi nama, lihat [Profil yang Diberi Nama](https://docs.aws.amazon.com/cli/latest/userguide/cli-multiple-profiles.html) dalam *Panduan Pengguna AWS Command Line Interface *.

   ```
   [profile adminuser]
   aws_access_key_id = adminuser access key ID
   aws_secret_access_key = adminuser secret access key
   region = aws-region
   ```

   Untuk daftar AWS Wilayah yang tersedia, lihat [Wilayah dan Titik Akhir](https://docs.aws.amazon.com/general/latest/gr/rande.html) di. *Referensi Umum Amazon Web Services*
**catatan**  
Contoh kode dan perintah dalam tutorial ini menggunakan US-east-1 US East (N. Virginia) Region. Untuk menggunakan Wilayah yang berbeda, ubah Wilayah dalam kode dan perintah untuk tutorial ini ke Wilayah yang ingin Anda gunakan.

1. Verifikasikan penyiapan dengan memasukkan perintah bantuan berikut pada prompt perintah. 

   ```
   aws help
   ```

Setelah Anda mengatur AWS akun dan AWS CLI, Anda dapat mencoba latihan berikutnya, di mana Anda mengkonfigurasi aplikasi sampel dan menguji end-to-end pengaturan.

## Langkah berikutnya
<a name="setup-awscli-next-step-3"></a>

[Membuat dan menjalankan Managed Service untuk aplikasi Apache Flink](get-started-exercise.md)

# Membuat dan menjalankan Managed Service untuk aplikasi Apache Flink
<a name="get-started-exercise"></a>

Pada langkah ini, Anda membuat Layanan Terkelola untuk aplikasi Apache Flink dengan aliran data Kinesis sebagai sumber dan wastafel.

**Topics**
+ [

## Buat sumber daya yang bergantung
](#get-started-exercise-0)
+ [

## Siapkan lingkungan pengembangan lokal Anda
](#get-started-exercise-2)
+ [

## Unduh dan periksa kode Java streaming Apache Flink
](#get-started-exercise-5)
+ [

## Tulis catatan sampel ke aliran input
](#get-started-exercise-5-4)
+ [

## Jalankan aplikasi Anda secara lokal
](#get-started-exercise-5-run)
+ [

## Amati data input dan output dalam aliran Kinesis
](#get-started-exercise-input-output)
+ [

## Menghentikan aplikasi Anda berjalan secara lokal
](#get-started-exercise-stop)
+ [

## Kompilasi dan paket kode aplikasi Anda
](#get-started-exercise-5-5)
+ [

## Unggah file JAR kode aplikasi
](#get-started-exercise-6)
+ [

## Buat dan konfigurasikan Layanan Terkelola untuk aplikasi Apache Flink
](#get-started-exercise-7)
+ [

## Langkah berikutnya
](#get-started-exercise-next-step-4)

## Buat sumber daya yang bergantung
<a name="get-started-exercise-0"></a>

Sebelum Anda membuat Layanan Terkelola untuk aplikasi Apache Flink untuk latihan ini, Anda membuat sumber daya dependen berikut: 
+ Dua aliran data Kinesis untuk input dan output
+ Bucket Amazon S3 untuk menyimpan kode aplikasi
**catatan**  
Tutorial ini mengasumsikan bahwa Anda menerapkan aplikasi Anda di wilayah us-east-1 US East (N. Virginia). Jika Anda menggunakan Wilayah lain, sesuaikan semua langkah yang sesuai.

### Buat dua aliran data Amazon Kinesis
<a name="get-started-exercise-1"></a>

Sebelum Anda membuat Layanan Terkelola untuk aplikasi Apache Flink untuk latihan ini, buat dua aliran data Kinesis (dan). `ExampleInputStream` `ExampleOutputStream` Aplikasi Anda menggunakan aliran ini untuk sumber aplikasi dan aliran tujuan.

Anda dapat membuat aliran ini menggunakan konsol Amazon Kinesis atau perintah berikut. AWS CLI Untuk instruksi konsol, lihat [Membuat dan Memperbarui Aliran Data](https://docs.aws.amazon.com/kinesis/latest/dev/amazon-kinesis-streams.html) di *Panduan Developer Amazon Kinesis Data Streams*. Untuk membuat aliran menggunakan AWS CLI, gunakan perintah berikut, sesuaikan dengan Wilayah yang Anda gunakan untuk aplikasi Anda.

**Untuk membuat aliran data AWS CLI**

1. Untuk membuat stream (`ExampleInputStream`) pertama, gunakan perintah Amazon Kinesis `create-stream` AWS CLI berikut:

   ```
   $ aws kinesis create-stream \
   --stream-name ExampleInputStream \
   --shard-count 1 \
   --region us-east-1 \
   ```

1. Untuk membuat aliran kedua yang digunakan aplikasi untuk menulis output, jalankan perintah yang sama, ubah nama aliran menjadi`ExampleOutputStream`:

   ```
   $ aws kinesis create-stream \
   --stream-name ExampleOutputStream \
   --shard-count 1 \
   --region us-east-1 \
   ```

### Buat bucket Amazon S3 untuk kode aplikasi
<a name="get-started-exercise-1-5"></a>

Anda dapat membuat bucket Amazon S3 menggunakan konsol. Untuk mempelajari cara membuat bucket Amazon S3 menggunakan konsol, lihat [Membuat bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) di Panduan Pengguna [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/). Beri nama bucket Amazon S3 menggunakan nama yang unik secara global, misalnya dengan menambahkan nama login Anda.

**catatan**  
 Pastikan Anda membuat bucket di Region yang Anda gunakan untuk tutorial ini (us-east-1).

### Sumber daya lainnya
<a name="get-started-exercise-1-6"></a>

Saat Anda membuat aplikasi, Managed Service for Apache Flink secara otomatis membuat CloudWatch resource Amazon berikut jika belum ada:
+ Sebuah grup log yang disebut `/AWS/KinesisAnalytics-java/<my-application>`
+ Aliran log yang disebut `kinesis-analytics-log-stream`

## Siapkan lingkungan pengembangan lokal Anda
<a name="get-started-exercise-2"></a>

Untuk pengembangan dan debugging, Anda dapat menjalankan aplikasi Apache Flink di mesin Anda langsung dari IDE pilihan Anda. Setiap dependensi Apache Flink ditangani seperti dependensi Java biasa menggunakan Apache Maven. 

**catatan**  
Pada mesin pengembangan Anda, Anda harus menginstal Java JDK 11, Maven, dan Git. [Kami menyarankan Anda menggunakan lingkungan pengembangan seperti [Eclipse Java Neon atau](https://www.eclipse.org/downloads/packages/release/neon/3) IntelliJ IDEA.](https://www.jetbrains.com/idea/) Untuk memverifikasi bahwa Anda memenuhi semua prasyarat, lihat. [Memenuhi prasyarat untuk menyelesaikan latihan](getting-started.md#setting-up-prerequisites) Anda **tidak** perlu menginstal cluster Apache Flink di mesin Anda. 

### Otentikasi sesi Anda AWS
<a name="get-started-exercise-2-5"></a>

Aplikasi ini menggunakan aliran data Kinesis untuk mempublikasikan data. Saat berjalan secara lokal, Anda harus memiliki sesi AWS otentikasi yang valid dengan izin untuk menulis ke aliran data Kinesis. Gunakan langkah-langkah berikut untuk mengautentikasi sesi Anda:

1. Jika Anda tidak memiliki AWS CLI dan profil bernama dengan kredensi valid yang dikonfigurasi, lihat[Mengatur AWS Command Line Interface (AWS CLI)](setup-awscli.md).

1. Verifikasi bahwa Anda AWS CLI telah dikonfigurasi dengan benar dan pengguna Anda memiliki izin untuk menulis ke aliran data Kinesis dengan menerbitkan catatan pengujian berikut:

   ```
   $ aws kinesis put-record --stream-name ExampleOutputStream --data TEST --partition-key TEST
   ```

1. Jika IDE Anda memiliki plugin untuk diintegrasikan AWS, Anda dapat menggunakannya untuk meneruskan kredensil ke aplikasi yang berjalan di IDE. [Untuk informasi selengkapnya, lihat [AWS Toolkit untuk IntelliJ IDEA](https://aws.amazon.com/intellij/) dan Toolkit AWS for Eclipse.](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/welcome.html)

## Unduh dan periksa kode Java streaming Apache Flink
<a name="get-started-exercise-5"></a>

Kode aplikasi Java untuk contoh ini tersedia dari GitHub. Untuk mengunduh kode aplikasi, lakukan hal berikut:

1. Kloning repositori jarak jauh menggunakan perintah berikut:

   ```
   git clone https://github.com/aws-samples/amazon-managed-service-for-apache-flink-examples.git
   ```

1. Buka direktori `amazon-managed-service-for-apache-flink-examples/tree/main/java/GettingStarted` tersebut.

### Tinjau komponen aplikasi
<a name="get-started-exercise-5-1"></a>

Aplikasi ini sepenuhnya diimplementasikan di `com.amazonaws.services.msf.BasicStreamingJob` kelas. `main()`Metode ini mendefinisikan aliran data untuk memproses data streaming dan menjalankannya. 

**catatan**  
Untuk pengalaman pengembang yang dioptimalkan, aplikasi ini dirancang untuk berjalan tanpa perubahan kode apa pun baik di Amazon Managed Service untuk Apache Flink maupun secara lokal, untuk pengembangan di IDE Anda.
+ Untuk membaca konfigurasi runtime sehingga akan berfungsi saat berjalan di Amazon Managed Service untuk Apache Flink dan di IDE Anda, aplikasi secara otomatis mendeteksi jika berjalan mandiri secara lokal di IDE. Dalam hal ini, aplikasi memuat konfigurasi runtime secara berbeda:

  1. Saat aplikasi mendeteksi bahwa aplikasi berjalan dalam mode mandiri di IDE Anda, bentuk `application_properties.json` file yang disertakan dalam folder **sumber daya** proyek. Isi file berikut.

  1. Saat aplikasi berjalan di Amazon Managed Service untuk Apache Flink, perilaku default memuat konfigurasi aplikasi dari properti runtime yang akan Anda tentukan di Amazon Managed Service untuk aplikasi Apache Flink. Lihat [Buat dan konfigurasikan Layanan Terkelola untuk aplikasi Apache Flink](#get-started-exercise-7).

     ```
     private static Map<String, Properties> loadApplicationProperties(StreamExecutionEnvironment env) throws IOException {
         if (env instanceof LocalStreamEnvironment) {
             LOGGER.info("Loading application properties from '{}'", LOCAL_APPLICATION_PROPERTIES_RESOURCE);
             return KinesisAnalyticsRuntime.getApplicationProperties(
                     BasicStreamingJob.class.getClassLoader()
                             .getResource(LOCAL_APPLICATION_PROPERTIES_RESOURCE).getPath());
         } else {
             LOGGER.info("Loading application properties from Amazon Managed Service for Apache Flink");
             return KinesisAnalyticsRuntime.getApplicationProperties();
         }
     }
     ```
+ `main()`Metode ini mendefinisikan aliran data aplikasi dan menjalankannya. 
  + Menginisialisasi lingkungan streaming default. Dalam contoh ini, kami menunjukkan cara membuat kedua yang `StreamExecutionEnvironment` akan digunakan dengan DataSteam API dan yang `StreamTableEnvironment` akan digunakan dengan SQL dan Table API. Dua objek lingkungan adalah dua referensi terpisah ke lingkungan runtime yang sama, untuk menggunakan yang berbeda APIs. 

    ```
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    ```
  + Muat parameter konfigurasi aplikasi. Ini akan secara otomatis memuatnya dari tempat yang benar, tergantung di mana aplikasi berjalan:

    ```
    Map<String, Properties> applicationParameters = loadApplicationProperties(env);
    ```
  + Aplikasi mendefinisikan sumber menggunakan konektor Konsumen [Kinesis](https://nightlies.apache.org/flink/flink-docs-release-1.18/docs/connectors/datastream/kinesis/#kinesis-consumer) untuk membaca data dari aliran input. Konfigurasi aliran input didefinisikan dalam `PropertyGroupId` =`InputStream0`. Nama dan Wilayah aliran berada di properti bernama `stream.name` dan `aws.region` masing-masing. Untuk mempermudah, sumber ini membaca catatan sebagai string. 

    ```
    private static FlinkKinesisConsumer<String> createSource(Properties inputProperties) {
        String inputStreamName = inputProperties.getProperty("stream.name");
        return new FlinkKinesisConsumer<>(inputStreamName, new SimpleStringSchema(), inputProperties);
    }
    ...
    
    public static void main(String[] args) throws Exception { 
       ...
       SourceFunction<String> source = createSource(applicationParameters.get("InputStream0"));
       DataStream<String> input = env.addSource(source, "Kinesis Source");  
       ...
    }
    ```
  + Aplikasi kemudian mendefinisikan wastafel menggunakan konektor [Kinesis Streams](https://nightlies.apache.org/flink/flink-docs-release-1.18/docs/connectors/datastream/kinesis/#kinesis-streams-sink) Sink untuk mengirim data ke aliran output. Nama aliran keluaran dan Wilayah didefinisikan dalam `PropertyGroupId` =`OutputStream0`, mirip dengan aliran input. Wastafel terhubung langsung ke internal `DataStream` yang mendapatkan data dari sumbernya. Dalam aplikasi nyata, Anda memiliki beberapa transformasi antara sumber dan wastafel. 

    ```
    private static KinesisStreamsSink<String> createSink(Properties outputProperties) {
        String outputStreamName = outputProperties.getProperty("stream.name");
        return KinesisStreamsSink.<String>builder()
                .setKinesisClientProperties(outputProperties)
                .setSerializationSchema(new SimpleStringSchema())
                .setStreamName(outputStreamName)
                .setPartitionKeyGenerator(element -> String.valueOf(element.hashCode()))
                .build();
    }
    ...
    public static void main(String[] args) throws Exception { 
       ...
       Sink<String> sink = createSink(applicationParameters.get("OutputStream0"));
       input.sinkTo(sink);
       ...
    }
    ```
  + Akhirnya, Anda menjalankan aliran data yang baru saja Anda tentukan. Ini harus menjadi instruksi terakhir dari `main()` metode ini, setelah Anda mendefinisikan semua operator aliran data membutuhkan:

    ```
    env.execute("Flink streaming Java API skeleton");
    ```

### Gunakan file pom.xml
<a name="get-started-exercise-5-2"></a>

File pom.xml mendefinisikan semua dependensi yang diperlukan oleh aplikasi dan menyiapkan plugin Maven Shade untuk membangun toples lemak yang berisi semua dependensi yang diperlukan oleh Flink. 
+ Beberapa dependensi memiliki `provided` ruang lingkup. Dependensi ini secara otomatis tersedia saat aplikasi berjalan di Amazon Managed Service untuk Apache Flink. Mereka diperlukan untuk mengkompilasi aplikasi, atau untuk menjalankan aplikasi secara lokal di IDE Anda. Untuk informasi selengkapnya, lihat [Jalankan aplikasi Anda secara lokal](#get-started-exercise-5-run). Pastikan Anda menggunakan versi Flink yang sama dengan runtime yang akan Anda gunakan di Amazon Managed Service untuk Apache Flink.

  ```
  <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-clients</artifactId>
      <version>${flink.version}</version>
      <scope>provided</scope>
  </dependency>
  <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-streaming-java</artifactId>
      <version>${flink.version}</version>
      <scope>provided</scope>
  </dependency>
  ```
+ Anda harus menambahkan dependensi Apache Flink tambahan ke pom dengan cakupan default, seperti konektor [Kinesis](https://nightlies.apache.org/flink/flink-docs-master/docs/connectors/datastream/kinesis/) yang digunakan oleh aplikasi ini. Untuk informasi selengkapnya, lihat [Gunakan konektor Apache Flink](how-flink-connectors.md). Anda juga dapat menambahkan dependensi Java tambahan yang diperlukan oleh aplikasi Anda. 

  ```
  <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-connector-kinesis</artifactId>
      <version>${aws.connector.version}</version>
  </dependency>
  ```
+ Plugin Maven Java Compiler memastikan bahwa kode dikompilasi terhadap Java 11, versi JDK yang saat ini didukung oleh Apache Flink. 
+ Plugin Maven Shade mengemas toples lemak, tidak termasuk beberapa pustaka yang disediakan oleh runtime. Ini juga menentukan dua transformator: dan. `ServicesResourceTransformer` `ManifestResourceTransformer` Yang terakhir mengkonfigurasi kelas yang berisi `main` metode untuk memulai aplikasi. Jika Anda mengganti nama kelas utama, jangan lupa untuk memperbarui transformator ini.
+ 

  ```
  <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-shade-plugin</artifactId>
      ...
          <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
              <mainClass>com.amazonaws.services.msf.BasicStreamingJob</mainClass>
          </transformer>
      ...
  </plugin>
  ```

## Tulis catatan sampel ke aliran input
<a name="get-started-exercise-5-4"></a>

Di bagian ini, Anda akan mengirim catatan sampel ke aliran untuk aplikasi untuk diproses. Anda memiliki dua opsi untuk menghasilkan data sampel, baik menggunakan skrip Python atau [Kinesis](https://github.com/awslabs/amazon-kinesis-data-generator) Data Generator.

### Menghasilkan data sampel menggunakan skrip Python
<a name="get-started-exercise-5-4-1"></a>

Anda dapat menggunakan skrip Python untuk mengirim catatan sampel ke aliran.

**catatan**  
Untuk menjalankan skrip Python ini, Anda harus menggunakan Python 3.x dan menginstal pustaka SDK [AWS untuk Python](https://aws.amazon.com/developer/language/python/) (Boto).

**Untuk mulai mengirim data uji ke aliran input Kinesis:**

1. Unduh skrip `stock.py` Python generator data dari repositori [generator GitHub Data](https://github.com/aws-samples/amazon-managed-service-for-apache-flink-examples/tree/main/python/data-generator).

1. Jalankan skrip `stock.py`.

   ```
   $ python stock.py
   ```

Jaga agar skrip tetap berjalan saat Anda menyelesaikan sisa tutorial. Anda sekarang dapat menjalankan aplikasi Apache Flink Anda.

### Hasilkan data sampel menggunakan Kinesis Data Generator
<a name="get-started-exercise-5-4-2"></a>

Atau menggunakan skrip Python, Anda dapat menggunakan [Kinesis Data Generator](https://github.com/awslabs/amazon-kinesis-data-generator), juga tersedia dalam [versi yang dihosting](https://awslabs.github.io/amazon-kinesis-data-generator/web/producer.html), untuk mengirim data sampel acak ke aliran. Kinesis Data Generator berjalan di browser Anda, dan Anda tidak perlu menginstal apa pun di mesin Anda. 

**Untuk mengatur dan menjalankan Kinesis Data Generator:**

1. Ikuti petunjuk dalam [dokumentasi Kinesis Data Generator](https://awslabs.github.io/amazon-kinesis-data-generator/web/help.html) untuk mengatur akses ke alat. Anda akan menjalankan CloudFormation template yang mengatur pengguna dan kata sandi. 

1. Akses Kinesis Data Generator melalui URL yang dihasilkan oleh template. CloudFormation Anda dapat menemukan URL di **Output** tab setelah CloudFormation template selesai. 

1. Konfigurasikan generator data:
   + **Wilayah:** Pilih Wilayah yang Anda gunakan untuk tutorial ini: us-east-1
   + **Stream/streaming pengiriman:** Pilih aliran input yang akan digunakan aplikasi: `ExampleInputStream`
   + **Catatan per detik:** 100
   + **Rekam templat:** Salin dan tempel templat berikut:

     ```
     {
       "event_time" : "{{date.now("YYYY-MM-DDTkk:mm:ss.SSSSS")}},
       "ticker" : "{{random.arrayElement(
             ["AAPL", "AMZN", "MSFT", "INTC", "TBV"]
         )}}",
       "price" : {{random.number(100)}}          
     }
     ```

1. Uji template: Pilih **template Uji** dan verifikasi bahwa catatan yang dihasilkan mirip dengan yang berikut:

   ```
   { "event_time" : "2024-06-12T15:08:32.04800, "ticker" : "INTC", "price" : 7 }
   ```

1. Mulai generator data: Pilih **Pilih Kirim Data**.

Kinesis Data Generator sekarang mengirimkan data ke file. `ExampleInputStream` 

## Jalankan aplikasi Anda secara lokal
<a name="get-started-exercise-5-run"></a>

Anda dapat menjalankan dan men-debug aplikasi Flink Anda secara lokal di IDE Anda.

**catatan**  
Sebelum Anda melanjutkan, verifikasi bahwa aliran input dan output tersedia. Lihat [Buat dua aliran data Amazon Kinesis](#get-started-exercise-1). Juga, verifikasi bahwa Anda memiliki izin untuk membaca dan menulis dari kedua aliran. Lihat [Otentikasi sesi Anda AWS](#get-started-exercise-2-5).   
Menyiapkan lingkungan pengembangan lokal membutuhkan Java 11 JDK, Apache Maven, dan IDE untuk pengembangan Java. Verifikasi bahwa Anda memenuhi prasyarat yang diperlukan. Lihat [Memenuhi prasyarat untuk menyelesaikan latihan](getting-started.md#setting-up-prerequisites).

### Impor proyek Java ke IDE Anda
<a name="get-started-exercise-5-run-1"></a>

Untuk mulai mengerjakan aplikasi di IDE Anda, Anda harus mengimpornya sebagai proyek Java. 

Repositori yang Anda kloning berisi beberapa contoh. Setiap contoh adalah proyek terpisah. Untuk tutorial ini, impor konten dalam `./java/GettingStarted` subdirektori ke IDE Anda. 

Masukkan kode sebagai proyek Java yang ada menggunakan Maven.

**catatan**  
Proses yang tepat untuk mengimpor proyek Java baru bervariasi tergantung pada IDE yang Anda gunakan.

### Periksa konfigurasi aplikasi lokal
<a name="get-started-exercise-5-run-2"></a>

Saat berjalan secara lokal, aplikasi menggunakan konfigurasi dalam `application_properties.json` file di folder sumber daya proyek di bawah`./src/main/resources`. Anda dapat mengedit file ini untuk menggunakan nama atau Wilayah aliran Kinesis yang berbeda.

```
[
  {
    "PropertyGroupId": "InputStream0",
    "PropertyMap": {
      "stream.name": "ExampleInputStream",
      "flink.stream.initpos": "LATEST",
      "aws.region": "us-east-1"
    }
  },
  {
    "PropertyGroupId": "OutputStream0",
    "PropertyMap": {
      "stream.name": "ExampleOutputStream",
      "aws.region": "us-east-1"
    }
  }
]
```

### Siapkan konfigurasi run IDE Anda
<a name="get-started-exercise-5-run-3"></a>

Anda dapat menjalankan dan men-debug aplikasi Flink dari IDE Anda secara langsung dengan menjalankan kelas utama`com.amazonaws.services.msf.BasicStreamingJob`, karena Anda akan menjalankan aplikasi Java apa pun. Sebelum menjalankan aplikasi, Anda harus mengatur konfigurasi Run. Pengaturan tergantung pada IDE yang Anda gunakan. Misalnya, lihat [konfigurasi Jalankan/debug dalam](https://www.jetbrains.com/help/idea/run-debug-configuration.html) dokumentasi IntelliJ IDEA. Secara khusus, Anda harus mengatur yang berikut:

1. **Tambahkan `provided` dependensi ke classpath.** Ini diperlukan untuk memastikan bahwa dependensi dengan `provided` cakupan diteruskan ke aplikasi saat berjalan secara lokal. Tanpa pengaturan ini, aplikasi segera menampilkan `class not found` kesalahan. 

1. **Lulus AWS kredensi untuk mengakses aliran Kinesis** ke aplikasi. Cara tercepat adalah dengan menggunakan [AWS Toolkit untuk IntelliJ IDEA](https://aws.amazon.com/intellij/). Menggunakan plugin IDE ini dalam konfigurasi Run, Anda dapat memilih AWS profil tertentu. AWS otentikasi terjadi menggunakan profil ini. Anda tidak perlu memberikan AWS kredensil secara langsung. 

1. Verifikasi bahwa IDE menjalankan aplikasi menggunakan **JDK 11**.

### Jalankan aplikasi di IDE Anda
<a name="get-started-exercise-5-run-4"></a>

Setelah Anda mengatur konfigurasi Run untuk`BasicStreamingJob`, Anda dapat menjalankan atau men-debug seperti aplikasi Java biasa. 

**catatan**  
Anda tidak dapat menjalankan toples lemak yang dihasilkan oleh Maven langsung dengan `java -jar ...` dari baris perintah. Toples ini tidak berisi dependensi inti Flink yang diperlukan untuk menjalankan aplikasi mandiri.

Ketika aplikasi dimulai dengan sukses, ia mencatat beberapa informasi tentang minicluster mandiri dan inisialisasi konektor. Ini diikuti oleh sejumlah INFO dan beberapa log WARN yang biasanya dipancarkan Flink saat aplikasi dimulai.

```
13:43:31,405 INFO  com.amazonaws.services.msf.BasicStreamingJob                 [] - Loading application properties from 'flink-application-properties-dev.json'
13:43:31,549 INFO  org.apache.flink.streaming.connectors.kinesis.FlinkKinesisConsumer [] - Flink Kinesis Consumer is going to read the following streams: ExampleInputStream, 
13:43:31,676 INFO  org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.cpu.cores required for local execution is not set, setting it to the maximal possible value.
13:43:31,676 INFO  org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.task.heap.size required for local execution is not set, setting it to the maximal possible value.
13:43:31,676 INFO  org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.task.off-heap.size required for local execution is not set, setting it to the maximal possible value.
13:43:31,676 INFO  org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.network.min required for local execution is not set, setting it to its default value 64 mb.
13:43:31,676 INFO  org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.network.max required for local execution is not set, setting it to its default value 64 mb.
13:43:31,676 INFO  org.apache.flink.runtime.taskexecutor.TaskExecutorResourceUtils [] - The configuration option taskmanager.memory.managed.size required for local execution is not set, setting it to its default value 128 mb.
13:43:31,677 INFO  org.apache.flink.runtime.minicluster.MiniCluster             [] - Starting Flink Mini Cluster
....
```

Setelah inisialisasi selesai, aplikasi tidak memancarkan entri log lebih lanjut. **Saat data mengalir, tidak ada log yang dipancarkan.**

Untuk memverifikasi apakah aplikasi memproses data dengan benar, Anda dapat memeriksa aliran Kinesis input dan output, seperti yang dijelaskan di bagian berikut.

**catatan**  
 Tidak memancarkan log tentang data yang mengalir adalah perilaku normal untuk aplikasi Flink. Memancarkan log pada setiap catatan mungkin nyaman untuk debugging, tetapi dapat menambahkan overhead yang cukup besar saat berjalan dalam produksi. 

## Amati data input dan output dalam aliran Kinesis
<a name="get-started-exercise-input-output"></a>

Anda dapat mengamati catatan yang dikirim ke aliran input oleh (menghasilkan sampel Python) atau Kinesis Data Generator (link) dengan menggunakan **Data Viewer** di konsol Amazon Kinesis. 

**Untuk mengamati catatan**

1. [Buka konsol Kinesis di /kinesis. https://console.aws.amazon.com](https://console.aws.amazon.com/kinesis)

1. Verifikasi bahwa Region sama dengan tempat Anda menjalankan tutorial ini, yaitu us-east-1 US East (Virginia N.) secara default. Ubah Wilayah jika tidak cocok. 

1. Pilih **Aliran Data**. 

1. Pilih aliran yang ingin Anda amati, salah satu `ExampleInputStream` atau `ExampleOutputStream.`

1. Pilih tab **Penampil data**. 

1. Pilih **Shard** apa saja, simpan **Terbaru** sebagai **posisi** Awal, lalu pilih **Dapatkan catatan**. Anda mungkin melihat kesalahan “Tidak ada catatan ditemukan untuk permintaan ini”. Jika demikian, pilih **Coba lagi mendapatkan catatan**. Catatan terbaru yang diterbitkan ke tampilan streaming. 

1. Pilih nilai di kolom Data untuk memeriksa konten catatan dalam format JSON.

## Menghentikan aplikasi Anda berjalan secara lokal
<a name="get-started-exercise-stop"></a>

Hentikan aplikasi yang berjalan di IDE Anda. IDE biasanya menyediakan opsi “berhenti”. Lokasi dan metode yang tepat tergantung pada IDE yang Anda gunakan. 

## Kompilasi dan paket kode aplikasi Anda
<a name="get-started-exercise-5-5"></a>

Di bagian ini, Anda menggunakan Apache Maven untuk mengkompilasi kode Java dan mengemasnya ke dalam file JAR. Anda dapat mengkompilasi dan mengemas kode Anda menggunakan alat baris perintah Maven atau IDE Anda.

**Untuk mengkompilasi dan paket menggunakan baris perintah Maven:**

Pindah ke direktori yang berisi GettingStarted proyek Java dan jalankan perintah berikut:

```
$ mvn package
```

**Untuk mengkompilasi dan mengemas menggunakan IDE Anda:**

Jalankan `mvn package` dari integrasi IDE Maven Anda.

Dalam kedua kasus, file JAR berikut dibuat:`target/amazon-msf-java-stream-app-1.0.jar`.

**catatan**  
 Menjalankan “build project” dari IDE Anda mungkin tidak membuat file JAR.

## Unggah file JAR kode aplikasi
<a name="get-started-exercise-6"></a>

Di bagian ini, Anda mengunggah file JAR yang Anda buat di bagian sebelumnya ke bucket Amazon Simple Storage Service (Amazon S3) yang Anda buat di awal tutorial ini. Jika Anda belum menyelesaikan langkah ini, lihat (tautan).

**Untuk mengunggah file JAR kode aplikasi**

1. Buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Pilih bucket yang sebelumnya Anda buat untuk kode aplikasi.

1. Pilih **Unggah**.

1. Pilih **Tambahkan file**.

1. Arahkan ke file JAR yang dihasilkan pada langkah sebelumnya:`target/amazon-msf-java-stream-app-1.0.jar`. 

1. Pilih **Unggah** tanpa mengubah pengaturan lainnya.

**Awas**  
Pastikan Anda memilih file JAR yang benar di`<repo-dir>/java/GettingStarted/target/amazon-msf-java-stream-app-1.0.jar`.   
`target`Direktori ini juga berisi file JAR lain yang tidak perlu Anda unggah.

## Buat dan konfigurasikan Layanan Terkelola untuk aplikasi Apache Flink
<a name="get-started-exercise-7"></a>

Anda dapat membuat dan menjalankan Layanan Terkelola untuk aplikasi Apache Flink menggunakan konsol atau aplikasi. AWS CLI Untuk tutorial ini, Anda akan menggunakan konsol. 

**catatan**  
Saat Anda membuat aplikasi menggunakan konsol, sumber daya AWS Identity and Access Management (IAM) dan Amazon CloudWatch Logs Anda dibuat untuk Anda. Saat Anda membuat aplikasi menggunakan AWS CLI, Anda membuat sumber daya ini secara terpisah.

**Topics**
+ [

### Buat aplikasi
](#get-started-exercise-7-console-create)
+ [

### Edit kebijakan IAM
](#get-started-exercise-7-console-iam)
+ [

### Konfigurasikan aplikasi
](#get-started-exercise-7-console-configure)
+ [

### Jalankan aplikasi
](#get-started-exercise-7-console-run)
+ [

### Amati metrik aplikasi yang sedang berjalan
](#get-started-exercise-7-console-stop)
+ [

### Amati data keluaran dalam aliran Kinesis
](#get-started-exercise-7-console-output)
+ [

### Hentikan aplikasi
](#get-started-exercise-stop)

### Buat aplikasi
<a name="get-started-exercise-7-console-create"></a>

**Untuk membuat aplikasi**

1. Masuk ke Konsol Manajemen AWS, dan buka konsol Amazon MSF di /flink. https://console.aws.amazon.com

1. Verifikasi bahwa Wilayah yang benar dipilih: us-east-1 US East (Virginia N.)

1. Buka menu di sebelah kanan dan pilih aplikasi **Apache Flink dan kemudian Buat aplikasi** **streaming**. Atau, pilih **Buat aplikasi streaming** di wadah Memulai halaman awal. 

1. Di halaman **Buat aplikasi streaming**:
   + **Pilih metode untuk mengatur aplikasi pemrosesan aliran:** pilih **Buat dari awal**.
   + **Konfigurasi Apache Flink, versi Aplikasi Flink:** pilih **Apache** Flink 1.20.

1. Konfigurasikan aplikasi Anda
   + **Nama aplikasi:** masukkan**MyApplication**.
   + **Deskripsi:** masuk**My java test app**.
   + **Akses ke sumber daya aplikasi:** pilih **Buat/perbarui peran IAM `kinesis-analytics-MyApplication-us-east-1` dengan kebijakan yang diperlukan**.

1. Konfigurasikan **Template Anda untuk pengaturan aplikasi**
   + **Template:** pilih **Pengembangan**.

1. Pilih **Buat aplikasi streaming** di bagian bawah halaman.

**catatan**  
Saat membuat aplikasi Managed Service for Apache Flink menggunakan konsol, Anda memiliki opsi untuk membuat peran dan kebijakan IAM untuk aplikasi Anda. Aplikasi Anda menggunakan peran dan kebijakan ini untuk mengakses sumber daya dependen. Sumber daya IAM ini diberi nama menggunakan nama aplikasi dan Wilayah sebagai berikut:  
Kebijakan: `kinesis-analytics-service-MyApplication-us-east-1`
Peran: `kinesisanalytics-MyApplication-us-east-1`
Amazon Managed Service untuk Apache Flink sebelumnya dikenal sebagai Kinesis Data Analytics. Nama sumber daya yang dibuat secara otomatis diawali `kinesis-analytics-` untuk kompatibilitas mundur.

### Edit kebijakan IAM
<a name="get-started-exercise-7-console-iam"></a>

Edit kebijakan IAM untuk menambahkan izin mengakses Kinesis data streams.

**Untuk mengedit kebijakan**

1. Buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Pilih **Policies** (Kebijakan). Pilih kebijakan **`kinesis-analytics-service-MyApplication-us-east-1`** yang dibuat konsol untuk Anda di bagian sebelumnya. 

1. Pilih **Edit** dan kemudian pilih tab **JSON**.

1. Tambahkan bagian yang disorot dari contoh kebijakan berikut ke kebijakan. Ganti akun sampel IDs (*012345678901*) dengan ID akun Anda.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "ReadCode",
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:GetObjectVersion"
               ],
               "Resource": [
                   "arn:aws:s3:::my-bucket/kinesis-analytics-placeholder-s3-object"
               ]
           },
           {
               "Sid": "ListCloudwatchLogGroups",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": [
                   "arn:aws:logs:us-east-1:012345678901:log-group:*"
               ]
           },
           {
               "Sid": "ListCloudwatchLogStreams",
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams"
               ],
               "Resource": [
                   "arn:aws:logs:us-east-1:012345678901:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
               ]
           },
           {
               "Sid": "PutCloudwatchLogs",
               "Effect": "Allow",
               "Action": [
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-east-1:012345678901:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
               ]
           },
           {
               "Sid": "ReadInputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-east-1:012345678901:stream/ExampleInputStream"
           },
           {
               "Sid": "WriteOutputStream",
               "Effect": "Allow",
               "Action": "kinesis:*",
               "Resource": "arn:aws:kinesis:us-east-1:012345678901:stream/ExampleOutputStream"
           }
       ]
   }
   ```

------

1.  Pilih **Berikutnya** di bagian bawah halaman dan kemudian pilih **Simpan perubahan**.

### Konfigurasikan aplikasi
<a name="get-started-exercise-7-console-configure"></a>

Edit konfigurasi aplikasi untuk mengatur artefak kode aplikasi.

**Untuk mengedit konfigurasi**

1. Pada **MyApplication**halaman, pilih **Konfigurasi**.

1. Di bagian **Lokasi kode aplikasi**:
   + Untuk bucket **Amazon S3, pilih bucket** yang sebelumnya Anda buat untuk kode aplikasi. Pilih **Browse** dan pilih bucket yang benar, lalu pilih **Pilih**. Jangan klik pada nama bucket.
   + Untuk **Jalur ke objek Amazon S3**, masukkan **amazon-msf-java-stream-app-1.0.jar**.

1. Untuk **izin Akses**, pilih **Buat/perbarui peran IAM `kinesis-analytics-MyApplication-us-east-1` dengan kebijakan yang diperlukan**.

1. Di bagian **properti Runtime**, tambahkan properti berikut.

1. Pilih **Tambahkan item baru** dan tambahkan masing-masing parameter berikut:    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/managed-flink/latest/java/get-started-exercise.html)

1. Jangan memodifikasi bagian lainnya.

1. Pilih **Simpan perubahan**.

**catatan**  
Saat Anda memilih untuk mengaktifkan CloudWatch pencatatan Amazon, Layanan Terkelola untuk Apache Flink membuat grup log dan aliran log untuk Anda. Nama-nama sumber daya ini adalah sebagai berikut:   
Grup log: `/aws/kinesis-analytics/MyApplication`
Aliran log: `kinesis-analytics-log-stream`

### Jalankan aplikasi
<a name="get-started-exercise-7-console-run"></a>

Aplikasi sekarang dikonfigurasi dan siap dijalankan.

**Untuk menjalankan aplikasi**

1. **Di konsol untuk Amazon Managed Service untuk Apache Flink, pilih **Aplikasi Saya** dan pilih Jalankan.**

1. Pada halaman berikutnya, halaman konfigurasi Pemulihan aplikasi, pilih **Jalankan dengan snapshot terbaru** dan kemudian pilih **Jalankan**. 

   **Status** dalam **Aplikasi merinci** transisi dari `Ready` ke `Starting` dan kemudian ke `Running` saat aplikasi telah dimulai.

Saat aplikasi dalam `Running` status, Anda sekarang dapat membuka dasbor Flink. 

**Untuk membuka dasbor**

1. Pilih **Buka dasbor Apache Flink**. Dasbor terbuka di halaman baru.

1. Dalam daftar **pekerjaan Runing**, pilih satu pekerjaan yang dapat Anda lihat. 
**catatan**  
Jika Anda menyetel properti Runtime atau mengedit kebijakan IAM secara tidak benar, status aplikasi mungkin berubah menjadi`Running`, tetapi dasbor Flink menunjukkan bahwa pekerjaan terus dimulai ulang. Ini adalah skenario kegagalan umum jika aplikasi salah konfigurasi atau tidak memiliki izin untuk mengakses sumber daya eksternal.   
Ketika ini terjadi, periksa tab **Pengecualian** di dasbor Flink untuk melihat penyebab masalah.

### Amati metrik aplikasi yang sedang berjalan
<a name="get-started-exercise-7-console-stop"></a>

Pada **MyApplication**halaman, di bagian ** CloudWatch metrik Amazon**, Anda dapat melihat beberapa metrik dasar dari aplikasi yang sedang berjalan. 

**Untuk melihat metrik**

1. Di sebelah tombol **Refresh**, pilih **10 detik** dari daftar dropdown.

1. Saat aplikasi berjalan dan sehat, Anda dapat melihat metrik **uptime** terus meningkat.

1. Metrik **fullrestart** harus nol. Jika meningkat, konfigurasi mungkin memiliki masalah. Untuk menyelidiki masalah ini, tinjau tab **Pengecualian** di dasbor Flink.

1. **Jumlah metrik pos pemeriksaan yang gagal** harus nol dalam aplikasi yang sehat. 
**catatan**  
Dasbor ini menampilkan satu set metrik tetap dengan perincian 5 menit. Anda dapat membuat dasbor aplikasi khusus dengan metrik apa pun di CloudWatch dasbor.

### Amati data keluaran dalam aliran Kinesis
<a name="get-started-exercise-7-console-output"></a>

Pastikan Anda masih mempublikasikan data ke input, baik menggunakan skrip Python atau Kinesis Data Generator. 

Anda sekarang dapat mengamati output dari aplikasi yang berjalan pada Managed Service untuk Apache Flink dengan menggunakan Data Viewer di [https://console.aws.amazon.com/kinesis/](https://console.aws.amazon.com/kinesis/), mirip dengan apa yang sudah Anda lakukan sebelumnya. 

**Untuk melihat output**

1. [Buka konsol Kinesis di /kinesis. https://console.aws.amazon.com](https://console.aws.amazon.com/kinesis)

1. Verifikasi bahwa Region sama dengan yang Anda gunakan untuk menjalankan tutorial ini. Secara default, itu adalah AS-Timur-1us Timur (Virginia N.). Ubah Wilayah jika perlu.

1. Pilih **Aliran Data**. 

1. Pilih aliran yang ingin Anda amati. Untuk tutorial ini, gunakan `ExampleOutputStream`. 

1.  Pilih tab **Penampil data**. 

1. Pilih **Shard** apa saja, simpan **Terbaru** sebagai **posisi** Awal, lalu pilih **Dapatkan catatan**. Anda mungkin melihat kesalahan “tidak ada catatan ditemukan untuk permintaan ini”. Jika demikian, pilih **Coba lagi mendapatkan catatan**. Catatan terbaru yang diterbitkan ke tampilan streaming.

1. Pilih nilai di kolom Data untuk memeriksa konten catatan dalam format JSON.

### Hentikan aplikasi
<a name="get-started-exercise-stop"></a>

Untuk menghentikan aplikasi, buka halaman konsol dari aplikasi Managed Service for Apache Flink bernama. `MyApplication`

**Untuk menghentikan aplikasi**

1. **Dari daftar dropdown **Action**, pilih Stop.**

1. **Status** dalam **Aplikasi merinci** transisi dari `Running` ke`Stopping`, dan kemudian ke `Ready` saat aplikasi benar-benar dihentikan. 
**catatan**  
Jangan lupa juga untuk berhenti mengirim data ke input stream dari script Python atau Kinesis Data Generator.

## Langkah berikutnya
<a name="get-started-exercise-next-step-4"></a>

[Bersihkan AWS sumber daya](getting-started-cleanup.md)

# Bersihkan AWS sumber daya
<a name="getting-started-cleanup"></a>

Bagian ini mencakup prosedur untuk membersihkan AWS sumber daya yang dibuat dalam tutorial Memulai (DataStream API) ini.

**Topics**
+ [

## Hapus Layanan Terkelola Anda untuk aplikasi Apache Flink
](#getting-started-cleanup-app)
+ [

## Hapus aliran data Kinesis
](#getting-started-cleanup-stream)
+ [

## Hapus objek dan bucket Amazon S3 Anda
](#getting-started-cleanup-s3)
+ [

## Hapus sumber daya IAM Anda
](#getting-started-cleanup-iam)
+ [

## Hapus CloudWatch sumber daya Anda
](#getting-started-cleanup-cw)
+ [

## Jelajahi sumber daya tambahan untuk Apache Flink
](#getting-started-cleanup-next-step-5)

## Hapus Layanan Terkelola Anda untuk aplikasi Apache Flink
<a name="getting-started-cleanup-app"></a>

Gunakan prosedur berikut untuk menghapus aplikasi.

1. [Buka konsol Kinesis di /kinesis. https://console.aws.amazon.com](https://console.aws.amazon.com/kinesis)

1. Di panel Managed Service for Apache Flink, pilih. **MyApplication**

1. Dari daftar dropdown **Tindakan**, pilih **Hapus** dan kemudian konfirmasikan penghapusan.

## Hapus aliran data Kinesis
<a name="getting-started-cleanup-stream"></a>

1. Masuk ke Konsol Manajemen AWS, dan buka konsol Amazon MSF di /flink.. https://console.aws.amazon.com

1. Pilih **Aliran data**.

1. Pilih dua aliran yang Anda buat, `ExampleInputStream` dan`ExampleOutputStream`. 

1. Dari daftar dropdown **Tindakan**, pilih **Hapus**, lalu konfirmasikan penghapusan.

## Hapus objek dan bucket Amazon S3 Anda
<a name="getting-started-cleanup-s3"></a>

Gunakan prosedur berikut untuk menghapus objek dan bucket Amazon S3 Anda.

**Untuk menghapus objek dari bucket S3**

1. Buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Pilih bucket S3 yang Anda buat untuk artefak aplikasi.

1. Pilih artefak aplikasi yang Anda unggah, bernama. `amazon-msf-java-stream-app-1.0.jar`

1. Pilih **Hapus** dan konfirmasikan penghapusan.

**Untuk menghapus bucket S3**

1. Buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Pilih ember yang Anda buat untuk artefak.

1. Pilih **Hapus** dan konfirmasikan penghapusan.
**catatan**  
Bucket S3 harus kosong untuk menghapusnya.

## Hapus sumber daya IAM Anda
<a name="getting-started-cleanup-iam"></a>

**Untuk menghapus sumber daya IAM Anda**

1. Buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Di bilah navigasi, pilih **Policies** (Kebijakan).

1. Di kontrol filter, masukkan **kinesis**.

1. Pilih kebijakan **kinesis-analytics-service- MyApplication -us-east-1**.

1. Pilih **Policy Actions** (Tindakan Kebijakan), lalu pilih **Delete** (Hapus).

1. Di bilah navigasi, pilih **Roles** (Peran).

1. Pilih peran **kinesis-analytics- -us-east-1**. MyApplication

1. Pilih **Delete role** (Hapus peran), lalu konfirmasi penghapusan.

## Hapus CloudWatch sumber daya Anda
<a name="getting-started-cleanup-cw"></a>

1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Di bilah navigasi, pilih **Logs**.

1. Pilih grup**/aws/kinesis-analytics/MyApplication**log.

1. Pilih **Delete Log Group** (Hapus Grup Log), lalu konfirmasi penghapusan.

## Jelajahi sumber daya tambahan untuk Apache Flink
<a name="getting-started-cleanup-next-step-5"></a>

[Jelajahi sumber daya tambahan](getting-started-next-steps.md)

# Jelajahi sumber daya tambahan
<a name="getting-started-next-steps"></a>

Setelah Anda membuat dan menjalankan Managed Service dasar untuk aplikasi Apache Flink, lihat sumber daya berikut untuk solusi Managed Service for Apache Flink yang lebih canggih.
+ **[Amazon Managed Service untuk Apache Flink Workshop](https://catalog.workshops.aws/managed-flink):** Dalam lokakarya ini, Anda membangun arsitektur end-to-end streaming untuk menelan, menganalisis, dan memvisualisasikan data streaming dalam waktu dekat. Anda mulai meningkatkan operasi perusahaan taksi di Kota New York. Anda menganalisis data telemetri armada taksi di Kota New York hampir secara langsung untuk mengoptimalkan operasi armada mereka.
+ **[Contoh untuk membuat dan bekerja dengan Managed Service untuk aplikasi Apache Flink](examples-collapsibles.md):** Bagian Panduan Pengembang ini memberikan contoh membuat dan bekerja dengan aplikasi di Managed Service untuk Apache Flink. Mereka menyertakan contoh kode dan step-by-step instruksi untuk membantu Anda membuat Layanan Terkelola untuk aplikasi Apache Flink dan menguji hasil Anda.
+ **[Belajar Flink: Pelatihan Langsung](https://nightlies.apache.org/flink/flink-docs-release-1.19/docs/learn-flink/overview/):** Pelatihan pengenalan resmi Apache Flink yang membuat Anda mulai menulis ETL streaming yang dapat diskalakan, analitik, dan aplikasi yang didorong peristiwa.