Kem Intensif DevOps · Pelajaran

Automasi Cakera, Sistem Fail dan Lekapan

Periksa peranti blok, urus entri fstab dan skripkan operasi LVM serta lekapan dengan selamat

Pelajaran 3 daripada 413 langkah

Automasi Cakera, Sistem Fail dan Lekapan ialah pelajaran Kem Intensif DevOps percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif DevOps, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif DevOps merangkumi sejumlah 4 pelajaran.

Memahami Peranti Blok dengan lsblk dan fdisk

Sebelum mengautomasikan operasi cakera, anda mesti dapat memeriksa peranti blok yang wujud pada sistem. Dua alat penting ialah lsblk dan fdisk -l.

lsblk — menyenaraikan peranti blok dalam format pepohon yang memaparkan nama peranti, saiz, titik lekapan dan jenis (disk, part, lvm)
fdisk -l — memaparkan jadual partisyen dan butiran sektor (memerlukan root)
blkid — mencetak UUID dan jenis sistem fail bagi setiap peranti blok

Dalam skrip, anda sering perlu menghuraikan output ini untuk mengesan cakera yang tersedia, menyemak sama ada sesuatu partisyen telah diformatkan atau menentukan UUID-nya sebelum melakukan lekapan.

#!/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

Menyemak Ruang Cakera dengan df dan du

df dan du ialah alat utama untuk melaporkan penggunaan sistem fail dan direktori. Dalam skrip pentadbir sistem, anda menggunakannya untuk mencetuskan amaran, menguatkuasakan kuota atau menentukan masa untuk menyediakan lebih banyak ruang.

df -h — penggunaan sistem fail dalam format mudah dibaca merentas semua sistem fail yang dilekapkan
df -BG — output dalam gigabait untuk penghuraian angka yang konsisten
du -sh /path — saiz ringkasan direktori tertentu
du -d 1 /var — pecahan sedalam satu aras (berguna untuk mencari subdirektori yang besar)

Lajur peratus digunakan daripada df lazimnya dihuraikan untuk mencetuskan amaran cakera 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 Menghuraikan /etc/fstab

/etc/fstab ialah jadual sistem fail statik — ia mentakrifkan peranti yang akan dilekapkan semasa but, pada laluan yang mana dan dengan pilihan yang mana. Setiap baris mempunyai enam medan:

Peranti — UUID=..., LABEL=... atau /dev/sdX
Titik lekapan — laluan direktori
Jenis sistem fail — ext4, xfs, nfs, tmpfs dan sebagainya
Pilihan — defaults, ro, noexec, nofail dan sebagainya
Dump — 0 atau 1 (bendera sandaran)
Pass — 0, 1 atau 2 (susunan fsck)

Skrip yang menambah atau mengesahkan entri fstab mesti mengendalikan ulasan (baris yang bermula dengan #) dan baris kosong dengan baik. Sentiasa utamakan UUID berbanding nama peranti supaya sistem dapat bertahan daripada but semula apabila susunan peranti 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"

Menambah Entri fstab dengan Selamat

Mengedit /etc/fstab secara manual mudah menyebabkan kesilapan. Entri yang salah boleh menghalang sistem daripada dibut. Skrip automasi yang selamat hendaklah:

Memeriksa sama ada entri itu sudah wujud sebelum menambahkannya (idempotensi)
Menyandarkan fail asal sebelum sebarang pengubahsuaian
Menggunakan UUID dan bukannya laluan peranti
Menambah nofail pada pilihan lekapan supaya cakera yang tiada tidak menghentikan proses but
Menjalankan mount -a dalam mod percubaan atau melakukan lekapan ujian untuk mengesahkan kesahihan sebelum but semula

Selepas menulis entri tersebut, sentiasa sahkan dengan findmnt --verify (tersedia pada distro systemd moden) untuk mengesan ralat sintaks dengan segera.

#!/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'

Melekap dan Menyah-lekap Sistem Fail dalam Skrip

Perintah mount dan umount adalah mudah digunakan, tetapi skrip mesti mengendalikan kes terpencil:

Peranti mungkin sudah dilekap — cubaan melekapkannya sekali lagi akan gagal; semak dengan findmnt atau mountpoint
Titik lekap mungkin sibuk (fail sedang dibuka) — umount akan gagal; gunakan lsof +D /mnt/target untuk mencari puncanya
Gunakan mount -o remount,ro /mnt/data untuk menukarnya kepada baca sahaja tanpa menyah-lekapkannya
Gunakan umount -l /mnt/data (malas) sebagai pilihan terakhir — ia menanggalkan ruang nama tetapi menunggu sehingga semua rujukan ditutup

Dalam automasi, sentiasa semak kod keluar 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"

Pengenalan kepada LVM: Jilid Fizikal, Kumpulan Jilid dan Jilid Logikal

LVM (Pengurus Jilid Logikal) menambah lapisan abstraksi yang fleksibel antara peranti blok mentah dengan sistem fail. Hierarki tiga peringkatnya ialah:

Jilid Fizikal (PV) — cakera mentah atau partition yang dimulakan dengan pvcreate
Kumpulan Jilid (VG) — satu atau lebih PV yang digabungkan dengan vgcreate
Jilid Logikal (LV) — partition maya yang diperuntukkan daripada VG dengan lvcreate; inilah yang diformatkan dan dilekapkan

Kelebihan utamanya: anda boleh melanjutkan LV semasa dalam talian tanpa menyah-lekapkannya, serta menambah cakera baharu kepada VG tanpa memformatkannya semula. Hal ini menjadikan LVM penting untuk automasi storan produksi.

Perintah pemeriksaan: pvs, vgs, lvs, serta perintah terperinci masing-masing, iaitu pvdisplay, vgdisplay dan lvdisplay.

Menskripkan Penciptaan Jilid LVM

Mengautomatikkan persediaan LVM mengikut urutan yang ketat: pvcreate → vgcreate → lvcreate → mkfs → mount. Setiap langkah mesti berjaya sebelum langkah seterusnya dijalankan — gunakan set -euo pipefail dan sahkan output setiap perintah.

Sentiasa semak bahawa cakera sasaran tidak mempunyai jadual partition sedia ada sebelum memanggil pvcreate
Gunakan bendera -y untuk menyekat gesaan interaktif dalam skrip bukan interaktif
Tentukan -L (saiz tetap) atau -l 100%FREE untuk menggunakan semua ruang yang masih ada
Selepas mkfs, gunakan laluan peranti 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

Melanjutkan Jilid Logikal Semasa Dalam Talian

Salah satu ciri LVM yang paling berkuasa ialah pengubahan saiz dalam talian — melanjutkan jilid logikal dan sistem failnya ketika ia sedang dilekapkan dan digunakan. Aliran kerjanya ialah:

Melanjutkan LV dengan lvextend (bendera -r mengubah saiz sistem fail dalam langkah yang sama)
Jika tidak menggunakan -r, ubah saiz sistem fail secara berasingan: resize2fs untuk ext4, xfs_growfs untuk xfs

Kekangan penting:

xfs hanya boleh dibesarkan, tidak boleh dikecilkan — rancang kapasiti dengan teliti
ext4 boleh dikecilkan tetapi hanya ketika tidak dilekapkan
Sentiasa sahkan bahawa VG mempunyai ruang kosong dengan vgdisplay -s sebelum melanjutkan

#!/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"

Mencipta dan Memformat Sistem Fail

Selepas membuat partition atau menyediakan LVM, anda perlu memformatkan peranti blok dengan sistem fail. Pilihan lazim dalam pentadbiran Linux:

ext4 — matang, mempunyai jurnal, menyokong pengecilan; lalai pada banyak distro (mkfs.ext4)
xfs — berprestasi tinggi, sesuai untuk fail besar dan I/O selari; lalai pada RHEL/CentOS (mkfs.xfs)
btrfs — salin semasa tulis, dengan snapshot terbina dalam (mkfs.btrfs)
tmpfs — disokong RAM, ditentukan dalam fstab tanpa mkfs

Sentiasa tetapkan label sistem fail yang bermakna (bendera -L) supaya peranti boleh dirujuk dengan LABEL= dalam fstab sebagai pilihan sandaran kepada 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"

Mengautomatikkan Lekapan NFS dengan autofs

Untuk sistem fail rangkaian, melekapkannya semasa but dengan fstab boleh menyebabkan kelewatan atau kegagalan jika pelayan NFS tidak dapat dicapai buat sementara waktu. autofs menyelesaikan masalah ini dengan melekapkan sistem fail apabila diperlukan dan menyah-lekapkannya selepas tempoh tamat.

Peta induk: /etc/auto.master — mentakrifkan direktori titik lekap dan fail petanya
Peta langsung: /etc/auto.nfs — menentukan pilihan dan laluan pelayan NFS bagi setiap subdirektori
Muat semula dengan systemctl reload autofs selepas perubahan
Lekapan muncul secara automatik di bawah direktori yang dikonfigurasikan apabila diakses

Dalam skrip, anda boleh menjana secara dinamik fail peta daripada senarai perkongsian NFS dan memuat semula autofs — berguna untuk menyediakan storan dikongsi merentas banyak hos.

#!/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 Sandaran Selamat

Snapshot LVM menyediakan salinan jilid logikal pada satu titik masa, sekali gus membolehkan sandaran sistem fail aktif yang konsisten tanpa menyah-lekapkannya. Snapshot merakam keadaan pada masa penciptaan menggunakan salin semasa tulis.

Cipta: lvcreate -s -n lv_snap -L 2G /dev/vg_data/lv_data
Lebapkan snapshot sebagai baca sahaja untuk membuat sandaran: mount -o ro /dev/vg_data/lv_snap /mnt/snap
Jalankan rsync atau tar terhadap titik lekap snapshot
Buang snapshot selepas sandaran: umount /mnt/snap && lvremove -f /dev/vg_data/lv_snap

Kekalkan saiz snapshot pada 10-20% daripada LV asal. Jika snapshot penuh, ia menjadi tidak sah — 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"

Semakan Pengetahuan: Automasi fstab dan Lekapan yang Selamat

Uji pemahaman anda tentang amalan automasi cakera, sistem fail dan lekapan yang selamat yang dibincangkan dalam pelajaran ini.

Jawab dalam pelajaran interaktif

Rumusan Pelajaran: Automasi Cakera, Sistem Fail dan Lekapan

Dalam pelajaran ini, anda telah membina kit alat lengkap untuk pengurusan cakera dan storan yang selamat serta boleh diskripkan pada sistem Linux. Perkara utama:

Pemeriksaan dahulu: lsblk, blkid, df dan du memberikan maklumat yang diperlukan sebelum sebarang perubahan.
Disiplin fstab: sentiasa gunakan UUID, sentiasa sertakan nofail, sentiasa buat sandaran sebelum mengedit, dan sahkan dengan findmnt --verify.
Keselamatan lekapan: semak mountpoint -q sebelum melekapkan, catat dengan logger, dan kendalikan ralat peranti sibuk dengan lsof.
Keupayaan LVM: pipeline PV → VG → LV membolehkan peluasan dalam talian dan sandaran berasaskan snapshot tanpa masa henti.
Pilihan sistem fail penting: xfs untuk prestasi (hanya boleh dibesarkan), ext4 untuk fleksibiliti (boleh dikecilkan ketika luar talian), btrfs untuk beban kerja asli snapshot.
NFS atas permintaan: autofs mengelakkan kelewatan but dengan hanya melekapkan perkongsian rangkaian apabila diakses.
Sandaran snapshot: snapshot LVM memberikan sandaran langsung yang konsisten — tetapi sentiasa pantau snap_percent dan buang snapshot dengan segera selepas sandaran.

Gabungkan corak ini dan anda boleh mengautomatikkan seluruh kitar hayat storan dengan pasti: penemuan, penyediaan, lekapan, pengubahan saiz dan sandaran.

Percuma untuk bermula

Pelajari Kem Intensif DevOps dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 142
Pelajaran: 568

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Automasi Cakera, Sistem Fail dan Lekapan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif DevOps, termasuk “Automasi Cakera, Sistem Fail dan Lekapan”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kem Intensif DevOps merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Automasi Cakera, Sistem Fail dan Lekapan”?

Periksa peranti blok, urus entri fstab dan skripkan operasi LVM serta lekapan dengan selamat Anda berlatih Kem Intensif DevOps menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif DevOps?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif DevOps di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Automasi Cakera, Sistem Fail dan Lekapan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif DevOps ini?

Ya. Setiap pelajaran Kem Intensif DevOps menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Mengautomatikkan Penyediaan Pengguna dan Kumpulan
Mengawal Perkhidmatan systemd dan Menulis Fail Unit
Automasi Cakera, Sistem Fail dan Lekapan
Membina Skrip Pemeriksaan Kesihatan Sistem dan Amaran

← Kembali ke Kem Intensif DevOps