14 Sep 2022 Bacaan 7 menit Berita

Cara mengoptimalkan Kluster Spark Anda dengan Pekerjaan Spark Interaktif

Pada artikel ini, Anda akan mempelajari:

Cara mengurangi waktu eksekusi pekerjaan percikan Anda
Apa itu pekerjaan interaktif di Ilum
Cara menjalankan pekerjaan percikan interaktif
Perbedaan antara menjalankan pekerjaan spark menggunakan Ilum API dan Spark API

Jenis pekerjaan Ilum

Ada tiga jenis pekerjaan yang dapat Anda jalankan di Ilum: Pekerjaan tunggal , Pekerjaan interaktif dan Kode interaktif . Pada artikel ini, kita akan fokus pada Pekerjaan interaktif jenis. Namun, penting untuk mengetahui perbedaan antara ketiga jenis pekerjaan tersebut, jadi mari kita lihat sekilas masing-masing.

Dengan Pekerjaan tunggal , Anda dapat mengirimkan program seperti kode. Mereka memungkinkan Anda mengirimkan aplikasi Spark ke kluster, dengan kode yang telah dikompilasi sebelumnya, tanpa interaksi selama runtime. Dalam mode ini, Anda harus mengirim jar yang dikompilasi ke Ilum, yang digunakan untuk meluncurkan satu pekerjaan. Anda dapat mengirimkannya secara langsung, atau Anda dapat menggunakan kredensial AWS untuk mendapatkannya dari bucket S3. Contoh umum dari penggunaan pekerjaan tunggal adalah semacam tugas persiapan data.

Ilum juga menyediakan interaktif Mode kode , yang memungkinkan Anda mengirimkan perintah saat runtime. Ini berguna untuk tugas di mana Anda perlu berinteraksi dengan data, seperti analisis data eksplorasi.

Pekerjaan interaktif

Pekerjaan interaktif memiliki sesi yang berjalan lama, di mana Anda dapat mengirim data instans pekerjaan untuk segera dieksekusi. Fitur pembunuh dari mode semacam itu adalah Anda tidak perlu menunggu konteks percikan diinisialisasi. Jika pengguna menunjuk ke id pekerjaan yang sama, mereka akan berinteraksi dengan konteks percikan yang sama. Ilum membungkus logika aplikasi Spark ke dalam pekerjaan Spark yang berjalan lama yang dapat menangani permintaan perhitungan segera, tanpa perlu menunggu inisialisasi konteks Spark.

Memulai pekerjaan interaktif

Mari kita lihat bagaimana sesi interaktif Ilum dapat dimulai. Hal pertama yang harus kita lakukan adalah menyiapkan Ilum. Anda dapat melakukannya dengan mudah dengan minikube. Tutorial dengan instalasi Ilum tersedia di bawah ini tautan . Pada langkah selanjutnya, kita harus membuat file jar yang berisi implementasi antarmuka pekerjaan Ilum. Untuk menggunakan API pekerjaan Ilum, kita harus menambahkannya ke proyek dengan beberapa manajer dependensi, seperti Maven atau Gradle. Dalam contoh ini, kita akan menggunakan beberapa kode Scala dengan Gradle untuk menghitung PI.

Contoh lengkapnya tersedia di GitHub .

Jika Anda memilih untuk tidak membuatnya sendiri, Anda dapat menemukan file jar yang dikompilasi Sini .

Langkah pertama adalah membuat folder untuk proyek kita dan mengubah direktori ke dalamnya.

$ mkdir interactive-job-example
$ cd interactive-job-example

Jika Anda belum menginstal Gradle versi terbaru di komputer, Anda dapat memeriksa cara melakukannya Sini . Kemudian jalankan perintah berikut di terminal dari dalam direktori proyek:

$ gradle init

Pilih aplikasi Scala dengan Groovy sebagai DSL. Output akan terlihat seperti ini:

Memulai Daemon Gradle (build berikutnya akan lebih cepat)

Pilih jenis proyek yang akan dihasilkan:
  1: dasar
  2: Aplikasi
  3: Perpustakaan
  4: Plugin Gradle
Masukkan pilihan (default: dasar) [1..4] 2

Pilih bahasa implementasi:
  1: C++
  2: Groovy
  3: Jawa
  4: Kotlin
  5: Scala
  6: Cepat
Masukkan pilihan (default: Java) [1..6] 5

Membagi fungsionalitas di beberapa subproyek?:
  1: tidak - hanya satu proyek aplikasi
  2: Ya - Proyek aplikasi dan perpustakaan
Masukkan pilihan (default: tidak - hanya satu proyek aplikasi) [1..2] 1

Pilih skrip build DSL:
  1: Groovy
  2: Kotlin
Masukkan pilihan (default: Groovy) [1..2] 1

Membuat build menggunakan API dan perilaku baru (beberapa fitur dapat berubah di rilis minor berikutnya)? (default: tidak) [Ya, tidak] Tidak                           
Nama proyek (default: interactive-job-example): 
Paket sumber (default: interactive.job.example): 

> Tugas :init
Dapatkan bantuan lebih lanjut terkait proyek Anda: https://docs.gradle.org/7.5.1/samples/sample_building_scala_applications_multi_project.html

MEMBANGUN SUKSES dalam 30-an
2 tugas yang dapat ditindaklanjuti: 2 dieksekusi

Sekarang kita harus menambahkan repositori Ilum dan dependensi yang diperlukan ke dalam build.gradle arsip. Dalam tutorial ini, kita akan menggunakan Scala 2.12.

dependensi {
    Implementasi 'org.scala-lang:scala-library:2.12.16'
    Implementasi 'cloud.ilum:ilum-job-api:5.0.1'
    compileOnly 'org.apache.spark:spark-sql_2.12:3.1.2'
}

Sekarang kita dapat membuat kelas Scala yang memperluas Pekerjaan Ilum dan yang menghitung PI:

paket interactive.job.example

impor cloud.ilum.job.Job
impor org.apache.spark.sql.SparkSession
impor scala.math.random

class InteractiveJobExample memperluas Job {

override def run(sparkSession: SparkSession, config: Map[String, Any]): Option[String] = {

val slices = config.getOrElse("irisan", "2").toString.toInt
    val n = math.min(100000L * irisan, Int.MaxValue).toInt
    val count = sparkSession.sparkContext.parallelize(1 sampai n, irisan).map { i =>
      val x = acak * 2 - 1
      val y = acak * 2 - 1
      jika (x * x + y * y <= 1) 1 lain 0
    }.reduce(_ + _)
    Beberapa(s"Pi kira-kira ${4.0 * hitungan / (n - 1)}")
  }
}

Jika Gradle telah menghasilkan beberapa kelas utama atau pengujian, cukup hapus dari proyek dan buat build.

$ gradle build

File jar yang dihasilkan harus berada di ' ./interactive-job-example/app/build/libs/app.jar ', kita kemudian bisa beralih kembali ke Ilum. Setelah semua pod berjalan, silakan buat port forward untuk ilum-ui:

kubectl port-forward svc/ilum-ui 9777:9777

Buka Ilum UI di browser Anda dan buat grup baru:

Masukkan nama grup, pilih atau buat kluster, unggah file jar Anda, dan terapkan perubahan:

Ilum akan membuat pod driver Spark dan Anda dapat mengontrol jumlah pod pelaksana percikan dengan menskalakannya. Setelah kontainer percikan siap, mari kita jalankan pekerjaan:

Sekarang kita harus memasukkan nama kanonik kelas Scala kita

interactive.job.example.InteractiveJobExample

dan tentukan parameter irisan dalam format JSON:

{
  "config": {
    "irisan": "10"
  }
}

Anda akan melihat hasilnya tepat setelah pekerjaan dimulai

Anda dapat mengubah parameter, dan menjalankan ulang pekerjaan dan perhitungan Anda akan terjadi di tempat.

Perbandingan pekerjaan interaktif dan tunggal

Di Ilum Anda juga dapat menjalankan satu pekerjaan. Perbedaan terpenting dibandingkan dengan mode interaktif adalah Anda tidak perlu mengimplementasikan Job API. Kita dapat menggunakan toples SparkPi dari contoh Spark:

Menjalankan pekerjaan seperti ini juga cepat, tetapi pekerjaan interaktif 20 kali lebih cepat (4 detik vs 200 ms) . Jika Anda ingin memulai pekerjaan serupa dengan parameter lain, Anda harus menyiapkan pekerjaan baru dan mengunggah toples lagi.

Perbandingan Ilum dan Apache Spark polos

Saya telah menyiapkan Apache Spark secara lokal dengan Bitnami/Percikan gambar buruh pelabuhan. Jika Anda juga ingin menjalankan Spark di mesin Anda, Anda dapat menggunakan docker-compose:

$ ikal -LO https://raw.githubusercontent.com/bitnami/containers/main/bitnami/spark/docker-compose.yml
$ docker-compose up

Setelah Spark berjalan, Anda seharusnya dapat pergi ke localhost:8080 dan melihat UI admin. Kita perlu mendapatkan URL Spark dari browser:

Kemudian, kita harus membuka kontainer Spark dalam mode interaktif menggunakan

$ buruh pelabuhan eksekutif -it <containerid> -- bash

Dan sekarang di dalam wadah, kita dapat mengirimkan pekerjaan sparkPi. Dalam hal ini, akan menggunakan SparkiPi dari contoh jar dan, sebagai parameter master, menempatkan URL dari browser:

$ ./bin/spark-submit --class org.apache.spark.examples.SparkPi\
  --master spark://78c84485d233:7077 \
  /opt/bitnami/percikan/contoh/toples/spark-examples_2.12-3.3.0.jar\
  10

Ringkasan

Seperti yang Anda lihat pada contoh di atas, Anda dapat menghindari konfigurasi dan penginstalan klien Spark yang rumit dengan menggunakan Ilum. Ilum mengambil alih pekerjaan dan memberi Anda antarmuka yang sederhana dan nyaman. Selain itu, ini memungkinkan Anda untuk mengatasi keterbatasan Apache Spark, yang dapat memakan waktu yang sangat lama untuk diinisialisasi. Jika Anda harus melakukan banyak eksekusi pekerjaan dengan logika yang sama tetapi parameter yang berbeda dan ingin perhitungan segera dilakukan, Anda harus menggunakan mode pekerjaan interaktif.

Kesamaan dengan Apache Livy

Ilum adalah alat cloud-native untuk mengelola penyebaran Apache Spark di Kubernetes. Ini mirip dengan Apache Livy dalam hal fungsionalitas - dapat mengontrol Sesi Spark melalui REST API dan membangun interaksi real-time dengan Klaster Spark. Namun, Ilum dirancang khusus untuk lingkungan cloud-native modern.

Kami menggunakan Apache Livy di masa lalu, tetapi kami telah mencapai titik di mana Livy tidak cocok untuk lingkungan modern. Livy sudah usang dibandingkan dengan Ilum. Pada tahun 2018, kami mulai memindahkan semua lingkungan kami ke Kubernetes, dan kami harus menemukan cara untuk menerapkan, memantau, dan memelihara Apache Spark di Kubernetes. Ini adalah kesempatan yang sempurna untuk membangun Ilum.

Cobalah, gratis