<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Debi Aprilia on Medium]]></title>
        <description><![CDATA[Stories by Debi Aprilia on Medium]]></description>
        <link>https://medium.com/@debi.aprilia?source=rss-c81725c91e44------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*EAUswnDoIBnAaiBRPiD8RQ.jpeg</url>
            <title>Stories by Debi Aprilia on Medium</title>
            <link>https://medium.com/@debi.aprilia?source=rss-c81725c91e44------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 21:22:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@debi.aprilia/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Machine Learning dengan Spark MLlib : Feature Engineering & Regresi — Praktikum Big Data]]></title>
            <link>https://medium.com/@debi.aprilia/machine-learning-dengan-spark-mllib-feature-engineering-regresi-praktikum-big-data-bae1da9b6a2a?source=rss-c81725c91e44------2</link>
            <guid isPermaLink="false">https://medium.com/p/bae1da9b6a2a</guid>
            <category><![CDATA[apache-spark]]></category>
            <category><![CDATA[spark-mllib]]></category>
            <category><![CDATA[feature-engineering]]></category>
            <category><![CDATA[linear-regression]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Debi Aprilia]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 14:45:01 GMT</pubDate>
            <atom:updated>2026-11-18T14:45:01.549Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RlogFjd5y79W8Ma-3RgQCA.jpeg" /></figure><p><strong>Machine Learning</strong> merupakan sebuah teknologi yang memungkinkan komputer mempelajari pola dari data untuk membuat prediksi.<strong> Scikit-learn</strong> merupakan pustaka <em>machine learning</em> berbasis Python yang bersifat <em>open-source, </em>yang dibangun di atas NumPy, SciPy, dan Matplotlib. Library ini menyediakan algoritma supervised dan unsupervised learning, serta alat untuk preprocessing, pemilihan model, dan evaluasi. Library ini memiliki kelebihan yaitu API yang konsisten, kemudahan integrasi dengan library Python lain, serta dokumentasi yang lengkap. Sedangkan kekurangan library ini adalah kurang efisien untuk dataset sangat besar, tidak cocok untuk deep learning, serta hanya sangat baik digunakan untuk dataset yang muat dalam memori (RAM) satu komputer.</p><p><strong>Spark MLlib</strong> merupakan pustaka machine learning skala besar yang dibangun di atas Apache Spark, menyediakan algoritma Machine Learning, utilitas preprocessing, pipeline, dan evaluasi untuk data besar. Library ini memiliki kelebihan yaitu memiliki skalabilitas dan performa yang tinggi untuk memproses data besar, memiliki algoritma yang banyak, memiliki fitur pipeline Machine Learning lengkap, serta mendukung berbagai sumber data Hadoop ecosystem. Sedangkan kekurangan library ini adalah kurang fleksibel dalam fleksibilitas fitur dan integrasi dengan deep learning, tidak selalu optimal untuk data kecil, serta dokumentasi dan contoh kode kurang intuitif untuk pengguna baru.</p><p>Perbedaan <strong>Scikit-learn</strong> dan <strong>Spark MLlib</strong> adalah jika Scikit-learn biasanya digunakan ketika dataset masih dapat ditampung dalam RAM satu komputer, sedangkan Spark MLlib dirancang untuk memproses data dalam skala besar menggunakan beberapa komputer atau node.</p><h4>Persiapan SparkSession dan Dataset</h4><p>Untuk melakukan pengolahan data dan Machine Learning dengan Spark MLlib, hubungkan terlebih dahulu program Python dengan Apache Spark. Blok kode berikut selain digunakan untuk menghubungkan ke Spark, juga digunakan untuk mengatur jumlah partisi ketika Spark melakukan operasi shuffle pada baris (“spark.sql.shuffle.partitions”, “4”).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*o3OzbmmqVNV04r7NFhhBOw.png" /></figure><p>Kemudian untuk melatih model Machine Learning, buat dataset buatan yang bersisi 2.000 baris dataset (n = 2000), dengan mengunci nilai angka acak (42) agar angka acak tetap konsisten ketika kode dijalankan ulang, membuat daftar kategori dan kota, serta mengubah menjadi DataFrame Spark.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/784/1*1W41LSq9kLq0e9Co9VT2qw.png" /></figure><h4>Feature Engineering : Menyiapkan Data untuk MLlib</h4><p>Feature Engineering merupakan proses menyiapkan dan mengubah data agar dapat digunakan oleh algortima Machine Learning.</p><ul><li><strong>StringIndexer — Mengubah Data Kategori Berbentuk Teks Menjadi Angka</strong></li></ul><p>Kode program berikut digunakan untuk mengubah kolom kategori yang berisi teks menjadi angka agar bisa diproses oleh algoritma Machine Learning. StringIndexer diperlukan untuk mengubah teks seperti <strong>Elektronik</strong> atau <strong>Magelang</strong> diubah menjadi indeks angka. Angka hasil StringIndexer menunjukkan kode kategori, bukan untuk menentukan kategori tersebut lebih besar atau lebih baik dari kategori yang lain.</p><p>→ <strong><em>inputCol=“kategori”</em></strong> : merupakan kolom sumber yang akan diubah.</p><p>→ <strong><em>outputCol=“kategori_idx”</em></strong> : merupakan nama kolom baru yang berisi hasil pengubahan.</p><p>→ <strong><em>indexer_kategori</em></strong> dan <strong><em>indexer_kota </em></strong>: variabel yang menyimpan konfigurasi StringIndexer. Dibuat menjadi dua variabel karena kategori dan kota merupakan dua atribut yang berbeda.</p><p>→ <strong><em>fit() </em></strong>: fungsi yang digunakan untuk mempelajari data dan menghasilkan model atau pemetaan.</p><p>→ <strong><em>transform()</em></strong> : fungsi yang digunakan untuk menerapkan hasil pembelajaran pada DataFrame.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/896/1*5sLkwHKOhQCr8861MoZhrg.png" /></figure><ul><li><strong>VectorAssembler — Menggabungkan Beberapa Kolom Menjadi Satu Kolom Fitur Berbentuk Vector</strong></li></ul><p>Kode program di bawah digunakan untuk menggabungkan lima kolom fitur menjadi satu kolom bernama <strong>features</strong>. VectorAssembler merupakan fitur Spark MLlib yang digunakan untuk menggabungkan beberapa kolom menjadi satu kolom Vector agar model dapat membaca seluruh atribut sebagai satu kumpulan fitur.</p><p>→ <strong><em>inputCols</em></strong> : untuk menentukan kolom yang akan digabungkan.</p><p>→ <strong><em>outputCol</em></strong> : untuk menentukan nama kolom hasil penggabungan, yaitu <strong>features</strong>.</p><p>→ <strong><em>df_final = assembler.transform(df_indexed)</em></strong> : untuk menerapkan VectorAssembler pada DataFrame <strong>df_indexed</strong> menggunakan fungsi <strong>transform()</strong> yang menggabungkan lima kolom menjadi satu kolom Vector, kemudian menyimpan hasilnya pada variabel <strong>df_final</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/893/1*u7hQ8A3L9B-QK8Lb7YhRRQ.png" /></figure><h4>Melatih Model Regresi Linear</h4><ul><li><strong>Membagi Data : Training vs Testing</strong></li></ul><p>Dataset akan dibagi atau dipisahkan menjadi data pelatihan dan data pengujian menggunakan fungsi <strong>randomSplit()</strong> untuk membagi data menjadi<strong> 80%</strong> untuk <strong>data training</strong> dan <strong>20%</strong> untuk <strong>data testing</strong>. Data harus dibagi menjadi dua bagian karena untuk menguji model harus menggunakan data yang tidak digunakan saat proses pelatihan. Jika model diuji menggunakan data yang sama dengan data pelatihan, maka hasilnya tidak akan akurat.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/895/1*R7514wffsnbFqpwqbGmzDQ.png" /></figure><ul><li><strong>Melatih Model Linear Regression</strong></li></ul><p>Kode program berikut digunakan untuk melatih model Machine Learning untuk memprediksi pendapatan transaksi menggunakan algoritma Linear Regression. <strong>Linear Regression</strong> merupakan algoritma regresi linear yang digunakan untuk memprediksi nilai numerik.</p><p>→ <strong><em>featuresCol=“features”</em></strong> : untuk menentukan kolom yang berisi fitur input.</p><p>→ <strong><em>labelCol=“pendapatan”</em></strong> : untuk menentukan kolom target yang ingin diprediksi.</p><p>→ <strong><em>model = lr.fit(train)</em></strong> : untuk melatih model menggunakan dataset training, kemudian menyimpan hasilnya pada variabel <strong>model</strong>. Proses yang terjadi adalah spark membaca fitur pada data training, kemudian spark membaca nilai target pendapatan, kemudian algoritma mempelajari hubungan antara fitur dan target, kemudian spark menghasilkan model yang telah dilatih.</p><p>→ Variabel <strong>lr</strong> menyimpan konfigurasi algoritma yang belum dilatih, sedangkan variabel <strong>model</strong> digunakan untuk menyimpan algoritma yang sudah dilatih.</p><p>→ Output <strong>koefisien</strong> menunjukkan perubahan prediksi ketika suatu fitur berubah satu unit, dengan menganggap fitur lain tetap. Tetapi nilai koefisien tidak bisa langsung dibandingkan tanpa mempertimbangkan skalanya, karena skala setiap fitur berbeda. Kemudian<strong> intercept</strong> menunjukkan nilai prediksi ketika seluruh fitur bernilai nol.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/895/1*VB6GtYVHMAC5z_1lfdNKzg.png" /></figure><ul><li><strong>Membuat Prediksi</strong></li></ul><p>Kode program berikut digunakan untuk memprediksi pendapatan pada data testing menggunakan model yang sudah dilatih. Fungsi <strong>transform()</strong> akan menghasilkan DataFrame baru yang berisi hasil prediksi. Hasilnya, semakin kecil selisih nilai <strong>pendapatan</strong> dan <strong>prediction</strong>, semakin dekat prediksi dengan kenyataannya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/897/1*-javvKo_bEj-T-WiVogqLA.png" /></figure><h4>Evaluasi Model Regresi</h4><p>Kode program berikut digunakan untuk mengetahui seberapa baik model dalam memprediksi pendapatan. <strong>RegressionEvaluator</strong> digunakan untuk menghitung metrik evaluasi untuk model regresi. <strong>RMSE (<em>Root Mean Squared Error</em>)</strong> digunakan untuk mengukur besar kesalahan prediksi dengan memberikan penalti lebih besar pada kesalahan yang besar. Semakin kecil nilai RMSE, semakin baik prediksi model. Sedangkan, <strong>R — squared</strong> digunakan untuk mengukur seberapa besar variasi nilai target yang dapat dijelaskan oleh model.<strong> R²</strong> dapat bernilai <strong>1</strong> yang artinya prediksi sempurna, bernilai <strong>0</strong> yang artinya tidak lebih baik daripada menggunakan rata — rata target sebagai prediksi, serta bernilai <strong>negatif</strong> yang artinya performa model lebih buruk daripada baseline rata — rata tersebut.</p><p>Outputnya akan menampilkan nilai RMSE, dengan perintah <strong><em>print(f“RMSE : Rp {rmse:,.0f}”)</em></strong> yang akan menampilkan angka dengan pemisah ribuan dan tanpa angka desimal dari hasil perhitungan yang disimpan pada variabel <strong>rmse</strong>. Serta menampilkan nilai R², dengan perintah <strong><em>print(f“R² : {r2:.4f} ({r2*100:.1f}% variasi data…)”) </em></strong>yang menampilkan empat angka dibelakang koma, kemudian mengubah R² menjadi persentase dan menampilkan satu angka desimal. Model ini mampu menjelaskan 89.5% variasi pada pendapatan</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/897/1*Vlu_P2tKuAtF33g98Hx7FQ.png" /></figure><p>Nilai RMSE dan R² digunakan bersama — sama untuk mengetahui seberapa besar kesalahan prediksi dan seberapa baik model menjelaskan pola data.</p><h4>Menutup SparkSession</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/897/1*D3KOfSJ751rvX-Lj2PeB-g.png" /></figure><h4>Latihan Mandiri</h4><p>Sebelum mengerjakan soal latihan, aktifkan kembali spark dan pembuatan dataset pada sub — bab 11.2.</p><pre># Persiapan ulang untuk latihan<br>spark = SparkSession.builder.appName(&quot;Latihan11&quot;).master(&quot;local[*]&quot;).getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br>spark.conf.set(&quot;spark.sql.shuffle.partitions&quot;, &quot;4&quot;)<br><br>df = spark.createDataFrame(data)<br>print(&quot;Siap untuk latihan. Total baris:&quot;, df.count())</pre><p><strong>Soal 1.</strong> Ulangi proses StringIndexer untuk kolom kategori dan kota, lalu buat VectorAssembler <strong>baru</strong> yang HANYA menggunakan tiga fitur: unit_terjual, harga_satuan, dan rating (tanpa kategori_idx/kota_idx). Beri nama kolom hasil features_sederhana.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/898/1*Vc8wbnsActYwzmDwM9-gRg.png" /></figure><p><strong>Soal 2.</strong> Latih model LinearRegression baru menggunakan features_sederhana dari Soal 1 (gunakan train/test split yang sama, seed=42). Bandingkan nilai <strong>R²</strong> model ini dengan model utama pada Sub-bab 11.4 yang menggunakan 5 fitur — apakah performanya lebih baik, sama, atau lebih buruk?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/894/1*8h2Sy6pylGL7D7LJD_zXQA.png" /></figure><p>Keterangan : Hasilnya menunjukkan R²<strong> </strong>model utama dan R² model sederhana memiliki nilai yang hampir sama. Berarti performa antara dua model ini adalah sama.</p><p><strong>Soal 3.</strong> Menggunakan model utama (5 fitur) dari Sub-bab 11.4, tampilkan <strong>5 baris prediksi dengan selisih (</strong><strong>pendapatan - prediction) terbesar</strong> — yaitu prediksi yang paling meleset. (Petunjuk: tambahkan kolom baru berisi nilai absolut selisihnya, lalu urutkan.)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/897/1*5rE0u64l6ARMB5qOo1dE_w.png" /></figure><p><strong>Soal 4 (Refleksi singkat).</strong> Dalam 2–3 kalimat: mengapa Spark MLlib mewajibkan kita menggabungkan seluruh fitur menjadi satu kolom Vector (melalui VectorAssembler), bukan menerima banyak kolom terpisah seperti kebiasaan di pandas/scikit-learn?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/870/1*nxihtP3BsagCFJ4CIDFVmg.png" /></figure><h4>Tugas Mandiri</h4><p>Tugas Mandiri dapat di akses pada link GitHub berikut :</p><p><a href="https://github.com/DebiAprilia/bigdata2026/blob/main/Tugas11_2320506038_DebiAprilia.ipynb">bigdata2026/Tugas11_2320506038_DebiAprilia.ipynb at main · DebiAprilia/bigdata2026</a></p><h4>Kesimpulan</h4><p>Proses model Machine Learning dilatih menggunakan Apache Spark MLlib yang sudah dipelajari dimulai dari membuat dataset, mengubah data kategorikal menjadi numerik menggunakan StringIndexer, menggabungkan fitur menggunakan VectorAssembler, membagi data testing dan data training, serta melatih model regresi linear. Kemudian, data dilakukan prediksi menggunakan data testing dan evaluasi RMSE dan R². Proses tersebut dapat digunakann untuk memproses data dan membangun model prediksi yang dirancang untuk pengolahan data besar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bae1da9b6a2a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pemrosesan Data Streaming dengan Spark Structured Streaming — Praktikum Big Data]]></title>
            <link>https://medium.com/@debi.aprilia/pemrosesan-data-streaming-dengan-spark-structured-streaming-praktikum-big-data-58a1269d6f3f?source=rss-c81725c91e44------2</link>
            <guid isPermaLink="false">https://medium.com/p/58a1269d6f3f</guid>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[data-streaming]]></category>
            <category><![CDATA[apache-spark]]></category>
            <dc:creator><![CDATA[Debi Aprilia]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 16:37:52 GMT</pubDate>
            <atom:updated>2026-11-09T16:37:52.172Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AWkpoU82SWcoyu3oWrF7Iw.jpeg" /></figure><p>Dalam Big Data, terdapat dua pendekatan utama untuk memproses sekumpulan data berdasarkan sifat kedatangannya, yaitu pemrosesan <em>batch</em> dan <em>streaming</em>. Pemrosesan <strong>Batch</strong> merupakan pendekatan yang digunakan untuk mengolah data statis yaitu data yang sudah lengkap dan sepenuhnya tersimpan (misalnya file CSV, HDFS, atau MongoDB) sebelum data diolah. Pemrosesan ini dilakukan secara terjadwal atau berkala karena menunggu data terkumpul, contohnya untuk mencetak laporan penjualan setiap bulan.</p><p>Pemrosesan <strong>Streaming</strong> merupakan pendekatan yang digunakan untuk menangani data mengalir tanpa henti di dunia nyata, contohnya data transaksi <em>e-commerce</em> per detik, data sensor IoT, log aktivitas aplikasi, atau aliran data media sosial. Sistem tidak menunggu data ‘selesai’ atau lengkap. tapi akan diproses secara inkremental dan sesegera mungkin setelah data tiba atau mendekati waktu nyata (<em>near real time</em>). Contoh penerapannya adalah pada sistem deteksi penipuan (<em>fraud</em>) pada transaksi secara langsung.</p><p>Spark Structured Streaming merupakan sebuah mesin pemrosesan di mana sistem secara otomatis menerjemahkan aliran data menjadi serangkaian pemrosesan <em>micro-batch </em>(sekumpulan batch berukuran kecil yang diproses secara berulang setiap beberapa saat). Ada 4 komponen untuk membangun sebuah <em>streaming query</em> pada spark :</p><ul><li><strong>Input Source</strong> (Sumber Masukan) : merupakan titik awal dari mana aliran data berasal dan dibaca, yang diinisialisasi menggunakan perintah ‘readStream’.</li><li><strong>Trigger</strong> (Pemicu) : merupakan penanda atau penentu interval waktu yang memberi tahu Spark kapan harus mengeksekusi sekumpulan data baru menjadi proses micro-batch secara berulang.</li><li><strong>Output Sink</strong> (Tujuan Keluaran) : merupakan lokasi atau media akhir dimana hasil dari data yang telah diproses (streaming query) akan ditulis dan disimpan, yangg didefinisikan melalui perintah writeStream.</li><li><strong>Output Mode</strong> (Mode Keluaran) : menentukan perilaku atau cara bagaimana hasil pemrosesan tersebut dituliskan ke dalam sink setiap kali trigger berjalan.</li></ul><h4>Persiapan : SparkSession dan Folder Simulasi Streaming</h4><p>Sebelum memulai simulasi streaming, buat sesi spark terlebih dahulu. Kemudian perintah ‘spark.conf.set(…)’ digunakan untuk menurunkan jumlah partisi menjadi 4 agar pemrosesannya lebih cepat dan efisien. Jumlah partisi harus dikurangi karena secara default, Spark akan membuat 200 partisi. Jika pada data simulasi yang kecil, angka 200 terlalu besar dan akan membuat proses lambat.</p><pre>from pyspark.sql import SparkSession<br>from pyspark.sql.types import StructType, StructField, StringType, IntegerType, TimestampType<br>from pyspark.sql.functions import window, sum as spark_sum, count, avg, col<br>import os<br>import shutil<br>import time<br>import pandas as pd<br><br>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan10-StructuredStreaming&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br># Mengurangi jumlah partisi shuffle default (200) agar pemrosesan pada VM/laptop kita lebih cepat<br># -- semakin kecil dataset (seperti simulasi kita), semakin tidak perlu partisi sebanyak itu<br>spark.conf.set(&quot;spark.sql.shuffle.partitions&quot;, &quot;4&quot;)<br><br>print(&quot;SparkSession siap. Versi Spark:&quot;, spark.version)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*2UADbiIfouIvIDKzaGM2RQ.png" /></figure><p>Perintah berikut digunakan untuk menghapus folder lama (jika ada) dan membuat folder kosong baru bernama ‘<strong>simulasi_stream_transaksi</strong>’. Folder ini bertindak sebagai sumber data (<em>input source</em>), jadi setiap kali aada berkas baru yang diletakkan di sini, Spark akan menganggap sebagai “aliran data baru” yang harus diproses.</p><pre># Menyiapkan folder kosong yang akan berperan sebagai &quot;sumber data streaming&quot;<br>folder_stream = &quot;simulasi_stream_transaksi&quot;<br>folder_checkpoint = &quot;checkpoint_pertemuan10&quot;<br><br>shutil.rmtree(folder_stream, ignore_errors=True)<br>shutil.rmtree(folder_checkpoint, ignore_errors=True)<br>os.makedirs(folder_stream, exist_ok=True)<br><br>print(f&quot;Folder simulasi streaming &#39;{folder_stream}&#39; siap (kosong).&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/483/1*M3nSAoZ3q1M-XlqFVMmJGA.png" /></figure><p>Perintah berikut digunakan untuk mendefinisikan nama dan tipe data untuk setiap kolom secara manual sebelum dibaca. Pada pemrosesan batch, kita bisa menggunakan ‘inferSchema=True’ agar Spark menebak tipe data secara otomatis. Namun, pada Structured Streaming, penebakan otomatis tidak diizinkan. Spark tidak bias menunggu semua data terkumpul untuk menebak tipe datanya karena <em>data streaming</em> tidak pernah selesai dan terus mengalir. Sehingga, skema <strong>wajib</strong> didefinisikan secara eksplisit di awal.</p><pre># Mendefinisikan skema secara eksplisit — wajib untuk streaming source berbasis berkas<br>skema_transaksi = StructType([<br>    StructField(&quot;trx_id&quot;, StringType(), True),<br>    StructField(&quot;kota&quot;, StringType(), True),<br>    StructField(&quot;kategori&quot;, StringType(), True),<br>    StructField(&quot;pendapatan&quot;, IntegerType(), True),<br>])<br><br>print(&quot;Skema berhasil didefinisikan:&quot;)<br>print(skema_transaksi)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*5D-IDjHBhuA7yawPRsuAGA.png" /></figure><h4>Membangun Streaming Query Pertama</h4><p><strong>Tahap 1 : Mendefinisikan Input Source (readStream)</strong></p><p>Perintah berikut digunakan untuk membaca data secara berkesinambungan dari folder yang ditentukan. Berbeda dengan ‘spark.read’ pada proses batch, ‘readStream’ membuat status DataFrame menjadi <em>streaming</em> (‘df_stream.isStreaming’ bernilai True). Eksekusi ini bersifat <em>lazy</em> (hanya rencana), pemrosesan data belum benar — benar berjalan pada tahap ini.</p><pre>df_stream = spark.readStream \<br>    .format(&quot;csv&quot;) \<br>    .schema(skema_transaksi) \<br>    .option(&quot;header&quot;, True) \<br>    .load(folder_stream)<br><br>print(&quot;Streaming DataFrame berhasil didefinisikan (belum berjalan — baru &#39;rencana&#39;).&quot;)<br>print(&quot;df_stream.isStreaming:&quot;, df_stream.isStreaming)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/553/1*hlEBIPqI1WQ9F19Tux7PTA.png" /></figure><p><strong>Tahap 2 : Mendefinisikan Transformasi (Sama Persis Seperti DataFrame Biasa)</strong></p><p>Langkah ini digunakan untuk mengelompokkan data berdasarkan kota dan menghitung total pendapatan serta jumlah transaksi. Sintaks berikut memang dibuat identik dengan pemrosesan DataFrame batch biasa. Tujuannya adalah untuk menerapkan logika yang sama tanpa harus mempelajari sintaks baru khusus untuk <em>streaming</em>.</p><pre># Melakukan agregasi — sintaks IDENTIK dengan groupBy/agg pada DataFrame batch (Pertemuan 4-5)<br>agregasi_stream = df_stream.groupBy(&quot;kota&quot;).agg(<br>    spark_sum(&quot;pendapatan&quot;).alias(&quot;total_pendapatan&quot;),<br>    count(&quot;trx_id&quot;).alias(&quot;jumlah_transaksi&quot;)<br>)<br><br>print(&quot;Transformasi berhasil didefinisikan.&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/261/1*m2_3SuAKbViHTxssFotwPQ.png" /></figure><p><strong>Tahap 3 : Mendefinisikan Output Sink (writeStream) dan Memulai Query</strong></p><p>Tahap ini berisi perintah untuk menentukan kemana hasil agregasi dibuang (<em>sink</em>) dan menjalankan proses <em>streaming</em> secara aktual. Menggunakan mode ‘format(“memory”)’ untuk menyimpan hasil sementara ke dalam RAM sebagai tabel agar mudah dicek menggunakan ‘spark.sql()’ selama tahap belajar dan debugging. Mode ‘outputMode(“complete”)’ untuk menginstrusikan Spark agar menulis dan menampilkan ulang seluruh tabel hasil agregasi setiap kali ada data baru yang masuk, untuk memastikan total akumulasi perhitungan terbaru.</p><pre>query = agregasi_stream.writeStream \<br>    .outputMode(&quot;complete&quot;) \<br>    .format(&quot;memory&quot;) \<br>    .queryName(&quot;hasil_agregasi&quot;) \<br>    .start()<br><br>print(&quot;Streaming query dimulai! Status:&quot;, query.status)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/982/1*jK5Q-AxGteUHU9eDqk_bdA.png" /></figure><p><strong>Tahap 4 : Mengalirkan “Data Baru” dan Mengamati Hasilnya</strong></p><p>Tahap ini merupakan simulasi datangnya <em>micro-batch</em> data baru dengan membuat file CSV menggunakan fungsi Pandas. Proses penulisan file CSV dan proses pembacaan agregasi data oleh Spark Streaming berjalan secara asinkron. Sehingga membutuhkan fungsi ‘time.sleep(6)’ untuk memberi jeda selama 6 detik agar Spark memiliki waktu untuk memproses data <em>micro-batch</em> pertama yang baru saja dikirim ke folder stream. Jika tidak ada jeda, kode evaluasi ‘spark.sql()’ akan langsung dieksekusi sebelum Spark selesai mendeteksi, membaca, dan memperhitungkan data baru tersebut ke dalam table agregasi.</p><pre># Batch data pertama &quot;tiba&quot;<br>pd.DataFrame({<br>    &quot;trx_id&quot;: [&quot;T1&quot;, &quot;T2&quot;, &quot;T3&quot;],<br>    &quot;kota&quot;: [&quot;Magelang&quot;, &quot;Solo&quot;, &quot;Magelang&quot;],<br>    &quot;kategori&quot;: [&quot;Elektronik&quot;, &quot;Fashion&quot;, &quot;Makanan&quot;],<br>    &quot;pendapatan&quot;: [150000, 200000, 75000],<br>}).to_csv(f&quot;{folder_stream}/batch_1.csv&quot;, index=False)<br><br>print(&quot;Batch 1 dikirim. Menunggu Spark memproses...&quot;)<br>time.sleep(6)  # memberi waktu Spark memproses micro-batch (proses pertama kali butuh waktu ekstra)<br><br>spark.sql(&quot;SELECT * FROM hasil_agregasi ORDER BY total_pendapatan DESC&quot;).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*I3G1wYMuX3BBLni3yaG7DA.png" /></figure><p>Ketika batch kedua datang, hasilnya merupakan gabungan kumulatif antara Batch 1 dan Batch 2. Output pada Batch 1 hanya muncul header kolom tanpa ada nilai di dalamnya karena jeda 6 detik masih kurang cukup untuk menyelesaikan dan memproses data Batch 1. Pada Batch 2, mesin streaming sudah berjalan stabil dan siap, sehingga waktu jeda 6 detik cukup untuk memproses data baru dan mengakumulasikannya.</p><pre># Batch data kedua &quot;tiba&quot; beberapa saat kemudian<br>pd.DataFrame({<br>    &quot;trx_id&quot;: [&quot;T4&quot;, &quot;T5&quot;],<br>    &quot;kota&quot;: [&quot;Magelang&quot;, &quot;Yogyakarta&quot;],<br>    &quot;kategori&quot;: [&quot;Fashion&quot;, &quot;Elektronik&quot;],<br>    &quot;pendapatan&quot;: [300000, 500000],<br>}).to_csv(f&quot;{folder_stream}/batch_2.csv&quot;, index=False)<br><br>print(&quot;Batch 2 dikirim. Menunggu Spark memproses...&quot;)<br>time.sleep(6)<br><br>spark.sql(&quot;SELECT * FROM hasil_agregasi ORDER BY total_pendapatan DESC&quot;).show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/993/1*KYb08JUOlKxfD_tdbTe8MA.png" /></figure><p><strong>Tahap 5 : Menghentikan Streaming Query</strong></p><p>Perintah berikut wajib dijalankan agar proses streaming berhenti karena proses streming dirancangg untuk hidup tanpa henti (<em>infinite</em>). Jika tidak dihentikan, proses tersebut akan tetap berjalan di latar belakang dan memakan sumber daya.</p><pre>query.stop()<br>print(&quot;Streaming query dihentikan. Status aktif:&quot;, query.isActive)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/342/1*NzE8w20q1AQuPHP6lvua-Q.png" /></figure><h4>Agregasi Berbasis Window Waktu</h4><p>Spark <em>Structured Streaming</em> memiliki konsep pengelompokan data berdasarkan rentang waktu atau <em>window</em> waktu. Konsep ini berguna untuk menjawab kebutuhan bisnis secara real — time, seperti menghitung berapa total pendapatan transaksi setiap 1 menit. Penggunaan window disini merujuk pada rentang waktu kronologis, yang berbeda dengan <em>window function</em> (<em>rank</em> atau <em>row_number</em>) yang digunakan untuk perankingan pada praktikum sebelumnya.</p><pre>#Menambahkan kolom Timestamp sebagai acuan waktu yang pasti untuk mengetahui kapan transaksi terjadi<br>skema_dengan_waktu = StructType([<br>    StructField(&quot;trx_id&quot;, StringType(), True),<br>    StructField(&quot;kota&quot;, StringType(), True),<br>    StructField(&quot;pendapatan&quot;, IntegerType(), True),<br>    StructField(&quot;waktu_transaksi&quot;, TimestampType(), True),<br>])<br><br># Membuat ulang folder simulasi (kosong) untuk demo window waktu<br>folder_stream2 = &quot;simulasi_stream_waktu&quot;<br>shutil.rmtree(folder_stream2, ignore_errors=True)<br>os.makedirs(folder_stream2, exist_ok=True)<br><br>df_stream2 = spark.readStream \<br>    .format(&quot;csv&quot;) \<br>    .schema(skema_dengan_waktu) \<br>    .option(&quot;header&quot;, True) \<br>    .load(folder_stream2)<br><br># Mengelompokkan berdasarkan window waktu 1 menit, dihitung dari kolom waktu_transaksi<br># Sintaks ini merupakan inti dari pemrosesan waktu, data yang ada pada rentang menit yang sama akan dijumlahkan<br>agregasi_window = df_stream2.groupBy(<br>    window(col(&quot;waktu_transaksi&quot;), &quot;1 minute&quot;)<br>).agg(<br>    spark_sum(&quot;pendapatan&quot;).alias(&quot;total_pendapatan&quot;),<br>    count(&quot;trx_id&quot;).alias(&quot;jumlah_transaksi&quot;)<br>)<br><br>query2 = agregasi_window.writeStream \<br>    .outputMode(&quot;complete&quot;) \<br>    .format(&quot;memory&quot;) \<br>    .queryName(&quot;hasil_window&quot;) \<br>    .start()<br><br>print(&quot;Streaming query window waktu dimulai.&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/242/1*XYh04B2jivjnbtdhUZV4NQ.png" /></figure><p>Kemudian perintah berikut digunakan untuk mereplika kondisi transaksi dunia nyata secara akurat, data yang dikirim memiliki stempel waktu (<em>timestamp</em>) tepat daat kode tersebut dijalankan. Kueri ‘spark.sql(…)’ akan menghasilkan kolom waktu awal (<em>start</em>) dan waktu akhir (<em>end</em>) dengan jarak waktu tepat 1 menit. Output yang dihasilkan merupakan pilar utama di balik pembuatan <em>dashboard real — time</em> yang menampilkan metrik berjalan pada aplikasi.</p><pre>from datetime import datetime<br><br># Mengirim data dengan timestamp saat ini<br>waktu_sekarang = datetime.now()<br><br>pd.DataFrame({<br>    &quot;trx_id&quot;: [&quot;W1&quot;, &quot;W2&quot;],<br>    &quot;kota&quot;: [&quot;Semarang&quot;, &quot;Solo&quot;],<br>    &quot;pendapatan&quot;: [120000, 180000],<br>    &quot;waktu_transaksi&quot;: [waktu_sekarang.strftime(&quot;%Y-%m-%d %H:%M:%S&quot;)] * 2,<br>}).to_csv(f&quot;{folder_stream2}/batch_w1.csv&quot;, index=False)<br><br>time.sleep(6)<br><br>#Untuk membaca hasil rentang waktu<br>spark.sql(&quot;SELECT window.start, window.end, total_pendapatan, jumlah_transaksi FROM hasil_window&quot;).show(truncate=False)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*Ri71J_7EZ-ftfahz3ur3Hw.png" /></figure><p>Jangan lupa untuk menghentikan proses kueri agar berhenti dan tidak berjalan di latar belakang dan menghabiskan sumber daya.</p><pre>query2.stop()<br>spark.stop()<br>print(&quot;Seluruh streaming query dihentikan, SparkSession ditutup.&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/407/1*zJ1ClveRVmM4cjvh3kc0sg.png" /></figure><h4>Latihan Mandiri</h4><p>Sebelum mengerjakan soal latihan mandiri, jalankan ulang cell pembuatan SparkSession pada sub-bab 10.2 dan jalankan cell persiapan ulang berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*RpY__ZLiOhF0vCw15azfnA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*sCIBYl_7pCC07x0o4ogvBg.png" /></figure><p><strong>Soal 1.</strong> Definisikan readStream dari folder latihan10_stream menggunakan skema_latihan, lalu buat agregasi groupBy(&quot;kategori&quot;) yang menghitung <strong>rata-rata</strong> pendapatan (gunakan avg, bukan sum). Jalankan query dengan queryName=&quot;latihan_agg&quot;.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*2R4OuopEKEiypA2ukBEjxw.png" /></figure><p><strong>Keterangan</strong> :</p><p>Menggunakan <strong>readStream</strong> untuk membaca aliran data dari <strong>folder_latihan</strong>. Serta mendefinisikan schema ‘<strong>skema_latihan</strong>’ karena Spark tidak bisa menebak secara otomatis. Kemudian membuat agregasi data yang mengelompokkan data berdasarkan <strong>kategori</strong>, lalu menggunakan fungsi <strong>avg</strong> untuk menghitung rata — rata <strong>pendapatan</strong>. Menggunakan ‘<strong>outputMode(“complete”)</strong>’ dan ‘<strong>format(“memory”)</strong>’ agar setiap ada data baru, seluruh hasil agregasi terbaru diperbarui dan disimpan ke dalam memori komputer (RAM). Kemudian data tabel di memori tersebut diberi nama ‘<strong>latihan_agg’</strong>.</p><p><strong>Soal 2.</strong> Kirim (tulis) sebuah berkas CSV berisi minimal 3 baris data ke folder latihan10_stream, tunggu beberapa detik, lalu tampilkan isi tabel latihan_agg menggunakan spark.sql().</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*YA4FXcwCZrpQx9Y-xMFEnQ.png" /></figure><p><strong>Keterangan</strong> :</p><p>Dengan menggunakan Pandas untuk membuat file CSV (<strong>pd.DataFrame(…).to_csv(…)</strong>) simulasi secara langsung yang di awasi spark. Menghentikan eksekusi selama 6 detik (‘<strong>time.sleep(6)</strong>’) untuk memproses berkas yang baru masuk. Kemudian data diambil dari tabel ‘<strong>latihan_agg</strong>’ yang sudah tersimpan di memori untuk ditampilkan menggunakan kueri sql.</p><p><strong>Soal 3.</strong> Kirim <strong>batch kedua</strong> dengan kategori yang <strong>sama</strong> seperti salah satu kategori pada batch pertama, tunggu beberapa detik, lalu tampilkan ulang latihan_agg. Amati: apakah nilai rata-ratanya berubah sesuai perhitungan gabungan kedua batch?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*mOXJeRaM7BMv5J8uZdXuww.png" /></figure><p><strong>Keterangan</strong> :</p><p>Pada batch kedua, memasukkan data dengan kategori yang sama seperti batch pertama yaitu kategori ‘<strong>Makanan</strong>’, membuat nilai <strong>rata_rata_pendapatan</strong> pada kategori Makanan akan berubah secara otomatis.</p><p><strong>Soal 4 (Refleksi singkat).</strong> Dalam 2–3 kalimat: mengapa Spark Structured Streaming <strong>mewajibkan</strong> skema didefinisikan secara eksplisit (StructType), sementara pemrosesan batch pada Pertemuan 4 bisa memakai inferSchema=True?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*fk5sYnc0R7IO4Dgg3otbRA.png" /></figure><p>Setelah selesai mengerjakan soal latihan mandiri, jangan lupa untuk menghentikan ‘<strong>query_latihan</strong>’ dan menghentikan SparkSession.</p><h4>Tugas Mandiri</h4><p>Tugas Mandiri dapat diakses pada link github berikut :</p><p><a href="https://github.com/DebiAprilia/bigdata2026/blob/main/Tugas10_2320506038_DebiAprilia.ipynb">bigdata2026/Tugas10_2320506038_DebiAprilia.ipynb at main · DebiAprilia/bigdata2026</a></p><h4>Kesimpulan</h4><p>Spark Structured Streaming dapat mempermudah dan lebih efisien digunakan untuk pemrosesan aliran data tanpa henti karena memanfaatkan sintaks DataFrame yang sama dengan pemrosesan batch biasa. Dengan mendefinisikan skema dan komponen dasar berupa <em>input</em> <em>source</em>, <em>sink</em>, dan<em> output mode</em>, Spark akan otomatis menangani kompleksitas di latar belakang seperti membaca data yang baru masuk, memperbarui hasil agregasi, mengelompokkan data, sampai menuliskan hasilnya ke penyimpanan akhir, tanpa perlu menuliskan logika perhitungannya berulang kali saat ada data baru.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=58a1269d6f3f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Basis Data NoSQL : Instalasi MongoDB dan Integrasi dengan PySpark — Praktikum Big Data]]></title>
            <link>https://medium.com/@debi.aprilia/basis-data-nosql-instalasi-mongodb-dan-integrasi-dengan-pyspark-praktikum-big-data-1c6d1c36f316?source=rss-c81725c91e44------2</link>
            <guid isPermaLink="false">https://medium.com/p/1c6d1c36f316</guid>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[mongodb]]></category>
            <category><![CDATA[nosql]]></category>
            <dc:creator><![CDATA[Debi Aprilia]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 17:06:48 GMT</pubDate>
            <atom:updated>2026-11-05T15:37:19.139Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WVSxtE37zey8U2keQf2DFQ.jpeg" /></figure><p><strong>NoSQL </strong>atau <strong>Not Only SQL</strong> merupakan sistem manajemen basis data yang dirancang untuk menyimpan, mengelola, dan mengkueri data non-relasional atau semi — terstruktur tanpa bergantung pada skema tabel yang kaku. NoSQL digunakan untuk menangani keragaman format data sesuai prinsip variety pada karakteristik 5v Big Data. MongoDB merupakan basis data NoSQL tipe document store yang menyimpan data dalam format BSON (Binary JSON). Data diorganisir ke dalam Collection (setara dengan tabel) berisi Document (setara dengan baris/objek JSON).</p><p>Perbedaan basis data relasional (SQL) dan basis data NoSQL dapat dilihat pada tabel berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2xbWWDOtHto2R29Y7t3vgw.jpeg" /></figure><h4>Instalasi MongoDB Community Server 8.0</h4><p>Untuk menginstal MongoDB, jalankan langkah — langkah berikut di Terminal Ubuntu.</p><p><strong>Langkah 1 : Impor kunci GPG resmi MongoDB</strong></p><p>Sebelum mengimpor kunci GPG, jalankan perintah berikut untuk menginstal dan mengunduh curl untuk mengunduh kunci keamanan GPG dan gnupg untuk memproses kunci tersebut di sistem Ubuntu.</p><pre>#Unduh dan Instal curl dan gnupg<br>sudo apt-get install gnupg curl</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/576/1*Rvq_YBxxbMT4f92eWES0ng.png" /></figure><p>Kemudian masukkan perintah berikut untuk mengunduh kunci keamanan publik (GPG Key) resmi dari repositori MongoDB tanpa menampilkan indikator proses (-s <em>silent</em>) dan akan memperlakukan kegagalan koneksi sebagai eror (-f <em>fail</em>). Perintah berikutnya, digunakan untuk mengonversi kunci GPG dari format ASCII (- — dearmor) ke bentuk biner dan menyimpannya (-o) ke direktori sistem keyrings dengan hak akses administrator (sudo). Kunci ini digunakan untuk memverifikasi keaslian paket MongoDB saat diinstal.</p><pre>#Kunci GPG resmi MongoDB<br>curl -fsSL https://pgp.mongodb.com/server-8.0.asc | \<br>   sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg --dearmor</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/773/1*nXu2yUgbiJ5CjYgZThAzJQ.png" /></figure><p><strong>Langkah 2 : Tambahkan repository MongoDB sesuai versi Ubuntu yang digunakan</strong></p><p>Ada 2 versi Ubuntu yaitu Ubuntu 22.04 (Jammy) dan Ubuntu 24.04 (Noble). Untuk mengetahui versi ubuntu yang digunakan, masukkan perintah berikut.</p><pre>#Untuk mengecek versi Ubuntu<br>cat /etc/lsb-release</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/472/1*wskRfTEFQBOuNv7pjMIOOg.png" /></figure><p>Kemudian, tambahkan repository MongoDB sesuai versi yang digunakan dengan memasukkan salah satu perintah berikut.</p><pre>#Untuk Ubuntu 22.04 (Jammy) gunakan perintah berikut<br>echo &quot;deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/8.0 multiverse&quot; | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list<br><br>#Untuk Ubuntu 24.04 (Noble) gunakan perintah berikut<br>echo &quot;deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu noble/mongodb-org/8.0 multiverse&quot; | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/810/1*iBwaFDSBR6JsSuRXmKosoQ.png" /></figure><p><strong>Langkah 3 : Perbarui daftar paket dan instal MongoDB</strong></p><p>Untuk memperbarui daftar indeks paket aplikasi pada sistem Ubuntu agar apt mengetahui ada repository baru MongoDB yang baru ditambahkan, gunakan perintah berikut.</p><pre>#Untuk memperbarui daftar paket<br>sudo apt update</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*gTQvX9Wz7rJP5OtLZbN77A.png" /></figure><p>Kemudian instal paket utama MongoDB beserta komponen pendukungnya dengan perintah berikut.</p><pre>#Untuk menginstal MongoDB<br>sudo apt install -y mongodb-org</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/571/1*_hgikcILc8Xwa5wB5rVPTA.png" /></figure><p><strong>Langkah 4 : Jalankan MongoDB sebagai service dan aktifkan agar otomatis menyala setiap boot</strong></p><p>Untuk menjalankan service atau daemon MongoDB (mongod) di latar belakang agar server basis data mulai aktif beroperasi gunakan perintah berikut.</p><pre>#Untuk menjalankan service MongoDB<br>sudo systemctl start mongod</pre><p>Agar layanan mongod otomatis berjalan secara mandiri setiap kali sistem Ubuntu dinyalakan, gunakan perintah berikut.</p><pre>#Untuk mengaktifkan secara otomatis layanan mongod<br>sudo systemctl enable mongod</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/545/1*8bvTMniCzj9oVLqiYOr4lA.png" /></figure><p><strong>Langkah 5: Verifikasi MongoDB berjalan</strong></p><p>Untuk memeriksa status operasional service mongod untuk memastikan basis data sudah berstatus <strong>active (<em>running</em>)</strong> gunakan perintah berikut.</p><pre>#Untuk memeriksa apakah mongod sudah aktif<br>sudo systemctl status mongod</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/812/1*u8YVqJdR5FviaUfdqsAPvw.png" /></figure><p>Untuk keluar dari tampilan status tekan huruf ‘q’.</p><p>Kemudian verifikasi versi MongoDB yang sudah terinstal dengan perintah berikut.</p><pre>#Untuk mengecek versi MongoDB<br>mongod --version</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/551/1*vF0W_MUTGdkdXUBNPYpfWQ.png" /></figure><h4>Operasi Dasar dengan mongosh (MongoDB Shell)</h4><p><strong>mongosh</strong> merupakan <em>command-line interface</em> resmi untuk berinteraksi langsung dengan MongoDB seperti penggunaan <strong>hdfs dfs</strong> untuk HDFS atau <strong>psql</strong> untuk PostgreSQL.</p><p>Perintah untuk membuka antarmuka berbasis teks interaktif (<em>command-line interface</em>) resmi dari MongoDB di terminal Ubuntu adalah <strong>mongosh</strong>. Outputnya akan diarahkan untuk masuk ke prompt interaktif <strong>test&gt;</strong>.</p><pre>#Perintah untuk masuk ke CLI MongoDB<br>mongosh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*RabUa7TyxFc6UlYg_O4y_Q.png" /></figure><p>Perintah berikut digunakan untuk berpindah ke database bernama <strong>praktikum_bigdata</strong>. Atau jika database tersebut belum ada, MongoDB akan membuat secara otomatis saat data pertama kali disimpan.</p><pre>#Untuk berpindah atau membuat database baru<br>use praktikum_bigdata</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/293/1*x9oJJNMCsGEIi_rviiRtGg.png" /></figure><p>Perintah berikut digunakan untuk menyisipkan satu dokumen data ke dalam collection bernama produk. Jika collection <strong>produk</strong> belum ada, MongoDB akan otomatis membuatnya tanpa perlu mendefinisikan skema tabelnya terlebih dahulu.</p><pre>#Untuk Menyisipkan satu dokumen ke collection &quot;produk&quot; (otomatis dibuat jika belum ada)<br>db.produk.insertOne({ nama_produk: &quot;Kopi Susu&quot;, kategori: &quot;Minuman&quot;, harga: 18000, stok: 120 })</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ae3HllEmQFRgCO3J5roqFw.png" /></figure><p>Perintah selanjutnya digunakan untuk mengambil dan menampilkan seluruh dokumen yang tersimpan di dalam collection<strong> produk</strong>.</p><pre>#Untuk menampilkan seluruh dokumen pada collection &quot;produk&quot;<br>db.produk.find()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/420/1*5Sgzwh1FrnqQsg3FGVHMpQ.png" /></figure><p>Perintah selanjutnya digunakan untuk menampilkan seluruh dokumen pada collection <strong>produk</strong> dengan format JSON yang rapi, sehingga lebih mudah dibaca.</p><pre>#Untuk menampilkan dengan format lebih rapi<br>db.produk.find().pretty()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/422/1*oI-jBMx1UyvmL78IDZR9hA.png" /></figure><p>Terakhir, perintah untuk keluar dari sesi interaktif mongosh dan kembali ke terminal utama dengan perintah berikut.</p><pre>#Untuk keluar dari sesi interaktif mongosh<br>exit</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/303/1*7Yg1N_zd3KCw07IqYZwZAQ.png" /></figure><h4>Melanjutkan di Jupyter Notebook</h4><p>Sebelum melanjutkan ke Jupyter Notebook, instal driver PyMongo di environment bigdata dengan perintah seperti berikut.</p><pre>#Masuk ke environment bigdata kemudian instal PyMongo<br>conda activate bigdata<br>pip install pymongo</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*3LwZP4bam-xZ-SnMSGV2ow.png" /></figure><p>Kemudian verifikasi versi PyMongo yang digunakan dengan perintah berikut, lalu jalankan jupyter notebook seperti biasa.</p><pre>#Untuk verifikasi<br>python -c &quot;import pymongo; print(&#39;PyMongo&#39;, pymongo.version)&quot;<br><br>#Untuk menjalankan jupyter notebook<br>cd ~/praktikum-bigdata<br>jupyter notebook</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/841/1*zBszSSzOisqTDQHnYhzrvQ.png" /></figure><h4>Koneksi ke MongoDB dari Python</h4><p>Untuk menghubungkan environment Python dengan server MongoDB, gunakan library PyMongo seperti pada perintah berikut.</p><pre>#Mengimpor modul MongoClient untuk jembatan atau driver untuk berkomunikasi dengan server MongoDB<br>from pymongo import MongoClient<br><br># Membuat instansiasi koneksi ke MongoDB yang berjalan di localhost, port default 27017<br>client = MongoClient(&quot;mongodb://localhost:27017/&quot;)<br><br># Memilih (atau otomatis membuat) database<br>db = client[&quot;praktikum_bigdata&quot;]<br><br># Memilih (atau otomatis membuat) collection<br>koleksi_produk = db[&quot;produk&quot;]<br><br>print(&quot;Koneksi ke MongoDB berhasil!&quot;)<br>print(&quot;Daftar database yang ada:&quot;, client.list_database_names())</pre><p>Sehingga menghasilkan output sebagai berikut. Output menampilkan daftar database yang ada, berarti koneksi berhasil.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/576/1*fClXbzI7SpUIq6RRr04l4Q.png" /></figure><h4>Operasi CRUD dengan PyMongo</h4><ul><li><strong>Create — Menyisipkan Dokumen</strong></li></ul><pre># Menghapus data lama jika ada (agar percobaan kita mulai dari kondisi bersih)<br># Filter {} berarti operasi berlaku untuk seluruh dokumen<br>koleksi_produk.delete_many({})<br><br># insert_one() — digunakan untuk menyisipkan tepat satu dokumen ke dalam collection<br>koleksi_produk.insert_one({<br>    &quot;nama_produk&quot;: &quot;Kopi Susu&quot;,<br>    &quot;kategori&quot;: &quot;Minuman&quot;,<br>    &quot;harga&quot;: 18000,<br>    &quot;stok&quot;: 120,<br>    &quot;tags&quot;: [&quot;best-seller&quot;, &quot;dingin&quot;]<br>})<br><br># insert_many() — digunakan untuk menyisipkan banyak dokumen sekaligus<br>koleksi_produk.insert_many([<br>    {&quot;nama_produk&quot;: &quot;Roti Bakar&quot;, &quot;kategori&quot;: &quot;Makanan&quot;, &quot;harga&quot;: 15000, &quot;stok&quot;: 45, &quot;tags&quot;: [&quot;hangat&quot;]},<br>    {&quot;nama_produk&quot;: &quot;Es Teh&quot;, &quot;kategori&quot;: &quot;Minuman&quot;, &quot;harga&quot;: 8000, &quot;stok&quot;: 200, &quot;tags&quot;: [&quot;dingin&quot;, &quot;murah&quot;]},<br>    {&quot;nama_produk&quot;: &quot;Kentang Goreng&quot;, &quot;kategori&quot;: &quot;Makanan&quot;, &quot;harga&quot;: 20000, &quot;stok&quot;: 60, &quot;tags&quot;: [&quot;gurih&quot;]},<br>    {&quot;nama_produk&quot;: &quot;Cappuccino&quot;, &quot;kategori&quot;: &quot;Minuman&quot;, &quot;harga&quot;: 25000, &quot;stok&quot;: 80, &quot;tags&quot;: [&quot;hangat&quot;, &quot;best-seller&quot;]},<br>])<br><br>print(&quot;Jumlah dokumen di collection &#39;produk&#39;:&quot;, koleksi_produk.count_documents({}))</pre><p>Ketika kode program di atas dijalankan, akan menghasilkan output seperti pada gambar berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/301/1*GMU4k5ot15MKDnsyL_hYVg.png" /></figure><ul><li><strong>Read — Membaca Dokumen</strong></li></ul><pre># find_one() — untuk mengambil satu dokumen pertama yang cocok dengan kriteria pencarian<br>satu_produk = koleksi_produk.find_one({&quot;kategori&quot;: &quot;Minuman&quot;})<br>print(&quot;Satu produk kategori Minuman:&quot;, satu_produk)<br><br>print()<br><br># find() — untuk mengambil SEMUA dokumen yang cocok (mengembalikan cursor, di-looping atau di-list())<br>print(&quot;Seluruh produk kategori Minuman:&quot;)<br>for p in koleksi_produk.find({&quot;kategori&quot;: &quot;Minuman&quot;}):<br>    print(f&quot;  - {p[&#39;nama_produk&#39;]} (Rp{p[&#39;harga&#39;]:,})&quot;)<br><br>print()<br><br># Filter dengan operator perbandingan: harga lebih dari 15000<br># $gt (greater than) untuk memfilter dokumrn yang memiliki harga lebih dari 15.000<br>print(&quot;Produk dengan harga &gt; 15000:&quot;)<br>for p in koleksi_produk.find({&quot;harga&quot;: {&quot;$gt&quot;: 15000}}):<br>    print(f&quot;  - {p[&#39;nama_produk&#39;]} (Rp{p[&#39;harga&#39;]:,})&quot;)</pre><p>Ketika kode program di atas dijalankan, akan menghasilkan output seperti pada gambar berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*nyRlOFVL8092Wng-jc8c-w.png" /></figure><ul><li><strong>Update — Memperbarui Dokumen</strong></li></ul><pre># update_one(filter, tindakan) — untuk memperbarui SATU dokumen pertama yang memenuhi kriteria filter<br>koleksi_produk.update_one(<br>    {&quot;nama_produk&quot;: &quot;Es Teh&quot;},<br>    {&quot;$set&quot;: {&quot;harga&quot;: 9000}}   # menaikkan harga Es Teh<br>)<br><br># update_many(filter, tindakan) — memperbarui SEMUA dokumen yang memenuhi kriteria filter<br># $inc (increment) untuk menambah atau mengurangi nilai field yang sudah ada, bukan menimpanya<br># Contoh: mengurangi stok seluruh produk kategori Minuman sebanyak 5 (simulasi penjualan)<br>koleksi_produk.update_many(<br>    {&quot;kategori&quot;: &quot;Minuman&quot;},<br>    {&quot;$inc&quot;: {&quot;stok&quot;: -5}}<br>)<br><br>print(&quot;Setelah update:&quot;)<br>for p in koleksi_produk.find({}, {&quot;_id&quot;: 0, &quot;nama_produk&quot;: 1, &quot;harga&quot;: 1, &quot;stok&quot;: 1}):<br>    print(f&quot;  - {p[&#39;nama_produk&#39;]}: harga=Rp{p[&#39;harga&#39;]:,}, stok={p[&#39;stok&#39;]}&quot;)</pre><p>Ketika kode program di atas dijalankan, akan menghasilkan output seperti pada gambar berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/313/1*ab9-0G81oB5QP_xOEMSFbA.png" /></figure><ul><li><strong>Delete — Menghapus Dokumen</strong></li></ul><pre># delete_one() — untuk menghapus SATU dokumen pertama yang cocok dengan kriteria<br>koleksi_produk.delete_one({&quot;nama_produk&quot;: &quot;Kentang Goreng&quot;})<br><br>print(&quot;Jumlah dokumen tersisa:&quot;, koleksi_produk.count_documents({}))<br>print(&quot;Daftar produk tersisa:&quot;, [p[&quot;nama_produk&quot;] for p in koleksi_produk.find({}, {&quot;nama_produk&quot;: 1, &quot;_id&quot;: 0})])</pre><p>Ketika kode program di atas dijalankan, akan menghasilkan output seperti pada gambar berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/550/1*Aq8RXV92vLqdT-jPvOcTjQ.png" /></figure><h4>Mengintegrasikan Data MongoDB ke Spark DataFrame</h4><p>Data NoSQL dari MongoDB bisa diubah menjadi format tabular terstruktur (Spark DataFrame) untuk dianalisis. Caranya adalah sebagai berikut.</p><pre>from pyspark.sql import SparkSession<br>import pandas as pd<br><br>#Membuat sesi Spark<br>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan9-MongoDBSpark&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br># Langkah 1: mengambil seluruh dokumen dari MongoDB menggunakan find({}) sebagai list of dict<br>dokumen_mongo = list(koleksi_produk.find({}))<br><br># Langkah 2: Mengubah list menjadi pandas DataFrame sebagai jembatan perantara<br>df_pandas = pd.DataFrame(dokumen_mongo)<br><br># Langkah 3: Tipe data khusus MongoDB (_id, dan kolom berisi list seperti &quot;tags&quot;)<br># perlu disesuaikan dulu agar Spark dapat membacanya dengan benar<br># ObjectId pada kolom _id diubah menjadi string standar, <br># sedangkan kolom tags yang berisi list/array digabung menjadi satu string yang dipisahkan oleh koma agar mudah dibaca<br>df_pandas[&quot;_id&quot;] = df_pandas[&quot;_id&quot;].astype(str)<br>df_pandas[&quot;tags&quot;] = df_pandas[&quot;tags&quot;].apply(lambda x: &quot;, &quot;.join(x) if isinstance(x, list) else &quot;&quot;)<br><br># Langkah 4: Mengonversi Pandas DataFrame yang sudah rapi ke Spark DataFrame<br>df_spark_produk = spark.createDataFrame(df_pandas)<br><br>df_spark_produk.printSchema()<br>df_spark_produk.show()</pre><p>Ketika kode program di atas dijalankan, akan menghasilkan output seperti pada gambar berikut. Data yang tersimpan di MongoDB sudah berhasil diubah menjadi Spark DataFrame, serta dapat langsung diolah menggunakan teknik yang sudah dipelajari pada praktikum sebelumnya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*8dOY8Yz42WK6F2LCf_CCAA.png" /></figure><p>Setelah data berhasil diubah menjadi Spark DataFrame, kita bisa menggunakan operasi analitik Spark untuk mengelompokkan data berdasarkan kategori, lalu menghitung rata — rata harga (avg) dan jumlah produk (count) dengan perintah berikut.</p><pre>from pyspark.sql.functions import avg, count<br><br># Contoh analisis sederhana: rata-rata harga &amp; jumlah produk per kategori<br>df_spark_produk.groupBy(&quot;kategori&quot;).agg(<br>    avg(&quot;harga&quot;).alias(&quot;rata_rata_harga&quot;),<br>    count(&quot;nama_produk&quot;).alias(&quot;jumlah_produk&quot;)<br>).show()<br><br># Menutup SparkSession<br>spark.stop()<br>print(&quot;SparkSession ditutup.&quot;)</pre><p>Ketika kode program di atas dijalankan, akan menghasilkan output seperti pada gambar berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/325/1*FZ7LEwyo8HZA4MMqvZa-HQ.png" /></figure><h4>Latihan Mandiri</h4><p>Untuk mengerjakan latihan mandiri, pastikan client, db, dan koleksi_produk masih aktif. Jika kernel sudah mati atau direstart, jalankan ulang cell berikut untuk mengaktifkan kambali koneksinya.</p><pre>from pymongo import MongoClient<br><br># Membuat koneksi ke MongoDB yang berjalan di localhost, port default 27017<br>client = MongoClient(&quot;mongodb://localhost:27017/&quot;)<br><br># Memilih (atau otomatis membuat) database<br>db = client[&quot;praktikum_bigdata&quot;]<br><br># Memilih (atau otomatis membuat) collection<br>koleksi_produk = db[&quot;produk&quot;]</pre><p><strong>Soal 1.</strong> Sisipkan (insert_many) lima dokumen baru ke collection produk dengan kategori bebas (boleh kategori baru selain Makanan/Minuman, misalnya &quot;Snack&quot;).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*iESzIl6m8L--kuYwXlhAuA.png" /></figure><p><strong>Keterangan</strong> : Dengan menggunakan fungsi<strong> insert_many()</strong> lima dokumen tersebut berhasil ditambahkan ke MongoDB sekaligus, serta dengan tambahan dua kategori berbeda yaitu ‘buah’ dan ‘snack’.</p><p><strong>Soal 2.</strong> Gunakan find() dengan operator $lt (kurang dari) untuk menampilkan seluruh produk dengan harga di bawah 20000.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*pMYC5HlYjcVaSGreWZEonQ.png" /></figure><p><strong>Keterangan :</strong> Menggunakan fungsi <strong>find()</strong> untuk mengambil seluruh dokumen yang memenuhi kriteria filter. Kriteria yang diambil adalah nilai harga dibawah 20000 menggunakan operator <strong>$lt</strong> (<em>less than</em>).</p><p><strong>Soal 3.</strong> Gunakan update_many() untuk menambahkan field baru bernama diskon bernilai 0 ke <strong>seluruh</strong> dokumen pada collection produk (petunjuk: gunakan operator $set).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*iMWyYlXECuBsWAKMQgI-Ng.png" /></figure><p><strong>Keterangan</strong> : menggunakan fungsi <strong>update_many()</strong> untuk memperbarui banyak dokumen sekaligus. Kurung kurawal kosong <strong>{}</strong> sebagai kriteria pencarian yang artinya mencakup semua data di dalam collection. Operator <strong>$set</strong> untuk menambahkan field baru bernama <strong>‘diskon’</strong> dengan nilai 0 jika field tersebut belum ada di dokumen.</p><p><strong>Soal 4 (Refleksi singkat).</strong> Dalam 2–3 kalimat: berikan <strong>satu contoh skenario nyata</strong> (boleh di luar konteks e-commerce yang sering kita pakai) di mana MongoDB akan menjadi pilihan lebih tepat dibanding tabel relasional biasa, dan jelaskan alasannya berdasarkan konsep <em>flexible schema</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/994/1*rARkgexKrzVxpgoKVbFMvg.png" /></figure><h4>Tugas Mandiri</h4><p>Tugas Mandiri dapat diakses pada link GitHub berikut :</p><p><a href="https://github.com/DebiAprilia/bigdata2026/blob/main/Tugas9_2320506038_DebiAprilia.ipynb">bigdata2026/Tugas9_2320506038_DebiAprilia.ipynb at main · DebiAprilia/bigdata2026</a></p><h4>Kesimpulan</h4><p>Basis data NoSQL seperti MongoDB merupakan solusi penyimpanan dengan flexible schema yang optimal untuk mengelola data semi-terstruktur untuk melengkapi peran basis data relasional dalam menangani aspek Variety pada Big Data. Selain itu, dokumen dari basis data NoSQL dapat diintegrasikan untuk analisis tingkat lanjut melalui PyMongo, merapikan tipe data dengan Pandas, serta mengonversi ke Spark DataFrame agar dapat diolah menggunakan Apache Spark.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c6d1c36f316" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Studi Kasus Terintegrasi : Analisis Big Data End-To-End — Praktikum Big Data]]></title>
            <link>https://medium.com/@debi.aprilia/studi-kasus-terintegrasi-analisis-big-data-end-to-end-praktikum-big-data-8987ed34499a?source=rss-c81725c91e44------2</link>
            <guid isPermaLink="false">https://medium.com/p/8987ed34499a</guid>
            <category><![CDATA[big-data-analytics]]></category>
            <category><![CDATA[pyspark]]></category>
            <dc:creator><![CDATA[Debi Aprilia]]></dc:creator>
            <pubDate>Fri, 09 Oct 2026 08:29:40 GMT</pubDate>
            <atom:updated>2026-10-09T08:29:40.764Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xcwzOtrfgU9OO8GmqLnaLg.jpeg" /></figure><p>Sebelum mengerjakan studi kasus, berikut adalah rangkuman materi dan istilah — istilah penting yang sudah dipelajari sebelumnya.</p><p>Konsep dasar Big Data yang dijelaskan melalui kerangka 5V :</p><ul><li><strong>Volume</strong> → jumlah data yang sangat besar. Contoh pada data transaksi seluruh cabang toko retail nasional per hari.</li><li><strong>Velocity</strong> → kecepatan data dihasilkan dan diproses. Contoh pada data sensor IoT pabrik yang mengirim pembacaan setiap detik.</li><li><strong>Variety</strong> → keragaman format data (terstruktur, semi-terstruktur, tidak terstruktur). Contoh tabel transaksi (terstruktur), log JSON (semi-terstruktur), foto/video (tidak terstruktur).</li><li><strong>Veracity</strong> → tingkat keakuratan dan kepercayaan terhadap data. Contoh data sensor yang bisa jadi noisy atau tidak lengkap.</li><li><strong>Value</strong> → nilai atau wawasan bisnis yang dapat digali dari data. Contoh pola pembelian pelanggan untuk strategi promosi.</li></ul><p>HDFS atau Hadoop Distributed File System digunakan untuk menyimpan berkas berukuran besar dengan cara memecah berkas ke beberapa blok data dan direplikasikan ke berbagai node. Perintah dasar yang ada pada HDFS adalah sebagai berikut.</p><ul><li><strong>put</strong> → untuk mengunggah berkas atau direktori dari sistem lokal ke HDFS.</li><li><strong>get</strong> → untuk mengunduh berkas atau direktori dari HDFS ke sistem lokal.</li><li><strong>cat</strong> → untuk menampilkan isi dari berkas yang tersimpan di HDFS langsung di terminal.</li><li><strong>ls</strong> → untuk menampilkan daftar berkas dan direktori yang ada di dalam path HDFS.</li></ul><p>SparkSession merupakan pintu masuk utama agar bisa menggunakan Spark untuk membuat DataFrame, mendaftarkan tabel SQL, dan mengeksekusi kueri. Operasi dasar DataFrame adalah sebagai berikut.</p><ul><li><strong>select</strong> → untuk memilih kolom tertentu yang ingin ditampilkan atau diproses dari DataFrame.</li><li><strong>filter</strong> → untuk menyaring atau mengambil baris data yang memenuhi kondisi tertentu.</li><li><strong>groupBy</strong> → untuk mengelompokkan data berdasarkan nilai dari satu atau beberapa kolom.</li><li><strong>agg</strong> → untuk menjalankan fungsi agregasi seperti hitung total (<em>sum</em>), rata — rata (<em>avg</em>), atau jumlah (<em>count</em>) pada data yang sudah dikelompokkan.</li><li><strong>join()</strong> → untuk menggabungkan dua DataFrame berdasarkan kolom kunci : <em>Inner Join</em> (menampilkan baris yang nilainya sama di kedua DataFrame), <em>Left Join</em> (menampilkan semua baris dari DataFrame kiri dan baris yang sama dari DataFrame kanan), <em>Right Join</em> (kebalikan left join), <em>Outer Join</em> (menampilkan seluruh baris ketika ada kesamaan pada salah satu DataFrame).</li><li><strong>window function</strong> → <em>rank</em> (memberi peringkat sama ketika nilainya sama), <em>row_number</em> (memberi nomor urut secara unik).</li><li><strong>spark SQL </strong>→ menggunakan bahasa kueri murni seperti <em>createOrReplaceTempView</em> (untuk mendaftarkan DataFrame sebagai temporary view agar bisa diakses menggunakan kueri SQL), <em>spark.sql()</em> (untuk mengeksekusi kueri SQL).</li></ul><p>Parquet merupakan penyimpanan berbasis kolom (<em>columnar storage</em>) yang efisien untuk kompresi data, mempercepat kueri, dan menghemat ruang. Partisi (<em>partitioning</em>) merupakan teknik membagi data besar menjadi bagian — bagian terpisah berdasarkan nilai kolom tertentu.</p><p>Pola pipeline ETL yaitu <em>Extract</em> (mengambil data mentah dari berbagai sumber seperti CSV, JSON, HDFS), <em>Tranform</em> (membersihkan, menggabungkan, memfilter, dan mengubah struktur data sesuai kebutuhan analisis), <em>Load</em> (menyimpan hasil olahan yang sudah bersih ke tempat penyimpanan akhir seperti format parquet di HDFS).</p><h4>7.1 Studi Kasus: Laporan Kinerja Triwulan Jaringan Toko Retail</h4><p><strong>Konteks:</strong> Sebuah perusahaan retail memiliki <strong>4 cabang toko</strong> di berbagai kota. Manajemen pusat meminta laporan kinerja triwulan (3 bulan terakhir) yang mencakup: performa penjualan per toko, produk terlaris di masing-masing toko, dan kontribusi tiap manajer cabang — seluruhnya harus diproses dari data mentah yang tersebar di tiga sumber berbeda.</p><p><strong>Persiapan: Membuat SparkSession dan Tiga Sumber Data</strong></p><p>Sebelum menyelesaikan studi kasus, jangan lupa untuk membuat sesi spark dan mengimpor fungsi — fungsi PySpark yang digunakan untuk menangani DataFrame. Spark berjalan di mode lokal dengan menggunakan semua inti CPU yang tersedia.</p><pre>from pyspark.sql import SparkSession<br>from pyspark.sql.functions import col, sum as spark_sum, avg, count, row_number, when<br>from pyspark.sql.window import Window<br>import numpy as np<br>import pandas as pd<br>import json<br><br>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan7-StudiKasusTerintegrasi&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br>print(&quot;SparkSession siap. Versi Spark:&quot;, spark.version)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1003/1*kZX4SSiuimVocaZg1pNEUw.png" /></figure><p>Kemudian, jalankan blok kode berikut untuk membuat tiga sumber data simulasi. Sumber pertama, data referensi toko berformat JSON Lines dengan nama ‘<strong>data_toko.json</strong>’ yang berisi kolom toko_id, nama_toko, kota, dan manager. Sumber kedua, data produk berformat CSV berjumlah 20 baris (<strong>for i in range(1, 21)</strong>) dengan nama ‘<strong>data_produk.csv</strong>’ yang berisi kolom product_id, nama_produk, kategori, dan harga. Sumber ketiga, data transaksi berformat CSV berjumlah 5.000 baris dengan nama ‘<strong>data_transaksi_triwulan.csv</strong>’ yang berisi kolom trx_id, toko_id, product_id, dan qty.</p><pre>np.random.seed(77)<br><br># SUMBER 1: Data toko/cabang (JSON) — tabel referensi kecil<br>toko_list = [&quot;Toko Magelang&quot;, &quot;Toko Yogyakarta&quot;, &quot;Toko Semarang&quot;, &quot;Toko Solo&quot;]<br>data_toko = [<br>    {&quot;toko_id&quot;: i + 1, &quot;nama_toko&quot;: t, &quot;kota&quot;: t.split()[1], &quot;manager&quot;: np.random.choice([&quot;Rani&quot;, &quot;Joko&quot;, &quot;Sari&quot;, &quot;Bayu&quot;])}<br>    for i, t in enumerate(toko_list)<br>]<br>with open(&quot;data_toko.json&quot;, &quot;w&quot;) as f:<br>    for t in data_toko:<br>        f.write(json.dumps(t) + &quot;\n&quot;)<br><br># SUMBER 2: Data produk (CSV) — tabel referensi kecil<br>data_produk = [<br>    {&quot;product_id&quot;: i, &quot;nama_produk&quot;: f&quot;Produk-{i}&quot;,<br>     &quot;kategori&quot;: np.random.choice([&quot;Elektronik&quot;, &quot;Fashion&quot;, &quot;Makanan&quot;]),<br>     &quot;harga&quot;: int(np.random.choice([50000, 100000, 200000]))}<br>    for i in range(1, 21)<br>]<br>pd.DataFrame(data_produk).to_csv(&quot;data_produk.csv&quot;, index=False)<br><br># SUMBER 3: Data transaksi triwulan (CSV) — data utama, jauh lebih besar<br>n = 5000<br>data_transaksi = pd.DataFrame({<br>    &quot;trx_id&quot;: [f&quot;T{i}&quot; for i in range(n)],<br>    &quot;toko_id&quot;: np.random.randint(1, 5, size=n),<br>    &quot;product_id&quot;: np.random.randint(1, 21, size=n),<br>    &quot;qty&quot;: np.random.randint(1, 6, size=n),<br>})<br>data_transaksi.to_csv(&quot;data_transaksi_triwulan.csv&quot;, index=False)<br><br>print(&quot;Ketiga sumber data berhasil dibuat:&quot;)<br>print(f&quot;- data_toko.json              : {len(data_toko)} baris&quot;)<br>print(f&quot;- data_produk.csv             : {len(data_produk)} baris&quot;)<br>print(f&quot;- data_transaksi_triwulan.csv : {len(data_transaksi)} baris&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/786/1*JOoulk5NC1DN31u2Y5HHMA.png" /></figure><p><strong>Mengunggah Sumber Data Utama ke HDFS</strong></p><p>Blok kode berikut digunakan untuk mengunggah data mentah yang berukuran besar ke HDFS dengan perintah ‘<strong>-mkdir -p</strong>’ untuk membuat direktori baru di HDFS, ‘<strong>-put -f</strong>’ untuk mengunggah berkas dari penyimpanan lokal ke direktori HDFS secara paksa jika sudah ada berkas lama dengan nama yang sama, dan perintah ‘<strong>ls</strong>’ untuk menampilkan daftar berkas yang tersimpan di HDFS sebagai verifikasi apakah proses penyimpanan berhasil.</p><pre>!hdfs dfs -mkdir -p /user/mahasiswa/pertemuan7/raw<br>!hdfs dfs -put -f data_transaksi_triwulan.csv /user/mahasiswa/pertemuan7/raw/<br>!hdfs dfs -put -f data_toko.json /user/mahasiswa/pertemuan7/raw/<br>!hdfs dfs -put -f data_produk.csv /user/mahasiswa/pertemuan7/raw/<br>!hdfs dfs -ls /user/mahasiswa/pertemuan7/raw</pre><p>Jika berhasil disimpan, maka output akan menampilkan daftar file nya seperti pada gambar berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/874/1*mKWr6ztiH_3UMCr2WFx9TA.png" /></figure><h4>7.2 Tahap EXTRACT — Membaca dari HDFS</h4><p>Pada tahap ini, berkas yang berhasil diunggah ke HDFS dibaca kembali dengan fungsi ‘<strong>spark.read.csv()</strong>’ dan ‘<strong>spark.read.json()</strong>’, kemudian file HDFS diubah menjadi PySpark DataFrame dengan parameter ‘<strong>header=True</strong>’ yaitu membaca baris pertama sebagai nama kolom dan ‘<strong>inferSchema=True</strong>’ untuk mendeteksi tipe data secara otomatis pada file CSV. Kemudian masing — masing DataFrame dicetak dengan menghitung jumlah baris dengan perintah ‘<strong>.count()</strong>’ untuk memastikan data terbaca lengkap.</p><pre>df_transaksi = spark.read.csv(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_transaksi_triwulan.csv&quot;,<br>    header=True, inferSchema=True<br>)<br><br>df_toko = spark.read.json(&quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_toko.json&quot;)<br><br>df_produk = spark.read.csv(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_produk.csv&quot;,<br>    header=True, inferSchema=True<br>)<br><br>print(&quot;Transaksi:&quot;, df_transaksi.count(), &quot;| Toko:&quot;, df_toko.count(), &quot;| Produk:&quot;, df_produk.count())</pre><p>Hasilnya menampilkan jumlah baris dari masing — masing DataFrame.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/829/1*U3TXSgzfIlIgTjiCKf2AHg.png" /></figure><h4>7.3 Tahap TRANSFORM</h4><p><strong>7.3.1 Menggabungkan Ketiga Sumber (Join)</strong></p><p>Ketiga data digabungkan dari DataFrame ‘<strong>df_transaksi</strong>’ dengan ‘<strong>df_toko</strong>’ digabungkan berdasarkan kolom ‘<strong>toko_id</strong>’, lalu digabungkan lagi dengan ‘<strong>df_produk</strong>’ berdasarkan kolom ‘<strong>product_id</strong>’ dengan metode <em>inner join</em>. Kemudian menambahkan kolom baru bernama ‘<strong>total_penjualan</strong>’ dengan perintah ‘<strong>.withColumn()</strong>’, yang isinya dihitung dari perkalian kolom ‘<strong>qty</strong>’ dengan kolom ‘<strong>harga</strong>’.</p><pre>df_gabungan = df_transaksi.join(df_toko, on=&quot;toko_id&quot;, how=&quot;inner&quot;) \<br>                           .join(df_produk, on=&quot;product_id&quot;, how=&quot;inner&quot;)<br><br>df_gabungan = df_gabungan.withColumn(&quot;total_penjualan&quot;, col(&quot;qty&quot;) * col(&quot;harga&quot;))<br>df_gabungan.show(5)</pre><p>Hasilnya, menampilkan 5 baris pertama dari hasil join dari ketiga DataFrame yang sudah ditambahkan kolom baru bernama ‘<strong>total_penjualan</strong>’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*22F9hA5QEG3DIwxDfYQJCA.png" /></figure><p><strong>7.3.2 Window Function — Top 3 Produk Terlaris per Toko</strong></p><p>Untuk menampilkan top 3 produk terlaris per toko, yang dilakukan pertama adalah mengelompokkan data (<strong>groupBy()</strong>) berdasarkan toko dan produk untuk menghitung total penjualan per produk setiap toko (<strong>.agg()</strong>). Kemudian menerapkan window function untuk menganalisis per toko (<strong>Window.partitionBy()</strong>) dan mengurutkan secara menurun (<strong>.desc()</strong>) berdasarkan kolom ‘<strong>total_penjualan</strong>’.</p><p>Selanjutnya, memberikan nomor urut dengan perintah ‘<strong>row_number().over()</strong>’ agar nomor urut peringkat unik untuk tiap baris produk pada masing — masing toko. Kemudian, hasilnya disaring agar hanya menampilkan 3 produk teratas di setiap toko dengan perintah ‘<strong>.filter(col(“peringkat”) &lt;= 3)</strong>’.</p><pre># Meringkas total penjualan per kombinasi toko + produk terlebih dahulu<br>ringkasan_produk_toko = df_gabungan.groupBy(&quot;nama_toko&quot;, &quot;nama_produk&quot;).agg(<br>    spark_sum(&quot;total_penjualan&quot;).alias(&quot;total_penjualan&quot;)<br>)<br><br># Menerapkan window function untuk mengambil top-3 produk pada setiap toko<br>window_toko = Window.partitionBy(&quot;nama_toko&quot;).orderBy(col(&quot;total_penjualan&quot;).desc())<br>top3_produk = ringkasan_produk_toko.withColumn(&quot;peringkat&quot;, row_number().over(window_toko)) \<br>                                    .filter(col(&quot;peringkat&quot;) &lt;= 3)<br><br>top3_produk.orderBy(&quot;nama_toko&quot;, &quot;peringkat&quot;).show(20)</pre><p>Hasilnya, menampilkan kolom nama_toko, nama_produk, total_penjualan, dan peringkat 3 teratas pada masing — masing toko.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1004/1*SSi5Xwz4tmk1f7-U78IRrg.png" /></figure><p><strong>7.3.3 Spark SQL — Kontribusi per Manajer Cabang</strong></p><p>Sebelum menggunakan kueri SQL murni pada DataFrame, daftarkan DataFrame ‘<strong>df_gabungan</strong>’ menjadi tabel sementara (<em>temporary view</em>) bernama ‘<strong>gabungan</strong>’. Kemudian, untuk mengeksekusi kueri SQL murni gunakan perintah ‘<strong>spark.sql()</strong>’, isi kuerinya untuk mengelompokkan data berdasarkan kolom ‘<strong>kota</strong>’ dan ‘<strong>manager</strong>’, lalu menghitung total penjualan tiap manajer cabang.</p><pre>df_gabungan.createOrReplaceTempView(&quot;gabungan&quot;)<br><br>kontribusi_manager = spark.sql(&#39;&#39;&#39;<br>    SELECT kota, manager, SUM(total_penjualan) AS total_penjualan<br>    FROM gabungan<br>    GROUP BY kota, manager<br>    ORDER BY total_penjualan DESC<br>&#39;&#39;&#39;)<br>kontribusi_manager.show()</pre><p>Hasilnya, menampilkan setiap kota dengan masing — masing manajer serta total penjualannya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/999/1*B-KyESvVUWNfFyha-NSjKA.png" /></figure><h4>7.4 Tahap LOAD — Menyimpan Laporan Akhir ke HDFS</h4><p>Setelah itu, hasilnya disimpan dalam HDFS dengan format Parquet terpartisi. Caranya dengan membuat direktori baru terlebih dahulu sebagai tempat menyimpan berkasnya, kemudian gunakan mode penulisan ‘<strong>.mode(“overwrite”)</strong>’ untuk menimpa file jika di dalam direktori tujuan sudah ada filenya. Selanjutnya, struktur direktori dibagi berdasarkan nilai pada kolom ‘<strong>kategori</strong>’ produk dengan perintah ‘<strong>.partitionBy(“kategori”)</strong>’. Kemudian perintah ‘<strong>.parquet()</strong>’ untuk menyimpan data dalam format Parquet ke HDFS.</p><pre>!hdfs dfs -mkdir -p /user/mahasiswa/pertemuan7/processed<br><br>df_gabungan.write.mode(&quot;overwrite&quot;).partitionBy(&quot;kategori&quot;).parquet(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/processed/laporan_triwulan&quot;<br>)<br><br>print(&quot;Laporan berhasil disimpan ke HDFS dalam format Parquet, terpartisi per kategori produk.&quot;)<br>!hdfs dfs -ls /user/mahasiswa/pertemuan7/processed/laporan_triwulan</pre><p>Hasilnya, akan menampilkan sub-folder untuk masing — masing kategori yang berhasil dipartisi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1003/1*P8aSv3d0laOJJehPQROJRA.png" /></figure><p><strong>Verifikasi Akhir — Ringkasan Eksekutif</strong></p><p><em>Executive Summary</em> atau ringkasan eksekutif merupakan tabel ringkasan yang digunakan dalam pekerjaan nyata. Untuk menghasilkan ringkasan tersebut yang pertama harus dilakukan adalah membaca kembali berkas Parquet dari HDFS dengan perintah ‘<strong>spark.read.parquet()</strong>’. Kemudian lakukan agregasi eksekutif dengan mengelompokkan data per toko, kota, dan manajer untuk menghitung total penjualan triwulan, total volume transaksi (<strong>count()</strong>), serta rata — rata transaksi (<strong>avg</strong>).</p><pre>df_final = spark.read.parquet(&quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/processed/laporan_triwulan&quot;)<br><br>ringkasan_eksekutif = df_final.groupBy(&quot;nama_toko&quot;, &quot;kota&quot;, &quot;manager&quot;).agg(<br>    spark_sum(&quot;total_penjualan&quot;).alias(&quot;total_penjualan_triwulan&quot;),<br>    count(&quot;trx_id&quot;).alias(&quot;jumlah_transaksi&quot;),<br>    avg(&quot;total_penjualan&quot;).alias(&quot;rata_rata_nilai_transaksi&quot;)<br>).orderBy(col(&quot;total_penjualan_triwulan&quot;).desc())<br><br>ringkasan_eksekutif.show()</pre><p>Hasilnya, <strong>Toko Semarang</strong> memiliki total omset tertinggi sebesar 416.250.000 sehingga Toko Semarang merupakan toko dengan kinerja terbaik, dengan jumlah transaksi sebesar 1.306, rata — rata transaksi sebesar 318.721,29 , dan dengan manajer atas nama Rani.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*iMPf_07ZkNO1A9Pwab9ogw.png" /></figure><h4>Menutup SparkSession</h4><p>Blok kode berikut digunakan untuk menghentikan sesi Spark untuk membebaskan alokasi memori dan sumber daya sistem yang suda terpakai oleh Spark.</p><pre>spark.stop()<br>print(&quot;SparkSession ditutup.&quot;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1003/1*8Odo6slUHlTzS1ekv2twSA.png" /></figure><h4>Latihan Mandiri</h4><p>Untuk mengerjakan latihan mandiri, jalankan ulang blok kode berikut yang berfungsi untuk membuat sesi spark dan tiga DataFrame.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/999/1*pGnvCcNu0PQbTVnMwCQFpw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/895/1*xKYIo90jaHJsv3rv0LDLOQ.png" /></figure><p>Jalankan pula blok kode berikut untuk membaca file dari HDFS,</p><pre># Persiapan ulang untuk latihan<br>spark = SparkSession.builder.appName(&quot;Latihan7&quot;).master(&quot;local[*]&quot;).getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br>df_transaksi = spark.read.csv(&quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_transaksi_triwulan.csv&quot;, header=True, inferSchema=True)<br>df_toko = spark.read.json(&quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_toko.json&quot;)<br>df_produk = spark.read.csv(&quot;hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_produk.csv&quot;, header=True, inferSchema=True)<br><br>df_gabungan = df_transaksi.join(df_toko, on=&quot;toko_id&quot;).join(df_produk, on=&quot;product_id&quot;)<br>df_gabungan = df_gabungan.withColumn(&quot;total_penjualan&quot;, col(&quot;qty&quot;) * col(&quot;harga&quot;))<br><br>print(&quot;Siap untuk latihan. Total baris:&quot;, df_gabungan.count())</pre><p><strong>Soal 1.</strong> Menggunakan Spark SQL, tampilkan <strong>kategori produk</strong> dengan total qty (jumlah unit terjual, bukan nilai rupiah) tertinggi secara keseluruhan.</p><pre># Jawaban Soal 1<br>#Membuat temporary view agar DataFrame bisa diakses dengan Spark SQL<br>df_gabungan.createOrReplaceTempView(&quot;v_gabungan&quot;)<br><br>#Kueri SQL<br>df_soal1 = spark.sql(&#39;&#39;&#39;<br>    SELECT kategori, SUM(qty) AS total_qty<br>    FROM v_gabungan<br>    GROUP BY kategori<br>    ORDER BY total_qty DESC<br>&#39;&#39;&#39;)<br><br>#Menampilkan hasil<br>df_soal1.show()</pre><p>Penjelasan :</p><ul><li><strong>createOrReplaceTempView(“v_gabungan”)</strong> → Sebelum memproses data menggunakan Spark SQL, buat temporary view dari ‘<strong>df_gabungan</strong>’ terlebih dahulu dengan nama ‘<strong>v_gabungan</strong>’.</li><li><strong>SELECT kategori, SUM(qty) AS total_qty</strong> → memilih kolom ‘<strong>kategori</strong>’ dan menjumlahkan kolom ‘<strong>qty</strong>’ karena yang diminta adalah jumlah unitnya bukan nominal rupiahnya. Kolom hasil penjumlahannya diberi nama alias ‘<strong>total_qty</strong>’.</li><li><strong>GROUP BY kategori</strong> → untuk mengelompokkan data berdasarkan jenis kategori produk, sehingga fungsi ‘<strong>SUM(qty)</strong>’ dihitung per kategori.</li><li><strong>ORDER BY total_qty DESC</strong> → mengurutkan hasil perhitungan di kolom ‘total_qty’ dari terbanyak/tertinggi ke terkecil. Jika hanya ingin menampilkan 1 kategori saja dengan jumlah penjualan unit terbanyak, dapat menambahkan perintah ‘LIMIT 1’.</li></ul><p>Hasilnya, kategori dengan jumlah penjualan unit terbanyak adalah kategori Elektronik yaitu sebanyak 6.736 unit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/895/1*0B74lilBy53WkQLuUaqQ7Q.png" /></figure><p><strong>Soal 2.</strong> Menggunakan window function, tentukan <strong>toko dengan penjualan tertinggi</strong> untuk <strong>masing-masing kategori produk</strong> (top-1 saja, gunakan row_number()).</p><pre># Jawaban Soal 2<br>#Agregasi menghitung total penjualan per kategori dan toko<br>df_kategori_toko = df_gabungan.groupBy(&quot;kategori&quot;, &quot;nama_toko&quot;).agg(spark_sum(&quot;total_penjualan&quot;).alias(&quot;total_penjualan&quot;))<br><br>#Mendefinisikan spesifikasi window<br>window_spec = Window.partitionBy(&quot;kategori&quot;).orderBy(col(&quot;total_penjualan&quot;).desc())<br><br>#Menggunakan row_number() dan filter peringkat 1 saja<br>df_soal2 = df_kategori_toko.withColumn(&quot;peringkat&quot;, row_number().over(window_spec)).filter(col(&quot;peringkat&quot;) == 1)<br><br>#Menampilkan hasil<br>df_soal2.show()</pre><p>Penjelasan :</p><ul><li><strong>groupBy(“kategori”, “nama_toko”).agg(spark_sum(“total_penjualan”))</strong> → untuk melakukan agregasi awal, kelompokkan nilai berdasarkan kolom kategori dan nama_toko. Kemudian, menghitung total penjualan untuk setiap kelompok kategori dan toko.</li><li><strong>Window.partitionBy(“kategori”).orderBy(…) </strong>→ memecah data berdasarkan kolom kategori, kemudian setiap kelompok kategori di urutkan berdasarkan penjualan dari yang paling tinggi ke paling rendah.</li><li><strong>row_number().over(window_spec)</strong> → untuk mengurutkan data (1, 2, 3, dst) dari penjualan tertinggi.</li><li><strong>filter(col(“peringkat”) == 1)</strong> → untuk menyaring hasilnya agar hanya menampilkan toko dengan urutan pertama pada setiap kategori.</li></ul><p>Hasilnya, akan menampilkan kolom kategori, nama_toko, total_penjualan, serta peringkat (hanya peringkat 1 saja yang ditampilkan) pada masing — masing kategori.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/893/1*oy8AAURSDmDalEdwZ-TQZQ.png" /></figure><p><strong>Soal 3.</strong> Simpan hasil ringkasan_eksekutif (dari Sub-bab 7.4 di atas — silakan buat ulang) ke HDFS sebagai Parquet <strong>tanpa partisi</strong>, pada path <a href="https://colab.research.google.com/drive/1ykF3I93eGR4x8YPr7RJaIfHQKiLCG7lZ#">/user/mahasiswa/latihan7/ringkasan_eksekutif</a>.</p><pre># Jawaban Soal 3<br>#Membuat ulang DataFrame ringkasan_eksekutif<br>ringkasan_eksekutif = df_gabungan.groupBy(&quot;nama_toko&quot;, &quot;kota&quot;, &quot;manager&quot;) \<br>    .agg(<br>        spark_sum(&quot;total_penjualan&quot;).alias(&quot;total_penjualan_triwulan&quot;),<br>        count(&quot;trx_id&quot;).alias(&quot;jumlah_transaksi&quot;),<br>        avg(&quot;total_penjualan&quot;).alias(&quot;rata_rata_nilai_transaksi&quot;)<br>    )<br><br>#Menyimpan ke HDFS dalam format Parquet tanpa partisi<br>ringkasan_eksekutif.write.mode(&quot;overwrite&quot;).parquet(&quot;hdfs://localhost:9000/user/mahasiswa/latihan7/ringkasan_eksekutif&quot;)<br><br>#Menampilkan folder yang tersimpan di HDFS<br>!hdfs dfs -ls /user/mahasiswa/latihan7/ringkasan_eksekutif</pre><p>Penjelasan :</p><ul><li><strong>ringkasan_eksekutif.write</strong> → merupakan perintah untuk menuliskan data dari DataFrame ke penyimpanan eksternal yaitu HDFS.</li><li><strong>.mode(“overwrite”)</strong> → untuk menimpa data baru jika sudah ada folder dengan nama yang sama.</li><li><strong>.parquet(“hdfs://…”)</strong> → untuk menyimpan data dalam format parquet di HDFS. Karena perintahnya tanpa partisi, tidak perlu menambahkan perintah ‘.partitionBy()’.</li></ul><p>Jika file berhasil disimpan, ketika perintah -ls dijalankan, akan menampilkan file yang berhasil disimpan beserta path dan nama filenya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/892/1*RE3ZOc3_F-XUkME3MRUc6A.png" /></figure><p><strong>Soal 4 (Refleksi menyeluruh).</strong> Sebagai persiapan UTS, jelaskan dalam 4–5 kalimat: bagaimana <strong>HDFS, Spark, dan format Parquet saling melengkapi</strong> dalam satu ekosistem Big Data? Gunakan istilah-istilah yang telah anda pelajari sejak Pertemuan 3 (mis. distributed storage, in-memory processing, columnar format, partitioning).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/898/1*FS9vD9t3Miq--hOKVedkiQ.png" /></figure><h4>Tugas Mandiri</h4><p>Tugas Mandiri dapat diakses pada link GitHub berikut :</p><p><a href="https://github.com/DebiAprilia/bigdata2026/blob/main/Tugas7_2320506038_DebiAprilia.ipynb">bigdata2026/Tugas7_2320506038_DebiAprilia.ipynb at main · DebiAprilia/bigdata2026</a></p><h4>Kesimpulan</h4><p>Dari studi kasus di atas, dapat diketahui bagaimana alur kerja analisis Big Data secara end — to — end yang diterapkan langsung pada studi kasus nyata. Analisis terdiri dari 3 tahap yaitu <em>Extract</em> (membaca data mentah), <em>Transform</em> (mengolah dan menganalisis data), dan <em>Load</em> (menyimpan hasil olahan dalam format Parquet).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8987ed34499a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Format Data Besar (Parquet dan JSON) dan Pipeline ETL Sederhana — Praktikum Big Data]]></title>
            <link>https://medium.com/@debi.aprilia/format-data-besar-parquet-dan-json-dan-pipeline-etl-sederhana-praktikum-big-data-01f9561d7c2d?source=rss-c81725c91e44------2</link>
            <guid isPermaLink="false">https://medium.com/p/01f9561d7c2d</guid>
            <category><![CDATA[big-data-analytics]]></category>
            <category><![CDATA[json]]></category>
            <category><![CDATA[pyspark]]></category>
            <category><![CDATA[parquet]]></category>
            <dc:creator><![CDATA[Debi Aprilia]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 16:24:25 GMT</pubDate>
            <atom:updated>2026-09-28T16:24:25.101Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RwRkxkPeqRjhOpxKpzVp5A.jpeg" /></figure><p>Parquet merupakan format penyimpanan berkas terkompresi berbentuk kolom (<em>columnar storage</em>) yang dirancang untuk pengolahan Big Data secara efisien dalam ekosistem Apache Spark, Hadoop, dan data warehouse modern.</p><p>CSV atau <em>Comma Separated Values</em> merupakan format penyimpanan data sederhana berbentuk data tabular (tabel spreadsheet atau tabel basis data) yang setiap nilainya dipisahkan oleh tanda koma.</p><p>JSON atau <em>JavaScript Object Notation</em> merupakan format pertukaran data ringan berbasis teks semi terstruktur yang menggunakan <em>key — value pairs</em> dan struktur array (daftar).</p><h4>6.1 Mengapa Parquet, bukan Sekadar CSV?</h4><p>Cara kerja CSV adalah seperti membaca buku, baris demi baris, dari kiri ke kanan. Jika ingin mencari total pada salah satu kolom atau baris, harus membaca keseluruhan isi kolom dan baris tersebut. Sedangkan cara kerja Parquet adalah setiap kolom dipisah ke dalam halaman atau buku catatannya sendiri. Sehingga ketika ingin mencari total suatu kolom, bisa langsung melihat ke kolom tersebut tanpa harus melihat kolom lain. Jadi, Parquet lebih unggul jika digunakan untuk mengolah Big Data. Perbedaan Parquet dan CSV dapat dilihat pada tabel berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xST0XNOLdiwHKuBPJzZ8DA.jpeg" /></figure><p>Sebelum melihat bagaimana Parquet bekerja, lakukan persiapan dengan cara memastikan environment bigdata aktif dengan mengetikkan perintah <strong>conda activate bigdata</strong> di terminal. Kemudian, pastikan Hadoop aktif dengan memasukkan perintah <strong>start-dfs.sh</strong> dan <strong>start-yarn.sh</strong> di terminal. Kemudian perintah <strong>jps</strong> untuk menampilkan 5 proses yang sedang berjalan di hadoop. Kemudian, masuk ke folder praktikum dengan perintah <strong>cd ~/praktikum-bigdata</strong>. Lalu yang terakhir masukkan perintah <strong>jupyter notebook</strong> untuk membuka jupyter notebook dari terminal yang akan otomatis terbuka di browser. Kemudian buat SparkSession seperti yang sudah dilakukan pada praktikum sebelumnya seperti berikut.</p><pre>from pyspark.sql import SparkSession<br>from pyspark.sql.functions import col, sum as spark_sum, avg, count<br>import numpy as np<br>import pandas as pd<br>import os<br><br>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan6-ParquetETL&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br>print(&quot;SparkSession siap. Versi Spark:&quot;, spark.version)</pre><p>Spark siap digunakan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*EJsU8uJM8msZiOT6CPMLMA.png" /></figure><h4>6.1.1 Membandingkan Ukuran CSV vs Parquet Secara Langsung</h4><p>Untuk membandingkan ukuran CSV dan Parquet, kita membutuhkan dataset berukuran besar agar perbedaannya terlihat jelas. Kode blok berikut digunakan untuk membuat dataset yang berjumlah 20.000 baris dengan kolom :</p><ul><li>order_id → id pesanan dibuat berurutan dari 00 sampai 019999</li><li>customer_id → id pelanggan dibuat acak antara 1–20</li><li>kategori → diacak dari 5 kategori yaitu Elektronik, Fashion, Makanan, Rumah Tangga, dan Kesehatan</li><li>kota → diacak dari 5 kota yaitu Magelang, Semarang, Solo, Yogyakarta, dan Purworejo</li><li>metode_pembayaran → diacak dari 4 metode pembayaran yaitu Transfer Bank, E — Wallet, COD, dan Kartu Kredit</li><li>pendapatan → diacak dari angka antara 50.000 sampai 500.000</li></ul><p>Kemudian, DataFrame diubah dan disimpan menjadi file CSV. Lalu kode akan menampilkan ukuran file dalam satuan bytes dan informasi dicetak untuk menampilkan ukuran file serta jumlah barisnya.</p><pre># Membuat dataset yang lebih besar (20.000 baris) khusus untuk latihan ini<br>np.random.seed(11)<br>n = 20000<br>data_besar = {<br>    &quot;order_id&quot;: [f&quot;O{i}&quot; for i in range(n)],<br>    &quot;customer_id&quot;: np.random.randint(1, 21, size=n),<br>    &quot;kategori&quot;: np.random.choice([&quot;Elektronik&quot;, &quot;Fashion&quot;, &quot;Makanan&quot;, &quot;Rumah Tangga&quot;, &quot;Kesehatan&quot;], size=n),<br>    &quot;kota&quot;: np.random.choice([&quot;Magelang&quot;, &quot;Semarang&quot;, &quot;Solo&quot;, &quot;Yogyakarta&quot;, &quot;Purworejo&quot;], size=n),<br>    &quot;metode_pembayaran&quot;: np.random.choice([&quot;Transfer Bank&quot;, &quot;E-Wallet&quot;, &quot;COD&quot;, &quot;Kartu Kredit&quot;], size=n),<br>    &quot;pendapatan&quot;: np.random.randint(50000, 500000, size=n),<br>}<br>pd.DataFrame(data_besar).to_csv(&quot;data_transaksi_besar.csv&quot;, index=False)<br><br>csv_size = os.path.getsize(&quot;data_transaksi_besar.csv&quot;)<br>print(f&quot;Ukuran CSV: {csv_size:,} bytes ({csv_size/1024:.1f} KB) untuk {n:,} baris&quot;)</pre><p>Hasilnya, file CSV tersebut berukuran 892,909 bytes dengan jumlah baris 20,000 baris.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/399/1*EXAaF3rLcQskGY4KisbD4Q.png" /></figure><p>Kemudian, file CSV dibaca (<strong>spark.read.csv()</strong>) dan dituliskan ulang (<strong>df_besar.write.mode().parquet()</strong>) menjadi format Parquet menggunakan PySpark. Kemudian, file Parquet tersebut dihitung keseluruhan total ukuran file tersebut (<strong>parquet_size = sum(…)</strong>). Kemudian, hasilnya dicetak dan ukurannya dibandingkan dengan ukuran file CSV.</p><pre># Membaca CSV, lalu menuliskannya ulang sebagai Parquet<br>df_besar = spark.read.csv(&quot;data_transaksi_besar.csv&quot;, header=True, inferSchema=True)<br>df_besar.write.mode(&quot;overwrite&quot;).parquet(&quot;data_transaksi_besar_parquet&quot;)<br><br># Menghitung total ukuran seluruh berkas .parquet yang dihasilkan<br>parquet_size = sum(<br>    os.path.getsize(os.path.join(dp, f))<br>    for dp, dn, fn in os.walk(&quot;data_transaksi_besar_parquet&quot;)<br>    for f in fn if f.endswith(&quot;.parquet&quot;)<br>)<br><br>print(f&quot;Ukuran CSV      : {csv_size:,} bytes ({csv_size/1024:.1f} KB)&quot;)<br>print(f&quot;Ukuran Parquet  : {parquet_size:,} bytes ({parquet_size/1024:.1f} KB)&quot;)<br>print(f&quot;Parquet {(1 - parquet_size/csv_size)*100:.1f}% lebih kecil dibanding CSV&quot;)</pre><p>Hasilnya, ukuran file Parquet lebih kecil 77.4% dibandingkan dengan ukuran file CSV. Ukuran file CSV sebesar 892,909 bytes, sedangkan ukuran 202,197 bytes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*_69vtLNjp0hUEN8zMRmOiA.png" /></figure><p>Jadi, ketika suatu kolom memiliki nilai yang sama misal kata ‘Magelang’ sebanyak 10.000 kali, maka file CSV akan menulis dan menyimpan kata ‘Magelang’ berulang sebanyak 10.000 kali. Sedangkan file Parquet akan menulis dan menyimpan kata ‘Magelang’ hanya sekali pada tabel referensi, dan mencatat bahwa nilai tersebut muncul sebanyak 10.000 kali.</p><h4>6.1.2 Skema Otomatis Tersimpan di Parquet</h4><p>Untuk mengetahui tipe data suatu kolom pada Spark, file CSV membutuhkan parameter ‘<strong>inferSchema=True</strong>’ untuk menebak tipe data tersebut. Sedangkan file Parquet tidak membutuhkannya karena skema data sudah otomatis tersimpan di dalam metadata file Parquet tersebut.</p><p>Untuk membaca file Parquet di Spark gunakan perintah ‘<strong>spark.read.parquet(…)</strong>’. Kemudian cetak skema yang berfungsi untuk menampilkan struktur tabel (nama kolom dan tipe datanya) ke konsol dalam bentuk pohon (<em>tree</em>). Lalu gunakan perintah ‘<strong>show()</strong>’ untuk menampilkan isi DataFrame tersebut dalam bentuk tabel.</p><pre># Membaca kembali Parquet — perhatikan kita TIDAK perlu inferSchema=True<br># karena skema/tipe data sudah tersimpan built-in di dalam berkas Parquet itu sendiri<br>df_dari_parquet = spark.read.parquet(&quot;data_transaksi_besar_parquet&quot;)<br>df_dari_parquet.printSchema()<br>df_dari_parquet.show(5)</pre><p>Hasilnya, akan menampilkan ‘root’ dengan nama kolom dan tipe datanya dengan struktur <em>tree</em>. Kemudian, output juga menampilkan 5 baris pertama.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*bG7zbiWK24kBh9gDdOkgdQ.png" /></figure><h4>6.2 Partitioning saat Menulis Data</h4><p>Partitioning adalah teknik membagi dataset berukuran besar ke dalam sub — folder terpisah berdasarkan nilai unik dari kolom tertentu. Contoh Partition Pruning atau efisiensi kueri pada kolom ‘<strong>kota</strong>’ misalnya pada perintah ‘<strong>WHERE kota = ‘Magelang</strong>’ ’, Spark tidak akan memindai seluruh dataset dari awal sampai akhir, akan tetapi Spark hanya akan membaca isi folder ‘<strong>kota=Magelang</strong>’ dan mengabaikan folder lainnya. Jika mencari satu kota dalam satu dataset berukuran 1 TB tidak menggunakan partisi, akan memakan waktu lama karena harus memindai file 1 TB penuh. Dengan partisi, Spark hanya akan membaca beberapa Megabyte saja.</p><p>Blok kode berikut digunakan untuk menyimpan data ke dalam folder/file parquet bernama ‘<strong>data_transaksi_partisi_kota</strong>’ dengan mode ‘<strong>overwrite</strong>’ yaitu jika sudah ada data lain dengan nama yang sama, maka spark akan menimpa data lama tersebut. Baris data dikelompokkan (<strong>partitionBy()</strong>) berdasarkan kolom ‘<strong>kota</strong>’ dan hasilnya dipisahkan ke sub — folder masing — masing. Untuk melihat struktur folder yang dihasilkan dari proses partisi dengan perintah ‘<strong>!ls</strong>’.</p><pre># Menulis ulang dengan partisi berdasarkan kolom &#39;kota&#39;<br>df_besar.write.mode(&quot;overwrite&quot;).partitionBy(&quot;kota&quot;).parquet(&quot;data_transaksi_partisi_kota&quot;)<br><br># Melihat struktur folder yang dihasilkan<br>!ls data_transaksi_partisi_kota</pre><p>Hasilnya, setiap sub — folder ditampilkan dengan format ‘<strong>nama_kolom=nilai</strong>’ yang disebut sebagai <em>Hive — style partitioning</em>. Di dalam folder tersebut tersimpan file parquet untuk masing — masing data transaksi dari kota tersebut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/996/1*Ied0JraJ9s6kXqrrsbhV6Q.png" /></figure><h4>6.3 Membaca Data JSON (Semi — Terstruktur)</h4><p>JSON merupakan data semi terstruktur yang biasanya berasal dari API web, log sistem, atau basis data NoSQL. JSON Lines / NDJSON (<em>Newline Delimited JSON</em>) yaitu setiap satu baris merepresentasikan satu objek JSON. Spark dapat membaca dan mengurai setiap baris data tanpa harus membaca seluruh isi file, sehingga format JSON lebih mudah diproses secara terdistribusi oleh Spark.</p><p>Blok kode berikut digunakan untuk membuat file JSON Lines :</p><ul><li><strong>import json</strong> → untuk mengimpor modul agar bisa bekerja dengan format data JSON</li><li><strong>np.random.seed(21)</strong> → untuk menghasilkan angka acak yang konsisten setiap kali kode dijalankan ulang</li><li><strong>pelanggan = […]</strong> → membuat dictionary yang berisi 20 data pelanggan dengan atribut customer_id, nama, membership, dan kota_domisili</li><li><strong>with open(“data_pelanggan.json”, “w”) as f:</strong> → untuk membuka file data_pelanggan dengan mode write</li><li><strong>f.write(json.dumps(p) + “\n”)</strong> → untuk mengubah dictionary Python menjadi string JSON, dengan ‘<strong>\n</strong>’ untuk membentuk format JSON Lines (satu objek per baris)</li></ul><pre>import json<br><br># Membuat data pelanggan sebagai JSON Lines (satu objek JSON per baris — format umum untuk big data)<br>np.random.seed(21)<br>pelanggan = [<br>    {<br>        &quot;customer_id&quot;: i,<br>        &quot;nama&quot;: f&quot;Pelanggan{i}&quot;,<br>        &quot;membership&quot;: np.random.choice([&quot;Silver&quot;, &quot;Gold&quot;, &quot;Platinum&quot;]),<br>        &quot;kota_domisili&quot;: np.random.choice([&quot;Magelang&quot;, &quot;Semarang&quot;, &quot;Solo&quot;, &quot;Yogyakarta&quot;, &quot;Purworejo&quot;])<br>    }<br>    for i in range(1, 21)<br>]<br><br>with open(&quot;data_pelanggan.json&quot;, &quot;w&quot;) as f:<br>    for p in pelanggan:<br>        f.write(json.dumps(p) + &quot;\n&quot;)<br><br>print(&quot;Berkas data_pelanggan.json berhasil dibuat (format JSON Lines).&quot;)</pre><p>Hasilnya, file data_pelanggan.json berhasil dibuat dengan format JSON Lines.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/451/1*SF2znYacihLyqJNNGKPSUQ.png" /></figure><p>Kode blok berikut digunakan untuk membaca file JSON dan secara otomatis Spark dapat menentukan skema atau tipe datanya. Kemudian hasilnya akan dicetak ke konsol serta menampilkan 5 baris pertamanya dalam bentuk DataFrame Spark.</p><pre># Membaca JSON menggunakan Spark — Spark otomatis mendeteksi struktur/skema JSON<br>df_pelanggan = spark.read.json(&quot;data_pelanggan.json&quot;)<br>df_pelanggan.printSchema()<br>df_pelanggan.show(5)</pre><p>Hasilnya, dapat diketahui bahwa file tersebut memiliki 4 kolom dan berhasil menampilkan DataFrame dalam bentuk tabel.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*zY93-YCv3_Wa1FF4UFtY0g.png" /></figure><h4>6.4 Membangun Pipeline ETL Sederhana</h4><p>ETL merupakan pola kerja paling fundamental dalam Data Engineering dan pemrosesan Big Data untuk mengolah data agar siap dianalisis.</p><p><strong>Tahap 1 : EXTRACT (Mengambil Data)</strong></p><p>Extract merupakan proses mengambil atau membaca data dari berbagai sumber data yang berbeda — beda bentuk, seperti gabungan file CSV, JSON, database SQL, atau sistem lainnya.</p><p>Perintah dalam kode blok berikut digunakan untuk membaca file data_transaksi.csv dengan format CSV dan data_pelanggan.json dengan format JSON Lines. Kemudian menghitung jumlah total baris pada masing — masing DataFrame untuk memastikan apakah data berhasil dimuat dengan benar.</p><pre># EXTRACT — membaca dari berbagai sumber<br>df_transaksi_etl = spark.read.csv(&quot;data_transaksi_besar.csv&quot;, header=True, inferSchema=True)<br>df_pelanggan_etl = spark.read.json(&quot;data_pelanggan.json&quot;)<br><br>print(&quot;Data transaksi:&quot;, df_transaksi_etl.count(), &quot;baris&quot;)<br>print(&quot;Data pelanggan:&quot;, df_pelanggan_etl.count(), &quot;baris&quot;)</pre><p>Hasilnya menunjukkan bahwa data berhasil dimuat dengan data transaksi berjumlah 20.000 baris, sedangkan data pelanggan berjumlah 20 baris.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*D9-090ceZ9p4JOiA9z7dCA.png" /></figure><p><strong>Tahap 2 : TRANSFORM (Mengubah dan Membersihkan Data)</strong></p><p>Transform merupakan proses membersihkan dan memperkaya data seperti menggabungkan (<em>Join</em>) beberapa tabel, menambah kolom baru, mengatasi <em>missing value</em> (data hilang), serta menjalankan <em>data quality check.</em></p><p>Perintah dalam kode blok berikut digunakan untuk menggabungkan kedua DataFrame berdasarkan kolom ‘<strong>customer_id</strong>’ dengan jenis <strong>Left Join</strong> yaitu seluruh transaksi (tabel kiri) akan dipertahankan meskipun ada pelanggan yang tidak tercatat. Proses berikutnya adalah membuat kolom baru bernama ‘<strong>segmen_transaksi</strong>’ yang akan diisi nilai dari mengkategorikan kolom pendapatan menjadi Tinggi, Sedang, dan Rendah. Proses berikutnya adalah melakukan verifikasi apakah proses join gagal yang ditunjukkan dengan apakah ada baris transaksi yang nama pelanggannya berisi ‘<strong>nul</strong>l’.</p><pre>from pyspark.sql.functions import when<br><br># TRANSFORM — menggabungkan, membersihkan, dan memperkaya data<br>df_etl = df_transaksi_etl.join(df_pelanggan_etl, on=&quot;customer_id&quot;, how=&quot;left&quot;)<br><br># Menambahkan kolom turunan: kategori nilai transaksi<br>df_etl = df_etl.withColumn(<br>    &quot;segmen_transaksi&quot;,<br>    when(col(&quot;pendapatan&quot;) &gt;= 300000, &quot;Tinggi&quot;)<br>    .when(col(&quot;pendapatan&quot;) &gt;= 150000, &quot;Sedang&quot;)<br>    .otherwise(&quot;Rendah&quot;)<br>)<br><br># Memastikan tidak ada data pelanggan yang gagal ter-join (data quality check sederhana)<br>jumlah_tanpa_pelanggan = df_etl.filter(col(&quot;nama&quot;).isNull()).count()<br>print(f&quot;Transaksi tanpa data pelanggan yang cocok: {jumlah_tanpa_pelanggan}&quot;)<br><br>df_etl.select(&quot;order_id&quot;, &quot;nama&quot;, &quot;membership&quot;, &quot;kategori&quot;, &quot;pendapatan&quot;, &quot;segmen_transaksi&quot;).show(5)</pre><p>Hasilnya, tidak ditemukan transaksi dengan tanpa data pelanggan yang cocok. Kemudian, berhasil menampilkan 5 baris pertama dalam DataFrame tersebut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*jlkz9ZIjL4vdWZqLCWcAsQ.png" /></figure><p><strong>Tahap 3 : LOAD (Menyimpan Data)</strong></p><p>Load merupakan proses menyimpan data yang sudah bersih dan terstruktur ke tujuan akhir seperti <em>data warehouse</em>, <em>data lake</em>, atau HDFS dalam format yang efisien seperti Parquet agar dapat digunakan oleh tim analyst.</p><p>Perintah dalam kode blok berikut digunakan untuk menyimpan data ke dalam HDFS dengan cara membuat direktori baru terlebih dahulu, kemudian melakukan partisi berdasarkan kolom ‘kategori’, dan menyimpan DataFrme final dengan format Parquet ke dalam HDFS.</p><pre># LOAD — menyimpan hasil akhir ke HDFS dalam format Parquet, terpartisi berdasarkan kategori<br>!hdfs dfs -mkdir -p /user/mahasiswa/etl_output<br><br>df_etl.write.mode(&quot;overwrite&quot;).partitionBy(&quot;kategori&quot;).parquet(<br>    &quot;hdfs://localhost:9000/user/mahasiswa/etl_output/transaksi_enriched&quot;<br>)<br><br>print(&quot;Pipeline ETL selesai — hasil tersimpan di HDFS.&quot;)<br>!hdfs dfs -ls /user/mahasiswa/etl_output/transaksi_enriched</pre><p>Hasilnya, pipeline ETL berhasil dilakukan dan data berhasil disimpan di HDFS. Data disimpan dalam format parquet berdasarkan kategori masng — masing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*sxfNyTjTUb4i-eRyBcHgmA.png" /></figure><p><strong>Verifikasi hasil akhir dengan membaca kembali dari HDFS</strong></p><p>Perintah pada blok kode berikut digunakan untuk membaca file dengan format Parquet yang disimpan di dalam HDFS, kemudian menghitung jumlah baris dalam DataFrame tersebut yang bertujuan untuk memastikan jumlah data yang dibaca dari HDFS konsisten dan tidak ada data hilang selama penulisan dan pembacaan kembali. Kemudian data dikelompokkan dan di agregasi sebagai bukti bahwa data siap digunakan untuk analisis lanjut.</p><pre>df_final = spark.read.parquet(&quot;hdfs://localhost:9000/user/mahasiswa/etl_output/transaksi_enriched&quot;)<br>print(&quot;Jumlah baris hasil akhir:&quot;, df_final.count())<br><br># Ringkasan cepat sebagai bukti data siap dipakai untuk analisis lebih lanjut<br>df_final.groupBy(&quot;segmen_transaksi&quot;).agg(<br>    count(&quot;order_id&quot;).alias(&quot;jumlah_transaksi&quot;),<br>    avg(&quot;pendapatan&quot;).alias(&quot;rata_rata_pendapatan&quot;)<br>).orderBy(&quot;segmen_transaksi&quot;).show()</pre><p>Hasilnya, data berjumlah 20.000 baris berhasil dibaca kembali dan tidak ada data yang hilang, kemudian output juga menampilkan hasil agregasi dan mengelompokkan data berdasarkan kolom ‘segmen_transaksi’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*-bOuTO-Uacz7CrlJvuVQ9g.png" /></figure><h4>Menutup SparkSession</h4><p>Jangan lupa untuk menutup sesi Spark ketika selesai digunakan untuk membebaskan memori yang sudah digunakan.</p><pre>spark.stop()<br>print(&quot;SparkSession ditutup.&quot;)</pre><h4>Latihan Mandiri</h4><p>Sebelum mengerjakan soal latihan mandiri, karena sebelumnya sesi Spark sudah ditutup, maka buat ulang sesi Spark dan baca ulang file data_transaksi_besar.csv &amp; data_pelanggan.json.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*EkhrI-SyxnbUHR6MoOaw3w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/897/1*8WCWBO4FVdexX3ZYdLu8lA.png" /></figure><p>File data_transaksi_besar.csv dibaca dan disimpan di dalam variabel <strong>df_transaksi_etl</strong>. Sedangkan file data_pelanggan.json dibaca dan disimpan dalam variabel <strong>df_pelanggan_etl</strong>.</p><pre># Persiapan ulang untuk latihan<br>spark = SparkSession.builder.appName(&quot;Latihan6&quot;).master(&quot;local[*]&quot;).getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br>df_transaksi_etl = spark.read.csv(&quot;data_transaksi_besar.csv&quot;, header=True, inferSchema=True)<br>df_pelanggan_etl = spark.read.json(&quot;data_pelanggan.json&quot;)<br>print(&quot;Siap untuk latihan.&quot;)</pre><p><strong>Soal 1.</strong> Baca kembali data_transaksi_besar_parquet (hasil Sub-bab 6.1.1) menggunakan spark.read.parquet(), lalu tampilkan printSchema()-nya. Bandingkan dengan skema hasil inferSchema=True pada CSV — apakah tipe datanya sama?</p><p>File data_transaksi_besar_parquet dibaca menggunakan fungsi <strong>spark.read.parquet()</strong> yang otomatis membaca skema yang ada di dalam file parquet tersbut. Kemudian, masing — masing file Parquet dan file CSV ditampilkan skemanya menggunakan fungsi <strong>printSchema()</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/895/1*ecsDOKoroy6RZEaIOXAYRA.png" /></figure><p>Hasilnya, tipe data pada kedua DataFrame adalah sama, dapat dilihat pada gambar berikut. Perbedaan keduanya hanya pada perintah untuk membaca filenya. Pada file parquet cukup memanggil fungsi <strong>printSchema()</strong>, sedangkan pada file CSV perlu menambahkan parameter <strong>inferSchema=True</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/895/1*E-k2PPqzB9h3nlJfKiMQmw.png" /></figure><p><strong>Soal 2.</strong> Gabungkan df_transaksi_etl dengan df_pelanggan_etl, lalu tampilkan jumlah transaksi untuk masing-masing nilai membership (Silver/Gold/Platinum).</p><p>Untuk menampilkan jumlah transaksi untuk masing — masing nilai di kolom membership, pertama gabungkan terlebih dahulu DataFrame <strong>transaksi</strong> dan <strong>pelanggan</strong> berdasarkan kolom ‘<strong>customer_id</strong>’ dengan teknik <em>left join</em>. Kemudian baris dikelompokkan berdasarkan nilai pada kategori kolom membership dan menghitung total baris yang ada pada masing — masing jenis membership.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/892/1*CnBmxiToVzNjyzb2OeXb0Q.png" /></figure><p>Hasilnya, akan menampilkan jumlah transaksi yang terjadi pada masing — masing nilai atau jenis di kolom ‘<strong>membership</strong>’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/892/1*TZlhMklseBwwMjHpsbo1dA.png" /></figure><p><strong>Soal 3.</strong> Tulis ulang hasil gabungan Soal 2 (sebelum di-groupBy) ke disk lokal dalam format Parquet, dipartisi berdasarkan membership. Tampilkan struktur foldernya dengan !ls.</p><p>Untuk menuliskan ulang hasil gabungan dapat menggunakan mode ‘<strong>overwrite</strong>’ untuk menimpa data lama jika nama file yang sama sudah ada. File dipartisi berdasarkan kolom ‘<strong>membership</strong>’ menjadi sub-folder terpisah. Kemudian file disimpan pada direktori lokal dengan nama ‘<strong>data_transaksi_partisi_membership</strong>’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/892/1*DRN0CRk4dveRKGANjkw9XQ.png" /></figure><p>Hasilnya, struktur folder akan menampilkan sub-folder yang berhasil dibuat seperti pada gambar berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/482/1*Di5OOGYVcG6p46hbDTEOmA.png" /></figure><p><strong>Soal 4 (Refleksi singkat).</strong> Dalam 2–3 kalimat: mengapa partitioning berdasarkan kolom kota cocok untuk skenario kita, namun akan menjadi <strong>pilihan buruk</strong> jika diterapkan pada kolom seperti order_id yang nilainya selalu unik di setiap baris?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/889/1*ujQs9FBp8RNN2bp2DcWEhg.png" /></figure><h4>Tugas Mandiri</h4><p>Tugas Mandiri dapat diakses pada link GitHub berikut :</p><p><a href="https://github.com/DebiAprilia/bigdata2026/blob/main/Tugas6_2320506038_DebiAprilia.ipynb">bigdata2026/Tugas6_2320506038_DebiAprilia.ipynb at main · DebiAprilia/bigdata2026</a></p><h4>Kesimpulan</h4><p>Parquet merupakan sebuah format penyimpanan berbasis columnar (<em>columnar storage</em>), sedangkan CSV merupakan sebuah format penyimpanan berbasis baris (<em>row-based</em>). Format Parquet lebih hemat penyimpanan karena file otomatis dikompresi dengan struktur kolumnar. Selain itu, Parquet bisa menebak secara otomatis tipe data dan nama kolom tanpa menambahkan perintah ‘inferSchema=True’. Dalam proses pencarian data, format Parquet menggunakan teknik <em>Partition Pruning</em> yaitu dapat langsung membuka sub-folder yang diinginkan tanpa harus membaca keseluruhan isi datanya, sehingga proses pencarian data jadi lebih cepat. Dalam pengolahan Big Data terdapat pola kerja ETL atau <em>Extract</em> (mengambil data), <em>Transform</em> (mengubah dan memperkaya data), dan <em>Load</em> (menyimpan data).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=01f9561d7c2d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PySpark DataFrame Lanjutan : Join, Window Function, dan Spark SQL — Praktikum Big Data]]></title>
            <link>https://medium.com/@debi.aprilia/pyspark-dataframe-lanjutan-join-window-function-dan-spark-sql-praktikum-big-data-e9129438bdd6?source=rss-c81725c91e44------2</link>
            <guid isPermaLink="false">https://medium.com/p/e9129438bdd6</guid>
            <category><![CDATA[pyspark]]></category>
            <category><![CDATA[bigdata-analytics]]></category>
            <category><![CDATA[apache-spark]]></category>
            <dc:creator><![CDATA[Debi Aprilia]]></dc:creator>
            <pubDate>Wed, 23 Sep 2026 16:17:00 GMT</pubDate>
            <atom:updated>2026-09-23T16:17:00.057Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KKF6iyu-ElTzqmMdXgi1kg.jpeg" /></figure><p>PySpark merupakan antarmuka untuk Apache Spark di dalam Python. PySpark dapat digunakan untuk memproses data terdistribusi, menganalisis data dengan cepat dan efisien, serta mudah diintegrasikan dengan tools lain seperti Hadoop dan Hive. PySpark juga dapat digunakan untuk mengeksekusi kueri SQL secara langsung untuk data yang terdistribusi.</p><h4>Membuat SparkSession dan Dataset</h4><p>Sebelum menggunakan Spark kita perlu memulai sebuah sesi Spark tersebut terlebih dahulu dengan mengimpor <strong>SparkSession</strong>. Tanpa perintah ini, tidak akan ada sesi Spark sehingga kita tidak bisa menggunakan struktur DataFrame dan Dataset pada PySpark. Kemudian, impor fungsi bawaan PySpark untuk memanipulasi kolom dan analisis data seperti :</p><ul><li><strong>col</strong> → untuk mereferensikan atau memanggil nama kolom tertentu yang ada di dalam DataFrame agar bisa diolah.</li><li><strong>sum as spark_sum</strong> → untuk menghitung total penjumlahan data. Fungsi ini ditulis ‘<strong>sum as spark_sum</strong>’ karena nama fungsi aslinya adalah ‘<strong>sum</strong>’ yang bisa bertabrakan dengan fungsi asli Python ‘<strong>sum()</strong>’. Alias ini digunakan agar Python tidak bingung membedakan antara fungsi bawaan Python dan fungsi dari PySpark.</li><li><strong>avg</strong> → untuk menghitung rata — rata.</li><li><strong>count</strong> → untuk menghitung jumlah baris.</li><li><strong>rank</strong> → merupakan salah satu <em>window function</em> untuk menberi peringkat pada baris berdasarkan kriteria tertentu, dengan nilai yang sama akan mendapat peringkat sama. Contoh : 1, 2, 2, 4.</li><li><strong>row_number</strong> → merupakan salah satu <em>window function</em> untuk memberi nomor urut unik pada setiap baris secara berurutan meskipun ada nilai yang sama. Contoh : 1, 2, 3, 4.</li><li><strong>when</strong> → untuk membuat kondisi percabangan logika seperti pernyataan <em>IF — THEN — ELSE</em>.</li></ul><pre>from pyspark.sql import SparkSession<br>from pyspark.sql.functions import col, sum as spark_sum, avg, count, rank, row_number, when<br>from pyspark.sql.window import Window<br><br>spark = SparkSession.builder \<br>    .appName(&quot;Pertemuan5-JoinWindowSQL&quot;) \<br>    .master(&quot;local[*]&quot;) \<br>    .getOrCreate()<br>spark.sparkContext.setLogLevel(&quot;ERROR&quot;)<br><br>print(&quot;SparkSession siap. Versi Spark:&quot;, spark.version)</pre><p>Ketika blok kode tersebut dijalankan, akan menghasilkan output seperti gambar berikut. Output tersebut bukan eror, akan tetapi merupakan pesan peringatan atau <em>warning</em> yang bersifat informatif dari sistem Apache Spark. Blok kode tersebut berhasil dieksekusi karena output menampilkan teks konfirmasi bahwa SparkSession berhasil dibuat.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4frHOly16XM7b1U3qY_DAg.png" /></figure><p>Kemudian, buat dua DataFrame PySpark untuk simulasi analisis data dan latihan operasi join dan agregasi. Blok kode berikut akan menghasilkan DataFrame dengan nama :</p><ul><li><strong>df_transaksi</strong> → berisi 300 data transaksi acak menggunakan NumPy (<strong>np.random</strong>).</li><li><strong>df_produk</strong> → berisi tabel referensi atau master yang memetaakan setiap kategori produk dengan target bulanan dan nama manager yang bertanggung jawab.</li></ul><p>Beberapa fungsi untuk mengacak data yang digunakan adalah sebagai berikut :</p><ul><li><strong>np.random.seed(7)</strong> → untuk mengunci hasil acak data yang dihasilkan oleh NumPy agar konsisten dan selalu sama ketika kode dijalankan ulang. Angka yang ada di dalam tanda kurung berfungsi sebagai penanda atau kunci dari rumus tersebut.</li><li><strong>np.random.choice()</strong> → untuk memilih elemen secara acak dari daftar atau array yang sudah ada.</li><li><strong>np.random.randint() </strong>→ untuk menghasilkan angka acak berupa bilangan bulat (integer) dari rentang yang sudah kita tentukan.</li></ul><pre>import numpy as np<br>import pandas as pd<br><br>np.random.seed(7)<br>kategori_list = [&quot;Elektronik&quot;, &quot;Fashion&quot;, &quot;Makanan &amp; Minuman&quot;, &quot;Kesehatan &amp; Kecantikan&quot;, &quot;Rumah Tangga&quot;]<br><br># Tabel referensi/master: target &amp; manager per kategori (data ini relatif statis, jarang berubah)<br>data_produk = {<br>    &quot;kategori&quot;: kategori_list,<br>    &quot;target_bulanan&quot;: [50000000, 40000000, 30000000, 25000000, 20000000],<br>    &quot;manager&quot;: [&quot;Andi&quot;, &quot;Budi&quot;, &quot;Citra&quot;, &quot;Dewi&quot;, &quot;Eka&quot;],<br>}<br>df_produk = spark.createDataFrame(pd.DataFrame(data_produk))<br><br># Tabel transaksi: data yang terus bertambah setiap hari<br>n = 300<br>data_transaksi = {<br>    &quot;order_id&quot;: [f&quot;O{i}&quot; for i in range(n)],<br>    &quot;kategori&quot;: np.random.choice(kategori_list, size=n),<br>    &quot;kota&quot;: np.random.choice([&quot;Magelang&quot;, &quot;Semarang&quot;, &quot;Solo&quot;], size=n),<br>    &quot;pendapatan&quot;: np.random.randint(50000, 500000, size=n),<br>}<br>df_transaksi = spark.createDataFrame(pd.DataFrame(data_transaksi))<br><br>print(&quot;df_produk:&quot;)<br>df_produk.show()<br>print(&quot;df_transaksi (5 baris pertama dari total&quot;, df_transaksi.count(), &quot;baris):&quot;)<br>df_transaksi.show(5)</pre><p>Hasilnya, kedua DataFrame tersebut berhasil dibuat dengan output blok kode yang menampilkan isi tabel ‘<strong>df_produk’</strong> secara keseluruhan, serta menampilkan 5 baris pertama dari 300 data pada DataFrame ‘<strong>df_transaksi’</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zUEsuT4asTqbSZD-gpLVeA.png" /></figure><h4>Menggabungkan DataFrame dengan join()</h4><p>Operasi <strong>join()</strong> digunakan untuk menggabungkan baris dari dua atau lebih DataFrame berdasarkan kolom kunci (<em>key column</em>) yang saling berkaitan. Sintaks dasar join() pada PySpark DataFrame adalah sebagai berikut.</p><pre>df_hasil = df1.join(df2, on=&quot;kolom_kunci&quot;, how=&quot;jenis_join&quot;)</pre><p>Jenis — jenis join :</p><p>a. <strong>Inner Join</strong> → hanya baris yang memiliki pasangan atau kesamaan di kedua DataFrame yang akan ditampilkan. Jenis ini dapat digunakan ketika membutuhkan data yang benar — benar lengkap dan ada di kedua DataFrame.</p><p>b. <strong>Left Join atau Left Outer Join</strong> → seluruh baris di DataFrame kiri akan dicocokkan dengan DataFrame yang ada di kanan. Kemudian, jika ditemukan pasangan di tabel kanan, tabel kiri akan dilengkapi dengan tabel kanan. Jika tidak ditemukan pasangan, maka nilai akan diisi null.</p><p>c. <strong>Right Join atau Right Outer Join</strong> → seluruh baris di DataFrame kanan akan dicocokkan dengan DataFrame yang ada di kiri. Kemudian, jika ditemukan pasangan di tabel kiri, tabel kanan akan dilengkapi dengan tabel kiri. Jika tidak ditemukan pasangan, maka nilai akan diisi null.</p><p>d. <strong>Outer Join atau Full Join</strong> → seluruh baris dari tabel di sebelah kanan dan kiri akan digabungkan baik yang memiliki pasangan atau tidak. Jika baris memiliki kecocokan, maka baris akan digabungkan secara utuh. Jika tidak memiliki kecocokan, maka akan tetap muncul dengan nilai null.</p><p>Contoh penerapan masing — masing jenis join adalah sebagai berikut.</p><ul><li><strong>Left Join — Melihat Detail Transaksi Beserta Info Manager</strong></li></ul><p>Blok kode berikut digunakan untuk menggabungkan tabel <strong>‘df_transaksi’</strong> dengan tabel ‘<strong>df_produk</strong>’. Kolom yang digunakan sebagai kunci penghubung antar tabel tersebut adalah kolom kategori (<strong>on=“kategori”</strong>). Jika pada baris tersebut kategori sama di kedua tabel, maka baris akan digabung. Jenis penggabungan yang digunakan adalah <em>left join, </em>yaitu jika ada kategori sama, tabel di sebelah kiri akan dipertahankan dan informasi dari tabel kanan seperti <em>target_bulanan</em> dan nama <em>manager</em> akan digabungkan.</p><pre>df_gabung = df_transaksi.join(df_produk, on=&quot;kategori&quot;, how=&quot;left&quot;)<br>df_gabung.show(5)</pre><p>Hasilnya, akan menampilkan kolom yang berasal dari DataFrame ‘<strong>df_transaksi</strong>’ yaitu kolom kategori, order_id, kota, dan pendapatan serta kolom tambahan dari DataFrame ‘<strong>df_produk’</strong> yaitu kolom target_bulanan dan manager. Dengan menggabungkan kedua DataFrame tersebut, kita dapat melihat informasi yang lebih lengkap dengan mudah.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F003aU4grn1rFdRsJM7lZA.png" /></figure><ul><li><strong>Inner Join Setelah Agregasi — Kasus yang Lebih Realistis</strong></li></ul><p>Blok kode berikut terdiri dari 3 langkah yang bertujuan untuk menghitung total pendapatan per kategori, menggabungkan dengan target bulanan, menghitung persentase pencapaian target, serta mengurutkan dari yang tertinggi.</p><p>→ <strong>Langkah 1</strong> : data dikelompokkan berdasarkan kategori produk dengan perintah ‘<strong>groupBy(“kategori”)</strong>’. Kemudian data pada kolom pendapatan dijumlahkan untuk setiap kategori, lalu nama kolom yang digunakan untuk menyimpan hasilnya diubah menjadi <strong>total_pendapatan</strong>.</p><p>→ <strong>Langkah 2</strong> : kemudian menggabungkan tabel ringkasan pendapatan dengan DataFrame df_produk menggunakan metode <em>inner join</em> berdasarkan kolom kategori. Lalu, membuat kolom baru bernama ‘<strong>pencapaian_persen</strong>’ yang diisi dengan cara membagi total pendapatan dengan target bulanan kemudian di kali dengan 100.</p><p>→ <strong>Langkah 3</strong> : data diurutkan berdasarkan kolom pencapaian_persen dari pencapaian terbesar ke terkecil, kemudian hasilnya dicetak.</p><p>Kode program disusun untuk agregasi terlebih dahulu, kemudian join karena jauh lebih efisien dibanding join terlebih dahulu baru agregasi. Jika join terlebih dahulu, harus menggabungkan data berjumlah 300 baris. Sedangkan jika agregasi terlebih dahulu, hanya akan menggabungkan 5 baris kategori saja, sehingga lebih sedikit dan lebih efisien.</p><pre># Langkah 1: Meringkas total pendapatan per kategori<br>ringkasan = df_transaksi.groupBy(&quot;kategori&quot;).agg(<br>    spark_sum(&quot;pendapatan&quot;).alias(&quot;total_pendapatan&quot;)<br>)<br><br># Langkah 2: Join dengan tabel target untuk menghitung pencapaian<br>hasil = ringkasan.join(df_produk, on=&quot;kategori&quot;, how=&quot;inner&quot;)<br>hasil = hasil.withColumn(<br>    &quot;pencapaian_persen&quot;,<br>    (col(&quot;total_pendapatan&quot;) / col(&quot;target_bulanan&quot;) * 100)<br>)<br><br>hasil.orderBy(col(&quot;pencapaian_persen&quot;).desc()).show()</pre><p>Hasilnya, terdapat 5 kategori dengan masing — masing total pendapatan, target bulanan, manager yang bertanggung jawab pada masing — masing kategori, serta persentase pencapaian target ditampilkan pada output. Dari output terlihat bahwa manager bernama Eka mencapai persentase tertingggi sebesar 86.22% pada kategori Rumah Tangga.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lXajo_VbpXhPmtTi6x3lMw.png" /></figure><h4>Window Function</h4><p>Window Function berfungsi untuk melakukan perhitungan kelompok seperti mencari peringkat, rata — rata, atau total tanpa menghapus detail baris aslinya. Proses yang terjadi di dalam Window Function diibaratkan seperti jendela. Pertama, membuat kelompok (<em>Partition By</em>) dengan mengelompokkan data berdasarkan kategori tertentu. Kemudian, data diurutkan (<em>Order By</em>) dan melakukan perhitungan untuk memberi peringkat, lalu hasilnya langsung ditampilkan di dalam data tersebut.</p><pre># Mendefinisikan &quot;window&quot;: kelompokkan berdasarkan kategori, urutkan dari pendapatan tertinggi<br>window_spec = Window.partitionBy(&quot;kategori&quot;).orderBy(col(&quot;pendapatan&quot;).desc())<br><br># Menambahkan kolom peringkat SETIAP transaksi di dalam kategorinya masing-masing<br>df_ranked = df_transaksi.withColumn(&quot;rank_dalam_kategori&quot;, rank().over(window_spec))<br><br># Menampilkan hanya 2 transaksi teratas (rank 1 dan 2) di setiap kategori<br>df_ranked.filter(col(&quot;rank_dalam_kategori&quot;) &lt;= 2) \<br>    .orderBy(&quot;kategori&quot;, &quot;rank_dalam_kategori&quot;) \<br>    .show(10)</pre><p>Outputnya menampilkan tabel berisi 5 kolom dengan dua transaksi dengan pendapatan tertinggi pada masing — masing kategori.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e6yK3zkbqvVwgl5Shcm7lQ.png" /></figure><h4>Spark SQL — Menjalankan Kueri SQL di Atas DataFrame</h4><p>Spark dapat digunakan untuk menuliskan kueri SQL langsung terhadap DataFrame tanpa harus menggunakan sintaks DataFrame API. Caranya adalah sebagai berikut.</p><p><strong>Langkah 1: Daftarkan DataFrame sebagai “tabel sementara” (temporary view)</strong></p><p>Kode program berikut digunakan untuk mendaftarkan DataFrame df_transaksi dan df_produk menjadi tabel sementara (<em>temporary view</em>). Dengan fungsi ‘<strong>createOrReplaceTempView()</strong>’, jika nama ‘transaksi’ dan ‘produk’ sudah ada, maka fungsi ini akan menimpa nama lama dengan yang baru dengan aman. Dengan mendaftarkan kedua DataFrame tersebut ke <em>temporary view</em>, maka kita bisa menggunakan perintah SQL secara langsung pada baris kode selanjutnya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K7BLEnqGU5U2O4GUfCUFZQ.png" /></figure><p><strong>Langkah 2: Jalankan kueri SQL menggunakan spark.sql()</strong></p><p>Untuk menuliskan kueri SQL secara langsung dalam PySpark gunakan perintah <strong>spark.sql(‘‘‘ … ’’’)</strong>. Tanda kutip tiga digunakan untuk menulis kueri SQL multi-baris agar mudah dibaca.</p><pre>hasil_sql = spark.sql(&#39;&#39;&#39;<br>    SELECT t.kategori, p.manager, SUM(t.pendapatan) AS total_pendapatan<br>    FROM transaksi t<br>    JOIN produk p ON t.kategori = p.kategori<br>    GROUP BY t.kategori, p.manager<br>    ORDER BY total_pendapatan DESC<br>&#39;&#39;&#39;)<br>hasil_sql.show()</pre><p>Hasil outputnya menampilkan sebuah tabel ringkasan dari kueri SQL yang menampilkan kolom kategori, manager, dan total_pendapatan. Ini berarti kueri SQL yang dijalankan di dalam ekosistem PySpark dapat berjalan dengan baik.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k5fiDYZTJKSUUGlGiFSQTg.png" /></figure><h4>Latihan Mandiri</h4><p>Sebelum mengerjakan soal latihan, jalankan ulang kedua cell berikut untuk pembuatan SparkSession dan untuk membuat DataFrame ‘df_transaksi’ dan ‘df_produk’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YHs9X1b42EQIMllX8OftUQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HhMlvhZCJECY4K3_nTcZLA.png" /></figure><p>Kemudian jalankan cell berikut sebagai persiapan awal sebelum mengerjakan latihan. Kode cell tersebut digunakan untuk membuat ulang SparkSession dengan nama aplikasi “<strong>Latihan5</strong>”, mengatur log eror, mengunci angka acak agar data tetap konsisten, membuat kembali DataFrame untuk data produk dan transaksi, serta mendaftarkan DataFrame tersebut sebagai tabel <em>temporary view</em> agar dapat digunakan untuk kueri SQL.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ImTd8kItVMFCGaxJmQSgzA.png" /></figure><p><strong>Soal 1.</strong> Menggunakan DataFrame API (join), tampilkan seluruh transaksi kota &quot;Solo&quot; beserta nama manager dari kategorinya masing-masing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1008/1*SFcYEBg3b-cyfuQnd-P-5g.png" /></figure><p>Keterangan :</p><ul><li><strong>df_transaksi.filter(col(“kota”) == “Solo”)</strong> → untuk menyaring data transaksi yang terjadi di kota Solo.</li><li><strong>.join(df_produk, on=”kategori”, how=”inner”)</strong> → untuk menggabungkan data hasil filter dengan DataFrame df_produk berdasarkan kolom kategori, dengan menggunakan jenis inner join yang berarti hanya baris yang kategorinya sama di kedua tabel yang akan digabungkan.</li><li><strong>.select(“order_id”, “kategori”, “kota”, “pendapatan”, “manager”)</strong> → untuk memilih kolom yang ingin ditampilkan dari kedua DataFrame.</li><li><strong>show(n=300, truncate=False)</strong> → untuk menampilkan seluruh transaksi yang ada di kota Solo dengan argumen ‘n=300&#39; yang berarti menampilkan baris dengan maksimal 300 data, serta argumen ‘truncate=False’ digunakan agar teks di dalam kolom tidak terpotong atau disingkat.</li></ul><p>Sehingga outputnya akan menampilkan seluruh transaksi yang ada di kota Solo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/517/1*jfJQCIWXjzNfpkcCwB9AVA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/525/1*I7N-J5xH-IzqHffkD9uSVA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*UCQvpIbBUWFhiWmyT6OeRw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/522/1*8mMbYV-1c0pDbsIaa6d37g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*qUFGCnMvCqtPu9j_7ZSlaw.png" /></figure><p><strong>Soal 2.</strong> Menggunakan <strong>window function</strong>, tentukan transaksi dengan pendapatan <strong>tertinggi</strong> (peringkat 1 saja) di <strong>setiap kota</strong> (bukan kategori). tidak boleh menggunakan rank().</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*Wa6tQt7SU0H9VzycTyeACg.png" /></figure><p>Keterangan :</p><ul><li><strong>Window.partitionBy(“kota”).orderBy(col(“pendapatan”).desc())</strong> → untuk membuat spesifikasi window function yang mengelompokkan data berdaar kota dan mengurutkan baris berdasarkan pendapatan terbesar ke terkecil.</li><li><strong>row_number().over(window_kota)</strong> → karena tidak diperbolehkan menggunakan rank(), maka row_number() digunakan untuk memberikan nomor urut dengan unik pada setiap transaksi pada masing — masing kota, kemudian setiap kota hanya diambil 1 transaksi teratas.</li><li><strong>.withColumn(“rn”, …) → </strong>untuk menambahkan kolom sementara yang menyimpan nomor urut tersebut dengan nama rn (row number).</li><li><strong>.filter(col(“rn”) == 1)</strong> → untuk menyaring DataFrame agar hanya menampilkan baris yang memiliki nilai rn = 1 yang menunjukkan transaksi dengan pendapatan tertinggi di setiap kota.</li><li><strong>.drop(“rn”)</strong> → untuk menghapus kolom sementara yang membantu mengurutkan pendapatan agar tampilan output tetap rapi seperti semula.</li></ul><p>Sehingga outputnya akan menampilkan transaksi dengan pendapatan tertinggi di setiap kota.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*7Uty8109cEeQPX_tclDfEw.png" /></figure><p><strong>Soal 3.</strong> Menggunakan <strong>Spark SQL</strong> (bukan DataFrame API), tulis kueri untuk menghitung rata-rata pendapatan per kota, urutkan dari tertinggi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*o8_OwFKe905bSKwzypnmfQ.png" /></figure><p>Keterangan :</p><ul><li><strong>spark.sql(“‘…’’’)</strong> → untuk menjalankan kueri SQL di dalam PySpark pada temporary view yang sudah dibuat pada saat persiapan sebelum mengerjakan latihan.</li><li><strong>SELECT kota, AVG(pendapatan) AS avg_pendapatan</strong> → untuk memilih kolom kota dan menghitung rata — rata pendapatan di setiap kota, lalu memberi alias nama kolom baru untuk menyimpan hasilnya.</li><li><strong>FROM transaksi</strong> → untuk mengambil data dari tabel sementara transaksi.</li><li><strong>GROUP BY kota</strong> → untuk mengelompokkan baris data berdasarkan kota agar fungsi AVG() menghitung pada masing — masing kota.</li><li><strong>ORDER BY avg_pendapatan DESC</strong> → untuk mengurutkan hasil berdasarkan rata — rata pendapatan dari yang tertinggi ke terendah.</li></ul><p>Sehingga outputnya akan menampilkan rata — rata pendapatan per kota dan datanya urut dari pendapatan tertinggi ke pendapatan terendah.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*JzEBA8pOUD4U8zRaG52-sA.png" /></figure><p><strong>Soal 4</strong> (Refleksi singkat).** Dalam 2–3 kalimat: menurut anda, dalam situasi seperti apa anda akan lebih memilih menulis Spark SQL dibanding DataFrame API pada pekerjaan anda nanti?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*aE1QHqj6LtfK8LbuU4tQ8w.png" /></figure><h4>Tugas Mandiri</h4><p>Tugas mandiri dapat di akses pada link GitHub berikut :</p><p><a href="https://github.com/DebiAprilia/bigdata2026/blob/main/Tugas5_2320506038_DebiAprilia.ipynb">bigdata2026/Tugas5_2320506038_DebiAprilia.ipynb at main · DebiAprilia/bigdata2026</a></p><h4>Kesimpulan</h4><p>PySpark memiliki berbagai jenis operasi <em>join</em> yang dapat digunakan untuk menggabungkan data seperti <em>inner join</em>, <em>left join</em>, <em>right join</em>, dan<em> outer join</em>. Pengolahan Big Data dapat lebih efisien jika menerapkan agregasi terlebih dahulu sebelum melakukan join karena proses agregasi dapat mengurangi jumlah baris data terlebih dahulu sebelum data digabung. Kombinasi join, window function, dan Spark SQL akan memudahkan evaluasi performa bisnis secara terukur.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e9129438bdd6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Instalasi Apache Spark dan Pengenalan PySpark DataFrame — Praktikum Big Data]]></title>
            <link>https://medium.com/@debi.aprilia/instalasi-apache-spark-dan-pengenalan-pyspark-dataframe-praktikum-big-data-978a0360a6ec?source=rss-c81725c91e44------2</link>
            <guid isPermaLink="false">https://medium.com/p/978a0360a6ec</guid>
            <category><![CDATA[pyspark-dataframes]]></category>
            <category><![CDATA[ubuntu]]></category>
            <category><![CDATA[apache-spark]]></category>
            <category><![CDATA[big-data]]></category>
            <dc:creator><![CDATA[Debi Aprilia]]></dc:creator>
            <pubDate>Wed, 16 Sep 2026 15:04:30 GMT</pubDate>
            <atom:updated>2026-09-16T15:04:30.519Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xabfi_hKwjuQAuI7laInGw.jpeg" /></figure><p><strong>Apache Spark</strong> merupakan mesin analitik (<em>unified analytics engine</em>) yang bersifat <em>open — source</em> yang dirancang untuk memproses data besar secara terdistribusi. Spark mengeksekusi komputasi di dalam memori, sehingga prosesnya lebih cepat dan efisien untuk analisis data interaktif, <em>batch processing</em>, serta <em>machine learning</em>. Perbedaan Apache Spark dengan MapReduce klasik pada kecepatan pemrosesan datanya adalah jika MapReduce klasik akan memproses data secara bertahap yang membuat prosesnya lambat, sedangkan Apache Spark memproses data langsung di dalam memori sehingga dapat memproses data 10–100 kali lebih cepat. Selain itu, MapReduce klasik mengoperasikan data dengan menjalankan setiap instruksi secara langsung dan menyimpan output ke dalam disk, sedangkan Apache Spark menggunakan sifat <em>Lazy Evaluation</em> yaitu operasi transformasi data seperti<strong> filter() </strong>dan <strong>select() </strong>hanya dicatat sebegai <em>Execution Plan</em> dan akan dijalankan ketika perintah <em>action</em> seperti <strong>.show()</strong> dan <strong>.count()</strong> dipanggil. MapReduce klasik sangat terikat dengan HDFS untuk penyimpanan input dan outputnya, sedangkan Apache Spark tidak memiliki penyimpanan bawaan tersendiri tetapi bertindak murni sebagai <em>processing engine</em>.</p><p><strong>PySpark DataFrame</strong> merupakan struktur data terdistribusi dua dimensi yang diorganisir ke dalam kolom dan baris berlabel (memiliki schema nama dan tipe data), mirip tabel pada basis data relasional atau DataFrame pada library pandas. PySpark DataFrame dibangun di atas <em>Resilient Distributed Dataset</em> (RDD). Namun, DataFrame menyediakan API tingkat tinggi yang mudah digunakan dan dioptimalkan secara otomatis oleh Spark.</p><p>Sebelum memulai praktikum, pastikan perintah ‘<strong>conda activate bigdata’</strong> di terminal Ubuntu berhasil. Pastikan Hadoop berjalan dengan perintah ‘<strong>start-dfs.sh</strong>’ dan ‘<strong>start-yarn.sh</strong>’. Serta pastikan folder ‘<strong>~/praktikum-bigdata</strong>’ dan perintah ‘<strong>jupyter notebook</strong>’ berhasil dijalankan dari terminal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*ZTCES-lkt-sg_2W3zNLjug.png" /></figure><h4>Download dan Ekstrak Apache Spark 3.5.9</h4><p>Untuk mengunduh <strong>Apache Spark 3.5.9</strong> jalankan perintah berikut di terminal dan tunggu sampai prosesnya selesai 100%.</p><pre>#Arahkan lokasi unduh ke home directory<br>cd ~<br>#Masukkan perintah berikut ke terminal untuk mengunduh Apache Spark<br>wget https://downloads.apache.org/spark/spark-3.5.9/spark-3.5.9-bin-hadoop3.tgz</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1019/1*ggOHMnNx0_Zyuk7LuU_Qkw.png" /></figure><p>Jika proses unduh sudah selesai, ekstrak file menggunakan perintah berikut.</p><pre>#Masukkan perintah ini ke terminal untuk mengekstrak file <br>tar -xzvf spark-3.5.9-bin-hadoop3.tgz</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/623/1*VpkI2AEti9U1Fh9tEWf3tg.png" /></figure><p>Kemudian, pindahkan file yang sudah diekstrak ke dalam file bernama spark dengan perintah berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/577/1*D4fLwQA3tRw2DUqjPkBoRA.png" /></figure><p>Lalu, pastikan folder spark berhasil dibuat dan diunduh dengan memasukkan perintah ‘<strong>ls ~/spark</strong>’ dan pastikan terdapat folder seperti bin, yarn, jars, python, dll. seperti pada gambar berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/661/1*SJtGlH_FMxr9eyLr3U_lYw.png" /></figure><h4>Konfigurasi Environment Variables</h4><p>Pertama, edit kembali file ~/.bashrc menggunakan perintah ‘<strong>nano ~/.bashrc’</strong> yang digunakan untuk membuka file .bashrc diterminal Ubuntu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/987/1*7MmET7P1dNqHeUzHQ1ooqw.png" /></figure><p>Kemudian, tambahkan baris berikut di bagian akhir file untuk konfigurasi Spark.</p><pre># Konfigurasi Spark — Praktikum Big Data<br>export SPARK_HOME=$HOME/spark<br>export PATH=$PATH:$SPARK_HOME/bin:$SPARK_HOME/sbin<br>export PYSPARK_PYTHON=python3</pre><p>Setelah selesai menambahkan konfigurasi, simpan perubahan dengan menekan tombol Ctrl + O lalu tekan enter, dan tekan Ctrl + X untuk keluar dari nano.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BiJki4QUpeZ0pHIAlrzrPA.png" /></figure><p>Kemudian muat ulang file ~/.bashrc agar konfigurasi Spark terbaca oleh sistem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HBW9PAylhvUBzfzFdxakHw.png" /></figure><p>Setelah itu lakukan verifikasi untuk mengetahui letak folder Spark di simpan dengan perintah ‘<strong>echo $SPARK_HOME</strong>’ serta lakukan verifikasi untuk memastikan versi Spark yang berhasil dipasang dengan perintah ‘<strong>spark-submit - -version</strong>’. Jika berhasil, output akan menampilkan versi Spark 3.5.9 serta logo ASCII Spark seperti gambar berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m7p2DPMOxQ8pF2NBHQd_CA.png" /></figure><h4>Instalasi PySpark di Environment bigdata</h4><p>Agar Spark dapat dipanggil langsung dari Jupyter, maka perlu install package PySpark terlebih dahulu di dalam conda environment bigdata yang sudah dibuat kemarin. Caranya adalah dengan memastikan kita sedang berada di environment bigdata (masukkan perintah ‘conda activate bigdata’), kemudian masukkan perintah untuk instal package pyspark ini ‘<strong>pip install pyspark==3.5.9</strong>’. Tunggu sampai proses unduh selesai.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YAES4IP9O6jPoooYd8L6qg.png" /></figure><p>Kemudian, verifikasi instalasi dengan memasukkan perintah berikut.</p><pre>python -c &quot;import pyspark; print(&#39;PySpark&#39;, pyspark.__version__)&quot;</pre><p>Outputnya adalah pyspark dan versinya yaitu PySpark 3.5.9 .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/1*A3T6y18Vx98xq640wZ4XSQ.png" /></figure><h4>Melanjutkan di Jupyter Notebook</h4><p>Untuk melanjutkan di Jupyter Notebook, buka terminal baru, lalu jalankan perintah berikut untuk mengaktifkan environment bigdata dan membuka modul di Jupyter Notebook menggunakan terminal.</p><pre>#Aktifkan environment bigdata<br>conda activate bigdata<br><br>#Masuk ke folder praktikum-bigdata<br>cd ~/praktikum-bigdata<br><br>#Buka Jupyter Notebook<br>jupyter notebook</pre><h4>Membuat SparkSession</h4><p><strong>SparkSession</strong> merupakan titik masuk utama untuk bekerja dengan Spark DataFrame. SparkSession<strong> wajib</strong> dibuat di awal setiap script atau notebook PySpark karena berfungsi untuk membuka koneksi sebelum menggunakan Spark.</p><p>Keterangan baris kode :</p><ul><li><strong>from pyspark.sql import SparkSession</strong> → ini merupakan perintah wajib agar DataFrame dan SQL di Spark dapat digunakan. Yaitu dengan mengimpor SparkSession dari modul pyspark.sql .</li><li><strong>spark = SparkSession.builder \ → </strong>merupakan perintah untuk membuat objek menggunakan pola builder dan hasilnya disimpan di variabel bernama ‘spark’. Tanda <em>backslash</em> (\) digunakan untuk memecah perintah panjang menjadi beberapa baris agar mudah dibaca.</li><li><strong>.appName(“Pertemuan4-PengenalanPySpark”) \</strong> <strong>→ </strong>untuk memberi nama aplikasi Spark ini, yaitu ‘Pertemuan4-PengenalanPySpark’. Nama aplikasi ini digunakan agar saat membuka Spark Web UI aplikasi mudah diidentifikasi.</li><li><strong>.master(“local[*]”) \</strong> <strong>→ </strong>untuk menentukan Spark akan berjalan di mana. Dengan argumen ‘local[*]’ berarti Spark berjalan dikomputer lokal dengan menggunakan seluruh inti CPU yang ada di komputer.</li><li><strong>.getOrCreate()</strong> <strong>→ </strong>untuk mengecek apakah sudah ada SparkSession yang aktif atau belum, jika sudah ada maka akan menggunakan sesi tersebut, jika belum ada maka akan membuat sesi baru.</li><li><strong>spark.sparkContext.setLogLevel(“ERROR”)</strong> <strong>→ </strong>output pada Spark biasanya akan mengeluarkan banyak pesan informasi (INFO) dan peringatan (WARN) sehingga output dipenuhi teks yang panjang. Dengan mengubah log level menjadi ‘ERROR’, spark hanya akan menampilkan kesalahan fatal.</li><li><strong>print(“SparkSession berhasil dibuat!”)</strong> <strong>→ </strong>untuk tanda bahwa proses inisialisasi Spark berhasil.</li><li><strong>print(“Versi Spark:”, spark.version)</strong> <strong>→ </strong>untuk menampilkan informasi versi spark di layar atau output.</li></ul><p>Keterangan Output :</p><p>Output yang berada di dalam kotak berwarna merah muda menampilkan beberapa peringatan (WARN) yang muncul sebelum baris pengaturan log level dieksekusi. Tetapi, bukan berarti Spark gagal dijalankan. Spark berhasil dijalankan karena berhasil mencetak perintah yang menampilkan ‘<strong>SparkSession berhasil dibuat!</strong>’ dan ‘<strong>Versi Spark: 3.5.9</strong>’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yxdV_RY5O_vxLPf5GXDsHA.png" /></figure><h4>Memuat Data ke Spark DataFrame</h4><p>Perintah berikut akan menghasilkan dataset transaksi e — commerce buatan secara otomatis dan menyimpannya ke dalam format CSV. Perintah yang digunakan adalah :</p><ul><li><strong>if not os.path.exists(“data_transaksi_ecommerce.csv”):</strong> <strong>→ </strong>baris ini digunakan untuk memeriksa apakah file dengan nama tersebut sudah ada atau belum, jika tidak ada maka baris berikutnya akan dieksekusi untuk membuat data.</li><li><strong>np.random.seed(42)</strong> → baris ini digunakan untuk mengacak data dengan menetapkan <em>seed</em> agar setiap kode ini dijalankan, hasil acakan datanya akan selalu sama.</li><li><strong>data = {…}</strong> → baris — baris di dalamnya digunakan untuk menyusun dataset menjadi dictionary Python. Perintah ‘<strong>np.random.choice</strong>’ untuk memilih nilai secara acak dengan parameter tambahan ‘<strong>p=[…]</strong>’ untuk mengatur probabilitas peluang terpilihnya suatu nilai untuk dimasukkan ke dalam tabel.</li><li><strong>pd.DataFrame(data).to_csv(“data_transaksi_ecommerce.csv”, index=False)</strong> → perintah ini akan mengubah dictionary menjadi tabel terstruktur menggunakan ‘<strong>pd.DataFrame()</strong>’, kemudian perintah ‘<strong>.to_csv()</strong>’ agar langsung disimpan dengan file ‘.csv’. Parameter ‘<strong>index=False</strong>’ untuk memastikan bahwa nomor baris tidak ikut disimpan sebagai kolom baru.</li><li>Outputnya menunjukkan bahwa sistem tidak menemukan file dengan nama tersebut, kemudian program membuat baris data acak, lalu disimpan menjadi file ‘.csv’, kemudian pesan ‘Dataset dibuat ulang’ dicetak. Jika kode dijalankan dua kali, maka outputnya akan berubah menjadi ‘Dataset sudah tersedia.’</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*COLmyc8pyzwTNQTyDVaySQ.png" /></figure><p>Blok kode program berikut digunakan untuk membaca data dari file CSV lokal ke format Spark DataFrame dengan perintah ‘<strong>spark.read.csv(…)</strong>’. Perintah ‘<strong>inferSchema=True</strong>’ merupakan perintah penting untuk memindai data secara otomatis dan menebak tipe data yang digunakan pada masing — masing kolom.</p><p>Output hasil eksekusi diawali dengan status progress bar berwarna merah muda yang merupakan ciri khas saat Spark mengerjakan suatu tugas. Kemudian, baris pertama menunjukkan bahwa CSV berhasil dibaca. Kemudian, struktur root akan ditampilkan yaitu berisi struktur kolom dari dataset tersebut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-qK54QEOUqKuJi29n9jMwg.png" /></figure><p>Selanjutnya, kita dapat melihat isi data pada sebuah Spark DataFrame menggunakan perintah ‘<strong>df.show(5)</strong>’ yang akan menampilkan 5 data pertama di dalam dataset. Kemudian untuk mengetahui atau menghitung jumlah baris menggunakan perintah ‘<strong>df.count()</strong>’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S6ig2ojNKvYJWWLoUqHT9w.png" /></figure><h4>Operasi Dasar DataFrame: Select, Filter, GroupBy, Agg</h4><ul><li><strong>select()</strong> → digunakan untuk memilih kolom tertentu</li></ul><p>Perintah dalam blok kode program dibawah ini digunakan untuk menampilkan 5 data pertama dan hanya menampilkan kolom <strong>order_id</strong>, <strong>kota</strong>, dan<strong> kategori </strong>saja.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*28nb9zHaOjaKqGO78CqFmg.png" /></figure><ul><li><strong>filter()</strong> → digunakan untuk menyaring baris sesuai kondisi yang diinginkan</li></ul><p>Perintah dalam blok kode program dibawah ini digunakan untuk menyaring baris — baris data di dalam DataFrame agar menampilkan data yang memenuhi dua syarat sekaligus yaitu <strong>kategori</strong> barang Elektronik dan <strong>jumlah unit</strong> yang terjual lebih dari 5. Kemudian hasilnya akan ditampilkan tapi hanya 5 baris pertama saja.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4K5iNDD_Ud61HH0phpL_sw.png" /></figure><ul><li><strong>groupBy() dan agg()</strong> → digunakan untuk meringkas data</li></ul><p>Perintah dalam blok kode program dibawah ini digunakan untuk menganalisis performa penjualan di tiap kota. Pertama buat kolom baru yang berisi perhitungan total pendapatan dari masing — masing transaki kemudian dikalikan dengan unit yang terjual dengan harga satuannya. Kemudian data dikelompokkan (groupBy) berdasarkan kota, lalu diurutkan dari kota dengan pendapatan tertinggi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zKlp2JuOz701pY7W5UIJUQ.png" /></figure><h4>Membaca Data Langsung dari HDFS</h4><p>Pertama, buat direktori baru dengan perintah ‘<strong>-mkdir</strong>’, pada baris awal perintah ada tanda seru <strong>(!)</strong> yang berarti baris ini bukan kode Python tapi perintah dijalankan di terminal dari notebook. Kemudian, argumen ‘<strong>-p</strong>’ memastikan bahwa belum ada folder induk dan secara otomatis folder dibuat tanpa eror. Baris berikutnya terdapat perintah ‘<strong>-put</strong>’ untuk mengunggah file dan argumen ‘<strong>-f</strong>’ yang berarti force untuk menimpa file dengan nama yang sama dengan file baru.</p><p>Kemudian PySpark mengarahkan untuk membaca file langsung dari HDFS dengan mengetikkan alamat NameNode yang menyimpan file tersebut. Perintah terakhir digunakan untuk menampilkan 5 baris pertama data tersebut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BjZdybpb99xOQG0WwZ39HQ.png" /></figure><p>Apache Spark diciptakan untuk mengatasi kelemahan MapReduce yang lambat memproses data karena harus selalu menyimpan hasilnya di dalam disk. Akan tetapi, Spark tidak memiliki sistem penyimpanannya sendiri. Sehingga Spark dirancang untuk memproses data dengan cepat, sedangkan HDFS sebagai tempat penyimpanannya.</p><h4>Menutup SparkSession</h4><p>Setelah selesai menggunakan Spark, jangan lupa untuk selalu menutup sesi Spark yang sudah berjalan tadi dengan perintah ‘<strong>spark.stop()</strong>’. Hal ini berfungsi untuk membebaskan RAM dan CPU yang sudah digunakan agar tidak berjalan terus di latar belakang.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FXmXWoxE4Bz1I9SNUOoiGw.png" /></figure><h4>Latihan Mandiri</h4><p>Sebelum mengerjakan latihan mandiri, buat SparkSession terlebih dahulu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/331/1*ALah5lSK7ErzpTq74Tk7kw.png" /></figure><p>Blok kode berikut digunakan untuk mempersiapkan environment Spark dan memuat data yang akan digunakan. Dataset dibaca kemudian dimodifikasi dengan menambahkan kolom baru bernama total_pendapatan. Dataset tersebut berjumlah 600 baris dan siap digunakan untuk latihan analisis data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/657/1*Mil5EVCnhCKlBuULhvvx9Q.png" /></figure><p>Untuk melihat struktur tabel dan 5 baris pertama pada dataset gunakan perintah ‘<strong>show()</strong>’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/986/1*VTK7l0bT82-1ZmEeUCg1aw.png" /></figure><p><strong>Soal 1.</strong> Tampilkan hanya kolom order_id, kategori, dan total_pendapatan untuk transaksi dengan metode_pembayaran bernilai &quot;E-Wallet&quot;.</p><p>Untuk menampilkan data transaksi yang menggunakan metode pembayaran berupa E-Wallet gunakan perintah <strong>filter()</strong> untuk menyaring data tersebut. Kemudian gunakan perintah<strong> select()</strong> untuk menampilkan hanya kolom yang disebutkan saja yaitu kolom order_id, kategori, dan total_pendapatan. Lalu, perintah <strong>show()</strong> untuk menampilkan hasilnya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*owd5zeQDnVLXmmLUbOUOMw.png" /></figure><p><strong>Soal 2.</strong> Hitung total pendapatan <strong>per kategori</strong> (bukan per kota), urutkan dari yang tertinggi.</p><p>Untuk menghitung total pendapatan per kategori gunakan perintah <strong>df.groupBy(“kategori”)</strong> untuk mengelompokkan data transaksi berdasarkan jenis kategorinya. Kemudian jumlahkan total pendapatan per kategori dengan perintah <strong>spark_sum()</strong> dan kolom hasilnya tetap diberi nama ‘total_pendapatan’. Lalu, hasil perhitungan diurutkan dari yang terbesar ke terkecil dengan perintah <strong>desc()</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/663/1*DZa20vMwODEUQY1BszWoUA.png" /></figure><p><strong>Soal 3.</strong> Tampilkan jumlah transaksi untuk masing-masing metode_pembayaran (tidak pakai agg).</p><p>Untuk menampilkan jumlah transaksi untuk masing — masing metode pembayaran, gunakan perintah <strong>groupBy()</strong>. Kemudian hitung jumlah transaksi masing — masing kelompok dengan perintah <strong>count()</strong>. Kemudian tampilkan hasilnya dengan perintah <strong>show()</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/1*QvJ3gmqb_sC2FzhULbgHfg.png" /></figure><p><strong>Soal 4 (Refleksi singkat).</strong> Dalam 2–3 kalimat: apa yang dimaksud dengan <em>lazy evaluation</em> di PySpark, dan mengapa hal ini menguntungkan ketika bekerja dengan data berskala besar? Tulis jawaban pada markdown cell di bawah ini.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PYWdC2l0rk8m7EWwM22G-Q.png" /></figure><h4>Tugas Mandiri</h4><p>Tugas mandiri dapat di akses pada link GitHub berikut :</p><p><a href="https://github.com/DebiAprilia/bigdata2026/blob/main/Tugas4_2320506038_DebiAprilia.ipynb">bigdata2026/Tugas4_2320506038_DebiAprilia.ipynb at main · DebiAprilia/bigdata2026</a></p><h4>Kesimpulan</h4><p>Apache Spark menyediakan alat pemrosesan data besar yang cepat berbasis memori dengan fitur <em>Lazy Evaluation</em> — nya untuk mengoptimalkan eksekusi data. Pada praktikum kali ini telah berhasil mengintegrasikan antara PySpark, Jupyter Notebook, dan HDFS untuk mengolah data dengan berbagai operasi data terdistribusi seperti select, filter, groupBy, dan agg.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=978a0360a6ec" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pengenalan Big Data dan Instalasi Apache Hadoop (Single — Node) — Praktikum Big Data]]></title>
            <link>https://medium.com/@debi.aprilia/pengenalan-big-data-dan-instalasi-apache-hadoop-single-node-praktikum-big-data-870228d3a9fe?source=rss-c81725c91e44------2</link>
            <guid isPermaLink="false">https://medium.com/p/870228d3a9fe</guid>
            <category><![CDATA[apache-hadoop]]></category>
            <dc:creator><![CDATA[Debi Aprilia]]></dc:creator>
            <pubDate>Tue, 08 Sep 2026 23:32:56 GMT</pubDate>
            <atom:updated>2026-09-08T23:32:56.786Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fScLR0TE3fyMj2iqlxPVpQ.jpeg" /></figure><p>Pada praktikum <a href="https://medium.com/@debi.aprilia/instalasi-python-environment-anaconda-pengenalan-jupyter-notebook-di-ubuntu-praktikum-big-data-29533930459b">sebelumnya</a>, kita berhasil membuat environment di Anaconda dan menjalankan Jupyter Notebook. Selanjutnya, kita akan mempelajari apa itu Hadoop Ecosystem. Tapi sebelum itu, pastikan Virtual Machine Ubuntu — Bigdata dapat digunakan tanpa eror. Caranya dengan memasukkan perintah <strong>conda activate bigdata</strong> di terminal, kemudian periksa apakah folder <strong>~/praktikum-bigdata</strong> masih ada, serta masukkan perintah <strong>jupyter notebook</strong> untuk menjalankan aplikasi tersebut.</p><h4>Konsep Dasar Big Data</h4><p>Big Data merupakan kumpulan data yang ukurannya sangat besar dan terdiri dari data terstruktur, semi terstruktur, dan tidak terstruktur. Big data memiliki 5 karakteristik yaitu :</p><ul><li><strong>Volume</strong> : data memiliki ukuran dan jumlah yang sangat besar</li><li><strong>Velocity</strong> : data memiliki kecepatan untuk dihasilkan, diproses, dan dianalisis</li><li><strong>Variety</strong> : data memiliki keragaman jenis yang bermacam — macam</li><li><strong>Veracity</strong> : data memiliki tingkat akurasi yang tinggi</li><li><strong>Value</strong> : data memiliki nilai yang dapat digunakan untuk mengambil keputusan</li></ul><h4>Hadoop Ecosystem</h4><p>Ekosistem Hadoop merupakan teknologi yang digunakan untuk menyimpan, memproses, menganalisis, dan mengolah data besar menggunakan komponen inti Hadoop yaitu HDFS, YARN, MapReduce, dan Hadoop Common.</p><ul><li><strong>HDFS (<em>Hadoop Distributed File System</em>)</strong> merupakan sistem penyimpanan terdistribusi untuk data terstruktur dan tidak terstruktur. HDFS terdiri dari <strong>NameNode</strong> (master yang menyimpan metadata) dan <strong>DataNode </strong>(slave yang menyimpan data sesungguhnya).</li><li><strong>YARN (<em>Yet Another Resource Negotiator</em>)</strong> merupakan lapisan manajemen sumber daya dan penjadwalan tugas. YARN terdiri dari <strong>ResourceManager</strong> (bertugas mengalokasikan sumber daya aplikasi), <strong>NodeManager</strong> (bertugas mengelola CPU/memori tiap node), dan <strong>ApplicationMaster</strong> (bertugas untuk menjembatani negosiasi sumber daya).</li><li><strong>MapReduce</strong> merupakan model pemrograman untuk pemrosesan data secara paralel. MapReduce dibagi menjadi dua fungsi yaitu <strong>Map()</strong> untuk mengelompokkan data menjadi <em>key — value pairs</em>, dan<strong> Reduce()</strong> untuk mengagregasi hasilnya.</li></ul><p>Pada kesempatan kali ini, Hadoop akan dijalankan dengan <strong>mode pseudo — distributed</strong>, yaitu mode di mana seluruh komponen Hadoop (NameNode, Datanode) akan dijalankan di satu mesin virtual. Hal ini bertujuan untuk mempelajari cara kerja Hadoop, menguji MapReduce dengan dataset kecil, dan menguji kode sebelum diimplementasikan ke klaster lokal.</p><h4>Instalasi Java (OpenJDK 11)</h4><p><strong>JDK (<em>Java Development Kit</em>)</strong> wajib terinstal karena Hadoop dibangun di atas Java. Untuk menginstal Java di virtual machine Ubuntu ikuti langkah — langkah berikut.</p><p>Pertama, buka terminal Ubuntu dan pastikan kembali environment <strong>bigdata</strong> dapat berjalan dengan baik dengan memasukkan perintah seperti gambar berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*pAQvIPhzfGhko5p6o6vRxg.png" /></figure><p>Masukkan perintah berikut yang masing — masing berfungsi untuk:</p><p>→ <strong>sudo</strong> : menjalankan perintah dengan hak akses administrator karena akan mengubah berkas sistem</p><p>→ <strong>apt</strong> : manajer paket untuk mengelola aplikasi</p><p>→ <strong>update</strong> : menyegarkan indeks lokal dengan server repositori</p><p>→<strong> install</strong> : mengunduh dan memasang aplikasi baru ke sistem</p><p>→ <strong>openjdk-11-jdk </strong>: nama paket dan versinya yang ingin diinstall</p><p>→ <strong>-y</strong> : memberi konfirmasi ‘yes’ secara otomatis untuk pertanyaan yang meminta persetujuan selama proses instalasi</p><pre>sudo apt update<br>sudo apt install openjdk-11-jdk -y</pre><p>Ketika memasukkan perintah pertama, kita diminta untuk memasukkan password username VM Ubuntu agar proses update bisa dilakukan. Ketikkan password lalu tekan enter, password yang kita ketikkan memang tidak terlihat pada layar terminal, akan tetapi sistem tetap bisa membaca apa yang kita ketikkan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/1*ugy9Ve2pXdAdHCZ96Z5vBA.png" /></figure><p>Untuk memastikan Java berhasil terpasang, lakukan verifikasi dengan memasukkan perintah berikut.</p><pre>java --version</pre><p>Jika instalasi Java berhasil, ketika memasukkan perintah tersebut akan menghasilkan output yang menampilkan versi Java yang berhasil terpasang.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*MsEN-NVg5ZlNGe5TY6Lf0A.png" /></figure><p>Setelah itu, lakukan pengecekan lokasi instalasi Java untuk konfigurasi Hadoop dengan perintah berikut.</p><pre>readlink -f $(which java)</pre><p>Outputnya akan menampilkan lokasi di mana Java disimpan. Catat hasil outputnya (<strong>/usr/lib/jvm/java-11-openjdk-amd64</strong>) untuk konfigurasi Hadoop nanti.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/528/1*f2LPStlLEJrhemF20-Nnyg.png" /></figure><h4>Konfigurasi SSH Tanpa Password</h4><p>Konfigurasi SSH tanpa password atau <em>passwordless SSH</em> tetap perlu dilakukan walaupun layanan SSH sudah aktif di sistem yang sama. Hadoop membutuhkan jalur komunikasi khusus agar proses start dan stop Hadoop tidak macet karena harus memasukkan password berkali — kali.</p><p>Pertama, masukkan perintah berikut ke terminal. Fungsi perintah tersebut adalah untuk menginstall paket yang akan mengubah komputer menjadi server SSH dan klien SSH.</p><pre>sudo apt install openssh-server openssh-client -y</pre><p>Tunggu proses instalasi selesai.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/1*plc-SSrBRtP4WibZcUhGpA.png" /></figure><p>Setelah itu, masukkan perintah berikut untuk membuat pasangan kunci SSH (<em>SSH key pair</em>) baru yang terdiri dari <em>private key</em> dan <em>public key</em> tanpa password.</p><p>→ <strong>ssh-keygen</strong> : untuk menggenerasi, mengelola, dan mengonversi kunci otentikasi SSH</p><p>→ <strong>-t rsa</strong> : untuk menentukan jenis/algoritma yang digunakan, yaitu RSA (<em>Rivest-Shamir-Adleman</em>)</p><p>→ <strong>-p ‘’</strong> : untuk menentukan password untuk <em>private key</em> dengan tanda petik kosong yang menandakan<em> private key</em> dibuat tanpa password.</p><p>→ <strong>-f ~/.ssh/id_rsa</strong> : untuk menentukan lokasi dan nama file penyimpanan kunci</p><pre>ssh-keygen -t rsa -P &#39;&#39; -f ~/.ssh/id_rsa</pre><p>Dari hasil output di bawah ini <em>private key</em> disimpan di <strong>~/.ssh/id_rsa</strong> dan <em>public key </em>disimpan ke <strong>~/.ssh/id_rsa.pub</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*TkSCU_4n7_yiknL-PWpuGg.png" /></figure><p>Selanjutnya, daftarkan <em>public key</em> agar dipercaya oleh mesin dengan memasukkan perintah berikut.</p><p>→ <strong>cat ~/.ssh/id_rsa.pub</strong> : perintah ini akan membaca isi file public key.</p><p>→ <strong>&gt;&gt;</strong> : operator append untuk menambahkan atau menyalin teks hasil pembacaan file tersebut.</p><p>→<strong> ~/.ssh/authorized_keys</strong> : merupakan folder tujuan untuk menyimpan public key.</p><p>→ <strong>chmood</strong> : kepanjangan dari <em>change mode</em> untuk mengubah hak akses</p><p>→ <strong>0600</strong> : kode untuk hak akses, <strong>angka 6</strong> berarti pemilik yang dapat read (membaca) dan write (mengubah), <strong>angka 0</strong> berarti grup tidak mendapat akses sama sekali, <strong>angka 0 </strong>lainnya atau others jugs tidak memiliki akses sama sekali.</p><pre>cat ~/.ssh/id_rsa.pub &gt;&gt; ~/.ssh/authorized_keys<br>chmod 0600 ~/.ssh/authorized_keys</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*6z-NVr1Bfv5PSKQ545c2eQ.png" /></figure><p>Kemudian masukkan perintah ‘<strong>ssh localhost</strong>’ untuk melihat apakah berhasil masuk sesi SSH tersebut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/747/1*n8GKufZ-ImgGFEjkZn9DPQ.png" /></figure><p>Jika sudah berhasil masuk, kemudian ketik ‘<strong>exit</strong>’ untuk keluar dari sesi SSH dan kembali ke terminal biasa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/329/1*dDjpWRlhlepFfdLb65VrRg.png" /></figure><h4>Unduh dan Ekstrak Apache Hadoopp 3.4.3</h4><p>Apache Hadoop di unduh dan disimpan di home directory. Untuk mengunduh Hadoop 3.4.3, masukkan perintah berikut ke terminal, tekan enter, lalu tunggu prosesnya sampai selesai. Perintah yang digunakan adalah <strong>wget</strong> yang digunakan untuk mengunduh file secara langsung dari internet yang melalui protokol HTTP, HTTPS, atau FTP.</p><pre>wget https://downloads.apache.org/hadoop/common/hadoop-3.4.3/hadoop-3.4.3.tar.gz</pre><p>Proses unduh selesai ketika proses sudah menunjukkan sampai 100% dan terdapat nama folder untuk menyimpan file unduhan tersebut. Pada gambar berikut file tersimpan dengan nama ‘hadoop-3.4.3.tar.gz.1’ karena ini merupakan proses pengunduhan yang kedua. Jika pada percobaan pertama proses unduh berhasil, folder tersebut akan otomatis bernama <strong>‘hadoop-3.4.3.tar.gz’</strong>. Sebenarnya ada cara lain agar tidak perlu mengunduh file dari awal, yaitu dengan mengetik ulang perintah <strong>wget</strong> dan menambahkan <strong>-c</strong> di depannya untuk melanjutkan mengunduh file (wget -c https:/…). Akan tetapi, penulis melakukan unduh ulang karena baru mengetahui cara tersebut ketika membuat laporan ini:)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/1*wRq_EhVUK0WIAy3r3wrv6w.png" /></figure><p>Kemudian, masukkan perintah untuk mengekstrak folder .tar.gz yang sudah di unduh tadi. Arti perintah -xzvf adalah sebagai berikut.</p><p>→ <strong>-x (eXtract)</strong> : memerintahkan tar untuk mengekstrak file yang ada di dalam arsip.</p><p>→<strong> -z (gzip) </strong>: menunjukkan bahwa folder arsip tersebut dikompresi dengan algoritma gzip (.gz), sehingga harus didekompresi terlebih dahulu.</p><p>→ <strong>-v (Verbose)</strong> : untuk menampilkan daftar semua file dan folder yang sedang diekstrak secara real — time di terminal. Hal ini memudahkan untuk memantau proses ektrak, akan tetapi terminal VM Ubuntu tidak bisa menampilkan kembali perintah — perintah yang sudah dimasukkan ke terminal sebelumnya.</p><p>→ <strong>f (File)</strong> : sebagai tanda bahwa perintah selanjutnya adalah nama folder yang akan diekstrak. Perintah ini harus diletakkan paling belakang sebelum nama folder yang ingin diekstrak.</p><pre>tar -xzvf hadoop-3.4.3.tar.gz.1</pre><p>Berikut adalah potongan output yang ditampilkan oleh terminal ketika proses ekstrak.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gVq6tyxDnld1FEinutZZNg.png" /></figure><p>Selanjutnya, ubah nama folder agar mudah dikonfigurasi, ubah dengan perintah <strong>mv (move)</strong> untuk mengganti nama folder, <strong>hadoop-3.4.3</strong> adalah nama folder yang ingin diganti, serta<strong> hadoop </strong>adalah nama baru untuk folder tersebut. Kemudian verifikasi folder tersebut dengan memasukkan perintah <strong>ls ~/hadoop , </strong>perintah ini digunakan untuk menampilkan folder yang ada di dalam folder hadoop yang terdiri dari bin, include, libexec, dll.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/726/1*wE_QoFBrBl9QmiLnYal_YQ.png" /></figure><h4>Konfigurasi Environment Variables</h4><p>Agar perintah hadoop dapat dipanggil dari mana saja tanpa mengetik path lengkap, tambahkan konfigurasi ke dalam file ~/.bashrc. Caranya dengan memasukkan perintah ‘<strong>nano ~/.bashrc</strong>’ yang berfungsi untuk membuka dan mengedit file menggunakan teks editor di terminal bernama Nano.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/417/1*7wXb4aX8j1VDX_FnnDHIpg.png" /></figure><p>Setelah file terbuka, tambahkan Konfigurasi Hadoop di bagian akhir file ~/.bashrc tersebut. Jika sudah simpan perubahan tersebut dengan menekan ‘<strong>Ctrl + o’</strong> , lalu tekan enter untuk menyimpan, kemudian keluar dari Nano dengan cara tekan <strong>‘Ctrl + x’</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*AMREtTDbeA-IiH_OU6bn-g.png" /></figure><p>Reload atau muat ulang konfigurasi dengan cara memasukkan perintah ‘<strong>source ~/.bashrc</strong>’. Perintah ini digunakan agar dapat mengaktifkan perubahan yang baru saja dilakukan di dalam file tersebut, serta perintah tersebut dapat langsung menerapkan path baru agar variabel baru bisa langsung dikenali dan digunakan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/331/1*dUTFfsWz62U5ctNzjNFiRQ.png" /></figure><p>Selanjutnya, lakukan verifikasi environment variabel apakah terbaca atau tidak. Dengan memasukkan perintah ‘<strong>echo $HADOOP_HOME</strong>’, maka dapat diketahui bahwa lokasi Hadoop tersimpan dengan benar pada ‘<strong>/home/deb/hadoop</strong>’. Kemudian, cek versi Hadoop yang terpasang pada sistem dengan perintah ‘<strong>hadoop version</strong>’. Outputnya adalah versi Hadoop yang berhasil diunduh yaitu <strong>Hadoop 3.4.3, </strong>serta detail buildnya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*7swQfkWqkgUp53fFrBVRog.png" /></figure><h4>Konfigurasi Berkas Hadoop</h4><p>Terdapat 5 file konfigurasi yang harus di edit karena Hadoop tidak mempunyai pengaturan default. File yang harus di edit semuanya ada di dalam folder <strong>~/hadoop/etc/hadoop/</strong> .</p><ul><li><strong>hadoop-env.sh</strong></li></ul><p>Hadoop dapat berjalan jika hadoop mengetahui di mana letak Java tersimpan. File ini harus di edit karena Hadoop menggunakan Java agar bisa dijalankan, jadi file ini diedit agar Hadoop dapat mengetahui letak Java. Untuk membuka file dan mengedit file ini, masukkan perintah berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/1*bdprZpOftBhn1ChO2rtcQA.png" /></figure><p>Kemudian setelah file terbuka, cari baris yang bertuliskan ‘<strong>export JAVA_HOME</strong>’ lalu tambahkan lokasi Java di simpan. Jika di depan tulisan ‘<strong>export JAVA_HOME</strong>’ terdapat simbol pagar (#), hapus terlebih dahulu simbolnya karena itu menandakan bahwa kalimat tersebut merupakan sebuah komentar. Setelah menambahkan baris tersebut, tekan<strong> ‘Ctrl + o’</strong> untuk menyimpan, dan tekan ‘<strong>Ctrl + x’</strong> untuk keluar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f2bKrTK5icUfPBFoTWO4Dg.png" /><figcaption>‘</figcaption></figure><ul><li><strong>core-site.xml</strong></li></ul><p>File ini digunakan untuk menentukan alamat server pusat tempat sistem akan beroperasi. Buka file dan tambahkan konfigurasi dengan memasukkan perintah berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/645/1*n8VOONiowDZT8ffXatOtZw.png" /></figure><p>Setelah file terbuka, hapus seluruh isi berkas lalu ganti dengan baris — baris konfigurasi seperti pada gambar berikut. Setelah menambahkan baris tersebut, tekan<strong> ‘Ctrl + o’</strong> untuk menyimpan, dan tekan ‘<strong>Ctrl + x’</strong> untuk keluar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/719/1*cUUJD4kHb6lDq2E4B_Hk5A.png" /></figure><ul><li><strong>hdfs-site.xml</strong></li></ul><p>File ini digunakan untuk mengetahui letak data disimpan di disk fisik. Sebelum itu, masukkan perintah ‘<strong>echo $HOME</strong>’ untuk memastikan lokasi home directory sudah benar, kemudian catat outputnya (<strong>/home/deb</strong>). Lalu masukkan perintah untuk membuat folder yang berfungsi untuk menyimpan data HDFS dengan perintah ‘<strong>mkdir</strong>’ dengan parameter ‘<strong>-p</strong>’ yang memastikan folder induk dibuat otomatis jika belum ada. Perintah tersebut digunakan untuk membuat folder untuk menyimpan fisik <strong>NameNode</strong> (metadata HDFS) dan <strong>DataNode</strong> (blok data asli HDFS).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2Dha4xsUreId9AkQSqbgTA.png" /></figure><p>Kemudian, setelah file terbuka ketikkan konfigurasi berikut. Jangan lupa untuk mengganti ‘<strong>/home/deb</strong>’ dengan hasil ‘<strong>echo $HOME</strong>’ milik kalian masing — masing. Untuk property dengan nama <strong>dfs.replication</strong> memiliki nilai 1 karena jumlah salinan setiap blok data yang disimpan di DataNode berbeda ketahanannya terhadap kegagalan. Nilai replikasi wajib 1 karena hanya memiliki satu DataNode (<strong>Mode Single — Node</strong>). Jika memiliki banyak node, nilai yang umum digunakan adalah 3. Setelah menambahkan konfigurasi tersebut, tekan<strong> ‘Ctrl + o’</strong> untuk menyimpan, dan tekan ‘<strong>Ctrl + x’</strong> untuk keluar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/598/1*-d870OGeZ4KgkscumU5GGA.png" /></figure><ul><li><strong>mapred-site.xml</strong></li></ul><p>File ini digunakan untuk menjalankan program MapReduce (pemrosesan data) yang menyerahkan alokasi memori dan CPU ke YARN. Untuk melakukan konfigurasi, buka file dengan memasukkan perintah berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T7colLNEUfw_aEz0qFXR-A.png" /></figure><p>Setelah file terbuka, tambahkan konfigurasi seperti pada gambar berikut. Setelah menambahkan baris tersebut, tekan<strong> ‘Ctrl + o’</strong> untuk menyimpan, dan tekan ‘<strong>Ctrl + x’</strong> untuk keluar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/491/1*DoH7j8e0xPlVq_v2_nROeA.png" /></figure><ul><li><strong>yarn-site.xml</strong></li></ul><p>File konfigurasi ini digunakan untuk mengaktifkan layanan <em>shuffle</em> pendukung operasi MapReduce. YARN akan membaca atau menulis data hasil olahan ke dalam HDFS. Untuk melakukan konfigurasi, buka file dengan memasukkan perintah berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AaceKN9IkXG1s6qS6DMmSA.png" /></figure><p>Setelah file terbuka, tambahkan konfigurasi seperti pada gambar berikut. Setelah menambahkan baris tersebut, tekan<strong> ‘Ctrl + o’</strong> untuk menyimpan, dan tekan ‘<strong>Ctrl + x’</strong> untuk keluar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/527/1*W0tBwuvLtwoHM2VeqYjgcA.png" /></figure><p>Kelima folder yang berisi konfigurasi untuk menjalankan Hadoop dengan mode pseudo — distributed telah berhasil tersimpan!</p><h4>Format HDFS NameNode</h4><p>Perintah berikut digunakan untuk menginisialisasi dan menata ulang sistem HDFS pada node utama (NameNode) sebelum kluster Hadoop digunakan untuk pertama kali. Proses pemformatan mirip dengan memformat hard disk baru. <strong>Perintah ini hanya dijalankan satu kali</strong> saat pertama kali melakukan konfigurasi Hadoop. Jika di kemudian hari perintah ini dijalankan kembali, maka akan menghapus seluruh data yang sudah tersimpan di HDFS.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/1*9jZSRcLlqAbKmwrgEDtTcA.png" /></figure><p>Proses pemformatan berhasil jika pada output di terminal terdapat baris berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/906/1*0qAGfSezqPY98LKlm3fd9g.png" /></figure><h4>Menjalankan Hadoop Daemons</h4><p>Perintah ‘<strong>start-dfs.sh</strong>’ dan ‘<strong>start-yarn.sh</strong>’ berfungsi untuk menjalankan seluruh layanan utama Hadoop di latar belakang tanpa harus memasukkan password karena konfigurasi <em>passwordless SSH</em> yang sudah dilakukan sebelumnya. Perintah ‘<strong>start-dfs.sh</strong>’ akan mengaktifkan layanan sistem HDFS, sedangkan perintah ‘<strong>start-yarn.sh</strong>’ berfungsi untuk mengaktifkan komponen pemrosesan data dan manajemen sumber daya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/883/1*EOlL_LNVef7-gRFOxSwErw.png" /></figure><p>Kemudian, verifikasi seluruh daemon yang berjalan menggunakan perintah ‘<strong>jps</strong>’. Perintah tersebut akan menampilkan output berupa 5 proses ID (PID) yang menunjukkan bahwa konfigurasi Hadoop berhasil dilakukan, serta sistem HDFS dan YARN siap digunakan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/330/1*p5PbCnGYJ13IHCwIvkqy9Q.png" /></figure><h4>Mengakses Website UI Hadoop</h4><p>Untuk memantau status klaster, Hadoop menyediakan dashboard berbasis web untuk mempermudah pemantauan. Dashboard <strong>NameNode UI</strong> dapat di akses pada alamat ‘<strong>http://localhost:9870</strong>&#39; yang dapat digunakan untuk melihat status HDFS, kapasitas, daftar DataNode, serta menjelajahi berkas. Berikut adalah tampilan web untuk NameNode UI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*11jLpKQnK52Fmq1UkCtq_Q.png" /></figure><p>Sedangkan dashboard <strong>ResourceManager UI</strong> dapat diakses pada alamat ‘<strong>http://localhost:8088</strong>’ yang dapat digunakan untuk melihat status YARN dan daftar aplikasi atau job yang berjalan. Berikut adalah tampilan web ResourceManager UI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pczjc6asdON8vsDXGHjIDw.png" /></figure><p>Kedua halaman web UI berhasil dibuka dan menampilkan dashboard tanpa menampilkan eror ‘<em>connection refused</em>’. Maka, instalasi Hadoop telah berhasil sepenuhnya.</p><p>Setelah selesai menggunakan Hadoop, jangan lupa untuk menghentikan Hadoop untuk menjaga integritas data dan efisiensi sistem menggunakan perintah berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/422/1*nWIB1HlQams07ReyxlwT_g.png" /></figure><h4>Melanjutkan di Jupyter Notebook</h4><p>Instalasi Hadoop telah selesai dan Hadoop sudah berjalan dan dapat digunakan. Kemudian buka terminal baru, masukkan perintah berikut untuk membuka Jupyter Notebook.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/726/1*QdqCiqibCy2KtoGxy2276g.png" /></figure><p>Kemudian, untuk memastikan integrasi Jupyter Notebook dengan Hadoop berhasil, ketikkan perintah ‘<strong>!hdfs version</strong>’ di dalam code cell pada Jupyter Notebook, lalu jalankan perintah tersebut. Jika tidak ada output berupa pesan eror, berarti integrasi berhasil dan Hadoop dapat digunakan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/826/1*KFeoH934OMUUMi_l9W8GWg.png" /></figure><h4>Hands — On: Perintah Dasar HDFS</h4><p>Bagian ini akan menjelaskan perintah dasar yang akan digunakan untuk berinteraksi, mengelola, dan memanipulasi file di dalam HDFS. Perintah dasar HDFS memiliki pola umum yaitu ‘<strong>hdfs dfs -[perintah] [argumen]</strong>’. Perintah tersebut mirip dengan perintah linux biasa, akan tetapi beroperasi pada sistem HDFS, bukan disk lokal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oDGevPbSOunfNgabaYT9hg.png" /></figure><ul><li><strong>Membuat direktori di HDFS</strong></li></ul><p>Untuk membuat direktori baru, gunakan perintah <strong>-mkdir</strong> dengan opsi <strong>-p</strong> untuk otomatis membuat folder induk jika folder tersebut belum ada. Kemudian kita juga dapat menampilkan daftar berkas yang ada di dalam lokasi HDFS tersebut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3gbDVZr2UG_rwUdcaKfkmA.png" /></figure><ul><li><strong>Upload berkas dari lokal ke HDFS (put)</strong></li></ul><p>Untuk mempraktikkan perintah dasar upload berkas dari lokal ke HDFS, kita perlu membuat contoh file yang akan digunakan untuk praktik tersebut. Caranya adalah sebagai berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mmX79Kkh4ame8Br2zb1F4w.png" /></figure><p>Kemudian, gunakan perintah <strong>-put</strong> untuk mengunggah berkas dari lokal ke direktori HDFS.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LsXlOKrjQSp7WTuBFcHICA.png" /></figure><ul><li><strong>Melihat isi berkas di HDFS (cat)</strong></li></ul><p>Setelah berkas berhasil diupload di direktori HDFS, kita bisa menggunakan perintah <strong>-cat</strong> untuk menampilkan isi berkas teks yang ada di dalam HDFS tanpa perlu mengunduh terlebih dahulu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NWvMTF4yb9Z5WeJ3DvM_AQ.png" /></figure><ul><li><strong>Download berkas dari HDFS ke Lokal (get)</strong></li></ul><p>Setelah itu, kita bisa mengunduh kembali file yang ada di HDFS dan disimpan di disk lokal komputer dengan menggunakan perintah <strong>-get</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9FqNeCapUnhRbGgmKy6K1A.png" /></figure><ul><li><strong>Informasi ukuran dan jumlah berkas</strong></li></ul><p>Selanjutnya, kita bisa menampilkan penggunaan memori pada HDFS dengan format yang mudah dibaca dengan perintah <strong>-du -h</strong>. Selain itu, perintah <strong>-count</strong> digunakan untuk menampilkan informasi rinci mengenai jumlah direktori, berkas, serta total ukuran fisik data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YwyUzGWMl2ctCA3LE8e5Hg.png" /></figure><ul><li><strong>Menghapus berkas/direktori di HDFS (rm)</strong></li></ul><p>Untuk menghapus berkas di HDFS gunakan perintah <strong>-rm</strong>. Jika ingin menghapus folder beserta seluruh isinya secara rekursif tambahkan perintah -r.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e7QI5Fxcjub-_FOApygg9w.png" /></figure><h3>Latihan Mandiri</h3><ul><li><strong>Soal 1 :</strong> Buatlah direktori baru di HDFS dengan path <strong>/user/mahasiswa/latihan3</strong> .</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FK8QMP3vVgIZLlWWE5W-Eg.png" /></figure><p><strong>Keterangan</strong> : Untuk membuat direktori baru, kita bisa menggunakan perintah -mkdir dan -p untuk otomatis membuat induk secara otomatis. Kemudian untuk memastikan direktori berhasil dibuat, gunakan perintah -ls untuk menampilkan daftar direktori HDFS.</p><ul><li><strong>Soal 2</strong> : Buatlah sebuah berkas teks lokal berisi biodata singkat kalian (nama, NIM, hobi — minimal 3 baris), lalu upload ke direktori <strong>/user/mahasiswa/latihan3</strong> yang baru dibuat pada <strong>Soal 1</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IW7haRzCXQqon4g5UiAsqg.png" /></figure><p>Keterangan : Untuk membuat berkas baru gunakan fungsi <strong>open()</strong> untuk membuat file dengan nama <strong>biodata.txt, </strong>serta mode <strong>“w”</strong> atau write untuk menunjukkan bahwa file dibuat untuk ditulis. Kemudian pernyataan “<strong>with … as f</strong>” digunakan untuk memastikan file ditutup secara otomatis setelah proses penulisan selesai agar tidak memakan memori. Perintah “<strong>f.write()</strong>” berfungsi untuk menuliskan baris ke dalam file dengan karakter “<strong>\n</strong>” untuk mengganti garis baru. Kemudian untuk memastikan file berhasil dibuat, gunakan perintah <strong>ls -la .</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LCgQD9wLiPUdHhl_Tf3XfQ.png" /></figure><p>Keterangan : Gunakan perintah <strong>-put</strong> untuk mengupload file yang sudah dibuat tadi ke dalam direktori pada soal nomer 1. Lalu pastikan file berhasil dibuat dengan memeriksa menggunakan perintah <strong>ls -la</strong> .</p><ul><li><strong>Soal 3 : </strong>Tampilkan isi berkas biodata kalian langsung dari HDFS (tanpa download terlebih dahulu), menggunakan perintah <strong>cat</strong> .</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JhO3At0L7jReDTBJhz0VoQ.png" /></figure><p>Keterangan : Tampilkan isi berkas biodata.txt menggunakan perintah cat tanpa harus mengunduh di disk lokal.</p><ul><li><strong>Soal 4 (Refleksi singkat) :</strong> Dalam 2–3 kalimat, jelaskan menurut pemahaman kalian sendiri: apa perbedaan mendasar antara menyimpan berkas di <strong>disk lokal VM</strong> (seperti contoh_lokal.txt tadi) dengan menyimpan di <strong>HDFS</strong>?</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vhCU2K6h6mdMjGwYiCrXGA.png" /></figure><h3>TUGAS MANDIRI</h3><p>Tugas mandiri dapat di akses pada link GitHub berikut :</p><p><a href="https://github.com/DebiAprilia/bigdata2026/blob/main/Tugas3_2320506038_DebiAprilia.ipynb">bigdata2026/Tugas3_2320506038_DebiAprilia.ipynb at main · DebiAprilia/bigdata2026</a></p><h4>Kesimpulan</h4><p>Sistem basis data konvensional dan library pemrosesan memori tunggal seperti Pandas memiliki keterbatasan saat menangani data berukuran besar. Apache Hadoop dapat mengatasi masalah tersebut dengan pendekatan penyimpanan dan pemrosesan terdistribusi berdasarkan prinsip utama Big Data yaitu 5V. Hadoop ecosystem memiliki komponen inti seperti HDFS, YARN, dan MapReduce yang memiliki peran masing — masing untuk membangun Hadoop. Dengan integrasi antara HDFS dan Python dapat memudahkan proses pengolahan data dari data mentah menjadi data yang sudah diolah untuk analisis data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=870228d3a9fe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Instalasi Python Environment (Anaconda) & Pengenalan Jupyter Notebook di Ubuntu— Praktikum Big Data]]></title>
            <link>https://medium.com/@debi.aprilia/instalasi-python-environment-anaconda-pengenalan-jupyter-notebook-di-ubuntu-praktikum-big-data-29533930459b?source=rss-c81725c91e44------2</link>
            <guid isPermaLink="false">https://medium.com/p/29533930459b</guid>
            <category><![CDATA[jupyter-notebook]]></category>
            <category><![CDATA[anaconda-python]]></category>
            <category><![CDATA[ubuntu-desktop]]></category>
            <category><![CDATA[big-data]]></category>
            <dc:creator><![CDATA[Debi Aprilia]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 15:52:10 GMT</pubDate>
            <atom:updated>2026-09-02T15:52:10.067Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dwDU1UQbYBoQSwvLF6lWFQ.jpeg" /></figure><p>Sebelum menginstal Anaconda dan Jupyter Notebook di Ubuntu, kita perlu mengetahui beberapa perintah dasar terminal Ubuntu. Perintah — perintah berikut akan sering digunakan pada terminal sistem operasi Ubuntu.</p><p><strong>a.) pwd</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/731/1*xVozwd7twwEmKbxJSRwk2g.png" /></figure><p>Perintah <strong>pwd</strong> atau <strong><em>print working directory</em></strong> berfungsi untuk menampilkan path direktori kerja saat ini. Contoh pada gambar di atas, ketika mengetikkan perintah pwd di terminal, muncul output <strong>/home/deb</strong> yang berarti kita sedang berada di dalam folder tersebut.</p><p><strong>b.) ls</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/729/1*iWmg2XnEOG9okuXGa_lctQ.png" /></figure><p>Perintah <strong>ls</strong> atau <strong>list</strong> digunakan untuk menampilkan daftar isi berupa file dan folder yang ada di dalam sistem. Selain menggunakan perintah ls, bisa juga menggunakan perintah <strong>dir</strong> atau <strong>directory</strong>. Perbedaan keduanya terdapat pada warna output. Jika menggunakan perintah <strong>ls</strong> outputnya akan berwarna menyesuaikan tipe file (biru untuk folder, hijau untuk file yang bisa dieksekusi, dan merah untuk file arsip). Jika menggunakan perintah <strong>dir</strong> outputnya akan berwarna putih, karena perintah ini dirancang agar hasil outputnya selalu konsisten. Perintah ls merupakan perintah standar di Linux, sedangkan perintah dir merupakan perintah bawaan dari Windows agar penggunanya tidak kebingungan saat menggunakan Linux.</p><p><strong>c.) ls -la</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/732/1*XSupmrgiPiqf6KIGl_XX6w.png" /></figure><p>Perintah <strong>ls -la</strong> digunakan untuk menampilkan isi file dan folder secara detail termasuk file yang tersembunyi. Perintah ini merupakan gabungan dari dua opsi yaitu perintah <strong>-l</strong> atau <strong>long format</strong> untuk menampilkan informasi lengkap dari hak akses, pemilik, ukuran file, dan tanggal modifikasi. Perintah kedua yaitu <strong>-a</strong> atau <strong>all</strong> untuk menampilkan semua file termasuk file yang tersembunyi (file yang namanya diawali tanda titik (.)). Cara membaca output dari perintah ls -la adalah :</p><ul><li><strong>Hak akses</strong> : karakter pertama menunjukkan tipe file (simbol (<strong>-)</strong> untuk file biasa, dan huruf (<strong>d)</strong> untuk direktori). Karakter kedua sebagai hak akses <em>Read</em> (<strong>r</strong>), <em>Write</em> (<strong>w</strong>), dan <em>Execute</em> (<strong>x</strong>) untuk <em>Owner</em>, <em>Group</em>, dan <em>Others</em>. Contoh : <strong>drwxr-xr-x, -rw-r- -r- -</strong></li><li><strong>Jumlah Link</strong> : angka yang menunjukkan berapa banyak tautan (<em>hard link</em>) ke file atau folder tersebut. Contoh : <strong>16, 3, 1, 12</strong> (kolom kedua).</li><li><strong>Pemilik</strong> <strong>(<em>Owner</em>)</strong> : nama pengguna pemilik file tersebut. Contoh : <strong>deb, root</strong></li><li><strong>Grup (<em>Group</em>)</strong> : nama grup pengguna pemilik file tersebut. Contoh : <strong>deb, root</strong></li><li><strong>Ukuran file</strong> : ukuran file tersebut dengan satuan <em>bytes</em>. Contoh : <strong>4096, 220, 3771</strong></li><li><strong>Waktu modifikasi</strong> : tanggal dan waktu terakhir file diubah. Contoh : <strong>Agu 27 15:51</strong></li><li><strong>Nama file/folder</strong> : nama file atau folder ada yang memiliki tanda khusus. Tanda <strong>titik satu (.)</strong> berarti tanda untuk direktori/folder saat ini, <strong>tanda titik dua (..)</strong> berarti tanda untuk direktori induk atau di atasnya, dan jika file diawali titik (Contoh : <strong>.bash_logout</strong>) berarti file tersebut adalah file tersembunyi yang berisi konfigurasi penting sistem atau aplikasi.</li></ul><p><strong>d.) cd <em>nama_folder</em></strong></p><p>Perintah <strong>cd</strong> atau <strong><em>change directory</em></strong> digunakan untuk berpindah ke folder tertentu.</p><p><strong>e.) cd ..</strong></p><p>Perintah cd disertai tanda titik dua (<strong>cd ..</strong>) digunakan untuk berpindah ke folder satu tingkat di atasnya.</p><p><strong>f.) cd ~</strong></p><p>Perintah cd disertai simbol tilde (~) digunakan untuk kembali ke folder utama (<em>home</em>).</p><p><strong>g.) mkdir <em>nama_folder</em></strong></p><p>Perintah <strong>mkdir</strong> atau <strong><em>make directory</em></strong> digunakan untuk membuat folder baru.</p><p><strong>f.) sudo perintah</strong></p><p>Perintah <strong>sudo</strong> atau <strong>SuperUser DO</strong> merupakan perintah yang digunakan untuk menjalankan perintah dengan hak akses tertinggi (sebagai administrator atau root) pada sistem operasi Ubuntu. Fungsi perintah sudo adalah untuk menginstal atau menghapus aplikasi sistem, memperbarui sistem dan paket software, mengedit konfigurasi sistem, mengelola layanan dan sistem, serta mengatur pengguna dan hak akses.</p><h4>Latihan : Membuat folder</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/430/1*Mukb6icYX1CHib1H6VqA1g.png" /></figure><ul><li>Perintah <strong>cd ~</strong> digunakan untuk kembali ke home karena folder baru akan dibuat di dalam folder home.</li><li>Perintah <strong>mkdir praktikum-bigdata</strong> digunakan untuk membuat folder baru dengan nama folder praktikum-bigdata. Folder ini akan berada di dalam folder home.</li><li>Perintah <strong>cd praktikum-bigdata</strong> digunakan untuk masuk ke dalam folder praktikum-bigdata yang telah dibuat. Perintah berhasil dieksekusi jika pada terminal yang awalnya bertanda <strong>~$</strong> menjadi <strong>~/praktikum-bigdata$.</strong></li><li>Perintah <strong>pwd</strong> digunakan untuk menampilkan lokasi dari direktori saat ini. Jika perintah berhasil dieksekusi, maka terminal menampilkan output lokasi saat ini yaitu <strong>/home/deb/praktikum-bigdata</strong>.</li></ul><h4>Instalasi Anaconda di Ubuntu</h4><p>Anaconda merupakan platform alternatif dari bahasa pemrograman Python dan library-nya. Anaconda memudahkan pengolahan data karena kita tidak perlu menginstal satu per satu library yang akan digunakan untuk mengolah data. Ada beberapa library yang bisa digunakan pada Anaconda, seperti pandas, numpy, scipy, matplotlib, sklearn, dan lain — lain. Untuk menggunakan library tersebut pada Anaconda, kita cukup memanggil librarynya saja tanpa menginstal satu per satu. Selain itu, Anaconda juga dilengkapi dengan Conda yang akan mengelola paket dan environment agar versi — versi librarynya selalu kompatibel.</p><p>Langkah — langkah instalasi Anaconda di Ubuntu adalah sebagai berikut.</p><p>1.) Buka Firefox yang ada di dalam VM Ubuntu, lalu buka situs resmi untuk mengunduh <a href="https://pro.anaconda.com/archive/">Anaconda</a>. Pilih versi ‘<strong>Anaconda3–2025.12–1-Linux-x86_64.sh’</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0okHI6VtODhPAK3pklqr2A.png" /></figure><p>2.) Setelah berhasil di unduh, file tersebut akan otomatis berada di folder <strong>~/Downloads</strong>. Selanjutnya, buka terminal dan masukkan perintah berikut :</p><ul><li><strong>cd ~/Downloads</strong> → untuk berpindah atau masuk ke dalam folder Downloads</li><li><strong>ls</strong> → untuk melihat file yang ada di dalamnya, memastikan file ‘<strong>Anaconda3–2025.12–1-Linux-x86_64.sh’ </strong>berhasil di unduh dan berada di folder Downloads</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*NX_zVjyljyfDEhqzci0APA.png" /></figure><p>3.) Kemudian jalankan installer dengan memasukkan perintah ‘<strong>bash Anaconda3–2025.12–1-Linux-x86_64.sh’</strong></p><ul><li>Untuk membaca lisensi, tekan <strong>Enter</strong>, kemudian tekan spasi berulang sampai akhir lisensi.</li><li>Kemudian saat muncul pertanyaan ‘<strong>Do you accept the license terms?</strong>’, ketik <strong>yes</strong>, lalu <strong>Enter</strong> untuk menyetujui lisensi.</li><li>Kemudian tekan Enter untuk menyetujui lokasi instalasi default (<strong>/home/user/anaconda3</strong>). Proses instalasi akan memerlukan beberapa waktu, tunggu saja sampai prosesnya selesai. Jangan menekan tombol lain ketika proses instalasi karena akan menyebabkan instalasi tidak berhasil.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/735/1*Qm6tmCIkiPB0Ta3zRB1QoA.png" /></figure><p>4.) Setelah berhasil terinstal akan muncul pertanyaan ‘<strong>Proceed with initialization?</strong>’, ketik <strong>yes</strong>, lalu tekan <strong>Enter</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/1*g67oGz-FE52R0FIuqyKRkg.png" /></figure><p>5.) Setelah itu, tutup dan buka kembali Terminal Ubuntu. Lakukan verifikasi untuk memastikan instalasi berhasil dengan memasukkan perintah ‘<strong>conda- -version</strong>’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/734/1*JB61cvWp1M5lTI25tJ5PIQ.png" /></figure><h4>Membuat Conda Environment untuk Big Data</h4><p>Selanjutnya, kita akan membuat environment bernama <strong>bigdata</strong> dengan kombinasi yang sudah diuji dan saling kompatibel untuk mendukung PySpark.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/413/1*fqb3clED_4O77XRvy82XQQ.png" /></figure><p>Untuk membuat environment tersebut, buka terminal Ubuntu, kemudian ketikkan perintah berikut.</p><pre>conda create -n bigdata python=3.11 pandas=2.2 numpy=1.26 matplotlib=3.8 jupyter notebook seaborn -c conda-forge -y</pre><p>Keterangan :</p><ul><li><strong>conda create</strong> → untuk membuat environment baru agar proyek tidak tercampur dengan pustaka lain.</li><li><strong>-n bigdata</strong> → untuk memberi nama environment yang dibuat, yaitu bigdata.</li><li><strong>python=3.11 pandas=2.2 numpy=1.26 matplotlib=3.8</strong> → library dan versi yang akan digunakan pada environment ini.</li><li><strong>jupyter notebook seaborn</strong> → untuk menginstal Jupyter Notebook dan Seaborn</li><li><strong>-c conda-forge</strong> → mengundug library tersebut dari channel repositori komunitas conda-forge</li><li><strong>-y</strong> → untuk otomatis menyetujui proses instalasi.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*MkRVQllFkRkl9oMMiTYBsg.png" /></figure><p>Setelah proses di atas selesai, aktifkan environment yang sudah dibuat dengan mengetikkan perintah ‘<strong>conda activate bigdata</strong>’. Environment bigdata berhasil di aktifkan ketika tulisan ‘<strong>(base)</strong>’ di terminal berubah menjadi ‘<strong>(bigdata)</strong>’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*Pf3pGstxqQdwyEcdUyl55A.png" /></figure><p>Setelah itu, lakukan verifikasi untuk memastikan library yang akan digunakan telah terpasang dengan benar dengan mengetikkan perintah berikut pada terminal.</p><pre>python --version<br><br>python -c &quot;import pandas, numpy, matplotlib; print(&#39;pandas&#39;, pandas.__version__); print(&#39;numpy&#39;, numpy.__version__); print(&#39;matplotlib&#39;, matplotlib.__version__)&quot;</pre><p>Jika library berhasil dipasang, output yang dihasilkan adalah sebagai berikut.</p><ul><li>Python 3.11.16</li><li>pandas 2.2.3</li><li>numpy 1.26.4</li><li>matplotlib 3.8.4</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/735/1*OZZMA3h8ogIm0_6_bi4TIQ.png" /></figure><p>Untuk praktikum selanjutnya, setiap kali membuka Terminal baru, lakukan aktivasi environment bigdata terlebih dahulu sebelum menjalankan Python atau Jupyter Notebook agar library yang digunakan sesuai.</p><h4>Menjalankan Jupyter Notebook</h4><p>Sebelum membuka Jupyter Notebook, pastikan environment bigdata sudah aktif. Jika belum bisa memasukkan perintah ‘<strong>conda activate bigdata</strong>’. Kemudian arahkan terminal ke folder praktikum yang sudah dibuat sebelumnya. Setelah itu pindahkan file modul <strong>.ipynb</strong> ke dalam folder tersebut, lalu jalankan Jupyter Notebook.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*raO5j1Ccn2bDaVwlfuKn1w.png" /></figure><p>Kemudian, browser akan otomatis terbuka dan menampilkan antarmuka Jupyter Notebook dengan daftar isi folder <strong>praktikum-bigdata</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0J9vsn6o474iYVt96SnEow.png" /></figure><p>Kemudian, pilih file <strong>Modul_Praktikum_BigData_Pertemuan2.ipynb</strong> untuk membuka di dalam Jupyter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O1Ek1x92E3n3aRO_Ypbweg.png" /></figure><h3>Hands-On: Python Dasar untuk Eksplorasi Data</h3><p>Pada praktikum ini, kita akan menggunakan tiga library utama dalam ekosistem Python untuk melakukan mengolah data, menganalisis data, serta memvisualisasikan data.</p><ul><li><strong>Pandas</strong> (Python Data Analysis Library) digunakan untuk mengelola dan menganalisis data terstruktur berupa tabel CSV, Excel, dan SQL.</li><li><strong>NumPy</strong> (Numerical Python) digunakan untuk memproses operasi numerik yang lebih cepat dan efisien.</li><li><strong>Matplotlib</strong> digunakan untuk memvisualisasikan data di Python yangg dapat berupa <em>line chart</em>, <em>bar chart</em>, <em>histogram</em>, serta <em>scatter plot.</em></li></ul><h4>Verifikasi Versi Library</h4><p>Sebelum memulai praktikum menggunakan Jupyter Notebook, lakukan pengecekan ulang versi library yang akan digunakan. Hal tersebut dilakukan untuk mencegah error, mempermudah proses debugging, memastikan hasil output konsisten, serta memastikan tidak salah menggunakan environment yang sudah dibuat.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aEoDbdPo4T_i8cU84v0-Xw.png" /></figure><h4>Variabel dan Tipe Data Dasar di Python</h4><p><strong>Variabel</strong> merupakan sebuah tempat di dalam memori komputer yang digunakan untuk menyimpan suatu nilai. Variabel memiliki nama agar nilai di dalamnya dapat dipanggil, digunakan, dan diubah dengan mudah. Contoh nama variabel dan nilainya : nama_mahasiswa = ‘Budi’, npm = 210411001, ipk = 3.75, aktif_kuliah = True.</p><p><strong>Tipe data</strong> merupakan jenis nilai yang disimpan di dalam variabel. Contoh tipe data :</p><ul><li><strong>String (str)</strong> → merupakan tipe data berupa teks. Untuk menuliskan teks wajib menambahkan tanda petik (“” atau ‘’). Contoh : “Budi”</li><li><strong>Integer (int)</strong> → merupakan tipe data berupa bilangan bulat positif dan negatif tanpa tanda koma. Contoh : 210411001</li><li><strong>Float (float)</strong> → merupakan tipe data berupa bilangan desimal atau pecahan dengan mengganti tanda koma menjadi titik. Contoh : 3.75</li><li><strong>Boolean (bool)</strong> → merupakan tipe data yang hanya memiliki dua nilai yaitu True dan False. Contoh : True</li></ul><pre>print(f&quot;Nama       : {nama_mahasiswa} ({type(nama_mahasiswa).__name__})&quot;)<br>print(f&quot;NPM        : {npm} ({type(npm).__name__})&quot;)<br>print(f&quot;IPK        : {ipk} ({type(ipk).__name__})&quot;)<br>print(f&quot;Aktif      : {aktif_kuliah} ({type(aktif_kuliah).__name__})&quot;)</pre><p>Keterangan :</p><ul><li>Perintah <strong>f“…” (Formatted String)</strong> → untuk memasukkan variabel Python langsung di dalam teks menggunakan kurung kurawal {}.</li><li>Perintah <strong>{nama_mahasiswa}</strong> → untuk mengambil dan menampilkan nilai dari variabel tersebut.</li><li>Perintah<strong> type(nama_mahasiswa)</strong> → merupakan fungsi bawaan Python untuk mengecek tipe data suatu variabel.</li><li>Perintah <strong>.__name__</strong> → untuk mengambil dan menampilkan nama singkat tipe data tersebut.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PbM9llS5ktlppIC5mkGnEg.png" /></figure><p>Selain tipe data di atas, ada dua struktur data dasar pada Python yang digunakan untuk menyimpan kumpulan data dalam satu variabel. Yang pertama, <strong>List</strong> merupakan kumpulan data terurut dan nilainya dapat diubah. Nilai di dalam List dapat diakses dengan indeks posisi angka yang dimulai dari angka 0. List biasanya ditandai dengan kurung siku []. <strong>Contoh</strong> : daftar_nilai = [85, 90, 78, 92, 88]</p><p>Sedangkan <strong>Dictionary</strong> merupakan kumpulan data yang menyimpan datanya dalam bentuk pasangan <em>key — value</em>. Nilai dalam dictionary dapat diakses menggunakan nama <em>key</em>-nya. Dictionary ditandai dengan kurung kurawal {} dan antara <em>key</em> dan <em>value</em> dipisahkan dengan titik dua (:).<strong> Contoh :</strong> mahasiswa = { “nama”: “Budi”, “npm”: 210411001, “jurusan”: “Teknologi Informasi”, “semester”: 3 }</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IaJto3pRBE2xwSXjVGdBTw.png" /></figure><h4>Membuat dan Mengeksplorasi DataFrame dengan Pandas</h4><p><strong>DataFrame</strong> merupakan struktur data yang berbentuk tabel pada Pandas yang terdiri dari baris dan kolom. Bentuk DataFrame mirip dengan tabel pada Excel atau tabel basis data (SQL). Untuk membuat DataFrame di Pandas bisa menggunakan perintah <strong>pd.DataFrame()</strong>. Contoh pada gambar di bawah ini, membuat DataFrame dari Dictionary. Dari dictionary <strong>data_penjualan</strong>, <em>key</em> akan menjadi nama kolom dan <em>list value</em> akan menjadi isi barisnya. Untuk menampilkan output DataFrame, hanya dengan memanggil nama variabel DataFrame yang dibuat. Hasil atau output DataFrame — nya dapat dilihat pada gambar berikut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lakh_whKNQXZtCxju3M_TA.png" /></figure><p>Pandas juga memiliki beberapa fungsi yang dapat digunakan untuk menganalisis DataFrame.</p><ul><li><strong>df.head()</strong> → digunakan untuk menampilkan 5 baris pertama dari DataFrame. Jika menambahkan angka di dalam tanda kurung, misal df.head(10) maka data yang akan ditampilkan adalah 10 data pertama dari DataFrame.</li><li><strong>df.info()</strong> → digunakan untuk menampilkan informasi struktur DataFrame seperti jumlah baris, jumlah kolom, tipe data, data atau nilai yang hilang, serta memori yang digunakan. Contoh gambar di bawah ini memiliki 5 kolom, 8 baris, tidak ada data yang hilang (non-null), tipe data object untuk teks atau string, tipe data int64 untuk integer (angka bulat 64-bit), dan memori yang digunakan 452.0+ bytes.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z0G6m4kgaDfSi7-os1f9bw.png" /></figure><ul><li><strong>df.describe()</strong> → digunakan untuk menghasilkan ringkasan statistika deskriptif secara otomatis dari kolom yang bertipe data angka, sehingga memudahkan memahami sebaran data, nilai tengah, dan rentang data tanpa harus menghitung satu per satu. Outputnya berupa → <strong>count</strong> : total jumlah baris data pada satu kolom,<strong> mean</strong> : rata — rata data pada kolom tersebut, <strong>std</strong> : standar deviasi yaitu ukuran sebaran nilai rata — ratanya, <strong>min</strong> : nilai terkecil kolom tersebut, <strong>25%</strong> : nilai batas bawah (25% data berada di bawah nilai ini), <strong>50%</strong> : nilai tengah data, <strong>75%</strong> : nilai batas atas (75% data berada di bawah nilai ini), <strong>max</strong> : nilai terbesar kolom tersebut.</li><li>Apakah hanya kolom yang bertipe data angka saja yang bisa ditampilkan? Tidak. Jika ingin menampilkan ringkasan data yang bertipe data teks atau string perintah diubah menjadi <strong>df.describe(include=‘all’). </strong>Pandas akan menambahkan 3 baris khusus untuk kolom bertipe data string, yaitu <strong>kolom unique</strong> (menampilkan jumlah nilai berbeda di kolom tersebut, misal kolom kota bernilai 4 [Magelang, Yogyakarta, Semarang, Solo]), <strong>kolom top</strong> (menampilkan teks yang sering muncul, misal kolom produk bernilai Kaos), serta <strong>kolom freq</strong> (menampilkan berapa kali nilai di kolom top muncul, misal kolom produk bernilai 8 karena 8 baris bernilai ‘Kaos’).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RihlK6pULcjLNp8Xg_tLKA.png" /></figure><ul><li>Selain itu, kita bisa menambahkan kolom baru ke dalam DataFrame dengan menggunakan perintah <strong>df[“total_pendapatan”]</strong> yang artinya untuk membuat kolom baru di dalam DataFrame dengan nama <strong>“total_pendapatan”</strong>. Perintah <strong>df[“unit_terjual”] * df[“harga_satuan”]</strong> digunakan untuk mengalikan nilai yang ada di dalam dua kolom tersebut atau kita bisa ganti sesuai dengan kondisi yang kita inginkan. Selanjutnya DataFrame ditampilkan kembali dengan perintah <strong>df</strong> setelah kolom baru berhasil dibuat.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NxDvjCef7m1lkT2qI27oOg.png" /></figure><h4>Operasi Dasar: Filtering dan Pengelompokan Data</h4><p><strong>Filter</strong> atau Filtering mmerupakan proses mengambil sebagian baris data tertentu sesuai kriteria yang diinginkan dan menampilkan data sesuai kriteria yang diminta. <strong>Group by</strong> merupakan proses mengelompokkan baris data yang memiliki nilai sama pada suatu kolom untuk melihat ringkasan per kelompok.</p><ul><li><strong>Filtering satu kondisi</strong></li></ul><pre>data_magelang = df[df[&quot;kota&quot;] == &quot;Magelang&quot;]<br>data_magelang</pre><p>Keterangan :</p><p>→ <strong>df[df[“kota”] == “Magelang”]</strong> : untuk memeriksa baris pada kolom <strong>kota</strong> yang bernilai <strong>True</strong> untuk kota <strong>Magelang</strong>.</p><p>→ <strong>df[…]</strong> : untuk menyimpan baris yang bernilai <strong>True</strong> ke dalam variabel <strong>data_magelang</strong>.</p><p>→ <strong>data_magelang</strong> : untuk menampilkan baris data yang berasal dari <strong>Magelang</strong> (ada 2 baris).</p><ul><li><strong>Filtering lebih dari satu kondisi</strong></li></ul><pre>data_filter = df[(df[&quot;unit_terjual&quot;] &gt; 100) &amp; (df[&quot;minggu&quot;] == 2)]<br>data_filter</pre><p>Keterangan :</p><p>→ <strong>(df[“unit_terjual”] &gt; 100)</strong> : kondisi pertama untuk mencari transaksi dengan penjualan di atas 100 unit.</p><p>→ <strong>(df[“minggu”] == 2)</strong> : kondisi kedua yang harus dipenuhi bersama yaitu mencari transaksi yang terjadi pada minggu ke — 2.</p><p>→ <strong>df[…]</strong> : menyimpan baris yang memenuhi kedua kondisi ke dalam variabel <strong>data_filter</strong>.</p><p>→ <strong>data_filter : </strong>untuk menampilkan baris yang memenuhi kedua kondisi yaitu ada 3 baris Magelang, Yogyakarta, dan Semarang.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dpkFt5uswpQXr96D-hvH-g.png" /></figure><ul><li><strong>Group by</strong></li></ul><pre>total_per_kota = df.groupby(&quot;kota&quot;)[&quot;total_pendapatan&quot;].sum().sort_values(ascending=False)<br>print(&quot;Total pendapatan per kota (2 minggu):&quot;)<br>total_per_kota</pre><p>Keterangan :</p><p>→ <strong>df.groupby(“kota”) </strong>: untuk mengelompokkan baris data berdasarkan nilai unik pada kolom ‘kota’.</p><p>→<strong> [“total_pendapatan”]</strong> : untuk menentukan kolom yang ingin dihitung nilai kelompoknya.</p><p>→<strong> .sum()</strong> : fungsi untuk menjumlahkan nilai ‘total_pendapatan’ dari baris minggu 1 dan 2 untuk masing — masing kota.</p><p>→ <strong>sort_values(ascending=False)</strong> : mengurutkan hasil penjumlahan dari yang terbesar ke terkecil.</p><p>→ <strong>print(“Total pendapatan per kota (2 minggu):”)</strong> dan <strong>total_per_kota</strong> : untuk menampilkan hasil pengelompokan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Evbwsa9ySgcLHNsM_iciA.png" /></figure><h4>Latihan Mandiri</h4><p><strong>Soal 1</strong></p><ul><li>Untuk membuat DataFrame baru yang berisi data nilai 5 mahasiswa, pertama buat data 5 mahasiswa yang berisi nama, nilai uts, dan nilai uas menggunakan struktur data dictionary.</li><li>Kemudian, ubah data tersebut menjadi tabel atau DataFrame menggunakan perintah <strong>pd.DataFrame(data_mhs)</strong>.</li><li>Kemudian, untuk menambahkan kolom <strong>nilai_akhir</strong>, gunakan perintah <strong>df_nilai[‘nilai_akhir’]</strong> untuk membuat kolom baru bernama <strong>nilai_akhir</strong> di dalam DataFrame <strong>df_nilai</strong>. Lalu baris berikutnya untuk menghitung seluruh nilai uts dikali 0.4, nilai uas dikali 0.6, serta menjumlahkan keduanya.</li><li>Perintah <strong>df_nilai</strong> digunakan untuk menampilkan DataFrame <strong>df_nilai</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HNTREm5pAo__-W7IBkvJEw.png" /></figure><p><strong>Soal 2</strong></p><ul><li>Untuk menampilkan hanya mahasiswa dengan nilai_akhir di atas 80 adalah dengan mengatur filter untuk memeriksa setiap baris pada kolom <strong>nilai_akhir </strong>dengan perintah <strong>df_nilai[‘nilai_akhir’] &gt; 80 .</strong></li><li>Perintah ini menerapkan <em>Boolean Indexing</em> yaitu teknik <em>filtering</em> pada Pandas dengan logika <em>True</em> dan <em>False </em>untuk memilih baris yang sesuai dengan kondisi yang kita inginkan.</li><li>Hasil penyaringan Boolean tidak ditampilkan langsung di output pengguna, akan tetapi disimpan pada <strong>df_nilai[…]</strong>. Pandas akan memilih atau memfilter tabel tersebut, jika baris bernilai <strong>True</strong> maka baris akan disimpan dalam DataFrame <strong>df_lulus</strong>. Jika bernilai <strong>False</strong> maka baris tidak akan ditampilkan.</li><li>Perintah <strong>df_lulus</strong> akan menampilkan data sesuai kondisi yaitu mahasiswa yang memiliki nilai akhir di atas 80.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f9kMr6RSL5LimMNw-XcWng.png" /></figure><h4>Kesimpulan</h4><p>Dengan menyiapkan Conda Environment pada Ubuntu menggunakan platform Anaconda diharapkan pada praktikum selanjutnya akan memudahkan proses pengolahan data dengan antarmuka Jupyter Notebook untuk mengeksekusi kode program dengan baik. Selain itu, pengenalan python dasar untuk pengolahan data dapat dijadikan bekal untuk pengolahan data selanjutnya yang lebih kompleks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=29533930459b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Installasi Ubuntu dengan Virtualbox — Praktikum Big Data]]></title>
            <link>https://medium.com/@debi.aprilia/installasi-ubuntu-dengan-virtualbox-praktikum-big-data-019d5b1d72d2?source=rss-c81725c91e44------2</link>
            <guid isPermaLink="false">https://medium.com/p/019d5b1d72d2</guid>
            <category><![CDATA[oracle-virtual-box]]></category>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[ubuntu-desktop]]></category>
            <dc:creator><![CDATA[Debi Aprilia]]></dc:creator>
            <pubDate>Sun, 23 Aug 2026 16:34:35 GMT</pubDate>
            <atom:updated>2026-08-23T16:34:35.337Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mEsFlLAmmY7Fgo4iRVJvXg.jpeg" /></figure><p>Oracle VirtualBox merupakan perangkat lunak <em>open source</em> yang dapat digunakan untuk menjalankan virtualisasi berbagai sistem operasi pada satu komputer tanpa harus melakukan <em>dual-boot</em>. Dengan menggunakan VirtualBox, sistem operasi pada laptop atau komputer asli tidak akan berubah, serta dapat dihapus kapan saja tanpa memengaruhi sistem asli.</p><p>Ubuntu merupakan salah satu pengembangan dari sistem operasi Linux, yaitu merupakan perkembangan dari sistem operasi Linux Debian. Sehingga, hampir semua library Linux dapat dijalankan dalam Ubuntu. Beberapa jenis Ubuntu yang cukup terkenal yaitu Ubuntu Desktop, Ubuntu GNOME, Ubuntu Xubuntu, Ubuntu Kubuntu, dan Ubuntu Server.</p><h4>Install VirtualBox</h4><p>Untuk mengunduh VirtualBox, kunjungi halaman resmi <a href="https://www.virtualbox.org/">VirtualBox</a>, kemudian pilih menu <a href="https://www.virtualbox.org/wiki/Downloads">Download,</a> dan unduh versi VirtualBox sesuai sistem operasi masing — masing perangkat yang digunakan.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L6hb8jo3725hvyX22LALgA.png" /></figure><p>Setelah proses mengunduh selesai, instal aplikasi dengan menekan tombol Next sampai VirtualBox berhasil terpasang.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*PYr5eOP5kKctYhgXqjTRkw.png" /></figure><p>Berikut adalah tampilan awal VirtualBox setelah berhasil terpasang.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/956/1*COFPzFnGjpfX5aLtm8i3dw.png" /></figure><h4>Install Ubuntu</h4><p>Sebelum membuat virtual machine baru untuk Ubuntu, unduh <a href="https://ubuntu.com/download/desktop">ISO Ubuntu</a> terlebih dahulu. ISO Ubuntu berfungsi sebagai salinan digital yang berisi semua file dan direktori dari disk asli dalam satu file yang dapat digunakan untuk membuat mesin virtual.</p><p>Setelah itu, buka VirtualBox dan pilih tombol <strong>New</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RuSG0UJqbnyxp6dfjJTKLA.png" /></figure><p>Kemudian isi nama dan sistem operasi yang akan digunakan. Masukkan file ISO Ubuntu yang sudah di unduh sebelumnya ke dalam kolom <strong>ISO Image</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*rzG--WqvbS5fqimZqhwpSg.png" /></figure><p>Kemudian pilih menu <strong>Hardware</strong>. Atur <strong>Base Memory</strong> dan <strong>Processors</strong> dengan menggeser slider atau mengetikkan secara langsung jumlah memori dan CPU yang akan digunakan. Usahakan jangan melebihi batas berwarna hijau agar sistem operasi utama tetap berjalan lancar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*sn4CKI3RX54dZX2i7fpUhQ.png" /></figure><p>Kemudian pilih menu <strong>Hard Disk</strong>. Atur File Location dan Size sesuai kebutuhan. Setelah itu pilih tombol <strong>finish</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*pMi8kKpxN6g2pZgFdbA6uw.png" /></figure><p>Mesin Virtual berhasil dibuat, kemudian pilih menu <strong>Start</strong> untuk mulai menginstall Ubuntu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fVDvoV8xba_7MAE7WwH2cg.png" /></figure><p>Setelah tombol Start ditekan, akan muncul pilihan seperti gambar berikut. Pilih menu <strong>Try or Install Ubuntu</strong> kemudian tekan Enter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*uXFYRc-IQL0c9aps4fN6Og.png" /></figure><p>Setelah itu pilih bahasa yang akan digunakan, kemudian tekan tombol <strong>Install Ubuntu</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JBXWY8MBETVsiBqqD3YciQ.png" /></figure><p>Ikuti langkah — langkah installasi dengan menekan tombol ‘<strong>Continue</strong>’ sampai muncul form untuk membuat username dan password.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MDdhEggYUtval2wgfvAbnA.png" /></figure><p>Kemudian tekan tombol Continue, dan tunggu proses installasi sampai selesai.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pRu8XENO-t2kSfT4yrWfRA.png" /></figure><p>Jika proses installasi sudah selesai, tekan tombol <strong>Restart Now</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-WegMrFbmvkpghQ34FuWwg.png" /></figure><p>Setelah proses Restart selesai, masukkan password yang tadi sudah dibuat, kemudian tekan Enter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vDX3n70prFuiUB8sc3RglQ.png" /></figure><p>Ubuntu berhasil diinstall dan siap digunakan untuk menjalankan aplikasi, internet, mengelola file, dan berbagai tugas lainnya.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5AZ_O8glwgEM29aUUwEDpQ.png" /></figure><h4>Kesimpulan</h4><p>Menggunakan Ubuntu di VirtualBox dapat memudahkan proses belajar Linux tanpa berisiko mengubah sistem utama. Proses installasi mungkin membutuhkan sedikit waktu lebih lama, namun setelah itu Ubuntu siap digunakan untuk mempelajari software Linux tanpa takut akan merusak sistem operasi bawaan laptop atau komputer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=019d5b1d72d2" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>