Memecahkan masalah error Dataflow kehabisan memori

Halaman ini menjelaskan cara menemukan dan mengatasi error kehabisan memori (OOM) di Dataflow.

Menemukan error kehabisan memori

Untuk menentukan apakah pipeline Anda kehabisan memori, gunakan salah satu metode berikut.

  • Di halaman Jobs details, di panel Logs, lihat tab Diagnostics. Tab ini menampilkan error yang terkait dengan masalah memori dan seberapa sering error tersebut terjadi.
  • Di antarmuka pemantauan Dataflow, gunakan diagram Penggunaan memori untuk memantau kapasitas dan penggunaan memori worker.
  • Di halaman Jobs details, di panel Logs, pilih Worker logs untuk menemukan error kehabisan memori di log worker.
  • Error kehabisan memori juga mungkin muncul di log sistem. Untuk melihatnya, buka Logs Explorer dan gunakan kueri berikut:

    resource.type="dataflow_step"
    resource.labels.job_id="JOB_ID"
    "out of memory" OR "OutOfMemory" OR "Shutting down JVM"
    

    Ganti JOB_ID dengan ID tugas Anda.

  • Untuk tugas Java, Java Memory Monitor secara berkala melaporkan metrik pembersihan sampah memori. Jika pecahan waktu CPU yang digunakan untuk pembersihan sampah memori melebihi batas 50% untuk jangka waktu yang lama, harness SDK akan gagal. Anda mungkin melihat error yang mirip dengan contoh berikut:

    Shutting down JVM after 8 consecutive periods of measured GC thrashing. Memory is used/total/max = ...
    

    Error ini dapat terjadi saat memori fisik masih tersedia, dan biasanya menunjukkan bahwa penggunaan memori pipeline tidak efisien. Untuk mengatasi masalah ini, optimalkan pipeline Anda.

    Java Memory Monitor dikonfigurasi oleh antarmuka MemoryMonitorOptions.

Jika tugas Anda memiliki penggunaan memori yang tinggi atau error kehabisan memori, ikuti rekomendasi di halaman ini untuk mengoptimalkan penggunaan memori atau meningkatkan jumlah memori yang tersedia.

Mengatasi error kehabisan memori

Perubahan pada pipeline Dataflow Anda mungkin dapat mengatasi error kehabisan memori atau mengurangi penggunaan memori. Kemungkinan perubahan mencakup tindakan berikut:

Diagram berikut menunjukkan alur kerja pemecahan masalah Dataflow yang dijelaskan di halaman ini.

Diagram yang menunjukkan alur kerja pemecahan masalah.

Coba mitigasi berikut:

  • Jika memungkinkan, optimalkan pipeline Anda untuk mengurangi penggunaan memori.
  • Jika tugas tersebut adalah tugas batch, coba langkah-langkah berikut sesuai urutan yang tercantum:
    1. Gunakan jenis mesin dengan memori per vCPU yang lebih besar.
    2. Kurangi jumlah thread menjadi kurang dari jumlah vCPU per worker.
    3. Gunakan jenis mesin kustom dengan lebih banyak memori per vCPU.
  • Jika tugas tersebut adalah tugas streaming yang menggunakan Python, kurangi jumlah thread menjadi kurang dari 12.
  • Jika tugas tersebut adalah tugas streaming yang menggunakan Java atau Go, coba langkah berikut:
    1. Kurangi jumlah thread menjadi kurang dari 500 untuk tugas yang menggunakan Portable Runner, atau kurang dari 300 untuk tugas yang tidak menggunakan Portable Runner.
    2. Gunakan jenis mesin dengan memori yang lebih besar.
  • Untuk pipeline Java, jika terjadi error kehabisan memori selama alokasi memori yang sering atau thrashing pembersihan sampah memori, coba gunakan pembersih sampah memori Java yang berbeda.

Mengoptimalkan pipeline Anda

Beberapa operasi pipeline dapat menyebabkan error kehabisan memori. Bagian ini memberikan opsi untuk mengurangi penggunaan memori pipeline Anda. Untuk mengidentifikasi tahap pipeline yang paling banyak menggunakan memori, gunakan Cloud Profiler untuk memantau performa pipeline.

Anda dapat menggunakan praktik terbaik berikut untuk mengoptimalkan pipeline:

Menggunakan konektor I/O bawaan Apache Beam untuk membaca file

Jangan buka file besar di dalam DoFn. Untuk membaca file, gunakan konektor I/O bawaan Apache Beam. File yang dibuka di DoFn harus sesuai dengan memori. Karena beberapa instance DoFn berjalan secara serentak, file besar yang dibuka di DoFn dapat menyebabkan error kehabisan memori.

Mendesain ulang operasi saat menggunakan PTransform GroupByKey

Saat Anda menggunakan GroupByKey PTransform di Dataflow, nilai per kunci dan per jendela yang dihasilkan akan diproses pada satu thread. Karena data ini diteruskan sebagai aliran data dari layanan backend Dataflow ke worker, data tersebut tidak perlu muat dalam memori worker. Namun, jika nilai dikumpulkan dalam memori, logika pemrosesan dapat menyebabkan error kehabisan memori.

Misalnya, jika Anda memiliki kunci yang berisi data untuk jendela, dan Anda menambahkan nilai kunci ke objek dalam memori, seperti daftar, error kehabisan memori mungkin terjadi. Dalam skenario ini, worker mungkin tidak memiliki kapasitas memori yang memadai untuk menampung semua objek.

Untuk mengetahui informasi selengkapnya tentang PTransform GroupByKey, lihat dokumentasi Apache Beam Python GroupByKey dan Java GroupByKey.

Daftar berikut berisi saran untuk mendesain pipeline Anda guna meminimalkan konsumsi memori saat menggunakan PTransform GroupByKey.

  • Untuk mengurangi jumlah data per kunci dan per periode, hindari kunci dengan banyak nilai, yang juga dikenal sebagai hot key.
  • Untuk mengurangi jumlah data yang dikumpulkan per periode, gunakan ukuran periode yang lebih kecil.
  • Jika Anda menggunakan nilai kunci dalam jendela untuk menghitung angka, gunakan transformasi Combine. Jangan melakukan penghitungan dalam satu instance DoFn setelah mengumpulkan nilai.
  • Filter nilai atau duplikat sebelum diproses. Untuk mengetahui informasi selengkapnya, lihat dokumentasi transformasi Python Filter dan Java Filter.

Mengurangi data masuk dari sumber eksternal

Jika Anda melakukan panggilan ke API eksternal atau database untuk pengayaan data, data yang ditampilkan harus sesuai dengan memori worker. Jika Anda mengelompokkan panggilan, sebaiknya gunakan transformasi GroupIntoBatches. Jika Anda mengalami error kehabisan memori, kurangi ukuran batch. Untuk mengetahui informasi selengkapnya tentang pengelompokan ke dalam batch, lihat dokumentasi transformasi GroupIntoBatches Python dan GroupIntoBatches Java.

Berbagi objek di seluruh thread

Membagikan objek data dalam memori di seluruh instance DoFn dapat meningkatkan efisiensi ruang dan akses. Objek data yang dibuat dalam metode DoFn apa pun, termasuk Setup, StartBundle, Process, FinishBundle, dan Teardown, dipanggil untuk setiap DoFn. Di Dataflow, setiap worker mungkin memiliki beberapa instance DoFn. Untuk penggunaan memori yang lebih efisien, teruskan objek data sebagai singleton untuk membagikannya di beberapa DoFn. Untuk mengetahui informasi selengkapnya, lihat postingan blog Penggunaan kembali cache di seluruh DoFn.

Menggunakan representasi elemen yang hemat memori

Evaluasi apakah Anda dapat menggunakan representasi untuk elemen PCollection yang menggunakan lebih sedikit memori. Saat menggunakan coder di pipeline, pertimbangkan tidak hanya representasi elemen PCollection yang dienkode, tetapi juga yang didekode. Matriks sparse sering kali dapat memanfaatkan jenis pengoptimalan ini.

Mengurangi ukuran input samping

Jika DoFn Anda menggunakan input samping, kurangi ukuran input samping. Untuk input samping yang merupakan kumpulan elemen, pertimbangkan untuk menggunakan tampilan iterable, seperti AsIterable atau AsMultimap, bukan tampilan yang mewujudkan seluruh input samping secara bersamaan, seperti AsList.

Mengurangi jumlah thread

Anda dapat meningkatkan memori yang tersedia per thread dengan mengurangi jumlah maksimum thread yang menjalankan instance DoFn. Perubahan ini mengurangi paralelisme, tetapi menyediakan lebih banyak memori untuk setiap DoFn.

Tabel berikut menunjukkan jumlah thread default yang dibuat Dataflow:

Jenis tugas Python SDK SDK Java/Go
Batch 1 thread per vCPU 1 thread per vCPU
Streaming dengan Portable Runner (sebelumnya disebut Runner v2) 12 thread per vCPU 500 thread per worker VM
Streaming tanpa Portable Runner (sebelumnya disebut Runner v2) 12 thread per vCPU 300 thread per worker VM

Untuk mengurangi jumlah thread Apache Beam SDK, tetapkan opsi pipeline berikut:

Java

Gunakan opsi pipeline --numberOfWorkerHarnessThreads.

Python

Gunakan opsi pipeline --number_of_worker_harness_threads.

Go

Gunakan opsi pipeline --number_of_worker_harness_threads.

Untuk tugas batch, tetapkan nilai ke angka yang lebih kecil dari jumlah vCPU.

Untuk tugas streaming, mulailah dengan mengurangi nilai menjadi setengah dari nilai default. Jika langkah ini tidak mengurangi masalah, terus kurangi nilainya menjadi setengah, dan amati hasilnya di setiap langkah. Misalnya, saat menggunakan Python, coba nilai 6, 3, dan 1.

Menggunakan jenis mesin dengan lebih banyak memori per vCPU

Untuk memilih worker dengan memori per vCPU yang lebih besar, gunakan salah satu metode berikut.

  • Gunakan jenis mesin bermemori tinggi dalam kelompok mesin tujuan umum. Jenis mesin bermemori tinggi memiliki memori per vCPU yang lebih tinggi daripada jenis mesin standar. Menggunakan jenis mesin bermemori tinggi akan meningkatkan memori yang tersedia untuk setiap worker dan memori yang tersedia per thread, karena jumlah vCPU tetap sama. Oleh karena itu, menggunakan jenis mesin bermemori tinggi dapat menjadi cara yang hemat biaya untuk memilih worker dengan lebih banyak memori per vCPU.
  • Untuk fleksibilitas yang lebih besar saat menentukan jumlah vCPU dan jumlah memori, Anda dapat menggunakan jenis mesin kustom. Dengan jenis mesin kustom, Anda dapat meningkatkan memori dalam kelipatan 256 MB. Jenis mesin ini memiliki harga yang berbeda dengan jenis mesin standar.
  • Beberapa kelompok mesin memungkinkan Anda menggunakan jenis mesin kustom memori tambahan. Memori yang diperluas memungkinkan rasio memori per vCPU yang lebih tinggi. Biayanya lebih tinggi. Contoh jenis mesin kustom dengan memori tambahan mencakup n2-custom-1-19456-ext dan n2-custom-8-317440-ext.

Untuk menetapkan jenis worker, gunakan opsi pipeline berikut. Untuk mengetahui informasi selengkapnya, lihat Menetapkan opsi pipeline dan Opsi pipeline.

Java

Gunakan opsi pipeline --workerMachineType.

Python

Gunakan opsi pipeline --machine_type.

Go

Gunakan opsi pipeline --worker_machine_type.

Hanya menggunakan satu proses Apache Beam SDK

Untuk pipeline streaming Python dan pipeline Python yang menggunakan Portable Runner, Anda dapat memaksa Dataflow untuk memulai hanya satu proses Apache Beam SDK per worker.

Sebelum mencoba opsi ini, coba selesaikan masalah terlebih dahulu menggunakan metode lain. Untuk mengonfigurasi worker VM Dataflow agar hanya memulai satu proses Python dalam container, gunakan opsi pipeline berikut:

--experiments=no_use_multiple_sdk_containers

Dengan konfigurasi ini, pipeline Python membuat satu proses Apache Beam SDK per worker. Konfigurasi ini mencegah objek dan data bersama direplikasi beberapa kali untuk setiap proses Apache Beam SDK. Namun, hal ini membatasi penggunaan resource komputasi yang tersedia di worker secara efisien.

Mengurangi jumlah proses Apache Beam SDK menjadi satu tidak selalu mengurangi jumlah total thread yang dimulai pada worker. Selain itu, memiliki semua thread pada satu proses Apache Beam SDK dapat menyebabkan pemrosesan yang lambat atau menyebabkan pipeline macet. Oleh karena itu, Anda mungkin juga harus mengurangi jumlah thread, seperti yang dijelaskan di bagian Mengurangi jumlah thread di halaman ini.

Anda juga dapat memaksa worker untuk hanya menggunakan satu proses Apache Beam SDK dengan menggunakan jenis mesin yang hanya memiliki satu vCPU.

Menggunakan pembersih sampah memori Java yang berbeda

Secara default, worker Java Dataflow menggunakan Parallel collector (-XX:+UseParallelGC). Worker ini memaksimalkan throughput CPU dengan overhead metadata yang rendah. Namun, GC ini menggunakan jeda stop-the-world dan memprioritaskan throughput daripada meminimalkan jejak heap. Karena hanya mengklaim kembali generasi lama selama pengumpulan penuh, alokasi yang sering dapat mendorong penggunaan heap mendekati batas maksimum sebelum pengumpulan berjalan, terutama di JDK 21 dan yang lebih baru. Jika digabungkan dengan memori off-heap, pertumbuhan puncak ini dapat memicu jeda yang lama, thrashing pembersihan sampah memori, atau error kehabisan memori.

Mengubah pembersih sampah memori tidak akan mengurangi memori aktif yang digunakan pipeline Anda. Jika objek aktif melebihi memori worker, optimalkan pipeline Anda, kurangi jumlah thread, atau gunakan jenis mesin dengan lebih banyak memori per vCPU.

Jika terjadi error kehabisan memori atau thrashing dalam alokasi yang sering, coba kolektor lain menggunakan opsi pipeline --experiments. Nilai yang didukung adalah --experiments=java_gc=UseG1GC atau --experiments=java_gc=UseZGC (untuk Java 17 dan yang lebih baru).

Memahami penggunaan memori Dataflow

Untuk memecahkan masalah error kehabisan memori, sebaiknya pahami cara pipeline Dataflow menggunakan memori.

Saat Dataflow menjalankan pipeline, pemrosesan didistribusikan ke beberapa virtual machine (VM) Compute Engine, yang sering disebut worker. Worker memproses item kerja dari layanan Dataflow dan mendelegasikan item kerja ke proses Apache Beam SDK. Proses Apache Beam SDK membuat instance DoFn. DoFn adalah class Apache Beam SDK yang menentukan fungsi pemrosesan terdistribusi.

Dataflow meluncurkan beberapa thread di setiap worker, dan memori setiap worker dibagikan ke semua thread. Thread adalah satu tugas yang dapat dieksekusi yang berjalan dalam proses yang lebih besar. Jumlah thread default bergantung pada beberapa faktor dan bervariasi antara tugas batch dan streaming.

Jika pipeline Anda memerlukan lebih banyak memori daripada jumlah memori default yang tersedia di worker, Anda mungkin mengalami error kehabisan memori.

Pipeline Dataflow utamanya menggunakan memori worker dengan tiga cara:

Memori operasional pekerja

Worker Dataflow memerlukan memori untuk sistem operasi dan proses sistemnya. Penggunaan memori worker biasanya tidak lebih dari 1 GB. Penggunaan biasanya kurang dari 1 GB.

  • Berbagai proses pada worker menggunakan memori untuk memastikan pipeline Anda berfungsi dengan baik. Setiap proses ini mungkin menyisihkan sejumlah kecil memori untuk operasinya.
  • Jika pipeline Anda tidak menggunakan Streaming Engine, proses worker tambahan akan menggunakan memori.

Memori proses SDK

Proses Apache Beam SDK dapat membuat objek dan data yang dibagikan di antara thread dalam proses, yang di halaman ini disebut sebagai objek dan data bersama SDK. Penggunaan memori dari objek dan data bersama SDK ini disebut sebagai memori proses SDK. Daftar berikut mencakup contoh objek dan data bersama SDK:

  • Input samping
  • Model machine learning
  • Objek singleton dalam memori
  • Objek Python yang dibuat dengan modul apache_beam.utils.shared
  • Data yang dimuat dari sumber eksternal, seperti Cloud Storage atau BigQuery

Tugas streaming yang tidak menggunakan Streaming Engine menyimpan input samping di memori. Untuk pipeline Java dan Go, setiap worker memiliki satu salinan input samping. Untuk pipeline Python, setiap proses Apache Beam SDK memiliki satu salinan input samping.

Tugas streaming yang menggunakan Streaming Engine memiliki batas ukuran input samping sebesar 80 MB. Input samping disimpan di luar memori worker.

Penggunaan memori dari objek dan data bersama SDK bertambah secara linear dengan jumlah proses Apache Beam SDK. Dalam pipeline Java dan Go, satu proses Apache Beam SDK dimulai per worker. Dalam pipeline Python, satu proses Apache Beam SDK dimulai per vCPU. Objek dan data bersama SDK digunakan kembali di seluruh thread dalam proses Apache Beam SDK yang sama.

Penggunaan memori DoFn

DoFn adalah class Apache Beam SDK yang menentukan fungsi pemrosesan terdistribusi. Setiap worker dapat menjalankan instance DoFn serentak. Setiap thread menjalankan satu instance DoFn. Saat mengevaluasi total penggunaan memori, menghitung ukuran set kerja, atau jumlah memori yang diperlukan agar aplikasi dapat terus berfungsi, mungkin akan membantu. Misalnya, jika setiap DoFn menggunakan memori maksimum 5 MB dan worker memiliki 300 thread, penggunaan memori DoFn dapat mencapai puncaknya pada 1,5 GB, atau jumlah byte memori dikalikan dengan jumlah thread. Bergantung pada cara worker menggunakan memori, lonjakan penggunaan memori dapat menyebabkan worker kehabisan memori.

Sulit untuk memperkirakan jumlah instance DoFn yang dibuat Dataflow. Jumlahnya bergantung pada berbagai faktor, seperti SDK, jenis mesin, dan variabel lainnya. Selain itu, DoFn mungkin digunakan oleh beberapa thread secara berurutan. Layanan Dataflow tidak menjamin berapa kali DoFn dipanggil, dan juga tidak menjamin jumlah pasti instance DoFn yang dibuat selama pipeline. Namun, tabel berikut memberikan beberapa insight tentang tingkat paralelisme yang dapat Anda harapkan dan memperkirakan batas atas jumlah instance DoFn.

Beam Python SDK

Batch Streaming tanpa Streaming Engine Streaming Engine
Keparalelan

1 proses per vCPU

1 thread per proses

1 thread per vCPU

1 proses per vCPU

12 thread per proses

12 thread per vCPU

1 proses per vCPU

12 thread per proses

12 thread per vCPU

Jumlah maksimum instance DoFn serentak (Semua angka ini dapat berubah sewaktu-waktu.)

1 DoFn per rangkaian pesan

1 DoFn per vCPU

1 DoFn per rangkaian pesan

12 DoFn per vCPU

1 DoFn per rangkaian pesan

12 DoFn per vCPU

SDK Beam Java/Go

Batch Streaming Appliance dan Streaming Engine tanpa Portable Runner Streaming Engine dengan Runner Portabel
Keparalelan

1 proses per worker VM

1 thread per vCPU

1 proses per worker VM

300 thread per proses

300 thread per worker VM

1 proses per worker VM

500 thread per proses

500 thread per worker VM

Jumlah maksimum instance DoFn serentak (Semua angka ini dapat berubah sewaktu-waktu.)

1 DoFn per rangkaian pesan

1 DoFn per vCPU

1 DoFn per rangkaian pesan

300 DoFn per worker VM

1 DoFn per rangkaian pesan

500 DoFn per worker VM

Misalnya, saat menggunakan Python SDK dengan worker Dataflow n1-standard-2, hal berikut berlaku:

  • Tugas batch: Dataflow meluncurkan satu proses per vCPU (dua dalam kasus ini). Setiap proses menggunakan satu thread, dan setiap thread membuat satu instance DoFn.
  • Tugas streaming dengan Streaming Engine: Dataflow memulai satu proses per vCPU (total dua). Namun, setiap proses dapat menghasilkan hingga 12 thread, masing-masing dengan instance DoFn-nya sendiri.

Saat Anda mendesain pipeline yang kompleks, penting untuk memahami siklus proses DoFn. Pastikan fungsi DoFn Anda dapat diserialisasi, dan hindari mengubah argumen elemen secara langsung di dalamnya.

Jika Anda memiliki pipeline multibahasa, dan lebih dari satu Apache Beam SDK berjalan di worker, worker akan menggunakan tingkat paralelisme thread per proses yang paling rendah.

Perbedaan Java, Go, dan Python

Java, Go, dan Python mengelola proses dan memori secara berbeda. Oleh karena itu, pendekatan yang harus Anda lakukan saat memecahkan masalah error kehabisan memori bervariasi berdasarkan apakah pipeline Anda menggunakan Java, Go, atau Python.

Pipeline Java dan Go

Di pipeline Java dan Go:

  • Setiap worker memulai satu proses Apache Beam SDK.
  • Objek dan data bersama SDK, seperti input samping dan cache, dibagikan di antara semua thread pada worker.
  • Memori yang digunakan oleh objek dan data bersama SDK biasanya tidak diskalakan berdasarkan jumlah vCPU pada worker.

Pipeline Python

Dalam pipeline Python:

  • Setiap worker memulai satu proses Apache Beam SDK per vCPU.
  • Objek dan data bersama SDK, seperti input samping dan cache, dibagikan di antara semua thread dalam setiap proses Apache Beam SDK.
  • Jumlah total thread pada worker diskalakan secara linear berdasarkan jumlah vCPU. Akibatnya, memori yang digunakan oleh objek dan data bersama SDK bertambah secara linear seiring dengan jumlah vCPU.
  • Thread yang melakukan pekerjaan didistribusikan di seluruh proses. Unit kerja baru ditetapkan ke proses tanpa item kerja, atau ke proses dengan item kerja paling sedikit yang ditetapkan pada saat itu.