Catatan Kuliah: Shell Scripting Lanjutan untuk Otomatisasi Backup dan Simulasi Penjadwalan CPU

Di artikel sebelumnya, kita telah mempelajari dasar-dasar shell scripting, mulai dari variabel hingga logika if-else. Sekarang, saatnya kita mendalami fitur yang lebih tangguh: Struktur Pengulangan (Looping) dan bagaimana menerapkannya secara nyata untuk Otomatisasi Backup Data di server kita.

Sebagai bonus di akhir panduan, kita juga akan membedah sebuah skrip tingkat lanjut yang menyimulasikan algoritma penjadwalan CPU menggunakan struktur Array dan Looping bersarang. Mari kita mulai!

1. Memahami 3 Jenis Pengulangan (Loop) di Bash

Ada tiga jenis struktur pengulangan yang didukung oleh Bash Shell untuk mengeksekusi blok kode secara berulang selama kondisi tertentu terpenuhi:

A. Loop for

Digunakan jika Anda sudah mengetahui dengan pasti berapa kali iterasi atau pengulangan harus dilakukan.

#!/bin/bash
for i in {1..5}
do
echo "Perulangan ke-$i"
done

Penjelasan: Skrip di atas akan mencetak teks dari angka 1 sampai 5 secara berurutan.

B. Loop while

Digunakan untuk menjalankan blok perintah secara terus-menerus selama kondisi yang ditentukan bernilai benar (true).

#!/bin/bash
i=1 # variabel counter
while [ $i -le 5 ] # Selama i kurang dari atau sama dengan 5
do
echo "Angka ke-$i"
i=$((i+1)) # Menaikkan nilai i (Bisa juga ditulis: ((i++)))
done

Penjelasan: Variabel i bertindak sebagai counter. Jika kita lupa menaikkan nilai i, pengulangan akan berjalan selamanya tanpa henti (infinite loop).

C. Loop until

Kebalikan dari while, loop until akan mengeksekusi blok kode secara terus-menerus sampai kondisi yang ditentukan berubah menjadi benar (true). Dengan kata lain, loop ini berjalan selama kondisinya salah (false).

#!/bin/bash
i=1
until [ $i -gt 5 ] # Berhenti jika i lebih besar dari 5
do
echo "Nilai: $i"
((i++))
done

2. Manajemen Backup dan Kompresi File di Linux

Sebelum mengotomatiskan proses cadangan data (backup), mari kita kenali perkakas dasar Linux yang digunakan untuk kompresi dan pengarsipan file:

Anda bisa menggunakan fungsi date bawaan Linux untuk menyisipkan tanggal otomatis pada nama berkas backup agar rapi dan teratur.

tar -czf backup_$(date +%Y%m%d).tar.gz /home/$USER/Documents

Perintah ini akan menghasilkan file arsip bernama sesuai tanggal eksekusi, misalnya: backup_20260519.tar.gz.

3. Langkah Praktik: Membuat Skrip Backup Sederhana

Mari kita coba membuat skrip pengumpul file otomatis. Skrip ini akan mencari seluruh file teks berformat .txt di direktori saat ini, lalu menyalinnya ke sebuah folder khusus.

1. Buat file baru bernama backup.sh: nano backup.sh
2. Isi file tersebut dengan kode berikut:
   #!/bin/bash
   mkdir -p backup
   cp *.txt backup/
   echo "Backup file .txt selesai disalin ke folder backup/"
3. Simpan berkas, lalu berikan hak eksekusi: chmod +x backup.sh
4. Jalankan skrip: ./backup.sh

4. Studi Kasus Tingkat Lanjut: Simulasi Penjadwalan CPU (Shortest Job First)

Di bawah ini adalah contoh skrip Bash yang mensimulasikan Algoritma Penjadwalan Shortest Job First (SJF). Algoritma ini bekerja dengan cara mendahulukan proses yang memiliki waktu eksekusi (Burst Time) paling pendek agar rata-rata waktu tunggu (Average Waiting Time) menjadi seminimal mungkin.

#!/bin/bash
# Program sederhana simulasi Algoritma Penjadwalan SJF
# Data Proses (Nama, Burst Time)
processes=("P1" "P2" "P3" "P4" "P5") # array proses
burst_time=(3 5 2 1 4) # array burst time proses
n=${#processes[@]} # menghitung banyaknya elemen array

# 1. Sorting berdasarkan Burst Time (Bubble Sort)
for ((i=0; i<$n; i++)); do
for ((j=0; j<$n-i-1; j++)); do
if [ ${burst_time[j]} -gt ${burst_time[$((j+1))]} ]; then
# Tukar Burst Time
temp_bt=${burst_time[j]}
burst_time[j]=${burst_time[$((j+1))]}
burst_time[$((j+1))]=$temp_bt

# Tukar Nama Proses agar tetap sinkron
temp_proc=${processes[j]}
processes[j]=${processes[$((j+1))]}
processes[$((j+1))]=$temp_proc
fi
done
done

# 2. Hitung Waiting Time (WT)
waiting_time=(0) # P4 (index 0 setelah sort) WT-nya adalah 0
total_wt=0
for ((i=1; i<$n; i++)); do
waiting_time[i]=$((waiting_time[i-1] + burst_time[i-1]))
total_wt=$((total_wt + waiting_time[i]))
done

# 3. Tampilkan Gantt Chart Sederhana
echo -e "\n— Gantt Chart —"

# Baris Atas
for i in "${processes[@]}"; do echo -n "+--—"; done; echo "+"

# Baris Tengah (Nama Proses)
for i in "${processes[@]}"; do echo -n "| $i "; done; echo "|"

# Baris Bawah
for i in "${processes[@]}"; do echo -n "+--—"; done; echo "+"

# Baris Waktu
echo -n "0"

current_time=0
for i in "${burst_time[@]}"; do
current_time=$((current_time + i))
if [ $current_time -lt 10 ]; then
echo -n " $current_time"
else
echo -n " $current_time"
fi
done
echo -e "\n"

# 4. Tampilkan Tabel dan Rata-rata
echo "— Detail Perhitungan —"
echo -e "Proses\tBT\tWT"
for ((i=0; i<$n; i++)); do
echo -e "${processes[i]}\t${burst_time[i]}\t${waiting_time[i]}"
done

# Hitung rata-rata menggunakan 'bc' agar dapat angka desimal
avg_wt=$(echo "scale=2; $total_wt / $n" | bc)
echo -e "\nTotal Waiting Time: $total_wt"
echo "Average Waiting Time (SJF): $avg_wt ms"

Simpan dengan nama sjf_simulasi.sh kemudian buat agar bisa dieksekusi, dan jalankan kode bash tersebut.

5. Bedah Logika & Analisis Algoritma Skrip SJF

Mari kita uraikan bagaimana skrip di atas bekerja di balik layar, agar Anda paham cara kerja logika tingkat lanjut ini:

1. Inisialisasi Data & Array

Skrip mendefinisikan dua buah array: processes untuk nama proses dan burst_time untuk durasi waktu pengerjaan masing-masing proses. Variabel n=${#processes[@]} digunakan secara otomatis untuk menghitung jumlah total proses yang terdaftar (dalam kasus ini ada 5 proses).

2. Pengurutan Data (Bubble Sort)

Sesuai prinsip SJF, proses dengan Burst Time (BT) terkecil harus dijalankan duluan. Bagian pertama skrip menggunakan teknik Bubble Sort dengan looping bersarang (nested loop). Skrip membandingkan nilai BT pada indeks ke-j dengan indeks di sebelahnya. Jika urutannya salah, posisinya ditukar.

• Penting: Agar data tidak tertukar, saat nilai Burst Time berpindah posisi, nama proses di array processes juga ikut ditukar pada indeks yang sama agar data tetap sinkron.
• Hasil Pengurutan: Urutan proses yang semula P1(3), P2(5), P3(2), P4(1), P5(4) berubah menjadi P4(1), P3(2), P1(3), P5(4), P2(5).

3. Perhitungan Waktu Tunggu (Waiting Time)

Proses pertama yang dieksekusi (P4) tidak perlu menunggu siapapun, sehingga waiting_time[0] diisi nilai 0. Untuk proses-proses selanjutnya, waktu tunggu dihitung dengan menjumlahkan waktu tunggu proses sebelumnya ditambah dengan durasi eksekusi proses sebelumnya:

$$\text{Waiting Time}_i = \text{Waiting Time}_{i-1} + \text{Burst Time}_{i-1}$$

Semua nilai waktu tunggu ini dijumlahkan ke dalam variabel total_wt.

4. Pembuatan Gantt Chart dan Hasil Akhir

Bagian akhir skrip mencetak grafik linier (Gantt Chart) menggunakan perulangan teks simbol seperti +----- dan | untuk memvisualisasikan garis waktu eksekusi CPU secara rapi di terminal. Terakhir, skrip menggunakan utilitas pengeksekusi kalkulasi kalkulator Linux bernama bc. Tanpa bc, pembagian di terminal Linux hanya akan menghasilkan angka bulat tanpa desimal (koma).

Kesimpulan

Kombinasi antara manipulasi struktur data menggunakan Array, kendali perulangan lewat Looping, dan integrasi perintah sistem (tools kompresi) menjadikan Shell Script sebagai sarana yang sangat perkasa bagi para pengelola sistem. Skrip simulasi SJF di atas membuktikan bahwa tugas-tugas logika pemrograman tingkat lanjut pun bisa diselesaikan dengan apik di dalam terminal Bash.