Menerapkan Layanan Mikro PySpark di Kubernetes: Merevolusi Data Lakes dengan Ilum.
Salam penggemar Ilum dan penggemar Python! Kami sangat senang meluncurkan fitur baru yang sangat ditunggu-tunggu yang akan memberdayakan perjalanan ilmu data Anda - dukungan penuh Python di Ilum. Bagi mereka yang berada di dunia data, Python dan Apache Spark telah lama menjadi duo ikonik, dengan mulus menangani volume data yang besar dan komputasi yang kompleks. Dan sekarang, dengan peningkatan terbaru Ilum, Anda dapat memanfaatkan kekuatan Python langsung di dalam lingkungan danau data favorit Anda.
Posting blog ini adalah tur berpemandu Anda untuk menjelajahi fitur ini. Kita akan memulai dengan pekerjaan Apache Spark sederhana yang ditulis dalam Python, menjalankannya di Ilum, dan kemudian menyelam lebih dalam. Kami akan mengubah kode awal untuk mendukung mode interaktif, menawarkan Anda akses langsung ke pekerjaan Spark melalui API Ilum. Pada akhir perjalanan ini, Anda akan memiliki layanan mikro berbasis Python yang merespons panggilan API, semuanya berjalan dengan lancar di Ilum.
Jadi, apakah Anda siap untuk meningkatkan permainan data Anda dengan Python dan Ilum? Mari kita mulai.
Semua contoh tersedia di Repositori GitHub .
Langkah 1: Menulis pekerjaan Apache Spark sederhana dalam Python.
Sebelum kita memulai perjalanan Python kita bersama Ilum, kita perlu memastikan lingkungan kita dilengkapi dengan baik. Untuk menjalankan pekerjaan Spark, Anda harus menginstal Ilum dan PySpark. Anda dapat menggunakan pip, penginstal paket Python, untuk menyiapkan PySpark. Pastikan Anda menggunakan Python >=3.9.
Pip menginstal Pyspark Untuk menyiapkan dan mengakses Ilum, silakan ikuti panduan yang disediakan Sini .
1.1 Contoh SparkPi.
Sekarang, mari selami penulisan pekerjaan Spark kita. Kita akan mulai dengan contoh sederhana SparkPi
Impor Sistem
dari impor acak
dari operator impor tambahkan
dari pyspark.sql mengimpor SparkSession
jika __name__ == "__main__":
percikan = SparkSession \
.pembangun\
.appName("PythonPi") \
.getOrCreate()
partisi = int(sys.argv[1]) jika len(sys.argv) > 1 else 2
n = 100000 * partisi
def f(_: int) -> mengambang:
x = acak() * 2 - 1
y = acak() * 2 - 1
mengembalikan 1 jika x ** 2 + y ** 2 <= 1 lain 0
count = spark.sparkContext.parallelize(range(1, n + 1), partisi).map(f).reduce(add)
print("Pi kira-kira %f" % (4.0 * hitungan / n))
percikan.berhenti() Simpan skrip ini sebagai ilum_python_simple.py
Dengan pekerjaan Spark kami siap, saatnya menjalankannya di Ilum. Ilum menawarkan kemampuan untuk mengirimkan pekerjaan menggunakan UI Ilum atau melalui REST API.
Mari kita mulai dengan UI dengan Fitur pekerjaan tunggal.
Kita dapat mencapai hal yang sama dengan API , tetapi pertama-tama, kita perlu mengekspos API ilum-core dengan port forward.
Svc/ilum-core port maju 9888:9888 Dengan port yang terekspos kita dapat melakukan panggilan API.
curl -X POST 'localhost:9888/api/v1/job/submit' \
--form 'name="ilumSimplePythonJob"' \
--form 'clusterName="default"' \
--form 'jobClass="ilum_python_simple"' \
--form 'args="10"' \
--form 'pyFiles=@"/path/to/ilum_python_simple.py"' \
--form 'language="PYTHON"' Panggilan API
Akibatnya, kita akan menerima id dari pekerjaan yang dibuat.
{"jobId":"20230724-1154-m78f3gmlo5j"} Hasil
Untuk memeriksa log pekerjaan, kita dapat melakukan panggilan API ke
curl localhost:9888/api/v1/job/20230724-1154-m78f3gmlo5j/log Panggilan API
Dan hanya itu! Anda telah menulis dan menjalankan pekerjaan Python Spark sederhana di Ilum. Mari kita lihat contoh yang sedikit lebih canggih yang membutuhkan pustaka Python tambahan.
1.2 Contoh pekerjaan dengan numpy.
Di bagian ini, kita akan membahas contoh praktis dari pekerjaan Spark yang ditulis dalam Python. Pekerjaan ini melibatkan membaca himpunan data, memprosesnya, melatih model pembelajaran mesin di atasnya, dan menyimpan prediksi. Kita akan menggunakan Tel-churn.csv file, yang dapat Anda temukan di kami Repositori GitHub . Untuk mempermudahnya, kami telah mengunggah file ini ke bucket bernama ilum-files dalam instans build-in MinIO, yang dapat diakses secara otomatis dari instans Ilum. Ini berarti Anda tidak perlu khawatir tentang mengonfigurasi akses apa pun untuk contoh ini - Ilum telah membantunya. Namun, jika Anda ingin mengambil data dari bucket lain atau menggunakan Amazon S3 dalam proyek Anda sendiri, Anda harus mengonfigurasi aksesnya yang sesuai.
Sekarang setelah kita menyiapkan data kita, mari kita mulai menulis pekerjaan Spark kita dalam Python. Berikut adalah contoh kode lengkapnya:
dari pyspark.sql mengimpor SparkSession
dari pyspark.ml mengimpor Pipeline
dari pyspark.ml.feature impor StringIndexer, VectorAssembler
dari pyspark.ml.classification impor LogisticRegression
jika __name__ == "__main__":
percikan = SparkSession \
.pembangun\
.appName("IlumAdvancedPythonExample") \
.getOrCreate()
df = spark.read.csv('s3a://ilum-files/Tel-churn.csv', header=True, inferSchema=True)
categoricalColumns = ['gender', 'Mitra', 'Tanggungan', 'PhoneService', 'MultipleLines', 'InternetService',
'OnlineSecurity', 'OnlineBackup', 'DeviceProtection', 'TechSupport', 'StreamingTV',
'StreamingMovies', 'Kontrak', 'PaperlessBilling', 'PaymentMethod']
tahapan = []
untuk categoricalCol di categoricalColumns:
stringIndexer = StringIndexer(inputCol=categoricalCol, outputCol=categoricalCol + "Indeks")
stages += [stringIndexer]
label_stringIdx = StringIndexer(inputCol="Churn", outputCol="label")
tahapan += [label_stringIdx]
numericCols = ['Warga Senior', 'tenuri', 'Biaya Bulanan']
assemblerInputs = [c + "Indeks" untuk c di categoricalColumns] + numericCols
assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="fitur")
tahapan += [perakit]
pipeline = Pipeline(stages=stages)
pipelineModel = pipeline.fit(df)
df = pipelineModel.transform(df)
train, test = df.randomSplit([0.7, 0.3], seed=42)
lr = LogisticRegression(featuresCol="features", labelCol="label", maxIter=10)
lrModel = lr.fit(kereta)
prediksi = lrModel.transform(uji)
prediksi.pilih("customerID", "label", "prediksi").show(5)
predictions.select("customerID", "label", "prediction").write.option("header", "true") \
.csv('s3a://ilum-files/predictions')
percikan.berhenti() Mari selami kodenya:
dari pyspark.sql mengimpor SparkSession
dari pyspark.ml mengimpor Pipeline
dari pyspark.ml.feature impor StringIndexer, VectorAssembler
dari pyspark.ml.classification impor LogisticRegression Di sini, kita mengimpor modul PySpark yang diperlukan untuk membuat sesi Spark, membangun alur pembelajaran mesin, memproses data, dan menjalankan model Regresi Logistik.
percikan = SparkSession \
.pembangun\
.appName("IlumAdvancedPythonExample") \
.getOrCreate() Kami menginisialisasi Sesi Percikan , yang merupakan titik masuk ke fungsionalitas apa pun di Spark. Di sinilah kita mengatur nama aplikasi yang akan muncul di UI web Spark.
df = spark.read.csv('s3a://ilum-files/Tel-churn.csv', header=True, inferSchema=True) Kami sedang membaca file CSV yang disimpan di bucket minio. Si header=Benar memberi tahu Spark untuk menggunakan baris pertama file CSV sebagai header, sementara inferSchema=Benar membuat Spark secara otomatis menentukan jenis data setiap kolom.
categoricalColumns = ['gender', 'Mitra', 'Tanggungan', 'PhoneService', 'MultipleLines', 'InternetService',
'OnlineSecurity', 'OnlineBackup', 'DeviceProtection', 'TechSupport', 'StreamingTV',
'StreamingMovies', 'Kontrak', 'PaperlessBilling', 'PaymentMethod'] Kami menentukan kolom dalam data kami yang kategoris. Ini akan diubah nanti menggunakan StringIndexer.
tahapan = []
untuk categoricalCol di categoricalColumns:
stringIndexer = StringIndexer(inputCol=categoricalCol, outputCol=categoricalCol + "Indeks")
stages += [stringIndexer] Di sini, kami mengulangi daftar kolom kategoris kami dan membuat StringIndexer untuk masing-masing. StringIndexers mengkodekan kolom string kategoris ke dalam kolom indeks. Kolom indeks yang diubah akan diberi nama sebagai nama kolom asli yang ditambahkan dengan "Indeks".
numericCols = ['Warga Senior', 'tenuri', 'Biaya Bulanan']
assemblerInputs = [c + "Indeks" untuk c di categoricalColumns] + numericCols
assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="fitur")
tahapan += [perakit] Di sini kami menyiapkan data untuk model pembelajaran mesin kami. Kami membuat VectorAssembler yang akan mengambil semua kolom fitur kami (baik kategoris maupun numerik) dan merakitnya menjadi satu kolom vektor. Ini adalah persyaratan untuk sebagian besar algoritme pembelajaran mesin di Spark.
train, test = df.randomSplit([0.7, 0.3], seed=42) Kami membagi data kami menjadi set pelatihan dan set pengujian, dengan 70% data untuk pelatihan dan 30% sisanya untuk pengujian.
lr = LogisticRegression(featuresCol="features", labelCol="label", maxIter=10)
lrModel = lr.fit(kereta) Kami melatih model Regresi Logistik pada data pelatihan kami.
prediksi = lrModel.transform(uji)
prediksi.pilih("customerID", "label", "prediksi").show(5)
predictions.select("customerID", "label", "prediction").write.option("header", "true") \
.csv('s3a://ilum-files/predictions') Terakhir, kami menggunakan model terlatih kami untuk membuat prediksi pada set pengujian kami, menampilkan 5 prediksi pertama. Kemudian kita menulis prediksi ini kembali ke ember minio kita.
Simpan skrip ini sebagai ilum_python_advanced.py
pyspark.ml menggunakan numpy sebagai dependensi yang tidak diinstal sebagai default sehingga kita perlu menentukannya sebagai persyaratan.
Dan hal yang sama dapat dilakukan melalui API.
curl -X POST 'localhost:9888/api/v1/job/submit' \
--form 'name="IlumAdvancedPythonExample"' \
--form 'clusterName="default"' \
--form 'jobClass="ilum_python_advanced"' \
--form 'pyRequirements="numpy"' \
--form 'pyFiles=@"/path/to/ilum_python_advanced.py"' \
--form 'language="PYTHON"' Panggilan API
Di bagian berikutnya, kita akan mengubah kedua skrip Python menjadi interaktif Pekerjaan percikan, memanfaatkan sepenuhnya kemampuan Ilum.
Langkah 2: Transisi ke Mode Interaktif
Mode interaktif adalah fitur menarik yang membuat pengembangan Spark lebih dinamis, memberi Anda kemampuan untuk menjalankan, berinteraksi, dan mengontrol pekerjaan Spark Anda secara real time. Ini dirancang untuk mereka yang mencari kontrol yang lebih langsung atas aplikasi Spark mereka.
Pikirkan mode Interaktif sebagai melakukan percakapan langsung dengan pekerjaan Spark Anda. Anda dapat memasukkan data, meminta transformasi, dan mengambil hasilnya - semuanya secara real time. Ini secara drastis meningkatkan kelincahan dan kemampuan alur pemrosesan data Anda, membuatnya lebih mudah beradaptasi dan responsif terhadap perubahan persyaratan.
Sekarang setelah kita terbiasa dengan membuat pekerjaan Spark dasar di Python, mari kita melangkah lebih jauh dengan mengubah pekerjaan kita menjadi pekerjaan interaktif yang dapat memanfaatkan kemampuan real-time Ilum.
2.1 Contoh SparkPi.
Untuk mengilustrasikan cara mentransisikan pekerjaan kita ke mode Interaktif, kita akan menyesuaikan ilum_python_simple.py Script.
dari impor acak
dari operator impor tambahkan
dari ilum.api impor IlumJob
kelas SparkPiInteractiveExample(IlumJob):
def run(diri, percikan, konfigurasi):
partisi = int(config.get('partisi', '5'))
n = 100000 * partisi
def f(_: int) -> mengambang:
x = acak() * 2 - 1
y = acak() * 2 - 1
mengembalikan 1 jika x ** 2 + y ** 2 <= 1 lain 0
count = spark.sparkContext.parallelize(range(1, n + 1), partisi).map(f).reduce(add)
mengembalikan "Pi kira-kira %f" % (4.0 * hitungan / n) Simpan ini sebagai ilum_python_simple_interactive.py
Hanya ada beberapa perbedaan dari SparkPi asli.
1. Paket Ilum
Untuk memulai, kami mengimpor IlumJob dari paket ILUM, yang berfungsi sebagai kelas dasar untuk pekerjaan interaktif kami.
Logika pekerjaan Spark dienkapsulasi dalam kelas yang memperluas IlumJob , terutama di dalam lari Metode. Kita dapat menambahkan paket ilum dengan:
pip instal ilum 2. Pekerjaan percikan di kelas
Logika pekerjaan Spark dienkapsulasi dalam kelas yang memperluas IlumJob , terutama di dalam lari Metode.
kelas SparkPiInteractiveExample(IlumJob):
def run(diri, percikan, konfigurasi):
# Logika pekerjaan di sini Membungkus logika pekerjaan dalam kelas sangat penting bagi kerangka kerja Ilum untuk menangani pekerjaan dan sumber dayanya. Ini juga membuat pekerjaan tanpa kewarganegaraan dan dapat digunakan kembali.
3. Parameter ditangani secara berbeda:
Kami mengambil semua argumen dari kamus konfigurasi
partisi = int(config.get('partisi', '5')) Pergeseran ini memungkinkan penguasaan parameter yang lebih dinamis dan terintegrasi dengan penanganan konfigurasi Ilum.
4. Hasilnya dikembalikan, bukan dicetak:
Hasilnya dikembalikan dari lari Metode.
mengembalikan "Pi kira-kira %f" % (4.0 * hitungan / n) Dengan mengembalikan hasilnya, Ilum dapat menanganinya dengan cara yang lebih fleksibel. Misalnya, Ilum dapat membuat serial hasilnya dan membuatnya dapat diakses melalui panggilan API.
5. Tidak perlu mengelola sesi Spark secara manual
Ilum mengelola sesi Spark untuk kami. Ini secara otomatis disuntikkan ke dalam lari dan kita tidak perlu menghentikannya secara manual.
def run(diri, percikan, konfigurasi): Perubahan ini menyoroti transisi dari pekerjaan Spark mandiri ke pekerjaan Ilum interaktif. Tujuannya adalah untuk meningkatkan fleksibilitas dan penggunaan kembali pekerjaan, membuatnya lebih cocok untuk komputasi dinamis, interaktif, dan dengan cepat.
Menambahkan pekerjaan percikan interaktif ditangani dengan fungsi 'grup baru'.
Dan eksekusi dengan fungsi pekerjaan interaktif di UI.
Nama kelas harus ditentukan sebagai pythonFileName.PythonClassImplementingIlumJob
Kita dapat mencapai hal yang sama dengan API .
1. Membuat grup
curl -X POST 'localhost:9888/api/v1/group' \
--form 'name="SparkPiInteractiveExample"' \
--form 'kind="JOB"' \
--form 'clusterName="default"' \
--form 'pyFiles=@"/path/to/ilum_python_simple_interactive.py"' \
--form 'language="PYTHON"' Panggilan API
{"groupId":"20230726-1638-mjrw3"} Hasil
2. Eksekusi pekerjaan
curl -X POST 'localhost:9888/api/v1/group/20230726-1638-mjrw3/job/execute' \
-H 'Content-Type: application/json' \
-d '{ "jobClass":"ilum_python_simple_interactive. SparkPiInteractiveExample", "jobConfig": {"partitions":"10"}, "type":"interactive_job_execute"}' Panggilan API
{
"jobInstanceId":"20230726-1638-mjrw3-a1srahhu",
"jobId":"20230726-1638-mjrw3-wwt5a",
"groupId":"20230726-1638-mjrw3",
"startTime":1690390323154,
"endTime":1690390325200,
"jobClass":"ilum_python_simple_interactive. SparkPiInteractiveExample",
"jobConfig":{
"partisi":"10"
},
"result":"Pi kira-kira 3.149400",
"kesalahan":null
} Hasil
2.2 Contoh pekerjaan dengan numpy.
Mari kita lihat contoh kedua kita.
dari pyspark.sql mengimpor SparkSession
dari pyspark.ml mengimpor Pipeline
dari pyspark.ml.feature impor StringIndexer, VectorAssembler
dari pyspark.ml.classification impor LogisticRegression
dari ilum.api impor IlumJob
class LogisticRegressionJobExample(IlumJob):
def run(self, spark_session: SparkSession, config: dict) -> str:
df = spark_session.read.csv(config.get('inputFilePath', 's3a://ilum-files/Tel-churn.csv'), header=True,
inferSchema=True)
categoricalColumns = ['gender', 'Mitra', 'Tanggungan', 'PhoneService', 'MultipleLines', 'InternetService',
'OnlineSecurity', 'OnlineBackup', 'DeviceProtection', 'TechSupport', 'StreamingTV',
'StreamingMovies', 'Kontrak', 'PaperlessBilling', 'PaymentMethod']
tahapan = []
untuk categoricalCol di categoricalColumns:
stringIndexer = StringIndexer(inputCol=categoricalCol, outputCol=categoricalCol + "Indeks")
stages += [stringIndexer]
label_stringIdx = StringIndexer(inputCol="Churn", outputCol="label")
tahapan += [label_stringIdx]
numericCols = ['Warga Senior', 'tenuri', 'Biaya Bulanan']
assemblerInputs = [c + "Indeks" untuk c di categoricalColumns] + numericCols
assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="fitur")
tahapan += [perakit]
pipeline = Pipeline(stages=stages)
pipelineModel = pipeline.fit(df)
df = pipelineModel.transform(df)
train, test = df.randomSplit([float(config.get('splitX', '0.7')), float(config.get('splitY', '0.3'))],
seed=int(config.get('seed', '42')))
lr = LogisticRegression(featuresCol="features", labelCol="label", maxIter=int(config.get('maxIter', '5')))
lrModel = lr.fit(kereta)
prediksi = lrModel.transform(uji)
mengembalikan '{}'.format(prediksi.select("customerID", "label", "prediksi").limit(
int(config.get('rowLimit', '5'))).toJSON().collect()) 1. Kami membungkus pekerjaan dalam kelas, seperti pada contoh sebelumnya:
class LogisticRegressionJobExample(IlumJob):
def run(self, spark_session: SparkSession, config: dict) -> str:
# Logika pekerjaan di sini Sekali lagi, logika pekerjaan dienkapsulasi dalam lari metode perpanjangan kelas IlumJob , membantu Ilum menangani pekerjaan secara efisien.
2. Semua parameter, termasuk untuk alur data (seperti jalur file dan hiperparameter Regresi Logistik), diperoleh dari konfigurasi kamus:
df = spark_session.read.csv(config.get('inputFilePath', 's3a://ilum-files/Tel-churn.csv'), header=True, inferSchema=True)
train, test = df.randomSplit([float(config.get('splitX', '0.7')), float(config.get('splitY', '0.3'))], seed=int(config.get('seed', '42')))
lr = LogisticRegression(featuresCol="features", labelCol="label", maxIter=int(config.get('maxIter', '5'))) Dengan memusatkan semua parameter di satu tempat, Ilum menyediakan cara yang seragam dan konsisten untuk mengonfigurasi dan menyetel pekerjaan.
Hasil pekerjaan, alih-alih ditulis ke lokasi tertentu, dikembalikan sebagai string JSON:
mengembalikan '{}'.format(prediksi.select("customerID", "label", "prediksi").limit(int(config.get('rowLimit', '5'))).toJSON().collect()) Hal ini memungkinkan penanganan hasil pekerjaan yang lebih dinamis dan fleksibel, yang kemudian dapat diproses lebih lanjut atau diekspos melalui API, tergantung pada kebutuhan aplikasi.
Kode ini dengan sempurna menunjukkan bagaimana kami dapat mengintegrasikan pekerjaan PySpark dengan Ilum dengan mulus untuk memungkinkan alur pemrosesan data berbasis API yang interaktif. Dari contoh sederhana seperti perkiraan Pi hingga kasus yang lebih kompleks seperti Regresi Logistik, pekerjaan interaktif Ilum serbaguna, mudah beradaptasi, dan efisien.
Langkah 3: Menjadikan Pekerjaan Spark Anda sebagai Layanan Mikro
Layanan mikro membawa perubahan paradigma dari struktur aplikasi monolitik tradisional ke pendekatan yang lebih modular dan gesit. Dengan memecah aplikasi yang kompleks menjadi layanan kecil yang digabungkan secara longgar, menjadi lebih mudah untuk membangun, memelihara, dan menskalakan setiap layanan secara independen berdasarkan persyaratan tertentu. Saat diterapkan ke pekerjaan Spark kami, ini berarti kami dapat membuat layanan pemrosesan data yang kuat yang dapat diskalakan, dikelola, dan diperbarui tanpa memengaruhi bagian lain dari tumpukan aplikasi kami.
Kekuatan mengubah pekerjaan Spark Anda menjadi layanan mikro terletak pada keserbagunaan, skalabilitas, dan kemampuan interaksi real-time. Layanan mikro adalah komponen aplikasi yang dapat disebarkan secara independen yang berjalan sebagai proses terpisah. Ini berkomunikasi dengan komponen lain melalui API yang terdefinisi dengan baik, memberi Anda kebebasan untuk merancang, mengembangkan, menerapkan, dan menskalakan setiap layanan mikro secara independen.
Dalam konteks Ilum, pekerjaan Spark interaktif dapat diperlakukan sebagai layanan mikro. Metode 'run' pekerjaan bertindak sebagai titik akhir API. Setiap kali Anda memanggil metode ini melalui API Ilum, Anda membuat permintaan ke layanan mikro ini. Ini membuka potensi interaksi real-time dengan pekerjaan Spark Anda.
Anda dapat membuat permintaan ke layanan mikro dari berbagai aplikasi atau skrip, mengambil data, dan memproses hasil dengan cepat. Selain itu, ini membuka peluang untuk membangun arsitektur yang lebih kompleks dan berorientasi layanan di sekitar alur pemrosesan data Anda.
Salah satu keuntungan utama dari pengaturan ini adalah skalabilitas. Melalui UI atau API Ilum, Anda dapat menaikkan atau menurunkan skala pekerjaan Anda (layanan mikro) berdasarkan beban atau kompleksitas komputasi. Anda tidak perlu khawatir tentang pengelolaan sumber daya secara manual atau penyeimbangan beban. Penyeimbang beban internal Ilum akan mendistribusikan panggilan API antar instans pekerjaan Spark Anda, memastikan pemanfaatan sumber daya yang efisien.
Perlu diingat bahwa waktu pemrosesan aktual pekerjaan bergantung pada kompleksitas pekerjaan Spark dan sumber daya yang dialokasikan untuknya. Namun, dengan skalabilitas yang disediakan oleh Kubernetes, Anda dapat dengan mudah meningkatkan sumber daya seiring berkembangnya kebutuhan pekerjaan Anda.
Kombinasi Ilum, Apache Spark, dan layanan mikro ini menghadirkan cara baru yang gesit untuk memproses data Anda - secara efisien, terukur, dan responsif!
Pengubah Permainan dalam Arsitektur Layanan Mikro Data
Kami telah menempuh perjalanan panjang sejak kami memulai perjalanan mengubah pekerjaan Python Apache Spark sederhana menjadi layanan mikro lengkap menggunakan Ilum. Kami melihat betapa mudahnya menulis pekerjaan Spark, menyesuaikannya untuk bekerja dalam mode interaktif, dan pada akhirnya mengeksposnya sebagai layanan mikro dengan bantuan API Ilum yang kuat. Sepanjang jalan, kami memanfaatkan kekuatan Python, kemampuan Apache Spark, serta fleksibilitas serta skalabilitas Ilum. Kombinasi ini tidak hanya mengubah kemampuan pemrosesan data kami, tetapi juga mengubah cara kami berpikir tentang arsitektur data.
Perjalanan tidak berhenti di sini. Dengan dukungan penuh Python di Ilum, dunia kemungkinan baru terbuka untuk pemrosesan dan analitik data. Saat kami terus membangun dan meningkatkan Ilum, kami sangat senang dengan kemungkinan masa depan yang dibawa Python ke platform kami. Kami percaya bahwa dengan Python dan Ilum bersama-sama, kami baru di awal mendefinisikan ulang apa yang mungkin terjadi di dunia arsitektur layanan mikro data.
Bergabunglah dengan kami dalam perjalanan yang mengasyikkan ini, dan mari kita bentuk masa depan pemrosesan data bersama!