Komendy terminala - Linux i macOS

Materiał przygotowany z pomocą AI

Zbiór najczęściej używanych komend, które działają zarówno na Debianie/Ubuntu, jak i macOS. Większość narzędzi jest wspólna (POSIX/GNU coreutils na Linuksie, BSD coreutils na macOS), ale są różnice w pojedynczych flagach i w narzędziach systemowych — systemd, apt i journalctl to wyłącznie Linux, brew i launchd to macOS. Tam, gdzie polecenia różnią się składnią, opisuję obie wersje.

Konwencja

Polecenia poprzedzone sudo wymagają uprawnień administratora. Na macOS sudo działa identycznie jak na Linuksie. Na Debianie użytkownik musi być w grupie sudo.

Czym jest terminal

Terminal to tekstowy sposób komunikacji z systemem operacyjnym. To ten sam komputer i ten sam system plików, do którego masz dostęp przez interfejs graficzny — tylko inny sposób wydawania mu poleceń, oparty na pisanych komendach zamiast okien i menu.

Aplikacja, w której pojawia się okno terminala, sama nie wykonuje poleceń — pełni rolę „okienka” wyświetlającego tekst. Faktycznym wykonawcą jest powłoka (ang. shell) — program, który czyta to, co wpisujesz, rozumie składnię i uruchamia odpowiednie polecenia.

Najczęściej spotkasz dwie powłoki:

• bash — domyślna na Debianie/Ubuntu i na większości serwerów
• zsh — domyślna na nowszych wersjach macOS

Komendy opisane w tym opracowaniu działają w obu — różnice pojawiają się dopiero przy bardziej zaawansowanych skryptach.

Powłoka Bourne’a (sh) — wspólny przodek

Zarówno bash, jak i zsh wywodzą się z powłoki Bourne’a (sh) — minimalistycznej powłoki, która stała się podstawą standardu opisującego, jak ma działać shell w systemach uniksowych (POSIX). Stąd nazwa bash: skrót od Bourne Again Shell, czyli „znów Bourne” — z założenia zgodna z sh, ale rozbudowana o wygodne dodatki (historia poleceń, autouzupełnianie, tablice asocjacyjne).

W praktyce ma to dwa skutki, które warto znać:

• Skrypty .sh zaczynające się od linii #!/bin/sh używają minimalnej, zgodnej powłoki — działają w zasadzie wszędzie, ale nie korzystają z udogodnień bash/zsh
• Skrypty .sh z linią #!/bin/bash lub #!/usr/bin/env bash mogą korzystać z rozszerzeń basha, ale na minimalnym systemie (np. Alpine Linux w kontenerze Docker) bash może nie być zainstalowany

Na Debianie /bin/sh to zazwyczaj dash — szybsza, ściśle POSIX-owa powłoka używana do skryptów systemowych. Na macOS /bin/sh to bash uruchamiany w trybie POSIX (czyli z wyłączonymi rozszerzeniami basha, zgodnie ze standardem sh). Dla codziennej pracy interaktywnej różnice nie mają znaczenia — sprowadzają się głównie do tego, jakiej składni używać w przenośnych skryptach.

Po co używać terminala

Praca w terminalu na początku wydaje się trudniejsza niż klikanie, ale szybko zaczyna się opłacać:

• Automatyzacja — każde polecenie można zapisać w skrypcie i uruchamiać wielokrotnie albo cyklicznie (np. raz dziennie)
• Reprodukowalność — instrukcje w formie „wpisz takie polecenie” są jednoznaczne, łatwo je dokumentować i powtarzać na innej maszynie
• Praca zdalna — pozwala zarządzać serwerem, który nie ma podłączonego monitora ani interfejsu graficznego
• Łączenie narzędzi — wynik jednego polecenia można od razu przekazać jako dane wejściowe do drugiego (operator |, tzw. potok)
• Precyzja — wiele operacji (np. masowa zmiana nazw plików, filtrowanie logów) jest w terminalu szybsza i pewniejsza niż w eksploratorze plików

Anatomia znaku zachęty (prompt)

Po otwarciu terminala zobaczysz krótką linijkę tekstu zakończoną znakiem $ (zwykły użytkownik) albo # (administrator). To prompt — sygnał, że powłoka jest gotowa na polecenie. Typowy wygląd:

piotr@komputer:~/dokumenty$

Z lewej strony masz informację, kto i gdzie pracuje (użytkownik, nazwa komputera, bieżący katalog). Po znaku $ wpisujesz polecenie, zatwierdzasz Enter, a powłoka pokazuje wynik i ponownie wyświetla prompt — gotowa na kolejne. Wygląd prompta można dowolnie konfigurować.

Najprostszym poleceniem, na którym warto się przekonać, że terminal działa, jest echo — wypisuje na ekranie to, co podasz mu jako argument:

$ echo "Witaj, Świecie!"
Witaj, Świecie!

Argument to dodatkowa informacja, którą przekazujesz poleceniu po jego nazwie — najczęściej oddzielona spacją. W przykładzie wyżej echo jest poleceniem, a "Witaj, Świecie!" argumentem mówiącym, co ma wypisać. Polecenia bywają bezargumentowe (np. pwd — wyświetla bieżący katalog i nic więcej nie potrzebuje), jedno- lub wieloargumentowe (np. cp zrodlo.txt cel.txt — dwa argumenty: skąd skopiować i dokąd).

Cudzysłów wokół "Witaj, Świecie!" jest tu potrzebny dlatego, że tekst zawiera spację — bez cudzysłowu powłoka potraktowałaby to jako dwa osobne argumenty (Witaj, i Świecie!). Dla pojedynczego słowa cudzysłów nie jest konieczny: echo Test zadziała tak samo jak echo "Test".

Oprócz argumentów polecenia często przyjmują też opcje (zwane też flagami) — krótkie przełączniki zmieniające zachowanie, zaczynające się od - (forma krótka, np. -l) albo -- (forma długa, np. --help). Spotkasz je już w następnej sekcji, np. ls -la.

W tym opracowaniu (i ogólnie w dokumentacji powłok) znak $ na początku linii oznacza prompt — nie wpisujesz go ręcznie, służy tylko do wizualnego oddzielenia tego, co wpisujesz, od wyniku, który zwraca system.

Pomoc — man, --help, tldr

Praktycznie każde polecenie ma własną dokumentację dostępną z poziomu terminala — nie musisz szukać w internecie, żeby sprawdzić, co robi dana flaga albo w jakiej kolejności idą argumenty.

man — strona podręcznika

Polecenie man (od manual) wyświetla pełny podręcznik dla wskazanego programu:

man ls                              # podręcznik polecenia ls
man grep                            # podręcznik grep

Strona man otwiera się w pagerze less, więc działają w niej te same skróty, które opisuję dalej w sekcji o przeglądaniu plików — q żeby wyjść, Spacja przewija stronę w dół, /wzorzec wyszukuje tekst.

Strony man są ponumerowane sekcjami — dla początkującego liczą się głównie:

Sekcja	Zawartość
1	polecenia użytkownika (ls, grep, cp)
5	formaty plików konfiguracyjnych (crontab, passwd)
8	polecenia administratora (mount, useradd)

Czasem ta sama nazwa istnieje w kilku sekcjach, np. crontab to i polecenie (sekcja 1), i format pliku (sekcja 5). Wtedy podajesz numer:

man 5 crontab                       # format pliku crontab, nie polecenie
man -k haslo                        # szukaj po słowie kluczowym (apropos)

--help / -h — szybka ściąga

Większość poleceń obsługuje przełącznik --help (lub krótszy -h), który wypisuje skróconą listę opcji bez otwierania pagera:

ls --help                           # skrótowa pomoc (Linux)
grep --help
rsync -h

Na macOS część narzędzi (BSD coreutils) nie ma --help — wtedy odpowiednikiem jest man. Polecenia GNU, które dograsz przez brew install coreutils, działają już ze standardową flagą.

tldr — przykłady z życia

man jest wyczerpujący, ale często chcesz tylko zobaczyć typowe użycie. Społecznościowy projekt tldr (od „too long; didn’t read”) zbiera kilka praktycznych przykładów dla każdego polecenia:

brew install tldr                   # macOS
sudo apt install tldr               # Debian/Ubuntu
 
tldr tar                            # 5-6 najczęstszych użyć tar
tldr rsync

To często szybsza droga do odpowiedzi niż czytanie kilkuset linii man tar.

info i help

• info polecenie — alternatywny format dokumentacji GNU, bardziej rozbudowany niż man (głównie Linux)
• help polecenie — opisuje polecenia wbudowane w samą powłokę, takie jak cd, export, alias, dla których man nie zadziała („No manual entry”); zamiast man cd użyj help cd

Gdy nie wiesz, jak się nazywa narzędzie

man -k temat (alias apropos temat) szuka słowa kluczowego w opisach wszystkich stron man. Przykład: man -k "compress files" zwróci gzip, bzip2, xz, zip itd.

Strumienie standardowe — wejście, wyjście, błędy

Każde polecenie uruchomione w terminalu ma trzy kanały komunikacji ze światem zewnętrznym, nazywane strumieniami standardowymi:

Strumień	Skrót	Numer	Domyślne źródło/cel
wejście	stdin	0	klawiatura
wyjście	stdout	1	ekran (okno terminala)
błędy	stderr	2	ekran (okno terminala)

Domyślnie polecenie czyta dane z klawiatury, a wyniki i komunikaty o błędach pisze na ekran. Siła powłoki polega na tym, że każdy z tych strumieni można przekierować — do pliku, do innego polecenia albo zignorować.

Przekierowanie do pliku

echo "Witaj" > plik.txt              # zapisz wyjście do pliku (nadpisuje)
echo "Druga linia" >> plik.txt       # dopisz na końcu (append)
ls /nieistniejacy 2> bledy.log       # tylko błędy do pliku
ls /etc > listing.txt 2> bledy.log   # wyjście i błędy osobno
ls /etc > wszystko.log 2>&1          # oba strumienie do jednego pliku
ls /nieistniejacy 2> /dev/null       # wyrzuć błędy w niebyt

Notacja 2>&1 znaczy „przekieruj stderr (kanał 2) tam, gdzie aktualnie idzie stdout (kanał 1)”. Plik specjalny /dev/null to „kosz” systemowy — wszystko, co tam trafi, jest po prostu wyrzucane.

Wczytanie z pliku

wc -l < plik.txt                     # zlicz linie, czytając plik jako stdin
sort < lista.txt                     # posortuj zawartość pliku

Większość poleceń przyjmuje plik również jako argument (wc -l plik.txt), ale przekierowanie < przydaje się wtedy, gdy program oczekuje danych ze standardowego wejścia.

Potok (pipe) — łączenie poleceń

Operator | przekazuje stdout jednego polecenia jako stdin następnego — bez tworzenia plików pośrednich:

ls -la | grep ".md"                  # listing → tylko linie z ".md"
ps aux | grep nginx | wc -l          # liczba procesów nginx
cat plik.log | sort | uniq -c        # policz wystąpienia każdej linii
history | grep ssh                   # wszystkie wpisane wcześniej komendy z "ssh"

To właśnie potok sprawia, że małe, wyspecjalizowane narzędzia (każde robi jedną rzecz dobrze) można składać w bardziej złożone operacje — to fundamentalna idea Uniksa.

Domyślnie | przekazuje tylko stdout. Jeśli chcesz przepuścić przez potok również błędy (stderr), użyj |& (skrót dla 2>&1 |):

make |& tee build.log                # wynik + błędy zapisuje do pliku i pokazuje

tee — rozdwojenie strumienia

Polecenie tee zapisuje stdin jednocześnie do pliku i przekazuje dalej. Przydatne, gdy chcesz widzieć wynik na ekranie i mieć go w pliku: make 2>&1 | tee build.log.

Łączenie poleceń — ;, &&, ||, &

Powłoka pozwala uruchomić kilka poleceń jednym wierszem, sterując kolejnością i warunkami wykonania:

cmd1 ; cmd2                          # uruchom cmd2 niezależnie od wyniku cmd1
cmd1 && cmd2                         # uruchom cmd2 TYLKO jeśli cmd1 się powiodło
cmd1 || cmd2                         # uruchom cmd2 TYLKO jeśli cmd1 padło
cmd1 &                               # uruchom cmd1 w tle, oddaj prompt od razu

Każde polecenie po zakończeniu zwraca kod wyjścia (exit code): 0 oznacza sukces, dowolna inna wartość — błąd. Operatory && i || reagują właśnie na ten kod.

Praktyczne przykłady:

mkdir -p build && cd build           # wejdź dopiero, jak katalog na pewno istnieje
git pull && npm install && npm test  # zatrzymaj łańcuch przy pierwszym błędzie
ping -c1 host || echo "host nie odpowiada"
make ; notify-send "Build skończony"  # powiadom niezależnie, czy się udało
python long_script.py &              # uruchom w tle, dalej pracuj w terminalu

Długie polecenia w wielu wierszach

Im więcej operatorów łączysz, tym trudniej zmieścić wszystko czytelnie w jednej linii. Powłoka pozwala rozbić polecenie na kilka wierszy na dwa sposoby — efekt jest taki sam, jakby wszystko było w jednej linii:

Backslash \ na końcu wiersza — wymusza kontynuację, gdy łamiesz linię w dowolnym miejscu (np. między argumentami):

rsync -avz \
    --exclude=".git" \
    --exclude="node_modules" \
    katalog/ \
    user@host:~/backup/

Naturalny podział po operatorach — po |, &&, || powłoka sama wie, że polecenie nie jest skończone, i czeka na kolejną linię (backslash niepotrzebny):

git pull &&
    npm install &&
    npm test &&
    npm run deploy
 
cat /var/log/syslog |
    grep "ERROR" |
    tail -n 50 |
    less

Oba zapisy w terminalu działają tak samo jak cmd1 && cmd2 && cmd3 w jednej linii — różnica jest tylko wizualna. Ten styl bardzo poprawia czytelność skryptów (.sh) i długich poleceń wpisywanych ręcznie.

W terminalu też możesz pisać wieloliniowo

Jeśli wpiszesz polecenie zakończone backslashem albo otwartym operatorem (|, &&) i wciśniesz Enter, prompt zmieni się na > (PS2) — powłoka czeka na dokończenie. Ten sam efekt daje niezamknięty cudzysłów: echo "linia 1 + Enter przeniesie cię do > i pozwoli kontynuować tekst.

Heredoc i here-string — wieloliniowy wejściowy tekst

Czasem trzeba przekazać poleceniu kilka linijek tekstu „z palca”, bez tworzenia pliku. Służą do tego dwa operatory.

W heredocach pojawia się znacznik końca — w przykładach poniżej EOF (od ang. end of file). Jest to po prostu dowolny napis, który mówi powłoce „wszystko, co napiszę między <<EOF a kolejną linią zawierającą wyłącznie EOF, traktuj jako wejście dla polecenia”. Sama nazwa nie ma znaczenia — równie dobrze można użyć <<KONIEC … KONIEC. EOF to tylko najpopularniejsza konwencja.

# Heredoc - wieloliniowy blok do stdin
cat > config.txt <<'EOF'
server = example.com
port = 443
EOF
 
# Here-string - pojedynczy łańcuch jako stdin
grep "TODO" <<< "$zmienna"
bc <<< "2 + 3 * 4"

W <<'EOF' apostrofy wokół znacznika wyłączają interpretację $zmiennych w treści — przydatne, gdy zapisujesz dosłowny tekst (np. skrypt) z dolarami w środku.

Podstawianie wyniku polecenia — $(...)

Konstrukcja $(polecenie) wykonuje polecenie i wstawia w to miejsce jego stdout. To inny mechanizm niż potok — wynik trafia jako argument, nie jako wejście:

echo "Dziś jest $(date +%Y-%m-%d)"        # wynik daty wstawiany w środek tekstu
cd "$(dirname "$0")"                       # przejdź do katalogu skryptu
kill $(pgrep -f long-script.py)            # zabij procesy pasujące do wzorca
files=$(ls *.md | wc -l)                   # zapisz liczbę plików do zmiennej

Starsza składnia z odwrotnymi apostrofami (`polecenie`) działa tak samo, ale jest mniej czytelna i nie da się jej zagnieżdżać — w nowych skryptach używaj $(...).

Znaki specjalne powłoki — szybka ściąga

W powłoce wiele zwykłych znaków interpunkcyjnych ma znaczenie składniowe. Poniżej zebrane w grupy — to, co już padło wyżej, plus kilka, które zobaczysz w skryptach.

Ścieżki

Znak	Znaczenie
/	korzeń systemu plików / separator katalogów
~	katalog domowy bieżącego użytkownika
~user	katalog domowy użytkownika user
.	bieżący katalog
..	katalog nadrzędny
-	(po cd) poprzedni katalog

Wzorce nazw plików (globbing)

Znak	Znaczenie
*	dowolny ciąg znaków (z wyjątkiem /) — ls *.md
?	dokładnie jeden dowolny znak — ls plik?.txt
[abc]	jeden ze znaków w nawiasie — ls plik[123].txt
[a-z]	zakres znaków — ls [a-c]*
{a,b}	rozwinięcie do kilku wariantów — cp plik.{txt,bak}

Cudzysłowy i escapowanie

Znak	Znaczenie
"..."	tekst — zachowuje spacje, interpretuje $zmienne i $(...)
'...'	tekst dosłowny — żadnej interpretacji (nawet $ jest dosłowne)
\znak	escapuj jeden znak (np. \$, \ , \")
\ (na końcu linii)	kontynuacja polecenia w następnym wierszu

Strumienie i przekierowania

Znak	Znaczenie
|	potok — stdout poprzedniego polecenia → stdin następnego
|&	potok łącznie ze stderr (skrót dla 2>&1 |)
>	przekieruj stdout do pliku (nadpisz)
>>	przekieruj stdout do pliku (dopisz na końcu)
<	wczytaj stdin z pliku
<<EOF	heredoc — wieloliniowy tekst do stdin
<<<	here-string — pojedynczy łańcuch do stdin
2>	przekieruj stderr do pliku
2>&1	scal stderr z stdout
&>	przekieruj oba (stdout + stderr) do pliku

Łączenie poleceń

Znak	Znaczenie
;	uruchom kolejno, niezależnie od wyniku
&&	uruchom kolejne TYLKO jeśli poprzednie się powiodło
||	uruchom kolejne TYLKO jeśli poprzednie padło
&	uruchom polecenie w tle

Zmienne i podstawienia

Znak	Znaczenie
$nazwa	wartość zmiennej nazwa
${nazwa}	wartość zmiennej z jawnymi granicami nazwy (${PLIK}_kopia)
$(...)	podstawienie wyniku polecenia
`...`	podstawienie wyniku polecenia (starsza składnia)
=	przypisanie zmiennej (BEZ spacji wokół: x=5, nie x = 5)

Pozostałe

Znak	Znaczenie
#	komentarz — wszystko do końca linii ignorowane
!!	powtórz ostatnio wpisane polecenie
!$	ostatni argument poprzedniego polecenia
(...)	uruchom polecenia w podpowłoce (zmiany cd/zmiennych nie wyciekają)
{...; }	zgrupuj polecenia w bieżącej powłoce
* ? [] w case/[[ ]]	dopasowanie wzorca (też w testach), nie tylko nazw plików

Globbing rozwija się przed wykonaniem polecenia

Jeśli wpiszesz rm *.tmp, to powłoka najpierw rozwija *.tmp do listy pasujących plików, a dopiero potem rm dostaje gotową listę argumentów. Gdy żaden plik nie pasuje, polecenie dostaje literalnie *.tmp (bash domyślnie). Aby uniknąć rozwinięcia, użyj cudzysłowów: find . -name "*.tmp".

Nawigacja po systemie plików

pwd                       # bieżący katalog (print working directory)
ls                        # listing katalogu
ls -la                    # z ukrytymi plikami i szczegółami
ls -lh                    # rozmiary w jednostkach (K/M/G)
cd /etc                   # wejdź do katalogu
cd ~                      # do katalogu domowego
cd -                      # wróć do poprzedniego katalogu
pushd /tmp && popd        # zapisz katalog na stos i wróć

Skróty ścieżek wspólne dla obu systemów: ~ (home), . (bieżący), .. (wyżej), / (root).

Użytkownicy i grupy

W systemach unixowych każdy proces działa w kontekście konkretnego użytkownika i przynależy do co najmniej jednej grupy. To one — a nie sam fakt zalogowania — decydują, jakie pliki możesz odczytać, zmienić albo uruchomić. Zrozumienie tego mechanizmu to fundament tego, co znajdziesz dalej w sekcji o uprawnieniach.

Kim jestem i do jakich grup należę

whoami                              # nazwa bieżącego użytkownika
id                                  # UID, GID, lista grup (numerycznie + nazwy)
id piotr                            # to samo dla wskazanego użytkownika
groups                              # tylko nazwy grup bieżącego usera
hostname                            # nazwa maszyny

Przykład wyniku id:

uid=1000(piotr) gid=1000(piotr) groups=1000(piotr),27(sudo),100(users),999(docker)

To znaczy: użytkownik piotr (UID 1000), grupa główna piotr (GID 1000), dodatkowo należy do sudo, users i docker. Przynależność do sudo daje prawo do sudo, do docker — pracę z Dockerem bez sudo, do users — typowe dostępy domyślne.

Kto jeszcze jest w systemie

who                                 # zalogowani użytkownicy + terminal + czas logowania
w                                   # to samo, plus co właśnie robią
users                               # lakoniczna lista nazw
last                                # historia logowań (z /var/log/wtmp)
last -n 10                          # ostatnich 10 sesji

Na serwerach w to pierwsza komenda warta wpisania — pokazuje, czy ktoś jeszcze pracuje, zanim np. zrestartujesz usługę.

Bazy użytkowników i grup (Linux)

Na Linuksie definicje użytkowników i grup żyją w trzech plikach tekstowych w /etc/:

Plik	Zawartość	Uprawnienia
/etc/passwd	użytkownicy, ich UID, GID, home, powłoka	644 (czytelne dla wszystkich)
/etc/shadow	hashe haseł i polityki ich ważności	640 (root + grupa shadow)
/etc/group	grupy i ich członkowie	644

Wpis w /etc/passwd ma format nazwa:x:UID:GID:opis:home:powłoka, np.:

piotr:x:1000:1000:Piotr,,,:/home/piotr:/bin/bash

x w drugim polu znaczy „hasło jest w /etc/shadow”. Cała ta wiedza przyda się, gdy będziesz diagnozować, dlaczego ktoś nie może się zalogować albo na jaką powłokę „wpada” cron.

Tworzenie i usuwanie użytkowników (Linux)

Debian/Ubuntu mają dwa narzędzia: niskopoziomowe useradd i przyjazne adduser (skrypt Perl, pyta o szczegóły). Większość dystrybucji udostępnia oba.

sudo adduser anna                   # interaktywne - pyta o hasło, imię itp. (Debian)
sudo useradd -m -s /bin/bash anna   # niskopoziomowe - -m tworzy /home, -s ustawia powłokę
sudo passwd anna                    # ustaw / zmień hasło (interaktywnie)
 
sudo usermod -aG sudo anna          # dodaj do grupy sudo (-a żeby nie nadpisać innych grup!)
sudo usermod -aG docker anna        # podobnie - Docker bez sudo
sudo usermod -s /bin/zsh anna       # zmień powłokę
sudo usermod -L anna                # zablokuj konto (lock)
sudo usermod -U anna                # odblokuj (unlock)
 
sudo deluser anna                   # usuń użytkownika (Debian, zachowuje /home)
sudo deluser --remove-home anna     # razem z katalogiem domowym
sudo userdel -r anna                # to samo niskopoziomowo (-r usuwa /home)

usermod -G BEZ -a nadpisuje grupy

sudo usermod -G docker anna wyrzuci Annę ze wszystkich pozostałych grup, zostawiając tylko docker. Niemal zawsze chcesz -aG (append). To klasyczny strzał w stopę po skopiowaniu polecenia z internetu.

Grupy

sudo groupadd deweloperzy           # utwórz grupę
sudo groupdel deweloperzy           # usuń
sudo gpasswd -a anna deweloperzy    # dodaj Annę do grupy
sudo gpasswd -d anna deweloperzy    # usuń Annę z grupy
sudo gpasswd -A piotr deweloperzy   # ustaw Piotra adminem grupy (-M lista członków)

Zmiana grup nie obowiązuje od razu

Po dodaniu się (lub kogoś) do grupy zmiany nie pojawią się w aktywnych sesjach — trzeba się wylogować i zalogować ponownie albo wymusić nową powłokę przez newgrp grupa. Symptom: właśnie dodałeś się do grupy docker, ale docker ps dalej wymaga sudo.

Przełączanie użytkownika

su anna                             # przełącz się na Annę (potrzebne JEJ hasło)
su - anna                           # to samo, ale z czystym środowiskiem (jak po loginie)
exit                                # wracasz do siebie

Kluczowy jest myślnik: su anna zachowuje twoje zmienne środowiskowe (PATH, HOME), a su - anna ładuje środowisko Anny od zera. W praktyce prawie zawsze chcesz wariant z myślnikiem.

sudo to inna filozofia — nie wymaga hasła docelowego użytkownika, tylko twojego (i przynależności do sudo/wheel):

sudo -i                             # interaktywna powłoka roota (jak su - root, ale twoim hasłem)
sudo -u anna polecenie              # uruchom JEDNO polecenie jako Anna
sudo -u www-data php script.php     # typowe - uruchom skrypt jako użytkownik usługi
sudo -l                             # lista poleceń, do których masz uprawnienia

macOS — dscl i sysadminctl

macOS przechowuje użytkowników w OpenDirectory, a nie w /etc/passwd (plik istnieje, ale leżą w nim tylko konta systemowe). Standardowe linuxowe useradd nie zadziała. Z terminala dostępne są:

# Lista użytkowników (filtrujemy spod-_ konta systemowe)
dscl . -list /Users | grep -v "^_"
 
# Tworzenie użytkownika (od macOS 10.13)
sudo sysadminctl -addUser anna -fullName "Anna Nowak" -password "tajne"
sudo sysadminctl -deleteUser anna
 
# Dodanie do grupy admin
sudo dseditgroup -o edit -a anna -t user admin
 
# Inspekcja
id anna
groups anna
dscl . -read /Users/anna             # pełny zapis konta z OpenDirectory

Dla pojedynczego polecenia su i sudo -u działają na macOS identycznie jak na Linuksie.

Konta _xxx to konta usług

Nazwy zaczynające się od _ (np. _www, _postgres) to systemowi „pseudoużytkownicy” przypisani do konkretnych usług. Mają zwykle powłokę /usr/bin/false (nie da się zalogować), służą tylko do izolowania uprawnień procesów. Nie usuwaj ich — system ich potrzebuje.

Uprawnienia plików

Każdy plik i katalog w systemie unixowym ma przypisane uprawnienia mówiące, kto może go odczytać, zmienić lub uruchomić. Ten mechanizm sprawia, że zwykły użytkownik nie skasuje pliku konfiguracyjnego z /etc/, a nieproszony program nie podejrzy twojego klucza SSH.

Czytanie listingu ls -l

Polecenie ls -l pokazuje uprawnienia w pierwszej kolumnie:

$ ls -l plik.txt
-rw-r--r--  1 piotr  staff  1234 May  8 14:20 plik.txt

Pierwszy znak to typ wpisu: - to plik, d to katalog, l to link symboliczny. Kolejne 9 znaków to trzy trójki uprawnień dla trzech grup użytkowników:

 typ  │ właściciel │   grupa   │ pozostali
  -   │   r w x    │   r w x   │   r w x

Litera	Plik	Katalog
r	odczyt zawartości	listowanie zawartości katalogu (ls)
w	modyfikacja zawartości	tworzenie/usuwanie plików w katalogu
x	uruchomienie pliku	wejście do katalogu (cd)
-	brak danego prawa	brak danego prawa

W przykładzie -rw-r--r-- znaczy: zwykły plik, właściciel może czytać i pisać, grupa i reszta — tylko czytać. Nikt nie może go uruchomić.

x na katalogu jest niezbędne

Bez prawa x na katalogu nie wejdziesz do niego (cd), nawet jeśli masz r (zobaczysz listę nazw plików, ale nie ich zawartość).

Zmiana uprawnień — chmod

chmod ma dwie składnie: liczbową i symboliczną. Obie robią to samo, ale w różnych sytuacjach jedna jest wygodniejsza.

Notacja liczbowa koduje każdą trójkę uprawnień jedną cyfrą (suma: r=4, w=2, x=1):

Cyfra	Uprawnienia	Co znaczy
7	rwx	pełne
6	rw-	odczyt + zapis
5	r-x	odczyt + uruchomienie
4	r--	tylko odczyt
0	---	brak

Trzy cyfry razem opisują uprawnienia dla właściciela, grupy i reszty:

chmod 644 plik.txt                  # rw-r--r-- - typowy plik tekstowy
chmod 755 skrypt.sh                 # rwxr-xr-x - wykonywalny skrypt/program
chmod 600 ~/.ssh/id_ed25519         # rw------- - klucz prywatny SSH (nikt poza tobą)
chmod 700 ~/.ssh                    # rwx------ - katalog .ssh
chmod -R 755 katalog/               # rekurencyjnie cały katalog

Notacja symboliczna zmienia konkretne bity bez nadpisywania całości. Trzy elementy: kto + operator + co.

Kto	Operator	Co
u (user/właściciel)	+ (dodaj)	r
g (group/grupa)	- (usuń)	w
o (others/pozostali)	= (ustaw)	x
a (all = u+g+o)

chmod +x skrypt.sh                  # dodaj prawo uruchamiania (a+x - wszystkim)
chmod u+w plik                      # właścicielowi: dodaj zapis
chmod g-w plik                      # grupie: zabierz zapis
chmod o=r plik                      # pozostałym: ustaw tylko odczyt
chmod u+x,g-w skrypt.sh             # kilka zmian naraz, oddzielone przecinkiem

Zmiana właściciela — chown i chgrp

sudo chown piotr plik.txt           # zmień właściciela
sudo chown piotr:staff plik.txt     # właściciel + grupa (macOS - domyślna grupa staff)
sudo chown piotr:piotr plik.txt     # Linux - typowo grupa o nazwie użytkownika
sudo chgrp staff plik.txt           # tylko grupa
sudo chown -R user:group katalog/   # rekurencyjnie cały katalog

Domyślne grupy różnią się: na Debianie/Ubuntu każdy użytkownik ma własną grupę o tej samej nazwie, na macOS wszyscy zwykli użytkownicy są w grupie staff.

sudo — tymczasowe podniesienie uprawnień

Niektóre operacje (modyfikacja /etc/, instalacja pakietów, restart usługi systemowej) wymagają uprawnień administratora. sudo uruchamia jedno polecenie jako root, prosząc o twoje hasło:

sudo apt install nginx              # instalacja wymaga root
sudo systemctl restart nginx        # restart usługi
sudo chown piotr plik.txt           # zmiana cudzego pliku
sudo !!                             # powtórz ostatnio wpisane polecenie z sudo

Hasło zapamiętywane jest na kilka minut — kolejne sudo w krótkim czasie nie zapyta ponownie.

SSH wymaga ścisłych uprawnień

SSH odmówi połączenia, jeśli plik klucza prywatnego ma zbyt liberalne uprawnienia (np. 644). Wymagane: chmod 600 ~/.ssh/id_ed25519 i chmod 700 ~/.ssh. To częsta pułapka po skopiowaniu klucza z innej maszyny.

Pliki i katalogi

touch plik.txt                      # utwórz pusty plik (lub zaktualizuj mtime)
mkdir nowy-katalog                  # utwórz katalog
mkdir -p a/b/c                      # z brakującymi rodzicami
cp zrodlo.txt cel.txt               # kopiuj plik
cp -r katalog/ kopia/               # kopiuj rekurencyjnie
mv stara-nazwa nowa-nazwa           # zmień nazwę / przenieś
rm plik.txt                         # usuń plik
rm -r katalog/                      # usuń rekurencyjnie
rm -rf katalog/                     # bez pytań - uważaj!
rmdir pusty-katalog                 # usuń tylko pusty katalog
ln -s /sciezka/oryginal link        # link symboliczny

rm -rf jest nieodwracalne

Na obu systemach kosz jest osobnym mechanizmem (Finder/Pliki). Komenda rm usuwa od razu — nie wpadnie do kosza. Zanim odpalisz rm -rf $ZMIENNA/, upewnij się że zmienna nie jest pusta.

Wyświetlanie zawartości plików

cat plik.txt                        # cała zawartość
less plik.txt                       # interaktywne przewijanie
head -n 20 plik.txt                 # 20 pierwszych linii
tail -n 20 plik.txt                 # 20 ostatnich linii
tail -f /var/log/syslog             # śledzenie nowych linii (logi)
wc -l plik.txt                      # zlicz linie

W less (i podobnych pagerach typu man, journalctl) działają te same klawisze:

Klawisz	Działanie
q	wyjście
Spacja	strona w dół
b	strona w górę
g	skok na początek pliku
G	skok na koniec pliku
/wzorzec	szukaj w przód
?wzorzec	szukaj wstecz
n / N	następne / poprzednie trafienie
h	pomoc

Liczenie linii, słów i bajtów — wc

wc (od word count) zlicza linie, słowa, znaki lub bajty — w pliku albo w danych przekazanych przez potok. To jedno z najczęściej używanych narzędzi pomocniczych w łańcuchach potoków: gdy potrzebujesz tylko liczby, a nie samej zawartości.

wc plik.txt                         # 3 wartości: linie, słowa, bajty + nazwa pliku
wc -l plik.txt                      # tylko liczba linii
wc -w plik.txt                      # tylko liczba słów
wc -c plik.txt                      # liczba bajtów
wc -m plik.txt                      # liczba znaków (różne od -c dla UTF-8)
wc -L plik.txt                      # długość najdłuższej linii
wc -l *.md                          # zlicz w wielu plikach (z wierszem total na końcu)

W połączeniu z potokiem wc zmienia się w licznik wszystkiego, co da się wypisać liniami:

ls | wc -l                          # ile wpisów w bieżącym katalogu
ps aux | wc -l                      # liczba procesów (+1 za nagłówek)
grep "ERROR" app.log | wc -l        # ile linii zawiera słowo "ERROR"
find . -name "*.py" | wc -l         # ile plików .py w drzewie
history | wc -l                     # długość historii powłoki

-c vs -m przy UTF-8

-c (bytes) i -m (characters) różnią się, gdy plik zawiera znaki spoza ASCII. W UTF-8 polski znak „ę” zajmuje 2 bajty, ale jest 1 znakiem. Do liczenia długości tekstu używaj -m, do rzeczywistego rozmiaru pliku — -c.

grep -c zamiast grep | wc -l

Jeśli chcesz tylko policzyć linie pasujące do wzorca, grep -c "wzorzec" plik jest krótsze i nie tworzy dodatkowego procesu. Różnica praktyczna: przy wielu plikach grep -c zwraca liczbę dla każdego pliku osobno, a grep ... | wc -l — łączną sumę.

Edytory tekstu

W terminalu najczęściej używa się nano (proste, intuicyjne) lub vim/vi (potężne, ale wymaga nauki). Oba są dostępne na Debianie i macOS — nano często domyślnie, vim przez apt install vim / brew install vim (macOS ma fabrycznie vi, czyli okrojony wariant).

nano — dla początkujących

nano plik.txt                       # otwórz (lub utwórz) plik

Skróty wyświetlone na dole ekranu (^ oznacza Ctrl):

Skrót	Działanie
Ctrl+O	zapisz (Write Out)
Ctrl+X	wyjdź (zapyta, czy zapisać)
Ctrl+W	szukaj
Ctrl+K	wytnij linię
Ctrl+U	wklej
Ctrl+G	pomoc

vim/vi — modalny edytor

vim ma tryby — najważniejsze to normal (po starcie, do nawigacji i komend) i insert (do pisania).

vim plik.txt                        # otwórz plik

Komenda	Działanie
i	wejdź w tryb insert (zaczynasz pisać)
Esc	wróć do trybu normal
:w	zapisz
:q	wyjdź (jeśli brak zmian)
:wq / ZZ	zapisz i wyjdź
:q!	wyjdź bez zapisywania (porzuć zmiany)
dd	usuń linię
yy + p	skopiuj linię (yank) i wklej
u	cofnij zmianę
/wzorzec	szukaj

Awaryjne wyjście z vima

Jeśli przypadkowo trafiłeś do vima (np. git commit bez -m) i nie wiesz, jak wyjść — wciśnij Esc, potem :q! i Enter. Wyjdziesz bez zapisywania zmian. To najczęściej zadawane pytanie na Stack Overflow w historii.

Wyszukiwanie plików i tekstu

find . -name "*.md"                 # pliki MD w bieżącym drzewie
find . -type d -name "test*"        # katalogi zaczynające się od test
find . -mtime -7                    # zmodyfikowane w ostatnich 7 dniach
find . -size +100M                  # większe niż 100 MB
 
grep "TODO" plik.txt                # szukaj literalnego tekstu "TODO"
grep -r "TODO" .                    # rekurencyjnie w bieżącym katalogu
grep -i "todo" plik.txt             # ignoruj wielkość liter (znajdzie też TODO, Todo)
grep -n "TODO" plik.txt             # z numerami linii
grep -v "TODO" plik.txt             # linie NIE zawierające "TODO"
grep -E "TODO|FIXME" plik.txt       # regex rozszerzony - wiele wariantów naraz
grep -w "log" plik.txt              # tylko całe słowo "log" (nie "logs", "login")

find różni się drobnymi flagami

Na Linuksie (GNU find) działa np. find . -printf, na macOS (BSD find) tej flagi nie ma. Podstawowe użycie (-name, -type, -mtime) jest identyczne.

Przetwarzanie tekstu — awk

awk to mały język programowania ukierunkowany na przetwarzanie tekstu wiersz po wierszu — szczególnie dobrze radzi sobie z danymi w kolumnach (logi, tabele, CSV). Jest na każdym Linuksie i macOS bez instalacji. Tam, gdzie grep tylko filtruje linie, awk pozwala je przekształcić: wyciągnąć wybrane kolumny, policzyć sumy, przeliczyć wartości, posortować po polu.

Podstawowa składnia

awk 'wzorzec { akcja }' plik

• wzorzec (opcjonalny) — które linie przetworzyć (regex, warunek logiczny, słowa kluczowe BEGIN / END)
• akcja w nawiasach klamrowych — co zrobić z pasującą linią (najczęściej print)

Bez wzorca akcja wykonuje się dla każdej linii. Bez akcji domyślnie wypisywana jest cała linia (jak grep).

Pola, czyli kolumny

awk automatycznie dzieli każdą linię na pola po białych znakach. Odwołujesz się do nich przez $1, $2, …, $NF (ostatnie pole). $0 to cała linia.

echo "Anna Kowalska 42" | awk '{print $1}'                 # Anna
echo "Anna Kowalska 42" | awk '{print $2, $3}'             # Kowalska 42
echo "Anna Kowalska 42" | awk '{print $NF}'                # 42 (ostatnie pole)
echo "Anna Kowalska 42" | awk '{print $1, "ma", $3, "lat"}' # Anna ma 42 lat

Inny separator pól — flaga -F

Domyślnie pola rozdzielają białe znaki. Dla CSV, /etc/passwd itp. ustawiamy własny separator:

awk -F: '{print $1}' /etc/passwd                # nazwy użytkowników (1. pole, separator :)
awk -F, '{print $2}' dane.csv                   # 2. kolumna z CSV
awk -F'\t' '{print $1, $3}' tabela.tsv          # tabela rozdzielana tabulatorem

Filtrowanie po wzorcu i warunku

Wzorzec przed { } zawęża linie do interesujących nas:

awk '/ERROR/' app.log                           # linie zawierające "ERROR" (jak grep)
awk '/ERROR/ {print $1, $2}' app.log            # tylko data + czas z linii błędów
awk '$3 > 100' dane.txt                         # linie, w których 3. kolumna > 100
awk 'NR > 1' dane.csv                           # pomiń pierwszą linię (np. nagłówek CSV)
awk 'NF == 5' plik                              # tylko linie mające dokładnie 5 pól
awk '$1 == "anna" {print $0}' /etc/passwd       # linia, gdzie 1. pole = "anna"

Zmienna	Co reprezentuje
$0	cała bieżąca linia
$1-$N	kolejne pola
NF	liczba pól w bieżącej linii
NR	numer bieżącej linii (od 1)
FS	aktualny separator pól (domyślnie biały znak)

Bloki BEGIN i END

BEGIN wykonuje się przed pierwszą linią, END — po ostatniej. Przydatne do nagłówków, sumowania, statystyk.

awk -F: 'BEGIN {print "User\tShell"} {print $1"\t"$7}' /etc/passwd
 
# Suma 3. kolumny z pominięciem nagłówka
awk 'NR > 1 {sum += $3} END {print "Suma:", sum}' dane.csv
 
# Średnia
awk '{sum += $1; n++} END {print sum/n}' liczby.txt
 
# Liczba linii zawierających słowo "ERROR"
awk '/ERROR/ {n++} END {print n}' app.log

Praktyczne przykłady z życia

# Top 10 IP-ów odwiedzających serwer (z access.log)
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head
 
# Lista użytkowników mających powłokę bash
awk -F: '$7 == "/bin/bash" {print $1}' /etc/passwd
 
# Procesy zużywające > 100 MB RAM (kolumna RSS w ps)
ps aux | awk 'NR > 1 && $6/1024 > 100 {print $11, $6/1024 "MB"}'
 
# Suma rozmiarów plików .log w katalogu
ls -l *.log | awk '{sum += $5} END {print sum/1024/1024 "MB"}'
 
# Wybierz partycje, które są zapełnione w >80%
df -h | awk 'NR > 1 && $5+0 > 80 {print $1, $5}'

awk vs cut

Do prostego wybrania n-tej kolumny cut -d: -f1 /etc/passwd jest krótsze niż awk -F: '{print $1}'. awk przewyższa cut, gdy potrzebujesz warunków (if), arytmetyki (sumy, średnie), formatowania wyjścia albo separator pól jest „elastyczny” (np. wiele spacji jako jeden).

Sprawdzanie wolnego miejsca

df -h                               # zajętość partycji w czytelnych jednostkach
df -h /                             # tylko partycja root
 
du -sh katalog/                     # rozmiar katalogu (sumarycznie)
du -h --max-depth=1 .               # rozmiary podkatalogów (Linux)
du -h -d 1 .                        # to samo na macOS (BSD du)
 
# RAM
free -h                             # Linux
vm_stat                             # macOS (strony × 4096 = bajty)
top                                 # procesy + RAM (q żeby wyjść)
htop                                # ładniejsze top (apt install / brew install)

Procesy

ps aux                              # wszystkie procesy
ps aux | grep nginx                 # filtruj
pgrep -fl python                    # PID procesów pasujących do wzorca
kill 12345                          # SIGTERM dla PID 12345
kill -9 12345                       # SIGKILL (ostatnia deska ratunku)
pkill -f "nazwa-skryptu"            # zabij po wzorcu

nohup — komenda przeżywa rozłączenie terminala

Domyślnie, gdy zamkniesz terminal albo rozłączysz się z sesją SSH, wszystkie uruchomione w nim procesy potomne dostają sygnał SIGHUP (hangup) i zwykle kończą działanie. nohup (od no hangup) ignoruje ten sygnał — pozwala uruchomić długie zadanie i bezpiecznie się wylogować:

nohup python long_task.py &                 # uruchom w tle, odporne na rozłączenie
nohup ./backup.sh > backup.log 2>&1 &       # wyjście i błędy do pliku

Bez przekierowań nohup automatycznie zapisuje stdout i stderr do pliku nohup.out w bieżącym katalogu (jeśli ma do niego prawo zapisu) lub w $HOME/nohup.out:

nohup ./skrypt.sh                           # wyjście trafia do ./nohup.out
tail -f nohup.out                           # śledź postęp

Trzy elementy często chodzą w parze:

Element	Rola
nohup	ignoruje SIGHUP przy rozłączeniu terminala
& (na końcu)	uruchomienie w tle (oddaje prompt)
przekierowanie do pliku	wyjście idzie tam, gdzie ma — nie blokuje terminala

Pełny scenariusz „uruchom na serwerze i się wyloguj”:

nohup python serwer.py > serwer.log 2>&1 &  # uruchom
echo $!                                     # PID właśnie uruchomionego procesu
disown                                      # usuń z listy zadań powłoki (opcjonalne)
exit                                        # wyloguj - proces żyje dalej
 
# Po powrocie:
pgrep -fl serwer.py                         # znajdź PID
tail -n 100 serwer.log                      # zerknij, co tam zalogowało
kill <PID>                                  # zatrzymaj, gdy skończysz

nohup vs tmux/screen vs systemd

• nohup — sprawdza się dla pojedynczych zadań fire-and-forget (backup, migracja, długi build). Nie da się wrócić do interaktywnej sesji.
• tmux / screen — multipleksery terminali. Pozwalają nie tylko przeżyć rozłączenie, ale też wrócić do uruchomionej powłoki (tmux attach) i pracować dalej interaktywnie. Lepsze do pracy ręcznej.
• systemd (Linux) — usługa systemowa. Najlepsza dla rzeczy, które mają działać zawsze (serwer aplikacji, daemon). Restart przy padzie, autostart po reboocie, logi w journalctl.

& bez nohup często wystarczy

Współczesny bash (z huponexit wyłączonym, jak w domyślnej konfiguracji Debiana) nie wysyła SIGHUP do procesów uruchomionych z &, gdy wyjdziesz przez exit. Ale przy zerwaniu połączenia SSH (np. utrata sieci) sygnał i tak doleci. nohup (albo disown -h) daje pewność niezależnie od scenariusza.

Sieć i HTTP

ping -c 4 example.com               # 4 pakiety
curl -I https://example.com         # tylko nagłówki HTTP
curl -L -o plik.zip https://...     # pobierz, podążając za redirectami
wget https://...                    # alternatywa (Linux domyślnie, brew na macOS)
 
# Otwarte porty / połączenia
ss -tulpn                           # Linux (zastąpiło netstat)
lsof -i :8080                       # kto słucha na porcie 8080 (oba systemy)
lsof -nP -iTCP -sTCP:LISTEN         # wszystkie nasłuchujące porty TCP
 
# Konfiguracja interfejsów
ip addr                             # Linux
ifconfig                            # macOS (na Linuksie też działa, ale przestarzałe)

SSH i klucze

# Generowanie nowej pary kluczy (ed25519 - szybki, bezpieczny)
ssh-keygen -t ed25519 -C "komentarz"
# Domyślnie: ~/.ssh/id_ed25519 (prywatny) i ~/.ssh/id_ed25519.pub (publiczny)
 
# Wgranie klucza publicznego na serwer
ssh-copy-id user@host               # Linux + macOS (od macOS Monterey)
# Alternatywa: ręczne dopisanie do ~/.ssh/authorized_keys
 
# Połączenie
ssh user@host
ssh -p 2222 user@host               # niestandardowy port
ssh -i ~/.ssh/inny_klucz user@host  # konkretny klucz
 
# Kopiowanie plików
scp plik.txt user@host:~/           # plik na serwer
scp user@host:~/plik.txt .          # z serwera
rsync -avz katalog/ user@host:~/    # synchronizacja (lepsze niż scp dla wielu plików)
 
# Agent SSH (cache hasła do klucza)
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
ssh-add --apple-use-keychain ~/.ssh/id_ed25519  # macOS, zapis do Keychain

Plik ~/.ssh/config pozwala definiować skróty:

Host serwer_domowy
    HostName 192.168.1.255
    User root
    Port 22
    IdentityFile ~/.ssh/klucz_ssh

Po zapisie wystarczy ssh serwer_domowy.

Archiwa: tar, gzip, zip

# tar.gz - najczęstszy format na Linuksie i macOS
tar -czvf archiwum.tar.gz katalog/  # spakuj (c=create, z=gzip, v=verbose, f=file)
tar -xzvf archiwum.tar.gz           # rozpakuj (x=extract)
tar -tzvf archiwum.tar.gz           # podgląd zawartości bez rozpakowywania
tar -xzvf archiwum.tar.gz -C /tmp   # rozpakuj do konkretnego katalogu
 
# Sam gzip (kompresja pojedynczego pliku)
gzip plik.txt                       # tworzy plik.txt.gz, usuwa oryginał
gzip -k plik.txt                    # zachowaj oryginał (-k = keep)
gunzip plik.txt.gz                  # rozpakuj
zcat plik.txt.gz                    # podgląd skompresowanej zawartości
 
# zip - gdy potrzebny format kompatybilny z Windows
zip -r archiwum.zip katalog/
unzip archiwum.zip
unzip -l archiwum.zip               # podgląd zawartości

Logi systemowe

Linux — journalctl (systemd)

journalctl -xe                      # ostatnie wpisy z dodatkowym kontekstem
journalctl -u nginx                 # logi konkretnej usługi
journalctl -u nginx -f              # śledzenie na żywo (jak tail -f)
journalctl --since "1 hour ago"     # filtr czasowy
journalctl --since today
journalctl -p err                   # tylko błędy (priorytet >= err)
journalctl --disk-usage             # ile miejsca zajmuje dziennik
sudo journalctl --vacuum-time=7d    # zostaw tylko z ostatnich 7 dni

Tradycyjne pliki logów (Debian): /var/log/syslog, /var/log/auth.log, /var/log/nginx/.

macOS — log show / Console.app

log show --last 1h                  # ostatnia godzina
log show --predicate 'process == "nginx"' --last 1h
log stream                          # logi na żywo

Aplikacja Console.app to graficzna alternatywa.

systemd (Linux) — usługi

systemd to system inicjalizacyjny Debiana, Ubuntu i większości dystrybucji. Sterowanie usługami przez systemctl.

# Status i sterowanie
sudo systemctl status nginx
sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx
sudo systemctl reload nginx         # przeładuj konfigurację bez restartu
 
# Włącz/wyłącz autostart
sudo systemctl enable nginx
sudo systemctl disable nginx
sudo systemctl is-enabled nginx
 
# Lista usług
systemctl list-units --type=service
systemctl list-units --failed       # tylko te, które padły
 
# Po edycji pliku .service
sudo systemctl daemon-reload

Pliki usług użytkownika: /etc/systemd/system/*.service. Po zmianie zawsze daemon-reload.

Odpowiednik na macOS — launchd

macOS używa launchd zamiast systemd. Sterowanie: launchctl load/unload/start/stop. Pliki .plist w ~/Library/LaunchAgents/ (per użytkownik) lub /Library/LaunchDaemons/ (globalne). Składnia jest inna niż w systemd, ale logika podobna.

cron — zadania cykliczne

cron działa identycznie na obu systemach (z drobnymi różnicami w domyślnym shellu i ścieżkach).

crontab -l                          # wyświetl harmonogram bieżącego użytkownika
crontab -e                          # edycja (otwiera $EDITOR)
sudo crontab -e                     # harmonogram roota
crontab -r                          # usuń cały harmonogram (uwaga!)

Format wpisu (5 pól + komenda):

#  ┌──── minuta (0-59)
#  │ ┌── godzina (0-23)
#  │ │ ┌── dzień miesiąca (1-31)
#  │ │ │ ┌── miesiąc (1-12)
#  │ │ │ │ ┌── dzień tygodnia (0-7, 0 i 7 = niedziela)
#  │ │ │ │ │
   0 4 * * * python3.12 /var/www/example.com/cron/skrypt.py

Częste przykłady:

*/15 * * * *  command          # co 15 minut
0 */2 * * *   command          # co 2 godziny
0 4 * * *     command          # codziennie o 04:00
0 0 * * 0     command          # co niedzielę o północy
@reboot       command          # przy starcie systemu

Logi crona: /var/log/syslog (Debian) lub journalctl -u cron. Na macOS: log show --predicate 'process == "cron"'.

Użyj pełnych ścieżek

cron ma minimalny $PATH. Wpisuj /usr/bin/python3 zamiast python3, albo ustaw PATH=... na początku crontaba.

Menedżer pakietów

Debian/Ubuntu — apt

sudo apt update                     # odśwież listę dostępnych pakietów
sudo apt upgrade                    # aktualizuj zainstalowane
sudo apt full-upgrade               # z usuwaniem konfliktujących
sudo apt install nginx              # instaluj
sudo apt remove nginx               # usuń (zachowaj konfigurację)
sudo apt purge nginx                # usuń razem z konfiguracją
sudo apt autoremove                 # usuń osierocone zależności
apt search nazwa                    # szukaj
apt show pakiet                     # informacje o pakiecie
apt list --installed                # zainstalowane pakiety

macOS — Homebrew

macOS nie ma własnego menedżera pakietów dla narzędzi wiersza poleceń — popularny jest Homebrew instalowany ręcznie. Wystarczy jedno polecenie skopiowane z brew.sh:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Instalator zapyta o hasło administratora, dograje Command Line Tools (jeśli ich nie ma) i utworzy katalog roboczy w /opt/homebrew (Apple Silicon) lub /usr/local (procesory Intel). Po zakończeniu może wypisać kilka linii do dopisania do ~/.zshrc (lub ~/.zprofile) — zwykle ustawienie PATH. Skopiuj je dosłownie i otwórz nowy terminal.

Sprawdź, czy działa:

brew --version
brew doctor                         # diagnostyka - powinno wypisać "Your system is ready to brew"

Homebrew nie wymaga sudo przy codziennej pracy — wszystko, co instaluje, trafia do katalogu, do którego twój użytkownik ma prawo zapisu.

brew update                         # odśwież formuły
brew upgrade                        # aktualizuj wszystko
brew upgrade nazwa                  # aktualizuj konkretny pakiet
brew install nazwa                  # instaluj
brew uninstall nazwa                # usuń
brew install --cask nazwa           # instaluj aplikację GUI (cask)
brew search nazwa                   # szukaj
brew info nazwa                     # informacje
brew list                           # zainstalowane
brew doctor                         # diagnostyka
brew cleanup                        # usuń stare wersje

Plik Brewfile (brew bundle dump) pozwala wyeksportować listę pakietów i odtworzyć setup na nowej maszynie.

Skróty edycyjne w terminalu

W większości powłok (bash, zsh) działają te same skróty:

Skrót	Działanie
Ctrl+A	początek linii
Ctrl+E	koniec linii
Ctrl+U	wytnij linię w lewo od kursora
Ctrl+K	wytnij linię w prawo od kursora
Ctrl+W	usuń słowo w lewo
Ctrl+R	przeszukiwanie historii
Ctrl+L	wyczyść ekran (clear)
Ctrl+C	przerwij bieżący proces
Ctrl+D	EOF / wyjdź z powłoki
Ctrl+Z	wstrzymaj proces (wznów: fg lub bg)
!!	powtórz ostatnią komendę
!$	ostatni argument poprzedniej komendy

Zobacz także

• IT — indeks narzędzi informatycznych
• Git - podstawowe operacje — wersjonowanie kodu i dokumentacji
• Docker - podstawowe operacje — uruchamianie aplikacji w kontenerach
• Bielik MCP — MCP server jako przykład skryptu uruchamianego z terminala
• Raspberry Pi Zero i Zigbee2MQTT — praktyczne użycie systemd, apt, ssh w jednym projekcie
• Debian Reference — oficjalna dokumentacja Debiana
• macOS Terminal User Guide — dokumentacja Apple
• explainshell.com — interaktywne wyjaśnianie komend wraz z flagami