Setelah mempertimbangkan dengan cermat, kami memutuskan untuk menghentikan Amazon Kinesis Data Analytics untuk aplikasi SQL:
1. Mulai **1 September 2025,** kami tidak akan memberikan perbaikan bug untuk Amazon Kinesis Data Analytics untuk aplikasi SQL karena kami akan memiliki dukungan terbatas untuk itu, mengingat penghentian yang akan datang.
2. Mulai **15 Oktober 2025,** Anda tidak akan dapat membuat Kinesis Data Analytics baru untuk aplikasi SQL.
3. Kami akan menghapus aplikasi Anda mulai **27 Januari 2026**. Anda tidak akan dapat memulai atau mengoperasikan Amazon Kinesis Data Analytics untuk aplikasi SQL. Support tidak akan lagi tersedia untuk Amazon Kinesis Data Analytics untuk SQL sejak saat itu. Untuk informasi selengkapnya, lihat [Amazon Kinesis Data Analytics untuk penghentian Aplikasi SQL](discontinuation.md).
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Contoh: Mendeteksi Anomali Data pada Aliran (Fungsi RANDOM\$1CUT\$1FORECT)
Amazon Kinesis Data Analytics menyediakan fungsi (`RANDOM_CUT_FOREST`) yang dapat menetapkan skor anomali ke setiap catatan berdasarkan nilai-nilai dalam kolom numerik. Untuk informasi selengkapnya, lihat [`RANDOM_CUT_FOREST`Fungsi](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/analytics-sql-reference.html) di *Amazon Managed Service for Apache Flink SQL* Reference.
Dalam latihan ini, Anda menulis kode aplikasi untuk menetapkan skor anomali ke catatan pada sumber streaming aplikasi Anda. Untuk menyiapkan aplikasi, Anda melakukan hal berikut:
1. **Siapkan sumber streaming** – Anda menyiapkan aliran data Kinesis dan menulis sampel data `heartRate`, seperti yang ditunjukkan berikut:
```
{"heartRate": 60, "rateType":"NORMAL"}
...
{"heartRate": 180, "rateType":"HIGH"}
```
Prosedur ini memberi Anda skrip Python untuk mengisi aliran. Nilai `heartRate` dibuat secara acak, dengan 99 persen catatan memiliki nilai `heartRate` antara 60 dan 100, dan hanya 1 persen dari nilai `heartRate` antara 150 dan 200. Dengan demikian, catatan yang memiliki nilai `heartRate` antara 150 dan 200 adalah anomali.
1. **Konfigurasi input** – Dengan menggunakan konsol, Anda membuat aplikasi Kinesis Data Analytics dan mengonfigurasi input aplikasi dengan memetakan sumber streaming ke aliran dalam aplikasi (`SOURCE_SQL_STREAM_001`). Saat aplikasi dimulai, Kinesis Data Analytics terus membaca sumber streaming dan memasukkan catatan ke dalam aliran dalam aplikasi.
1. **Tentukan kode aplikasi** – Contoh ini menggunakan kode aplikasi berikut:
```
--Creates a temporary stream.
CREATE OR REPLACE STREAM "TEMP_STREAM" (
"heartRate" INTEGER,
"rateType" varchar(20),
"ANOMALY_SCORE" DOUBLE);
--Creates another stream for application output.
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
"heartRate" INTEGER,
"rateType" varchar(20),
"ANOMALY_SCORE" DOUBLE);
-- Compute an anomaly score for each record in the input stream
-- using Random Cut Forest
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "TEMP_STREAM"
SELECT STREAM "heartRate", "rateType", ANOMALY_SCORE
FROM TABLE(RANDOM_CUT_FOREST(
CURSOR(SELECT STREAM * FROM "SOURCE_SQL_STREAM_001")));
-- Sort records by descending anomaly score, insert into output stream
CREATE OR REPLACE PUMP "OUTPUT_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM * FROM "TEMP_STREAM"
ORDER BY FLOOR("TEMP_STREAM".ROWTIME TO SECOND), ANOMALY_SCORE DESC;
```
Kode membaca baris dalam `SOURCE_SQL_STREAM_001`, menetapkan skor anomali, dan menulis baris yang dihasilkan ke aliran dalam aplikasi lainnya (`TEMP_STREAM`). Kode aplikasi kemudian mengurutkan catatan di `TEMP_STREAM` dan menyimpan hasilnya ke aliran dalam aplikasi lainnya (`DESTINATION_SQL_STREAM`). Anda menggunakan pompa untuk memasukkan baris di aliran dalam aplikasi. Untuk informasi selengkapnya, lihat [Aliran dan Pompa dalam Aplikasi](streams-pumps.md).
1. **Konfigurasi output** – Anda mengonfigurasi output aplikasi untuk menyimpan data dalam `DESTINATION_SQL_STREAM` ke tujuan eksternal, yang merupakan Kinesis data stream lainnya. Meninjau skor anomali yang ditetapkan untuk setiap catatan dan dan menentukan skor yang menunjukkan anomali (dan Anda perlu diberi tahu) adalah hal di luar aplikasi. Anda dapat menggunakan AWS Lambda fungsi untuk memproses skor anomali ini dan mengonfigurasi peringatan.
Latihan ini menggunakan US East (N. Virginia) (`us-east-1`) untuk membuat aliran ini dan aplikasi Anda. Jika Anda menggunakan Wilayah lain, Anda harus memperbarui kode tersebut dengan sesuai.
**Topics**
+ [Langkah 1: Siapkan](app-anomaly-prepare.md)
+ [Langkah 2: Buat Aplikasi](app-anom-score-create-app.md)
+ [Langkah 3: Konfigurasi Output Aplikasi](app-anomaly-create-ka-app-config-destination.md)
+ [Langkah 4: Verifikasi Output](app-anomaly-verify-output.md)
**Langkah Selanjutnya**
[Langkah 1: Siapkan](app-anomaly-prepare.md)
# Langkah 1: Siapkan
Sebelum membuat aplikasi Amazon Kinesis Data Analytics untuk latihan ini, Anda harus membuat dua Kinesis data streams. Konfigurasikan salah satu aliran sebagai sumber streaming untuk aplikasi Anda, dan aliran lainnya sebagai tujuan tempat Kinesis Data Analytics menyimpan output aplikasi Anda.
**Topics**
+ [Langkah 1.1: Buat Aliran Data Input dan Output](#app-anomaly-create-two-streams)
+ [Langkah 1.2: Menulis Catatan Sampel ke Aliran Input](#app-anomaly-write-sample-records-inputstream)
## Langkah 1.1: Buat Aliran Data Input dan Output
Di bagian ini, Anda akan membuat dua aliran Kinesis: `ExampleInputStream` dan `ExampleOutputStream`. Anda dapat membuat aliran ini menggunakan Konsol Manajemen AWS atau AWS CLI.
+
**Untuk menggunakan konsol**
1. [Masuk ke Konsol Manajemen AWS dan buka konsol Kinesis di /kinesis. https://console.aws.amazon.com](https://console.aws.amazon.com/kinesis)
1. Pilih **Create data stream** (Buat aliran data). Buat aliran dengan satu serpihan bernama `ExampleInputStream`. Untuk informasi selengkapnya, lihat [Buat Aliran](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html) di *Panduan Developer Amazon Kinesis Data Streams*.
1. Ulangi langkah sebelumnya, yang membuat aliran dengan satu serpihan bernama `ExampleOutputStream`.
+
**Untuk menggunakan AWS CLI**
1. Gunakan `create-stream` AWS CLI perintah Kinesis berikut untuk membuat stream pertama ()`ExampleInputStream`.
```
$ aws kinesis create-stream \
--stream-name ExampleInputStream \
--shard-count 1 \
--region us-east-1 \
--profile adminuser
```
1. Jalankan perintah yang sama, yang mengubah nama aliran menjadi `ExampleOutputStream`. Perintah ini membuat aliran kedua yang digunakan aplikasi untuk menulis output.
## Langkah 1.2: Menulis Catatan Sampel ke Aliran Input
Dalam langkah ini, Anda menjalankan kode Python untuk terus menghasilkan catatan sampel dan menulis catatan ini ke aliran `ExampleInputStream`.
```
{"heartRate": 60, "rateType":"NORMAL"}
...
{"heartRate": 180, "rateType":"HIGH"}
```
1. Instal Python dan `pip`.
Untuk informasi tentang menginstal Python, lihat situs web [Python](https://www.python.org/).
Anda dapat menginstal dependensi menggunakan pip. Untuk informasi tentang menginstal pip, lihat [Penginstalan](https://pip.pypa.io/en/stable/installing/) di situs web pip.
1. Jalankan kode Phyton berikut. Perintah `put-record` dalam kode menulis catatan JSON ke aliran.
```
from enum import Enum
import json
import random
import boto3
STREAM_NAME = "ExampleInputStream"
class RateType(Enum):
normal = "NORMAL"
high = "HIGH"
def get_heart_rate(rate_type):
if rate_type == RateType.normal:
rate = random.randint(60, 100)
elif rate_type == RateType.high:
rate = random.randint(150, 200)
else:
raise TypeError
return {"heartRate": rate, "rateType": rate_type.value}
def generate(stream_name, kinesis_client, output=True):
while True:
rnd = random.random()
rate_type = RateType.high if rnd < 0.01 else RateType.normal
heart_rate = get_heart_rate(rate_type)
if output:
print(heart_rate)
kinesis_client.put_record(
StreamName=stream_name,
Data=json.dumps(heart_rate),
PartitionKey="partitionkey",
)
if __name__ == "__main__":
generate(STREAM_NAME, boto3.client("kinesis"))
```
**Langkah Selanjutnya**
[Langkah 2: Buat Aplikasi](app-anom-score-create-app.md)
# Langkah 2: Buat Aplikasi
Di bagian ini, Anda membuat aplikasi Amazon Kinesis Data Analytics sebagai berikut:
+ Konfigurasikan input aplikasi untuk menggunakan Kinesis data stream yang Anda buat di [Langkah 1: Siapkan](app-anomaly-prepare.md) sebagai sumber streaming.
+ Gunakan templat **Deteksi Anomali** di konsol.
**Untuk membuat aplikasi**
1. Ikuti langkah 1, 2, dan 3 dalam latihan **Memulai** Kinesis Data Analytics (lihat [Langkah 3.1: Buat Aplikasi](get-started-create-app.md)).
+ Dalam konfigurasi sumber, lakukan hal berikut:
+ Tentukan sumber streaming yang Anda buat di bagian sebelumnya.
+ Setelah konsol menyimpulkan skema, edit skema, dan tetapkan tipe kolom `heartRate` ke `INTEGER`.
Sebagian besar nilai detak jantung normal, dan proses penemuan kemungkinan besar akan menetapkan tipe `TINYINT` ke kolom ini. Namun sebagian kecil nilai menunjukkan detak jantung yang tinggi. Jika nilai tinggi ini tidak cocok dengan tipe `TINYINT`, Kinesis Data Analytics mengirimkan baris ini ke aliran kesalahan. Perbarui tipe data ke `INTEGER` agar dapat menampung semua data detak jantung yang dihasilkan.
+ Gunakan templat **Deteksi Anomali** di konsol. Anda kemudian memperbarui kode templat untuk memberikan nama kolom yang sesuai.
1. Perbarui kode aplikasi dengan menyediakan nama kolom. Kode aplikasi yang dihasilkan ditampilkan di bawah ini (tempel kode ini ke editor SQL):
```
--Creates a temporary stream.
CREATE OR REPLACE STREAM "TEMP_STREAM" (
"heartRate" INTEGER,
"rateType" varchar(20),
"ANOMALY_SCORE" DOUBLE);
--Creates another stream for application output.
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
"heartRate" INTEGER,
"rateType" varchar(20),
"ANOMALY_SCORE" DOUBLE);
-- Compute an anomaly score for each record in the input stream
-- using Random Cut Forest
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "TEMP_STREAM"
SELECT STREAM "heartRate", "rateType", ANOMALY_SCORE
FROM TABLE(RANDOM_CUT_FOREST(
CURSOR(SELECT STREAM * FROM "SOURCE_SQL_STREAM_001")));
-- Sort records by descending anomaly score, insert into output stream
CREATE OR REPLACE PUMP "OUTPUT_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM * FROM "TEMP_STREAM"
ORDER BY FLOOR("TEMP_STREAM".ROWTIME TO SECOND), ANOMALY_SCORE DESC;
```
1. Jalankan kode SQL dan tinjau hasilnya di konsol Kinesis Data Analytics:
![\[Tangkapan layar konsol yang menampilkan tab analitik waktu nyata dengan data yang dihasilkan di aliran dalam aplikasi.\]](http://docs.aws.amazon.com/id_id/kinesisanalytics/latest/dev/images/anom-v2-40.png)
**Langkah Selanjutnya**
[Langkah 3: Konfigurasi Output Aplikasi](app-anomaly-create-ka-app-config-destination.md)
# Langkah 3: Konfigurasi Output Aplikasi
Setelah menyelesaikan [Langkah 2: Buat Aplikasi](app-anom-score-create-app.md), Anda memiliki kode aplikasi yang membaca data detak jantung dari sumber streaming dan menetapkan skor anomali untuk masing-masing.
Sekarang Anda dapat mengirim hasil aplikasi dari aliran dalam aplikasi ke tujuan eksternal, yang merupakan aliran data Kinesis lainnya (`OutputStreamTestingAnomalyScores`). Anda dapat menganalisis skor anomali dan menentukan detak jantung mana yang anomali. Anda kemudian dapat memperluas aplikasi ini lebih lanjut untuk menghasilkan pemberitahuan.
Ikuti langkah berikut untuk mengonfigurasi output aplikasi:
1. Buka konsol Amazon Kinesis Data Analytics. Di editor SQL, pilih **Destination** (Tujuan) atau **Add a destination** (Tambahkan tujuan) di dasbor aplikasi.
1. Di halaman **Sambungkan ke tujuan**, pilih aliran `OutputStreamTestingAnomalyScores` yang Anda buat di bagian sebelumnya.
Sekarang Anda memiliki tujuan eksternal, tempat Amazon Kinesis Data Analytics menyimpan catatan yang ditulis aplikasi Anda ke aliran dalam aplikasi `DESTINATION_SQL_STREAM`.
1. Anda dapat mengonfigurasi secara opsional AWS Lambda untuk memantau `OutputStreamTestingAnomalyScores` aliran dan mengirimi Anda peringatan. Untuk petunjuk, lihat [Memproses Data Terlebih Dulu Menggunakan Fungsi Lambda](lambda-preprocessing.md). Jika tidak menetapkan pemberitahuan, Anda dapat meninjau catatan yang ditulis oleh Kinesis Data Analytics ke tujuan eksternal, yaitu Kinesis data stream `OutputStreamTestingAnomalyScores`, seperti yang dijelaskan dalam [Langkah 4: Verifikasi Output](app-anomaly-verify-output.md).
**Langkah Selanjutnya**
[Langkah 4: Verifikasi Output](app-anomaly-verify-output.md)
# Langkah 4: Verifikasi Output
Setelah mengonfigurasi output aplikasi di [Langkah 3: Konfigurasi Output Aplikasi](app-anomaly-create-ka-app-config-destination.md), gunakan perintah AWS CLI berikut untuk membaca catatan dalam aliran tujuan yang ditulis oleh aplikasi:
1. Jalankan perintah `get-shard-iterator` untuk mendapatkan pointer ke data pada aliran output.
```
aws kinesis get-shard-iterator \
--shard-id shardId-000000000000 \
--shard-iterator-type TRIM_HORIZON \
--stream-name OutputStreamTestingAnomalyScores \
--region us-east-1 \
--profile adminuser
```
Anda mendapatkan respons dengan nilai iterator serpihan, seperti yang ditunjukkan dalam contoh respons berikut:
```
{
"ShardIterator":
"shard-iterator-value" }
```
Salin nilai iterator serpihan.
1. Jalankan perintah AWS CLI `get-records`.
```
aws kinesis get-records \
--shard-iterator shared-iterator-value \
--region us-east-1 \
--profile adminuser
```
Perintah mengembalikan halaman catatan dan iterator serpihan lain yang dapat Anda gunakan dalam perintah `get-records` berikutnya untuk mengambil serangkaian berikutnya catatan.