Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Membuat dan menjalankan aplikasi Layanan Terkelola untuk Apache Flink Pada langkah ini, Anda membuat aplikasi Layanan Terkelola untuk 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 kemas kode aplikasi Anda](#get-started-exercise-5-5) + [Unggah file JAR kode aplikasi](#get-started-exercise-6) + [Buat dan konfigurasikan Managed Service untuk aplikasi Apache Flink](#get-started-exercise-7) + [Langkah berikutnya](#get-started-exercise-next-step-4) ## Buat sumber daya yang bergantung Sebelum Anda membuat aplikasi Layanan Terkelola untuk 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 AS Timur (Virginia Utara). Jika Anda menggunakan Wilayah lain, sesuaikan semua langkah yang sesuai. ### Buat dua aliran data Amazon Kinesis Sebelum Anda membuat aplikasi Layanan Terkelola untuk Apache Flink untuk latihan ini, buat dua aliran data Kinesis (`ExampleInputStream`dan`ExampleOutputStream`). Aplikasi Anda menggunakan aliran ini untuk sumber aplikasi dan aliran tujuan. Anda dapat membuat aliran ini menggunakan konsol Amazon Kinesis atau AWS CLI perintah berikut. 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 pertama (`ExampleInputStream`), gunakan `create-stream` AWS CLI perintah Amazon Kinesis 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 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 Wilayah yang Anda gunakan untuk tutorial ini (us-east-1). ### Sumber daya lainnya Saat Anda membuat aplikasi, Layanan Terkelola untuk Apache Flink secara otomatis membuat CloudWatch sumber daya Amazon berikut jika belum ada: + Grup log yang disebut `/AWS/KinesisAnalytics-java/` + Stream log disebut `kinesis-analytics-log-stream` ## Siapkan lingkungan pengembangan lokal Anda 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 ](https://www.eclipse.org/downloads/packages/release/neon/3) atau [ IntelliJ IDE ](https://www.jetbrains.com/idea/) A. 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 Anda AWS sesi Aplikasi ini menggunakan aliran data Kinesis untuk mempublikasikan data. Saat menjalankan secara lokal, Anda harus memiliki sesi ter AWS autentikasi yang valid dengan izin untuk menulis ke aliran data Kinesis. Gunakan langkah-langkah berikut untuk mengotentikasi sesi Anda: 1. Jika Anda tidak memiliki AWS CLI dan profil bernama dengan kredensi valid yang dikonfigurasi, lihat[Siapkan AWS Command Line Interface (AWS CLI)](setup-awscli.md). 1. Pastikan 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 kredenSIAL ke aplikasi yang berjalan di IDE. Untuk informasi selengkapnya, lihat [AWS Toolkit untuk IntelliJ IDE ](https://aws.amazon.com/intellij/) A dan [AWS Toolkit untuk Eclipse. ](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/welcome.html) ## Unduh dan periksa kode Java streaming Apache Flink 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 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 dan 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 apakah itu berjalan mandiri secara lokal di IDE. Dalam hal ini, aplikasi memuat konfigurasi runtime secara berbeda: 1. Ketika aplikasi mendeteksi bahwa itu berjalan dalam mode mandiri di IDE Anda, bentuk `application_properties.json` file yang disertakan dalam ** folder ** resource proyek. Isi file berikut. 1. Saat aplikasi berjalan di Amazon Managed Service for Apache Flink, perilaku default memuat konfigurasi aplikasi dari properti runtime yang akan Anda tentukan di aplikasi Amazon Managed Service for Apache Flink. Lihat [Buat dan konfigurasikan Managed Service untuk aplikasi Apache Flink](#get-started-exercise-7). ``` private static Map 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 yang `StreamExecutionEnvironment` akan digunakan dengan DataSteam API dan yang akan `StreamTableEnvironment` digunakan dengan SQL dan Table API. Kedua objek lingkungan adalah dua referensi terpisah ke lingkungan runtime yang sama, untuk menggunakan API yang berbeda. ``` StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); ``` + Muat parameter konfigurasi aplikasi. Ini akan secara otomatis memuatnya dari tempat yang benar, tergantung di mana aplikasi berjalan: ``` Map applicationParameters = loadApplicationProperties(env); ``` + Aplikasi mendefinisikan sumber menggunakan [ konektor ](https://nightlies.apache.org/flink/flink-docs-release-1.18/docs/connectors/datastream/kinesis/#kinesis-consumer) Kinesis Consumer untuk membaca data dari aliran input. Konfigurasi aliran input didefinisikan dalam `PropertyGroupId` =`InputStream0`. Nama dan Wilayah aliran berada di properti yang diberi nama `stream.name` dan `aws.region` masing-masing. Untuk kesederhanaan, sumber ini membaca catatan sebagai string. ``` private static FlinkKinesisConsumer 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 source = createSource(applicationParameters.get("InputStream0")); DataStream input = env.addSource(source, "Kinesis Source"); ... } ``` + Aplikasi kemudian mendefinisikan sink menggunakan [ konektor ](https://nightlies.apache.org/flink/flink-docs-release-1.18/docs/connectors/datastream/kinesis/#kinesis-streams-sink) Kinesis Streams Sink untuk mengirim data ke aliran keluaran. 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 createSink(Properties outputProperties) { String outputStreamName = outputProperties.getProperty("stream.name"); return KinesisStreamsSink.builder() .setKinesisClientProperties(outputProperties) .setSerializationSchema(new SimpleStringSchema()) .setStreamName(outputStreamName) .setPartitionKeyGenerator(element -> String.valueOf(element.hashCode())) .build(); } ... public static void main(String[] args) throws Exception { ... Sink 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 yang dibutuhkan aliran data: ``` env.execute("Flink streaming Java API skeleton"); ``` ### Gunakan file pom.xml File pom.xml mendefinisikan semua dependensi yang diperlukan oleh aplikasi dan mengatur plugin Maven Shade untuk membangun fat-jar 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 diminta 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. ``` org.apache.flink flink-clients ${flink.version} provided org.apache.flink flink-streaming-java ${flink.version} provided ``` + Anda harus menambahkan dependensi Apache Flink tambahan ke pom dengan cakupan default, seperti konektor [ Kinesis yang ](https://nightlies.apache.org/flink/flink-docs-master/docs/connectors/datastream/kinesis/) 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. ``` org.apache.flink flink-connector-kinesis ${aws.connector.version} ``` + Plugin Maven Java Compiler memastikan bahwa kode dikompilasi terhadap Java 11, versi JDK yang saat ini didukung oleh Apache Flink. + Plugin Maven Shade mengemas fat-jar, tidak termasuk beberapa pustaka yang disediakan oleh runtime. Ini juga menentukan dua transformator: `ServicesResourceTransformer` dan`ManifestResourceTransformer`. Yang terakhir mengkonfigurasi kelas yang berisi `main` metode untuk memulai aplikasi. Jika Anda mengganti nama kelas utama, jangan lupa untuk memperbarui transformator ini. + ``` org.apache.maven.plugins maven-shade-plugin ... com.amazonaws.services.msf.BasicStreamingJob ... ``` ## Tulis catatan sampel ke aliran input Di bagian ini, Anda akan mengirim catatan sampel ke aliran untuk diproses aplikasi. Anda memiliki dua opsi untuk menghasilkan data sampel, baik menggunakan skrip Python atau [ Kinesis Data Generator](https://github.com/awslabs/amazon-kinesis-data-generator). ### Hasilkan data sampel menggunakan skrip Python 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 [AWS SDK for Python (Boto) ](https://aws.amazon.com/developer/language/python/) library. **Untuk mulai mengirim data uji ke aliran input Kinesis: ** 1. Unduh skrip `stock.py` Python generator data dari GitHub repositori generator [ 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 berjalan saat Anda menyelesaikan sisa tutorial. Anda sekarang dapat menjalankan aplikasi Apache Flink Anda. ### Menghasilkan data sampel menggunakan Kinesis Data Generator Sebagai alternatif untuk menggunakan skrip Python, Anda dapat menggunakan [ Kinesis Data Generator](https://github.com/awslabs/amazon-kinesis-data-generator), juga tersedia dalam versi yang di [https://awslabs.github.io/amazon-kinesis-data-generator/web/producer.html](https://awslabs.github.io/amazon-kinesis-data-generator/web/producer.html) hosting, 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 CloudFormation template. Anda dapat menemukan URL di ** tab ** Output setelah CloudFormation template selesai. 1. Konfigurasikan generator data: + **Wilayah: ** Pilih Wilayah yang Anda gunakan untuk tutorial ini: us-east-1 + **Stream/delivery stream: ** Pilih aliran input yang akan digunakan aplikasi: `ExampleInputStream` + **Catatan per detik: ** 100 + **Template rekam: Salin dan ** tempel template 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 ** Uji template ** 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 mengirim data ke`ExampleInputStream`. ## Jalankan aplikasi Anda secara lokal 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 Anda AWS sesi](#get-started-exercise-2-5). Menyiapkan lingkungan pengembangan lokal membutuhkan Java 11 JDK, Apache Maven, dan IDE untuk pengembangan Java. Pastikan Anda memenuhi prasyarat yang diperlukan. Lihat [Memenuhi prasyarat untuk menyelesaikan latihan](getting-started.md#setting-up-prerequisites). ### Impor proyek Java ke IDE Anda 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 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 aliran Kinesis atau Wilayah 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 menjalankan IDE Anda Anda dapat menjalankan dan men-debug aplikasi Flink dari IDE Anda secara langsung dengan menjalankan kelas utama`com.amazonaws.services.msf.BasicStreamingJob`, seperti Anda akan menjalankan aplikasi Java apa pun. Sebelum menjalankan aplikasi, Anda harus mengatur konfigurasi Run. Pengaturannya tergantung pada IDE yang Anda gunakan. Misalnya, lihat [ Run/debug konfigurasi ](https://www.jetbrains.com/help/idea/run-debug-configuration.html) dalam dokumentasi IntelliJ IDEA. Secara khusus, Anda harus mengatur yang berikut: 1. **Tambahkan `provided` dependensi ke clas ** spath. Ini diperlukan untuk memastikan bahwa dependensi dengan cak `provided` upan diteruskan ke aplikasi saat berjalan secara lokal. Tanpa pengaturan ini, aplikasi segera menampilkan `class not found` kesalahan. 1. **Berikan AWS kredenSIAL 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 meneruskan AWS kredensi secara langsung. 1. Verifikasi bahwa IDE menjalankan aplikasi menggunakan ** JDK 11**. ### Jalankan aplikasi di IDE Anda Setelah Anda mengatur konfigurasi Run untuk`BasicStreamingJob`, Anda dapat menjalankan atau men-debugnya seperti aplikasi Java biasa. **catatan** Anda tidak dapat menjalankan fat-jar yang dihasilkan oleh Maven secara langsung `java -jar ...` dari baris perintah. Jar 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 menambah overhead yang cukup besar saat berjalan dalam produksi. ## Amati data input dan output dalam aliran Kinesis Anda dapat mengamati catatan yang dikirim ke aliran input oleh (menghasilkan sampel Python) atau Kinesis Data Generator (tautan) dengan menggunakan Penampil ** Data ** di konsol Amazon Kinesis. **Untuk mengamati catatan** 1. Buka konsol Kinesis di [ https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis). 1. Verifikasi bahwa Wilayah sama di mana Anda menjalankan tutorial ini, yaitu us-east-1 US East (Virginia Utara) secara default. Ubah Wilayah jika tidak cocok. 1. Pilih ** Aliran Data**. 1. Pilih streaming yang ingin Anda amati, salah satu `ExampleInputStream` atau `ExampleOutputStream.` 1. Pilih ** tab Pen ** ampil data. 1. Pilih ** Shard apa saja**, pertahankan ** Ter ** baru ** sebagai posisi A ** wal, lalu pilih ** Dapatkan catatan**. Anda mungkin melihat kesalahan “Tidak ada catatan yang ditemukan untuk permintaan ini”. Jika demikian, pilih C ** oba lagi mendapatkan catatan**. Catatan terbaru yang dipublikasikan ke tampilan streaming. 1. Pilih nilai di kolom Data untuk memeriksa konten catatan dalam format JSON. ## Menghentikan aplikasi Anda berjalan secara lokal Hentikan aplikasi yang berjalan di IDE Anda. IDE biasanya menyediakan opsi “stop”. Lokasi dan metode yang tepat tergantung pada IDE yang Anda gunakan. ## Kompilasi dan kemas kode aplikasi Anda Pada 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 mengemas 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: ** Jalan `mvn package` kan dari integrasi IDE Maven Anda. Dalam kedua kasus, file JAR berikut dibuat:`target/amazon-msf-java-stream-app-1.0.jar`. **catatan** Menjalankan “proyek build” dari IDE Anda mungkin tidak membuat file JAR. ## Unggah file JAR kode aplikasi 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 ** Ung ** gah tanpa mengubah pengaturan lainnya. **Awas** Pastikan Anda memilih file JAR yang benar di`/java/GettingStarted/target/amazon-msf-java-stream-app-1.0.jar`. Direk `target` tori juga berisi file JAR lain yang tidak perlu Anda unggah. ## Buat dan konfigurasikan Managed Service untuk aplikasi Apache Flink Anda dapat membuat dan menjalankan aplikasi Layanan Terkelola untuk Apache Flink menggunakan konsol atau. 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 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) + [Mengedit 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 di aliran Kinesis](#get-started-exercise-7-console-output) + [Hentikan aplikasi](#get-started-exercise-stop) ### Buat aplikasi **Untuk membuat aplikasi** 1. Masuk ke Konsol Manajemen AWS, dan buka konsol Amazon MSF di https://console.aws.amazon.com/flink. 1. Verifikasi bahwa Wilayah yang benar dipilih: us-east-1 AS Timur (Virginia Utara) 1. Buka menu di sebelah kanan dan pilih aplikasi ** Apache Flink ** lalu ** Buat aplikasi ** streaming. Atau, pilih ** Buat aplikasi streaming ** di wadah Mulai halaman awal. 1. Pada ** 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: ** masukkan**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 Peng ** embangan**. 1. Pilih ** Buat aplikasi streaming ** di bagian bawah halaman. **catatan** Saat Anda membuat aplikasi Layanan Terkelola untuk Apache Flink menggunakan konsol, Anda memiliki opsi untuk memiliki peran dan kebijakan IAM yang dibuat 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 dengan `kinesis-analytics-` untuk kompatibilitas mundur. ### Mengedit kebijakan IAM 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 contoh ID akun ({{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 S ** impan perubahan**. ### Konfigurasikan aplikasi 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 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 salah satu bagian lainnya. 1. Pilih **Simpan perubahan**. **catatan** Saat Anda memilih untuk mengaktifkan CloudWatch logging 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 Aplikasi sekarang dikonfigurasi dan siap dijalankan. **Untuk menjalankan aplikasi** 1. Pada konsol untuk Amazon Managed Service for Apache Flink, pilih Aplikasi ** Saya ** dan pilih J ** alan ** kan. 1. Pada halaman berikutnya, halaman konfigurasi pemulihan aplikasi, pilih J ** alankan dengan snapshot terbaru ** dan kemudian pilih J ** alankan**. **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 ** Runing jobs, pilih pekerjaan tunggal 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 dikonfigurasi 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 Di ** MyApplication ** halaman, di ** bagian CloudWatch metrik ** Amazon, Anda dapat melihat beberapa metrik mendasar 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 ** fullrestarts harus nol. Jika meningkat, konfigurasi mungkin memiliki masalah. Untuk menyelidiki masalah ini, tinjau ** tab ** Pengecualian di dasbor Flink. 1. **Metrik ** Jumlah pos pemeriksaan yang gagal harus nol dalam aplikasi yang sehat. **catatan** Dasbor ini menampilkan serangkaian metrik tetap dengan perincian 5 menit. Anda dapat membuat dasbor aplikasi khusus dengan metrik apa pun di CloudWatch dasbor. ### Amati data keluaran di aliran Kinesis Pastikan Anda masih menerbitkan data ke input, baik menggunakan skrip Python atau Kinesis Data Generator. Anda sekarang dapat mengamati output dari aplikasi yang berjalan pada Layanan Terkelola untuk Apache Flink dengan menggunakan Penampil Data 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 [ https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis). 1. Verifikasi bahwa Wilayah sama dengan yang Anda gunakan untuk menjalankan tutorial ini. Secara default, itu adalah AS-East-1US East (Virginia Utara). Ubah wilayah jika perlu. 1. Pilih ** Aliran Data**. 1. Pilih streaming yang ingin Anda amati. Untuk tutorial ini, gunakan `ExampleOutputStream`. 1. Pilih ** tab Pen ** ampil data. 1. Pilih ** Shard apa saja**, pertahankan ** Ter ** baru ** sebagai posisi A ** wal, lalu pilih ** Dapatkan catatan**. Anda mungkin melihat kesalahan “tidak ada catatan yang ditemukan untuk permintaan ini”. Jika demikian, pilih C ** oba lagi mendapatkan catatan**. Catatan terbaru yang dipublikasikan ke tampilan streaming. 1. Pilih nilai di kolom Data untuk memeriksa konten catatan dalam format JSON. ### Hentikan aplikasi Untuk menghentikan aplikasi, buka halaman konsol dari Managed Service untuk aplikasi Apache Flink bernama. `MyApplication` **Untuk menghentikan aplikasi** 1. Dari daftar tar ** ik- ** turun Tindakan, pilih Ber ** henti**. 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 aliran input dari skrip Python atau Kinesis Data Generator. ## Langkah berikutnya [Bersihkan AWS sumber daya](getting-started-cleanup.md)