Ketika sebuah komputer digunakan untuk bekerja, menjalankan aplikasi, mengakses internet, atau melakukan berbagai aktivitas lainnya, sebenarnya banyak data yang dihasilkan oleh sistem. Data tersebut dapat berupa penggunaan CPU, penggunaan memory, hingga aktivitas jaringan.

Bagi orang yang baru belajar jaringan atau sedang menjalani magang di bidang IT, angka-angka tersebut mungkin terlihat sederhana. Namun, jika dikumpulkan secara terus-menerus, data monitoring tersebut dapat memberikan informasi penting mengenai kondisi sebuah komputer atau server.

Misalnya, kita dapat mengetahui kapan penggunaan CPU meningkat, apakah memory cenderung stabil, atau apakah komputer sedang menerima dan mengirim data dalam jumlah besar.

Untuk memahami pola tersebut, kita dapat menggunakan pendekatan Exploratory Data Analysis (EDA). Pada praktik kali ini, kita akan mencoba melakukan EDA sederhana terhadap data CPU, memory, dan trafik jaringan menggunakan Python.

Apa Itu EDA?

Exploratory Data Analysis (EDA) adalah proses mengeksplorasi dan memahami sebuah dataset sebelum dilakukan analisis yang lebih lanjut. Dengan EDA, kita dapat mengetahui bagaimana bentuk data, apakah terdapat data kosong, apakah ada data duplikat, serta bagaimana pola yang terdapat di dalam dataset.

Dalam praktik system monitoring, EDA dapat digunakan untuk melihat kondisi resource komputer berdasarkan data yang sudah dikumpulkan.

Contohnya, daripada hanya mengatakan bahwa “CPU komputer sedang digunakan”, kita dapat mengetahui berapa rata-rata penggunaan CPU, berapa penggunaan tertinggi, dan bagaimana perubahan penggunaan CPU dari waktu ke waktu.

Apa yang Akan Kita Analisis?

Pada praktik ini kita akan mengumpulkan dan menganalisis tiga indikator utama, yaitu:

• CPU Usage — untuk melihat persentase penggunaan processor.
• Memory Usage — untuk melihat persentase penggunaan RAM.
• Network Traffic — untuk melihat jumlah data yang dikirim dan diterima oleh komputer.

Data tersebut nantinya akan dikumpulkan secara otomatis menggunakan Python dan disimpan dalam file CSV. Setelah itu, file CSV akan dianalisis menggunakan Pandas dan divisualisasikan menggunakan Matplotlib.

Persiapan Praktik

Sebelum memulai praktik, siapkan sebuah laptop atau komputer yang sudah terpasang sistem operasi Linux, misalnya Debian. Kita juga membutuhkan Python 3 dan beberapa library Python.

Jika menggunakan Debian dengan tampilan desktop, pertama buka menu Applications, kemudian cari aplikasi Terminal dan klik aplikasi tersebut.

Selain melalui menu, Terminal pada sebagian besar desktop Linux juga dapat dibuka menggunakan shortcut:

Ctrl + Alt + T

Setelah Terminal terbuka, kita akan melihat tampilan kurang lebih seperti berikut:

user@debian:~$

Mengecek Python

Langkah pertama adalah memastikan Python sudah tersedia di komputer. Pada Terminal, ketik perintah berikut kemudian tekan Enter.

python3 --version

Jika Python sudah terpasang, Terminal akan menampilkan versi Python. Contohnya:

Python 3.11.2

Versi yang muncul pada komputer pembaca mungkin berbeda. Yang penting adalah perintah tersebut menghasilkan informasi versi Python.

Mengecek pip

Selanjutnya kita perlu mengecek pip. Pip digunakan untuk menginstal library Python.

pip3 --version

Jika pip sudah tersedia, akan muncul informasi mengenai versi pip yang digunakan.

Jika pip belum tersedia, kita dapat memasangnya menggunakan perintah berikut:

sudo apt update
sudo apt install python3-pip

Membuat Folder Praktik

Agar file yang digunakan selama praktik tidak tercampur dengan file lainnya, sebaiknya kita membuat folder khusus.

Pada Terminal, ketik:

mkdir system-monitoring
cd system-monitoring

Perintah pertama digunakan untuk membuat folder bernama system-monitoring, sedangkan perintah kedua digunakan untuk masuk ke folder tersebut.

Untuk memastikan posisi folder saat ini, gunakan:

pwd

Contoh hasilnya:

/home/user/system-monitoring

Menginstal Library Python

Sekarang kita akan menginstal beberapa library yang diperlukan untuk praktik. Library yang digunakan adalah psutil, pandas, dan matplotlib.

psutil digunakan untuk mengambil informasi mengenai resource sistem seperti CPU, memory, dan network. Sementara itu, Pandas digunakan untuk mengolah dataset dan Matplotlib digunakan untuk membuat grafik.

Jalankan perintah berikut satu persatu:

apt install python3-venv
python3 -m venv venv
source venv/bin/activate
pip3 install psutil pandas matplotlib

Tunggu hingga proses instalasi selesai.

Membuat Program Monitoring

Setelah semua persiapan selesai, sekarang kita akan membuat program yang bertugas mengambil data system monitoring secara otomatis.

Program akan mengambil beberapa informasi, yaitu waktu pengambilan data, penggunaan CPU, penggunaan memory, jumlah data yang dikirim melalui network, dan jumlah data yang diterima.

Untuk membuat file Python, pada Terminal ketik:

nano monitor.py

Setelah menekan Enter, editor Nano akan terbuka. Masukkan kode berikut:

import psutil
import csv
import time
from datetime import datetime

filename = "system_monitoring.csv"

with open(filename, "w", newline="") as file:
    writer = csv.writer(file)

    writer.writerow([
        "timestamp",
        "cpu_usage",
        "memory_usage",
        "network_sent",
        "network_received"
    ])

    previous = psutil.net_io_counters()

    for i in range(60):
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        cpu = psutil.cpu_percent(interval=1)

        memory = psutil.virtual_memory().percent

        current = psutil.net_io_counters()

        sent = current.bytes_sent - previous.bytes_sent
        received = current.bytes_recv - previous.bytes_recv

        writer.writerow([
            timestamp,
            cpu,
            memory,
            sent,
            received
        ])

        previous = current

        print(
            timestamp,
            "CPU:", cpu,
            "% Memory:", memory,
            "% Sent:", sent,
            "bytes Received:", received,
            "bytes"
        )

        time.sleep(1)

print("Monitoring selesai.")
print("Data tersimpan di:", filename)

Menyimpan Program

Setelah kode selesai dimasukkan, tekan Ctrl + O untuk menyimpan file.

Nano akan meminta nama file. Pastikan nama file tetap monitor.py, kemudian tekan Enter.

Setelah itu tekan Ctrl + X untuk keluar dari Nano.

Untuk memastikan file sudah tersimpan, jalankan:

ls

Seharusnya muncul:

monitor.py

Menjalankan System Monitoring

Sekarang program monitoring sudah siap digunakan. Jalankan menggunakan perintah:

python3 monitor.py

Setelah menekan Enter, program akan mulai mengambil data dari komputer.

Contoh output yang dapat muncul:

2026-08-27 09:10:01 CPU: 12.5 % Memory: 43.2 % Sent: 1250 bytes Received: 8300 bytes
2026-08-27 09:10:02 CPU: 18.4 % Memory: 43.5 % Sent: 2100 bytes Received: 10200 bytes
2026-08-27 09:10:03 CPU: 25.7 % Memory: 43.6 % Sent: 3500 bytes Received: 14500 bytes

Program tersebut melakukan pengambilan data sebanyak 60 kali. Oleh karena itu, proses monitoring membutuhkan waktu kurang lebih satu menit.

Selama proses berlangsung, jangan menutup Terminal. Tunggu sampai muncul pesan:

Monitoring selesai.
Data tersimpan di: system_monitoring.csv

Melihat Dataset Hasil Monitoring

Setelah proses selesai, program akan menghasilkan file bernama system_monitoring.csv. File tersebut merupakan dataset yang nantinya akan kita analisis.

Untuk melihat file yang tersedia, gunakan:

ls -lh

Kemudian kita dapat melihat beberapa baris pertama dataset menggunakan:

head system_monitoring.csv

Contoh hasil:

timestamp,cpu_usage,memory_usage,network_sent,network_received
2026-08-27 09:10:01,12.5,43.2,1250,8300
2026-08-27 09:10:02,18.4,43.5,2100,10200
2026-08-27 09:10:03,25.7,43.6,3500,14500

Memahami Struktur Dataset

Dataset yang kita hasilkan memiliki lima kolom utama. Setiap kolom memiliki fungsi yang berbeda dalam proses analisis.

timestamp menunjukkan waktu ketika data diambil.

cpu_usage menunjukkan persentase penggunaan CPU.

memory_usage menunjukkan persentase penggunaan memory.

network_sent menunjukkan jumlah data yang dikirim komputer.

network_received menunjukkan jumlah data yang diterima komputer.

Karena data tersusun dalam baris dan kolom, dataset ini termasuk structured data.

Membuat Program EDA

Sekarang kita masuk ke bagian utama, yaitu Exploratory Data Analysis. Kita akan menggunakan Pandas untuk membaca dan memeriksa dataset.

Buat file baru menggunakan:

nano eda.py

Kemudian masukkan kode berikut:

import pandas as pd

df = pd.read_csv("system_monitoring.csv")

print("=== INFORMASI DATASET ===")
df.info()

print("\n=== 5 DATA PERTAMA ===")
print(df.head())

print("\n=== UKURAN DATASET ===")
print(df.shape)

print("\n=== NAMA KOLOM ===")
print(df.columns.tolist())

print("\n=== MISSING VALUE ===")
print(df.isnull().sum())

print("\n=== DUPLICATE DATA ===")
print(df.duplicated().sum())

print("\n=== STATISTIK DESKRIPTIF ===")
print(df.describe())

Simpan menggunakan Ctrl + O, tekan Enter, kemudian keluar menggunakan Ctrl + X.

Menjalankan EDA

Untuk menjalankan analisis, ketik:

python3 eda.py

Program akan membaca dataset kemudian menampilkan informasi mengenai struktur dan kondisi data.

Melihat Informasi Dataset dengan df.info()

Perintah df.info() digunakan untuk melihat informasi dasar dataset.

Dari hasil tersebut kita dapat mengetahui jumlah baris, jumlah kolom, nama kolom, tipe data, dan jumlah data yang tidak kosong. Contohnya, apabila muncul informasi 60 entries dan 5 columns, berarti dataset mempunyai 60 baris data dan 5 kolom.

Melihat Lima Data Pertama dengan df.head()

Selanjutnya kita dapat menggunakan df.head() untuk melihat lima data pertama.

Perintah ini berguna untuk memastikan data berhasil dibaca dan struktur kolomnya sesuai dengan yang kita harapkan.

Contoh:

python3 -c "import pandas as pd; df=pd.read_csv('system_monitoring.csv'); print(df.head())"

Mengecek Missing Value

Dalam proses analisis data, salah satu masalah yang perlu diperiksa adalah missing value atau data yang kosong.

Kita dapat mengeceknya menggunakan:

python3 -c "import pandas as pd; df=pd.read_csv('system_monitoring.csv'); print(df.isnull().sum())"

Jika hasilnya seperti berikut:

timestamp            0
cpu_usage            0
memory_usage         0
network_sent         0
network_received     0

Artinya tidak terdapat missing value pada kolom-kolom tersebut.

Mengecek Data Duplikat

Selain missing value, kita juga perlu memeriksa apakah terdapat data yang sama atau duplikat.

python3 -c "import pandas as pd; df=pd.read_csv('system_monitoring.csv'); print(df.duplicated().sum())"

Jika hasilnya 0, berarti tidak terdapat baris yang terduplikasi secara keseluruhan.

Melihat Statistik Deskriptif

EDA tidak hanya digunakan untuk melihat struktur data. Kita juga dapat melihat statistik dasar menggunakan df.describe().

python3 -c "import pandas as pd; df=pd.read_csv('system_monitoring.csv'); print(df.describe())"

Statistik tersebut dapat memberikan informasi seperti jumlah data, rata-rata, standar deviasi, nilai minimum, kuartil, dan nilai maksimum.

Dari sini kita mulai dapat memahami bagaimana kondisi sistem selama periode monitoring.

Menganalisis CPU Usage

CPU merupakan salah satu komponen penting dalam komputer. Penggunaan CPU dapat berubah tergantung aktivitas yang sedang dilakukan.

Untuk melihat statistik CPU secara khusus, jalankan:

python3 -c "import pandas as pd; df=pd.read_csv('system_monitoring.csv'); print(df['cpu_usage'].describe())"

Dari hasil tersebut kita dapat melihat nilai rata-rata, minimum, dan maksimum penggunaan CPU.

Data ini nantinya dapat digunakan untuk mengetahui apakah CPU cenderung stabil atau mengalami beberapa lonjakan selama proses monitoring.

Menganalisis Memory Usage

Selain CPU, memory atau RAM juga penting untuk diamati. Penggunaan memory dapat meningkat ketika pengguna membuka banyak aplikasi atau menjalankan program yang membutuhkan RAM cukup besar.

Untuk melihat statistik memory, gunakan:

python3 -c "import pandas as pd; df=pd.read_csv('system_monitoring.csv'); print(df['memory_usage'].describe())"

Hasilnya dapat digunakan untuk melihat rata-rata penggunaan memory serta nilai penggunaan terendah dan tertinggi selama monitoring.

Menganalisis Trafik Jaringan

Indikator berikutnya adalah trafik jaringan. Pada dataset kita terdapat dua informasi, yaitu network_sent dan network_received.

Network Sent menunjukkan jumlah data yang dikirim komputer, sedangkan Network Received menunjukkan jumlah data yang diterima.

Jika komputer sedang melakukan download, nilai data yang diterima dapat meningkat. Sebaliknya, ketika melakukan upload, jumlah data yang dikirim dapat meningkat.

Membuat Grafik CPU

Data akan lebih mudah dipahami jika ditampilkan dalam bentuk visualisasi. Untuk membuat grafik CPU, buka kembali file EDA:

nano eda.py

Tambahkan kode berikut di bagian bawah program:

import matplotlib.pyplot as plt

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

plt.plot(df["timestamp"], df["cpu_usage"])

plt.title("CPU Usage Monitoring")
plt.xlabel("Timestamp")
plt.ylabel("CPU Usage (%)")

plt.xticks(rotation=45)

plt.tight_layout()

plt.savefig("cpu_usage.png")

plt.show()

Simpan file kemudian jalankan kembali:

python3 eda.py

Grafik CPU akan muncul berdasarkan data yang sudah dikumpulkan.

Membaca Grafik CPU

Grafik CPU menunjukkan bagaimana penggunaan processor berubah dari waktu ke waktu.

Jika terdapat kenaikan secara tiba-tiba, kita dapat mencari tahu aktivitas apa yang sedang dilakukan pada saat tersebut. Misalnya sedang membuka aplikasi, menjalankan program, melakukan proses download, menjalankan virtual machine, atau melakukan aktivitas lainnya.

Hal yang perlu diperhatikan adalah jangan langsung menganggap setiap kenaikan CPU sebagai masalah. Lonjakan CPU bisa saja terjadi karena komputer memang sedang menjalankan proses yang membutuhkan resource lebih besar.

Membuat Grafik Memory

Selanjutnya kita akan membuat grafik penggunaan memory.

Tambahkan kode berikut:

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

plt.plot(df["timestamp"], df["memory_usage"])

plt.title("Memory Usage Monitoring")
plt.xlabel("Timestamp")
plt.ylabel("Memory Usage (%)")

plt.xticks(rotation=45)

plt.tight_layout()

plt.savefig("memory_usage.png")

plt.show()

Simpan dan jalankan kembali program:

python3 eda.py

Membaca Grafik Memory

Berbeda dengan CPU yang dapat berubah cukup cepat, penggunaan memory biasanya lebih stabil. Namun, penggunaan memory dapat meningkat ketika semakin banyak aplikasi atau proses yang berjalan.

Jika grafik menunjukkan peningkatan memory secara terus-menerus dalam periode monitoring yang lebih panjang, kondisi tersebut perlu diperiksa lebih lanjut untuk mengetahui proses apa yang menggunakan memory.

Membuat Grafik Network Traffic

Bagian terakhir yang akan divisualisasikan adalah trafik jaringan.

Tambahkan kode berikut ke file eda.py:

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

plt.plot(
    df["timestamp"],
    df["network_sent"],
    label="Network Sent"
)

plt.plot(
    df["timestamp"],
    df["network_received"],
    label="Network Received"
)

plt.title("Network Traffic Monitoring")

plt.xlabel("Timestamp")

plt.ylabel("Bytes")

plt.xticks(rotation=45)

plt.legend()

plt.tight_layout()

plt.savefig("network_traffic.png")

plt.show()

Kemudian jalankan:

python3 eda.py

Grafik akan menampilkan dua garis yang menunjukkan data yang dikirim dan diterima.

Membaca Grafik Network Traffic

Grafik network membantu kita melihat pola aktivitas komunikasi komputer dengan jaringan.

Apabila nilai Network Received meningkat, salah satu kemungkinan penyebabnya adalah komputer sedang menerima data, misalnya melakukan download atau menerima data dari aplikasi tertentu.

Sementara itu, peningkatan Network Sent dapat terjadi ketika komputer mengirim data, misalnya saat melakukan upload.

Membuat Ringkasan Hasil Analisis

Agar hasil analisis lebih mudah dibaca, kita dapat membuat program sederhana yang menampilkan nilai rata-rata, minimum, maksimum, serta total trafik jaringan.

Buat file baru:

nano summary.py

Masukkan kode:

import pandas as pd

df = pd.read_csv("system_monitoring.csv")

print("===== RINGKASAN SYSTEM MONITORING =====")

print("\nCPU")
print("Rata-rata :", df["cpu_usage"].mean())
print("Minimum   :", df["cpu_usage"].min())
print("Maximum   :", df["cpu_usage"].max())

print("\nMEMORY")
print("Rata-rata :", df["memory_usage"].mean())
print("Minimum   :", df["memory_usage"].min())
print("Maximum   :", df["memory_usage"].max())

print("\nNETWORK SENT")
print("Total :", df["network_sent"].sum(), "bytes")

print("\nNETWORK RECEIVED")
print("Total :", df["network_received"].sum(), "bytes")

Simpan file menggunakan Ctrl + O, tekan Enter, kemudian keluar menggunakan Ctrl + X.

Jalankan program:

python3 summary.py

Program akan menampilkan ringkasan kondisi sistem berdasarkan dataset yang telah dikumpulkan.

Bagaimana Cara Membuat Insight?

Dalam EDA, membuat grafik saja belum cukup. Kita juga perlu menjelaskan apa yang dapat kita pelajari dari data tersebut.

Misalnya dari hasil monitoring kita mendapatkan rata-rata CPU sebesar 18%, penggunaan memory sekitar 43%, dan trafik data yang diterima lebih besar daripada data yang dikirim.

Dari data tersebut kita dapat membuat insight seperti:

Berdasarkan hasil monitoring, penggunaan CPU selama periode pengamatan berada pada tingkat yang relatif rendah dengan beberapa peningkatan pada waktu tertentu. Penggunaan memory cenderung stabil, sedangkan trafik network received lebih besar dibandingkan network sent. Hal tersebut menunjukkan bahwa selama periode pengamatan komputer menerima data lebih banyak daripada mengirim data.

Namun, angka pada contoh tersebut bukan hasil yang harus sama pada setiap komputer. Gunakan angka yang benar-benar diperoleh dari hasil praktik masing-masing.

Mengapa Insight Penting?

Insight penting karena tujuan EDA bukan hanya menghasilkan angka, tetapi memahami apa yang terjadi di dalam data.

Contohnya, ketika CPU mengalami lonjakan, kita tidak cukup hanya mengatakan bahwa CPU naik. Kita perlu melihat kapan kenaikan tersebut terjadi dan apa aktivitas yang sedang dilakukan pada komputer.

Hal yang sama berlaku untuk memory dan network. Dengan menghubungkan data monitoring dengan aktivitas pengguna, kita dapat memperoleh pemahaman yang lebih baik mengenai kondisi sistem.

Mengecek Semua File Hasil Praktik

Setelah seluruh proses selesai, kita dapat melihat semua file yang sudah dibuat menggunakan:

ls -lh

Kurang lebih struktur file yang dihasilkan adalah:

system-monitoring/
├── monitor.py
├── system_monitoring.csv
├── eda.py
├── summary.py
├── cpu_usage.png
├── memory_usage.png
└── network_traffic.png

Apa yang Bisa Dipelajari dari Praktik Ini?

Praktik ini menunjukkan bahwa data monitoring sistem sebenarnya dapat diperlakukan sebagai sebuah dataset.

Awalnya kita hanya melihat angka CPU, memory, dan network yang muncul di Terminal. Setelah data tersebut dikumpulkan ke dalam CSV, kita dapat melakukan proses EDA seperti mengecek struktur data, missing value, duplicate, statistik deskriptif, hingga membuat visualisasi.

Dengan pendekatan tersebut, kita tidak hanya mengetahui kondisi komputer pada satu waktu, tetapi juga dapat melihat perubahan kondisi sistem berdasarkan data historis yang dikumpulkan.

Penerapan di Dunia Industri

Konsep yang kita praktikkan sebenarnya merupakan versi sederhana dari proses yang dapat digunakan dalam lingkungan industri.

Di perusahaan, server biasanya memiliki data monitoring yang jauh lebih besar. Data dapat dikumpulkan selama berhari-hari, berminggu-minggu, bahkan berbulan-bulan.

Data tersebut kemudian dapat digunakan untuk membantu tim IT mengetahui server mana yang memiliki beban tinggi, kapan penggunaan resource meningkat, bagaimana pola trafik jaringan, dan kapan diperlukan peningkatan kapasitas.

Data monitoring juga dapat dikembangkan lebih lanjut dengan menambahkan indikator seperti disk usage, temperatur, response time, jumlah koneksi, jumlah request, dan error rate.

Dengan begitu, monitoring sistem tidak hanya digunakan untuk melihat apakah sebuah komputer atau server sedang berjalan, tetapi juga dapat menjadi dasar untuk melakukan analisis dan pengambilan keputusan.

Kesimpulan

Melalui praktik EDA System Monitoring, kita telah mempelajari bagaimana data CPU, memory, dan trafik jaringan dapat dikumpulkan kemudian dianalisis menggunakan Python.

Data monitoring dikumpulkan menggunakan library psutil, kemudian disimpan dalam format CSV. Setelah itu, dataset dianalisis menggunakan Pandas untuk mengetahui struktur data, missing value, duplicate, serta statistik deskriptif.

Selanjutnya, Matplotlib digunakan untuk membuat visualisasi sehingga perubahan penggunaan CPU, memory, dan trafik jaringan dapat dilihat dengan lebih mudah.

Hal yang paling penting dari praktik ini adalah memahami bahwa data monitoring bukan hanya sekumpulan angka. Jika dikumpulkan dan dianalisis dengan benar, data tersebut dapat membantu kita memahami kondisi sistem dan menemukan pola yang mungkin tidak terlihat hanya dengan melihat komputer secara langsung.

Bagi anak magang di bidang IT, networking, maupun data, praktik sederhana seperti ini dapat menjadi langkah awal untuk memahami bagaimana proses monitoring, data analysis, dan troubleshooting dapat saling berhubungan.

Penulis : Devina Ghea Amanda