Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • asztrikx/linux-presentation
  • zoli0/linux-presentation
2 results
Show changes
# Linux alapok (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.
<center>
<ImageZoom
src="pics/ubuntu.jpg"
/>
Gnome Ubuntun
<br>
</center>
<br>
<center>
<ImageZoom
src="pics/kde.jpg"
/>
KDE
<br>
</center>
<br>
<center>
<ImageZoom
src="pics/xfce.png"
/>
Xfce
<br>
</center>
<br>
<center>
<ImageZoom
src="pics/elementary.png"
/>
elementary OS
<br>
</center>
<br>
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>
#!/bin/bash -l
export PS1='[\u@\h \W]\$ '
function cmd() {
local command="$1"
echo -n "${PS1@P}"
read -s
for (( i=0 ; i<${#command} ; i++)); do
echo -n "${command:i:1}"
sleep .1
done
read
$command
}
clear
cmd ls
cmd 'ls -la'
cmd 'ls --help'
cmd 'ls --help | less'
cmd "mkdir alma"
cmd ls
cmd "cd alma"
cmd "echo asd"
bash
#!/bin/bash
echo "Várunk a vasárnapi képzésen!"
echo
echo
második
\ No newline at end of file
server {
listen 80;
listen [::]:80;
server_name localhost;
root /usr/share/nginx/html;
location / {
index index.html index.htm;
# kill cache
add_header Last-Modified $date_gmt;
add_header Cache-Control 'no-store, no-cache';
if_modified_since off;
expires off;
etag off;
}
# Media: images, icons, video, audio, HTC
location ~* \.(?:jpg|jpeg|gif|png|ico|cur|gz|svg|svgz|mp4|ogg|ogv|webm|htc)$ {
expires 1M;
access_log off;
add_header Cache-Control "public";
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/html;
}
error_page 404 /404.html;
location = /404.html {
root /usr/share/nginx/html;
}
}
pics/elementary.png

781 KiB

pics/gnome-settings-network.png

170 KiB

pics/gnome-settings-wifi.png

185 KiB

pics/kde.jpg

55.9 KiB

pics/nmtui1.png

122 KiB

pics/nmtui2.png

128 KiB

pics/nmtui3.png

126 KiB

pics/nmtui4.png

162 KiB

pics/ubuntu.jpg

94.3 KiB

pics/xfce.png

324 KiB

# Saját virtuális gép
## Pár szó
Mostani alkalomtól biztosítunk mindannyiótoknak
1-1 virtuális gépet,
Ezek a gépek a saját
[Proxmox](https://en.wikipedia.org/wiki/Proxmox_Virtual_Environment) klaszterünkben
futnak majd egészen a képzés végéig.
Specifikáció:
- Oprendszer: Ubuntu 20.04
- RAM: 2GB
- CPU: 2 Mag (AMD Opteron 6128)
## Elérés
A gépet [SSH](szerver kezelés#távoli-hozzáférés-ssh)
-n keresztül tudod majd menedzselni, viszont csak
az SCH belső hálózatán.
A gépek egy belső hálón vannak, azonban van egy gép,
ami kívülről elérhetővé teszi őket, a kepzodok.sch.bme.hu.
Ezen a gépen különböző portokon éritek el a saját gépeteket.
Ennek menete:
```
$ ssh kepzodo@kepzodok.sch.bme.hu -p <kapott port>
...
Belépsz a Mattermoston kapott infókkal
...
```
Ha windowsról vagy hasonló a folyamat.
Nyiss egy Windows Terminált vagy egy parancssort vagy egy PowerShell-t,
és oda írd be ugyanezeket a parancsokat.
Ha Windows 7 vagy korábbi verzión vagy, akkor
a Putty nevezetű programot használva tudsz csatlakozni a gépedre.
# Szerver kezelés (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.
<center>
<ImageZoom
src="pics/nmtui1.png"
/>
nmtui "főmenü"
<br>
</center>
<br>
<center>
<ImageZoom
src="pics/nmtui2.png"
/>
nmtui edit connecntion menü
<br>
</center>
<br>
<center>
<ImageZoom
src="pics/nmtui4.png"
/>
nmtui edit ethernet connecntion
<br>
</center>
<br>
<center>
<ImageZoom
src="pics/nmtui3.png"
/>
nmtui activate connecntion
<br>
</center>
<br>
- A hálózati beállítások a grafikus felület beállításaiban is megváltoztathatóak (gnome settings, kde settings...)
<center>
<ImageZoom
src="pics/gnome-settings-network.png"
/>
network settings
<br>
</center>
<br>
- `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
Bemutatkozás, rövid bevezető
Azért kell megtanulni konzolos felületet megtanulni, mert a szervereken nincs GUI. De saját gépen valszeg lesz.
Nyissuk meg.
látszik a user
látszik a gép neve
látszik, hogy most hol vagyok (~)
shellben parancsokat hasyálunk arra hogz különböző feladatokat elvégeyyünk.
tab megnyomásával kiegísyítheted a parancsot, ha egyértelmű, ha nem akkor felkínálja a lehetőségeket
nyilakkal előző parancsok
ls
cd Documentsbe tab tab
. az aktuális mapppa
.. az eggyel feljebb lévő mappa
visszaértünk
ls -la
l- listáz
a- rejtett fájlokat is megmutatja
a parancsoknak vannak --kapcsolói, plusz functionok
-la az több infót is kiír egy-egy fájlról nem csak a nevét, később lesz róla szó még
-- help
Ahogz láthatjátoknem fér ki a szöveg a képernzőre, erre találták ki a
less parancsot, melz a bemenetén kapott szöveget görgethető formában jeleníti meg.
-- help | less
egy terminálnyi szöveget ír ki és így olvashatóbb
lehet enterrel és pgup pgdn navigálniú
q-val kilépni ebből a módból
man - manual, felhasználói segédlet, bővebb leírás a különböző parancsokhoz.
mkdir make directory
látjuk a listában
menjünk bele
touch - üres fájl létrehozása tetszőleges fájlkiterjesztéssel
csináltam pörkölt, listában látsyik
echo visszhang, vagyis visszakapod, amit utána írtál
cat: kiírja a fájlok tartalmát a terminalra.
cat pörkötl, üres
mi az a > ? átirányítja egy program kimenetét egy fájlba
echo szeretem > pörkölt
cat pörkölt, benne van a szó
cd ..
cd Documents
látjuk a fájlokat
ls *.txt
| pipe, egy program kimenetét beleírja egy másik program bemenetébe
grep - szűr a bemenetére kapott sorokra
grep almafa
grep alma
mi van a randomsorok.txt-ben (cat)
| grep never viszont így csak egy találatunk van, mivel csak a kisbetűs egzeyéseket keresi
erre van a -i parancs és így már a nagzbetűk és kisbetűk között nem tesz különbséget -i (case insensitive)
nano egyszerű szövegszerkesztő...
ha újra megnyitjuk látszik hogy tényleg sikerült szerkeszteni.
van még egy nagyon hasznos bash mágia, ez a shell execution
"valami szöveg amit akarsz $(parancs)" és ezzel a program kimenetét hozzá fogja illeszteni a szöveghez.
próbáljuk ki
rm - remove
rmdir - remove directory
rm randomsorok.txt
ls --> eltűnt
menjünk eggyel feljebb a mappák között
töröljük az almafa mappa tartalmát és utána az almafa mappát
ls --> eltűnt lol
A csomag alatt egy programot értünk, annak konfigurációs fájljaival, valamint függőségeivel együtt.
Általában sudo hasynálata syükséges a rendsyer konfigurációjának, fájljainak, valamint a rendsyer programjainak módosításáhoy
Néyyük meg hogz hogzan néy ki a linux rendsyerek mappastruktúrja
Jelenleg a user mappájában tartóykodom ~ -vel jelöl.
ls -la
minden fájl valamelyik felhasználó és csoport tulajdona
különböző jogok (w,x,r) ez van a mappa első oszlopában d - directory, hármassal a jelölések,
user, group, other users, - nincs hozzá jogom, betű van hozzá
második oszlop a felhasználó, user
harmadik a csoport, group
utána még egy pár adat, méret, modosítás dátuma, név
lehet eyeket modósítani chmod segítségével, u, g, o, +, -,
lehet módosítani a tulajdonost is a chown és a chgrp segítségével, ezekhez root jog szükséges.
Sziasztok!
Mike vagyok, főleg a sysadminban tevékenykedek, de megtalálhatsz
a Devteamben, Neteamben és Securiteamben is.
Ez az előadássorozat a Linuxról szól és a mostani videóban
szó lesz az UNIX-ról,
a Linux felépítéséről,
a felhasználók kezeléséről,
az init rendszerekről (de főként a systemd-ről),
service-ek kezeléséről,
hálózatkonfigurációról
és SSH-ról.
Kezdjünk is bele!
Mi is az UNIX?
A korábbiakban szó volt arról, hogy "UNIX rendszer", de mit
is jelent ez?
Az UNIX egy '70-es években kifejlesztett operációs rendszer, aminek mai
változatai is léteznek, például a macOS, iOS és társai,
illetve a BSD-k formájában. Ezek igazi UNIX-ok, hiszen kódot
örökölnek az eredeti UNIX operációs rendszerből.
Ezzel szemben a Linux-ok, UNIX-szerű operációs rendszerek,
mert a Linux fejlesztése teljesen független az UNIX-tól,
csupán az UNIX filozófiáját és viselkedését követik.
A továbbiakban UNIX rendszer alatt az UNIX-szerű rendszerekre
is gondolok a valódi UNIX-ok mellett.
Mitől lesz valami UNIX-szerű?
Két fontos elvet említenék, amik megtalálhatóak az UNIX-okban:
Az első a KISS, vagyis a Keep It Simple, Stupid.
Ennek a jelentése az, hogy írjunk, rövid, egyszerű programokat,
amik kevés feladatot látnak el, de azokat jól.
Ezeket a kicsit programokat a shell használatával úgyis össze
tudjuk majd kötni és el is tudják egymást indítani.
Ezt tapasztaltuk is, amikor a korábbiakban egymás után
fűztünk kicsi programokat pipe-pal, vagy ahogy láthatóan
a man a háttérben less-t használ a szöveg megjelenítésére.
Ez azért hasznos, mivel így ha valamelyik része a rendszernek
nem tetszik nekünk, azt könnyen ki tudjuk cserélni egy másik
kicsi programra, emellett, mivel ezek a programok kicsik és egyszerűek,
kisebb a támadási felülete egy-egy programnak.
A másik UNIX-os elem, amiről beszélnék,
az az "everything is a file", vagyis minden egy file.
Ezt azt takarja, hogy a gépen minden, legyen az diszkek, RAM,
videokártyák, futó folyamatok vagy bármi más, mind
elérhetőek mint egy-egy file vagy mappa.
Nézzünk is erre példát:
Először is nyitok egy terminált.
Ha kiadom az lsblk parancsot, akkor az kilistázza a géphez
csatlakoztatott diszkeket. Itt látszik egy olyan, hogy vda és
vda1, illetve látszik, hogy vda1 van a /-be felcsatolva,
ez a root.
A Linuxos jelölésrendszerben a SATA diszkeket
sd<és valami betű>-vel,
NVMe SSD-ket nvme<szám>n<szám>-mal,
virtuális diszkeket pedig vd<majd egy betű>-vel jelöljük,
ezeken a partíciókat pedig SATA és virtuális diszkek esetén
egy számmal, NVMe esetén pedig p és utána egy számmal jelöljük.
Itt /dev/vda a diszk, /dev/vda1 pedig a partíció.
Ha kilistázom a /dev-et, vagyis devices-t,
ahol a hardverek fájljai élnek, akkor a sok más fájl közt ott van
a vda és vda1 is.
Ez azért hasznos, mivel így, ha például
egy programot akarnék írni, ami biztonsági menti
a diszkemet, akkor csupán a /dev/vda vagy hasonlót kéne másolnia
a programomnak egy másik meghajtóra. Emellett a fájlrendszert
nem érdekli, hogy ő egy diszken vagy egy fájlon van,
így simán megtehetem, hogy egy fájlrendszeren belüli fájlon
létrehozok és használok egy fájlrendszert.
Most szeretnék az UNIX-ok architektúrájáról beszélni.
Unixon a KISS-t követve, jóval modulárisabbak ezek a részek,
mint mondjuk Windows-on.
De mik is ezek a részek?
Kezdjük a bootloader-rel. Ennek a feladata az, hogy
betölti RAM-ba a kernelt és pár,
a gép beindításához szükséges fájlt, emellet dual-boot
esetén lehetőséget ad arra, hogy kiválasszuk, hogy mit tölt be.
Ubuntu-n a bootloader a Grub.
Miután a bootloader betöltötte a kernelt, esetünkben a Linuxot,
a kernel inicializálja a hardvereket és önmagát, majd beindítja
az init rendszert, ezután szépen a háttérben kezelgeti a
hardvereket.
Az init rendszer, esetünkben a systemd, pedig beindít minden
szolgáltatást, ami a gép futásához kell, illetve amit kértünk.
Például egy asztali gép esetén a grafikus felületet,
vagy egy szerver esetén a webszervert.
Az operációs rendszerek azon része, ami a kernelen kívül fut
az az úgynevezett userland. Mivel az Ubuntu egy GNU/Linux
oprendszer, így a userland alapját a GNU programok képezik.
Ezek a programok közt van a cat, cp, rm, ls és sok egyéb
olyan eszköz, amit elvárunk, hogy legyen egy shellben.
Na de térjünk is át a szárazabb anyagról a gyakorlati részekre!
Előszöris tanuljunk meg usereket kezelni.
Hozzuk létre a Patrik usert. Ehhez root jogosultság szükséges
A patrik user létrehozáshoz a sudo useradd -m patrik parancsot
kéne kiadni, azonban ezen lehet finomítani.
Én szeretném, hogy Patrik ha shellt indít bash-t kapjon,
ne sima sh-t. Ehhez a parancshoz hozzá kell adnom a
-s /bin/bash parancsot is.
Emellett szeretnék ha szeretnék patriknak jogosultságot adni
ahhoz, hogy sambán megosszon mappákat, akkor hozzáadhatom
a sambashare grouphoz a -G sambashare megadásával.
Így létre is jött Patrik fiókja, de még nincs rajta jelszó,
nem lehet belépni. Állítsunk neki jelszót!
Más userek jelszavának állításához érthető okokból
root jogosultság szükséges.
Így hát kezdjük is azzal, hogy sudo.
A passwd paranccsal tudunk jelszót állítani és argumentumként
adjuk meg azt, hogy patrik, hiszen az ő jelszavát
akarjuk beállítani.
Adjunk meg neki valami jó biztonságos jelszót...
mégegyszer...
és most már van jelszava, be tud lépni.
Mi van, ha a saját jelszavam szeretném megváltoztani.
Ehhez érthetően nem kell root. Futtassuk a passwd-t paraméterek
nélkül.
Ami most újdonság, hogy megkérdi a korábbi jelszavunk, mivel
nem használtunk sudo-t, de adjuk is meg neki.
Most jöhet az új jelszó...
és megint...
És kész is vagyunk.
Eközben rájöttem, hogy megbízok Patrikban és szeretnék neki
root jogokat adni, vagyis hozzáférést a sudo parancshoz.
Ehhez hozzá kell adnom a sudo grouphoz. Ezt megtehetem
a sudo usermod -aG (vagyis add group) sudo patrik
paranccsal.
Tegyük fel, hogy mégse szeretném, hogy Patrik hozzáférjen
ehhez a géphez. Töröljük a felhasználóját a
sudo userdel -r patrik paranccsal.
Az -r kapcsoló azt jelenti, hogy patrik home mappáját
is szeretném törölni. Ha nem adom meg, akkor a fájljai rajt
maradnának a gépen.
Debian alapú disztrókon, így Ubuntun is van egy adduser script
is emellett, ami talán egy kicsit kényelmesebben használható,
azonban nincs minden gépen szemben a korábbi parancsokkal,
amik gnu programok.
Hozzuk létre újra patrik felhasználóját, de ezúttal az
adduser paranccsal a useradd helyett.
Ha kiadjuk, hogy sudo adduser patrik, akkor az adduser
végigvezet minket a Patrik fiók létrehozásán.
Most adjuk meg patrik jelszavát...
Emellett csomó metaadatot is megadhatunk.
A Full name azért külön mező, mivel az unixos felhasználónevek
csak kisbetűs angol karaktereket tartalmazhatnak. Ez a full name
jelenik meg például a bejelentkezőképernyőn.
Most megint adjuk hozzá patrikot a sudo csoporthoz, viszont
most ezt az adduser-rel tegyük.
sudo adduser patrik sudo
Király, meg is vagyunk.
Most töröljük patrikot, de használjuk a deluser parancsot
sudo deluser patrik
kész.
Most, hogy usereket tudunk kezelni, nézzük meg a csoportkezelést.
Először is nézzük meg milyen csoportok tagjai vagyunk,
ezt a groups-szal tehetjük meg.
Nézzük meg, hogy Bélának milyen csoporttagságai vannak:
ehhez a groups bela parancsot kell kiadni.
Próbaként hozzuk létre a kszksok csoportot.
sudo groupadd csoportom
Nézzük is meg, hogy működött, csináljunk egy mappát és
tegyük elérhetővé a csoport számára.
létrehozok egy mappát
mkdir test
group ownerré teszem a csoportom-at
sudo chgrp csoportom test
és nézzük meg
ls -la
Most adjuk hozzá magunkat a csoporthoz.
sudo usermod -aG csoportom mike
Nézzük is meg, hogy belekerültünk-e a csoportba:
groups
Nincs a listában a csoportom. Vajon mi lehet a probléma?
A probléma az, hogy a csoporttagságok életbelépéséhez
ki kell jelentkezni, majd újra bejelentkezni.
Erre van egy alternatíva is, a newgrp paranccsal tudunk kérni
egy shellt az új csoporttagsággal.
Ezt úgy tudjuk használni, hogy futtatjuk a
newgrp csoportom parancsot.
És most ha megnézzük...
benne vagyunk a csoportom csoportban.
És, hogy látszódjon, hogy ez tényleg egy új shell volt
adjuk ki az exit parancsot.
Most visszakerültünk a korábbi shellbe, a terminál nem záródott be.
Most adjuk ki a groups-ot...
és megint nem szerepel a csoportom a listában.
Most vegyük ki magunkat a tagok közül:
sudo gpasswd -d csoportom kszksok
Majd töröljük a csoportot:
sudo groupdel csoportom
Ezzel megtanultunk mindent, amit a csoportkezelésről tudni
kell.
Az init rendszer, ahogy korábban említettem, a gépen futó
szolgáltatásokat menedzseli. A gép indulásakor automatikusan
elindít minden szolgáltatást, ami szükséges a gép futásához,
vagy amire megkértük, hogy indítsa el automatikusan.
Emellett el tudunk indítani és le tudunk állítani
szolgáltatásokat kézzel is. Nézzük is meg, hogy ez hogy működik.
Erre a gépre telepítve van egy apache webszerver.
Először is nézzük meg, hogy mi a service neve.
Ehhez futtassuk a systemctl list-unit-files parancsot.
Most egy less-es görgethető listában megjelent az
összes szolgáltatás telepített szolgáltatás neve és állapota.
Szűrjünk grep-pel az apache-ra.
Itt láthatjuk, hogy apache2 a szolgáltatás neve.
Nézzük meg az állapotát:
systemctl status apache2
Látható, hogy le van állítva az apache és le is van tiltva,
vagyis nem indul el automatikusan a rendszerrel.
Most indítsuk el:
sudo systemctl start apache2
Ha most megnézzük az állapotát, akkor látszik, hogy
szépen el is indult.
Ha elindítunk egy böngészőt és felmegyünk localhost-ra, akkor
láthatjuk, hogy tényleg elindult.
Nézzük meg a logjait!
Ezt a journalctl -u apache2-vel tehetjük meg.
A journald a systemd loggyűjtő komponense, önmaga is egy
szolgáltatás és a journalctl paranccsal lehet használni.
Ha azt szeretnénk, hogy az apache induljon el a géppel együtt,
akkor engedélyezni kell a service-t.
Ezt a sudo systemctl enable apache2 paranccsal tudjuk megtenni.
A státuszát megint megtekintve láthatjuk, hogy engedélyezve lett.
Most állítsuk le. Ehhez a systemctl stop apache2-t kell futtatni.
Nézzük meg a státuszát.
Éés le is lett tiltva.
Most állítsuk le:
sudo systemctl stop apache2
Nézzünk státuszt!
És láthatjuk, hogy leállt.
Ha a böngészőben újratöljük az oldalt, akkor nem is tölt be.
Nézzünk egy kis hálózatkezelést:
Alapesetben az ip paranccsal lehet beállítani kézzel
az ip címünket és az alapértelmezett átjarót, sok egyéb
IP-hez kötődő beállítással együtt.
Nézzük meg az ip címünket az ip address paranccsal.
Sok infóval együtt, de megkaptuk az ip címünket.
Az ip parancsban vannak rövidítések is, elég azt beírni, hogy
ip a.
Ha meg akarjuk kapni az átjárónkat, akkor pedig az
ip route vagy ip r parancsot kell használni.
Azonban nem mennék bele a kézi hálókonfigba,
mivel általában hálózatkezelőket, vagyis network manager-eket
használunk, amik indítás után automatikusan beállítanak mindent.
Ubuntu Desktop-on az alapértelmezett hálókezelő a NetworkManager,
Ubuntu Server-en pedig a systemd-networkd.
A NetworkManager-nek van egy szép terminálos felülete is,
az nmtui.
Sőt, a legtöbb aztali Linux disztribúció NetworkManager-t
használ, így ha a beállítások alkalmazáson keresztül állítjátok
a hálózatot, több, mint valószínű, hogy networkmananger-t
állítatok a háttérben.
Emellett parancsokkal is tudjuk vezérelni a networkmanager-t
az nmcli-n keresztül.
Ha ennél bővebben érdekel titeket a téma, akkor olvassátok el
az ip, a NetworkManager és a systemd-networkd man page-eit.
Amiről még most beszélnék az az SSH, vagyis secure shell.
Ezzel biztonságos módon csatlakozhatunk egy távoli géphez.
Ha kiadom azt a parancsot, hogy
ssh mikewashere@ssh.sch.bme.hu
és beírom a jelszavam,
akkor satyr-on találom magam, ami a publikus terminálszerverünk.
Ez a parancs amúgy Window 8 utáni Windowsokon is megtalálható.
Ezt bátran próbáljátok ki, ssh-zzatok fel az schacc-otokkal
satyr-ra és nézzetek körül.
Emellett kaphattatok emailben bejelentkezési adatokat
saját Linuxos VM-ekre, amiket a gyakorlaton fogunk használni,
lehetőleg próbáljatok meg belépni rájuk még a vasárnapi alkalom
előtt.
Ez a videó ennyi volt, köszönöm a figyelmet, és találkozunk
vasárnap. Sziasztok!