Linux Command Line & Bash Scripting Mastery · Pelajaran

Otomatisasi Disk, Sistem File, dan Mount

Periksa perangkat blok, kelola entri fstab, serta jalankan operasi LVM dan mount dengan aman melalui skrip.

Otomatisasi Disk, Sistem File, dan Mount adalah pelajaran Linux Command Line & Bash Scripting Mastery gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Linux Command Line & Bash Scripting Mastery, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Memahami Perangkat Blok dengan lsblk dan fdisk

Sebelum mengotomatiskan operasi disk, Anda harus dapat memeriksa perangkat blok yang tersedia di sistem. Dua alat penting untuk ini adalah lsblk dan fdisk -l.

lsblk — mencantumkan perangkat blok dalam format pohon yang menampilkan nama perangkat, ukuran, titik kait, dan jenisnya (disk, part, lvm)
fdisk -l — menampilkan tabel partisi dan detail sektor (memerlukan root)
blkid — mencetak UUID dan jenis sistem berkas untuk setiap perangkat blok

Dalam skrip, Anda sering perlu mengurai keluaran ini untuk mendeteksi disk yang tersedia, memeriksa apakah partisi telah diformat, atau menentukan UUID-nya sebelum melakukan pemasangan.

#!/usr/bin/env bash
# Inspect all block devices and their UUIDs
set -euo pipefail

echo '=== Block Device Tree ==='
lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT,UUID

echo ''
echo '=== Partition Table Details ==='
sudo fdisk -l 2>/dev/null | grep -E '^Disk |^/dev/'

echo ''
echo '=== UUID Lookup via blkid ==='
sudo blkid | awk -F: '{print $1}' | while read -r dev; do
  uuid=$(sudo blkid -s UUID -o value "$dev" 2>/dev/null || echo 'N/A')
  fstype=$(sudo blkid -s TYPE -o value "$dev" 2>/dev/null || echo 'unknown')
  printf '%-20s UUID=%-38s TYPE=%s\n' "$dev" "$uuid" "$fstype"
done

Memeriksa Ruang Disk dengan df dan du

df dan du adalah alat utama untuk melaporkan penggunaan sistem berkas dan direktori. Dalam skrip administrasi sistem, Anda menggunakannya untuk memicu peringatan, menerapkan kuota, atau menentukan kapan perlu menyediakan ruang tambahan.

df -h — penggunaan sistem berkas dalam format yang mudah dibaca pada semua sistem berkas yang terpasang
df -BG — keluaran dalam gigabita untuk penguraian angka yang konsisten
du -sh /path — ukuran ringkasan direktori tertentu
du -d 1 /var — rincian hingga kedalaman satu tingkat (berguna untuk menemukan subdirektori yang besar)

Kolom persentase terpakai dari df biasanya diurai untuk memicu peringatan disk penuh dalam skrip pemantauan.

#!/usr/bin/env bash
# Alert if any mounted filesystem exceeds a usage threshold
set -euo pipefail

THRESHOLD=80   # percent

echo 'Checking filesystem usage...'
df -h --output=source,pcent,target | tail -n +2 | while IFS= read -r line; do
  device=$(awk '{print $1}' <<< "$line")
  pct=$(awk '{print $2}' <<< "$line" | tr -d '%')
  mount=$(awk '{print $3}' <<< "$line")

  # Skip pseudo filesystems
  [[ "$device" == tmpfs* || "$device" == devtmpfs* ]] && continue

  if (( pct >= THRESHOLD )); then
    echo "WARNING: $device mounted at $mount is ${pct}% full" >&2
  else
    echo "OK: $device at $mount is ${pct}% used"
  fi
done

Membaca dan Mengurai /etc/fstab

/etc/fstab adalah tabel sistem berkas statis — tabel ini menentukan perangkat mana yang dipasang saat boot, pada jalur apa, dan dengan opsi apa. Setiap baris memiliki enam bidang:

Perangkat — UUID=..., LABEL=..., atau /dev/sdX
Titik kait — jalur direktori
Jenis sistem berkas — ext4, xfs, nfs, tmpfs, dan sebagainya
Opsi — defaults, ro, noexec, nofail, dan sebagainya
Dump — 0 atau 1 (penanda pencadangan)
Pass — 0, 1, atau 2 (urutan fsck)

Skrip yang menambahkan atau memvalidasi entri fstab harus menangani komentar (baris yang diawali #) dan baris kosong dengan baik. Selalu utamakan UUID daripada nama perangkat agar sistem tetap berfungsi setelah boot ulang ketika urutan perangkat mungkin berubah.

#!/usr/bin/env bash
# Parse /etc/fstab and display non-comment entries in a readable table
set -euo pipefail

FSTAB=/etc/fstab

printf '%-40s %-20s %-10s %s\n' 'DEVICE' 'MOUNTPOINT' 'FSTYPE' 'OPTIONS'
printf '%s\n' '-------------------------------------------------------------------------------------'

while IFS= read -r line; do
  # Skip blank lines and comments
  [[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue

  read -r device mountpt fstype options _dump _pass <<< "$line"
  printf '%-40s %-20s %-10s %s\n' "$device" "$mountpt" "$fstype" "$options"
done < "$FSTAB"

Menambahkan Entri fstab dengan Aman

Mengedit /etc/fstab secara manual rentan menimbulkan kesalahan. Entri yang salah dapat mencegah sistem melakukan boot. Skrip otomatisasi yang aman harus:

Memeriksa apakah entri sudah ada sebelum menambahkannya (idempoten)
Mencadangkan file asli sebelum melakukan perubahan apa pun
Menggunakan UUID, bukan jalur perangkat
Menambahkan nofail ke opsi pemasangan agar disk yang hilang tidak menghentikan proses boot
Menjalankan mount -a dalam mode simulasi atau melakukan pemasangan uji untuk memvalidasi sebelum melakukan boot ulang

Setelah menulis entri, selalu lakukan verifikasi dengan findmnt --verify (tersedia pada distro modern berbasis systemd) untuk segera menemukan kesalahan sintaks.

#!/usr/bin/env bash
# Safely append a new entry to /etc/fstab (idempotent)
set -euo pipefail

DEVICE_PATH='/dev/sdb1'
MOUNTPOINT='/mnt/data'
FSTYPE='ext4'
OPTIONS='defaults,nofail'
FSTAB='/etc/fstab'

# Resolve UUID for stable identification
UUID=$(sudo blkid -s UUID -o value "$DEVICE_PATH")
if [[ -z "$UUID" ]]; then
  echo "ERROR: Could not resolve UUID for $DEVICE_PATH" >&2
  exit 1
fi

ENTRY="UUID=$UUID  $MOUNTPOINT  $FSTYPE  $OPTIONS  0  2"

# Idempotency: skip if UUID already referenced in fstab
if grep -qsF "UUID=$UUID" "$FSTAB"; then
  echo "INFO: fstab already contains UUID=$UUID — skipping."
  exit 0
fi

# Backup
cp -p "$FSTAB" "${FSTAB}.bak.$(date +%Y%m%d%H%M%S)"

# Create mountpoint if needed
sudo mkdir -p "$MOUNTPOINT"

# Append entry
echo "$ENTRY" | sudo tee -a "$FSTAB" > /dev/null
echo "INFO: Added: $ENTRY"

# Validate
sudo findmnt --verify --verbose || echo 'WARNING: findmnt verify reported issues'

Memasang dan Melepas Sistem Berkas dalam Skrip

Perintah mount dan umount cukup sederhana, tetapi skrip harus menangani kasus khusus:

Perangkat mungkin sudah terpasang — pemasangan ulang akan gagal; periksa dengan findmnt atau mountpoint
Titik pemasangan mungkin sedang digunakan (ada file yang terbuka) — umount akan gagal; gunakan lsof +D /mnt/target untuk menemukan proses penyebabnya
Gunakan mount -o remount,ro /mnt/data untuk beralih ke mode hanya-baca tanpa melepas pemasangan
Gunakan umount -l /mnt/data (lazy) sebagai pilihan terakhir — perintah ini melepaskan ruang nama, tetapi menunggu hingga semua referensi ditutup

Dalam otomatisasi, selalu periksa kode keluar dari mount dan catat kegagalan ke syslog dengan logger.

#!/usr/bin/env bash
# Mount a device only if not already mounted; log outcome
set -euo pipefail

DEVICE='/dev/sdb1'
MOUNTPOINT='/mnt/data'

log() { logger -t disk-mount "$*"; echo "[$(date '+%F %T')] $*"; }

# Check if already mounted
if mountpoint -q "$MOUNTPOINT"; then
  log "INFO: $MOUNTPOINT is already mounted — nothing to do."
  exit 0
fi

# Ensure mountpoint directory exists
sudo mkdir -p "$MOUNTPOINT"

# Attempt mount
if sudo mount "$DEVICE" "$MOUNTPOINT"; then
  log "OK: Mounted $DEVICE at $MOUNTPOINT"
else
  log "ERROR: Failed to mount $DEVICE at $MOUNTPOINT"
  exit 1
fi

# Show what is now mounted there
df -h "$MOUNTPOINT"

Pengantar LVM: Volume Fisik, Grup Volume, dan Volume Logis

LVM (Logical Volume Manager) menambahkan lapisan abstraksi yang fleksibel antara perangkat blok mentah dan sistem berkas. Hierarki tiga tingkatnya adalah:

Physical Volume (PV) — disk mentah atau partisi yang diinisialisasi dengan pvcreate
Volume Group (VG) — satu atau beberapa PV yang digabungkan dengan vgcreate
Logical Volume (LV) — partisi virtual yang dibuat dari VG dengan lvcreate; inilah yang diformat dan dipasang

Keuntungan utamanya: Anda dapat memperbesar LV secara daring tanpa melepas pemasangan, serta menambahkan disk baru ke VG tanpa memformat ulang. Hal ini membuat LVM penting untuk otomatisasi penyimpanan produksi.

Perintah pemeriksaan: pvs, vgs, lvs, serta versi terperincinya pvdisplay, vgdisplay, dan lvdisplay.

Membuat Volume LVM dengan Skrip

Mengotomatiskan penyiapan LVM mengikuti urutan yang ketat: pvcreate → vgcreate → lvcreate → mkfs → mount. Setiap langkah harus berhasil sebelum langkah berikutnya dijalankan — gunakan set -euo pipefail dan validasi keluaran setiap perintah.

Selalu pastikan disk target tidak memiliki tabel partisi sebelum memanggil pvcreate
Gunakan tanda -y untuk menonaktifkan pertanyaan interaktif dalam skrip noninteraktif
Tentukan -L (ukuran tetap) atau -l 100%FREE untuk menggunakan seluruh ruang yang tersisa
Setelah mkfs, gunakan jalur perangkat LV: /dev/<vgname>/<lvname>

#!/usr/bin/env bash
# Automate LVM setup: PV -> VG -> LV -> mkfs -> mount
set -euo pipefail

DISK='/dev/sdc'          # raw disk, no existing partitions
VG_NAME='vg_appdata'
LV_NAME='lv_appdata'
LV_SIZE='10G'
MOUNTPOINT='/mnt/appdata'
FSTYPE='xfs'

echo "[1/6] Initializing Physical Volume on $DISK"
sudo pvcreate -y "$DISK"

echo "[2/6] Creating Volume Group: $VG_NAME"
sudo vgcreate "$VG_NAME" "$DISK"

echo "[3/6] Creating Logical Volume: $LV_NAME (${LV_SIZE})"
sudo lvcreate -y -L "$LV_SIZE" -n "$LV_NAME" "$VG_NAME"

echo "[4/6] Formatting as $FSTYPE"
sudo mkfs."$FSTYPE" "/dev/$VG_NAME/$LV_NAME"

echo "[5/6] Mounting at $MOUNTPOINT"
sudo mkdir -p "$MOUNTPOINT"
sudo mount "/dev/$VG_NAME/$LV_NAME" "$MOUNTPOINT"

echo "[6/6] Done. Disk usage:"
df -h "$MOUNTPOINT"

# Show LVM summary
vgs && lvs

Memperbesar Volume Logis Secara Daring

Salah satu fitur LVM yang paling kuat adalah pengubahan ukuran secara daring — memperbesar volume logis dan sistem berkasnya saat volume tersebut sedang terpasang dan digunakan. Alurnya adalah:

Perbesar LV dengan lvextend (tanda -r mengubah ukuran sistem berkas dalam langkah yang sama)
Jika tidak menggunakan -r, ubah ukuran sistem berkas secara terpisah: resize2fs untuk ext4, xfs_growfs untuk xfs

Batasan penting:

xfs hanya dapat diperbesar, tidak dapat diperkecil — rencanakan kapasitas dengan cermat
ext4 dapat diperkecil, tetapi hanya saat tidak terpasang
Selalu pastikan VG memiliki ruang kosong dengan vgdisplay -s sebelum memperbesar

#!/usr/bin/env bash
# Extend an LV and its xfs filesystem online
set -euo pipefail

VG_NAME='vg_appdata'
LV_NAME='lv_appdata'
EXTEND_BY='5G'
LV_DEV="/dev/$VG_NAME/$LV_NAME"

# Confirm VG has enough free space
FREE_GB=$(vgs --noheadings --units g -o vg_free "$VG_NAME" | tr -d ' g')
echo "VG free space: ${FREE_GB}G"
if (( $(echo "$FREE_GB < 5" | bc -l) )); then
  echo 'ERROR: Not enough free space in VG' >&2
  exit 1
fi

echo "Extending LV by $EXTEND_BY..."
sudo lvextend -L "+${EXTEND_BY}" "$LV_DEV"

echo 'Growing xfs filesystem online...'
sudo xfs_growfs "$LV_DEV"

echo 'New size:'
df -h "$LV_DEV"
lvs "$LV_DEV"

Membuat dan Memformat Sistem Berkas

Setelah melakukan partisi atau menyiapkan LVM, Anda perlu memformat perangkat blok dengan sistem berkas. Pilihan umum dalam administrasi Linux:

ext4 — matang, menggunakan jurnal, mendukung pengecilan ukuran; bawaan pada banyak distro (mkfs.ext4)
xfs — berperforma tinggi, cocok untuk file besar dan I/O paralel; bawaan pada RHEL/CentOS (mkfs.xfs)
btrfs — menggunakan mekanisme copy-on-write, dengan snapshot bawaan (mkfs.btrfs)
tmpfs — berbasis RAM, ditentukan dalam fstab tanpa mkfs

Selalu tetapkan label sistem berkas yang bermakna (tanda -L) agar perangkat dapat dirujuk dengan LABEL= dalam fstab sebagai cadangan untuk UUID.

#!/usr/bin/env bash
# Format a partition and assign a label; print resulting UUID
set -euo pipefail

PARTITION='/dev/sdb1'
FSTYPE='ext4'
LABEL='appdata'

# Safety check: refuse to format a currently mounted device
if findmnt --source "$PARTITION" > /dev/null 2>&1; then
  echo "ERROR: $PARTITION is currently mounted. Unmount first." >&2
  exit 1
fi

echo "Formatting $PARTITION as $FSTYPE with label '$LABEL'..."
sudo mkfs."$FSTYPE" -L "$LABEL" -F "$PARTITION"

# Retrieve and display the new UUID
NEW_UUID=$(sudo blkid -s UUID -o value "$PARTITION")
echo "Formatted successfully."
echo "Label : $LABEL"
echo "UUID  : $NEW_UUID"
echo "Use this in fstab: UUID=$NEW_UUID  /mnt/$LABEL  $FSTYPE  defaults,nofail  0  2"

Mengotomatiskan Pemasangan NFS dengan autofs

Untuk sistem berkas jaringan, pemasangan saat boot menggunakan fstab dapat menyebabkan penundaan atau kegagalan jika server NFS sementara tidak dapat dijangkau. autofs mengatasi hal ini dengan memasang sesuai permintaan dan melepas pemasangan setelah batas waktu.

Peta utama: /etc/auto.master — menentukan direktori titik pemasangan dan file petanya
Peta langsung: /etc/auto.nfs — menentukan opsi dan jalur server NFS untuk setiap subdirektori
Muat ulang dengan systemctl reload autofs setelah melakukan perubahan
Pemasangan muncul secara otomatis di bawah direktori yang dikonfigurasi saat diakses

Dalam skrip, Anda dapat membuat peta secara dinamis dari daftar berbagi NFS lalu memuat ulang autofs — berguna untuk menyediakan penyimpanan bersama di banyak host.

#!/usr/bin/env bash
# Generate an autofs NFS map file from a share list and reload autofs
set -euo pipefail

NFS_SERVER='192.168.1.50'
AUTO_MAP='/etc/auto.nfs'
AUTO_MASTER='/etc/auto.master'
MOUNT_BASE='/nfs'

# Define shares: localname:remote_path
declare -A SHARES=(
  [homes]='/export/homes'
  [media]='/export/media'
  [backups]='/export/backups'
)

# Write map file
{
  echo '# Generated by disk-automation script'
  for localname in "${!SHARES[@]}"; do
    remote="${SHARES[$localname]}"
    echo "$localname  -rw,soft,timeo=30  ${NFS_SERVER}:${remote}"
  done
} | sudo tee "$AUTO_MAP" > /dev/null

echo "Wrote $AUTO_MAP"

# Ensure master map references this file
if ! grep -qF "$AUTO_MAP" "$AUTO_MASTER"; then
  echo "$MOUNT_BASE  $AUTO_MAP" | sudo tee -a "$AUTO_MASTER" > /dev/null
  echo "Updated $AUTO_MASTER"
fi

sudo systemctl reload autofs && echo 'autofs reloaded'

Snapshot LVM untuk Cadangan yang Aman

Snapshot LVM menyediakan salinan volume logis pada titik waktu tertentu, sehingga memungkinkan pencadangan sistem berkas aktif secara konsisten tanpa melepas pemasangannya. Snapshot menangkap keadaan pada saat dibuat dengan menggunakan copy-on-write.

Buat: lvcreate -s -n lv_snap -L 2G /dev/vg_data/lv_data
Pasang snapshot dalam mode hanya-baca untuk mencadangkannya: mount -o ro /dev/vg_data/lv_snap /mnt/snap
Jalankan rsync atau tar pada titik pemasangan snapshot
Hapus snapshot setelah pencadangan: umount /mnt/snap && lvremove -f /dev/vg_data/lv_snap

Pertahankan ukuran snapshot sebesar 10–20% dari LV asal. Jika snapshot penuh, snapshot menjadi tidak valid — pantau dengan lvs -o lv_name,snap_percent.

#!/usr/bin/env bash
# Create an LVM snapshot, back up via tar, then remove snapshot
set -euo pipefail

VG='vg_appdata'
ORIGIN_LV='lv_appdata'
SNAP_LV='lv_appdata_snap'
SNAP_SIZE='2G'
SNAP_MOUNT='/mnt/snap_backup'
BACKUP_DEST='/var/backups/appdata'
DATESTAMP=$(date +%Y%m%d_%H%M%S)

trap 'sudo umount "$SNAP_MOUNT" 2>/dev/null; sudo lvremove -f "/dev/$VG/$SNAP_LV" 2>/dev/null' ERR EXIT

echo '[1] Creating snapshot...'
sudo lvcreate -s -n "$SNAP_LV" -L "$SNAP_SIZE" "/dev/$VG/$ORIGIN_LV"

echo '[2] Mounting snapshot read-only...'
sudo mkdir -p "$SNAP_MOUNT"
sudo mount -o ro "/dev/$VG/$SNAP_LV" "$SNAP_MOUNT"

echo '[3] Archiving to backup destination...'
sudo mkdir -p "$BACKUP_DEST"
sudo tar -czf "$BACKUP_DEST/appdata_${DATESTAMP}.tar.gz" -C "$SNAP_MOUNT" .

echo '[4] Cleaning up snapshot...'
sudo umount "$SNAP_MOUNT"
sudo lvremove -f "/dev/$VG/$SNAP_LV"

echo "Backup complete: $BACKUP_DEST/appdata_${DATESTAMP}.tar.gz"

Uji Pengetahuan: Otomatisasi fstab dan Pemasangan yang Aman

Uji pemahaman Anda tentang praktik aman untuk otomatisasi disk, sistem berkas, dan pemasangan yang dibahas dalam pelajaran ini.

Rangkuman Pelajaran: Otomatisasi Disk, Sistem Berkas, dan Pemasangan

Dalam pelajaran ini, Anda telah membangun perangkat lengkap untuk mengelola disk dan penyimpanan secara aman dan dapat dibuat dalam skrip pada sistem Linux. Hal-hal penting:

Periksa terlebih dahulu: lsblk, blkid, df, dan du memberikan informasi yang diperlukan sebelum perubahan apa pun.
Kedisiplinan fstab: selalu gunakan UUID, selalu sertakan nofail, selalu buat cadangan sebelum mengedit, dan validasi dengan findmnt --verify.
Keamanan pemasangan: periksa mountpoint -q sebelum memasang, catat dengan logger, dan tangani kesalahan perangkat yang sedang digunakan dengan lsof.
Kekuatan LVM: alur PV → VG → LV memungkinkan perluasan secara daring dan pencadangan berbasis snapshot tanpa waktu henti.
Pilihan sistem berkas penting: xfs untuk performa (hanya dapat diperbesar), ext4 untuk fleksibilitas (dapat diperkecil saat tidak terpasang), dan btrfs untuk beban kerja yang menggunakan snapshot secara bawaan.
NFS sesuai permintaan: autofs menghindari penundaan saat boot dengan hanya memasang berbagi jaringan ketika diakses.
Pencadangan dengan snapshot: snapshot LVM menghasilkan cadangan aktif yang konsisten — tetapi selalu pantau snap_percent dan segera hapus snapshot setelah pencadangan.

Gabungkan pola-pola ini agar Anda dapat mengotomatiskan seluruh siklus hidup penyimpanan dengan andal: penemuan, penyediaan, pemasangan, pengubahan ukuran, dan pencadangan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Otomatisasi Disk, Sistem File, dan Mount” gratis?

Ya — teks lengkap “Otomatisasi Disk, Sistem File, dan Mount” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Linux Command Line & Bash Scripting Mastery, upgrade ke CoddyKit PRO. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Otomatisasi Disk, Sistem File, dan Mount”?

Periksa perangkat blok, kelola entri fstab, serta jalankan operasi LVM dan mount dengan aman melalui skrip. Kamu berlatih Linux Command Line & Bash Scripting Mastery dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Linux Command Line & Bash Scripting Mastery?

Tidak diperlukan pengalaman sebelumnya. Linux Command Line & Bash Scripting Mastery di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Otomatisasi Disk, Sistem File, dan Mount” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Linux Command Line & Bash Scripting Mastery ini?

Ya. Setiap pelajaran Linux Command Line & Bash Scripting Mastery menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Mengotomatiskan Penyediaan Pengguna dan Grup
Mengendalikan Layanan systemd dan Menulis File Unit
Otomatisasi Disk, Sistem File, dan Mount
Membangun Skrip Pemeriksaan Kesehatan Sistem dan Peringatan

← Kembali ke Linux Command Line & Bash Scripting Mastery