TASK BEFORE TEST (BIG DATA)

REKAPAN MATERI SEMESTER 1

9 min readOct 10, 2026

1. Big Data

Big Data adalah kumpulan data yang memiliki ukuran, kecepatan pertumbuhan, dan keragaman tinggi sehingga memerlukan teknologi khusus untuk mengelolanya. Salah satu konsep yang digunakan untuk menjelaskan Big Data adalah 5V, yaitu Volume, Velocity, Variety, Veracity, dan Value.

2. HDFS

Hadoop Distributed File System (HDFS) merupakan sistem penyimpanan terdistribusi yang dirancang untuk menyimpan data dalam jumlah besar. HDFS memungkinkan data disimpan dan diakses melalui sistem Hadoop. Pada praktikum ini, HDFS digunakan untuk menyimpan data transaksi, data toko, data produk, dan hasil pengolahan.

3. Apache Spark dan PySpark

Apache Spark merupakan teknologi pemrosesan data terdistribusi yang mendukung pengolahan data dalam jumlah besar. PySpark adalah antarmuka Python untuk menggunakan Apache Spark. Dalam praktikum ini, PySpark digunakan untuk membaca data, menggabungkan tabel, menghitung penjualan, melakukan pengelompokan, dan menghasilkan ringkasan analisis.

4. Spark DataFrame

Spark DataFrame merupakan struktur data berbentuk tabel yang terdiri atas baris dan kolom. DataFrame menyediakan berbagai fungsi, seperti select(), filter(), groupBy(), agg(), dan withColumn(), yang dapat digunakan untuk mengolah data.

5. Join

Join adalah proses menggabungkan dua atau lebih tabel berdasarkan kolom yang saling berhubungan. Pada praktikum ini, data transaksi digabungkan dengan data toko menggunakan toko_id dan dengan data produk menggunakan product_id. Jenis join yang digunakan adalah inner join.

6. Window Function

Window function merupakan fungsi yang digunakan untuk melakukan perhitungan atau memberikan peringkat pada data berdasarkan kelompok tertentu. Fungsi row_number() digunakan untuk memberikan nomor urut berdasarkan nilai yang telah ditentukan. Dalam praktikum ini, window function digunakan untuk mengambil tiga produk dengan total penjualan tertinggi pada setiap toko.

7. Spark SQL

Spark SQL merupakan fitur Apache Spark yang memungkinkan pengolahan data menggunakan perintah SQL. DataFrame dapat didaftarkan sebagai temporary view menggunakan createOrReplaceTempView(), kemudian dianalisis melalui fungsi spark.sql().

8. Format Parquet

Parquet merupakan format penyimpanan data berbentuk kolumnar yang cocok digunakan untuk analisis Big Data. Format ini mendukung kompresi dan pembacaan kolom secara selektif. Pada praktikum ini, data hasil penggabungan disimpan dalam format Parquet dengan partisi berdasarkan kategori produk.

9. ETL (Extract, Transform, Load)

ETL adalah proses pengolahan data yang terdiri dari tiga tahapan utama. Extract merupakan proses mengambil data dari sumber, Transform merupakan proses mengubah dan menganalisis data, sedangkan Load merupakan proses menyimpan hasil pengolahan ke tempat penyimpanan tujuan. Ketiga tahapan tersebut diterapkan dalam studi kasus pada praktikum pertemuan 7.

STUDI KASUS

Konteks: Sebuah perusahaan retail memiliki 4 cabang toko 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.

Persiapan: Membuat SparkSession dan Tiga Sumber Data

from pyspark.sql import SparkSession
from pyspark.sql.functions import col, sum as spark_sum, avg, count, row_number, when
from pyspark.sql.window import Window
import numpy as np
import pandas as pd
import json

spark = SparkSession.builder \
    .appName("Pertemuan7-StudiKasusTerintegrasi") \
    .master("local[*]") \
    .getOrCreate()
spark.sparkContext.setLogLevel("ERROR")

print("SparkSession siap. Versi Spark:", spark.version)

OUTPUT

SparkSession siap. Versi Spark: 3.5.9

np.random.seed(77)

# SUMBER 1: Data toko/cabang (JSON) — tabel referensi kecil
toko_list = ["Toko Magelang", "Toko Yogyakarta", "Toko Semarang", "Toko Solo"]
data_toko = [
    {"toko_id": i + 1, "nama_toko": t, "kota": t.split()[1], "manager": np.random.choice(["Rani", "Joko", "Sari", "Bayu"])}
    for i, t in enumerate(toko_list)
]
with open("data_toko.json", "w") as f:
    for t in data_toko:
        f.write(json.dumps(t) + "\n")

# SUMBER 2: Data produk (CSV) — tabel referensi kecil
data_produk = [
    {"product_id": i, "nama_produk": f"Produk-{i}",
     "kategori": np.random.choice(["Elektronik", "Fashion", "Makanan"]),
     "harga": int(np.random.choice([50000, 100000, 200000]))}
    for i in range(1, 21)
]
pd.DataFrame(data_produk).to_csv("data_produk.csv", index=False)

# SUMBER 3: Data transaksi triwulan (CSV) — data utama, jauh lebih besar
n = 5000
data_transaksi = pd.DataFrame({
    "trx_id": [f"T{i}" for i in range(n)],
    "toko_id": np.random.randint(1, 5, size=n),
    "product_id": np.random.randint(1, 21, size=n),
    "qty": np.random.randint(1, 6, size=n),
})
data_transaksi.to_csv("data_transaksi_triwulan.csv", index=False)

print("Ketiga sumber data berhasil dibuat:")
print(f"- data_toko.json              : {len(data_toko)} baris")
print(f"- data_produk.csv             : {len(data_produk)} baris")
print(f"- data_transaksi_triwulan.csv : {len(data_transaksi)} baris")

OUTPUT

Ketiga sumber data berhasil dibuat:
- data_toko.json              : 4 baris
- data_produk.csv             : 20 baris
- data_transaksi_triwulan.csv : 5000 baris

Mengunggah Sumber Data Utama ke HDFS

Konsisten dengan praktik yang dipelajari sejak Pertemuan 3: data mentah berukuran besar sebaiknya disimpan di HDFS, bukan hanya di disk lokal.

!hdfs dfs -mkdir -p /user/mahasiswa/pertemuan7/raw
!hdfs dfs -put -f data_transaksi_triwulan.csv /user/mahasiswa/pertemuan7/raw/
!hdfs dfs -put -f data_toko.json /user/mahasiswa/pertemuan7/raw/
!hdfs dfs -put -f data_produk.csv /user/mahasiswa/pertemuan7/raw/
!hdfs dfs -ls /user/mahasiswa/pertemuan7/raw

OUTPUT

Found 3 items
-rw-r--r--   1 adnan supergroup        599 2026-10-10 14:19 /user/mahasiswa/pertemuan7/raw/data_produk.csv
-rw-r--r--   1 adnan supergroup        332 2026-10-10 14:19 /user/mahasiswa/pertemuan7/raw/data_toko.json
-rw-r--r--   1 adnan supergroup      61655 2026-10-10 14:19 /user/mahasiswa/pertemuan7/raw/data_transaksi_triwulan.csv

Tahap EXTRACT — Membaca dari HDFS

df_transaksi = spark.read.csv(
    "hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_transaksi_triwulan.csv",
    header=True, inferSchema=True
)
df_toko = spark.read.json("hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_toko.json")
df_produk = spark.read.csv(
    "hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_produk.csv",
    header=True, inferSchema=True
)

print("Transaksi:", df_transaksi.count(), "| Toko:", df_toko.count(), "| Produk:", df_produk.count())

OUTPUT

Transaksi: 5000 | Toko: 4 | Produk: 20

Tahap TRANSFORM

Menggabungkan Ketiga Sumber (Join)

df_gabungan = df_transaksi.join(df_toko, on="toko_id", how="inner") \
                           .join(df_produk, on="product_id", how="inner")

df_gabungan = df_gabungan.withColumn("total_penjualan", col("qty") * col("harga"))
df_gabungan.show(5)

OUTPUT

+----------+-------+------+---+----------+-------+---------------+-----------+----------+------+---------------+
|product_id|toko_id|trx_id|qty|      kota|manager|      nama_toko|nama_produk|  kategori| harga|total_penjualan|
+----------+-------+------+---+----------+-------+---------------+-----------+----------+------+---------------+
|         7|      1|    T0|  5|  Magelang|   Bayu|  Toko Magelang|   Produk-7|   Makanan|200000|        1000000|
|         5|      2|    T1|  5|Yogyakarta|   Bayu|Toko Yogyakarta|   Produk-5|Elektronik|200000|        1000000|
|         2|      3|    T2|  2|  Semarang|   Rani|  Toko Semarang|   Produk-2|Elektronik|100000|         200000|
|         2|      2|    T3|  2|Yogyakarta|   Bayu|Toko Yogyakarta|   Produk-2|Elektronik|100000|         200000|
|        18|      4|    T4|  2|      Solo|   Rani|      Toko Solo|  Produk-18|Elektronik|100000|         200000|
+----------+-------+------+---+----------+-------+---------------+-----------+----------+------+---------------+
only showing top 5 rows

2. Window Function — Top 3 Produk Terlaris per Toko

# Meringkas total penjualan per kombinasi toko + produk terlebih dahulu
ringkasan_produk_toko = df_gabungan.groupBy("nama_toko", "nama_produk").agg(
    spark_sum("total_penjualan").alias("total_penjualan")
)

# Menerapkan window function untuk mengambil top-3 produk pada setiap toko
window_toko = Window.partitionBy("nama_toko").orderBy(col("total_penjualan").desc())
top3_produk = ringkasan_produk_toko.withColumn("peringkat", row_number().over(window_toko)) \
                                    .filter(col("peringkat") <= 3)

top3_produk.orderBy("nama_toko", "peringkat").show(20)

OUTPUT

+---------------+-----------+---------------+---------+
|      nama_toko|nama_produk|total_penjualan|peringkat|
+---------------+-----------+---------------+---------+
|  Toko Magelang|   Produk-7|       46000000|        1|
|  Toko Magelang|   Produk-5|       44400000|        2|
|  Toko Magelang|  Produk-14|       38400000|        3|
|  Toko Semarang|   Produk-8|       49200000|        1|
|  Toko Semarang|   Produk-7|       40400000|        2|
|  Toko Semarang|   Produk-5|       39000000|        3|
|      Toko Solo|  Produk-14|       38400000|        1|
|      Toko Solo|   Produk-7|       37200000|        2|
|      Toko Solo|   Produk-5|       33200000|        3|
|Toko Yogyakarta|  Produk-14|       48200000|        1|
|Toko Yogyakarta|   Produk-5|       37600000|        2|
|Toko Yogyakarta|   Produk-4|       37000000|        3|
+---------------+-----------+---------------+---------+

Spark SQL — Kontribusi per Manajer Cabang

df_gabungan.createOrReplaceTempView("gabungan")

kontribusi_manager = spark.sql('''
    SELECT kota, manager, SUM(total_penjualan) AS total_penjualan
    FROM gabungan
    GROUP BY kota, manager
    ORDER BY total_penjualan DESC
''')
kontribusi_manager.show()

OUTPUT

+----------+-------+---------------+
|      kota|manager|total_penjualan|
+----------+-------+---------------+
|  Semarang|   Rani|      416250000|
|  Magelang|   Bayu|      408550000|
|Yogyakarta|   Bayu|      389150000|
|      Solo|   Rani|      369950000|
+----------+-------+---------------+

Tahap LOAD — Menyimpan Laporan Akhir ke HDFS

!hdfs dfs -mkdir -p /user/mahasiswa/pertemuan7/processed

df_gabungan.write.mode("overwrite").partitionBy("kategori").parquet(
    "hdfs://localhost:9000/user/mahasiswa/pertemuan7/processed/laporan_triwulan"
)

print("Laporan berhasil disimpan ke HDFS dalam format Parquet, terpartisi per kategori produk.")
!hdfs dfs -ls /user/mahasiswa/pertemuan7/processed/laporan_triwulan

OUTPUT

Laporan berhasil disimpan ke HDFS dalam format Parquet, terpartisi per kategori produk.
                                                                                
Found 4 items
-rw-r--r--   3 adnan supergroup          0 2026-10-10 14:20 /user/mahasiswa/pertemuan7/processed/laporan_triwulan/_SUCCESS
drwxr-xr-x   - adnan supergroup          0 2026-10-10 14:20 /user/mahasiswa/pertemuan7/processed/laporan_triwulan/kategori=Elektronik
drwxr-xr-x   - adnan supergroup          0 2026-10-10 14:20 /user/mahasiswa/pertemuan7/processed/laporan_triwulan/kategori=Fashion
drwxr-xr-x   - adnan supergroup          0 2026-10-10 14:20 /user/mahasiswa/pertemuan7/processed/laporan_triwulan/kategori=Makanan

Verifikasi Akhir — Ringkasan Eksekutif

df_final = spark.read.parquet("hdfs://localhost:9000/user/mahasiswa/pertemuan7/processed/laporan_triwulan")

ringkasan_eksekutif = df_final.groupBy("nama_toko", "kota", "manager").agg(
    spark_sum("total_penjualan").alias("total_penjualan_triwulan"),
    count("trx_id").alias("jumlah_transaksi"),
    avg("total_penjualan").alias("rata_rata_nilai_transaksi")
).orderBy(col("total_penjualan_triwulan").desc())

ringkasan_eksekutif.show()

OUTPUT

+---------------+----------+-------+------------------------+----------------+-------------------------+
|      nama_toko|      kota|manager|total_penjualan_triwulan|jumlah_transaksi|rata_rata_nilai_transaksi|
+---------------+----------+-------+------------------------+----------------+-------------------------+
|  Toko Semarang|  Semarang|   Rani|               416250000|            1306|       318721.28637059726|
|  Toko Magelang|  Magelang|   Bayu|               408550000|            1315|       310684.41064638784|
|Toko Yogyakarta|Yogyakarta|   Bayu|               389150000|            1200|        324291.6666666667|
|      Toko Solo|      Solo|   Rani|               369950000|            1179|        313782.8668363019|
+---------------+----------+-------+------------------------+----------------+-------------------------+

Anda baru saja menyelesaikan satu alur analisis Big Data yang utuh — persis seperti pekerjaan seorang data engineer/analyst sesungguhnya: dari data mentah tersebar di berbagai sumber & format, tersimpan di HDFS, diproses dengan Spark (join, window function, Spark SQL), hingga tersimpan rapi sebagai laporan akhir berformat Parquet yang siap dipakai tim lain atau divisualisasikan di dashboard.

Get Adnan Tsaqif’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

MENUTUP SPARK SESSION

spark.stop()
print("SparkSession ditutup.")

LATIHAN MANDIRI

Jalankan ulang cell pembuatan SparkSession dan ketiga DataFrame (df_transaksi, df_toko, df_produk, baca dari HDFS) sebelum mengerjakan latihan berikut.

# Persiapan ulang untuk latihan
spark = SparkSession.builder.appName("Latihan7").master("local[*]").getOrCreate()
spark.sparkContext.setLogLevel("ERROR")

df_transaksi = spark.read.csv("hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_transaksi_triwulan.csv", header=True, inferSchema=True)
df_toko = spark.read.json("hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_toko.json")
df_produk = spark.read.csv("hdfs://localhost:9000/user/mahasiswa/pertemuan7/raw/data_produk.csv", header=True, inferSchema=True)
df_gabungan = df_transaksi.join(df_toko, on="toko_id").join(df_produk, on="product_id")
df_gabungan = df_gabungan.withColumn("total_penjualan", col("qty") * col("harga"))
print("Siap untuk latihan. Total baris:", df_gabungan.count())

Siap untuk latihan. Total baris: 5000

Menggunakan Spark SQL, tampilkan kategori produk dengan total qty (jumlah unit terjual, bukan nilai rupiah) tertinggi secara keseluruhan.

# Jawaban Soal 1 di sini
# Mendaftarkan dataframe ke temporary view agar bisa di-query menggunakan Spark SQL
df_gabungan.createOrReplaceTempView("gabungan")

# Query Spark SQL untuk menjumlahkan qty per kategori produk dan mengurutkannya dari yang tertinggi
query_soal1 = """
    SELECT kategori, SUM(qty) AS total_qty
    FROM gabungan
    GROUP BY kategori
    ORDER BY total_qty DESC
"""

spark.sql(query_soal1).show(truncate=False)

OUTPUT

+----------+---------+
|kategori  |total_qty|
+----------+---------+
|Elektronik|6736     |
|Fashion   |5307     |
|Makanan   |3114     |
+----------+---------+

2. Menggunakan window function, tentukan toko dengan penjualan tertinggi untuk masing-masing kategori produk (top-1 saja, gunakan row_number()).

# Jawaban Soal 2 di sini
from pyspark.sql.window import Window
from pyspark.sql.functions import col, row_number, sum as _sum

# 1. Agregasi total penjualan (atau total qty/nilai rupiah, di sini diasumsikan total_penjualan berdasarkan konteks umum, atau sesuaikan dengan kolom total_penjualan) per kategori dan toko
df_toko_kategori = df_gabungan.groupBy("kategori", "toko_id", "nama_toko").agg(
    _sum("total_penjualan").alias("pendapatan_toko") # atau ganti dengan "qty" jika yang diminta jumlah unit
)

# 2. Definisikan Window partition berdasarkan kategori, diurutkan berdasarkan penjualan tertinggi
windowSpec = Window.partitionBy("kategori").orderBy(col("pendapatan_toko").desc())

# 3. Terapkan row_number() dan filter peringkat 1 (top-1)
df_top1 = df_toko_kategori.withByRowNumber = df_toko_kategori.withColumn("rank", row_number().over(windowSpec))
df_top1.filter(col("rank") == 1).drop("rank").show(truncate=False)

OUTPUT

+----------+-------+-------------+---------------+
|kategori  |toko_id|nama_toko    |pendapatan_toko|
+----------+-------+-------------+---------------+
|Elektronik|1      |Toko Magelang|202150000      |
|Fashion   |3      |Toko Semarang|123000000      |
|Makanan   |1      |Toko Magelang|108200000      |
+----------+-------+-------------+---------------+

3. Simpan hasil ringkasan_eksekutif (dari Sub-bab 7.4 di atas — silakan buat ulang) ke HDFS sebagai Parquet tanpa partisi, pada path /user/mahasiswa/latihan7/ringkasan_eksekutif.

# Jawaban Soal 3 di sini
# Menyimpan dataframe ke HDFS dalam format Parquet tanpa partisi
ringkasan_eksekutif = df_gabungan # Ganti dengan variabel dataframe ringkasan Anda jika ada

ringkasan_eksekutif.write \
    .mode("overwrite") \
    .parquet("hdfs://localhost:9000/user/mahasiswa/latihan7/ringkasan_eksekutif")

print("Penyimpanan ringkasan eksekutif ke Parquet berhasil!")

OUTPUT

Penyimpanan ringkasan eksekutif ke Parquet berhasil!

4. (Refleksi menyeluruh). Sebagai persiapan UTS, jelaskan dalam 4–5 kalimat: bagaimana HDFS, Spark, dan format Parquet saling melengkapi dalam satu ekosistem Big Data? Gunakan istilah-istilah yang telah anda pelajari sejak Pertemuan 3 (mis. distributed storage, in-memory processing, columnar format, partitioning).
Jawaban
(Dalam ekosistem Big Data, HDFS berperan sebagai fondasi distributed storage yang menyimpan data berukuran besar secara terdistribusi di beberapa node. Apache Spark kemudian memanfaatkan data tersebut untuk melakukan in-memory processing yang sangat cepat, jauh lebih efisien dibanding metode berbasis disk tradisional. Agar performa pemrosesan semakin optimal, data disimpan menggunakan format columnar format seperti Parquet yang mendukung kompresi tinggi dan partitioning untuk mempercepat proses pembacaan data. Ketiganya saling melengkapi untuk menciptakan alur kerja analisis data skala besar yang handal, cepat, dan efisien.)

(https://github.com/AdnanTIF-0064/Praktikum-BIG-DATA/blob/main/Modul_Praktikum_BigData_Pertemuan7.ipynb)