# Podstawowe komendy użytkowe # Poruszanie się w CLI / BASH / SSH **Wprowadzenie:** W systemach Linux/Unix praca odbywa się głównie w środowisku tekstowym (terminalu). Zrozumienie, jak nawigować po systemie plików, jest fundamentem pracy administracyjnej. Poniżej przedstawiamy podstawowe i zaawansowane komendy do poruszania się po strukturze katalogów. ## 1. Komenda `pwd` – gdzie jestem? ``` pwd ``` Polecenie `pwd` (print working directory) wyświetla pełną, bezwzględną ścieżkę do katalogu, w którym aktualnie się znajdujemy. Jest to podstawowa komenda pozwalająca na orientację w strukturze katalogów systemu. **Przykład:** ``` $ pwd /home/admin/projekty ``` ## 2. Komenda `ls` – co jest w katalogu? ``` ls ``` Komenda `ls` (list) wyświetla listę plików i katalogów w bieżącym katalogu. To podstawowe narzędzie do przeglądania zawartości systemu plików. **Najczęściej używane opcje:** ``` ls -l ``` Wyświetla szczegółowe informacje o plikach: uprawnienia, właściciela, grupę, rozmiar, datę modyfikacji i nazwę. ``` ls -a ``` Pokazuje również pliki ukryte (których nazwa zaczyna się od kropki `.`). ``` ls -lh ``` Łączy opcję `-l` z `-h` (human-readable), wyświetlając rozmiary plików w formacie czytelnym dla człowieka (KB, MB, GB). ``` ls -lah ``` Połączenie wszystkich trzech opcji – szczegółowy widok ze wszystkimi plikami (w tym ukrytymi) i czytelnymi rozmiarami. ``` ls -lt ``` Sortuje pliki według daty modyfikacji (najnowsze na górze). ``` ls -lS ``` Sortuje pliki według rozmiaru (największe na górze). ## 3. Komenda `cd` – poruszanie się między katalogami ``` cd /ścieżka/do/katalogu ``` Polecenie `cd` (change directory) zmienia aktualny katalog roboczy na wskazany. **Najważniejsze sposoby użycia:** ``` cd ~ ``` Przechodzi do katalogu domowego aktualnego użytkownika (np. `/home/admin`). ``` cd .. ``` Przechodzi do katalogu nadrzędnego (rodzica) względem bieżącego katalogu. ``` cd - ``` Wraca do poprzedniego katalogu, w którym byliśmy przed ostatnią zmianą. ``` cd ./katalog ``` Wchodzi do podkatalogu `katalog` znajdującego się w bieżącej lokalizacji. ``` cd / ``` Przechodzi do katalogu głównego systemu (root directory). ## 4. Zrozumienie kropek w ścieżkach - `.` – oznacza bieżący katalog - `..` – oznacza katalog nadrzędny (jeden poziom wyżej) - `~` – oznacza katalog domowy użytkownika **Przykłady:** ``` cd ../dokumenty # przejdź poziom wyżej, potem do katalogu dokumenty cd ~/projekty # przejdź do katalogu projekty w katalogu domowym cd ../../tmp # dwa poziomy wyżej, potem do katalogu tmp ``` ## 5. Komenda `readlink` – rozwijanie ścieżek ``` readlink -f nazwa_pliku ``` Polecenie `readlink` z opcją `-f` wyświetla pełną, absolutną ścieżkę do pliku lub katalogu, rozwijając wszystkie linki symboliczne. Przydatne, gdy pracujemy z skrótami i chcemy poznać rzeczywistą lokalizację pliku. ## 6. Komenda `tree` – drzewo katalogów ``` tree ``` Wyświetla strukturę katalogów w formie drzewa (jeśli narzędzie jest zainstalowane). Pozwala na szybką wizualizację zagnieżdżenia katalogów. ``` tree -L 2 ``` Ogranicza głębokość wyświetlania do 2 poziomów. ## Podsumowanie praktyczne: ``` # Sprawdź, gdzie jesteś pwd # Wyświetl pliki w bieżącym katalogu ze szczegółami ls -lah # Przejdź do katalogu projekty cd ~/projekty # Wróć do poprzedniego katalogu cd - # Przejdź poziom wyżej cd .. # Wyświetl pełną ścieżkę do pliku readlink -f config.conf ``` # Obsługa przegladania plików : CAT, HEAD, TAIL **1. `cat` – wyświetlanie zawartości pliku** ```bash cat plik.txt ``` Wyświetla całą zawartość pliku `plik.txt` na standardowe wyjście (terminal). Używany też do łączenia plików i przekierowania ich zawartości. **Przykład łączenia plików i zapisu do nowego pliku:** ```bash cat plik1.txt plik2.txt > polaczony_plik.txt ``` --- **2. `head` – wyświetlanie początkowych linii pliku** ```bash head plik.txt ``` Wyświetla domyślnie pierwsze 10 linii pliku `plik.txt`. **Zmiana liczby wyświetlanych linii:** ```bash head -n 20 plik.txt ``` Wyświetla pierwsze 20 linii pliku. --- **3. `tail` – wyświetlanie końcowych linii pliku** ```bash tail plik.txt ``` Wyświetla ostatnie 10 linii pliku. **Śledzenie zmieniającego się pliku (np. pliku logu):** ```bash tail -f /var/log/syslog ``` Na żywo wyświetla kolejne dodawane linie do pliku (przydatne przy monitorowaniu logów). **Wyświetlenie określonej liczby ostatnich linii:** ```bash tail -n 50 plik.log ``` Ostatnie 50 linii pliku `plik.log`. --- **Praktyczne zastosowania połączeń narzędzi** Wyświetlenie ostatnich 100 linii z monitorowaniem na żywo (analogicznie jak `tail -f`): ```bash tail -n 100 -f /var/log/system.log ``` Wyświetlenie pierwszych 50 linii wyszukanego pliku, np. połączone z `grep`: ```bash grep "error" /var/log/syslog | head -n 50 ``` **Parametry komendy ich wykorzystanie:** ```bash -n (–lines=ILE) ``` Opcja pozwala określić liczbę wyświetlanych linii od końca pliku. ```bash tail -n 20 plik.txt ``` Wyświetli ostatnie 20 linii pliku `plik.txt`. Domyślnie jest to 10 linii, jeśli nie podamy opcji.

-f (–follow\[=OPTION\])

Opcja stosowana do śledzenia pliku na bieżąco. Wypisuje najpierw ostatnie linie, potem wyświetla na żywo nowe linie dopisywane do pliku. ``` tail -f /var/log/syslog ``` Przydatne do monitorowania plików logów w czasie rzeczywistym.

-c (–bytes=ILE)

Wypisuje z pliku zamiast linii określoną liczbę ostatnich bajtów. ``` tail -c 100 plik.txt ``` Wyświetla ostatnie 100 bajtów pliku. Jeden bajt to jeden znak lub nowa linia.

-q (–quiet, –silent)

Przy wyświetlaniu wielu plików nie wyświetla ich nazw nad zawartością. ``` tail -q -n 10 plik1.txt plik2.txt ```

-v (–verbose)

Zawsze wyświetla nazwę pliku nad jego zawartością nawet przy jednym pliku. ##### Inne przydatne opcje - `--retry` – wielokrotna próba otwarcia pliku, przydatne w monitorowaniu. - `--pid=PID` – automatyczne zatrzymanie działania gdy zakończy się proces o podanym PID. - `-s N` – opóźnienie między odczytami gdy używamy `-f`, domyślnie 1 sekunda. **Przykład kompleksowy:** ```bash tail -n 50 -f -s 2 /var/log/app.log ``` Wyświetla ostatnie 50 linii pliku `app.log`, a następnie śledzi plik, odświeżając co 2 sekundy. **Użycie w potoku i z filtrowaniem:** ```bash tail -f /var/log/app.log | grep --color "ERROR" ``` Monitoruje na żywo plik logów i podświetla słowo "ERROR". # Obsługa komendy "ps" - Proces Status Komenda `ps` (process status) jest jednym z fundamentalnych narzędzi administracyjnych do monitorowania procesów w systemach Unix/Linux. Pozwala na identyfikację, śledzenie i diagnostykę działających aplikacji. W pracy z serwerami (szczególnie przy Proxmox, FreeBSD czy administracji gra serwerów MT2) niezbędna jest umiejętność interpretacji wyniku `ps`. ## Podstawowe użycie `ps` ```bash ps ``` Wyświetla procesy bieżącego użytkownika w aktualnej sesji terminalowej. Bardzo podstawowe, rzadko wystarczające dla administratora. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/jVDimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/jVDimage.png)

Przeglądanie wszystkich procesów z pełnymi informacjami

```bash ps aux ``` To najczęstsze polecenie dla administratorów. Wyświetla wszystkie procesy w systemie (`a` – wszystkie, `u` – szczegółowy format, `x` – procesy bez terminala). Kolumny oznaczają: USER (właściciel), PID (ID procesu), %CPU (procent CPU), %MEM (procent pamięci), VSZ (rozmiar wirtualny), RSS (resident set size – fizyczna pamięć), TTY (terminal), STAT (status), START (czas startu), TIME (czas CPU), COMMAND (polecenie). [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/03limage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/03limage.png)

Alternatywny format wyświetlania

``` ps -ef ``` Inny sposób na wyświetlenie wszystkich procesów, bardziej zbliżony do formatu Linuksa (zamiast BSD-owego `aux`). PPID (ID procesu nadrzędnego) jest tu bardziej widoczne. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/7f1image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/7f1image.png)

Filtrowanie procesów konkretnego użytkownika

```bash ps -u 'nazwa_usera' ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/t3ximage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/t3ximage.png) Pokazuje tylko procesy należące do użytkownika `admin`. Przydatne gdy szukamy co robi konkretny użytkownik. ``` ps -u root,www-data ``` Procesy należące do wielu użytkowników naraz.

Wyszukiwanie konkretnych procesów

```bash ps aux | grep 'nazwa procesu' ``` Wyszukuje procesy związane z danym procesem [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/3t4image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/3t4image.png) ``` ps aux | grep -v grep ```
[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/BTgimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/BTgimage.png) [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/SwQimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/SwQimage.png)
Eliminuje z wyniku samo polecenie grep (często pojawia się w wynikach). ```bash pgrep -lf 'nazwa_procesu' ``` Szuka procesu po pełnej nazwie polecenia (bardziej precyzyjne niż grep). [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/hnhimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/hnhimage.png)

Sortowanie procesów

```bash ps aux --sort=-%cpu | head -20 ``` Wyświetla 20 procesów zużywających najwięcej CPU, posortowanych malejąco. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/nizimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/nizimage.png) ```bash ps aux --sort=-%mem | head -20 ``` Wyświetla 20 procesów zużywających najwięcej pamięci RAM. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/wxZimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/wxZimage.png) ```bash ps aux --sort=-vsz ``` Sortuje po wirtualnym rozmiarze pamięci. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/tx6image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/tx6image.png) ```bash ps aux | wc -l ``` Liczy całkowitą liczbę procesów w systemie. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/GBUimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/GBUimage.png)

Monitorowanie procesów hiearchy – relacje między procesami

```bash ps auxf ``` Wyświetla procesy w formie drzewa, pokazując które procesy są "dziećmi" innych procesów. ```bash pstree -p user ``` Pokazuje drzewo procesów danego użytkownika z PID.

Monitorowanie procesów w czasie – status i sygnały

```bash ps aux | grep -E 'S|Ss|R|T' ``` Statusy procesów: S (sleeping – uśpiony), Ss (session leader), R (running – działający), T (stopped – zatrzymany), Z (zombie). **Zombie procesy – problem w naszych czatach:** ``` ps aux | grep Z ``` Wyszukuje procesy zombie (znane z naszych dzienników z serwera MT2SRV, gdzie czasami pojawiały się procesy nieusunięte prawidłowo).

Wyświetlanie konkretnych kolumn

``` ps -o pid,user,%cpu,%mem,comm ``` Wyświetla tylko wybrane kolumny: PID, użytkownik, CPU, pamięć i nazwa polecenia. ``` ps aux -o pid,ppid,user,comm ``` PID, PPID (proces nadrzędny), użytkownik i nazwa polecenia – przydatne do zrozumienia zależności między procesami.

Monitorowanie procesów w pętli rzeczywistej – ale nie programem top

``` while true; do ps aux | grep game; sleep 2; done ``` Monitoruje konkretny proces co 2 sekundy. Przydatne gdy chcemy obserwować czy proces się restartuje.

Specjalistyczne zapytania

```bash ps aux | awk '$3 > 10 { print $0 }' ``` Wyświetla procesy zużywające więcej niż 10% CPU. ```bash ps aux | awk '$4 > 20 { print $2, $4, $11 }' ``` Wyświetla procesy zużywające więcej niż 20% pamięci (PID, %MEM, komenda).

Praktyczne scenariusze

```bash # Sprawdzenie stanu serwera gry MT2SRV ps aux | grep -E 'game|db|auth' ``` Szukamy trzech kluczowych procesów serwera. ```bash # Znalezienie procesu zużywającego zasoby ps aux --sort=-%mem | head -1 ``` Proces zużywający największą pamięci. ```bash # Znalezienie i zabicie zombie procesów ps aux | grep Z | awk '{print $2}' | xargs kill -9 ``` Ostrożnie! Usuwa procesy zombie (choć powinny być usunięte automatycznie). # Monitorowanie procesów na żywo: top i htop `top` to standardowe narzędzie do monitorowania systemu w czasie rzeczywistym. `htop` to nowoczesna, bardziej przyjazna alternatywa z kolorowym interfejsem i lepszą nawigacją.

Komenda `top` – klasyczne monitorowanie

```bash top ``` Uruchamia interaktywny monitor systemowy. Domyślnie sortuje procesy wg CPU. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/C23image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/C23image.png) ## Klawisze i komendy w `top` `q` – wyjście z top `h` – pomoc `M` – sortuj wg pamięci (zamiast CPU) `P` – sortuj wg CPU (domyślnie) `T` – sortuj wg czasu uruchomienia `u` – pokaż procesy konkretnego użytkownika `k` – zabij proces (przydatne gdy proces "szaleje") `r` – zmień priorytet procesu (nice value) ## Uruchamianie `top` z opcjami ```bash top -u 'nazwa_usera' ``` Pokazuje tylko procesy użytkownika `admin`. ```bash top -p 1234,5678 ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/BQOimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/BQOimage.png) Monitoruje konkretne procesy po PID. ```bash top -n 1 ``` Pokazuje tylko jeden snapshot (raz odświeża) i wyłącza się (przydatne w skryptach). ```bash top -o %MEM ``` Sortuj wg zużycia pamięci przy uruchomieniu. **Praktyczne zastosowanie z naszych czatów:** ```bash top -p $(pgrep -f game | tr '\n' ',')) ``` Monitoruj procesy serwera gry (game, db, auth). ## Komenda `htop` – ulepszona wersja ```bash htop ``` Uruchamia interaktywny monitor z kolorowym interfejsem. ## Zalety `htop` nad `top` - Kolorowy, bardziej czytelny interfejs - Możliwość zaznaczania wielu procesów naraz - Łatwiejsze filtrowanie i wyszukiwanie - Łatwiejsze zabijanie procesów bez znajomości ich PID - Drzewo procesów (Forest View) ## Klawisze w `htop` `q` – wyjście `F3` – wyszukaj proces `F4` – filtruj (np. po użytkowniku) `F5` – widok drzewa procesów `F6` – zmień kolumnę sortowania `F9` – wyślij sygnał do procesu (kill, SIGSTOP, etc.) `u` – pokaż procesy użytkownika ## Porównanie `top` vs `htop`
Cecha`top``htop`
DostępnośćZawsze zainstalowanyWymaga instalacji
InterfejsTekstowyKolorowy, przyjazny
WyszukiwanieTrudneŁatwe (F3)
Zabijanie procesówWymaga PIDZaznacz i F9
Drzewo procesówBrakF5

Wykorzystanie htop

```bash htop ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/q1Ximage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/q1Ximage.png) Uruchom htop, press F4 by filtrować procesy, wpisz np "docker". [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/uXIimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/uXIimage.png) **Zabij proces szalejący (zużywający 100% CPU):** ```bash top ``` Znajdź proces, naciśnij `k`, wpisz sygnał (9 dla SIGKILL). **Monitoruj konkretny proces i jego dzieci (fork):** ```bash htop -p [PID] ``` Lub w htop: F5 dla Forest View, wyszukaj proces. # Zaawansowane wyszukiwanie z użyciem find i grep **1. `find` – wyszukiwanie plików i katalogów** ``` find /ścieżka -iname "wzorzec" ``` Szukamy plików lub katalogów według nazwy ze **zignorowaniem wielkości liter** (opcja `-iname`). Przykład: `find /var/log -iname "*.LOG"` znajdzie wszystkie pliki z rozszerzeniem .log lub .LOG. ``` find . -type f ``` Szukamy wyłącznie zwykłych plików w bieżącym katalogu i jego podkatalogach. (`-type f` = file) ``` find . -type d ``` Szukamy tylko katalogów. (`-type d` = directory) ``` find /home -mtime -7 ``` Wyszukujemy pliki zmodyfikowane w ciągu ostatnich 7 dni. (`-mtime` to czas modyfikacji, `-7` oznacza mniej niż 7 dni temu) ``` find /var/www -size +10M ``` Wyszukujemy pliki większe niż 10 megabajtów. (`+10M` oznacza większe niż 10MB) **Co oznaczają opcje:** - `-iname` – wyszukiwanie nazwy pliku bez zwracania uwagi na wielkość liter. - `-name` – wyszukiwanie nazwy pliku uwzględnia wielkość liter. - `-type f/d/l` – filtr według typu: *f* = plik zwykły, *d* = katalog, *l* = link symboliczny. - `-mtime N` – pliki modyfikowane dokładnie N dni temu; `-mtime -N` – zmodyfikowane w ciągu ostatnich N dni. - `-size +N` – pliki większe niż N jednostek (k, M, G). --- **2. `grep` – wyszukiwanie tekstu wewnątrz plików lub strumieni danych** ``` grep "wzorzec" plik.txt ``` Wyszukuje linie zawierające `wzorzec` w podanym pliku. ``` grep -i "blad" plik.txt ``` Ignoruje wielkość liter, znajdzie "blad", "Blad", "BLAD" itd. ``` grep -r "error" /var/log ``` Rekurencyjnie wyszukuje słowo "error" we wszystkich plikach w katalogu /var/log. ``` grep -n "start" plik.txt ``` Wyświetla numer linii, w której znaleziono dopasowanie. ``` grep -c "fail" plik.txt ``` Liczy liczbę linii, które zawierają "fail". ``` grep -v "warning" plik.txt ``` Wyświetla linie, które *nie* zawierają słowa "warning". ``` grep -l "TODO" *.c ``` Wyświetla tylko nazwy plików z rozszerzeniem .c, w których znaleziono słowo "TODO". **Opisy opcji:** - `-i` – ignoruj wielkość liter; - `-r` – rekurencyjne przeszukiwanie katalogów; - `-n` – pokazywanie numerów linii; - `-c` – liczenie wystąpień; - `-v` – negacja wzorca (linia nie zawiera wzorca); - `-l` – pokazuje tylko nazwy plików z dopasowaniem. --- **3. Łączenie `find` z `grep` – wyszukiwanie wzorców tekstowych w określonych plikach** ``` find /var/www -type f -name "*.php" -exec grep -l "mysqli_connect" {} \; ``` Znajduje wszystkie pliki .php w katalogu /var/www, które zawierają tekst "mysqli\_connect". ``` find /var/www -type f -iname "*.conf" -exec grep -iH "server" {} \; ``` Znajduje pliki konfiguracyjne (bez zwracania uwagi na wielkość liter w nazwie) zawierające słowo "server" (ignorując wielkość liter, pokazując nazwy plików i linie). ``` find . -iname "test*" -print0 | xargs -0 grep -l "error" ``` Wyszukuje pliki zaczynające się na "test" i sprawdza, czy zawierają słowo "error". Bezpieczne dla nazw z odstępami dzięki `-print0` i `xargs -0`. --- **Praktyczne wskazówki** - Używaj `-iname` w find, jeśli nie jesteś pewien wielkości liter w nazwach plików. - Łącz `find` z `grep` przy pomocy `-exec` lub `xargs`, aby wyszukiwać w treści plików wybrane wzorce. - Opcje `grep` `-r` i `--include` pozwalają filtrować rekurencyjne wyszukiwania wg typu plików. - Przetestuj zapytania na mniejszych katalogach dla sprawdzenia wyników przed uruchomieniem na dużych strukturach. --- **Podsumowanie** `find` i `grep` to podstawowe, lecz bardzo potężne narzędzia do wyszukiwania plików i danych w nich zawartych, ich właściwe stosowanie znacząco ułatwia administrowanie systemami i skryptowanie operacji. # Obsługa dysków i systemów plików: df, du, lsblk, lscsi Zarządzanie dyskami i miejscem na nich to kluczowa część administracji systemów. W serwerach (szczególnie Proxmox, FreeBSD czy serwery gier) ważne jest monitorowanie pojemności dysków i szybkie diagnozowanie problemów z miejscem na dysku. Gdy dysk się zapełni, serwis przestaje działać – stąd konieczność bieżącego monitorowania i konserwacji.

Komenda `df` – informacje o systemach plików

```bash df ```

Wyświetla użycie dysku dla wszystkich zamontowanych systemów plików (domyślnie w blokach 1K). Jest to podstawowe narzędzie do szybkiego sprawdzenia "ile miejsca zostało".

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/WAAimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/WAAimage.png) ```bash df -h ```

Format czytelny (B, KB, MB, GB) – najczęstszy sposób użycia. Zamiast liczb takich jak 15360000 zobaczymy 15G.

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/ROQimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/ROQimage.png) ```bash df -H ```

Format dziesiętny (1000 zamiast 1024 jako podstawa) – dla jednostek SI. Niektórzy wolą taki zapis.

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/zJnimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/zJnimage.png) ```bash df -T ```

Dodaje kolumnę z typem systemu plików (ext4, xfs, btrfs, zfs, ntfs, etc.). Przydatne gdy zarządzasz różnymi typami systemów plików.

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/7NBimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/7NBimage.png) ```bash df -i ```

Wyświetla inode'y zamiast bloków. Ważne: można mieć wolne miejsce, ale brak inode'ów (gdy mamy miliony małych plików). System wtedy nie pozwoli tworzyć nowych plików mimo wolnego miejsca!

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/eh7image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/eh7image.png)

**Praktyczne kombinacje:**

```bash df -Th ```

Typ systemu plików i format czytelny – najbardziej praktyczna forma dla administratorów.

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/7NBimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/7NBimage.png) ```bash df -h | grep -v tmpfs ```

Ukryj tymczasowe systemy plików tmpfs, devtmpfs (często nieistotne).

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/KU1image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/KU1image.png) ```bash df -h | awk '$5 > 80 {print $0}' ``` Pokaż tylko dyski zapełnione powyżej 80% (kolumna 5 to procent użycia). [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/4y2image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/4y2image.png) ```bash df -hT | sort -k6 -rn ```

Posortuj dyski wg procentu zajęcia miejsca (kolumna 6) malejąco – szybko znajdziesz problematyczne dyski.

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/kMQimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/kMQimage.png) ##### Komenda `du` – rozmiar katalogów i plików `du` (disk usage) pokazuje ile miejsca zajmują poszczególne katalogi i pliki. Jest niezbędne gdy `df` pokazuje że dysk jest pełny, a potrzebujemy znaleźć które katalogi lub pliki odpowiadają za ten stan. ```bash du ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/03cimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/03cimage.png)

Domyślnie wyświetla rozmiary wszystkich podkatalogów rekurencyjnie (może wypisać tysiące linii!).

``` du -h ```

Format czytelny (KB, MB, GB).

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/mNZimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/mNZimage.png) ``` du -sh katalog/ ```

Podsumowanie (-s, summary) rozmiaru katalogu w czytelnym formacie.

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/AX4image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/AX4image.png)

Wszystkie pliki i katalogi (-a, all) z rozmiarami – pokaże też pojedyncze pliki, nie tylko katalogi.

```bash du -d 1 -h /var ```

Ograniczenie głębokości (-d 1) do jednego poziomu – nie wchodzi głębiej w strukturę.

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/ppximage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/ppximage.png)

**Znalezienie największych katalogów i plików:**

```bash du -ah /var | sort -rh | head -20 ```

20 największych plików i podkatalogów w /var (sortuj malejąco wg rozmiaru czytelnego dla człowieka).

```bash du -sh /* 2>/dev/null | sort -rh ``` Sprawdź rozmiar wszystkich głównych katalogów systemu (/, /home, /var, /usr itd), ignoruj błędy dostępu. ``` find /var -type f -size +100M -exec ls -lh {} \; | awk '{print $5, $9}' | sort -rh ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/PGlimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/PGlimage.png) Znajdź wszystkie pliki większe niż 100MB. Przydatne gdy szukasz co zabiera miejsce. ```bash find /var/log -type f -size +1G ``` Znajdź pliki logów większe niż 1GB – często to one zapełniają dysk. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/4gEimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/4gEimage.png) **Praktyczne scenariusze z doświadczeń sysadmina:** ```bash # Dysk pełny na serwerze – diagnoza krok po kroku df -h # Sprawdź który dysk jest pełny du -sh /* | sort -rh # Szukaj dużych katalogów głównych du -sh /var/* | sort -rh # Zagłębienie w /var du -sh /var/log/* | sort -rh # Sprawdź logi ```

Sprawdź rozmiar bazy danych

```bash du -sh /var/lib/mysql du -sh /var/lib/postgresql ```

Sprawdź cache, tymczasowe pliki

```bash du -sh /tmp /var/tmp /var/cache ```

Komenda `lsblk` – lista urządzeń blokowych

**Wprowadzenie:** `lsblk` wyświetla strukturę dysków twardych, partycji, wolumenów logicznych (LVM) oraz punktów montowania. Niezastąpione gdy chcesz szybko zobaczyć "co jest podpięte i gdzie". ```bash lsblk ``` Wyświetla wszystkie urządzenia blokowe w formie drzewa. Idealnie pokazuje relacje między dyskami, partycjami i punktami montowania. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/c3Oimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/c3Oimage.png) ```bash lsblk -f ``` Dodatkowo pokazuje systemy plików, UUID, etykiety (labels) i procent użycia. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/eHgimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/eHgimage.png) ```bash lsblk -o NAME,SIZE,TYPE,MOUNTPOINT,FSTYPE ```

Wybrane kolumny – dostosuj wyświetlanie do swoich potrzeb.

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/1Ftimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/1Ftimage.png) ```bash lsblk -p ```

Pokazuje pełne ścieżki urządzeń (np. /dev/sda zamiast sda).

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/sWIimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/sWIimage.png) ##### Komenda `lscsi` – lista urządzeń SCSI/SATA ```bash lscsi ```

Wyświetla listę podłączonych urządzeń SCSI/SATA. Przydatne do weryfikacji że wszystkie dyski fizyczne są widoczne w systemie.

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/xTQimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/xTQimage.png) ``` lscsi -s ```

Dodaje rozmiar dysków.

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/F9cimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/F9cimage.png) ##### Monitorowanie I/O dysku w czasie rzeczywistym ```bash iostat -xz 1 ```

Monitoruj operacje I/O na dyskach co sekundę (wymaga pakietu `sysstat`). Szukaj kolumny %util > 80% – oznacza mocne obciążenie dysku.

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/Arlimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/Arlimage.png) ```bash iotop ```

Interaktywne narzędzie pokazujące które procesy generują najwięcej operacji I/O (wymaga instalacji i uprawnień root).

[![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/HGXimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/HGXimage.png) ```bash watch -n 1 'df -h | grep -v tmpfs' ``` Monitoruj zmiany w zajęciu dysku co sekundę (przydatne gdy coś szybko zabiera miejsce). ##### Diagnostyka problemów z dyskiem – praktyczne scenariusze **Problem: Dysk nagle zapełniony** ```bash # Krok 1: Sprawdź który system plików df -h # Krok 2: Szukaj dużych katalogów (zacznij od głównych) du -sh /* 2>/dev/null | sort -rh | head -10 # Krok 3: Zagłębienie (np. jeśli /var jest duży) du -sh /var/* | sort -rh | head -10 # Krok 4: Sprawdź logi du -sh /var/log/* find /var/log -type f -size +500M -exec ls -lh {} \; # Krok 5: Sprawdź czy nie ma usuniętych plików nadal otwartych lsof +L1 | grep deleted ``` **Problem: Brak miejsca mimo że pliki nie zajmują tyle** ```bash # Sprawdź inode'y (mogą się skończyć przy wielu małych plikach) df -i # Jeśli inode'y na wyczerpaniu, znajdź katalogi z wieloma plikami find / -xdev -printf '%h\n' | sort | uniq -c | sort -rn | head -20 ``` **Problem: Serwer gry MT2SRV – logi zapełniają dysk** ```bash # Sprawdź rozmiar logów gry du -sh /path/to/game/log/* # Usuń stare logi (ostrożnie!) find /path/to/game/log -name "*.log" -mtime +7 -delete # Skompresuj duże logi zamiast usuwać find /path/to/game/log -name "*.log" -size +100M -exec gzip {} \; ``` **Czyszczenie dysku – bezpieczne metody:** ```bash # Wyczyść cache pakietów (Debian/Ubuntu) apt clean apt autoclean # Wyczyść cache pakietów (RedHat/CentOS) yum clean all # Usuń stare kernele (Ubuntu - ostożnie!) apt autoremove --purge # Wyczyść dzienniki systemd starsze niż 7 dni journalctl --vacuum-time=7d # Wyczyść pliki tymczasowe starsze niż 10 dni find /tmp -type f -mtime +10 -delete ```

Monitorowanie trendu zajęcia dysku

```bash # Zapisz snapshot dziennie df -h > /var/log/disk_usage_$(date +%Y%m%d).txt # Porównaj z wczoraj diff /var/log/disk_usage_20251122.txt /var/log/disk_usage_20251123.txt ``` ```bash # Prosty skrypt alertu gdy dysk > 90% #!/bin/bash USAGE=$(df -h / | awk 'NR==2 {print $5}' | tr -d '%') if [ $USAGE -gt 90 ]; then echo "ALERT: Dysk zapełniony w $USAGE%" | mail -s "Disk Alert" admin@example.com fi ```

Sprawdzanie stanu zdrowia dysku (S.M.A.R.T.) (wymaga pakietu `smartmontools`).

```bash smartctl -a /dev/sda ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/XR7image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/XR7image.png)

Wyświetla szczegółowe informacje o stanie dysku z S.M.A.R.T.

```bash smartctl -H /dev/sda ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/cL1image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/cL1image.png)

Szybki test zdrowia dysku (PASSED/FAILED).

##### LVM, RAID i ZFS

**Dla systemów z LVM:**

```bash lvs # Lista logical volumes pvs # Lista physical volumes vgs # Lista volume groups lvdisplay # Szczegóły LV ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/ebUimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/ebUimage.png)

**Dla systemów z RAID:**

```bash cat /proc/mdstat # Status software RAID mdadm --detail /dev/md0 # Szczegóły RAID array ```

**Dla systemów z ZFS (FreeBSD, Linux z ZFS):**

```bash zpool list # Lista pool'i ZFS zpool status # Status pool'i zfs list # Lista systemów plików ZFS zfs get all # Wszystkie właściwości ```

Podsumowanie praktycznych komend

```bash # Quick check – co się dzieje z dyskami df -Th du -sh /* | sort -rh | head -10 lsblk -f # Deep dive – znajdź największe pliki find / -type f -size +1G -exec ls -lh {} \; 2>/dev/null # Monitoring w czasie rzeczywistym watch -n 2 'df -h; echo ""; du -sh /var/log /var/cache /tmp' # Diagnoza performance iostat -xz 2 5 iotop -o # tylko aktywne procesy I/O ``` # Linki symboliczne i twarde w systemach Linux/Unix **Wprowadzenie:** Linki w systemach Linux pozwalają na tworzenie alternatywnych nazw i dróg dostępu do plików bez duplikowania ich zawartości. Są dwa typy linków: symboliczne (symlinki) i twarde (hard links), każdy z nich ma swoje zastosowania i ograniczenia. ## 1. Link symboliczny (symbolic link, symlink) **Co to jest link symboliczny?** Link symboliczny to specjalny plik, który zawiera ścieżkę do innego pliku lub katalogu. Można go traktować jak "skrót" w systemach Windows. Link wskazuje na lokalizację docelową, ale sam nie zawiera danych oryginalnego pliku. **Tworzenie linku symbolicznego:** ``` ln -s /ścieżka/do/originalu /ścieżka/do/linku ``` **Przykłady praktyczne:** ``` ln -s /usr/local/bin/python3.11 /usr/local/bin/python ``` Tworzy link `python` wskazujący na `python3.11`. Dzięki temu można wywoływać `python` zamiast pełnej nazwy. ``` ln -s /var/www/html/projekty/strona ~/strona_link ``` Tworzy wygodny skrót do katalogu projektu w katalogu domowym. ``` ln -s /mnt/dysk_zewnetrzny/backup ~/backup ``` Skrót do katalogu backupu na zewnętrznym dysku. **Sprawdzanie linków symbolicznych:** ``` ls -l link_nazwa ``` Wyświetla informację o linku i pokazuje gdzie wskazuje, np.: ``` lrwxrwxrwx 1 user user 24 Nov 23 15:00 strona_link -> /var/www/html/projekty/strona ``` **Usuwanie linku symbolicznego:** ``` rm link_nazwa ``` Uwaga: usuwanie linku nie usuwa pliku docelowego! **Cechy linków symbolicznych:** - Mogą wskazywać na pliki i katalogi - Mogą wskazywać na nieistniejące cele (tzw. "wiszące linki") - Działają między różnymi systemami plików i partycjami - Są widoczne jako osobny typ pliku (oznaczenie `l` w `ls -l`) ## 2. Link twardy (hard link) **Co to jest link twardy?** Link twardy to dodatkowa nazwa dla tego samego pliku na dysku. W przeciwieństwie do linku symbolicznego, link twardy wskazuje bezpośrednio na te same dane (ten sam inode) co oryginalny plik. W praktyce nie ma różnicy między "oryginałem" a "linkiem" – oba są równorzędnymi nazwami tego samego pliku. **Tworzenie linku twardego:** ``` ln /ścieżka/do/pliku /ścieżka/do/twardego_linku ``` **Przykłady praktyczne:** ``` ln /var/log/syslog /home/admin/syslog_backup ``` Tworzy drugi dostęp do tego samego pliku logów. Modyfikacja w jednym miejscu jest widoczna w drugim. ``` ln dokument.txt dokument_kopia.txt ``` Obie nazwy wskazują na ten sam plik. Usunięcie jednej nazwy nie usuwa danych, dopóki istnieje druga. **Sprawdzanie linków twardych:** ``` ls -li plik ``` Opcja `-i` pokazuje numer inode. Pliki o tym samym numerze inode to linki twarde do tych samych danych. ``` $ ls -li dokument.txt dokument_kopia.txt 12345678 -rw-r--r-- 2 user user 1024 Nov 23 15:00 dokument.txt 12345678 -rw-r--r-- 2 user user 1024 Nov 23 15:00 dokument_kopia.txt ``` Ten sam numer inode (12345678) i liczba linków "2" oznacza, że to linki twarde. **Cechy linków twardych:** - Działają tylko dla plików (nie dla katalogów) - Muszą być w tym samym systemie plików - Plik jest usuwany dopiero gdy usuniemy wszystkie linki twarde do niego - Nie są widoczne jako osobny typ – wyglądają jak zwykłe pliki ## 3. Różnice między linkami symbolicznymi a twardymi ## 4. Praktyczne zastosowania ```bash # Link symboliczny do aktualnej wersji aplikacji ln -s /opt/app-1.2.3 /opt/app # Link symboliczny do konfiguracji ln -s /etc/nginx/sites-available/strona.conf /etc/nginx/sites-enabled/strona.conf # Link twardy jako backup przed edycją ln ważny_plik.conf ważny_plik.conf.backup # Sprawdzenie gdzie prowadzi link readlink -f link_nazwa # Znalezienie wszystkich linków twardych do pliku find / -inum $(ls -i plik | awk '{print $1}') 2>/dev/null ``` # Monitorowanie zasobów: free, vmstat, iostat, sara Monitorowanie dostępnej pamięci jest kluczowe dla stabilności systemu. Przy administracji serwerami, maszyn wirtualnych czy serwerów ważne jest zrozumienie jak Linux alokuje i zarządza pamięcią.

Komenda `free` – stan pamięci teraz

``` free ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/UP7image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/UP7image.png) Wyświetla podsumowanie zużycia RAM i swap. Domyślnie w kilobajtach (KB). ``` free -h ``` Format czytelny (B, KB, MB, GB). Najczęściej stosowana opcja. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/8dAimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/8dAimage.png) ``` free -m ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/OhVimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/OhVimage.png) Wynik w megabajtach. ``` free -g ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/lEQimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/lEQimage.png) Wynik w gigabajtach (przydatne na dużych serwerach). ``` free -w ``` Rozszerzony format z osobną kolumną na bufory i cache. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/DKoimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/DKoimage.png) **Interpretacja wyniku `free -h`:** ``` total used free shared buff/cache available Mem: 15.6G 8.2G 2.1G 0.5G 5.3G 7.4G Swap: 4.0G 0.5G 3.5G ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/S4Wimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/S4Wimage.png) - `total` – całkowita pamięć RAM - `used` – faktycznie używana pamięć - `free` – zupełnie wolna (często mała, bo Linux używa cache) - `buff/cache` – bufory i cache (mogą być zwolnione, jeśli trzeba) - `available` – pamięć dostępna do użytku dla aplikacji (ważna liczba!)

Monitorowanie pamięci w czasie rzeczywistym

``` free -h -s 2 ``` Wyświetla stan pamięci co 2 sekundy. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/7sJimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/7sJimage.png) ``` free -h -s 2 -c 10 ``` Monitoruje co 2 sekundy, 10 razy. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/IsRimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/IsRimage.png) ``` watch -n 1 'free -h' ``` Monitorowanie pamięci co sekundę w atrakcyjnym formacie (wymaga pakietu `watch`). [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/fAMimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/fAMimage.png)

Komenda `vmstat` – Virtual Memory Statistics

**Wprowadzenie do `vmstat`:** Bardziej zaawansowana niż `free`, pokazuje statystyki pamięci wirtualnej, I/O i swap activity. ``` vmstat ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/Zdrimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/Zdrimage.png) Jednorazowy raport. ``` vmstat 2 5 ``` Raport co 2 sekundy, 5 razy. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/cDfimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/cDfimage.png) **Interpretacja wyniku:** ``` procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu----- r b swpd free buff cache si so bi bo in cs us sy id wa st 1 0 0 2048000 51200 5242880 0 0 2 1 50 30 25 5 70 0 0 ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/Zdrimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/Zdrimage.png) - `r` – procesy czekające na CPU - `b` – procesy w I/O wait - `swpd` – swap w użyciu (MB) - `free` – wolna pamięć - `si/so` – swap in/out (jeśli > 0, system ma problemy z pamięcią) - `id` – % czasu CPU bezczynny (wysoki = dobry, niski = CPU obciążony) - `wa` – % czasu czekania na I/O (wysokie wartości = problemy z dyskiem)

Komenda `iostat` – I/O Statistics

`iostat` monitoruje aktywność dysków i procesorów. Wymaga pakietu `sysstat`. ``` iostat ``` Ogólne statystyki od ostatniego restartu systemu. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/q6nimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/q6nimage.png) ``` iostat -x 2 5 ``` Rozszerzone statystyki dysku, co 2 sekundy, 5 razy. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/cDUimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/cDUimage.png) **Interpretacja wyniku:** ```bash Device r/s w/s rMB/s wMB/s rrqm/s wrqm/s %rrqm %wrqm r_await w_await aqu-sz %util sda 10.5 5.2 0.50 0.25 0.5 1.2 5% 10% 2.5ms 5.0ms 0.08 8.5% ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/lQnimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/lQnimage.png) - `r/s` – read operations per second - `w/s` – write operations per second - `rMB/s / wMB/s` – megabajty czytane/zapisywane na sekundę - `%util` – procent wykorzystania dysku (>80% = problem) - `r_await / w_await` – średni czas oczekiwania operacji (wysoki = wolny dysk)

Komenda `sar` – System Activity Reporter

`sar` z pakietu `sysstat` to kompleksowe narzędzie do monitorowania systemu. Może zbierać dane historyczne. ```bash sar -u 2 5 ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/bTKimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/bTKimage.png) Statystyki CPU co 2 sekundy, 5 razy. ```bash sar -r 2 5 ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/Pgvimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/Pgvimage.png) Statystyki pamięci. ```bash sar -d 2 5 ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/Rjzimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/Rjzimage.png) Statystyki dysków (podobnie jak `iostat`). [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/SGNimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/SGNimage.png) ```bash sar -b 2 5 ``` I/O i przełączenia stron (page faults). [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/xAuimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/xAuimage.png)

Monitorowanie swap activity – problem w systemach

```bash vmstat 1 | grep -v procs | awk '$7 > 0 || $8 > 0 { print "SWAP AKTYWNY!", $0 }' ``` [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/3S7image.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/3S7image.png) Ostrzeżenie gdy system zaczyna pisać do swap ```bash watch -n 1 'vmstat 1 2 | tail -1' ``` Ciągłe monitorowanie najnowszych danych vmstat. [![image.png](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/scaled-1680-/HGJimage.png)](https://wiedza.konio-dc.eu/uploads/images/gallery/2025-11/HGJimage.png)

Praktyczne problemy z pamięcią i jak je diagnozować

**Problem: System powolny, dużo swap activity**

```bash # 1. Sprawdź dostępną pamięć free -h 2. Sprawdź swap vmstat 1 5 | grep -E 'si|so' 3. Szukaj procesów zużywających pamięć ps aux --sort=-%mem | head -20 4. Sprawdź I/O wait iostat -x 1 5 ```

**Problem: Serwer Metin2 (MT2SRV) zajmuje za dużo pamięci**

```bash # Monitoruj samo server gry watch -n 1 'ps aux | grep -E "game|db|auth" | awk "{print \$2, \$4, \$11}"' Jeśli pamięć rośnie bezustannie (memory leak) ps aux | grep game | awk '{print $2}' # Uzyskaj PID cat /proc/[PID]/status | grep VmRSS # Aktualna pamięć tego procesu ```

Wyzwalanie alertów przy braku pamięci

```bash #!/bin/bash AVAILABLE=$(free -h | awk '/^Mem:/ {print $7}' | tr -d 'G') if (( $(echo "$AVAILABLE < 1" | bc -l) )); then echo "ALARM: Pamięć poniżej 1GB!" fi ``` # Uprawnienia plików i katalogów - chmod i chowa ## 1. Podstawy modelu uprawnień Każdy plik i katalog ma przypisane uprawnienia dla trzech grup użytkowników: - **u** (user) – właściciel pliku - **g** (group) – grupa, do której należy plik - **o** (others) – wszyscy pozostali użytkownicy Dla każdej z tych grup można przypisać trzy typy uprawnień: - **r** (read) – prawo do odczytu - **w** (write) – prawo do zapisu/modyfikacji - **x** (execute) – prawo do wykonania (dla plików) lub wejścia (dla katalogów) ## 2. Wyświetlanie uprawnień ``` ls -l plik.txt ``` Wyświetla szczegółowe informacje, w tym uprawnienia w formacie: ``` -rwxr-xr-- ``` Gdzie: - Pierwszy znak: typ pliku (`-` zwykły plik, `d` katalog, `l` link symboliczny) - Kolejne 3 znaki: uprawnienia właściciela (`rwx`) - Kolejne 3 znaki: uprawnienia grupy (`r-x`) - Ostatnie 3 znaki: uprawnienia innych (`r--`) ## 3. Komenda `chmod` – zmiana uprawnień **Format symboliczny (literowy):** ``` chmod u+x skrypt.sh ``` Dodaje właścicielowi prawo wykonywania pliku `skrypt.sh`. ``` chmod g-w dokument.txt ``` Odbiera grupie prawo do zapisu w pliku `dokument.txt`. ``` chmod o+r raport.pdf ``` Dodaje innym użytkownikom prawo do odczytu pliku `raport.pdf`. ``` chmod a+r plik.txt ``` Dodaje prawo do odczytu dla wszystkich (właściciel, grupa, inni). ``` chmod go-rwx prywatny.txt ``` Odbiera grupie i innym wszystkie uprawnienia do pliku. **Format numeryczny (oktalny):** Każde uprawnienie ma wartość liczbową: - r (read) = 4 - w (write) = 2 - x (execute) = 1 Sumując wartości, otrzymujemy kod uprawnień dla każdej grupy: - 7 = rwx (4+2+1) - 6 = rw- (4+2) - 5 = r-x (4+1) - 4 = r-- (4) - 0 = --- (brak uprawnień) ``` chmod 755 skrypt.sh ``` Właściciel: rwx (7), grupa: r-x (5), inni: r-x (5). ``` chmod 644 dokument.txt ``` Właściciel: rw- (6), grupa: r-- (4), inni: r-- (4). ``` chmod 700 prywatny_skrypt.sh ``` Tylko właściciel ma pełny dostęp, inni nie mają żadnych uprawnień. ## 4. Rekurencyjna zmiana uprawnień ``` chmod -R 755 /var/www/strona ``` Opcja `-R` (recursive) zmienia uprawnienia dla katalogu i wszystkich plików oraz podkatalogów w nim zawartych. ``` chmod -R u+rwX /home/user/dokumenty ``` Duże `X` dodaje prawo wykonywania tylko do katalogów i plików, które już mają to prawo dla kogokolwiek. ## 5. Komenda `chown` – zmiana właściciela i grupy ``` chown user plik.txt ``` Zmienia właściciela pliku na użytkownika `user`. ``` chown user:grupa plik.txt ``` Zmienia właściciela na `user` i grupę na `grupa`. ``` chown :grupa plik.txt ``` Zmienia tylko grupę (właściciel pozostaje bez zmian). ``` chown -R www-data:www-data /var/www ``` Rekurencyjnie zmienia właściciela i grupę dla całego katalogu i jego zawartości. ## 6. Praktyczne przykłady zastosowań ```bash # Nadanie uprawnień wykonywania dla skryptu chmod +x deploy.sh # Zabezpieczenie pliku konfiguracyjnego (tylko właściciel może czytać i pisać) chmod 600 config.ini # Typowe uprawnienia dla katalogu www chmod -R 755 /var/www/html chown -R www-data:www-data /var/www/html # Odebranie wszystkich uprawnień innym użytkownikom chmod go-rwx /home/user/tajne_dane # Sprawdzenie uprawnień przed i po zmianie ls -l plik.txt chmod 644 plik.txt ls -l plik.txt ``` # Atrybuty plików i katalogów **Wprowadzenie:** Poza standardowymi uprawnieniami (rwx), system Linux oferuje dodatkowe mechanizmy kontroli dostępu do plików i katalogów. Należą do nich pliki ukryte oraz rozszerzone atrybuty zarządzane poleceniem `chattr`. ## 1. Pliki ukryte w systemie Linux/Unix **Co to są pliki ukryte?** W systemach Unix/Linux plikami ukrytymi nazywamy pliki i katalogi, których nazwa zaczyna się od kropki (`.`). Są one domyślnie niewidoczne przy standardowym wywoływaniu `ls`. Pliki ukryte często zawierają konfiguracje użytkownika lub aplikacji. **Wyświetlanie plików ukrytych:** ``` ls -a ``` Pokazuje wszystkie pliki, w tym ukryte. ``` ls -la ``` Szczegółowy widok ze wszystkimi plikami, w tym ukrytymi. **Przykłady typowych plików ukrytych:** - `.bashrc` – konfiguracja powłoki bash - `.bash_profile` – konfiguracja przy logowaniu - `.ssh/` – katalog z kluczami SSH - `.gitignore` – plik konfiguracyjny git - `.vimrc` – konfiguracja edytora vim **Tworzenie ukrytego pliku:** ``` touch .ukryty_plik.txt ``` Wystarczy, że nazwa zaczyna się od kropki. ## 2. Rozszerzone atrybuty plików – `chattr` **Co to są rozszerzone atrybuty?** Rozszerzone atrybuty to dodatkowe flagi kontrolujące zachowanie plików na poziomie systemu plików. Pozwalają one na bardziej precyzyjną kontrolę niż standardowe uprawnienia rwx. Są obsługiwane głównie w systemach plików ext2, ext3, ext4. **Komenda `chattr` – zmiana atrybutów:** ``` chattr +i plik.txt ``` Ustawia atrybut niezmienności (immutable). Plik nie może być modyfikowany, usuwany, zmieniany ani przenoszony – nawet przez użytkownika root! ``` chattr -i plik.txt ``` Usuwa atrybut niezmienności. ## 3. Najważniejsze atrybuty `chattr` **Atrybut `i` (immutable – niezmienny):** ``` chattr +i /etc/ważny_config.conf ``` Plik nie może być w żaden sposób modyfikowany. Przydatne do ochrony krytycznych plików konfiguracyjnych przed przypadkową zmianą. **Atrybut `a` (append only – tylko dopisywanie):** ``` chattr +a /var/log/aplikacja.log ``` Plik może być tylko rozszerzany (dopisywanie na końcu), ale nie można modyfikować ani usuwać istniejącej zawartości. Idealne dla plików logów. **Atrybut `c` (compressed – kompresowany):** ``` chattr +c duży_plik.txt ``` Jądro automatycznie kompresuje plik na dysku (jeśli system plików to obsługuje). **Atrybut `d` (no dump – pomijany w backup):** ``` chattr +d cache.tmp ``` Plik jest pomijany przez narzędzie `dump` podczas tworzenia kopii zapasowej. **Atrybut `s` (secure deletion – bezpieczne usuwanie):** ``` chattr +s tajny_dokument.txt ``` Przy usuwaniu pliku, jego bloki na dysku są nadpisywane zerami, co utrudnia odzyskanie danych. **Atrybut `u` (undeletable – możliwy do odzyskania):** ``` chattr +u ważny_plik.txt ``` System zachowuje informacje pozwalające na odzyskanie pliku po usunięciu (jeśli system plików to wspiera). ## 4. Komenda `lsattr` – wyświetlanie atrybutów ``` lsattr plik.txt ``` Pokazuje aktualne atrybuty pliku. ``` lsattr -d katalog/ ``` Pokazuje atrybuty samego katalogu (a nie jego zawartości). ``` lsattr -a ``` Pokazuje atrybuty wszystkich plików, w tym ukrytych. **Przykładowy wynik:** ``` $ lsattr plik.txt ----i---------e----- plik.txt ``` Litera `i` oznacza atrybut immutable. ## 5. Rekurencyjna zmiana atrybutów ``` chattr -R +i /etc/config/ ``` Opcja `-R` (recursive) stosuje atrybut do wszystkich plików i podkatalogów. ## 6. Praktyczne przykłady zastosowań ```bash # Ochrona pliku konfiguracyjnego przed modyfikacją sudo chattr +i /etc/ssh/sshd_config # Teraz nawet root nie może go zmienić bez usunięcia atrybutu # Sprawdzenie atrybutów lsattr /etc/ssh/sshd_config # Aby móc edytować, trzeba najpierw usunąć atrybut sudo chattr -i /etc/ssh/sshd_config # Zabezpieczenie pliku logów – tylko dopisywanie sudo chattr +a /var/log/aplikacja.log # Ochrona całego katalogu przed usunięciem sudo chattr -R +i /opt/produkcja/ # Weryfikacja atrybutów wszystkich plików w katalogu lsattr -a /home/user/ ``` ## 7. Ważne uwagi - Rozszerzone atrybuty działają na poziomie systemu plików – nie wszystkie systemy plików je obsługują - Tylko użytkownik root może zmieniać większość atrybutów - Atrybuty są niezależne od standardowych uprawnień Unix (rwx) - Podczas przenoszenia plików między systemami atrybuty mogą zostać utracone - Warto dokumentować użycie atrybutów, aby inni administratorzy wiedzieli o ich zastosowaniu # Obsługa komendy sed **Co to jest `sed`?**

`sed` (stream editor) to narzędzie do przetwarzania tekstu na poziomie linii, działające linia po linii. Pozwala na automatyczną edycję plików lub strumieni tekstu bez konieczności otwierania ich w interaktywnym edytorze.

## Podstawowa składnia polecenia ``` sed [opcje] 'polecenia' plik ``` W poleceniu `sed` wykonujemy polecenia edycyjne na każdej linii pliku lub strumienia. ## Najważniejsze polecenia `sed` używane w przykładach - `s/wzorzec/tekst/` – zamiana pierwszego wystąpienia wzorca w linii na podany tekst. - `s/wzorzec/tekst/g` – zamiana wszystkich wystąpień wzorca w linii (opcja `g` – globalnie). - `d` – usunięcie linii (np. `/^#/d` usuwa linie zaczynające się od #). - `p` – wyświetlenie linii (często stosowane z opcją `-n`, by wyświetlić tylko wybrane linie). - `a` – dodanie tekstu po bieżącej linii. - `i` – wstawienie tekstu przed bieżącą linią. ## Wyjaśnienie składni zamiany (substytucji) `s///` oraz znaków - `s` – instrukcja “substitute” (zamień). - Separator w `s///` zwykle to znak `/`, ale może być dowolny (np. `#`) aby uniknąć uciekania `/` w zamienianych wzorcach. - `\'` – apostrofy służą do ujęcia polecenia tak, by uniknąć interpretacji przez powłokę. - `g` – oznacza "globalnie", czyli zamień wszystkie wystąpienia. - `d` – oznacza "delete", usuń linie pasujące do wzorca. ## Obsługa znaków specjalnych - escape w `sed` - `\\` – backslash musi być podwójnie ucieczony `\\\\` w poleceniach. - `\.` – kropka oznacza dowolny znak, żeby faktycznie wyszukać kropkę musimy ją uciec. - `\*`, `\^`, `\$`, `\[ \]` – także mają specjalne znaczenie, wymagają escape. - Alternatywnie możemy zmienić separator `s/old/new/` na np. `s#old#new#`, co ułatwia pracę ze ścieżkami. ## Przykłady: **Zamiana adresu IP na inny:** ``` sed 's/192\.168\.1\.1/10.0.0.1/g' plik.conf ``` Zamienia wszystkie wystąpienia adresu IP 192.168.1.1 na 10.0.0.1, kropki są escape'owane. **Zamiana ścieżek za pomocą innego separatora:** ``` sed 's#/var/www/html#/srv/www#g' plik.conf ``` Użycie znaku `#` zamiast `/` jako separatora pozwala uniknąć escape'ów w ścieżkach. **Komentowanie zakresu linii:** ``` sed '10,20s/^/#/' plik.conf ``` Dodaje znak `#` na początku linii od 10 do 20. **Odkomentowanie zakresu linii:** ``` sed '10,20s/^#//' plik.conf ``` Usuwa znak `#` z początku linii od 10 do 20. **Usuwanie pustych linii:** ``` sed '/^$/d' plik.conf ``` Usuwa linie całkowicie puste. **Podwajanie backslash:** ``` sed 's/\\/\\\\/g' plik.conf ``` Zamienia pojedynczy znak `\` na podwójny `\\` (używane np. przy generowaniu ścieżek w skryptach). **Zamiana z grupami przechwytywania:** ``` sed 's/\(foo\) \(bar\)/\2 \1/' plik.conf ``` Zamienia wystąpienie "foo bar" na "bar foo", gdzie `\( ... \)` wskazuje grupy tekstu, a `\1`, `\2` odwołują się do nich w zamianie. **Zaawansowana zamiana adresu IP z regexp:** ``` sed 's/\([0-9]\{1,3\}\.\)\{3\}[0-9]\{1,3\}/10.0.0.1/g' plik.conf ``` Zamienia dowolny adres IPv4 (4 liczby 0-999 rozdzielone kropkami) na 10.0.0.1. **Edycja pliku in-place na FreeBSD:** ``` sed -i '' 's/stary/nowy/g' plik.conf ``` Podmienia wszystkie wystąpienia "stary" na "nowy" bez tworzenia kopii zapasowej, ważne jest wymienienie `''` po `-i`. # Obsługa awk

AWK to potężne narzędzie do przetwarzania i analizy tekstu, szczególnie przydatne do pracy z danymi podzielonymi na kolumny. Pozwala na wyszukiwanie, filtrowanie, formatowanie i agregację danych z plików tekstowych lub wyników innych poleceń.

## Podstawowa składnia AWK ```bash awk 'warunek { działania }' plik ``` **Wyjaśnienie:** - `warunek` – wyrażenie logiczne lub wzorzec tekstowy, który musi być spełniony, aby wykonać `działania` (np. filtrowanie linii). - `{ działania }` – polecenia wykonywane na liniach spełniających warunek (np. wypisanie wybranych kolumn). ## Odwołania do pól i zmienne w AWK ```bash $0 # cała linia tekstu wejściowego $1, $2, … # kolejne kolumny/ pola w linii (domyślnie pola rozdzielone spacjami) NR # numer bieżącego wiersza (count) NF # liczba pól w bieżącej linii ``` **Wyjaśnienia:** AWK dzieli każdą linię na pola (domyślnie na spacje/tabulacje). Użycie `$1` zwraca pierwszą kolumnę, `$2` drugą itd. Zmienna `NR` oznacza numer bieżącej linii, a `NF` ilość kolumn w bieżącym wierszu. ## Przykłady użycia AWK – pojedyncze komendy **1. Wyświetl pierwszą i trzecią kolumnę każdego wiersza:** ```bash awk '{ print $1, $3 }' plik.txt ``` **2. Wyświetl linie, których pierwsza kolumna równa jest "error":** ```bash awk '$1 == "error" { print $0 }' plik.txt ``` **3. Sumowanie wartości w kolumnie numer 2:** ```bash awk '{ suma += $2 } END { print suma }' plik.txt ``` *Wyjaśnienie:* dla każdej linii dodaj wartość pola 2 do zmiennej `suma`, a na końcu `END` wypisz wynik. **4. Wypisz numer linii oraz zawartość linii:** ```bash awk '{ print NR, $0 }' plik.txt ``` ## Wyrażenia regularne (regexp) w AWK AWK wspiera wyrażenia regularne do dopasowywania tekstu. Można je stosować w warunkach: ```bash awk '/pattern/ { print $0 }' plik.txt ``` Znajduje i wypisuje linie zawierające `pattern`. Można łączyć takie dopasowanie z innymi warunkami i operatorami: ```bash awk '$3 ~ /error/' plik.txt ``` Wypisuje linie, w których trzecia kolumna zawiera słowo "error". ```bash awk '$2 !~ /^[0-9]+$/' plik.txt ``` Wypisuje linie, gdzie druga kolumna nie składa się wyłącznie z cyfr. ## Przetwarzanie i filtrowanie danych z AWK – bardziej rozbudowane przykłady **Wyświetlanie wierszy, gdzie kolumna 5 jest większa niż 100:** ```bash awk '$5 > 100 { print $0 }' plik.txt ``` **Formatowane wypisywanie danych (np. kolumny 1 i 3 oddzielone tabulatorem):** ```bash awk '{ printf "%s\t%s\n", $1, $3 }' plik.txt ``` **Podliczanie wystąpień unikalnych wartości w kolumnie 3:** ```bash awk '{ counts[$3]++ } END { for (val in counts) print val, counts[val] }' plik.txt ``` ## Wywołania specjalne i kontrola przepływu AWK pozwala na tworzenie bloków `BEGIN` i `END` do wykonania instrukcji przed lub po przeczytaniu wszystkich linii: ```bash awk 'BEGIN { print "Start przetwarzania" } { print $1 } END { print "Koniec przetwarzania" }' plik.txt ``` Pętla i warunki są typowe dla języków programowania, np.: ```bash awk '{ if ($2 > 100) print $0 else next }' plik.txt ```