diff --git a/app/docs/guides/training/_category_.json b/app/docs/guides/training/_category_.json new file mode 100644 index 0000000000000000000000000000000000000000..6628dd9267b4fe1a35b227b5daf25b3dfdbf537b --- /dev/null +++ b/app/docs/guides/training/_category_.json @@ -0,0 +1,5 @@ +{ + "label": "Képzésanyagok", + "position": 20 +} + \ No newline at end of file diff --git a/app/docs/guides/training/git/ scripts/elso.md b/app/docs/guides/training/git/ scripts/elso.md new file mode 100644 index 0000000000000000000000000000000000000000..9a3aae6be7351cb2b905de2fd7b7462b6335eca4 --- /dev/null +++ b/app/docs/guides/training/git/ scripts/elso.md @@ -0,0 +1,96 @@ +Sziasztok, `<insert name here>` vagyok! + +Üdvözlök mindenkit. A videóban a gitről szeretnék mesélni nektek, és a végére remélem sikerül olyan szintű tudást átadnom, hogy a jövőben ne *nagyon* okozzon problémát a verziókezelés. +Olyan kérdésekre fogok választ adni, mint *"Miért kell git-et használnom?"*, *"Miért ilyen bonyolult ez az egész?"* és *"Mégis mi a francot nyerek ezzel?"* +Amire szükséged lesz: egy konzol, működő git-el (erre majd később visszatérek). + + + +A parancsokat nem kötelező nektek is kiadni, de egész hasznos lesz, ha már csináltatok ilyet a gyakorlatra. + + +## Mi is az a verziókezelés? + +(ide beszúrhatod a saját szövegedet, ha szeretnéd) + +Biztos mindannyiótoknak van egy olyan élménye, hogy írt egy dokumentumot. Ezt elmentette, majd egy hét múlva újra írt bele, és szerette volna, hogy a korábbi munkája megmaradjon, vagy csak rögzíteni a különböző állapotokat. + +Ezekből szoktak megszületni az itt látható mappák, fájlok. + +(ide majd be fogok vágni egy képet, amin látszik a első.docx, első_v2.docx, etc...) + +Természetesen ez lehetne egy használható megoldás, de mi van, ha szeretnénk valakivel ezt megosztani? Mi van ha a módosítás dátuma megváltozik közben? Hogyan biztosítjuk, hogy nem sérülnek a fájlok, és nem veszik el egy változata a munkánknak, amire lehet egy-két hét/hónap múlva mégiscsak vissza kell térjünk? + +Erre adnak megoldást a különböző verziókezelő rendszerek. Ezeknek többek között dolguk, hogy számon tartsák a fájljainkat, ahogyan mi ezt kézzel megtettük. + +### Helyi + +Erre a fenti példa a legjobb példa. +Vannak különböző verziói a fájlunknak és ezeket valamilyen +adatbázisban rögzítjük. + +(ide kép jön majd) + +### Központosított + +Ez már egy fokkal okosabb. +A különböző verziókat a központi szerverre rakjuk fel és +onnan szedjük le. +Például van egy Fájlszerverünk amit minden gépről elérnek +az emberek és oda dolgoznak közösen... +Érezhető probléma, hogy így ha meghal a központi szerver, +akkor mindent elvesztünk (eskü nem volt még ilyen 😅). +Továbbá probléma lehet, hogy egymás munkáját felülírjük, +szerencsére egy jó rendszernél erről értesítést kapunk, +hozzá és nem felülírjuk a módosításaink. + +(ide kép jön majd) + +### Megosztott + +Na és itt lépünk be a ma is használt Git világába. +Ennél a megoldásnál már az a trükk, hogy mindenkinek megvan +a teljes projekt az összes verziójával. Felmerül, hogy na +de akkor honnan szedjük le a legújabb verziót? +Különböző megoldások léteznek, például a fejlesztők a +módosításokat azonnal megosztják egymással +(pl.: p2p Torrenthez hasonló módon) vagy +kijelölnek egy központi szervert amivel mindenki +szinkronban van. +Ilyen központi szerver lehet például a [Github](https://github.com/) vagy a [Gitlab](https://gitlab.com/). +Csak megjegyzem, akár a módosításokat emailben is el lehet +küldeni és a szoftver automatikusan megcsinálja a többit a mi részünkön. + + +## Git története + +Még mielőtt belemerülnék a git telepítésébe, használatába, +szeretnék némi sztorizást is megejteni. + +Annó a Linux kernel fejlesztése során okozott nagy fejtörést +az egész verziókezelés megoldása. +1991-től 2002-ig, tehát 11 éven át patchekben +(pl.: e-mailben elküldött szöveg a módosításokkal) +és tömörített fájlokban küldözgették a verziókat a fejlesztők. +Aztán 2002-től egy zárt licenszű verzió kezelőre, a +[BitKeeper](http://www.bitkeeper.org/)-re váltottak. + +Ezt a Linux fejlesztői ingyen használhatták egészen 2005-ig, +mikorra annyira elromlott a kapcsolat a fejlesztők és a cég +között, hogy elvették tőlük a licenszt. +Az i-re a pontott az tette fel, mikor az egyik +kernel fejlesztő +[reverse engineer-elte](https://lwn.net/Articles/132938/) +a BitKeeper-t. +Ekkoriban +[Linus Torvalds](https://en.wikipedia.org/wiki/Linus_Torvalds) +úgy döntött, hogy egy új megoldást kell találnia, mely + +- gyors +- egyszerű +- támogatja a többszálú fejlesztést +- teljesen elosztott +- nagy projekteket is képes kezelni (pl.: Linux kernel) + +Így hát megírta a [Git](https://en.wikipedia.org/wiki/Git)-et, mely a mai napig a legelterjedtebb, leggyorsabb és +legkényelmesebb verzió kezelő rendszer. diff --git a/app/docs/guides/training/git/ scripts/masodik.md b/app/docs/guides/training/git/ scripts/masodik.md new file mode 100644 index 0000000000000000000000000000000000000000..4db2ba88d34f1d4c2e9ac4346745a666cee63d42 --- /dev/null +++ b/app/docs/guides/training/git/ scripts/masodik.md @@ -0,0 +1,463 @@ +Sziasztok, Blint vagyok! + +Másfél éve kszk-zom, leginkább a sysadminban találhattok meg, nemrég lettem megválasztva a kubernetesünk rendszergazdájának. A git-et már jó pár éve használom aktívan, el se tudom képzelni, hogy ne használjam egy projekthez. + +Ebben a videóban szeretném nektek a git gyakorlati alkalmazását megmutatni, abba bevezetni titeket. + +Kezdetben szeretnélek megkérni, hogy telepítsétek fel a git-et a gépetekre a segédletben leírtak szerint, vagy használjátok a linuxos előadáshoz kapott vm-eteket. + +Én alapból zsh-t használok a gépemen, így lehet, pár dolog nem ugyanúgy fog kinézni, mint nálatok (ha bash-t használtok), de minden ugyanúgy működik (ez egy POSIX shell), csak kicsit barátságosabban néz ki 😉. + +## Konfiguráció + +Állítsuk be magunknak a git-et, hogy kényelmesen tudjuk használni. + +Először is a saját adatainkat állítsuk be, ezt a: + +``` +git config --global user.name "Bálint Réthelyi" +git config --global user.email rethelyibalint@gmail.com +``` + +begépelésével tehetjük meg. + +Ezután állítsuk be, hogy a git milyen szövegszerkesztőt nyisson meg alapértelmezetten, ezt főként `commit`-oknál és `merge`-eknél fogjuk használni. + +A szükséges parancs pedig: + +``` +git config --global core.editor vim +``` + +Én szeretek `vim`-et használni, de ti nyugodtan beállíthattok magatoknak `nano`-t, vagy akár a VS Code-ot is, sokszor elég kényelmes tud lenni. + +Esetleg windows-on a notepad++-t is beállíthatjátok, ehhez a parancsot a segédleteben láthatjátok. + +### Jelenlegi konfig + +Nah, akkor nézzük meg, eddig mit alkottunk, hogy néz ki az összes git-es beállításunk: + +Ezt a: + +``` +git config --list +``` +parancs kiadásával nézhetjük meg. + +## Alapok + +Ha elakadtok git használat közben, akkor rengeteg segítség létezik, szerencsére a git-nek van egy nagyon jó help parancsa, valamint a man page-t is lehet nézegetni. + +### Git repo + +A git repository, vagy repo egy olyan mappa, mely gites verziókövetve van, azaz bárhol, ahol találunk egy .git mappát, az valójában egy git repo. + +Kezdjünk is bele, készítsünk egy saját repot! + +Ehhez készítsünk egy tetszőleges mappát, ez lesz a projektünk mappája, és lépjünk is bele. + +``` +mkdir projektem +cd projektem +``` + +Persze megnézhetjük, mi a helyzet a git-el, a `git status` paranccsal, de nem fog meglepni minket, hogy semmi (hiszen most hoztuk csak létre a projektet). + +``` +git status +hiba hiba.... +``` + +A teljesen üres mappánk még nincs verziókezelés alatt. Egy `ls -la`-val ezt ellenőrizni is tudjuk, nem látunk `.git` mappát. + +``` +ls -la +``` + +#### Git init + +Inicializáljuk hát ebbe a mappába a gitet, ezt a beszédes `git init` paranccsal tehetjük meg. Ez beállítja nekünk a `master` branchet és még jó pár alap dolgot (a branch-ről majd később beszélek még, egyelőre annyit elég tudni, hogy ide kerülnek a mentéspontok sorban, mint egy fa ága, innét jön a branch elnevezés). + +``` +git init +``` + +Ha megint megnézzük az `ls -la` paranccsal, mostmár van egy `.git` mappánk. Ebben benne van minden adatunk a repoval kapcsolatban. + +Amikor egy távoli repo-t leszedünk, akkor ezt a `.git` mappát kapjuk meg, és ennek tartalmából már a gépünkön található git alkalmazás előállítja nekünk a master ág legutóbbi mentéspontját. + +#### Mentéseink tárolása + +A mentések tárolásának fajtáiról a jegyzetben olvashattok, itt annyit említenék csak meg, hogy a git minden, azaz tényleg minden fájlt lemásol, ami verziókezelés alatt áll. Azaz, ha feltöltünk egy 1 GiB-os videót, majd a következő mentéskor átnevezem a videót, akkor már 2 GiB-nyi videót fog tartalmazni a repónk. Ha ez megijesztett minket és megpróbálnánk letörölni, ettől még a repóban ugyanúgy benne lesz, méretet nem csökentünk vele, persze utólag vissza tudunk menni az adott mentéshez, és kitörölni belőle... + +Nézzül meg, mi a helyzet a jelenlegi repónkkal. + +``` +git status +``` + +Láthatjuk, hogy még nincs semmilyen mentéspontunk, nincs mit elmentenünk. Megfigyelhetjük, hogy a git próbál segíteni nekünk (ezt jó sok helyen láthatjuk majd). + +Vegyünk fel egy új fájlt: + +``` +echo alma > gyumolcskosar +``` + +Újra megnézve a git status-t, láthatjuk, megjelent a fájlunk, de még nincs verziókezelés alatt. + +#### Git status-ok + +Milyen állapotok léteznek egy repo-ban? + +Van az: + +- Untracked: Ami még nincs verziókontroll alatt +- Staged: Ami már verziókontroll alatt van de még nem + készítettünk róla pillanatképet +- Unmodified: Amit már elmentettünk és azóta nem változott +- Modified: Az a fájl, ami már verziókontroll alatt van + és változott. Ezt utánna szintén Stage-be tudjuk tenni + +Láthatjuk, hogy a git megint próbál segíteni nekünk, írja is, hogy ahhoz hogy verziókövetve legyen a fájlunk, használjuk a `git add` parancsot. + +Adjuk is ki: + +``` +git add gyumolcskosar +``` + +Itt a gyümölcskosár helyett írhattam volna simán . -ot, akkor a repo-ban található összes fájlt bele tette volna (kivéve persze, amit megtíltunk neki, erről is kicsit később). + +Mostmár, ha `git status`-t hívunk, megjelenik a gyümölcskosarunk, új fájlként, `staged` állapotba került, akár el is tudjuk menteni. A mentéshez a `git commit` parancsot adjuk ki. Ekkor megnyílik az előre beállított szövegszerkesztőnk, valamint némi információ a leendő mentéspontról. + +``` +git commit +``` + +Láthatjuk, amit a `git status` írna ki, valamint pár segítséget a git-től. +A #-el kezdődő sorok kommentek, ezek a commit üzenetbe nem kerülnek bele, ezek csak nekünk szólnak. + +Írjuk is be az első sorba, hogy Készítettem egy gyümölcskosarat, majd mentsük el a fájlt, zárjuk b e a szövegszerkesztőt. + +A git érzékelte, hogy bezártuk a fájlt, abból kiolvasta a # nélküli sorokat és hozzáadta a mentéspontunkhoz, mint üzenet, valamint megjelent pár *hasznos* infó is. + +Nézzük, most mi a helyzet a repoban? + +``` +git status +``` + +Már nem szól semmit amiatt, hogy nincs mentésünk (hiszen az előbb készítettünk egyet), továbbá azt is írja, hogy nincs semmi amin változtattunk volna, azaz erről az állapotról nem is tudnánk új mentést készíteni (megegyezne az korábbival). + +Nézzük meg a következő két állapotot is, amiben egy fájl lehet. Írjuk bele a gyümölcskosarunkba, hogy már körte is van benne. + +``` +echo körte >> gyumolcskosar +``` + +Adjuk ki a `git status`-t: + +Láthatjuk, hogy mostmár `modified` állapotba került a gyümölcskosarunk. Mentsük is el, de egy kicsit kényelmesebb módon. + +``` +git add gyumolcskosar +git commit -m "Raktam bele körtét is" +``` + +Fontos, ne felejtsük el először hozzáadni a fájlunkat a stage-hez, a `git add gyumolcskosar` paranccsal. + +Készítsünk egy új fájlt `hordo` névvel, és nézzük meg, mit ír ki a `git status -s` parancs. Ezzel a kapcsolóval képesek vagyunk egy rövidített státuszt lekérni. + +Add-oljuk, majd commit-oljuk el. + +``` +git add hordo +git status -s +git commit -m "Hoztunk egy hordót" +``` + +#### Gitignore + +Oké, de mi van, ha nagyon nem szeretnénk, ha egy fájlunk verziókezelés alatt állna? Mondjuk a build-ek mappái, egy IDE által generált fájlokra, esetleg a gites előadás jegyzeteimre. + +Hozzunk létre egy `jegyzeteim.txt`-t és egy `.gitgnore`-t + +``` +touch jegyzeteim.txt +touxh .gitgnore +``` + +Ha kiadjuk a `git status` parancsot, megjelenik a jegyzeteim. + +Írjuk bele a a jegyzeteim.txt-t a gitignore-ba. + +``` +echo jegyzeteim.txt >> .gitignore +``` + +Adjuk ki *megint* a `git status` parancsot. Oh, eltűnt a jegyzetünk! Pont ezt akartuk, mostmár a git nem fogja figyelni ezt a fájlt. +Add-oljuk és mentsük el a gitignore-t. + +``` +git add .gitignore; git commit -m "jegyzeteim ignorálása" +``` + +#### Fájlok mozgatása + +A git nem tárol semmi adatot változásokról, csak mentéseket készít. Próbáljuk ki, mi történik, ha átnevezünk egy fájlt? + +``` +mv gyumolcskosar gyumolcskosar.txt +``` + +Toljunk egy `git status`-t. + +Láthatjuk, hogy az eredeti fájlt "töröltük", és sikeresen létrehoztunk egy új fájlt a repoban. Nézzük meg, mi történik, ha add-oljuk a változtatásokat. + +``` +git add . +git status +``` + +Persze a szokásos `git status` sem maradhat el. Mostmár látszik, hogy átnevezés történt.## + +A git képes rá, hogy felismerjea fájlokat és eldöntse, hogy a két fájl ugyanaz, csak átneveztük, mozgattuk, etc.. Követni nem tudja, csak azt látja, hogy létrejött egy új fájl, mint ami törölve lett nemrég. + +#### Mentési előzmények + +A git egyik leghasznosabb parancsa a `git status` után a `git log`. + +Próbáljuk is ki: + +``` +git log +``` + +Láthatjuk, milyen mentéspontjaink vannak, és a hozzájuk tartozó dolgokat, mint a commit hash vagy az üzenet. + +Picit szebbé is tehetjük, ha kiadjuk a parancsot a `--oneline` kapcsolóval. + +``` +git log --oneline +``` + +Máris csak a lényeget látjuk. Azt is észre vehetjük, csak 7 karaktert kapunk a hash-ből. ELég csak pár karakter, hogy be tudjuk azonosítani a commit-ot. + +## Branch-ek, elágazás + +### Mik azok a branch-ek? + +Korábban már említettem a branch-et, mint fogalmat. Képzeljük el a git-et, hogy szeretne adatokat, mutatókat tárolni. Mi van akkor, ha egy mutatóból kétfelé is elindulunk? Mondjuk Rick és én elkezdünk együtt kódolni... +Képzeljük el úgy, mint egy fa törzse, melyből ágak jönnek létre. Készítünk egy ágat Rick-nek és egyet nekem. Így tudunk ketten külön dolgozni, míg a master-t nem piszkáltuk. +Úgy is el lehet képzelni egy nagyobb projektnél, hogy van a master, amin az éles, jól működő kód van, és van a fejlesztési ág, amin pedig a fejlesztők dolgoznak (ez így azért még nagyon leegyszerűsíti). + +Nézzünk is egy példát, adjuk ki a `git status` parancsot. + +``` +git status +``` + +Látható, hogy jelenleg a `master` ágon vagyunk. Nézzük meg, milyen branch-ek vannak most a repónkban. + +``` +git branch +``` + +Még csak eyg águnk van. Ha kiadjuk a `git branch <új branch neve>` parancsot, akkor készül egy új ág, de arra figyeljünk, ilyenkor még nem megyünk át rá. +Nézzük is meg, hogy tényleg elkészült, a `git branch` paranccsal. + +``` +git branch atnevezes +git branch +``` + +Itt a `*` azt jelöli, hogy éppen melyik branch-en vagyunk. Ha kiadnánk a `git status`-t, amit most nem teszünk meg, ne koptassuk el szegényt, ugyanúgy láthatánk, melyik ágon vagyunk. + +Menjünk át az új ágra. + +``` +git checkout atnevezes +``` + +Itt rögtön látjuk is, a módosításainkkal nem történt semmi. Ha most elmentjük őket, akkor a jelenlegi ágra fogja beilleszteni őket. + +``` +git add . +git status +git commit -m "Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz" +``` + +Most ha kiadjuk a `git log --graph --oneline` parancsot, akkor meg is láthatjuk, hogy néz ki a fánk. + +### Hogyan épülnek fel? + +Ezt nézzétek meg a jegyzetben, röviden annyit, hogy mutatókat, pointereket használ a git, minden mentéspont az előzőre mutat, valamint a megfelelő fájlokra, amiket módosítottunk. + +### Ágak közötti mozgás + +Mielőtt visszatérnénk a master-re, nézzük meg, milyen fájljaink vannak. + +``` +ls -la +``` + +A gyumolcskosar.txt a lényeges. + +Térjünk vissza a master-re, és adjuk ki megint az `ls -la`-t. + +``` +git checkout master +ls -la +``` + +Látható, hogy visszaléptünk pontosan abba az állapotba, ami volt, mielőtt eljöttünk volna, azaz a gyümölcskosarat nem is változtattuk meg. Ez azért jó, mert két teljesen elkülönülő munkát szét tudunk választani. + +Írjuk a gyümölcskosár végére, hogy szőlő és mentsük is el. + +``` +echo szolo >> gyumolcskosar +git add . +git commit -m "Tettem bele szőlőt is" +``` + +Most kiadva a `git log --graph --oneline`-t már egy érdekesebb eredményt láthatunk. + +Hová tűnt a fájlunk? A git nem fogja alapból jelezni nekünk azt, amit nem lát a jelenlegi mentésből visszamenve. +Ahhoz hogy lássuk a másik ágat is, tegyük hozzá a `--all` kapcsolót. + +``` +git log --graph --oneline --all +``` + +Nah, rögtön látjuk a másik ágat is. + +Menjünk vissza az átnevezés ágra sé módosítsuk kicsit. + +``` +git checkout atnevezes +``` + +Nevezzük át a hordót hordó.txt-re, majd mentsük is el a munánkat. + +``` +mv hordo hordo.txt +git add . +git commit -m "Adtam kiterjesztést a hordónak is" +``` + +Egy megismételt `git log`-al láthatjuk is a fánkat. + +``` +git log --graph --oneline --all +``` + +### Merge-elés + +Az egyik legfontosabb dolog az ágak létrehozása után, hogy azokat be is tudjuk olvasztani valahova. A feladat az lenne, hogy a masterre beillesszük az átnevezés ágon végzett módosításokat. +Ehhez a `git merge <branch neve>` parancsot használhatjuk. Ez a parancs a kiválasztott ágat megpróbálja beolvasztani oda, ahol jeleneleg a `HEAD` mutatónk van. + +Menjünk is vissza a masterre. és próbáljuk meg merge-elni az átnevezés ágat. + + +``` +git checkout master +git merge atnevezes +``` + +Ekkor meg fog nyílni a szövegszerkesztőnk, ugyanis egy +új mentéspontot fogunk készíteni a `master` águnkra. +A feladott merge üzeneten nem kell módosítanunk, teljesen +jó így. + +A merge lefut és láthatjuk mi is történt. +Most egy újabb `git log --graph --oneline --all`-al ezt láthatjuk. +Ez a merge commit egyszerre mutat két ágra is. + +#### Merge conflict + +Mi van akkor, ha ketten egyszerre ugyanazat változtatjuk? +Úgy döntöttünk, Rick barátommal szeretnénk pálinkát főzni, szóval a hordóba teszzük ízlás szerint pár gyümölcsöt. + +Menjünk át a saját branch-ünkre. + +``` +git checkout -b blint +``` + +A -b kapcsolóval létre tudunk hozni nemlétező branch-et a checkout-nak megadva. + +Ha kiadjuk megint a `git branch`-et, láthatjuk, már három ág is van. + +Tegyünk bele a hordóba egy nekünk tetsző gyümölcsöt. + +``` +echo korte >> hordo.txt +``` + +Mentsül is el. A -a kapcsolóval egy lépést megint meg tudok spórolni. + +``` +git commit -a -m "Raktam bele körtét" +``` + +Rick eközben úgy döntött, ugyanebbe a hordóba szilvát szeretne tenni. Menjünk át a master-re és tegyük meg ott. + +Tehát: +``` +git checkout master +echo szilva >> hordo.txt +git commit -a -m "Raktam bele szilvát" +``` + +Ha megnézzük megint a gráfunkat, láthatjuk mi a helyzet jelenleg a reponkban. + +``` +git log --graph --oneline --all +``` + +Hát most próbáljuk meg merge-lni. + +``` +git merge blint +``` + +Oh, no, merge conflict keletkezett. +Nem kell megijedni, nem a világ vége és a git segít ahol tud. + +Az a helyzet, hogy egyszerre ugyanazt a sort módosítottuk és a git nem tudta +eldönteni mit tegyen. Megtartsa az egyiket vagy mindkettőt? Mégis mi legyen? + +Ezeket a kérdéseket nekünk kell megválaszolnunk. + +Először nézzük meg, mi a státusz. + +``` +git status +``` + +Ilyenkor a git beírja a fájlba mindkét branch változatát, ezt meg is jelöli nekünk, és tőlünk várja a megoldást. + +Nincs mit tenni, mint kitalálni, hogy mi maradjon a fájlban. + +Itt láthatjuk nyilakkal a HEAD és a blint branch által eszközölt módosításokat, egyenlőségjellel elválasztva egymástól. + +Csináljunk egy vegyes pálinkát, legyen benne mind a kettő. + +Ha megnézzük a státuszt, láthatjuk, még mindig ugyanaz a helyzet, mint korábban. Amíg nem mentjük el a módosításunkat, addig ezt fogja kiírni. + +``` +git commit -a -m "blint branch mergelve és konflikt megoldva" +``` + +Nézzük meg a gráfot ezután. + +``` +git --graph --oneline --all +``` + +Látjuk, a merge commit-unk egyben a konfliktus megoldását is tartalmazza. + +Most hogy tudjuk az alapokat, már csak mindezt közösen kell végezzük, online. Erről majd a gyakorlaton lesz szó. + +Addig is szép hétvégét, hetet, ki mikor nézi meg kívánok nektek! \ No newline at end of file diff --git a/app/docs/guides/training/git/01_intro.md b/app/docs/guides/training/git/01_intro.md new file mode 100644 index 0000000000000000000000000000000000000000..90bb18eb847f0ceb779f9bfbeb0fe0cc6e8c39f4 --- /dev/null +++ b/app/docs/guides/training/git/01_intro.md @@ -0,0 +1,39 @@ +# Intro + +## Bevezetés + +Először is üdvözlök mindenkit. Ezen doksi és előadás +végére remélem sikerül egy olyan szintű tudást átadnom, +hogy a jövőben ne okozzon problémát a verziókezelés. +Olyan kérdésekre fogok választ adni, mint "Miért kell +git-et használnom?", "Miért ilyen bonyolult ez az egész?" +és "Mégis mi a francot nyerek ezzel?". + +Amire szükséged lesz: Egy konzol, működő git-el ([workshop elején](../workshop/1_installation.md) +van egy útmutató) + +## Tippek + +Próbáld a parancsokat saját magad is kiadni, ugyanis +leghatékonyabban gyakorlati módon lehet a git-et elsajátítani. +Emellett légy kitartó és ne ijedj meg a rengeteg információtól. +A git nem egy egyszerű témakör, de hidd el, megéri a +belefektett munkát. + +## Ki vagyok én? + +Réthelyi Bálint (Blint), másod éves infós, jelenleg a reszortgazdaságis és kancellár, emellett lelkes szerversimogató és DevOps-os. +Van pár [DevTeam](https://git.sch.bme.hu/kszk/devteam)ben megtalálható projektem ([hőmérőSCH](https://git.sch.bme.hu/kszk/devteam/statusch/homerosch) és [becskasszáSCH](https://git.sch.bme.hu/kszk/devteam/becskasszasch)). + +Ha bármi kérdésed merülne fel a doksi olvasása vagy az előadás +során nyugodtan keress meg + +- Emailben: rethelyi.balint [kukac] kszk.bme.hu + +<div style={{textAlign: 'center'}}> +<img src={require('./img/me.jpg').default} alt="Kép magamról" /> +</div> + +<!--Forrás: [Rafael László (Lackó) git-es jegyzete](https://home.sch.bme.hu/~rlacko/git/) +Forrás2: [Pro Git könyv](https://git-scm.com/book/en/v2/) +--> diff --git a/app/docs/guides/training/git/02_versioning.md b/app/docs/guides/training/git/02_versioning.md new file mode 100644 index 0000000000000000000000000000000000000000..4f856459ef69694de87e26915479e69a2a3fa6d8 --- /dev/null +++ b/app/docs/guides/training/git/02_versioning.md @@ -0,0 +1,101 @@ +# Verziókezelés + +Mi is az a verzió kezelés? +Talán a legegyszerűbb egy példán keresztül szemléltetni. +Tegyük fel egy docx fájlt szerkesztünk és ezt hetente +frissítve rendszeresen el kell küldenünk emailben valakinek. +Ilyenkor különböző verziók keletkeznek a fájlból és ezeket +a postafiókunkból könnyedén elő tudjuk szedni. + +Na ugyanazen a példán tovább mehetünk. +Mi van ha lokális kezdjük ezeket a fájlokat tárolni? +Gondolom mindenki találkozott már hasonló fájlnevekkel: + +``` +├── elso_beadasom.docx +├── masodik_beadasom.docx +├── masodik_beadasom (1).docx +├── masodik_beadasom (1) Javított.docx +├── masodik_beadasom (1) Javított másolata.docx +├── asd.docx +├── asdasd.docx +└── asdasdasdasd.docx +``` + +Ha ügyesek vagyunk még mappákat is készítünk és dátumot is hozzá cimkézünk. + +``` +└── 2021 + └── 02 + ├── 13 + │ └── elso_beadasom.docx + ├── 19 + │ └── masodik_beadasom_felkesz.docx + ├── 20 + │ ├── masodik_beadasom.docx + │ ├── masodik_beadasom_javitott.docx + │ └── masodik_beadasom_vegleges.docx + └── ideiglenes + ├── asd.docx + ├── asdasd.docx + └── asdasdadsads.docx +``` + +Persze az operációs rendszer képes dátum alapján rendezni, +és megspórol nekünk pár lépést, de mi van ha ezt valakinek +el is szeretnénk küldeni? Mi van ha a módosítás dátuma közben +módosul? Hogyan biztosítjuk, hogy közben nem sérülnek a fájlok? + +Ezekre megoldást adnak a különböző verziókezelő rendszerek. +Többek közt dolguk, hogy fájljaink számon tartsák, ahogy például +kézileg tettük. + +### Milyen verzió kezelő rendszereink lehetnek? + +#### Helyi + +Erre a fenti példa a legjobb példa. +Vannak különböző verziói a fájlunknak és ezeket valamilyen +adatbázisban rögzítjük. + +<div style={{textAlign: 'center'}}> +<img src={require('./img/vcstype_local.png').default} alt="Local Version Control Systems" /> +</div> + +Ilyen az [RCS](https://www.gnu.org/software/rcs/). + +### Központosított + +Ez már egy fokkal okosabb. +A különböző verziókat a központi szerverre rakjuk fel és +onnan szedjük le. +Például van egy Fájlszerverünk amit minden gépről elérnek +az emberek és oda dolgoznak közösen... +Érezhető probléma, hogy így ha meghal a központi szerver, +akkor mindent elvesztünk (eskü nem volt még ilyen 😅). +Továbbá probléma lehet, hogy egymás munkáját felülírjük, +szerencsére egy jó rendszernél erről értesítést kapunk, +hozzá és nem felülírjuk a módosításaink. + +<div style={{textAlign: 'center'}}> +<img src={require('./img/vcstype_central.png').default} alt="Centralized Version Control Systems" /> +</div> + +### Megosztott + +Na és itt lépünk be a ma is használt Git világába. +Ennél a megoldásnál már az a trükk, hogy mindenkinek megvan +a teljes projekt az összes verziójával. Felmerül, hogy na +de akkor honnan szedjük le a legújabb verziót? +Különböző megoldások léteznek, például a fejlesztők a +módosításokat azonnal megosztják egymással +(pl.: p2p Torrenthez hasonló módon) vagy +kijelölnek egy központi szervert amivel mindenki +szinkronban van. +Ilyen központi szerver lehet például a [Github](https://github.com/) vagy a [Gitlab](https://gitlab.com/). +Csak megjegyzem, akár a módosításokat emailben is el lehet +küldeni és a szoftver automatikusan megcsinálja a többit a mi részünkön. + +<div style={{textAlign: 'center'}}> +<img src={require('./img/vcstype_distributed.png').default} alt="Distributed Version Control Systems" /> +</div> diff --git a/app/docs/guides/training/git/03_history.md b/app/docs/guides/training/git/03_history.md new file mode 100644 index 0000000000000000000000000000000000000000..502e68475c41449a2a2641f532a3e273c297d22e --- /dev/null +++ b/app/docs/guides/training/git/03_history.md @@ -0,0 +1,32 @@ +# Git története + +Még mielőtt belemerülnék a git telepítésébe, használatába, +szeretnék némi sztorizást is megejteni. + +Annó a Linux kernel fejlesztése során okozott nagy fejtörést +az egész verziókezelés megoldása. +1991-től 2002-ig, tehát 11 éven át patchekben +(pl.: e-mailben elküldött szöveg a módosításokkal) +és tömörített fájlokban küldözgették a verziókat a fejlesztők. +Aztán 2002-től egy zárt licenszű verzió kezelőre, a +[BitKeeper](http://www.bitkeeper.org/)-re váltottak. + +Ezt a Linux fejlesztői ingyen használhatták egészen 2005-ig, +mikorra annyira elromlott a kapcsolat a fejlesztők és a cég +között, hogy elvették tőlük a licenszt. +Az i-re a pontott az tette fel, mikor az egyik +kernel fejlesztő +[reverse engineer-elte](https://lwn.net/Articles/132938/) +a BitKeeper-t. +Ekkoriban +[Linus Torvalds](https://en.wikipedia.org/wiki/Linus_Torvalds) +úgy döntött, hogy egy új megoldást kell találnia, mely + +- gyors +- egyszerű +- támogatja a többszálú fejlesztést +- teljesen elosztott +- nagy projekteket is képes kezelni (pl.: Linux kernel) + +Így hát megírta a [Git](https://en.wikipedia.org/wiki/Git)-et, mely a mai napig a legelterjedtebb, leggyorsabb és +legkényelmesebb verzió kezelő rendszer. diff --git a/app/docs/guides/training/git/04_installation.md b/app/docs/guides/training/git/04_installation.md new file mode 100644 index 0000000000000000000000000000000000000000..c2cc64a6e9e7ba6a19c09c19c2e9c19514ede9ba --- /dev/null +++ b/app/docs/guides/training/git/04_installation.md @@ -0,0 +1,142 @@ +# Telepítés és konfiguráció + +A Git-nek vannak grafikus kliens-ei is, de ahhoz, hogy igazán +megérthessük konzolt fogunk használni. +Továbbá azt is hozzátenném, hogy a grafikus alkalmazások nem tudják lefedni a Git összes rendelkezésre álló funkcióját +és néha nagyon lebutítják a felhasználó felé, ezért +nem is lehet feltétlen megtanulni a működését grafikus +alkalmazásból. + +## Telepítés + +#### Windows + +Elég egyszerű a telepítés. +Felmész a [https://git-scm.com/download/win](https://git-scm.com/download/win) címre és az ott lévő .exe fájlt letöltöd. +A telepítőben a beállításokkal nem kell foglalkozni, az +alapértelmezett mindenhol jó lesz. + +Esetleg később ha szeretnél egy grafikus felület, akkor a Github +Desktop is egy jó opció. Ez magába foglalja mind a konzolos, +mind az asztali programot. +[https://desktop.github.com/](https://desktop.github.com/) + +#### MacOS + +Nincs sok tapasztalatom vele, de ha megpróbálod konzolból +kiadni a +`git --version` +parancsot, akkor fel fogja ajánlani, +hogy telepítsd. Itt kapsz egy telepítőt és az alapértelmezett +beállításain végig mész. + +#### Linux + +Talán a legtriviálisabb. Attól függően milyen disztrót használsz, +letölthető a megfelelő csomagkezelővel. +RPM alapúak (Fedora, RHEL, CentOS, ...): +`sudo dnf install git` +Debian alapúak (Ubuntu, ...): +`sudo apt install git` + +Többi Disztróra: +[git-scm.com/download/linux](https://git-scm.com/download/linux) + +## Konfiguráció + +### Hol vannak a konfigok? + +Legegyszerűbben ezzel a paranccsal lehet a jelenlegi konfig +fájlok helyzetét kiírni: +`git config --list --show-origin` + +Látható, hogy a konfigokat valamilyen config fájlba menti, +a fájlrendszerben elszórva. Erről egy pár táblázat: + +##### Windows + +| Scope | Hely | Fájlnév | +| -------- | ---------------------------- | --------------- | +| Rendszer | mingw32\etc vagy mingw64\etc | gitconfig | +| Globális | C:\Users\\<felhasználónév> | .gitconfig | +| Lokális | Git repo .git mappája | config | +| Worktree | Git repo .git mappája | config.worktree | +| Portable | C:\ProgramData\Git\ | config | + +##### Linux (Ubuntu) + +(MacOS ehhez hasonló) + +| Scope | Hely | Fájlnév | +| -------- | --------------------- | --------------- | +| Rendszer | /etc | gitconfig | +| Globális | ~ | .gitconfig | +| Lokális | Git repo .git mappája | config | +| Worktree | Git repo .git mappája | config.worktree | + +Nálam a konfig a home mappámban például így néz ki: + +``` +$ cat ~/.gitconfig +[user] + name = Bálint Réthelyi + email = rethelyibalint@gmail.com + signingkey = 6EA0C1AC38C567DE +[core] + editor = nvim + autocrlf = input +[pull] + rebase = true +[commit] + gpgsign = true +``` + +### Állítsuk be a dolgokat magunknak + +##### Saját adatok + +Először is a saját adataink: + +``` +$ git config --global user.name "John Doe" +$ git config --global user.email johndoe [AT] example.com +``` + +##### Szövegszerkesztő + +Állítsuk be a szövegszerkesztőnket. +Erre főként a mentéspontokhoz tartozó üzenet megírásához van +szükség. + +``` +$ git config --global core.editor nano +``` + +vagy például notepad++-ra windows-on: + +``` +$ git config --global core.editor "'C:/Program Files/Notepad++/notepad++.exe' -multiInst -notabbar -nosession -noPlugin" +``` + +##### Jelenlegi konfig + +Nézzük meg az összes beállításunk: + +``` +$ git config --list +user.name=Bálint Réthelyi +user.email=rethelyibalint@gmail.com +user.signingkey=6EA0C1AC38C567DE +core.editor=nvim +core.autocrlf=input +pull.rebase=true +commit.gpgsign=true +... +``` + +Ha pedig csak egy adottat szeretnénk: + +``` +$ git config user.name +Bálint Réthelyi +``` diff --git a/app/docs/guides/training/git/05_basics.md b/app/docs/guides/training/git/05_basics.md new file mode 100644 index 0000000000000000000000000000000000000000..10f67f053d84bd0a0d28c70a054843000e440e3f --- /dev/null +++ b/app/docs/guides/training/git/05_basics.md @@ -0,0 +1,519 @@ +# Alapok + +##### Mit tegyek ha elakadok? + +Git-ben van egy beépített git help parancs: + +``` +$ git help <verb> +$ git <verb> --help +$ man git-<verb> +``` + +Például a config-al kapcsolatos dolgok: + +``` +$ git help config +``` + +De ha csak egy gyors áttekintésre van szükséged: + +``` +$ git config -h +usage: git config [<options>] + +Config file location +--global use global config file +--system use system config file +--local use repository config file +--worktree use per-worktree config file +-f, --file <file> use given config file +--blob <blob-id> read config from given blob object + +Action +--get get value: name [value-regex] +... + +``` + +#### Repository + +A Git repository egy olyan mappa, mely Git verziókezelés alatt +áll. +Tehát az a mappa, ahol van egy .git mappa, az egy git repo. + +``` +$ ls -al +total 20 +drwxrwxr-x 4 blint blint 4096 okt 8 12:59 . +drwxrwxr-x 3 blint blint 4096 okt 7 12:04 .. +drwxrwxr-x 5 blint blint 4096 okt 7 12:46 docs +drwxrwxr-x 8 blint blint 4096 okt 8 16:39 .git +-rw-r--r-- 1 blint rlacko 17 okt 7 12:09 README.md + +``` + +Csináljunk egy sajátot! + +Hozzunk létre egy tetszőleges projekt mappát és lépjünk bele + +``` +$ mkdir projektem +$ cd projektem + +``` + +Nézzük meg, hogy mi a helyzet a git-el. +Ehhez a `git status` parancsot tudjuk használni. +Ez a parancs a jelenlegi git repo-nkról képes +információkat kiírni. + +``` +$ git status +fatal: not a git repository (or any of the parent directories): .git + +``` + +Teljesen üres a mappa, még nincs verzió kontroll alatt. +`ls -al` -el tudjuk is ellenőrizni, hogy nincsen `.git` +mappa. + +Tegyük verziókontroll alá a `git init` paranccsal. +Ez beállítja nekünk a `master` branchet és más alap dolgokat. +A branch-ről még később beszélek, de azt jegyezzük meg addig, +hogy ide kerülnek a mentéspontjaink egymás után sorban, mint +egy fa ága. + +<div style={{textAlign: 'center'}}> +<img src={require('./img/basic-branching.png').default} alt="Git branch" /> +</div> + +``` +$ git init . +hint: Using 'master' as the name for the initial branch. This default branch name +hint: is subject to change. To configure the initial branch name to use in all +hint: of your new repositories, which will suppress this warning, call: +hint: +hint: git config --global init.defaultBranch <name> +hint: +hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and +hint: 'development'. The just-created branch can be renamed via this command: +hint: +hint: git branch -m <name> +Initialized empty Git repository in /home/blint/Projects/random codes/git_pres_working_dir/projektem/.git/ + +``` + +Ha megnézzük, mostmár van egy .git mappánk + +``` +$ ls -al +total 12 +drwxr-xr-x 3 blint blint 4096 Mar 19 12:40 . +drwxr-xr-x 3 blint blint 4096 Mar 19 12:39 .. +drwxr-xr-x 7 blint blint 4096 Mar 19 12:40 .git + +``` + +Ebben van minden adatunk a git repo-val kapcsolatban. +Gyakorlatilag mikor egy távoli git repo-t leszedünk, akkor +ezt a mappát kapjuk meg. Ebből ezután a git alkalmazásunk +előállítja nekünk a master ág legutóbbi mentéspontját. + +#### Mentéseink tárolása + +Egy logikus megoldásnak tűnhet, hogy az egyes fájlok közt +csak az eltéréseket tároljuk. Például: + +```gyumolcskosar +1. mentés: +alma + +2. mentés: +[1.mentés 1.sora] +alma +``` + +Ez annyiból jó, hogy a tárhellyel spórol, viszont nem gyors. +Képzeljünk el egy 1000 commit-ból álló repo-t. +Mi történik mikor a legutóbbit lekérjük? + +Erre egyik megoldás más verziókezelőknél, hogy optimalizálnak +és mondjuk 50 mentésenként csinálnak egy teljes mentést, stb. + +A Git ezt úgy oldja meg, hogy egy mentés az összes fájlt +egy az egybe lemásolja. +Például egyik mentés alkalmával feltöltök egy 1gb-os videót, +majd a következő mentéskor pár bitet átírok, akkor már +2gb-nyi videó lesz a repóban és ha utána egy másik mentésel +ki is töröljük, az attól még megmarad. +Persze utólag tudunk olyat, hogy visszmegyünk és kitöröljük +az adott mentésből (ezért nem jó ötlet git repo-ba 100 GB-os vm image-t felpush-olni, majd letörölni, hogy oops ez véletlen volt srácok). + +Oké, tehát például a mappákba bemásolja a mentéseinket valamilyen +módon, de mégis hova? + +``` +$ tree .git/objects/ +.git/objects/ +├── 13 +│ └── 46dac32baea8123272f60b6a04227fe3872bdb +... +├── e6 +│ └── 9de29bb2d1d6434b8b29ae775ad8c2e48c5391 +├── f4 +│ └── 5a6ff55496414b573e97064e998f065182eeee +├── info +└── pack +``` + +Mégis mik ezek? +A Git tömörítve és hashelve tárolja a fájlokat. +A hashelésnek annyi a lényege, hogy a fájl teljes tartalmán +átfuttatunk egy algoritmust, mely ezután kiköp egy 0-9a-z +szöveget és ha akár 1 bit-et is változtatunk egy fájlon, akkor +más lesz a hash-e. +Tehát ha valaki elcommitol valamit, akkor azt már más nem tudja +megváltoztatni anélkül, hogy változna a hash. +Így tudjuk biztosítani a teljes konzisztenciát az elosztott +repo-k között. + +Hash-t láthatunk például a mentéspontjainkon, fájljainkon, stb. + +Például itt egy ábra, hogy hogyan társítja a git egy +commit-hoz a megfelelő fájlokat egy kis pointer mágia keretében. + +<div style={{textAlign: 'center'}}> +<img src={require('./img/commit-and-tree.png').default} alt="Commit and Tree" /> +</div> + +Ennél jobban nem megyek bele a témába, de érdekes olvasmány. + +#### Változtatások mentése + +Hogyan néz ki egy mentés (a `git log`-al tudod megnézni)? + +``` +commit e334ae2e8c4104429ff034152e622851a25c3a97 +Author: blint <blintmester@sch.bme.hu> +Date: Thu Mar 18 15:37:54 2021 +0100 + + Készítettem egy gyümölcskosarat +``` + +Van egy commit-nak `commit hash`-e, `készítője`, +`létrehozási dátuma`, és `commit üzenete` + +Na de hogyan készítünk egy mentéspontot? + +A fájljainknak különböző állapotai létezhetnek egy +repo-ban. + +- Untracked: Ami még nincs verziókontroll alatt +- Staged: Ami már verziókontroll alatt van de még nem + mentettük el +- Unmodified: Amit már elmentettünk és azóta nem változott +- Modified: Az a fájl, ami már verziókontroll alatt van + és változott. Ezt utánna szintén Stage-be tudjuk tenni + +Nézzük meg ezen az ábrán és egy példa projekten keresztül: + +<div style={{textAlign: 'center'}}> +<img src={require('./img/git_lifecycle.png').default} alt="Git Life cycle" /> +</div> + +Mi a jelenlegi helyzet a frissen inicializált repo-ban? + +``` +$ git status +On branch master +No commits yet +nothing to commit (create/copy files and use "git add" to track) +``` + +Láthatjuk, hogy még nincsenek mentéspontjaink, nincs mit +elmentenünk és egyben a git próbál segíteni, hogy hogyan +tudunk stagelni valamit. +Ezt több helyen is megfigyelhetjük a git-ben. +Próbál segíteni ahol csak tud. + +Vegyünk fel egy új fájlt. + +``` +echo 'alma' > gyumolcskosar +``` + +_Itt az `echo` egy olyan parancs volt, mely kiírta nekünk a +terminálra azt, hogy "alma", de átirányítottuk egy fájlba +a `>` operátorral és mivel nem létezett a fájl, azt létre is +hozta._ - Linux magic #01 + +Újra megvizsgálva a status-t, látni fogjuk, hogy megjelent, de +még nincs verziókontroll alatt. + +``` +$ git status +... +Untracked files: +(use "git add <file>..." to include in what will be committed) +gyumolcskosar + +nothing added to commit but untracked files present (use "git add" to track) +``` + +Ahhoz, hogy git alá helyezzük, a `git add <fájl>` parancsot +fogjuk kiadni. +_Ezek a parancsok mind képesek rá, hogy +Unix-os módon több fájlra is kiadhatóak legyenek. +Például a `<fájl>` lehet `*.jpg`amivel minden .jpg fájlt kijelölünk a jelenlegi mappában._ - Linux magic #02 + +``` +$ git add gyumolcskosar +``` + +Ezután megjelenik, mint új fájl a git adatbázisában. + +``` +$ git status +... +Changes to be committed: +(use "git rm --cached <file>..." to unstage) +new file: gyumolcskosar +``` + +A fájlunk átkerült staged módba és ezt akár el is +tudjuk menteni. +A mentéshez a `git commit` parancsot tudjuk +használni. +`$ git commit`-ot kiadva megnyilik a beállított szövegszerkesztőnk és némi +információ a leendő mentéspontról. + +``` +# Please enter the commit message for your changes. Lines starting +# with '#' will be ignored, and an empty message aborts the commit. +# +# On branch master +# +# Initial commit +# +# Changes to be committed: +# new file: gyumolcskosar +``` + +Láthatjuk amit a `git status` parancs írna ki és pár extra +segítséget a git-től. +A # -el kezdődő sorok kommentek, ezek nem fognak a commit +üzenetbe belekerülni. +Írjuk be az első sorba, hogy `Készítettem egy gyümölcskosarat`, +majd mentsük el a fájlt és zárjuk be a szövegszerkesztőt. + +``` +$ git commit +[master (root-commit) c45abc3] Készítettem egy gyümölcskosarat +1 file changed, 1 insertion(+) +create mode 100644 gyumolcskosar +``` + +A git mikor érzékelte, hogy bezártuk a fájlt, akkor abból +kiolvasta a sorokat, ignorálva a #-el kezdődőket és hozzáadta +a mentéspontunkhoz, mint üzenet. +Ezt láthatjuk is a visszajelzésben. +Továbbá megjelent pár további hasznos információ is. + +Ismételten nézzük meg mi a helyzet a reponkban: + +``` +$ git status +On branch master +nothing to commit, working tree clean +``` + +Mostmár nem szól amiatt, hogy még nincsen mentésünk, továbbá +azt is írja, hogy még semmin nem változtattunk, nem tudunk +mit elmenteni. + +Nézzük meg a további két állapotot is amiben lehet egy fájl. +Írjuk bele a gyumolcskosar fájlba, hogy `korte` + +``` +alma +korte +``` + +Ezután kiadva a `git status`-t: + +``` +$ git status +On branch master +Changes not staged for commit: + (use "git add <file>..." to update what will be committed) + (use "git restore <file>..." to discard changes in working directory) + modified: gyumolcskosar + +no changes added to commit (use "git add" and/or "git commit -a") +``` + +Látható, hogy mostmár `modified` a fájlunk, mentsük is el, +de most picit másképp. A git és általában minden Unix +parancsnak át tudunk adni úgynevezett kapcsolókat. +Például `git commit -m <message>`. +Ez annyit spórol meg nekünk, hogy nem kell szövegszerkesztőt +megnyitnia a git-nek mikor új commit-ot készítünk, +hanem átrakjuk a parancsot olyan módba, +hogy várjon egy szöveget, mint mentéshez kapcsolódó üzenet. +Általában logikusak az egy betűs rövidítések: +`-m: message, -a: all`, de tudunk hosszabb verziókat is +használni, mint `--message, --all`. + +<Note type="warning" label="Megjegyzés"> + +Ne felejtsük el először stagelni a mentendő fájljaink egy +`git add <fájl>` parancs kiadásával. + +</Note> + +``` +$ git add gyumolcskosar +$ git commit -m "Raktam bele egy körtét" +``` + +Készítsünk egy új fájlt `hordo` néven és nézzük mit ír ki +a `git status -s` parancs. + +``` +$ git status -s +?? hordo +``` + +Ezzel a kapcsolóval képesek vagyunk egy rövidített státuszt +lekérni. Stageljük majd pedig commitoljuk el +`"Hoztunk egy hordót"` üzenettel. A lépések közt nézzük meg +mit ír ki a `git status -s`. + +Mi van akkor, ha valami fájlt nem szeretnénk verziókontroll +alá tenni? Gondolok például a build-ek mappáira vagy +egy IDE által generált fájlokra. + +Hozzunk létre egy `.gitignore` fájlt és egy `jegyzeteim.txt` +fájlt. +Ezután adjuk ki a `git status` parancsot. +Láthatjuk, hogy a `jegyzeteim` fájl megjelent. + +Most írjuk be a fájl nevét a `.gitignore`-ba. + +<Note type="tip" label="Tipp"> + +```shell-session +echo jegyzeteim.txt >> .gitingore +``` + +Itt a >> a hozzáfűzés miatt kell, hasznos ha nem írjuk felül az egész fájlt. + +</Note> + + +`.gitignore`: +``` +jegyzeteim.txt +``` + +Ezt követően adjuk ki újra a `git status` parancsot. +Oh, eltünt a fájlunk! Pont ezt akartuk, mostmár nem fogja +figyelni a git ha ilyen fájlt készítünk. +Mostmár csak stageljük és mentsük el az új fájlunk. +`git add .`, `git commit -m "jegyzeteim ignorálása"` + +#### Fájlok mozgatása + +A git semmi adatot nem tárol változásokról, csak +mentéseket készít, ahogy említettem. +Próbáljuk ki, hogy mi történik ha átnevezünk egy fájlt? + +``` +mv gyumolcskosar gyumolcskosar.txt +``` + +``` +git status +On branch master +Changes not staged for commit: + (use "git add/rm <file>..." to update what will be committed) + (use "git restore <file>..." to discard changes in working directory) + deleted: gyumolcskosar + +Untracked files: + (use "git add <file>..." to include in what will be committed) + gyumolcskosar.txt + +no changes added to commit (use "git add" and/or "git commit -a") +``` + +Látható, hogy az eredeti fájlt "töröltük" és egy új +fájlt vettünk fel a repo-ba. Érdekes, mi lenne ha stagelnénk +a változtatásokat `git add .` -al? + +```shell-session +$ git add . +$ git status +On branch master +Changes to be committed: + (use "git restore --staged <file>..." to unstage) + renamed: gyumolcskosar -> gyumolcskosar.txt +``` + +Most meg már látszik, hogy csak átnevezés történt? + +A Git képes rá, hogy felismerje a fájlokat és eldöntse, hogy +ugyanaz volt a kettő, tehát átnevezés, mozgatás, stb. történt. +De nem tudja követni a fájlt, csak látja, hogy jött egy új +fájl ami szinte ugyanaz, mint ami törölve lett nemrég. + +#### Mentési előzmények + +A Git egyik legjobb parancsa a `git log` a `git status` után és +szeretném ha kipróbálnád. + +``` +commit 996698cf3273800680c351df950ebe1fbaf5182a (HEAD -> master) +Author: Bálint Réthelyi <rethelyibalint@gmail.com> +Date: Sat Mar 20 13:02:20 2021 +0100 + + jegyzeteim ignorálása + +commit 36552bc9400d94f399bd505a566178a4c83e8abd +Author: Bálint Réthelyi <rethelyibalint@gmail.com> +Date: Sat Mar 20 13:00:32 2021 +0100 + + Hoztunk egy hordót is + +commit a8a9b268e50a784fb2e3c0d7422d4d8ccd638b64 +Author: Bálint Réthelyi <rethelyibalint@gmail.com> +Date: Sat Mar 20 12:59:32 2021 +0100 + + Raktam bele egy körtét + +commit 2a685fcd1e66b11805570869f8f49d5c5ef3bca1 +Author: Bálint Réthelyi <rethelyibalint@gmail.com> +Date: Sat Mar 20 12:12:40 2021 +0100 + + Készítettem egy gyümölcskosarat +``` + +Itt azt láthatjuk, hogy milyen mentéspontjaink vannak +és a hozzájuk tartozó dolgokat, mint a commit hash vagy +a üzenet. + +Picit tegyük szebbé. Adjuk ki az előző parancsot a +`--oneline` kapcsolóval. + +``` +996698c (HEAD -> master) jegyzeteim ignorálása +36552bc Hoztunk egy hordót is +a8a9b26 Raktam bele egy körtét +2a685fc Készítettem egy gyümölcskosarat +``` + +Máris csak a lényeget látjuk. Az is látható, hogy csak 7 +karaktert kaptunk a hashből. +Elég csak pár karakter, hogy beazonosítsunk +például egy commitot a hash-ével. diff --git a/app/docs/guides/training/git/06_branch.md b/app/docs/guides/training/git/06_branch.md new file mode 100644 index 0000000000000000000000000000000000000000..6947596b9ad2635a54fc3d1c03b1848ef02e635f --- /dev/null +++ b/app/docs/guides/training/git/06_branch.md @@ -0,0 +1,488 @@ +# Branch-ek, elágazás + +## Mik azok a branch-ek? + +Talán legegyszerűbb, ha előbb készítünk egyet. + +Az előző témakörben átneveztünk egy fájlt, de +nem commitoltuk el. +Ezt ne tegyük meg, hanem készítsünk egy ágat onnan, +ahol jártunk mondjuk azzal a névvel, hogy `atnevezes`. + +Először nézzük meg, mi a helyzet jelenleg a +`git status` paranccsal. + +``` +$ git status +On branch master +Changes to be committed: + (use "git restore --staged <file>..." to unstage) + renamed: gyumolcskosar -> gyumolcskosar.txt +``` + +Látható, hogy a `master` nevű ágon vagyunk. +Ezt képzeljük el úgy, mint egy fa törzse, melyből +le ágazunk. +Nézzük meg jelenleg milyen branch-ek vannak a repo-nkban +a `git branch` paranccsal. + +``` +$ git branch + +* master +``` + +Látható, hogy még csak egy van. +Ha a `git branch <új branch neve>` parancsot kiadjuk, akkor +készül egy új ág, de arra figyeljünk, hogy ilyenkor még nem +megyünk át rá. +Nézzük is meg, hogy tényleg elkészült a `git branch` paranccsal. + +``` +$ git branch + + atnevezes +* master +``` + +Itt a `*` azt jelöli, hogy melyiken vagyunk jelenleg. +Ha kiadnánk a `git status` parancsot, akkor is láthatnánk +melyik ágon vagyunk. + +Gyerünk át az új ágra. +Ehhez a `git checkout <ág neve>` parancsot tudjuk használni. + +``` +$ git checkout atnevezes +D gyumolcskosar +A gyumolcskosar.txt +Switched to branch 'atnevezes' +``` + +Itt azt is látjuk azonnal, hogy a módosításainkkal nem történt +semmi. +Ezek jelenleg még `staged`-be vannak és ha elmentjük őket +a commital, akkor az épp jelenlegi ágra fogja +beilleszteni őket. + +Nézzük meg `git status`-al, hogy mi a helyzet. + +``` +$ git status +On branch atnevezes +Changes to be committed: + (use "git restore --staged <file>..." to unstage) + renamed: gyumolcskosar -> gyumolcskosar.txt +``` + +Látszik is, hogy az `atnevezes` ágon vagyunk. +Mentsük el ide a módosításaink +`Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz` +üzenettel + +``` +$ git commit -m "Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz" +[atnevezes 07ac740] Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz + 1 file changed, 0 insertions(+), 0 deletions(-) + rename gyumolcskosar => gyumolcskosar.txt (100%) +``` + +Ezt követően ha kiadjuk a `git log --graph --oneline` parancsot, akkor +meg is láthatjuk a jelenlegi helyzetet a mi fánkban: + +``` +* 07ac740 (HEAD -> atnevezes) Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz +* 996698c (master) jegyzeteim ignorálása +* 36552bc Hoztunk egy hordót is +* a8a9b26 Raktam bele egy körtét +* 2a685fc Készítettem egy gyümölcskosarat +``` + +## Hogy épül fel? + +Először is, ahhoz hogy tudja a git melyik mentéspont után +melyik jön, mutatókat használ ehhez az ábrához +hasonló módon: + +<div style={{textAlign: 'center'}}> +<img src={require('./img/commits-and-parents.png').default} alt="Commits and parents" /> +</div> + +A mentéspontjaink az előzőre mutatnak. +Ahogy láthattuk az előző fejezetben, a mentéspontok pedig +mutatnak a megfelelő fájlokra amiket épp módosítottunk. + +Vizsgáljuk meg a jelenlegi repo-nkat, hogy pontosan +mi merre is van. + +<div style={{textAlign: 'center'}}> +<img src={require('./img/tree_with_one_branch.png').default} alt="Tree with one branch" /> +</div> + +A mentéspontok képesek mutatni az előzőre, ezt láthatjuk +az ábrán. +Továbbá azt is látjuk, hogy van még 3 pointerünk. +Az egyik `master`, ez az ami a legfrissebb mentésre +mutat a master ágon. +Ugyanez igaz az `atnevezes` ág esetében, de oda még mutat +egy `HEAD` mutató is. +Ez az a mutató ami azt jelzi, hogy hol vagyunk mi jelenleg. +Mikor egy új mentést hozunk létre, akkor az a mentés ide +fog mutatni. +Ezért is kellett figyelni az előzőnél, hogy mentés +előtt átváltsunk a megfelelő ágra. + +#### Ágak közti mozgás + +Még mielőtt vissza mennénk a master-re, nézzük meg milyen +fájljaink vannak az `ls -al` -el. + +```shell-session +$ ls -al +total 20 +drwxr-xr-x 3 blint blint 4096 Mar 20 13:02 . +drwxr-xr-x 3 blint blint 4096 Mar 19 12:39 .. +drwxr-xr-x 8 blint blint 4096 Mar 20 13:12 .git +-rw-r--r-- 1 blint blint 15 Mar 20 13:01 .gitignore +-rw-r--r-- 1 blint blint 11 Mar 20 12:58 gyumolcskosar.txt +-rw-r--r-- 1 blint blint 0 Mar 20 12:59 hordo +-rw-r--r-- 1 blint blint 0 Mar 20 13:01 jegyzeteim.txt +``` + +Egy pár extra adatot is kapunk, de nekünk most a +`gyumolcskosar.txt` a lényeges. + +Most gyerünk vissza a `master` ágra a `git checkout <ág neve>` +paranccsal. + +```shell-session +$ git checkout master +Switched to branch 'master' +``` + +Most adjuk ismét ki az `ls -al` parancsot. + +```shell-session +$ ls -al +total 20 +drwxr-xr-x 3 blint blint 4096 Mar 20 13:16 . +drwxr-xr-x 3 blint blint 4096 Mar 19 12:39 .. +drwxr-xr-x 8 blint blint 4096 Mar 20 13:16 .git +-rw-r--r-- 1 blint blint 15 Mar 20 13:01 .gitignore +-rw-r--r-- 1 blint blint 11 Mar 20 13:16 gyumolcskosar +-rw-r--r-- 1 blint blint 0 Mar 20 12:59 hordo +-rw-r--r-- 1 blint blint 0 Mar 20 13:01 jegyzeteim.txt +``` + +Látható, hogy vissza léptünk arra az állapotra mikor még +nem változtattunk rajta. + +Ez elképesztően jó, ugyanis két teljesen külön álló munkát +így elkülönítöttünk egymástól! + +Írjuk a `gyumolcskosar` fájl végére, hogy `szolo` és mentsük el +azzal az üzenettel, hogy `Tettem a kosaramba szőlőt`. + +```shell-session +$ git commit -m "Tettem a kosaramba szőlőt" +[master c8496bf] Tettem a kosaramba szőlőt + 1 file changed, 1 insertion(+) +``` + +Most újra kiadva a `git log --graph --oneline` parancsot, +már érdekesebb eredményt láthatunk. + +``` +$ git log --graph --oneline + +* c8496bf (HEAD -> master) Tettem a kosaramba szőlőt +* 996698c jegyzeteim ignorálása +* 36552bc Hoztunk egy hordót is +... +``` + +Mégis hova tünt a másik águnk? +A git nem fogja alapból jelezni nekünk azt amit nem lát +a jelenlegi mentéstől vissza menve. +Hogy lássuk a másik ágat is, tegyük hozzá a `--all` kapcsolót. + +``` +$ git log --graph --oneline --all + +* c8496bf (HEAD -> master) Tettem a kosaramba szőlőt +| * 07ac740 (atnevezes) Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz +|/ +* 996698c jegyzeteim ignorálása +* 36552bc Hoztunk egy hordót is +* a8a9b26 Raktam bele egy körtét +* 2a685fc Készítettem egy gyümölcskosarat +``` + +Na így már látjuk a másik ágat is. +Még vizuálisabban jelenleg így állunk: + +<div style={{textAlign: 'center'}}> +<img src={require('./img/tree_awesome.png').default} alt="Tree with one branch" /> +</div> + +Menjünk vissza az `atnevezes` ágra és módosítsunk picit. + +```shell-session +$ git checkout atnevezes +``` + +Majd pedig nevezzük át a `hordo`-t `hordo.txt`-re. + +```shell-session +$ mv hordo hordo.txt +``` + +És ezt is mentsük el + +```shell-session +$ git add . +$ git commit -m "Adtam kiterjesztést a hordónak" +``` + +Egy ismételt `git log`-al láthatjuk is a fánkat. + +``` +$ git log --graph --oneline --all + +* c040bc1 (HEAD -> atnevezes) Adtam kiterjesztést a hordónak +* 07ac740 Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz +| * c8496bf (master) Tettem a kosaramba szőlőt +|/ +* 996698c jegyzeteim ignorálása +* 36552bc Hoztunk egy hordót is +* a8a9b26 Raktam bele egy körtét +* 2a685fc Készítettem egy gyümölcskosarat +``` + +#### Mergelés + +Az egyik legfontosabb dolog az ágak létrehozása után, hogy +be tudjuk olvasztani az águnk valahova. +Az lenne a feladat, hogy a `master`-re beillesszük az +`atnevezes` ágon végzett módosításaink. +Ehhez a `git merge <branch neve>` parancsot használhatjuk. +A lényege, hogy ez a parancs azt az ágat amit kiválasztottunk +megpróbálja beolvasztani oda ahol épp a `HEAD` mutatónk van. + +Gyerünk is át a `master` ágra. + +```shell-session +$ git checkout master +Switched to branch 'master' +``` + +Ezután pedig mergeljük át a `master`-re az `atnevezes` ágat. + +```shell-session +git merge atnevezes +``` + +Ekkor meg fog nyílni a szövegszerkesztőnk, ugyanis egy +új mentéspontot fogunk készíteni a `master` águnkra. +A feladott merge üzeneten nem kell módosítanunk, teljesen +jó úgy. + +A merge lefut és láthatjuk mi is történt: + +``` +$ git merge atnevezes +Merge made by the 'recursive' strategy. + ") Hozz\303\241adtam a txt kiterjeszt\303\251st a gy\303\274m\303\266lcskosar f\303\241jlhoz" | 248 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ + gyumolcskosar => gyumolcskosar.txt | 0 + hordo => hordo.txt | 0 + 3 files changed, 248 insertions(+) + create mode 100644 ") Hozz\303\241adtam a txt kiterjeszt\303\251st a gy\303\274m\303\266lcskosar f\303\241jlhoz" + rename gyumolcskosar => gyumolcskosar.txt (100%) + rename hordo => hordo.tx (100%) +``` + +Most egy újabb `git log --graph --oneline --all`-al ezt láthatjuk: + +``` +* e4b5d9d (HEAD -> master) Merge branch 'atnevezes' +|\ +| * c040bc1 (atnevezes) Adtam kiterjesztést a hordónak +| * 07ac740 Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz +* | c8496bf Tettem a kosaramba szőlőt +|/ +* 996698c jegyzeteim ignorálása +* 36552bc Hoztunk egy hordót is +* a8a9b26 Raktam bele egy körtét +* 2a685fc Készítettem egy gyümölcskosarat +``` + +Ez a bizonyos `merge commit` egyszerre mutat a két ág +tartalmára. + +#### Merge conflict + +Mi van akkor ha ketten egyszerre ugyanazt változtatjuk? +Úgy döntöttünk, hogy pálinkát szeretnénk főzni Rickel, +szóval a hordóba teszünk ízlés szerint valami +gyümölcsöt. +Gyerünk át a saját águnkra, de egy paranccsal. +Ezt a `-b` kapcsolóval tudjuk +elérni a `git checkout` mellett. + +``` +$ git checkout -b blint +``` + +Most egy újabb `git branch` kiadásával már látható, hogy +3 ággal rendelkezünk. + +``` + atnevezes +* blint + master +``` + +Tegyünk bele a `hordo.txt`-be egy nekünk tetsző gyümölcsöt. + +``` +korte +``` + +Ezt mentsük is el, de most picit csaljunk és ne rakjuk +`staged`-be, hanem azonnal mentsük el `-a` kapcsolót használva. + +``` +$ git commit -a -m "Raktam a hordóba körtét" +``` + +Úgy döntött a szomszéd Rick, hogy ugyanebbe a hordóba +szilvát szeretne rakni. Menjünk át a master ágra és +tegyük meg ott. + +Tehát: +`hordo.txt`: +``` +szilva +``` + +Ezt is mentsük el. + +``` +$ git commit -a -m "Raktam szilvát a hordóba" +``` + +Most ha megnézzük a gráfunkat újra, akkor láthatjuk is, +hogy mi a helyzet: + +``` +$ git log --graph --oneline --all + +* 85744ad (HEAD -> master) Raktam szilvát a hordóba +* e4b5d9d (blint) Merge branch 'atnevezes' +|\ +| * c040bc1 (atnevezes) Adtam kiterjesztést a hordónak +| * 07ac740 Hozzáadtam a txt kiterjesztést a gyümölcskosar fájlhoz +* | c8496bf Tettem a kosaramba szőlőt +|/ +* 996698c jegyzeteim ignorálása +* 36552bc Hoztunk egy hordót is +* a8a9b26 Raktam bele egy körtét +* 2a685fc Készítettem egy gyümölcskosarat +``` + +Na és akkor most mergeljünk be a master-re a módosításaink. + +``` +$ git merge blint +Auto-merging hordo.txt +CONFLICT (content): Merge conflict in hordo.txt +Automatic merge failed; fix conflicts and then commit the result. +``` + +Oh! Merge conflict keletkezett. +Nem kell megijedni, nem a világ vége és a git segít ahol tud. + +Az a helyzet, hogy egyszerre ugyanazt a sort módosítottuk és a git nem tudta +eldönteni mit tegyen. Megtartsa az egyiket vagy mindkettőt? Mégis mi legyen? + +Ezeket a kérdéseket nekünk kell megválaszolnunk. + +Először nézzük meg, mi a státusz. + +``` +$ git status +On branch master +You have unmerged paths. + (fix conflicts and run "git commit") + (use "git merge --abort" to abort the merge) + +Unmerged paths: + (use "git add <file>..." to mark resolution) + both modified: hordo.txt + +no changes added to commit (use "git add" and/or "git commit -a") +``` + +Az van, hogy ilyenkor a git beírja a fájlunkba mind a két branch változásait +és utána azt várja tőlünk, hogy átalakítsuk a fájlt, majd pedig azt elmentsük. +Szóval nem kell megijedni, csak átírjuk mi kell nekünk és mentünk egyet. + +Nézzük meg mi van a fájlunkban. + +```hordo.txt +<<<<<<< HEAD +szilva +======= +korte +>>>>>> blint +``` + +Mit is jelent ez? Ketté szedte az bejövő adatokat a git arra ahová mergeltünk +(`HEAD`) és amit mergeltünk (`blint`). Köztük pedig egy sor "======="-t láthatunk. +Itt már csak átírjuk a fájlt ahogy szeretnénk, hogy kinézzen. + +``` +korte +``` + +Nézzük meg mi a státusz ezután: + +``` +git status +On branch master +You have unmerged paths. + (fix conflicts and run "git commit") + (use "git merge --abort" to abort the merge) + +Unmerged paths: + (use "git add <file>..." to mark resolution) + both modified: hordo.txt + +no changes added to commit (use "git add" and/or "git commit -a") +``` + +Továbbra is azt írja, amit az imént. Amíg nem commitoljuk a módosításunk, +addig ezt is fogja. Hát akkor mentsünk. + +``` +git commit -a -m "blint branch mergelve és konflikt megoldva" +``` + +Nézzük meg hogy néz ki a gráfunk ezután. + +``` +* 7341274 (HEAD -> master) blint + branch mergelve és konflikt megoldva +|\ +| * 6d6d1ac (blint) Raktam a hordóba körtét +* | 41f1c05 Raktam szilvát a hordóba +|/ +* 366140d Merge branch 'atnevezes' +... +``` + +Tehát most a merge commitunk egyben a konfliktusok megoldását is tartalmazza. +Nem elképesztő? Innentől már csak együtt kell dolgozni, margeknél a konfliktusokat +megoldani. + +Semmi extra effortot nem fog igényelni egy hasonló elvégzése. diff --git a/app/docs/guides/training/git/07_basics.md b/app/docs/guides/training/git/07_basics.md new file mode 100644 index 0000000000000000000000000000000000000000..684eb25a65042f9bd265ef8ad6ec41bfb3ebd57d --- /dev/null +++ b/app/docs/guides/training/git/07_basics.md @@ -0,0 +1,121 @@ +# Alapok és SSH kulcs + +### Alapok + +Hogyan lehet a mi `.git` mappánkat megosztani a nagyvilággal? + +Több módja is van ennek, például akár egy .git mappát +is lelehet magunkhoz klónozni. + +A `git clone <elérési út>` parancsot használjuk ahhoz, hogy +valahonnan lehúzzunk egy git repo-t. + +Ha például csak egy mappára utalunk, aminek a neve +`awesome_project.git`: + +``` +$ git clone --bare awesome_project awesome_project.git +Cloning into bare repository 'awesome_project.git'... +done. +``` + +Ezt akár kirakhatjuk egy fájlszerverre és onnan megoszthatnánk. + +Következő szint, mikor weben keresztül szedjük le a nekünk +kellő repo-t. Ilyenkor HTTP protokollt használhatunk, +ami hasonló az előzőhöz és olyan, mint mikor egy fájlt +töltünk le egy oldalról. + +``` +$ git clone https://git.sch.bme.hu/blintmester/git-presentation.git +Cloning into 'git-presentation'... +remote: Enumerating objects: 173, done. +remote: Counting objects: 100% (173/173), done. +remote: Compressing objects: 100% (114/114), done. +remote: Total 173 (delta 65), reused 155 (delta 47), pack-reused 0 +Receiving objects: 100% (173/173), 291.34 KiB | 1.22 MiB/s, done. +Resolving deltas: 100% (65/65), done. +``` + +Ez szimplán fogja és készít nekünk egy olyan repository-t, mint +amit az előzőkben csináltunk kézzel. +Lemásolja a .git mappát, majd pedig onnan kiszedi a megfelelő +dolgokat a mi `work tree`-nkbe. + +### SSH + +Másik protokoll amit tudunk használni az az SSH. +Ez azért nagyon jó, mert ha ezen keresztül szedünk le, +akkor nem kell minden alkalommal a github, gitlab +felhasználónkba belépnünk egy repo-n való dolgozáskor. + +Ahhoz, hogy ilyet tudjunk csinálni viszont SSH kulcsot kell +készítenünk. +Ennek annyi a trükkje, hogy rakunk a saját gépünkre egy +privát kulcsot és a távoli szerverre egy publikus kulcsot, +vagy bárhova ahova szeretnénk. +Ezután mikor az adott szerverre felakarunk menni, valamit +csinálni ott, akkor előtte a szerver leauthentikál minket +és egy kulcs csere után elkezdhetünk vele kommunikálni. +Az authentikáció lépése nagy vonalakban: + +- Szerver publikus kulcsal letitkosít valamit és elküldi nekünk +- Ezt amit elküld csak a privát kulccsal lehet kibontani, + ezt mi elvégezzük +- A kibontott adatok közt lesz egy másik kulcs, mellyel + titkosítva elküldjük a szervernek ami kell az authentikációhoz +- A szerver kibontja, látja hogy minden oké és + megtörténik a kulcs csere + +Ezután áttérnek egy másik módszerre amihez már mindkét oldalt +megvan a megfelelő kulcs és titkosítva küldik egymásnak +az adatokat + +Nagyon király dolog, mivel gyors, hatékony és nem kell +jelszót beírogatni minden művelet közt + +#### Saját SSH kulcs + +###### Linuxon / MacOS-en + +1. Terminált megnyitjuk +2. Generálunk egy SSH kulcsot + `ssh-keygen -t rsa -b 4096` +3. Alapértelmezett helyre mentjük +4. Megadunk egy jelszót ha szeretnénk + _Ha valaki megszerzi a privát kulcsunk nem tudja használni + a jelszó beírása nélkül_ + +Adjuk hozzá az SSH agent-ünkhöz. + +1. Elindítjuk az agent-et ha még nem ment volna + `$ eval "$(ssh-agent -s)"` + `Agent pid 59566` +2. Hozzáadjuk az új kulcsunk + `ssh-add ~/.ssh/id_rsa` + +Végezetül a publikus kulcsot feltöltjük például githubra + +A publikus kulcs helye: `~/ssh/id_rsa.pub` + +###### Windowson + +1. Git Bash-t megnyitjuk +2. Generálunk egy kulcsot + `ssh-keygen -t rsa -b 4096` +3. Elmentjük az alapértelmezett helyre +4. Jelszó adunk hozzá ha szeretnénk + +Hozzá adjuk az SSH agent-ünkhöz + +1. Elindítjuk az agent-et ha még nem ment volna + `$ eval $(ssh-agent -s)` + `> Agent pid 59566` +2. Hozzáadjuk az új kulcsunk + `ssh-add ~/.ssh/id_rsa` + +Végezetül a publikus kulcsot feltöltjük például githubra + +A publikus kulcs helye: `~/ssh/id_rsa.pub` + +Forrás: [docs.github.com](https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent) diff --git a/app/docs/guides/training/git/08_segedlet.md b/app/docs/guides/training/git/08_segedlet.md new file mode 100644 index 0000000000000000000000000000000000000000..35f4253cab74554b645a26e2b1bac3034a71d1bd --- /dev/null +++ b/app/docs/guides/training/git/08_segedlet.md @@ -0,0 +1,142 @@ +# Segédlet + +## 0. GitSCH + +Mutassátok meg neki a [GitSCH](https://git.sch.bme.hu/)-t. Némá', ez olyan mint a [GitLab](https://gitlab.com/)! + +### Dolgok felfedezése + +Először kattintsanak a jobb felső sarokban a profiljukra, és nézzék meg miket látnak ott. + +<div style={{textAlign: 'center'}}> +<img src={require('./img/1.png').default} alt="Jobb felső sarok izé" /> +</div> + +#### Profil + +Érdemes nekik megmutatnotok a saját profilotokon, hogy rákattintotok a felhasználónevetekre, és behozza, mennyire voltatok aktívak az elmúlt időben git szerint, személyes projekteket, etc... nekik ez nem biztos hogy annyira szép lesz, hiszen valószínűleg nem használták még. + +#### Státusz + +0 perces művelet, de tök szórakoztató, állíttatsatok be velük státuszt. Mutassátok meg, hogy emojikat is be lehet állítani, etc... Legyenek kicsit vidámak tőle! + +#### Beállítások + +Az edit profile és a preferences-t is megmutathatjátok nekik, DE ne ezek beállításával húzzátok el az időtöket. + +Esetleg a témát beállíttathatjátok velük, az nem sok idő és nem fáj, cserébe kényelmes. + +### SSH kulcs hozzáadása a profilhoz + +Ami fontos, legalábbis kényelmes, de nagyon, adjanak hozzá egy ssh-kulcsot a profiljukhoz. Ezt a `preferences/SSH Keys` alatt találják meg. +Akinek nincs meg teljesen az SSH, és az SSH kulcs fogalma, azt irányítástok át a [linuxos előadás](http://home.sch.bme.hu/~mikewashere/linux/#/) ide [passzoló fejezetéhez](http://home.sch.bme.hu/~mikewashere/linux/#/m%C3%A1sodik%20vide%C3%B3#t%C3%A1voli-hozz%C3%A1f%C3%A9r%C3%A9s-ssh), illetve meséljétek el nekik röviden mi is ez, (hogyan működik) hogyan kell használni. +Gites előadás [ide kapcsolódó része](http://home.sch.bme.hu/~blintmester/git/#/guide/remote/1_basics). + +## 1. új repó + +Kérjetek meg valakit (NE TI LEGYETEK!), hogy hozzon létre egy új projektet. Ezen vezessétek végig a csapatot, jó lenne, ha screensharingel menne végig, a többiek is lássák. + +### Lépések + +Ennek a lépései: + - nagy kék gomb (new project) névvel + - bal felső opció (create blank project) + - töltsétek ki a field-eket + - projekt név lehet bármit, lehet benne ékezet, szóköz, etc... + - figyeljék meg, hogy `project slug` hogyan változik a beírt név hatására + - mondjátok el, hogy a `project slug`-ot is módosíthatják még ilyenkor (később már asszem nem lehet, vagy naaaagyon fájdalmas) + - meséljétek el a láthatóság fontosságát + - private: nem látja más, csak te, meg akiket meghívsz, hogy lássák (ÍGY hozzák létre először, később majd fogjuk állítani!) + - internal: sch domainen belül (akinek van hozzáférése a GitSCH-hoz) mindenki látja + - public: mindenki látja, Özséb néni is Romániából + - az `Initialize repository with a README`-t tanulják meg, hogy kényelmes nem bekapcsolni, ekkor a Git* segít a létrejött projek lokális bekonfigurálásában (egész hasznos, mi?) + - hozzátok létre a projektet + +### Tagok hozzáadása + +Ahhoz hogy más is hozzáférjen a repohoz, hozzá kell adni a többieket, hiszen private-ként hoztuk létre. +Tegyük is meg, baloldalt a sávon a Members-re kattintva kapunk egy felületet, ahol ezt megtehetjük. + +Láthatjuk, hogy embereket, valamint csoportokat is hozzá tudunk adni. Ha valaki megkérdezi, mesélhettek a csoportokról is, vagy irányítsátok hozzám. + +Kérjétek meg a projekt tulajdonost, hogy vegyen fel Titeket és engem mint owner, hogy tudjunk segíteni ha szükség lenne rá, valamint a többieket, mint developer/maintainer, ezt már döntsék el ők maguk. + +A [role-ok](https://git.sch.bme.hu/help/user/permissions)ról itt olvashatnak, azért egész beszédes. + +## 2. Klónozzás + +Klónozzák le a repót, ehhez segítséget nyújt a GitLab is, valamint itt van egy leírás: + +``` +git clone git@git.sch.bme.hu:blintmester/projektem.git +cd projektem +touch README.md +git add README.md +git commit -m "add README" +git push -u origin master +``` + +Persze cseréljétek ki a dolgokat az aktuális projektre! + +## 3. Pythonos webszerver + +Készítsetek el közösen egy basic pythonos webszervert. Segédletnek használhatjátok Lackó [pythonos segédletét](https://home.sch.bme.hu/~rlacko/python3/#/guide/10_exercise#2-%C3%ADrj%C3%A1tok-meg-a-saj%C3%A1t-hanyadikh%C3%A9tvan-apitokat). + +Persze ne lemásoljátok, hanem használjátok fel okosan! + +Itt egy mintamegoldás: + +```python +import flask + +app = flask.Flask(__name__) + +app.config["DEBUG"] = True + +@app.route('/', methods=['GET']) +def home(): + return """ + <html> + <head> + <meta charset="utf-8" /> + <title>Gites meme</title> + </head> + <body> + <h1>Hello Git</h1> + <p>Ez egy basic oldal</p> + </body> + </html> + """ +app.run() +``` + +Fontos, vagy venv-el, vagy lokálisan tegyék fel a flask-et, hogy tudják használni. + +Kipróbálni a `python3 git.py`-al tudják, megnézni az eredményt pedig a `http://localhost:5000/`. + +## 4. branch-ek + +Hozzanak létre saját branch-eket. Ezt a [videó](https://youtu.be/gU0yjbZR8lY)ban és a [jegyzet ](https://home.sch.bme.hu/~blintmester/git)ben is olvashatják, hogy kell. + +```shell-session +$ git checkout -b <username vagy amit akartok> +``` + +## 5. jogok megint + +Állítsák be, hogy a repo internal szinten elérhető legyen. + +### Feladat + +Mindenki készítsen egy nagyon egyszerű html-t a saját branch-én, commitolják, és a legvégén merge-elhetitek. + +## 6. Házi feladat + +### Alap + +Kaptok egy [repo](https://git.sch.bme.hu/KSZKepzes/cicas-kepek)-t, azt el kell forkolni, és saját képet kell feltölteni. + +### Expert + +Készítsetek pipeline-t a gyakorlat repo-jához, és csináljatok autodeploy-t a linux-os vm-etekre! + diff --git a/app/docs/guides/training/git/09_hazi.md b/app/docs/guides/training/git/09_hazi.md new file mode 100644 index 0000000000000000000000000000000000000000..dec1a34f696a8a9a3a13425f0a1bb5d35f582821 --- /dev/null +++ b/app/docs/guides/training/git/09_hazi.md @@ -0,0 +1,46 @@ +# Házi segédlet + +<Note type="warning" label="Megjegyzés"> + +Nem kell gitlab runner-t telepítenetek a képződős vm-etekre! Nem kell azt bekötni git.sch-ra! + +A feladat annyi, hogy hozzatok létre egy `.gitlab-ci.yml`-t! + +</Note> + +## The easy way (recommended) + +Használjatok proxyjumpot és agent forward-ot! + +```shell-session +$ ssh -A -J userem@proxyjump.host userem@ahova-szeretnem-deployolni.host +``` + +Itt az `-A` az AgentForward miatt kell, a `-J` pedig hogy jumpolni akartok, azaz egy közbülső szerverről *elugrotok* a célba. + +Az `scp`-nek is van ám kapcsolója, amivel meg lehet adni, hogy ssh-agent-et továbbítson, valamint a proxyjumpot is be lehet neki állítani, keressétek ki, ha nagyon elakadnátok, akkor keressetek meg. + +Egy példa [`.gitlab-ci.yml`](https://gitlab.com/disappointment-industries/lamp/-/blob/master/.gitlab-ci.yml)-t belinkelek, de először próbáljátok megoldani magatoktól! + +## Kerberosos authentikáció (amúgy ezt ne akarjátok) + +<Note type="tip" label="Tipp"> + +Ne akarjátok nagyon! + +</Note> + +```shell-session +$ cd /afs/sch.bme.hu/home/<Schaccod>/.system/ +$ ktutil +> ktutil: addent -password -p username@domain.com -k 1 -e rc4-hmac + Password for username@domain.com: [enter your password] +> ktutil: addent -password -p username@domain.com -k 1 -e aes256-cts + Password for username@domain.com: [enter your password] +> ktutil: wkt username.keytab +> ktutil: quit + +``` + +Ha ezt választottátok mégis, akkor ennek nézzetek utánna jobban, mondjuk [ezt](https://stackoverflow.com/a/55826172/10044393) érdemes még elolvasni. +A git-es előadás [repo](https://git.sch.bme.hu/blintmester/git-presentation)jában ha megnézitek a [`.gitlab-ci.yml`](https://git.sch.bme.hu/blintmester/git-presentation/-/blob/master/.gitlab-ci.yml)-t, abból tudtok még segítséget találni. \ No newline at end of file diff --git a/app/docs/guides/training/git/_category_.json b/app/docs/guides/training/git/_category_.json new file mode 100644 index 0000000000000000000000000000000000000000..188c868e62a58f6c78cad11ab9f97b621aa208e3 --- /dev/null +++ b/app/docs/guides/training/git/_category_.json @@ -0,0 +1,5 @@ +{ + "label": "Verziókezelés", + "position": 2 +} + \ No newline at end of file diff --git a/app/docs/guides/training/git/img/1.png b/app/docs/guides/training/git/img/1.png new file mode 100644 index 0000000000000000000000000000000000000000..0d14b032b4c3ce3795c91d68faf21e394c5085bd --- /dev/null +++ b/app/docs/guides/training/git/img/1.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c0898b52e7403411fce3838f34b09575798bb2c68eed0f08b681a293945a3c4e +size 14545 diff --git a/app/docs/guides/training/git/img/basic-branching.png b/app/docs/guides/training/git/img/basic-branching.png new file mode 100644 index 0000000000000000000000000000000000000000..e958221203c49c50bb721c500240b7a464f1ba20 --- /dev/null +++ b/app/docs/guides/training/git/img/basic-branching.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b9a4bd9fd2c7fd81a9c7cabb666b323f383a611e6f8cbd357cd78c6622d564ca +size 15060 diff --git a/app/docs/guides/training/git/img/commit-and-tree.png b/app/docs/guides/training/git/img/commit-and-tree.png new file mode 100644 index 0000000000000000000000000000000000000000..91e4d227655412d502828641f770bc08104272a1 --- /dev/null +++ b/app/docs/guides/training/git/img/commit-and-tree.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0964b5b819a591404b748b09113fcc9227ac114c258d5483031a0d7a0c096a32 +size 22842 diff --git a/app/docs/guides/training/git/img/commits-and-parents.png b/app/docs/guides/training/git/img/commits-and-parents.png new file mode 100644 index 0000000000000000000000000000000000000000..bbc2cf53263d359a9d516d1d8d7115d5d66d637c --- /dev/null +++ b/app/docs/guides/training/git/img/commits-and-parents.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9a91e848c1f36c61a8135d1dd02dc8ee4f9959ac5c46ad4ea48b702daf0a5843 +size 19774 diff --git a/app/docs/guides/training/git/img/git_lifecycle.png b/app/docs/guides/training/git/img/git_lifecycle.png new file mode 100644 index 0000000000000000000000000000000000000000..cc90d9a3b569bab743aadacb94bc695b0ce24f72 --- /dev/null +++ b/app/docs/guides/training/git/img/git_lifecycle.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cad26e07b7519a5ce11b6d551e3740a0f5f6b381b0c0632d4c9181af37bfaa28 +size 13727 diff --git a/app/docs/guides/training/git/img/me.jpg b/app/docs/guides/training/git/img/me.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4b57f90506201373b6994db9e3ab95340eb946a9 --- /dev/null +++ b/app/docs/guides/training/git/img/me.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eaa34e431ba444d44af87e7de1e36b8fdc88a0c6955508b6da03d6cc86b64d5f +size 6501562 diff --git a/app/docs/guides/training/git/img/tree_awesome.png b/app/docs/guides/training/git/img/tree_awesome.png new file mode 100644 index 0000000000000000000000000000000000000000..7ba94e33f138667f54d46fa64f7e3107332f116f --- /dev/null +++ b/app/docs/guides/training/git/img/tree_awesome.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:647e537d41d24655f34f85e3e41286f9782a4a8d635c2a2a3be9bb1f4a335ea1 +size 44957 diff --git a/app/docs/guides/training/git/img/tree_with_one_branch.png b/app/docs/guides/training/git/img/tree_with_one_branch.png new file mode 100644 index 0000000000000000000000000000000000000000..e4e3938708788519909aa8acc4d7859df2263dfc --- /dev/null +++ b/app/docs/guides/training/git/img/tree_with_one_branch.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:06ef07f228c18d613f9006a7a66022464cdfb9fcd637cb6377e05c9c0c191050 +size 34629 diff --git a/app/docs/guides/training/git/img/vcstype_central.png b/app/docs/guides/training/git/img/vcstype_central.png new file mode 100644 index 0000000000000000000000000000000000000000..6caccf8a8e9241f5da871f494f73425b611e91ff --- /dev/null +++ b/app/docs/guides/training/git/img/vcstype_central.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5f7ec73cb95207e4c9522a92dcab8cc5695c3093ec64a690c79cedbd50978db5 +size 22810 diff --git a/app/docs/guides/training/git/img/vcstype_distributed.png b/app/docs/guides/training/git/img/vcstype_distributed.png new file mode 100644 index 0000000000000000000000000000000000000000..43871fca96c911f5397838c9df07dc3f977ad3ee --- /dev/null +++ b/app/docs/guides/training/git/img/vcstype_distributed.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69855c253ee15655331b03889f56db3e566fbf1f0e31e8b82973a3287747728e +size 26657 diff --git a/app/docs/guides/training/git/img/vcstype_local.png b/app/docs/guides/training/git/img/vcstype_local.png new file mode 100644 index 0000000000000000000000000000000000000000..25e44933d9ae6231d9f719546ad6eb5fea47f67c --- /dev/null +++ b/app/docs/guides/training/git/img/vcstype_local.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2198f766c6708cb55c45a97b3fefdf00f7a53108c6c72c6859c93e22065c14bd +size 20255 diff --git a/app/docs/guides/training/linux/01_elso_video.md b/app/docs/guides/training/linux/01_elso_video.md new file mode 100644 index 0000000000000000000000000000000000000000..46eb81a2530b532ccb328f1dd77ff324a238224c --- /dev/null +++ b/app/docs/guides/training/linux/01_elso_video.md @@ -0,0 +1,820 @@ +# 1. videó segédlet + +## Mi is a Linux + +A [Linux](https://www.kernel.org/) önmaga csak egy kernel, nem tartalmaz egy programot sem. +Amikor Linuxról beszélünk, általában GNU/Linux-ra gondolunk, +ami azt jelenti, hogy Linux kernelen futtatunk [GNU +rendszerprogramokat](https://www.gnu.org/software/coreutils/) és könyvtárakat. + +<Note type="warning" label="Megjegyzés"> + +Ha Linux-ot mondunk ebben a segédletben, sok esetben itt is +GNU/Linux-ra gondolunk + +</Note> + +<Note type="tip" label="Extra infó"> + +Vannak nem GNU programokat használó Linux [disztribúciók](#disztribúciók) is, +pl: az Alpine Linux vagy az Android + +</Note> + +### Disztribúciók + +Nem lenne túl kényelmes kézzel lefordítani és helyére másolni +minden programot (beleértve a fordítót és kernelt is). +Ennek a problémának az áthidalására születtek meg +a Linux disztribúciók, vagy röviden disztrók. + +Egy disztró feladatai: +- telepítés megkönnyítése + - telepítő diszk, akár grafikus telepítővel + - telepítéskor alap rendszerprogramok feltelepítése +- használat megkönnyítése + - csomagkezelő biztosítása a könnyű és biztonságos + programtelepítéshez + - értelmes alapbeállítások programokhoz +- segítségkérés + - minden disztrónak van fóruma, soknak wikije is, + így az esetleges hibákra gyorsan lehet találni megoldást + +[Nagyon sok disztró van](https://upload.wikimedia.org/wikipedia/commons/8/83/Linux_Distribution_Timeline_27_02_21.svg), +mindenki meg tudja találni a magának megfelelőt. + +Az [Ubuntu](https://ubuntu.com/) a legelterjedtebb disztró, +a továbbiakban is Ubuntut fogunk használni, de a legtöbb dolog +univerzális. + +### GUI + +Linux-ra van nagyon sokféle GUI shell (vagy Desktop Environment, DE), +a legelterjedtebbek a +Gnome, KDE, Xfce. + +<div style={{textAlign: 'center'}}> +<img src={require('./pics/ubuntu.jpg').default} alt="Gnome Ubuntun" /> +</div> + +<div style={{textAlign: 'center'}}> +<img src={require('./pics/kde.jpg').default} alt="KDE" /> +</div> + +<div style={{textAlign: 'center'}}> +<img src={require('./pics/xfce.png').default} alt="Xfce" /> +</div> + +<div style={{textAlign: 'center'}}> +<img src={require('./pics/elementary.png').default} alt="elementary OS" /> +</div> + +Az asztali számítógépre szánt disztrókon általában alapértelmezetten +telepítve van valamilyen DE. + +## CLI, terminál, shell + +<Note type="tip" label="Megjegyzés"> + +Ez a fejezet sok fogalmat tartalmaz, kérlek **_ne_** magold be ezeket. +Csupán annyi a célja a fejezetnek, hogy akik nemigazán +használtak CLI-t, azoknak bemutasson pár alapelemet. + +A fő cél, hogy értsd, tudd használni; nem az, hogy tudd a definíciókat. + +</Note> + +### CLI +**C**ommand **L**ine **I**nterface, +egy felhasználói felület, ami alapvetően szövegesen kommunikál a userrel. +Szöveg be → szöveg ki. +Ennél sokkal bővebben nem hiszem, +hogy bárkinek is be kell mutatni, hogy mit jelent. + +### Terminál +Ez jeleníti meg a karaktereket és adja meg a programnak a beírt karaktereket. +Régebben külön céleszközök voltak, ma már programok. + +### Shell +Egy olyan CLI program, amibe parancsokat lehet bepötyögni és a shell +a megfelelő programokat elindítva és összekapcsolva<sup>(erről később lesz szó)</sup> +lefuttatja azt. + +### Pár ismertebb shell + +#### `sh` +[Bourne shell](https://en.wikipedia.org/wiki/Bourne_shell) +(a készítőjének neve után) vagy +[POSIX shell](https://en.wikipedia.org/wiki/Unix_shell) + +Egy butább shell, ami megtalálható minden UNIX-szerű számítógépen. +Jó régen, az eredeti UNIX-hoz hozták létre a Bourne shell-t, ami később +[bővítve](https://en.wikipedia.org/wiki/KornShell), majd specifikálva lett a +[POSIX](https://en.wikipedia.org/wiki/POSIX) szabványban. + +#### `bash` +**B**ourne-**a**gain **sh**ell, dupla szójáték. 😉 + +A [bash](https://en.wikipedia.org/wiki/Bash_(Unix_shell)) az alapértelmezett shell a Linux disztribúciók +túlnyomó többségén. Később ezzel fogunk dolgozni. +Kellően okos és többnyire elvárható, hogy ott legyen mindenhol, ahova beléptek. +A hatalmas elterjedtsége (és nagy kompatibilitása) miatt esett erre a választás. + +#### `zsh` +[zsh](https://en.wikipedia.org/wiki/Z_shell) vagy Z shell. + +Gyakorlatilag a bash kibővítése, +a legtöbb Linuxos disztrón csomagkezelővel telepíthető, +emellett macOS-en alap shell. Minden bash parancs működik itt is, +de nem minden zsh parancs működik bash-ben. + +#### `fish` +[fish](https://en.wikipedia.org/wiki/Fish_(Unix_shell)), +**f**riendly **i**nteractive **sh**ell. + +Különlegessége, hogy kifejezetten felhasználóbarátnak van tervezve, +alapbeállításokkal is nagyon kényelmes használni. +Azonban *nem* POSIX shell, vagyis a következőekben bemutatott parancsok +nem feltétlenül működnek benne. + +<Note type="warning" label="Figyelem"> + +Innentől bash-ről lesz szó. Ha olyat olvasol, hogy +"írjuk be a shellünkbe", akkor ott a "bashünkre" gondolunk. + +</Note> + + +### Hogy is néz ki? + +TL;DR: sokféleképpen. +Például sok helyen így néz ki az alap beállításokkal: +```shell-session +[mike@thinkyboi ~]$ ls *.pdf +mozilla.pdf +[mike@thinkyboi ~]$ ls *.txt +asd.txt ize.txt metrics.txt pcr2.txt pcrtouse.txt pcr.txt +[mike@thinkyboi ~]$ ls *.txt | grep rt +pcrtouse.txt +[mike@thinkyboi ~]$ +``` +Ez mit is mutat? +- `[mike@thinkyboi ~]$`: a prompt + - mutatja, hogy a `mike` user van belépve + - a `thinkyboi` nevű számítógépre + - éppen a `~` mappában vagyunk + - sima user jogosultságokkal `$` +- `ls *.pdf`: egy parancs, ami minden .pdf végű fájlt kilistáz +- `ls *.txt`: egy parancs, ami minden .txt végű fájlt kilistáz +- `ls *.txt | grep rt`: egy parancs, ami minden .txt végű fájlt kilistáz, mely nevében megtalálható az "rt" + +Ne ijedjünk meg az ismeretlen fogalmaktól, erről mind lesz szó bővebben. + +### Pár shelles fogalom + +- parancs: egy program, a kapcsolói, és egyéb opciók + - általában: `parancs --kapcsoló -k fájl.txt` + - kapcsolók: programok különböző funkcióit + lehet velük ki-be kapcsolni + - pl: + - `ls -la`: kilistázza a mostani mappa tartalmát + - `ls`: listázó program + - `-l`: listaként jelenjen meg + - `-a`: rejtett fájlokat is megjeleníti + - `ls -a en_mappam`: kilistázza az `en_mappam` mappa tartalmát + a rejtett fájlokkal együtt + - `ip address`: kiírja a gépünk IP címeit + - `cd en_mappam`: belelép az `en_mappam` mappába + - `cd ..`: egy mappával feljebb lép +- redirekció (`>`, `<`) + - `>`: átirányítja egy program kimenetét egy fájlba + - `<`: egy program konzolos bemenetét egy fájlból olvassa + - pl: + - `ls > fajlok.txt`: a jelenlegi mappában létrehozza + a `fajlok.txt` fájlt és beleírja a jelenlegi + mappában lévő fájlok és mappák neveit +- pipe (`|`) + - egy program kimenetét beleírja egy másik program bemenetébe + - pl: + - `ls -l *.txt | grep alma`: + - `ls -l *.txt`: kiírja a jelenlegi mappában lévő + txt fájlok neveit, ez lesz a grep bemenete + - `grep alma`: kiszűri a bemenetén kapott szövegből + azokat a sorokat, amikben nem szerepel az alma szó + - → kilistázza azokat a txt fájlokat, amelyek nevében + szerepel az, hogy alma. + +- shell execution `"$(parancs)"` + - egy program kimenetét beleteszi egy stringbe + - pl: + - `echo a mappa tartalma: $(ls)` + + +#### [Egyéb hasznos shell cuccok](https://devhints.io/bash) + +### Szövegszerkesztők + +- `nano`: egyszerű szövegszerkesztő + - terminál alján kiír pár támogatott billentyűkombinációt + - használat: + - `nano <fájl>` + - irkáljunk + - `CTRL+S` ment + - `CTRL+X` bezár +- `vi`: bonyolultabb picivel, de többet tud + - `vim`: vi improved, továbbfejlesztés + - `nvim`: neovim, vim továbbfejlesztés + - használat + - `vim <fájl>` + - `i` (insert mode) + - irkáljunk + - `ESC` (normal mode) + - `:wq` (parancs: write, quit) + - a fejlettebb funkcióit nem mutatjuk most be + +### Fontosabb shell parancsok/programok + +- `ls`: listáz +- `man <parancs>`: "manual", felhasználói útmutató programokhoz + - pl: `man ip` +- `cat <fájlok>`: fájlokat ír ki +- `less`: a bemenetén kapott szöveget görgeti, így lassabban +lehet olvasni, mint ahogy jön +- `echo <szöveg>`: kiír egy szöveget +- `cd <mappa>`: mappát vált +- `mkdir <mappa>`: mappa létrehozása +- `rm <fájlok>`: fájlok törlése +- `rmdir <mappa>`: mappa törlése +- `touch <fájl>`: üres fájl létrehozása + +## Csomagkezelés + +### Mi a csomag? + +**Gyakorlatilag egy program, amit tudsz telepíteni.** +*Bővebben:* +A különböző programokat nevezzük csomagoknak (package), melyek +a bináris (futtatható) fájlokon kívül különböző konfigurációs fájlokat és +a program más programoktól való függőségeit is tartalmazza. + +### Hogyan telepítsünk csomagokat? + +A programokat telepíthetjük [kézzel](http://www.linuxfromscratch.org/lfs/downloads/stable/LFS-BOOK-10.1.pdf) (8.2-es fejezet), de ez +általában nehézkes művelet és nem valami hatékony, +ezért csomagkezelőt (package manager) szoktunk használni a csomagok +telepítéséhez. A csomagkezelő egy egyszerű program, mellyel biztonságosan telepíthetünk, +frissíthetünk, eltávolíthatunk és kereshetünk csomagokat. +Egy csomagkezelő frissen tudja tartani a rendszert, kezeli a függőségeket és ütközéseket. + +Mi az apt nevű csomagkezelőt fogjuk használni a továbbiakban. + +```shell-session {highlight: [1, 3, 12, 24, 33, 42, 51, 59, 61]} +[patrik@patrik-laptop ~]$ cowsay test +bash: cowsay: command not found +[patrik@patrik-laptop ~]$ sudo apt update +Get:1 http://archive.ubuntu.com/ubuntu focal InRelease [265 kB] +Get:2 http://security.ubuntu.com/ubuntu focal-security InRelease [109 kB] +[...] +Fetched 17.2 MB in 2s (11.2 MB/s) +Reading package lists... Done +Building dependency tree +Reading state information... Done +1 package can be upgraded. Run 'apt list --upgradable' to see it. +[patrik@patrik-laptop ~]$ sudo apt search cowsay +Sorting... Done +Full Text Search... Done +cowsay/focal 3.03+dfsg2-7 all + configurable talking cow + +cowsay-off/focal 3.03+dfsg2-7 all + configurable talking cow (offensive cows) + +xcowsay/focal 1.5-1 amd64 + Graphical configurable talking cow + +[patrik@patrik-laptop ~]$ sudo apt install cowsay +Reading package lists... Done +Building dependency tree +Reading state information... Done +[...] +After this operation, 46.4 MB of additional disk space will be used. +Do you want to continue? [Y/n] y +[...] +Setting up cowsay (3.03+dfsg2-7) ... +[patrik@patrik-laptop ~]$ cowsay test + ______ +< test > + ------ + \ ^__^ + \ (oo)\_______ + (__)\ )\/\ + ||----w | + || || +[patrik@patrik-laptop ~]$ sudo apt upgrade +[...] +The following packages will be upgraded: + libzstd1 +1 upgraded, 0 newly installed, 0 to remove and 0 not upgraded. +Need to get 237 kB of archives. +After this operation, 0 B of additional disk space will be used. +Do you want to continue? [Y/n] y +[...] +[patrik@patrik-laptop ~]$ sudo apt remove cowsay +[...] +The following packages will be REMOVED: + cowsay +0 upgraded, 0 newly installed, 1 to remove and 0 not upgraded. +After this operation, 93.2 kB disk space will be freed. +Do you want to continue? [Y/n] y +Removing cowsay (3.03+dfsg2-7) ... +[patrik@patrik-laptop ~]$ cowsay test +bash: cowsay: command not found +[patrik@patrik-laptop ~]$ +``` + +<Note type="success" label="Infó"> + +Ahogy látod, kihagytunk részeket a parancsok kimenetéből. +Ez azért van, mert nem fér bele értelmesen a doksiba. +A videón látható ezek kimenete, de bátran próbáljátok ki ti is. + +</Note> + +Az `apt update` paranccsal frissíthetjük az apt adatbázisát, mely a +csomagok elérhetőségéről tárol adatokat. + +Az `apt search a_csomag_neve` paranccsal a csomagkezelő megkeresi a +hasonló nevű csomagokat és kilistázza azokat. + +Az `apt install a_csomag_neve` paranccsal a megadott csomagot telepíti a +csomagkezelő, ha azt megtalálja. + +Az `apt upgrade` paranccsal a telepített csomagokhoz elérhető frissítéseket +telepíti a csomagkezelő. + +Az `apt remove a_csomag_neve` paranccsal a megadott csomag távolítható el. + +### Különböző csomagkezelők + +A különböző Linux disztribúciók különböző csomagkezelőket használnak, ilyenek például +az alábbi táblázatban található csomagkezelők is. Néhány csomagkezelő disztribúcióhoz van kötve, +azonban egyre jobban kezdenek elterjedni a disztribúcióktól független csomagkezelők is. + +- `apt`: Debian és Ubuntu alapú disztrókon +- `dnf`: Red Hat (alapú) disztrók: Fedora, CentOS, Red Hat Enterprise Linux +- `pacman`: Arch Linux, Manjaro +- `flatpak` és `snap`: disztrófüggetlen, mindenhol működik, ha [feltelepítjük](https://flatpak.org/setup/) egy +disztróspecifikus csomagkezelővel + +| parancs | apt | dnf | pacman | snap | flatpak | +|---|---|---|---|---|---| +| telepítés | install | install | -S | install | install | +| adatbázis frissítése | update | check-update | -Sy | automatikus | a frissítéssel együtt ez is megtörténik (update) | +| frissítés | upgrade | upgrade | -Syu | automatikus (ha kézzel akarod: refresh) | update | +| törlés | remove | remove | -R | nincs ilyen | nincs ilyen | +| törlés beállításokkal | purge | nincs ilyen | -Rns | remove | uninstall | +| keresés | search | search | -Ss | find | search | + +--- + +<Note type="danger" label="Légy óvatos"> + +Itt szó lesz két azonos nevű, de különböző dologról. +- `root` user +- `root` mappa + +A kettő teljesen független egymástól, ne keverjük össze. + +</Note> + +## Hogyan néz ki a Linux fájlrendszere? + +UNIX-on a mappastruktúra a `/`-ből indul, ellenben a Windows-zal, ahol a +meghajtók külön betűket kapnak (`C:\ `, `D:\ `, stb). +Emellett UNIX-on a mappaelválasztó a `/`, míg Windows-on a `\ `. + +Itt a rendszermeghajtó lesz a `/` <sup>(root, ejtsd: rút)</sup>, +minden mappa innen indul. Erre fel lehet csatolni (`mount`-olni) más meghajtókat is, +tetszőleges mappákba. Például, ha a rendszerünket egy SSD-re telepítjük, majd egy +HDD-t felcsatolunk a `/mnt/HDD` mappába, akkor: +- a `/home/béla/random_file.txt` az SSD-n lesz +- a `/mnt/HDD/cucc/random_file.txt` pedig a merevlemezen lesz + +Ennek a megközelítésnek egy nagy előnye, hogy bármit tehetünk bárhova, +például - az előző példát folytatva - ha azt szeretnénk, hogy a fájljaink +a merevlemezen legyenek, de a rendszer és a programok az SSD-n, hogy felcsatoljuk +a merevlemezt a `/home`-ra, így a userek fájljai a merevlemezre kerülnek. + +### [Könyvtárak](https://www.linux.com/training-tutorials/linux-filesystem-explained/) + +<Note type="tip" label="Megjegyzés"> + +A fájlrendszer mappastruktúráját nem kell tudni fejből, +elég ha tudod, hogy a konfigurációs fájlokat a `/etc`-ben szokás keresni +és a userek a `/home/<username>` alatt élnek. + +</Note> + +- `/bin`: "binaries", futtatható programok +- `/boot`: bootloader, kernel és egyéb indításhoz szükséges fájl<sup>erről később lesz szó</sup> +- `/dev`: "devices", eszközök<sup>erről később lesz szó</sup> +- `/etc`: konfigurációs fájlok +- `/home`: userek fájljai +- `/lib`: "libraries", programok futásához szükséges könyvtárak +- `/lib64`: 64 bites `/lib` +- `/mnt`: felcsatolt meghajtók +- `/opt`: "optional programs", néhány program itt él <sup>(olyan programok, amik nem kötődnek a rendszerhez)</sup> +- `/proc`: futó programokról információk<sup>erről később lesz szó</sup> +- `/root`: a [root user](#user-ek-és-groupok) home-ja +- `/run`: rendszerindításonként újraépül, a futó szolgáltatásokhoz való csatlakozásban segít <!-- TODO --> +- `/sbin`: "system binaries", rendszerprogramok +- `/srv`: "servers", a gépen futtatott szerver programok fájljai +- `/sys`: "system", hardvereléréshez kell<sup>erről később lesz szó</sup> +- `/tmp`: "temporary", ideiglenes fájlok, RAM-ban tartva +- `/usr`: "user installed", a telepített csomagok pakolnak ide fájlokat +- `/var`: szolgáltatások tárhelyei + +### Speciális "mappák" + +- `.`: a jelenlegi mappa + - `././././.`: ez is a jelenlegi mappa, mert a jelenlegi mappa jelenlegi mappájának [...] jelenlegi mappája +- `..`: az egy szinttel feljebb lévő mappa + - `/..` == `/`, root fölé nem lehet menni +- `~`: a mi userünk home mappája + - `~béla`: a `béla` user home mappája + +## Jogosultságkezelés + +A UNIX permission rendszer elemei: +- user-ek +- group-ok +- módok + +Minden fájl és mappa egy user-hez és egy group-hoz tartozik, +vagyis a user és a group annak a fájlnak és mappának a tulajdonosa. +Minden fájlra és mappára meg lehet adni, hogy mi legyen +a módja (továbbiakban permissionjei), ezek: +- `user`: a birtokló user tudja-e: + - `r`: read, olvasni + - `w`: write, írni + - `x`: futtatni (ha fájl) vagy a tartalmát listázni (ha mappa) +- `group`: a birtokló csoport tagjai tudják-e: + - `r`: olvasni + - `w`: írni + - `x`: futtatni vagy listázni +- `others`: bárki más tudja-e: + - `r`: olvasni + - `w`: írni + - `x`: futtatni vagy listázni + +<Note type="tip" label="Extra infó"> + +Van két extra permission, a `setuid` és `setgid`. +Ezekkel meg lehet adni, hogy egy program a tulajdonos nevében +vagy tulajdonos csoport nevében fusson. +Ezt a permission-t használja pár program, amit mindennapi userek +is kell, hogy tudjanak futtatni, de mégis kell valami, csak nagyobb +jogosultsággal elérhető funkció bele. + +Ezen kívül van egy ma már nem igazán használt permission is, +a "sticky bit", erről [itt](http://permissions-calculator.org/info/#sticky-bit) olvashatsz. + +</Note> + +Mindezek számok alapján vannak tárolva, +de a programok okosan feloldják nevekre ezeket. + +### User-ek és groupok + +Egy user az pont ugyanaz, mint aminek elképzelted, +egy felhasználó, aki tud programokat futtatni. + +Egy különleges felhasználó a `root`, ő a főfelhasználó (super-user), +az ő nevében lehet csak a rendszerbeállításokat módosítani, +ez a Windows-os "Rendszergazda" vagy "Adminisztrátor" megfelelője. + +Minden userhez tartozik egy ugyanolyan nevű group is, azonban egy +user több groupban is benne lehet. + +### Példa a jogosultságokra + +Alul látható, hogy hogy néz ki egy listázás `ls`-sel. +A permission-ök user, group, other sorrendben követik egymást. + +<Note type="tip" label="Tip"> + +A különböző fájlokhoz/mappákhoz tartozó magyarázatokat +lenyíló szövegként tettük az oldalra, hogy össze tudd +nézni a magyarázatot és a shell-t. + +</Note> + +```shell-session +[mike@thinkyboi permissions]$ ls -la -tr +total 0 +drwxr-xr-x 3 mike mike 120 Mar 11 13:19 . +drwxrwxrwt 21 root root 640 Mar 11 04:20 .. +-rw-r----- 1 root ftp 0 Mar 11 13:37 egyik +-rw-r--r-- 1 mike daemon 0 Mar 11 13:37 másik +-rwx------ 1 mike mike 0 Mar 11 13:37 harmadik +drwxr-xr-x 2 mike daemon 40 Mar 11 13:37 negyedik +-rwsr-sr-x 1 mike mike 0 Mar 11 13:37 ötödik +``` + +<details> +<summary> + <code>ls -la -tr</code> +</summary> + +- `ls`: fájlokat és mappákat listázó program +- `-la` + - `l`: listaként + - `a`: a `.`-tal kezdődő fájlokat is +- `-tr` + - `t`: idő szerint rendezve + - `r`: visszafelé rendezve + +(ezt meg lehetne adni úgy is, hogy `ls -latr`, +de az olvashatóság kedvéért mi külön vettük) + +</details> + +<details> +<summary> + <code>.</code> (a jelenlegi mappa, vagyis `permissions`, ami a prompt-ból látszik) +</summary> + + - `d`: egy mappa + - `rwx`: a birtokos usernek (`mike`) van joga: + - olvasni + - írni + - listázni + - `r-x`: a birtokos csoportnak (szintén `mike`) van joga: + - olvasni + - listázni + - `r-x`: mindenki másnak van joga: + - olvasni + - listázni + - → bárki meglesheti mi van benne, de csak `mike` + tehet bele dolgokat + +</details> + +<details> +<summary> +<code>..</code> (az eggyel e fölött lévő mappa) +</summary> + + - `d`: egy mappa + - `rwx`: `root` user mindent csinálhat vele + - `rwx`: `root` group mindent csinálhat vele + - `rwt`: mindenki más is bármit csinálhat, de mivel a mappa + "sticky", így ha valakinél meg van nyitva valami benne, azt + más nem piszkálhatja + - `t` == `x` + sticky bit + +</details> + +<details> +<summary> +<code>egyik</code> +</summary> + + - egy file (nem `d`-vel kezdődik a permission sor) + - `rw-`: `root` user tudja olvasni és írni + - `r--`: `ftp` csoport tagjai tudják olvasni + - `---`: a többiek nem tudnak semmit csinálni vele + +</details> + +<details> +<summary> +<code>másik</code> +</summary> + + - egy file + - `mike` tudja olvasni és írni + - `daemon` csoport tagja tudják olvasni + - mindenki más is tudja olvasni + +</details> + +<details> +<summary> +<code>harmadik</code> +</summary> + + - egy file + - `mike` tudja írni, olvasni, futtatni + - `x`: mivel lehet futtatni, ez vagy egy program, + vagy hibát dob, ha megpróbáljuk futtatni + +</details> + +<details> +<summary> +<code>negyedik</code> +</summary> + + - egy mappa + - mindenki tudja olvasni és listázni, de csak `mike` tud benne + fájlt létrehozni + + +</details> + +<details> +<summary> +<code>ötödik</code> +</summary> + +- `rws`: `mike` tudja futtani, és ha futtatva van bárki által, + akkor is `mike` usere nevében fut + - `s` == `x` + setuid +- `r-s`: `mike` csoport tagjai tudják olvasni és futtatni, és + ha bárki futtatja, akkor is kap `mike` csoporttagságot a program +- `r-x`: bárki futtathatja +- → bárki olvashatja és futtathatja, és ha futtatja, akkor + `mike` nevében fog futni a program + +</details> + + +### Jogosultságok megváltoztatása + +Vannak különböző parancsok, melyek segítségével megváltoztathatjuk mind a user-ek, +mind a group-ok, mind a többi felhasználó jogosultságait, sőt megváltoztathatjuk a +tulajdonosokat is. + +#### `chmod` + +Segítségével megváltoztathatjuk az állományok hozzáférési jogait (change mode). +Ha nem a saját fájljaink, mappáink jogait szeretnénk módosítani, ahhoz `sudo` is kell. + +Ehhez megadjuk a `chmod` után, hogy kire vonatkozzon (user, group, others), +megadjuk, hogy hozzáférést szeretnénk-e adni vagy elvenni akarjuk azt, +valamint magát az állományt. A különböző paraméterek a következőek: + + +`u` - user, a birtokló user + +`g` - group, a birtokló csoport tagjai + +`o` - others, bárki más + +`+` hozzáad egy jogot + +`-` eltávolítja a jogot + +`r` - read, olvasási jog + +`w` - write, írási jog + +`x` - execute, végrehajtási jog + +Például: + +`chmod u+x <fájlnév vagy mappanév>` itt a user kap listázási vagy futtatási jogot. + +`chmod g-w <fájlnév vagy mappanév>` itt a group-nak szűnik meg az írási joga + +Ugyanezen konvenció alapján működik mindegyik parancs. + +Kicsit szemléletesebben: + +``` +patrik@ubuntu:~/Documents$ ls -la +total 8 +drwxr-xr-x 2 patrik patrik 4096 Mar 18 19:38 . +drwxr-xr-x 15 patrik patrik 4096 Mar 17 16:20 .. +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 linux.pdf +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 pálinka.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:38 pörkölt.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 randomsorok.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 recept.txt +patrik@ubuntu:~/Documents$ chmod o+w pörkölt.txt +patrik@ubuntu:~/Documents$ ls -la +total 8 +drwxr-xr-x 2 patrik patrik 4096 Mar 18 19:38 . +drwxr-xr-x 15 patrik patrik 4096 Mar 17 16:20 .. +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 linux.pdf +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 pálinka.txt +-rw-rw-rw- 1 patrik patrik 0 Mar 18 19:38 pörkölt.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 randomsorok.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 recept.txt +patrik@ubuntu:~/Documents$ +``` + +Itt a `chmod o+w pörkölt.txt` parancs segítségével mások kapnak írási jogot +a pörkölt.txt fájlhoz, ami eddig nem volt nekik. +A `-rw-rw-r--` megváltozott `-rw-rw-rw-` -ra. +Az others-re az utolsó három karakter vonatkozik, ezek közül +a második változott meg, míg eddig egy `-` jel volt, vagyis nincs joga hozzá, +most pedig `w` lett, vagyis van hozzá joga. + +Ha egyszerre szeretnénk jogot adni a user-nek, group-nak, others-nek vagy elvenni, +valamint ha többféle joggal szeretnénk ezt, akkor több paramétert is megadhatunk egy parancsban. +Ezt kétféleképpen is megtehetjük: + + - `chmod` `u` `g` `o` közül a kiválasztottak `+` vagy `-` az `r` `w` `x` közül a + kiválasztottak. Vagyis a bal oldalra írjuk kinek a jogait szeretnénk módosítani, + középre, hogy elvenni vagy adni szeretnénk, jobb oldalra pedig, hogy mely jogokat. + +``` +patrik@ubuntu:~/Documents$ chmod ug-rw pörkölt.txt +patrik@ubuntu:~/Documents$ ls -la +total 8 +drwxr-xr-x 2 patrik patrik 4096 Mar 18 19:38 . +drwxr-xr-x 15 patrik patrik 4096 Mar 17 16:20 .. +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 linux.pdf +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 pálinka.txt +-------rw- 1 patrik patrik 0 Mar 18 19:38 pörkölt.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 randomsorok.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 recept.txt +patrik@ubuntu:~/Documents$ +``` + + - Másik módja, hogy a különböző műveleteket vesszővel elválasztva adjuk meg. + +``` +patrik@ubuntu:~/Documents$ chmod u+rw,g+r,o-rw pörkölt.txt +patrik@ubuntu:~/Documents$ ls -la +total 8 +drwxr-xr-x 2 patrik patrik 4096 Mar 18 19:38 . +drwxr-xr-x 15 patrik patrik 4096 Mar 17 16:20 .. +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 linux.pdf +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 pálinka.txt +-rw-r----- 1 patrik patrik 0 Mar 18 19:38 pörkölt.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 randomsorok.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 recept.txt +patrik@ubuntu:~/Documents$ +``` + +#### `chown` +Segítségével megváltoztatható az állományok tulajdonosa +(a change the owner rövidítése). +Egy fájl vagy mappa tulajdonosának megváltoztatásához `sudo` jog kell. + +``` +patrik@ubuntu:~/Documents$ sudo chown mike recept.txt +[sudo] password for patrik: +patrik@ubuntu:~/Documents$ ls -la +total 8 +drwxr-xr-x 2 patrik patrik 4096 Mar 18 19:38 . +drwxr-xr-x 15 patrik patrik 4096 Mar 17 16:20 .. +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 linux.pdf +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 pálinka.txt +-rw-r----- 1 patrik patrik 0 Mar 18 19:38 pörkölt.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 randomsorok.txt +-rw-rw-r-- 1 mike patrik 0 Mar 18 19:37 recept.txt +patrik@ubuntu:~/Documents$ +``` + +#### `chgrp` + +A parancs lehetőséget ad arra, egy fájl vagy mappa csoportját megváltoztassuk +(a change group rövidítése). +Normál felhasználó akkor módosíthatja a fájl vagy mappa csoportját, +ha a régi és új csoportnak is tagja, ellenkező esetben a `sudo` parancs is szükséges. + +``` +patrik@ubuntu:~/Documents$ sudo chgrp mike recept.txt +patrik@ubuntu:~/Documents$ ls -la +total 8 +drwxr-xr-x 2 patrik patrik 4096 Mar 18 19:38 . +drwxr-xr-x 15 patrik patrik 4096 Mar 17 16:20 .. +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 linux.pdf +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 pálinka.txt +-rw-r----- 1 patrik patrik 0 Mar 18 19:38 pörkölt.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 randomsorok.txt +-rw-rw-r-- 1 mike mike 0 Mar 18 19:37 recept.txt +patrik@ubuntu:~/Documents$ +``` + +<Note type="tip" label="Tip"> + +A csoportot nem csak az előbbi `chgrp` paranccsal lehet módosítani, hanem +a `chown` paranccsal is. +Ehhez a következőt kell tenni: + +`sudo chown username:groupname fájl` + +```shell-session +patrik@ubuntu:~/Documents$ ls -la +total 8 +drwxr-xr-x 2 patrik patrik 4096 Mar 19 19:18 . +drwxr-xr-x 15 patrik patrik 4096 Mar 17 16:20 .. +-rw-r----- 1 patrik patrik 0 Mar 18 19:38 pörkölt.txt +-rw-rw-r-- 1 mike mike 0 Mar 18 19:37 recept.txt +patrik@ubuntu:~/Documents$ sudo chown patrik:patrik recept.txt +[sudo] password for patrik: +patrik@ubuntu:~/Documents$ ls -la +total 8 +drwxr-xr-x 2 patrik patrik 4096 Mar 19 19:18 . +drwxr-xr-x 15 patrik patrik 4096 Mar 17 16:20 .. +-rw-r----- 1 patrik patrik 0 Mar 18 19:38 pörkölt.txt +-rw-rw-r-- 1 patrik patrik 0 Mar 18 19:37 recept.txt +patrik@ubuntu:~/Documents$ +``` + +</Note> \ No newline at end of file diff --git a/app/docs/guides/training/linux/02_masodik_video.md b/app/docs/guides/training/linux/02_masodik_video.md new file mode 100644 index 0000000000000000000000000000000000000000..21b9c2c75821c258ea67bc5b547f8bf0aaf83089 --- /dev/null +++ b/app/docs/guides/training/linux/02_masodik_video.md @@ -0,0 +1,667 @@ +# 2. videó segédlet + + +## UNIX alapelvek + +<Note type="tip" label="Magyarázat"> + +A Linux egy [UNIX-szerű](https://en.wikipedia.org/wiki/Unix-like) rendszer, ugyanazokra az alapelvekre épül, +ezért beszélünk most róluk. Amiket ebben a fejezetben olvashattok egyaránt +vonatkozik a UNIX-ra és a Linux-ra is. + +</Note> + +Vannak különböző [elvek](https://en.wikipedia.org/wiki/Unix_philosophy), amik alapján egy UNIX operációs rendszert megalkotnak. +A Linux is ezen elvek alapján készült. + +Ezen elvek közül néhány: + + - Moduláris szemlélet figyelembe vétele + - Válaszd szét a működést az előírásoktól, szabályzatoktól + - Egy program legyen kicsi, egyszerű, átlátható, mégis robosztus + - Szükség esetén, inkább az adatstruktúra legyen összetettebb, ne a program + - Számolj a potenciális felhasználók felkészültségével + - Kerüld el a szükségtelen mellékhatásokat + - Ha a program összeomlik, mérhető, elemezhető legyen + - A fejlesztő ideje fontosabb a gép idejénél + - A programok kézi kódolása helyett írj absztrakt programot, amely megalkotja a kódot + - Írj rugalmas és nyílt programokat + - A programok, protokollok bővíthetőek legyenek + + +### KISS (Keep it Simple, Stupid) + +A legtöbb rendszer akkor működik a legjobban, ha azt egyszerűnek hagyják, +és nem teszik egyre bonyolultabbá. +Ezért az egyszerűségnek a tervezés egyik fő céljának kell lennie, +és kerülni kell az olyan összetételeket, amelyekre nincs szükség. + +### Everything is a file + +Ez azt jelenti, hogy a felhasználó fájljai, a rendszer könyvtárkatalógusai +és a rendszerhez csatlakoztatott hardver eszközök, mint fájlok +egységesen kezelhetőek. + +Ezen megközelítés előnye, hogy ugyanazokat az eszközöket és API-kat +széles körben fel tudjuk használni. Többféle fájltípus van, de bármelyik +megnyitásakor egy állományleíró, ún. file descriptor jön létre. Így a fájl útvonala +használható egy címkezelő rendszerként, és a file descriptor pedig a bájtfolyam +I/O interfésze. De a file descriptor ugyanakkor létrehozható pipe +és hálózati socketek megvalósítására is. Ennél fogva azt is mondhatnánk: +Minden is egy file descriptor. + +Kiegészítésképp, létezik egy sor pszeudo és virtuális fájlkezelő rendszer amelyek +képesek bizonyos folyamatokról, rendszer információkról adatokat +megjeleníteni, hiszen ezek is egyetlen fájl hierarchiába vannak csatolva. + +### Architektúra + +A UNIX rendszereknél az operációs rendszer részei +jóval függetlenebbek egymástól, mint mondjuk egy Windows alapú rendszernél. + +*De mik is ezek a részek?* + +#### Bootloader +Ez a legelső program, ami betöltődik, amikor a gépet bekapcsoljuk. +A feladata a kernel és pár [alapvető driver és program](https://en.wikipedia.org/wiki/Initial_ramdisk) +betöltése RAM-ba, majd a kernel elindítása. +Dual boot esetén lehetőséget ad arra, hogy kiválasszuk melyik OS-t +szeretnénk elindítani. +*Az Ubuntu által használt bootloader a Grub.* + +#### Kernel +A kernel feladata a hardverek bekurblizása és kezelése, +erőforrások szétosztása, jogosultságok behajtása +és sok gyakran használt, +hardverközeli teendőhöz függvényeket biztosítani +(pl: hálózati csomagküldés, adatblokk beolvasása lemezről, stb.). +*Az Ubuntu által használt kernel a Linux.* + +#### Init rendszer +Az init rendszer feladata az operációs rendszer szolgáltatásainak +elindítása, felügyelete és kezelése. +Ez indítja el a hálózatkezelőt és bejelentkezőablakot is például. +*Az Ubuntu által használt init rendszer a systemd.* + +#### Userland +A userland egy nehezen behatárolható dolog. Igazából minden, +az operációs rendszerrel jövő, nem kernelben élő szoftver a userland része. +Ebbe beletartozik az init rendszer is, de mégse venném ide, mivel +annak elég jól elkülönülő határai vannak. + +Egy UNIX rendszer userland-ja alatt általában +az alapvető programokat értjük, amik a rendszer és rajta futó +programok használatához szükségesek. +Ilyen pélául az `ls`, `cat`, `sh`, `cp`, `rm`, stb. +*Az Ubuntu GNU userland-et használ.* + + +## A többfelhasználós rendszer működése, kezelése + +https://linuxhint.com/ubuntu-user-management/ + +### Felhasználók kezelése + +#### Létrehozás +A `useradd` parancs segítségével hozhatunk létre új felhasználót. + +`sudo useradd -G kszksok -s /bin/bash -m mike` +- `sudo`: mert root hozhat csak létre új usert +- `useradd`: ez a parancs hoz létre usert +- `-G kszksok`: a `kszksok` csoport tagja legyen az új user +- `-s /bin/bash`: a bash legyen a shellje a usernek +- `-m`: legyen home mappája +- `mike`: az új user neve + +Ezután az új felhasználónak be kell állítani egy jelszót, ezt +a `sudo passwd mike` parancs kiadása után állítható be. + +<Note type="warning" label="Megjegyzés"> +A `passwd` nem ír semmit a terminálra miközben írjuk a jelszót, +de ne kételkedjünk, hogy nem látunk semmit, attól még íródik. +</Note> + +<Note type="tip" label="Extra infó"> +Ubuntun és egyéb Debian alapú disztrókon megtalálható egy +`adduser` script is, ami szintén userek létrehozására van. +Használata kicsit egyszerűbb, azonban nincs minden rendszeren. +Használata: + +```shell-session +mike@mike-elementary:~$ sudo adduser patrik +[sudo] password for mike: +Adding user `patrik' ... +Adding new group `patrik' (1001) ... +Adding new user `patrik' (1001) with group `patrik' ... +Creating home directory `/home/patrik' ... +Copying files from `/etc/skel' ... +Enter new UNIX password: +Retype new UNIX password: +passwd: password updated successfully +Changing the user information for patrik +Changing the user information for patrik +Enter the new value, or press ENTER for the default + Full Name []: Fodor Patrik + Room Number []: 6969 + Work Phone []: +36306942069 + Home Phone []: + Other []: Jógyerek amúgy +chfn: 'Jógyerek amúgy' contains non-ASCII characters +Is the information correct? [Y/n] y +mike@mike-elementary:~$ sudo adduser patrik sudo +Adding user `patrik' to group `sudo' ... +Adding user patrik to group sudo +Done. +mike@mike-elementary:~$ +``` + +</Note> + +```shell-session +patrik@ubuntu:/home$ useradd -m -s /bin/bash mike +useradd: Permission denied. +useradd: cannot lock /etc/passwd; try again later. +patrik@ubuntu:/home$ sudo useradd -m -s /bin/bash mike +patrik@ubuntu:/home$ sudo passwd mike +New password: +Retype new password: +passwd: password updated successfully +patrik@ubuntu:/home$ +``` +#### Törlés +`sudo userdel <username>`parancs segítségével +eltávolíthatunk egy új felhasználót a rendszerből. +Azonban ez csak a felhasználót törli a hozzá tartozó `home` mappát +és egyéb fájlokat nem, ezt az `-r` kapcsoló megadásával tehetjük meg. + +```shell-session +patrik@ubuntu:/home$ sudo userdel -r mike +[sudo] password for patrik: +patrik@ubuntu:/home$ +``` + +<Note type="tip" label="Extra infó"> +A `userdel` Debian-os párja a `deluser`. +</Note> + +#### Jelszó megváltoztatása + +`sudo passwd <username>` parancs segítségével megváltoztatható +egy-egy felhasználó jelszava. Akkor ha csak annyit írunk, hogy passwd, azzal +a bejelentkezett felhasználó jelszavát változtatjuk meg. + +```shell-session +patrik@ubuntu:/home$ sudo passwd mike +[sudo] password for patrik: +New password: +Retype new password: +passwd: password updated successfully +patrik@ubuntu:/home$ passwd +Changing password for patrik. +Current password: +New password: +Retype new password: +passwd: password updated successfully +patrik@ubuntu:/home$ passwd +Changing password for patrik. +Current password: +New password: +Retype new password: +Password unchanged +New password: +Retype new password: +You must choose a longer password +New password: +Retype new password: +Bad: new and old password are too similar +passwd: Authentication token manipulation error +passwd: password unchanged +patrik@ubuntu:/home$ +``` + +A jelszó megadásánál van egy pár követelmény, +aminek meg kell felelni. Ilyenek azok is, melyek fentebb láthatóak. +A jelszó nem egyezhet meg a korábbival, nem lehet ahhoz nagyon hasonló, +hosszúnak kell lennie, ha túl egyszerű +azt se engedi (1234, asdasd...stb.). + +#### Root jog "szerzése" + +`usermod -aG sudo <username>` parancs segítségével hozzáadjuk a +megadott felhasználót a sudo nevű csoporthoz. +*Hint: `-aG`, mint add group.* +```shell-session +patrik@ubuntu:/home$ sudo usermod -aG sudo mike +``` +Vagy a létrehozás során adjuk meg a plusz group-ot +```shell-session +patrik@ubuntu:/home$ useradd -m -G sudo -s /bin/bash mike +``` + +### Csoportok kezelése + +`groups username` parancs megadásával megtudhatjuk egy felhasználó, +mely csoportoknak a tagjai. A `groups` parancs önmagában a bejelentkezett felhasználó +csoportjait mutatja meg. + +```shell-session +patrik@ubuntu:~$ groups mike +mike : mike sudo +patrik@ubuntu:~$ groups patrik +patrik : patrik adm cdrom sudo dip plugdev lpadmin lxd sambashare +patrik@ubuntu:~$ groups +patrik adm cdrom sudo dip plugdev lpadmin lxd sambashare +``` + +#### Létrehozás + +`sudo groupadd <groupname>` parancs segítségével lehet létrehozni egy új +csoportot. + +```shell-session +patrik@ubuntu:~$ sudo groupadd almafa +[sudo] password for patrik: +patrik@ubuntu:~$ sudo cat /etc/group | grep alma +almafa:x:1002: +patrik@ubuntu:~$ +``` + +<Note type="tip" label="Extra infó"> +Debian alapú disztrókon a `sudo addgroup almafa` is működik. +</Note> + +A `/etc/group` fájlban található a csoportok listája és azok tulajdonságai. +sudo cat /etc/group | grep alma: + - `sudo` csak root joggal olvasható vagy írható a `group` fájl + - 'cat' kiírja egy fájl tartalmát, ez most a group, vagyis a csoportok listája + - a `|` segítségével a `cat` kimenetét odaadjuk egy másik program bemenetének (jelen esetben a `grep`) + - a `grep` a bemenetére kapott szövegből az `"alma"` (rész)szót tartalmazókra fog szűrni + +Ennek a segítségével leellenőrézhetó egy a csoport valóban létrejött. + +#### Törlés + +`sudo groupdel <groupname>` parancs segítségével eltávolíthatunk egy csoportot. + +```shell-session +patrik@ubuntu:~$ sudo groupdel almafa +[sudo] password for patrik: +patrik@ubuntu:~$ sudo cat /etc/group | grep alma +patrik@ubuntu:~$ +``` + +<Note type="tip" label="Extra infó"> +Debian alapú disztrókon a `sudo delgroup almafa` is működik. +</Note> + +Hasonlóan az előző ellenőrzéshez itt is ellenőrizhető, +hogy valóban eltávolításra került-e a csoport. +Mivel a kimeneten nem jelent meg semmi, megállapítható, hogy nincs alma szót +tartalmazó group. + +#### Felhasználók hozzáadása + +`sudo usermod -aG <groupname> <username>` parancs segítségével felhasználót +lehet hozzáadni a megadott csoporthoz. +A `groups` parancs segítségével megnézhetjük, hogy tényleg megtörténik a hozzáadás. + +```shell-session +patrik@ubuntu:~$ sudo usermod -aG almafa mike +[sudo] password for patrik: +patrik@ubuntu:~$ groups mike +mike : mike sudo almafa +patrik@ubuntu:~$ +``` + +Hozzáadni egy felhasználót egy csoporthoz nem csak a `usermod` +segítségével lehet, hanem a `gpasswd` paranccsal is. + +``` +patrik@ubuntu:~$ groups mike +mike : mike sudo +patrik@ubuntu:~$ sudo gpasswd -a mike almafa +[sudo] password for patrik: +Adding user mike to group almafa +patrik@ubuntu:~$ groups mike +mike : mike sudo almafa +patrik@ubuntu:~$ +``` + +`sudo gpasswd -a <username> <groupname>`: +- A `gpasswd` egy parancs, mely segítségével különböző műveleteket lehet + végrehajtani a csoportokon. +- `-a` kapcsoló, mely megadja, hogy hozzáadni szeretnénk egy felhasználót. (add) +- `username` a felhasználó, akit szeretnénk Hozzáadni +- `groupname` a csoport, amelyikhez szeretnénk hoozáadni a felhasználót + +<Note type="tip" label="Extra infó"> +Debian alapú disztrókon a `sudo adduser mike almafa` is működik. +</Note> + + +#### Felhasználók eltávolítása a csoportból + +`sudo gpasswd -d <username> <groupname>` parancs segítségével törölhetünk +egy felhasználót a csoportból. + +``` +patrik@ubuntu:~$ sudo gpasswd -d mike almafa +[sudo] password for patrik: +Removing user mike from group almafa +patrik@ubuntu:~$ groups mike +mike : mike sudo +``` + +<Note type="tip" label="Extra infó"> +Debian alapú disztrókon a `sudo deluser mike almafa` is működik. +</Note> + +Pontosan ugyanazt kell itt csinálni, mint amikor a `gpasswd` segítségével +hozzáadunk egy felhasználót, csupán a kapcsoló eltérő `-d`. + +## Init rendszer + +A UNIX operációs rendszerben vannak olyan feladatok, amiket a +háttérben (gyakran "észrevétlenül") futó folyamatok végeznek el. +Ezeket a programokat daemon folyamatoknak is nevezik. +Mivel ezeket a folyamatokat nem a terminálról indítják, +általában a rendszerindításkor automatikusan indulnak el. + +Egy szolgáltatás nem más, mint egy szerver alkalmazás vagy alkalmazások összesége , amelyek +a háttérben futnak, és a feladatukra várnak, vagy már valamilyen fontos feladatot +(taskot) látnak el. Őket gyakorlatilag csak processzek közti kommunikáció során +hívják meg. + +Manapság a démonok (daemon) és a szolgáltatások (service) alatt ugyanazt a +fogalmat értjük, mivel ezek a programok egyszerre démonok és szolgáltatások is. + +Az init rendszer a legelső (és egyetlen) program, démon, amelyet a kernel indulása után elindít. +Az ő feladata, hogy minden szükséges szolgáltatást, démont elindítson. + +### systemd + +A systemd egy init rendszer, +amely nagyon elterjedt Linux rendszereken, ma már szinte az +összes disztribúció ezt használja, mivel számos előnye van elődeihez képest. + +Feladata, hogy a Linux kernel +indulása után előkészítse az induló szolgáltatásokat +és a systemd felel nagyon +sok olyan háttérmunkáért, amiről sok esetben nem is tudunk, +de szükségesek a rendszerhez, vagy egy-egy feladat indításához. + +Megjegyzés: a `.service`-t nem kötelező kiírni + +Vannak olyan programok, amit szeretnénk, a rendszerrel együtt indítani, +a rendszerrel együtt szabályosan leállítani, valamint +igény szerint kézzel indítani, leállítani, újraindítani. + +#### `systemctl`: a systemd-t piszkáló, vele kommunikáló eszköz + +`systemctl status <service_neve.service>` Szolgáltatás státusza + +`systemctl list-unit-files` Létező szolgáltatások kilistázása + +`systemctl start <service_neve.service>` Szolgáltatás indítása + +`systemctl stop <service_neve.service>` Szolgáltatás leállítása + +`systemctl restart <service_neve.service>` Szolgáltatás újraindítása + +`systemctl enable <service_neve.service>` Indítás a rendszerrel + +`systemctl disable <service_neve.service>` Ne induljon a rendszerrel + +#### `journalctl`: naplózó, logkezelő service + +`journalctl` Naplók megjelenítése + +`journalctl -xe` Hibák megjelenítése + +`journalctl -u <service_neve>` Egy szolgáltatás logjainak megjelenítése + +`journalctl --since "1 hour ago"` Egy időpont óta történt események + +#### Saját program használata szolgáltatásként + +Ha szeretnénk saját programjainkat szolgáltatásként használni, +ezt megtehetjük, ha írunk a programhoz egy fájlt. + +``` +[Unit] +Description=Leírás a programhoz + +[Service] +Type=simple +ExecStart=program_elérési_útja + +[Install] +WantedBy=multi-user.target +``` + +Ezt a fájlt bele kell rakni a `/etc/systemd/system` mappába, ezután a `systemctl` paranccsal + + +## Hálózat alapszintű konfigurálása + +<Note type="tip" label> + +Az esetek többségében ezt nem kell nekünk kézzel megcsinálni, +hanem network manager megoldja helyettünk + +</Note> + +### Parancsok a hálózat konfigurálásához + +- `ip a`, `ip address`: Kilistázza a hálózati interfészeket és azoknak az IP címeit + +```shell-session +patrik@ubuntu:~$ ip a +1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000 + link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 + inet 127.0.0.1/8 scope host lo + valid_lft forever preferred_lft forever + inet6 ::1/128 scope host + valid_lft forever preferred_lft forever +2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000 + link/ether 00:0c:29:c9:db:ba brd ff:ff:ff:ff:ff:ff + altname enp2s1 + inet 172.16.228.135/24 brd 172.16.228.255 scope global dynamic noprefixroute ens33 + valid_lft 1684sec preferred_lft 1684sec + inet6 fe80::e85d:ab8d:2f03:2fa9/64 scope link noprefixroute + valid_lft forever preferred_lft forever +patrik@ubuntu:~$ +``` + +- `ip r`, `ip route`: Kilistázza a (kernel) [routing table](https://en.wikipedia.org/wiki/Routing_table) tartalmát + +```shell-session +patrik@ubuntu:~$ ip r +default via 172.16.228.2 dev ens33 proto dhcp metric 100 +169.254.0.0/16 dev ens33 scope link metric 1000 +172.16.228.0/24 dev ens33 proto kernel scope link src 172.16.228.135 metric 100 +patrik@ubuntu:~$ +``` + +- ip beállítása: `sudo ip addr add IP_cím/hálózati_maszk dev interfész` + +```shell-session {highlight: [14]} +patrik@ubuntu:~$ sudo ip addr add 192.168.4.44/24 dev ens33 +patrik@ubuntu:~$ ip a +1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000 + link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 + inet 127.0.0.1/8 scope host lo + valid_lft forever preferred_lft forever + inet6 ::1/128 scope host + valid_lft forever preferred_lft forever +2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000 + link/ether 00:0c:29:c9:db:ba brd ff:ff:ff:ff:ff:ff + altname enp2s1 + inet 172.16.228.135/24 brd 172.16.228.255 scope global dynamic noprefixroute ens33 + valid_lft 1378sec preferred_lft 1378sec + inet 192.168.4.44/24 scope global ens33 + valid_lft forever preferred_lft forever + inet6 fe80::e85d:ab8d:2f03:2fa9/64 scope link noprefixroute + valid_lft forever preferred_lft forever +patrik@ubuntu:~$ +``` + +- router beállítása: `ip route add default via default_gateway_IP_címe` + +```shell-session +patrik@ubuntu:~$ sudo ip route add default via 192.168.4.44 +patrik@ubuntu:~$ ip r +default via 192.168.4.44 dev ens33 +169.254.0.0/16 dev ens33 scope link metric 1000 +192.168.4.0/24 dev ens33 proto kernel scope link src 192.168.4.44 +patrik@ubuntu:~$ +``` + +### Hálózatkezelők + +#### [NetworkManager](https://wiki.archlinux.org/index.php/NetworkManager) + +Automatikusan elvégzi a hálózati konfigurációt és kezeli, kontrollálja +a hálózati eszközöket. + +A network managert többféle módon szabályozhatjuk, állíthatjuk: + - `nmtui` (Network Manager Text User Interface) + +Terminálos "grafikus" felületű alkalmazás, az `nmtui` kiadása után nyílik meg. +A nyílik, az enter és az Esc segítségével navigálhatunk benne, +valamint a szóközt használhatjuk bizonyos paraméterek megváltoztatásához. + +<div style={{textAlign: 'center'}}> +<img src={require('./pics/nmtui1.png').default} alt="nmtui 'főmenü'" /> +</div> + +<div style={{textAlign: 'center'}}> +<img src={require('./pics/nmtui2.png').default} alt="nmtui edit connection menü" /> +</div> + +<div style={{textAlign: 'center'}}> +<img src={require('./pics/nmtui4.png').default} alt="nmtui edit ethernet connection" /> +</div> + +<div style={{textAlign: 'center'}}> +<img src={require('./pics/nmtui3.png').default} alt="nmtui activate connection" /> +</div> + + + + - A hálózati beállítások a grafikus felület beállításaiban is megváltoztathatóak (gnome settings, kde settings...) + +<div style={{textAlign: 'center'}}> +<img src={require('./pics/gnome-settings-network.png').default} alt="network settings" /> +</div> + + + - `nmcli` [NetworkManager command-line tool](https://opensource.com/article/20/7/nmcli) + +Parancssori alkalmazás, mellyel +a shell-ben különböző kapcsolók segítségével módosíthatjuk a NetworkManager beállításait. + +```shell-session +patrik@ubuntu:~$ nmcli +ens33: connected to Wired connection 1 + "Intel 82545EM" + ethernet (e1000), 00:0C:29:C9:DB:BA, hw, mtu 1500 + ip4 default + inet4 172.16.228.135/24 + route4 0.0.0.0/0 + route4 172.16.228.0/24 + route4 169.254.0.0/16 + inet6 fe80::e85d:ab8d:2f03:2fa9/64 + route6 fe80::/64 + route6 ff00::/8 + +lo: unmanaged + "lo" + loopback (unknown), 00:00:00:00:00:00, sw, mtu 65536 + +DNS configuration: + servers: 172.16.228.2 + domains: localdomain + interface: ens33 + +Use "nmcli device show" to get complete information about known devices and +"nmcli connection show" to get an overview on active connection profiles. + +Consult nmcli(1) and nmcli-examples(7) manual pages for complete usage details. +patrik@ubuntu:~$ +``` + +#### [systemd-networkd](https://wiki.archlinux.org/index.php/Systemd-networkd) + +Hálózati szolgáltatás, amely hálózatokat kezeli, felismeri és konfigurálja a hálózati eszközöket, a NetworkManager-höz hasonlóan. +Míg az Ubuntu Desktop verziója a NetworkManager-t használja, addig az +Ubuntu Server a systemd-networkd-t a hálózat konfigurálásához. + +A különböző beállításokat egy-egy plain-text fájlban tárolja, ezek kiterjesztése általában `.network`. +Ha kézzel szeretnénk egy beállítást hozzáadni, akkor mi is írhatunk ilyen +fájlokat. Ezeket különböző [mappákba helyezhetjük el](https://wiki.archlinux.org/index.php/systemd-networkd#Configuration_files), +a fajtájától és prioritásától függően. (Általában `/etc/systemd/network/`) + +A fájlok nagyon hasonlóan épülnek fel, mint a systemd `.service` fájljai. +``` +Wired adapter using a static IP + +/etc/systemd/network/20-wired.network + +[Match] +Name=enp1s0 + +[Network] +Address=10.1.10.9/24 +Gateway=10.1.10.1 +DNS=10.1.10.1 +``` + +A networkd-nek egy nagyon hasznos eszköze, a `networkctl`. +Ennek segítségével ellenőrizhetjük és teljes +információkat szerezhetünk a hálózati interfészekről. +Ha új konfigurációs fájlt hoztunk létre és szeretnénk betölteni, azt a +`networkctl reload` parancs segítségével tehetjük meg, majd a `networkctl reconfigure` segítségével alkalmazhatjuk is. + +## Távoli hozzáférés (SSH) + +A rendszerhez hozzáférhetünk távolról is, így is megkönnyítve a munkánkat, +nem kell fizikailag az adott számítógépnél/szervernél lennünk. +Erre többféle módszer is van, de a legbiztonságosabb és ma is leginkább használatos +az ssh (secure shell). + +### Használata + + - `ssh a_távoligépen_lévő_felhasználónk_neve@a_távoli_gép_neve` + - Megkérdezi a felhasználó nevünkhöz +tartozó jelszót, ezt megadjuk ééééééééés bent is vagyunk + +```shell-session +[patrik@patrik-laptop ~]$ whoami +patrik +[patrik@patrik-laptop ~]$ ssh hallgato@172.16.228.130 3944ms 2021. márc. 16., kedd, 20:41:28 CET +hallgato@172.16.228.130's password: + +Welcome to Ubuntu 20.04.2 LTS (GNU/Linux 5.4.0-65-generic x86_64) + + * Documentation: https://help.ubuntu.com + * Management: https://landscape.canonical.com + * Support: https://ubuntu.com/advantage +Last login: Tue Mar 16 20:41:47 2021 +hallgato@ubuntu:~$ whoami +hallgato +hallgato@ubuntu:~$ +``` +Ez mit is mutat? + - `whoami` (ki vagyok én?) válaszol erre a kérdésre + - Ezt a parancsot kiadom a saját gépemen és visszaadja, hogy `patrik` + - `ssh hallgato@172.16.228.130 ` szeretnék belépni ssh-n keresztül + a 172.16.228.130 ip címmel rendelkező gépre hallgato felhasználó névvel + - `hallgato@172.16.228.130's password:` itt kell megadni a felhasználó jelszavát + - Ha létezik a felhasználó és jó a megadott jelszó, akkor belépünk a rendszerbe + - Ezután látható, hogy tényleg sikeresen beléptem, egy "üdvözlő üzenet" fogad, + valamint a promt is megváltozott `hallgato@ubuntu:~$`-ra + - `whoami` parancs kiadása a távoli gépem + - Itt már a `hallgato` nevet kapom vissza, ebből is látszik, + hogy most egy másik felhasználóként használom a shell-t + diff --git a/app/docs/guides/training/linux/03_hf.md b/app/docs/guides/training/linux/03_hf.md new file mode 100644 index 0000000000000000000000000000000000000000..a263cfc359acc9264ca9fa8488e681153187516e --- /dev/null +++ b/app/docs/guides/training/linux/03_hf.md @@ -0,0 +1,29 @@ +# Házi Feladatok + +## Alap házi + +Csinálj felhasználót a csapattársaidnak a VM-edre úgy, hogy +hozzáférjenek a statikus weboldalak mappájához, +ezután próbáljátok ki, hogy valóban hozzáfértek-e +és ha igen, rakjatok valami funky html-t a mappába ajándékba a társaitoknak. + +Hint: adduser/useradd, usermod/gpasswd, chmod. + +## Side Quest + +Állíts be kulcsos hitelesítést a képzés VM-eden az SSH kapcsolatodhoz. +Ehhez szükséged lesz egy privát és egy publikus kulcsra a kliensgépeden. + +Hint: ssh-keygen. + +## Expert (sudo) + +Nyomozz hogyan és miért műküdik a sudo parancs! +Ha megtaláltad próbáld meg összefoglalni nekünk néhány mondatban. + +Hint: setuid + +## Expert (Csomag mágus) + +Készíts egy új csomagot (package) egy általad válaszott programból +(saját program is lehet), egy általad választott disztribúcióhoz. diff --git a/app/docs/guides/training/linux/_category_.json b/app/docs/guides/training/linux/_category_.json new file mode 100644 index 0000000000000000000000000000000000000000..fd817650b880b53dc0ef75a9a6ef18318f2cf0ad --- /dev/null +++ b/app/docs/guides/training/linux/_category_.json @@ -0,0 +1,5 @@ +{ + "label": "Linux", + "position": 3 +} + \ No newline at end of file diff --git a/app/docs/guides/training/linux/pics/elementary.png b/app/docs/guides/training/linux/pics/elementary.png new file mode 100644 index 0000000000000000000000000000000000000000..b2de5f04f3665a4420395f8e598b425d08d69d1f --- /dev/null +++ b/app/docs/guides/training/linux/pics/elementary.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ebbe4b4232eec0cf81e31441d94b32b5257060f2302e7356d210ee380c93e683 +size 799702 diff --git a/app/docs/guides/training/linux/pics/gnome-settings-network.png b/app/docs/guides/training/linux/pics/gnome-settings-network.png new file mode 100644 index 0000000000000000000000000000000000000000..6735984937fb5fcce66825d3d63b7ce785ea65ca --- /dev/null +++ b/app/docs/guides/training/linux/pics/gnome-settings-network.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:82cca1adff9523fa39c0e2441564ce6811db9a797c895374de2629593b96ce84 +size 173751 diff --git a/app/docs/guides/training/linux/pics/gnome-settings-wifi.png b/app/docs/guides/training/linux/pics/gnome-settings-wifi.png new file mode 100644 index 0000000000000000000000000000000000000000..35b3cff18a60765c75f44e514c58d6b448b21645 --- /dev/null +++ b/app/docs/guides/training/linux/pics/gnome-settings-wifi.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5eafa1270f79f1cc515e495472454d6c97559edbaf4a8c6b53c6950c6dae0677 +size 189272 diff --git a/app/docs/guides/training/linux/pics/kde.jpg b/app/docs/guides/training/linux/pics/kde.jpg new file mode 100644 index 0000000000000000000000000000000000000000..02cec11c45a9ab579fe086333073142da9713d87 --- /dev/null +++ b/app/docs/guides/training/linux/pics/kde.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7304fe9b4066072c6eed7e7aca99b5eec1582453ab40e0bc34646dc06eb94d6 +size 57276 diff --git a/app/docs/guides/training/linux/pics/nmtui1.png b/app/docs/guides/training/linux/pics/nmtui1.png new file mode 100644 index 0000000000000000000000000000000000000000..0e15b7f82f7a9fdca764dd9903fa58069707727b --- /dev/null +++ b/app/docs/guides/training/linux/pics/nmtui1.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:24159e4fbe54b5497840d2180f8862edd3ae99de06aa46240d098476eb456603 +size 124485 diff --git a/app/docs/guides/training/linux/pics/nmtui2.png b/app/docs/guides/training/linux/pics/nmtui2.png new file mode 100644 index 0000000000000000000000000000000000000000..fc6e2b6dee6534fd58a9de2c47c105f097014e2d --- /dev/null +++ b/app/docs/guides/training/linux/pics/nmtui2.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a4d000a7d8fa759b10cc3ed8dff9dbc71d2b8cef56bd2851f79e4ba44d4541b8 +size 130679 diff --git a/app/docs/guides/training/linux/pics/nmtui3.png b/app/docs/guides/training/linux/pics/nmtui3.png new file mode 100644 index 0000000000000000000000000000000000000000..db6c8c99da03c68062031921810f04b262876435 --- /dev/null +++ b/app/docs/guides/training/linux/pics/nmtui3.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4102a31157e3c0d4406a99fde8e374a8ff667032b4adf4e82e93dde43c33e0a5 +size 128537 diff --git a/app/docs/guides/training/linux/pics/nmtui4.png b/app/docs/guides/training/linux/pics/nmtui4.png new file mode 100644 index 0000000000000000000000000000000000000000..bc99cc9c541ec7dad671284a3a85453971d0cd9d --- /dev/null +++ b/app/docs/guides/training/linux/pics/nmtui4.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d76492b91895ab2f176aacbe5733cdf73047ffab3e6673d191d1913c6f54b353 +size 165795 diff --git a/app/docs/guides/training/linux/pics/ubuntu.jpg b/app/docs/guides/training/linux/pics/ubuntu.jpg new file mode 100644 index 0000000000000000000000000000000000000000..81f9acfd595fcd53782e324c67003bf5efe3b0bc --- /dev/null +++ b/app/docs/guides/training/linux/pics/ubuntu.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d15ce8c0750e404d6f4be8180af7ce6f1773553a7f9b9b2667cdee7be26b0bed +size 96526 diff --git a/app/docs/guides/training/linux/pics/xfce.png b/app/docs/guides/training/linux/pics/xfce.png new file mode 100644 index 0000000000000000000000000000000000000000..8afe52ab2dc55a171594ce1b81baac896ac95172 --- /dev/null +++ b/app/docs/guides/training/linux/pics/xfce.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6dbae7f4ed9e3d0eaccd527f4f33f4cb948b4f275fb8d0ff72026fbc84772550 +size 332240 diff --git a/app/docs/guides/training/networking/01_introduction.md b/app/docs/guides/training/networking/01_introduction.md new file mode 100644 index 0000000000000000000000000000000000000000..51995a14623ebdfc39175b1c84a2feb18bc6e329 --- /dev/null +++ b/app/docs/guides/training/networking/01_introduction.md @@ -0,0 +1,33 @@ +# Bevezetés + +## Elöljáróban + +Ez egy networking gyorstalpaló, teljesen az alapoktól. +A cél az, hogy aki elolvassa, annak legyen fogalma arról, mi szükséges a hálózaton keresztül történő kommunikációhoz, mik a lépései, milyen hálózati eszközök vesznek részt ebben, mi a feladatuk. Hogyan épül fel egy „interneten keringő” üzenet, és hogyan jut el egyik eszköztől a másikig. Természetesen mindezt olyan részletességgel, ami belefér közel 8 szerény oldalba. + +Ha úgy érzed, ez neked megy, tudsz válaszolni az alábbi kérdésekre (vagy esetleg hallgattad a KomHálók 1 című tárgyat), nem szükséges elolvasnod ezt. Azért átfutni mindenképp megéri:) + +:::tip Tudtad? + +- A Schönherz teljes hálózatát a KSZK üzemelteti +- 2db 10Gbites Uplinkkel rendelkezünk az egyetem felé +- Nálunk volt az elsők közt elérhető az IPv6 +- Több, mint 1100 végponttal rendelkezünk +- RTR-1 annyit fogyaszt, mint egy hajszárító (Bár picit nehéz lenne hosszabban megtartani) + +::: + +## Tipp + +<!-- Az oldalak elején található egy rövid összefoglaló, +továbbá pár extra feladat amik megoldásával +jobban elsajátíthatod az anyagot. --> + +A doksiban több kódsort is fogsz találni, melyeket arra +bíztatnálak, hogy bátran próbáld ki a saját gépeden. +Az egyes részek közt továbbá javasolt, hogy tarts szüneteket +és próbáld feldolgozni amit tanultál. + +Ha bármi hibát találnál az oldalon, jelezd bátran vagy +akár adj fel merge requestet a kapcsolódó +[GitSCH Repo](https://git.sch.bme.hu/kszk/website)-ban. diff --git a/app/docs/guides/training/networking/02_summary.md b/app/docs/guides/training/networking/02_summary.md new file mode 100644 index 0000000000000000000000000000000000000000..d8095a60072676bb6a8afca96438a1a511718d64 --- /dev/null +++ b/app/docs/guides/training/networking/02_summary.md @@ -0,0 +1,209 @@ +# Jegyzet + +Mindenki számára ismerős az alábbi helyzet: +<img +src={require('./img/network_simple.png').default} +alt="Bevezető hálózat" +width="500px" +/> + +de mégis hogyan kapja meg a számítógépünk a kért weboldalt, miért tudunk beszélgetni barátainkkal, mit is jelent az, hogy „az internethez kapcsolódva”? + +Az internet hálózatok hálózatok ... hálózatok hálózata, felhasználók milliárdjait köti össze, és ebből egy a mi gépünk. Ezt végiggondolva jogos az első kérdés, hogy mégis hogyan van ennyi eszköz azonosítva? + +A hálózat szereplői, és maguk a hálózatok is, különböző címzésekkel érhetők el. De még mielőtt a címzéseket kifejtjük, fontos tudni azok módjait. Ha van egy üzenetünk, ami egyetlenegy címzettnek szól, akkor az üzenet **unicast**. Ha azt szeretnénk, mindenki meghallja a mondandónk, mindenkinek megcímezzük. Ez a **broadcast**. Létezik egy kettő közti állapot, mikor egy bizonyos csoport minden tagjának, de kizárólag csak csoporttagoknak szól az üzenetünk. Ezt hívjuk **multicast**nak. +További információért tekintsük meg az alábbi ábrát. + +<img +src={require('./img/network_large.png').default} +alt="Extrémebb hálózat" +/> + +Ez egy bonyolultabb hálózat. A hengerek routerek, a téglatestek switchek, egyelőre nem baj, ha nem tudjuk pontosan, mik ezek az eszközök és mi a feladatuk. Most a hangsúly az **alhálózat** (subnet) fogalmának elsajátításán van. A bekarikázott részek az alhálózatok. Az alhálózat olyan eszközök csoportja, amin belül mindenki megkapja a broadcast, azaz a mindenkinek szóló üzeneteket. Nyilvánvalóan lehetetlen és értelmetlen lenne az, ha az internethez csatlakozó összes létező eszköz megkapná az általunk kiküldött broadcast üzenetet. Ezek a csoportok, vagy más néven broadcast domainek osztják kisebb alhálózatokra a nagy egészet. Sok szó lesz még arról, hogy gyakorlatban ez hogyan történik. Előtte még térjünk vissza az ábrához. +Az eszközök switchekhez vannak kötve, a switchek routerekhez. +A routerek másik routerekhez. Az összekötött routerek hatalmas hálózata alkotja az internetet. Ennyi észrevétel egyenlőre elég. + +### Fizikai cím + +Az első fontos, azonosításra szolgáló cím a MAC-cím (vagy fizikai cím, Media Access Control Address). Ez a cím a világon egyedi, minden, a hálózaton kommunikálni képes eszközhöz gyártásnál lesz hozzárendelve. Ez alapján az eszközünk egyértelműen azonosítható. +Egy MAC-cím összesen 48 bites, 6 darab kettősponttal elválasztott hexadecimális szám, például: + +<center> +<code style={{fontSize: "1.5rem"}}>01:23:45:67:89:AB</code> +</center> <br /> + +A saját MAC-címünket Linuxon az `ip link` , Windowson az `ipconfig /all` parancsokkal nézheted meg. + +Van egy MAC-cím, amit egy eszköz sem kaphat meg. Ez az `FF:FF:FF:FF:FF:FF`. Ennek a címnek külön feladata van, mégpedig az, hogy ő a broadcast cím. Ha az üzenetben nem egy specifikus eszközhöz tartozó cél MAC-cím található, hanem a broadcast MAC-cím, akkor minden eszköz megkapja az alhálózaton belül. + +A fentieknek köszönhetően, az eszközöd ismeri a szobatársad eszközének MAC-címét, és a neki szóló üzeneteket képes az ő saját MAC-címével megcímezni. + +<img +src={require('./img/network_room.png').default} +alt="Szoba hálózata" +/> + +### Logikai cím + +De mi van akkor, ha egy másik emeleten, vagy akár másik kollégiumban lévő eszközzel szeretnél kommunikálni? Nem tudhatjuk a világ minden hálózati kártyájának fizikai címét. Konkrétabban csak azokét tudhatjuk, akik egy alhálózatban, _broadcast domain_-ben vannak velünk. +A következő felmerülő kérdés, hogy hogyan juthatunk messzebb, ki a hálózatunkból? +Szükségünk van egy olyan címre, amivel alhálózatunkon kívülre is címezhetünk. +Ez a cím az **IP cím** (vagy logikai cím, Internet Protocol). + +Az IP cím teszi lehetővé, hogy bárkit és bármit elérjünk interneten keresztül, ugyanis tudatosan tervezve kapod, ellentétben a MAC címmel, amit beégettek az eszközbe. Egy IP cím összesen 32 bites, 4 darab 8 bites, ponttal elválasztott decimális szám, például: + +<center> +<code style={{fontSize: "1.5rem"}}>152.66.169.42</code> +</center> <br /> + +A saját IP címünket Linuxon az `ip address`, Windowson az `ipconfig /all` parancsokkal nézheted meg. + +### Hálózatszámítás + +A legkisebb létező IP cím a `0.0.0.0` (binárisan „csupa nulla”), a legnagyobb a `255.255.255.255` (binárisan „csupa egy”). Ezeket a címeket viszont nem osztjuk felhasználóknak, külön feladataik vannak. Jópár olyan IP cím (és címtartomány) létezik, amelyek bizonyos célokra vannak lefoglalva. Ezekről egy kicsit később még szó lesz. +Ahhoz, hogy megértsük, hogyan működik az IP-általi címzés, muszáj egy kicsit a felépítését boncolgatni. + +Az IP címek nem csak eszközöket, de alhálózatokat is azonosítanak. Az alhálózaton belüli IP cím első X darab bitje a hálózati cím, a maradék pedig tetszőleges, az alhálózaton belül egyedi. Na de hogyan értsük ezt az „X darab bitet”, és hogyan is jelöl ez ki alhálózatot? + +Minden IP címhez jár egy úgynevezett hálózati maszk (netmask). A hálózati maszk segítségével jelöljük ki az „első X bitet”. +Nézzünk egy tetszőleges IP címet, mondjuk a 192.168.0.1-et. Ez binárisan felírva: +<code style={{fontSize: "1.1rem"}}>11000000.10101000.00000000.00000001</code> + +Ha erre a címre alkalmazunk egy hálózati maszkot, az azt jelenti, hogy bitenként „kimaszkoljuk” az alhálózat címét az IP címből. Ennek az a módja, hogy a (szintén binárisan felírt) maszkunkat `AND`-eljük az IP címünkkel. Egy maszk így néz(het) ki: + +<code style={{fontSize: "1.1rem"}}>11111111.11111111.11111111</code>.<code style={{fontSize: "1.1rem"}}>00000000</code> (decimálisan 255.255.255.0) <br /> +<code style={{fontSize: "1.1rem"}}>11000000.10101000.00000000</code>.<code style={{fontSize: "1.1rem"}}>00000001</code> (ez a fent már említett IP cím) <br /> +<code style={{fontSize: "1.1rem", color: "red"}}>11000000.10101000.00000000</code>.<code style={{fontSize: "1.1rem", color: "blue"}}>00000000</code> ez pedig az eredmény ha elvégezzük az AND-et. +<br /> +Tehát az alhálózat címe: <code style={{fontSize: "1.1rem"}}>192.168.0.0</code> + +De mi határozza meg a maszk méretét, és mégis mi értelme ennek? + +Az alhálózati cím méretét az alhálózatban elhelyezett eszközök száma határozza meg. Ha belegondolunk, minél több bit van fixen az alhálózat címének szentelve, annál kevesebb bit marad a cím egyedi részének, tehát annál kevesebb egyedi címet tudunk kiosztani. A példánkban az első 24 bit az alhálózat címzését szolgálja, tehát már csak 8 bit maradt, amit szét tudunk osztani a kapcsolódó eszközök közt. Ez 254 darab különböző IP címet jelent, hiszen 1 byteon (vagyis 8 darab biten) 2<sup>8</sup> = 256 darab különböző szám írható le. (Annak az elveszett 2 címnek oka van, a legeslegelső kiosztható címet maga a hálózat kapja, a legeslegutoló pedig egy IP-beli broadcast cím). + +Az első 24 bit. Így jelezzük gyakorlatban az IP címekhez tartozó alhálózati maszkot. Konkrétabban, egy IP cím korrekt megadása az alhálózat megadásával történik, így: `192.168.0.1/24`. Tehát ez azt jelenti, hogy az IP cím első 24 bitje fix, az alhálózatot azonosítja, az utolsó 8 bit pedig szabadon felhasználható. + +Tehát akkor mit jelent? + +Ha csatlakozunk egy `192.168.0.0/24` hálózati maszkkal rendelkező alhálózatba, akkor kaphatunk `192.168.0.5`, `192.168.0.85`, de akár `192.168.0.222`-es IP címet is, az utolsó byte akármilyen szám lehet 1 és 254 közt. Nem kaphatunk viszont `192.168.8.85`-öset, hiszen az első 24 bit fix, azt nem változtathatjuk. + +A félreértések elkerülés végett, a legeslegelső kiadható IP cím (ebben az esetben a `192.168.0.0`) mindig az alhálózatot azonosítja, ezt nem osztjuk eszköznek. A hálózati maszkot jelző /24-es számot nem csak az alhálózatot azonosító IP cím mögé írjuk oda, de az ebből a tartományból kiosztott IP címek mögé is. + +Ennek az egésznek a hálózat tervezésénél van értelme, hiszen minél kisebb egy alhálózat, annál kevesebb IP címre van szüksége, és nem pocsékolunk el rá feleslegesen többet, így is kevés van. Gondoljunk csak arra, hogy IP címből 2<sup>32</sup>, azaz körülbelül 4 milliárd különböző, kiosztható létezhet, emberből a Földön pedig (2020-as adat szerint) 7.753 milliárd van. Ha mindenkinek csak egyetlenegy eszköze is lenne az interneten, már akkor is régen kifutottunk a címekből. + +### Publikus és Privát IP címek + +De hogyan jut mégis elég IP cím mindenre úgy, hogy nem jut saját IP cím mindenkinek? + +A helyzet az, hogy ellentétben a MAC-címekkel, IP címek kiosztása nem véletlenszerű, hanem a hálózat struktúrájának megfelelően vannak kiosztva. És nem is tartoznak az eszközhöz örökké, hálózatonként, de sokszor hálózatba kapcsolódásonként cserélődnek. Egy eszköznek csak akkor van IP címe, ha csatlakozik egy hálózathoz. + +Ez nem azt jelenti, hogy ne lehetne a világon egyedi IP címünk. Ezt hívjuk **publikus IP** címnek. Aki a koliban lakik, kap is kettőt. + +Ígértem, hogy még lesz szó a lefoglalt címekről. Mostmár, hogy ismerjük az alhálózati maszk fogalmát, beszélhetünk címtartományokról. + +A `10.0.0.0/8`, `172.16.0.0/12` és a `192.168.0.0/16` tartományokat **privát hálózati cím**eknek hívjuk, legtöbbször ilyen címet kapunk egy átlagos alhálózatba becsatlakozva. + +Privát,( vagyis publikus interneten nem találkozhatunk velük, erről „gondoskodnak a routerek”. A külvilág számára elfedik az általuk vigyázott alhálózat összes eszközét, egy IP címként mutatva az egész alhálózatot. Ez a **NAT** (Network Address Translation), erről egyelőre elég ennyit tudni. + +A `127.0.0.1` címet még érdemes megemlíteni, ez az úgynevezett **loopback** cím. Ez minden számítógép számára a saját belső címe, ide küldi a saját magának szóló üzeneteket. + +Van még egy fontos IP cím, amit ismerni kell. Minden, az interneten kommunikálni kívánó eszköznek szüksége van a sajátján kívül még egy IP címre, hogy ezt megtehesse. Ezt hívjuk **default gateway**-nek. + +A default gateway nem a mi számítógépünk saját címe, hanem a legközelebbi olyan eszköz (tipikusan router) IP címe, ami tudja a mi, IP címmel ellátott csomagjainkat továbbítani más hálóztok felé. A számítógépünk a default gateway-nek címzi azokat a csomagokat, amelyeket ki szeretne juttatni a saját hálózatából. + +Ez már egy bonyolultabb hálózat, több alhálózattal, ahol IP cím alapján címzünk. + +<img +src={require('./img/network_sch.png').default} +alt="SCH Hálózat" /> + +Tehát ha felkeressük a google.com-ot, az eszközünk „valami varázslat” folytán megtudja a keresett oldal IP címét, és neki címzi az üzenetet. Ennek segítségével talál el az üzenet a megfelelő hálózatba. Mivel az eszközünknek fogalma sincs merre van ez a hálózat, a default gateway MAC-címére küldi. Később világosabb lesz, ígérem. És a “valami varázslat” is kézzel foghatóbbá válik majd. + +### Szolgáltatások elérése + +De ezek előtt még át kell beszélni valamit, ami elsőre úgy tűnhet, nem ide tartozik, de mégis. + +A számítógépünkön rengeteg olyan szolgáltatás, folyamat fut, amely hálózaton keresztül kommunikál. A Google-nek is több szolgáltatása van (például a HTTP, HTTPS). Honnan tudják a folyamatok, hogy melyik üzenet szól nekik, és melyik nem? + +Erre valók a **portok**. A portok „sima” decimális számok, minden szolgáltatásnak van egy, vagy több sajátja. Különböző közismert szolgáltatásokat közismert portokon lehet elérni. Biztosan mindannyian találkoztunk már a HTTP-vel, ami a 80-as porton érhető el. Ennek a biztonságos változata a HTTPS a 443-as porton figyel. SSH sem ismeretlen, ő a 22-es porton ül (de ha mégis ismeretlenek ezek a dolgok ne aggódj, a későbbiekben lesz még szó róluk). Egy tetszőleges folyamat tetszőleges, „magas portot” (néhány nagyságrenddel nagyobb számot) kap. + +Tehát, számítógépünk különböző folyamatokhoz különböző portokat társít, innen tudja, melyik hálózatról érkező üzenet melyik folyamatának jött. + +Ha egy weboldalt szeretnénk megnézni, az előbbi „ha felkeressük a google.com-ot, az eszközünk „valami varázslat” folytán megtudja a keresett oldal IP címét, és neki címzi az üzenetet. Ennek segítségével talál el az üzenet a megfelelő hálózatba. Mivel az eszközünknek fogalma sincs merre van ez a hálózat, a default gateway MAC-címére küldi.” Kijelentésünket kiegészíthetjük azzal, hogy „és a 80-as porton keresi”. + +A visszautalásokat folytatva, fényt derítünk „a „valami varázslat” folytán”-ra. Ez a varázslat a **DNS** (vagy névfeloldás, Domain Name System). A DNS olyan hierarchikus felépítésű szerverek hálózata, amik az ember által olvasható domain nevekhez (például google.com, edu.vik.bme.hu) IP címet társítanak. A legtöbbet használt DNS szerverek a Google 8.8.8.8 című és a CloudFlare 1.1.1.1 című szerverei. Mikor rákeresünk a google.com-ra, vagyis tudni szeretnénk az IP címét, a gépünk először lokálisan megnézi, van-e arról valami információja. Ha nincs, kérést intéz az (már előre ismert) DNS szervernek. Ha ő sem tudja, továbbdobja a következőnek. A kérésünk egészen addig kering, míg választ nem ad valaki. De nem ám véletlenszerűen dobálóznak. A domain nevek hierarchikusak, és a DNS szerverek is hierarchikusan vannak elosztva ez alapján. Példaként az edu.vik.bme.hu. Hu-ból van a legtöbb, ezen belül bme is van jó pár, és így tovább. A szerverek tudják, hogy a lefedett domain neveiken belül merre továbbítsák a kérést. Ha létezik a domain név, meglesz az IP cím. + +Figyelem, jól haladunk, végigjártuk az **OSI modell**t!! Úgy, hogy nem is beszéltünk róla. + +## OSI Modell + +<center> +<img +src={require('./img/osi.png').default} +alt="OSI Modell" width="400px"/> +</center> + +Már oldalak óta arról olvasunk, hogy nagyon különböző feladatkörökre lehet osztani a hálózati kommunikációt. Ezeket a feladatokat, felelősségeket rétegekbe rendezték, és elnevezték őket, hogy ilyen szép ábráról tanulhassunk. Meg azért, hogy mindennek meglegyen a saját felelőssége, függetlenül a többiektől, és ha egy réteget kicserélünk, ez a többire ne legyen hatással. +Ahhoz, hogy minden egységesen működjön, előre definiált szabályok, eljárási módok szükségesek. Ezt hívjuk protokollnak. Akármilyen hálózati eszközről beszélünk, mind ismeri a protokollokat és az OSI modellt, és ez alapján jár el. Ezért tud működni az internet. +A kép jobb oldalán olvashatók a rétegek nevei és felelősségük, jobb oldalon pedig, hogy minek hívjuk az adott rétegbeli „üzenetet”. +A színkód is fontos. Ez a 7 darab réteg alaposan átgondoltak, de gyakorlatban nem különítünk el ennyit. Az azonos színű rétegeket egynek értelmezzük a TCP/IP modellben, ami az OSI modell továbbgondolása, vagy inkább gyakorlatba ültetése. + +Az **1., fizikai réteg**gel ebben a jegyzetben külön nem foglalkozunk. Ez a témakör inkább arról szól, hogy mégis hogyan juttatjuk el bitjeinket a különböző rendelkezésre álló közegeken keresztül. +A **2., adatkapcsolati réteg** a „MAC-címes” réteg. Itt történik a fizikai címzés, az eszköz fizikai azonosítása. +A **3., hálózati réteg** az „IP címes” réteg. Itt történik a logikai címzés, hogy a világon merre is keressük azt az eszközt. Megvalósítja a végponttól végpontig tartó kapcsolatot. +A **4., szállítási réteg** a „portos” réteg. Tudja, hogy melyik szolgáltatásnak címezték az üzenetet, küldő és fogadó oldalon is azonosítja a kommunikáló szolgáltatásokat. +A **„felsőbb rétegeket”**, amik már a felhasználói élményt gazdagítják, erről is csak minimálisan beszélünk. + +De hogyan kell ezt elképzelni a gyakorlatban, hogyan lesz a bitekből weboldal? + +Nos, tegyük fel, hogy megszületett az adathalmazunk, ami például egy http kérés. Mivel most a legfelső rétegekkel nem foglalkozunk, feltesszük azt is, hogy ez az adathalmaz készen áll arra, hogy a webserver értelmezze és válaszoljon rá. Az egyben elküldhető méretűre darabolt adathalmazt feldarabolás (vagyis szegmentálás) után szegmensnek hívjuk, és ellátjuk egy portszámmal. A szegmenst megcímezzük a google.com IP címével, hogy a router tudja, merre kell küldeni a tőlünk kapott csomagot (packet). A csomagunkat a default gatewaynek kell küldeni, hiszen azon keresztül mennek ki alhálózatunkból az üzenetek. Megcímezzük a csomagot a default gateway MAC-címével. Mostmár ez egy Ethernet keret. És az üzenetünk elküldhető állapotban van. + +Mi történik a kerettel az út során? + +A switch (az ábrán „szinti rendező”) megnézi a keretben lévő MAC-címet és tudja, hogy az a default gateway-é. Hát elküldi neki. A default gateway (vagyis, a router) megkapja, látja, hogy neki van címezve a keret. Leszedi a keretet, ránéz a csomagra, és megtudja, hogy a 142.250.180.238-nak (azaz a google.com-nak) kell küldeni. Persze a router sem mindentudó, annyi információja van csupán, hogy merre kell továbbküldenie, hogy közelebb kerüljön a célhoz. És ez az út számtalan routeren vezeti keresztül szegény üzenetet, míg ténylegesen célba ér. De amint az üzenet és a szerver egymásra találnak, a többi már rájuk tartozik. +A szerver a megadott port alapján megkeresi a szolgáltatást, akinek szól, az majd értelmezi az üzenetet. + +Hogy kicsit konkretizáljuk a megnevezéseket, az adatkapcsolati réteget szoktuk **Layer2**-nek, a hálózati réteget **Layer3**-nak is hívni. +A tipikus layer2-es hálózati eszköz a switch, ami nem néz bele az IP címekbe, csakis fizikai, azaz MAC-címek alapján küldi tovább a keretet. +A tipikus layer3-as hálózati eszköz a router, ami az alhálózat „kilépési pontja”(default gateway), és IP címek szerint továbbítja az üzeneteket megfelelő irányba. + +Jobb esetben senki nem nézi az üzenet nem rá tartozó rétegeit. + +Igaz, hogy azt mondtam, nem beszélünk a felsőbb rétegbeli dolgokról, de a gyakorlat miatt mégis meg kell említeni néhány szolgáltatást, protokollt. + +Amivel egy átlagos felhasználó is találkozik, az a HTTP(S) (Hypertext Transfer Protocol), weboldalakkal(például HTML dokumentummal) szolgálja ki a felhasználót. Az „S” a biztonság ebben. + +Amivel szintén találkozik, csak nem tud róla, az a **DHCP** (Dynamic Host Configuration Protocol). + +Ez a protokoll felelős azért, hogy a DHCP szerver osszon IP címet minden, hálózatba kapcsolódott eszköznek. A folyamat (üzenetváltások sorozata), ahogyan címet kap tőle, a DORA. + +Azért feloldanám a betűket. + +**D: Discover** – a gép küldd egy broadcast üzenetet (tehát mindenkinek, aki egy alhálózaton van vele), hogy valaki adjon neki IP címet +**O: Offer** – jobb esetben a DHCP szerver ezt meghallgatja, és küldd neki egyet +**R: Request** – a gép elfogadja, és kéri a szervertől a továbbiakat +**A: acknowledge** – a szerver elküldd minden információt, és elfogadja, hogy a szóban forgó IP cím már a gépünkké. + +Egymás megismerése egy nagyon fontos lépés az életünkben. Erre jól bevált módszereink vannak. Főleg a MAC címek világában. Az **ARP** (Address Resolution Protocol) egy olyan “2.5-ik rétegbeli” protokoll, aminek segítségével megtudhatjuk a velünk egy alhálózatban levő eszközök MAC címét úgy, hogy csak az IP címük van a tulajdonunkban . Tehát, az ARP IP címhez MAC-címet rendel. Az ARP segítségével megszerzett MAC-címeket a gépünk egy táblázatban tárolja, ezt ARP-táblának (másnéven ARP-cache-nek) hívjuk. Az eszközünk ezt a táblát használja arra, hogy cél-MAC-címmel címezze az elküldendő keretet. Ha nem talál számára megfelelőt, ARP kérést intéz. +Azért mondjuk 2.5-nek, mert kapcsolatot teremt a Layer2-es (MAC) és Layer3-as (IP) címek közt. + +A **webszerver** fogalma szintén elengedhetetlen a gyakorlathoz. A webszerver nem meglepő módon webes tartalmat szolgál ki (http, https). Rákeresünk az almafa.hu-ra, és megjelenik a weboldala. Az almafa.hu mögött ül egy szerver, aki állandóan arra figyel, ki kéri el tőle a tartalmat. A port amin figyel, általában a 80-as számú. Ha a gépünk DNS segítségével feloldja az almafa.hu IP címét, és kérést intéz annak 80-as portára, megkapja a weboldalt. + +Nekünk is vannak eszközeink arra, hogy mélyebben belemenjünk ebbe saját rendszerünkön. + +Legfontosabb „netes” parancsok: + +- Linuxon `ip a` / `ip l` , windowson `ipconfig /all` a MAC és IP címeink kiderítéséhez +- `ping` [ip cím vagy domain név]: Layer3-as kapcsolat tesztelésére szolgál. +- `traceroute` [ip cím vagy domain név]: végigköveti a csomag útját, kiírja, milyen hálózati eszközökön ment keresztül az üzenetünk. +- `dhclient` [interface]: a beírt interfésznek kér a DHCP szervertől egy IP címet +- `nslookup` [ip cím/domain név]: DNS kérés indít, IP címet lefordítja domain névre, domain nevet lefordítja IP címre +- `tcpdump` (vagy wireshark): mindkét program a számítógépünkről kimenő, vagy arra érkező üzenetek elkapására szolgál. A tcpdump-al ellentétben a Wireshark-nak van grafikus felülete, látványosan ki lehet bontani benne rétegenként az üzeneteket. +- `ip route`: megmutatja az eszköz routing tábláját +- `arp`: megmutatja az eszköz arp tábláját +- `curl` [ip cím vagy domain név]: lekéri az ip címhez tartozó webes tartalmat +- `netstat -tupln`: (tcp udp process listener no-resolve) ez minden amit tudi kell + +És még egy utolsó dolog, mi az az SSH? + +Az SSH (Secure shell) titkosított távoli asztali kapcsolat. Ha egy gépen van SSH szerver, arra jó eséllyel lehet SSH-zni. Ez a szerver alapértelmezetten a 22-as porton hallgatja, ki kíván kapcsolatot létesíteni(ezt a portot általában nagyobbra állítjuk a saját eszközeinken, hogy illetékteleneknek ne legyen olyan könnyű megtalálni). SSH-zni az `ssh felhasznalo@domain` -el lehet, a felhasználót le lehet hagyni, a domain nevet lehet írni IP cím formájában. diff --git a/app/docs/guides/training/networking/_category_.json b/app/docs/guides/training/networking/_category_.json new file mode 100644 index 0000000000000000000000000000000000000000..6771b663dadff4669b5124e4090dfb8e88aee030 --- /dev/null +++ b/app/docs/guides/training/networking/_category_.json @@ -0,0 +1,4 @@ +{ + "label": "Python 3", + "position": 2 +} diff --git a/app/docs/guides/training/networking/img/network_large.png b/app/docs/guides/training/networking/img/network_large.png new file mode 100644 index 0000000000000000000000000000000000000000..4a594d3df56615e64a5251ffa706c201a3b24324 --- /dev/null +++ b/app/docs/guides/training/networking/img/network_large.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:18f66130ab31bad2a43e976129f484f5f03c3cef8719c7787da575b8bd548bb3 +size 385194 diff --git a/app/docs/guides/training/networking/img/network_room.png b/app/docs/guides/training/networking/img/network_room.png new file mode 100644 index 0000000000000000000000000000000000000000..f60ea606b61c2407a8f8a019fc727789c34e7b90 --- /dev/null +++ b/app/docs/guides/training/networking/img/network_room.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aba77b3a40eb048c895d31637f95b188bb9569975018a6d541156774c5b23abc +size 84296 diff --git a/app/docs/guides/training/networking/img/network_sch.png b/app/docs/guides/training/networking/img/network_sch.png new file mode 100644 index 0000000000000000000000000000000000000000..ac137c4dda17c701ab7e5bb28bdad0d81cbaf0f4 --- /dev/null +++ b/app/docs/guides/training/networking/img/network_sch.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:877a3faaec141d6d8555e719dfc474a358ca2025e81d95b37b2425455310dc71 +size 176586 diff --git a/app/docs/guides/training/networking/img/network_simple.png b/app/docs/guides/training/networking/img/network_simple.png new file mode 100644 index 0000000000000000000000000000000000000000..3c2ce9c9a55dc83e3552577464b2c9b486df3150 --- /dev/null +++ b/app/docs/guides/training/networking/img/network_simple.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fbf412a4046187c4b51d1032e7b38e3a213d7e856946a9391920759e41e87412 +size 15138 diff --git a/app/docs/guides/training/networking/img/osi.png b/app/docs/guides/training/networking/img/osi.png new file mode 100644 index 0000000000000000000000000000000000000000..062be02d9b1a5c57b685628924dd9a065fe9c9e5 --- /dev/null +++ b/app/docs/guides/training/networking/img/osi.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1fc49b838256533a267498d25c3b3913c32eddf0df245b675e65d594d7b51a7 +size 42299 diff --git a/app/docs/guides/training/python/01_introduction.md b/app/docs/guides/training/python/01_introduction.md new file mode 100644 index 0000000000000000000000000000000000000000..5eca11b23e0470c37131584ee1326c030545ea8f --- /dev/null +++ b/app/docs/guides/training/python/01_introduction.md @@ -0,0 +1,110 @@ +# Bevezetés + +## Elöljáróban + +Van Sötét téma, oldalt a menüben betudod kapcsolni 😉 +Ugyanitt megtalálod az egyes fejezeteket. +Használd bátran! + +Az oldalak elején található egy rövid összefoglaló, +továbbá pár extra feladat amik megoldásával +jobban elsajátíthatod az anyagot. + +Ha bármi hibát találnál az oldalon, jelezd bátran vagy +akár adj fel merge requestet a kapcsolódó +[GitSCH Repo](https://git.sch.bme.hu/rlacko/python-presentation)-ban. + +<Note type="tip" label> + +**Ahol mi használjuk a Pythont** + +- Újonc weboldal backendje: [GitSCH](https://git.sch.bme.hu/kszk/devteam/kszkepzes/old/kszkepzes-backend) +- Mátrix egyes kódjai: [GitSCH](https://git.sch.bme.hu/matrix-group) +- Mattermost botok +- SCH hálózatát működtető programok +- [AdminSCH](https://admin.sch.bme.hu/) +- És megannyi kisebb-nagyobb projektünk + +</Note> + +## Python nyelvről pici ízelítő + +A Python egy viszonylag könnyen tanulható, viszont elképesztően +sok funkcióval ellátott nyelv. +Magasszintű, azaz különböző adatstruktúrákat, könyvtárakat +biztosít nekünk, hogy minél kevesebbet kelljen kódolnunk +és ne az alacsony szintű dolgokon kelljen törnünk a fejünk. + +Amellett, hogy mennyi lehetőséget bizosít, az iparban is igen elterjedt nyelv. +Különböző ágazatokban előszeretettel használják az apró +probléma megoldásától a legbonyolultabbakig. +Lehet benne apróbb szkripteket, webszervereket vagy akár +gépi tanulásra képes szoftvereket is írni. + +## Tipp + +A doksiban több kódsort is fogsz találni, melyeket arra +bíztatnálak, hogy bátran próbáld ki a saját gépeden. +Az egyes részek közt továbbá javasolt, hogy tarts szüneteket +és próbáld feldolgozni amit tanultál. + +## Telepítés + +### Windows + +Három opciód van, ebből válassz egyet: + +- Microsoft Store-ban a [Python 3.8](https://www.microsoft.com/en-us/p/python-38/9mssztt1n39l?activetab=pivot:overviewtab)-ra keresel és azt feltelepíted +- [Pyhton weboldaláról](https://www.python.org/downloads/windows/) letöltöd a hivatalos telepítőt. + Itt a `Latest Python 3`-ra kattints, majd az oldal legalján megtalálod a `Windows installer (64-bit)` nevű fájlt. +- Utolsó opció, hogy feltelepítesz egy Windows Subsystem for Linux-ot ([WSL](https://docs.microsoft.com/en-us/windows/wsl/install-win10)) és arra telepíted fel a lentebb leírt módon. + +### MacOS + +Két módot találtam, de ha elakadnál, keress bátran. + +- [Pyhton weboldaláról](https://www.python.org/downloads/windows/) letöltöd a hivatalos telepítőt. + Itt a `Latest Python 3`-ra kattints, majd az oldal legalján megtalálod a `macOS 64-bit ... Installer`-t nevű fájlt. + Description-be látod, hogy melyik kell a te rendszeredhez. +- Letöltöd a [Brew](https://brew.sh/) nevű Package manager-t, + majd pedig egy `brew install python`-al feltelepíted. + +### Linux + +Linuxon viszonylag egyszerű. +A kedvenc csomagkezelőd ha kiválasztod, abban +megfogod találni a `python3` nevezetű csomagot. +Azt telepítsd fel. +Például egy Ubuntu rendszeren a terminálból telepítve: + +- `sudo apt install python3` + +_vagy a grafikus csomagkezelőben rákeresel és feltelepíted._ + +## Rólam + +Lehet, hogy ezt nem az oldal végére kellett volna tennem, +de mostmár hogy ennyi mindent elolvastál, Szia! + +A KSZK-ba még gólyaként volt szerencsém csatlakozni és akkor még nem hogy a Linux-hoz nem értettem, de még azt se tudtam, hogy mi az az API kérés és hol induljak el, ha fejleszteni szeretnék egy alkalmazást. Ez idő alatt nem csak megannyi szakmai tapasztalatot szereztem, de életre szóló barátságokra is leltem ebben a közösségben. +A félév során, mint DevTeam körvezető és VMWare rendszergazda tevékenykedtem. Volt szerencsém ez idő alatt megismerkedni különböző virtualizációs technológiákkal, üzemeltetéssel, szoftver fejlesztéssel és projekt menedzsmenti megoldásokkal. Mostanában legfőképp webfejlesztéssel foglalkozom. +Harmadéves infósként szinte bármivel megtalálhattok, legyen az szakmai kérdés, újonc oldalon felmerülő ötlet vagy csak egy baráti beszélgetés. Szóval csak keress bátran! + +((Az [Újonc oldalon](https://ujonc.kszk.bme.hu/mentors) lévő +leírással való egyezés csak a véletlen műve)) + +Elérhetőségeim: + +- Email: laszlo.rafael[AT]kszk.bme.hu +- Mattermost: [@rlacko](https://mattermost.kszk.bme.hu/kszkepzes-21/messages/@rlacko) +- Telegram: [@rlacko](https://t.me/rlacko) + +<img + src={require('./rafael_laszlo-min.jpg').default} + border="false" + width="200" +/> + +A dokumentációhoz főképp a +[hivatalos doksikat](https://docs.python.org/3/), +a Google-t és a saját tapasztalataim használtam fel diff --git a/app/docs/guides/training/python/02_interpreter.md b/app/docs/guides/training/python/02_interpreter.md new file mode 100644 index 0000000000000000000000000000000000000000..c8cf8c8607767d8356c03c9b49d6971445ad217d --- /dev/null +++ b/app/docs/guides/training/python/02_interpreter.md @@ -0,0 +1,126 @@ +# Az Interpreter és a nyelv felépítése + +<Note type="tip" label> + +**TL;DR Tartalom** = _Too long; didn't read_ + +- [Interpreted / Compiled nyelv](#interpreted--compiled-nyelv) - Picit szó van az interpreterről, továbbá a REPL-ről. (Érdemes + ránézni a REPL-re) +- Végén pedig van egy pár példa kód + +</Note> + +## Parancsok és azok feldolgozása + +Python Interpreter egy olyan kis program, ami a +háttérben fut és várja szövegként a parancsokat amit futtason. + +Ha csak egy parancsot szeretnénk lefuttatni, akkor +a terminál megnyitása után: +`python3 -c "parancs"` + +```shell-session +$ python3 -c "print('Első python kódom')" +``` + +_C-ben mennyi munka lett volna egy hasonló kódot megírni?_ + +```c +#include <stdio.h> + +int main() { + printf("N+1-edik C kódom\n"); + + return 0; +} +// Látható, hogy mennyi mindent megspórol nekünk a Python +``` + +<Note type="tip" label> + +<Badge type="tip">Linux</Badge> +`$` jellel a parancssorban kiadott parancsokat szokták +jelölni. + +</Note> + +## Interpreted / Compiled nyelv + +Kódunkat többféleképp oda adhatjuk a gépünknek, hogy +dolgozza fel. +Első opciónk, hogy előtte lefordítjuk, azaz +**Compile**-oljuk. +Ilyenkor igazából mielőtt futtathatnánk a kódunk, +készítünk belőle egy gépi kódot. +Ilyen nyelv például a C, C++, Rust és a Go. + +Második opció esetén fut egy programunk a gépen, +mely különböző instrukciókat vár és az alapján +végez műveleteket. Ezeket nevezik **Interpretált** +nyelveknek. Ilyen a Python is. + +<Note type="tip" label> + +<Badge type="tip">REPL</Badge> +Read-Eval-Print-Loop, azaz egy olyan környezet, +mely interaktív mód várja az utasításokat és +ezeket azonnal végrehajtja, majd várja a következőt. +_Hasznos ismeret, mert sok nyelv követi ezt a logikát._ +[Wikipédia](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) + +</Note> + +Következő fejezetben ki is próbálhatod! + +## Python Interpreter + +A Python interpreterét a `python3` parancs kiadásával +érheted el. + +<Note type="tip" label> + +<Badge type="tip">Tipp</Badge> +A gépünkön a pythonnak egy régebbi 2-es verziója is jelen +lehet. +Ebben a verzióban több dolog máshogy működik, mint a 3-asban. +Ennek elkerülése érdekében használd a `python3` parancsot. + +</Note> + +```python +$ python3 +Python 3.8.5 (default, Jan 27 2021, 15:41:15) +[GCC 9.3.0] on linux +Type "help", "copyright", "credits" or "license" for more information. +>>> +``` + +Láthatunk több adatot is a python interpreterünkről. +Nálam például a `3.8.5`-ös verzió van meg és +Január 27-én került telepítésre. + +Azt is észrevehetjük, hogy GCC-t használ az interpreterünk, +azaz a program, mely majd futtatja a Python utasításaink +az C-ben íródott. + +Akkor az előzők alapján próbáljuk is ki a Python értelmezőt. + +```python +>>> # Adjuk ki az előző példánk parancsát +... print('Második Python kódom') +... +Második Python kódom +``` + +Valamivel bonyolultabb példa: +_Próbáld értelmezni, hogy vajon mit csinálhat futtatás után_ + +```python +>>> lapos_a_fold = True +>>> if lapos_a_fold: +... print("Hol van ausztrália?") +... +``` + +Következő két fejezetben a különböző típusoktól kezdve +a nyelv vezérlési szerkezeteivel fogunk megismerkedni diff --git a/app/docs/guides/training/python/03_types.md b/app/docs/guides/training/python/03_types.md new file mode 100644 index 0000000000000000000000000000000000000000..4f10fe16513eebe437b34728ba075970362d4ff7 --- /dev/null +++ b/app/docs/guides/training/python/03_types.md @@ -0,0 +1,508 @@ +# Típusok + +<Note type="tip" label> + +**TL;DR Tartalom** + +- [Int - Egész](#int---egész) - Jó hosszú lehet, több + számrendszert is kezel +- [Float - Tört](#float---tört) - Max 64 bites és könnyedén lehet + 10-es hatvánnyal szorozni +- [Complex - Komplex szám](#complex---komplex-szám) +- [String - Szöveg](#string---szöveg) - Pár hasznos függvény, + escapelés, speciális karakterek, """ +- [Boolean - Logikai](#boolean---logikai) - Típus, truthiness +- [Pár művelet a típusainkkal](#pár-művelet-a-típusainkkal) - + Matek, extra operátorok, \_ jel, + sztring műveletek, indexelés, sliceolás +- [List - Lista](#list---lista) - Létrehozás, tömb műveletek, + pár függvény + +</Note> + +<Note label> + +**Extra feladatok** +_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb +megtanulni a dolgokat_ + +- 192.168.1.101 oktetjeit konvertáld át binárisba és írd ki +- 255.255.255.240 oktetjeit konvertáld át binárisba és írd ki +- Írd ki a hálózat címét az előző kettő alapján 10-es + számrendszerben. (Spoiler: Össze éseled a bináris formát, majd vissza konvertálsz) +- Hogyan írnád le a 3.14\*10^87 -ent Pythonban? +- [Eiffel 65 - Blue](https://youtu.be/zA52uNzx7Y4) című + slágerét hallgatva észre vetted, + hogy van egy pár ismétlődő rész. + Mint jó programozó féltve az elpazarolt biteket, + szeretnéd ezt kódból lerövidíteni. + Tedd ezt meg a lehető legegyszerűbben (Spoiler: + Sztring műveleteknél találsz hasonlót) +- Készíts egy listát a kedvenc 7 számoddal. + (_nem zene szám, hanem numerikus szám_) + Ezt követően ezekből vedd ki három legkedvencebb számod. + Végül pedig oszd el az első és az utolsó számot úgy, hogy + csak az egész része maradjon meg. (Spoiler: `Pár művelet` + fejezetnél találsz majd egy operátort) + +</Note> + +## Int - Egész + +Szám értéket jelöl és mérete bármekkora lehet. (Amíg van ram) + +```python +>>> print(123123123123123123123123123123123123123123123123123123123123123123 + 1) +123123123123123123123123123123123123123123123123123123123123123124 +``` + +_Bármilyen számjegyből álló sorozatot egészként fog értelmezni +a Python egészen addig, míg nincs benne egy tizedes pont._ + +Több **számrendszer**ben is tudunk dolgozni. + +| Szintaxis | Számrendszer | Konstruktor | +| ---------- | ------------- | ----------- | +| 0b vagy 0B | Bináris | bin | +| 0o vagy 0O | Oktális | oct | +| 0x vagy 0X | Hexadecimális | hex | + +```python +>>> 0x10 + 0x02 +18 # 16 + 2 +``` + +Ezeknek mind `Int` a típusa + +```python +>>> type(10) +<class 'int'> +>>> type(0o10) +<class 'int'> +>>> type(0x10) +<class 'int'> +``` + +A megfelelő konstruktort használva, akár át is tudjuk +őket konvertálni. + +```python +>>> hexa = hex(79) # 10-es számrendszerből hexába +>>> hexa +'0x4f' +>>> int(hexa, 16) # Vissza hexából 10-esbe +79 +``` + +## Float - Tört + +Bármilyen számsorozat amiben van egy decimális pont. + +64 bites precízióra vagyunk képesek, tehát a max értéke +kb 1.8 \* 10^308-on lehet. +E fölött `inf`-nek értelmezi a Python. + +```python +>> 1.79e308 +1.79e+308 +>> 1.8e308 +inf +``` + +<Note type="tip" label> + +<Badge type="tip">Magyarázat</Badge> +Itt az `e` egy 10-es hatványt jelent és ilyenkor mindig +Float-ot kapunk vissza. +Pl.: `3e4 = 30000.0` + +</Note> + +```python +>>> 4e7 +40000000.0 +>>> .4e7 +4000000.0 +``` + +## Complex - Komplex szám + +Komplex szám ugyanúgy egy típus, mint az egész vagy a tört, +továbbá egyes kódolást megkönnyítő funkciókkal is rendelkezik. + +```python +>>> 2+3j # létrehozása: szám + szám * j +(2+3j) +>>> complex(2, -3) # Vagy konstruktort használva +(2-3j) +>>> complex("2-3j") # Akár szövegesen is jó +(2-3j) +>>> type(2+3j) +<class 'complex'> +>>> (2+3j).conjugate() +(2-3j) +>>> (2+3j).real +2.0 +>>> (2+3j).imag +3.0 +>>> pow(3 + 4j, 2) # Második hatványát vesszük +(-7+24j) +``` + +## String - Szöveg + +Jelölése `str` és hossza bármekkora lehet. (Megint a RAM a határ) + +`"`-k vagy `'`-k közti karaktersorozatot értünk `str`-nek + +```python +>>> "Egy szöveg vagyok" +'Egy szöveg vagyok' +>>> 'Én is' +'Én is' +``` + +Akár egy beépített `print` funkciót is használhatunk, +mely a különböző speciális karaktereket is kifogja írni. + +```python +>>> print("Egy kis szöveg") +Egy kis szöveg +``` + +Ha szeretnénk benne `"`-t, akkor **escapel**nünk kell, mely +igazából a speciális karakterek nem feldolgozását jelenti. +Ezt a `\` jel használatával tehetjük meg. + +```python +>>> print("Itt egy macskaköröm (") karakter.") + File "<stdin>", line 1 + print("Itt egy macskaköröm (") karakter.") + ^ +SyntaxError: invalid syntax +>>> print("Itt egy macskaköröm (\") karakter.") +Itt egy macskaköröm (") karakter. +``` + +<Note type="tip" label> + +<Badge type="tip">Error</Badge> +Részletesebben a [Hibák és azok kezelése](/guide/09_error) című fejezetben lesz szó a hibák működéséről. +Addig is látható, hogy a Python hogyan írja ki ezeket. + +</Note> + +Említettem, hogy a Python sorról sorra értelmezi a kódunk. +Mégis akkor hogyan írunk egy több soros szöveget például? +→ Escapelünk + +```python +>>> print("a + File "<stdin>", line 1 + print("a + ^ +SyntaxError: EOL while scanning string literal + +>>> print("a\ +... b\ +... c") +abc +``` + +Sőt, akár az escapelést is escapelhetjük. +<Badge type="danger"> +[Escapeception](https://inception.davepedu.com/) +</Badge> + +```python +>>> print('foo\\bar') +foo\bar +``` + +A sztringükben egyes speciális karakterek is lehetnek. +Ilyen például az új sor (`\n`) és a tabulátor (`\t`). + +```python +>>> print("a\tb") +a b +>>> print("a\141\x61") +aaa +>>> print("a\nb") +a +b +>>> print('\u2192 \N{rightwards arrow}') +→ → +``` + +Akár "raw" sztringünk is lehet. +Ebben nem kerülnek értelmezésre a speciális karakterek. + +```python +>>> print('C:\user\name') # \n új sort jelent +C:\user +ame +>>> print(r'C:\user\name') # vedd észre az r-t a szöveg előtt +C:\user\name +``` + +Tripla idézőjeles stringben lehet ugyanaz a karakter, +továbbá a sortörést is megőrzi. + +```python +>>> print('''Itt már minden is van, pl " és ' is.''') +Itt már minden is van, pl " és ' is. +``` + +Sőt ilyenkor az új sorok is belekerülnek. + +```python +>>> """Ez a +... szöveg több +... soros.""" +'Ez a\nszöveg több\nsoros.' +>>> print("""Ez a +... szöveg több +... soros.""") +Ez a +szöveg több +soros. +``` + +## Boolean - Logikai + +`True` vagy `False` értéke lehet. + +```python +>>> type(True) +<class 'bool'> +>>> type(False) +<class 'bool'> +``` + +A különböző típusainkat képesek vagyunk logikaira +konvertálni. +Ilyenkor szoktunk beszélni a Truthiness / Falsinessről. +Például hamis az üres sztring, a `0`. + +```python +>>> bool(0) +False +>>> bool("") +False +>>> bool("0") +True +>>> bool(2+3j) +True +>>> bool([]) # Üres lista (2 alfejezettel lejebb) +False +``` + +## Pár művelet a típusainkkal + +<Note type="tip" label> + +<Badge type="tip">Question of the Day</Badge> +A Python használható számológépként? + +</Note> + +```python +>>> 2 + 2 +4 +>>> 50 - 5*6 +20 +>>> (50 - 5*6) / 4 +5.0 +>>> 8 / 5 # Osztás mindig Float-tal tér vissza +1.6 +``` + +Az alap matematikai műveletek mellett pár extra +funkcionalitást is nyújt. + +```python +>>> 17 // 3 # Kerekítve osztás +5 +>>> 17 // 4 +4 +>>> 5 ** 3 # Hatványozás +125 +>>> 2 ** 7 +128 +>>> 1235 % 3 # Maradékos osztás +2 +``` + +<Note type="tip" label> + +<Badge type="tip">\_</Badge> +Ezek mellett egy másik érdekes beépített dolog +az interpreterbe, hogy vissza tudjuk kérni az +utoljára kapott értéket. + +</Note> + +```python +>>> afa = 27 / 100 # Így hozunk létre változót +>>> ar = 1314 +>>> afa * ar +354.78000000000003 +>>> ar + _ +1668.78 +>>> round(_, 1) # Első tizedesre kerekítünk +1668.8 +``` + +Egyébként lehet egy változó névben [UTF-8](https://en.wikipedia.org/wiki/UTF-8) karakter is. +Tehát az `Áfa = 27 / 100` is egy valid kód. +Viszont nem ajánlott, ugyanis lehet, hogy más is olvassa majd +a kódod, sőt az is lehet, hogy nem is ismeri a magyar nyelvet. + +Sztringeket akár össze tudunk adni `+`-al vagy +megismételni `*`-al. + +```python +>>> "ski" + 2 * "-ba-bop" + "-ba-dop-bop" +'ski-ba-bop-ba-bop-ba-dop-bop' # ?v=Hy8kmNEo1i8 +``` + +Ha csak szövegeink vannak, akkor el is hagyhatjuk a `+`-t és +automatikusan összevonásra kerülnek. + +``` +>>> 'Egy' 'be' +'Egybe' +``` + +Ez akkor hasznos például, ha egy hosszú szöveget szeretnénk +több sorban megadni. + +```python +>>> text = ('Írj pár dolgot így, ' +... 'hogy összevonásra kerüljenek') +>>> text +'Írj pár dolgot így, hogy összevonásra kerüljenek' +``` + +Viszont ugyanez a változókkal nem fog működni. + +```python +>>> gyumolcs1 = "alma" +>>> gyumolcs2 = "korte" +>>> gyumolcs1 gyumolcs2 + File "<stdin>", line 1 + gyumolcs1 gyumolcs2 + ^ +SyntaxError: invalid syntax +``` + +Sztringjeink egyes karaktereit akár indexelni is tudjuk: + +```python +>>> word = 'Python' +>>> word[0] # Karakter a 0. pozícióban +'P' +>>> word[5] # Karakter az 5. pozícióban +'n' +``` + +Akár visszafele is tudunk indexelni + +```python +>>> word[-1] # Hátulról az első karakter +'n' +>>> word[-2] # Hátulról a második karakter +'o' +>>> word[-6] +'P' +``` + +<Note type="tip" label> + +<Badge type="tip">Mutatók</Badge> +Indexeléskor az egyes karakterek memória címére mutatunk +rá. +Az ez alatti ábra ezt jól mutatja + +</Note> + +```python + +---+---+---+---+---+---+ + | P | y | t | h | o | n | + +---+---+---+---+---+---+ + 0 1 2 3 4 5 6 +-6 -5 -4 -3 -2 -1 +``` + +Indexelés mellett sliceolni is tudunk (szeletet kivenni). + +```python +>>> word[0:2] # Karakterek 0-tól (benne van) 2-ig (nincs benne) +'Py' +>>> word[2:5] # Karakterek 2-tól (benne van) 5-ig (nincs benne) +'tho' +``` + +Látható, hogy az eleje még benne van az indexnek, viszont +az utolsó nem. + +```python +>>> word[:2] + word[2:] +'Python' +>>> word[:4] + word[4:] +'Python' +``` + +## List - Lista + +Különböző típusainkat akár listába is tudjuk tenni. +Ehhez csak `[...]` közé kell tenni őket. + +```python +>>> negyzetszamok = [1, 4, 9, 16, 25] +>>> negyzetszamok +[1, 4, 9, 16, 25] +``` + +Ezt is tudjuk indexelni, továbbá sliceolni, mint a +sztringet. +_Hasonló logikát követ, mint a sztringnél_. + +```python +>>> negyzetszamok[0] # Visszatér az adott elemmel +1 +>>> negyzetszamok[-1] +25 +>>> negyzetszamok[-3:] # Slice visszatér egy új listával +[9, 16, 25] +``` + +Sztringgel ellentétben a megindexelt elemeink módosíthatóak. + +```python +>>> negyzetek = [1, 8, 27, 65, 125] # Az a 65 ott hibás! +>>> negyzetek[3] = 64 # Javítás +>>> negyzetek +[1, 8, 27, 64, 125] +``` + +Akár egy elemet ki is tudunk venni! + +```python +>>> negyzetek = [1, 8, 27, 65, 125] +>>> negyzetek = negyzetek[:3] + negyzetek[4:] +>>> negyzetek +[1, 8, 27, 125] +``` + +Akár a méretét is lekérhetjük a `len()` funkcióval. + +```python +>>> letters = ['a', 'b', 'c', 'd'] +>>> len(letters) +4 +``` + +Ugyanez a függvény (`len`) sztringekkel is működik. _próbáld ki!_ + +Akár a tömbünkbe tömböt is bele tehetünk. _próbáld ki!_ diff --git a/app/docs/guides/training/python/04_language_and_control.md b/app/docs/guides/training/python/04_language_and_control.md new file mode 100644 index 0000000000000000000000000000000000000000..8c7669f4fe7491f717999df3a7b0f56adb9add9e --- /dev/null +++ b/app/docs/guides/training/python/04_language_and_control.md @@ -0,0 +1,585 @@ +# Nyelvi dolgok és Vezérlési folyam + +<Note type="tip" label> + +**TL;DR Tartalom** + +- [Változók](#változók) - Létrehozás, dinamikus típus, törlés, + helyben csere +- [Indentáció](#indentáció) - Szóköz vagy tab, sor escapelés +- [if](#if) - if, elif, else, operátorok +- [while](#while-) - Példa +- [for ... in ...](#for--in-) - Iterálható objektumok, példa +- [range](#range) - Létrehozás, paraméterek +- [break, continue, else](#break-continue-else) - Példák +- [pass](#pass) - ¯\\_(ツ)_/¯ +- [funkciók](#funkciók) - Felépítés, dokumentáció + - [Argumentum](#argumentum) - Kötelező / nem, \* és \*\* + - [Lambda](#lambda) - Egy példa + +</Note> + +<Note label> + +**Extra feladatok** +_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb +megtanulni a dolgokat_ + +- Készíts egy függvényt, egy kapott IP címből és MASZK-ból + eldönti, hogy mi a hálózat amiben van. + (Spoiler: `.split('.')`) +- Implementálj egy szöveg rendezési algoritmust, mely + a paraméterben bármennyi szót kaphat és azok alapján + egy tömmbel tér vissza. + A függvény ezután legyen képes akár listákat is elfogadni + a paraméterében. +- Dokumentálj egy függvényt. + +</Note> + +## Változók + +Az előző fejezetben láttál pár változót, viszont +még részletesebben nem meséltem róluk. + +```python +>>> width = 20 +>>> height = 5 * 9 +``` + +Észreveheted, hogy semmi típus definíciónk nincs a +változónál. +Sőt, ezt a típust menet közben cserélhetjük is. + +```python +>>> test = 1 +>>> test +1 +>>> test = "alma" +>>> test +'alma' +``` + +Ez egy kényelmi része annak, hogy interpretált nyelv +a Python. +Menet közben képes rá az interpreter, hogy eldobja +az előző értéket, majd kicserélje egy teljesen újra +típustól függetlenül. + +<Note type="tip" label> + +<Badge type="tip">TypeError go brrr</Badge> +Ez a kényelem azt is jelenti, hogy gyakran futhatunk típus +hibákba. +Például feltételezzük, hogy egy változó szám és mégis +sztring lesz, akkor egy osztás műveletnél elszáll +a programunk. +Próbáld ki! _De csak saját felelősségre_ + +</Note> + +Mi van akkor, ha egy változóra többé nincs szükségünk? +A `del` segítségével azt ki tudjuk törölni. + +```python +>>> test = "alma" +>>> test +'alma' +>>> del test +>>> test +Traceback (most recent call last): + File "<stdin>", line 1, in <module> +NameError: name 'test' is not defined +``` + +Sőt akár egy listából is ki tudunk venni a `del` segítségével. + +```python +>>> # Előző fejezet kódja +... negyzetek = [1, 8, 27, 65, 125] +>>> negyzetek = negyzetek[:3] + negyzetek[4:] +>>> negyzetek +[1, 8, 27, 125] +>>> # Új kód +... negyzetek = [1, 8, 27, 65, 125] +>>> del(negyzetek[3]) +>>> negyzetek +[1, 8, 27, 125] +``` + +Másik elképesztő képessége a pythonnak, hogy akár +egyszerre több változót is tudunk létrehozni különböző +értékekkel. + +```python +>>> a, b = 2, 3 # a = 2, b = 3 +>>> print(a, b) +2 3 +``` + +Sőt akár meg is tudjuk őket cserélni **egy sorban** + +```python +>>> a, b = 2, 3 # a = 2, b = 3 +>>> a, b = b, a # a = 3 és b = 2 +>>> print(a, b) +3 2 +``` + +## Indentáció + +Indentációban a kód blokkosítását értjük, azaz mikor az egyes +logikai egységeket külön választjuk. +Például C-ben `{}` -el tudjuk ezt megtenni. + +Pythonban ehhez tabulátort vagy szóközt használunk. + +C++-ban: +_Megjelölt sorok 1-1 új blokkot kezdenek meg_ + +```cpp {highlight:[2, 4]} +int j = 0; +for (int i= 0; i < 10; i++) { + std::cout<<i + if (j % 2 == 0) { + std::cout<<"2-vel oszthato iteraciohoz ertunk" + } + j++ +} +``` + +Pythonban: + +```python {highlight:[2, 4]} +j = 0 +for i in range(0, 10): + print(i) + if j % 2 == 0: + print("2-vel oszthato iteraciohoz ertunk") + j += 1 +``` + +Ha netán elfelejtenénk indentálni, akkor szól a Python. + +```python +>>> if 1>0: +... print("hi") + File "<stdin>", line 2 + print("hi") + ^ +IndentationError: expected an indented block +``` + +Ilyenkor felismerte a Python, hogy egy új blokkot +kezdünk meg és beljebb fogunk kezdeni a következő sorban. + +Tabulátorral: (_ajánlott_) + +```python +>>> if 1 > 0: +... print("hi") +... +hi +``` + +Szóközzel: (_nehezen látható_) + +```python +>>> if 1 > 0: +... print("hi") # Itt van egy szóköz +... +hi +``` + +Egy feltételt akár több sorban is tudunk írni, csak +szimplán jelezzük az interpreternek egy escapeléssel. + +```python +>>> if 1 > 0 \ +... and 3 > 2: +... print("Több soros feltétel") +... +Több soros feltétel +``` + +## if + +`if`-nek több része is van. + +- `if`: Feltétel +- `elif`: else if, avagy egy különben ág feltétellel +- `else`: Ha már egy feltétel sem teljesül + +```python +>>> x = int(input("Adj meg egy számot: ")) +Adj meg egy számot: 42 +>>> if x < 0: +... x = 0 +... print('Negatív értéket 0-ra cseréltük') +... elif x == 0: +... print('Nulla') +... elif x == 1: +... print('Egy') +... else: +... print('Több') +... +Több +``` + +Az `input` függvény szöveget kér be, szóval át kellett alakítani. + +<Note type="tip" label> + +<Badge type="tip">Valaki felkapcsolta a lámpát?</Badge> +`switch` és a hozzá kapcsolódó `case` nincs a pythonban. +Helyette sok-sok `elif`-et tudunk írni. + +</Note> + +Feltételünket tovább tudjuk spékelni köztük elhelyezett +**logikai operátorok**kal. + +- `and`: `x < 3 and x > 0` +- `or`: `x >= 3 or x =< 0` +- `not`: `not (x < 3 and x > 0)` + +Sőt bit operátorok is elérhetőek. (`&`, `|`, `^`, `~`, ...) + +```python +>>> a = 10 # 1010 (binárisan) +>>> b = 6 # 0110 +>>> a & b # És operátor +2 # 0010 +``` + +## while ... + +Talán a legegyszerűbben magyarázható eszközunk a +pythonban. +Addig fut újra és újra, amig a feltétele igaz. + +```python +>>> iteracio_szam = 0 +>>> while True: +... iteracio_szam += 1 +... print(iteracio_szam) +... print("Nyomj CTRL + C -t, hogy megállíts") +``` + +<Note type="tip" label> + +<Badge type="tip">De lassú ez a terminálra kiíratás :/</Badge> +Ha kiveszed a kiíratásokat és ctrl + c után kiírod a változódat +azt fogod tapasztalni, hogy sokkal nagyobb lett az +`iteracio_szam`, mint kiíratásokkal. Szerinted miért? + +</Note> + +```python +>>> paros = False +>>> while True: +... if not paros: +... print("work hard") +... else: +... print("play hard") +... paros = not paros # ?v=5dbEhBKGOtY +``` + +## for ... in ... + +A for cíklus Pythonban lehetővé teszi, hogy +szekvenciákon menjünk végig. +Tehát nem a szokásos `ciklus i=0 ...`-t fogjuk eljátszani. + +Ilyen szekvencia például egy lista. + +```python +>>> # Írjunk ki egymás alá a szavakat: +... szavak = ['macska', 'kutya', 'horcsog'] +>>> for szo in szavak: +... print(szo) +... +macska +kutya +horcsog +``` + +Sőt a sztring is egy szekvencia. + +```python +>>> kszk = "KSZK" +>>> for betu in kszk: +... print(betu) +... +K +S +Z +K +``` + +Na és mi van akkor ha 0-tól 18-ig kiakarjuk írni a számokat? + +Sima ügy. + +```python +>>> for i in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]: +... print(i) +... +0 # ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ +1 # ░░░░░░░░░░░░░▄▄▄▄▄▄▄░░░░░░░░░ +2 # ░░░░░░░░░▄▀▀▀░░░░░░░▀▄░░░░░░░ +3 # ░░░░░░░▄▀░░░░░░░░░░░░▀▄░░░░░░ +4 # ░░░░░░▄▀░░░░░░░░░░▄▀▀▄▀▄░░░░░ +5 # ░░░░▄▀░░░░░░░░░░▄▀░░██▄▀▄░░░░ +6 # ░░░▄▀░░▄▀▀▀▄░░░░█░░░▀▀░█▀▄░░░ +7 # ░░░█░░█▄▄░░░█░░░▀▄░░░░░▐░█░░░ +8 # ░░▐▌░░█▀▀░░▄▀░░░░░▀▄▄▄▄▀░░█░░ +9 # ░░▐▌░░█░░░▄▀░░░░░░░░░░░░░░█░░ +10 # ░░▐▌░░░▀▀▀░░░░░░░░░░░░░░░░▐▌░ +11 # ░░▐▌░░░░░░░░░░░░░░░▄░░░░░░▐▌░ +12 # ░░▐▌░░░░░░░░░▄░░░░░█░░░░░░▐▌░ +13 # ░░░█░░░░░░░░░▀█▄░░▄█░░░░░░▐▌░ +14 # ░░░▐▌░░░░░░░░░░▀▀▀▀░░░░░░░▐▌░ +15 # ░░░░█░░░░░░░░░░░░░░░░░░░░░█░░ +16 # ░░░░▐▌▀▄░░░░░░░░░░░░░░░░░▐▌░░ +17 # ░░░░░█░░▀░░░░░░░░░░░░░░░░▀░░░ +18 # ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ +``` + +_Vagy használd a range nevezetű funkciót ez alatt_ + +### range + +Ez a funkció arra képes, hogy egy olyan iterálható +objektumot készítsen nekünk, melyet a for cíklus +képes elfogadni. +(Ne aggódj, nem generál egy 0-tól millióig tartó tömböt, +ennél okosabb) + +```python +>>> for i in range(5): # 0,1,2,3,4 +... print(i) +... +0 +1 +2 +3 +4 +``` + +Ez a `range` függvény több paramétert is elfogad. + +`range(mettől, meddig, lépésszám)` + +```python +range(5, 10) + 5, 6, 7, 8, 9 + +range(0, 10, 3) + 0, 3, 6, 9 + +range(-10, -100, -30) + -10, -40, -70 +``` + +Ha egy szekvencián mégis index alapján szeretnénk végig menni, +akkor tudjuk a `len`-t és a `range`-t kombinálni. + +```python +>>> abc = "abcdefghijklmnopqrstuvwxyz" +>>> for i in range(len(abc)): +... print(str(i) + ". betű: " + abc[i]) + +``` + +### break, continue, else + +Egy ciklus szokásos lefutásán tudunk módosítani is ha +szeretnénk. + +`break`: Kitör a legközelebi `for` vagy `while` ciklusból + +```python +>>> for i in range(5): +... print(i) +... if i == 3: +... break +... +0 +1 +2 +3 # 4-es számot szkippeltük +``` + +`continue`: Kihagyja a jelenlegi iteráció többi részét + +```python {highlight: [13]} +>>> for i in range(5): +... print("< " + str(i)) +... if i == 3: +... continue +... print("> " + str(i)) +... +< 0 +> 0 +< 1 +> 1 +< 2 +> 2 +< 3 # > 3 hiányzik utána +< 4 +> 4 +``` + +`else`: Akkor fut le, ha a ciklusban nem történik `break` +vagy valami error + +```python +>>> for i in range(5): +... print(i) +... else: +... print("Nem volt break") +... +0 +1 +2 +3 +4 +Nem volt break +``` + +```python +>>> for i in range(5): +... print(i) +... break +... else: +... print("Nem volt break") +... +0 +``` + +## pass + +¯\\_(ツ)_/¯ + +Nem csinál semmit. +Arra használható, ha szintaktikailag valahova írni kell +valamit. + +```python +>>> class MyEmptyClass: # Spoiler: Így néz ki egy osztály +... pass +... +``` + +Például hasznos lehet, ha a programozó még nem szeretne +implementálni egyes részeket. + +```python +>>> def how_to_make_a_lot_of_money(a): +... pass # TODO: Ne felejtsd el implementálni +... +``` + +## funkciók + +Hasonló, mint C-ben, viszont továbbra sincsenek típusaink + +`def funkció_neve(paraméterek):` + +Például így tudunk egy fibonacci kiíró funkciót készíteni: + +```python +>>> def fib(n): +... """Fibonacci sorozat kiíró n-ig.""" +... a, b = 0, 1 +... while a < n: +... print(a, end=' ') +... a, b = b, a+b +... print() +... +``` + +```python +>>> fib(2000) +0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 +``` + +<Note type="tip" label> + +<Badge type="tip">Dokumentáció</Badge> +Funkcióink első soraiban eltudunk helyezni dokumentációt, majd +azt később akár elérni. +Javasolt, hogy hasonlóképp dokumentáld a funkcióid. + +</Note> + +```python +>>> fib.__doc__ +'Fibonacci sorozat kiíró n-ig.' +``` + +### Argumentum + +Akár alapértelmezett argumentum definícióink is lehetnek. + +```python +>>> def primek_bejelentkezes_utan(udvozlo_uzenet, # vessző miatt +... max_probalkozas=4, # tudja a python +... hiba_eseten='Próbáld újra!'): # hogy több soros +... """Helyes jelszó beírása esetén kiírja az első 30 prímszámot""" +... pass # Próbáld implementálni +``` + +Ilyenkor a függvény hívásakor nem kötelező átadni az +alapértelmezett értékeket. + +Akár **kulcsszó** szerint is hívhatjuk a függvényeink. + +```python +>>> primek_bejelentkezes_utan(udvozlo_uzenet="Helló", +... max_probalkozas=3) +``` + +Sőt, nem kell minden paramétert feltüntetni! + +```python +>>> def hmmm(required, *tuple_arg, **dictionary_arg): +... print(required) +... print(tuple_arg) +... print(dictionary_arg) +``` + +És utána így tudjuk meghívni: + +```python +>>> hmmm("Kotelezo mezo", +... "ez mar nem", +... "ez se", +... foszereplo="Kata", +... postas="Pista") +``` + +Ilyenkor az arguments úgynevezett Tuple-ként működik, a +keywords pedig Dictionary-ként. Következő fejezetben lesz +ezekről szó. + +Egyenlőre látható, hogy `Tuple`-be csak az értékek +kerültek be sorban, míg a `Dictionary`-be már kulcs-érték +párosok. + +### Lambda + +Akár le is tudjuk rövidíteni a függvény definícióink. + +`lambda a, b: a + b`: Ilyenkor készítünk egy függvényt, +melynek a két paramétere `a` és `b` és visszatér ezek +összegével. + +```python +>>> f = lambda a, b: a+b +>>> f +<function <lambda> at 0x7fb0602f31f0> +>>> f(1, 2) +3 +``` diff --git a/app/docs/guides/training/python/05_data_structures.md b/app/docs/guides/training/python/05_data_structures.md new file mode 100644 index 0000000000000000000000000000000000000000..df1055b2993fe539353569a7370516b46a9a3c43 --- /dev/null +++ b/app/docs/guides/training/python/05_data_structures.md @@ -0,0 +1,272 @@ +# Adatstruktúrák + +<Note type="tip" label> + +**TL;DR Tartalom** + +- [List](#list) - Lista metódusai példával +- [Tuple](#tuple) - Példa és kapcsolódó metódusok +- [Sets](#sets) - Példa +- [Dictionary](#dictionary) - {kulcs: érték} + Példa és függvény paraméter +- [Iterálás](#iterálás) + - [Dictionary](#dictionary-2) - kulcs, értéken lehet egyszerre + - [enumerate](#enumerate) - megszámozva az elemeket + - [zip](#zip) - egyszerre több szekvencián + - [reversed](#reversed) - uno reverse card + +</Note> + +<Note label> + +**Extra feladatok** +_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb +megtanulni a dolgokat_ + +- Készíts egy `Tuple`-t, majd írd ki az elemeit úgy, hogy egyszerre + indulsz az elejétől és a végétől. + Pl.: ("A", "B", "C") esetén: (Spoiler: `zip`) + ``` + A C + B B + C A + ``` +- Készíts egy programot, mely megszámolja egy szövegben, + hogy az egyes betűkből mennyi van. (Spoiler: `Sets`) + +</Note> + +## List + +Listának az említetteken kívül van egy pár beépített függvénye. + +```python +>>> gyumolcs = ['narancs', 'alma', 'körte', 'banán', 'kiwi', 'alma', 'banán'] +>>> gyumolcs.count('alma') +2 +>>> gyumolcs.count('mandarin') +0 +>>> gyumolcs.index('banán') +3 +>>> gyumolcs.index('banán', 4) # Következő banán a 4. index után +6 +>>> gyumolcs.reverse() # Elemek megfordítása helyben +>>> gyumolcs +['banán', 'alma', 'kiwi', 'banán', 'körte', 'alma', 'narancs'] +>>> gyumolcs.append('szőlő') # Új elem a végére +>>> gyumolcs +['banán', 'alma', 'kiwi', 'banán', 'körte', 'alma', 'narancs', 'szőlő'] +>>> gyumolcs.sort() +>>> gyumolcs +['alma', 'alma', 'banán', 'banán', 'szőlő', 'kiwi', 'narancs', 'körte'] +>>> gyumolcs.pop() # Töröl egyet a végéről és azzal visszatér +'körte' +``` + +Például `stack`-ként egy listát elég egyszerűen lehet +használni ha csak az `append` és a `pop` függvényt használjuk. + +`pop` mellet tudunk akár a `del` -el is egy adott elemet +törölni. + +```python +>>> a = [-1, 1, 66.25, 333, 333, 1234.5] +>>> del a[0] +>>> a +[1, 66.25, 333, 333, 1234.5] +>>> del a[2:4] +>>> a +[1, 66.25, 1234.5] +>>> del a[:] +>>> a +[] +``` + +## Tuple + +Lista mellett `Tuple`-t is tudunk készíteni. + +Ezek definiálásához csak értékeket kell felsorolnunk +vesszővel elválasztva. +(Akár zárójelbe is tehetjük őket) + +```python +>>> t = 12345, 54321, 'hello!' +>>> t[0] +12345 +>>> t +(12345, 54321, 'hello!') +>>> # Több tuple-t össze illeszthetünk: +... u = t, (1, 2, 3, 4, 5) +>>> u +((12345, 54321, 'hello!'), (1, 2, 3, 4, 5)) +>>> # Nem tudjuk változtani az értékeit: +... t[0] = 88888 +Traceback (most recent call last): + File "<stdin>", line 1, in <module> +TypeError: 'tuple' object does not support item assignment +>>> # Viszont lehet bennük változtatható objektum: +... v = ([1, 2, 3], [3, 2, 1]) +>>> v +([1, 2, 3], [3, 2, 1]) +>>> v[0][0] = 4 +>>> v +([4, 2, 3], [3, 2, 1]) +``` + +Egy függvényben `*` -al tudjuk jelölni, hogy az extra mezőket +mely változóba szeretnénk tenni. + +```python +>>> def fv(*a): +... print(a) +... +>>> fv(2,3,4,5) +(2, 3, 4, 5) +``` + +Ilyenkor az átadott értékeket becsomagolja az a változóba, mint +Tuple. + +```python +>>> fv((1,2,3)) +((1, 2, 3),) +``` + +## Sets + +A `set` egy duplikátumok nélküli lista. +Köztük a különböző halmaz műveleteket is ellehet végezni. + +```python +>>> kosar = {'alma', 'narancs', 'alma', 'korte', 'narancs', 'banan'} +>>> print(kosar) # Duplikátumok törölve lettek +{'korte', 'banan', 'alma', 'narancs'} +>>> 'narancs' in kosar # Tudjuk a tagokat gyorsan ellenőrizni +True +>>> 'szilva' in kosar +False + +>>> # Alapértelmezett konstruktor a kapott sztringet +... # betűnként set-be konvertálja +>>> a = set('abracadabra') +>>> b = set('alacazam') +>>> # Halmaz műveletek +... +>>> a # Egyedi karakterek a-ban +{'b', 'c', 'a', 'd', 'r'} +>>> a - b # Betűk a-ban, de b-ben nem +{'d', 'b', 'r'} +>>> a | b # Betű a-ban vagy b-ben +{'b', 'c', 'm', 'z', 'a', 'l', 'd', 'r'} +>>> a & b # Betűk a-ban és b-ben is +{'a', 'c'} +>>> a ^ b # Betűk a-ban vagy b-ben, +{'b', 'm', 'l', 'z', 'd', 'r'} # metszetet kivéve +``` + +## Dictionary + +Kulcs - Érték párosokat tudunk ebben az adatstruktúrában +tárolni. + +```python +>>> telefon = {'bella': 4098, 'kata': 4139} +>>> telefon['attila'] = 4127 # Így tudunk kulcs szerint indexelni +>>> telefon +{'bella': 4098, 'kata': 4139, 'attila': 4127} +>>> telefon['bella'] +4098 +>>> del telefon['kata'] +>>> telefon['vivi'] = 4127 +>>> telefon +{'bella': 4098, 'attila': 4127, 'vivi': 4127} +>>> list(telefon) +['bella', 'attila', 'vivi'] +>>> sorted(telefon) +['attila', 'vivi', 'bella'] +>>> 'attila' in telefon +True +>>> 'bella' not in telefon +False +``` + +Hasonlóan a `Tuple`-höz, a függvényekben a `**`-al tudjuk +jelölni azon változót, melyben szeretnénk a +kulcs érték párosokat összegyüjteni. + +```python +>>> def fv(**dic): +... print(dic) +... +>>> fv(a=1, b=2, c=3) +{'a': 1, 'b': 2, 'c': 3} +``` + +## Iterálás + +A felsorolt objektumok mind iterálható objektumok, tehát +for ciklussal hasonlóan a listához végig tudunk menni rajtuk. + +### Dictionary + +Egy **Dictionary**-n kulcs és érték párossal tudunk +végig iterálni. + +```python +>>> kosar = {'alma': 23, 'korte': 41} +>>> for kulcs, ertek in kosar.items(): +... print(kulcs, str(ertek) + " db.") +... +alma 23 db. +korte 41 db. +``` + +### enumerate + +Ha indexel szeretnénk végig iterálni, akkor +az `enumerate` függvénnyel ezt megtudjuk oldani. + +```python +>>> for i, v in enumerate(['tic', 'tac', 'toe']): +... print(i, v) +... +0 tic +1 tac +2 toe +``` + +### zip + +Egyszerre akár több szekvencián is végig tudunk menni a +`zip` segítségével. + +```python +>>> kerdesek = ['neved', 'küldetésed', 'kedvenc szined'] +>>> valaszok = ['Szófia', 'Átmenni analízisból', 'Kék'] +>>> for k, v in zip(kerdesek, valaszok): +... print('Mi a {0}? {1}.'.format(k, v)) +... +Mi a neved? Szófia. +Mi a küldetésed? Átmenni analízisból. +Mi a kedvenc szined? Kék. +``` + +Itt használtam a `.format` függvényt. Ezzel egy szövegben +`{szám}`-al megjelölt helyekre tudjuk beilleszteni a paraméterben +megadott változókat. + +### reversed + +Akár meg is tudjuk fordítani a listánkat. + +```python +>>> for i in reversed(range(1, 10, 2)): +... print(i) +... +9 +7 +5 +3 +1 +``` diff --git a/app/docs/guides/training/python/06_modules.md b/app/docs/guides/training/python/06_modules.md new file mode 100644 index 0000000000000000000000000000000000000000..fb17b606d0d9409cb53d140c94d7ffb09994ecdd --- /dev/null +++ b/app/docs/guides/training/python/06_modules.md @@ -0,0 +1,206 @@ +# Modulok + +<Note type="tip" label> + +**TL;DR Tartalom** + +- [Fájl és enkódolás](#fájl-és-enkódolás) - + Fájl fibonaccival, enkódolás +- [Importálás](#importálás) - Importálás többféleképp +- [Szkriptként indítás](#szkriptként-indítás) - Elindítjuk + közvetlen a fájlt, \_\_main\_\_ + +</Note> + +<Note label> + +**Extra feladatok** +_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb +megtanulni a dolgokat_ + +- Készíts egy fájlt, melyben az eddig megírt függvényeid + összegyüjtöd +- Importáld be egy másik fájlba és kezd el használni. + Keletkezik valami új fájl? +- Írj egy szkriptet, ami az argumentumban kapott IP cím és + hálózati maszk párosról megmondja, hogy milyen hálózatban van, + továbbá, hogy mi a Broadcast címe. + (Tipp: Előzőleg írtál egy hasonló funkciót már) + +</Note> + +## Fájl és enkódolás + +Miután kilépsz az Interpreterből tapasztalhatod, +hogy elvesznek a módosításaid mikor újra belépsz. +Továbbá az is feltünhetett, hogy egy valamivel +bonyolultabb programot nehéz lenne csak +az interpreterben megírni. + +Erre megoldás, hogy egy fájlba írjuk meg a kódunkat, +majd pedig később azt fordítja le az interpreter. + +Ezeket a fájlokat a python alapértelmezette UTF-8 fogja +értelmezni. (python 2-ben ASCII volt az alap) +Ezt akár definiálhatjuk is ha a fájl elejére írjuk, hogy +`# coding=<Kódolás>` +`# coding=UTF-8` + +Egy modul egy fájl, melyben Python definíciók és utasítások +találhatóak. +Ezeknek a kiterjesztése `.py` + +Hozz létre egy fájlt `fibo.py` néven a kedvenc +szövegszerkesztődben. + +```python +# Fibonacci számokért felelős modul + +def fib(n): # Fibonacci kiírása n-ig + a, b = 0, 1 + while a < n: + print(a, end=' ') + a, b = b, a+b + print() + +def fib2(n): # Fibonacci-k listája n-ig + result = [] + a, b = 0, 1 + while a < n: + result.append(a) + a, b = b, a+b + return result +``` + +Az itt definiált függvényeket később más fájlokból is elérjük. + +## Importálás + +Akár az interpreterünkbe is tudjuk használni a definiált +függvényeink. + +```python +>>> import fibo +``` + +```python +>>> fibo.fib(1000) +0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 +>>> fibo.fib2(100) +[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] +>>> fibo.__name__ # modul neve +'fibo' +``` + +Akár egy lokális változóhoz is rendelhetjük egy modul +függvényét / változóját. + +```python +>>> fib = fibo.fib +>>> fib(500) +0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 +``` + +Többféleképp is importálhatunk. + +Ha csak pár függvényt szeretnénk: + +```python +>>> from fibo import fib, fib2 +>>> fib(500) +0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 +``` + +Ha az összes függvényt: + +```python +>>> from fibo import * +>>> fib(500) +0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 +``` + +Ha átszeretnénk nevezni: + +```python +>>> import fibo as fib +>>> fib.fib(500) +0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 +``` + +De akár ötvözhetjük az eddigieket is: + +```python +>>> from fibo import fib as fibonacci +>>> fibonacci(500) +0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 +``` + +## Szkriptként indítás + +Akár el is tudunk egy modult önállóan indítani. + +```shell-session +$ python3 fajl_neve.py <argumentumok> +``` + +Például nálam van egy ilyen fájl: + +```python +print("Első fájlba írt Python kódom") +py_szoveg = "Python" + +for betu in reversed(py_szoveg): + print(betu) + +if __name__ == '__main__': + print("main") +``` + +Ha ezt futtatom: + +```python +n +o +h +t +y +P +main +``` + +A modul neve `__main__`-re változott. +Így akár tudjuk ellenőrizni, hogy tényleg +az adott fájlt indítottuk-e és csak akkor +lefuttatni a programot. + +```python +if __name__ == "__main__": + import sys + fib(int(sys.argv[1])) +``` + +Ilyenkor a python nem fogja feldolgozni 1-1 importáláskor +a feltételben lévő dolgokat, mivel nem azt indítottuk. +Ezt tudjuk is ellenőrizni egy interpreterben. +Próbáld ki if-el és a nélkül. + +```python +>>> import fibo +``` + +Láthattuk ennél a kódnál, hogy a `sys` nevű modult beimportáltuk, +majd az argv tömbből lekértük az első elemet. +Ez valójában a kapott argumentumokat jelenti a függvény +meghívásakor. + +```shell-session +$ python fibo.py 50 +0 1 1 2 3 5 8 13 21 34 +``` + +Az importált modulokat a python folyamatosan cacheli a +`__pycache__` nevű mappában. +Importáld be a fibo.py fájlodat egy másik fájlba és nézd meg mi +történik. + +_The Cake: 🍔_ diff --git a/app/docs/guides/training/python/07_scope_class.md b/app/docs/guides/training/python/07_scope_class.md new file mode 100644 index 0000000000000000000000000000000000000000..579b815bb1d881587989ca934da91b832eba0139 --- /dev/null +++ b/app/docs/guides/training/python/07_scope_class.md @@ -0,0 +1,509 @@ +# Scope és Osztály + +<Note type="tip" label> + +**TL;DR Tartalom** + +- [Osztályok](#osztályok) - Ízelítő az osztályokról +- [Elnevezések](#elnevezések) - snake_case, UpperCaseCamelCase +- [Scope](#scope) - általánosságban + - [Built-in Namespace - Beépített névtér](#built-in-namespace---beépített-névtér) - + bárhol elérhető objektumok + - [Global Namespace - Globális névtér](#global-namespace---globális-névtér) - + Modulon belül elérhető objektumok + - [Local Namespace - Lokális névtér](#local-namespace---lokális-névtér) - + Lokálisan, függvény példák, katalógus +- [Python osztály](#python-osztály) - Felépítés, + példák, init és dunder metódusok +- [Láthatóság](#láthatóság) - \_ -al privátnak tekintjük +- [Öröklés](#öröklés) - `Osztály(Ős1, Ős2, ...)`, + Melyik függvényt hívjam? + - [super](#super) - Függvény keresés egy sorrend + alapján + +</Note> + +<Note label> + +**Extra feladatok** +_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb +megtanulni a dolgokat_ + +- Készíts osztályokat a kutyáknak, macskáknak és a + medvéknek úgy, hogy ezeknek legyen ősosztálya és + a legtöbb közös tulajdonságot reprezentálja. +- Injektálj be egy osztályt a kutyák és a készített + ősosztály közé úgy, hogy minden konstruktor + lefusson. (Tipp: super) + +</Note> + +## Osztályok + +Az osztályok egy lehetőséget biztosítanak, hogy +az adatainkat és a hozzájuk kapcsolódó funkcionalitást +összecsatoljuk. +Osztályainkból különböző objektumokat tudunk létrehozni, +melyek saját egyedi adatokkal rendelkeznek. +Ezek mellett az egyes osztályainknak lehetnek leszármazottaik, +melyek az ősosztály funkcionalitásait és adatait +megöröklik. + +Na de miért használnék Pythonban osztályokat? +Először is biztosítja, hogy objektum orientált szemlélettel +dolgozzunk, továbbá függvényben mikor objektumot adunk át, +akkor valójában a háttérben csak egy arra mutató pointert +visz tovább a Python, tehát sokkal hatékonyabbá válik +a program. +Továbbá az objektumainkat tudjuk a függvényen +belül módosítani és nem csak egy másolatával dolgozunk. + +## Elnevezések + +Pythonban a függvényeinket és változóinkat szokás +`snake_case`-esítve írni. Ez annyit jelent, hogy +minden betű kisbetűs és a szóköz helyett `_`-k vannak. + +Osztályainkat pedig `UpperCaseCamelCase` írjuk, azaz +egybe, és minden szó kezdő betűjét nagy betűvel +szóköz nélkül. + +## Scope + +Ahhoz, hogy megértsük, hogy hogyan tudunk egy objektumhoz +adatot hozzá csatolni, meg kell értsük a Scope-okat is. + +A Python folyamatosan menedzseli a jelenleg kezelt neveket +és hozzájuk tartozó objektumokat. +Egy katalógusként tudod ezt az egészet elképzelni. +Ezeket névtereknek (namespace) nevezzük és több +fajtáját különböztetjük meg. + +### Built-in Namespace - Beépített névtér + +Itt vannak azok az objektumok, melyeket bármikor elérünk a +kódunkban. + +```python +>>> dir(__builtins__) +['ArithmeticError', 'AssertionError', 'AttributeError', ... ] +``` + +### Global Namespace - Globális névtér + +Bármi, amit a futtatott programunkon definiáltunk. +Minden modulhoz készül egy ilyen. +A modulon belül bárhonnan elérjük az itt definiált +dolgokat. + +### Local Namespace - Lokális névtér + +Minden függvényen belül egy saját névteret készít +a python. Tehát ha belül definiálunk egy változót, +az csak azon a funkción belül lesz elérhető. + +```python +>>> def fv(): +... a = 3 +... if a == 1: +... b=2 +... print(a) +... print(b) +... +>>> fv() +3 +Traceback (most recent call last): + File "<stdin>", line 1, in <module> + File "<stdin>", line 6, in fv +UnboundLocalError: local variable 'b' referenced before assignment +``` + +Látható, hogy ennél a példánál még az `if` ágon belüli `b` is +létezik, viszont nem kapott értéket és emiatt Error-t kaptunk. + +Például egy nem létező változóval: + +```python +def fv2(): +... a = 3 +... if a == 1: +... b=2 +... print(a) +... print(not_existing_variable) +... +>>> fv2() +3 +Traceback (most recent call last): + File "<stdin>", line 1, in <module> + File "<stdin>", line 6, in fv2 +NameError: name 'not_existing_variable' is not defined +``` + +Itt már azt a hibát kaptuk, hogy a változót nem is hoztuk létre. + +Ezt úgy képzeld el, hogy a Python mikor sorról sorra +végigment a kódon, akkor felépített minden funkción belül +egy saját katalógust a változóknak és oda felírta a talált +neveket. +Viszont az értékeket csak akkor írta bele, ha ténylegesen +kapott is. + +## Python osztály + +Na és akkor nézzük meg, hogy hogyan néz ki egy osztály. + +```python +class OsztalyNev: + . + . + . +``` + +Hogy legyen is benne valami: + +```python +>>> class Osztalyom: +... """A simple example class""" # Dokumentáció +... i = 12345 +... def f(self): +... return 'hello world' +... +``` + +Ebből tudunk egy példányt készíteni: + +```python +>>> x = Osztalyom() # Példányosítás +>>> x.i +12345 +``` + +Ilyenkor meghívódott az alapértelmezett konstruktora. + +Ha saját konstruktort szeretnénk, akkor a beépített +**\_\_init\_\_** függvényt tudjuk felhasználni. + +A különböző objektumainknak megannyi ilyen beépített +függvénye van egyébként. +Például felültudjuk írni, hogy mi történjen, +ha az objektumot összeszorozzuk valamivel, +vagy mit írjon ki ha simán ki Printeljük és így tovább. +_Ezeket Double Underscore, azaz "Dunder" metódusoknak +hívják_ +[Részletesebben](https://docs.python.org/3/reference/datamodel.html) + +```python +>>> class Osztalyom: +... """Egy példa osztály""" +... i = 12345 # Minden objektum által megosztott +... def f(self): +... return 'hello world' +... def __init__(self): # +... self.data = [] +``` + +Egy érdekes különbség C-től, hogy a változóinkat +nem definiáljuk közvetlen, hanem az init metódusában +vesszük fel őket. +Ha ezt nem így tennénk, akkor valójában egy statikus +minden objektum közt megosztott változót készítenénk. + +A konstruktor metódusunkban feltűnhet az első paraméter. +Ez az a változó, mely a jelenleg létrejövő objektumra mutat. +Ha ehhez hozzáírunk új adatokat, akkor csak abban lesz benne. + +```python +>>> class Komplex: +... def __init__(self, valos, imaginarius): +... self.r = valos +... self.i = imaginarius +... +>>> x = Komplex(3.0, -4.5) +>>> x.r, x.i +(3.0, -4.5) +``` + +Statikus változóval ilyesmi problémába üzközhetünk bele: + +```python +class Dog: + + tricks = [] + + def __init__(self, name): + self.name = name + + def add_trick(self, trick): + self.tricks.append(trick) + +>>> d = Dog('Fido') +>>> e = Dog('Buddy') +>>> d.add_trick('roll over') +>>> e.add_trick('play dead') +>>> d.tricks +['roll over', 'play dead'] +``` + +Helyesen: + +```python +class Dog: + def __init__(self, name): + self.name = name + self.tricks = [] # Minden kutyánál saját lista lesz + + def add_trick(self, trick): + self.tricks.append(trick) + +>>> d = Dog('Fido') +>>> e = Dog('Buddy') +>>> d.add_trick('roll over') +>>> e.add_trick('play dead') +>>> d.tricks +['roll over'] +>>> e.tricks +['play dead'] +``` + +Erre a magyarázat, hogy ezekre az objektumokra csak mutatók +készülnek. +Tehát mikor mi definiáltuk az osztályunk akkor készítettünk +egy új listát `[]`, majd pedig a tricks változót rámutattuk a +listánkra. +Ezt követően mikor ebből új példányokat képeztünk, +akkor ugyanazokat a mutató értékeket kapták az egyes +leszármazottak. + +## Láthatóság + +Pythonban az osztályokban a tagváltozók és függvények +publikusan elérhetőek és nem lehet őket priváttá tenni. +Erre egy konvenció, hogyha `_`-al kezdődik a nevük, akkor +privátként kezeljük őket. +Ekkor nem lesznek privátak, ugyanúgy publikok maradnak, +viszont ha valaki hozzányúl a kódhoz, akkor nem fogja +ezeket használni, legfeljebb Getter, Setteren keresztül. + +```python +class Lathatosag: + def __init__(self, privat_info): + self.privat_info = privat_info + + def get_privat_info(self): + return self.privat_info + + def set_privat_info(self, uj_ertek): + self.privat_info = uj_ertek + +``` + +## Öröklés + +Mikor egy osztályból leöröklünk, akkor a gyerekosztály +megjegyzi az ősét és később tudunk rá hivatkozni. +Az egyes függvények és változók elérhetőek +a leszármazott osztály `self`-jében, viszont hogy +pontosan melyik ősosztály függvényét hívjuk, ha +egyezés van köztük az nem egyértelmű elsőre ha +például több osztályunk is van. + +Nézzük is meg! +(`Osztálynév(Ősosztály, ...)`) + +```python +class A: + pass + +class B(A): + pass + +b = B() # Példányosítottuk +print(isinstance(b, A)) +# isinstance metódus ellenőrzi, hogy leszármazottja-e +# az objektumunk A-nak + +# Kimenet: +# True +``` + +Akár több osztályt is megadhatunk ősosztálynak. + +Tegyünk bele pár konstruktort + +```python +class A: + def __init__(self): + print("A") + +class B(A): + def __init__(self): + print("B") +``` + +Mit gondolsz, példányosításkor mi fog történni? + +```python +b = B() + +# Kimenet: +# B +``` + +Nem futott le az A konstruktora. +Ezt két féleképp tudjuk megoldani. + +```python +class A: + def __init__(self): + print("A") + +class B(A): + def __init__(self): + A.__init__(self) # Explicit meghívjuk A konstruktorát + print("B") + +b = B() + +# Kimenet: +# A +# B +``` + +### super + +Másik megoldás, hogy használjuk a beépített `super` függvényt. + +```python +class A: + def __init__(self): + print("A") + +class B(A): + def __init__(self): + super().__init__() + # ez super(B, self).init() -ként is írhatnánk + # alapértelmezetten az üres verzió python 3-ban + # (B, self)-re egészül + print("B") + +b = B() + +# Kimenet: +# A +# B +``` + +A `super` függvény ilyenkor egy úgynevezett +metódus feloldási sorrendet követve végigjárja +a megadott osztálytól kezdve az ősosztályokat +és megkeresi a megfelelő függvényt, majd megáll. +Tehát a fenti példánál megtalálta `A`-ban az +`__init__` függvényt és abbahagyta a keresést, +majd meghívta a függvényt. + +A metódus feloldási sorrendünk ez esetben: + +```python +print(B.__mro__) # Method Resolution Order + +# Kimenet: +# (<class '__main__.B'>, +# <class '__main__.A'>, +# <class 'object'>) +``` + +Mikor a `super`-t alapértelmezetten `B`-től indítottuk, +akkor a következő `A` osztályban kereste meg az `__init__` +függvényt. + +_Azt is észrevehetted, hogy alapértelmezetten az osztályaink +az object osztályból öröklődnek_ + +Na de miért használjak `super` -t? + +```python +class A(object): + def __init__(self): + print('A.__init__(self) -t hívtunk') + +class B(A): + def __init__(self): + print('B.__init__(self) -t hívtunk') + A.__init__(self) # Nem használtam Super-t + +class C(A): + def __init__(self): + print('C.__init__(self) -t hívtunk') + super(C, self).__init__() # Használtam Supert +``` + +Ha netán úgy döntenénk, hogy ezekből az osztályokból +leszeretnénk származni, de úgy, hogy +A alá még helyezünk egy osztályt, így: + +<!--TODO picture--> +<img + src={require('./injektalas.svg').default} + border="false" + width="100%" +/> + +```python +class Injektalt_Osztaly(A): + def __init__(self): + print('Injektalt_Osztaly.__init__(self) -t hívtunk') + super(Injektalt_Osztaly, self).__init__() + +class B_bol(B, Injektalt_Osztaly): + pass + +class C_bol(C, Injektalt_Osztaly): + pass + +B_bol() +# Kimenet: +# B.__init__(self) -t hívtunk +# A.__init__(self) -t hívtunk + +C_bol() +# Kimenet: +# C.__init__(self) -t hívtunk +# Injektalt_Osztaly.__init__(self) -t hívtunk +# A.__init__(self) -t hívtunk +``` + +Miért nem futott le a B_bol esetén? +Nézzük meg a metódus feloldási sorrendet + +`<class '__main__.B_bol'>,` +`<class '__main__.B'>,` +`<class '__main__.Injektalt_Osztaly'>,` +`<class '__main__.A'>,` +`<class 'object'>` + +`B_bol` osztály után meghívódott `B` konstruktora, +mert az alapértelmezett konstruktora `B`-nek meghívja +a `super()` függvényt. +Ezt követően `B`-ben a következő hívás `A`-ra fog +mutatni. +Ezt követően pedig a végére érünk és ha hívnánk +újabb `super`-t, akkor már az object jönne. + +Mikor a `C_bol` osztályból indultunk, akkor `C` +osztályban a `super` függvény lefutott és +az `Injektalt_Osztaly`-ban megtalálta a függvényünk. + +<Note type="tip" label> + +<Badge type="tip">Összefoglalva</Badge> +Mikör öröklünk és a super függvényunk használjuk, +akkor felépít egy metódus feloldási sorrendet attól +függően, hogy hogyan definiáltuk az osztályainkat. +Ezt követően mikor hívogatjuk a super-eket, +akkor mindig a sorrendben következő fog jönni, kivéve +ha átugorjuk, mert statikusan definiáljuk, hogy +melyik a következő osztály. + +A super-el akár más függvényeket is megtudunk így találni. + +</Note> diff --git a/app/docs/guides/training/python/08_error.md b/app/docs/guides/training/python/08_error.md new file mode 100644 index 0000000000000000000000000000000000000000..c7fe85aec13d977872467a6b129b76d377af27ca --- /dev/null +++ b/app/docs/guides/training/python/08_error.md @@ -0,0 +1,204 @@ +# Hibák és azok kezelése + +<Note type="tip" label> + +**TL;DR Tartalom** + +- [Hibák általánosságban](#hibák-általánosságban) - + Objektumok, példák +- [Hibakezelés](#hibakezelés) + - [Saját hiba osztályok](#saját-hiba-osztályok) - Ugyanolyan + osztály + - [try ... catch ...](#try--catch-) - Dobunk és elkapunk hibát + - [else](#else) - Semmi hiba nem volt, csinálj valamit + - [raise](#raise) - Hibával dobálózás + - [finally](#finally) - Még a returnt is felülírjuk + +</Note> + +<Note label> + +**Extra feladatok** +_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb +megtanulni a dolgokat_ + +- Készíts egy saját hiba osztályt, melyben letárolsz + egy számot és híváskor kiírja azt. + (Tipp: `__init__`, `__str__`) +- Imént definiált hibát kapd el, irasd ki és ne hagyd + miatta leállni a programot. + +</Note> + +## Hibák általánosságban + +Python, mint magasszintű nyelv hibák dobására és azok +kezelésére is képes. +Ezek olyan objektumok, melyekkel a program futásának +vezérlési szerkezetét tudjuk megszakítani, majd valahol +lekezelni őket. + +Alapvetően ha nem kerülnek lekezelésre, akkor a futás megáll +és a hibát kiírja nekünk az interpeter. +A leggyakoribb hiba, amivel a Python tanulása közben fogsz +találkozni, az a SyntaxError. + +```python +>>> while True print('Hello world') + File "<stdin>", line 1 + while True print('Hello world') + ^ +SyntaxError: invalid syntax +``` + +Valamennyire próbál neked segíteni a fordító mikor ilyen +keletkezik. + +Még egy pár hiba: + +```python +Traceback (most recent call last): + File "<stdin>", line 1, in <module> +ZeroDivisionError: division by zero +>>> 4 + spam*3 +Traceback (most recent call last): + File "<stdin>", line 1, in <module> +NameError: name 'spam' is not defined +>>> '2' + 2 +Traceback (most recent call last): + File "<stdin>", line 1, in <module> +TypeError: Can't convert 'int' object to str implicitly +``` + +## Hibakezelés + +### Saját hiba osztályok + +Tudunk készíteni saját hibákat. +Ehhez csak egy osztályt kell készítenünk. + +```python +class ForgovillaHiba(Exception): # Leszármazik az Exceptionből + """Valami baj van a forgóvillával""" + pass # sad SCH noises +``` + +### try ... catch ... + +`try` és `except` kulcsszavakkal eltudjuk kapni a különböző +hibáinkat. + +```python +>>> while True: +... try: +... x = int(input("Adj meg egy számot: ")) +... break +... except ValueError: +... print("Ez nem egy szám...") +... +``` + +A `try`-on belüli részen ha keletkezik bármilyen hiba, akkor +azonnal tovább dobja az `except`-hez. +Itt definiálhatjuk, hogy milyen típusú hibát szeretnénk +elkapni. + +Akár többet is elkaphatunk egyben: + +```python +... except (RuntimeError, TypeError, NameError): +... pass +``` + +Az `except` részben definiált osztályok akkor kapják el +az adott hibát, ha kompatibilisek a dobott hibával. + +Tanulmányozd, hogy mit dob ez esetben a kód: + +```python +class B(Exception): + pass + +class C(B): + pass + +class D(C): + pass + +for osztaly in [B, C, D]: + try: + raise osztaly() + except D: + print("D") + except C: + print("C") + except B: + print("B") +``` + +Különböző dobott hibákat akár le is menthetjük +egy változóba, majd annak tartalmával dolgozhatunk. + +```python +import sys + +try: + f = open('fajl.txt') + s = f.readline() + i = int(s.strip()) +except OSError as err: + print("OS error: {0}".format(err)) +except ValueError: + print("Nem sikerült intbe konvertálni.") +except: # Minden más + print("Váratlan hiba:", sys.exc_info()[0]) + raise +``` + +### else + +Egy `try`, `catch` blokk legvégére tehetünk egy `else`-t, +hogy lefuttasunk valamit ha nem történt semmi hiba. + +### raise + +Mi is tudunk hibákat dobni a `raise` +kulcsszó segítségével. + +```python +>>> raise NameError('HiThere') +Traceback (most recent call last): + File "<stdin>", line 1, in <module> +NameError: HiThere +``` + +```python +>>> try: +... raise NameError('HiThere') +... except NameError: +... print('Egy hiba történt!') +... raise +... +An exception flew by! +Traceback (most recent call last): + File "<stdin>", line 2, in <module> +NameError: Egy hiba történt! +``` + +### finally + +Végül pedig a `try` lefutása után tudunk definiálni még +lépéseket. +Az itt definiált dolgok mindenképp lefognak futni, ha volt, +ha nem volt hiba. + +```python +>>> def fv(): +... try: +... return True +... finally: +... return False +... +>>> fv() +False +``` diff --git a/app/docs/guides/training/python/09_virtual_env.md b/app/docs/guides/training/python/09_virtual_env.md new file mode 100644 index 0000000000000000000000000000000000000000..436479da4518f4cebf24b85a7dfdda3f2bd34b6f --- /dev/null +++ b/app/docs/guides/training/python/09_virtual_env.md @@ -0,0 +1,166 @@ +# Virtuális környezet + +<Note type="tip" label> + +**TL;DR Tartalom** + +- [Bevezető](#bevezető) +- [Hogyan készítünk ilyen környezetet?](#hogyan-készítünk-ilyen-környezetet) - `-m venv`, `source` +- [Csomagkezelés Pip-el](#csomagkezelés-pip-el) - + `pip`, `install`, `show`, `freeze`, telepítés requirementsből + +</Note> + +<Note label> + +**Extra feladatok** +_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb +megtanulni a dolgokat_ + +- Készíts el a saját környezeted, lépj bele és telepíts + fel egy szerinted funky csomagot. + Használd a kódodban. + Végül pedig tedd egy másik virtuális környezetbe a projektet + és érd el, hogy az ott is működjön a kódod. + +</Note> + +## Bevezető + +Az alap könyvtáraink (modulok) mellett néha szükségünk van +mások által megírt könyvtárakra is. +Erre egyik lehetőségünk, hogy az adott csomagot feltelepítjük +a gépünkre és onnantól a python majd megtalálja mikor +beimportáljuk a kódunkba. +Másik lehetőség, hogy felépítünk egy virtuális környezetet és +csak azon belülre helyezünk egyes könyvtárakat amikre +szükségünk lesz. + +## Hogyan készítünk ilyen környezetet? + +Nyissunk egy új mappát, majd pedig ott adjuk ki a +`python3 -m venv tutorial-env` parancsot. +Ekkor keletkezik egy mappa, melyben megtalálható minden +konfigurációnk ami a virtuális python környezetünkhöz kell. + +Hogy átlépjünk ebbe a környezetbe, OS-től függően: + +- Windows: `tutorial-env\Scripts\activate.bat` +- Linux / MacOS: `source tutorial-env/bin/activate` + +Miután ezt kiadtuk, látni fogjuk a terminálunkban, hogy +ezt jelöli is. + +```shell-session + ...$ source tutorial-env/bin/activate +(tutorial-env) ...$ python +``` + +```python +Python 3.8.5 (default, Jan 27 2021, 15:41:15) +[GCC 9.3.0] on linux +Type "help", "copyright", "credits" or "license" for more information. +>>> +``` + +Ekkor már elég volt a `python` parancsot kiadnom, hogy a 3-as +verzióval induljon az interpreter. +Ez azért van, mert python3-al hoztam létre a virtuális +környezetem. +Ha belelépek, utána már az ekkor definiált pythont fogja +használni. + +## Csomagkezelés Pip-el + +Ahhoz, hogy külső csomagokat tudjunk behozni a projektünkhöz, +a `pip` nevezetű csomagkezelőt fogjuk használni. + +Ellenőrizd, hogy elérhető-e a `pip`. +`python -m pip --version` +Ennek a parancsnak működnie kell ha benne vagy az +environmentben. +Python 3 esetén a 3.4-nél nagyobb verziónál +bele kerül generáláskor. + +A [PyPi](https://pypi.org/) honlapján lehet böngészni +az elérhető csomagokat. +Mikor ezt írtam kb. 292 ezer volt. + +Na miután megtaláltunk álmaink csomagját, azt letudjuk +tölteni a jelenlegi virtuális környezetünkbe. + +```shell-session +$ pip install requests +``` + +Megtudjuk akár nézni 1-1 csomag adatait a terminálból. + +```shell-session +$ pip show requests +Name: requests +Version: 2.25.1 +Summary: Python HTTP for Humans. +Home-page: https://requests.readthedocs.io +Author: Kenneth Reitz +Author-email: me@kennethreitz.org +License: Apache 2.0 +Location: /tmp/sad/tutorial-env/lib/python3.8/site-packages +Requires: certifi, chardet, urllib3, idna +Required-by: +``` + +Mostmár elméletileg fel van telepítve a környezetünkben, +de azért nézzük meg. + +```shell-session +$ pip list +Package Version +------------- --------- +certifi 2020.12.5 +chardet 4.0.0 +idna 2.10 +pip 20.0.2 +pkg-resources 0.0.0 +requests 2.25.1 +setuptools 44.0.0 +urllib3 1.26.3 +``` + +És itt van 2.25.1-es verzióval. + +Ha más gépre át akarjuk vinni a kért csomagokat, akkor +akár ezt a listát ki is tudjuk exportálni és akkor +később bárhol feltudjuk állítani ugyanezt a környezetet. + +```shell-session +$ pip freeze > requirements.txt +$ cat requirements.txt +certifi==2020.12.5 +chardet==4.0.0 +idna==2.10 +requests==2.25.1 +urllib3==1.26.3 +``` + +Készítettünk egy fájlt, ahol fel van listázva az összes +csomag és kapcsolódó verziók. +Ha csinálunk egy új virtuális környezetet, akkor ebből +feltudjuk telepíteni a csomagjainkat. + +```shell-session +$ python -m pip install -r requirements.txt +Collecting certifi==2020.12.5 + Using cached certifi-2020.12.5-py2.py3-none-any.whl (147 kB) +Collecting chardet==4.0.0 + Using cached chardet-4.0.0-py2.py3-none-any.whl (178 kB) +Collecting idna==2.10 + Using cached idna-2.10-py2.py3-none-any.whl (58 kB) +Collecting requests==2.25.1 + Using cached requests-2.25.1-py2.py3-none-any.whl (61 kB) +Collecting urllib3==1.26.3 + Using cached urllib3-1.26.3-py2.py3-none-any.whl (137 kB) +Installing collected packages: certifi, chardet, idna, urllib3, requests +Successfully installed certifi-2020.12.5 chardet-4.0.0 idna-2.10 requests-2.25.1 urllib3-1.26.3 +``` + +_És igazából ezek az alapjai a virtuális környezetnek_ diff --git a/app/docs/guides/training/python/10_exercise.md b/app/docs/guides/training/python/10_exercise.md new file mode 100644 index 0000000000000000000000000000000000000000..6046978671133293dfb67f2f878ddd2508494387 --- /dev/null +++ b/app/docs/guides/training/python/10_exercise.md @@ -0,0 +1,242 @@ +# Gyakorlat + +## 0. Virtuális környezet és Modulok bemutatása + +### Beépített fájlkezelő modul + +Alapból a Python a rendszerünkre feltelepített csomagokat fogja használni, melyeket +be is tudunk importálni a fájlunkba. +Alapértelmezetten rengeteg beépített modullal rendelkezünk, például +tudunk fájlokat kezelni, melyet próbáljunk ki! + +```python +# Beolvasás +# +# builtins.py fájlból jön ez az "open" függvény +# első paramétere a fájl neve és mindig onnan értékelődik ki +# ahonnan indítottuk a pythont. +# utána jövő paraméter, hogy hogyan nyitjuk meg a fájlt. +# r - read +# w - write: felülírja az egészet +# a - append: fájl végére ír hozzá +# x - Create: Létrehozza a fájlt. + +# r,w,a,x -et próbálják ki + +# Készítsenek egy 01_file.txt -t vagy hasonlót + +# Read: +fajl = open("01_file.txt", "r") +print(fajl.read()) + +fajl.close() # Mindig zárják be + +# Write +fajl = open("01_file.txt", "w") +fajl.write("Okay. ") +# Mi történt a fájlal? - Felülírta teljesen + + +fajl.close() + +# Append +fajl = open("01_file.txt", "a") +fajl.write("Okay?") +# Mi történt? - Végére írta + + +fajl.close() + + +# Create +fajl = open("something_new.txt", "x") +# Mi történt? - Létrehozta +# Ha újra lefutatják mi történik? - Errort kaptunk, ezt kezeljük is le! + +fajl.close() +``` + +### Hibakezelés + +```python +# Előző példában fájl újra létrehozáskor kaptunk +# egy hibát! +# Python ezeket az úgynevezett "objektumokat" szokta +# dobni, mikor hiba keletkezik és különféle +# adatokkal rendelkeznek, mint üzenet. +# Előzőben volt egy: FileExistsError: [Errno 17] File exists: 'something_new.txt' + +try: # Ezen a blokkon belüli dolgokat majd elkapja + fajl = open("something_new.txt", "x") + fajl.close() # Ha errort kap, akkor nem nyitja meg a fájlt, + # szóval nem kell a finally blokkba tenni +except FileExistsError as fe: # Itt feltudjuk típus szerint sorolni, hogy mit kapjon el. + print(fe) # Ha oda írjuk, hogy "as ...", akkor abba bele menti. + # Első körben as nélkül. "Hogyan tudnánk kiírni a hibát?" + + +# Ezután írjuk ki, hogy "kész a fájl" hibától független + +try: + fajl = open("something_new.txt", "x") + fajl.close() # Ha errort kap, akkor nem nyitja meg a fájlt, + # szóval nem kell a finally blokkba tenni +except FileExistsError as fe: + print(fe) +finally: + print("Fájl elkészítve! (Vagy már el volt)") +``` + +### Virtuális környezet + +Láttuk, hogy hogyan tudunk beépített modullal fájlt kezelni, de mi van akkor ha +egy külső csomagot szeretnénk használni? +Feltelepíthetjük, viszont feleslegesen terhelnénk vele a rendszerünket. +Ennek megoldására tudunk `virtuális környezeteket` készíteni magunknak egy-egy +mappában. + +```shell-session +$ python3 -m venv awesome-env +``` + +Ezután aktiválhatjuk az environmentet. + +```shell-session +Windows : $ awesome-env\Scripts\activate.bat +Linux / Mac : $ source awesome-env/bin/activate +``` + +Ebben a virtuális környzetben kapunk egy saját csomagkezelőt, a pip-et. + +```shell-session +$ python -m pip --version +``` + +Na és akkor a requests library-t fogjuk használni. + +```shell-session +$ pip show requests +``` + +Telepítsük is fel! + +```shell-session +$ pip install requests +``` + +Na de hogyan látjuk mi van feltelepítve? + +```shell-session +$ pip list +``` + +Akár ezt a listát ki is tudjuk exportálni és megosztani másokkal, hogy aztán +a saját virtuális környezetükben feltelepítsék. + +```shell-session +$ pip freeze > requirements.txt +$ cat requirements.txt +certifi==2020.12.5 +chardet==4.0.0 +idna==2.10 +requests==2.25.1 +urllib3==1.26.3 +``` + +Nyissanak egy új terminált, menjenek egy másik mappába, készítsenek ott egy +virtual env-et és telepítsék fel a dolgokat. + +```shell-session +$ python -m pip install -r requirements.txt +``` + +## 1. Hanyadik hét van? + +Készítsetek egy Python szkriptet, ami a https://hanyadikhetvan.attiss.eu/api -ról leszedett információ alapján kiírja, hogy hanyadik hét van. + +```python +# https://hanyadikhetvan.attiss.eu/api + +import requests + + +# Mi az az API? +# Application Programming Interface, a lényeg, hogy +# ez az interfész, amin 1-1 alkalmazást elérünk és valamilyen +# formában tudunk vele kommunikálni. +# +# Nézzék meg, hogy mi van a https://hanyadikhetvan.attiss.eu/api oldalon. +# Ez egy JSON, mely egy sztenderd adatközlési mód a weben, +# a lényeg, hogy kulcs érték párosokat tudunk az oldalon lévőhöz hasonlóképp +# leírni. +# Na és használjuk! + +r = requests.get('https://hanyadikhetvan.attiss.eu/api') + +print(r) # <Response [200]> - Különböző státuszkódokkal térhet vissza + # egy API, pl 200 - OK, vagy 404 - Not Found +# Vannak beépített függvényeink +print(r.status_code) # Státuszkód számként +print(r.ok) # Státuszkód 200 és 400 közé esik + +# Na de olvassuk ki az adatunkat végre +print(r.content) # hmm ez így nem lesz tökéletes nekünk. Látható, hogy b'', azaz + # ezek bájtok, továbbá egy új sor is van benne +print(r.json()) # Újabb beépített függvény, mely készít nekünk egy Dictionary-t!! +print(type(r.json())) # <class 'dict'> +print(r.json()["week"]) # 5 + +# Végleges kód: + +import requests + +r = requests.get('https://hanyadikhetvan.attiss.eu/api') + +print(r.json()["week"]) +``` + +## 2. Írjátok meg a saját "hanyadikhétvan" apitokat. + +```python +# Ehhez a flask könyvtárat fogjuk használni, +# mellyel képesek vagyunk nagyon könnyedén +# webszervereket készíteni. + +import flask +import requests + +# Inicializáció. Ez az objektum fő amin +# keresztül mindent elérünk Flask-ben. +# Kosntruktorban átadtuk a jelenlegi App nevét, +# emlékeztek ha ez = "__main__" akkor ezt a fájlt +# indítottuk el. +app = flask.Flask(__name__) +# Engedélyezzük, hogy logoljon mindent +app.config["DEBUG"] = True + + +# Megmondjuk, hogy a /-re GET-el ezt a függvényt hívja meg. +# Hogy ez hogyan működik a háttérben? +# - Nézzenek utánna a különböző Python dekorátoroknak :) +@app.route('/', methods=['GET']) +def home(): + # Lekérjük az előző oldalról :D Laziness 100 + # Ha szeretnének saját json-el visszatérni, akkor készítsetek + # egy Dict objektumot és azzal térjetek vissza. Ezt majd a library + # megfelelő mód küldi le. + r = requests.get('https://hanyadikhetvan.attiss.eu/api') + # Visszatérünk vele + return r.json() + +app.run() +``` + +## 3. Kössétek össze az első szkriptetekkel + +```python +import requests + +r = requests.get('http://127.0.0.1:5000') + +print(r.json()["week"]) +``` diff --git a/app/docs/guides/training/python/_category_.json b/app/docs/guides/training/python/_category_.json new file mode 100644 index 0000000000000000000000000000000000000000..4c409a8fe518f6441c10e092e5c8604dc638facb --- /dev/null +++ b/app/docs/guides/training/python/_category_.json @@ -0,0 +1,5 @@ +{ + "label": "Python 3", + "position": 1 +} + \ No newline at end of file diff --git a/app/docs/guides/training/python/injektalas.svg b/app/docs/guides/training/python/injektalas.svg new file mode 100644 index 0000000000000000000000000000000000000000..7107de86f903b1eb2d20ff3ea884c4da791785c4 --- /dev/null +++ b/app/docs/guides/training/python/injektalas.svg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:65c3c8a1ad972a0662c708c0ee2370e43dbdf6adb3457307dff5ff146b0a287c +size 9839 diff --git a/app/docs/guides/training/python/rafael_laszlo-min.jpg b/app/docs/guides/training/python/rafael_laszlo-min.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1fa893b4cddb078f9ff854c396e032eb983b8f0b --- /dev/null +++ b/app/docs/guides/training/python/rafael_laszlo-min.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c21297c3f40be407b50add7e6ff15bf19cb332db3bd3d1b6573d6aad28bbc0ba +size 896640 diff --git a/app/sidebars.js b/app/sidebars.js index 7f322bd575a92c1ebe7eb297afafa4b27736f723..69db68c47d782aa767156428967e74e63c2b6941 100644 --- a/app/sidebars.js +++ b/app/sidebars.js @@ -14,7 +14,60 @@ /** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */ const sidebars = { // By default, Docusaurus generates a sidebar from the docs folder structure - guidesSidebar: [{ type: "autogenerated", dirName: "guides" }], + guidesSidebar: [ + "guides/main", + { + type: "category", + label: "Szolgáltatásaink", + link: { + type: "generated-index", + }, + items: [{ type: "autogenerated", dirName: "guides/services" }], + }, + { + type: "category", + label: "Képzésanyagaink", + link: { + type: "generated-index", + }, + items: [ + { + type: "category", + label: "Behálózás", + link: { + type: "generated-index", + }, + items: [ + { type: "autogenerated", dirName: "guides/training/networking" }, + ], + }, + // { TODO + // type: "category", + // label: "Python3", + // link: { + // type: "generated-index", + // }, + // items: [{ type: "autogenerated", dirName: "guides/training/python" }], + // }, + // { TODO + // type: "category", + // label: "Git", + // link: { + // type: "generated-index", + // }, + // items: [{ type: "autogenerated", dirName: "guides/training/git" }], + // }, + // { TODO + // type: "category", + // label: "Linux", + // link: { + // type: "generated-index", + // }, + // items: [{ type: "autogenerated", dirName: "guides/training/linux" }], + // }, + ], + }, + ], // But you can create a sidebar manually /*