Buat dua aliran data Amazon Kinesis Tulis Catatan Sampel ke Aliran Input Unduh dan periksa kode Java streaming Apache Flink Kompilasi kode aplikasi Unggah kode Java streaming Apache Flink Buat dan jalankan Managed Service untuk aplikasi Apache Flink

Langkah 3: Buat dan jalankan Layanan Terkelola untuk aplikasi Apache Flink

Dalam latihan ini, Anda membuat Layanan Terkelola untuk aplikasi Apache Flink dengan aliran data sebagai sumber dan wastafel.

Bagian ini berisi langkah-langkah berikut.

Buat dua aliran data Amazon Kinesis
Tulis Catatan Sampel ke Aliran Input
Unduh dan periksa kode Java streaming Apache Flink
Kompilasi kode aplikasi
Unggah kode Java streaming Apache Flink
Buat dan jalankan Managed Service untuk aplikasi Apache Flink

Buat dua aliran data Amazon Kinesis

Sebelum Anda membuat Amazon Managed Service untuk 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 AWS CLI berikut. Untuk petunjuk konsol, lihat Membuat dan Memperbarui Aliran Data.

Untuk membuat aliran data AWS CLI

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-west-2 \
--profile adminuser

Untuk membuat aliran kedua yang digunakan aplikasi untuk menulis output, jalankan perintah yang sama, yang mengubah nama aliran menjadi ExampleOutputStream.
```
$ aws kinesis create-stream \
--stream-name ExampleOutputStream \
--shard-count 1 \
--region us-west-2 \
--profile adminuser
```

Tulis Catatan Sampel ke Aliran Input

Di bagian ini, Anda menggunakan script Python untuk menulis catatan sampel ke aliran untuk diproses aplikasi.

catatan

Bagian ini memerlukan AWS SDK for Python (Boto).

Buat file bernama stock.py dengan konten berikut:


 
import datetime
import json
import random
import boto3

STREAM_NAME = "ExampleInputStream"


def get_data():
    return {
        "EVENT_TIME": datetime.datetime.now().isoformat(),
        "TICKER": random.choice(["AAPL", "AMZN", "MSFT", "INTC", "TBV"]),
        "PRICE": round(random.random() * 100, 2),
    }


def generate(stream_name, kinesis_client):
    while True:
        data = get_data()
        print(data)
        kinesis_client.put_record(
            StreamName=stream_name, Data=json.dumps(data), PartitionKey="partitionkey"
        )


if __name__ == "__main__":
    generate(STREAM_NAME, boto3.client("kinesis"))

Selanjutnya dalam tutorial ini, Anda menjalankan skrip stock.py untuk mengirim data ke aplikasi.
```
$ python stock.py
```

Unduh dan periksa kode Java streaming Apache Flink

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

Klon repositori jarak jauh dengan perintah berikut:


git clone https://github.com/aws-samples/amazon-kinesis-data-analytics-java-examples.git

Buka direktori GettingStarted tersebut.

Kode aplikasi terletak di file CustomSinkStreamingJob.java dan CloudWatchLogSink.java. Perhatikan hal tentang kode aplikasi berikut:

Aplikasi menggunakan sumber Kinesis untuk membaca dari aliran sumber. Cuplikan berikut membuat sink Kinesis:


return env.addSource(new FlinkKinesisConsumer<>(inputStreamName,
                new SimpleStringSchema(), inputProperties));

Kompilasi kode aplikasi

Di bagian ini, Anda menggunakan compiler Apache Maven untuk membuat kode Java untuk aplikasi. Untuk informasi tentang menginstal Apache Maven dan Java Development Kit (JDK), lihat. Prasyarat untuk menyelesaikan latihan

Aplikasi Java Anda memerlukan komponen-komponen berikut:

File Model Objek Proyek (pom.xml). File ini berisi informasi tentang konfigurasi dan dependensi aplikasi, termasuk Amazon Managed Service untuk pustaka Apache Flink.
mainMetode yang berisi logika aplikasi.

catatan

Untuk menggunakan konektor Kinesis untuk aplikasi berikut, Anda harus mengunduh kode sumber untuk konektor dan membangunnya seperti yang dijelaskan dalam dokumentasi Apache Flink.

Untuk membuat dan mengkompilasi kode aplikasi

Buat aplikasi Java/Maven di lingkungan pengembangan Anda. Untuk informasi tentang membuat aplikasi, lihat dokumentasi untuk lingkungan pengembangan Anda:
- Membuat proyek Java pertama Anda (Eclipse Java Neon)
- Membuat, Menjalankan, dan Mengemas Aplikasi Java Pertama Anda (IntelliJ Idea)

Gunakan kode berikut untuk file bernamaStreamingJob.java.


 
package com.amazonaws.services.kinesisanalytics;

import com.amazonaws.services.kinesisanalytics.runtime.KinesisAnalyticsRuntime;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kinesis.FlinkKinesisConsumer;
import org.apache.flink.streaming.connectors.kinesis.FlinkKinesisProducer;
import org.apache.flink.streaming.connectors.kinesis.config.ConsumerConfigConstants;

import java.io.IOException;
import java.util.Map;
import java.util.Properties;

public class StreamingJob {

    private static final String region = "us-east-1";
    private static final String inputStreamName = "ExampleInputStream";
    private static final String outputStreamName = "ExampleOutputStream";

    private static DataStream<String> createSourceFromStaticConfig(StreamExecutionEnvironment env) {
        Properties inputProperties = new Properties();
        inputProperties.setProperty(ConsumerConfigConstants.AWS_REGION, region);
        inputProperties.setProperty(ConsumerConfigConstants.STREAM_INITIAL_POSITION, "LATEST");

        return env.addSource(new FlinkKinesisConsumer<>(inputStreamName, new SimpleStringSchema(), inputProperties));
    }

    private static DataStream<String> createSourceFromApplicationProperties(StreamExecutionEnvironment env)
            throws IOException {
        Map<String, Properties> applicationProperties = KinesisAnalyticsRuntime.getApplicationProperties();
        return env.addSource(new FlinkKinesisConsumer<>(inputStreamName, new SimpleStringSchema(),
                applicationProperties.get("ConsumerConfigProperties")));
    }

    private static FlinkKinesisProducer<String> createSinkFromStaticConfig() {
        Properties outputProperties = new Properties();
        outputProperties.setProperty(ConsumerConfigConstants.AWS_REGION, region);
        outputProperties.setProperty("AggregationEnabled", "false");

        FlinkKinesisProducer<String> sink = new FlinkKinesisProducer<>(new SimpleStringSchema(), outputProperties);
        sink.setDefaultStream(outputStreamName);
        sink.setDefaultPartition("0");
        return sink;
    }

    private static FlinkKinesisProducer<String> createSinkFromApplicationProperties() throws IOException {
        Map<String, Properties> applicationProperties = KinesisAnalyticsRuntime.getApplicationProperties();
        FlinkKinesisProducer<String> sink = new FlinkKinesisProducer<>(new SimpleStringSchema(),
                applicationProperties.get("ProducerConfigProperties"));

        sink.setDefaultStream(outputStreamName);
        sink.setDefaultPartition("0");
        return sink;
    }

    public static void main(String[] args) throws Exception {
        // set up the streaming execution environment
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        /*
         * if you would like to use runtime configuration properties, uncomment the
         * lines below
         * DataStream<String> input = createSourceFromApplicationProperties(env);
         */

        DataStream<String> input = createSourceFromStaticConfig(env);

        /*
         * if you would like to use runtime configuration properties, uncomment the
         * lines below
         * input.addSink(createSinkFromApplicationProperties())
         */

        input.addSink(createSinkFromStaticConfig());

        env.execute("Flink Streaming Java API Skeleton");
    }
}

Perhatikan hal berikut tentang contoh kode sebelumnya:

File ini berisi main metode yang mendefinisikan fungsionalitas aplikasi.
Aplikasi Anda membuat konektor sumber dan sink untuk mengakses sumber daya eksternal menggunakan objek StreamExecutionEnvironment.
Aplikasi membuat konektor sumber dan sink menggunakan properti statis. Untuk menggunakan properti aplikasi dinamis, gunakan metode createSourceFromApplicationProperties dan createSinkFromApplicationProperties untuk membuat konektor. Metode ini membaca properti aplikasi untuk mengonfigurasi konektor.

Untuk menggunakan kode aplikasi Anda, Anda mengkompilasi dan mengemasnya ke dalam sebuah JAR file. Anda dapat mengompilasi dan mengemas kode Anda dengan salah satu dari dua cara:
- Gunakan alat Maven baris perintah. Buat JAR file Anda dengan menjalankan perintah berikut di direktori yang berisi pom.xml file:
```
mvn package
```
- Menyiapkan lingkungan pengembangan Anda. Lihat dokumentasi lingkungan pengembangan Anda untuk detail.
Anda dapat mengunggah paket Anda sebagai JAR file, atau Anda dapat mengompres paket Anda dan mengunggahnya sebagai ZIP file. Jika Anda membuat aplikasi menggunakan AWS CLI, Anda menentukan jenis konten kode Anda (JARatauZIP).
Jika ada kesalahan saat mengompilasi, pastikan variabel lingkungan JAVA_HOMEAnda diatur dengan benar.

Jika aplikasi berhasil mengompilasi, file berikut dibuat:

target/java-getting-started-1.0.jar

Unggah kode Java streaming Apache Flink

Pada bagian ini, Anda membuat bucket Amazon Simple Storage Service (Amazon S3) dan mengunggah kode aplikasi Anda.

Untuk mengunggah kode aplikasi

Buka konsol Amazon S3 di. https://console.aws.amazon.com/s3/
Pilih Buat bucket.
Masukkan ka-app-code-<username> di bidang Bucket name (Nama bucket). Tambahkan sufiks ke nama bucket, seperti nama pengguna Anda, untuk membuatnya unik secara global. Pilih Next (Selanjutnya).
Di langkah Konfigurasi opsi, jangan ubah pengaturan, dan pilih Next (Selanjutnya).
Di langkah Atur izin, jangan ubah pengaturan, dan pilih Next (Selanjutnya).
Pilih Create bucket (Buat bucket).
Di konsol Amazon S3, pilih - ka-app-code<username>bucket, dan pilih Upload.
Di langkah Pilih file, pilih Add files (Tambahkan berkas). Navigasikan ke file java-getting-started-1.0.jar yang Anda buat di langkah sebelumnya. Pilih Selanjutnya.
Di langkah Atur izin, jangan ubah pengaturan. Pilih Selanjutnya.
Di langkah Atur properti, jangan ubah pengaturan. Pilih Upload (Unggah).

Kode aplikasi Anda sekarang disimpan di bucket Amazon S3 yang dapat diakses aplikasi Anda.

Buat dan jalankan Managed Service untuk aplikasi Apache Flink

Anda dapat membuat dan menjalankan Layanan Terkelola untuk aplikasi Apache Flink menggunakan konsol atau aplikasi. AWS CLI

catatan

Saat Anda membuat aplikasi menggunakan konsol, resource 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.

Buat dan jalankan aplikasi (Konsol)

Ikuti langkah-langkah ini untuk membuat, mengonfigurasi, memperbarui, dan menjalankan aplikasi menggunakan konsol.

Buat aplikasi

Buka konsol Kinesis di https://console.aws.amazon.com/kinesis.
Di dasbor Amazon Kinesis, pilih Buat aplikasi analitik.
Di halaman Kinesis Analytics - Buat aplikasi, masukkan detail aplikasi sebagai berikut:
- Untuk Application name (Nama aplikasi), masukkan MyApplication.
- Untuk Description (Deskripsi), masukkan My java test app.
- Untuk Runtime, pilih Apache Flink 1.6.
Untuk izin Akses, pilih Buat/perbarui IAM peran kinesis-analytics-MyApplication-us-west-2.
Pilih Create application (Buat aplikasi).

catatan

Saat Anda membuat Amazon Managed Service untuk aplikasi Apache Flink menggunakan konsol, Anda memiliki opsi untuk membuat IAM peran dan kebijakan untuk aplikasi Anda. Aplikasi Anda menggunakan peran dan kebijakan ini untuk mengakses sumber daya dependen. IAMSumber daya ini diberi nama menggunakan nama aplikasi dan Wilayah Anda sebagai berikut:

Kebijakan: kinesis-analytics-service-MyApplication-us-west-2
Peran: kinesis-analytics-MyApplication-us-west-2

Edit IAM kebijakan

Edit IAM kebijakan untuk menambahkan izin untuk mengakses aliran data Kinesis.

Buka konsol IAM di https://console.aws.amazon.com/iam/.
Pilih Policies (Kebijakan). Pilih kebijakan kinesis-analytics-service-MyApplication-us-west-2 yang dibuat konsol untuk Anda di bagian sebelumnya.
Di halaman Ringkasan, pilih Edit policy (Edit kebijakan). Pilih JSONtab.

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


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "ReadCode",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:GetObjectVersion"
            ],
            "Resource": [
                "arn:aws:s3:::ka-app-code-username/java-getting-started-1.0.jar"
            ]
        },
        {
            "Sid": "ListCloudwatchLogGroups",
            "Effect": "Allow",
            "Action": [
                "logs:DescribeLogGroups"
            ],
            "Resource": [
                "arn:aws:logs:us-west-2:012345678901:log-group:*"
            ]
        },
        {
            "Sid": "ListCloudwatchLogStreams",
            "Effect": "Allow",
            "Action": [
                "logs:DescribeLogStreams"
            ],
            "Resource": [
                "arn:aws:logs:us-west-2:012345678901:log-group:/aws/kinesis-analytics/MyApplication:log-stream:*"
            ]
        },
        {
            "Sid": "PutCloudwatchLogs",
            "Effect": "Allow",
            "Action": [
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:us-west-2:012345678901:log-group:/aws/kinesis-analytics/MyApplication:log-stream:kinesis-analytics-log-stream"
            ]
        },
        {
            "Sid": "ReadInputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:012345678901:stream/ExampleInputStream"
        },
        {
            "Sid": "WriteOutputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:012345678901:stream/ExampleOutputStream"
        }
    ]
}

Konfigurasikan aplikasi

Pada MyApplicationhalaman, pilih Konfigurasi.
Di halaman Konfigurasikan aplikasi, berikan Code location (Lokasi kode):
- Untuk Bucket Amazon S3, masukkan ka-app-code-<username>.
- Untuk Jalur ke objek Amazon S3, masukkan java-getting-started-1.0.jar.
Di bawah Akses ke sumber daya aplikasi, untuk izin Akses, pilih Buat/perbarui IAM peran kinesis-analytics-MyApplication-us-west-2.
Di bawah Properties (Properti), untuk Group ID (ID Grup), masukkan ProducerConfigProperties.

Masukkan properti dan nilai aplikasi berikut:

Kunci	Nilai
`flink.inputstream.initpos`	`LATEST`
`aws:region`	`us-west-2`
`AggregationEnabled`	`false`

Di bawah Pemantauan, pastikan Memantau tingkat metrik diatur ke Aplikasi.
Untuk CloudWatch logging, pilih kotak centang Aktifkan.
Pilih Perbarui.

catatan

Saat Anda memilih untuk mengaktifkan CloudWatch logging, Managed Service for 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

Pada MyApplicationhalaman, pilih Jalankan. Konfirmasikan tindakan.
Ketika aplikasi berjalan, refresh halaman. Konsol menunjukkan Grafik aplikasi.

Hentikan aplikasi

Pada MyApplicationhalaman, pilih Berhenti. Konfirmasikan tindakan.

Memperbarui aplikasi

Menggunakan konsol, Anda dapat memperbarui pengaturan aplikasi seperti properti aplikasi, pengaturan pemantauan, dan lokasi atau nama file aplikasiJAR. Anda juga dapat memuat ulang aplikasi JAR dari bucket Amazon S3 jika Anda perlu memperbarui kode aplikasi.

Pada MyApplicationhalaman, pilih Konfigurasi. Perbarui pengaturan aplikasi dan pilih Update (Perbarui).

Buat dan jalankan aplikasi (AWS CLI)

Di bagian ini, Anda menggunakan AWS CLI untuk membuat dan menjalankan aplikasi Managed Service for Apache Flink. Managed Service untuk Apache Flink menggunakan kinesisanalyticsv2 AWS CLI perintah untuk membuat dan berinteraksi dengan Managed Service untuk aplikasi Apache Flink.

Membuat Kebijakan Izin

Pertama, Anda membuat kebijakan izin dengan dua pernyataan: satu yang memberikan izin untuk tindakan read di aliran sumber, dan lainnya yang memberikan izin untuk tindakan write di aliran sink. Anda kemudian melampirkan kebijakan ke IAM peran (yang Anda buat di bagian berikutnya). Jadi, ketika Layanan Terkelola untuk Apache Flink mengasumsikan peran tersebut, layanan memiliki izin yang diperlukan untuk membaca dari aliran sumber dan menulis ke aliran wastafel.

Gunakan kode berikut untuk membuat kebijakan izin KAReadSourceStreamWriteSinkStream. Ganti username dengan nama pengguna yang Anda gunakan untuk membuat bucket Amazon S3 untuk menyimpan kode aplikasi. Ganti ID akun di Amazon Resource Names (ARNs) (012345678901) dengan ID akun Anda.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "S3",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:GetObjectVersion"
            ],
            "Resource": ["arn:aws:s3:::ka-app-code-username",
                "arn:aws:s3:::ka-app-code-username/*"
            ]
        },
        {
            "Sid": "ReadInputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:012345678901:stream/ExampleInputStream"
        },
        {
            "Sid": "WriteOutputStream",
            "Effect": "Allow",
            "Action": "kinesis:*",
            "Resource": "arn:aws:kinesis:us-west-2:012345678901:stream/ExampleOutputStream"
        }
    ]
}

Untuk step-by-step petunjuk membuat kebijakan izin, lihat Tutorial: Membuat dan Melampirkan Kebijakan Terkelola Pelanggan Pertama Anda di Panduan IAM Pengguna.

catatan

Untuk mengakses AWS layanan lain, Anda dapat menggunakan AWS SDK for Java. Layanan Terkelola untuk Apache Flink secara otomatis menetapkan kredensional yang SDK diperlukan oleh IAM peran eksekusi layanan yang terkait dengan aplikasi Anda. Tidak ada langkah tambahan yang diperlukan.

Buat IAM Peran

Di bagian ini, Anda membuat IAM peran yang dapat diasumsikan oleh Managed Service for Apache Flink untuk membaca aliran sumber dan menulis ke aliran sink.

Layanan Terkelola untuk Apache Flink tidak dapat mengakses aliran Anda tanpa izin. Anda memberikan izin ini melalui IAM peran. Setiap IAM peran memiliki dua kebijakan yang terlampir. Kebijakan kepercayaan memberikan izin Layanan Terkelola untuk Apache Flink untuk mengambil peran, dan kebijakan izin menentukan apa yang dapat dilakukan Layanan Terkelola untuk Apache Flink setelah mengambil peran.

Anda melampirkan kebijakan izin yang Anda buat di bagian sebelumnya ke peran ini.

Untuk membuat IAM peran

Buka konsol IAM di https://console.aws.amazon.com/iam/.
Dalam panel navigasi, pilih Roles (Peran), Create role (Buat Peran).
Di bawah Pilih tipe identitas tepercaya, pilih Layanan AWS . Di bawah Pilih layanan yang akan menggunakan peran ini, pilih Kinesis. Di bawah Pilih kasus penggunaan Anda, pilih Analitik Kinesis.

Pilih Berikutnya: Izin.
Di halaman Lampirkan kebijakan izin, pilih Next: Review (Selanjutnya: Tinjau). Anda melampirkan kebijakan izin setelah Anda membuat peran tersebut.
Di halaman Buat peran, masukkan KA-stream-rw-role untuk Role name (Nama peran). Pilih Create role (Buat peran).

Sekarang Anda telah menciptakan IAM peran baru yang disebutKA-stream-rw-role. Berikutnya, Anda memperbarui kebijakan kepercayaan dan izin untuk peran.
Lampirkan kebijakan izin ke peran tersebut.

catatan
Untuk latihan ini, Managed Service for Apache Flink mengasumsikan peran ini untuk membaca data dari aliran data Kinesis (sumber) dan menulis output ke aliran data Kinesis lain. Jadi, Anda melampirkan kebijakan yang Anda buat di langkah sebelumnya, Membuat Kebijakan Izin.
1. Di halaman Ringkasan, pilih tab Permissions (Izin).
2. Pilih Attach Policies (Lampirkan Kebijakan).
3. Di kotak pencarian, masukkan KAReadSourceStreamWriteSinkStream (kebijakan yang Anda buat bagian sebelumnya).
4. Pilih KAReadInputStreamWriteOutputStreamkebijakan, lalu pilih Lampirkan kebijakan.

Anda sekarang telah membuat peran eksekusi layanan yang digunakan aplikasi Anda untuk mengakses sumber daya. Catat peran baru. ARN

Untuk step-by-step petunjuk cara membuat peran, lihat Membuat IAM Peran (Konsol) di Panduan IAM Pengguna.

Buat Managed Service untuk Apache Flink Application

Simpan JSON kode berikut ke file bernamacreate_request.json. Ganti peran sampel ARN dengan peran yang Anda buat sebelumnya. ARN Ganti ARN akhiran bucket (username) dengan akhiran yang Anda pilih di bagian sebelumnya. Ganti ID akun sampel (012345678901) di peran eksekusi layanan dengan ID akun Anda.


{
    "ApplicationName": "test",
    "ApplicationDescription": "my java test app",
    "RuntimeEnvironment": "FLINK-1_6",
    "ServiceExecutionRole": "arn:aws:iam::012345678901:role/KA-stream-rw-role",
    "ApplicationConfiguration": {
        "ApplicationCodeConfiguration": {
            "CodeContent": {
                "S3ContentLocation": {
                    "BucketARN": "arn:aws:s3:::ka-app-code-username",
                    "FileKey": "java-getting-started-1.0.jar"
                }
            },
            "CodeContentType": "ZIPFILE"
        },
        "EnvironmentProperties":  { 
         "PropertyGroups": [ 
            { 
               "PropertyGroupId": "ProducerConfigProperties",
               "PropertyMap" : {
                    "flink.stream.initpos" : "LATEST",
                    "aws.region" : "us-west-2",
                    "AggregationEnabled" : "false"
               }
            },
            { 
               "PropertyGroupId": "ConsumerConfigProperties",
               "PropertyMap" : {
                    "aws.region" : "us-west-2"
               }
            }
         ]
      }
    }
}

Jalankan tindakan CreateApplication dengan permintaan sebelumnya untuk membuat aplikasi:
```
aws kinesisanalyticsv2 create-application --cli-input-json file://create_request.json
```

Aplikasi ini sekarang dibuat. Anda memulai aplikasi di langkah berikutnya.

Mulai Aplikasi

Di bagian ini, Anda menggunakan tindakan StartApplication untuk memulai aplikasi.

Untuk memulai aplikasi

Simpan JSON kode berikut ke file bernamastart_request.json.


{
    "ApplicationName": "test",
    "RunConfiguration": {
        "ApplicationRestoreConfiguration": { 
         "ApplicationRestoreType": "RESTORE_FROM_LATEST_SNAPSHOT"
         }
    }
}

Jalankan tindakan StartApplication dengan permintaan sebelumnya untuk memulai aplikasi:
```
aws kinesisanalyticsv2 start-application --cli-input-json file://start_request.json
```

Aplikasi sekarang berjalan. Anda dapat memeriksa metrik Layanan Terkelola untuk Apache Flink di CloudWatch konsol Amazon untuk memverifikasi bahwa aplikasi berfungsi.

Hentikan Aplikasi

Di bagian ini, Anda menggunakan tindakan StopApplication untuk menghentikan aplikasi.

Untuk menghentikan aplikasi

Simpan JSON kode berikut ke file bernamastop_request.json.
```
{"ApplicationName": "test"
}
```
Jalankan tindakan StopApplication dengan permintaan berikut untuk menghentikan aplikasi:
```
aws kinesisanalyticsv2 stop-application --cli-input-json file://stop_request.json
```

Aplikasi sekarang dihentikan.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

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

Konvensi Dokumen

Langkah 2: Siapkan AWS CLI

Tutorial: Gunakan AWS Lambda dengan Amazon Kinesis Data Streams