Tutorial Big Data untuk Pemula: Mengolah 1 Juta Data Menggunakan PySpark dan Memvisualisasikannya dengan Python

Bagaimana mengubah jutaan baris data menjadi informasi yang mudah dipahami? Mari praktik langsung menggunakan Apache Spark dan Python.

Pendahuluan

Pernah membayangkan bagaimana perusahaan seperti marketplace, perbankan, atau platform digital menganalisis jutaan transaksi setiap harinya?

Data transaksi yang dihasilkan dapat berisi informasi mengenai waktu pembelian, kategori produk, nilai transaksi, hingga perilaku pelanggan. Jika diolah dengan tepat, data tersebut dapat membantu perusahaan memahami pola penjualan dan menentukan keputusan bisnis.

Namun, semakin besar volume data, semakin tinggi pula kebutuhan terhadap teknologi pemrosesan data yang efisien.

Dalam pembelajaran Big Data Analysis and Data Visualization, kita tidak hanya dituntut memahami bagaimana data disimpan dan diproses, tetapi juga bagaimana mengubah data mentah menjadi informasi yang bermakna.

Pada tutorial kali ini, saya ingin berbagi eksperimen sederhana menggunakan Apache Spark melalui PySpark untuk mengolah satu juta baris data transaksi simulasi dan memvisualisasikan hasilnya menggunakan Python.

Menariknya, praktik ini dapat dilakukan di laptop pribadi tanpa harus memiliki infrastruktur cluster Big Data.

1. Mengenal Apache Spark dan PySpark

Apache Spark merupakan mesin pemrosesan data yang dirancang untuk mendukung komputasi paralel dan terdistribusi.

Spark memiliki sejumlah komponen yang mendukung analisis data, antara lain:

• Spark SQL: memproses data terstruktur menggunakan DataFrame maupun SQL.
• Structured Streaming: memproses data streaming.
• MLlib: mendukung pengembangan pipeline machine learning.
• PySpark: menyediakan antarmuka Python untuk menggunakan kemampuan Apache Spark.

Berbeda dengan Pandas yang secara umum melakukan pemrosesan DataFrame dalam memori satu komputer, Spark dapat membagi pekerjaan komputasi ke beberapa partisi dan menjalankannya secara paralel.

Pada tutorial ini, Spark dijalankan dalam mode lokal. Artinya, kita memanfaatkan kemampuan pemrosesan paralel pada komputer sendiri, bukan cluster multi-server.

Tujuan utamanya adalah memahami konsep dan alur analisis data menggunakan teknologi yang umum digunakan dalam ekosistem Big Data.

2. Studi Kasus: Analisis Satu Juta Transaksi E-Commerce

Bayangkan kita sedang mengembangkan sebuah sistem analitik untuk marketplace.

Tim bisnis ingin mengetahui kategori produk dengan nilai transaksi terbesar, total transaksi setiap bulan, dan bagaimana distribusi nilai transaksi pada berbagai kategori.

Untuk menjawab kebutuhan tersebut, kita akan membuat dataset simulasi sebanyak 1.000.000 baris transaksi.

Dataset terdiri atas beberapa kolom:

Kolom	Keterangan
transaction_id	ID unik transaksi
tanggal	Tanggal transaksi
kategori	Kategori produk
jumlah	Jumlah unit barang
harga_satuan	Harga per unit
total	Nilai transaksi

Data yang digunakan merupakan data sintetis, bukan data transaksi pelanggan yang sebenarnya. Pendekatan ini memungkinkan kita memahami pemrosesan data tanpa memerlukan akses ke data pribadi atau sistem perusahaan.

3. Persiapan Lingkungan

Sebelum memulai, pastikan komputer sudah memiliki Python dan Java yang kompatibel dengan versi Apache Spark.

Untuk praktik ini kita dapat menggunakan PySpark 4.1.1 dengan Python 3.10 atau lebih baru dan Java 17 atau Java 21.

Buka terminal atau PowerShell, kemudian jalankan:

python --version
java -version

Selanjutnya buat virtual environment agar pustaka yang digunakan tidak mengganggu proyek Python lainnya.

python -m venv .venv

Untuk Windows PowerShell:

.\.venv\Scripts\Activate.ps1

Untuk Linux atau macOS:

source .venv/bin/activate

Setelah lingkungan aktif, instal pustaka yang diperlukan:

python -m pip install pyspark==4.1.1 pandas matplotlib

PySpark digunakan untuk memproses data, Pandas untuk menyiapkan hasil agregasi sebelum divisualisasikan, sedangkan Matplotlib digunakan untuk membuat grafik.

4. Membuat Spark Session

Langkah pertama adalah membuat Spark Session yang menjadi pintu masuk untuk menjalankan operasi Spark.

Buat file Python dengan nama:

analisis_bigdata.py

Kemudian masukkan kode berikut:

from pyspark.sql import SparkSession
from pyspark.sql import functions as F
import matplotlib.pyplot as plt

spark = (
    SparkSession.builder
    .appName("AnalisisBigDataMahasiswa")
    .master("local[*]")
    .getOrCreate()
)

print("Spark berhasil dijalankan!")

Perintah local[*] berarti Spark akan menggunakan core CPU logis yang tersedia pada mesin lokal.

Untuk memulai dengan sumber daya lebih terbatas, kita juga dapat menggantinya menjadi local[2].

5. Membuat Dataset Satu Juta Transaksi

Setelah Spark Session siap, kita dapat menghasilkan dataset secara otomatis.

Tambahkan kode berikut:

from pyspark.sql import functions as F

kategori = [
    "Elektronik",
    "Fashion",
    "Makanan",
    "Kesehatan",
    "Peralatan Rumah",
]

df = (
    spark.range(1, 1_000_001)
    .withColumnRenamed("id", "transaction_id")
    .withColumn(
        "kategori",
        F.element_at(
            F.array(*[F.lit(k) for k in kategori]),
            (F.col("transaction_id") % 5 + 1).cast("int")
        )
    )
    .withColumn(
        "jumlah",
        (F.col("transaction_id") % 5 + 1).cast("int")
    )
    .withColumn(
        "harga_satuan",
        (
            (F.col("transaction_id") % 20 + 1)
            * 25000
        ).cast("long")
    )
    .withColumn(
        "tanggal",
        F.date_add(
            F.lit("2025-01-01").cast("date"),
            (F.col("transaction_id") % 365).cast("int")
        )
    )
    .withColumn(
        "total",
        F.col("jumlah") * F.col("harga_satuan")
    )
)

df.printSchema()
df.show(10, truncate=False)

Kode tersebut membuat satu juta transaksi sintetis dengan tanggal, kategori, jumlah barang, dan nilai transaksi yang dibangkitkan secara deterministik.

Dataset sengaja dirancang sederhana agar fokus pembelajaran berada pada proses analisis.

Perlu dipahami bahwa data yang dibuat menggunakan pola matematis ini tidak menggambarkan perilaku konsumen nyata. Karena itu, hasilnya hanya digunakan untuk latihan pemrosesan dan visualisasi, bukan untuk menyimpulkan karakteristik pasar.

6. Melakukan Analisis Data dengan Spark

Setelah memiliki dataset, tahap berikutnya adalah melakukan agregasi.

Misalnya, kita ingin mengetahui total nilai transaksi berdasarkan kategori produk.

penjualan_kategori = (
    df.groupBy("kategori")
    .agg(
        F.count("*").alias("jumlah_transaksi"),
        F.sum("total").alias("total_penjualan"),
        F.avg("total").alias("rata_rata_transaksi")
    )
    .orderBy(F.desc("total_penjualan"))
)

penjualan_kategori.show(truncate=False)

Di sinilah kemampuan Spark mulai digunakan.

Alih-alih menghitung setiap transaksi secara manual menggunakan perulangan Python, kita memanfaatkan operasi DataFrame untuk melakukan pengelompokan dan agregasi.

Tiga informasi yang dihasilkan adalah jumlah transaksi, total nilai penjualan, dan rata-rata nilai transaksi untuk setiap kategori.

Metode groupBy() dan agg() menjadi dasar penting dalam proses analisis karena banyak pertanyaan bisnis pada akhirnya membutuhkan agregasi seperti jumlah, rata-rata, nilai minimum, maupun maksimum.

7. Mengubah Hasil Analisis Menjadi Visualisasi

Data tabular sangat membantu proses komputasi, tetapi tidak selalu menjadi cara terbaik untuk menyampaikan hasil analisis.

Karena itu, kita akan membuat grafik batang menggunakan Matplotlib.

Pertama, konversi hasil agregasi menjadi Pandas DataFrame:

pandas_df = penjualan_kategori.toPandas()

Langkah ini aman untuk latihan kita karena hasil agregasi hanya berisi lima kategori, bukan satu juta baris data mentah.

Selanjutnya, buat grafik:

plt.figure(figsize=(10, 6))

plt.bar(
    pandas_df["kategori"],
    pandas_df["total_penjualan"] / 1_000_000,
    color="steelblue"
)

plt.title(
    "Total Nilai Penjualan per Kategori",
    fontsize=14
)

plt.xlabel("Kategori Produk")
plt.ylabel("Total Penjualan (Juta Rupiah)")

plt.xticks(rotation=20, ha="right")
plt.tight_layout()

plt.savefig("penjualan_kategori.png", dpi=150)
plt.show()

Grafik yang dihasilkan memperlihatkan perbandingan total nilai penjualan pada lima kategori produk.

Visualisasi seperti ini memudahkan kita untuk mengidentifikasi kategori dengan nilai penjualan tertinggi dan terendah tanpa harus membaca angka satu per satu.

Dalam praktik Data Visualization, memilih grafik yang tepat sangat penting. Grafik batang cocok untuk membandingkan nilai antarkategori, sedangkan grafik garis lebih sesuai untuk mengamati perubahan data berdasarkan waktu.

8. Analisis Tren Penjualan Bulanan

Selain mengetahui kategori dengan nilai penjualan terbesar, kita juga ingin memahami bagaimana nilai transaksi berubah setiap bulan.

Tambahkan kode berikut:

penjualan_bulanan = (
    df.withColumn(
        "bulan",
        F.date_format("tanggal", "yyyy-MM")
    )
    .groupBy("bulan")
    .agg(
        F.sum("total").alias("total_penjualan")
    )
    .orderBy("bulan")
)

bulanan_pd = penjualan_bulanan.toPandas()

plt.figure(figsize=(11, 5))

plt.plot(
    bulanan_pd["bulan"],
    bulanan_pd["total_penjualan"] / 1_000_000,
    marker="o"
)

plt.title("Tren Nilai Penjualan Bulanan")
plt.xlabel("Bulan")
plt.ylabel("Total Penjualan (Juta Rupiah)")

plt.xticks(rotation=45)
plt.grid(alpha=0.3)
plt.tight_layout()

plt.savefig("tren_penjualan_bulanan.png", dpi=150)
plt.show()

Grafik garis akan memperlihatkan perubahan total nilai transaksi selama satu tahun.

Pada dataset nyata, analisis seperti ini dapat digunakan untuk mengidentifikasi pola musiman, perubahan permintaan, dan efektivitas aktivitas promosi.

Namun, pada dataset sintetis kita, perubahan bulanan berasal dari pola pembangkitan data serta jumlah hari pada setiap bulan. Oleh karena itu, grafik tersebut tidak boleh langsung ditafsirkan sebagai tren perilaku konsumen.

9. Mengapa Tidak Menggunakan Pandas Saja?

Pertanyaan ini cukup menarik untuk dibahas.

Jika hanya menggunakan satu juta baris data dengan struktur sederhana, Pandas sebenarnya masih dapat menjadi pilihan yang masuk akal, tergantung kapasitas RAM dan karakteristik pemrosesannya.

Lalu mengapa menggunakan Spark?

Karena tujuan eksperimen ini adalah mempelajari pendekatan komputasi yang dapat diperluas ke pengolahan data terdistribusi.

Aspek	Pandas	PySpark
Eksekusi utama	Satu mesin	Lokal atau cluster
Pemrosesan terdistribusi	Bukan kemampuan utama	Didukung secara native
Kemudahan untuk dataset kecil	Sangat baik	Membutuhkan konfigurasi tambahan
Overhead pemrosesan	Relatif rendah	Lebih tinggi karena Spark engine
Cocok untuk	Analisis eksploratif dan data yang muat di memori	Pipeline data besar dan komputasi terdistribusi

Spark tidak selalu lebih cepat daripada Pandas. Pada dataset kecil, waktu startup dan overhead eksekusi Spark justru dapat membuatnya lebih lambat.

Keunggulan Spark menjadi lebih relevan ketika volume data, kebutuhan komputasi, dan kompleksitas pemrosesan meningkat.

10. Hubungan Tutorial dengan Big Data Analytics

Melalui eksperimen ini, kita telah mempraktikkan alur sederhana analisis data:

Data Generation → Data Processing → Aggregation → Visualization → Interpretation

Alur tersebut sangat dekat dengan proses yang dilakukan dalam proyek analitik sebenarnya.

Perbedaannya, pada lingkungan produksi data dapat berasal dari transaksi aplikasi, database, message broker, data lake, maupun sistem penyimpanan terdistribusi.

Dataset yang diproses pun tidak terbatas pada satu juta transaksi. Sistem dapat menangani data dalam skala jauh lebih besar dengan menyesuaikan infrastruktur dan strategi pemrosesannya.

Dalam penelitian akademik, alur serupa juga dapat diterapkan untuk menganalisis data pendidikan, hasil survei, log sistem, teks dokumen, maupun dataset yang digunakan dalam pengembangan machine learning.

11. Pengembangan Eksperimen Selanjutnya

Setelah memahami tutorial dasar ini, kita dapat mengembangkannya menjadi beberapa eksperimen lanjutan.

Misalnya membandingkan waktu pemrosesan Pandas dan PySpark pada ukuran data yang berbeda, menggunakan format Parquet untuk penyimpanan analitik, menerapkan Spark SQL, atau menambahkan dashboard interaktif menggunakan Streamlit.

Eksperimen tersebut akan membuat pembelajaran menjadi lebih menarik karena kita dapat melakukan pengukuran dan evaluasi, bukan hanya menjalankan kode.

Hal terpenting dalam mempelajari Big Data bukan sekadar menggunakan teknologi yang populer, melainkan memahami kapan teknologi tersebut diperlukan, bagaimana cara kerjanya, dan apa manfaatnya untuk menyelesaikan masalah.

Kesimpulan

Tutorial ini menunjukkan bahwa teknologi Big Data dapat dipelajari melalui eksperimen yang relatif sederhana menggunakan perangkat pribadi.

Dengan PySpark, kita membuat dan memproses satu juta data transaksi sintetis, kemudian melakukan agregasi dan memvisualisasikan hasilnya menggunakan Matplotlib.

Dari praktik tersebut, kita mempelajari keterkaitan antara pemrosesan data dan visualisasi. Data mentah yang sebelumnya sulit dipahami dapat diringkas menjadi informasi yang lebih mudah dibaca.

Bagi saya, inilah hal menarik dari bidang Big Data Analysis and Data Visualization. Kita tidak hanya belajar bagaimana mengolah data dalam jumlah besar, tetapi juga bagaimana menemukan informasi yang berguna dari data tersebut.

Karena pada akhirnya, nilai sebuah data bukan ditentukan oleh seberapa besar ukurannya, melainkan oleh seberapa baik kita mampu memanfaatkannya.

---

Referensi

1. Apache Software Foundation. Apache Spark Documentation. https://spark.apache.org/docs/4.1.1/
2. Apache Software Foundation. PySpark Getting Started. https://spark.apache.org/docs/4.1.1/api/python/getting_started/index.html
3. The pandas development team. pandas Documentation. https://pandas.pydata.org/docs/
4. Matplotlib Development Team. Matplotlib Documentation. https://matplotlib.org/stable/

Catatan: Seluruh dataset dan contoh visualisasi dalam tutorial ini menggunakan data simulasi untuk tujuan pembelajaran.