Karakteristik performa pipeline Kafka ke BigQuery

Halaman ini menjelaskan karakteristik performa untuk tugas streaming Dataflow yang membaca dari Apache Kafka dan menulis ke BigQuery. Benchmark ini memberikan hasil pengujian benchmark untuk pipeline khusus peta, yang melakukan transformasi per pesan tanpa melacak status atau mengelompokkan elemen di seluruh aliran.

Banyak beban kerja integrasi data, termasuk ETL, validasi kolom, dan pemetaan skema, termasuk dalam kategori khusus peta. Jika pipeline Anda mengikuti pola ini, Anda dapat menggunakan tolok ukur ini untuk menilai tugas Dataflow terhadap konfigurasi referensi yang berperforma baik.

Metodologi pengujian

Tolok ukur dilakukan menggunakan resource berikut:

Cluster Managed Service for Apache Kafka. Pesan dibuat menggunakan template Streaming Data Generator.
- Kecepatan pesan: Sekitar 1.000.000 pesan per detik
- Input Load: 1 GiB/dtk
- Format pesan: Teks JSON yang dibuat secara acak dengan skema tetap
- Ukuran pesan: Sekitar 1 KiB per pesan
- Partisi Kafka: 1000
Tabel BigQuery standar.
Pipeline streaming Dataflow yang menggunakan template Apache Kafka ke BigQuery. Pipeline ini melakukan pemetaan skema dan penguraian minimum yang diperlukan. Tidak ada fungsi yang ditentukan pengguna (UDF) kustom yang digunakan.

Setelah penskalaan horizontal stabil dan pipeline mencapai status stabil, pipeline diizinkan berjalan selama sekitar satu hari, setelah itu hasilnya dikumpulkan dan dianalisis.

Pipeline Dataflow

Benchmark ini menggunakan pipeline khusus peta yang melakukan pemetaan dan konversi pesan JSON sederhana. Pipeline diuji menggunakan mode tepat satu kali dan mode minimal satu kali. Pemrosesan minimal sekali (at-least-once) memberikan throughput yang lebih baik. Namun, opsi ini hanya boleh digunakan jika kumpulan data duplikat dapat diterima atau sink hilir menangani penghapusan duplikat.

Konfigurasi tugas

Tabel berikut menunjukkan cara konfigurasi tugas Dataflow.

Setelan	Nilai
Jenis mesin pekerja	`e2-standard-2`
vCPU mesin pekerja	2
RAM mesin pekerja	8 GB
Persistent Disk mesin pekerja	Persistent Disk Standar (HDD), 30 GB
Pekerja maksimum	120
Streaming Engine	Ya
Penskalaan horizontal otomatis	Ya
Model penagihan	Penagihan berbasis resource
Storage Write API diaktifkan?	Ya
Streaming Storage Write API	400
Frekuensi pemicuan Storage Write API	5 detik
Format Pesan	JSON
Mode Autentikasi Kafka	Kredensial Default Aplikasi (ADC). Untuk mengetahui informasi selengkapnya, lihat Jenis autentikasi untuk broker Kafka.

BigQuery Storage Write API direkomendasikan untuk pipeline streaming. Saat menggunakan mode tepat satu kali dengan Storage Write API, Anda dapat menyesuaikan setelan berikut:

Jumlah aliran penulisan. Untuk memastikan paralelisme kunci yang memadai pada tahap penulisan, tetapkan jumlah streaming Storage Write API ke nilai yang lebih besar dari jumlah CPU pekerja, sambil mengikuti rekomendasi throughput per streaming.
Frekuensi pemicuan. Nilai detik satu digit cocok untuk pipeline throughput tinggi.

Untuk mengetahui informasi selengkapnya, lihat artikel Menulis dari Dataflow ke BigQuery.

Pertimbangan khusus juga harus diberikan pada jumlah partisi Apache Kafka. Untuk memastikan paralelisme kunci yang memadai pada tahap baca, jumlah partisi setidaknya harus sama dengan jumlah total vCPU pekerja. Untuk mengetahui informasi selengkapnya, lihat Membaca dari Apache Kafka ke Dataflow.

Hasil benchmark

Bagian ini menjelaskan hasil pengujian benchmark.

Throughput dan penggunaan resource

Tabel berikut menunjukkan hasil pengujian untuk throughput pipeline dan penggunaan resource.

Hasil	Tepat satu kali	Minimal sekali
Throughput input per pekerja	Rata-rata: 15 MBps, n=3	Rata-rata: 18 MBps, n=3
Penggunaan CPU rata-rata di semua pekerja	Rerata: 70%, n=3	Rerata: 75%, n=3
Jumlah worker node	Rerata: 63, n=3	Rerata: 53, n=3
Unit Komputasi Streaming Engine per jam	Rata-rata: 58, n=3	Rata-rata: 0, n=3

Algoritma penskalaan otomatis dapat memengaruhi tingkat penggunaan CPU target. Untuk mencapai target penggunaan CPU yang lebih tinggi atau lebih rendah, Anda dapat menetapkan rentang penskalaan otomatis atau petunjuk penggunaan pekerja. Target pemanfaatan yang lebih tinggi dapat menghasilkan biaya yang lebih rendah, tetapi juga latensi ekor yang lebih buruk, terutama untuk beban yang bervariasi.

Latensi

Tabel berikut menunjukkan hasil benchmark untuk latensi pipeline dalam mode exactly-once, tidak termasuk tahap input.

Total latensi end-to-end tahap, tidak termasuk tahap input	Tepat satu kali
P50	Rerata: 1.200 md, n=3
P95	Rerata: 3.000 md, n=3
P99	Rerata: 5.400 md, n=3

Pengujian mengukur latensi end-to-end per tahap (metrik job/streaming_engine/stage_end_to_end_latencies) di tiga eksekusi pengujian yang berjalan lama. Metrik ini mengukur berapa lama Streaming Engine menghabiskan waktu di setiap tahap pipeline. Hal ini mencakup semua langkah internal pipeline, seperti:

Mengacak dan mengantrekan pesan untuk diproses
Waktu pemrosesan sebenarnya; misalnya, mengonversi pesan menjadi objek baris
Menulis status persisten, serta waktu yang dihabiskan untuk mengantre guna menulis status persisten

Karena batasan metrik, latensi tahap input tidak dilaporkan. Oleh karena itu, tidak termasuk dalam total.

Tolok ukur yang ditampilkan di sini mewakili dasar pengukuran. Latensi sangat sensitif terhadap kompleksitas pipeline. UDF kustom, transformasi tambahan, dan logika windowing yang kompleks dapat meningkatkan latensi.

Perkirakan biaya

Anda dapat memperkirakan biaya dasar pipeline Anda sendiri yang sebanding dengan Penagihan berbasis resource menggunakan kalkulator harga Google Cloud Platform, sebagai berikut:

Buka kalkulator harga.
Klik Tambahkan ke estimasi.
Pilih Dataflow.
Untuk Jenis layanan, pilih "Dataflow Klasik".
Pilih Setelan lanjutan untuk menampilkan semua opsi.
Pilih lokasi tempat tugas berjalan.
Untuk Job type, pilih "Streaming".
Pilih Aktifkan Streaming Engine.
Masukkan informasi untuk jam eksekusi tugas, worker node, mesin pekerja, dan penyimpanan Persistent Disk.
Masukkan perkiraan jumlah Unit Komputasi Streaming Engine.

Penggunaan resource dan biaya meningkat secara linear dengan throughput input, meskipun untuk tugas kecil dengan hanya beberapa pekerja, total biaya didominasi oleh biaya tetap. Sebagai titik awal, Anda dapat mengekstrapolasi jumlah node pekerja dan konsumsi resource dari hasil tolok ukur.

Misalnya, Anda menjalankan pipeline khusus peta dalam mode tepat satu kali, dengan kecepatan data input 100 MiB/s. Berdasarkan hasil tolok ukur untuk pipeline 1 GiB/s, Anda dapat memperkirakan persyaratan resource sebagai berikut:

Faktor Penskalaan: (100 MiB/dtk) / (1 GiB/dtk) = 0,1
Node pekerja yang diproyeksikan: 63 pekerja × 0,1 = 6,3 pekerja
Perkiraan jumlah Unit Komputasi Streaming Engine per jam: 58 × 0,1 = 5,8 unit per jam

Nilai ini hanya boleh digunakan sebagai perkiraan awal. Throughput dan biaya sebenarnya dapat sangat bervariasi, berdasarkan faktor-faktor seperti jenis mesin, distribusi ukuran pesan, kode pengguna, jenis agregasi, paralelisme kunci, dan ukuran jendela. Untuk mengetahui informasi selengkapnya, lihat Praktik terbaik untuk pengoptimalan biaya Dataflow.

Menjalankan pipeline pengujian

Bagian ini menunjukkan perintah gcloud dataflow flex-template run yang digunakan untuk menjalankan pipeline khusus peta.

Mode tepat satu kali

gcloud dataflow flex-template run JOB_NAME \
  --project=PROJECT_ID \
  --template-file-gcs-location=gs://dataflow-templates-us-central1/latest/flex/Kafka_to_BigQuery_Flex \
  --enable-streaming-engine \
  --parameters \
readBootstrapServerAndTopic="KAFKA_BOOTSTRAP_ADDRESS;KAFKA_TOPIC",\
kafkaReadAuthenticationMode=APPLICATION_DEFAULT_CREDENTIALS,\
messageFormat=JSON,\
writeMode=SINGLE_TABLE_NAME,\
outputTableSpec="PROJECT_ID:BQ_DATASET.BQ_TABLE_NAME",\
useBigQueryDLQ=true,\
outputDeadletterTable="PROJECT_ID:BQ_DATASET.BQ_TABLE_NAME_dlq",\
numStorageWriteApiStreams=400

Mode minimal satu kali

gcloud dataflow flex-template run JOB_NAME \
  --project=PROJECT_ID \
  --template-file-gcs-location=gs://dataflow-templates-us-central1/latest/flex/Kafka_to_BigQuery_Flex \
  --enable-streaming-engine \
  --additional-experiments=streaming_mode_at_least_once \
  --parameters \
readBootstrapServerAndTopic="KAFKA_BOOTSTRAP_ADDRESS;KAFKA_TOPIC",\
kafkaReadAuthenticationMode=APPLICATION_DEFAULT_CREDENTIALS,\
messageFormat=JSON,\
writeMode=SINGLE_TABLE_NAME,\
outputTableSpec="PROJECT_ID:BQ_DATASET.BQ_TABLE_NAME",\
useBigQueryDLQ=true,\
outputDeadletterTable="PROJECT_ID:BQ_DATASET.BQ_TABLE_NAME_dlq",\
numStorageWriteApiStreams=400,\
useStorageWriteApiAtLeastOnce=true

Ganti kode berikut:

JOB_NAME: nama tugas Dataflow
PROJECT_ID: the project ID
KAFKA_BOOTSTRAP_ADDRESS: alamat bootstrap cluster Apache Kafka
KAFKA_TOPIC: nama topik Kafka
BQ_DATASET: nama set data BigQuery
BQ_TABLE_NAME: nama tabel BigQuery

Membuat data pengujian

Untuk membuat data pengujian, gunakan perintah berikut untuk menjalankan template Streaming Data Generator:

gcloud dataflow flex-template run JOB_NAME \
  --project=PROJECT_ID \
  --template-file-gcs-location=gs://dataflow-templates-us-central1/latest/flex/Streaming_Data_Generator \
  --max-workers=140 \
  --parameters \
schemaLocation=SCHEMA_LOCATION,\
qps=1000000,\
sinkType=KAFKA,\
bootstrapServer=KAFKA_BOOTSTRAP_ADDRESS,\
kafkaTopic=KAFKA_TOPIC,\
outputType=JSON