Linux - Pytania Rekrutacyjne dla DevOps i Backend Developera [2026]

Przygotowujesz się do rozmowy na stanowisko DevOps Engineer lub Backend Developer? Linux to fundament - nawet jeśli rozwijasz kod na macOS czy Windows, Twoje aplikacje prawie na pewno działają na serwerach Linux. Rekruterzy oczekują, że swobodnie poruszasz się po terminalu, debugujesz problemy i automatyzujesz zadania.

Ten przewodnik zawiera 50+ pytań rekrutacyjnych z odpowiedziami - od podstawowych komend po zaawansowany bash scripting i administrację systemem.

Spis treści

• Nawigacja i system plików
• Uprawnienia i własność plików
• Zarządzanie procesami
• Wyszukiwanie i filtrowanie
• Sieć i połączenia
• Bash scripting
• Zarządzanie usługami
• Dyski i pamięć
• Zobacz też

---

Nawigacja i system plików

Jakie są podstawowe komendy do nawigacji w Linux?

Odpowiedź w 30 sekund: Podstawowe komendy to pwd (gdzie jestem), cd (zmień katalog), ls (lista plików). Rekruterzy oczekują płynności - nie zastanawiania się nad podstawami.

Odpowiedź w 2 minuty:

Najlepiej pokazać to na praktycznych przykładach komend, które używasz codziennie w pracy.

# Nawigacja
pwd                     # Print working directory - gdzie jestem
cd /path/to/dir         # Change directory - przejdź do katalogu
cd ..                   # Katalog wyżej
cd ~                    # Katalog domowy
cd -                    # Poprzedni katalog (bardzo użyteczne!)

# Wyświetlanie plików
ls                      # Lista plików
ls -la                  # Long format + ukryte pliki
ls -lh                  # Human-readable rozmiary (KB, MB, GB)
ls -lt                  # Sortuj po czasie modyfikacji
ls -lS                  # Sortuj po rozmiarze

# Informacje o plikach
file document.pdf       # Typ pliku
stat file.txt           # Szczegółowe informacje
wc -l file.txt          # Liczba linii

Wyjaśnij strukturę katalogów Linux

Odpowiedź w 30 sekund: Wszystko zaczyna się od / (root). Kluczowe katalogi: /etc (konfiguracja), /var (logi, dane), /home (użytkownicy), /usr (programy), /tmp (tymczasowe).

Odpowiedź w 2 minuty:

Struktura katalogów w Linux jest hierarchiczna i zhierarchizowana - warto znać kluczowe lokalizacje.

Katalog	Zawartość	Przykłady
/	Root filesystem	Punkt startowy
/etc	Konfiguracja systemowa	nginx.conf, passwd
/var	Zmienne dane	/var/log, /var/www
/home	Katalogi użytkowników	/home/jan
/usr	Programy i biblioteki	/usr/bin, /usr/lib
/tmp	Pliki tymczasowe	Czyszczone przy reboot
/opt	Oprogramowanie zewnętrzne	/opt/myapp
/proc	Wirtualny filesystem	/proc/cpuinfo
/dev	Urządzenia	/dev/sda, /dev/null

# Szybkie sprawdzenie kluczowych lokalizacji
cat /etc/os-release     # Informacje o dystrybucji
ls /var/log/            # Logi systemowe
df -h                   # Zamontowane systemy plików

Jaka jest różnica między hard link a symbolic link?

Odpowiedź w 30 sekund: Hard link to dodatkowa nazwa dla tego samego pliku (tego samego inode). Symbolic link to wskaźnik na ścieżkę - jak skrót w Windows. Usunięcie oryginału psuje symlink, ale nie hard link.

Odpowiedź w 2 minuty:

Różnice najlepiej przedstawić w formie porównania kluczowych cech i zachowań obu typów linków.

Cecha	Hard Link	Symbolic Link
Wskazuje na	Inode (dane pliku)	Ścieżkę (nazwę pliku)
Po usunięciu oryginału	Działa dalej	Psuje się (dangling)
Między systemami plików	Nie	Tak
Dla katalogów	Nie	Tak
Rozmiar	Taki sam jak oryginał	Rozmiar ścieżki

# Tworzenie linków
ln plik.txt hardlink.txt        # Hard link
ln -s plik.txt symlink.txt      # Symbolic link

# Sprawdzenie
ls -li                          # -i pokazuje inode
# Hard link ma TEN SAM inode co oryginał
# Symlink ma WŁASNY inode i wskazuje na ścieżkę

# Znajdowanie broken symlinks
find /path -xtype l             # Znajduje dangling symlinks

Na co zwracają uwagę rekruterzy: Czy rozumiesz różnicę na poziomie inode, nie tylko "jeden działa po usunięciu, drugi nie".

---

Uprawnienia i własność plików

Jak działają uprawnienia plików w Linux?

Odpowiedź w 30 sekund: Trzy zestawy uprawnień (owner, group, others), każdy z trzema typami (read, write, execute). Zapis numeryczny: r=4, w=2, x=1. Więc 755 to rwx dla właściciela, rx dla reszty.

Odpowiedź w 2 minuty:

System uprawnień Linux opiera się na trzech grupach i trzech typach dostępu - zobaczmy jak to wygląda w praktyce.

# ls -l pokazuje uprawnienia
-rwxr-xr-x 1 jan developers 4096 Jan 1 10:00 script.sh
│└┬┘└┬┘└┬┘
│ │  │  └── others (inni)
│ │  └───── group (grupa)
│ └──────── owner (właściciel)
└────────── typ pliku (- = plik, d = katalog, l = link)

Symbol	Wartość	Znaczenie dla pliku	Znaczenie dla katalogu
r	4	Odczyt zawartości	Lista plików (ls)
w	2	Zapis/modyfikacja	Tworzenie/usuwanie plików
x	1	Wykonanie	Wejście do katalogu (cd)

# Zmiana uprawnień
chmod 755 script.sh         # rwxr-xr-x (właściciel wszystko, reszta rx)
chmod 644 config.txt        # rw-r--r-- (właściciel rw, reszta tylko r)
chmod +x script.sh          # Dodaj execute dla wszystkich
chmod u+x script.sh         # Dodaj execute tylko dla właściciela
chmod g-w file.txt          # Usuń write dla grupy
chmod -R 755 directory/     # Rekursywnie

# Zmiana właściciela
chown jan:developers file.txt    # Właściciel i grupa
chown jan file.txt               # Tylko właściciel
chown :developers file.txt       # Tylko grupa
chown -R www-data:www-data /var/www/   # Rekursywnie

Co to jest SUID, SGID i Sticky Bit?

Odpowiedź w 30 sekund: SUID (4xxx) - program działa z uprawnieniami właściciela pliku (np. passwd). SGID (2xxx) - program działa z uprawnieniami grupy lub nowe pliki dziedziczą grupę katalogu. Sticky bit (1xxx) - tylko właściciel może usuwać pliki (np. /tmp).

Odpowiedź w 2 minuty:

Te specjalne uprawnienia pozwalają na zaawansowaną kontrolę dostępu - oto jak działają w praktyce.

# SUID - Set User ID (4xxx)
ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root ...
#   ^-- 's' zamiast 'x' = SUID włączony
# passwd może modyfikować /etc/shadow mimo że uruchamia go zwykły user

# SGID - Set Group ID (2xxx)
chmod 2755 /shared/project/
# Nowe pliki w tym katalogu dziedziczą grupę katalogu, nie użytkownika

# Sticky Bit (1xxx)
ls -ld /tmp
drwxrwxrwt 10 root root ...
#        ^-- 't' = sticky bit
# Każdy może pisać do /tmp, ale tylko właściciel może usuwać swoje pliki

# Ustawianie
chmod 4755 program         # SUID
chmod 2755 directory       # SGID
chmod 1777 /shared/tmp     # Sticky bit
chmod u+s program          # SUID symbolicznie

Typowe pytanie follow-up: "Dlaczego SUID na skryptach jest niebezpieczny?"

• Skrypty mogą być łatwo zmodyfikowane lub manipulowane przez zmienne środowiskowe
• Kernel ignoruje SUID na skryptach w większości systemów

Czym jest umask i jak działa?

Odpowiedź w 30 sekund: Umask określa domyślne uprawnienia dla nowych plików przez "maskowanie" bitów. Domyślne uprawnienia (666 dla plików, 777 dla katalogów) minus umask = rzeczywiste uprawnienia. Umask 022 daje pliki 644 i katalogi 755.

Odpowiedź w 2 minuty:

Umask działa przez odejmowanie bitów od domyślnych uprawnień - najlepiej to pokazać na przykładach.

# Sprawdzenie aktualnego umask
umask              # np. 0022
umask -S           # symbolic: u=rwx,g=rx,o=rx

# Jak działa:
# Pliki: 666 (domyślne) - 022 (umask) = 644 (rw-r--r--)
# Katalogi: 777 (domyślne) - 022 (umask) = 755 (rwxr-xr-x)

# Ustawienie restrykcyjnego umask
umask 077          # Tylko właściciel ma dostęp (600/700)

# Typowe wartości umask
# 022 - standardowa (rw-r--r-- dla plików)
# 027 - bez dostępu dla others
# 077 - tylko właściciel

---

Zarządzanie procesami

Jak sprawdzić działające procesy?

Odpowiedź w 30 sekund: ps aux pokazuje wszystkie procesy. top lub htop dla live view. pgrep do szukania po nazwie. Kluczowe kolumny: PID, USER, %CPU, %MEM, COMMAND.

Odpowiedź w 2 minuty:

Istnieje kilka sposobów na sprawdzenie procesów - każdy przydatny w innych sytuacjach.

# Podstawowe komendy
ps aux                      # Wszystkie procesy (BSD syntax)
ps -ef                      # Wszystkie procesy (POSIX syntax)
ps aux | grep nginx         # Filtruj po nazwie
pgrep -a nginx              # PID i komenda procesów nginx
pgrep -u jan                # Procesy użytkownika jan

# Live monitoring
top                         # Klasyczny monitor
htop                        # Lepszy interfejs (jeśli zainstalowany)
watch -n 1 'ps aux | head'  # Odświeżaj co sekundę

# Szczegóły procesu
ps -p 1234 -o pid,ppid,cmd,%cpu,%mem    # Wybrane kolumny
cat /proc/1234/status       # Wszystko o procesie 1234
ls -l /proc/1234/fd         # Otwarte file descriptors

Kolumny ps aux:

Kolumna	Znaczenie
PID	Process ID
PPID	Parent Process ID
USER	Właściciel procesu
%CPU	Użycie CPU
%MEM	Użycie pamięci
VSZ	Virtual memory size
RSS	Resident Set Size (fizyczna pamięć)
STAT	Status (R=running, S=sleeping, Z=zombie)
COMMAND	Komenda uruchamiająca proces

Jak zabić proces?

Odpowiedź w 30 sekund: kill PID wysyła SIGTERM (graceful shutdown). kill -9 PID wysyła SIGKILL (natychmiastowe zabicie). pkill nazwa zabija po nazwie. Zawsze próbuj SIGTERM przed SIGKILL.

Odpowiedź w 2 minuty:

Zabijanie procesów to coś więcej niż tylko kill -9 - poznaj różne sygnały i ich zastosowania.

# Graceful shutdown (SIGTERM = 15)
kill 1234                   # Domyślnie SIGTERM
kill -15 1234               # Jawnie SIGTERM
kill -TERM 1234             # Lub po nazwie

# Force kill (SIGKILL = 9) - ostateczność!
kill -9 1234                # Proces nie może tego zignorować
kill -KILL 1234

# Po nazwie
pkill nginx                 # SIGTERM do wszystkich procesów nginx
pkill -9 nginx              # SIGKILL
killall nginx               # Podobne do pkill

# Wszystkie procesy użytkownika
pkill -u username

# Proces na porcie
lsof -i :8080               # Znajdź proces na porcie
fuser -k 8080/tcp           # Zabij proces na porcie

Najważniejsze sygnały:

Sygnał	Numer	Znaczenie
SIGTERM	15	Graceful shutdown (domyślny)
SIGKILL	9	Natychmiastowe zabicie (nie można zignorować)
SIGHUP	1	Hangup - często reload konfiguracji
SIGINT	2	Interrupt (Ctrl+C)
SIGSTOP	19	Zatrzymaj proces
SIGCONT	18	Wznów zatrzymany proces

Na co zwracają uwagę rekruterzy: "Dlaczego nie zawsze używać kill -9?" - Proces nie ma szansy na cleanup (zamknięcie plików, zwolnienie zasobów, zapisanie stanu).

Co to jest zombie process i jak się go pozbyć?

Odpowiedź w 30 sekund: Zombie to proces, który zakończył działanie, ale jego parent nie odebrał exit code (nie wywołał wait()). Nie zużywa zasobów oprócz wpisu w tabeli procesów. Nie można go zabić - trzeba zabić parenta lub poczekać aż parent wywoła wait().

Odpowiedź w 2 minuty:

Zombie procesy wyglądają specyficznie w systemie - oto jak je zidentyfikować i obsłużyć.

# Znajdowanie zombie
ps aux | grep 'Z'           # Status 'Z' = zombie
ps aux | awk '$8=="Z"'      # Tylko zombie

# Zombie wygląda tak:
# USER  PID  PPID  STAT  COMMAND
# jan   1234 5678  Z     [defunct]

# Sprawdzenie parenta
ps -o ppid= -p 1234         # PPID zombie
ps -p 5678                  # Info o parent

# "Rozwiązania"
# 1. Zabij parent process - zombie znikną (adoptowane przez init)
kill -9 5678

# 2. Jeśli parent to ważny proces - napraw kod
#    Parent musi wywołać wait() lub waitpid()

# 3. Poczekaj - init (PID 1) adoptuje i czyści orphans

Orphan vs Zombie:

• Orphan - parent umarł, proces adoptowany przez init (PID 1)
• Zombie - proces umarł, parent nie odebrał exit status

---

Wyszukiwanie i filtrowanie

Jak wyszukiwać tekst w plikach?

Odpowiedź w 30 sekund: grep to podstawowe narzędzie. grep -r pattern dir/ szuka rekursywnie. grep -i ignoruje wielkość liter. grep -n pokazuje numery linii. grep -v odwraca dopasowanie.

Odpowiedź w 2 minuty:

Grep to najważniejsze narzędzie do wyszukiwania tekstu - oto najczęściej używane opcje i wzorce.

# Podstawowe użycie
grep "ERROR" logfile.txt              # Znajdź linie z ERROR
grep -i "error" logfile.txt           # Case insensitive
grep -n "error" logfile.txt           # Z numerami linii
grep -c "error" logfile.txt           # Tylko liczba dopasowań
grep -v "DEBUG" logfile.txt           # Linie BEZ DEBUG

# Rekursywne szukanie
grep -r "TODO" src/                   # W katalogu src/
grep -rn "TODO" src/                  # Z numerami linii
grep -rl "TODO" src/                  # Tylko nazwy plików

# Regex
grep -E "error|warning" log.txt       # Extended regex (OR)
grep "^Start" log.txt                 # Linie zaczynające się od "Start"
grep "end$" log.txt                   # Linie kończące się na "end"
grep -E "[0-9]{3}" log.txt            # 3 cyfry pod rząd

# Kontekst
grep -A 3 "ERROR" log.txt             # 3 linie po dopasowaniu (After)
grep -B 3 "ERROR" log.txt             # 3 linie przed (Before)
grep -C 3 "ERROR" log.txt             # 3 linie przed i po (Context)

# Z innymi komendami
cat access.log | grep "404"
ps aux | grep nginx | grep -v grep

Jak wyszukiwać pliki?

Odpowiedź w 30 sekund: find to potężne narzędzie do szukania plików. find /path -name "*.log" szuka po nazwie. find . -type f -mtime -7 znajduje pliki zmodyfikowane w ostatnich 7 dniach. locate jest szybsze ale wymaga aktualizacji bazy.

Odpowiedź w 2 minuty:

Find oferuje potężne możliwości wyszukiwania po różnych kryteriach - nazwie, rozmiarze, czasie, uprawnieniach.

# Po nazwie
find /var/log -name "*.log"           # Dokładna nazwa
find . -iname "*.txt"                 # Case insensitive
find . -name "test*"                  # Zaczyna się od "test"

# Po typie
find . -type f                        # Tylko pliki
find . -type d                        # Tylko katalogi
find . -type l                        # Symlinks

# Po rozmiarze
find . -size +100M                    # Większe niż 100MB
find . -size -1k                      # Mniejsze niż 1KB
find . -empty                         # Puste pliki/katalogi

# Po czasie
find . -mtime -7                      # Zmodyfikowane w ostatnich 7 dniach
find . -mtime +30                     # Zmodyfikowane ponad 30 dni temu
find . -mmin -60                      # Zmodyfikowane w ostatniej godzinie
find . -newer reference.txt           # Nowsze niż reference.txt

# Po uprawnieniach
find . -perm 755                      # Dokładnie 755
find . -perm -u+x                     # Executable dla owner

# Wykonanie akcji
find . -name "*.tmp" -delete          # Usuń znalezione
find . -name "*.sh" -exec chmod +x {} \;    # Wykonaj komendę
find . -type f -exec grep -l "TODO" {} \;   # Grep w znalezionych

# Kombinacje
find /var/log -name "*.log" -size +10M -mtime +7
# Logi większe niż 10MB, starsze niż 7 dni

locate vs find:

# locate - szybki (używa bazy danych)
locate nginx.conf
sudo updatedb                 # Aktualizuj bazę locate

# find - wolniejszy ale real-time
find / -name "nginx.conf"

Jak używać pipes i redirection?

Odpowiedź w 30 sekund: Pipe | przekazuje stdout jednej komendy jako stdin następnej. > nadpisuje plik, >> dopisuje. 2> przekierowuje stderr. 2>&1 łączy stderr ze stdout.

Odpowiedź w 2 minuty:

Pipes i redirection to fundament pracy w terminalu - pozwalają łączyć proste komendy w potężne operacje.

# Pipes - łączenie komend
cat file.txt | grep "error" | wc -l
ps aux | grep nginx | awk '{print $2}'
ls -la | sort -k5 -n | tail -10      # 10 największych plików

# Redirection - do pliku
echo "hello" > file.txt              # Nadpisz
echo "world" >> file.txt             # Dopisz
command 2> errors.log                # Tylko stderr do pliku
command > output.log 2>&1            # stdout i stderr do pliku
command &> all.log                   # To samo (bash shortcut)

# Ważne: kolejność ma znaczenie!
command > file 2>&1                  # OK - stderr idzie gdzie stdout
command 2>&1 > file                  # ŹLE - stderr idzie na terminal

# /dev/null - czarna dziura
command > /dev/null                  # Ignoruj stdout
command 2> /dev/null                 # Ignoruj stderr
command &> /dev/null                 # Ignoruj wszystko

# Here document
cat << EOF > config.txt
line 1
line 2
EOF

# Here string
grep "pattern" <<< "text to search"

Typowe kombinacje:

# Logi - ostatnie błędy
tail -f /var/log/syslog | grep -i error

# Top 10 procesów po pamięci
ps aux | sort -k4 -rn | head -10

# Unikalne IP z access loga
cat access.log | awk '{print $1}' | sort | uniq -c | sort -rn

# Znajdź duże pliki i posortuj
find . -type f -exec du -h {} + | sort -rh | head -20

---

Sieć i połączenia

Jak sprawdzić otwarte porty i połączenia?

Odpowiedź w 30 sekund: ss -tulpn lub netstat -tulpn pokazuje listening ports. lsof -i :port pokazuje proces na porcie. nc -zv host port testuje połączenie.

Odpowiedź w 2 minuty:

Do sprawdzania portów i połączeń używamy głównie ss (nowoczesne) lub netstat (klasyczne).

# Listening ports
ss -tulpn                    # Nowoczesne (zastępuje netstat)
netstat -tulpn               # Klasyczne
# -t TCP, -u UDP, -l listening, -p process, -n numeric

# Wszystkie połączenia
ss -tan                      # TCP wszystkie, numeric
ss state established         # Tylko ustanowione

# Proces na porcie
lsof -i :8080                # Co słucha na 8080?
fuser 8080/tcp               # PID procesu na porcie

# Testowanie połączeń
nc -zv localhost 8080        # Test czy port otwarty
telnet localhost 8080        # Interaktywne połączenie
curl -I http://localhost     # HTTP test

# DNS
dig example.com              # DNS lookup
nslookup example.com         # Starszy odpowiednik
host example.com             # Prosty lookup

# Routing i interfejsy
ip addr                      # Interfejsy sieciowe
ip route                     # Tablica routingu
ping -c 4 google.com         # Test connectivity
traceroute google.com        # Śledzenie trasy
mtr google.com               # Kombinacja ping + traceroute

Jak debugować problemy sieciowe?

Odpowiedź w 30 sekund: Sprawdź kolejno: 1) IP i interfejs (ip addr), 2) Gateway (ip route), 3) DNS (dig), 4) Połączenie (ping, curl), 5) Firewall (iptables -L). Użyj tcpdump do analizy pakietów.

Odpowiedź w 2 minuty:

Debugowanie sieci to systematyczne przechodzenie przez warstwy OSI - od interfejsu przez routing po DNS i aplikację.

# 1. Czy mam IP?
ip addr show
ip link show                 # Status interfejsów

# 2. Czy mam routing?
ip route
# default via 192.168.1.1 dev eth0

# 3. Czy DNS działa?
cat /etc/resolv.conf
dig google.com
dig @8.8.8.8 google.com      # Użyj konkretnego DNS

# 4. Czy mogę pingować?
ping -c 4 8.8.8.8            # IP (omija DNS)
ping -c 4 google.com         # Domain (testuje DNS)

# 5. Czy usługa odpowiada?
curl -v http://localhost:8080
telnet localhost 8080

# 6. Firewall?
sudo iptables -L -n          # Lista reguł
sudo ufw status              # Ubuntu firewall

# 7. Analiza pakietów
sudo tcpdump -i eth0 port 80
sudo tcpdump -i any host 192.168.1.1
tcpdump -w capture.pcap      # Zapisz do pliku

Typowe problemy i rozwiązania:

Problem	Diagnoza	Rozwiązanie
Brak IP	ip addr shows no IP	dhclient eth0
Brak gateway	ip route empty	ip route add default via X
DNS nie działa	dig fails	Sprawdź /etc/resolv.conf
Port zamknięty	nc timeout	Sprawdź firewall, usługę
Połączenie timeout	ping ok, curl fail	Sprawdź aplikację, port

---

Bash scripting

Jak napisać podstawowy skrypt bash?

Odpowiedź w 30 sekund: Zacznij od shebang #!/bin/bash. Używaj set -euo pipefail dla bezpieczeństwa. Zmienne: VAR="value", użycie: $VAR lub ${VAR}. Argumenty: $1, $2, $@ (wszystkie), $# (liczba).

Odpowiedź w 2 minuty:

Dobry skrypt bash zaczyna się od shebang i bezpiecznych ustawień - oto podstawowy szablon z najważniejszymi elementami.

#!/bin/bash
set -euo pipefail   # Exit on error, undefined vars, pipe failures

# Zmienne
NAME="Jan"
echo "Hello, $NAME"
echo "Hello, ${NAME}!"   # Bezpieczniejsza forma

# Argumenty
echo "Script name: $0"
echo "First arg: $1"
echo "All args: $@"
echo "Arg count: $#"

# Warunki
if [ "$1" == "hello" ]; then
    echo "Hi there!"
elif [ -z "$1" ]; then
    echo "No argument provided"
else
    echo "Unknown: $1"
fi

# Test operatory
[ -f file.txt ]     # Plik istnieje
[ -d dir/ ]         # Katalog istnieje
[ -z "$VAR" ]       # String pusty
[ -n "$VAR" ]       # String niepusty
[ "$A" == "$B" ]    # Stringi równe
[ "$A" -eq "$B" ]   # Liczby równe
[ "$A" -gt "$B" ]   # A > B (greater than)

# Pętle
for file in *.txt; do
    echo "Processing $file"
done

for i in {1..5}; do
    echo "Number $i"
done

while read -r line; do
    echo "Line: $line"
done < input.txt

# Funkcje
greet() {
    local name="$1"
    echo "Hello, $name"
}
greet "Jan"

# Command substitution
DATE=$(date +%Y-%m-%d)
FILES=$(ls *.txt)

Napisz skrypt do backupu z rotacją

Odpowiedź w 2 minuty:

Oto praktyczny przykład skryptu backupowego z rotacją starych kopii - można go używać w cronie.

#!/bin/bash
set -euo pipefail

# Konfiguracja
BACKUP_DIR="/backups"
SOURCE_DIR="/var/www"
RETENTION_DAYS=7
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_NAME="backup_${DATE}.tar.gz"

# Tworzenie backupu
echo "Starting backup..."
tar -czf "${BACKUP_DIR}/${BACKUP_NAME}" "$SOURCE_DIR"

if [ $? -eq 0 ]; then
    echo "Backup created: ${BACKUP_NAME}"
else
    echo "Backup failed!" >&2
    exit 1
fi

# Rotacja - usuwanie starych backupów
echo "Cleaning old backups..."
find "$BACKUP_DIR" -name "backup_*.tar.gz" -mtime +${RETENTION_DAYS} -delete

# Raport
BACKUP_SIZE=$(du -h "${BACKUP_DIR}/${BACKUP_NAME}" | cut -f1)
TOTAL_BACKUPS=$(ls -1 "${BACKUP_DIR}"/backup_*.tar.gz 2>/dev/null | wc -l)
echo "Backup size: $BACKUP_SIZE"
echo "Total backups: $TOTAL_BACKUPS"

Co znaczy set -euo pipefail?

Odpowiedź w 30 sekund: set -e kończy skrypt przy pierwszym błędzie. set -u traktuje niezdefiniowane zmienne jako błąd. set -o pipefail zwraca błąd jeśli którakolwiek komenda w pipe zwróci błąd, nie tylko ostatnia.

Odpowiedź w 2 minuty:

Każda z tych opcji zabezpiecza skrypt przed innym typem błędu - najlepiej pokazać różnicę na przykładach.

# Bez set -e - skrypt kontynuuje mimo błędów
#!/bin/bash
rm /nonexistent/file     # Błąd, ale idzie dalej
echo "This still runs"   # Niebezpieczne!

# Z set -e - skrypt kończy się przy błędzie
#!/bin/bash
set -e
rm /nonexistent/file     # Błąd
echo "This won't run"    # Skrypt już zakończony

# set -u - niezdefiniowane zmienne to błąd
set -u
echo $UNDEFINED_VAR      # Błąd! (bez -u: pusta wartość)

# set -o pipefail - błąd w pipe
# Bez pipefail:
false | true             # Exit code: 0 (ostatnia komenda)

# Z pipefail:
set -o pipefail
false | true             # Exit code: 1 (pierwsza komenda)

# Typowe bezpieczne rozpoczęcie skryptu
#!/bin/bash
set -euo pipefail
IFS=$'\n\t'              # Bezpieczniejszy IFS

---

Zarządzanie usługami

Jak zarządzać usługami systemowymi?

Odpowiedź w 30 sekund: Systemd jest standardem. systemctl start/stop/restart service kontroluje usługi. systemctl enable/disable zarządza autostartem. systemctl status pokazuje stan. journalctl do logów.

Odpowiedź w 2 minuty:

Systemd to standardowy system zarządzania usługami w nowoczesnych dystrybucjach - oto podstawowe komendy.

# Kontrola usług
systemctl start nginx      # Uruchom
systemctl stop nginx       # Zatrzymaj
systemctl restart nginx    # Restart
systemctl reload nginx     # Reload konfiguracji (bez restartu)

# Status
systemctl status nginx     # Szczegółowy status
systemctl is-active nginx  # Tylko active/inactive
systemctl is-enabled nginx # Czy autostart włączony

# Autostart
systemctl enable nginx     # Włącz autostart
systemctl disable nginx    # Wyłącz autostart
systemctl enable --now nginx  # Enable + start

# Lista usług
systemctl list-units --type=service              # Aktywne
systemctl list-units --type=service --all        # Wszystkie
systemctl list-unit-files --type=service         # Pliki jednostek

# Logi (journalctl)
journalctl -u nginx                # Logi nginx
journalctl -u nginx -f             # Follow (jak tail -f)
journalctl -u nginx --since today  # Od dzisiaj
journalctl -u nginx -n 100         # Ostatnie 100 linii
journalctl -u nginx -p err         # Tylko błędy

# Tworzenie własnej usługi
# /etc/systemd/system/myapp.service
[Unit]
Description=My Application
After=network.target

[Service]
Type=simple
User=www-data
WorkingDirectory=/var/www/myapp
ExecStart=/usr/bin/node server.js
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

# Po utworzeniu
systemctl daemon-reload
systemctl enable myapp
systemctl start myapp

---

Dyski i pamięć

Jak sprawdzić wykorzystanie dysku i pamięci?

Odpowiedź w 30 sekund: df -h pokazuje wykorzystanie systemów plików. du -sh folder/ rozmiar katalogu. free -h pokazuje pamięć RAM i swap. top/htop dla live view.

Odpowiedź w 2 minuty:

Monitorowanie zasobów dyskowych i pamięci to kluczowa część administracji - oto najważniejsze komendy.

# Dyski - systemy plików
df -h                       # Human-readable
df -h /                     # Konkretny filesystem
df -i                       # Inodes (może się skończyć!)

# Rozmiar katalogów
du -sh /var/log             # Rozmiar katalogu
du -sh /var/*               # Rozmiar podkatalogów
du -h --max-depth=1 /var    # Jeden poziom głębokości
du -sh * | sort -rh | head  # Top 10 największych

# Znajdź duże pliki
find / -type f -size +100M -exec ls -lh {} \;
ncdu /                      # Interaktywny (jeśli zainstalowany)

# Pamięć RAM
free -h                     # Human-readable
free -m                     # W MB
# Ważne: "available" nie "free" - to rzeczywista dostępna pamięć

# Szczegóły pamięci
cat /proc/meminfo
vmstat 1                    # Live stats co sekundę

Interpretacja free:

              total        used        free      shared  buff/cache   available
Mem:           16Gi       4.2Gi       1.1Gi       312Mi        10Gi        11Gi
Swap:          8.0Gi          0B       8.0Gi

• available (11Gi) - tyle pamięci może dostać nowy program
• buff/cache (10Gi) - może być zwolnione w razie potrzeby
• free (1.1Gi) - naprawdę nieużywane (marnowane!)

Jak zamontować i odmontować system plików?

Odpowiedź w 30 sekund: mount /dev/sdb1 /mnt/data montuje urządzenie. umount /mnt/data odmontowuje. /etc/fstab dla permanentnego montowania. lsblk pokazuje urządzenia blokowe.

Odpowiedź w 2 minuty:

Montowanie systemów plików wymaga zrozumienia urządzeń blokowych i punktów montowania - oto praktyczne przykłady.

# Lista urządzeń
lsblk                       # Urządzenia blokowe
fdisk -l                    # Partycje
blkid                       # UUID urządzeń

# Montowanie
mount /dev/sdb1 /mnt/usb                    # Podstawowe
mount -t ext4 /dev/sdb1 /mnt/data           # Z typem FS
mount -o ro /dev/sdb1 /mnt/data             # Read-only
mount -o remount,rw /mnt/data               # Przemontuj jako rw

# Odmontowanie
umount /mnt/usb
umount -l /mnt/usb          # Lazy unmount (jeśli busy)
fuser -m /mnt/usb           # Kto używa mount point?

# /etc/fstab - permanentne montowanie
# Format: <device> <mount point> <type> <options> <dump> <pass>
UUID=abc123 /data ext4 defaults 0 2
/dev/sdb1   /backup ext4 defaults,noatime 0 2

# Po edycji fstab
mount -a                    # Zamontuj wszystko z fstab
systemctl daemon-reload     # Systemd reload

# NFS mount
mount -t nfs server:/share /mnt/nfs
# W fstab:
server:/share /mnt/nfs nfs defaults 0 0

---

Zobacz też

• Kompletny Przewodnik - Rozmowa DevOps Engineer - pełny przewodnik przygotowania do rozmowy DevOps
• Docker - Pytania Rekrutacyjne - 42 pytania z odpowiedziami o konteneryzacji
• Wzorce i Architektura Backend - architektura i mikrousługi

---

Ten artykuł jest częścią serii przygotowującej do rozmów rekrutacyjnych na stanowisko DevOps Engineer. Opanuj Linux i inne technologie DevOps z naszymi fiszkami do nauki.