🚀 Saya Membuat Dasbor CLI Statis di Python Menggunakan Rich dan Pyfiglet – Tampil Kutu Buku, Bekerja Cerdas 😎📊

Pernahkah Anda merasa ingin memiliki dasbor yang ringkas, informatif, dan tentu saja, keren, langsung di terminal Anda? Saya juga! Dalam postingan blog ini, saya akan membimbing Anda melalui proses pembuatan dasbor CLI (Command-Line Interface) statis di Python, menggunakan kekuatan pustaka rich untuk pemformatan teks yang cantik dan pyfiglet untuk judul bergaya ASCII Art. Bersiaplah untuk menggabungkan tampilan kutu buku dengan kecerdasan fungsional!

Mengapa Dasbor CLI?

Sebelum kita masuk ke inti kode, mari kita bahas mengapa Anda mungkin menginginkan dasbor CLI. Meskipun antarmuka grafis (GUI) sangat bagus untuk interaksi yang kompleks, CLI unggul dalam hal berikut:

1. Kecepatan dan Efisiensi: CLI biasanya lebih cepat dan hemat sumber daya daripada GUI, terutama untuk tugas-tugas sederhana.
2. Otomatisasi: CLI mudah diotomatisasi melalui skrip shell dan alat otomatisasi lainnya.
3. Akses Jarak Jauh: CLI sangat ideal untuk mengelola server dan sistem jarak jauh melalui SSH.
4. Portabilitas: Skrip CLI dapat dijalankan di berbagai sistem operasi dengan sedikit atau tanpa modifikasi.
5. Keren! Mari kita hadapi itu, ada sesuatu yang sangat memuaskan tentang menjalankan perintah dan melihat hasilnya di terminal.

Apa yang Akan Kita Bangun?

Dasbor yang akan kita bangun adalah dasbor statis, yang berarti datanya tidak diperbarui secara otomatis secara real-time. Sebagai gantinya, kita akan membuat skrip yang mengumpulkan informasi dan menampilkannya dalam format yang menarik. Kita dapat menjalankan skrip ini secara berkala menggunakan cron job atau penjadwal tugas lainnya untuk memperbarui data.

Dasbor kita akan mencakup hal-hal berikut:

1. Judul: Judul besar dan menarik yang dibuat dengan pyfiglet.
2. Informasi Sistem: Informasi dasar tentang sistem operasi, nama host, dan kernel.
3. Penggunaan CPU: Persentase penggunaan CPU.
4. Penggunaan Memori: Total memori, memori yang digunakan, dan memori yang tersedia.
5. Penggunaan Disk: Penggunaan ruang disk untuk partisi root.
6. Waktu Aktif Sistem: Berapa lama sistem telah berjalan.

Persiapan: Instalasi Pustaka

Hal pertama yang pertama, kita perlu menginstal pustaka rich dan pyfiglet. Anda dapat melakukannya menggunakan pip:

pip install rich pyfiglet

Pastikan Anda memiliki Python terinstal (versi 3.6 atau lebih tinggi direkomendasikan). Anda dapat memeriksa versi Python Anda dengan menjalankan:

python --version

Langkah demi Langkah: Membangun Dasbor

Sekarang, mari kita masuki kode! Kami akan membangun dasbor langkah demi langkah, menjelaskan setiap bagian secara rinci.

Langkah 1: Mengimpor Pustaka

Pertama, kita perlu mengimpor pustaka yang akan kita gunakan:

import platform
import psutil
import time
from rich.console import Console
from rich.table import Table
from rich import box
from pyfiglet import Figlet
from datetime import timedelta

Mari kita uraikan impor ini:

• platform: Menyediakan informasi tentang platform sistem operasi.
• psutil: Pustaka lintas platform untuk mengambil informasi tentang proses yang berjalan dan penggunaan sistem (CPU, memori, disk, jaringan, sensor).
• time: Untuk fungsi terkait waktu (digunakan untuk menghitung waktu aktif).
• rich.console.Console: Kelas utama dari pustaka rich yang digunakan untuk mencetak output berwarna dan terformat ke konsol.
• rich.table.Table: Untuk membuat tabel yang diformat dengan baik.
• rich.box: Menyediakan berbagai gaya batas tabel.
• pyfiglet.Figlet: Untuk membuat teks ASCII Art.
• datetime.timedelta: Untuk memformat waktu aktif sistem.

Langkah 2: Membuat Judul dengan Pyfiglet

Mari kita buat judul yang menarik menggunakan pyfiglet:

def print_title():
  f = Figlet(font='slant')  # Pilih font yang berbeda jika Anda mau
  console.print(f.renderText('System Dashboard'), style="bold blue", justify="center")

Fungsi ini membuat objek Figlet dengan font ‘slant’ (Anda dapat memilih font lain dari daftar font yang tersedia). Kemudian, ia merender teks “System Dashboard” menggunakan font yang dipilih dan mencetaknya ke konsol menggunakan console.print() dengan gaya “bold blue” dan perataan tengah.

Langkah 3: Mengumpulkan Informasi Sistem

Sekarang, mari kita kumpulkan informasi sistem yang ingin kita tampilkan di dasbor:

def get_system_info():
  os_name = platform.system()
  os_version = platform.release()
  hostname = platform.node()
  kernel_version = platform.version()

  return os_name, os_version, hostname, kernel_version

Fungsi ini menggunakan modul platform untuk mendapatkan nama sistem operasi, versi, nama host, dan versi kernel.

Langkah 4: Mengumpulkan Informasi Penggunaan CPU

Dapatkan penggunaan CPU menggunakan psutil:

def get_cpu_usage():
  cpu_percentage = psutil.cpu_percent(interval=1)  # Ambil penggunaan CPU selama 1 detik
  return cpu_percentage

Fungsi ini menggunakan psutil.cpu_percent(interval=1) untuk mendapatkan persentase penggunaan CPU selama 1 detik. Parameter interval menentukan berapa lama (dalam detik) psutil harus mengukur penggunaan CPU.

Langkah 5: Mengumpulkan Informasi Penggunaan Memori

Dapatkan informasi penggunaan memori dengan psutil:

def get_memory_usage():
  memory = psutil.virtual_memory()
  total_memory = memory.total
  used_memory = memory.used
  available_memory = memory.available

  return total_memory, used_memory, available_memory

Fungsi ini menggunakan psutil.virtual_memory() untuk mendapatkan informasi tentang penggunaan memori virtual. Ini mengembalikan total memori, memori yang digunakan, dan memori yang tersedia.

Langkah 6: Mengumpulkan Informasi Penggunaan Disk

Dapatkan informasi penggunaan disk untuk partisi root:

def get_disk_usage():
  disk = psutil.disk_usage('/')  # '/' adalah partisi root
  total_disk = disk.total
  used_disk = disk.used
  free_disk = disk.free

  return total_disk, used_disk, free_disk

Fungsi ini menggunakan psutil.disk_usage('/') untuk mendapatkan informasi tentang penggunaan disk untuk partisi root. Anda dapat mengubah ‘/’ menjadi jalur lain jika Anda ingin memantau partisi lain.

Langkah 7: Mendapatkan Waktu Aktif Sistem

Dapatkan berapa lama sistem telah berjalan:

def get_uptime():
  uptime_seconds = time.time() - psutil.boot_time()
  uptime = timedelta(seconds=uptime_seconds)
  return uptime

Fungsi ini menghitung waktu aktif dengan mengurangkan waktu boot (diperoleh dengan psutil.boot_time()) dari waktu saat ini (diperoleh dengan time.time()). Hasilnya dikonversi ke objek timedelta untuk pemformatan yang mudah.

Langkah 8: Membuat Tabel dengan Rich

Sekarang, mari kita buat tabel untuk menampilkan informasi yang kita kumpulkan:

def create_table(os_name, os_version, hostname, kernel_version, cpu_percentage, total_memory, used_memory, available_memory, total_disk, used_disk, free_disk, uptime):
  table = Table(title="System Information", box=box.ROUNDED, title_style="bold green")

  table.add_column("Category", style="cyan", justify="right")
  table.add_column("Value", style="magenta", justify="left")

  table.add_row("Operating System", f"{os_name} {os_version}")
  table.add_row("Hostname", hostname)
  table.add_row("Kernel Version", kernel_version)
  table.add_row("CPU Usage", f"{cpu_percentage}%")

  # Format memory values to human-readable format
  total_memory_gb = total_memory / (1024 ** 3)
  used_memory_gb = used_memory / (1024 ** 3)
  available_memory_gb = available_memory / (1024 ** 3)

  table.add_row("Total Memory", f"{total_memory_gb:.2f} GB")
  table.add_row("Used Memory", f"{used_memory_gb:.2f} GB")
  table.add_row("Available Memory", f"{available_memory_gb:.2f} GB")

  # Format disk values to human-readable format
  total_disk_gb = total_disk / (1024 ** 3)
  used_disk_gb = used_disk / (1024 ** 3)
  free_disk_gb = free_disk / (1024 ** 3)

  table.add_row("Total Disk", f"{total_disk_gb:.2f} GB")
  table.add_row("Used Disk", f"{used_disk_gb:.2f} GB")
  table.add_row("Free Disk", f"{free_disk_gb:.2f} GB")
  table.add_row("System Uptime", str(uptime))

  return table

Fungsi ini membuat objek Table dengan judul “System Information”. Ini menambahkan dua kolom: “Category” dan “Value”. Kemudian menambahkan baris ke tabel dengan informasi sistem yang kita kumpulkan. Perhatikan bagaimana kita menggunakan pemformatan f-string untuk memasukkan nilai variabel ke dalam string dan bagaimana kita mengubah byte menjadi gigabyte untuk keterbacaan.

Langkah 9: Fungsi Utama

Terakhir, mari kita buat fungsi utama untuk mengikat semuanya bersama-sama:

if __name__ == "__main__":
  console = Console()
  print_title()

  os_name, os_version, hostname, kernel_version = get_system_info()
  cpu_percentage = get_cpu_usage()
  total_memory, used_memory, available_memory = get_memory_usage()
  total_disk, used_disk, free_disk = get_disk_usage()
  uptime = get_uptime()

  table = create_table(os_name, os_version, hostname, kernel_version, cpu_percentage, total_memory, used_memory, available_memory, total_disk, used_disk, free_disk, uptime)

  console.print(table)

Blok if __name__ == "__main__": memastikan bahwa kode ini hanya dijalankan ketika skrip dieksekusi secara langsung (bukan diimpor sebagai modul). Di dalam blok ini, kita melakukan hal berikut:

1. Membuat instance objek Console.
2. Memanggil fungsi print_title() untuk mencetak judul.
3. Memanggil fungsi-fungsi untuk mengumpulkan informasi sistem.
4. Memanggil fungsi create_table() untuk membuat tabel.
5. Mencetak tabel ke konsol menggunakan console.print().

Kode Lengkap

Berikut adalah kode lengkap untuk referensi:

import platform
import psutil
import time
from rich.console import Console
from rich.table import Table
from rich import box
from pyfiglet import Figlet
from datetime import timedelta

def print_title():
  f = Figlet(font='slant')
  console.print(f.renderText('System Dashboard'), style="bold blue", justify="center")

def get_system_info():
  os_name = platform.system()
  os_version = platform.release()
  hostname = platform.node()
  kernel_version = platform.version()

  return os_name, os_version, hostname, kernel_version

def get_cpu_usage():
  cpu_percentage = psutil.cpu_percent(interval=1)
  return cpu_percentage

def get_memory_usage():
  memory = psutil.virtual_memory()
  total_memory = memory.total
  used_memory = memory.used
  available_memory = memory.available

  return total_memory, used_memory, available_memory

def get_disk_usage():
  disk = psutil.disk_usage('/')
  total_disk = disk.total
  used_disk = disk.used
  free_disk = disk.free

  return total_disk, used_disk, free_disk

def get_uptime():
  uptime_seconds = time.time() - psutil.boot_time()
  uptime = timedelta(seconds=uptime_seconds)
  return uptime

def create_table(os_name, os_version, hostname, kernel_version, cpu_percentage, total_memory, used_memory, available_memory, total_disk, used_disk, free_disk, uptime):
  table = Table(title="System Information", box=box.ROUNDED, title_style="bold green")

  table.add_column("Category", style="cyan", justify="right")
  table.add_column("Value", style="magenta", justify="left")

  table.add_row("Operating System", f"{os_name} {os_version}")
  table.add_row("Hostname", hostname)
  table.add_row("Kernel Version", kernel_version)
  table.add_row("CPU Usage", f"{cpu_percentage}%")

  # Format memory values to human-readable format
  total_memory_gb = total_memory / (1024 ** 3)
  used_memory_gb = used_memory / (1024 ** 3)
  available_memory_gb = available_memory / (1024 ** 3)

  table.add_row("Total Memory", f"{total_memory_gb:.2f} GB")
  table.add_row("Used Memory", f"{used_memory_gb:.2f} GB")
  table.add_row("Available Memory", f"{available_memory_gb:.2f} GB")

  # Format disk values to human-readable format
  total_disk_gb = total_disk / (1024 ** 3)
  used_disk_gb = used_disk / (1024 ** 3)
  free_disk_gb = free_disk / (1024 ** 3)

  table.add_row("Total Disk", f"{total_disk_gb:.2f} GB")
  table.add_row("Used Disk", f"{used_disk_gb:.2f} GB")
  table.add_row("Free Disk", f"{free_disk_gb:.2f} GB")
  table.add_row("System Uptime", str(uptime))

  return table

if __name__ == "__main__":
  console = Console()
  print_title()

  os_name, os_version, hostname, kernel_version = get_system_info()
  cpu_percentage = get_cpu_usage()
  total_memory, used_memory, available_memory = get_memory_usage()
  total_disk, used_disk, free_disk = get_disk_usage()
  uptime = get_uptime()

  table = create_table(os_name, os_version, hostname, kernel_version, cpu_percentage, total_memory, used_memory, available_memory, total_disk, used_disk, free_disk, uptime)

  console.print(table)

Menjalankan Skrip

Simpan kode sebagai file Python (misalnya, dashboard.py) dan jalankan dari terminal Anda:

python dashboard.py

Anda akan melihat dasbor yang diformat dengan indah di terminal Anda!

Kustomisasi dan Peningkatan

Ini hanyalah dasbor dasar. Anda dapat menyesuaikannya dan meningkatkannya dalam banyak cara:

• Tambahkan lebih banyak informasi: Pantau penggunaan jaringan, suhu, proses, atau metrik lain yang Anda minati.
• Gunakan font Pyfiglet yang berbeda: Eksperimen dengan font yang berbeda untuk tampilan yang unik.
• Tambahkan warna dan gaya: rich menawarkan banyak opsi untuk menyesuaikan tampilan dasbor. Bereksperimenlah dengan gaya teks, warna, dan batas tabel yang berbeda.
• Perbarui data secara berkala: Gunakan time.sleep() untuk memperbarui data secara berkala dan menampilkan dasbor secara real-time (atau dekat dengan real-time).
• Otomatiskan dengan cron job: Jadwalkan skrip untuk berjalan secara berkala menggunakan cron job (di Linux/macOS) atau Task Scheduler (di Windows).
• Buat dasbor interaktif: Gunakan pustaka seperti inquirer atau prompt_toolkit untuk membuat dasbor interaktif yang memungkinkan pengguna untuk memilih informasi yang akan ditampilkan atau melakukan tindakan tertentu.
• Logging: Tambahkan pencatatan ke skrip untuk mendiagnosis masalah dan melacak kinerja sistem.
• Konfigurasi: Gunakan file konfigurasi (misalnya, format JSON atau YAML) untuk menyimpan pengaturan dasbor seperti interval pembaruan dan metrik yang akan dipantau.

Contoh Kode dengan Pembaruan Periodik

Berikut adalah contoh kode yang memperbarui dasbor setiap 5 detik:

import platform
import psutil
import time
from rich.console import Console
from rich.table import Table
from rich import box
from pyfiglet import Figlet
from datetime import timedelta

def print_title():
  f = Figlet(font='slant')
  console.print(f.renderText('System Dashboard'), style="bold blue", justify="center")

def get_system_info():
  os_name = platform.system()
  os_version = platform.release()
  hostname = platform.node()
  kernel_version = platform.version()

  return os_name, os_version, hostname, kernel_version

def get_cpu_usage():
  cpu_percentage = psutil.cpu_percent(interval=1)
  return cpu_percentage

def get_memory_usage():
  memory = psutil.virtual_memory()
  total_memory = memory.total
  used_memory = memory.used
  available_memory = memory.available

  return total_memory, used_memory, available_memory

def get_disk_usage():
  disk = psutil.disk_usage('/')
  total_disk = disk.total
  used_disk = disk.used
  free_disk = disk.free

  return total_disk, used_disk, free_disk

def get_uptime():
  uptime_seconds = time.time() - psutil.boot_time()
  uptime = timedelta(seconds=uptime_seconds)
  return uptime

def create_table(os_name, os_version, hostname, kernel_version, cpu_percentage, total_memory, used_memory, available_memory, total_disk, used_disk, free_disk, uptime):
  table = Table(title="System Information", box=box.ROUNDED, title_style="bold green")

  table.add_column("Category", style="cyan", justify="right")
  table.add_column("Value", style="magenta", justify="left")

  table.add_row("Operating System", f"{os_name} {os_version}")
  table.add_row("Hostname", hostname)
  table.add_row("Kernel Version", kernel_version)
  table.add_row("CPU Usage", f"{cpu_percentage}%")

  # Format memory values to human-readable format
  total_memory_gb = total_memory / (1024 ** 3)
  used_memory_gb = used_memory / (1024 ** 3)
  available_memory_gb = available_memory / (1024 ** 3)

  table.add_row("Total Memory", f"{total_memory_gb:.2f} GB")
  table.add_row("Used Memory", f"{used_memory_gb:.2f} GB")
  table.add_row("Available Memory", f"{available_memory_gb:.2f} GB")

  # Format disk values to human-readable format
  total_disk_gb = total_disk / (1024 ** 3)
  used_disk_gb = used_disk / (1024 ** 3)
  free_disk_gb = free_disk / (1024 ** 3)

  table.add_row("Total Disk", f"{total_disk_gb:.2f} GB")
  table.add_row("Used Disk", f"{used_disk_gb:.2f} GB")
  table.add_row("Free Disk", f"{free_disk_gb:.2f} GB")
  table.add_row("System Uptime", str(uptime))

  return table

if __name__ == "__main__":
  console = Console()

  while True:
    console.clear() # Clear the console
    print_title()

    os_name, os_version, hostname, kernel_version = get_system_info()
    cpu_percentage = get_cpu_usage()
    total_memory, used_memory, available_memory = get_memory_usage()
    total_disk, used_disk, free_disk = get_disk_usage()
    uptime = get_uptime()

    table = create_table(os_name, os_version, hostname, kernel_version, cpu_percentage, total_memory, used_memory, available_memory, total_disk, used_disk, free_disk, uptime)

    console.print(table)
    time.sleep(5) # Wait for 5 seconds

Perubahan utama adalah penambahan loop while True: yang terus-menerus memperbarui dasbor. console.clear() digunakan untuk membersihkan konsol sebelum setiap pembaruan. time.sleep(5) menyebabkan skrip tidur selama 5 detik sebelum mengulangi loop.

Praktik Terbaik SEO

Untuk mengoptimalkan postingan blog ini untuk SEO, saya telah menyertakan praktik terbaik berikut:

• Kata Kunci: Judul dan konten menyertakan kata kunci yang relevan seperti “dasbor CLI”, “Python”, “rich”, “pyfiglet”, “informasi sistem”, “penggunaan CPU”, “penggunaan memori”, dan “penggunaan disk”.
• Judul: Judul menarik, mengandung kata kunci, dan menjanjikan nilai kepada pembaca.
• Deskripsi Meta: Deskripsi meta (tidak terlihat di artikel itu sendiri, tetapi digunakan oleh mesin pencari) harus secara ringkas meringkas artikel dan menyertakan kata kunci utama.
• Struktur Heading: Menggunakan tag heading (<h1>, <h2>, dll.) untuk menyusun konten secara logis dan membuatnya mudah dipindai.
• Link Internal dan Eksternal: Link ke sumber daya internal dan eksternal yang relevan untuk memberikan nilai tambahan kepada pembaca.
• Konten Berkualitas: Menulis konten yang informatif, akurat, dan menarik yang akan dihargai oleh pembaca.
• Keterbacaan: Menggunakan kalimat pendek, paragraf, dan daftar untuk meningkatkan keterbacaan.
• Alt Text pada Gambar: Jika menggunakan gambar, menyertakan alt text deskriptif yang mengandung kata kunci yang relevan.

Kesimpulan

Dalam postingan blog ini, kita telah belajar cara membuat dasbor CLI statis di Python menggunakan pustaka rich dan pyfiglet. Kita telah membahas proses mengumpulkan informasi sistem, membuat tabel yang diformat dengan baik, dan memperbarui dasbor secara berkala. Saya harap Anda menikmati proyek ini dan terinspirasi untuk membuat dasbor CLI Anda sendiri yang keren dan cerdas!

Sekarang keluarlah dan buat sesuatu yang luar biasa!