Linux Command Line & Bash Scripting Mastery · Lekcja

Automatyzacja dysków, systemów plików i montowania

Sprawdzaj urządzenia blokowe, zarządzaj wpisami fstab i bezpiecznie twórz skrypty obsługujące LVM oraz operacje montowania.

Automatyzacja dysków, systemów plików i montowania to bezpłatna lekcja Linux Command Line & Bash Scripting Mastery na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Linux Command Line & Bash Scripting Mastery, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Linux Command Line & Bash Scripting Mastery zawiera 4 lekcji w sumie.

Poznawanie urządzeń blokowych za pomocą lsblk i fdisk

Przed zautomatyzowaniem operacji dyskowych należy umieć sprawdzić, jakie urządzenia blokowe istnieją w systemie. Dwa podstawowe narzędzia to lsblk i fdisk -l.

lsblk — wyświetla urządzenia blokowe w formie drzewa, pokazując nazwy urządzeń, rozmiary, punkty montowania i typy (dysk, partycja, lvm)
fdisk -l — pokazuje tablice partycji i informacje o sektorach (wymaga uprawnień root)
blkid — wyświetla identyfikatory UUID i typy systemów plików dla każdego urządzenia blokowego

W skryptach często trzeba analizować te dane wyjściowe, aby wykrywać dostępne dyski, sprawdzać, czy partycja jest sformatowana, lub ustalać jej UUID przed zamontowaniem.

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

Sprawdzanie miejsca na dysku za pomocą df i du

df i du to podstawowe narzędzia do raportowania wykorzystania systemów plików i katalogów. W skryptach administratora systemu służą do uruchamiania alertów, egzekwowania limitów lub określania, kiedy należy przydzielić więcej miejsca.

df -h — czytelne dla człowieka informacje o wykorzystaniu wszystkich zamontowanych systemów plików
df -BG — dane wyjściowe w gigabajtach, ułatwiające spójne przetwarzanie wartości liczbowych
du -sh /path — podsumowany rozmiar określonego katalogu
du -d 1 /var — zestawienie o głębokości jednego poziomu (przydatne do znalezienia dużego podkatalogu)

Kolumna percent used z df jest często analizowana w celu wyzwalania alertów o zapełnieniu dysku w skryptach monitorujących.

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

Odczytywanie i analizowanie pliku /etc/fstab

/etc/fstab to statyczna tabela systemów plików — definiuje, które urządzenia są montowane podczas uruchamiania systemu, w jakich ścieżkach i z jakimi opcjami. Każdy wiersz zawiera sześć pól:

Device — UUID=..., LABEL=... lub /dev/sdX
Mount point — ścieżka katalogu
Filesystem type — ext4, xfs, nfs, tmpfs itd.
Options — defaults, ro, noexec, nofail itd.
Dump — 0 lub 1 (flaga kopii zapasowej)
Pass — 0, 1 lub 2 (kolejność sprawdzania za pomocą fsck)

Skrypty, które dodają lub weryfikują wpisy w pliku fstab, muszą prawidłowo obsługiwać komentarze (wiersze zaczynające się od #) oraz puste wiersze. Zawsze należy preferować identyfikatory UUID zamiast nazw urządzeń, aby uniknąć problemów po ponownym uruchomieniu systemu, gdy kolejność urządzeń może się zmienić.

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

Bezpieczne dodawanie wpisu do fstab

Ręczna edycja /etc/fstab jest podatna na błędy. Nieprawidłowy wpis może uniemożliwić uruchomienie systemu. Bezpieczny skrypt automatyzujący powinien:

sprawdzić, czy wpis już istnieje, zanim go dopisze (idempotentność)
utworzyć kopię zapasową oryginalnego pliku przed wprowadzeniem jakichkolwiek zmian
używać identyfikatora UUID zamiast ścieżki urządzenia
dodać nofail do opcji montowania, aby brakujący dysk nie zatrzymał uruchamiania systemu
uruchomić mount -a w trybie testowym lub wykonać testowe montowanie, aby zweryfikować konfigurację przed ponownym uruchomieniem

Po zapisaniu wpisu zawsze należy przeprowadzić weryfikację za pomocą findmnt --verify (dostępnego w nowoczesnych dystrybucjach korzystających z systemd), aby natychmiast wykryć błędy składni.

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

Montowanie i odmontowywanie systemów plików w skryptach

Polecenia mount i umount są proste w użyciu, ale skrypty muszą obsługiwać sytuacje brzegowe:

urządzenie może być już zamontowane — ponowne montowanie zakończy się niepowodzeniem; należy sprawdzić to za pomocą findmnt lub mountpoint
punkt montowania może być zajęty (otwarte pliki) — umount zakończy się niepowodzeniem; polecenie lsof +D /mnt/target pozwala znaleźć przyczynę
polecenie mount -o remount,ro /mnt/data służy do przełączenia w tryb tylko do odczytu bez odmontowywania
polecenia umount -l /mnt/data (lazy) należy używać w ostateczności — odłącza przestrzeń nazw, ale czeka na zamknięcie odwołań

W automatyzacji zawsze należy sprawdzać kod wyjścia polecenia mount i zapisywać błędy w syslogu za pomocą 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"

Wprowadzenie do LVM: woluminy fizyczne, grupy woluminów i woluminy logiczne

LVM (Logical Volume Manager) dodaje elastyczną warstwę abstrakcji między surowymi urządzeniami blokowymi a systemami plików. Hierarchia składa się z trzech poziomów:

Physical Volume (PV) — surowy dysk lub partycja zainicjalizowana za pomocą pvcreate
Volume Group (VG) — jedna lub więcej pul PV połączonych za pomocą vgcreate
Logical Volume (LV) — wirtualna partycja utworzona w VG za pomocą lvcreate; to ją formatuje się i montuje

Najważniejsza zaleta polega na tym, że można rozszerzać LV online bez odmontowywania, a także dodawać nowe dyski do VG bez ponownego formatowania. Dzięki temu LVM jest niezbędny w automatyzacji pamięci masowej w środowiskach produkcyjnych.

Polecenia inspekcji: pvs, vgs, lvs oraz ich bardziej szczegółowe odpowiedniki: pvdisplay, vgdisplay, lvdisplay.

Skryptowe tworzenie woluminów LVM

Automatyzacja konfiguracji LVM przebiega w ściśle określonej kolejności: pvcreate → vgcreate → lvcreate → mkfs → mount. Każdy etap musi zakończyć się powodzeniem, zanim rozpocznie się następny — należy użyć set -euo pipefail i zweryfikować wynik każdego polecenia.

Zawsze należy sprawdzić, czy dysk docelowy nie zawiera istniejącej tablicy partycji, zanim wywoła się pvcreate
W skryptach nieinteraktywnych należy używać flagi -y, aby wyłączyć monity wymagające interakcji
Należy określić -L (stały rozmiar) lub -l 100%FREE, aby wykorzystać całą pozostałą przestrzeń
Po wykonaniu mkfs należy użyć ścieżki urządzenia 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

Rozszerzanie woluminu logicznego online

Jedną z najważniejszych funkcji LVM jest zmiana rozmiaru online — rozszerzanie woluminu logicznego i jego systemu plików, gdy jest on zamontowany i używany. Procedura wygląda następująco:

Rozszerz LV za pomocą lvextend (flaga -r zmienia rozmiar systemu plików w tym samym kroku)
Jeśli nie używasz -r, zmień rozmiar systemu plików osobno: resize2fs dla ext4, xfs_growfs dla xfs

Ważne ograniczenia:

xfs można wyłącznie powiększać, nigdy zmniejszać — należy starannie zaplanować pojemność
ext4 można zmniejszać, ale tylko po odmontowaniu
Przed rozszerzeniem zawsze należy sprawdzić, czy VG ma wolne miejsce, za pomocą vgdisplay -s

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

Tworzenie i formatowanie systemów plików

Po partycjonowaniu lub konfiguracji LVM należy sformatować urządzenie blokowe systemem plików. Typowe wybory w administracji systemem Linux:

ext4 — dojrzały system plików z dziennikiem, obsługujący zmniejszanie; domyślny w wielu dystrybucjach (mkfs.ext4)
xfs — wydajny, preferowany w przypadku dużych plików i równoległych operacji wejścia-wyjścia; domyślny w RHEL/CentOS (mkfs.xfs)
btrfs — system plików typu copy-on-write z wbudowaną obsługą migawek (mkfs.btrfs)
tmpfs — system plików oparty na pamięci RAM, określany w fstab bez użycia mkfs

Zawsze należy ustawić opisową etykietę systemu plików (flaga -L), aby w razie potrzeby można było odwołać się do urządzenia za pomocą LABEL= w fstab zamiast 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"

Automatyzacja montowania NFS za pomocą autofs

W przypadku sieciowych systemów plików montowanie podczas uruchamiania za pomocą fstab może powodować opóźnienia lub błędy, jeśli serwer NFS jest tymczasowo niedostępny. autofs rozwiązuje ten problem, montując system plików na żądanie i odmontowując go po upływie limitu czasu.

Mapa główna: /etc/auto.master — definiuje katalog punktu montowania i jego plik mapy
Mapa bezpośrednia: /etc/auto.nfs — określa opcje i ścieżkę serwera NFS dla każdego podkatalogu
Po zmianach należy przeładować konfigurację za pomocą systemctl reload autofs
Punkty montowania pojawiają się automatycznie w skonfigurowanym katalogu po uzyskaniu do nich dostępu

W skryptach można dynamicznie generować plik mapy na podstawie listy udziałów NFS i przeładowywać autofs — jest to przydatne podczas udostępniania wspólnej pamięci masowej na wielu hostach.

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

Migawka LVM na potrzeby bezpiecznych kopii zapasowych

Migawki LVM udostępniają kopię woluminu logicznego z określonego momentu, umożliwiając tworzenie spójnych kopii zapasowych używanych systemów plików bez ich odmontowywania. Migawka przechwytuje stan z chwili utworzenia, korzystając z mechanizmu copy-on-write.

Utworzenie: lvcreate -s -n lv_snap -L 2G /dev/vg_data/lv_data
Zamontowanie migawki tylko do odczytu w celu wykonania kopii zapasowej: mount -o ro /dev/vg_data/lv_snap /mnt/snap
Uruchomienie rsync lub tar dla punktu montowania migawki
Usunięcie migawki po wykonaniu kopii: umount /mnt/snap && lvremove -f /dev/vg_data/lv_snap

Rozmiar migawki powinien wynosić 10–20% rozmiaru źródłowego LV. Jeśli migawka się zapełni, stanie się nieprawidłowa — należy monitorować ją za pomocą 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"

Sprawdzenie wiedzy: bezpieczna automatyzacja fstab i montowania

Sprawdź swoją znajomość bezpiecznych praktyk automatyzacji dysków, systemów plików i montowania omówionych w tej lekcji.

Podsumowanie lekcji: automatyzacja dysków, systemów plików i montowania

W tej lekcji zbudowano kompletny zestaw narzędzi do bezpiecznego, skryptowego zarządzania dyskami i pamięcią masową w systemach Linux. Najważniejsze wnioski:

Najpierw inspekcja: polecenia lsblk, blkid, df i du dostarczają informacji potrzebnych przed wprowadzeniem jakichkolwiek zmian.
Dyscyplina przy fstab: zawsze używaj UUID, zawsze uwzględniaj nofail, zawsze twórz kopię zapasową przed edycją i przeprowadzaj weryfikację za pomocą findmnt --verify.
Bezpieczne montowanie: przed montowaniem sprawdzaj mountpoint -q, zapisuj informacje za pomocą logger i obsługuj błędy zajętego urządzenia przy użyciu lsof.
Możliwości LVM: potok PV → VG → LV umożliwia rozszerzanie online i tworzenie kopii zapasowych na podstawie migawek bez przestojów.
Wybór systemu plików ma znaczenie: xfs zapewnia wydajność (można go tylko powiększać), ext4 elastyczność (można go zmniejszać po odmontowaniu), a btrfs sprawdza się w zastosowaniach natywnie wykorzystujących migawki.
NFS na żądanie: autofs unika opóźnień podczas uruchamiania, montując udziały sieciowe dopiero po uzyskaniu do nich dostępu.
Kopie zapasowe z migawek: migawki LVM zapewniają spójne kopie zapasowe działających systemów, ale należy zawsze monitorować snap_percent i niezwłocznie usuwać migawki po wykonaniu kopii.

Połączenie tych wzorców pozwala niezawodnie zautomatyzować cały cykl życia pamięci masowej: wykrywanie, udostępnianie, montowanie, zmianę rozmiaru i tworzenie kopii zapasowych.

Często zadawane pytania

Czy lekcja „Automatyzacja dysków, systemów plików i montowania” jest bezpłatna?

Tak — pełny tekst „Automatyzacja dysków, systemów plików i montowania” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Linux Command Line & Bash Scripting Mastery, przejdź na CoddyKit PRO. Kurs Linux Command Line & Bash Scripting Mastery zawiera 4 lekcji w sumie.

Co nauczysz się w „Automatyzacja dysków, systemów plików i montowania”?

Sprawdzaj urządzenia blokowe, zarządzaj wpisami fstab i bezpiecznie twórz skrypty obsługujące LVM oraz operacje montowania. Ćwiczysz Linux Command Line & Bash Scripting Mastery z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Linux Command Line & Bash Scripting Mastery?

Nie wymagamy żadnego doświadczenia. Linux Command Line & Bash Scripting Mastery w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Automatyzacja dysków, systemów plików i montowania”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Linux Command Line & Bash Scripting Mastery?

Tak. Każda lekcja Linux Command Line & Bash Scripting Mastery zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Automatyzacja tworzenia użytkowników i grup
Sterowanie usługami systemd i pisanie plików jednostek
Automatyzacja dysków, systemów plików i montowania
Tworzenie skryptów do kontroli kondycji systemu i alertów

← Powrót do Linux Command Line & Bash Scripting Mastery