Kuidas seda õpikut kasutada

See õpik on praktiline tööriist:

• kiireks meeldetuletuseks
• käskude loogika õppimiseks
• näidete kopeerimiseks ja läbi proovimiseks
• harjutuste tegemiseks

Kui oled täiesti algaja, alusta nii

Kui sul puudub käsurea kogemus, siis ei pea sa kogu raamatut korraga haarama. Rahulik esimene rada on:

1. Terminali esimesed sammud
2. Abi leidmine: man, --help ja info
3. Kataloogid ja failid
4. Teksti vaatamine ja liikumine
5. Failide muutmine: nano ja esimene kokkupuude vim-iga
6. Käskude kuju ja argumentide loogika
7. Sisend, väljund, torud ja suunamine
8. Esimene tervikharjutus: 30 minutit

Tööta alguses oma harjutuskaustas, tee väikesi samme ja kontrolli iga sammu järel tulemust. Täpsema teekaardi eri eesmärkide jaoks leiad peatükist Õpitee ja õppetunnid.

Kui tahad üsna alguses turvalist harjutuskohta, kus saab käske läbi proovida ja ülesandeid lahendada, siis võid kasutada ka Tartu Ülikooli keskkonda terminal.cs.ut.ee. Seal saad katsetada valmis harjutustega ilma, et peaksid omaenda masinas kohe kõike seadistama.

Mida sa ei pea veel teadma

Esimeses ringis ei pea sa veel tundma:

• regulaaravaldisi
• Git-i, SSH-d ega Dockerit
• keerulisemaid käsuahelaid ja töövooge
• süsteemi administraatori võtteid

Piisab sellest, kui oskad terminalis liikuda, abi vaadata, faile leida ja väikseid muudatusi turvaliselt kontrollida.

Põhimõisted: CLI ja GUI

Selles õpikus kohtad sageli sõna CLI. See tuleb ingliskeelsest väljendist command-line interface.

Selle kõige loomulikum eestikeelne vaste on:

• CLI ehk käsurealiides

Tavaline alternatiiv sellele on:

• GUI ehk graafiline kasutajaliides

Praktiline vahe on lihtne:

• CLI tähendab, et suhtled arvutiga käske kirjutades
• GUI tähendab, et suhtled akende, nuppude, menüüde ja ikoonide kaudu

Terminal on tavaliselt see programm või aken, mille kaudu CLI-d kasutatakse. Shell on omakorda käsutõlk selle terminali sees.

Õpik keskendub peamiselt CLI-le, kuid võrdleb seda vajadusel ka GUI-ga.

Kuidas peatükki lugeda

Enamik peatükke töötab kõige paremini nii:

1. loe kõigepealt loogikaosa, et saada aru, milleks seda tööriista vaja on
2. vaata süntaksit või kiirspikrit
3. proovi lühikesed näited ise läbi
4. tee minitest või harjutus

Kui mõni sümbol, lipp või käsk tundub liiga vara võõras, peatu korraks ja mine eelmise sammu juurde tagasi. Õpik on mõeldud kasutamiseks väikeste, kontrollitavate osadena.

Näidete põhimõte

Näited peaksid olema:

• piisavalt ohutud, et ei muudaks kogemata päris tööfaile
• väikeste sammudena
• kopeeritavad
• kontrollitava tulemusega

Hea näide õpetab ühe töövõtte loogikat ja näitab kohe tulemust.

Näiteks:

pwd
ls
mkdir proov
cd proov
mkdir naide
cd naide
printf 'tere\nmaailm\n' > sonad.txt
wc -l sonad.txt

Siin kontrollid alguskohta, lood harjutuskausta, kirjutad faili kaks rida ja kontrollid tulemuse üle.

Kaks lugemisviisi

Õpikut tasub kasutada kahel viisil:

• järjest õppides peatükist peatükki
• käsiraamatuna, kui on vaja kiirelt midagi meelde tuletada

Kui tahad lisaks õpikule ka ametlikke ja usaldusväärseid algmaterjale, siis vaata lisa Lisa E: usaldusväärsed viited ja lisalugemine.

Õpitee ja õppetunnid

See peatükk aitab valida, mis järjekorras lugeda. Raamatut saab kasutada ka käsiraamatuna, kuid alguses on lihtsam liikuda kindla õpitee järgi.

Kui tahad liikuda võimalikult rahulikult lihtsamast keerulisemani, alusta peatükist Terminali esimesed sammud. Peatükk Esimene tervikharjutus: 30 minutit on mõeldud hiljem, kui baas on juba all.

Kuidas seda peatükki kasutada

Kui oled täiesti alguses, ära loe raamatut järjest algusest lõpuni nagu romaani. Vaata seda pigem osade kaupa:

1. kõigepealt õpi, kuidas käsurida lugeda ja kasutada
2. siis ehita juurde süsteemipilt: failisüsteem, õigused, kettaruum, paketid
3. seejärel mine failide, võrgu ja süsteemitöö juurde
4. alles pärast seda võta suuremad töövood nagu Git, Docker ja arenduskeskkonnad

See järjekord on oluline, sest hilisemad teemad ehituvad varasematele. Näiteks:

• ssh kasutab sama käsurea loogikat, mida õpid varem
• git käsud kasutavad samu valikute ja argumentide mustreid
• rsync, grep, find ja torud muutuvad arusaadavaks alles siis, kui failide ja voogude põhimõte on selge
• veaotsing muutub palju lihtsamaks, kui tead juba, kus failid süsteemis elavad

Kiirtee: algajast töövõimeliseks kasutajaks

Staatus: soovitatav, kui tahad kiiresti saada praktiliselt kasutatavaks käsurea kasutajaks.

See ei ole kõige rahulikum rada, aga viib kiiresti seisuni “ma saan päris asju tehtud”.

Vaata peatükke selles järjekorras:

1. Terminali esimesed sammud
2. Abi leidmine: man, --help ja info
3. Kataloogid ja failid
4. Sisend, väljund, torud ja suunamine
5. Lihtne veaotsing käsureal
6. Failide kopeerimine ja sünkroonimine
7. Kauglogimine ja SSH
8. Logid ja teenused
9. Git, GitHub ja töövoog

Pärast seda kiirteed oskad juba:

• liikuda terminalis kindlamalt ja otsida abi ilma paanikata
• kopeerida faile, ühendada käske torudega ja lugeda lihtsamaid veateateid
• logida serverisse, tuua või saata faile ja vaadata logidest, mis toimub
• teha väikese muudatuse Gitis ning kontrollida enne commit'i, mis päriselt muutus

Õpitee 1: täiesti algaja

Staatus: vajalik esimeses ringis.

Vaata peatükke selles järjekorras:

1. Kuidas seda õpikut kasutada
2. Terminali esimesed sammud
3. Abi leidmine: man, --help ja info
4. Kataloogid ja failid
5. Teksti vaatamine ja liikumine
6. Failide muutmine: nano ja esimene kokkupuude vim-iga
7. Käskude kuju ja argumentide loogika
8. Sisend, väljund, torud ja suunamine
9. Esimene tervikharjutus: 30 minutit
10. Linux, Unix, GNU, macOS, Windows ja shellid

Pärast seda rada oskad juba:

• terminalis liikuda
• faile leida, vaadata ja muuta
• abi otsida
• aru saada, miks käsud käituvad nii nagu nad käituvad
• ning alles siis paigutada need oskused Linuxi, macOS-i ja Windowsi laiemasse konteksti

Õpitee 2: süsteemi pildi loomine

Staatus: vajalik pärast esimest ringi.

Kui baas on all, liigu siia:

1. Failisüsteemi kaart
2. Kettaruum ja süsteemi maht
3. Õigused, omanikud ja täitmisbitid
4. Kasutajad, grupid ja sudo
5. Muutujad, keskkond, PATH ja aliased
6. Paketihaldus: apt, dnf, pacman, brew
7. Lihtne veaotsing käsureal
8. Võrgu põhitööriistad

See plokk aitab süsteemi “musta kasti” lahti võtta.

Pärast seda rada oskad:

• paigutada tähtsamad süsteemikaustad ja tööriistad õigesse konteksti
• lugeda õigusi, kasutajaid ja PATH-i ilma liigse müstikata
• aru saada, kust tulevad paketid, käsud ja paljud tüüpilised vead

Õpitee 3: igapäevane Linuxi ja serveri kasutaja

Staatus: soovitatav, kui töötad serverite, kaugühenduste või suuremate failipuudega.

Kui tahad teha päris töid masinate, failide ja kaugühendustega, siis vaata eriti neid peatükke:

1. Failide kopeerimine ja sünkroonimine
2. Kauglogimine ja SSH
3. Veebist sisu toomine ja tekstivaade: curl, wget, lynx
4. Arhiivid ja pakkimine
5. Tervete kataloogipuude haldus ja jagamine
6. Protsessid, tööd ja signaalid
7. Logid ja teenused
8. Püsivad terminalisessioonid: tmux ja screen

See rada on seotud praktilise süsteemikasutusega:

• failid liiguvad masinate vahel
• protsessid võivad kinni jääda või kaua joosta
• logidest tuleb probleeme otsida
• katkestuste vastu on vaja püsivaid sessioone

Pärast seda rada oskad:

• kopeerida faile ja katalooge masinate vahel
• logida sisse SSH kaudu ja kasutada võtmeid turvalisemalt
• lugeda logisid ning hallata pikemalt jooksvaid töid

Õpitee 4: tekst, filtrid ja automatiseerimine

Staatus: soovitatav kohe pärast baasi, kui tahad käsurea päris jõudu kasutada.

Kui tahad saada tugevaks Unix-laadsete tekstivoo tööriistade kasutajaks, siis liigu nii:

1. Teksti otsimine: grep ja sugulased
2. Teksti teisendamine: tr, cut, paste, column, strings
3. Vood ja tabelid: sort, uniq, wc, pr, join
4. sed, awk ja perl praktiliselt
5. `find` ja `xargs` ohutumalt
6. Esimene shelliskript
7. `cron` ja ajastatud tööd

See on üks tähtsamaid õpiteid, sest siin tekib “väikeste tööriistade ühendamise” tunnetus.

Pärast seda rada oskad:

• otsida ja filtreerida ridu mustri järgi
• sortida, loendada ja teisendada tekstivooge
• kirjutada esimesi lühikesi shelliskripte ja ajastatud töid

Õpitee 5: arendaja suund

Staatus: soovitatav, kui kasutad käsurida tarkvaraprojektides.

Kui eesmärk on tarkvara arendamine, siis pärast baasi vaata eriti neid peatükke:

1. Git, GitHub ja töövoog
2. Pythoni venv ja eraldatud keskkonnad
3. Dockeri alused
4. IDE-d ja arenduskeskkonnad
5. Andmeteaduse eelteadmised käsurea vaates
6. CSV, JSON ja XML käsureal
7. Andmebaasi algus: sqlite ja Python
8. Kompileerimine ja käivitamine: shell, Python, C, C++, Go, Rust, Java
9. LaTeX käsurealt

See järjekord on mõistlik:

• Git tuleb peaaegu igas projektis enne
• venv aitab projektisõltuvused korras hoida
• Docker ja IDE on mugavus- ning töövooteemad
• andmeteaduse eelteadmiste osa aitab siduda käsurea, failivormingud ja SQL-i
• SQLite, kompileerimine ja LaTeX näitavad, kuidas käsurida seob andmed, programmid ja dokumendid üheks töövooks

Pärast seda rada oskad:

• hoida projekti muudatusi Git-is korras
• isoleerida sõltuvusi ja arenduskeskkondi
• lugeda, käivitada ja ehitada mitut tüüpi arendusprojekte

Õpitee 6: andmeteaduse stardirada

Staatus: soovitatav, kui tahad käsurida kasutada andmete puhastamiseks ja uurimiseks.

Kui eesmärk on andmeteaduse või andmeanalüüsi suund, siis pärast käsurea baasi vaata eriti neid peatükke:

1. Sisend, väljund, torud ja suunamine
2. Teksti otsimine: grep ja sugulased
3. Teksti teisendamine: tr, cut, paste, column, strings
4. Vood ja tabelid: sort, uniq, wc, pr, join
5. Andmeteaduse eelteadmised käsurea vaates
6. CSV, JSON ja XML käsureal
7. Andmebaasi algus: sqlite ja Python
8. Pythoni venv ja eraldatud keskkonnad

See rada on hea, sest:

• kõigepealt õpid andmeid failidest lugema ja filtreerima
• siis saad aru, mis vahe on tabelil, JSON-il ja XML-il
• pärast seda muutub SQL palju loomulikumaks
• lõpuks saad sama töövoo viia Pythoni projekti või andmetöötlusse

Pärast seda rada oskad:

• töödelda tekstifaile ja tabeleid käsureal
• eristada CSV-d, JSON-i ja XML-i
• teha esimesi SQL-päringuid ning siduda see Pythoni töövooga

Minimaalne 7 päeva plaan

Kui tahad võtta ühe lühikese esimese ringi, siis üks praktiline plaan on:

1. päev: Terminali esimesed sammud, Abi leidmine, Kataloogid ja failid
2. päev: Teksti vaatamine ja liikumine, Failide muutmine, Käskude kuju
3. päev: Sisend, väljund, torud ja suunamine, Esimene tervikharjutus, Linux, Unix, GNU, macOS, Windows ja shellid
4. päev: Failisüsteemi kaart, Kettaruum, Õigused
5. päev: Kasutajad, grupid ja sudo, Muutujad ja PATH, Paketihaldus, Lihtne veaotsing
6. päev: Võrgu põhitööriistad, Failide kopeerimine ja sünkroonimine, Kauglogimine ja SSH, Veebist sisu toomine
7. päev: grep, Teksti teisendamine, sort, uniq, wc, pr, join, Esimene shelliskript, Git, GitHub ja töövoog

Iga päeva puhul:

• loe peatüki loogika läbi
• proovi vähemalt pooled näited ise läbi
• tee peatüki minitest

Millal kasutada raamatut referentsina

Kui oled juba baasi läbinud, siis ei pea enam liikuma õpitee järgi. Siis on parem kasutada peatükke probleemipõhiselt:

• “mul on vaja faile leida” -> Kataloogid ja failid
• “mul on vaja aru saada, mis süsteemikaust kuhu käib” -> Failisüsteemi kaart
• “mul on vaja mustrit otsida” -> Teksti otsimine: grep ja sugulased
• “mul on vaja serverisse saada” -> Kauglogimine ja SSH
• “mul on vaja veebileht alla tõmmata või linke kokku koguda” -> Veebist sisu toomine ja tekstivaade: curl, wget, lynx
• “mul on vaja aru saada, miks käsk ei tööta” -> Lihtne veaotsing käsureal
• “mul on vaja sõltuvused paigaldada” -> Paketihaldus: apt, dnf, pacman, brew

Terminali esimesed sammud

Terminalis kirjutad käsu reale, vajutad Enter ja näed vastust. Enne esimesi käske on kasulik eristada kolme sõna: terminal, shell ja viip.

Loogika

Kõige rahulikum algus on käskudega, mis ainult näitavad infot ega muuda midagi. Nii saad kõigepealt aru:

• kus sa oled
• mis selles kaustas on
• mis kasutajaga sa töötad
• mis aega süsteem näitab

Alles pärast seda tasub teha esimene väike muudatus, näiteks luua oma harjutuskaust.

1. Terminal, shell ja viip

Terminal on tekstipõhine aken või rakendus. Selle sees töötab tavaliselt shell, näiteks zsh või bash. Shell loeb sinu käsurea, tõlgendab selle käsuks ja käivitab vastava programmi või shelli enda toimingu.

Lihtne pilt:

• terminal on aken, kus sa kirjutad ja näed vastust
• shell on programm terminali sees, mis käske tõlgendab
• viip ehk prompt on shelli kuvatav kutse: nüüd võid käsu sisestada

Näiteks:

~/proov %

või:

kasutaja@arvuti:~$

Viip näitab tavaliselt mõnda neist asjadest:

• kasutajanime
• arvuti nime
• praegust kausta
• seda, kas oled tavaline kasutaja või kõrgemate õigustega kasutaja

Viiba täpne kuju võib olla erinev. Hea rusikareegel on:

• viip on shelli kuvatav kasutajaliidese osa
• pwd ütleb kindlalt, kus sa päriselt oled

Kui tahad teada, milline shell parajasti töötab, küsi:

echo "$SHELL"

See näitab tavaliselt shelli teed, näiteks /bin/zsh või /bin/bash.

Hiljem kohtad ka shelli muutujaid nagu PS1 ja PROMPT. Need ei kuulu terminaliaknale, vaid shellile: nende abil otsustab shell, millise viiba terminalis kuvab.

Kui oled lihtsalt uudishimulik, võid vaadata:

echo "$PS1"

zsh-s võib kasulik olla ka:

print -r -- "$PROMPT"

Need käsud näitavad viiba tehnilist kuju, mitte alati täpselt sama pilti, mida terminal ekraanil kuvab.

Oluline: ära kopeeri viipa käsu ette kaasa

Kui terminalis on näha näiteks:

~/proov % pwd

siis kopeeritav käsk on ainult:

pwd

Viip ise ei ole käsu osa. See on shelli kuvatav tähis, mis näitab, et shell ootab sinu sisestust.

Pildi mõte:

1. viip on lühike, et käsud oleksid loetavad
2. pwd, ls, whoami ja date ainult näitavad infot
3. ükski neist käskudest ei muuda faile

2. Esimesed ohutud käsud

Alusta nende neljaga:

pwd
ls
whoami
date

Need näitavad, kus sa oled, mis sinu ümber on, kes sa oled ja mis kell süsteemi arvates on.

Kui tahad harjutada valmis keskkonnas

Kui sul ei ole oma Linuxi masinat käepärast või tahad lahendada valmis ülesandeid, siis on hea varajane harjutuskoht terminal.cs.ut.ee.

See sobib alguses hästi, sest:

• saad käske kohe läbi proovida
• saad lahendada väikseid sissejuhatavaid ülesandeid
• ei pea enne kõike oma masinas valmis seadistama

Pildi mõte:

1. vasakul on ülesannete nimekiri, mida saab ükshaaval avada
2. paremal on terminaliaken, kus käske kohe läbi proovida
3. keskkond sobib eriti hästi varajasteks katsetusteks ja väikesteks kontrollitud ülesanneteks

Kui tahad oma terminaliaknas samasugust lihtsat prompti, siis ajutised käsud on:

zsh jaoks:

PROMPT='user@terminal:%~$ '

bash jaoks:

PS1='user@terminal:\w$ '

Need muudavad viipa ainult käesolevas shellis. Uues aknas tuleb tagasi sinu tavaline viip.

3. Kaustade vahel liikumine

Kui esimesed vaatavad käsud on tuttavad, saad hakata liikuma ühest kaustast teise.

Süntaks

cd kaust
cd ..
cd ~

Tähendus

• cd kaust liigub kausta sisse
• cd .. liigub ühe taseme võrra üles
• cd ~ viib kodukataloogi

Lisaks kohtad tihti ka neid kujusid:

• . tähendab praegust kausta
• .. tähendab ülemkausta
• ~ tähendab kodukataloogi

Näide

pwd
cd ..
pwd
cd ~
pwd

4. Tab aitab pikki nimesid lõpetada

Kui faili-, kausta- või käsunimi on pikk, ei pea seda alati lõpuni käsitsi kirjutama. Tavaliselt piisab sellest, et kirjutad nime alguse ja vajutad Tab.

Mida Tab teeb

• kui vaste on üks, lõpetab shell nime tavaliselt ise ära
• kui vasteid on mitu, lõpetab shell nime ühise osani
• kui valikuid on mitu ja neist ei piisa eristamiseks, näitab shell sageli järgmise Tab vajutuse järel valikuid

Näide: üks sobiv nimi

mkdir pikk-kaustanimi
cd pik<Tab>
pwd

Siin juhtub tavaliselt järgmine:

1. kirjutad cd pik
2. vajutad Tab
3. shell pakub ette kogu nime pikk-kaustanimi
4. vajutad Enter ja liigud sellesse kausta

Näide: mitu sarnast nime

mkdir pildid
mkdir pildid-varu
cd pil<Tab>

Siin ei saa shell veel üht kindlat valikut teha, sest mõlemad nimed algavad samamoodi. Tavaliselt juhtub üks neist kahest:

• shell lõpetab nime ainult ühise osani, näiteks pildid
• või ootab uut Tab vajutust ja näitab valikuid

Praktiline rusikareegel: kirjuta nii palju nime algusest, kui tead, vajuta Tab, ja kui sellest ei piisa, lisa mõni täht juurde.

5. Esimene teadlik muudatus

Kui vaatavad käsud ja liikumine on juba arusaadavad, tee endale väike harjutuskaust:

mkdir proov
cd proov
pwd
ls

See on hea algus: kaust on sinu enda alal ja päris projektid ei lähe kogemata segi.

Kui kaust proov on sul juba olemas, vali lihtsalt mõni teine nimi.

6. Kuidas abi küsida

Kui käsu mõte läheb meelest, siis kõige kindlam esimene samm on:

man ls

See avab käsu manuaali. Paljud käsud toetavad ka kujusid --help või -h.

Näited:

man ls
ls --help

Oluline on meeles pidada, et -h ei tähenda kõigis käskudes tingimata abi. Seepärast on man sageli kindlam põhireegel.

7. Käsuajalugu

Shell jätab tavaliselt käsud meelde. Kõige lihtsam kuju on:

history

Alguses piisab täiesti sellest. Kui ajalugu on veel lühike, ei ole mõtet teda kohe “viimase 20” kujule lõigata.

Kasulikud lisad:

• ülesnool toob eelmise käsu
• allanool liigub uuema käsu poole tagasi
• Ctrl-r otsib käsuajaloost

Kui kordad ajaloost käsku, mis midagi muudab, kontrolli see enne üle.

Hiljem tasub teada

On olemas ka kiiremad ajaloo-otseteed nagu !!, !25 ja !ls. Need käivitavad mõne vana käsu väga kiiresti uuesti. Algaja põhivoos ei ole neid veel vaja: rahulikum ja turvalisem on kasutada esialgu history, nooleklahve ja Ctrl-r.

8. Esimesed kasulikud klahvid

Mõned klahvikombinatsioonid aitavad juba esimestel päevadel väga palju:

• Ctrl-c katkestab parajasti töötava programmi või käsu töö
• Ctrl-a liigub käsurea algusesse
• Ctrl-e liigub käsurea lõppu
• Ctrl-k kustutab kursori paremalt poolelt rea lõpu

Kui mõni programm tundub “kinni olevat” või kestab liiga kaua, siis on Ctrl-c esimene asi, mida proovida.

9. Vaikne käsk ei ole automaatselt vigane

Mõni käsk töötab edukalt, aga ei kuva midagi.

Näide:

kasutaja@mac proov % touch tyhi.txt
kasutaja@mac proov % cat tyhi.txt
kasutaja@mac proov % ls -l tyhi.txt
-rw-r--r--  1 kasutaja  staff  0 Apr 13 09:21 tyhi.txt
kasutaja@mac proov %

Siin:

• touch tyhi.txt loob tühja faili või uuendab olemasoleva faili ajatemplit
• cat tyhi.txt ei näita midagi, sest fail on tühi
• ls -l tyhi.txt kinnitab, et fail on olemas

Seega uus viip ei tähenda automaatselt viga. Mõnikord tähendab see lihtsalt, et käsul ei olnud midagi ekraanile näidata.

10. Viip võib olla eri kujuga, aga pwd kontrollib asukohta

Pea meeles peatüki alguse põhimõtet: viip on shelli kuvatav rida, mitte kindel tõend sinu asukoha kohta. Sama töökausta võib näidata väga erineva viibaga.

$ pwd
/Users/kasutaja/proov

Kui viip lõpeb #, siis oled sageli kõrgemate õigustega shellis ja pead eriti hoolikalt vaatama, mida teed.

Pildi mõte:

1. esimene pwd näitab, et kasutaja asub kaustas /Users/kasutaja/uuskaust/pildid
2. seejärel seatakse viip ajutiselt väga lühikeseks kujuga $
3. uus pwd näitab, et töökoht ei muutunud, muutus ainult see, kuidas viip välja näeb
4. lõpuks seatakse viip kujule %~ %#, mis näitab lühikest rada nagu ~/uuskaust/pildid %

Järeldus: viiba kuju võib muutuda, aga tegelik asukoht tuleb endiselt käsust pwd.

11. Väike turvamärkus

Ära kopeeri terminali käsuridu pimesi lihtsalt sellepärast, et need näevad veebis või vestluses usaldusväärsed välja.

Eriti ettevaatlik tasub olla käskudega, mis:

• tõmbavad midagi veebist
• muudavad palju faile korraga
• käivitavad teise käsu automaatselt

Kui sa ei saa aru, mida käsk teeb, siis peata korraks töö ja loe enne abi.

Minitest

1. Käivita pwd, ls, whoami ja date.
2. Liigu cd .. abil ühe taseme võrra üles ja tule cd ~ abil kodukataloogi tagasi.
3. Loo kodukataloogi alla kaust proov ja liigu selle sisse.
4. Käivita history.
5. Too eelmine käsk uuesti ette ülesnoole abil või otsi seda Ctrl-r abil.
6. Selgita ühe lausega, miks pwd on sageli kindlam kui viiba kuju.

Abi leidmine: man, --help ja info

Kui uus käsk ei tööta või selle mõte ei ole selge, siis esimene mõistlik reaktsioon ei ole juhuslik veebileht, vaid käsu enda abi.

Esimene abirada

Kui käsk on võõras, liigu tavaliselt selles järjekorras. Nii saad kõigepealt kohaliku, sinu süsteemi kohta käiva info.

Hea harjumus on otsida abi kõigepealt käsu enda dokumentatsioonist, mitte loota juhuslikule veebinäitele.

Tüüpilised algaja vead

• ehmatatakse ära, kui man “võtab terminali üle”
• arvatakse, et --help peab kõigil käskudel töötama täpselt sama moodi
• minnakse kohe veebi, kuigi kohalik abi annaks vastuse kiiremini

1. Käsu manuaal: man

Kõige tavalisem kuju on:

man ls

See avab käsu manuaali.

Mida seal teha saab

• Space liigub järgmise lehe peale
• b liigub tagasi
• /muster otsib tekstist
• q väljub

Näited

man ls
man grep
man less

Kui sa ei tea veel kõiki detaile, siis piisab alguses täiesti sellest, et loed manuaali alguse läbi ja otsid üles kõige tavalisemad valikud.

2. Lühike abi: --help

Paljud käsud toetavad lühikest abi kujul:

ls --help
grep --help

See on hea siis, kui tahad kiirelt näha:

• milliseid lippe käsk toetab
• milline on põhisüntaks
• mis järjekorras argumendid käivad

--help on eriti mugav siis, kui sa ei taha kohe pikka manuaali lugema minna.

3. Kui man puudub või --help ei tööta

Mõnes minimaalses süsteemis, konteineris või eriprogrammis võib juhtuda, et:

• man ei ole paigaldatud
• käsk ei tunne kuju --help
• abi tuleb hoopis mõne teise võtmega

Siis tasub liikuda nii:

1. proovi kõigepealt käsk --help
2. kui see ei tööta, vaata, kas dokumentatsioon või veateade vihjab kujule -h
3. kasuta whatis või apropos, et leida õige käsu nimi
4. kui vajadus jääb püsima, tule hiljem tagasi paketihalduri peatüki juurde ja paigalda puuduv dokumentatsioon

Oluline mõte on lihtne: kui üks abivõte ei tööta, siis see ei tähenda veel, et abi üldse puudub.

4. -h, --help ja -H ei ole sama asi

Kõik käsud ei kasuta samu võtmeid.

• --help on levinud GNU stiil
• -h tähendab mõnes käsus abi, mõnes käsus midagi muud
• -H tähendab sageli hoopis teist käitumist

Seepärast ei maksa eeldada, et -h on alati “help”.

Praktiline rusikareegel:

• proovi kõigepealt man käsk
• seejärel vaata käsk --help

5. Kui käsu nime ei mäleta

Mõnikord tead teemat, aga mitte käsku. Siis on abiks:

whatis ls
apropos archive

Vahe nende vahel

• whatis käsk annab ühe lühikirjelduse tuntud käsu kohta
• apropos sõna otsib märksõna järgi seotud käske

Näited:

whatis awk
apropos copy
apropos archive

6. GNU info-dokumendid

Mõne suurema GNU tööriistakogumi puhul kohtad ka käsku:

info coreutils

See ei ole alguses kõige tähtsam tööriist, aga hea on teada, et ta on olemas.

info on kõige kasulikum siis, kui:

• man tundub liiga lühike
• teema koosneb tervest tööriistaperest
• vajad sügavamat dokumentatsiooni

7. Väike praktiline rada

Kui sa ei mäleta, kuidas tar töötab, siis hea järjekord on:

man tar
tar --help
apropos archive

Siin:

1. man tar annab tervikpildi
2. tar --help näitab lühikest meeldetuletust
3. apropos archive aitab leida ka teisi samasse teemasse kuuluvaid käske

Minitest

1. Ava man less.
2. Kontrolli, kas käsk tar toetab kuju --help.
3. Leia apropos abil mõni pakkimisega seotud käsk.
4. Vaata käsu ls lühikirjeldust käsuga whatis.

Lisalugemine

Selle teema usaldusväärsemad viited leiad lisast Lisa E: usaldusväärsed viited ja lisalugemine.

Kataloogid ja failid

Unix-laadses süsteemis on peaaegu kõik töö lõpuks failide ja kataloogidega töötamine. Selles peatükis teed esimesed päris muudatused, aga teed neid kontrollitult.

Loogika

Failidega töötamisel hoia rütm lihtne:

1. kontrolli, kus oled
2. vaata, mis seal juba on
3. tee üks väike muudatus
4. kontrolli tulemus üle
5. kustuta alles siis, kui oled kindel

See rütm on tähtsam kui üksik käsk. Enamik algaja vigu tuleb sellest, et muudatus tehakse vales kataloogis.

Kiire orientiir

Tühi väljund ei tähenda automaatselt viga. Paljud failikäsud ütlevad midagi ainult siis, kui midagi läks valesti.

Tüüpilised algaja vead

• pwd jääb vaatamata ja fail luuakse valesse kohta
• tühikutega nimi jäetakse jutumärkideta
• mv käsu puhul ei märgata, kas tegu on ümbernimetamise või liigutamisega
• arvatakse, et rm viib faili prügikasti
• kasutatakse rm -rf, sest see “töötab alati”, mõistmata, kui palju see võib kustutada

Tee endale harjutuskataloog

Ära harjuta esimesi kustutamis- ja liigutamiskäske päris projektikataloogis. Tee eraldi harjutuskoht.

pwd
mkdir -p ~/tmp/faili-naited
cd ~/tmp/faili-naited
pwd
ls

Siin:

• ~ tähendab sinu kodukataloogi
• mkdir -p ~/tmp/faili-naited loob vajadusel ka vahekataloogi tmp
• kui tmp või faili-naited oli juba olemas, ei ole see viga
• viimane pwd kinnitab, et oled õiges kohas

mkdir -p on hea harjutuskäsk just sellepärast, et ta teeb puuduva tee valmis. Ilma -p-ta oskab mkdir luua ainult viimase kataloogi siis, kui vahepealne tee on juba olemas.

Teed: ., .. ja ~

Kolm märki tulevad failitöös pidevalt tagasi.

Näited:

pwd
cd ..
pwd
cd ~/tmp/faili-naited
pwd

Kui käsk kasutab kuju ./fail.txt, tähendab see faili fail.txt siinsamas praeguses kataloogis. See on sama fail, mida tähistab ka lihtsalt fail.txt, aga ./ teeb asukoha nähtavamaks.

Failinimed ja tühikud

Shell jagab käsu tühikute kohalt osadeks. Kui faili või kataloogi nimes on tühik, pane nimi jutumärkidesse.

mkdir "Minu failid"
cd "Minu failid"
touch "esimene fail.txt"
ls
cd ..

Algajana on lihtsam kasutada failinimedes sidekriipsu või alakriipsu:

minu-failid
esimene_fail.txt

Tühikutega nimed on lubatud, aga käsureal nõuavad need rohkem tähelepanu.

Kataloogi sisu vaatamine

ls on kõige tavalisem esimene vaade.

ls
ls -l
ls -a
ls -la
ls -A

Nende vahe:

• ls näitab tavalisi nimesid
• ls -l näitab detailvaadet
• ls -a näitab ka punktiga algavaid peidetud nimesid
• ls -la ühendab detailvaate ja peidetud nimed
• ls -A näitab peidetud nimesid, aga jätab . ja .. välja

Selles aknas on oluline järjekord:

1. pwd näitab praegust asukohta
2. mkdir tmp proovib luua kataloogi, aga saab teate File exists
3. see ei ole ohtlik viga, vaid tähendab, et kataloog oli juba olemas
4. cd tmp liigub olemasolevasse kataloogi
5. ls näitab tavalist sisu
6. ls -a lisab . ja ..
7. ls -al näitab sama pika detailvaatena

Punktiga algavad nimed

Punktiga algavad nimed on tavaliselt peidetud:

• .zshrc
• .ssh
• .git
• .config

Need ei ole kadunud ega erilise kaitse all. See on kuvamiskokkulepe: paljud tööriistad jätavad punktiga algavad nimed vaikimisi näitamata.

mkdir -p ~/tmp/peidetud-naide
cd ~/tmp/peidetud-naide
touch tavaline.txt .peidetud.txt
ls
ls -a
ls -A

Pildi põhisõnum on lihtne:

• punktiga algav fail on olemas
• tavaline ls ei pruugi seda näidata
• ls -a või ls -A teeb peidetud nimed nähtavaks

macOS Finderis saab peidetud failide kuvamist lülitada klahviga:

Command-Shift-.

Loo, kopeeri, nimeta ümber ja liiguta

Nüüd tee väike tervikharjutus samas harjutuskataloogis.

cd ~/tmp/faili-naited
pwd
touch esimene.txt
cp esimene.txt koopia.txt
mkdir arhiiv
mv koopia.txt arhiiv/
ls
ls arhiiv

Siin:

• touch esimene.txt loob tühja faili, kui seda veel ei ole
• cp esimene.txt koopia.txt teeb koopia
• mkdir arhiiv loob kataloogi
• mv koopia.txt arhiiv/ liigutab faili kataloogi arhiiv

Kui käsk õnnestub, ei pruugi ta midagi öelda. Tulemuse kontrollimiseks kasuta ls.

mv teeb kaks eri asja

mv võib tähendada ümbernimetamist:

mv vana.txt uus.txt

Sama käsk võib tähendada liigutamist:

mv fail.txt arhiiv/

Eristus tuleb viimasest argumendist:

• kui lõpus on uus failinimi, nimetad ümber
• kui lõpus on kataloog, liigutad sinna sisse

Kui kahtled, tee enne:

ls -l
ls -l arhiiv

touch ja ajatempel

touch teeb kaks asja:

• kui faili ei ole, loob tühja faili
• kui fail on olemas, uuendab tavaliselt faili muutmisaega

Näide:

touch tyhi.txt
cat tyhi.txt
ls -l tyhi.txt

cat tyhi.txt ei näita midagi, sest fail on tühi. See on normaalne.

Kui tahad näha, millised failid on viimati muutunud, kasuta:

ls -lt

ls -lt sorteerib detailvaate aja järgi.

Terminal ja Finder näitavad sama kohta

Terminal ja graafiline failihaldur ei ole eri maailmad. Nad võivad näidata sama kataloogi.

macOS-is ava praegune kataloog Finderis nii:

open .

Selles näites:

1. cd ~/uuskaust/pildid liigub kindlasse kataloogi
2. pwd kontrollib asukoha üle
3. open . avab sama kataloogi Finderis
4. touch uus.txt loob tühja faili
5. echo "siin on ka teksti" > teine.txt loob tekstiga faili
6. ls ja ls -al näitavad samu faile terminalis
7. Finder näitab sama tulemust graafiliselt

Õppetund: kui fail tekib Terminalis, näed seda tavaliselt ka Finderis, ja vastupidi.

Kustutamine: rm, rmdir, rm -r

Kustutamine on selle peatüki kõige riskantsem osa.

Enne kustutamist tee alati:

pwd
ls

Üksik fail:

rm fail.txt

Tühi kataloog:

rmdir tyhi-kataloog

Kataloog koos sisuga:

rm -r vana-kataloog

rmdir on algajale hea, sest ta töötab ainult tühja kataloogiga. Kui kataloogis on midagi sees, käsk peatub.

rm -r läheb kataloogi sisse ja kustutab rekursiivselt ka selle sisu. Seda kasuta ainult siis, kui oled teinud pwd ja ls kontrolli.

Miks rm -rf on eraldi ohtlik

Kuju:

rm -rf vana-kataloog

tähendab:

• -r kustutab rekursiivselt
• -f sunnib kustutamist ja vähendab küsimist

Käsureal ei ole vaikimisi Finderi või Windows Exploreri prügikasti. Kui rm õnnestub, on fail tavakasutuse mõttes kohe läinud.

Hea algaja rusikareegel:

• fail: rm fail.txt
• tühi kataloog: rmdir kataloog
• kataloog koos sisuga: rm -r kataloog
• rm -rf: ainult siis, kui saad täpselt aru, miks seda vajad

Failide leidmine

ls näitab praegust kataloogi. find otsib kataloogipuu seest.

Ohutud otsingud:

find . -name '*.txt'
find . -type f
find . -type d
find . -maxdepth 2 -type f

Kui näed juhendis kuju:

find . -name '*.log' -delete

siis ära käivita seda pimesi. Esmalt tee sama otsing ilma -delete osata:

find . -name '*.log'

Alles siis otsusta, kas kustutamine on tõesti õige. find-i ohutumad töövood tulevad hiljem eraldi peatükis.

Faili sisu kiire võrdlus räsi abil

Kui tahad kontrollida, kas kaks faili on sisult samad, saab kasutada räsi.

printf 'tere\n' > a.txt
cp a.txt b.txt
shasum -a 256 a.txt b.txt

Kui kahe faili SHA-256 räsi on sama, on nende sisu praktilises mõttes sama.

Linuxis näed sageli ka käsku:

sha256sum a.txt b.txt

macOS-is on levinud:

shasum -a 256 a.txt b.txt

Selle teema põhjalikum koht on hiljem andmete tervikluse ja allalaadimiste juures. Siin piisab mõttest: sama sisu annab sama räsi.

Minitest

1. Loo harjutuskataloog ~/tmp/faili-naited.
2. Mine selle kataloogi sisse ja kontrolli asukohta käsuga pwd.
3. Loo fail readme.txt.
4. Tee failist koopia nimega readme.bak.
5. Nimeta koopia ümber nimeks vana.txt.
6. Loo peidetud fail .salajane.
7. Võrdle käske ls, ls -a ja ls -A.
8. Kustuta üks tavaline fail alles pärast pwd ja ls kontrolli.
9. Leia find abil kõik .txt failid oma harjutuskataloogist.

Teksti vaatamine ja liikumine

Loogika

Faili vaatamiseks vali käsk selle järgi, kui palju sisu tahad korraga näha:

• lühikese faili jaoks kasuta cat
• pika faili sirvimiseks ja otsimiseks kasuta less
• faili alguse vaatamiseks kasuta head
• faili lõpu või värskeimate logiridade vaatamiseks kasuta tail

cat trükib kogu faili kohe terminali. Kui fail on pikk, täidab see ekraani paljude ridadega ja varasem osa jääb terminali kerimisajalukku. Sellisel juhul on less parem, sest saad faili sees rahulikult liikuda, otsida ja q-ga väljuda.

Kiirülevaade

Eesmärk on valida vaatamiseks tööriist, mis ei uputa ekraani üle ega muuda faili.

Tüüpilised algaja vead

• kasutatakse cat-i väga pika faili peal, kuigi less oleks parem
• unustatakse, et less-ist tuleb q-ga välja tulla
• aetakse segi “vaatan faili lõppu” ja “jälgin faili muutumist”

Kiirspikker

• cat fail.txt kuvab faili tervikuna
• less fail.txt avab faili mugavaks sirvimiseks
• head fail.txt näitab algust
• tail fail.txt näitab lõppu
• tail -f logi.txt jälgib faili muutumist
• less sees /muster otsib teksti
• less sees 78g läheb reale 78
• less sees 25% või 25p läheb umbes veerandi peale faili sisse

Kõige tavalisemad valikud:

• head -n 20 näita esimesed 20 rida
• tail -n 20 näita viimased 20 rida
• tail -f jälgi faili juurde lisanduvat sisu

Käivita need käsud

seq 25 > numbrid.txt
head -n 7 numbrid.txt
tail -n 7 numbrid.txt

less numbrid.txt

less sees:

• q väljub
• /tekst otsib edasi
• n liigub järgmise vaste juurde
• g läheb faili algusse
• G läheb faili lõppu
• 78g läheb reale 78
• 25% või 25p liigub 25% peale faili sisse

less sees saab hüpata rea või protsendi järgi

See aitab siis, kui fail on pikk ja tahad kerimise asemel minna kohe kindlasse kohta.

Näiteks:

seq 200 > numbrid.txt
less numbrid.txt

less sees võid kirjutada:

• 78g, et minna reale 78
• 25%, et minna umbes veerandi peale faili sisse
• 50%, et minna faili keskele
• G, et minna faili lõppu

Loogika on:

• rea number + g tähendab "mine sellele reale"
• protsent + % või p tähendab "mine selle koha peale failis"

See on eriti kasulik logide, konfiguratsioonifailide ja suurte andmefailide puhul.

Millal mida kasutada

• cat lühikese faili jaoks
• less pika faili või logi jaoks
• head ja tail siis, kui fail on piisavalt pikk, et terve sisu korraga ei oleks mõistlik vaadata

Kõige sagedasem päriselu muster on:

tail -f app.log

või:

less /etc/passwd

tail -f logide vaatamiseks

tail -f on eraldi oluline juhtum, sest siin ei vaata sa ainult faili lõppu, vaid jälgid faili kasvu reaalajas.

See on seotud logide, serverite ja taustaprotsessidega:

• programm lisab faili uusi ridu
• tail -f näitab neid ridu kohe, kui need faili jõuavad
• vaatamine kestab seni, kuni selle katkestad

Kõige tavalisem kasutus on:

tail -f app.log

Peata jälgimine:

Ctrl-c

Praktiline harjutus on teha kaks terminaliakent:

Esimeses aknas:

touch app.log
tail -f app.log

Teises aknas:

printf 'server käivitus\n' >> app.log
printf 'viga: ühendus katkes\n' >> app.log

Siis näed kohe, kuidas tail -f sobib logide vaatamiseks paremini kui tavaline cat või ühekordne tail -n 20.

Minitest

1. Loo 25-realine fail seq 25 > numbrid.txt.
2. Vaata esimesed 7 rida käsuga head -n 7 numbrid.txt.
3. Vaata viimased 7 rida käsuga tail -n 7 numbrid.txt.
4. Ava fail less abil ja otsi üles number 17.
5. Ava pikem fail seq 200 > numbrid.txt, sisene less-i ja proovi käske 78g ning 25%.
6. Proovi logi jälgimist käsuga tail -f app.log ja lisa teises terminalis faili paar rida juurde.

Failide muutmine: nano ja esimene kokkupuude vim-iga

Loogika

Need tööriistad on seotud nii:

• less aitab faili sisu enne muutmist mugavalt üle vaadata
• nano on alguses kõige lihtsam tekstiredaktor
• vim ja vi on sama pere klassikalised tekstiredaktorid

Praktiliselt tähendab see, et alguses piisab täiesti sellest:

• vaata faili less abil
• tee lihtne muudatus nano abil
• õpi vim-ist või vi-st vähemalt kindlalt väljuma

Kiirülevaade

Eesmärk on liikuda vaatamiselt muutmisele nii, et tead, millal fail päriselt muutub.

Tüüpilised algaja vead

• aetakse segi faili vaatamine ja faili muutmine
• avatakse vim kogemata ja ei teata, kuidas välja saada
• unustatakse, et redaktor muudab päris faili, mitte ainult ekraanivaadet

Kiirspikker

• less fail.txt vaata faili sisu mugavalt
• nano fail.txt lihtne tekstiredaktor
• vim fail.txt klassikaline redaktor
• vi fail.txt sama pere variant
• Ctrl-O salvesta nano-s
• Ctrl-X välju nano-st
• Ctrl-W otsi nano-s

Kõige sagedasemad vim käsud alguses:

• Esc väljub sisestusrežiimist
• :q väljub, kui midagi pole muutunud
• :q! väljub ilma salvestamata
• :wq salvestab ja väljub

nano kõige vajalikumad klahvid

Alguses piisab täiesti neist kolmest:

• Ctrl-O salvestab faili
• Ctrl-X väljub redaktorist
• Ctrl-W otsib tekstist

Praktiline rada on tavaliselt selline:

1. ava fail nano abil
2. tee muudatus
3. vajuta Ctrl-O, siis Enter
4. vajuta Ctrl-X

Hea on meeles pidada, et nano näitab allservas ise peamisi kiirnuppe. Kui unustad klahvi, vaata ekraani allaossa.

Käivita need käsud

printf 'esimene\nteine\nkolmas\n' > naide.txt
less naide.txt

nano naide.txt
vim naide.txt

Kuidas vim-ist välja saada

Kõige klassikalisem:

1. vajuta Esc
2. kirjuta :q ja Enter

Kui fail on muudetud ja tahad ilma salvestamata väljuda:

:q!

Kui tahad salvestada ja väljuda:

:wq

Kui less-i otsimine või liikumine on meelest läinud, vaata tagasi peatükki Teksti vaatamine ja liikumine.

Kui nano puudub

Mõnes süsteemis ei ole nano vaikimisi paigaldatud.

Siis on sul kolm lihtsat varianti:

• proovi, kas nano on siiski olemas käsuga command -v nano
• kasuta ajutiselt vi või vim
• paigalda nano hiljem siis, kui paketihaldus on juba tuttav

Alguses on kõige tähtsam teada, kuidas tundmatust redaktorist turvaliselt väljuda.

Kõige tavalisem töövoog

Kui pead muutma konfiguratsioonifaili, siis üks lihtne rada on:

less seadistus.conf
nano seadistus.conf

Kui töötad rohkem terminalis, liigud hiljem võib-olla vim-i peale.

Minitest

1. Loo tekstifail kolme reaks.
2. Ava see nano abil ja lisa üks rida.
3. Ava see vim abil ja välju failist.

Käskude kuju ja argumentide loogika

Paljud käsud näevad käsureal välja sarnased. Kui see põhimuster on selge, on hiljem palju lihtsam uusi käske õppida.

Alusta ühest näitest

Võta kõigepealt üks lihtne näide:

ls -la /etc

Siin on kolm eri rolli:

• ls on käsk
• -la on lipud ehk valikud
• /etc on argument ehk koht, mille peal käsk töötab

Sama loogika kordub väga paljudes teistes käskudes.

Näiteks:

cp vana.txt uus.txt

Siin:

• cp on käsk
• eraldi lippu ei ole
• vana.txt ja uus.txt on argumendid

Põhireegel

Enamasti saab käsurea lugeda nii:

käsk [valikud] [argumendid]

See tähendab:

• kõigepealt tuleb käsu nimi
• siis tulevad valikud ehk lipud
• siis tulevad argumendid ehk see, mille peal käsku kasutatakse

Näiteks:

ls -la /etc
grep -n root fail.txt
cp fail.txt koopia.txt

Tüüpilised algaja vead

• aetakse segi, mis on valik ja mis on argument
• arvatakse, et kõik lipud töötavad igal käsul ühtmoodi
• unustatakse jutumärgid siis, kui nimes on tühikud

Kui saad aru valikutest, argumentidest ja jutumärkidest, tuleb üllatusi vähem.

1. Lühikesed ja pikad valikud

Valikud muudavad käsu käitumist.

Lühikesed valikud

ls -l
ls -a
ls -la

Siin:

• -l on üks lühike valik
• -a on teine lühike valik
• -la tähendab, et mõlemad pannakse kokku

Pikad valikud

Mõni käsk toetab pikemaid nimesid:

grep --help
grep --color=auto root fail.txt

Siin:

• --help on pikk valik ilma väärtuseta
• --color=auto on pikk valik koos väärtusega

Kõik käsud ei toeta samu kujusid. Mõni toetab -h, mõni --help, mõni mõlemat.

2. Argumendid

Argument on see, mille peal käsk töötab.

Näited:

ls /etc
cat fail.txt
cp vana.txt uus.txt

Siin on argumendid:

• /etc
• fail.txt
• vana.txt ja uus.txt

Need on siin näidetes rajad ja failinimed, millele käsk rakendub. Argument ei ole alati failinimi: see võib olla ka kataloogitee, muster, URL või muu väärtus, mida käsk vajab.

Rusikareegel jääb samaks:

käsk [valikud] [argumendid]

3. Valikute ja argumentide järjekord

Mõne käsu puhul võib järjekord tunduda paindlik, aga alati ei tasu sellele loota.

Turvalisem on kirjutada nii:

grep -n root fail.txt
cp -R kaust koopia
tar -czf varu.tar.gz kaust/

Ehk:

1. käsu nimi
2. kõige tavalisemad valikud
3. sihtfailid või muud argumendid

4. Erimärk --

Kui faili nimi algab miinusega, võib käsk seda valikuna valesti tõlgendada.

Siis aitab --:

touch -- -imelik-fail
ls -- -imelik-fail
rm -- -imelik-fail

-- tähendab siin: “siit edasi ära tõlgenda enam midagi valikuna”.

5. Globbing ehk mustrid failinimedes

Shell oskab mõningaid märke tõlgendada mustritena.

Näited:

ls *.txt
ls words.0?.txt
ls pilt[12].png

Need tähendavad:

• *.txt valib kõik .txt lõpuga failid
• words.0?.txt valib failid nagu words.00.txt, words.01.txt, words.02.txt
• [] sobitab ühe märgi etteantud hulgast

Üldreegel nende märkide taga on:

• * sobitab null või rohkem märki
• ? sobitab täpselt ühe märgi

Oluline detail on see, et shell laiendab need mustrid enne, kui käsk ise käivitub.

Näiteks:

grep root *.txt

siin ei saa grep argumenti *.txt. Shell teeb sellest enne tegelike failinimede loendi.

6. Jutumärgid ja backslash

Kui failinimes on tühikud või erimärgid, tuleb nimi kaitsta.

Kõige tavalisemad võtted on:

echo '$HOME'
echo "$HOME"
echo fail\ nimega\ tühik.txt

Tähendus:

• '...' jätab teksti täht-tähelt nii, nagu see on kirjutatud
• "..." lubab näiteks muutuja asenduse
• \ kaitseb ühte märki

Näited

mkdir "Minu Kaust"
cd "Minu Kaust"
printf 'tere\n' > "fail nimi.txt"
cat "fail nimi.txt"

ja:

touch Minu\ fail.txt
cat Minu\ fail.txt

Mõlemad töötavad. Pikemate nimede puhul on jutumärgid tavaliselt loetavamad.

7. Üksik- ja topeltjutumärgid ei ole sama asi

Need kaks on shellis erineva tähendusega.

nimi='Mari'
echo 'Tere $nimi'
echo "Tere $nimi"

Tulemus on põhimõtteliselt selline:

• 'Tere $nimi' jätab teksti muutmata
• "Tere $nimi" asendab muutuja väärtusega

Praktiline reegel:

• kasuta '...', kui tahad teksti võtta täht-tähelt nii, nagu see on kirjutatud
• kasuta "...", kui tahad säilitada ühe argumendi, aga lubada muutujate asendust

8. Failinimed tühikute ja erimärkidega

Kui failinimes on tühik, sulud, tärnid või muud erimärgid, siis shell võib nime valesti tükkideks jagada või mustrina tõlgendada.

Näited:

printf 'sisu\n' > "Minu fail.txt"
mv "Minu fail.txt" "Uus nimi.txt"

Kõige praktilisem soovitus alguses on:

1. eelista nimedes sidekriipse või alakriipse
2. kui nimes on tühik või erimärk, kasuta jutumärke

9. Kõige sagedamini korduvad lipud

Paljudes käskudes kohtad samu lühikesi märke, aga nende tähendus ei ole alati täpselt sama.

• -h võib tähendada abi või inimloetavat kuju
• -v tähendab sageli jutukamat väljundit
• -r või -R tähendab sageli rekursiivselt
• -n tähendab sageli arvu või rea numbrit

Näited:

head -n 5 fail.txt
grep -n root fail.txt
rm -r vana-kaust

Sama lipp ei tähenda kõigis käskudes sama asja. Seepärast tuleb iga käsu abi eraldi vaadata.

Minitest

1. Käivita ls -la.
2. Ava mõne käsu abi kujul --help.
3. Loo fail nimega Minu fail.txt ja kuva selle sisu.
4. Proovi käsku ls *.md mõnes kaustas, kus on mitu Markdown-faili.
5. Selgita ühe lausega, mida teeb --.

Sisend, väljund, torud ja suunamine

Loogika

Kõige tähtsam mõte:

• käsk võib kirjutada tavalist väljundit
• käsk võib anda ka eraldi veateateid
• tavalise väljundi võib suunata faili
• tavalise väljundi võib anda teisele käsule
• käske saab ka lihtsalt järjest või tingimusega käivitada

Need ei ole sama asi. Faili suunamine, toru ja tingimuslik käsujada lahendavad eri probleeme.

Kiirülevaade

Eesmärk on panna käsud koostööd tegema: salvesta väljund, ühenda käsud või käivita järgmine samm tingimusega.

Lõpetuskood ei paista otse välja; vajadusel küsi seda käsuga echo $?.

Tüüpilised algaja vead

• aetakse segi ; ja |
• kirjutatakse fail kogemata > abil üle, kuigi taheti lisada >>
• eeldatakse, et sudo echo ... > fail annab suunamisele samuti root-õiguse
• imestatakse, miks edukas käsk vaikis, kuigi väljund läks tegelikult faili või torusse

1. Tavaline väljund, veaväljund ja lõpetuskood

Käsureal on hea eristada kolme mõistet:

• stdout: tavaline väljund, mida käsk kirjutab
• stderr: eraldi veaväljund vigade ja hoiatuste jaoks
• lõpetuskood ehk exit code: märge selle kohta, kas käsk lõppes edukalt

Praktiline rusikareegel on:

• 0 tähendab tavaliselt edu
• mõni muu arv tähendab tavaliselt, et midagi läks valesti

Kui tahad näha viimase käsu lõpetuskoodi, saad kasutada:

ls sonad.txt
echo $?
ls puuduv_fail
echo $?

See mõte muutub oluliseks hiljem siis, kui jõuame märkideni && ja ||.

2. > kirjutab faili

Kui tahad käsu väljundi faili panna, kasuta märki >.

echo tere > sonad.txt
cat sonad.txt

Siin:

• echo tere toodab teksti
• > suunab selle faili
• cat sonad.txt näitab tulemust

Oluline reegel: > kirjutab vana sisu üle.

3. >> lisab faili lõppu

Kui tahad olemasolevale failile juurde lisada, kasuta märki >>.

echo esimene > read.txt
echo teine >> read.txt
cat read.txt

Tulemus on:

esimene
teine

Peamine vahe on lihtne: > kirjutab üle, >> lisab lõppu.

4. Toru |

Toru ei kirjuta väljundit faili. Ta saadab ühe käsu väljundi järgmise käsu sisendiks.

Näide:

printf 'üks\nkaks\nkolm\n' | wc -l

Siin:

• printf toodab kolm rida
• toru | saadab need edasi
• wc -l loeb kokku, mitu rida tuli

See on teistsugune loogika kui > abil faili kirjutamine.

5. Järjestikused käsud: ;

Märk ; tähendab lihtsalt: käivita järgmine käsk pärast eelmist.

pwd ; ls ; date

Siin käivitatakse kolm käsku järjest. ; ei anna andmeid ühest käsust teise edasi. Vahe on lihtne: ; käivitab käsud järjest, | ühendab käsud voona.

6. && ja ||

Need kaks märki lisavad käsujadale tingimuse. Nad ei vaata faili sisu ega toru kaudu tulevaid ridu, vaid eelmise käsu lõpetuskoodi.

&&

mkdir proov && cd proov

See tähendab: tee teine käsk ainult siis, kui esimene õnnestus.

||

grep 'midagi' puuduv.txt || echo 'otsing ebaõnnestus'

See tähendab: tee teine käsk siis, kui esimene ebaõnnestus.

Võrdlus

false ; echo 'see käivitus ikkagi'
false && echo 'seda ei näe'
false || echo 'varukäsk läks tööle'

Siin juhtub:

• ; järel läheb järgmine käsk alati käima
• && järel järgmine käsk ei käivitu, sest esimene ebaõnnestus
• || järel järgmine käsk käivitub just sellepärast, et esimene ebaõnnestus

7. Vead ja 2>

Tavaline väljund ja veateated ei ole käsureal päris sama asi.

• tavaline väljund läheb tavaliselt stdout kaudu
• vead lähevad tavaliselt stderr kaudu

Kui tahad vead eraldi faili panna, kasuta:

ls puuduv_fail 2> vead.txt
cat vead.txt

Siin:

• 2> tähendab veaväljundi suunamist
• tavaline väljund läheks endiselt ekraanile

Kui tahad veateate lihtsalt ära peita, siis võid kirjutada:

ls puuduv_fail 2> /dev/null

/dev/null on erifail, kuhu saadetud väljund kaob ära. Seda võib mõelda kui musta auku väljundile. Aprillinaljana öeldakse vahel, et /dev/null sai täis, aga päriselt tähendab see lihtsalt kohta, kuhu saab midagi teadlikult “mitte kuhugi” saata.

8. tee

tee on kasulik siis, kui tahad väljundit korraga ekraanil näha ja faili salvestada.

Näide:

printf 'Tallinn\nTartu\nNarva\n' | tee linnad.txt
cat linnad.txt

Kui tahad faili lõppu lisada, kasuta:

printf 'Pärnu\n' | tee -a linnad.txt

9. 2>&1 ja muud keerulisemad kujud

Kui tahad ühendada veaväljundi tavalise väljundiga, kohtad kuju:

find . -name '*.md' > tulemused.txt 2>&1

See tähendab, et nii tavaline väljund kui ka vead lähevad samasse faili.

See ei ole esimene kuju, mida pähe õppida, aga hea on teada, et selline võimalus on olemas.

10. Miks sudo echo ... > fail ei tööta nii, nagu algaja ootab

Paljud proovivad kuju:

sudo echo 'naide=1' > /etc/naide.conf

Aga siin teeb ümbersuunamise > sinu praegune shell, mitte sudo.

Sellepärast kasutatakse sageli hoopis sellist kuju:

echo 'naide=1' | sudo tee /etc/naide.conf

Peamine loogika on:

• sudo echo ... > fail ei anna root-õigust shelli suunamisele
• sudo tee fail avab faili protsessis, millel on vajalikud õigused

11. Kui väljund ei ilmu kohe

Mõni programm ei kirjuta iga rida kohe ekraanile või torusse edasi, vaid kogub väljundi vahepeal puhvrisse.

See tähendab:

• terminalis töötav programm võib näidata ridu kohe
• sama programm toru või faili kaudu võib väljundi edasi anda hiljem

Pythoni puhul kohtab seda sageli. Selleks on olemas näiteks:

• python3 -u programm.py
• print(..., flush=True)

See on juba natuke järgmise taseme teema, aga hea on teada, miks mõni toru “vaikib” kauem kui ootasid.

Minitest

1. Loo fail käsuga echo tere > fail.txt.
2. Lisa teine rida käsuga echo maailm >> fail.txt.
3. Näita faili sisu käsuga cat.
4. Ühenda kaks käsku toruga, näiteks printf ... | wc -l.
5. Võrdle käske pwd ; ls ja pwd | ls.
6. Proovi, kuidas false && echo ok erineb käsust false || echo ok.

Esimene tervikharjutus: 30 minutit

See peatükk ei ole enam täiesti esimene kokkupuude käsureaga. Kui terminali põhimõtted, failid, abi leidmine ja suunamine on juba tuttavad, saad siin teha ühe lühikese tervikharjutuse algusest lõpuni läbi.

Loogika

See harjutus seob kokku mõned juba tuttavad mõtted:

• vaata enne, kus sa oled
• tööta eraldi harjutuskaustas
• kirjuta faili sisu väikeste sammudena
• kontrolli tulemust iga muudatuse järel

See on hea koht, kus harjutada ilma uusi sümboleid või käske juurde toomata.

Enne alustamist

Kui mõni käsk on meelest läinud, siis peata korraks töö ja vaata abi:

man pwd
man ls
man cat

Paljud käsud toetavad ka kujusid --help või -h, aga see ei ole kõigis süsteemides ühtlane. Kõige kindlam algus on tavaliselt man.

Kiirspikker

• pwd näitab praegust kausta
• ls näitab kausta sisu
• mkdir loob kausta
• cd liigub kausta sisse
• echo ... > fail kirjutab faili esimese rea
• echo ... >> fail lisab faili lõppu järgmise rea
• cat fail näitab faili sisu
• wc -l fail loeb ridu
• cp allikas siht teeb koopia

Harjutus

Tee see plokk rahulikult algusest lõpuni läbi:

pwd
ls
mkdir proov
cd proov
mkdir esimene-harjutus
cd esimene-harjutus
echo tere > sonad.txt
echo maailm >> sonad.txt
echo linux >> sonad.txt
ls
cat sonad.txt
wc -l sonad.txt
cp sonad.txt koopia.txt
ls
cat koopia.txt

Mida siin tehti

Harjutuses juhtus samm-sammult järgmine:

1. pwd ja ls kontrollisid alguskohta
2. mkdir proov ja mkdir esimene-harjutus lõid eraldi töökaustad
3. cd liikus õigesse kohta
4. echo ... > sonad.txt lõi faili ja kirjutas sinna esimese rea
5. echo ... >> sonad.txt lisas järgmised read olemasoleva faili lõppu
6. cat sonad.txt näitas faili sisu
7. wc -l sonad.txt luges kokku, mitu rida failis on
8. cp sonad.txt koopia.txt tegi failist koopia
9. viimane cat koopia.txt kinnitas, et koopia sisaldab sama teksti

See on käsureal väga tavaline tööviis: tee väike samm ja kontrolli tulemust kohe.

> ja >> vahe

Selles harjutuses on kaks väga tähtsat märki:

• > kirjutab faili uue sisu ja kirjutab vana sisu üle
• >> lisab uue rea olemasoleva faili lõppu

Näiteks:

echo esimene > naide.txt
echo teine >> naide.txt
cat naide.txt

Tulemus on:

esimene
teine

Kui teha viimane rida kujul echo teine > naide.txt, siis vana sisu kirjutataks üle.

Väike turvamärkus

Terminalis ei tasu kunagi lihtsalt kopeerida ja käivitada käsku, mille mõtet sa ei mõista.

Eriti ettevaatlik tasub olla käskudega, mis:

• tõmbavad midagi veebist
• muudavad palju faile korraga
• käivitavad teise käsu automaatselt

Kui jääd kahtlema, peata ja loe enne abi või küsi üle. Käsurida on võimas just sellepärast, et ta teeb täpselt seda, mida sa käsid.

Kui käsk jääb “rippuma”

Kui mõni programm jääb pikalt tööle ja sa tahad selle peatada, siis esimene tavaline pääsetee on:

Ctrl-c

See ei ole iga juhtumi jaoks lahendus, aga alguses on see kõige tähtsam katkestusklahv.

Kui see tundus arusaadav

Pärast seda harjutust on hea jätkata selles järjekorras:

1. Linux, Unix, GNU, macOS, Windows ja shellid
2. Failisüsteemi kaart
3. Kettaruum ja süsteemi maht
4. Õigused, omanikud ja täitmisbitid

Kui see tundus veel liiga kiire

Siis tasub minna tagasi ja lugeda aeglasemalt:

1. Terminali esimesed sammud
2. Abi leidmine: man, --help ja info
3. Kataloogid ja failid
4. Sisend, väljund, torud ja suunamine

Minitest

1. Tee kaust teine-harjutus.
2. Loo sinna fail read.txt kolme reaga.
3. Kontrolli käsuga cat, kas kõik read on olemas.
4. Kontrolli käsuga wc -l, kas failis on kolm rida.
5. Tee failist koopia nimega read-koopia.txt.
6. Muuda koopiat nii, et lisad sinna ühe rea juurde käsuga >>.

Linux, Unix, GNU, macOS, Windows ja shellid

Linuxi kasutamisel kohtab kiiresti mitut sarnast sõna: Linux, Unix, GNU, macOS, Windows, shell, sh, bash, zsh, PowerShell, WSL. Need ei tähenda päris sama asja.

Lühidalt

• Unix oli ajalooline operatsioonisüsteemide perekond ja mõtteviis.
• Linux on kernel ehk tuum, mille ümber ehitatakse süsteem.
• GNU on tööriistade kogum, mis annab paljud tuttavad käsud ja utiliidid.
• macOS on Unix-laadne süsteem, kuid kasutab mitmes kohas BSD- ja Apple'i tööriistu.
• Windows ei ole Unix-laadne, kuid selle saab WSL-i abil väga Linuxi moodi tööle panna.
• Shell on käsutõlk, mille kaudu kasutaja käske sisestab.

Loogika

Selle peatüki mõte on anda õiged mõisted enne, kui käsud lähevad detailseks. Nii on hiljem lihtsam aru saada, milline käitumine tuleb shellist, milline Linuxi süsteemist, milline GNU tööriistadest ja millised erinevused tulevad macOS-ist või Windowsist.

Et samad töövood toimiksid eri masinates võimalikult sarnaselt, on kõige olulisem eristada kolme kihti:

• operatsioonisüsteem
• käsureatööriistad
• shell

Kui need kihid on sarnased, siis on ka õpiku näited sarnasemad.

Kiirülevaade

Eesmärk on saada mõisteline kaart: mis tuleb süsteemist, mis shellist ja mis konkreetsetest käsureatööriistadest.

Tüüpilised algaja vead

• arvatakse, et Linux, Unix ja GNU tähendavad sama asja
• aetakse segi terminal, shell ja operatsioonisüsteem
• eeldatakse, et macOS-i või Windowsi käsk käitub täpselt nagu Linuxis

Kiirspikker

• uname -a näitab süsteemi infot
• echo $SHELL näitab sinu vaikimisi shelli
• ps -p $$ näitab käimasolevat shelliprotsessi
• bash --version või zsh --version näitab shelli versiooni
• command -v ls näitab, kust käsk leitakse
• sw_vers näitab macOS-i versiooni
• wsl -l -v näitab Windowsi WSL-jaotusi ja nende versiooni

Kasuta siit ainult neid käske, mis sobivad sinu masinaga:

• sw_vers on macOS-i jaoks
• wsl -l -v on Windowsi ja WSL-i jaoks
• uname -a, echo "$SHELL" ja ps -p $$ on Unix-laadsetes shellides kõige üldisemad näited

Käivita need käsud

uname -a
echo "$SHELL"
ps -p $$

bash --version
zsh --version

sw_vers
wsl -l -v

Miks see oluline on

Kui loed dokumentatsiooni või juhendeid, siis:

• mõni käitumine tuleb kernelist
• mõni käitumine tuleb shellist
• mõni käsk on GNU variant ja võib teistes Unix-laadsetes süsteemides erineda
• mõni erinevus tuleb sellest, kas töötad päris Linuxis, macOS-is või Windowsis

Levinud shellid

• sh on ajalooline ja üldine shelliliides
• bash on väga levinud GNU shell
• zsh on paindlik interaktiivne shell, mida kasutatakse palju ka macOS-is
• PowerShell on Windowsi käsukeskkond ja skriptikeel

Linux, Unix ja GNU erinevused

Praktikas öeldakse sageli "Linux", kuigi tegelik süsteem koosneb mitmest kihist:

• Linux annab kerneli
• GNU annab suure hulga käsureatööriistu
• distributsioon seob need tervikuks

Samas macOS on Unix-laadne, kuid paljud käsud ei ole seal GNU variandid. Näiteks sed, grep, find ja tar võivad käituda veidi teisiti kui Linuxis. Windows ei ole Unix-laadne, kuid WSL annab päris Linuxi kasutajaruumi, nii et enamik selle õpiku näiteid töötab seal otse.

macOS: miks see on sarnane

macOS tundub käsureal Linuxi moodi, sest:

• tal on Unix-laadne kasutajakeskkond
• seal on olemas sh, bash, zsh, ssh, grep, sed, awk
• failisüsteem, õigused ja torude loogika on tuttavad
• väga suur osa shelli- ja SSH-töövoost on sama

See on põhjus, miks suur osa siinsetest käsureatöövoogudest töötab macOS-is väikeste kohandustega.

macOS: mis on teisiti

macOS ei ole tavaliselt "GNU/Linux". Praktikas tähendab see:

• paketihaldur ei ole apt või dnf; kõige levinum lisapakettide tööriist on Homebrew ehk brew
• mitmed käsud on BSD variandid, mitte GNU variandid
• mõni lipp või vaikekäitumine erineb
• teenuste haldus ei käi systemd kaudu

Mõni Linuxi käsk puudub macOS-is ka täiesti sama nime all. Näiteks:

• Linuxis kasutatakse tihti ip a
• macOS-is on tavalisem ifconfig
• Linuxis kasutatakse tihti ss -ltn
• macOS-is on tavalisem lsof -iTCP -sTCP:LISTEN -n -P või netstat -anv -p tcp | grep LISTEN

Kõige sagedasem praktiline erinevus on see, et Linuxi juhendis toodud lipp ei pruugi macOS-is sama moodi töötada.

Kuidas saada macOS võimalikult sarnaseks Linuxiga

Algaja jaoks ei ole tavaliselt vaja macOS-i vägisi Linuxi moodi ümber ehitada.

Enamasti piisab sellest:

1. kasuta olemasolevat zsh-i või bash-i
2. õpi selgeks põhilised käsud ja nende loogika
3. paigalda Homebrew ainult siis, kui sul on päriselt vaja lisatarkvara

Kui tahad mõnda Linuxi tööriista ka nime poolest lähemale tuua, siis tee seda vajaduspõhiselt, mitte “igaks juhuks”. Näiteks võrgukäskude puhul võib hiljem abiks olla brew install iproute2mac, aga alguses ei ole see vajalik.

Mida macOS-is ei tasu vägisi samaks teha

Kõike ei ole mõtet Linuxi moodi suruda.

• Homebrew ei ole macOS-is vaikimisi sees; see on eraldi paigaldatav lisatööriist
• brew on macOS-is loomulik paketihaldur siis, kui sul on vaja lisatarkvara
• Finder ja rakenduste käivitamine jäävad Apple'i loogika järgi
• teenuste haldus ja süsteemikonfiguratsioon ei ole üks ühele Linuxiga

Hea eesmärk ei ole "teha macOS-ist Linux", vaid teha shelli- ja arendustöö piisavalt sarnaseks.

Kui sul tekib hiljem mõni konkreetne ühilduvusprobleem, siis lahenda see eraldi. Alguses ei ole vaja paigaldada GNU variante lihtsalt harjumuse pärast.

Windows: milline tee valida

Windowsis on kolm peamist teed:

• WSL2: parim valik, kui tahad selle õpiku käske kasutada võimalikult päris Linuxi moodi
• PowerShell: parim valik Windowsi enda halduseks
• Git Bash: kerge ja mugav, aga mitte täielik Linux

Kui eesmärk on "see õpik töötaks samal moel", siis soovitus on väga selge: kasuta WSL2.

WSL tähendab Windows Subsystem for Linux. See on Windowsi võimalus käivitada päris Linuxi kasutajaruumi omaette keskkonnas. Praktikas tähendab see, et saad Windowsi sees avada Ubuntu või muu Linuxi keskkonna ja kasutada seal tavapäraseid Linuxi käske, pakette ja shelli.

WSL2 on uuem ja tavalisem variant. Õpiku mõttes on ta hea sellepärast, et käsud käituvad seal palju rohkem päris Linuxi moodi kui PowerShellis või vanas cmd.exe-s.

Kuidas saada Windows võimalikult sarnaseks Linuxiga

Kõige mõistlikum töövoog on:

1. paigalda Windows Terminal
2. paigalda WSL2
3. vali näiteks Ubuntu
4. tee käsureatöö WSL-i sees, mitte tavalises cmd.exe-s

Alustuseks piisab sageli sellest:

wsl --install

Pärast paigaldust kontrolli:

wsl -l -v

Ja siis mine Linuxi sisse:

wsl

Seal sees hakkavad juba tööle tavapärased Linuxi käsud:

uname -a
echo "$SHELL"
sudo apt update

Kuidas Windowsis shelliga mõelda

Kui töötad WSL-is, siis loogika on:

• Windows on host-süsteem
• WSL annab Linuxi kasutajaruumi
• shell, paketid ja käsud töötavad Linuxi loogika järgi

Kui töötad PowerShellis, siis loogika on teine:

• toru ei kanna ainult teksti, vaid objekte
• käsunimed ja lühendid on teised
• paljud selle õpiku näited ei ole üks ühele kopeeritavad

See tähendab, et "sama moodi toimima" saad Windowsis kõige paremini WSL-i abil, mitte PowerShelli Linuxiks painutades.

Praktilised soovitused Windowsi jaoks

• hoia Linuxi projektid võimalusel WSL-i kodukataloogis nagu ~/projekt, mitte alati /mnt/c/...
• kasuta Windows Terminali, mitte vana konsooli
• kasuta VS Code Remote WSL töövoogu, kui arendad Windowsist Linuxi tööriistadega
• kasuta PowerShelli siis, kui haldad Windowsi ennast

Mis jääb Windowsis ikkagi teistsuguseks

• failiteed ja kettatähed on teistsugused
• CRLF ja LF võivad tekitada segadust
• .exe, .bat ja Windowsi õiguste loogika ei ole sama mis Unixis
• mõni tööriist töötab WSL-is paremini kui otse Windowsi failisüsteemis

Minitest

1. Uuri välja, millist shelli sa kasutad.
2. Võrdle käske echo $SHELL ja ps -p $$.
3. Kontrolli, kas sinu süsteemis on olemas bash, zsh ja sh.
4. Kui oled macOS-is, kontrolli käsuga sw_vers, millist süsteemi kasutad.
5. Kui oled Windowsis, kontrolli käsuga wsl -l -v, kas WSL on olemas.
6. Kirjelda ühe lausega, miks WSL2 sobib Linuxi-laadse käsureatöö jaoks paremini kui ainult PowerShell.

Lisalugemine

Selle teema usaldusväärsemad viited leiad lisast Lisa E: usaldusväärsed viited ja lisalugemine ning shelli enda kohta jaotisest Shellid ja põhikäsud.

Failisüsteemi kaart

Loogika

Algaja jaoks on väga tavaline küsimus:

• mis vahe on / ja ~ vahel
• miks mõni fail on minu kodukataloogis, aga mõni /etc all
• miks süsteemifailidega ei tasu suvaliselt katsetada

Failisüsteemi kaart aitab siduda üksikuid käske suurema pildiga. Kui tead, mis tüüpi asjad mingis kaustas tavaliselt elavad, on ka veaotsing ja navigeerimine palju lihtsam.

Kiirülevaade

Eesmärk on saada süsteemist kaart, et teaksid, kus on ohutu töötada ja millised kohad on süsteemi omad.

Tüüpilised algaja vead

• arvatakse, et ~ ja / on lihtsalt kaks erinevat märki sama asja jaoks
• minnakse süsteemikaustadesse midagi muutma enne, kui saadakse aru, mis seal elab
• eeldatakse, et Linux ja macOS kasutavad täpselt samu teid

Kiirspikker

• / on kogu failipuu juur
• ~ tähendab sinu kodukataloogi
• /home on Linuxis kasutajate kodukataloogide tavaline vanemkaust
• /Users on macOS-is kasutajate kodukataloogide tavaline vanemkaust
• /etc sisaldab palju süsteemi seadistusfaile
• /bin ja /usr/bin sisaldavad käivitatavaid programme
• /usr sisaldab palju programme ja teeke
• /var sisaldab muutuvat sisu nagu logid ja vaheandmed
• /tmp on ajutiste failide koht

Käivita need käsud

pwd
echo "$HOME"
cd /
ls
ls /etc | head
ls /usr | head
ls /var | head
ls -ld /tmp

Kui kasutad macOS-i, siis vaata ka:

ls /Users

/ ehk juur

Kõige ülemine kaust on /.

See ei tähenda “minu kodukataloog”, vaid kogu failipuu algust. Kui kirjutad:

cd /

siis liigud juurkataloogi, mitte oma isiklikku töökataloogi.

Oluline vahe:

• cd / viib juurkataloogi
• cd ~ viib sinu kodukataloogi
• cd .. liigub ühe taseme võrra üles

Kodukataloog: ~

Kodukataloog on koht, kus tavaline kasutaja enamasti töötab.

Linuxis on see sageli midagi sellist:

/home/kasutaja

macOS-is sageli midagi sellist:

/Users/kasutaja

Sümbol ~ tähendab lühidalt sinu kodukataloogi. Näiteks:

• ~/Downloads
• ~/.ssh
• ~/proov

See on põhjus, miks esimesed harjutused tasub teha just kodukataloogi all.

/etc

/etc sisaldab palju süsteemi seadistusi.

Sealt võib leida näiteks:

• teenuste seadistusfaile
• võrgu seadeid
• kasutajate ja gruppide infot

See ei ole hea koht algajale juhuslikeks katsetusteks. Selles kaustas muudatusi tehes tasub alati täpselt teada, mida muudad ja miks.

/usr

/usr sisaldab palju programme, käske, teeke ja dokumentatsiooni.

Praktiliselt võid sellest mõelda nii:

• siin on palju “süsteemi poolt pakutud tööriistu”
• sina kasutad neid sageli, aga ei muuda neid otse käsitsi

Sageli näed seal kaustu nagu:

• /usr/bin
• /usr/lib
• /usr/share

Nimi bin tuleb ajalooliselt sõnast binary. Unix-laadsetes süsteemides tähendab see tavaliselt kataloogi, kus on käivitatavad programmid ehk käsud. Näiteks:

• /bin sisaldab süsteemi põhilisi käske
• /usr/bin sisaldab suurt hulka tavakasutaja käske
• ~/bin on levinud koht kasutaja enda väikeste skriptide jaoks

Kõik bin-kataloogis olev ei pea tänapäeval olema masinkoodis binaar. Seal võib olla ka shelliskripte või Pythoni programme, kui neid saab käsuna käivitada.

/var

/var on mõeldud muutuvate andmete jaoks.

Seal võivad olla näiteks:

• logifailid
• vahemälud
• spool-id
• teenuste töö käigus tekkivad andmed

Kui otsid, miks mingi teenus ei tööta või kuhu ruum kadus, jõuad üsna tihti just /var alla.

/tmp

/tmp on ajutiste failide koht.

See tähendab tavaliselt:

• siia pannakse lühiajaliselt vahefaile
• süsteem või programmid võivad selle sisu hiljem kustutada
• siia ei tasu panna faile, mida tahad kindlasti alles hoida

Kui tahad lihtsalt kiiresti midagi testida, võib /tmp olla kasulik töökoht. Kui tahad, et fail kindlasti alles jääks, kasuta pigem oma kodukataloogi.

Linux ja macOS ei ole siin täiesti samad

Raamatu loogika on Unix-laadne, aga detailides on vahe:

• Linuxis on kasutajate kodud tihti /home
• macOS-is on kasutajate kodud tihti /Users
• macOS-is on osa süsteemikaustu kaitstumad ja neid ei ole mõistlik käsitsi muuta

Seetõttu tasub mõelda mitte ainult teepärale endale, vaid ka selle rollile.

Rusikareegel

Kui mõtled “kus ma tohiksin vabalt katsetada?”, siis tavaliselt:

• hea koht on sinu kodukataloog
• ettevaatlik koht on projektikaust, kus on päris töö
• halb koht juhukatsetusteks on süsteemikaust nagu /etc või /usr

Minitest

1. Seleta oma sõnadega, mis vahe on cd / ja cd ~ vahel.
2. Uuri välja, mis on sinu kodukataloogi tegelik tee.
3. Vaata, kas sinu süsteemis on kasutajate kodud pigem /home või /Users all.
4. Pane kirja, milline kaust sobib ajutisteks failideks ja milline süsteemi seadistusteks.

Kettaruum ja süsteemi maht

Loogika

Algajal tuleb väga kiiresti ette küsimus:

• kuhu ruum kadus
• kui suur mingi kaust on
• kas kettal on üldse veel vaba ruumi

Siin on oluline eristada kahte eri vaadet:

• faili- või kettasüsteemi üldseis
• konkreetse kausta või puu suurus

df ja du lahendavad need kaks eri küsimust.

Kiirülevaade

Erista kaht küsimust: kas failisüsteemis on ruumi ja mis konkreetse kausta sees ruumi võtab.

Tüüpilised algaja vead

• arvatakse, et df ja du annavad sama vastuse
• vaadatakse ainult kogumahtu, mitte seda, milline kaust ruumi võtab
• unustatakse peidetud kaustad nagu .git, .venv või .cache

Kiirspikker

• df -h näitab failisüsteemide kasutust
• df -h . näitab selle koha failisüsteemi, kus sa parajasti oled
• du -sh . näitab praeguse kausta kogusuurust
• du -sh * näitab alamkaustade ja failide suurusi
• du -sh * | sort -h sorteerib inimloetavad mahud väiksemast suuremani
• du -a . | sort -nr | less näitab suurimaid kirjeid detailsemalt

Käivita need käsud

df -h
df -h .
du -sh .
du -sh * 2>/dev/null
du -sh * 2>/dev/null | sort -h

Kui tahad detailsemalt näha, kuhu ruum kaob:

du -a . 2>/dev/null | sort -nr | less

Kui tahad vaadata oma kodukataloogi tüüpilisi “ruumisööjaid”, siis proovi:

cd "$HOME"
du -sh Downloads Documents Desktop 2>/dev/null

df: kui palju ruumi failisüsteemil on

df vastab küsimusele:

“Kui täis see kettasüsteem või mount point on?”

Näide:

df -h

Lipp -h tähendab inimesele loetavat vormi, näiteks:

• K
• M
• G
• T

Kui tahad teada, millisel failisüsteemil praegune töökaust asub:

df -h .

See on hea nipp, sest mitme mount point'i puhul ei huvita sind alati kogu masin, vaid just see failisüsteem, mille peal su töökaust asub.

du: kui suur see kaust ise on

du vastab küsimusele:

“Kui palju ruumi see kaust või failipuu kasutab?”

Näited:

du -sh .
du -sh *

Siin tähendab:

• -s summary ehk kogu kokkuvõte
• -h inimesele loetav suurus

See kombinatsioon on üks praktilisemaid ruumikontrolle kogu käsureal.

Kui tahad ainult ühte kogusummat, siis sobib hästi:

du -sh .

Kui tahad näha ka faili- ja alamkaustade taset detailsemalt, siis:

du -a .

Siin tähendab:

• -a näita mitte ainult kaustu, vaid ka üksikfaile

Just see teeb du-st väga praktilise veaotsingutööriista siis, kui ruum on “kuskile ära kadunud”.

df ja du ei vasta samale küsimusele

Oluline vahe:

• df räägib failisüsteemi tasemest
• du räägib faili või kausta tasemest

Näiteks:

• df -h võib näidata, et kettal on alles ainult 5% vaba ruumi
• du -sh Downloads võib näidata, et suure osa sellest võtab Downloads

Kõige tavalisem töövoog

Kui ruum tundub otsas olevat, siis liigu nii:

1. vaata df -h, kas probleem on päriselt ruumis
2. mine kausta, kus arvad suure sisu olevat
3. käivita du -sh *
4. sorteeri tulemus, et näha suurimaid kohti

Näide:

cd "$HOME"
du -sh * 2>/dev/null | sort -h

Siin tähendab sort -h, et sorditakse inimloetavaid suurusi nagu 12K, 450M ja 3.1G, mitte ainult paljaid numbreid.

Sellest on tihti kohe näha, kas ruumi söövad näiteks:

• allalaadimised
• vana projektikaust
• andmefailid
• buildi väljundid

Kui sellest ei piisa ja tahad minna sügavamale, siis järgmine väga tavaline päriselu käik on:

du -a . 2>/dev/null | sort -nr | less

Selle loogika on:

• du -a . käib kogu puu läbi ja annab iga faili või kausta suuruse
• sort -nr paneb suurimad kirjed ette
• less lubab tulemust rahulikult sirvida ja otsida

See on üks kõige praktilisemaid “mis siin kõige rohkem ruumi võtab?” käsujadasid kogu Unix-laadses käsureas.

du -a | sort -nr | less päris töös

See kuju väärib eraldi väljaütlemist, sest seda kasutatakse palju rohkem kui alguses arvata võiks.

Näide:

cd "$HOME"
du -a . 2>/dev/null | sort -nr | less

Mida siin vaadata:

• kõige ülemised read on tavaliselt suurimad ruumisööjad
• kui näed mõnd kausta, mine sinna sisse ja korda sama käsku kitsamas kohas
• less sees saad otsida näiteks /Downloads, /node_modules, /.git, /.venv

See on hea iteratiivne tööviis:

1. alusta suuremast kohast
2. leia suurim alamkaust või fail
3. mine sinna sisse
4. korda sama analüüsi

Inimloetav vs toores numbriline sort

Kõige universaalsem kuju on:

du -a . 2>/dev/null | sort -nr | less

Seda on hea kasutada, sest:

• sort -n töötab numbrite peal selgelt
• du annab suurused ühes sisemises ühikus
• tulemus on hästi võrreldav

Mõnes keskkonnas meeldib inimestele rohkem ka inimloetav kuju:

du -ah . 2>/dev/null | sort -hr | less

Aga see eeldab, et sinu sort toetab -h lippu. Selle õpiku põhikuju on seetõttu pigem du -a . | sort -nr | less.

Peidetud kaustad võivad olla kõige suuremad

Väga sageli söövad ruumi just peidetud kaustad, mida tavaline ls kohe silma ette ei too, näiteks:

• .git
• .venv
• .cache
• .npm

Peidetud kaustade kaasamiseks kasuta:

du -sh .[!.]* * 2>/dev/null | sort -h

See näitab koos:

• peidetud kirjed
• tavalised kirjed

Kui ruum “justkui kadus ära”, siis see on üks esimesi käske, mida tasub proovida.

Ettevaatus

Kõiki suuri käske ei tasu pimesi käivitada suvalises kohas.

Näiteks:

du -sh /

võib olla aeglane ja mitte eriti informatiivne, eriti kui sul ei ole õigusi kõiki kaustu lugeda.

Praktilisem on alustada kitsamalt:

• du -sh .
• du -sh *
• du -sh "$HOME"/*

Kas failide arv ja suurus on sama asi?

Ei ole.

• üks väga suur fail võib võtta rohkem ruumi kui tuhat väikest
• samas tuhanded väikesed failid võivad teha töö aeglaseks või segaseks

Kui tahad lisaks suurusele aru saada ka failide hulgast, siis saad vaadata näiteks:

find . -type f | wc -l

See ei mõõda ruumi, aga aitab näha, kas probleem võib olla ka väga suures failide arvus.

Minitest

1. Uuri välja, kui palju vaba ruumi on failisüsteemil, kus asub sinu praegune töökaust.
2. Vaata, kui suur on sinu praegune kaust kokku.
3. Sorteeri praeguse kausta alamkaustad suuruse järgi.
4. Pane ühe lausega kirja, mis vahe on df -h ja du -sh . vahel.

Õigused, omanikud ja täitmisbitid

Loogika

Õigused määravad, kes võib faili lugeda, muuta või käivitada. See on seotud kasutajate, gruppide, sudo ja shelliskriptidega, sest kõik need teemad sõltuvad õiguste korrektsest mõistmisest.

Kiirülevaade

Eesmärk on lugeda õiguste rida, teha fail vajadusel käivitatavaks ja mõista “Permission denied” viga.

drwxr-xr-x algab d tähega, sest tegu on kataloogiga.

Tüüpilised algaja vead

• arvatakse, et chmod +x teeb failist automaatselt “programmi”
• muudetakse õigused liiga laiaks, ilma et oleks aru saadud, kellele mida antakse
• aetakse segi faili lugemisõigus ja käivitamisõigus

Kiirspikker

• ls -l vaata õigusi
• chmod +x fail tee fail käivitatavaks
• chmod 644 fail tavaline tekstifail
• chmod 755 fail tavaline käivitatav fail
• chown kasutaja:grupp fail muuda omanikku

Õiguste vaatamine

ls -l

Näites:

-rw-r--r-- 1 mari users 120 Apr 12 10:00 naide.txt

See rida kirjeldab:

• faili tüüpi
• omaniku õigusi
• grupi õigusi
• teiste kasutajate õigusi

Lühidalt:

• r tähendab lugemist
• w tähendab kirjutamist
• x tähendab faili puhul käivitamist, kataloogi puhul sisenemist

Miks kataloogi x-õigus on eriline

Faili puhul tähendab x, et faili võib programmina käivitada.

Kataloogi puhul tähendab x midagi natuke muud:

• tohid sinna cd abil siseneda
• tohid kasutada selle sees olevaid nimesid
• ilma x-õiguseta võib kataloog olemas olla, aga sa ei saa selles normaalselt liikuda

See on üks tavaline koht, kus permission denied tundub esmapilgul segane.

Õiguste muutmine

chmod u+x skript.sh
chmod 644 naide.txt

Siin on kaks levinud stiili:

• sümboolne kuju nagu chmod u+x fail
• numbriline kuju nagu chmod 644 fail

Sümboolne kuju sobib hästi siis, kui tahad teha ühe väikese muudatuse:

• u+x fail lisa omanikule täitmisõigus
• g-w fail võta grupilt kirjutamisõigus ära

Numbriline kuju sobib siis, kui tahad seada terve õiguste rea korraga:

• 644 tähendab tavaliselt tekstifaili
• 755 tähendab tavaliselt käivitatavat faili või kataloogi

Kõige tavalisemad lipud

• ls -l kuva õigused detailvaates
• chmod +x lisa täitmisõigus
• chmod 644 sea tavalise tekstifaili õigused
• chmod 755 sea tavalise käivitatava faili õigused
• chown kasutaja:grupp muuda omanikku ja gruppi

Omaniku muutmine

sudo chown kasutaja:grupp fail.txt

Käivitatavaks tegemine

chmod +x ja shebang-rida käivad sageli koos.

• shebang nagu #!/bin/sh või #!/usr/bin/env python3 ütleb, millise interpretaatoriga faili käivitada
• täitmisõigus ütleb, et faili tohib käivitada käsuga ./fail
• kui käivitad faili kujul ./fail, siis süsteem vaatab kõigepealt faili algust ja otsib sealt, millega seda tõlgendada

Kui üks neist puudub, siis võib fail küll olemas olla, aga ta ei käivitu ootuspäraselt.

Käivita need käsud

printf '#!/bin/sh\necho tere\n' > tere.sh
chmod +x tere.sh
./tere.sh

printf '#!/usr/bin/env perl\nprint \"tere\\n\";\n' > tere.pl
chmod +x tere.pl
./tere.pl

Mida tähendab käivitatav fail

Täidetavaks tegemine ei muuda faili maagiliselt programmiks. Tavaliselt on vaja:

1. õiget shebang-rida
2. täitmisõigust
3. olemasolevat interpretaatorit või binaari

Kui fail algab näiteks nii:

#!/usr/bin/env perl

siis süsteem proovib selle käivitada Perliga. Kui Perl puudub või tee on vale, siis ei piisa ainult täitmisõigusest.

Minitest

1. Tee fail proov.sh, mis väljastab ühe rea.
2. Anna talle täitmisõigus.
3. Käivita fail nii sh proov.sh kui ./proov.sh.

Kasutajad, grupid ja sudo

Loogika

Unix-laadsed süsteemid eeldavad, et igal tegevusel on tegija. Seetõttu on oluline aru saada, millise kasutajana sa töötad, millistesse gruppidesse kuulud ja millal on vaja kõrgemaid õigusi.

Kiirülevaade

Eesmärk on teha nähtavaks, kes käsu käivitab ja millal kasutatakse kõrgemaid õigusi.

Tüüpilised algaja vead

• arvatakse, et sudo tähendab “paranda see käsk võluväel ära”
• jäädakse pikaks ajaks root-i või kõrgemate õigustega shelli
• käivitatakse ohtlik käsk sudo-ga enne, kui kontrollitakse, kus parajasti ollakse

Kiirspikker

• whoami näitab aktiivset kasutajat
• id näitab kasutajat ja gruppe
• groups näitab gruppe
• sudo käsk käivitab käsu kõrgemate õigustega
• su - kasutaja vahetab kasutajat

Käivita need käsud

whoami
id
groups

sudo -l

Miks ettevaatlik olla

sudo annab suure võimu. Vale käsk kõrgemate õigustega võib:

• kustutada süsteemifaile
• muuta õigusi valesti
• paigaldada või eemaldada tarkvara

Seega tasub enne sudo käivitamist mõelda, kas seda on päriselt vaja.

Mis on root

root on Unix-laadsete süsteemide eriline administraatori kasutaja.

Oluline loogika:

• tavakasutaja töötab piiratud õigustega
• root võib peaaegu kõike
• sudo annab tavakasutajale võimaluse käivitada mõni üksik käsk ajutiselt kõrgemate õigustega

Seega ei ole root ja sudo päris sama asi:

• root on kasutaja
• sudo on tööriist, millega mõni käsk käivitatakse kõrgemate õigustega

Kuidas root promptis ära tunda

Sageli on root-i promptis lõpus märk #, samas kui tavakasutajal on sageli $ või %.

Näited:

kasutaja@mac proov % whoami
kasutaja

root@server:/etc# whoami
root

See ei ole küll absoluutne reegel, kuid väga levinud rusikareegel on:

• $ või % tähendab tavakasutajat
• # tähendab, et tasub olla eriti ettevaatlik

Kui on kahtlus, kontrolli alati:

whoami
id

sudo käsk vs sudo -i vs su -

Kõige ohutum tavakasutus on enamasti:

sudo käsk

Näiteks:

sudo apt update
sudo systemctl restart ssh

See on hea, sest kõrgemad õigused kehtivad ainult sellele ühele käsule.

On olemas ka kujud:

sudo -i
su -

Need annavad sulle root-shelli või vahetavad kasutajat. See tähendab, et järgmised käsud töötavad juba kõrgemate õigustega seni, kuni sellest shellist väljud.

Algajale on see riskantsem, sest:

• prompt võib muutuda
• iga järgmine käsk võib teha suurema mõjuga muudatuse
• on lihtne unustada, et oled enam mitte tavakasutaja

Seepärast on hea algreegel:

• eelista sudo käsk
• väldi püsivat root-shelli, kui selleks ei ole selget põhjust

Mida root-ina mitte teha

Hea ettevaatusreegel on: ära tee harjutusi, failide sorteerimist ega igapäevast tekstitööd root-kasutajana.

Väldi eriti:

• rm -rf käske root'ina
• failide juhuslikku chown või chmod muutmist süsteemikaustades
• harjumust "kui ei tööta, siis pane sudo ette"

Parem mõtteviis on:

1. proovi käsku tavakasutajana
2. loe veateadet
3. mõtle, kas probleem on õigustes või hoopis milleski muus
4. kasuta sudo ainult siis, kui tead, miks seda vaja on

Väike praktiline kontroll

Kui tahad näha, millal oled tavakasutaja ja millal kõrgemates õigustes, siis need käsud on kõige kasulikumad:

whoami
id
sudo -l

Need annavad rohkem kindlust kui ainult prompti kuju vaatamine.

Minitest

1. Vaata oma kasutaja gruppe.
2. Uuri, milliseid käske tohib sinu kasutaja sudo abil käivitada.
3. Selgita oma sõnadega, miks sudo rm -rf ... on ohtlik.
4. Selgita ühe lausega, mis vahe on root kasutajal ja käsul sudo.

Muutujad, keskkond, PATH ja aliased

Shell ei käivita ainult programme. Ta hoiab ka väärtusi, otsustab, kust käske otsida, ja võib anda käskudele lühinimesid.

Loogika

Selles peatükis on neli põhimõtet:

1. shellimuutuja on väärtus praeguses shellis
2. keskkonnamuutuja antakse edasi käivitatud programmidele
3. PATH on kataloogide järjekord, kust väliseid käske otsitakse
4. alias on lühinimi käsule või käsukujule

Kõige tähtsam on mitte ajada segi väärtust, käsu otsimist ja mugavusnime.

Kiire orientiir

Tüüpilised algaja vead

• pannakse nimi=väärtus juurde tühikud, näiteks nimi = Mari
• arvatakse, et shellimuutuja on automaatselt kõigile programmidele nähtav
• muudetakse PATH-i nii, et kogemata varjutatakse süsteemi käsk
• usaldatakse ainult which käsku ja ei märgata alias't või shelli sisseehitatud käsku
• lisatakse alias valesse seadistusfaili ja imestatakse, miks uus terminaliaken seda ei tunne
• kopeeritakse prompti muutmise näide püsivasse faili enne, kui seda ajutiselt prooviti

Shellimuutuja ja keskkonnamuutuja

Shellimuutuja elab praeguses shellis.

nimi='Mari'
echo "$nimi"

Kui käivitad uue programmi, ei pruugi tavaline shellimuutuja sinna kaasa minna.

nimi='Mari'
sh -c 'echo "$nimi"'

Keskkonnamuutuja tehakse alamprotsessidele nähtavaks käsuga export.

export PROJEKT='linux-opik'
sh -c 'echo "$PROJEKT"'

Põhireegel:

• nimi='Mari' sobib väärtuseks praeguses shellis
• export NIMI='Mari' sobib siis, kui käivitatav programm peab seda nägema

Hea tava on kirjutada keskkonnamuutujad sageli suurte tähtedega, näiteks PATH, HOME, EDITOR, SHELL.

Tühikud ja jutumärgid

Muutuja omistamisel ei panda võrdusmärgi ümber tühikuid.

Õige:

nimi='Mari'

Vale:

nimi = 'Mari'

Kui väärtuses on tühik, pane väärtus jutumärkidesse.

projekt='Linuxi õpik'
echo "$projekt"

Muutuja lugemisel eelista kuju:

echo "$projekt"

Jutumärgid hoiavad väärtuse koos ka siis, kui sees on tühikuid.

Mis asi käsk on

Terminali kirjutatud nimi ei tähenda alati välist programmi failisüsteemis.

See võib olla:

Seetõttu on õppimisel väga kasulik:

type cd
type grep
type ll
command -v python3

type ütleb käsu liigi. command -v ütleb lühidalt, mida shell käivitaks.

Kui sama nimega vasteid on mitu:

type -a python3
type -a grep

See aitab näha, kas eespool on näiteks Homebrew, Conda, süsteemi Python või sinu enda skript.

PATH: kust käsk leitakse

Kui kirjutad käsu:

python3

siis shell otsib väliseid programme muutujas PATH loetletud kataloogidest.

echo "$PATH"

Tüüpiline kuju on selline:

/Users/kasutaja/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin

Oluline reegel:

• teed on eraldatud kooloniga
• otsitakse vasakult paremale
• esimene sobiv käivitatav fail võidab

Kontrolli alati päris vastet:

command -v python3
command -v grep

Kui käsk ei leidu, on tavaliselt üks kahest põhjusest:

• programm pole paigaldatud
• programmi kataloog pole PATH-is

Oma bin kataloog

Oma väikesed skriptid võib panna näiteks kataloogi ~/bin või ~/.local/bin.

Loo kataloog:

mkdir -p "$HOME/bin"

Lisa see praeguses shellis otsingutee ette:

export PATH="$HOME/bin:$PATH"

Ette lisamine tähendab, et sinu ~/bin vaste leitakse enne süsteemi sama nimega käsku. See on mugav, aga nõuab tähelepanu.

Ettevaatlikum kuju on lisada oma kataloog lõppu:

export PATH="$PATH:$HOME/bin"

Sel juhul jäävad süsteemi tavalised käsud eelisjärjekorda.

Väike oma käsk

Tee üks väike käsurea tööriist oma ~/bin kataloogi.

mkdir -p "$HOME/bin"
cat > "$HOME/bin/opik-tere" <<'EOF'
#!/bin/sh
echo "Tere oma bin-kataloogist"
EOF
chmod +x "$HOME/bin/opik-tere"
export PATH="$HOME/bin:$PATH"
command -v opik-tere
opik-tere

Siin:

• fail opik-tere on väike shelliskript
• chmod +x teeb selle käivitatavaks
• PATH lisamine lubab käivitada seda nimega opik-tere
• command -v opik-tere kinnitab, kust käsk leitakse

Kui see töötab ainult praeguses aknas, on põhjus lihtne: export PATH=... oli ajutine. Püsivaks muutmiseks lisa rida shelli seadistusfaili.

Seadistusfailid

Shell loeb käivitumisel seadistusfaile. Täpne fail sõltub shellist ja sellest, kas tegu on login-shelli või interaktiivse shelliga.

Praktiline algaja jaotus:

Kui sa ei taha veel startup-failide nüanssidesse süveneda, alusta oma aktiivse shelli interaktiivsest failist:

• zsh: ~/.zshrc
• bash: ~/.bashrc

Näide zsh jaoks:

cat >> ~/.zshrc <<'EOF'
export PATH="$HOME/bin:$PATH"
alias ll='ls -lah'
EOF
source ~/.zshrc

Näide bash jaoks:

cat >> ~/.bashrc <<'EOF'
export PATH="$HOME/bin:$PATH"
alias ll='ls -lah'
EOF
source ~/.bashrc

Shelli seadistusfailide põhjalikumad näited on lisas Lisa F: shelli seadistusfailid bash ja zsh jaoks.

Alias'ed

Alias on lühinimi sagedase käsu jaoks.

alias ll='ls -lah'
alias la='ls -A'
alias gs='git status'
alias h='history | tail -n 20'

Alias sobib hästi siis, kui ta lühendab tuttavat käsku, aga ei peida olulist loogikat.

Vaata olemasolevaid alias'eid:

alias
type ll

Eemalda alias praeguses shellis:

unalias ll

Väldi alias'eid, mis teevad ohtliku käsu liiga “mugavaks”. Näiteks rm ümberkirjutamine võib aidata ühes shellis, aga tekitada vale turvatunde teises masinas.

Miks which võib petta

Paljud kasutavad käsku:

which grep

Õppimiseks eelista:

type grep
command -v grep

Põhjus:

• which keskendub sageli välistele programmidele
• type näitab ka alias'ed, built-in käsud ja shelli vaatenurga
• command -v on lühike ning sobib hästi kontrolliks

Kui “käsk käitub imelikult”, alusta kontrollist:

type käsk
type -a käsk

Prompt ja ajalugu lühidalt

Prompt on tekst enne käsu sisestamist. See ei ole käsu osa.

Näide:

~/projekt %

Kui prompt näitab üht asja ja oled ebakindel, kontrolli käsuga:

pwd

Ajutine lihtne prompt zsh-is:

export PROMPT='%# '

Ajutine lihtne prompt bash-is:

export PS1='$ '

Proovi prompti muutmist alguses ainult jooksvas shellis. Püsiv prompt kuulub hiljem ~/.zshrc või ~/.bashrc faili.

Ajaloo vaatamiseks piisab alguses:

history

Kui torud ja filtrid on juba tuttavad:

history | tail -n 20

Mõned sagedased keskkonnamuutujad

Näited:

echo "$HOME"
echo "$SHELL"
echo "$LANG"
export EDITOR=nano

Kui mõni programm avab ootamatult teise redaktori, kontrolli EDITOR muutujat.

Minitest

1. Loo shellimuutuja nimi='Mari' ja kuva see.
2. Loo keskkonnamuutuja DEMO=1 ning kontrolli seda käsuga env.
3. Vaata oma PATH muutujat.
4. Kontrolli, kust leitakse python3 või bash.
5. Võrdle käske type cd ja command -v cd.
6. Loo alias ll='ls -lah' ja kontrolli seda käsuga type ll.
7. Lisa ~/bin ajutiselt PATH-i ette ja kontrolli, et rida muutus.
8. Selgita ühe lausega, miks PATH järjekord võib olla ohtlik.

Paketihaldus: apt, dnf, pacman, brew

Paketihaldur paigaldab tarkvara koos vajalike sõltuvustega ja hoiab süsteemi seisundi jälgitavana. Peamine oskus on valida õige tase: kas paigaldad tööriista kogu süsteemile, oma kasutajale või ainult ühele projektile.

Loogika

Paketihalduses on kolm taset:

1. süsteemi paketihaldur paigaldab käsureatööriistu ja süsteemiteeke
2. keele paketihaldur paigaldab ühe programmeerimiskeele teeke
3. projekti sõltuvused kuuluvad võimalusel projekti kataloogi või virtuaalkeskkonda

Kõige sagedasem algaja viga on paigaldada kõik ühe käsuga “kuhugi süsteemi”, mõtlemata, kes seda hiljem kasutab ja kust see leitakse.

Kiire orientiir

Vali korraga ainult oma süsteemile või projektile sobiv rida. Ubuntu kasutaja ei käivita Fedora käske ja macOS-i kasutaja ei paigalda Homebrew pakette käsuga sudo apt.

Tüüpilised algaja vead

• käivitatakse mitu eri distributsiooni paigalduskäsku järjest
• kasutatakse sudo-t seal, kus paketihaldur seda ei vaja, näiteks Homebrew puhul
• paigaldatakse Pythoni projektiteek süsteemi, kuigi õigem oleks venv
• arvatakse, et Homebrew on macOS-is juba olemas
• ei loeta paigalduslogi lõppu, kus sageli on tegelik veateade või järgmine juhis

Vali oma süsteemi käsk

Otsi paketti enne paigaldamist:

apt search ripgrep
dnf search ripgrep
pacman -Ss ripgrep
brew search ripgrep

Paigalda ainult oma süsteemi rida:

sudo apt install ripgrep
sudo dnf install ripgrep
sudo pacman -S ripgrep
brew install ripgrep

Kontrolli pärast paigaldust:

rg --version
command -v rg

Kui paigaldus õnnestub, näed tavaliselt logi, allalaadimist, sõltuvusi ja lõpuks vaikset käsuviipa. Kui käsk ei ilmu pärast paigaldust nähtavale, kontrolli PATH-i ja ava vajadusel uus terminaliaken.

Miks mõnikord on vaja sudo

Linuxi süsteemipaketid muudavad tavaliselt süsteemi katalooge. Seetõttu kasutatakse tihti:

sudo apt install htop

Homebrew töötab enamasti kasutaja õigustes:

brew install htop

Ära lisa sudo-t lihtsalt harjumusest. Kui paketihaldur seda ei küsi, on parem jätta see kasutamata.

update ja upgrade

Nimed on sarnased, aga tähendus on erinev.

Ära käivita suurt upgrade-i siis, kui sul on kohe vaja arvutit tööks või esitluseks. Uuendamine võib võtta aega ja mõnikord küsida lisavalikuid.

Uuendamine, info ja eemaldamine

Debianis ja Ubuntus värskendab apt update paketinimekirja, mitte veel kõiki programme.

sudo apt update
apt show ripgrep
sudo apt install ripgrep
sudo apt remove ripgrep

Fedoras on tavaline kuju:

dnf info ripgrep
sudo dnf install ripgrep
sudo dnf remove ripgrep

Arch Linuxis otsitakse ja paigaldatakse nii:

pacman -Ss ripgrep
sudo pacman -S ripgrep
sudo pacman -R ripgrep

Homebrew puhul:

brew info ripgrep
brew install ripgrep
brew uninstall ripgrep

Eemaldamise näited on siin väikese tööriista peal. Ära eemalda juhuslikult süsteemiteeke ega pakette, mille rollist sa aru ei saa.

Süsteemi paketihaldur ja keele paketihaldur

apt install python3-requests ja python3 -m pip install requests ei ole sama asi.

Pythoni projektis on tavaliselt parem kasutada virtuaalkeskkonda:

python3 -m venv .venv
source .venv/bin/activate
python3 -m pip install requests
python3 -m pip show requests

Node.js projektis paigaldatakse sõltuvused projekti kataloogis:

npm install
npm list --depth=0
npm run dev

Kui käsk npm run dev ei tööta, vaata kõigepealt package.json faili. Seal on kirjas, millised scripts nimed on üldse olemas.

pip kuju

Pythoni puhul eelista kuju:

python3 -m pip install requests

mitte lihtsalt:

pip install requests

Nii on selgem, millise Pythoni tõlgendiga pakette paigaldatakse. See muutub eriti tähtsaks siis, kui arvutis on mitu Pythoni versiooni või aktiivne virtuaalkeskkond.

macOS ja Homebrew

macOS-is on osa Unixi käske juba olemas, aga Homebrew tuleb tavaliselt ise paigaldada. Seda ei pea tegema enne, kui vajad tööriista, mida süsteemis pole või mille uuemat versiooni on vaja.

Näiteks:

brew install ripgrep jq tmux gh

Graafilisi rakendusi paigaldatakse Homebrew's sageli --cask võtmega:

brew install --cask docker-desktop

Kui vajad macOS-is Linuxi võrgukäskude sarnaseid nimesid, on üks võimalus:

brew install iproute2mac

See on valikuline lisakiht. Enamasti piisab macOS-is sisseehitatud käskudest ifconfig, lsof ja netstat.

Kontrollkäigud pärast paigaldust

Kontrolli tööriista olemasolu ja versiooni:

command -v python3
python3 --version
python3 -m pip --version
command -v node
node --version
npm --version

Kui käsk on paigaldatud, aga shell seda ei leia, kontrolli:

echo "$PATH"
command -v käsk
type -a käsk

Kui paigaldus ebaõnnestub

Kõigepealt loe veateate viimaseid ridu. Seal on tavaliselt põhjus.

Minitest

1. Ütle, milline süsteemi paketihaldur sobib sinu masinale.
2. Otsi sellega paketti ripgrep või htop.
3. Loe ühe paketi infot ilma seda paigaldamata.
4. Selgita, miks pip install ja apt install ei ole sama tase.
5. Kontrolli, kas python3, pip, node ja npm on sinu masinas olemas.
6. Kui kasutad macOS-i, kontrolli, kas brew on olemas käsuga command -v brew.

Lihtne veaotsing käsureal

Veaotsing ei alga uue käsu proovimisest, vaid olukorra kitsendamisest. Enamiku algaja vigade puhul aitab lühike kontrollrada: mida täpselt käivitati, mida terminal vastas, kus sa oled, kas fail või käsk on olemas ja kas õigused lubavad.

Loogika

Hea käsurea veaotsing liigub kitsamaks:

1. kirjuta üles täpne käsk ja täpne veateade
2. kontrolli asukohta ja failinime
3. kontrolli, kas käsk on leitav
4. kontrolli õigusi ja skripti esimest rida
5. kontrolli, kas probleem on paketis, shellis või teekonnas

Ära alusta juhusliku “paranduskäsu” kopeerimisest. Kui esimene oletus on vale, võib järgmine käsk teha olukorra segasemaks.

Kiire orientiir

Kõige väärtuslikum info on täpne veateade. “Ei tööta” ei ole veel diagnoos; permission denied, command not found või No such file or directory on juba diagnoosi algus.

Tüüpilised algaja vead

• veateadet ei kopeerita täpselt
• eeldatakse, et ollakse õiges kataloogis, aga pwd ütleb midagi muud
• aetakse segi puuduv fail ja puuduv õigus
• kasutatakse sudo-t enne, kui on selge, miks õigused ei luba
• parandatakse PATH-i, kuigi käsu nimi oli lihtsalt valesti kirjutatud
• käivitatakse Bashi skript sh-iga ja saadakse süntaksiviga

Kolme minuti kontrollrada

Kui käsk ei tööta, tee kõigepealt see väike rada.

pwd
ls -lah
command -v rg
type -a rg
echo "$SHELL"

Kui probleem on skriptiga:

ls -l skript.sh
head -n 1 skript.sh
bash skript.sh

Need käsud ei paranda veel midagi. Nad annavad pildi: asukoht, failid, käsu leidmine, shell ja skripti käivitusviis.

Levinud veateated

command not found

See viga tähendab, et shell ei leidnud käivitatavat käsku selle nime järgi.

Kontrolli:

command -v rg
type -a rg
echo "$PATH"

Kui command -v ei näita midagi, on järgmised küsimused:

• kas käsu nimi on õige
• kas tööriist on paigaldatud
• kas paigaldatud tööriista kataloog on PATH-is

Kui nimi on õige ja tööriist puudub, mine peatükki Paketihaldus: apt, dnf, pacman, brew.

No such file or directory

See viga tähendab enamasti, et viitad failile või kataloogile, mida selle tee järgi ei leita.

Kontrolli:

pwd
ls
ls -lah
ls kahtlane-fail

Pööra tähelepanu kolmele asjale:

• suur- ja väiketähed peavad klappima
• tühikutega failinimed vajavad jutumärke
• suhteline tee sõltub praegusest kataloogist

Näiteks:

ls "Minu fail.txt"
ls ./skript.sh
ls ../andmed/sisend.txt

Permission denied

See viga ei tähenda automaatselt, et pead kasutama sudo-t. Kõigepealt vaata, milline õigus puudu on.

ls -l fail
ls -ld kaust

Kui skript ei käivitu, kontrolli õigusi ja proovi seda teadlikult shelliga:

ls -l skript.sh
bash skript.sh

Kui skript peab olema otse käivitatav, siis täitmisõigus lisatakse näiteks nii:

chmod u+x skript.sh
./skript.sh

Kui probleem on süsteemikaustas, peatu korraks. Küsimus ei ole ainult käsus, vaid selles, kas sul peaks üldse olema õigus seda kohta muuta.

Vale shell või vale süntaks

Shellid on sarnased, kuid mitte samad. Bashi skript võib anda vea, kui käivitad selle sh-iga.

Kontrolli aktiivset shelli:

echo "$SHELL"

Kontrolli skripti esimest rida:

head -n 1 skript.sh

Bashi skripti tavaline esimene rida on:

#!/usr/bin/env bash

Kui tahad olla kindel, et skripti käivitab Bash:

bash skript.sh

Kui käsk ise on võõras, kinnita süntaks enne:

grep --help
man grep

Kui probleem tuli pärast paigaldust

Paigaldus võib õnnestuda, aga uus käsk ei ilmu kohe sinu shelli nähtavale.

Kontrolli:

command -v htop
type -a htop
echo "$PATH"

Kui pakett paigaldati Homebrew, pip või mõne projekti tööriistaga, võib vaja olla:

• avada uus terminaliaken
• aktiveerida õige virtuaalkeskkond
• kontrollida, mis nimega käivitatav käsk päriselt paigaldati

Hea veakirjeldus

Kui küsid abi inimeselt või foorumist, pane kaasa vähemalt:

1. mida tahtsid teha
2. täpne käsk
3. täpne veateade
4. pwd väljund
5. süsteem või keskkond, näiteks macOS, Ubuntu, WSL või terminal.cs.ut.ee

Hea veakirjeldus säästab aega ja vähendab juhuslike oletuste hulka.

Minitest

1. Kontrolli, kas sinu masinas leitakse python3.
2. Tee meelega üks vale failinimi ja vaata täpset veateadet.
3. Selgita, mis vahe on vigadel command not found ja No such file or directory.
4. Vaata ühe skripti õigusi käsuga ls -l.
5. Kontrolli ühe skripti esimest rida käsuga head -n 1.
6. Kirjuta näidis-veakirjeldus, kus on käsk, veateade ja pwd väljund.

Võrgu põhitööriistad

Võrgu veaotsingus on tähtis eristada mitut eri küsimust. “Internet ei tööta”, “veebileht ei vasta” ja “minu programm ei kuula porti” võivad välja näha sarnased, aga kontrollitakse neid eri käskudega.

Loogika

Esimene võrgukontroll liigub tavaliselt nii:

1. kas nimi või host vastab üldse
2. kas HTTP/HTTPS teenus vastab
3. millised võrguliidesed ja aadressid sinu masinal on
4. kas kohalik teenus kuulab õiget porti

ping ei kontrolli veebilehte. curl -I ei näita sinu võrguliideseid. ss ja lsof ei ütle, kas DNS-nimi laheneb. Iga tööriist vastab oma kitsale küsimusele.

Kiire orientiir

Kui kasutad macOS-i ja ip a või ss annab command not found, siis see on normaalne. Need on Linuxi tööriistad; macOS-is kasuta alguses ifconfig ja lsof.

Tüüpilised algaja vead

• peetakse ping tulemust veebiteenuse lõplikuks kontrolliks
• unustatakse, et mõni server ei vasta ping-ile, kuigi veeb töötab
• kasutatakse Linuxi käske ip ja ss macOS-is ning arvatakse, et midagi on katki
• vaadatakse kuulavat porti, aga ei eristata 127.0.0.1, 0.0.0.0 ja päris võrguaadressi
• kontrollitakse kauget teenust, kuigi probleem on enda arvutis käivitatud programmis

Esimene kontrollrada

Veebiteenuse puhul alusta HTTP-st:

curl -I https://example.com/

Kui tahad näha, kas host vastab ICMP-le:

ping -c 4 example.com

Kui uurid oma masina võrku, vali süsteemi järgi üks rida:

ip a
ifconfig

Kui uurid, kas kohalik teenus kuulab porti, vali süsteemi järgi üks rida:

ss -ltn
lsof -iTCP -sTCP:LISTEN -n -P

Ära käivita Linuxi ja macOS-i variante läbisegi. Vali see, mis sinu süsteemis olemas on.

ping: hosti esimene signaal

ping saadab ICMP-pakette ja mõõdab, kas host vastab.

ping -c 4 example.com

Tulemuse lugemine:

• vastuseread tähendavad, et host vastas ICMP-le
• paketikadu tähendab, et osa päringuid ei saanud vastust
• vastuse puudumine ei tõesta veel, et veebiteenus on maas

Paljud serverid piiravad või blokeerivad ping vastuseid. Seetõttu on veebiteenuse kontrolliks parem järgmine käsk.

curl -I: veebiteenuse kontroll

curl -I küsib ainult HTTP päised, mitte kogu lehe sisu.

curl -I https://example.com/

Olulised read:

Kui tahad suunamist jälgida, lisa -L:

curl -I -L https://example.com/

Võrguliidesed: ip a ja ifconfig

Liides on võrguühendus sinu arvutis: Wi-Fi, kaabel, VPN, loopback või virtuaalne adapter.

Linuxis:

ip a

macOS-is:

ifconfig

Alguses otsi ainult kahte asja:

• kas mõnel liidesel on IP-aadress
• kas näed loopback-aadressi 127.0.0.1

127.0.0.1 tähendab sinu enda masinat. See on kasulik kohalike teenuste testimisel, aga ei tähenda, et teenus oleks teistele arvutitele nähtav.

Kuulavad pordid

Kui programm peab teenust pakkuma, peab ta tavaliselt kuulama mingit porti. Näiteks:

• 22 SSH
• 80 HTTP
• 443 HTTPS
• 3000, 5173, 8000, 8080 arenduse kohalikud serverid

Linuxis:

ss -ltn

macOS-is:

lsof -iTCP -sTCP:LISTEN -n -P

Teine macOS-i sisseehitatud vaade:

netstat -anv -p tcp | grep LISTEN

Vaata eriti aadressi osa:

Kui brauseris http://localhost:3000 töötab, aga teiselt masinalt ligi ei saa, võib põhjus olla just selles, et teenus kuulab ainult 127.0.0.1 peal või tulemüür ei luba ühendust.

Kas port on kaugelt avatud

Kui tahad kontrollida konkreetset hosti ja porti, sobib sageli nc.

nc -vz example.com 443

See ei tõenda, et rakendus töötab õigesti, aga näitab, kas TCP-ühendus porti õnnestub.

Kui nc pole olemas, kasuta veebiteenuse puhul curl -I-d. HTTP jaoks annab see tavaliselt rohkem infot.

macOS: kas pean midagi paigaldama?

Alguses ei pea. macOS-is on võrgukontrolliks piisavalt sisseehitatud tööriistu:

• ping
• curl
• ifconfig
• lsof
• netstat
• sageli ka nc

Kui tahad hiljem Linuxi ip-stiilis käsku, saab lisada:

brew install iproute2mac

See on mugav lisakiht, mitte õpiku eeldus.

Minitest

1. Tee curl -I päring aadressile https://example.com/.
2. Tee ping -c 4 example.com ja võrdle, kas see vastab samale küsimusele.
3. Vaata oma süsteemis võrguliideseid: Linuxis ip a, macOS-is ifconfig.
4. Vaata, kas sinu masinas kuulab mõni TCP-port.
5. Selgita ühe lausega, mis vahe on aadressidel 127.0.0.1:3000 ja 0.0.0.0:3000.

Failide kopeerimine ja sünkroonimine

Loogika

Neid käske ühendab üks küsimus:

• kas liigutad faile samas masinas
• teise masinasse üle SSH
• või tõmbad midagi veebist

Just selle järgi tasub valida tööriist:

• cp kohalik koopia
• scp kiire kopeerimine üle SSH
• rsync nutikas sünkroniseerimine
• curl ja wget veebist toomine

Kiirülevaade

Eesmärk on valida kopeerimiseks õige tööriist ja enne suuremat sünkroonimist kontrollida, mida tehtaks.

rsync -n on enne suuremat kopeerimist hea turvapidur: ta näitab, mida tehtaks, aga ei muuda veel midagi.

Tüüpilised algaja vead

• valitakse vale tööriist: scp korduva sünkroonimise jaoks või curl seal, kus vaja oleks lihtsalt wget
• unustatakse rsync allika lõpu kaldkriips
• jäetakse --dry-run või -n vahele enne suurt sünkroonimist
• eeldatakse, et kopeeriv käsk peab alati midagi ekraanile kirjutama

Kiirspikker

• cp kopeerib lokaalseid faile
• scp kopeerib üle SSH
• rsync sünkroonib nutikalt
• wget laeb alla URL-ist
• curl teeb HTTP-päringuid ja allalaadimisi

Kõige sagedamini kasutatud lipud:

• cp -R kopeeri kataloog rekursiivselt
• cp -a GNU/Linuxis säilitab metaandmeid nii hästi kui võimalik
• scp -r kopeeri kataloog üle võrgu
• scp -p säilita faili ajad ja õigused nii hästi kui võimalik
• rsync -a säilita struktuur ja metaandmed
• rsync -v näita, mida tehakse
• rsync -n tee dry-run
• curl -O salvesta serveri failinimega
• curl -L järgi ümbersuunamisi

Käivita need käsud

cp fail.txt koopia.txt
cp -R kaust kaust-koopia

scp fail.txt kasutaja@server:/tmp/
rsync -av kaust/ kasutaja@server:/tmp/kaust/

wget https://example.com/fail.txt
curl -O https://example.com/fail.txt

curl -L -O https://example.com/arhiiv.tar.gz
curl -I https://example.com/

Millal mida kasutada

• cp kui allikas ja sihtkoht on samas masinas
• scp kui tahad lihtsalt faili üle SSH saata
• rsync kui sisu muutub ja tahad korduvat sünkroniseerimist
• curl või wget kui allikas on veebis

Praktiliselt:

• üks kiire koopia: cp
• üks kiire ülekanne serverisse: scp
• korduv sünkroonimine või varukoopia: rsync
• URL-ist faili tõmbamine: curl -L -O

cp, scp, rsync omavahel

Need kolm näevad sarnased välja, aga loogika on erinev.

cp:

cp fail.txt koopia.txt
cp -R kaust kaust-koopia

scp:

scp fail.txt kasutaja@server:/tmp/
scp -r kaust kasutaja@server:/tmp/

rsync:

rsync -av kaust/ kasutaja@server:/tmp/kaust/
rsync -avn kaust/ kasutaja@server:/tmp/kaust/

rsync on eriti tähtis just sellepärast, et:

• ta saadab ainult muutused
• ta sobib korduvaks tööks
• -n abil saab enne kontrollida, mida ta teeks

Kataloogipuu loogika

Kui kopeerid tervet kaustapuud, siis tasub alati läbi mõelda neli küsimust:

1. kas allikas ja sihtkoht on samas masinas või üle võrgu
2. kas teed ühekordset koopiat või korduvat sünkroonimist
3. kas tahad säilitada õigused, ajatemplid ja lingid
4. kas tahad pärast kontrollida, et tulemus sai õige

Just siin tuleb vahe eriti selgelt välja:

• cp -R teeb lihtsa kohaliku koopia
• scp -r saadab puu üle SSH, aga ei ole kõige mugavam korduva töö jaoks
• rsync -av sobib kõige paremini korduvaks sünkroonimiseks

Oluline detail rsync juures:

• rsync -av kaust/ siht/ tähendab tavaliselt “kopeeri kausta sisu”
• rsync -av kaust siht/ tähendab sagedamini “kopeeri kaust ise sihtkausta sisse”

See kaldkriipsu detail on väike, aga muudab tulemust palju.

rsync ja lõpu kaldkriips

See on üks kõige olulisemaid rsync-i detaile.

Näide:

mkdir -p ~/tmp/rsync-naide/allikas/alam
mkdir -p ~/tmp/rsync-naide/siht
printf 'tere\n' > ~/tmp/rsync-naide/allikas/alam/fail.txt

Nüüd võrdle kahte käsku:

rsync -avn ~/tmp/rsync-naide/allikas ~/tmp/rsync-naide/siht/
rsync -avn ~/tmp/rsync-naide/allikas/ ~/tmp/rsync-naide/siht/

Loogika:

• ilma lõpu kaldkriipsuta kopeeritakse tavaliselt kaust allikas ise sihtkoha sisse
• lõpu kaldkriipsuga kopeeritakse kausta allikas sisu sihtkohta

Just sellepärast tasub enne päris sünkroonimist teha:

rsync -avn allikas/ siht/

-n ehk --dry-run aitab enne näha, mida käsk teeks.

Metaandmed: õigused, omanikud, ajatemplid

Suure puu puhul ei ole tähtis ainult faili sisu. Sageli on tähtsad ka:

• faili õigused
• omanik ja grupp
• ajatemplid
• sümboolsed lingid

Rusikareeglid:

• cp -R keskendub eelkõige sisule ja struktuurile
• cp -a GNU/Linuxis püüab säilitada metaandmeid võimalikult terviklikult
• scp -p säilitab ajatemplid ja õigused paremini kui paljas scp
• rsync -a on tavaliselt kõige mõistlikum valik, kui metaandmed loevad

Omaniku kohta tasub meeles pidada:

• tavaline kasutaja ei saa üldjuhul taastada suvalise teise kasutaja omandit
• kaugserveris sõltub lõplik omanik sageli sellest, mis kasutajana sa sisse logisid
• seetõttu võib “sisu sama, aga omanik teine” olla täiesti ootuspärane tulemus

curl ja wget

Mõlemad oskavad faile alla laadida, kuid rõhuasetus on veidi erinev:

• wget on klassikaline allalaadija
• curl on üldisem HTTP-klient ja sobib hästi ka API-dega rääkimiseks

Kui tahad veebilehte tekstina lugeda, linke kokku koguda või teha väikest crawl'i, siis vaata edasi peatükki Veebist sisu toomine ja tekstivaade: curl, wget, lynx.

Levinud curl võtmed:

• -O salvesta serveri failinimega
• -o fail salvesta kindla nimega
• -L järgi ümbersuunamisi
• -I küsi ainult päised

Näited:

curl -o naide.html https://example.com/
curl -L -O https://example.com/fail.txt
curl -I https://example.com/

Need käsud on väga kasulikud ka selleks, et kontrollida, kas URL üldse vastab ootuspäraselt.

Kõige tavalisemad päriselu näited

Kopeeri projektikaust varuks:

rsync -av projekt/ projekt-varu/

Saada üks fail serverisse:

scp backup.sql kasutaja@server:/tmp/

Tõmba arhiiv veebist:

curl -L -O https://example.com/arhiiv.tar.gz

Kontrolli enne päris sünkroniseerimist, mida rsync teeks:

rsync -avn projekt/ server:/srv/projekt/

Kui teed suure või tundliku sünkroonimise, siis --dry-run võiks olla peaaegu automaatne esimene samm.

Minitest

1. Kopeeri üks fail uue nime alla.
2. Tee kaustast rekursiivne koopia.
3. Uuri rsync --help abil, mida teeb võti -a.
4. Tee curl -I abil päring mõnele veebiaadressile ja vaata päiseid.

Kauglogimine ja SSH

SSH on turvaline viis logida teise masinasse, käivitada seal käske ja liigutada faile. Sama ühendusloogikat kasutavad sageli ka scp, rsync ja Git.

Loogika

SSH töövoog liigub tavaliselt nii:

1. proovi parooli või olemasoleva võtmega tavalist sisselogimist
2. kontrolli, kas sul on võtmepaar juba olemas
3. loo uus võti ainult siis, kui seda on vaja
4. lisa avalik võti serverisse
5. pane korduv ühendus ~/.ssh/config faili alias'e alla
6. macOS-is lase Keychainil võtme paroolifraasi meeles pidada

Kõige tähtsam piir on lihtne: privaatvõti jääb sinu arvutisse, avalik võti läheb serverisse.

Kiire orientiir

Esmakordsel ühendusel küsib SSH sageli serveri sõrmejälje kinnitamist. See on serveri tuvastus, mitte sinu kasutajavõti. Tundmatu serveri puhul kontrolli sõrmejälge usaldusväärsest allikast.

Tüüpilised algaja vead

• aetakse segi privaatvõti ja avalik võti
• kirjutatakse olemasolev võti kogemata üle
• arvatakse, et Apple Keychain asendab ~/.ssh võtmefailid
• lisatakse serverisse privaatvõti, kuigi lisada tuleb ainult .pub fail
• tehakse keeruline ssh -L või agent forwarding enne, kui tavaline sisselogimine töötab
• unustatakse, et ~/.ssh/config alias'e saavad kasutada ka scp, rsync ja Git

Esimene ühendus

Kõigepealt proovi kõige tavalisemat kuju:

ssh kasutaja@server.example.org

Kui port ei ole tavaline 22, lisa port:

ssh -p 2222 kasutaja@server.example.org

Ühekordse kaugkäsu saab anda nii:

ssh kasutaja@server.example.org 'hostname && uptime'

Kui see veel ei tööta, ära alusta võtmete ümbertegemisest. Enne kontrolli kasutajanime, hostinime, porti ja veateadet.

Kas sul on võtmed juba olemas?

Vaata kõigepealt oma ~/.ssh kataloogi.

ls -la ~/.ssh

Tüüpilised failid:

Kontrolli võtme sõrmejälge:

ssh-keygen -lf ~/.ssh/id_ed25519.pub

Kontrolli, mis võtmed on praegu ssh-agent-is:

ssh-add -l
ssh-add -L

ssh-add -l näitab sõrmejälgi. ssh-add -L näitab agendis olevate võtmete avalikke ridu. Kui agent on tühi, ei tähenda see, et võtmefaile pole olemas; see tähendab ainult, et agent ei hoia neid praegu mälus.

Uue võtme loomine

Ära kirjuta olemasolevat võtit üle. Kui ~/.ssh/id_ed25519 on juba olemas ja kasutusel, kasuta seda või loo eraldi nimega võti.

Tavaline uus võti:

ssh-keygen -t ed25519 -C 'kasutaja@arvuti'

Kui tahad eraldi õpiku või serveri võtit:

ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_opik -C 'opik-server'

Soovitus: pane privaatvõtmele paroolifraas. Siis kaitseb võtmefaili ka see, kui fail satub kogemata valesse kohta.

Õigused peavad olema kitsad:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub

Kui kasutasid teise nimega võtit, asenda käsus failinimi vastavaks.

macOS: Keychain ja ssh-agent

macOS-is on kaks eri asja:

• ssh-agent hoiab võtmeid jooksva kasutusseansi ajal mälus
• Apple Keychain saab hoida privaatvõtme paroolifraasi, et sa ei peaks seda iga kord uuesti sisestama

Keychain ei asenda võtmefaile. Privaatvõti on endiselt näiteks ~/.ssh/id_ed25519; Keychain aitab selle paroolifraasi hallata.

Lisa võti agendile ja salvesta paroolifraas Keychaini:

ssh-add --apple-use-keychain ~/.ssh/id_ed25519

Kui paroolifraas on juba Keychainis ja tahad võtmed agendile laadida:

ssh-add --apple-load-keychain

Kui tahad võtme ainult jooksvast agendist eemaldada:

ssh-add -d ~/.ssh/id_ed25519

Kui tahad eemaldada ka Keychaini salvestatud paroolifraasi, lisa eemaldamisel Apple'i Keychaini valik:

ssh-add --apple-use-keychain -d ~/.ssh/id_ed25519

Vanemates macOS-i juhendites näeb vahel käske ssh-add -K ja ssh-add -A. Tänapäevasem ja selgem kuju on kasutada --apple-use-keychain ja --apple-load-keychain.

Kontrolli pärast:

ssh-add -l

Kui ssh-add ütleb, et agenti ei saa ühendada, ava uus terminaliaken ja proovi uuesti. macOS-is käivitab graafiline kasutajaseanss agendi tavaliselt ise.

~/.ssh/config: alias'ed ja püsiseaded

Kui ühendud sama serveriga korduvalt, tee config-faili alias.

Host opik-server
    HostName server.example.org
    User kasutaja
    Port 2222
    IdentityFile ~/.ssh/id_ed25519
    IdentitiesOnly yes

Pärast seda töötavad lühemad käsud:

ssh opik-server
scp fail.txt opik-server:/tmp/
rsync -av kaust/ opik-server:/tmp/kaust/

IdentitiesOnly yes on kasulik siis, kui agendis on palju võtmeid. See ütleb SSH-le, et selle hosti puhul kasuta eelkõige siin nimetatud võtit.

macOS-i mugav plokk võib olla selline:

Host *
    IgnoreUnknown UseKeychain
    AddKeysToAgent yes
    UseKeychain yes

Host opik-server
    HostName server.example.org
    User kasutaja
    IdentityFile ~/.ssh/id_ed25519
    IdentitiesOnly yes

IgnoreUnknown UseKeychain peab olema enne UseKeychain rida, sest Linuxi OpenSSH ei pruugi Apple'i UseKeychain valikut tunda. Nii saab sama config fail olla talutavam mitmes süsteemis.

Config-faili õigused:

chmod 600 ~/.ssh/config

Avaliku võtme lisamine serverisse

Serverisse lisatakse avalik võti, mitte privaatvõti.

Kui ssh-copy-id on olemas:

ssh-copy-id -i ~/.ssh/id_ed25519.pub kasutaja@server.example.org

Kui ssh-copy-id puudub, kuva avalik võti:

cat ~/.ssh/id_ed25519.pub

macOS-is saad selle lõikelauale panna nii:

pbcopy < ~/.ssh/id_ed25519.pub

Seejärel lisa see avalik rida serveris faili ~/.ssh/authorized_keys. Serveris peavad õigused olema tavaliselt:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

Failide kopeerimine sama alias'ega

Kui ~/.ssh/config alias töötab ssh-iga, töötab see sageli ka kopeerimisel.

scp fail.txt opik-server:/tmp/
rsync -av kaust/ opik-server:/tmp/kaust/

Korduva töö puhul eelista rsync-i ja proovi enne:

rsync -avn kaust/ opik-server:/tmp/kaust/

Veaotsing

Kõige kasulikum esimene diagnostikakäsk on:

ssh -v opik-server

See näitab:

• millist config-kirjet kasutatakse
• millist hosti ja porti proovitakse
• milliseid võtmeid pakutakse
• kas viga on ühenduses, serveri sõrmejäljes või autentimises

Kui väljund on liiga pikk, otsi sealt ridu Offering public key, Authentications that can continue ja Permission denied.

Mis jääb hilisemaks

SSH-l on ka võimsamad töövõtted:

• port forwarding: ssh -L ...
• agent forwarding: ssh -A ...
• hüppemasinad: ProxyJump
• püsivad ühendused: ControlMaster

Need on kasulikud, aga tulevad pärast seda, kui tavaline sisselogimine, võtmed ja ~/.ssh/config alias'ed on selged.

Minitest

1. Vaata, kas sul on ~/.ssh kataloog ja millised võtmefailid seal on.
2. Selgita, kumb on privaatvõti ja kumb avalik võti.
3. Kontrolli, kas ssh-agent hoiab praegu mõnd võtit.
4. Kirjuta näidis Host opik-server plokk ~/.ssh/config jaoks.
5. Selgita, mida teeb macOS-is ssh-add --apple-use-keychain.
6. Kirjuta ühe lausega, miks UseKeychain ei tähenda, et võti oleks serverisse lisatud.

Lisalugemine

Selle teema usaldusväärsemad viited leiad lisast Lisa E: usaldusväärsed viited ja lisalugemine.

Veebist sisu toomine ja tekstivaade: curl, wget, lynx

Loogika

Veebist sisu toomisel tasub kõigepealt eristada kolme eri ülesannet:

1. too üks vastus või fail
2. laadi alla terve lehtede puu või jätka katkestatud tõmmet
3. vaata HTML-i loetava tekstina või kogu sealt lingid kokku

Just selle järgi tasub tööriist valida:

• curl ühe päringu, päiste, API või toor-HTML jaoks
• wget allalaadimise, jätkamise ja crawl'i jaoks
• lynx HTML-i tekstivaate ja linkide loendi jaoks

Sõna “scrape” tähendab siin lihtsalt seda, et võtad veebist sisu ja töötled seda edasi käsureal. Kui ametlik API või andmefail on olemas, siis eelista seda peaaegu alati HTML-i kraapimisele.

Enne kui kraabid

Enne automaatset allalaadimist tasub alati kontrollida mõnda lihtsat asja:

• kas saidil on olemas API või andmeeksport
• kas robots.txt või kasutustingimused lubavad seda tööd
• kas saad alustada väikese prooviga, mitte kohe terve domeeniga
• kas lisad päringute vahele pausi, kui teed korduvaid tõmbeid
• kas suudad hiljem tõestada, kust andmed tulid ja millal sa need tõid

Hea reegel on: alusta ühe URL-iga, kontrolli tulemust ja alles siis mõtle suurema crawl'i peale.

Kiirülevaade

Eesmärk on veebist sisu tuua kontrollitult: alusta väikesest proovist ja vaata enne, mida server vastab.

Päiste vaatamine aitab enne suuremat tõmmet aru saada, kas aadress töötab ja kas server suunab sind mujale.

Tüüpilised algaja vead

• minnakse kohe suure crawl'i peale, enne kui üks URL on kontrollitud
• aetakse segi “too üks vastus” ja “laadi fail alla”
• unustatakse, et mõistlik on eelistada API-t või andmefaili HTML-i kraapimisele

Kiirspikker

• curl -I URL küsib ainult päised
• curl -L -o fail.html URL salvestab vastuse faili ja järgib ümbersuunamisi
• curl -sL URL | lynx -stdin -dump muudab veebilehe tekstiks
• wget URL laeb URL-i vaikimisi faili
• wget -c URL jätkab katkestatud allalaadimist
• wget --recursive --level=1 --no-parent URL teeb väikese piiratud crawl'i
• lynx URL avab tekstilise veebivaate interaktiivselt
• lynx -dump URL trükib lehe teksti koos viidetega välja
• lynx -dump -listonly URL trükib välja ainult linkide nimekirja

Kui tööriist puudub

curl on sageli juba olemas, kuid wget ja lynx ei pruugi igas süsteemis vaikimisi paigaldatud olla.

Vali ainult oma süsteemile sobiv paigalduskäsk:

Debianis või Ubuntus:

sudo apt install wget lynx

Fedoras:

sudo dnf install wget lynx

macOS-is Homebrew kaudu:

brew install wget lynx

Käivita need käsud

See plokk näitab ühe väikese ohutu töövoo:

• vaata, kas URL üldse vastab
• salvesta leht faili
• muuda HTML tekstiks
• kogu linkide nimekiri eraldi välja

mkdir -p veeb-naide
cd veeb-naide
curl -I https://example.com/
curl -L -o naide-curl.html https://example.com/
wget -O naide-wget.html https://example.com/
lynx -dump naide-curl.html | sed -n '1,20p'
lynx -dump -listonly https://example.com/
ls -lh

Kui tahad veebist tulnud HTML-i kohe torusse panna, siis tee nii:

curl -sL https://example.com/ | lynx -stdin -dump | sed -n '1,20p'

curl: üks vastus korraga

curl on hea siis, kui tahad täpselt kontrollida, mis päring tehakse ja mida vastuseks saadakse.

Olulised lipud alguses:

• -I ainult päised
• -L järgi ümbersuunamisi
• -o fail salvesta kindla nimega
• -O salvesta serveri pakutud nimega
• -s vaikne reziim
• -S näita viga ka siis, kui kasutad -s

Näited:

curl -I https://example.com/
curl -L -o esileht.html https://example.com/
curl -sL https://example.com/ | grep -i '<title'
curl -sL https://example.com/ | lynx -stdin -dump

Praktiline mõte on siin lihtne:

• curl kirjutab vaikimisi väljundi ekraanile
• seetõttu sobib ta hästi torude ja filtritega
• curl ise ei tee “veebipuud”, vaid ühe või mõne konkreetse päringu

wget: allalaadija ja crawler

wget on mugav siis, kui tahad, et fail päriselt kettale jääks, või kui tahad teha piiratud rekursiivset allalaadimist.

Olulised lipud alguses:

• -O fail salvesta kindla nimega
• -c jätka katkestatud tõmmet
• -P kaust salvesta kindlasse kausta
• --recursive rekursiivne allalaadimine
• --level=1 või -l 1 piira sügavust
• --no-parent ära mine ülemkataloogidesse
• --page-requisites tõmba lehe toimimiseks vajalikud failid
• --convert-links muuda lingid lokaalses koopias sobivaks
• --adjust-extension pane HTML-failidele sobiv laiend
• --wait=1 ja --random-wait tee viisakam crawl

Näited:

wget https://example.com/
wget -O esileht.html https://example.com/
wget -c -O esileht-koopia.html https://example.com/

Väike piiratud crawl:

wget --recursive --level=1 --no-parent https://example.com/

Kui tahad teha lokaalse koopiana väikest dokumentatsioonipuud, siis mall on näiteks selline:

wget \
  --mirror \
  --convert-links \
  --adjust-extension \
  --page-requisites \
  --no-parent \
  --wait=1 \
  --random-wait \
  https://docs.example.org/juhend/

Seda viimast käsku ei tasu kunagi pimesi suvalise suure saidi juurel käivitada. Kõigepealt kontrolli alati:

• kui suur ala sul tegelikult vaja on
• kas --no-parent ja õige alg-URL piiravad töö piisavalt kitsaks
• kas serverile on mõistlik teha nii palju päringuid

lynx: HTML tekstiks ja lingid välja

lynx on kasulik siis, kui veebileht on vaja teha kiiresti loetavaks tekstiks.

See on hea tööriist näiteks siis, kui:

• tahad lehte lugeda terminalist
• tahad HTML-ist saada lihtsa tekstivaate
• tahad linkide nimekirja eraldi kätte
• tahad torust tuleva HTML-i kiiresti puhastada enne grep-i või sed-i

Kõige tavalisemad töökujud:

lynx https://example.com/
lynx -dump https://example.com/
lynx -dump -listonly https://example.com/

Kui sul on HTML juba failis, siis saad sama teha lokaalselt:

lynx -dump naide-curl.html
lynx -dump -listonly naide-curl.html

Vahe on lihtne:

• lynx URL on interaktiivne tekstibrauser
• lynx -dump URL prindib loetava tekstivaate ekraanile
• lynx -dump -listonly URL prindib ainult lingid

Väike scrape-töövoog

Kui eesmärk ei ole “terve sait alla”, vaid “too üks leht ja töötle seda”, siis üks praktiline töövoog on:

curl -L -o leht.html https://example.com/
lynx -dump leht.html > leht.txt
grep -n 'Example' leht.txt
lynx -dump -listonly leht.html > lingid.txt
wc -l lingid.txt

See töövoog on hea, sest iga samm on kontrollitav:

1. tõmbad algse HTML-i faili
2. teed sellest inimesele loetava tekstiversiooni
3. otsid tekstist mustrit
4. võtad lingid eraldi nimekirjana välja

See seob hästi kokku ka peatükid grep, sed, sort ja awk.

Mida tasub meeles pidada

• curl sobib paremini üksikute päringute ja torude jaoks
• wget sobib paremini allalaadimise ja crawl'i jaoks
• lynx ei ole “crawler”, vaid tekstivaate ja linkide tööriist
• HTML-i scrape on habras, sest lehe struktuur võib muutuda
• JavaScriptiga ehitatud sait ei pruugi anda curl-ile või wget-ile sama pilti, mida näeb brauser

Kui näed, et info tuleb lehele alles JavaScripti abil, siis puhas curl või wget ei pruugi sulle tegelikku sisu anda. Siis tasub otsida:

• ametlikku API-t
• JSON-vastust brauseri võrgupaneelist
• eksportfaili nagu CSV või JSON

Minitest

1. Tee curl -I päring aadressile https://example.com/.
2. Salvesta sama leht korraga nii curl-i kui wget-iga.
3. Muuda üks HTML-fail lynx -dump abil tekstiks.
4. Trüki lynx -dump -listonly abil välja ainult lingid.
5. Seleta ühe lausega, millal kasutaksid curl, millal wget ja millal lynx.

Arhiivid ja pakkimine

Loogika

Arhiveerimine koondab failid, pakkimine teeb need väiksemaks. See on seotud failide liigutamise, allalaadimise ja varukoopiatega.

Kiirülevaade

Erista kaht sammu: failide koondamine üheks arhiiviks ja selle arhiivi tihendamine väiksemaks.

Tüüpilised algaja vead

• arvatakse, et .tar tähendab juba tihendatud faili
• pakitakse arhiiv lahti vales kataloogis
• ei vaadata enne lahtipakkimist, mis arhiivi sees on

Kiirspikker

• tar -cf fail.tar kaust/ loo arhiiv
• tar -xf fail.tar paki lahti
• tar -tf fail.tar vaata arhiivi sisu
• tar -czf fail.tar.gz kaust/ loo gzip-pakitud arhiiv
• tar -czf fail.tgz kaust/ sama loogika lühema laiendiga
• tar -xzf fail.tar.gz paki gzip-arhiiv lahti
• tar -cJf fail.tar.xz kaust/ loo xz-pakitud arhiiv
• zip -r fail.zip kaust/ loo zip-arhiiv
• unzip fail.zip paki zip lahti

Tähtsamad võtmed

• c create ehk loo arhiiv
• x extract ehk paki lahti
• t table ehk näita sisu
• f file ehk järgmine argument on arhiivifaili nimi
• z kasuta gzip pakkimist
• J kasuta xz pakkimist
• v verbose ehk näita töö käigus rohkem infot

tar põhimõte

tar ise on ajalooliselt arhiveerija. Pakkimine lisatakse sageli eraldi:

• tar ainult koondab failid
• gzip teeb faili väiksemaks
• xz pakib tihedamalt, aga võib olla aeglasem

Sellepärast on need kujundid sisuliselt järgmised:

• tar -cf loo arhiiv ilma pakkimata
• tar -czf loo gzip-ga pakitud arhiiv
• tar -xzf paki gzip-ga pakitud arhiiv lahti
• tar -cJf loo xz-ga pakitud arhiiv

.tar.gz ja .tgz tähendavad tavaliselt sama asja. .tgz on lihtsalt lühem failinimi.

Käivita need käsud

mkdir -p ~/tmp/arh/kaust
printf 'tere\n' > ~/tmp/arh/kaust/tere.txt
tar -cf ~/tmp/arh/proov.tar -C ~/tmp/arh kaust
tar -tf ~/tmp/arh/proov.tar

tar -czf ~/tmp/arh/proov.tar.gz -C ~/tmp/arh kaust
tar -xzf ~/tmp/arh/proov.tar.gz -C ~/tmp/arh

zip -r ~/tmp/arh/proov.zip ~/tmp/arh/kaust
unzip ~/tmp/arh/proov.zip -d ~/tmp/arh/unzipped

Millal mida kasutada

• tar.gz on väga levinud Linuxi maailmas
• tar.xz sobib siis, kui tihendusaste on tähtis
• zip on mugav, kui faile jagatakse erinevate süsteemide vahel

Metaandmed ja puustruktuur

Arhiiviformaadi valikul ei loe ainult tihendusaste. Loeb ka see, mida arhiiv peab kaasa võtma.

• tar sobib hästi Unix-laadse puustruktuuri jaoks
• tar säilitab failipuud, õigused, ajatemplid ja lingid paremini kui zip
• zip on sageli mugavam jagamiseks eri süsteemide vahel
• zip ei ole tavaliselt parim valik siis, kui Unix-i õigused ja omanikud on olulised

Praktiline mõtteviis:

• Linuxi või serveri varukoopia: eelista sageli tar.gz või tar.xz
• laiemaks jagamiseks: zip

Kasulikud võtted

• tar -tf fail.tar.gz näitab sisu ilma lahti pakkimata
• tar -tzf fail.tar.gz | less laseb suure arhiivi sisu sirvida
• tar -xzf fail.tar.gz -C sihtkaust pakib lahti kindlasse kohta
• tar -czf backup-$(date +%F).tar.gz kaust/ teeb kuupäevaga varukoopia
• unzip -l fail.zip näitab zip-arhiivi sisu ilma lahti pakkimata

Kui arhiiv on suurem, lehitse sisuloendit:

tar -tzf fail.tar.gz | less

See aitab enne lahtipakkimist näha:

• mis kaustad seal sees üldse on
• kas arhiivis on ootuspärane juurkaust
• kas failinimed paistavad mõistlikud

Minitest

1. Loo väike testkaust kahe failiga.
2. Tee sellest tar.gz arhiiv.
3. Vaata arhiivi sisu ilma seda lahti pakkimata.
4. Paki arhiiv lahti teise kausta.

Tervete kataloogipuude haldus ja jagamine

See peatükk koondab üheks töövooks käsud cp, rsync, scp, tar, zip ja Git-i loogika. Mõte ei ole korrata kõiki üksikkäske, vaid anda tervikpilt: mida teha siis, kui sul on vaja hallata või jagada tervet projektipuud.

Loogika

Kui liigud üksikfailidest edasi tervete kaustapuudeni, siis küsimus ei ole enam ainult “kuidas kopeerida üks fail”, vaid:

1. kas tahan teha kohaliku koopia
2. kas tahan saata puu teise masinasse
3. kas tahan teha ühest hetkest arhiivi
4. kas tahan jagada seda nii, et hiljem saaks muudatusi jälgida
5. kuidas kontrollida, et tulemus sai õige

Just siin lähevad tööriistad oma tugevuste järgi lahku.

Kiirülevaade

Eesmärk on valida tööriist terve projektipuu jaoks: koopia, sünkroon, arhiiv või muudatusajalugu.

Tüüpilised algaja vead

• kasutatakse sama töö jaoks juhuslikult eri tööriistu, mõtlemata eesmärgile
• arvatakse, et scp -r ja rsync on alati sisuliselt sama
• ei kontrollita, kas koopia sisaldab ka peidetud faile või õigeid metaandmeid

Millal millist tööriista kasutada

• cp -R sobib, kui tahad samas masinas teha lihtsa koopia
• rsync -av sobib, kui tahad korduvat sünkroonimist või varundust
• scp -r sobib, kui tahad kiiresti terve puu SSH kaudu teise masinasse saata
• tar -czf või tar -cJf sobib, kui tahad ühest hetkest ühte arhiivifaili
• zip -r sobib, kui jagad sisu inimestega, kes töötavad eri süsteemides
• Git sobib, kui tahad mitte ainult jagada tulemust, vaid ka jälgida muudatusi ajas

Kohalik koopia: cp

Kui vajad ühekordset koopiat samas masinas, siis alusta lihtsast käsust:

cp -R projekt projekt-koopia

See on hea valik siis, kui:

• tahad kiiresti proovida midagi teises koopias
• tahad teha enne suuremat muutust kohaliku varu
• allikas ja sihtkoht on samal masinal

Kui metaandmed loevad, siis GNU/Linuxis kasutatakse sageli:

cp -a projekt projekt-koopia

Seda tasub võtta kui “säilita nii palju kui võimalik”. Eri süsteemid ei käitu siin alati täpselt ühtemoodi.

Korduv sünkroonimine: rsync

Kui sama puud liigutatakse korduvalt, siis rsync on tavaliselt parem kui cp või scp.

rsync -av projekt/ projekt-varu/

Selle käsu tugevused:

• saadab uuesti peamiselt muutunud sisu
• säilitab struktuuri ja metaandmeid paremini
• sobib nii lokaalseks kui kaugsünkroonimiseks

Oluline kaldkriipsu loogika:

• projekt/ tähendab enamasti “selle kausta sisu”
• projekt tähendab sagedamini “see kaust tervikuna”

Enne suuremat kopeerimist on väga mõistlik teha dry-run:

rsync -avn projekt/ projekt-varu/

Kui siht on serveris:

rsync -av projekt/ kasutaja@server:/srv/projekt/

Kiire ülekanne teise masinasse: scp

scp on hea siis, kui tahad lihtsalt midagi kiiresti teise masinasse saata:

scp -r projekt kasutaja@server:/tmp/

See on praktiline, kui:

• vajad ühekordset üleslaadimist
• sul ei ole vaja keerukamat sünkroonimisloogikat
• SSH on juba seadistatud

Kui tahad võimalikult palju säilitada ajatemplite ja õiguste kohta, kasuta sageli:

scp -rp projekt kasutaja@server:/tmp/

Üks fail kogu puust: tar, tgz, zip

Kui tahad tervest puust teha ühe jagatava faili, siis sobib arhiiv:

tar -czf projekt-2026-04-13.tgz projekt/
tar -tf projekt-2026-04-13.tgz

See on hea valik siis, kui:

• tahad saata ühe faili
• tahad võtta kindla hetke snapshot'i
• tahad arhiivi enne lahti pakkimata kontrollida

Kui adressaadil on tõenäoliselt Linux või macOS, on tar.gz või .tgz sageli loomulik valik.

Kui adressaadid on väga eri keskkondades, on zip mugav:

zip -r projekt.zip projekt/
unzip -l projekt.zip

Mis saab õigustest ja omanikest

Suure puu halduses on oluline eristada nelja asja:

• faili sisu
• failipuu struktuur
• õigused
• omanikud ja grupid

Rusikareeglid:

• cp -R ja scp -r lahendavad eelkõige sisu ja struktuuri
• rsync -a ja tar hoiavad Unix-laadset metaandmete pilti paremini koos
• zip sobib rohkem jagamiseks kui täpseks Unix-i säilitamiseks
• Git ei talleta tavaliselt omanikku, gruppi ega ajatemplite ajalugu

Git talletab hästi:

• faili sisu
• kataloogistruktuuri
• tekstimuudatuste ajaloo
• täidetavusbitte olulisemates juhtudes

Git ei ole varukoopia-arhiiv igas mõttes. See ei asenda tar-i ega rsync-i, kui tähtis on kogu failisüsteemi metaandmete võimalikult täpne ülekandmine.

Jagamine: arhiiv või GitHub

Kui eesmärk on lihtsalt “saada see tervik teisele inimesele”, siis mõtle nii:

• üks ühekordne hetkeseis: tar.gz või zip
• korduv uuendamine serverisse: rsync
• ühine arendus ja muudatuste ajalugu: Git + GitHub

Seega:

• andmepuu või snapshot: arhiiv
• deploy või varu: rsync
• koostöö ja versioonihaldus: Git

Kuidas kontrollida, et said õige asja

Suure puu juures on kontroll sama tähtis kui kopeerimine ise.

Kõige praktilisemad kontrollid:

• vaata failide arvu ja suurust
• loe arhiivi sisu ilma lahti pakkimata
• tee rsync-iga dry-run
• võrdle vähemalt mõne võtmefaili räsi

Näited:

du -sh projekt projekt-koopia
find projekt | wc -l
find projekt-koopia | wc -l

tar -tf projekt-2026-04-13.tgz | head
unzip -l projekt.zip

shasum -a 256 projekt/README.md projekt-koopia/README.md

Linuxis on sama loogika sageli kujul:

sha256sum projekt/README.md projekt-koopia/README.md

Soovitatud töövood

1. Enne riskantset muutust

rsync -av projekt/ projekt-varu/

2. Saada tervik serverisse

rsync -avn projekt/ kasutaja@server:/srv/projekt/
rsync -av projekt/ kasutaja@server:/srv/projekt/

3. Tee jagatav snapshot

tar -czf projekt-$(date +%F).tgz projekt/
tar -tf projekt-$(date +%F).tgz | head

4. Jaga koostööks

git status
git add .
git commit -m 'Valmista projekt jagamiseks'
git push

Viimase töövoo detailid tulevad eraldi Git-i peatükis.

Minitest

1. Tee ühest testkaustast kohalik koopia käsuga cp -R.
2. Tee samast kaustast rsync -avn dry-run teise kausta.
3. Paki sama kaust .tgz faili ja kuva selle sisu käsuga tar -tf.
4. Mõtle ühe näite põhjal, kas sinu eesmärk on snapshot, sünkroonimine või koostöö ajalooga.

Protsessid, tööd ja signaalid

Loogika

Siin on oluline eristada kolme asja:

1. protsess
2. shelli töö
3. signaal

Need on seotud, aga mitte samad:

• protsess on käivitatud programm
• töö on shelli vaates hallatav käsk või käsujada
• signaal on viis protsessile juhtsõnum saata

Kiirülevaade

Eesmärk on saada kontroll olukorra üle, kus midagi jookseb kaua, kasutab palju ressursse või peab liikuma taustale.

PID on süsteemi protsessinumber; %1 ja %2 on ainult selle shelli töö numbrid.

Tüüpilised algaja vead

• kasutatakse kohe kill -9, kuigi tavalisest kill-ist piisaks
• aetakse segi PID ja jobs-i töö number
• unustatakse, et taustatöö ei pruugi akna sulgemisel alles jääda
• vaadatakse ainult protsesside nimekirja, ilma et küsitaks, kas töö kuulub üldse samale shellile

Kiirspikker

• ps näitab protsesse
• ps aux või ps -ef näitab rohkem infot
• top või htop näitab protsesse reaalajas
• kill PID saadab protsessile signaali
• kill -9 PID lõpetab protsessi jõuga
• käsk & käivitab töö taustal
• jobs näitab shelli taustatöid
• bg jätkab tööd taustal
• fg toob töö esiplaanile
• wait ootab taustatööd ära
• Ctrl-c katkestab programmi töö
• Ctrl-z peatab programmi ajutiselt

Kõige tavalisemad tegevused päriselus on:

• vaata, mis jookseb
• peata või lõpeta kinni jäänud käsk
• saada pikk töö taustale

Protsesside vaatamine

ps
ps aux
ps -ef

top
htop

top ja htop näitavad:

• protsessi ID-d
• kasutatavat mälu
• protsessori koormust
• käimasolevaid käske

Kõige kasulikumad variandid alguses on tavaliselt:

ps aux | grep python
top
htop

ehk kas otsid konkreetset protsessi või vaatad tervikut reaalajas.

Kui tahad väga kiiresti näha suurimaid protsessiressursside kasutajaid, siis need on head 1-linerid:

ps aux | sort -nrk 3 | head
ps aux | sort -nrk 4 | head

Siin:

• veerg 3 on tavaliselt CPU kasutus
• veerg 4 on tavaliselt mälu kasutus

Need käsud vastavad kahele tavalisele küsimusele:

• mis praegu protsessorit sööb
• mis võtab kõige rohkem mälu

Protsessi lõpetamine

Igal protsessil on tavaliselt PID ehk protsessi number.

kill 12345
kill -15 12345
kill -9 12345

Tavapraktika:

• proovi esmalt tavalist kill või kill -15
• kasuta kill -9 ainult siis, kui protsess ei allu viisakamale lõpetamisele

See loogika on oluline, sest:

• SIGTERM annab programmile võimaluse ise viisakalt lõpetada
• SIGKILL katkestab ta jõuga

Seepärast ei tasu kill -9 teha automaatselt esimeseks valikuks.

Tööd shellis: jobs, fg, bg

Shell oskab hallata käske ka töödena.

Näide:

sleep 300

vajuta seejärel Ctrl-z, et töö peatada, ja siis:

jobs
bg
jobs
fg

Tähendus:

• Ctrl-z peatab töö ajutiselt
• jobs näitab shelli teadaolevaid töid
• bg jätkab peatatud tööd taustal
• fg toob töö tagasi esiplaanile

Taustal saab töö käivitada ka kohe:

sleep 300 &
jobs

Kõige tavalisem lühike töövoog on:

1. käivita käsk
2. saad aru, et see võtab kaua aega
3. vajuta Ctrl-z
4. tee bg
5. vaata jobs

See on põhjus, miks jobs, bg ja fg on seotud terminali ja shelli peatükkidega.

Järjest või korraga

Protsesside ja tööde juures tekib väga sageli küsimus: kas käsud käivad üksteise järel või samal ajal?

Kõige lihtsam rusikareegel on:

• käsk1 ; käsk2 tähendab: tee järjest
• käsk & tähendab: saada käsk taustale ja jätka kohe järgmisega

Järjestikune näide:

date '+%H:%M:%S'
sleep 3
echo 'kolm sekundit hiljem'
sleep 1
echo 'veel üks sekund hiljem'

Siin teine sleep ei alga enne, kui esimene on lõpetanud.

Taustaga näide:

sh -c 'sleep 3; echo "pikk töö valmis"' &
sh -c 'sleep 1; echo "lühike töö valmis"' &
jobs
wait

Siin käivad kaks tööd korraga. Kuigi "pikk töö" käivitati enne, võib "lyhike töö" lõpetada varem.

See ongi üks tähtis erinevus:

• järjestikuses jadas määrab järjekorra shell
• taustatööde puhul võivad lõpetamisajad olla teistsugused kui käivitamisjärjekord

Signaalid lühidalt

Signaal on lühike juhtsõnum protsessile.

Levinud näited:

• SIGTERM palub protsessil viisakalt lõpetada
• SIGKILL lõpetab protsessi jõuga
• SIGINT tekib sageli Ctrl-c vajutamisel
• SIGTSTP tekib sageli Ctrl-z vajutamisel

Kõige tavalisemad näited

Leia mõni protsess:

ps aux | grep ssh

Katkesta esiplaanil töötav käsk:

• vajuta Ctrl-c

Peata ja saada töö taustale:

sleep 300

siis Ctrl-z, edasi:

bg
jobs

Päris näide: taustale saadetud pikk töö

Kui tahad õppida jobs, bg ja fg loogikat, siis sleep on endiselt üks parimaid harjutusi.

sleep 300

Seejärel:

• vajuta Ctrl-z
• käivita jobs
• käivita bg
• käivita uuesti jobs

Siin näed väga selgelt:

• kuidas esiplaanil olev käsk peatatakse
• kuidas shell muudab selle tööks
• kuidas sama töö jätkub taustal

Ja lõpetuseks:

fg

või teises variandis:

kill %1

See on hea "päris shelli" näide, sest siin ei pea PID-i kohe käsitsi teadma.

Päris näide: kaks peatatud tööd ja %1, %2

Kui tahad aru saada, mida tähendavad fg %1 ja bg %2, siis tee teadlikult kaks peatatud tööd.

Kõigepealt:

sleep 120

vajuta Ctrl-z.

Siis:

sleep 240

vajuta jälle Ctrl-z.

Nüüd:

jobs
bg %1
jobs
fg %2

Loogika on:

• %1 tähendab töö number 1 shelli jobs nimekirjas
• %2 tähendab töö number 2
• bg %1 jätkab esimese töö taustal
• fg %2 toob teise töö ette

Kui tood töö 2 ette ja peatad selle uuesti Ctrl-z abil, siis võid sama loogikat jätkata ka nii:

bg %2
jobs

See on hea viis harjutada, et töö numbrid tulevad jobs väljundist, mitte "kõhutunde järgi".

See ei ole sama asi mis PID:

• %1 on shelli töö number
• 12345 tüüpi number on protsessi PID

Kui tahad taustal jooksva töö lõpetada shelli töö numbri järgi, siis võid teha ka:

kill %1

See on tihti mugavam kui hakata PID-i käsitsi otsima.

Päris näide: hiljem käivitatud töö võib enne lõpetada

See on väga hea harjutus mõistmaks, mida tähendab "korraga":

sh -c 'sleep 5; echo "viie sekundi töö lõpetas"' &
sh -c 'sleep 2; echo "kahe sekundi töö lõpetas"' &
jobs
wait

Siin käivitati viie sekundi töö enne, aga kahe sekundi töö lõpetab varem.

See aitab hästi eristada:

• käivitamisjärjekorda
• tegelikku lõpetamisjärjekorda

Just taustatööde juures ei ole need alati samad.

Mis juhtub, kui terminali aken läheb kinni

Siin tuleb veel üks oluline vahe:

• jobs, bg, fg töötavad sinu praeguse shelli sees
• kui see shell lõpeb, võivad ka tema taustatööd lõppeda

See tähendab, et pelgalt & ei ole sama asi mis "töö jääb kindlasti elama".

Kui tead, et terminal võib sulguda, on tavaliselt kolm praktilist varianti:

• kasuta tmux-i või screen-i
• kasuta nohup
• mõnes shellis kasuta disown

Kui töö on oluline ja pikk, siis tmux on enamasti kõige mõistlikum valik.

nohup ja disown

nohup tähendab umbes "ära katkesta seda tööd lihtsalt sellepärast, et sessioon lõpeb".

Näide:

nohup sh -c 'sleep 10; echo "valmis"' > nohup-naide.log 2>&1 &
jobs

Siin:

• nohup aitab tööl jääda ellu ka siis, kui sessioon kaob
• väljund suunatakse faili, sest terminali ei pruugi enam olemas olla

disown on teistsugune tööriist:

• käivitad töö kõigepealt tavaliselt
• siis eemaldad selle shelli tööde nimekirjast

Näiteks:

sleep 120 &
jobs
disown %1
jobs

Pärast disown-i ei halda shell seda tööd enam samamoodi töö numbriga %1.

Hea rusikareegel:

• kui vajad püsivat sessiooni, eelista tmux-i
• kui vajad lihtsalt "ära tapa seda tööd terminali sulgemisel", siis nohup võib aidata
• disown on kasulik pigem teadlikule shellikasutajale, mitte esimese valikuna algajale

Päris näide: käivita väike server taustal

Veel praktilisem näide on käivitada väike kohalik teenus:

python3 -m http.server 8000 &
jobs
ps aux | grep '[h]ttp.server'

Selle töövoo loogika:

• & saadab käsu kohe taustale
• jobs näitab shelli teadaolevat tööd
• ps aux | grep '[h]ttp.server' näitab päris protsessi süsteemi vaates