Farkas Attila Wiki - Felhasználó közreműködései [hu]

EDU::GAMF::Felhőalapú-szolgáltatások

2026-09-20T09:35:27Z

ApelPro: A 2. órai diasor belinkelve a felsorolás 2. pontjához

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a projektfeladatból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett: ([[Fájl:Felhoalapu-szolgaltatasok-1-ora-diak.pdf|diasor]])
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma ([[Fájl:Felhoalapu-szolgaltatasok-2-ora-diak.pdf|diasor]])
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email] és alap szolgáltatások átbeszélése
# EC2 telepítés, nginx + apache2 bevezetés, alap parancsok ismétlése (ls, nano, mcedit stb.)
# Alkalmazás telepítése előre elkészített script segítségével + AMI, ASG, LB
# RDS telepítés és alkalmazás integráció ellenőrzése
# Docker alapok
# Docker compose alapok
# Alkalmazás indítása Docker környezetben
# IaC eszközök áttekintése
# IaC eszközök áttekintése
# MessageQueue eszközök használata
# Projekt bemutató (6db)
# Projekt bemutató (6db)
# Projekt bemutató (6db)

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj maximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::IaC|IaC]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

Fájl:Felhoalapu-szolgaltatasok-2-ora-diak.pdf

2026-09-20T09:35:04Z

ApelPro: A 2. órai előadás diasora: Felhő ökoszisztéma (szolgáltatási modellek, megosztott felelősség, AWS régiók/zónák és automatikus redundancia)

A 2. órai előadás diasora: Felhő ökoszisztéma (szolgáltatási modellek, megosztott felelősség, AWS régiók/zónák és automatikus redundancia)

Fájl:Felhoalapu-szolgaltatasok-1-ora-diak.pdf

2026-09-14T10:08:09Z

ApelPro: ApelPro Fájl:Felhoalapu-szolgaltatasok-1-ora-diak.pdf új verzióját töltötte fel

Az 1. órai bevezető előadás diasora a [[EDU::GAMF::Felhőalapú-szolgáltatások]] tárgyhoz.

EDU::GAMF::Felhőalapú-szolgáltatások

2026-09-14T10:05:25Z

ApelPro: Diasor link áthelyezve a felsorolás 1. pontjához (diasor) formában, külön bekezdés eltávolítva

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a projektfeladatból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett: ([[Fájl:Felhoalapu-szolgaltatasok-1-ora-diak.pdf|diasor]])
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email] és alap szolgáltatások átbeszélése
# EC2 telepítés, nginx + apache2 bevezetés, alap parancsok ismétlése (ls, nano, mcedit stb.)
# Alkalmazás telepítése előre elkészített script segítségével + AMI, ASG, LB
# RDS telepítés és alkalmazás integráció ellenőrzése
# Docker alapok
# Docker compose alapok
# Alkalmazás indítása Docker környezetben
# IaC eszközök áttekintése
# IaC eszközök áttekintése
# MessageQueue eszközök használata
# Projekt bemutató (6db)
# Projekt bemutató (6db)
# Projekt bemutató (6db)

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj maximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::IaC|IaC]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Felhőalapú-szolgáltatások

2026-09-14T10:03:27Z

ApelPro: Az 1. órai bevezető előadás PDF diasora felöltve és belinkelve az Az előadás menete résznél

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a projektfeladatból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

'''Az 1. órai bevezető előadás diasora:''' [[Fájl:Felhoalapu-szolgaltatasok-1-ora-diak.pdf|1. órai diasor (PDF)]]

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email] és alap szolgáltatások átbeszélése
# EC2 telepítés, nginx + apache2 bevezetés, alap parancsok ismétlése (ls, nano, mcedit stb.)
# Alkalmazás telepítése előre elkészített script segítségével + AMI, ASG, LB
# RDS telepítés és alkalmazás integráció ellenőrzése
# Docker alapok
# Docker compose alapok
# Alkalmazás indítása Docker környezetben
# IaC eszközök áttekintése
# IaC eszközök áttekintése
# MessageQueue eszközök használata
# Projekt bemutató (6db)
# Projekt bemutató (6db)
# Projekt bemutató (6db)

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj maximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::IaC|IaC]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

Fájl:Felhoalapu-szolgaltatasok-1-ora-diak.pdf

2026-09-14T10:02:59Z

ApelPro: Az 1. órai bevezető előadás diasora (tárgy felépítése, AWS regisztráció/bankkártya tanács, időbeosztás, követelmények)

Az 1. órai bevezető előadás diasora a [[EDU::GAMF::Felhőalapú-szolgáltatások]] tárgyhoz.

EDU::GAMF::Felhőalapú-szolgáltatások

2026-09-14T08:35:59Z

ApelPro:

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a projektfeladatból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email] és alap szolgáltatások átbeszélése
# EC2 telepítés, nginx + apache2 bevezetés, alap parancsok ismétlése (ls, nano, mcedit stb.)
# Alkalmazás telepítése előre elkészített script segítségével + AMI, ASG, LB
# RDS telepítés és alkalmazás integráció ellenőrzése
# Docker alapok
# Docker compose alapok
# Alkalmazás indítása Docker környezetben
# IaC eszközök áttekintése
# IaC eszközök áttekintése
# MessageQueue eszközök használata
# Projekt bemutató (6db)
# Projekt bemutató (6db)
# Projekt bemutató (6db)

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj maximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::IaC|IaC]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Felhőalapú-szolgáltatások

2026-09-14T08:26:12Z

ApelPro: Új IaC gyakorlat oldal belinkelve a Jegyzetek szekcióban

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a projektfeladatból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email] és alap szolgáltatások átbeszélése
# EC2 telepítés, nginx + apache2 bevezetés, alap parancsok ismétlése (ls, nano, mcedit stb.)
# Alkalmazás telepítése előre elkészített script segítségével + AMI, ASG, LB
# RDS telepítés és alkalmazás integráció ellenőrzése
# Docker alapok
# Docker compose alapok
# Alkalmazás indítása Docker környezetben
# IaC eszközök áttekintése
# IaC eszközök áttekintése
# MessageQueue eszközök használata
# Projekt bemutató (6db)
# Projekt bemutató (6db)
# Projekt bemutató (6db)

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj maximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::IaC|IaC (Terraform, Ansible, Jenkins)]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Felhőalapú-szolgáltatások::IaC

2026-09-14T08:25:43Z

ApelPro: Új IaC gyakorlat oldal létrehozása: Terraform, Ansible, Jenkins (a Docker/AWS oldalak struktúrájához illesztve)

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
[[category:GAMF AWS|AWS]]
== Mi az az Infrastructure as Code (IaC)? ==
Eddig a gyakorlatok során mindent kézzel, a grafikus felületen keresztül hoztunk létre - EC2 példányt, VPC-t, RDS-t, Security Groupot stb. Ez tanulási célra kiváló, mert látjuk, hogy pontosan mi történik, de éles környezetben rengeteg problémát okoz:
* Nem reprodukálható megbízhatóan (két ember, két kattintgatás - könnyen eltérő eredmény)
* Nincs verziókezelve, nem látszik a történet, ki mit miért módosított
* Nincs automatikusan dokumentálva - a konfiguráció "a fejekben" és a felületen él
* Nehéz gyorsan, azonos módon többször újra felépíteni (pl. teszt- és éles környezet)

Az '''Infrastructure as Code''' lényege, hogy az infrastruktúrát (és sokszor a rajta futó szolgáltatások konfigurációját is) szöveges, verziókezelhető fájlokban írjuk le, amit aztán eszközök automatikusan alkalmaznak. Ezen a gyakorlaton három, egymást kiegészítő - és a piacon igen elterjedt - eszközzel ismerkedünk meg:
{| class="wikitable"
! Eszköz !! Feladata !! Egy mondatban
|-
| '''Terraform''' || Infrastruktúra '''létrehozása''' (provisioning) || "Milyen gépek/hálózatok/szolgáltatások legyenek?"
|-
| '''Ansible''' || Már létező szerverek '''konfigurálása''' || "Mi fusson/legyen telepítve a gépeken?"
|-
| '''Jenkins''' || A folyamat '''automatizálása''' (CI/CD) || "Mikor és hogyan fusson le mindez magától?"
|}

A három eszköz tipikusan egy láncban dolgozik együtt: '''Jenkins''' elindítja a folyamatot (pl. egy git push hatására), ami meghívja a '''Terraform'''-ot, hogy felépítse/frissítse az infrastruktúrát, majd az '''Ansible''' konfigurálja fel és telepíti az alkalmazást a friss szerverekre.

== Terraform ==
=== Mi az a Terraform? ===
A HashiCorp által fejlesztett, nyílt forráskódú IaC eszköz. Deklaratív nyelven (HCL - HashiCorp Configuration Language) írjuk le a '''kívánt végállapotot''' ("legyen egy ilyen EC2 példányom, ekkora Security Grouppal"), és a Terraform kitalálja, milyen API-hívásokkal éri ezt el - beleértve azt is, ha valamit módosítani vagy törölni kell egy korábbiállapothoz képest.

=== Telepítés ===
A Terraform nincs benne az alapértelmezett Ubuntu/Debian csomagtárolókban, a HashiCorp hivatalos tárolóját kell hozzáadnunk:
<syntaxhighlight lang="bash">
apt update && apt install -y gnupg software-properties-common curl
curl -fsSL https://apt.releases.hashicorp.com/gpg | gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" \
| tee /etc/apt/sources.list.d/hashicorp.list
apt update && apt install terraform -y
terraform -version
</syntaxhighlight>

=== AWS hitelesítés ===
A Terraformnak ugyanazokra a hozzáférési kulcsokra van szüksége, mint korábban az AWSCLI-nek (lásd az [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS#Access_Key_management|AWS oldalon]]). Két lehetőségünk van:
* Ha már lefuttattuk az '''aws configure''' parancsot, a Terraform automatikusan megtalálja azt
* Vagy környezeti változóként is megadhatjuk:
<syntaxhighlight lang="bash">
export AWS_ACCESS_KEY_ID="ide_jön_az_access_key"
export AWS_SECRET_ACCESS_KEY="ide_jön_a_secret_key"
export AWS_DEFAULT_REGION="eu-west-1"
</syntaxhighlight>
'''Figyelem!''' Soha ne írjuk a hozzáférési kulcsokat közvetlenül a .tf fájlokba, és ne kerüljenek verziókezelőbe (git)! Használjunk környezeti változót, vagy az AWS CLI által létrehozott hitelesítési fájlt.

=== Alapfogalmak ===
* '''Provider''': melyik szolgáltatóval (AWS, Azure, GCP stb.) és hogyan kommunikáljon a Terraform
* '''Resource''': egy konkrét, létrehozandó/kezelendő erőforrás (pl. egy EC2 példány)
* '''Variable''': paraméterezhető bemeneti érték (pl. instance típusa, régió)
* '''Output''': a végrehajtás után visszaadott érték (pl. a létrehozott szerver publikus IP-je)
* '''State''': a Terraform saját nyilvántartása arról, hogy legutóbb milyen állapotot hozott létre - ez alapján tudja kiszámolni, hogy legközelebb mit kell módosítania

=== Gyakorlati példa: EC2 + Security Group ===
Hozzunk létre egy ''main.tf'' fájlt, ami a korábban már megismert módon (lásd [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS#EC2_szolgáltatásai|EC2 gyakorlat]]) indít egy t2.micro szervert, rajta egy Security Grouppal, ami engedi a SSH és HTTP forgalmat:
<syntaxhighlight lang="hcl">
terraform {
required_providers {
aws = {
source = "hashicorp/aws"
version = "~> 5.0"
}
}
}

provider "aws" {
region = "eu-west-1"
}

variable "neptun" {
description = "Neptun kód, az erőforrások elnevezéséhez"
type = string
default = "neptun"
}

resource "aws_security_group" "web" {
name = "${var.neptun}-sg"
description = "SSH + HTTP engedelyezese"

ingress {
description = "SSH"
from_port = 22
to_port = 22
protocol = "tcp"
cidr_blocks = ["0.0.0.0/0"]
}

ingress {
description = "HTTP"
from_port = 80
to_port = 80
protocol = "tcp"
cidr_blocks = ["0.0.0.0/0"]
}

egress {
from_port = 0
to_port = 0
protocol = "-1"
cidr_blocks = ["0.0.0.0/0"]
}

tags = {
Name = "${var.neptun}-sg"
}
}

resource "aws_instance" "web" {
ami = "ami-0c1c30571d2dae5c9" # Ubuntu 22.04 LTS, eu-west-1
instance_type = "t2.micro"
key_name = "test" # a korabban letrehozott kulcspar neve
vpc_security_group_ids = [aws_security_group.web.id]

tags = {
Name = "${var.neptun}-web"
}
}

output "public_ip" {
value = aws_instance.web.public_ip
}
</syntaxhighlight>
'''Figyelem!''' Az AMI azonosító régiónként és időszakonként változik - mindig ellenőrizzük a konzolon (EC2 → Launch instance → AMI kiválasztás), hogy az adott régióban érvényes-e még az azonosító, mielőtt bemásoljuk.

=== A munkafolyamat: init / plan / apply / destroy ===
<syntaxhighlight lang="bash">
terraform init # letölti a szükséges providereket, előkészíti a munkakönyvtárat - csak egyszer kell (vagy provider váltáskor)
terraform plan # megmutatja, MIT fog csinálni, anélkül hogy bármit is végrehajtana - mindig nézzük át!
terraform apply # végrehajtja a terveket - rákérdez, hogy biztosan folytassuk-e (yes-szel hagyjuk jóvá)
terraform destroy # törli az összes, ebben a konfigurációban létrehozott erőforrást
</syntaxhighlight>
'''Figyelem, ez a legfontosabb szabály a féléves munkához!''' Amikor végeztünk egy gyakorlattal, futtassunk ''terraform destroy''-t, különben a létrehozott erőforrások tovább futnak és fizetési kötelezettséget okozhatnak a free tier keretein túl.

=== A state fájl ===
A ''terraform apply'' lefuttatása után megjelenik egy ''terraform.tfstate'' nevű fájl a könyvtárban - ez tárolja, hogy pontosan mit hozott létre a Terraform. '''Ez a fájl bizalmas adatokat is tartalmazhat''' (pl. jelszavakat, ha voltak a konfigurációban), ezért:
* Soha ne kerüljön git-be (vegyük fel a ''.gitignore''-ba)
* Csapatmunkánál érdemes távoli tárolást használni (pl. S3 bucket, amit korábban már megismertünk), hogy mindenki ugyanazt az állapotot lássa

== Ansible ==
=== Mi az az Ansible, és miben más, mint a Terraform? ===
Amíg a Terraform azzal foglalkozik, hogy '''milyen gépek létezzenek''', addig az Ansible azzal, hogy '''mi legyen rajtuk telepítve/beállítva'''. Az Ansible '''agentless''': nem kell külön ügynök-szoftvert telepíteni a célgépekre, elég, ha van rajtuk SSH szerver (amit eddig is használtunk a gépekhez való csatlakozáshoz) és Python.

=== Telepítés ===
<syntaxhighlight lang="bash">
apt update && apt install ansible -y
ansible --version
</syntaxhighlight>

=== Inventory - kikhez csatlakozzon? ===
Az Ansible egy úgynevezett ''inventory'' fájlból tudja, mely szerverekkel dolgozzon. Hozzunk létre egy ''inventory.ini'' fájlt, a korábban megismert SSH kulcsot és felhasználónevet felhasználva (lásd [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS#Csatlakozás_Linux_terminálból|itt]]):
<syntaxhighlight lang="ini">
[webservers]
web1 ansible_host=3.252.168.207 ansible_user=ubuntu ansible_ssh_private_key_file=~/test.pem
</syntaxhighlight>

Ellenőrizzük, hogy elérjük-e a gépet:
<syntaxhighlight lang="bash">
ansible -i inventory.ini webservers -m ping
</syntaxhighlight>

=== Ad-hoc parancsok ===
Egyszeri feladatokhoz nem kell playbookot írnunk, elég egy modult megneveznünk:
<syntaxhighlight lang="bash">
# csomaglista frissítése minden webservers csoportba tartozó gépen
ansible -i inventory.ini webservers -m apt -a "update_cache=yes" --become

# egy adott parancs lefuttatása
ansible -i inventory.ini webservers -m shell -a "uptime"
</syntaxhighlight>
A ''--become'' kapcsoló jelenti a sudo-s (root) jogosultsággal történő végrehajtást, hasonlóan ahhoz, mintha ''sudo''-t írnánk a parancs elé.

=== Playbook - a korábbi telepítő script Ansible-lel ===
Emlékezzünk vissza: a gyakorlat elején egy bash scripttel (''UI indítás'', lásd az AWS oldalon) telepítettük fel a weboldalunkat egy EC2-re. Ennek '''két nagy hátránya''' volt: csak egyszer, az EC2 indításakor futott le (User data), és nem volt idempotens - ha kétszer lefuttatnánk, hibákat okozna (pl. már létező mappa létrehozása). Nézzük meg, hogyan váltja ki ugyanezt egy Ansible playbook, amit '''bármikor, bármennyiszer''' újra lefuttathatunk anélkül, hogy kárt tenne:
<syntaxhighlight lang="yaml">
---
- name: Weboldal UI telepítése
hosts: webservers
become: yes
vars:
neptun: "neptun"
api_lb_domain: "localhost"

tasks:
- name: Csomaglista frissítése
apt:
update_cache: yes

- name: Szükséges csomagok telepítése
apt:
name:
- apache2
- libapache2-mod-php8.3
- php8.3
- php8.3-curl
- unzip
state: present

- name: Weboldal letöltése és kicsomagolása
unarchive:
src: https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
dest: /tmp/
remote_src: yes

- name: Célkönyvtár létrehozása
file:
path: "/srv/{{ neptun }}"
state: directory

- name: <ip> csere a tényleges API domain-re és fájlok elhelyezése
copy:
src: "/tmp/{{ item.src }}"
dest: "/srv/{{ neptun }}/{{ item.dest }}"
remote_src: yes
loop:
- { src: "ui.php", dest: "index.php" }
- { src: "ui_newproduct.php", dest: "newproduct.php" }

- name: <ip> tag lecserélése a tényleges API domain-re
replace:
path: "/srv/{{ neptun }}/{{ item }}"
regexp: "<ip>"
replace: "{{ api_lb_domain }}"
loop:
- index.php
- newproduct.php

- name: Apache virtualhost beállítása
template:
src: templates/000-default.conf.j2
dest: /etc/apache2/sites-enabled/000-default.conf
notify: Apache ujraindul

handlers:
- name: Apache ujraindul
service:
name: apache2
state: restarted
</syntaxhighlight>
Figyeljük meg az '''idempotencia''' elvét minden lépésnél: az ''apt'' modul csak akkor telepít, ha a csomag még nincs fent; a ''file'' modul csak akkor hoz létre könyvtárat, ha az még nem létezik. Ha kétszer futtatjuk le a playbookot, a második futás nem fog hibázni, csak megállapítja, hogy "már minden rendben van" (ez az úgynevezett ''changed=0'' állapot).

A playbook futtatása:
<syntaxhighlight lang="bash">
ansible-playbook -i inventory.ini deploy-ui.yml
</syntaxhighlight>

== Jenkins ==
=== Mi az a Jenkins? ===
A Jenkins egy nyílt forráskódú CI/CD (Continuous Integration / Continuous Deployment) automatizáló szerver: az ő feladata, hogy a fejlesztői munka (pl. egy git push) hatására automatikusan lefuttassa a szükséges lépéseket - tesztelés, build, majd akár a Terraform és Ansible meghívása is, hogy a legfrissebb kód éles környezetbe kerüljön emberi beavatkozás nélkül.

=== Telepítés Docker konténerben ===
Mivel a félév második fele a Dockerről szól, a Jenkins telepítését is ezen keresztül végezzük el - így nem szennyezzük a hoszt rendszert, és könnyen el is távolítható:
<syntaxhighlight lang="bash">
docker volume create jenkins_home
docker run -d --name jenkins \
-p 8080:8080 -p 50000:50000 \
-v jenkins_home:/var/jenkins_home \
jenkins/jenkins:lts
</syntaxhighlight>
A '''8080'''-as port a webes admin felület, az '''50000'''-es port pedig azoknak az esetleges elosztott build-ügynököknek (agent) van fenntartva, amik egy másik gépről csatlakoznának a Jenkins szerverhez.

A kezdeti admin jelszót a konténer belsejéből kell kiolvasnunk:
<syntaxhighlight lang="bash">
docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword
</syntaxhighlight>
Ezt beillesztve a ''http://<szerver_ip>:8080'' címen elérhető telepítő varázslóba, majd a javasolt beépülők (plugins) telepítésével elkészül az alapkonfiguráció.

=== Pipeline alapfogalmak ===
A Jenkins munkafolyamatait ''Jenkinsfile'' néven, a projekt gyökerében elhelyezett, Groovy szintaxisú fájlban írjuk le (tehát ez a fájl is git-be kerül a projekt kódjával együtt - önmagában is egyfajta "code" a CI/CD folyamatból):
* '''pipeline''': a teljes folyamatot összefogó blokk
* '''stage''': egy-egy logikai szakasz (pl. "Build", "Terraform Apply", "Ansible Deploy") - ezek jelennek meg névvel a Jenkins felületén
* '''steps''': az adott szakaszban ténylegesen végrehajtandó parancsok

=== Gyakorlati példa: Terraform + Ansible pipeline ===
<syntaxhighlight lang="groovy">
pipeline {
agent any

stages {
stage('Checkout') {
steps {
git branch: 'main', url: 'https://github.com/pelda/gamf-projekt.git'
}
}

stage('Terraform Init') {
steps {
sh 'terraform init'
}
}

stage('Terraform Apply') {
steps {
sh 'terraform apply -auto-approve'
}
}

stage('Ansible Deploy') {
steps {
sh 'ansible-playbook -i inventory.ini deploy-ui.yml'
}
}
}

post {
failure {
echo 'A pipeline elszállt - ellenőrizzük a logokat!'
}
}
}
</syntaxhighlight>
'''Figyelem!''' Ahhoz, hogy a fenti ''sh'' lépések ténylegesen működjenek, a Terraform-ot és az Ansible-t is telepíteni kell magába a Jenkins konténerbe (vagy egy erre felkészített, saját ''Dockerfile''-ból épített Jenkins image-be - gondoljunk vissza a Docker fejezetre, pontosan ez a ''image készítés'' egyik tipikus, valós felhasználási módja).

== Összefoglalás - hogyan áll össze a lánc? ==
{| class="wikitable" style="margin:0px auto"
! Lépés !! Eszköz !! Mit csinál
|-
| 1 || Fejlesztő || ''git push'' a kódra
|-
| 2 || Jenkins || Észleli a változást, elindítja a pipeline-t
|-
| 3 || Terraform || Felépíti/frissíti az infrastruktúrát (VPC, EC2, Security Group, RDS stb.)
|-
| 4 || Ansible || Feltelepíti és konfigurálja az alkalmazást a friss szervereken
|-
| 5 || - || Az alkalmazás elérhetővé válik, emberi kattintgatás nélkül
|}

Ez a minta közvetlenül kapcsolódik a féléves projektfeladat követelményeihez is: a Terraformmal létrehozott VPC, EC2, ASG/LB, RDS mind beleszámít a projektkövetelmény-listába (lásd a [[EDU::GAMF::Felhőalapú-szolgáltatások|főoldalon]]), csak éppen automatizált, verziókezelt, újra futtatható formában - ami jóval közelebb áll ahhoz, ahogy ma egy valós cégnél is üzemeltetik a felhős infrastruktúrát.

== Jegyzetek ==
* [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]] - lásd a Felhő ökoszisztéma fejezet IaC alfejezetét az elméleti háttérhez

EDU::GAMF::Felhőalapú-szolgáltatások::AWS

2026-09-14T08:21:20Z

ApelPro: /* Alkalmazások telepítése */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
[[category:GAMF AWS|AWS]]
== Amazon Web Services regisztráció ==
Az AWS regisztrációhoz szükségünk lesz egy email címre, egy telefonszámra a megerősítéshez és egy netes vásárlásra alkalmas bankkártyára. A regisztráció során az AWS jellemzően egy jelképes összeggel (kb. 1$ vagy annak megfelelő) meg terheli a számlát a kártya ellenőrzéséhez, de később erre nem tart igény, így a tranzakció lejáratakor jóváíródik a számlán.

'''Figyelem!''' 2024 közepe óta az AWS megváltoztatta az ingyenes csomag felépítését: az újonnan regisztráló fiókok már '''nem''' a régi, klasszikus "12 hónapig minden Free tier eligible szolgáltatás ingyenes" modellt kapják, hanem egy kredit alapú, rövidebb (jellemzően kb. fél éves) ingyenes időszakot induló jóváírással. A korábban regisztrált fiókok a régi, 12 hónapos feltételeket tarthatják meg. Regisztráció előtt mindenképp nézzük meg az aktuális [https://aws.amazon.com/free/ AWS Free Tier] feltételeit, mert idővel ezek is változhatnak.

== Ingyenes verzió korlátai ==
Az ingyenes csomagban nem minden érhető el és ami mégis, az sem korlátlan ideig (a klasszikus modellben pl. 750 óra EC2 futási idő havonta, az új kredit alapú modellben pedig a jóváírt összeg elfogyásáig), amit ha átlépünk, akkor fizetési kötelezettségünk jelentkezik a szolgáltató felé. Igyekezzünk mindent leállítani az órai munka illetve az otthoni gyakorlás után, hogy lehetőleg ne kerüljön pénzbe a féléves munkánk. A hallgatók által elszenvedett károkért sem az iskola sem Én nem tudunk felelősséget vállalni, de azt meg tudjuk ígérni, hogy fizetős szolgáltatást nem használunk és nem is kérünk számon.

== AWS alapok ==
'''Figyelem!''' Az iskolai hálózatból csak az eu-west-1 és az eu-central-1, azaz Írország és Frankfurt IP címei vannak engedélyezve, ezekre fogunk tudni SSH kapcsolaton keresztül csatlakozni. 
'''Figyelem!''' Próbaidőszak alatt minden szolgáltatás mellett keressük a ''Free tier eligible'' megjegyzést, különben fizetési kötelezettségünk adódhat!

=== EC2 szolgáltatásai ===
Az ''EC2'' gyakorlatilag egy VPS-nek feleltethető meg és nem is tévedünk vele hatalmasat. A hivatalos neve ''Elastic Compute Cloud'', innen az ''EC2'' rövidítés: a ''2''-es a végén azt jelzi, hogy a névben két ''C'' kezdőbetűs szó van (''Compute'' és ''Cloud'').

A különbséget a VPS-hez elsősorban a rugalmas (''elastic'') skálázhatóság okozza: az EC2 példányokat gyorsan tudjuk indítani, leállítani, típust váltani rajtuk, illetve automatikusan is skálázhatjuk a darabszámukat (lásd később: Auto Scaling Group). Emiatt architekturálisan úgy érdemes tervezni, mintha bármikor cserélődhetne egy adott példány - ez alap (On-Demand) EC2 esetén a gyakorlatban ritkán, hardverhiba vagy saját leállítás esetén fordul csak elő, de a olcsóbb ''Spot'' típusú példányoknál az AWS bármikor, rövid (kb. 2 perces) előzetes figyelmeztetéssel visszavonhatja a gépet. Emiatt körültekintően kell eljárnunk: semmilyen adatot nem érdemes úgy egy alkalmazáson belül tárolni, mint egy VPS esetén: a dinamikus adatok (pl. PHP Session, feltöltött fájlok) egy EC2 csere esetén elvesznek, így ezeket nem helyben fogjuk tárolni.

Az EC2 szolgáltatásait a keresőmezőbe írt ''„EC2”'' kulcsszóval és az eredményekben megjelenő ''EC2''-re való kattintással érhetjük el.

[[Fájl:GAMFAWS search EC2.png.png]]

Az alapértelmezetten megjelenő menüpont a ''Dashboard'', ahol információkat találhatunk az ''EC2'' köré felhúzható szolgáltatásokról, melyeknek egy részét a továbbiakban tárgyalni is fogunk. Az összefoglaló táblázat az alább látható módon jelenik meg. '''Figyelem''', a táblázat csak az adott régióban elindított/elérhető szolgáltatásokat mutatja, régió váltása előtt érdemes az esetlegesen létrehozott, régió függő elemeket leállítani, hogy később ne jelenjen meg fizetési kötelezettség.

[[Fájl:GAMFAWS ec2 dashboard.png]]

==== EC2 telepítése és beállítása ====
EC2 létrehozásához meg kell nyomnunk a ''Launch instance'' gombot, melyet több helyen is elérhetünk:
* A Dashboardon
* A bal oldali menüben található ''Intances'' menüpont megnyitása után jobb felül
A gomb minden esetben a következőképp néz ki: [[Fájl:GAMFAWS ec2 launch instance button.png]]

A gombra kattintva egy űrlap jelenik meg, amely segítségével elvégezhetjük a szükséges beállításokat: 
======Név és tag beállítok======
Megadása nem kötelező, de több szerver futtatása esetén könnyebben azonosíthatjuk be őket ezek segítségével
[[Fájl:GAMFAWS ec2 setup name and tags.png]]

Az ''Add additional tags'' gombra kattintva további kulcs=érték párokat adhatunk hozzá, amivel dinamikusan csatolhatjuk össze egyéb szolgáltatásokkal, amelyek egy-egy kulcsot keresve döntik el, hogy melyik szolgáltatásokkal kell együttműködniük (például monitorozás bekapcsolása 'monitoring=true' kulcs=érték pár alapján.

======Kezdeti képfájl kiválasztása======
Az Amazon többféle indítóképpel is rendelkezik, így nagy valószínűséggel meg fogjuk találni a hozzánk közelálló operációs rendszert. Új hozzáadására nincs lehetőségünk, de készíthetünk az alapképfájlokból olyan verziót, ami már tartalmazza a saját konfigurációnkat (lásd [[GAMF :: Felhőalapú-szolgáltatások :: AWS#AMI_létrehozása|itt]]). 
[[Fájl:GAMFAWS ec2 setup AMI choose2.png]] 
Az órákon az Ubuntu legújabb verzióját használjuk, mivel ennek a Desktop változata az egyik legelterjedtebb a Linux felhasználók körében, így nem kell más környezetet megszoknia egy átlag hallgatónak. Érdemes lehet azonban egyéb disztribúciók kipróbálása is, különösen a '''Debian'''-t, '''Suse'''-t/'''OpenSuse'''-t, '''ReadHat'''-et és annak ingyenes változatait ('''AlmaLinux''', '''RockyLinuxtm''', amelyek az egykori '''CentOS'''-t hivatottak váltani), mivel céges környezetben ezek sűrűbben előfordulnak: némelyik a kisebb erőforrásigénye, míg másik az Enterprise szolgáltatásai miatt.

======Szerver típusának meghatározása======
Különböző erősségű szerverkonfigurációk közül választhatunk, de természetesen nem mindegyik érhető el az ingyenes verzióban. A számítógépek ára a konfiguráció függvényében változik, de csak azért az időért kell fizetni, amíg a szerver ''Running'' állapotban volt. Az órán az alapértelmezett ''t2.micro''-t használjuk. 
[[Fájl:GAMFAWS ec2 setup instance type.png]]

======Kulcspár hozzárendelése======
Az Amazonon belüli szolgáltatásokat felhasználónév/jelszó páros helyett SSH kulcspárok segítségével érjük el. Minden felhasználó számára készíthetünk egyet és jogosultságok segítségével korlátozhatjuk, hogy mihez férhet hozzá (IAM). 
Ebben a szekcióban ki kell választanunk, hogy a telepíteni kívánt EC2-höz milyen kulcspárral lehet majd hozzáférni. Amennyiben nem rendelkezünk még kulcspárral, úgy van lehetőségünk helyben elkészíteni a ''Create new keypair'' gomb segítségével, amelynek lépési megegyeznek az [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Kulcspár_létrehozása|itt]] leírtakkal. 
[[Fájl:GAMFAWS ec2 setup keypair.png]]

======Hálózati és biztonsági beállítások======
Az EC2-k közötti kommunikációs csatornák kialakításához definiálnunk kell, hogy melyik virtuális hálózatba akarjuk elhelyezni és milyen alkalmazásokat szeretnénk elérhetővé tenni. Ezt a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#VPC_beállításai|VPC]] és a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Security_Group|Security Group]] beállításával tehetjük meg. Előbbi a virtuális hálózatnak felel meg, míg utóbbi hasonlóan egy tűzfalhoz, meghatározza, hogy a szerveren milyen portokat érhetünk el. Érdemes az SSH-t engedélyezni és ha webes alkalmazást szeretnénk rajta futtatni a későbbiekben, akkor a HTTP és/vagy HTTPS szolgáltatást/szolgáltatásokat is, így később nem kell szerkeszteni ezeket a beállításokat. 
[[Fájl:GAMFAWS ec2 setup networking.png]]

======Tárhely beállítások======
Ebben a részben adhatjuk meg, hogy a szerverünk mekkora tárhellyel rendelkezzen. Egy Linux alapú operációs rendszernek nem kell 8GB-nél több, így az alapértéken hagyhatjuk. Az itt megadott érték inkább csak egy korlát, valójában csak akkora tárhelyet vesz igénybe, amennyire ténylegesen szüksége van a rendszernek. Ez az érték alatt látható figyelmeztetés miatt lényeges, hiszen a 30GB-t elhagyva fizetőssé válik a tárterület is, ám ez nem jelenti, hogy csak 4 szervert tudnánk elindítani az ingyenes keretek között. 
[[Fájl:GAMFAWS ec2 setup ebs.png]]

Ezt a szolgáltatást EBS-nek nevezik (''Elastic Block Store'') és az EC2 megszűnésekor minden erre mentett adat elveszik, így általában az OS-t és az applikáció kódját tároljuk ezen - semmi dinamikus adatot.

======Haladó beállítások======
Ebben a szekcióban különböző beállításokat végezhetünk el, ám ezeket az órán nem módosítjuk. Érdekes lehet azonban a menüt lenyitva legalul található ''User data'' opció, amivel parancsokat adhatunk meg az új operációs rendszer számára, hogy miket futtasson le. Ennek segítségével lehetőségünk nyílik applikációk telepítésére - pl. git - és a kód letöltésére egy másik szerverről, amennyiben a kiválasztott képfájl nem tartalmazta azt. 
''Az órai keretek között ezt a funkciót nem használjuk ki, de érdemes lehet kipróbálni, mivel valós alkalmazások üzemeltetésekor jól jöhet.'' 
[[Fájl:GAMFAWS ec2 setup userdata.png]]

======Összefoglaló======
A beállító panel mellett jobbra találhatjuk az összefoglaló ablakot, amelyben megtalálható a ''Launch Instance'' gomb. Ennek segítségével kezdhetjük meg a végleges telepítést, ha erre rá nyomunk, akkor a rendszer megkezdi a kiválasztott konfiguráció telepítését. Ha ebben az ablakban pénzösszegeket látunk, akkor az egészen biztosan fizetési kötelezettséget vonz magával, legyünk körültekintőek. 
[[Fájl:GAMFAWS ec2 setup summary.png]]

======Az elkészült instance tulajdonságai======
A futó szerverek az ''Instances'' menüpontban érhetők el. Az egyes sorokra kattintva alul megtekinthetjük a beállításait, amely tartalmazza az AWS által kiosztott publikus és privát IP címeket és domain neveket. Ezeken keresztül tudunk kommunikálni szerverünkkel. 
[[Fájl:GAMFAWS ec2 properties.png]] 
''Jelen példában a külső IP címünk: 3.252.168.207, amit a mellette található ikonnal egyszerűen a vágólapra másolhatunk.''

======Csatlakozás Linux terminálból======
A csatlakozáshoz nyissunk meg egy terminált a CTRL+T billentyűkombinációval, majd navigáljunk a ''cd'' parancs segítségével a letöltött kulcsfájl mappájába. Az SSH megköveteli, hogy a csatlakozáshoz használt kulcsfájlhoz csak a tulajdonos felhasználó férjen hozzá, így a következő parancsot futtassuk le rajta: ''chmod 600 test.pem''

A következő paranccsal tudunk kapcsolódni: ''ssh -i test.pem ubuntu@3.252.168.207'' 
Ha a fenti parancs kéri, fogadjuk el a tanúsítványt. Amennyiben ''Permission error'' hibát kapunk, akkor a fenti ''chmod'' parancsra van szükségünk, vagy nem mi vagyunk a kulcsfájl tulajdonosai (''ls -l'' segíthet). 
A ''test.pem'' az AWS rendszerből letöltött .pem formátumú kulcsfájl, az ''ubuntu'' a szerveren elérhető felhasználó. A különböző disztribúcióknál használt felhasználónevekről [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connection-prereqs.html ezen] a linken tájékozódhatsz. 
[[Fájl:GAMFAWS ec2 connect linux.png]]

======Csatlakozás Putty használatával======
Amennyiben a .pem kiterjesztésű állományt töltöttük le az AWS rendszeréből, akkor a '''puttygen''' eszköz segítségével ki kell exportálni belőle a privát kulcsot. [https://www.ssh.com/academy/ssh/putty/windows/puttygen Ezen a linken] részletes segédlet található a programcsomaghoz, ahol további funkciók is bemutatásra kerülnek (pl. kulcsgenerálás).

==== Kulcspár létrehozása ====
A kulcspárok kezeléséhez a ''Key Pairs'' linket nyissuk meg a bal oldali menüből. Újat a jobb oldalon látható ''Create key pair'' gomb segítségével készíthetünk. [[Fájl:GAMFAWS ec2 keypair create.png]]

A gombra kattintva egy űrlapot kapunk, amely végig vezet minket a létrehozás lépésein.
# Név megadása
# Típus kiválasztása - ''RSA-val dolgozunk az órán''
# Letöltendő kulcs típusa - ''Linux terminálból való csatlakozáshoz a .pem fájlra lesz szükségünk''
# Esetleges tag-ek hozzárendelése
# A ''Create key pair'' gombra kattintva letölthetjük a kulcspárt

[[Fájl:GAMFAWS ec2 keypair setup.png|Kulcspár létrehozása]]

'''Figyelem!''' A kulcspár csak a létrehozás után tölthető le '''egyetlen egyszer''', az elvesztett fájlok nem reprodukálhatók! Amennyiben egy EC2 csak az elhagyott kulcspárral érhető el, úgy annak (EC2) törlése és újrakonfigurálása szükséges egy új kulccsal.

==== Security Group ====
A Security Group-ok segítségével kontrollálhatjuk, hogy a szervereinkhez milyen portokon férhetnek hozzá, tehát mintegy tűzfal működik. Egy Security Group több gépre is ráhúzható és függetlenül működik, azaz a megadott szabályokat nem másolja át az operációs rendszer konfigurációs állományaiba, mintegy a szerver elé telepített eszköz működik. Ennek köszönhetően futási időben változtathatjuk a szabályokat, életbelépésükhöz nem kell újracsinálni az EC2-ket.

A bal oldali sávban, a ''Network & Security'' csoportban érhető el.

===== Security Group hozzáadása =====
Egy új szabályrendszer felvételét kezdeményezhetjük az EC2 telepítésekor, ahogyan azt [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Hálózati_és_biztonsági_beállítások|itt]] is láthattuk, de készíthetünk előre meghatározottakat is.

Az előre definiált csoportokat a ''Create Security Group'' gomb segítségével hozhatjuk létre, amelyet a jobb felső sarokban találhatunk meg. 
[[Fájl:GAMFAWS ec2 secg new button.png|bélyeg]sdfsad] 

A gomb megnyomását követően egy űrlapot kapunk, melynek 3 fő része van:
# Általános adatok [[Fájl:GAMFAWS ec2 secg new basic.png|bélyeg|Általános adatok]]
#* '''A név és a leírás mező megadása is kötelező'''
#* Itt választhatjuk ki, hogy mely VPC-ben szeretnénk elérhetővé tenni.
# Bejövő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg inbound.png|bélyegkép|Inbound rules]]
#* '''Az itt megjelenő szabályok lesznek engedélyezve a szerverünk felé, minden más csomag eldobásra kerül'''
#* Háromféle szabályból választhatunk:
#** '''Anywhere''' (IPv4, IPv6): A megadott IP típusból mindenhonnan elfogadjuk a csomagokat
#** '''Custom''': Csak a megadott IP címekről/IP tartományokból érjük el az adott portot
#** '''MyIP''': automatikusan beillesztésre kerül az felhasználó aktuális IP címe (hasonló a custom lehetőséghez)
# Kimenő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg outbound.png|bélyegkép|Outbound rules]]
#* A kimenő forgalom szabályozása biztonsági szempontból megfontolandó, de természetesen a publikus alkalmazások esetében (pl. web) nem tudunk ilyen szűrést alkalmazni.
#* Alkalmazhatjuk például SSH-ra, hogy megszüntessük annak a lehetőségét, hogy egy esetleges fertőzésből kifolyólag SSH-t hackelgető botnetté változzunk (volt már hasonló tapasztalat).
#* Az órán ezzel bővebben nem foglalkozunk, de éles környezetben ne felejtsünk el ezen szabályok definiálására időt szánni.
# Tag-ek megadása

===== Security Group szerkesztése =====
A szerkeszteni kívánt soron kattintsunk jobb gombbal és válasszuk ki a szerkeszteni kívánt szabályok csoportját:
* '''Edit inbound rules''', ha a bejövő csomagok szűrését szeretnénk módosítani,
* ''' Edit outbound rules''', ha a kimenő forgalmat szeretnénk szűrni.
A megnyíló ablakban ugyanazon a módon vehetünk fel szabályokat, ahogyan a létrehozásnál. A módosítások mentés után életbe lépnek. 
[[Fájl:GAMFAWS ec2 secg context menu.png]]

==== Terheléselosztás vázlat ====
[[Fájl:EC2LoadBalancingRequirements.png|középre]]

==== AMI ====
Az AMI gyakorlatilag egy bitről-bitre lemásolt HDD képfájl, amely tömörítve lett. Így tárolja az összes elmentett adat- és konfigurációs állományt. Ha egy alkalmazást készítünk, akkor a következő okokból készítünk ilyen képfájlt:
# Biztonsági mentés a telepített szolgáltatásokról, így később nem kell egy esetleges hiba miatt újrakonfigurálni az egészet
# AutoScaling group-ba szeretnénk rendezni az alkalmazásunkat, annak pedig meg kell mondani, hogy melyik képfájlt indítsa el

'''Figyelem!''' A képfájlok úgynevezett snapshot-okat hoznak létre, amelyek tárolásáért fizetni kell, ha az összméret meghaladja a 8GB-ot. (A snapshotok az éppen futó rendszer miatt készülnek: minden írási műveletet lezár, majd a snapshot készítés után elindított írási műveletek már a háttértár egyéb területeire történik, amelyet a mentés nem fog tartalmazni, így garantálható, hogy nem lesznek félig lezárt fájlok a mentésben. Lásd bővebben: BTRFS (linux) és NTFS support). A pillanatképek nem törölhetők, amíg a belőlük készült AMI létezik!

===== AMI létrehozás lépései =====
'''Navigáljunk az Instances menüpontra, ahol láthatjuk, hogy milyen EC2 szolgáltatások vannak a rendszerünkben.'''
# Kattintsunk jobb gombbal azon az elemen, amelyet menteni szeretnénk
# Nyissuk ki az ''Image and templates'' menüpontot
# Kattintsunk a ''Create image'' lehetőségre 
[[Fájl:GAMFAWS ec2 ami create.png]]

'''Nevezzük el a képfájlt tetszés szerint''' 
[[Fájl:GAMFAWS ec2 ami setup.png]]

'''Navigáljunk a bal oldalon található menüben az ''Images'' szekcióhoz és válasszuk ki az ''AMIs'' elemet. Itt megtekinthetjük és törölhetjük a létrehozott képfájljainkat.''' 
[[Fájl:GAMFAWS ec2 ami list.png]]

'''Ha a mentés sikeresen elkészült, akkor az EC2 létrehozásánál kiválaszthatjuk azt.''' 
[[Fájl:GAMFAWS ec2 setup own ami select.png]]

==== Indítási konfigurációk elkészítése ====
Az indítási konfigurációk mind egy célt szolgálnak: egységes profilba rendezi az EC2-ről készült képfájlokat. Míg az AMI nem tárolt információt a mentett gép erőforrásáról, egy indítási konfigurációban megadhatjuk ezeket. Később ezek felhasználásával egyszerűbben indíthatunk újabb szervereket és vannak olyan esetek is, amikor a rendszer megköveteli, hogy a képfájl megadása helyett konkrét, hardverinformációkat is tároló konfigurációs sablonokat adjunk meg.

''Az Auto Scaling Group például megköveteli, hogy a következő kettő elem közül az egyiket megadjuk, ebből fogja tudni, hogy milyen típusú EC2-t, mekkora tárhellyel és milyen VPC-ben indítson el.''

===== Launch configuration =====
'''Egy kifutóban lévő konfigurációs séma, amely 2022. December 31-e után nem kapja meg a frissítéseket. Az AWS javaslata szerint érdemes ezeket a beállításokat a következőkben tárgyalt ''Launch template'' alá migrálni.

A ''Launch configuration'-nek nevezett séma egy egyszerűsített változata a sablonoknak. Jóval kevesebb beállítási lehetőséget tartalmaz, mint a párja, de tökéletesen elegendőt az ''Auto Scaling Group''hoz.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Auto Scaling group'' szekciót és válasszuk ki a ''Launch Configuration'' menüpontot. A jobb felső sarokban található ''Create launch configuration'' gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''Név megadása''', aminek segítségével később hivatkozhatunk erre az elemre. Kitöltése kötelező! 
[[Fájl:GAMFAWS ec2 launch conf setup name.png]]

''AMI kiválasztása'', tehát azok képfájl megadása, amit a kiválasztott EC2 konfiguráció futtatni fog. Lehetőségünk van a saját készítésű (''My AMIs'') és a közösségi képfájlok közül választani (''Marketplace''). 
[[Fájl:GAMFAWS ec2 launch conf setup ami.png]]

'''Instance típus''' alatt megadhatjuk, hogy a konfiguráció milyen teljesítményű legyen.
'''Ne feledjük el, hogy a t2.micro az ingyenes, a többi használata után fizetési kötelezettségünk jelenhet meg.'''
[[Fájl:GAMFAWS ec2 launch conf setup instance type.png]]

'''Az Additional configruation''' részben megadhatunk különböző paramétereket, amelyeket az EC2 fog felvenni - pl. mindenképp kapjon IP címet, a subnet beállításaitól függetlenül, vagy éppen ne kapjon; itt adhatjuk meg a telepítéskor lefuttatott scripteket (User data).

'''A Storage''' szekcióban megadhatjuk, hogy milyen lemezek és milyen méretűek legyenek a rendszerhez csatolva.

'''A Security Group''' részben kiválaszthatunk egy már meglévő szabályrendszert, vagy készíthetünk újat. 
[[Fájl:GAMFAWS ec2 launch conf setup secg.png]]

'''A Key pairs''' blokkban megadhatjuk, hogy milyen privát kulccsal léphetnek be a szerverekre. Ennek meglétét jóvá kell hagyni az alul található checkbox-szal. 
[[Fájl:GAMFAWS ec2 launch conf setup keypair.png]]

'''Végül kattintsunk a ''Create launch confgiration'' gombra a létrehozáshoz.'''

===== Launch template =====
A Launch template jóval gazdagabb a beállítási lehetőségekben, mint párja. A konfigurációs adatlap tartalmaz segédletet az AutoScaling Group-pal történő használathoz, amely ''required'', azaz kötelező mezőként jelöli meg azokat az adatbeviteli elemeket, amelyeket az automata skálázó rendszer használ. Érdemes ezt bekapcsolni, amennyiben ilyen célzattal készítjük el a sablonunkat.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Instances'' szekciót és válasszuk ki a ''Launch template'' menüpontot. Az oldal közepén vagy a jobb felső sarokban található Create launch configuration gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''A sablon neve és leírása''' blokkban megadhatjuk a nevet és a leírást, de ugyanakkor itt választhatjuk ki azt a checkboxot is, ami később a segítségünkre lesz a konfigurációs sablon AutoScaling Group-hoz való illesztését is (''Auto Scaling guidence''). 
[[Fájl:GAMFAWS ec2 launch templ setup name.png]]

'''Az Application and OS images''' szekcióban megadhatjuk, hogy milyen AMI-val települjön az EC2. Itt választhatunk a sajátunkból, vagy az EC2-nél is megtalálható egyebekből. 
[[Fájl:GAMFAWS ec2 launch templ setup ami.png]]

'''Az Instance type''' csoportban megadhatjuk, hogy milyen teljesítményű gépet szeretnénk indítani.
'''Ne feledjük el, hogy az ingyenes változatban a t2.micro érhető el, másik lehetőség választása esetén fizetési kötelezettségek léphetnek fel!''' 
[[Fájl:GAMFAWS ec2 launch templ setup instancetype.png]]

'''A Key Pair''' blokkban megadhatjuk, hogy a gépek milyen kulcspárral engedélyezzék a belépést. 
[[Fájl:GAMFAWS ec2 launch templ setup key pair.png]]

'''A Network Confguration''' részben definiálhatjuk, hogy milyen VPC-be szeretnénk lerakni az EC2-ket, milyen security group legyen rajtuk. Természetesen utóbbi helyben is létrehozható, ha korábban ezt nem készítettük volna el. 
[[Fájl:GAMFAWS ec2 launch templ setup network.png]]

'''A Storage'''-nél megadhatjuk, hogy milyen kötetek, milyen méretben legyenek hozzácsatolva a rendszerhez.

'''A Tags''' blokkban felvehetjük a kívánt ''kulcs=érték'' párokat.

'''Az Additional Configuration''' szekcióban különböző haladó beállításokat eszközölhetünk a sablon által létrehozott EC2-n, többet között itt adhatjuk meg az indításkor lefuttatandó parancsok listáját (''User data'').

'''Végül kattintsunk a Create launch template nyomógombra a mentéshez!'''.

==== Target Group ====
A target group EC2-k azon csoportja, amelyeken valamilyen ''health check'' algoritmust futtatunk, ezzel meghatározva, hogy az adott csoportban hány használható, működő szerver fut. Ezt az információt elsőként a Load balancer használja ki.

A Target Group a bal oldali menüben, a ''Load Balancing'' szekcióban érhető el ''Target Groups'' néven.

Létrehozhatunk új csoportot, de meg kell adnunk, hogy milyen módon kerüljenek bele az EC2-k. Erre a következő metódusokat ajánlja fel az Amazon:
# Konkrét EC2 (Instance) kiválasztása
# EC2-k definiálása IP tartománnyal
# Lambda függvény hozzáadása
# Alkalmazás LoadBalancer, amely egy teljes VPC tartalmát magába foglalja.

Az űrlap alján megadhatjuk, hogy milyen életjel ellenőrzés történjen.

Általában nem mi vesszük fel egyesével az Instancokat ebbe a csoportba, hanem az AutoScaling group regisztrálja őket bele. '''Ezért ezt az űrlapot nem használjuk'''.

==== Load Balancer ====
A Load Balancer terheléselosztást jelent, tehát a bejövő forgalmat több gép között osztjuk el. Ezzel növekszik a felhasználói élmény, ráadásul a rendszer megállítása (egy hacker által) nehezebbé válik: ha kettő t2.micro teljesítményű szerver fut, amelyek között elosztjuk a bejövő forgalmat, akkor a rendszerünk valójában 2xt2.micro teljesítményű.

Terheléselosztót a bal oldali menü ''Load Balancing'' szekciójának ''Load Balancers'' menüpontjában hozhatunk létre.

'''A támogatott szolgáltatási szintek:'''
# Alkalmazás terheléselosztás (HTTP, HTTPS)
# Hálózati terheléselosztás (TCP, UDP)
# Átjáró terheléselosztása (GW)

===== Alkalmazás terheléselosztása =====
Ebben a formában konfigurálhatjuk az eszközt úgy, hogy az internet felől elérhető legyen (internet-facing) és úgy, hogy csak belső hálózaton működjön (internal). A belső hálózatot mindig az aktuális VPC-re kell érteni, tehát annak minden alhálózatából elérhető alapértelmezetten.
[[Fájl:GAMFAWS ec2 loadbalancer setup basic.png]]

A hálózati beállításoknál választhatunk, hogy mely alhálózatokban szeretnénk végrehajtani a terheléselosztást, így csak az azokban futó EC2-k kaphatnak ezen keresztül csomagokat. Arra kell ügyelnünk, hogy legalább kettő különböző zónában lévő alhálózatot kell kiválasztanunk (pl. eu-west-1a, eu-west-1b stb.).
[[Fájl:GAMFAWS ec2 loadbalancer setup network.png]]

Természetesen a LoadBalancer internetfelőli végpontján létrehozhatunk ''Security Group''okat, amelyet szabályozzák, hogy milyen IP címről fogadunk el csomagokat.
[[Fájl:GAMFAWS ec2 loadbalancer setup secg.png]]

A ''Listeners and routing'' résznél megadhatjuk, hogy melyik target group fogja a terhelést fogadni, tehát hogy mely EC2-k között tudunk ténylegesen terhelést elosztani. Amennyiben a target group egy darab EC2-t tartalmaz, akkor a terheléselosztás gyakorlatilag nem valósul meg, csak az elméleti esélyét adtuk meg, hogy ''„amennyiben lenne még egy EC2 a target group-ban, akkor a terhelés egy részét az vinné el”''.
[[Fájl:GAMFAWS ec2 loadbalancer setup routing.png]]

Végül kattintsunk a ''Create load balancer'' gombra, amennyiben a kívánt tag-eket is rögzítettük.

==== Auto Scaling Group ====
A szolgáltatás segítségével automatikusan skálázott rendszereket építhetünk ki, ahol a szerverek által nyújtott elérhető erőforrásokat minél közelebb tartja a bejövő terhelés által meghatározott erőforrásigényhez. Természetesen mindez akkor igaz, ha az ''Auto Scaling Group'' be regisztrálja az általa létrehozott ''EC2''-ket egy ''Target Group''-ba, ami felett ''Load Balancing'' van definiálva.

'''Előnyei''':
* Amikor nincs bejövő terhelés, akkor nincsenek nagy költségek
* Amikor nagy a bejövő terhelés, akkor a költségek megugranak ugyan, de az ügyfeleket ki tudtuk szolgálni úgy, hogy elégedettek voltak a rendszer teljesítményével.

'''Hátrányai''':
* Kaotikus számlák, nem előre tervezhető költségek
* Megnövekedett költségek DDoS és egyéb támadások esetén

===== A beállítás lépései =====
A szolgáltatást a bal oldali menü ''Auto Scaling Group'' szekciójában érjük el, az ''Auto Scaling Group'' menüpontban. A képernyő közepén vagy a képernyő jobb felső sarkában megjelenő ''Create auto scaling group'' gombra kattintva egy űrlap jelenik meg, ami végig vezet minket a telepítés lépésein.

'''A Name''' szekcióban elnevezzük az új group-ot.
[[Fájl:GAMFAWS ec2 autoscaling setup name.png]]

'''A következő szekcióban''' két választási lehetőségünk van:
* Launch Template-tel telepítjük az új group-ot, ez esetben csak ki kell választanunk a korábban létrehozott sablont, vagy az alatta található link segítségével készíthetünk újat. ''Amennyiben újat készítünk, a sablon létrehozása új ablakban nyílik meg, így a befejezést követően vissza kéne térnünk erre és a frissítést gombot megnyomva látni fogjuk az új lehetősége(ke)t.
[[Fájl:GAMFAWS ec2 autoscaling setup lt.png]]

* Launch Configuration-nel telepítjük az új group-ot, ez esetben át kell váltatnunk a ''Switch to launch configuration'' link segítségével a blokkot. A váltást követően hasonlóan az előzőekhez: vagy kiválasztjuk a már meglévő konfigurációs sémát, vagy hozhatunk létre újat.
[[Fájl:GAMFAWS ec2 autoscaling setup lc.png]]

'''A Next gombra kattintva a hálózati beállítások''' szekcióhoz érünk, ahol megadhatjuk, hogy az indított EC2 milyen VPC-be kerüljön és azon belül milyen alhálózatokba. VPC-ből egy, alhálózatból több is kiválasztható. Ügyeljünk rá, hogy ha később erre Load Balancer szolgáltatás is kerül, akkor legalább kettő zónát jelöljünk ki!
'''Figyelem!''' A zóna nem egyezik meg az alhálózattal!
[[Fájl:GAMFAWS ec2 autoscaling setup network.png]]

'''A Next gombra kattintva a Load Balancing beállítások''' következnek, ahol választhatunk:
* Nincs terheléselosztás opciót,
* Létező Load Balancer hozzáillesztését,
* Új Load Balancer létrehozását.

Utóbbi esetében a Load Balancer konfigurálásánál leírt módon ki kell töltenünk a Load Balancer űrlapját is helyben. 
[[Fájl:GAMFAWS ec2 autoscaling setup lb setup.png]]

Hasonlóan a ''Target Group''-ot is létrehozhatjuk helyben, amennyiben ezt nem tettük meg korábban.
[[Fájl:GAMFAWS ece autoscaling setup new lb new tg.png]]

'''A Next gombra kattintva a csoport méretét definiálhatjuk''', azaz megszabhatjuk, hogy hány darab szervertől, hány darab szerverig engedélyezzük az automatikus skálázást. Ez egy hasznos funkció, hiszen ezzel korlátok közé szoríthatjuk a költségeinket, miközben a legkisebb terhelés esetén is előkészülhetünk egy hirtelen bejövő nagyobb terhelésre (ha a minimum nem 1).
* Desired capacity: ennyi szervert fog elindítani az ASG mentés után
* Minimum capacity: ennyi szerver esetén már nem állít le semmit az ASG
* Maximum capacity: ennyi szerver esetén már nem indít el újabbat az ASG
[[Fájl:GAMFAWS ec2 autoscaling setup group.png]]

'''Alatta a Scaling Policy''' blokkban megadhatjuk, hogy milyen paraméterek mentén indítson vagy épp állítson le szervereket az ASG. Ehhez aktiválnunk kell a szolgáltatást és a ''Metric type'' listából ki kell választani az számunkra megfelelőt. Mi általában CPU terhelés alapján döntünk az órán.
[[Fájl:GAMFAWS ec2 autoscaling setup scaling.png]]

'''A Next gombokkal lépkedve hozhatunk létre Tag-eket, majd végül létrehozhatjuk az ASG-t is és az ''Instances'' menüpontban ellenőrizhetjük, hogy ténylegesen elindult a kívánt darabszámú szerver.'''

=== RDS szolgáltatások ===
A ''Relational Database Service'' foglalja magában a különböző adatbázisokat:
* MariaDB
* MySQL
* Aurora
* Oracle
* PostgreSQL
* MSSQL

'''Figyelem!''' Az itt felsorolt szerverek között lehetnek fizetősek is. Mindig járjunk el figyelmesen, kövessük a költségeket. Az RDS az amazon egyik legdrágább szolgáltatása.

==== MySQL adatbázis telepítése ====
==== Csatlakozás MySQL adatbázishoz CLI-ből ====
<syntaxhighlight lang="bash">
apt install mysql-client -y
# mysql -h<rds_endpoint> -u<rds_user> -p<rds_password>
mysql -hwebshop-989.rds.amazon.com -uadmin -p123456789
</syntaxhighlight>

A megnyíló '''mysql>''' PROMPT-ot tartalmazó sor azt jelenti, hogy sikeresen csatlakoztunk az SQL szerverhez. Amennyiben a csatlakozás sikertelen, akkor valószínűleg az RDS-hez kapcsolt Security Group beállításai nem engedik az EC2-ről a kapcsolódást - tipikusan a mi saját publikus IP címünk kerül bele az engedélyezett tartományba (pl. iskolai IP vagy otthoni) és ez nem került átírásra az amazonos tartománynak megfelelően.

A konzolra be kell illeszteni a ''networks.sql'' fájl tartalmát. A végén '''exit''' paranccsal léphetünk vissza a BASH környezetbe.

=== VPC ===
A '''V'''irtual '''P'''rivate '''C'''loud egy szolgáltatás, melynek segítségével össze köthetjük az összetartozó komponenseket, alkalmazásokat. A VPC-t modellezhetjük hétköznapibb értelemben, mint egy routert, amelynek vannak alhálózatai, route táblája és valamilyen gateway címe, amin keresztül a kliensei az internet más résztvevőivel tudnak kommunikálni.

A VPC szolgáltatásait a keresőbe írt ''VPC'' kulccsal érhetjük el.
==== VPC létrehozása ====
Navigáljunk a 'Your VPCs' menüpontra a bal oldali menüben és kattintsunk a jobb felső sarokban látható ''Create VPC' gombra. Ezután megnyílik egy űrlap, amely végig vezet minket a telepítés lépésein.

Az űrlap elején választhatunk, hogy ''VPC only'' vagy ''VPC and more'' módban szeretnénk folytatni. Előbbi csak a VPC-t hozza létre nevéből is adódóan, míg a másik opcióval létrehozhatjuk az alhálózatokat is, igaz, a tervezés szabadságáról le kell ilyenkor mondanunk, cserébe grafikán láthatjuk az eredményt. Számunkra az órán utóbbi nem lesz megfelelő, hiszen szükségünk lesz a ''tervezés szabadságára''. 
[[Fájl:GAMFAWS vpc setup.png]]

A VPC beállításainál mindig a teljes hálózatot átfogó IP/MASZK párost kell megadnunk, később az alhálózatok nem lóghatnak ki az itt megadott tartományból.

==== Alhálózatok ====
Az alhálózatok lehetőséget biztosítanak arra, hogy az egyes komponenseket el is szigeteljük egymástól, meg engedélyezzünk is közöttük bizonyos kommunikációt.

Alhálózatok típusai:
* Publikus: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten kapnak publikus IP címet
* Privát: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten nem kapnak publikus IP címet

===== Alhálózatok létrehozása =====
Navigáljunk a ''Subnets'' menüpontra. A képernyő jobb felső sarkában kattintsunk a ''Create subnet'' gombra, így megkapjuk a létrehozási űrlapot.

'''Először''' a VPC-t kell kiválasztanunk, aminek eredményeképp kiírja segítségképp annak tartományát. Ezen a tartományon kívül nem léphetünk. 
[[Fájl:GAMFAWS vpc subnet setup.png]]

A VPC kiválasztása után aktívvá válik az alhálózatok űrlap, ahol megadhatjuk annak nevét, hálózati címét és maszkját. 
[[Fájl:GAMFAWS vpc subnet setup new.png]]

'''Figyelem!''' A rendszer csak hálózati címet fogad el! Minden más esetben hibát ír ki.

A ''Remove'' gombbal eltávolíthatjuk az aktuális konfigurációt a listából, míg a lentebb található ''Add new subnet'' segítségével újabbat vehetünk fel.

Befejezésül nyomjuk meg a ''Create subnet'' gombot, így az összes definiált alhálózat létrejön a kiválasztott VPC-hez.

===== Publikus/Privát alhálózat beállítása =====
Az alhálózat típusának átállításához navigáljunk a ''Subnets'' menüpontra. Kattintsunk jobb gombbal a kívánt alhálózat során és válasszuk ki az ''Edit subnet settings'' opciót. 
[[Fájl:GAMFAWS vpc subnet edit s settings.png]]

Az űrlapon keressük meg az ''Auto-assign IP settings'' blokkot és a kívánt típusnak megfelelően módosítsuk azt.
[[Fájl:GAMFAWS vpc subnet edit type.png]]

===== Különböző route tábla minden alhálózaton =====
A VPC támogatja, hogy minden subnet saját route táblával rendelkezzen. Ez lehet akár egy biztonsági funkció is, hogy ne ismerje minden EC2 az útvonalat egy adott szerverhez, de egyes esetekben kötelezően létre kell hoznunk. A route táblákat a ''Route tables'' menüpontban hozhatjuk létre és a ''Subnets'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Edit route table association'' opciót kiválasztva szerkeszthetjük.

'''Figyelem!''' A route táblák cseréje okozhat internetelérési problémákat szerver oldalon, aminek következtében a futó szolgáltatások számunkra is elérhetetlenekké válnak (pl. SSH és/vagy HTTP/HTTPS stb.), így legyünk körültekintőek.

==== Internet Gateway ====
Ahhoz, hogy a VPC-n belül legyen internet, ahhoz egy IGW-t kell hozzá csatolnunk. Ezt megelőzően azonban létre kell hoznunk egyet.
'''Figyelem!''' A VPC-hez nem kapcsolt IGW-k pénzbe kerülhetnek, mivel feleslegesen foglalnak le egy publikus IPv4 címet.

[[Fájl:GAMFAWS vpc igw setup.png|bélyegkép|Internet Gateway létrehozás]]
Az IGW az ''Internet Gateways'' menüpont alatt érhető el és a jobb felső sarokban található ''Create internet gateway'' gombbal hozhatunk létre újat. Csupán egy nevet kell megadnunk, illetve rakhatunk rá tag-eket igény szerint.

A létrehozást követően hozzá kell rendelnünk egy létező VPC-hez, amit az ''Internet Gateways'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Attach to VPC'' opciót kiválasztva tudunk megtenni. Amennyiben a soron az ''Attached'' (zöld színű) felirat jelenik meg a (szürke színű) ''Detached'' helyett, akkor nem tudjuk VPC-hez csatolni (ilyenkor először a ''Detach from VPC'' opciót kell választanunk). 
[[Fájl:GAMFAWS vpc igw attach.png]]

Az IGW VPC-hez rendelése után a kívánt route táblákba fel kell vennünk, hogy minden csomagot arra irányítson.
[[Fájl:GAMFAWS vpc igw route setup.png]]

==== NAT Gateway ====
Lehetőség van Internet Gateway helyett NAT Gateway létrehozására is, de ez egy fizetős szolgáltatás. A nevének megfelelően ez lehetőséget biztosít, hogy azok az EC2-k, amelyek privát alhálózatba kerültek, kilássanak az internet felé (pl. frissítések keresése, telepítése), miközben védve vannak a kívülről érkező támadásoktól.
'''Ez egy lehetséges oka lehet, hogy külön válasszuk a route táblákat az alhálózatokon, hiszen az egyiknek minden csomagot az IGW felé, míg a másiknak minden csomagot a NAT Gateway felé kell továbbítania.''' ''Ha nem használunk NAT Gatewayt, akkor is érdemes lehet leválasztani az IGW-ről a privát alhálózatokat.''

=== AWSCLI ===
Az AWSCLI egy konzolos alkalmazás, amelynek segítségével menedzselhetjük környezetünket: hozhatunk létre új EC2-t akár, vagy kapcsolhatunk hozzá egyéb szolgáltatásokat (Security Group, ASG, LB stb.).

Az awscli program elérhető linux és windows környezetben egyaránt.

==== AWSCLI telepítése ====
'''Figyelem!''' Az ''apt install awscli'' a legtöbb Debian/Ubuntu rendszeren a régebbi, 1-es főverziójú AWS CLI-t telepíti a disztribúció saját tárolójából, amit az AWS már csak fenntartási (maintenance) módban frissít. Az AWS hivatalosan a 2-es főverzió telepítését ajánlja, amit a következő paranccsal tehetünk meg:
<syntaxhighlight lang="bash">
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
</syntaxhighlight>
Órai/gyakorlási célra az ''apt install awscli'' is elegendő lehet, de érdemes tudni, hogy nem ez a hivatalosan ajánlott telepítési mód.
==== Access Key management ====
Az ''awscli'' hozzáférési kulcsokon keresztül kap jogosultságot a szolgáltatások adataihoz, így használata előtt készítenünk kell egy újat. Ez a nevünkre kattintva (jobb felül), majd a ''Security credentials'' menüpontot kiválasztva tehetjük meg, az ''Access keys'' szekcióban. Nyissuk ezt le és kattintsunk a ''Create New Access Key'' gombra. 
<center>
{|
| [[Fájl:GAMFAWS UserMenu.png|150px|keretnélküli]] || [[Fájl:GAMFAWS SecurityCredentials.png|keretnélküli]]
|}
</center>

A gomb megnyomása után egy felugró ablak fogad, amelyben megtalálható az ''Access Key'' és a ''Security Access Key'' értéke. Érdemes a fájlt letölteni, hogy később is elérhetők legyenek ezek az adatok, '''az AWS többet nem fogja engedélyezni ezek megjelenítését!''' Ha az adatokat később nem tudjuk megadni, akkor újat kell készíteni.
[[Fájl:GAMFAWS SecurityCredentials ShowData.png|középre]]

==== AWS CLI konfigurálás autentikációs adatokkal ====
Az eszköz telepítése annak konfigurálásával ér véget: meg kell adnunk az autentikációs tokeneket. 
Ezt az '''aws configure''' parancs kiadásával tehetjük meg, ahol egyesével bekéri a szükséges adatokat. Ahol nem szeretnénk változtatni az előző értéken (szögletes zárójelek között láthatjuk ezt), ott hagyjuk üresen a sort és csupán entert nyomjunk.
[[Fájl:GAMFAWS AWSCLI config.png|középre]]

Az adatok megadása után menedzselhetjük az aws parancsokkal a környezetünket. Az aws parancsairól az '''aws help''' szolgáltat információt.

=== S3 ===
Ez a szolgáltatás fájlok tárolására alkalmas.

Több típusa is elérhető:
* Standard:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban sűrűn használt objektumok tárolására alkalmas
** A régiók közötti szinkronizáció megoldott
* Instant Glacier:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban ritkábban használt, hosszú élettartamú, de azonnali hozzáférést igénylő objektumok tárolására alkalmas
* Flexible Glacier:
** Magas rendelkezésre állás jellemzi
** Az alkalmazásban ritkán használt (évente 1x-2x), a mérettől független költséggel rendelkező megoldás
* Deep Archive Glacier:
** 7-10 évig tárolt adatokhoz optimalizált költségvonzat
** Előnyös a backup adatok tárolásához

A szolgáltatás a keresőben ''S3'' füzérrel kereshető.

==== Bucket létrehozása ====
Új tárolót a ''Create bucket'' gomb segítségével hozhatunk létre. A megjelenő űrlapon a nevet kell kitölteni és érdemes egy pillantást vetni a publikusság beállításaira is, hogy ez ténylegesen a célunknak megfelelő legyen.

'''Figyelem!''' A névnek nem csupán a mi környezetünkön belül kell egyedinek lennie, hanem a teljes AWS-en belül.

{| style="margin:auto"
| [[Fájl:GAMFAWS S3 new name.png|bélyegkép]] || [[Fájl:GAMFAWS S3 new public.png|bélyegkép]]
|}

==== Bucket kezelése ''awscli'' programmal ====
Az '''aws s3 help''' parancs segítségével további információt szerezhetünk az egyes utasításokról.

'''Bucket tartalmának listázása''' 
<syntaxhighlight lang="bash">
aws s3 ls [bucket_name]
</syntaxhighlight>
[[Fájl:GAMFAWS S3 CLI LS.png|középre]]

'''Adatok másolása Bucket-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* LOCAL_PATH a lokális fájlrendszeren belüli elérési útvonala a forrásfájlnak (vagy könyvtárnak)
* REMOTE_PATH a cél helye az S3-ban
** Az s3:// jelzi, hogy a cél az S3-ban van (S3Uri)
** A mappák helyett PREFIX-ek vannak (/folder/to/my/file esetében /folder/to/my a PREFIX)
** A mappákat nem kell S3-ban létrehoznunk (az előző pontból következik), a fájlnév előtti prefix dönti el a hova tartozását
** A PREFIX-eket az '''ls''' úgy kezeli, mint egy mappát
[[Fájl:GAMFAWS S3 AWSCLI cp2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* --recursive jelzi, hogy a LOCAL_PATH alatt minden bejegyzést töltsön fel
[[Fájl:GAMFAWS S3 AWSCLI copy recursive2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ból helyi fájlrendszerbe''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive s3://REMOTE_PATH LOCAL_PATH
</syntaxhighlight>
[[Fájl:GAMFAWS S3 AWSCLI cp2local.png|középre]]

==== Bucket kezelése grafikus felületen keresztül ====
Az S3 tartalmát elérhetjük az AWS grafikus felületén keresztül is, így tölthetünk fel, törölhetünk és módosíthatunk fájlokat anélkül, hogy saját számítógépünkre telepítenénk az ''awscli'' programot.

# Nyissuk meg az S3 szolgáltatás vezérlőpultját
# Kattintsunk a szerkeszteni kívánt tárhely nevére [[Fájl:GAMFAWS S3f list.png]] 
# A vezérlőgombok segítségével végezzük el a kívánt műveletet (feltöltés, törlés), vagy válasszunk ki egy PREFIX-et az „almappák” tartalmának megtekintéséhez. [[Fájl:GAMFAWS S3 control.png|középre]]

= Indítást gyorsító scriptek =
== UI indítás ==
<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun code
API_LB_DOMAIN="localhost" # api server IP

apt update
apt install wget unzip apache2 libapache2-mod-php8.3 php8.3 php8.3-curl -y

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui.php
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui_newproduct.php
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv ui.php /srv/$NEPTUN/index.php
mv ui_newproduct.php /srv/$NEPTUN/newproduct.php

# remove tmp directory
cd /
rm /tmp/code

cat << EOF > /etc/apache2/sites-enabled/000-default.conf
<VirtualHost *:80>
#ServerName www.example.com

ServerAdmin webmaster@localhost
DocumentRoot /srv/$NEPTUN

<Directory /srv/$NEPTUN/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>

ErrorLog \${APACHE_LOG_DIR}/error.log
CustomLog \${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

systemctl restart apache2
</syntaxhighlight>

== API indítás ==

<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun
MYSQL_DOMAIN="localhost" # RDS mysql domain

apt update
apt install wget unzip python3 python3-pip python3-flask -y
pip3 install mysql-connector-python --break-system-packages

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$MYSQL_DOMAIN/g" api.py
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv api.py /srv/$NEPTUN/

# remove tmp directory
cd /
rm /tmp/code

echo "@reboot root sleep 10s && python3 /srv/$NEPTUN/api.py &" >> /etc/crontab
cd /srv/$NEPTUN && python3 api.py &
‎</syntaxhighlight>

Hálózat rendelkezésreállás számítás

2026-09-14T08:18:21Z

ApelPro: Az ábra időközben javítva lett (újragenerálva helyes végeredménnyel), a 'hibás ábra' figyelmeztetés eltávolítva

Amennyiben magas rendelkezésreállású hálózatot tervezünk, akkor redundanciát kell kialakítanunk. Ezen az [[ISP csatlakozási típusok|oldalon]] összegyűjtöttem milyen módon csatlakozhatunk a szolgáltatókkal, ám ott nem esett szó számszerű értékekről a hiba lehetőségét tekintve. A következőkben felsorolok pár kapcsolást a hozzá tartozó hiba valószínűséggel.

'''A hibák valószínűségét mindenhol 1%-nak vettem, de ez messze nem igaz a hálózat minden elemére!'''

= 1 router - N router kapcsolat =
Ebben a fejezetben a kapcsolat egyik oldalán fixen egy router lesz, a másik oldalon pedig maximum kettő. A közöttük lévő vezetékek száma szintén maximum kettő.

== 1-1 router kapcsolat ==
[[Fájl:Fail 1-1 router.png|1000px|keretnélküli|középre]]

Ebben az esetben hibát okozhat, ha a bal oldali router megy tönkre (1%), a vezeték megy tönkre (1%) vagy jobb oldali router megy tönkre (1%). A vagy kapcsolat miatt az értékek összeadódnak, így összesen 3% valószínűséggel nem fogja tudni a csomagot továbbítani ez a kapcsolattípus.

[[Fájl:Fail Dual Homed.png|1000px|keretnélküli|középre]]
Ebben az esetben a routerek között két vezeték található, amelyek 1-1% valószínűséggel mehetnek tönkre. A kapcsolat csak akkor szakad meg, ha a bal oldali router (1%) vagy mind a két vezeték, vagy a jobb oldali router (1%) megy tönkre. Az előbbiek alapján láthattuk, hogy a vagy kapcsolat miatt az értékek összeadódnak, ám a vezeték esetében ÉS kapcsolat van, tehát azok hiba valószínűségét szorozni kell: 0.01*0.01 = 0.0001, azaz 0.01% valószínűséggel fog mindkét kábel tönkremenni. Ebből adódóan a teljes kapcsolás 2.01% valószínűséggel nem fogja továbbítani a csomagokat.

== 1-2 router kapcsolat ==
[[Fájl:Fail 1-2 router.png|1000px|keretnélküli|középre]]
Ebben az esetben egyértelműen bajba kerülünk, ha a bal oldalon lévő egyetlen router tönkremegy (1%). Azonban mindkét vezetéknek vagy mindkét routernek tönkre kell mennie (ezt előző számításból tudjuk, hogy 0.01% eséllyel megy tönkre mind a kettő), vagy az egyik vezetéknek és a másik jobb oldali routernek (0.01% eséllyel megy ilyen formában tönkre, de 2 kombinációban teheti ezt meg). A képletünk tehát 1% + 0.01% (két vezeték) + 0.01% (két router) + 0.01% * 2 (egyik vezeték másik router), tehát összesen 1.04% eséllyel nem fogja ez a kapcsolás a csomagjainkat továbbítani. Jól látható, hogy a +1 router nagyobb mértékben csökkentette a hiba lehetőségét.

= 2 router - 2 router kapcsolat =

== 1-1 router csak 1 másik routerrel áll kapcsolatban egy vezetékkel összekapcsolva ==
[[Fájl:1-1 router 1-1 link.png|1000px|keretnélküli|középre]]
Ebben az esetben két ág keletkezik, bármelyiken lehetséges az információk továbbítása. A rendszer akkor válik elérhetetlenné, ha mind a két ág kiesik. Egy ág akkor esik ki, ha valamelyik router kiesik (vagy kapcsolat) vagy a vezeték közöttük meghibásodik. Ezt korábban kiszámoltuk, hogy 3% valószínűséggel okoz problémát. A két ágnak együtt kell meghibásodnia, hogy a rendszer működésképtelen legyen (és kapcsolat), tehát összességében 0.09% eséllyel nem fogunk tudni információt továbbítani egy ilyen hálózaton.

== 1-1 router csak 1 másik routerrel áll kapcsolatban két vezetékkel összekapcsolva ==
[[Fájl:1-1 router, 2-2 link.png|1000px|keretnélküli|középre]]
Ez az eset hasonló az előzőhöz, azonban két-két vezetékkel kötöttük össze a routereket. Ezt az előzőek alapján tudjuk, hogy az egyes ágak hibalehetősége 2.01%-ra változik. A teljes rendszer szintén akkor lesz működésképtelen, ha mind a két ágon hiba történik (és kapcsolat), tehát 0.0404% esély adódik arra, hogy egy ilyen hálózat nem fog működni.

== 1-1 router 2 másikkal áll kapcsolatban, egy vezetékkel összekapcsolva ==
[[Fájl:1-2 router, 1-1 link.png|1000px|keretnélküli|középre]]
Ez egy igen kis hibalehetőséggel működő kapcsolás. Az előzőekhez képest óriási előnye, hogy az egyes ágak nem külön-külön működnek, tehát egy vezeték tönkremenetele esetén továbbra is elérhető mind a négy router. A kapcsolás hibavalószínűségét úgy a legegyszerűbb kiszámolni, ha visszavezetjük az 1 router - 2 router kapcsolatra (fentebb) és annak a valószínűségét négyzetre emeljük. Így 0.011% az eredmény, tehát ekkora eséllyel nem fog működni a hálózatunk.

== 1-1 router 2 másikkal áll kapcsolatban, két vezetékkel összekapcsolva ==
[[Fájl:2-2 router, 2-2 link.png|1000px|keretnélküli|középre]]
Az előző kapcsolást fejleszthetjük tovább oly módon, hogy két kapcsolatot létesítünk minden router között. A csatolt ábra pontos (nem közelítő) számítása szerint egy-egy ág - tehát egy router, amely két vezetékkel kapcsolódik mindkét másik routerhez - hibavalószínűsége 1,0103%-ra adódik. Mivel a teljes kapcsolat csak akkor válik működésképtelenné, ha mindkét ág egyszerre hibásodik meg (ÉS kapcsolat), a végeredmény: 0,010103 × 0,010103 × 100 ≈ '''0,0102%'''.

Fájl:2-2 router, 2-2 link.png

2026-09-14T08:17:49Z

ApelPro: ApelPro Fájl:2-2 router, 2-2 link.png új verzióját töltötte fel

2-2 router, 2-2 link

Hálózat rendelkezésreállás számítás

2026-09-14T08:12:35Z

ApelPro: Utolsó számítás javítva a csatolt ábra alapján (1.0103%/ág, végeredmény kb. 0.0102%, nem 0.0001%) - az ábrán 100x-os számolási/kiírási hiba van, ami külön javítást igényel

BGP protokoll

2026-09-14T08:11:46Z

ApelPro: RIPE NCC / IANA viszony pontosítva (nem szervezeti alárendelt); elavult BGP tábla méret (880k route, 2021-es adat) frissítve/általánosítva

Nem túlzás azt állítani, hogy a BGP-nek (Border Gateway Protocol) köszönhetően tudunk ma internetezni, hiszen ez az egyetlen EGP (Exterior Gateway Protocol) protokoll.

== IGP / EGP ==
Megkülönböztetünk belső (Interior) és külső (Exterior) útvonal megosztó protokollokat. Előbbibe tartoznak a:
* RIP (Routing Information Protocol)
* OSPF (Open Shortest Path First)
* iBGP (Internal BGP)
* stb.

Egy protokoll akkor oszt meg belül információkat, ha egy AS-en (Autonomous System) belül működik és akkor külső, ha AS-ek között oszt meg információt.

=== Autonomous System ===
Az internet sok-sok kis hálózatból épül fel. A kisebb hálózatokat más-más cég tartja karban, tehát más és más szabályok vonatkoznak rájuk - sokszor jogi kérdésekben is különböznek a válaszok területtől függően. Egy ilyen ''„kis”'' hálózaton belül mindig a helyi főnök hozza a szabályokat: ő felel azért, hogy a csomagok sikeresen keresztül jussanak az ő hálózatán a cél felé, de hogy pontosan milyen útvonalat követnek, abba senki nem szólhat bele. Az egyszerűség kedvéért tekintsük úgy, hogy egy AS egy internetszolgáltatót jelent - később árnyaljuk ezt a képet. Az internetszolgáltatók vagy kiépítik saját hálózatukat - általában a helyi kis szolgáltatók wireless technológiát használnak (WISP - Wireless Internet Service Provider). A nagyobb szolgáltatók saját optikai vezetékeket húznak manapság (Telekom, Digi stb.), és vannak állami fennhatóság alá tartozó vonalak is, amelyek karbantartására pályáznak a szolgáltatók. A magyarázat kedvéért nézzük meg nagy vonalakban, hogy hogyan lehetséges egy internetszolgáltatót létrehozni:
# Cég regisztrálása a cégjegyzékben
# AS azonosító, úgynevezett ASN (Autonomous System Number) igénylése (vásárlása) a RIPE-től
# IP cím tartomány igénylése (vásárlása) a RIPE-től
# Helyi internetszolgáltatótól vonal bérlés (esetleg földrajzilag több ponton is, több szolgáltatótól is)
# ASN+IP tartomány hirdetése '''BGP protokollon keresztül''' a szolgáltatóval és a RIPE-vel egyeztetett cél számára

'''Fontos''': Publikus AS nem csak egy internetszolgáltató lehet. Egy egyszerű vállalkozás is vásárolhat IP tartományt, amihez szüksége lesz egy ASN-re is. Ez pl. multihomed kapcsolatok esetén történik meg - emiatt tudják kívülről a céget két internetszolgáltatón keresztül is elérni és így lehetséges, hogy mind a két szolgáltató ugyanazon az IP címen regisztrálja. Léteznek privát ASN-ek is, amelyeket nem kell beregisztrálnunk, ezeket általában a helyi hálózaton belül alkalmazzák (64512-65534). Ezek segítségével lehetőség nyílik arra is, hogy egy publikus AS több kisebb privát AS-ből épüljön fel. Az internetszolgáltatók a saját hálózatukon belül általában valamilyen IGP szolgáltatást használnak - pl. OSPF-et.

A BGP útvonalak mára jelentős méretet foglalnak el (nagyságrendileg százas MB-tól akár GB-os nagyságrendig, a tábla folyamatosan, évről évre nő). Ezt az Edge eszköz a memóriájában tartja, tehát egyrészt megfelelő eszközt kell választanunk erre a célra memóriaszempontból, de természetesen a rekordokat frissíteni is kell (a globális IPv4 BGP tábla mérete 2024-re már meghaladta az 1 millió útvonalat, és ehhez jön még az IPv6 tábla is), amihez CPU időt kell biztosítanunk. Egy kisebb eszköz ekkora teher alatt lefagy és működésképtelenné válik! ''(A pontos, aktuális méretet érdemes közvetlenül a lentebb linkelt bgp.potaroo.net oldalon ellenőrizni, mert ez folyamatosan változik.)''

==== Hasznos linkek ====
* [https://bgp.potaroo.net/ BGP tábla megtekintés és statisztikai adatok]
* [https://bgpview.io/ BGP információk ASN, IP cím alapján]

==== RIPE ====
A RIPE NCC névre hallgató szervezet egy önálló, tagjai (internetszolgáltatók, cégek) által fenntartott, nonprofit regionális szervezet - nem az IANA szervezeti alárendeltje, hanem attól függetlenül működik, azzal együttműködve. Az IANA (amit ma az ICANN felügyel) osztja ki a nagy IP-tartományokat a régiónkénti regisztrátoroknak, a RIPE NCC pedig ebből allokál tovább ASN-eket és IP-tartományokat az európai/közel-keleti régió szolgáltatóinak, cégeinek. A szakirodalom RIR (Regional Internet Registry) módon említi.
Az IANA tartja számon a világon eladott összes IP címtartományt és a hozzájuk tartozó ASN-eket.

== BGP működése ==
A BGP peer-to-peer alapú, tehát nem frissíti a tábla tartalmát időről-időre, hanem jelez minden olyan esetben, amikor a szabályok módosultak - pl. bedugunk egy kábelt vagy éppen kihúzzuk. A fő hátránya, hogy emiatt minden eszközt össze kell kapcsolni egymással, ami összesen x*(x-1) konfigurációs lépést igényel x router esetén. A sok konfiguráció elkerülése érdekében több kisebb méretű AS-t hoznak létre, így csökkenthető a kapcsolatok száma. Másik módszer lehet, hogy úgynevezett Route Reflector eszközöket definiálnak, amelyek begyűjtik és továbbítják az információt minden peer-nek, így elegendő ezzel összekapcsolni minden routert.

A peer-ek között L3 kapcsolat kialakítása szükséges (nem kell fizikai és L2).

=== BGP az internetszolgáltatóknál ===
Érezzük, hogy egy internetszolgáltató nem ússza meg a szabályok továbbítását: egyes ügyfelek rendelkeznek saját tartománnyal, ráadásul ezek esetleg más szolgáltatókhoz is be vannak kapcsolva; mások minél alacsonyabb szinten szeretnének VPN kapcsolatot kialakítani és ehhez az szolgáltató segítségét kérik - intranet. Azonban látjuk azt is, hogy a Route Reflector használata lassítja az információk terjedését - nem közvetlen kapcsolaton keresztül jut el az információ, hanem egy köztes eszköz segítségével és a szükséges routerek teljesítményéről nem is szóltunk (CPU a frissítések miatt, memória a útvonalak tárolása miatt). Ha végig gondoljuk, hogy egy szolgáltató hány eszközből épül fel és hogy a csomagunk célba juttatásához minden eszköznek tisztában kell lennie azzal, hogy merre kell irányítani a csomagot (tehát minden eszköznek tárolnia kell azt az 1GB-nyi útvonalat), akkor hirtelen elszörnyedünk és talán csodálkozunk is, hogy az ilyen eszközök költségei mellett hogyan éri meg olyan áron a szolgáltatás, amennyiért kapjuk?

A válasz az lehet, hogy nem minden eszköz tudja a route szabályokat. Ha végig gondoljuk, akkor nagyon kevés eszköznek kell azokat ismernie: a felhasználó alapértelmezett átjárójaként használt eszköznek és a szolgáltató peremterületén, tehát ahol más szolgáltatókhoz kapcsolódik (uplink). Az összes többi router switchként funkcionál és ezek között az eszközök között továbbítják az adatforgalmat. Ez az úgynevezett MPLS (Multi Protocol Label Switching) segítségével valósul meg, amely egy 2.5-ös rétegbeli (tehát a 2-es és a 3-as réteg közötti) technológia. Segítségével a csomagok kapnak útvonalirányításkor egy label-t, hogy melyik routerhez kell irányítani a csomagot. A köztes eszközök csak eddig bontják le a fejlécet és azt keresik meg, hogy nekik merre kell továbbítani az adott címkét. Ha a csomag célba ért, akkor újra IP alapon történik a továbbítás. Ez a technológia úgy alakítja át a routerekből felépülő hálózatot, mintha az egy nagy switch lenne és a sebességet is megnöveli. Egy így kialakított hálózatban definiálhatunk 2.5 rétegbeli VPN kapcsolatot (VPLS: Virtual Private Lan Service), aminek segítségével két klienst kapcsolhatunk össze úgy, hogy a csomagjaik a szolgáltató switchnek látszó hálózatán keresztül haladnak, ezzel növelve a sávszélességet.
Ha két ügyfél azonos szolgáltatónál van, akkor is L3 csomóponthoz kell jutnia ahhoz, hogy a másik ügyfelet elérje (pl. SSTP, L2TP stb.). A VPLS valójában ezt a felesleges lépést hagyja ki és az L3 csomóponttól független útvonalon juttatja el a csomagokat A-ból B-be.
A technológiának köszönhetően feloldható a BGP konfigurációs problémája: csökkenthető a routerként működő eszközök száma, amelyeknek a BGP routing táblát alkalmazniuk kell - ezáltal a peer-to-peer kapcsolatban részt kell venniük.

GAMF

2026-09-14T08:05:35Z

ApelPro: Törött AWS/Docker linkek javítva a helyes oldalcímekre + hibás listaformázás javítva

== GAMF órai tantárgyak, segédletek ==
==== Felhőszolgáltatások ====
* [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]

MikroTik::Scripting

2026-09-14T08:05:24Z

ApelPro: Script hiba javítva: sender=$email (nem létező változó) -> sender=$sendEmail

[[category:MikroTik]]
= Bevezetés =
A MikroTik eszközök rendelkeznek grafikus programozói felülettel (Winbox), de több olyan helyzet is előállhat, hogy a parancssorhoz kellene nyúlnunk:
* Alap konfigurációk előállítása
** L1-L2 konfiguráció
*** bridge
*** wireless mód (station, ap stb.)
*** VPN szerver / kliens aktiválás és alap konfiguráció
*** VLAN interfészek
** L3 konfiguráció
*** IP címek
*** statikus route szabályok
*** routing protokollok (ospf, bgp) alap beállítások
* Ütemezett feladatok végrehajtása
** Backup küldése emailben
** Watchdog / Netwatch
** Paraméterek monitorozása

A fentiek között találhatunk kényelmi megoldásokat és olyanokat is, amelyeket nem tudunk más módon megvalósítani ezen az eszközön. Ezért tehát érdemes bele nézni, hogy hogyan is készíthetünk scripteket az eszközre.

A script nyelv dokumentációját a MikroTik hivatalos oldalán [https://help.mikrotik.com/docs/display/ROS/Scripting itt] találod.

= A terminál használata =
[[Fájl:MikroTik terminál.png|keretnélküli|középre|alt=MikroTik terminál|MikroTik terminál]]

= Nyelvi alap elemek =
== Változók ==
* Lokális változók
* Globális változók
* Tömbök
== Elágazás ==
== Ciklusok ==
* for
* foreach
* do-while
==Terminál alapvető eszközei==
Az eszközök közül csak egy-két érdekesebbet tekintek át, ezeknél sokkal több áll rendelkezésünkre.
* :put
* :set
* :pick
* :delay
* :resolv

= Scriptelési lehetőségek =
Az eszközben több olyan menüpontot is találunk, amelyek egy több soros text mezőt rejtenek. Ezekben a pozíciókban írhatunk saját scriptet, ami egy adott eseményre triggerelődik. Ha a jelet egy olyan esemény indítja el, amelyhez adatcsomag is tartozott (például egy dhcp lease történt), akkor egyedi változók segítségével kikérhetjük annak tartalmát. A következő helyeken találkozhatunk ilyennel, alatta a használható változókkal:
* [https://help.mikrotik.com/docs/display/ROS/Scripting /system/script]
* [https://help.mikrotik.com/docs/display/ROS/Scheduler /system/scheduler]
* [https://wiki.mikrotik.com/wiki/Manual:IP/DHCP_Client#Properties /ip/dhcp-client]
** bound
** $"server-address"
** $"lease-address"
** $interface
** $"gateway-address"
** $"vendor-specific"
** $"lease-options"
* [https://wiki.mikrotik.com/wiki/Manual:IP/DHCP_Server#General /ip/dhcp-server]
** $leaseBound
** $leaseServerName
** $leaseActMAC
** $leaseActIP
** $lease-hostname
** $lease-options
* [https://help.mikrotik.com/docs/display/ROS/Netwatch#Netwatch-Properties /tool/netwatch]
*# up-script
*# down-script
*# test-script
* [https://help.mikrotik.com/docs/display/ROS/PPP+AAA /ppp/profile]
*# on-up
*#* $user
*#* $"local-address"
*#* $"remote-address"
*#* $"caller-id"
*#* $"called-id"
*#* $interface
*# on-down
*#* $user
*#* $"local-address"
*#* $"remote-address"
*#* $"caller-id"
*#* $"called-id"
*#* $interface
* [https://help.mikrotik.com/docs/display/ROS/MQTT#MQTT-Subscriptions /iot/mqtt/subscriptions]
** $msgData
** $msgTopic

= Komplex scriptek =
[[category:Backup]]
[[category:Biztonsági mentés]]
== Backup küldés emailben és SFTP szerverre ==
Az egyik legfontosabb, hogy mindig legyen mentésünk az eszközökről. A következő script segítségével biztonsági mentést hozhatunk létre, amit akár egyszerre több email címre és SFTP szerverre tölthetünk fel.

<syntaxhighlight lang="bash">
:local sendEmail {\
"address"="email@provider.hu"\
}

:local smtp {\
"server"="smtp.provider.hu";\
"port"=465;\
"tls"="yes";\
"user"="user@provider.hu";\
"password"="password"\
}

:local toEmails {\
"email1@provider.hu";\
"email2@provider.com"\
}

:local backup {\
"prefix"="";\
"key"="VERYSTRONGKEY";\
"fileName"=([/system identity get name ] . "_" . \
[:pick [/system clock get date] 0 4] ."_". \
[:pick [/system clock get date] 5 7] ."_". \
[:pick [/system clock get date] 8 10] ."-". \
[:pick [/system clock get time] 0 2] ."_". \
[:pick [/system clock get time] 3 5] ."_". \
[:pick [/system clock get time] 6 8] \
.".backup"\
)\
}

:local sftpServers {\
{\
"address"="srv1.hu";\
"port"="22";\
"dst-path"="/destination/path/";\
"user"="username";\
"password"="password"\
};\
{\
"address"="srv2.hu";\
"port"="22";\
"dst-path"="/destination/path/";\
"user"="user";\
"password"="password"\
}\
}

# sendMail function
:local sendMail do={
:local toEmails ""
:foreach i in $emails do={
:if ( $toEmails != "" ) do={
:set toEmails ($toEmails . ",")
}
:set toEmails ($toEmails . $i)
}

/tool/e-mail/send server=($smtp->"server") port=($smtp->"port") tls=($smtp->"tls") \
user=($smtp->"user") password=($smtp->"password") \
subject="$subject" to="$toEmails" from=($sender->"address") \
body="$text" file="$file"
}
# end of sendMail function

# uploadSftp function
:local uploadSftp do={
:foreach i in $servers do={
:put (\
"Upload ". $file . " to " . $i->"address" .":". $i->"port" \
. ", into " . $i->"dst-path" . " folder with user: ". $i->"user" \
)
/tool/fetch mode=sftp upload=yes \
address=($i->"address") port=($i->"port") \
user=($i->"user") password=($i->"password") \
src-path="$file" dst-path=($i->"dst-path".$file)
}
}
#end of uploadSftp function

/file remove [find where type="backup"]
/file remove [find where type="script"]

/system backup save name=(($backup->"prefix") . ($backup->"fileName")) password=($backup->"key")
/export show-sensitive file=(($backup->"prefix").($backup->"fileName"))

:delay 10000ms

$sendMail emails=$toEmails sender=$sendEmail smtp=$smtp file=($backup->"prefix" . $backup->"fileName") \
subject=([/system identity get name] ." ". [/system clock get date] . " " . [/system clock get time] . " backup file") \
text="Please note that the file is transmitted encrypted. If you have forgotten the key, please contact the appropriate person."

$uploadSftp servers=$sftpServers file=($backup->"prefix" . $backup->"fileName")
$uploadSftp servers=$sftpServers file=($backup->"prefix" . $backup->"fileName".".rsc")

/file remove [find where type="script"]
</syntaxhighlight>

A script elején található konfigurációs rész igény szerint bővíthető, vagy redukálható. Jelenlegi állapotában két email címre és két sftp szerverre került mentésre a biztonsági mentésünk. A plain text alapú RSC fájlt csak az SFTP szerverre töltjük fel. Meg kell jegyezni, hogy ha az Identity paraméter szóközöket tartalmaz, akkor az RSC fájl feltöltésével problémák adódhatnak - ez esetben érdemes a $backup->fileName paramétert úgy előállítani, hogy ne legyen benne szóköz.

EDU::GAMF::MikroTik

2026-09-14T08:05:15Z

ApelPro: Pontosítva, hogy pfSense BSD pf-et használ (nem iptables-t), és a MikroTik RouterOS saját tűzfalmotorral rendelkezik

Ha új dolgokkal találkozunk, akkor a fizikai megjelenés az első, amit a leghamarabb felismerünk, ám a hálózatok világában ez az egyik legkevésbé lényeges tulajdonság. Sokkal fontosabb, hogy a benne rejlő titkokat felfedjük, a működési elvét megértsük, hiszen ezek tudatában bírjuk a rendeltetési helyének megfelelően alkalmazni.

A MikroTik lelke egy szoftver, amit RouterOS-nek neveznek. A ma elérhető legtöbb modellre igaz, hogy a forgalmat ezen szoftver segítségével igyekszik megvalósítani - tehát hardveres támogatás nélkül, úgymond mindent „izomból” hajt végre. Sok helyen pont erre van szükségünk: célhardverek helyett a teljes packetflow nyitott és ott nyúlunk bele, ahol mi szeretnénk, nem ahol a célhardver azt lehetővé teszi. Természetesen ami előny, az hátrány is: a nagy sebességek eléréséhez olyan erős hardver kéne alá, amit költségei miatt nem érne meg megvásárolni. Manapság a 25G/40G/100G világában ez a gyártó is alkalmaz L3 szintű hardveres támogatással, ám ez még nagyon kezdetleges fázisban van.

'''Hasonló megoldások:'''
* pfSense
* VyOS
* OpenWRT
* Debian/Ubuntu/Fedora stb.

A fent felsoroltak mind-mind Linux (vagy BSD) alapú rendszerek, amelyek képesek router funkciókat ellátni. A tűzfal-motorjuk azonban nem egységes: a Linux alapú megoldások (VyOS, OpenWRT, Debian/Ubuntu/Fedora) a Linux kernel netfilter alrendszerére, tehát az ''iptables''/''nftables'' családra épülnek, a FreeBSD alapú pfSense viszont a BSD-k saját, ezektől független csomagszűrőjét, a ''pf''-et (Packet Filter) használja - a kettő nem kompatibilis egymással. A MikroTik RouterOS is Linux kernelt használ, de a tűzfala nem a szabványos iptables/nftables, hanem egy saját fejlesztésű, azokéhoz hasonló (lánc alapú) motor.

'''Linkek:'''
* [[EDU::GAMF::IPTABLES|iptables alapok]]
* Képzés:
** [[EDU::GAMF::MikroTik::MTCNA|Alapok]]

EDU::GAMF::IPTABLES

2026-09-14T08:05:05Z

ApelPro: Hibás 'main iptables-extensions' parancs javítva 'man'-ra; ufw zóna-állítás pontosítva

Az iptables általában alapból telepítve van Linux alapú operációs rendszereken. A legtöbb ember ennek ellenére igen ritkán találkozik vele, de sokszor a szakemberek is a ráépülő eszközöket használják, mint például az ''ufw'' és a ''firewalld''. Utóbbiak rendelkeznek egy nagy előnnyel: az iptables utódjaként szolgáló ''nft''-t is képesek kezelni, így nem kell más programot megtanulni a fejlődéshez.

Az iptables egy szabálylánc alapú tűzfalrendszer, amelyeket különböző táblákba rendeznek (az nft szintén láncokkal dolgozik; a firewalld ezekkel ellentétben zónákba rendezi a szabályokat, az ufw pedig még ennél is egyszerűbb, lineáris szabálylistával dolgozik, zóna fogalom nélkül. Ne feledjük el azonban, hogy minden ufw és firewalld programokkal felvett szabály végül az iptables/nft láncokba kerülnek be, amiből levonható az a következtetés, hogy az alapvetően szabályláncokkal operáló alkalmazásban is tudunk zóna szerű, átlátható struktúrát kialakítani). Vannak alapértelmezetten létező láncok, amelyeket le sem tudunk törölni: ezeket a netfilter kernelmodul hívja meg, amikor a csomag életútjának megadott fázisában jár. A láncok meghívási sorrendjét ''packetflow''-nak nevezzük. Érdemes a tűzfal tervezésekor figyelembe venni, hogy minél hamarabb szabadulunk meg egy nem kívánt csomagtól, annál kevesebb CPU időt igényel. Az eldobás akcióval ellentétben az elfogadás sokkal körülményesebb: ezek a csomagok a létező összes alapértelmezett láncon át kell menjenek és elfogadásra kell kerüljenek (nagyon könnyen belátható, hogy ha egy láncban az adott csomagot tovább engedjük, akkor a csomag életútjának következő fázisában a netfilter meg fogja hívni a következő láncot, ahol egy ''eldobás'' művelet a feldolgozás megszakítását jelenti, tehát a csomag nem fog célba érkezni).

'''Témakörök:'''
* Alapértelmezett -
** táblák,
** láncok
* Packetflow
* Szabályok létrehozása
* Láncok létrehozása
* Váltás a láncok között
* "Zóna szerű", átlátható struktúra kialakítása

'''Fontosabb teendők'''
* Érdemes áttekinteni a kézikönyvet! Ezáltal lesz fogalmunk arról, hogy milyen funkciók vannak és később könnyebben keresünk benne.
man iptables # az iptables parancs kapcsolóit dokumentálja
man iptables-extensions # az iptables parancs -m kapcsolója után megadható kiterjesztéseket és kapcsolóit írja le
* Érdemes megjegyezni, hogy hogyan tudjuk a szabályainkat kilistázni, menteni és visszaállítani.
iptables [-t table] --list # ez a hosszú formátum, de alapértelmezetten a ''filter'' tábla tartalmát listázza és használhatjuk a rövidebb, -L kapcsolót is a --list helyett.

iptables -L # ez tehát a számunkra legfontosabb ''filter'' tábla tartalmát listázza ki

iptables-save # ez a parancs minden szabályt kiír a képernyőre - ha menteni akarjuk, irányítsuk át egy fájlba!

iptables-restore # ez a parancs visszaállítja a szabályrendszert a STANDARD INPUT-ról. Ha nem billentyűzettel szeretnénk beírni a szabályokat, akkor irányítsuk át egy korábbi mentésünket a bemenetre (< saved_rules)

'''Teszt környezet'''
Mielőtt belekezdünk a próbálkozásba, érdemes megtekinteni a szabályokat, mik vannak befecskendezve. Könnyen lehet, hogy az internet elérésünk is megszűnik egy hibása létrehozott szabály miatt, így mindig érdemes magunknál tartani egy olyan mentést, amit visszaállítva minden megfelelően működik. Ezt megtehetjük az említett ''iptables-save'' és ''iptables-restore'' kiegészítők segítségével.

Sokkal szerencsésebb azonban, ha nem a saját gépünkön próbálkozunk, hanem egy virtuális gépben például. Így semmilyen változtatást nem hajtunk végre a mindennapokban használt rendszeren: ha a próbálkozások közepette elfáradunk, nem kell azzal időt tölteni, hogy mindent visszaállítsunk alapra, hanem csak bezárjuk a virtuális környezetet és nincs több teendő.

Manapság a docker környezetet sokan használják „sandbox” üzemmódban is. Természetesen az iptables program is feltelepíthető, csupán egy kisebb trükköt kell végrehajtanunk. Ennek előnye a virtuális környezethez képest, hogy gyengébb, KVM-mel nem rendelkező gépeken is kellő gyorsasággal fut. Ennek beüzemeléséhez a következő parancsokat kell lefuttatnunk a '''host''' számítógépen:
docker run -ti --cap-add=NET_ADMIN --cap-add=NET_RAW ubuntu bash
A képfájl (ubuntu) bátran cserélhető másra is, de ez a legelterjedtebb disztribúció, ezért ezt választottam.
A következőket kell végrehajtanunk a konténeren belül:
apt update
apt install iptables
apt install iproute2
Az utóbbi (''iproute2'') csomagnak köszönhetően futtathatjuk a megszokott ''ip addr'' illetve ''ip link'' parancsokat.
A telepítés után kiadhatjuk a ''iptables -L'' parancsot, aminek az eredménye egy üres tűzfal lesz, benne az alapértelmezett ''INPUT'', ''FORWARD'' és ''OUTPUT'' láncokkal.

ISP csatlakozási típusok

2026-09-14T08:04:55Z

ApelPro: EGP hibás kifejtése javítva (External -> Exterior Gateway Protocol)

Egy átlag ember általában nem gondolkozik sokat azon, hogy milyen lehetőségei vannak az internetelérésre, esetleg szerverek üzemeltetésére: a jól bevált módszer, hogy kérünk egy publikus IP címet az egyik környékünkön elérhető szolgáltatótól, a szolgáltatással együtt kapott kábel végét bedugják a routerünkbe és meg is van oldva a problémánk. Ennél azonban jóval több lehetőségünk akad.

Az internet kis hálózatokból - úgymond felhőkből - felépülő halmaz. Az egyes felhőket más-más szervezetek tartják karban és teljes autonómiájuk van azzal kapcsolatban, hogy mit csinálnak, milyen routing protokollokat (BGP, OSPF, RIP stb.) alkalmaznak. Ezeket angolul ''Autonomous System''-nek nevezik (röviden AS) és minden ilyen kis hálózat rendelkezik egy úgynevezett ''AS Number''-rel (röviden ASN), ami azonosítja. Az ASN-t és a hozzátartozó, belül elérhető IP címeket BGP (Border Gateway Protocol) protokollon keresztül kell hirdetni, ami jelenleg az egyetlen elérhető EGP (Exterior Gateway Protocol) protokoll (figyelem, korábban mint IGP protokoll szerepelt a listában, amelyből több is létezik). A BGP protokoll működéséhez Peer-eket kell felvennünk, kapcsolatot kell felépítenünk egy olyan eszközzel, aki már részese az ''internet'' hálózatának és továbbítani tudja a szabályainkat (mindkét oldalon konfigurálni kell, ez biztosítja, hogy nem léphet be bárki ebbe a „zárt” hálózatba).

Egy ilyen AS lehet az otthoni hálózatunk is: teljes mértékben mi döntünk a belső felépítéséről, a szolgáltató nem szólhat bele. Az egyetlen eltérés, hogy nekünk nem kell az ASN-t hirdetni a szolgáltató felé - de Ő hirdetni fogja a mi publikus IP címünket a világon működő egyéb AS-ek felé. Mi általában a részévé válunk az Ő hálózatának, csúnyán szólva az Ő AS-ének. Ezeket az otthoni hálózatokat a szakirodalom ''stub network''-nek nevezi - mintegy sziget az óceánon, amelyre egyetlen híd vezet a szárazföldről. Léteznek ''non-stub network'' megoldások is, amihez a szolgáltató (vagy szolgáltatókkal) való szoros együttműködés keretein belül lehet létrehozni és természetesen magasabb költségekkel kell számolnunk.

= Stub / non-stub network =
Ahogy korábban említettem, ez egy olyan hálózat, amelybe egyetlen úton lehet bejutni illetve onnan egyetlen útvonalon lehet kijutni. A megfogalmazásnak annyi problémája van - látjuk a későbbiekben -, hogy a hálózatunk több szolgáltatóhoz is be lehet kötve - ekkor a hálózatból több kijárat is adódik -, de mégis konfigurálható elszigetelt hálózatként. A kulcs az, hogy a ''stub network'' esetében a szolgáltató(k) felé többnyire a teljes tartományunk hirdetjük. Ehhez a típushoz szorosan kötődik a belsőhálózaton az alapértelmezett átjáró (0.0.0.0/0) fogalma. A ''non-stub'' esetében a hálózatunkon belül elérhető nagyobb csomópontok is hirdetésre kerülnek - emiatt elképzelhető, hogy az egyik eszközt ''A'', míg a másik eszközt ''B'' szolgáltatón keresztül érjük el. Az útvonalak dinamikusan, a szolgáltató route táblájában található költségek alapján változhatnak. Az egy szolgáltatóval kötött szerződés keretein belül ''non-stub'' hálózatot létesíteni nem értelmezhető, hiszen semmilyen optimalizálást nem érünk el vele: mindenképp ugyanazon a kapcsolaton keresztül fogunk kommunikálni.

{| class="wikitable" style="margin:auto"
! Stub network || Non-stub network
|-
| [[Fájl:Single Multihomed Stub Network.png|keretnélküli|500px|nyújtás|alt=Stub Network|Stub network]] ||
[[Fájl:Single Multihomed Non Stub Network.png|keretnélküli|500px|középre|Non-Stub network]]
|}

= Redundancia =
A fent említett két típus az útvonal optimalizálásra van hatással, de van lehetőségünk a redundanciát szem előtt tartva különböző kapcsolattípusok kialakítására. Fontos megemlíteni, hogy a hálózatunk vagy ''stub network'' vagy ''non-stub network'' kategóriába esik mindettől függetlenül!

== Single Homed (Stub Network) ==
A tipikus szolgáltató-ügyfél kapcsolat mind ebbe a kategóriába esik: egy router és egy vezeték a szolgáltató felé. Ennek a kapcsolattípusnak a legrosszabb a rendelkezésreállása, mivel nem rendelkezik semmilyen redundanciával.
[[Fájl:Single Homed.png|keretnélküli|középre]]

== Dual Homed ==
Ez a kapcsolattípus több módon is létrejöhet. Az egyik megjelenési forma, amikor a vásárlói oldalon egy routerbe két vezetéken keresztül kapcsolódik a szolgáltató, de megvalósítható a vásárlói oldalon két routerrel, amelybe ugyanaz a szolgáltató kapcsolódik.
[[Fájl:Dual Homed version 1.png|keretezett|középre|Egy router, két vezeték a szolgáltatóhoz]]
[[Fájl:Dual Homed version 2.png|keretezett|középre|Két router ugyanahhoz a szolgáltatóhoz kötve]]

== Multihomed kapcsolatok ==
Ezek esetében több (legalább kettő) szolgáltatónál vásárolunk hálózati hozzáférést.

=== Single Multihomed ===
Egy routeren építünk fel a szolgáltatóval 1-1 kapcsolatot, vagy két routeren 1-1 kapcsolatot alakítunk ki a két szolgáltató felé. Itt valójában a Single kifejezés arra utal, hogy egy-egy szolgáltató felé egy vezetéken tudunk kommunikálni.
[[Fájl:Signle Multihomed version 1.png|keretezett|középre]]
[[Fájl:Single Multihomed version 2.png|keretezett|középre|2 router, 2 szolgáltató, 1-1 kapcsolat]]

=== Dual Multihomed ===
Ebben az esetben a szolgáltatókhoz több vezetéken keresztül építünk fel kapcsolatot. Több formában is létrehozható: a vásárlói oldalon egy vagy két routerrel. Ezek a megoldások igen költségesek tudnak lenni, de a hiba lehetőségét közel nullára csökkentik.

[[Fájl:Dual Multihomed version 1.png|keretezett|középre|1 router, két szolgáltató, 2-2 kapcsolat]]
[[Fájl:Dual Multihomed version 2.png|keretezett|középre|2 router, 2 szolgáltató, 2 kapcsolat]]

A legjobb rendelezésreállást biztosító elrendezés, ám a legköltségesebb is egyben.
[[Fájl:Dual Multihomed version 3.png|keretezett|középre|2 router, 2 szolgáltató, 2 kapcsolat (X)]]

Hálózat rendelkezésreállás számítás

2026-09-14T08:04:46Z

ApelPro: Számolási elgépelés javítása (0.1% -> 0.01%, konzisztens a végösszeggel)

Amennyiben magas rendelkezésreállású hálózatot tervezünk, akkor redundanciát kell kialakítanunk. Ezen az [[ISP csatlakozási típusok|oldalon]] összegyűjtöttem milyen módon csatlakozhatunk a szolgáltatókkal, ám ott nem esett szó számszerű értékekről a hiba lehetőségét tekintve. A következőkben felsorolok pár kapcsolást a hozzá tartozó hiba valószínűséggel.

'''A hibák valószínűségét mindenhol 1%-nak vettem, de ez messze nem igaz a hálózat minden elemére!'''

= 1 router - N router kapcsolat =
Ebben a fejezetben a kapcsolat egyik oldalán fixen egy router lesz, a másik oldalon pedig maximum kettő. A közöttük lévő vezetékek száma szintén maximum kettő.

== 1-1 router kapcsolat ==
[[Fájl:Fail 1-1 router.png|1000px|keretnélküli|középre]]

Ebben az esetben hibát okozhat, ha a bal oldali router megy tönkre (1%), a vezeték megy tönkre (1%) vagy jobb oldali router megy tönkre (1%). A vagy kapcsolat miatt az értékek összeadódnak, így összesen 3% valószínűséggel nem fogja tudni a csomagot továbbítani ez a kapcsolattípus.

[[Fájl:Fail Dual Homed.png|1000px|keretnélküli|középre]]
Ebben az esetben a routerek között két vezeték található, amelyek 1-1% valószínűséggel mehetnek tönkre. A kapcsolat csak akkor szakad meg, ha a bal oldali router (1%) vagy mind a két vezeték, vagy a jobb oldali router (1%) megy tönkre. Az előbbiek alapján láthattuk, hogy a vagy kapcsolat miatt az értékek összeadódnak, ám a vezeték esetében ÉS kapcsolat van, tehát azok hiba valószínűségét szorozni kell: 0.01*0.01 = 0.0001, azaz 0.01% valószínűséggel fog mindkét kábel tönkremenni. Ebből adódóan a teljes kapcsolás 2.01% valószínűséggel nem fogja továbbítani a csomagokat.

== 1-2 router kapcsolat ==
[[Fájl:Fail 1-2 router.png|1000px|keretnélküli|középre]]
Ebben az esetben egyértelműen bajba kerülünk, ha a bal oldalon lévő egyetlen router tönkremegy (1%). Azonban mindkét vezetéknek vagy mindkét routernek tönkre kell mennie (ezt előző számításból tudjuk, hogy 0.01% eséllyel megy tönkre mind a kettő), vagy az egyik vezetéknek és a másik jobb oldali routernek (0.01% eséllyel megy ilyen formában tönkre, de 2 kombinációban teheti ezt meg). A képletünk tehát 1% + 0.01% (két vezeték) + 0.01% (két router) + 0.01% * 2 (egyik vezeték másik router), tehát összesen 1.04% eséllyel nem fogja ez a kapcsolás a csomagjainkat továbbítani. Jól látható, hogy a +1 router nagyobb mértékben csökkentette a hiba lehetőségét.

= 2 router - 2 router kapcsolat =

== 1-1 router csak 1 másik routerrel áll kapcsolatban egy vezetékkel összekapcsolva ==
[[Fájl:1-1 router 1-1 link.png|1000px|keretnélküli|középre]]
Ebben az esetben két ág keletkezik, bármelyiken lehetséges az információk továbbítása. A rendszer akkor válik elérhetetlenné, ha mind a két ág kiesik. Egy ág akkor esik ki, ha valamelyik router kiesik (vagy kapcsolat) vagy a vezeték közöttük meghibásodik. Ezt korábban kiszámoltuk, hogy 3% valószínűséggel okoz problémát. A két ágnak együtt kell meghibásodnia, hogy a rendszer működésképtelen legyen (és kapcsolat), tehát összességében 0.09% eséllyel nem fogunk tudni információt továbbítani egy ilyen hálózaton.

== 1-1 router csak 1 másik routerrel áll kapcsolatban két vezetékkel összekapcsolva ==
[[Fájl:1-1 router, 2-2 link.png|1000px|keretnélküli|középre]]
Ez az eset hasonló az előzőhöz, azonban két-két vezetékkel kötöttük össze a routereket. Ezt az előzőek alapján tudjuk, hogy az egyes ágak hibalehetősége 2.01%-ra változik. A teljes rendszer szintén akkor lesz működésképtelen, ha mind a két ágon hiba történik (és kapcsolat), tehát 0.0404% esély adódik arra, hogy egy ilyen hálózat nem fog működni.

== 1-1 router 2 másikkal áll kapcsolatban, egy vezetékkel összekapcsolva ==
[[Fájl:1-2 router, 1-1 link.png|1000px|keretnélküli|középre]]
Ez egy igen kis hibalehetőséggel működő kapcsolás. Az előzőekhez képest óriási előnye, hogy az egyes ágak nem külön-külön működnek, tehát egy vezeték tönkremenetele esetén továbbra is elérhető mind a négy router. A kapcsolás hibavalószínűségét úgy a legegyszerűbb kiszámolni, ha visszavezetjük az 1 router - 2 router kapcsolatra (fentebb) és annak a valószínűségét négyzetre emeljük. Így 0.011% az eredmény, tehát ekkora eséllyel nem fog működni a hálózatunk.

== 1-1 router 2 másikkal áll kapcsolatban, két vezetékkel összekapcsolva ==
[[Fájl:2-2 router, 2-2 link.png|1000px|keretnélküli|középre]]
Az előző kapcsolást fejleszthetjük tovább oly módon, hogy két kapcsolatot létesítünk minden router között. Azt már tudjuk, hogy ez esetben a kapcsolat működésképtelensége 0.01%-ra csökken az eredeti 1%-kal számolva vezetékenként. A számítási mód ugyanaz, mint az előző esetben, csak a vezeték meghibásodásának valószínűségét kell az új értékre cserélnünk. Így tehát 0.0001% valószínűségűre tudjuk szorítani a hibát.

EDU::GAMF::Felhőalapú-szolgáltatások

2026-09-14T07:56:10Z

ApelPro: Elgépelés javítása a PHP5 kódpéldában (mamximum -> maximum)

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a projektfeladatból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email] és alap szolgáltatások átbeszélése
# EC2 telepítés, nginx + apache2 bevezetés, alap parancsok ismétlése (ls, nano, mcedit stb.)
# Alkalmazás telepítése előre elkészített script segítségével + AMI, ASG, LB
# RDS telepítés és alkalmazás integráció ellenőrzése
# Docker alapok
# Docker compose alapok
# Alkalmazás indítása Docker környezetben
# IaC eszközök áttekintése
# IaC eszközök áttekintése
# MessageQueue eszközök használata
# Projekt bemutató (6db)
# Projekt bemutató (6db)
# Projekt bemutató (6db)

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj maximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

GAMF::Felhőalapú-szolgáltatások::Előadás

2026-09-14T07:55:48Z

ApelPro: Felhőbiztonság fejezet megírása (IAM, hálózati biztonság, titkosítás, monitorozás, DDoS/WAF, tipikus hibák, megfelelőség)

= Bérelt szervertől (VPS) a felhő megoldásokig =
A legalapvetőbb feladat, amit egy szerverre szeretnénk bízni, hogy szolgálja ki a weboldalunkat. Szerencsére ehhez ingyenesen elérhető tárhelyek is rendelkezésünkre állnak, mint például a [https://nethely.hu nethely]. Az ingyenes változatok gyakran reklámokkal tűzdelik tele weboldalunkat és/vagy olyan tárhely korlátokkal vehetjük igénybe, amelyekkel egy komolyabb alkalmazás esetén nem ússzuk meg a fizetős változatok megrendelését. Azonban jó ha tudjuk, hogy ezek a szolgáltatások főleg PHP alkalmazások futtatására alkalmasak, a ma népszerű NodeJS kódokat nem tudják futtatni.

== VPS ==
Ha nem csupán egy tárhelyet szeretnénk bérelni - ennek oka lehet, hogy nem tudja a tárhely szolgáltató futtatni alkalmazásunkat (pl. NodeJS), vagy annyira komplikált/bonyolult az üzemeltetése, hogy nem fér bele a sablonos keretekbe -, akkor bérelhetünk virtuális szervereket is: VPS-t (Virtual Private Server). Ekkor egy virtuális „vasat” kapunk, amire korlátozott, de széles választékból telepíthetünk operációs rendszert és kedvünk szerint konfigurálhatjuk azt. Ez a legelterjedtebb megoldás, azonban ezen szolgáltatásoknak is meg vannak a szintjei:
# VPS bérlés - a fent említett módon, virtuális környezetben létezik szerverünk
# Dedikált szerver - Egy komplett szerverhez kapunk hozzáférést. Többnyire igen drága szolgáltatás.

A szolgáltató ezeket a rendszereket általában monitorozzák, illetve webes felületet biztosítanak, hogy újra tudjuk indítani/telepíteni, távoli asztallal rá tudjunk csatlakozni stb. A rendszert azonban nekünk kell karbantartanunk, így a vírusok, támadások ellen többségében nekünk kell kivédenünk (természetesen egy valamirevaló szolgáltató rendelkezik IDS/IPS rendszerekkel, de ügyeljünk rá, hogy ezek nem adnak százszázalékos védelmet). Ilyenkor mi telepítjük fel és frissítjük a webkiszolgálót, az adatbáziskezelőt, amennyiben szükségünk van rá és az alkalmazáshoz szükséges minden csomagot nekünk kell naprakészen tartanunk.

== Saját globális hálózat ==
Míg egy kis cégnek elegendő egyetlen VPS, amelyen fut a webkiszolgáló és az SQL szerver is, egy nagyobb cégnek, gyakrabban látogatott alkalmazásoknak célszerű szét darabolni az elemeit - külön SQL szerver, külön fájl szerver és külön kiszolgáló. Ennek a háromnak folyamatosan kommunikálni kell egymással (lényeges a közöttük kialakított hálózat minősége), de egy támadás a webkiszolgáló felé valószínűleg nem fogja elérhetetlenné tenni a fájlszerverünket és az adatbázisunkat, ezzel együtt pedig az adatokat is megvédtük a behatolók elől. Ezzel le is írtunk egy mini felhőt.
Sok alkalmazás esetében azonban ez sem volt elegendő: hol adatvédelmi okból, hol a rendelkezésreállás javítása miatt clustereket hoztak létre, esetleg datacentereket létesítettek a világ több pontján. Ezek gyakorlatilag egyeznek a ma privát felhőként emlegetett megoldással, komplexitásuk megközelíti a ma igénybevehető szolgáltatások mögött található rendszerek bonyolultságát.

== Felhőszolgáltatás ==
A fentebb említett cluster illetve datacenter kialakítások igen költségesek. Mivel a szolgáltatók ezeket már kiépítették világszerte, így célszerű ebbe bekapcsolódni ahelyett, hogy a sajátunkat kezdenénk el megtervezni. Egy szolgáltatás igénybevételével hozzáférhetünk a teljes hálózathoz, így például nagyon egyszerűen biztosíthatjuk, hogy Amerikában ugyanolyan gyorsan töltsön be weboldalunk, mint Magyarországon - természetesen nem ugyanarról a szerverről. Emlékezzünk vissza, hogy ezekkel a tulajdonságokkal régebben nagyon kevés cég (Google, Microsoft) rendelkezett és csakis azért kezdtek el adatközpontokat létesíteni a világ más pontjain, hogy ne kelljen az óceán fenekén húzódó optikai kábeleken keresztül, nagy távolságon és sok hálózati ugráson át elérnünk a szolgáltatást (ami jelentős késleltetést (latency) okozna), amikor például Európából akarjuk böngészni a weboldalukat. Ha ma megnézzük az elérhető felhőszolgáltatókat, akkor pontosan ezeket a „mamut cégeket” fogjuk megtalálni a piacon.

Ritka ugyan, de manapság is előfordul, hogy saját felhőt alakítanak ki maguknak cégek: például az Instagram eleinte az Amazon Web Services hálózatát használta fel, hogy a világ minden táján elérhető legyen, majd a Facebook általi felvásárlása (2012) után fokozatosan átköltöztették a Facebook saját infrastruktúrájára.

'''A felhőszolgáltatások előnyei egyben hátrányként is szolgálnak:'''
* A felhőben általában csak az elhasznált erőforrásokért fizetünk (gyakran idő alapon) - ez gyakorlatilag nagyon nehézzé teszi a költségtervezést
* A felhő biztosítja számunkra, hogy az adataink mindig elérhetők legyenek - a nagy szolgáltatók (pl. AWS) ma már régió szintjén garantálják, hogy az általunk kiválasztott adatközpont-régión belül maradnak az adatok (pl. van kifejezetten EU-s régió is), de érdemes tudni, hogy egyes globális/menedzselt szolgáltatásaik alapértelmezetten több régió között replikálhatnak, ha ezt nem konfiguráljuk explicit módon régióhoz kötötten. Emiatt egy bizalmas adatokat kezelő cégnek (pl. bank) az EU-s adatvédelmi (GDPR) elvárások miatt mindig tudatosan, szerződéses garanciákkal (Data Processing Agreement, adott régióra korlátozás) kell konfigurálnia a felhős környezetét, nem elég csak "belefutni" az alapértelmezett beállításokba.

Érdemes azt is megjegyezni, hogy az alacsony költségek igen relatívak. Sok cég még ma sem engedheti meg magának, a felhőbe költöztesse az alkalmazásait. Ennek egyik oka az említett adatbiztonsági szabályozás az EU tagjaként, de benne lehet a bizalmatlanság és a vélt forgalomhoz becsült árak és a szintén említett kiszámíthatatlanság. Sok cégnek még ma is jobban megéri egy VPS szolgáltatást igénybe venni, főleg ha nem akar a határokon kívülieket megszólítani. Az alacsony költségek főleg ott értelmezhetők, ahol speciális eszközök (TensorCore, GPU) kellenek rövid időre, illetve a cég felhőszolgáltató hiányában saját globális hálózatot építene ki magának a Google-höz és a Microsoft-hoz hasonlóan.

== Ajánlott VPS szolgáltatók ==
A szolgáltatás árak egy cég számára talán nem magasak, ám egy tanuló informatikus számára, aki csupán azért szeretne bérelni egy szervert, hogy kipróbálja az iskolában tanultakat (esetleg máshol olvasottakat), neki minden fillér számítani fog. Amennyiben az egy éves próbaidőszakon túl is szeretnél szerverekkel, azok konfigurációjával foglalkozni, akkor a következő szolgáltatókat ajánlom figyelmedbe:
* [https://contabo.com/en/ Contabo] - egy német cég, igen alacsony bérleti árakkal (évi 20.000HUF kb., természetesen Euróban). Hátránya, hogy Németországban lesz a szervered, ami földrajzilag távol esik, főleg ha VPN szerű alkalmazásokkal is próbálkozni szeretnél. Hozzá kell tenni, hogy a BIX (''Budapest Internet Exchange''), ami Magyarország fő kilépési pontja a világháló felé, Frankfurtból kapja szolgáltatását. Innen nézve Németország nincs is olyan messze...

== Alkalmazások, amelyek segítségével felügyelhetjük a szerverünket ==
''Az alkalmazások a felhőben létrehozott IaaS szolgáltatásokra is telepíthetők''
* [https://zabbix.com Zabbix] - Telemetria rendszer, amely alkalmas konténerek és alkalmazások monitorozására a szerver alapvető (CPU, RAM, HDD) tulajdonságain túl.
* [https://www.nagios.org Nagios] - a Zabbixhoz hasonló Telemetria rendszer
* [https://openvas.org OpenVAS] - A szerveren futó alkalmazások verziószámát összeveti a CVE adatbázissal (pl. [https://cve.mitre.org cve.mitre.org] és naplózza a talált hibákat. Segítségével értesülhetünk a hibákat tartalmazó szoftvereinkről és még idejében frissíthetjük, lecserélhetjük azokat, mielőtt egy hacker találna rá. Nagyon fontos, hogy az információkat bejelentkezés nélkül szedi össze, tehát csupán a publikum számára is elérhető információk alapján keres. További információkért keresd fel az [https://nmap.org/book/man-nse.html nmap scripts] oldalt.

= Felhő ökoszisztéma =
'''''Oldalszám: 13-40.'''''

A skálázásnak mélyreható következményei vannak a menedzsmentet tekintve: egyik oldalon a rendszernek rugalmasnak kell lennie, tudnia kell kezelni a hirtelen megnövekvő terhelést is; míg a másik oldalon optimalizálnia kell az energiafelhasználást. Természetesen ezeket a nehézségeket el kell rejteni a felhasználó elől egy jól átlátható, könnyen használható felület mögé.

== Szolgáltatási szintek ==

==== IaaS, azaz Infrastructure as a Service ====
Ez a szolgáltatásszint a tárhelyet, hálózatot és egyéb alapvető számítási erőforrásokat foglal magában. Ez esetben a bérlő természetesen nem fér hozzá a felhő belső infrastruktúrájához, de testreszabhatja a vásárolt virtuális gép erőforrásait: tárhelyméret, CPU, memória, operációs rendszer, terhelés elosztás (...) és saját virtuális hálózatot, internet kilépési pontot konfigurálhat köré. Ez a szolgáltatásszint hasonlít a korábban tárgyalt VPS-hez.
A modell akkor lehet hasznos, ha egy induló vállalkozásnak számítási kapacitásra van szüksége, de nem akar saját szervereket karbantartani, vagy ha a szervezet gyorsan növekszik.

==== PaaS, azaz Platform as a Service ====
Lehetővé teszi, hogy a bérlő saját alkalmazásokat futtasson a felhőben, természetesen azzal a megkötéssel, hogy a szolgáltató támogatja az adott programkészletet. Ebben az esetben a bérlőnek nem kell üzemeltetési kérdésekkel foglalkoznia - operációs rendszer, CPU, memória, tárhely, hálózat (...) - csupán a saját programjára és az ahhoz kapcsolódó konfigurációs lehetőségekre kell koncentrálnia.
Ez a szolgáltatásszint nem ésszerű választás, ha az alkalmazásnak hordozhatónak kell lennie, ha szabadalom alatt álló programozási nyelvet használunk vagy ha az alkalmazás erőforrásait konfigurálni szeretnénk. Gyakran szoftverfejlesztők használják, amikor több fejlesztő dolgozik együtt és mind a fejlesztési mind a tesztelési szolgáltatásokat automatizálni kell.

==== SaaS, azaz Software as a Service ====
A szolgáltatások ezen szintjén sem az alkalmazás kódját, sem az alatta futó infrastruktúrát nem ismerjük. Tipikus példa az email vagy a keresés, ahol használjuk az alkalmazást, esetleg testreszabhatjuk (kinézet, logó, név stb.), de többnyire nem rendelkezünk információkkal (vagy teljesen lényegtelen a használat szempontjából), hogy milyen programnyelven készültek és milyen közegben működnek. Lehetnek ilyen alkalmazások továbbá asztali / telefonos alkalmazások, de például számlázó végpontok is. Fontos figyelembe venni, hogy a felhőbe érkező kérések nem valósidőben kerülnek feldolgozásra, így csak azon programok esetén használható, amelyek ezt nem követelik meg.

==== DBaaS, azaz Database as a Service ====
Ez a szolgáltatás garanciát ad azonnali skálázhatóságra, teljesítményre; a legújabb technológiákat használja és rendelkezik hibakezeléssel. A legfontosabb tulajdonságai:
# Self-service: különösebb konfigurálás nélkül elindítható. Nem csökkentett teljesítménnyel rendelkezik és nincs telepítési díj.
# Eszköz és helyfüggetlen adatbázis erőforrás
# Rugalmasság és skálázhatóság
# Annyit fizetsz, amennyit használsz
# Zökkenőmentes váltás a verziók / technológiák között

A szolgáltatás réteges architektúrát alkalmaz:
* UI réteg: interneten keresztül elérhetővé teszi a szolgáltatást
* Alkalmazás réteg: A szoftver szolgáltatásait és a tároló réteget is eléri
* Adatbázis réteg: hatékony és megbízható szolgáltatást nyújt - például menti az utolsó lekérdezéseket, hogy ismétlődés esetén ne kelljen újra lefuttatnia azokat
* Adat tároló réteg: adatok titkosítása, biztonsági mentések és lemezfigyelők találhatók itt

==== IaC, azaz Infrastructure as Code ====
Az infrastruktúra vezérlése magas szintű leírónyelv (deklaratív konfigurációs fájlok) segítségével, kézi kattintgatás helyett. Fontos leszögezni, hogy az IaC önmagában '''nem''' követeli meg sem a mikroszolgáltatás-architektúrát, sem a konténerek használatát - ugyanígy leírható vele akár egyetlen monolitikus alkalmazáshoz tartozó hagyományos virtuális gép, hálózat vagy adatbázis is. Az IaC segítségével megadhatjuk, hogy milyen erőforrásokat (EC2, VPC, RDS stb.) szeretnénk elindítani, milyen kapcsolatban álljanak egymással, és ez a leírt állapot verziókezelhető, újrafelhasználható és automatizáltan alkalmazható a felhőben. A legsűrűbben használt eszköz az ''Ansible'' és a ''Terraform''.

==== Összefoglalás ====
{| class="wikitable"
|+ Megosztott biztonsági felelősség (SSR) modell a szolgáltató (félkövér) és az ügyfelek között
|-
! SaaS !! PaaS !! IaaS
|-
| Felhaszálói hozzáférés || Felhaszálói hozzáférés || Felhaszálói hozzáférés
|-
| Adatok || Adatok || Adatok
|-
| '''Alkalmazások''' || Alkalmazások || Alkalmazások
|-
| '''Operációs rendszer''' || '''Operációs rendszer''' || Operációs rendszer
|-
| '''Hálózati forgalom''' || '''Hálózati forgalom''' || Hálózati forgalom
|-
| '''Hypervisor''' || '''Hypervisor''' || '''Hypervisor'''
|-
| '''Infrastruktúra''' || '''Infrastruktúra''' || '''Infrastruktúra'''
|}

== Felhők típusai ==
==== Privát felhő ====
Az adatok nincsenek megosztva harmadik féllel, a kontrollt teljes egészében a struktúrát kialakító rendszergazda kezében van. Természetesen nem korlátozódik a cég helyszínén üzemeltetett szerverekre a fogalom, szóba jöhetnek harmadik féltől bérelt VPS, VDS, de komplett bérelt szerverek is, de általában az eszközök VPN alagúton keresztül cserélnek információt, ezzel védve az adatokat.

==== Publikus felhő ====
Az adatokat egy harmadik fél által kialakított hálózaton keresztül használjuk, ami a csomagokat a publikus IP hálózaton keresztül továbbítják egymás között. Óriási előnye, hogy nincs üzemeltetési költsége a szolgáltatást igénybe vevőnek, általában a CPU idő után kell fizetni, tehát flexibilis költséget hoz magával.

==== Hibrid felhő ====
A publikus és a privát felhő kombinációja, így a kiemelt biztonságot igénylő adatok nem kerülnek ki az internetre, míg a kevésbé érzékeny adatok továbbíthatók a publikus felhő segítségével, ezzel kihasználva annak minden előnyét.

== AWS szolgáltatásai ==
Az AWS első körben IaaS szolgáltatásokat nyújt, nagy sebességű hálózaton összekötött feldolgozóegységet és tárolóegységeket tartalmazó infrastruktúrát és az ezeket támogató szolgáltatáshalmazt kínál.

=== Feldolgozás, adattárolás és kommunikációs szolgáltatások ===
==== Elastic Compute Cloud (EC2) ====
Egy szolgáltatás, amely egyszerű felület segítségével teszi lehetővé, hogy szerver példányokat futtassunk a felhőben. Létrehozáskor meg kell adnunk az operációs rendszert, amely lehet Linux alapú, OpenSolaris, FreeBSD, NetBSD, de akár a Windows Server különböző verziói közül is választhatunk. Szintén ki kell választanunk, hogy melyik régióban és melyik rendelkezésreállási zónában szeretnénk futtatni, ahogy az erőforrásigény szerint létrehozott különböző típusok közül is választatnunk kell. A nagyobb teljesítmény magasabb költségekkel rendelkezik.

A létrehozott szerver rendelkezik belső és külső IP címekkel és a hozzájuk tartozó domain nevekkel is. Ezeket a címeket leállításkor elveszíti és újraindításkor kap újat. A címek tehát dinamikusak, ami egy szerver esetében ritka jelenség. Van lehetőségünk azonban statikus IP címek (Elastic IP) igénylésére is. '''Figyelem, 2024 februárja óta megváltozott az árazási modell:''' korábban csak a nem használt (egyetlen futó szerverhez sem csatolt) statikus IP-kért kellett fizetni, ma viszont az AWS '''minden''' publikus IPv4 címért számláz óránként, függetlenül attól, hogy csatolva van-e egy futó szerverhez. Az IP címtartományok zónánként változnak.

A szerver példányok létrehozhatók előre definiált képfájlokból - ''Amazon Machine Image'' (AMI) -, vagy egy a felhasználó által létrehozott készletből. Az AMI képfájlok másolatot készítenek egy meglévő rendszerről - könyvtárak, applikációk, amelyeket a felhasználó saját maga telepített fel - kivéve a alsóbb szintű konfigurációs paramétereket, mint például a ''hostname'' vagy a MAC címek.

Egy EC2-ben létrehozott szerver interakcióba léphet egyéb más szolgáltatásokkal is, mint például S3, EBS, DynamoDB stb.

==== Simple Storage Service (S3) ====
Nagy objektumok tárolására alkalmas szolgáltatás. A minimálisan szükséges funkciókkal rendelkezik: írás, olvasás és törlés. A szolgáltatás lehetővé teszi egy alkalmazás számára, hogy korlátlan mennyiségű objektumot kezeljen 1 bájt mérettől egészen 5 terabájtig. Az objektumok úgynevezett ''bucket''-ban tárolódnak, amelynek egyedi azonosítója van és a felhasználó által kiválasztott régióban helyezkedik el. Az objektumokhoz állíthatunk be hozzáférési listát (ACL), amellyel kontrollálhatjuk, hogy ki milyen fájlokhoz, milyen módon férhet hozzá. Elérését egy REST illetve egy SOAP API biztosítja, alapvetően HTTP(S) alapon. ''(Régebben BitTorrent protokollon keresztüli hozzáférés is elérhető volt, de ezt az AWS 2021-ben megszüntette.)'' Az egyes fájlokhoz MD5 hash (ETag) készül, így letöltés után ellenőrizhető a fájlok helyessége.

==== Elastic Block Store (EBS) ====
Tartós tár, amelyet az EC2-höz csatolva használunk: egy fizikai lemezként megjelenő meghajtó. Mérete kötettípustól függően akár 16 tebibájtig (gp3, io1/io2) is terjedhet. A meghajtók a rendelkezésreállási zónán belül csoportosításra kerülnek, majd replikációkat hoznak létre az egyéb zónákban. Egy EC2 több EBS-t is használhat, és jellemzően egy EBS is csak egy EC2-höz lehet aktívan hozzárendelve (kivétel az io1/io2 Multi-Attach funkció, ami korlátozott esetekben több példányhoz is engedi csatolni ugyanazt a kötetet). Használható pillanatképek létrehozására egy szerverpéldányból, hogy később ezt felhasználva új EC2 példányt indíthassunk belőle.

==== DynamoDB ====
Az AWS natív NoSQL (kulcs-érték és dokumentum modellű) adatbázis szolgáltatása, amely web szolgáltatásokon keresztül teszi lehetővé a fejlesztők számára az adatok manipulálását. A szolgáltatás több, földrajzilag távol eső helyeken is képes másolatot készíteni (globális táblák). Támogatja a nagy teljesítményigényű alkalmazásokat, automatikusan skálázza a használat alapján az erőforrásokat, a táblában található indexeket és kezeli az adatbázis replikációkat. ''(Az AWS korábbi, hasonló célú szolgáltatása a SimpleDB volt, ezt azonban évek óta nem ajánlják új projektekhez, helyette a DynamoDB használata javasolt.)''

==== Simple Queue Service (SQS) ====
Szolgáltatások szinkronizációjára szolgáló üzenetsor, amelybe bejelentkezés nélkül lehet adatokat küldeni. Az üzenetsorok megoszthatók különböző regisztrációk között is. Az egyes üzenetek feldolgozás alatt zárolásra kerülnek, hogy elkerüljék azok többszöri feldolgozását. Amennyiben az üzenet feldolgozása valamilyen okból kifolyólag sikertelen eredménnyel zárul, akkor feloldják, ezáltal újra kivehető a sorból. A hozzáférés IP és idő alapon is tiltható.

==== CloudWatch ====
Egy monitorozó rendszer, amely telemetria adatokat gyűjt. Segítségével optimalizálható az alkalmazás. Anélkül, hogy a felhasználó bármit telepítene, tucatnyi metrika közül választhat, majd megtekintheti a hozzájuk tartozó grafikonokat. Az alap monitorozás ingyenes, amely 5 percenként gyűjt adatot, de készíthetünk bővebb, 1 perces mintavételezéssel is jelentést. A szolgáltatás monitorozza a az EBS elérésének idejét, az adatbázis hozzáférés idejét és az SQS-ben tárolt adatokat is és természetesen még sok egyéb paramétert.

==== Virtual Private Cloud ====
A VPC egy saját, elkülönített, logikailag izolált virtuális hálózat az AWS felhőjén belül: hétköznapibb értelemben modellezhetjük egy routerként, amelynek vannak alhálózatai, route táblája és egy internet kilépési pontja (Internet Gateway), amin keresztül a benne futó erőforrások (EC2 stb.) kommunikálnak egymással és a külvilággal. A VPC-n belül tűzfalként funkcionáló Security Groupokat és hálózati ACL-eket is definiálhatunk. Nem kötelező eleme egy VPC-nek, hogy egy meglévő céges hálózathoz kapcsolódjon - ha viszont erre is szükség van, arra külön szolgáltatás áll rendelkezésre: a VPN-alapú Site-to-Site VPN, illetve a dedikált vonalas Direct Connect köti össze a VPC-t egy meglévő, helyi infrastruktúrával.

==== Auto Scaling ====
Az Auto Scaling segítségével megadhatunk olyan szabályokat, amelyek segítségével az erőforrásaink dinamikusan változnak. Csoportokat hozhatunk létre, amelyben monitorozhatjuk az EC2 példányainkat, majd triggerek segítségével újabb és újabb példányokat indíthatunk el vagy éppen állíthatunk le, annak függvényében, hogy a csoportban megszabott szabályok szerint az erőforrás kevés vagy sok. A csoportban szereplő EC2 példányokra állíthatunk be teszteket, aminek segítségével információt nyújthatunk a terheléselosztást végző ''Load Balancer'' szolgáltatásnak: így biztosíthatjuk, hogy csak olyan gépek szerepeljenek annak listájában, amelyek elérhetők. A leggyakoribb trigger a CPU: ha a csoport CPU kihasználtsága magas, akkor újabb EC2 példány indul, ami egyúttal csökkenti a csoport CPU terhelését. Ha a csoport CPU terhelése nagyon alacsony (pl. 0%), akkor kevesebb EC2 példány is képes kiszolgálni az aktuális forgalmat, tehát leállít egyet. A létrehozáskor megadhatjuk, hogy milyen értékek között változhat a példányok darabszáma.

==== Cloud Formation ====
Segítségével JSON fájlban írhatjuk le az alkalmazás futtatásához szükséges infrastruktúrát. Benne leírhatjuk a szükséges erőforrások paramétereit, mint például az instance típusa, az SQL portja vagy mérete.

==== Elastic Beanstalk ====
Ez a szolgáltatás automatikusan skálázza az erőforrásokat az alkalmazás igényeihez igazítva. Ezt úgy éri el, hogy az Amazon egyéb szolgáltatásait automatikusan paraméterezi: EC2, S3, SNS, Load Balancer, Auto Scaling Group stb.

==== Lambda Service ====
Egy esemény alapú számítási erőforrás. ''Serverless''-nek is nevezik a megvalósítást. Ez esetben egy-egy függvényt írunk meg, amit a Lambda egy erősen izolált, könnyűsúlyú mikro-virtuális gépben (AWS Firecracker) futtat le. 2020 óta lehetőség van a függvényt Docker (OCI) image formájában is csomagolni és feltölteni, de ez csak a csomagolás/terjesztés módja - maga a futtatókörnyezet ekkor sem egy hagyományos Docker daemon, hanem ugyanaz a Firecracker alapú izolált környezet. A függvény egy esemény hatására elindul és végrehajtja a benne lévő kódot, majd le is áll - ezért serverless, mert nem kell, hogy folyamatosan fusson egy szerver. Az eredmény általában adatbázisba kerül, de használhat egyéb szolgáltatásokat is, mint például az SQS, SNS stb. Egy alkalmazás több Lambda kifejezésből épül fel általában. Ez esetben a fizetés idő alapú: amennyi ideig használjuk az erőforrást, annyi idő után fogunk fizetni.

=== Régiók és rendelkezésre állási zónák ===
Az Amazon mára több száz adatközponttal rendelkezik szerte a világban, ezekből épülnek fel a rendelkezésre állási zónák (availability zone) - egy zóna jellemzően egy vagy több, egymáshoz nagyon közeli adatközpontot takar, amelyben nagyságrendileg tízezres nagyságrendű szerver található. (A pontos szerver- és adatközpont-számokat az AWS nem publikálja, ezek becslések.) Minden AWS régió minimum három rendelkezésre állási zónával rendelkezik (ez már évek óta az AWS hivatalos vállalása új régiók indításakor), melyek nagy sebességű hálózaton vannak összekapcsolva. A régiók nem osztanak meg erőforrásokat és nem kommunikálnak az interneten keresztül. A tárhelyek esetében automatikus replikáció jön létre a régiókon belül: az S3 a rendelkezésre állási zónák között, az EBS csak az adott rendelkezésre állási zónán belül. A kritikus alkalmazásokat célszerű több régióban definiálni biztonság szempontból. Az egyes régiók között lehet különbség számlázás (árak) és az elérhető szolgáltatások tekintetében.

=== AWS hálózatok ===
Minden régió redundáns kapcsolaton keresztül lett összekapcsolva a többi régióval. Ezen kívül privát link kerül kiépítésre a ''Direct Connect'' ügyfelek számára. A legtöbb főbb régió privát linken keresztül került összekötésre, aminek segítségével minimalizálható a szakadások lehetősége.

A rendelkezésre állási zónákon belül akár 25Tbps sebességgel képesek kommunikálni egymással a szolgáltatások, miközben a késleltetés 1-2 ms.

== Átjárhatóság a felhőszolgáltatók között ==
Miközben a legtöbb szolgáltató arra törekszik, hogy minél több ügyfelet szólítson meg, minden szolgáltatónak vannak erősségei és gyengeségei. Emiatt könnyedén bekövetkezhet, hogy egy cégnek, amelynek addig megfelelő volt XY szolgáltató, hirtelen annak gyengébb minőségű szolgáltatásaival kellene dolgoznia, így a váltás, esetleg az újdonságok más szolgáltatónál történő elhelyezését helyezi kilátásba. Ekkor használjuk a ''vendor lock-in'' kifejezést, ami arra utal, hogy csak rengeteg idő és energia befektetéssel oldhatjuk fel a problémát, ráadásul elképzelhető, hogy épp olyan kellemetlenségekkel jár az új szolgáltatóhoz költöztetés más (régebbi) funkciók esetében, mintha az addigi szolgáltatónál helyeztük volna el az újításokat.

Egy tervezet szerint a szolgáltatók lehetőséget biztosítanak az egymást közötti átjárásra. A problémát messze nem egyszerű feloldani, hiszen nincs szabvány az adattárolásra, kommunikációs megoldásokra - sőt, az egyes szolgáltatók vonakodnak ezeket az információkat egymás között megosztani, hiszen egy hatékonyabb algoritmus sok pénzt spórolhat meg a gazdájának, ami előnybe is hozza a piacon. A szolgáltatók között úgynevezett ''Intercloud exchange'' interfészen keresztül lehetne kommunikálni.

= Adatközpontok belső hálózata =
'''''Oldalszám: 175-212.'''''

Ennek a fejezetnek a tanulmányozása előtt érdemes átolvasni a következő oldalakat is:
* [[Tipikus vállalati hálózati struktúra]]
* [[Hálózat rendelkezésreállás számítás]]
* [[BGP protokoll]]

== CLOS hálózati topológia elmélete ==
A clos hálózati topológiát Charles Clos írta le 1953-ban ("A Study of Non-Blocking Switching Networks", Bell System Technical Journal). A vezetékes telefonokhoz készült, hogy két végpont minden esetben tudjon egymással kommunikálni, független attól, hogy hány ügyfél telefonál egyszerre.
[[Fájl:Clos topológia.png|középre]]
A fenti képen látható a használt modell: van egy bemeneti ág (inbound) és egy kimeneti ág (outbound). Mind a Spine (gerinc), mind a Leaf (a fa levelei) switchek. A szabály szerint a Spine esetlegesen üresen maradt portjaira NEM köthetünk semmilyen végponti eszközt, csak és kizárólag a Leaf szintre. A hálózati topológia blokkolásmentes, ha a Spine-Leaf között több vagy egyenlő link van, mint a Leaf-ek és a rájuk kötött végponti eszközök között.

A példában 3 fokozatú (3-stage clos) hálózat látható. Minden ennél nagyobb fokozat elérhető, ha a középső (Spine) switcheket egy 3 fokozatú clos hálózattal helyettesítjük. Független a fokozatok számától mindig igaz, hogy a hálózaton a forrás és a cél között pontosan a fokozatok számával megegyező távolság alakul ki (jelen példában 3 - bemeneti leaf, spine, kimeneti leaf).

== CLOS a gyakorlatban ==
[[Fájl:Datacenter network.png|középre]]

Az adatközpontok hálózatában a [[Tipikus vállalati hálózati struktúra|vállalatoknál használt]] hálózati struktúra nem megfelelő, hiszen azt Észak-Dél irányú kommunikációra optimalizálták - kliens gépek internet hozzáférésének biztosítása stb. Az a struktúra azt feltételezi, hogy a vállalat szerverei egy ''Distribution'' rétegben foglalnak helyet, a szerver és a adattár (Storage) között csak egy switch található. Az adatközpontokban ez az állítás nem igaz: a központ bármely pontján lehet az adattár, akár több rack szekrény távolságban is. Ráadásul az észak-dél irányú kommunikációt biztosító struktúra bővítése igen költséges széltében és egy adatközpont általában ebben az irányban fejleszt.

A fenti okok miatt adatközpontokban olyan hálózati struktúrát kell alkalmazni, ami:
* széltében viszonylag kis költségek mentén bővíthető (végtelenségig),
* észak-dél irányú kommunikáció helyett nyugat-kelet irányra van optimalizálva.
Ezeknek a kritériumoknak megfelel például a Clos hálózat:
* a Clos hálózati modell felső fokozatát tükrözzük a Spine fokozatra, így a fentebb látható struktúrát kapjuk
* a spine L3 switch, tipikusan 100Gbps linkekkel
* a Leaf L3 switch 40Gbps sávszélességgel, amely vagy megegyezik a ToR (Top of Rack) switchekkel (3-stage clos) vagy erre csatlakozik (ez esetben 5-stage clos hálózat alakul ki).
* Az L3 kapcsolatot érdemes a ToR szintig letolni - tehát a Spine-Leaf-ToR között is L3 kapcsolat van (routing) -, így kiküszöbölhetők az L2 hátrányai:
** a spanning tree kikapcsolja a hurkot okozó portot, így a redundánsan kialakított portokból csak az egyik használható
** L2 hálózaton sok olyan nem kívánatos kommunikáció zajlik, ami csökkenti a sávszélességet
* point-point IP címeket használunk a Spine-Leaf-ToR hálózatban
* VXLAN segítségével kapcsolódunk a Leaf-ekre, így a szerverek nagyon gyorsan mozgathatók akár a rack szekrények között is (pl. egy virtuális gép áttelepítése során nem okoz problémát, hogy az IP tartományt is mozgassuk vele).
* Egy blokkolásmentes Clos hálózat minden portját ugyanakkora sávszélességgel érünk el, fix távolsággal (ez könnyedén kezelhető). Emiatt az adattárak bárhol lehetnek
* ne feledjük el, hogy az internetelérést biztosító router is a Leaf-re van kötve (nem a spine felett helyezkedik el!)

Az L3 kapcsolaton általában BGP protokollt alkalmaznak az IP cím tartományok hirdetésére. Lehet ehelyett mást is alkalmazni, azonban egy adatközpont többnyire publikus címeket is továbbít az internet felé, amire csak a BGP képes, így adja magát, hogy a belső hálózat címeihez is ezt használják. A BGP előnye, hogy támogatja az ún. ECMP szabályokat (Equal Cost Multipath routing), így a Spine és a Leaf fokozat között található összes kapcsolatot képes kihasználni - kvázi összeadva a sávszélességüket. Hátránya, hogy az eszközök számával exponenciálisan növekszik a konfigurációs igény is, de ezt különböző AS-ek kialakításával lehet mérsékelni.

A gyakorlatban nem törekednek a blokkolásmentes hálózat kialakítására, hiszen jelentősen növeli a költségeket, ha több ezer portra van szükségünk. Ugyanakkor azt se felejtsük el, hogy a Spine és a Leaf között nagyobb sávszélességet (100Gbps), mint a végpontok és a Leaf között (40Gbps). Ebből kifolyólag kevesebb Spine eszközzel is tudjuk biztosítani a szükséges sávszélességet - ennek következtében több elérhető port marad a Leaf fokozaton. A tipikus kialakítás, hogy a Spine-Leaf között a szükséges sávszélesség 3-át alakítják ki. Példa:
* Egy Rack-ben 10 szerver található, melyek fejenként 4x10Gbps kapcsolaton csatlakoznak a Leaf switch-re (egyben ToR)
* A rack szekrény sávszélessége így összesen 400Gbps
* A Spine-Leaf sávszélességét tehát 400/3=134Gbps sebességre kell optimalizálni
* Ha a Spine-Leaf között 100Gbps linkekkel számolunk, akkor összesen 2 Spine elegendő a szükséges sávszélesség eléréséhez (2-nél kevesebb Spine elhelyezése megszünteti a redundanciát is!).

=== A hálózat bővítése ===
A hálózatot két módon lehet bővíteni:
* Új Leaf switch elhelyezésével (A Leaf-et rá kell kötni az összes Spine switchre) a kapacitás növelhető - több portunk lesz
* Új Spine switch elhelyezésével jelentősen növelhetjük a rendszer sávszélességét.

A hálózat bővítésének felső korlátját a Leaf switchek portszáma jelöli ki: egy eszköz portszámának a felénél több spine nem telepíthető. (Ha többet telepítünk, akkor maradnak kihasználatlan vonalak maximális terhelés mellett is.) A fent látható hálózat nem bővíthető tovább (a Spine switchek telítettek, a Leaf switchek felét elfoglalja a Spine-Leaf kapcsolat).

== Fat-tree topológia ==
A Fat-tree egy speciális clos topológia. Korábban szó esett arról, hogy egy Clos hálózat Spine fokozata kicserélhető egy 3 fokozatú Clos hálózattal - így kettővel növekedik az addigi hálózat fokszáma. Alább láthatjuk ezt a bővítést 3-ról 5 fokozatra.
[[Fájl:Extend 3-stage clos to 5 stage.png|középre]]
A képen be van keretezve a 3 fokozatú hálózat Spine rétege, de ne feledjük, hogy egy Clos hálózatnak egyetlen ilyen fokozata van: tehát a fenti képen a fehérrel jelölt switchek képezik ezt a fokozatot. A képen a színezés miatt jól látható, hogy egy Leaf egyetlen Spine-hoz kapcsolódik csoporton belül (azonos színárnyalattal lettek jelölve, pl. zöld, kék stb.), mindegyik csoport két eszközből áll (világosak és sötétebbek). Természetesen az összes switchez kapcsolódik valamelyik Leaf, és egy Leaf továbbra is négy Spine-hoz kapcsolódik - mivel összesen 4 Spine csoport látható.

Ezzel a kapcsolással lehetőségünk nyílik a portok megtöbbszörözésére - a belső réteg arra szolgál, hogy az egyébként 2x2 portos switchekből 2x4 portos eszközöket hozzunk létre. A kapcsolás blokkolásmentes, tehát teljes egészében úgy működik, mintha egy 8 portos switcheket használtunk volna - igaz, ez sokkal költségesebb. Ne feledjük el, hogy ez a Clos hálózati topológia célja: blokkolásmentes óriás hálózatok felépítése.

A Fat-tree szintén ezt a bővítést használja ki: N darab spine switchet csoportokba rendez és szerverek egy csoportját - úgynevezett POD-okat - csatlakoztatja hozzá úgy, hogy minden POD minden switchel kapcsolatban álljon. ez az alábbi képen látható.
[[Fájl:Fat-tree.png|középre]]
A kialakítás során alkalmazunk egy pár trükköt, hogy a fenti struktúra alakuljon ki az 5 fokozatú Clos hálózatból:
* A középső switcheket megcseréljük alul és felül is - így alakul ki 2-2 POD (mindegyikbe kettő leaf lesz)
* A Spine fokozatra tükrözünk, így összesen 8 Leaf switch lesz, amelyet bármelyik irányba használhatunk
* N Leaf-re N darab (a példában 2) switch-et kapcsolunk, amelyek mind össze vannak kötve minden szemben lévő eszközzel
* A rétegekeket átnevezzük:
** A spine fokozat lesz a Core réteg
** A Leaf fokozat lesz az Aggregation réteg.
** A Leaf-ekre kapcsolt újabb switchek lesznek az Edge réget.
* A Core rétegben a Spine switchek átrendezhetők - ez a képen is így látható (az eredeti elrendezés szerint minden POD Leaf eszköze a Spine csoport első eszközére, minden POD második Leaf eszköze a Spine csoport második eszközére lenne kapcsolva), hogy minden POD egy Leaf eszköze egyetlen Spine switch csoporthoz kapcsolódjon. Ezek a csoportok Plane névre hallgatnak, amelyek innentől kezdve könnyedén telepíthetőek - egy újabb plane telepítéséhez újabb switch szükséges minden POD-ba az Aggregation rétegbe (és ezzel együtt az edge rétegbe is), majd minden újonnan telepített switchhez csatlakoztatni kell az új Plane eszközt (a csoportosítás nélkül a Spine switchek szét lennének szórva a rack szekrények között).

A fenti képen a 3 rétegű Fat-tree topológia látható, de a Clos topológiához hasonlóan több réteggel is létrehozható.

=== Összefüggések ===
L = rétegek száma, 
k = használt switcheken található portok száma

{| class="wikitable" style="margin: 0px auto;"
! Tulajdonság !! Általános !! 3 réteg
|-
| Spine eszközök maximális száma || (k/2)^(L-1) || (k/2)^2
|-
| Maximális végpontok száma || 2*(k/2)^(L) || 2*(k/2)^3
|-
| Összes felhasznált switch || (2*L-1)*(k/2)^(L-1) || 5*(k/2)^2
|-
| Edge rétegbeli switchek száma || 2*(k/2)^(L-1) || 2*(k/2)^2
|-
| Maximális POD || 2*(k/2)^(L-2) || k
|}

=== Méretezés ===
Tegyük fel, hogy egy hálózatot szeretnénk létrehozni, amelyben az alábbiakat kell teljesítenünk:
* 12 db szervert szeretnénk üzemeltetni,
* a szerver és az Edge között 10Gbps linkekkel
* a leaf és a spine között 25Gbps linkekkel
* 16 portos switcheket fogunk felhasználni

Ha mindezt 3 rétegű Fat-tree topológiában szeretnénk létrehozni, akkor a következő tulajdonságokat írhatjuk le:
* F(16, 3):
** Maximum (16/2)^2 = 64 Core switch
** Maximum 2*(16/2)^3 = 1024 végpont lesz
** 16 POD hozható létre

Elsőként el kell döntenünk, hogy ezek a korlátok hogyan befolyásolják a jövőnket: várhatóan mikor lépünk túl ezen. Ha kevés, vagy hamarosan kevés lesz, akkor növelnünk kell a switch portszámát (k) vagy a rétegeket. Tegyük fel, hogy számunkra ez megfelelő választás. Azonban nincs pénzünk az egésznek a kiépítésére (hiszen tudjuk, hogy összesen 256 darab switch árát kellene kifizetni), ráadásul nem is indokolt a jelenlegi terheltség mellett. Ez esetben el kell döntenünk, hogy mit szeretnénk elérni. Például a teljes kapacitás 1/4-t garantáljuk - figyelem! '''nem blokkolásmentes hálózatot építünk ki''', de a terheltség növekedésével tudunk fejleszteni. Nézzük hogyan méretezhetjük be a hálózatunkat a kívánt szintre:
* A 12 szerver 10Gbps sebességgel összesen 120Gbps sávszélességet igényel.
* A 120Gbps 1/4-dét szeretnénk kiépíteni, tehát: 120/x = 4/1 => 4x = 120 => x = 30Gbps.
* A switchek között 25Gbps sebesség érhető el, tehát 30Gbps/25Gbps darab Spine switch-re lesz szükségünk, hogy elérjük a minimális szintet. Mivel az eredmény tört, ezért 2 Spine switch szükségeltetik minden Spine-csoportba, amivel a lefedett sebesség 50Gbps lesz.
* A kettő Spine-switchez 2 Leaf tartozik (Aggregation) és 2 Edge switch - ezeket később a Core switchek növelésével szintén növelnünk kell
* A 64 darab Core switch összesen 8 csoportban helyezhető el (8x8). Jelenleg minden csoportban csak 2 eszközre van szükségünk. (Valójában ez egészen addig igaz, amíg a 16 POD mindegyike létezik és azok között 30Gbps sebességet szeretnénk garantálni. Jelenleg egy POD-ban elfér a 12 szerver (1 POD 16x25Gbps csatlakozással rendelkezik).

Ha a switch-ek kapacitása nagyobb, mint a használt sávszélesség (pl. 25Gbps helyett 50 vagy 100Gbps a gerincen), akkor a Fat-tree konfiguráció többszörözhető (pl. F(16,3)-ból F(32,3) lesz 50Gbps esetén és F(64,3) lesz 100Gbps esetén).

= Erőforrás virtualizálás =
'''''Oldalszám: 135-173.'''''

== Virtuális gépek ==
=== „Software Stack” ===
Egy szerver rétegekből épül fel: legalul a fizikai hardver, fölötte az operációs rendszer (kernel + driverek), majd az azon futó szolgáltatások/alkalmazások. Virtualizáció esetén ez a "software stack" kiegészül egy újabb réteggel: a hardver fölé egy hypervisor (Virtual Machine Monitor, VMM) kerül, ami több, egymástól elszigetelt virtuális gépet (VM) hoz létre, mindegyikben saját, önálló vendég operációs rendszerrel és saját szoftverstack-kel. A hypervisor feladata, hogy a fizikai erőforrásokat (CPU, memória, hálózat, tárolás) szétossza és elszigetelje a rajta futó VM-ek között.

A hypervisorokat két nagy csoportba szokás sorolni:
* '''1-es típus (bare-metal)''': közvetlenül a hardveren fut, nincs alatta „host” operációs rendszer (pl. VMware ESXi, Microsoft Hyper-V, Xen, KVM). Ez a jellemző megoldás szerverkörnyezetben, felhőszolgáltatóknál is.
* '''2-es típus (hosted)''': egy már futó operációs rendszeren belül, alkalmazásként fut (pl. VirtualBox, VMware Workstation asztali gépen). Kényelmesebb fejlesztői/tesztelési célra, de nagyobb overhead-del jár.

== Környezetek ==
=== QEMU ===
Nyílt forráskódú gépemulátor és virtualizáló szoftver. Önmagában, hardveres gyorsítás nélkül is képes teljes rendszereket emulálni - akár eltérő processzorarchitektúrát is (pl. ARM emulálása x86-os gépen), ez viszont jelentős teljesítménybeli veszteséggel jár, mivel minden processzorutasítást szoftveresen kell értelmeznie. Linux alatt tipikusan a KVM-mel párosítva használják: ekkor a KVM végzi a CPU/memória virtualizációját hardveres gyorsítással, míg a QEMU az eszközök (hálózati kártya, lemez, grafikus kártya stb.) emulálásáért felel - így érhető el közel natív teljesítmény, teljes eszközemulációval kombinálva.

=== XEN ===
A Cambridge-i Egyetemen indult, ma nyílt forráskódú, bare-metal (1-es típusú) hypervisor. Az egyik úttörője volt a paravirtualizációnak: a korai x86-os processzorok még nem támogatták hardveresen a virtualizációt, ezért a Xen a vendég operációs rendszer forráskódjának (kernel) módosításával érte el a hatékony működést. Történelmi jelentősége van az AWS szempontjából is: az Amazon EC2 hosszú éveken át Xen alapokon futott, mielőtt áttértek volna a saját fejlesztésű, KVM-alapokra épülő Nitro rendszerre.

== Virtualizációk típusai ==
=== Paravirtualizáció ===
A vendég operációs rendszer "tudatában van" annak, hogy virtualizált környezetben fut: a kritikus, hardverközeli műveleteket (pl. memóriakezelés, megszakítások) nem a valódi hardver felé, hanem közvetlenül a hypervisor felé, egy erre kialakított interfészen (hypercall) keresztül kéri. Ez elkerüli a drága hardveremulációt, cserébe a vendég operációs rendszer kernelét módosítani kell, ami nem minden esetben lehetséges (pl. zárt forráskódú, nem támogatott rendszerek esetén).

=== Hardware Virtual Machine (HVM) ===
A modern processzorok hardveres virtualizációs kiegészítéseit (Intel VT-x, AMD-V) kihasználó megoldás. Ezekkel a kiegészítésekkel a processzor hardveresen ismeri fel és kezeli a privilegizált utasításokat, így a hypervisornak nem kell szoftveresen emulálnia vagy a vendég kernelt módosítania - teljesen változtatás nélküli ("unmodified"), akár zárt forráskódú operációs rendszer (pl. Windows) is virtualizálható vele, közel natív teljesítménnyel.

=== Kernel-based Virtual Machine (KVM) ===
A Linux kernelbe épített modul, ami magát a Linux kernelt alakítja hypervisorrá: a HVM hardveres kiegészítéseket (VT-x/AMD-V) használja ki, és a Linuxot 1-es típusú hypervisorként viselkedteti. Önmagában csak a CPU és memória virtualizációját végzi, az eszközök emulálásához jellemzően a fentebb már említett QEMU-val párosítják. Nyílt forráskódú, ingyenes, és mivel a Linux kernel részét képezi, rendkívül elterjedt (többek között ezt használja a Proxmox, az OpenStack alapértelmezett hypervisoraként, és ez az alapja az AWS jelenlegi Nitro rendszerének is).

== Privát felhő platformok ==
=== Eucalyptus ===
Az egyik legkorábbi (2008-as) nyílt forráskódú privát felhő platform, ami kifejezetten az AWS API-jaival (EC2, S3) kompatibilis felületet biztosított, így az AWS-re írt eszközök/scriptek egy saját, helyben üzemeltetett felhőn is futtathatók voltak. A HP felvásárlása (2014) után a fejlesztése lelassult, mára inkább csak történeti jelentősége van, éles környezetben aktívan nem igazán terjedt el.

=== Open-Nebula ===
Nyílt forráskódú, viszonylag könnyűsúlyú felhő-menedzsment platform privát és hibrid felhők kialakítására. Az OpenStacknál egyszerűbb architektúrájú, gyorsabban üzembe helyezhető, cserébe kevésbé moduláris/rugalmas nagy, komplex, sok komponensből álló környezetekhez.

=== OpenStack ===
A legszélesebb körben elterjedt nyílt forráskódú IaaS felhőplatform, amivel saját, AWS-hez hasonló szolgáltatáskínálatú privát vagy hibrid felhő építhető ki. Moduláris felépítésű, önálló, de egymással együttműködő szolgáltatásokból áll, például:
* '''Nova''' - számítási erőforrások (VM-ek) kezelése
* '''Neutron''' - hálózatkezelés
* '''Cinder''' - blokk tárolás
* '''Swift''' - objektum tárolás
* '''Glance''' - image-ek (virtuálisgép-sablonok) kezelése
* '''Keystone''' - azonosítás- és jogosultságkezelés
* '''Horizon''' - webes admin felület
Nagyvállalati és telekommunikációs környezetekben (pl. saját adatközponttal rendelkező szolgáltatóknál) különösen elterjedt, ahol fontos szempont, hogy ne legyenek egy adott nyilvános felhőszolgáltatóhoz kötve (vendor lock-in elkerülése).

== Virtualizáló szoftverek ==
A fentebb tárgyalt virtualizációs típusokat (paravirtualizáció, HVM) a gyakorlatban konkrét, telepíthető hypervisor-termékek valósítják meg. Néhány elterjedt, elsősorban vállalati/szerver környezetben használt példa:
* Red Hat Virtualization (RHV), KVM alapú
* Hyper-V, Windows
* z/VM, IBM VM OS
* VMware ESXi
* Oracle VM Server

= Adattárolás a felhőben =
'''''Oldalszám: 215-230.'''''

== Tárolási modellek ==
A felhős tárolási szolgáltatásokat érdemes három alapmodell mentén elkülöníteni, amelyeket korábban az AWS szolgáltatásainál konkrét termékeken keresztül is érintettünk:
* '''Objektum tárolás''' (pl. AWS S3): fájlokat (objektumokat) tárol laposan, mappastruktúra nélkül (a "mappákat" csak a fájlnevek elé fűzött prefixek szimulálják), HTTP(S) API-n keresztül érhető el. Nagy mennyiségű, ritkán módosuló adathoz (képek, videók, biztonsági mentések, statikus weboldalak) ideális, de nem csatolható fájlrendszerként egy operációs rendszerbe.
* '''Blokk tárolás''' (pl. AWS EBS): egy nyers, particionálható, fájlrendszerrel ellátható "virtuális merevlemezt" ad, amit egyetlen szerverhez csatolunk. Adatbázisok, operációs rendszer image-ek jellemző felhasználási területei, mivel alacsony késleltetésű, blokk szintű elérést biztosít.
* '''Fájl tárolás''' (pl. AWS EFS - Elastic File System): hálózati fájlrendszer (NFSv4 alapokon), amit egyszerre több szerver is csatolhat és közösen írhat/olvashat, szemben az EBS-sel, ami jellemzően csak egy EC2-höz kapcsolódik aktívan. Megosztott konfigurációkhoz, közös feltöltési könyvtárakhoz kifejezetten hasznos (pl. egy Auto Scaling Group több példánya számára közös feltöltött fájlok tárolására).

== Konzisztencia modellek ==
Elosztott, több gépen/zónán replikált tárolók esetén fontos kérdés, hogy egy írás után azonnal, minden olvasó ugyanazt az (új) adatot látja-e:
* '''Erős konzisztencia (strong consistency)''': egy sikeres írás után minden következő olvasás garantáltan a legfrissebb adatot adja vissza, függetlenül attól, melyik replikát/zónát érte el a kérés.
* '''Végső konzisztencia (eventual consistency)''': egy írás után rövid ideig előfordulhat, hogy egy másik replikáról olvasva még a régi adatot kapjuk vissza, de egy idő után (jellemzően másodperceken belül) minden replika konzisztenssé válik.
Érdemes tudni, hogy az AWS S3 sokáig csak végső konzisztenciát biztosított egyes műveleteknél, 2020 végétől azonban minden művelethez (GET, PUT, LIST, DELETE) erős, olvasás-írás utáni konzisztenciát garantál, külön felár nélkül.

== Helyi fájlrendszerek a tárolás mögött ==
A blokk tárolók (pl. egy EBS kötet) önmagukban csak nyers, particionálatlan tárterületet adnak - ahhoz, hogy fájlokat tudjunk rajtuk tárolni, fájlrendszert kell rájuk telepíteni. A választott fájlrendszer jelentősen befolyásolja a teljesítményt, a megbízhatóságot és az üzemeltethetőséget, ezért érdemes ismerni a leggyakoribb Linux alatti lehetőségeket:

=== ext4 ===
A legtöbb Linux disztribúció (pl. Ubuntu) alapértelmezett fájlrendszere. Naplózó (journaling) fájlrendszer, ami azt jelenti, hogy a metaadat-módosításokat előbb egy naplóba írja, csak utána a végleges helyükre, így egy váratlan áramkimaradás vagy összeomlás esetén is konzisztens állapotba állítható vissza gyorsan. Kiforrott, jól ismert, kompatibilis és jó alapértelmezett választás, ha nincs speciális igényünk.

=== XFS ===
Eredetileg az SGI IRIX rendszeréhez készült, ma a Red Hat Enterprise Linux (és az AlmaLinux, RockyLinux) alapértelmezett fájlrendszere. Kifejezetten nagy fájlokra és nagy párhuzamos írási/olvasási terhelésre lett optimalizálva (pl. adatbázisok, nagy médiafájlok), jól skálázódik több CPU maggal is. Hátránya, hogy natívan nem támogat pillanatképeket (snapshot) - ehhez alsóbb szintű megoldásra (pl. LVM snapshot) van szükség -, és a fájlrendszer méretét utólag csak növelni lehet, csökkenteni nem.

=== BTRFS ===
Modern, copy-on-write (CoW) elvű Linux fájlrendszer (az openSUSE alapértelmezettje, sok NAS gyártó - pl. Synology - is használja). A CoW elv miatt egy módosításkor sosem írja felül a régi adatot a helyén, hanem az új verziót máshova írja, majd a mutatókat frissíti - ennek köszönhetően pillanatképek (snapshot) készítése szinte azonnali és nulla extra hellyel jár (amíg az adat nem változik). Beépített adatintegritás-ellenőrzést (checksumming) végez minden blokkon, támogat tömörítést és több lemez összekapcsolását (hasonlóan egy RAID-hoz). '''Fontos korlát:''' a BTRFS RAID5/RAID6 módja évek óta ismert, nem javított "write hole" hibával küzd, éles környezetben emiatt továbbra sem ajánlott ezekben a módokban használni.

=== ZFS ===
Eredetileg a Sun Microsystems Solaris rendszeréhez készült, ma nyílt forráskódú, közösségi fejlesztésű folytatása az OpenZFS (Linux, FreeBSD, TrueNAS stb. alatt is elérhető). A ZFS egyszerre fájlrendszer '''és''' kötetkezelő (a hagyományos LVM+fájlrendszer páros helyett), ezért sok funkciót natívan, nagyon hatékonyan valósít meg:
* Copy-on-write elv, akárcsak a BTRFS-nél, így itt is azonnali, olcsó pillanatképek/klónok készíthetők
* Beépített, blokkonkénti ellenőrzőösszeg (checksum) minden adaton és metaadaton, ami az esetleges "silent data corruption" (csendes adatsérülés) hibákat is kiszűri
* Saját RAID megvalósítás (RAIDZ1/2/3), amely - szemben a hagyományos RAID5/6-tal - nem szenved a "write hole" jelenségtől
* Beépített tömörítés és (opcionális) deduplikáció
* Az ARC (Adaptive Replacement Cache) nevű, RAM-alapú olvasási gyorsítótár jelentősen felgyorsítja a gyakran használt adatok elérését
A ZFS erőforrásigénye (elsősorban RAM) magasabb a fentieknél, cserébe kiemelkedően megbízható, ezért elsősorban dedikált tárolószervereken, NAS-okon, adatbázis-szerverek mögött terjedt el.

=== Összefoglalás ===
{| class="wikitable"
! Fájlrendszer !! Copy-on-write !! Natív snapshot !! Natív RAID !! Jellemző felhasználás
|-
| ext4 || Nem || Nem || Nem || Általános célú, alapértelmezett választás
|-
| XFS || Nem || Nem || Nem || Nagy fájlok, párhuzamos I/O, adatbázisok
|-
| BTRFS || Igen || Igen || Igen (RAID5/6 kerülendő) || Desktop/NAS, gyors pillanatképek
|-
| ZFS (OpenZFS) || Igen || Igen || Igen (RAIDZ) || Dedikált tárolószerverek, NAS, kritikus adatok
|}

= Felhőbiztonság =
'''''Oldalszám: 257-291.'''''

== Megosztott felelősség modell ==
A felhőbiztonság megértésének alapja a korábban (a Felhő ökoszisztéma fejezetnél) már bemutatott megosztott biztonsági felelősség (Shared Responsibility Model): a szolgáltató mindig a felhő '''infrastruktúráját''' (fizikai biztonság, hypervisor, hálózati gerinc stb.) védi, míg az ügyfél felelőssége a felhőn '''belüli''' konfiguráció - annál több, minél alacsonyabb szintű szolgáltatást (IaaS) használ. A leggyakoribb, valós felhős biztonsági incidensek túlnyomó többsége nem a szolgáltató oldalán, hanem az ügyfél helytelen konfigurációjából (pl. nyilvánosan elérhető S3 bucket, túl megengedő jogosultság) fakad.

== Identitás- és hozzáférés-kezelés (IAM) ==
Az AWS IAM (Identity and Access Management) szolgáltatásán keresztül szabályozható, hogy ki, milyen szolgáltatáshoz, milyen módon férhet hozzá. Alapelvek:
* '''Legkisebb jogosultság elve (least privilege)''': mindenki csak azt a jogosultságot kapja meg, ami a feladatához feltétlenül szükséges - ne adjunk soha alapból ''AdministratorAccess''-t egy alkalmazásnak vagy felhasználónak.
* '''Felhasználók vs. szerepkörök (roles)''': önálló felhasználó helyett gyakran célszerűbb egy EC2-höz/Lambdához szerepkört (role) rendelni, amihez időben korlátozott, automatikusan lejáró hitelesítő adatok tartoznak - így nincs statikus kulcs, amit ellophatnak.
* '''Többfaktoros azonosítás (MFA)''': különösen a root és adminisztrátori fiókoknál alapkövetelmény.
* '''Hozzáférési kulcsok (Access Key) kezelése''': ezek statikus, hosszú élettartamú titkok, ezért soha nem szabad forráskódba, verziókezelőbe (pl. GitHub) beleégetni őket - sajnos ez a felhős adatszivárgások egyik leggyakoribb oka.

== Hálózati biztonság ==
A VPC-n belül több rétegben is szabályozható a forgalom:
* '''Security Group''': a korábban már tárgyalt, EC2 (vagy más erőforrás) szintjén ható, ''stateful'' tűzfal - ha egy bejövő kapcsolatot engedélyezünk, a rá érkező válaszforgalmat automatikusan is engedi, külön szabály nélkül.
* '''Network ACL (NACL)''': alhálózat szintjén ható, ''stateless'' szűrő - itt a bejövő és kimenő szabályokat külön-külön, explicit módon kell megadni, mivel nem emlékszik a kapcsolat állapotára.
* '''Mélységi védelem (defense in depth)''': a gyakorlatban ezeket egymásra rétegezve érdemes alkalmazni (VPC szegmentálás, publikus/privát alhálózatok, Security Group + NACL együtt), hogy egyetlen hibásan beállított szabály se jelentsen azonnal teljes kompromittálódást.

== Titkosítás ==
* '''Nyugalmi állapotú adatok (encryption at rest)''': a tárolt adatok titkosítása, jellemzően az AWS KMS (Key Management Service) által kezelt kulcsokkal - EBS kötetek, S3 objektumok, RDS adatbázisok mind támogatják, sok esetben egyetlen checkbox bekapcsolásával.
* '''Adatátviteli titkosítás (encryption in transit)''': a hálózaton mozgó adatok védelme, jellemzően TLS/HTTPS segítségével - egy publikus alkalmazásnál ez ma már alapkövetelmény, nem opció.

== Monitorozás és naplózás ==
* '''CloudTrail''': minden API-hívást naplóz (ki, mikor, milyen szolgáltatáson, milyen műveletet hajtott végre) - utólagos vizsgálathoz (audit), illetéktelen hozzáférés kiderítéséhez nélkülözhetetlen.
* '''GuardDuty''': gépi tanuláson és fenyegetettségi adatbázisokon alapuló, folyamatos anomália-/fenyegetésfelismerő szolgáltatás (pl. szokatlan API-hívási minták, ismert rosszindulatú IP-kről érkező forgalom jelzése).
* '''CloudWatch''': a korábban már tárgyalt monitorozó szolgáltatás biztonsági szempontból is releváns - riasztásokat (alarm) állíthatunk be szokatlan erőforrás-felhasználásra, ami akár egy kompromittálódás jele is lehet.

== DDoS és alkalmazásszintű védelem ==
* '''AWS Shield''': hálózati/szállítási rétegbeli (L3/L4) DDoS védelem, ami alapszinten minden ügyfélnek automatikusan, ingyenesen jár.
* '''AWS WAF (Web Application Firewall)''': alkalmazásrétegbeli (L7) szűrés, amivel pl. SQL injection, XSS és egyéb tipikus webes támadásminták ellen védekezhetünk, illetve rate limitinget is beállíthatunk vele.
* '''CloudFront (CDN)''': a felhasználókhoz földrajzilag közelebb elhelyezett gyorsítótárazó réteg, ami a látható eredeti szerver elrejtésével és a terhelés elosztásával is csökkenti a támadási felületet.

== Tipikus felhős biztonsági hibák ==
A gyakorlatban tapasztalt incidensek jelentős része néhány visszatérő hibára vezethető vissza:
* Nyilvánosan (publikusan) elérhetőre állított S3 bucket, amiben bizalmas adat van
* Túl megengedő (pl. ''0.0.0.0/0'' minden portra nyitott) Security Group szabályok
* Forráskódba/verziókezelőbe kerülő, hardcode-olt hozzáférési kulcsok
* Az EC2 metaadat-szolgáltatás (Instance Metadata Service) régebbi, v1 verziójának használata, ami SSRF-sebezhetőség esetén jogosultsági adatok kiszivárgásához vezethet - emiatt ma már az újabb, tokenalapú IMDSv2 használata javasolt/kötelező sok szervezetnél
* Elavult, javítatlan szoftverek/csomagok futtatása a szerverpéldányokon (ezért is hasznos a korábban említett OpenVAS-szerű, CVE-alapú sebezhetőség-vizsgálat)

== Megfelelőség (compliance) ==
A felhőszolgáltatók számos iparági és jogi szabványnak (pl. ISO 27001, SOC 2, PCI-DSS) való megfelelést tanúsítanak az infrastruktúrájukra, ez azonban csak a megosztott felelősség modell "szolgáltatói" felét fedi le - az, hogy egy konkrét alkalmazás/adatkezelés megfelel-e például a GDPR-nak, továbbra is az üzemeltető felelőssége, a megfelelő régióválasztástól kezdve a hozzáférés-szabályozásig.

= Docker =

GAMF::Felhőalapú-szolgáltatások::Előadás

2026-09-14T07:54:26Z

ApelPro: Szakmai hibák javítása (EC2 név, Clos éve, VPC/IaC/Lambda leírás, EBS/S3/SimpleDB/Elastic IP frissítés, Facebook->Instagram) + Adattárolás a felhőben (ZFS/XFS/BTRFS/ext4) és Erőforrás virtualizálás fejezetek megírása

EDU::GAMF::Felhőalapú-szolgáltatások::AWS

2026-09-14T07:48:16Z

ApelPro: 2024-es Free Tier váltás jelzése; EC2 névmagyarázat javítása; AWSCLI v2 hivatalos telepítés hozzáadva

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
[[category:GAMF AWS|AWS]]
== Amazon Web Services regisztráció ==
Az AWS regisztrációhoz szükségünk lesz egy email címre, egy telefonszámra a megerősítéshez és egy netes vásárlásra alkalmas bankkártyára. A regisztráció során az AWS jellemzően egy jelképes összeggel (kb. 1$ vagy annak megfelelő) meg terheli a számlát a kártya ellenőrzéséhez, de később erre nem tart igény, így a tranzakció lejáratakor jóváíródik a számlán.

'''Figyelem!''' 2024 közepe óta az AWS megváltoztatta az ingyenes csomag felépítését: az újonnan regisztráló fiókok már '''nem''' a régi, klasszikus "12 hónapig minden Free tier eligible szolgáltatás ingyenes" modellt kapják, hanem egy kredit alapú, rövidebb (jellemzően kb. fél éves) ingyenes időszakot induló jóváírással. A korábban regisztrált fiókok a régi, 12 hónapos feltételeket tarthatják meg. Regisztráció előtt mindenképp nézzük meg az aktuális [https://aws.amazon.com/free/ AWS Free Tier] feltételeit, mert idővel ezek is változhatnak.

== Ingyenes verzió korlátai ==
Az ingyenes csomagban nem minden érhető el és ami mégis, az sem korlátlan ideig (a klasszikus modellben pl. 750 óra EC2 futási idő havonta, az új kredit alapú modellben pedig a jóváírt összeg elfogyásáig), amit ha átlépünk, akkor fizetési kötelezettségünk jelentkezik a szolgáltató felé. Igyekezzünk mindent leállítani az órai munka illetve az otthoni gyakorlás után, hogy lehetőleg ne kerüljön pénzbe a féléves munkánk. A hallgatók által elszenvedett károkért sem az iskola sem Én nem tudunk felelősséget vállalni, de azt meg tudjuk ígérni, hogy fizetős szolgáltatást nem használunk és nem is kérünk számon.

== AWS alapok ==
'''Figyelem!''' Az iskolai hálózatból csak az eu-west-1 és az eu-central-1, azaz Írország és Frankfurt IP címei vannak engedélyezve, ezekre fogunk tudni SSH kapcsolaton keresztül csatlakozni. 
'''Figyelem!''' Próbaidőszak alatt minden szolgáltatás mellett keressük a ''Free tier eligible'' megjegyzést, különben fizetési kötelezettségünk adódhat!

=== EC2 szolgáltatásai ===
Az ''EC2'' gyakorlatilag egy VPS-nek feleltethető meg és nem is tévedünk vele hatalmasat. A hivatalos neve ''Elastic Compute Cloud'', innen az ''EC2'' rövidítés: a ''2''-es a végén azt jelzi, hogy a névben két ''C'' kezdőbetűs szó van (''Compute'' és ''Cloud'').

A különbséget a VPS-hez elsősorban a rugalmas (''elastic'') skálázhatóság okozza: az EC2 példányokat gyorsan tudjuk indítani, leállítani, típust váltani rajtuk, illetve automatikusan is skálázhatjuk a darabszámukat (lásd később: Auto Scaling Group). Emiatt architekturálisan úgy érdemes tervezni, mintha bármikor cserélődhetne egy adott példány - ez alap (On-Demand) EC2 esetén a gyakorlatban ritkán, hardverhiba vagy saját leállítás esetén fordul csak elő, de a olcsóbb ''Spot'' típusú példányoknál az AWS bármikor, rövid (kb. 2 perces) előzetes figyelmeztetéssel visszavonhatja a gépet. Emiatt körültekintően kell eljárnunk: semmilyen adatot nem érdemes úgy egy alkalmazáson belül tárolni, mint egy VPS esetén: a dinamikus adatok (pl. PHP Session, feltöltött fájlok) egy EC2 csere esetén elvesznek, így ezeket nem helyben fogjuk tárolni.

Az EC2 szolgáltatásait a keresőmezőbe írt ''„EC2”'' kulcsszóval és az eredményekben megjelenő ''EC2''-re való kattintással érhetjük el.

[[Fájl:GAMFAWS search EC2.png.png]]

Az alapértelmezetten megjelenő menüpont a ''Dashboard'', ahol információkat találhatunk az ''EC2'' köré felhúzható szolgáltatásokról, melyeknek egy részét a továbbiakban tárgyalni is fogunk. Az összefoglaló táblázat az alább látható módon jelenik meg. '''Figyelem''', a táblázat csak az adott régióban elindított/elérhető szolgáltatásokat mutatja, régió váltása előtt érdemes az esetlegesen létrehozott, régió függő elemeket leállítani, hogy később ne jelenjen meg fizetési kötelezettség.

[[Fájl:GAMFAWS ec2 dashboard.png]]

==== EC2 telepítése és beállítása ====
EC2 létrehozásához meg kell nyomnunk a ''Launch instance'' gombot, melyet több helyen is elérhetünk:
* A Dashboardon
* A bal oldali menüben található ''Intances'' menüpont megnyitása után jobb felül
A gomb minden esetben a következőképp néz ki: [[Fájl:GAMFAWS ec2 launch instance button.png]]

A gombra kattintva egy űrlap jelenik meg, amely segítségével elvégezhetjük a szükséges beállításokat: 
======Név és tag beállítok======
Megadása nem kötelező, de több szerver futtatása esetén könnyebben azonosíthatjuk be őket ezek segítségével
[[Fájl:GAMFAWS ec2 setup name and tags.png]]

Az ''Add additional tags'' gombra kattintva további kulcs=érték párokat adhatunk hozzá, amivel dinamikusan csatolhatjuk össze egyéb szolgáltatásokkal, amelyek egy-egy kulcsot keresve döntik el, hogy melyik szolgáltatásokkal kell együttműködniük (például monitorozás bekapcsolása 'monitoring=true' kulcs=érték pár alapján.

======Kezdeti képfájl kiválasztása======
Az Amazon többféle indítóképpel is rendelkezik, így nagy valószínűséggel meg fogjuk találni a hozzánk közelálló operációs rendszert. Új hozzáadására nincs lehetőségünk, de készíthetünk az alapképfájlokból olyan verziót, ami már tartalmazza a saját konfigurációnkat (lásd [[GAMF :: Felhőalapú-szolgáltatások :: AWS#AMI_létrehozása|itt]]). 
[[Fájl:GAMFAWS ec2 setup AMI choose2.png]] 
Az órákon az Ubuntu legújabb verzióját használjuk, mivel ennek a Desktop változata az egyik legelterjedtebb a Linux felhasználók körében, így nem kell más környezetet megszoknia egy átlag hallgatónak. Érdemes lehet azonban egyéb disztribúciók kipróbálása is, különösen a '''Debian'''-t, '''Suse'''-t/'''OpenSuse'''-t, '''ReadHat'''-et és annak ingyenes változatait ('''AlmaLinux''', '''RockyLinuxtm''', amelyek az egykori '''CentOS'''-t hivatottak váltani), mivel céges környezetben ezek sűrűbben előfordulnak: némelyik a kisebb erőforrásigénye, míg másik az Enterprise szolgáltatásai miatt.

======Szerver típusának meghatározása======
Különböző erősségű szerverkonfigurációk közül választhatunk, de természetesen nem mindegyik érhető el az ingyenes verzióban. A számítógépek ára a konfiguráció függvényében változik, de csak azért az időért kell fizetni, amíg a szerver ''Running'' állapotban volt. Az órán az alapértelmezett ''t2.micro''-t használjuk. 
[[Fájl:GAMFAWS ec2 setup instance type.png]]

======Kulcspár hozzárendelése======
Az Amazonon belüli szolgáltatásokat felhasználónév/jelszó páros helyett SSH kulcspárok segítségével érjük el. Minden felhasználó számára készíthetünk egyet és jogosultságok segítségével korlátozhatjuk, hogy mihez férhet hozzá (IAM). 
Ebben a szekcióban ki kell választanunk, hogy a telepíteni kívánt EC2-höz milyen kulcspárral lehet majd hozzáférni. Amennyiben nem rendelkezünk még kulcspárral, úgy van lehetőségünk helyben elkészíteni a ''Create new keypair'' gomb segítségével, amelynek lépési megegyeznek az [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Kulcspár_létrehozása|itt]] leírtakkal. 
[[Fájl:GAMFAWS ec2 setup keypair.png]]

======Hálózati és biztonsági beállítások======
Az EC2-k közötti kommunikációs csatornák kialakításához definiálnunk kell, hogy melyik virtuális hálózatba akarjuk elhelyezni és milyen alkalmazásokat szeretnénk elérhetővé tenni. Ezt a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#VPC_beállításai|VPC]] és a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Security_Group|Security Group]] beállításával tehetjük meg. Előbbi a virtuális hálózatnak felel meg, míg utóbbi hasonlóan egy tűzfalhoz, meghatározza, hogy a szerveren milyen portokat érhetünk el. Érdemes az SSH-t engedélyezni és ha webes alkalmazást szeretnénk rajta futtatni a későbbiekben, akkor a HTTP és/vagy HTTPS szolgáltatást/szolgáltatásokat is, így később nem kell szerkeszteni ezeket a beállításokat. 
[[Fájl:GAMFAWS ec2 setup networking.png]]

======Tárhely beállítások======
Ebben a részben adhatjuk meg, hogy a szerverünk mekkora tárhellyel rendelkezzen. Egy Linux alapú operációs rendszernek nem kell 8GB-nél több, így az alapértéken hagyhatjuk. Az itt megadott érték inkább csak egy korlát, valójában csak akkora tárhelyet vesz igénybe, amennyire ténylegesen szüksége van a rendszernek. Ez az érték alatt látható figyelmeztetés miatt lényeges, hiszen a 30GB-t elhagyva fizetőssé válik a tárterület is, ám ez nem jelenti, hogy csak 4 szervert tudnánk elindítani az ingyenes keretek között. 
[[Fájl:GAMFAWS ec2 setup ebs.png]]

Ezt a szolgáltatást EBS-nek nevezik (''Elastic Block Store'') és az EC2 megszűnésekor minden erre mentett adat elveszik, így általában az OS-t és az applikáció kódját tároljuk ezen - semmi dinamikus adatot.

======Haladó beállítások======
Ebben a szekcióban különböző beállításokat végezhetünk el, ám ezeket az órán nem módosítjuk. Érdekes lehet azonban a menüt lenyitva legalul található ''User data'' opció, amivel parancsokat adhatunk meg az új operációs rendszer számára, hogy miket futtasson le. Ennek segítségével lehetőségünk nyílik applikációk telepítésére - pl. git - és a kód letöltésére egy másik szerverről, amennyiben a kiválasztott képfájl nem tartalmazta azt. 
''Az órai keretek között ezt a funkciót nem használjuk ki, de érdemes lehet kipróbálni, mivel valós alkalmazások üzemeltetésekor jól jöhet.'' 
[[Fájl:GAMFAWS ec2 setup userdata.png]]

======Összefoglaló======
A beállító panel mellett jobbra találhatjuk az összefoglaló ablakot, amelyben megtalálható a ''Launch Instance'' gomb. Ennek segítségével kezdhetjük meg a végleges telepítést, ha erre rá nyomunk, akkor a rendszer megkezdi a kiválasztott konfiguráció telepítését. Ha ebben az ablakban pénzösszegeket látunk, akkor az egészen biztosan fizetési kötelezettséget vonz magával, legyünk körültekintőek. 
[[Fájl:GAMFAWS ec2 setup summary.png]]

======Az elkészült instance tulajdonságai======
A futó szerverek az ''Instances'' menüpontban érhetők el. Az egyes sorokra kattintva alul megtekinthetjük a beállításait, amely tartalmazza az AWS által kiosztott publikus és privát IP címeket és domain neveket. Ezeken keresztül tudunk kommunikálni szerverünkkel. 
[[Fájl:GAMFAWS ec2 properties.png]] 
''Jelen példában a külső IP címünk: 3.252.168.207, amit a mellette található ikonnal egyszerűen a vágólapra másolhatunk.''

======Csatlakozás Linux terminálból======
A csatlakozáshoz nyissunk meg egy terminált a CTRL+T billentyűkombinációval, majd navigáljunk a ''cd'' parancs segítségével a letöltött kulcsfájl mappájába. Az SSH megköveteli, hogy a csatlakozáshoz használt kulcsfájlhoz csak a tulajdonos felhasználó férjen hozzá, így a következő parancsot futtassuk le rajta: ''chmod 600 test.pem''

A következő paranccsal tudunk kapcsolódni: ''ssh -i test.pem ubuntu@3.252.168.207'' 
Ha a fenti parancs kéri, fogadjuk el a tanúsítványt. Amennyiben ''Permission error'' hibát kapunk, akkor a fenti ''chmod'' parancsra van szükségünk, vagy nem mi vagyunk a kulcsfájl tulajdonosai (''ls -l'' segíthet). 
A ''test.pem'' az AWS rendszerből letöltött .pem formátumú kulcsfájl, az ''ubuntu'' a szerveren elérhető felhasználó. A különböző disztribúcióknál használt felhasználónevekről [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connection-prereqs.html ezen] a linken tájékozódhatsz. 
[[Fájl:GAMFAWS ec2 connect linux.png]]

======Csatlakozás Putty használatával======
Amennyiben a .pem kiterjesztésű állományt töltöttük le az AWS rendszeréből, akkor a '''puttygen''' eszköz segítségével ki kell exportálni belőle a privát kulcsot. [https://www.ssh.com/academy/ssh/putty/windows/puttygen Ezen a linken] részletes segédlet található a programcsomaghoz, ahol további funkciók is bemutatásra kerülnek (pl. kulcsgenerálás).

==== Kulcspár létrehozása ====
A kulcspárok kezeléséhez a ''Key Pairs'' linket nyissuk meg a bal oldali menüből. Újat a jobb oldalon látható ''Create key pair'' gomb segítségével készíthetünk. [[Fájl:GAMFAWS ec2 keypair create.png]]

A gombra kattintva egy űrlapot kapunk, amely végig vezet minket a létrehozás lépésein.
# Név megadása
# Típus kiválasztása - ''RSA-val dolgozunk az órán''
# Letöltendő kulcs típusa - ''Linux terminálból való csatlakozáshoz a .pem fájlra lesz szükségünk''
# Esetleges tag-ek hozzárendelése
# A ''Create key pair'' gombra kattintva letölthetjük a kulcspárt

[[Fájl:GAMFAWS ec2 keypair setup.png|Kulcspár létrehozása]]

'''Figyelem!''' A kulcspár csak a létrehozás után tölthető le '''egyetlen egyszer''', az elvesztett fájlok nem reprodukálhatók! Amennyiben egy EC2 csak az elhagyott kulcspárral érhető el, úgy annak (EC2) törlése és újrakonfigurálása szükséges egy új kulccsal.

==== Security Group ====
A Security Group-ok segítségével kontrollálhatjuk, hogy a szervereinkhez milyen portokon férhetnek hozzá, tehát mintegy tűzfal működik. Egy Security Group több gépre is ráhúzható és függetlenül működik, azaz a megadott szabályokat nem másolja át az operációs rendszer konfigurációs állományaiba, mintegy a szerver elé telepített eszköz működik. Ennek köszönhetően futási időben változtathatjuk a szabályokat, életbelépésükhöz nem kell újracsinálni az EC2-ket.

A bal oldali sávban, a ''Network & Security'' csoportban érhető el.

===== Security Group hozzáadása =====
Egy új szabályrendszer felvételét kezdeményezhetjük az EC2 telepítésekor, ahogyan azt [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Hálózati_és_biztonsági_beállítások|itt]] is láthattuk, de készíthetünk előre meghatározottakat is.

Az előre definiált csoportokat a ''Create Security Group'' gomb segítségével hozhatjuk létre, amelyet a jobb felső sarokban találhatunk meg. 
[[Fájl:GAMFAWS ec2 secg new button.png|bélyeg]sdfsad] 

A gomb megnyomását követően egy űrlapot kapunk, melynek 3 fő része van:
# Általános adatok [[Fájl:GAMFAWS ec2 secg new basic.png|bélyeg|Általános adatok]]
#* '''A név és a leírás mező megadása is kötelező'''
#* Itt választhatjuk ki, hogy mely VPC-ben szeretnénk elérhetővé tenni.
# Bejövő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg inbound.png|bélyegkép|Inbound rules]]
#* '''Az itt megjelenő szabályok lesznek engedélyezve a szerverünk felé, minden más csomag eldobásra kerül'''
#* Háromféle szabályból választhatunk:
#** '''Anywhere''' (IPv4, IPv6): A megadott IP típusból mindenhonnan elfogadjuk a csomagokat
#** '''Custom''': Csak a megadott IP címekről/IP tartományokból érjük el az adott portot
#** '''MyIP''': automatikusan beillesztésre kerül az felhasználó aktuális IP címe (hasonló a custom lehetőséghez)
# Kimenő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg outbound.png|bélyegkép|Outbound rules]]
#* A kimenő forgalom szabályozása biztonsági szempontból megfontolandó, de természetesen a publikus alkalmazások esetében (pl. web) nem tudunk ilyen szűrést alkalmazni.
#* Alkalmazhatjuk például SSH-ra, hogy megszüntessük annak a lehetőségét, hogy egy esetleges fertőzésből kifolyólag SSH-t hackelgető botnetté változzunk (volt már hasonló tapasztalat).
#* Az órán ezzel bővebben nem foglalkozunk, de éles környezetben ne felejtsünk el ezen szabályok definiálására időt szánni.
# Tag-ek megadása

===== Security Group szerkesztése =====
A szerkeszteni kívánt soron kattintsunk jobb gombbal és válasszuk ki a szerkeszteni kívánt szabályok csoportját:
* '''Edit inbound rules''', ha a bejövő csomagok szűrését szeretnénk módosítani,
* ''' Edit outbound rules''', ha a kimenő forgalmat szeretnénk szűrni.
A megnyíló ablakban ugyanazon a módon vehetünk fel szabályokat, ahogyan a létrehozásnál. A módosítások mentés után életbe lépnek. 
[[Fájl:GAMFAWS ec2 secg context menu.png]]

==== Terheléselosztás vázlat ====
[[Fájl:EC2LoadBalancingRequirements.png|középre]]

==== AMI ====
Az AMI gyakorlatilag egy bitről-bitre lemásolt HDD képfájl, amely tömörítve lett. Így tárolja az összes elmentett adat- és konfigurációs állományt. Ha egy alkalmazást készítünk, akkor a következő okokból készítünk ilyen képfájlt:
# Biztonsági mentés a telepített szolgáltatásokról, így később nem kell egy esetleges hiba miatt újrakonfigurálni az egészet
# AutoScaling group-ba szeretnénk rendezni az alkalmazásunkat, annak pedig meg kell mondani, hogy melyik képfájlt indítsa el

'''Figyelem!''' A képfájlok úgynevezett snapshot-okat hoznak létre, amelyek tárolásáért fizetni kell, ha az összméret meghaladja a 8GB-ot. (A snapshotok az éppen futó rendszer miatt készülnek: minden írási műveletet lezár, majd a snapshot készítés után elindított írási műveletek már a háttértár egyéb területeire történik, amelyet a mentés nem fog tartalmazni, így garantálható, hogy nem lesznek félig lezárt fájlok a mentésben. Lásd bővebben: BTRFS (linux) és NTFS support). A pillanatképek nem törölhetők, amíg a belőlük készült AMI létezik!

===== AMI létrehozás lépései =====
'''Navigáljunk az Instances menüpontra, ahol láthatjuk, hogy milyen EC2 szolgáltatások vannak a rendszerünkben.'''
# Kattintsunk jobb gombbal azon az elemen, amelyet menteni szeretnénk
# Nyissuk ki az ''Image and templates'' menüpontot
# Kattintsunk a ''Create image'' lehetőségre 
[[Fájl:GAMFAWS ec2 ami create.png]]

'''Nevezzük el a képfájlt tetszés szerint''' 
[[Fájl:GAMFAWS ec2 ami setup.png]]

'''Navigáljunk a bal oldalon található menüben az ''Images'' szekcióhoz és válasszuk ki az ''AMIs'' elemet. Itt megtekinthetjük és törölhetjük a létrehozott képfájljainkat.''' 
[[Fájl:GAMFAWS ec2 ami list.png]]

'''Ha a mentés sikeresen elkészült, akkor az EC2 létrehozásánál kiválaszthatjuk azt.''' 
[[Fájl:GAMFAWS ec2 setup own ami select.png]]

==== Indítási konfigurációk elkészítése ====
Az indítási konfigurációk mind egy célt szolgálnak: egységes profilba rendezi az EC2-ről készült képfájlokat. Míg az AMI nem tárolt információt a mentett gép erőforrásáról, egy indítási konfigurációban megadhatjuk ezeket. Később ezek felhasználásával egyszerűbben indíthatunk újabb szervereket és vannak olyan esetek is, amikor a rendszer megköveteli, hogy a képfájl megadása helyett konkrét, hardverinformációkat is tároló konfigurációs sablonokat adjunk meg.

''Az Auto Scaling Group például megköveteli, hogy a következő kettő elem közül az egyiket megadjuk, ebből fogja tudni, hogy milyen típusú EC2-t, mekkora tárhellyel és milyen VPC-ben indítson el.''

===== Launch configuration =====
'''Egy kifutóban lévő konfigurációs séma, amely 2022. December 31-e után nem kapja meg a frissítéseket. Az AWS javaslata szerint érdemes ezeket a beállításokat a következőkben tárgyalt ''Launch template'' alá migrálni.

A ''Launch configuration'-nek nevezett séma egy egyszerűsített változata a sablonoknak. Jóval kevesebb beállítási lehetőséget tartalmaz, mint a párja, de tökéletesen elegendőt az ''Auto Scaling Group''hoz.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Auto Scaling group'' szekciót és válasszuk ki a ''Launch Configuration'' menüpontot. A jobb felső sarokban található ''Create launch configuration'' gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''Név megadása''', aminek segítségével később hivatkozhatunk erre az elemre. Kitöltése kötelező! 
[[Fájl:GAMFAWS ec2 launch conf setup name.png]]

''AMI kiválasztása'', tehát azok képfájl megadása, amit a kiválasztott EC2 konfiguráció futtatni fog. Lehetőségünk van a saját készítésű (''My AMIs'') és a közösségi képfájlok közül választani (''Marketplace''). 
[[Fájl:GAMFAWS ec2 launch conf setup ami.png]]

'''Instance típus''' alatt megadhatjuk, hogy a konfiguráció milyen teljesítményű legyen.
'''Ne feledjük el, hogy a t2.micro az ingyenes, a többi használata után fizetési kötelezettségünk jelenhet meg.'''
[[Fájl:GAMFAWS ec2 launch conf setup instance type.png]]

'''Az Additional configruation''' részben megadhatunk különböző paramétereket, amelyeket az EC2 fog felvenni - pl. mindenképp kapjon IP címet, a subnet beállításaitól függetlenül, vagy éppen ne kapjon; itt adhatjuk meg a telepítéskor lefuttatott scripteket (User data).

'''A Storage''' szekcióban megadhatjuk, hogy milyen lemezek és milyen méretűek legyenek a rendszerhez csatolva.

'''A Security Group''' részben kiválaszthatunk egy már meglévő szabályrendszert, vagy készíthetünk újat. 
[[Fájl:GAMFAWS ec2 launch conf setup secg.png]]

'''A Key pairs''' blokkban megadhatjuk, hogy milyen privát kulccsal léphetnek be a szerverekre. Ennek meglétét jóvá kell hagyni az alul található checkbox-szal. 
[[Fájl:GAMFAWS ec2 launch conf setup keypair.png]]

'''Végül kattintsunk a ''Create launch confgiration'' gombra a létrehozáshoz.'''

===== Launch template =====
A Launch template jóval gazdagabb a beállítási lehetőségekben, mint párja. A konfigurációs adatlap tartalmaz segédletet az AutoScaling Group-pal történő használathoz, amely ''required'', azaz kötelező mezőként jelöli meg azokat az adatbeviteli elemeket, amelyeket az automata skálázó rendszer használ. Érdemes ezt bekapcsolni, amennyiben ilyen célzattal készítjük el a sablonunkat.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Instances'' szekciót és válasszuk ki a ''Launch template'' menüpontot. Az oldal közepén vagy a jobb felső sarokban található Create launch configuration gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''A sablon neve és leírása''' blokkban megadhatjuk a nevet és a leírást, de ugyanakkor itt választhatjuk ki azt a checkboxot is, ami később a segítségünkre lesz a konfigurációs sablon AutoScaling Group-hoz való illesztését is (''Auto Scaling guidence''). 
[[Fájl:GAMFAWS ec2 launch templ setup name.png]]

'''Az Application and OS images''' szekcióban megadhatjuk, hogy milyen AMI-val települjön az EC2. Itt választhatunk a sajátunkból, vagy az EC2-nél is megtalálható egyebekből. 
[[Fájl:GAMFAWS ec2 launch templ setup ami.png]]

'''Az Instance type''' csoportban megadhatjuk, hogy milyen teljesítményű gépet szeretnénk indítani.
'''Ne feledjük el, hogy az ingyenes változatban a t2.micro érhető el, másik lehetőség választása esetén fizetési kötelezettségek léphetnek fel!''' 
[[Fájl:GAMFAWS ec2 launch templ setup instancetype.png]]

'''A Key Pair''' blokkban megadhatjuk, hogy a gépek milyen kulcspárral engedélyezzék a belépést. 
[[Fájl:GAMFAWS ec2 launch templ setup key pair.png]]

'''A Network Confguration''' részben definiálhatjuk, hogy milyen VPC-be szeretnénk lerakni az EC2-ket, milyen security group legyen rajtuk. Természetesen utóbbi helyben is létrehozható, ha korábban ezt nem készítettük volna el. 
[[Fájl:GAMFAWS ec2 launch templ setup network.png]]

'''A Storage'''-nél megadhatjuk, hogy milyen kötetek, milyen méretben legyenek hozzácsatolva a rendszerhez.

'''A Tags''' blokkban felvehetjük a kívánt ''kulcs=érték'' párokat.

'''Az Additional Configuration''' szekcióban különböző haladó beállításokat eszközölhetünk a sablon által létrehozott EC2-n, többet között itt adhatjuk meg az indításkor lefuttatandó parancsok listáját (''User data'').

'''Végül kattintsunk a Create launch template nyomógombra a mentéshez!'''.

==== Target Group ====
A target group EC2-k azon csoportja, amelyeken valamilyen ''health check'' algoritmust futtatunk, ezzel meghatározva, hogy az adott csoportban hány használható, működő szerver fut. Ezt az információt elsőként a Load balancer használja ki.

A Target Group a bal oldali menüben, a ''Load Balancing'' szekcióban érhető el ''Target Groups'' néven.

Létrehozhatunk új csoportot, de meg kell adnunk, hogy milyen módon kerüljenek bele az EC2-k. Erre a következő metódusokat ajánlja fel az Amazon:
# Konkrét EC2 (Instance) kiválasztása
# EC2-k definiálása IP tartománnyal
# Lambda függvény hozzáadása
# Alkalmazás LoadBalancer, amely egy teljes VPC tartalmát magába foglalja.

Az űrlap alján megadhatjuk, hogy milyen életjel ellenőrzés történjen.

Általában nem mi vesszük fel egyesével az Instancokat ebbe a csoportba, hanem az AutoScaling group regisztrálja őket bele. '''Ezért ezt az űrlapot nem használjuk'''.

==== Load Balancer ====
A Load Balancer terheléselosztást jelent, tehát a bejövő forgalmat több gép között osztjuk el. Ezzel növekszik a felhasználói élmény, ráadásul a rendszer megállítása (egy hacker által) nehezebbé válik: ha kettő t2.micro teljesítményű szerver fut, amelyek között elosztjuk a bejövő forgalmat, akkor a rendszerünk valójában 2xt2.micro teljesítményű.

Terheléselosztót a bal oldali menü ''Load Balancing'' szekciójának ''Load Balancers'' menüpontjában hozhatunk létre.

'''A támogatott szolgáltatási szintek:'''
# Alkalmazás terheléselosztás (HTTP, HTTPS)
# Hálózati terheléselosztás (TCP, UDP)
# Átjáró terheléselosztása (GW)

===== Alkalmazás terheléselosztása =====
Ebben a formában konfigurálhatjuk az eszközt úgy, hogy az internet felől elérhető legyen (internet-facing) és úgy, hogy csak belső hálózaton működjön (internal). A belső hálózatot mindig az aktuális VPC-re kell érteni, tehát annak minden alhálózatából elérhető alapértelmezetten.
[[Fájl:GAMFAWS ec2 loadbalancer setup basic.png]]

A hálózati beállításoknál választhatunk, hogy mely alhálózatokban szeretnénk végrehajtani a terheléselosztást, így csak az azokban futó EC2-k kaphatnak ezen keresztül csomagokat. Arra kell ügyelnünk, hogy legalább kettő különböző zónában lévő alhálózatot kell kiválasztanunk (pl. eu-west-1a, eu-west-1b stb.).
[[Fájl:GAMFAWS ec2 loadbalancer setup network.png]]

Természetesen a LoadBalancer internetfelőli végpontján létrehozhatunk ''Security Group''okat, amelyet szabályozzák, hogy milyen IP címről fogadunk el csomagokat.
[[Fájl:GAMFAWS ec2 loadbalancer setup secg.png]]

A ''Listeners and routing'' résznél megadhatjuk, hogy melyik target group fogja a terhelést fogadni, tehát hogy mely EC2-k között tudunk ténylegesen terhelést elosztani. Amennyiben a target group egy darab EC2-t tartalmaz, akkor a terheléselosztás gyakorlatilag nem valósul meg, csak az elméleti esélyét adtuk meg, hogy ''„amennyiben lenne még egy EC2 a target group-ban, akkor a terhelés egy részét az vinné el”''.
[[Fájl:GAMFAWS ec2 loadbalancer setup routing.png]]

Végül kattintsunk a ''Create load balancer'' gombra, amennyiben a kívánt tag-eket is rögzítettük.

==== Auto Scaling Group ====
A szolgáltatás segítségével automatikusan skálázott rendszereket építhetünk ki, ahol a szerverek által nyújtott elérhető erőforrásokat minél közelebb tartja a bejövő terhelés által meghatározott erőforrásigényhez. Természetesen mindez akkor igaz, ha az ''Auto Scaling Group'' be regisztrálja az általa létrehozott ''EC2''-ket egy ''Target Group''-ba, ami felett ''Load Balancing'' van definiálva.

'''Előnyei''':
* Amikor nincs bejövő terhelés, akkor nincsenek nagy költségek
* Amikor nagy a bejövő terhelés, akkor a költségek megugranak ugyan, de az ügyfeleket ki tudtuk szolgálni úgy, hogy elégedettek voltak a rendszer teljesítményével.

'''Hátrányai''':
* Kaotikus számlák, nem előre tervezhető költségek
* Megnövekedett költségek DDoS és egyéb támadások esetén

===== A beállítás lépései =====
A szolgáltatást a bal oldali menü ''Auto Scaling Group'' szekciójában érjük el, az ''Auto Scaling Group'' menüpontban. A képernyő közepén vagy a képernyő jobb felső sarkában megjelenő ''Create auto scaling group'' gombra kattintva egy űrlap jelenik meg, ami végig vezet minket a telepítés lépésein.

'''A Name''' szekcióban elnevezzük az új group-ot.
[[Fájl:GAMFAWS ec2 autoscaling setup name.png]]

'''A következő szekcióban''' két választási lehetőségünk van:
* Launch Template-tel telepítjük az új group-ot, ez esetben csak ki kell választanunk a korábban létrehozott sablont, vagy az alatta található link segítségével készíthetünk újat. ''Amennyiben újat készítünk, a sablon létrehozása új ablakban nyílik meg, így a befejezést követően vissza kéne térnünk erre és a frissítést gombot megnyomva látni fogjuk az új lehetősége(ke)t.
[[Fájl:GAMFAWS ec2 autoscaling setup lt.png]]

* Launch Configuration-nel telepítjük az új group-ot, ez esetben át kell váltatnunk a ''Switch to launch configuration'' link segítségével a blokkot. A váltást követően hasonlóan az előzőekhez: vagy kiválasztjuk a már meglévő konfigurációs sémát, vagy hozhatunk létre újat.
[[Fájl:GAMFAWS ec2 autoscaling setup lc.png]]

'''A Next gombra kattintva a hálózati beállítások''' szekcióhoz érünk, ahol megadhatjuk, hogy az indított EC2 milyen VPC-be kerüljön és azon belül milyen alhálózatokba. VPC-ből egy, alhálózatból több is kiválasztható. Ügyeljünk rá, hogy ha később erre Load Balancer szolgáltatás is kerül, akkor legalább kettő zónát jelöljünk ki!
'''Figyelem!''' A zóna nem egyezik meg az alhálózattal!
[[Fájl:GAMFAWS ec2 autoscaling setup network.png]]

'''A Next gombra kattintva a Load Balancing beállítások''' következnek, ahol választhatunk:
* Nincs terheléselosztás opciót,
* Létező Load Balancer hozzáillesztését,
* Új Load Balancer létrehozását.

Utóbbi esetében a Load Balancer konfigurálásánál leírt módon ki kell töltenünk a Load Balancer űrlapját is helyben. 
[[Fájl:GAMFAWS ec2 autoscaling setup lb setup.png]]

Hasonlóan a ''Target Group''-ot is létrehozhatjuk helyben, amennyiben ezt nem tettük meg korábban.
[[Fájl:GAMFAWS ece autoscaling setup new lb new tg.png]]

'''A Next gombra kattintva a csoport méretét definiálhatjuk''', azaz megszabhatjuk, hogy hány darab szervertől, hány darab szerverig engedélyezzük az automatikus skálázást. Ez egy hasznos funkció, hiszen ezzel korlátok közé szoríthatjuk a költségeinket, miközben a legkisebb terhelés esetén is előkészülhetünk egy hirtelen bejövő nagyobb terhelésre (ha a minimum nem 1).
* Desired capacity: ennyi szervert fog elindítani az ASG mentés után
* Minimum capacity: ennyi szerver esetén már nem állít le semmit az ASG
* Maximum capacity: ennyi szerver esetén már nem indít el újabbat az ASG
[[Fájl:GAMFAWS ec2 autoscaling setup group.png]]

'''Alatta a Scaling Policy''' blokkban megadhatjuk, hogy milyen paraméterek mentén indítson vagy épp állítson le szervereket az ASG. Ehhez aktiválnunk kell a szolgáltatást és a ''Metric type'' listából ki kell választani az számunkra megfelelőt. Mi általában CPU terhelés alapján döntünk az órán.
[[Fájl:GAMFAWS ec2 autoscaling setup scaling.png]]

'''A Next gombokkal lépkedve hozhatunk létre Tag-eket, majd végül létrehozhatjuk az ASG-t is és az ''Instances'' menüpontban ellenőrizhetjük, hogy ténylegesen elindult a kívánt darabszámú szerver.'''

=== RDS szolgáltatások ===
A ''Relational Database Service'' foglalja magában a különböző adatbázisokat:
* MariaDB
* MySQL
* Aurora
* Oracle
* PostgreSQL
* MSSQL

'''Figyelem!''' Az itt felsorolt szerverek között lehetnek fizetősek is. Mindig járjunk el figyelmesen, kövessük a költségeket. Az RDS az amazon egyik legdrágább szolgáltatása.

==== MySQL adatbázis telepítése ====
==== Csatlakozás MySQL adatbázishoz CLI-ből ====
<syntaxhighlight lang="bash">
apt install mysql-client -y
# mysql -h<rds_endpoint> -u<rds_user> -p<rds_password>
mysql -hwebshop-989.rds.amazon.com -uadmin -p123456789
</syntaxhighlight>

A megnyíló '''mysql>''' PROMPT-ot tartalmazó sor azt jelenti, hogy sikeresen csatlakoztunk az SQL szerverhez. Amennyiben a csatlakozás sikertelen, akkor valószínűleg az RDS-hez kapcsolt Security Group beállításai nem engedik az EC2-ről a kapcsolódást - tipikusan a mi saját publikus IP címünk kerül bele az engedélyezett tartományba (pl. iskolai IP vagy otthoni) és ez nem került átírásra az amazonos tartománynak megfelelően.

A konzolra be kell illeszteni a ''networks.sql'' fájl tartalmát. A végén '''exit''' paranccsal léphetünk vissza a BASH környezetbe.

=== VPC ===
A '''V'''irtual '''P'''rivate '''C'''loud egy szolgáltatás, melynek segítségével össze köthetjük az összetartozó komponenseket, alkalmazásokat. A VPC-t modellezhetjük hétköznapibb értelemben, mint egy routert, amelynek vannak alhálózatai, route táblája és valamilyen gateway címe, amin keresztül a kliensei az internet más résztvevőivel tudnak kommunikálni.

A VPC szolgáltatásait a keresőbe írt ''VPC'' kulccsal érhetjük el.
==== VPC létrehozása ====
Navigáljunk a 'Your VPCs' menüpontra a bal oldali menüben és kattintsunk a jobb felső sarokban látható ''Create VPC' gombra. Ezután megnyílik egy űrlap, amely végig vezet minket a telepítés lépésein.

Az űrlap elején választhatunk, hogy ''VPC only'' vagy ''VPC and more'' módban szeretnénk folytatni. Előbbi csak a VPC-t hozza létre nevéből is adódóan, míg a másik opcióval létrehozhatjuk az alhálózatokat is, igaz, a tervezés szabadságáról le kell ilyenkor mondanunk, cserébe grafikán láthatjuk az eredményt. Számunkra az órán utóbbi nem lesz megfelelő, hiszen szükségünk lesz a ''tervezés szabadságára''. 
[[Fájl:GAMFAWS vpc setup.png]]

A VPC beállításainál mindig a teljes hálózatot átfogó IP/MASZK párost kell megadnunk, később az alhálózatok nem lóghatnak ki az itt megadott tartományból.

==== Alhálózatok ====
Az alhálózatok lehetőséget biztosítanak arra, hogy az egyes komponenseket el is szigeteljük egymástól, meg engedélyezzünk is közöttük bizonyos kommunikációt.

Alhálózatok típusai:
* Publikus: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten kapnak publikus IP címet
* Privát: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten nem kapnak publikus IP címet

===== Alhálózatok létrehozása =====
Navigáljunk a ''Subnets'' menüpontra. A képernyő jobb felső sarkában kattintsunk a ''Create subnet'' gombra, így megkapjuk a létrehozási űrlapot.

'''Először''' a VPC-t kell kiválasztanunk, aminek eredményeképp kiírja segítségképp annak tartományát. Ezen a tartományon kívül nem léphetünk. 
[[Fájl:GAMFAWS vpc subnet setup.png]]

A VPC kiválasztása után aktívvá válik az alhálózatok űrlap, ahol megadhatjuk annak nevét, hálózati címét és maszkját. 
[[Fájl:GAMFAWS vpc subnet setup new.png]]

'''Figyelem!''' A rendszer csak hálózati címet fogad el! Minden más esetben hibát ír ki.

A ''Remove'' gombbal eltávolíthatjuk az aktuális konfigurációt a listából, míg a lentebb található ''Add new subnet'' segítségével újabbat vehetünk fel.

Befejezésül nyomjuk meg a ''Create subnet'' gombot, így az összes definiált alhálózat létrejön a kiválasztott VPC-hez.

===== Publikus/Privát alhálózat beállítása =====
Az alhálózat típusának átállításához navigáljunk a ''Subnets'' menüpontra. Kattintsunk jobb gombbal a kívánt alhálózat során és válasszuk ki az ''Edit subnet settings'' opciót. 
[[Fájl:GAMFAWS vpc subnet edit s settings.png]]

Az űrlapon keressük meg az ''Auto-assign IP settings'' blokkot és a kívánt típusnak megfelelően módosítsuk azt.
[[Fájl:GAMFAWS vpc subnet edit type.png]]

===== Különböző route tábla minden alhálózaton =====
A VPC támogatja, hogy minden subnet saját route táblával rendelkezzen. Ez lehet akár egy biztonsági funkció is, hogy ne ismerje minden EC2 az útvonalat egy adott szerverhez, de egyes esetekben kötelezően létre kell hoznunk. A route táblákat a ''Route tables'' menüpontban hozhatjuk létre és a ''Subnets'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Edit route table association'' opciót kiválasztva szerkeszthetjük.

'''Figyelem!''' A route táblák cseréje okozhat internetelérési problémákat szerver oldalon, aminek következtében a futó szolgáltatások számunkra is elérhetetlenekké válnak (pl. SSH és/vagy HTTP/HTTPS stb.), így legyünk körültekintőek.

==== Internet Gateway ====
Ahhoz, hogy a VPC-n belül legyen internet, ahhoz egy IGW-t kell hozzá csatolnunk. Ezt megelőzően azonban létre kell hoznunk egyet.
'''Figyelem!''' A VPC-hez nem kapcsolt IGW-k pénzbe kerülhetnek, mivel feleslegesen foglalnak le egy publikus IPv4 címet.

[[Fájl:GAMFAWS vpc igw setup.png|bélyegkép|Internet Gateway létrehozás]]
Az IGW az ''Internet Gateways'' menüpont alatt érhető el és a jobb felső sarokban található ''Create internet gateway'' gombbal hozhatunk létre újat. Csupán egy nevet kell megadnunk, illetve rakhatunk rá tag-eket igény szerint.

A létrehozást követően hozzá kell rendelnünk egy létező VPC-hez, amit az ''Internet Gateways'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Attach to VPC'' opciót kiválasztva tudunk megtenni. Amennyiben a soron az ''Attached'' (zöld színű) felirat jelenik meg a (szürke színű) ''Detached'' helyett, akkor nem tudjuk VPC-hez csatolni (ilyenkor először a ''Detach from VPC'' opciót kell választanunk). 
[[Fájl:GAMFAWS vpc igw attach.png]]

Az IGW VPC-hez rendelése után a kívánt route táblákba fel kell vennünk, hogy minden csomagot arra irányítson.
[[Fájl:GAMFAWS vpc igw route setup.png]]

==== NAT Gateway ====
Lehetőség van Internet Gateway helyett NAT Gateway létrehozására is, de ez egy fizetős szolgáltatás. A nevének megfelelően ez lehetőséget biztosít, hogy azok az EC2-k, amelyek privát alhálózatba kerültek, kilássanak az internet felé (pl. frissítések keresése, telepítése), miközben védve vannak a kívülről érkező támadásoktól.
'''Ez egy lehetséges oka lehet, hogy külön válasszuk a route táblákat az alhálózatokon, hiszen az egyiknek minden csomagot az IGW felé, míg a másiknak minden csomagot a NAT Gateway felé kell továbbítania.''' ''Ha nem használunk NAT Gatewayt, akkor is érdemes lehet leválasztani az IGW-ről a privát alhálózatokat.''

=== AWSCLI ===
Az AWSCLI egy konzolos alkalmazás, amelynek segítségével menedzselhetjük környezetünket: hozhatunk létre új EC2-t akár, vagy kapcsolhatunk hozzá egyéb szolgáltatásokat (Security Group, ASG, LB stb.).

Az awscli program elérhető linux és windows környezetben egyaránt.

==== AWSCLI telepítése ====
'''Figyelem!''' Az ''apt install awscli'' a legtöbb Debian/Ubuntu rendszeren a régebbi, 1-es főverziójú AWS CLI-t telepíti a disztribúció saját tárolójából, amit az AWS már csak fenntartási (maintenance) módban frissít. Az AWS hivatalosan a 2-es főverzió telepítését ajánlja, amit a következő paranccsal tehetünk meg:
<syntaxhighlight lang="bash">
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
</syntaxhighlight>
Órai/gyakorlási célra az ''apt install awscli'' is elegendő lehet, de érdemes tudni, hogy nem ez a hivatalosan ajánlott telepítési mód.
==== Access Key management ====
Az ''awscli'' hozzáférési kulcsokon keresztül kap jogosultságot a szolgáltatások adataihoz, így használata előtt készítenünk kell egy újat. Ez a nevünkre kattintva (jobb felül), majd a ''Security credentials'' menüpontot kiválasztva tehetjük meg, az ''Access keys'' szekcióban. Nyissuk ezt le és kattintsunk a ''Create New Access Key'' gombra. 
<center>
{|
| [[Fájl:GAMFAWS UserMenu.png|150px|keretnélküli]] || [[Fájl:GAMFAWS SecurityCredentials.png|keretnélküli]]
|}
</center>

A gomb megnyomása után egy felugró ablak fogad, amelyben megtalálható az ''Access Key'' és a ''Security Access Key'' értéke. Érdemes a fájlt letölteni, hogy később is elérhetők legyenek ezek az adatok, '''az AWS többet nem fogja engedélyezni ezek megjelenítését!''' Ha az adatokat később nem tudjuk megadni, akkor újat kell készíteni.
[[Fájl:GAMFAWS SecurityCredentials ShowData.png|középre]]

==== AWS CLI konfigurálás autentikációs adatokkal ====
Az eszköz telepítése annak konfigurálásával ér véget: meg kell adnunk az autentikációs tokeneket. 
Ezt az '''aws configure''' parancs kiadásával tehetjük meg, ahol egyesével bekéri a szükséges adatokat. Ahol nem szeretnénk változtatni az előző értéken (szögletes zárójelek között láthatjuk ezt), ott hagyjuk üresen a sort és csupán entert nyomjunk.
[[Fájl:GAMFAWS AWSCLI config.png|középre]]

Az adatok megadása után menedzselhetjük az aws parancsokkal a környezetünket. Az aws parancsairól az '''aws help''' szolgáltat információt.

=== S3 ===
Ez a szolgáltatás fájlok tárolására alkalmas.

Több típusa is elérhető:
* Standard:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban sűrűn használt objektumok tárolására alkalmas
** A régiók közötti szinkronizáció megoldott
* Instant Glacier:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban ritkábban használt, hosszú élettartamú, de azonnali hozzáférést igénylő objektumok tárolására alkalmas
* Flexible Glacier:
** Magas rendelkezésre állás jellemzi
** Az alkalmazásban ritkán használt (évente 1x-2x), a mérettől független költséggel rendelkező megoldás
* Deep Archive Glacier:
** 7-10 évig tárolt adatokhoz optimalizált költségvonzat
** Előnyös a backup adatok tárolásához

A szolgáltatás a keresőben ''S3'' füzérrel kereshető.

==== Bucket létrehozása ====
Új tárolót a ''Create bucket'' gomb segítségével hozhatunk létre. A megjelenő űrlapon a nevet kell kitölteni és érdemes egy pillantást vetni a publikusság beállításaira is, hogy ez ténylegesen a célunknak megfelelő legyen.

'''Figyelem!''' A névnek nem csupán a mi környezetünkön belül kell egyedinek lennie, hanem a teljes AWS-en belül.

{| style="margin:auto"
| [[Fájl:GAMFAWS S3 new name.png|bélyegkép]] || [[Fájl:GAMFAWS S3 new public.png|bélyegkép]]
|}

==== Bucket kezelése ''awscli'' programmal ====
Az '''aws s3 help''' parancs segítségével további információt szerezhetünk az egyes utasításokról.

'''Bucket tartalmának listázása''' 
<syntaxhighlight lang="bash">
aws s3 ls [bucket_name]
</syntaxhighlight>
[[Fájl:GAMFAWS S3 CLI LS.png|középre]]

'''Adatok másolása Bucket-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* LOCAL_PATH a lokális fájlrendszeren belüli elérési útvonala a forrásfájlnak (vagy könyvtárnak)
* REMOTE_PATH a cél helye az S3-ban
** Az s3:// jelzi, hogy a cél az S3-ban van (S3Uri)
** A mappák helyett PREFIX-ek vannak (/folder/to/my/file esetében /folder/to/my a PREFIX)
** A mappákat nem kell S3-ban létrehoznunk (az előző pontból következik), a fájlnév előtti prefix dönti el a hova tartozását
** A PREFIX-eket az '''ls''' úgy kezeli, mint egy mappát
[[Fájl:GAMFAWS S3 AWSCLI cp2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* --recursive jelzi, hogy a LOCAL_PATH alatt minden bejegyzést töltsön fel
[[Fájl:GAMFAWS S3 AWSCLI copy recursive2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ból helyi fájlrendszerbe''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive s3://REMOTE_PATH LOCAL_PATH
</syntaxhighlight>
[[Fájl:GAMFAWS S3 AWSCLI cp2local.png|középre]]

==== Bucket kezelése grafikus felületen keresztül ====
Az S3 tartalmát elérhetjük az AWS grafikus felületén keresztül is, így tölthetünk fel, törölhetünk és módosíthatunk fájlokat anélkül, hogy saját számítógépünkre telepítenénk az ''awscli'' programot.

# Nyissuk meg az S3 szolgáltatás vezérlőpultját
# Kattintsunk a szerkeszteni kívánt tárhely nevére [[Fájl:GAMFAWS S3f list.png]] 
# A vezérlőgombok segítségével végezzük el a kívánt műveletet (feltöltés, törlés), vagy válasszunk ki egy PREFIX-et az „almappák” tartalmának megtekintéséhez. [[Fájl:GAMFAWS S3 control.png|középre]]

= Alkalmazások telepítése =
== UI ==
== API ==

= Indítást gyorsító scriptek =
== UI indítás ==
<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun code
API_LB_DOMAIN="localhost" # api server IP

apt update
apt install wget unzip apache2 libapache2-mod-php8.3 php8.3 php8.3-curl -y

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui.php
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui_newproduct.php
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv ui.php /srv/$NEPTUN/index.php
mv ui_newproduct.php /srv/$NEPTUN/newproduct.php

# remove tmp directory
cd /
rm /tmp/code

cat << EOF > /etc/apache2/sites-enabled/000-default.conf
<VirtualHost *:80>
#ServerName www.example.com

ServerAdmin webmaster@localhost
DocumentRoot /srv/$NEPTUN

<Directory /srv/$NEPTUN/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>

ErrorLog \${APACHE_LOG_DIR}/error.log
CustomLog \${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

systemctl restart apache2
</syntaxhighlight>

== API indítás ==

<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun
MYSQL_DOMAIN="localhost" # RDS mysql domain

apt update
apt install wget unzip python3 python3-pip python3-flask -y
pip3 install mysql-connector-python --break-system-packages

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$MYSQL_DOMAIN/g" api.py
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv api.py /srv/$NEPTUN/

# remove tmp directory
cd /
rm /tmp/code

echo "@reboot root sleep 10s && python3 /srv/$NEPTUN/api.py &" >> /etc/crontab
cd /srv/$NEPTUN && python3 api.py &
‎</syntaxhighlight>

EDU::GAMF::Felhőalapú-szolgáltatások::Docker

2026-09-14T07:46:50Z

ApelPro: Hibás apt install docker.io docker parancs javítva; hibás CMD ["-D FOREGROUND"] példa magyarázó figyelmeztetéssel kiegészítve; 777-es jogosultság megjegyzéssel; apró elgépelések

== Mi az a Docker? ==
A Docker a konténer technológiák egyike. A konténerek és a virtuális gépek rokonságban állnak egymással, de mégis nagy különbség van közöttük: a konténerek pehelykönnyűek.

'''De hogyan válik egy virtuális gép pehelykönnyűvé?'''
A válasz az, hogy Docker esetében nincs hardvervirtualizáció, így kisebb az erőforrásigénye - nem kell az eszközökre "memory map"-ot létrehozni a felmerülő biztonsági problémák kezelésére és nem kell minden hozzáférésnél azokat forwardolni - és a benne futó operációs rendszerek is a lehető legminimálisabb konfigurációval rendelkeznek.

'''Tekintsük meg egy virtuális gép szintjeit''' (lásd: [https://www.researchgate.net/figure/Virtual-Machine-underlying-layers_fig1_344208115 VM szintek]):
# A fizikai vas szintje fölé telepítünk valamilyen hypervisort, azaz virtualizációs környezetet
#* itt jön létre az említett "memory map"
#* a virtuális gépek az itt beállított hardverkörnyezetet fogják látni, ami akár fals információ is lehet, eltérhet a valóságtól (kompatibilitások miatt szokás átverni a felsőbb szinteket)
# A Virtualizált OS szintje, saját kernellel és driverekkel
# A virtuális gépben telepített alkalmazások szintje

'''Ezzel szemben tekintsük meg a Docker szintjeit''' (lásd: [https://www.researchgate.net/figure/Container-underlying-layers_fig2_344208115 Docker szintek] vagy [https://www.researchgate.net/figure/Comparison-of-Docker-Container-and-Virtual-Machine-Architecture-13_fig1_343764931 VM vs Docker]
# A fizikai vas szintje fölé telepítjük a HOST operációs rendszert, ami többnyire valamilyen linux alapú operációs rendszer
# Az operációs rendszeren telepítünk egy konténerizációs alkalmazást (esetünkben ''docker daemon''-t)
# Az elindított konténerek a telepített konténerizációs alkalmazással kommunikálnak számukra ez az API a HOST operációs rendszere felé.

Végső soron '''a nagy különbséget az jelenti''', hogy a konténerek esetén a kernelt nem virtualizáljuk, hanem felhasználjuk a HOST operációs rendszerét, így mindent, ami az alatti szinten található ki vehetjük a virtuális környezet menedzseléséből.

==== Egyéb konténer technológiák ====
Szerencsés megjegyezni, hogy bár a piac nagy részét jelenleg a Docker birtokolja a konténerek világában, azért nem nevezhetjük egyeduralkodónak. Vannak egyéb fejlesztések is, amelyek bizonyos esetekben célravezetőbbek lehetnek, bár ezek felhasználási területei jóval szegényesebbek.

A teljesség igénye nélkül egy pár nevesebb (a többit lásd: [https://www.containiq.com/post/docker-alternatives Docker alternatívák 2022-ben]):
* LXC / LXD, azaz Linux Container, amelyet többet között a Proxmox is támogat (a proxmox egy ESXi-hez hasonló virtuális gép vezérlő operációs rendszer, amelyet a VPS szolgáltatók (is) használnak).
* Podman
* RunC
* Containerd

Érdemes tájékozódni, mielőtt egy technológiát ténylegesen ajánlatba adunk, gyorsan fejlődik az iparág, így könnyedén jelenhetnek meg újabb szereplők is, akik lesöprik a megszokott dolgokat!

=== Docker felhasználási területei ===
A docker mára annyira kinőtte magát, hogy a legtöbb cég az alkalmazásait ilyen környezetben telepíti, ezzel ténylegesen időt spórolva magának.

'''Hogyan spórolhat időt egy olyan technológia, ami újabb üzemeltetési kérdéseket vet fel?'''
Képzeljünk el egy olyan szervert, amely 5db weboldalt futtat, azaz 5 különböző virtual host létezik rajta. Az egyik nginx alatt fut, a másik nodejs, a harmadik php7-es verzióval, a negyedik php8-as verzióval fut és még nem is említettük, hogy adatokat is szeretnénk tárolni mssql, mysql, postgresql esetleg sqlite adatbázisokban, akármilyen kombinációban. Érezzük, hogy ennek a szervernek az üzemeltetése nem kis feladat, de ha csak a különböző verziót igénylő PHP-s weboldalakat szeretnénk egy szerveren elhelyezni, azzal is rendkívül érdekes feladatokba ütközhetünk (természetesen lehetséges és meg van rá a bejáratott módszer, hiszen ez a docker előtt is probléma volt).
Ha ezt tekintjük és ezzel állítjuk szembe azt a többlet feladatot, hogy a docker daemon-t is üzemeltetni, frissíteni kell, akkor már nem is tűnik rossz ötletnek: ha egy-egy alkalmazás külön-külön konténerekbe kerülne, akkor nem kellene sem az egy szerveren futtatott többféle verzió problémájával, sem a különböző adatbázis szükségletekkel, sem a különböző webszerver szükségletekkel foglalkoznunk, gyakorlatilag mindenki olyan technológiát használ, amilyet szeretne és úgy frissíti a konténeren belül azokat, amilyen ütemben szeretné, a többire nem lesz hatással.

'''Mi a helyzet a konténerek okozta többlet teljesítmény szükséglettel?'''
A korábbi fejezetben tárgyaltak alapján a konténer nem fogyaszt sokat, így az overhead rendkívül kicsi. Természetesen van némi többlet CPU idő, memória és tárhely felhasználás - ha csak azt vesszük, hogy egyetlen SQL szerver helyett minden konténerbe külön fel lesz telepítve, így töbszörösen tároljuk a szerver konfigurációs állományait stb.), de mindez manapság bőven ellensúlyozható viszonylag alacsony költségen: nem okoz akkora költség többletet, mint amekkora veszteséget okozna egy frissítést követően összeomlott vegyes rendszer, tehát mondhatjuk, hogy bár teljesítmény vesztés jelentkezik, azt mégis megéri bevállalni az előnyei miatt (a virtuális gépet ugyanerre a célra például nem érte meg bevetni).

Az üzemeltetés gyorsításán túl '''használják felhő kialakítására is''', hiszen a daemon-ba épített '''swarm'''-nak köszönhetően automatikusan skálázhatunk dockereket akár több szerveren is, amik ráadásul pár másodperc alatt elérhetővé válnak, így a bootolási időt is megspóroljuk.
Hozzá kell tenni, hogy a ''swarm''-nál manapság létezik jobb és barátságosabb ''orchestrator'' is, pl.: Kubernetes.

'''Nem csak az üzemeltetést könnyíti meg vagy javítja a rendelkezésreállást, hanem a fejlesztési időn is javít'''.
Természetesen ne gondoljunk olyanokra, hogy a programot helyettünk lefejleszti egy konténer, de azzal nagyon sokat nyerünk, hogy ha egy konténerben lefejlesztünk valamit és működik, akkor a konténert egy másik gépre másolva is működni fog, függetlenül attól, hogy esetleg platformot váltottunk (windows->linux vagy fordítva), hogy verziót váltottunk vagy hogy milyen csomagok érhetők el a cél szerveren. Ezek a kérdések sok esetben plusz fejlesztési időt jelentenek, hogy valamelyest dinamikus legyen.

''Sandboxing'' megoldások körében is előkerül a docker. Ez azt jelenti, hogy egy alkalmazást először egy konténerben próbálnak ki és ha úgy gondolják, akkor telepítik az éles rendszerbe is. Ha úgy alakul, hogy nincs rá szükség, akkor a konténerrel együtt elveszik minden módosítás is, tehát a tárhely 100%-ban visszanyerhető. Legyünk azért ezzel is óvatosak, egy virtuális gép alkalmazás tesztelésre sokkal jobb lehetőséget biztosít, sokkal mélyebben szétválik a két rendszer egymástól. Docker esetében például egy kernel sebezhetőséggel konténeren belülről is vissza lehet élni és ne feledkezzünk meg a ''docker daemon'' hibáiról sem.

=== Docker registry ===
Ez a szolgáltatás tárolja az elérhető képfájlokat. A docker egyéb információ hiányában a [https://docker.com docker.com] webhelyre feltöltött fájlok között keres és innen tölti le a találatokat, de telepíthetünk sajátot is (erről később lesz szó).

A docker.com-ra a regisztráció ingyenes, egy privát projektet hozhatunk létre és bármennyit publikusan. Ez magában foglalja a veszélyt is: bárki feltölthet például egy webszervert, amelyben kiskapuk vannak stb.
'''Mindig ügyeljünk rá, hogy megbízható helyről származzon, amit letöltünk!'''

== Docker Telepítése ==
A futáshoz telepítenünk kell a ''docker daemon''-t, amit a következő paranccsal tehetünk meg: 
<syntaxhighlight lang="bash">
apt update && apt install docker.io -y
</syntaxhighlight>

'''Figyelem!''' Ne próbáljunk meg egy önálló ''docker'' csomagot is telepíteni a ''docker.io'' mellé - Debian/Ubuntu alatt nem ez a konténerizációs Dockert jelenti (a névütközés miatt kapta annak idején a csomag a ''docker.io'' nevet), hanem egy azzal semmilyen kapcsolatban nem álló, régi segédprogramot, így egy ''apt install docker.io docker'' parancs hibára fut vagy felesleges csomagot telepít.

''Éles / production környezetben érdemes lehet a Docker hivatalos apt tárolóját használni ''docker.io'' helyett, mert abban naprakészebb (Docker CE) verzió érhető el: lásd a [https://docs.docker.com/engine/install/ubuntu/ hivatalos telepítési útmutatót].''

== Docker konténerek indítása ==
Az elérhető konténerek között kereshetünk az ''ubuntu'' karakterláncra a következő paranccsal:
<syntaxhighlight lang="bash">
docker search ubuntu
</syntaxhighlight>

A kimeneten láthatjuk, hogy mely csomagnak milyen a megítélése, biztonságos forrásból származik-e stb.

A képfájlok neve a következőképp épül fel: '''[registry_server]/namespace/name[:tags]'''
* A ''registry_server'' a ''docker search'' kimenetében nem látszik, mivel ebben az esetben fixen a ''docker.com'' oldalon keresünk.
* A ''namespace''-re láthatunk példát
* Amennyiben nincs benne /-jel, akkor csak a nevét adtuk meg namespace és szerver nélkül
* Kettőspont után adhatunk hozzá tag-et (egyet, de általában kötőjellel választjuk el, ha többet is szeretnénk mégis). Ha nem írunk tag-et egy image után, akkor a docker úgy veszi, hogy a '''latest''' nevűt akarjuk használni, tehát ezt nem kell kiírni. Minden más esetben igen.

Mivel az ''ubuntu''-ra volt találat, így indítsunk el egy konténert belőle:
<syntaxhighlight lang="bash">
docker run ubuntu
</syntaxhighlight>

Ha a fenti parancsot lefuttatjuk, akkor nem fogunk tapasztalni semmit, igazán csak azt látjuk, hogy a daemon úgy döntött, hogy ez az image nálunk nem elérhető, így letöltötte és egyébként futtatta is, de a végén ugyanúgy a HOST OS-ben találjuk magunkat. Ez nem hiba, rosszul paramétereztük a rendszerünket.

Most indítsuk el a következő paranccsal:
<syntaxhighlight lang="bash">
docker run -ti ubuntu
</syntaxhighlight>

-t => pseudo-tty hozzárendelése
-i => interaktív, tehát tudunk kommunikálni a dockerrel
Ebben az esetben kapunk egy újszerű PROMPT-ot, tehát most tényleg a konténerben vagyunk, azt tudjuk konfigurálni. '''exit''' paranccsal be tudjuk ezt a terminált zárni.

Miután vissza kaptuk a HOST OS terminálját futtassuk le az alábbi parancsot, ahol azt tapasztaljuk, hogy egyetlen konténer sem fut:
<syntaxhighlight lang="bash">
docker ps
</syntaxhighlight>

A '''ps''' kilistázza a futó konténereket és azok főbb tulajdonságait - pl. mi a neve, milyen portokat engedélyeztünk rajta, melyik image-ből indult ki stb.

A konténer leállását az okozza, hogy az ''exit'' parancsra a ''bash'' program kilép és az ''ubuntu'' ennek a leállását várja: addig fut a konténer, amíg a ''bash'' is fut. Amikor az leállt, akkor a docker-nek már nem volt egyéb feladata, így leállt. '''Erre mindig oda kell majd figyelnünk, hogy amivel elindítjuk a konténert, az folyamatosan fusson benne, hogy a konténerünk működésben maradjon'''.

A fenti problémát feloldhatjuk azzal, ha daemonizáljuk a konténert - azaz a háttérben indítjuk el:
<syntaxhighlight lang="bash">
docker run -d ubuntu
</syntaxhighlight>

Ez esetben azonban nem kaptunk PROMPT-ot sem, bár a ''docker ps'' parancs mutatja, hogy fut.
Szerezzünk terminált a futó konténerhez:
<syntaxhighlight lang="bash">
docker exec -ti <a ''docker ps'' által kiírt container_id> bash
</syntaxhighlight>

Az ''exec'' segítségével új feladatot adhatunk a konténernek, ami természetesen az előző mellett, párhuzamosan fog futni. Ha a program, amit futtatunk egy SHELL, pl. ''bash'', akkor kapunk egy konzolt a konténerben. (-ti jelentése ugyanaz, mint korábban).

== Docker konténerek leállítása ==
# A ''docker ps'' parancsot futtatva kinyerhetjük a futó konténer ID-ját
# Futtassuk a ''docker kill <container_id> <container_id2> <container_id3>'' parancsot a kívánt konténerek erőszakos kilövéséhez vagy a ''docker stop <container_id> <container_id2> <container_id3>'' parancsot a normál leállításhoz.

== Docker konténerek menedzselése ==
A rendszerben futó konténereket kilistázhatjuk a következő paranccsal:
<syntaxhighlight lang="bash">
docker container ls
</syntaxhighlight>

A rendszerben egyszer elindított (nem feltétlen futó) konténereket listázhatjuk a következő paranccsal:
<syntaxhighlight lang="bash">
docker container ls -a
</syntaxhighlight>

A nem futó konténereket letörölhetjük egyesével megnevezve a következő paranccsal:
<syntaxhighlight lang="bash">
docker container rm <container_id> <container_id2> <container_idN>
</syntaxhighlight>

A nem futó konténereket letörölhetjük egy paranccsal:
<syntaxhighlight lang="bash">
docker container prune
</syntaxhighlight>

== Docker képfájlok menedzselése ==
A helyi gyűjtőbe mentett képfájlokat a következő paranccsal listázhatjuk:
<syntaxhighlight lang="bash">
docker image ls
</syntaxhighlight>

A nem használt képfájlokat letörölhetjük egyesével megnevezve a következő paranccsal:
<syntaxhighlight lang="bash">
docker image rm <image_id> <image_id> <image_id>
</syntaxhighlight>

A nem használt képfájlokat letörölhetjük egy paranccsal:
<syntaxhighlight lang="bash">
docker image prune
</syntaxhighlight>

== Docker image készítése ==
=== Konténerből ===
Először is indítsunk el egy konténert a kiválasztott képfájlból (pl. ubuntu)!
<syntaxhighlight lang="bash">
docker run -ti ubuntu
</syntaxhighlight>
Ezzel kapnunk kell egy terminált, aminek a PROMPT-ja nem hasonlít a HOST OS-ére, legyünk körültekintőek, hogy hol futtatjuk a következő parancsokat: a konténeren belül legyünk!

Frissítsük le a csomaglistát és telepítsük fel az apache2 programot, hogy legyen webes alkalmazásunk!
<syntaxhighlight lang="bash">
apt update && apt install apache2 -y
exit
</syntaxhighlight>
Miután feltelepült, ki is lépünk az '''exit''' paranccsal. Emlékezzünk, hogy ezzel a konténerünk leállt!

Keressük ki az előbb létrehozott konténer ID-ját (a ''docker ps'' csak a futó konténereket listázza)
<syntaxhighlight lang="bash">
docker container ls -a
</syntaxhighlight>
A leállítás óta eltelt időnél a legkisebb értéket jegyző konténer lesz az, amit most állítottunk le, amennyiben többet is listázott és nem ismerjük fel.

Mentsük a konténeren történt változásokat egy új képfájlba:
<syntaxhighlight lang="bash">
# docker commit <container_id> <name>:<tag>
docker commit <container_id> ubuntu:apache2
</syntaxhighlight>

Ellenőrizzük, hogy létrejött-e az új képfájl:
<syntaxhighlight lang="bash">
docker image ls
</syntaxhighlight>
Itt látszódnia kell egy ubuntu:apache2 sornak. Ügyeljünk rá, hogy a név és a tag ez esetben tabulátorral vannak elválasztva, nem kettősponttal, hiszen táblázatos formában jelenik meg.

Végül próbáljuk ki, hogy ténylegesen a mentett állapot fogad-e minket, ha az új konténer indítjuk el:
<syntaxhighlight lang="bash">
docker run -ti ubuntu:apache2 bash
</syntaxhighlight>
A konténer terminálját megnyitva teszteljük le, hogy létezik-e például az apache2ctl nevű parancs:
<syntaxhighlight lang="bash">
which apache2ctl
</syntaxhighlight>
Ha ezutóbbi parancs ír ki valamit, akkor jó eséllyel telepítve van a konténerben.

Ahhoz, hogy ténylegesen működjön az alkalmazásunk, ahhoz jelezni kell, hogy a konténerben a 80-as porton van egy szolgáltatásunk. Ez a ''docker daemon'' felé nyújtott információ, így lesz lehetőségünk rá forgalmat küldeni, ha szeretnénk. Természetesen amíg nem engedélyezzük, addig nem fogja elérni senki.
A következő paranccsal futtathatjuk úgy, hogy a HOST gép IP-jével hivatkozva (saját gépen localhost, egyébként a szerver IP-je) betöltsön a konténeren belüli alkalmazás:
<syntaxhighlight lang="bash">
docker run -d --expose 80 -p 80:80 ubuntu:apache2 apache2ctl -D FOREGROUND
</syntaxhighlight>
Az ''--expose 80'' üzeni a ''docker daemon'' felé, hogy ez a konténer kommunikálhat a 80-as porton keresztül a HOST OS felé. 
A ''-p 80:80'' jelzi, hogy a HOST OS 80-as portját át irányítjuk az ubuntu:apache2 képfájlból készített konténer 80-as portjára. Sablon: '''"<host_ip>:<host_port>:<container_port>"''', ahol a host_ip lehet 127.0.0.1 => csak a localhostról érhető el a portforward (proxy esetén javasolt, hogy kívülről ne lehessen elérni a konténert direktben), lehet a szerver IP címei közül bármelyik megadva (pl. 192.168.1.100, amennyiben ez a belsőhálózati IP címe) és lehet '''0.0.0.0''' (ez '''az alapértelmezett'''), ami minden a géphez köthető IP címen hallgatózni fog. 
Az ''„apache2ctl -D FOREGROUND”'' előtérben futtatja az apache2 szervert, így nem áll le a konténer sem, futásban marad és várja a csatlakozó klienseket.

Érdemes a parancs lefuttatása után megnézni a ''docker ps'' kimenetét, a port átirányítások és lehetőségek ott is látszódnak. Ha pl. az előző parancsot megismételjük a következő bővítéssel:
<syntaxhighlight lang="bash">
docker run -d --expose 80 --expose 443 -p 80:80 ubuntu:apache2 apache2ctl -D FOREGROUND
</syntaxhighlight>
A ''docker ps'' kimenetében azt fogjuk látni, hogy a 80:80-as portforward szabály él erre a konténerre, de mindeközben '''lenne lehetőség''' a 443-as porton is kommunikálni, ha ezt is felkonfigurálnánk egy '-p 443:443' kapcsolóval.

=== Build ===
==== Dockerfile tartalma ====
Képfájlt hozhatunk létre anélkül is, hogy elindítanánk egyet kézzel és be konfigurálnánk azt, ahogy az előbb tettük. Ehhez egy ''Dockerfile'' nevű állományt kell létrehoznunk.
Érdemes ezt a saját könyvtárunkban megtenni, esetleg egy külön mappában, ahogy a következő kód is mutatja:
<syntaxhighlight lang="bash">
cd ~ && mkdir web && cd web && nano Dockerfile
</syntaxhighlight>

A fájl tartalma legyen ez:
<syntaxhighlight lang="dockerfile">
FROM ubuntu
RUN apt update && apt install apache2 -y
EXPOSE 80 443
ENTRYPOINT apache2ctl -D FOREGROUND
</syntaxhighlight>
Jól látható, hogy ugyanazok a parancsok vannak benne, amit az előbb is lefuttatunk, csupán ezt most egy fájlban foglaltuk össze.

A ''„FROM”''-mal adjuk meg, hogy melyik képfájlból akarunk kiindulni
A ''„RUN”'' kulcsszót olyan parancsok követik, amelyet a kiválasztott képfájlban végre akarunk hajtani.
Az ''„EXPOSE”'' kulcsszó után megadhatjuk szóközzel elválasztva, hogy mely portokon képes kommunikálni a konténer.
Az ''„ENTRYPOINT”'' kulcsszót követi a docker elindítását követően (''docker run'') automatikusan induló program (a ''docker daemon'' ennek a programnak a kilépésére fog várni, amikor ez a program megszakad, akkor a konténer is leáll, tehát csak olyat írjunk ide, ami a végtelenségig képes futni).

Az ENTRYPOINT helyett írhatunk CMD-t is, azonban jó, ha tudjuk, hogy a ''docker run'' parancs végén a ''CMD'' utasítást adhatjuk meg:
<syntaxhighlight lang="bash">
docker run -ti ubuntu bash
</syntaxhighlight>
Ebben az esetben a ''„bash”'' kulcsszó a CMD-nek felel meg, így ha a felhasználó ezt a paramétert is megadja, akkor felül fogja írni a képfájlban definiáltat, ami az alkalmazás helyi összeomlását is jelentheti egyes esetekben (természetesen az újbóli futtatása jelen esetben ''bash'' paraméter nélkül meg fogja oldani a problémát).
Az ENTRYPOINT érétke azonban csak külön kapcsolóval változtatható meg, így kisebb az esélye, hogy egy hozzá nem értő ezzel működésképtelenné teszi a konténerben az alkalmazást.

A program futtatása úgy épül fel, hogy ''${ENTRYPOINT} ${CMD}'', tehát az ''ENTRYPOINT''-ban megadhatjuk, hogy melyik programot szeretnénk, hogy mindenképp lefusson és ''CMD''-vel megadhatjuk, hogy alapértelmezetten milyen paraméterekkel induljon, de a felhasználó ha szeretné, akkor a paramétereket megváltoztathatja. Ehhez a következő formában kell megadnunk ezeket az értékeket:
<syntaxhighlight lang="dockerfile">
FROM ubuntu
RUN apt update && apt install apache2 -y
EXPOSE 80
ENTRYPOINT ["apache2ctl"]
CMD ["-D FOREGROUND"]
</syntaxhighlight>
'''Csak ebben a megadási módban működik, „[” „]” párok nélkül nem cserélődik le a ''CMD'' tartalma!'''

'''Figyelem, ez a konkrét példa hibás lesz futtatáskor!''' Exec formában (szögletes zárójelekkel) a ''CMD'' tömb minden eleme '''külön''', önálló argumentumként adódik át a programnak. A fenti ''CMD ["-D FOREGROUND"]'' emiatt egyetlen, szóközt is tartalmazó argumentumként (''"-D FOREGROUND"'') adja át az értéket az ''apache2ctl''-nek két külön kapcsoló (''-D'' és ''FOREGROUND'') helyett, amit a program nem fog tudni értelmezni, és a konténer el fog állni. A helyes megoldáshoz minden argumentumot külön tömbelemként kell felsorolni - lásd az alábbi példát.

Lehetséges konfiguráció lehet jelen esetben a következő is:
<syntaxhighlight lang="dockerfile">
FROM ubuntu
RUN apt update && apt install apache2 -y
EXPOSE 80
ENTRYPOINT ["apache2ctl", "-D"]
CMD ["FOREGROUND"]
</syntaxhighlight>
Ez esetben a '-D' kapcsoló mindenképp az ''apache2ctl'' parancs után kerül, a felhasználó a docker indításakor azt választhatja meg, hogy a defualt ''FOREGROUND'' vagy egy explicit megadott ''BACKGROUND'' paraméterrel szeretné-e futtatni ('''utóbbi esetben a konténer egyből kilépne, így ennek a nyitva hagyása jelen esetben nem ésszerű''').

Adhatunk meg továbbá ''USER'' és ''WORKDIR'' kulcsszavakat: előbbivel azt állíthatjuk be, hogy a docker milyen felhasználónévvel fusson, utóbbi a kezdőkönyvtárat változtatja meg.
'''A USER paraméter NAGYON fontos, soha ne készítsünk olyan image-t, amely root joggal fut! A biztonsági kockázata nagyon magas.'''
<syntaxhighlight lang="dockerfile">
FROM ubuntu
RUN apt update && apt install apache2 -y

# ez egy pillanatra elindítja az apache2-t, így kialakítja root joggal a működéshez szükséges mappákat
RUN apache2ctl start

# admin felhasználó létrehozása
RUN useradd admin

# apache logfájlokon legyen admin csoport a szerző
RUN chgrp admin /var/log/apache2 -R

# apache2 log fájlokon root és admin csoport bármit tehet, mindenki más olvashat
RUN chmod 2774 /var/log/apache2 -R

# admin el tudja indítani az apache2 szolgáltatást
RUN chgrp admin /var/run/apache2 -R

# admin el tudja indítani az apache2 szolgáltatást, tudjon ide írni
RUN chmod 2775 /var/run/apache2 -R

# admin-ként fogja inicializálni a konténert indításkor (docker run)
USER admin

# a kezdőkönyvtár legyen az app könyvtára (nem muszáj, de így nem kell keresni később)
WORKDIR /var/www/html
EXPOSE 80
ENTRYPOINT apache2ctl -D FOREGROUND
</syntaxhighlight>

==== Képfájl mentése Dockerfile-ból ====
A következő paranccsal létrehozhatjuk a képfájlt, ha a Dockerfile az aktuális mappában van:
<syntaxhighlight lang="bash">
# docker build --tag <server>/<namespace>/<name>:<tags> <context>
# ne feledkezzünk meg a kontextus paraméterről a sor végén, mivel a Dockerfile mellettünk van, '.' van a parancs végén.
docker build --tag ubuntu:apache2 .
</syntaxhighlight>

=== Saját image feltöltése registrybe ===

== Docker hálózatok ==
== Docker containerek csoportosítása (compose) ==

== Apache2 ubuntu - biztonságos ==
'''Megjegyzés:''' az alábbi példa a ''root'' nélküli futtatást (USER app) mutatja be, ami valóban jó gyakorlat, de a ''mkdir /environment -m 777'' sor világolvasható-írható (777) jogosultságot ad a mappának, ami önmagában nem tekinthető szigorúan biztonságosnak. Éles környezetben inkább a fentebb bemutatott, csoport alapú, szűkebb jogosultságú megoldást (''chgrp''+''chmod 2774/2775'') érdemes követni, a 777 helyett.
<syntaxhighlight lang="dockerfile">
FROM ubuntu
RUN apt update && apt install -y \
apache2
EXPOSE 80/tcp
RUN useradd app
RUN mkdir /environment -m 777
RUN sed -i \
"s/\/var\/run\/apache2\$SUFFIX\/apache2.pid/\/environment\/apache2.pid/" \
/etc/apache2/envvars
RUN sed -i \
"s/\/var\/run\/apache2\$SUFFIX/\/environment/" \
/etc/apache2/envvars
RUN sed -i \
"s/\/var\/lock\/apache2\$SUFFIX/\/environment/" \
/etc/apache2/envvars
RUN sed -i \
"s/\/var\/log\/apache2\$SUFFIX/\/environment/" \
/etc/apache2/envvars

USER app
ENTRYPOINT ["/sbin/apache2ctl", "-D", "FOREGROUND"]

# docker build --tag test:apache2 .
</syntaxhighlight>

EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések

2026-09-14T07:45:22Z

ApelPro: Rövidítések javítása: EC2, ECS, S3, TCP, HTML, RFC, GIMP hibás kifejtések javítva; elgépelések és a COMA/CORBA egybefolyt sor javítva

{| class="wikitable"
|+ Hasznos rövidítések
|-
! Rövidítés !! Kifejtés
|-
| ABI || Application Binary Interface
|-
| ACID || Atomicity, Consistency, Isolation, Durability
|-
| ACL || Access Control List
|-
| AMI || Amazon Machine Image
|-
| API || Application Programming Interface
|-
| ARM || Advanced RISC Machine
|-
| ASIC || Application Specific Integrated Circuit
|-
| AVX || Advanced Vector Extensions
|-
| AWS || Amazon Web Services
|-
| AWSLA || Amazon Web Services Licensing Agreement
|-
| BASE || Basically Available, Soft state, Eventually consistent
|-
| BCE || Basic Core Equivalent
|-
| BIOS || Basic Input Output System
|-
| BPD || Bootstrap Performance Diagnostic
|-
| BSP || Bulk Synchronous Parallel
|-
| CCN || Content Centric Network
|-
| CDN || Content Delivery Network
|-
| CISC || Complex Instruction Set Computer
|-
| COMA || Cache Only Memory Access
|-
| CORBA || Common Object Request Broker Architecture
|-
| CPI || Cycles per Instruction
|-
| CPU || Central Processing Unit
|-
| CRM || Customer Relationship Management
|-
| CSP || Cloud Service Provider
|-
| CUDA || Compute Unified Device Architecture
|-
| DAT || Dynamic Address Translation
|-
| DBaaS || Database as a Service
|-
| DDoS || Distributed Denial of Service
|-
| DHCP || Dynamic Host Configuration Protocol
|-
| DMA || Direct Memory Access
|-
| DRAM || Dynamic Random Access Memory
|-
| DVFS || Dynamic Voltage and Frequency Scaling
|-
| EBS || Elastic Block Store
|-
| EC2 || Elastic Compute Cloud
|-
| ECS || Elastic Container Service
|-
| EMR || Elastic Map Reduce
|-
| EPIC || Explicitly Parallel Instruction Computing
|-
| FC || Fibre Channel
|-
| FCFS || First Come First Serve
|-
| FIFO || First In First Out
|-
| FPGA || Field Programmable Gate Array
|-
| FSM || Finite State Machine
|-
| GFS || Google File System
|-
| GiB || Gibibyte
|-
| GIMP || GNU Image Manipulation Program
|-
| GPFS || General Parallel File System
|-
| GPU || Graphics Processing Unit
|-
| HDD || Hard Disk Drive
|-
| HDFS || Hadoop Distributed File System
|-
| HTML || Hypertext Markup Language
|-
| HTTP || Hypertext Transfer Protocol
|-
| IaaS || Infrastructure as a Service
|-
| IDE || Integrated Drive Electronics
|-
| IoT || Internet of Things
|-
| IPC || Instructions per Clock Cycle
|-
| IRTF || Internet Research Task Force
|-
| ISA || Instruction Set Architecture
|-
| JDBC || Java Database Connectivity
|-
| JMS || Java Message Service
|-
| JSON || JavaScript Object Notation
|-
| KVM || Kernel-based Virtual Machine
|-
| MAC || Medium Access Control
|-
| MFLOPS || Million Floating Point Operations per Second
|-
| MIMD || Multiple Instruction Multiple Data
|-
| MIPS || Million Instructions per Second
|-
| MLMM || Multi-level Memory Manager
|-
| MMX || Multi Media Extension
|-
| MPI || Message Passing Interface
|-
| MSCR || Map Shuffle Combine Reduce
|-
| NAT || Network Address Translation
|-
| NDN || Named Data Networks
|-
| NFS || Network File System
|-
| NTFS || New Technology File System
|-
| NUMA || Non-Uniform Memory Access
|-
| NV-RAM || Non-Volatile Random Access Memory
|-
| OCCI || Open Cloud Computing Interface
|-
| OGF || Open Grid Forum
|-
| OLTP || On Line Transaction Processing
|-
| OLAP || On Line Analytical Processing
|-
| PaaS || Platform as a Service
|-
| PHP || Recursive acronym for PHP, Hypertext Preprocessor
|-
| PN || Petri Net
|-
| QoS || Quality of Service
|-
| RAID || Redundant Array of Independent Disks
|-
| RAM || Random Access Memory
|-
| RAR || Read After Read
|-
| RAW || Read After Write
|-
| RDD || Resilient Distributed Dataset
|-
| RDBMS || Relational Database Management System
|-
| RDS || Relational Database Service
|-
| REST || Representational State Transfer
|-
| RFC || Request For Comments
|-
| RFB || Remote Framebuffer (a VNC protokollja)
|-
| RISC || Reduced Instruction Set Computer
|-
| RMI || Remote Method Invocation
|-
| RPC || Remote Procedure Call
|-
| RTT || Round Trip Time
|-
| SaaS || Software as a Service
|-
| SAN || Storage Area Network
|-
| SDK || Software Development Kit
|-
| SDN || Software Defined Network
|-
| SHA || Secure Hash Algorithm
|-
| SIMD || Single Instruction Multiple Data
|-
| SLA || Service Level Agreement
|-
| SNS || Simple Notification Service
|-
| SOAP || Simple Object Access Protocol
|-
| SPMD || Single Program Multiple Data
|-
| SQL || Structured Query Language
|-
| SQS || Simple Queue Service
|-
| SSD || Solid State Disk
|-
| SSE || Streaming SIMD Extensions
|-
| S3 || Simple Storage Service
|-
| SWF || Simple Workflow Service
|-
| TCP || Transmission Control Protocol
|-
| TLB || Translation Lookaside Buffer
|-
| UDP || User Datagram Protocol
|-
| UFS || Unix File System
|-
| UMA || Uniform Memory Access
|-
| vCPU || Virtual CPU
|-
| VLIW || Very Long Instruction Word
|-
| VM || Virtual Machine
|-
| VMCS || Virtual Machine Control Structure
|-
| VMM || Virtual Machine Monitor (hypervisor) / Virtual Memory Manager (a két jelentés kontextusfüggő)
|-
| VNC || Virtual Network Computing
|-
| VPC || Virtual Private Cloud
|-
| VPN || Virtual Private Network
|-
| WAN || Wide Area Network
|-
| WAR || Write After Read
|-
| WAW || Write After Write
|-
| WSC || Warehouse Scale Computer
|-
| WWN || World Wide Name
|-
| XML || Extensible Markup Language
|-
| YARN || Yet Another Resource Negotiator
|}

EDU::GAMF::Felhőalapú-szolgáltatások

2026-09-14T06:55:10Z

ApelPro: /* A tárgy teljesítéséhez szükséges idő */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a projektfeladatból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email] és alap szolgáltatások átbeszélése
# EC2 telepítés, nginx + apache2 bevezetés, alap parancsok ismétlése (ls, nano, mcedit stb.)
# Alkalmazás telepítése előre elkészített script segítségével + AMI, ASG, LB
# RDS telepítés és alkalmazás integráció ellenőrzése
# Docker alapok
# Docker compose alapok
# Alkalmazás indítása Docker környezetben
# IaC eszközök áttekintése
# IaC eszközök áttekintése
# MessageQueue eszközök használata
# Projekt bemutató (6db)
# Projekt bemutató (6db)
# Projekt bemutató (6db)

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj mamximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Felhőalapú-szolgáltatások

2026-09-14T06:54:26Z

ApelPro: /* A tantárgy követelményei - nem hivatalos */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a projektfeladatból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy teljesítéséhez szükséges idő ==
Az állami elvárás szerint minden kredit megszerzése egy átlagos hallgató számára 30 óra ráfordítást vesz igénybe - beleértve a tanórákat, ZH és vizsgaalkalmakat, valamint az otthoni önálló tanulást is. Ez a tárgy 5 kreditet ér, tehát a félév során összesen 150 órát kell a hallgatóknak ezzel foglalkozniuk, ami sokszor a pótZH-ban (és manapság a pót-pót ZH-ban) csapódik le.
Mivel a félév során 13 hét áll rendelkezésünkre és mind az előadás, mind a gyakorlat 1,5 óra időtartamú, így összesen 39 órát ölel fel a tanórai képzés (ZH-val együtt). Rossz hír, hogy ez esetben egy gyakorlati jegyes tárgyról van szó, így a maradék időt legkésőbb a 13. hét végéig kell eltölteni otthoni tanulással, nem lehet a vizsgaidőszakra csúsztatni azt. Ez alapján heti 8.5, azaz valamivel több, mint napi 1,5 órát (heti 5 nappal számolva) a tárggyal kapcsolatos ismeretanyagok gyűjtésével és megértésével kellene a hallgatónak foglalkoznia. Mivel ezen számítás alapján a hallgatóknak napi 13,5 órát kellene 30 kredit felvétele esetén tanulással tölteni, így természetesen ez egy irreális elvárásnak bizonyul. Azonban kreditarányosan számolva, ezen tárgy esetében '''heti 2 óra''' ráfordítással éri el a hallgató a napi 8 órás munkaidőt (tanórák közötti szüneteket pihenőidőként kezelve) 30 kredit esetén, ami a normális szint. Ez tehát '''elvárhatónak és számon kérhetőnek bizonyul''' nappali tagozaton annak érdekében, hogy a hallgatók a lehető legnagyobb felkészültségben üljenek az órákon.

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email] és alap szolgáltatások átbeszélése
# EC2 telepítés, nginx + apache2 bevezetés, alap parancsok ismétlése (ls, nano, mcedit stb.)
# Alkalmazás telepítése előre elkészített script segítségével + AMI, ASG, LB
# RDS telepítés és alkalmazás integráció ellenőrzése
# Docker alapok
# Docker compose alapok
# Alkalmazás indítása Docker környezetben
# IaC eszközök áttekintése
# IaC eszközök áttekintése
# MessageQueue eszközök használata
# Projekt bemutató (6db)
# Projekt bemutató (6db)
# Projekt bemutató (6db)

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj mamximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Felhőalapú-szolgáltatások

2026-09-14T06:53:22Z

ApelPro: /* A gyakorlat menete */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a ZH-ból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy teljesítéséhez szükséges idő ==
Az állami elvárás szerint minden kredit megszerzése egy átlagos hallgató számára 30 óra ráfordítást vesz igénybe - beleértve a tanórákat, ZH és vizsgaalkalmakat, valamint az otthoni önálló tanulást is. Ez a tárgy 5 kreditet ér, tehát a félév során összesen 150 órát kell a hallgatóknak ezzel foglalkozniuk, ami sokszor a pótZH-ban (és manapság a pót-pót ZH-ban) csapódik le.
Mivel a félév során 13 hét áll rendelkezésünkre és mind az előadás, mind a gyakorlat 1,5 óra időtartamú, így összesen 39 órát ölel fel a tanórai képzés (ZH-val együtt). Rossz hír, hogy ez esetben egy gyakorlati jegyes tárgyról van szó, így a maradék időt legkésőbb a 13. hét végéig kell eltölteni otthoni tanulással, nem lehet a vizsgaidőszakra csúsztatni azt. Ez alapján heti 8.5, azaz valamivel több, mint napi 1,5 órát (heti 5 nappal számolva) a tárggyal kapcsolatos ismeretanyagok gyűjtésével és megértésével kellene a hallgatónak foglalkoznia. Mivel ezen számítás alapján a hallgatóknak napi 13,5 órát kellene 30 kredit felvétele esetén tanulással tölteni, így természetesen ez egy irreális elvárásnak bizonyul. Azonban kreditarányosan számolva, ezen tárgy esetében '''heti 2 óra''' ráfordítással éri el a hallgató a napi 8 órás munkaidőt (tanórák közötti szüneteket pihenőidőként kezelve) 30 kredit esetén, ami a normális szint. Ez tehát '''elvárhatónak és számon kérhetőnek bizonyul''' nappali tagozaton annak érdekében, hogy a hallgatók a lehető legnagyobb felkészültségben üljenek az órákon.

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email] és alap szolgáltatások átbeszélése
# EC2 telepítés, nginx + apache2 bevezetés, alap parancsok ismétlése (ls, nano, mcedit stb.)
# Alkalmazás telepítése előre elkészített script segítségével + AMI, ASG, LB
# RDS telepítés és alkalmazás integráció ellenőrzése
# Docker alapok
# Docker compose alapok
# Alkalmazás indítása Docker környezetben
# IaC eszközök áttekintése
# IaC eszközök áttekintése
# MessageQueue eszközök használata
# Projekt bemutató (6db)
# Projekt bemutató (6db)
# Projekt bemutató (6db)

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj mamximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Felhőalapú-szolgáltatások

2026-09-14T06:52:59Z

ApelPro: /* A gyakorlat menete */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a ZH-ból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy teljesítéséhez szükséges idő ==
Az állami elvárás szerint minden kredit megszerzése egy átlagos hallgató számára 30 óra ráfordítást vesz igénybe - beleértve a tanórákat, ZH és vizsgaalkalmakat, valamint az otthoni önálló tanulást is. Ez a tárgy 5 kreditet ér, tehát a félév során összesen 150 órát kell a hallgatóknak ezzel foglalkozniuk, ami sokszor a pótZH-ban (és manapság a pót-pót ZH-ban) csapódik le.
Mivel a félév során 13 hét áll rendelkezésünkre és mind az előadás, mind a gyakorlat 1,5 óra időtartamú, így összesen 39 órát ölel fel a tanórai képzés (ZH-val együtt). Rossz hír, hogy ez esetben egy gyakorlati jegyes tárgyról van szó, így a maradék időt legkésőbb a 13. hét végéig kell eltölteni otthoni tanulással, nem lehet a vizsgaidőszakra csúsztatni azt. Ez alapján heti 8.5, azaz valamivel több, mint napi 1,5 órát (heti 5 nappal számolva) a tárggyal kapcsolatos ismeretanyagok gyűjtésével és megértésével kellene a hallgatónak foglalkoznia. Mivel ezen számítás alapján a hallgatóknak napi 13,5 órát kellene 30 kredit felvétele esetén tanulással tölteni, így természetesen ez egy irreális elvárásnak bizonyul. Azonban kreditarányosan számolva, ezen tárgy esetében '''heti 2 óra''' ráfordítással éri el a hallgató a napi 8 órás munkaidőt (tanórák közötti szüneteket pihenőidőként kezelve) 30 kredit esetén, ami a normális szint. Ez tehát '''elvárhatónak és számon kérhetőnek bizonyul''' nappali tagozaton annak érdekében, hogy a hallgatók a lehető legnagyobb felkészültségben üljenek az órákon.

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email] és alap szolgáltatások átbeszélése
# EC2 telepítés, nginx + apache2 bevezetés, alap parancsok ismétlése (ls, nano, mcedit stb.)
# Alkalmazás telepítése előre elkészített script segítségével + AMI, ASG, LB
# RDS telepítés és alkalmazás integráció ellenőrzése
# Docker alapok
# Docker compose alapok
# Alkalmazás indítása Docker környezetben
# IaC eszközök áttekintése
# IaC eszközök áttekintése
# MessageQueue eszközök használata
# Lambda eszköz használata
# Projekt bemutató (6db)
# Projekt bemutató (6db)
# Projekt bemutató (6db)

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj mamximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Felhőalapú-szolgáltatások::AWS

2025-10-14T06:29:19Z

ApelPro: /* UI indítás */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
[[category:GAMF AWS|AWS]]
== Amazon Web Services regisztráció ==
Az AWS mindenki számára biztosít 1 év ingyenes próbaverziót. Ehhez regisztrálnunk kell a rendszerbe, amihez szükségünk lesz egy email címre, egy telefonszámra a megerősítéshez és egy netes vásárlásra alkalmas bankkártyára. A regisztráció során az AWS 1$-ral meg terheli a számlát, de később erre nem tart igény, így a tranzakció lejáratakor jóváíródik a számlán.

== Ingyenes verzió korlátai ==
Az ingyenes verzióban nem minden érhető el és ami mégis, az sem korlátlan ideig (750 óra EC2 futási idő például), amit ha átlépünk, akkor fizetési kötelezettségünk jelentkezik a szolgáltató felé. Igyekezzünk mindent leállítani az órai munka illetve az otthoni gyakorlás után, hogy lehetőleg ne kerüljön pénzbe a féléves munkánk. A hallgatók által elszenvedett károkért sem az iskola sem Én nem tudunk felelősséget vállalni, de azt meg tudjuk ígérni, hogy fizetős szolgáltatást nem használunk és nem is kérünk számon.

== AWS alapok ==
'''Figyelem!''' Az iskolai hálózatból csak az eu-west-1 és az eu-central-1, azaz Írország és Frankfurt IP címei vannak engedélyezve, ezekre fogunk tudni SSH kapcsolaton keresztül csatlakozni. 
'''Figyelem!''' Próbaidőszak alatt minden szolgáltatás mellett keressük a ''Free tier eligible'' megjegyzést, különben fizetési kötelezettségünk adódhat!

=== EC2 szolgáltatásai ===
Az ''EC2'' gyakorlatilag egy VPS-nek feleltethető meg és nem is tévedünk vele hatalmasat. A neve az ''Elastic Cloud Compute'' szavak kezdőbetűiből kialakuló ''ECC''-ből fakad, a ''2''-es a végén jelzi, hogy a ''C'' betűből kettő van.

A különbséget a VPS-hez az EC2 futási ideje okozza: bár nem feltétlen, de meg van a lehetősége, hogy egyik napról a másikra megszűnjön egy EC2 úgy, hogy az alkalmazásunk mégis működőképes marad. E tulajdonsága miatt kapta az ''Elastic'' nevet, amit körültekintően kell kezelni: semmilyen adatot nem tárolhatunk úgy egy alkalmazáson belül, mint egy VPS esetén: a dinamikus adatok (pl. PHP Session, feltöltött fájok) egy EC2 csere esetén elvesznek, így ezeket nem helyben fogjuk tárolni.

Az EC2 szolgáltatásait a keresőmezőbe írt ''„EC2”'' kulcsszóval és az eredményekben megjelenő ''EC2''-re való kattintással érhetjük el.

[[Fájl:GAMFAWS search EC2.png.png]]

Az alapértelmezetten megjelenő menüpont a ''Dashboard'', ahol információkat találhatunk az ''EC2'' köré felhúzható szolgáltatásokról, melyeknek egy részét a továbbiakban tárgyalni is fogunk. Az összefoglaló táblázat az alább látható módon jelenik meg. '''Figyelem''', a táblázat csak az adott régióban elindított/elérhető szolgáltatásokat mutatja, régió váltása előtt érdemes az esetlegesen létrehozott, régió függő elemeket leállítani, hogy később ne jelenjen meg fizetési kötelezettség.

[[Fájl:GAMFAWS ec2 dashboard.png]]

==== EC2 telepítése és beállítása ====
EC2 létrehozásához meg kell nyomnunk a ''Launch instance'' gombot, melyet több helyen is elérhetünk:
* A Dashboardon
* A bal oldali menüben található ''Intances'' menüpont megnyitása után jobb felül
A gomb minden esetben a következőképp néz ki: [[Fájl:GAMFAWS ec2 launch instance button.png]]

A gombra kattintva egy űrlap jelenik meg, amely segítségével elvégezhetjük a szükséges beállításokat: 
======Név és tag beállítok======
Megadása nem kötelező, de több szerver futtatása esetén könnyebben azonosíthatjuk be őket ezek segítségével
[[Fájl:GAMFAWS ec2 setup name and tags.png]]

Az ''Add additional tags'' gombra kattintva további kulcs=érték párokat adhatunk hozzá, amivel dinamikusan csatolhatjuk össze egyéb szolgáltatásokkal, amelyek egy-egy kulcsot keresve döntik el, hogy melyik szolgáltatásokkal kell együttműködniük (például monitorozás bekapcsolása 'monitoring=true' kulcs=érték pár alapján.

======Kezdeti képfájl kiválasztása======
Az Amazon többféle indítóképpel is rendelkezik, így nagy valószínűséggel meg fogjuk találni a hozzánk közelálló operációs rendszert. Új hozzáadására nincs lehetőségünk, de készíthetünk az alapképfájlokból olyan verziót, ami már tartalmazza a saját konfigurációnkat (lásd [[GAMF :: Felhőalapú-szolgáltatások :: AWS#AMI_létrehozása|itt]]). 
[[Fájl:GAMFAWS ec2 setup AMI choose2.png]] 
Az órákon az Ubuntu legújabb verzióját használjuk, mivel ennek a Desktop változata az egyik legelterjedtebb a Linux felhasználók körében, így nem kell más környezetet megszoknia egy átlag hallgatónak. Érdemes lehet azonban egyéb disztribúciók kipróbálása is, különösen a '''Debian'''-t, '''Suse'''-t/'''OpenSuse'''-t, '''ReadHat'''-et és annak ingyenes változatait ('''AlmaLinux''', '''RockyLinuxtm''', amelyek az egykori '''CentOS'''-t hivatottak váltani), mivel céges környezetben ezek sűrűbben előfordulnak: némelyik a kisebb erőforrásigénye, míg másik az Enterprise szolgáltatásai miatt.

======Szerver típusának meghatározása======
Különböző erősségű szerverkonfigurációk közül választhatunk, de természetesen nem mindegyik érhető el az ingyenes verzióban. A számítógépek ára a konfiguráció függvényében változik, de csak azért az időért kell fizetni, amíg a szerver ''Running'' állapotban volt. Az órán az alapértelmezett ''t2.micro''-t használjuk. 
[[Fájl:GAMFAWS ec2 setup instance type.png]]

======Kulcspár hozzárendelése======
Az Amazonon belüli szolgáltatásokat felhasználónév/jelszó páros helyett SSH kulcspárok segítségével érjük el. Minden felhasználó számára készíthetünk egyet és jogosultságok segítségével korlátozhatjuk, hogy mihez férhet hozzá (IAM). 
Ebben a szekcióban ki kell választanunk, hogy a telepíteni kívánt EC2-höz milyen kulcspárral lehet majd hozzáférni. Amennyiben nem rendelkezünk még kulcspárral, úgy van lehetőségünk helyben elkészíteni a ''Create new keypair'' gomb segítségével, amelynek lépési megegyeznek az [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Kulcspár_létrehozása|itt]] leírtakkal. 
[[Fájl:GAMFAWS ec2 setup keypair.png]]

======Hálózati és biztonsági beállítások======
Az EC2-k közötti kommunikációs csatornák kialakításához definiálnunk kell, hogy melyik virtuális hálózatba akarjuk elhelyezni és milyen alkalmazásokat szeretnénk elérhetővé tenni. Ezt a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#VPC_beállításai|VPC]] és a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Security_Group|Security Group]] beállításával tehetjük meg. Előbbi a virtuális hálózatnak felel meg, míg utóbbi hasonlóan egy tűzfalhoz, meghatározza, hogy a szerveren milyen portokat érhetünk el. Érdemes az SSH-t engedélyezni és ha webes alkalmazást szeretnénk rajta futtatni a későbbiekben, akkor a HTTP és/vagy HTTPS szolgáltatást/szolgáltatásokat is, így később nem kell szerkeszteni ezeket a beállításokat. 
[[Fájl:GAMFAWS ec2 setup networking.png]]

======Tárhely beállítások======
Ebben a részben adhatjuk meg, hogy a szerverünk mekkora tárhellyel rendelkezzen. Egy Linux alapú operációs rendszernek nem kell 8GB-nél több, így az alapértéken hagyhatjuk. Az itt megadott érték inkább csak egy korlát, valójában csak akkora tárhelyet vesz igénybe, amennyire ténylegesen szüksége van a rendszernek. Ez az érték alatt látható figyelmeztetés miatt lényeges, hiszen a 30GB-t elhagyva fizetőssé válik a tárterület is, ám ez nem jelenti, hogy csak 4 szervert tudnánk elindítani az ingyenes keretek között. 
[[Fájl:GAMFAWS ec2 setup ebs.png]]

Ezt a szolgáltatást EBS-nek nevezik (''Elastic Block Store'') és az EC2 megszűnésekor minden erre mentett adat elveszik, így általában az OS-t és az applikáció kódját tároljuk ezen - semmi dinamikus adatot.

======Haladó beállítások======
Ebben a szekcióban különböző beállításokat végezhetünk el, ám ezeket az órán nem módosítjuk. Érdekes lehet azonban a menüt lenyitva legalul található ''User data'' opció, amivel parancsokat adhatunk meg az új operációs rendszer számára, hogy miket futtasson le. Ennek segítségével lehetőségünk nyílik applikációk telepítésére - pl. git - és a kód letöltésére egy másik szerverről, amennyiben a kiválasztott képfájl nem tartalmazta azt. 
''Az órai keretek között ezt a funkciót nem használjuk ki, de érdemes lehet kipróbálni, mivel valós alkalmazások üzemeltetésekor jól jöhet.'' 
[[Fájl:GAMFAWS ec2 setup userdata.png]]

======Összefoglaló======
A beállító panel mellett jobbra találhatjuk az összefoglaló ablakot, amelyben megtalálható a ''Launch Instance'' gomb. Ennek segítségével kezdhetjük meg a végleges telepítést, ha erre rá nyomunk, akkor a rendszer megkezdi a kiválasztott konfiguráció telepítését. Ha ebben az ablakban pénzösszegeket látunk, akkor az egészen biztosan fizetési kötelezettséget vonz magával, legyünk körültekintőek. 
[[Fájl:GAMFAWS ec2 setup summary.png]]

======Az elkészült instance tulajdonságai======
A futó szerverek az ''Instances'' menüpontban érhetők el. Az egyes sorokra kattintva alul megtekinthetjük a beállításait, amely tartalmazza az AWS által kiosztott publikus és privát IP címeket és domain neveket. Ezeken keresztül tudunk kommunikálni szerverünkkel. 
[[Fájl:GAMFAWS ec2 properties.png]] 
''Jelen példában a külső IP címünk: 3.252.168.207, amit a mellette található ikonnal egyszerűen a vágólapra másolhatunk.''

======Csatlakozás Linux terminálból======
A csatlakozáshoz nyissunk meg egy terminált a CTRL+T billentyűkombinációval, majd navigáljunk a ''cd'' parancs segítségével a letöltött kulcsfájl mappájába. Az SSH megköveteli, hogy a csatlakozáshoz használt kulcsfájlhoz csak a tulajdonos felhasználó férjen hozzá, így a következő parancsot futtassuk le rajta: ''chmod 600 test.pem''

A következő paranccsal tudunk kapcsolódni: ''ssh -i test.pem ubuntu@3.252.168.207'' 
Ha a fenti parancs kéri, fogadjuk el a tanúsítványt. Amennyiben ''Permission error'' hibát kapunk, akkor a fenti ''chmod'' parancsra van szükségünk, vagy nem mi vagyunk a kulcsfájl tulajdonosai (''ls -l'' segíthet). 
A ''test.pem'' az AWS rendszerből letöltött .pem formátumú kulcsfájl, az ''ubuntu'' a szerveren elérhető felhasználó. A különböző disztribúcióknál használt felhasználónevekről [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connection-prereqs.html ezen] a linken tájékozódhatsz. 
[[Fájl:GAMFAWS ec2 connect linux.png]]

======Csatlakozás Putty használatával======
Amennyiben a .pem kiterjesztésű állományt töltöttük le az AWS rendszeréből, akkor a '''puttygen''' eszköz segítségével ki kell exportálni belőle a privát kulcsot. [https://www.ssh.com/academy/ssh/putty/windows/puttygen Ezen a linken] részletes segédlet található a programcsomaghoz, ahol további funkciók is bemutatásra kerülnek (pl. kulcsgenerálás).

==== Kulcspár létrehozása ====
A kulcspárok kezeléséhez a ''Key Pairs'' linket nyissuk meg a bal oldali menüből. Újat a jobb oldalon látható ''Create key pair'' gomb segítségével készíthetünk. [[Fájl:GAMFAWS ec2 keypair create.png]]

A gombra kattintva egy űrlapot kapunk, amely végig vezet minket a létrehozás lépésein.
# Név megadása
# Típus kiválasztása - ''RSA-val dolgozunk az órán''
# Letöltendő kulcs típusa - ''Linux terminálból való csatlakozáshoz a .pem fájlra lesz szükségünk''
# Esetleges tag-ek hozzárendelése
# A ''Create key pair'' gombra kattintva letölthetjük a kulcspárt

[[Fájl:GAMFAWS ec2 keypair setup.png|Kulcspár létrehozása]]

'''Figyelem!''' A kulcspár csak a létrehozás után tölthető le '''egyetlen egyszer''', az elvesztett fájlok nem reprodukálhatók! Amennyiben egy EC2 csak az elhagyott kulcspárral érhető el, úgy annak (EC2) törlése és újrakonfigurálása szükséges egy új kulccsal.

==== Security Group ====
A Security Group-ok segítségével kontrollálhatjuk, hogy a szervereinkhez milyen portokon férhetnek hozzá, tehát mintegy tűzfal működik. Egy Security Group több gépre is ráhúzható és függetlenül működik, azaz a megadott szabályokat nem másolja át az operációs rendszer konfigurációs állományaiba, mintegy a szerver elé telepített eszköz működik. Ennek köszönhetően futási időben változtathatjuk a szabályokat, életbelépésükhöz nem kell újracsinálni az EC2-ket.

A bal oldali sávban, a ''Network & Security'' csoportban érhető el.

===== Security Group hozzáadása =====
Egy új szabályrendszer felvételét kezdeményezhetjük az EC2 telepítésekor, ahogyan azt [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Hálózati_és_biztonsági_beállítások|itt]] is láthattuk, de készíthetünk előre meghatározottakat is.

Az előre definiált csoportokat a ''Create Security Group'' gomb segítségével hozhatjuk létre, amelyet a jobb felső sarokban találhatunk meg. 
[[Fájl:GAMFAWS ec2 secg new button.png|bélyeg]sdfsad] 

A gomb megnyomását követően egy űrlapot kapunk, melynek 3 fő része van:
# Általános adatok [[Fájl:GAMFAWS ec2 secg new basic.png|bélyeg|Általános adatok]]
#* '''A név és a leírás mező megadása is kötelező'''
#* Itt választhatjuk ki, hogy mely VPC-ben szeretnénk elérhetővé tenni.
# Bejövő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg inbound.png|bélyegkép|Inbound rules]]
#* '''Az itt megjelenő szabályok lesznek engedélyezve a szerverünk felé, minden más csomag eldobásra kerül'''
#* Háromféle szabályból választhatunk:
#** '''Anywhere''' (IPv4, IPv6): A megadott IP típusból mindenhonnan elfogadjuk a csomagokat
#** '''Custom''': Csak a megadott IP címekről/IP tartományokból érjük el az adott portot
#** '''MyIP''': automatikusan beillesztésre kerül az felhasználó aktuális IP címe (hasonló a custom lehetőséghez)
# Kimenő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg outbound.png|bélyegkép|Outbound rules]]
#* A kimenő forgalom szabályozása biztonsági szempontból megfontolandó, de természetesen a publikus alkalmazások esetében (pl. web) nem tudunk ilyen szűrést alkalmazni.
#* Alkalmazhatjuk például SSH-ra, hogy megszüntessük annak a lehetőségét, hogy egy esetleges fertőzésből kifolyólag SSH-t hackelgető botnetté változzunk (volt már hasonló tapasztalat).
#* Az órán ezzel bővebben nem foglalkozunk, de éles környezetben ne felejtsünk el ezen szabályok definiálására időt szánni.
# Tag-ek megadása

===== Security Group szerkesztése =====
A szerkeszteni kívánt soron kattintsunk jobb gombbal és válasszuk ki a szerkeszteni kívánt szabályok csoportját:
* '''Edit inbound rules''', ha a bejövő csomagok szűrését szeretnénk módosítani,
* ''' Edit outbound rules''', ha a kimenő forgalmat szeretnénk szűrni.
A megnyíló ablakban ugyanazon a módon vehetünk fel szabályokat, ahogyan a létrehozásnál. A módosítások mentés után életbe lépnek. 
[[Fájl:GAMFAWS ec2 secg context menu.png]]

==== Terheléselosztás vázlat ====
[[Fájl:EC2LoadBalancingRequirements.png|középre]]

==== AMI ====
Az AMI gyakorlatilag egy bitről-bitre lemásolt HDD képfájl, amely tömörítve lett. Így tárolja az összes elmentett adat- és konfigurációs állományt. Ha egy alkalmazást készítünk, akkor a következő okokból készítünk ilyen képfájlt:
# Biztonsági mentés a telepített szolgáltatásokról, így később nem kell egy esetleges hiba miatt újrakonfigurálni az egészet
# AutoScaling group-ba szeretnénk rendezni az alkalmazásunkat, annak pedig meg kell mondani, hogy melyik képfájlt indítsa el

'''Figyelem!''' A képfájlok úgynevezett snapshot-okat hoznak létre, amelyek tárolásáért fizetni kell, ha az összméret meghaladja a 8GB-ot. (A snapshotok az éppen futó rendszer miatt készülnek: minden írási műveletet lezár, majd a snapshot készítés után elindított írási műveletek már a háttértár egyéb területeire történik, amelyet a mentés nem fog tartalmazni, így garantálható, hogy nem lesznek félig lezárt fájlok a mentésben. Lásd bővebben: BTRFS (linux) és NTFS support). A pillanatképek nem törölhetők, amíg a belőlük készült AMI létezik!

===== AMI létrehozás lépései =====
'''Navigáljunk az Instances menüpontra, ahol láthatjuk, hogy milyen EC2 szolgáltatások vannak a rendszerünkben.'''
# Kattintsunk jobb gombbal azon az elemen, amelyet menteni szeretnénk
# Nyissuk ki az ''Image and templates'' menüpontot
# Kattintsunk a ''Create image'' lehetőségre 
[[Fájl:GAMFAWS ec2 ami create.png]]

'''Nevezzük el a képfájlt tetszés szerint''' 
[[Fájl:GAMFAWS ec2 ami setup.png]]

'''Navigáljunk a bal oldalon található menüben az ''Images'' szekcióhoz és válasszuk ki az ''AMIs'' elemet. Itt megtekinthetjük és törölhetjük a létrehozott képfájljainkat.''' 
[[Fájl:GAMFAWS ec2 ami list.png]]

'''Ha a mentés sikeresen elkészült, akkor az EC2 létrehozásánál kiválaszthatjuk azt.''' 
[[Fájl:GAMFAWS ec2 setup own ami select.png]]

==== Indítási konfigurációk elkészítése ====
Az indítási konfigurációk mind egy célt szolgálnak: egységes profilba rendezi az EC2-ről készült képfájlokat. Míg az AMI nem tárolt információt a mentett gép erőforrásáról, egy indítási konfigurációban megadhatjuk ezeket. Később ezek felhasználásával egyszerűbben indíthatunk újabb szervereket és vannak olyan esetek is, amikor a rendszer megköveteli, hogy a képfájl megadása helyett konkrét, hardverinformációkat is tároló konfigurációs sablonokat adjunk meg.

''Az Auto Scaling Group például megköveteli, hogy a következő kettő elem közül az egyiket megadjuk, ebből fogja tudni, hogy milyen típusú EC2-t, mekkora tárhellyel és milyen VPC-ben indítson el.''

===== Launch configuration =====
'''Egy kifutóban lévő konfigurációs séma, amely 2022. December 31-e után nem kapja meg a frissítéseket. Az AWS javaslata szerint érdemes ezeket a beállításokat a következőkben tárgyalt ''Launch template'' alá migrálni.

A ''Launch configuration'-nek nevezett séma egy egyszerűsített változata a sablonoknak. Jóval kevesebb beállítási lehetőséget tartalmaz, mint a párja, de tökéletesen elegendőt az ''Auto Scaling Group''hoz.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Auto Scaling group'' szekciót és válasszuk ki a ''Launch Configuration'' menüpontot. A jobb felső sarokban található ''Create launch configuration'' gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''Név megadása''', aminek segítségével később hivatkozhatunk erre az elemre. Kitöltése kötelező! 
[[Fájl:GAMFAWS ec2 launch conf setup name.png]]

''AMI kiválasztása'', tehát azok képfájl megadása, amit a kiválasztott EC2 konfiguráció futtatni fog. Lehetőségünk van a saját készítésű (''My AMIs'') és a közösségi képfájlok közül választani (''Marketplace''). 
[[Fájl:GAMFAWS ec2 launch conf setup ami.png]]

'''Instance típus''' alatt megadhatjuk, hogy a konfiguráció milyen teljesítményű legyen.
'''Ne feledjük el, hogy a t2.micro az ingyenes, a többi használata után fizetési kötelezettségünk jelenhet meg.'''
[[Fájl:GAMFAWS ec2 launch conf setup instance type.png]]

'''Az Additional configruation''' részben megadhatunk különböző paramétereket, amelyeket az EC2 fog felvenni - pl. mindenképp kapjon IP címet, a subnet beállításaitól függetlenül, vagy éppen ne kapjon; itt adhatjuk meg a telepítéskor lefuttatott scripteket (User data).

'''A Storage''' szekcióban megadhatjuk, hogy milyen lemezek és milyen méretűek legyenek a rendszerhez csatolva.

'''A Security Group''' részben kiválaszthatunk egy már meglévő szabályrendszert, vagy készíthetünk újat. 
[[Fájl:GAMFAWS ec2 launch conf setup secg.png]]

'''A Key pairs''' blokkban megadhatjuk, hogy milyen privát kulccsal léphetnek be a szerverekre. Ennek meglétét jóvá kell hagyni az alul található checkbox-szal. 
[[Fájl:GAMFAWS ec2 launch conf setup keypair.png]]

'''Végül kattintsunk a ''Create launch confgiration'' gombra a létrehozáshoz.'''

===== Launch template =====
A Launch template jóval gazdagabb a beállítási lehetőségekben, mint párja. A konfigurációs adatlap tartalmaz segédletet az AutoScaling Group-pal történő használathoz, amely ''required'', azaz kötelező mezőként jelöli meg azokat az adatbeviteli elemeket, amelyeket az automata skálázó rendszer használ. Érdemes ezt bekapcsolni, amennyiben ilyen célzattal készítjük el a sablonunkat.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Instances'' szekciót és válasszuk ki a ''Launch template'' menüpontot. Az oldal közepén vagy a jobb felső sarokban található Create launch configuration gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''A sablon neve és leírása''' blokkban megadhatjuk a nevet és a leírást, de ugyanakkor itt választhatjuk ki azt a checkboxot is, ami később a segítségünkre lesz a konfigurációs sablon AutoScaling Group-hoz való illesztését is (''Auto Scaling guidence''). 
[[Fájl:GAMFAWS ec2 launch templ setup name.png]]

'''Az Application and OS images''' szekcióban megadhatjuk, hogy milyen AMI-val települjön az EC2. Itt választhatunk a sajátunkból, vagy az EC2-nél is megtalálható egyebekből. 
[[Fájl:GAMFAWS ec2 launch templ setup ami.png]]

'''Az Instance type''' csoportban megadhatjuk, hogy milyen teljesítményű gépet szeretnénk indítani.
'''Ne feledjük el, hogy az ingyenes változatban a t2.micro érhető el, másik lehetőség választása esetén fizetési kötelezettségek léphetnek fel!''' 
[[Fájl:GAMFAWS ec2 launch templ setup instancetype.png]]

'''A Key Pair''' blokkban megadhatjuk, hogy a gépek milyen kulcspárral engedélyezzék a belépést. 
[[Fájl:GAMFAWS ec2 launch templ setup key pair.png]]

'''A Network Confguration''' részben definiálhatjuk, hogy milyen VPC-be szeretnénk lerakni az EC2-ket, milyen security group legyen rajtuk. Természetesen utóbbi helyben is létrehozható, ha korábban ezt nem készítettük volna el. 
[[Fájl:GAMFAWS ec2 launch templ setup network.png]]

'''A Storage'''-nél megadhatjuk, hogy milyen kötetek, milyen méretben legyenek hozzácsatolva a rendszerhez.

'''A Tags''' blokkban felvehetjük a kívánt ''kulcs=érték'' párokat.

'''Az Additional Configuration''' szekcióban különböző haladó beállításokat eszközölhetünk a sablon által létrehozott EC2-n, többet között itt adhatjuk meg az indításkor lefuttatandó parancsok listáját (''User data'').

'''Végül kattintsunk a Create launch template nyomógombra a mentéshez!'''.

==== Target Group ====
A target group EC2-k azon csoportja, amelyeken valamilyen ''health check'' algoritmust futtatunk, ezzel meghatározva, hogy az adott csoportban hány használható, működő szerver fut. Ezt az információt elsőként a Load balancer használja ki.

A Target Group a bal oldali menüben, a ''Load Balancing'' szekcióban érhető el ''Target Groups'' néven.

Létrehozhatunk új csoportot, de meg kell adnunk, hogy milyen módon kerüljenek bele az EC2-k. Erre a következő metódusokat ajánlja fel az Amazon:
# Konkrét EC2 (Instance) kiválasztása
# EC2-k definiálása IP tartománnyal
# Lambda függvény hozzáadása
# Alkalmazás LoadBalancer, amely egy teljes VPC tartalmát magába foglalja.

Az űrlap alján megadhatjuk, hogy milyen életjel ellenőrzés történjen.

Általában nem mi vesszük fel egyesével az Instancokat ebbe a csoportba, hanem az AutoScaling group regisztrálja őket bele. '''Ezért ezt az űrlapot nem használjuk'''.

==== Load Balancer ====
A Load Balancer terheléselosztást jelent, tehát a bejövő forgalmat több gép között osztjuk el. Ezzel növekszik a felhasználói élmény, ráadásul a rendszer megállítása (egy hacker által) nehezebbé válik: ha kettő t2.micro teljesítményű szerver fut, amelyek között elosztjuk a bejövő forgalmat, akkor a rendszerünk valójában 2xt2.micro teljesítményű.

Terheléselosztót a bal oldali menü ''Load Balancing'' szekciójának ''Load Balancers'' menüpontjában hozhatunk létre.

'''A támogatott szolgáltatási szintek:'''
# Alkalmazás terheléselosztás (HTTP, HTTPS)
# Hálózati terheléselosztás (TCP, UDP)
# Átjáró terheléselosztása (GW)

===== Alkalmazás terheléselosztása =====
Ebben a formában konfigurálhatjuk az eszközt úgy, hogy az internet felől elérhető legyen (internet-facing) és úgy, hogy csak belső hálózaton működjön (internal). A belső hálózatot mindig az aktuális VPC-re kell érteni, tehát annak minden alhálózatából elérhető alapértelmezetten.
[[Fájl:GAMFAWS ec2 loadbalancer setup basic.png]]

A hálózati beállításoknál választhatunk, hogy mely alhálózatokban szeretnénk végrehajtani a terheléselosztást, így csak az azokban futó EC2-k kaphatnak ezen keresztül csomagokat. Arra kell ügyelnünk, hogy legalább kettő különböző zónában lévő alhálózatot kell kiválasztanunk (pl. eu-west-1a, eu-west-1b stb.).
[[Fájl:GAMFAWS ec2 loadbalancer setup network.png]]

Természetesen a LoadBalancer internetfelőli végpontján létrehozhatunk ''Security Group''okat, amelyet szabályozzák, hogy milyen IP címről fogadunk el csomagokat.
[[Fájl:GAMFAWS ec2 loadbalancer setup secg.png]]

A ''Listeners and routing'' résznél megadhatjuk, hogy melyik target group fogja a terhelést fogadni, tehát hogy mely EC2-k között tudunk ténylegesen terhelést elosztani. Amennyiben a target group egy darab EC2-t tartalmaz, akkor a terheléselosztás gyakorlatilag nem valósul meg, csak az elméleti esélyét adtuk meg, hogy ''„amennyiben lenne még egy EC2 a target group-ban, akkor a terhelés egy részét az vinné el”''.
[[Fájl:GAMFAWS ec2 loadbalancer setup routing.png]]

Végül kattintsunk a ''Create load balancer'' gombra, amennyiben a kívánt tag-eket is rögzítettük.

==== Auto Scaling Group ====
A szolgáltatás segítségével automatikusan skálázott rendszereket építhetünk ki, ahol a szerverek által nyújtott elérhető erőforrásokat minél közelebb tartja a bejövő terhelés által meghatározott erőforrásigényhez. Természetesen mindez akkor igaz, ha az ''Auto Scaling Group'' be regisztrálja az általa létrehozott ''EC2''-ket egy ''Target Group''-ba, ami felett ''Load Balancing'' van definiálva.

'''Előnyei''':
* Amikor nincs bejövő terhelés, akkor nincsenek nagy költségek
* Amikor nagy a bejövő terhelés, akkor a költségek megugranak ugyan, de az ügyfeleket ki tudtuk szolgálni úgy, hogy elégedettek voltak a rendszer teljesítményével.

'''Hátrányai''':
* Kaotikus számlák, nem előre tervezhető költségek
* Megnövekedett költségek DDoS és egyéb támadások esetén

===== A beállítás lépései =====
A szolgáltatást a bal oldali menü ''Auto Scaling Group'' szekciójában érjük el, az ''Auto Scaling Group'' menüpontban. A képernyő közepén vagy a képernyő jobb felső sarkában megjelenő ''Create auto scaling group'' gombra kattintva egy űrlap jelenik meg, ami végig vezet minket a telepítés lépésein.

'''A Name''' szekcióban elnevezzük az új group-ot.
[[Fájl:GAMFAWS ec2 autoscaling setup name.png]]

'''A következő szekcióban''' két választási lehetőségünk van:
* Launch Template-tel telepítjük az új group-ot, ez esetben csak ki kell választanunk a korábban létrehozott sablont, vagy az alatta található link segítségével készíthetünk újat. ''Amennyiben újat készítünk, a sablon létrehozása új ablakban nyílik meg, így a befejezést követően vissza kéne térnünk erre és a frissítést gombot megnyomva látni fogjuk az új lehetősége(ke)t.
[[Fájl:GAMFAWS ec2 autoscaling setup lt.png]]

* Launch Configuration-nel telepítjük az új group-ot, ez esetben át kell váltatnunk a ''Switch to launch configuration'' link segítségével a blokkot. A váltást követően hasonlóan az előzőekhez: vagy kiválasztjuk a már meglévő konfigurációs sémát, vagy hozhatunk létre újat.
[[Fájl:GAMFAWS ec2 autoscaling setup lc.png]]

'''A Next gombra kattintva a hálózati beállítások''' szekcióhoz érünk, ahol megadhatjuk, hogy az indított EC2 milyen VPC-be kerüljön és azon belül milyen alhálózatokba. VPC-ből egy, alhálózatból több is kiválasztható. Ügyeljünk rá, hogy ha később erre Load Balancer szolgáltatás is kerül, akkor legalább kettő zónát jelöljünk ki!
'''Figyelem!''' A zóna nem egyezik meg az alhálózattal!
[[Fájl:GAMFAWS ec2 autoscaling setup network.png]]

'''A Next gombra kattintva a Load Balancing beállítások''' következnek, ahol választhatunk:
* Nincs terheléselosztás opciót,
* Létező Load Balancer hozzáillesztését,
* Új Load Balancer létrehozását.

Utóbbi esetében a Load Balancer konfigurálásánál leírt módon ki kell töltenünk a Load Balancer űrlapját is helyben. 
[[Fájl:GAMFAWS ec2 autoscaling setup lb setup.png]]

Hasonlóan a ''Target Group''-ot is létrehozhatjuk helyben, amennyiben ezt nem tettük meg korábban.
[[Fájl:GAMFAWS ece autoscaling setup new lb new tg.png]]

'''A Next gombra kattintva a csoport méretét definiálhatjuk''', azaz megszabhatjuk, hogy hány darab szervertől, hány darab szerverig engedélyezzük az automatikus skálázást. Ez egy hasznos funkció, hiszen ezzel korlátok közé szoríthatjuk a költségeinket, miközben a legkisebb terhelés esetén is előkészülhetünk egy hirtelen bejövő nagyobb terhelésre (ha a minimum nem 1).
* Desired capacity: ennyi szervert fog elindítani az ASG mentés után
* Minimum capacity: ennyi szerver esetén már nem állít le semmit az ASG
* Maximum capacity: ennyi szerver esetén már nem indít el újabbat az ASG
[[Fájl:GAMFAWS ec2 autoscaling setup group.png]]

'''Alatta a Scaling Policy''' blokkban megadhatjuk, hogy milyen paraméterek mentén indítson vagy épp állítson le szervereket az ASG. Ehhez aktiválnunk kell a szolgáltatást és a ''Metric type'' listából ki kell választani az számunkra megfelelőt. Mi általában CPU terhelés alapján döntünk az órán.
[[Fájl:GAMFAWS ec2 autoscaling setup scaling.png]]

'''A Next gombokkal lépkedve hozhatunk létre Tag-eket, majd végül létrehozhatjuk az ASG-t is és az ''Instances'' menüpontban ellenőrizhetjük, hogy ténylegesen elindult a kívánt darabszámú szerver.'''

=== RDS szolgáltatások ===
A ''Relational Database Service'' foglalja magában a különböző adatbázisokat:
* MariaDB
* MySQL
* Aurora
* Oracle
* PostgreSQL
* MSSQL

'''Figyelem!''' Az itt felsorolt szerverek között lehetnek fizetősek is. Mindig járjunk el figyelmesen, kövessük a költségeket. Az RDS az amazon egyik legdrágább szolgáltatása.

==== MySQL adatbázis telepítése ====
==== Csatlakozás MySQL adatbázishoz CLI-ből ====
<syntaxhighlight lang="bash">
apt install mysql-client -y
# mysql -h<rds_endpoint> -u<rds_user> -p<rds_password>
mysql -hwebshop-989.rds.amazon.com -uadmin -p123456789
</syntaxhighlight>

A megnyíló '''mysql>''' PROMPT-ot tartalmazó sor azt jelenti, hogy sikeresen csatlakoztunk az SQL szerverhez. Amennyiben a csatlakozás sikertelen, akkor valószínűleg az RDS-hez kapcsolt Security Group beállításai nem engedik az EC2-ről a kapcsolódást - tipikusan a mi saját publikus IP címünk kerül bele az engedélyezett tartományba (pl. iskolai IP vagy otthoni) és ez nem került átírásra az amazonos tartománynak megfelelően.

A konzolra be kell illeszteni a ''networks.sql'' fájl tartalmát. A végén '''exit''' paranccsal léphetünk vissza a BASH környezetbe.

=== VPC ===
A '''V'''irtual '''P'''rivate '''C'''loud egy szolgáltatás, melynek segítségével össze köthetjük az összetartozó komponenseket, alkalmazásokat. A VPC-t modellezhetjük hétköznapibb értelemben, mint egy routert, amelynek vannak alhálózatai, route táblája és valamilyen gateway címe, amin keresztül a kliensei az internet más résztvevőivel tudnak kommunikálni.

A VPC szolgáltatásait a keresőbe írt ''VPC'' kulccsal érhetjük el.
==== VPC létrehozása ====
Navigáljunk a 'Your VPCs' menüpontra a bal oldali menüben és kattintsunk a jobb felső sarokban látható ''Create VPC' gombra. Ezután megnyílik egy űrlap, amely végig vezet minket a telepítés lépésein.

Az űrlap elején választhatunk, hogy ''VPC only'' vagy ''VPC and more'' módban szeretnénk folytatni. Előbbi csak a VPC-t hozza létre nevéből is adódóan, míg a másik opcióval létrehozhatjuk az alhálózatokat is, igaz, a tervezés szabadságáról le kell ilyenkor mondanunk, cserébe grafikán láthatjuk az eredményt. Számunkra az órán utóbbi nem lesz megfelelő, hiszen szükségünk lesz a ''tervezés szabadságára''. 
[[Fájl:GAMFAWS vpc setup.png]]

A VPC beállításainál mindig a teljes hálózatot átfogó IP/MASZK párost kell megadnunk, később az alhálózatok nem lóghatnak ki az itt megadott tartományból.

==== Alhálózatok ====
Az alhálózatok lehetőséget biztosítanak arra, hogy az egyes komponenseket el is szigeteljük egymástól, meg engedélyezzünk is közöttük bizonyos kommunikációt.

Alhálózatok típusai:
* Publikus: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten kapnak publikus IP címet
* Privát: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten nem kapnak publikus IP címet

===== Alhálózatok létrehozása =====
Navigáljunk a ''Subnets'' menüpontra. A képernyő jobb felső sarkában kattintsunk a ''Create subnet'' gombra, így megkapjuk a létrehozási űrlapot.

'''Először''' a VPC-t kell kiválasztanunk, aminek eredményeképp kiírja segítségképp annak tartományát. Ezen a tartományon kívül nem léphetünk. 
[[Fájl:GAMFAWS vpc subnet setup.png]]

A VPC kiválasztása után aktívvá válik az alhálózatok űrlap, ahol megadhatjuk annak nevét, hálózati címét és maszkját. 
[[Fájl:GAMFAWS vpc subnet setup new.png]]

'''Figyelem!''' A rendszer csak hálózati címet fogad el! Minden más esetben hibát ír ki.

A ''Remove'' gombbal eltávolíthatjuk az aktuális konfigurációt a listából, míg a lentebb található ''Add new subnet'' segítségével újabbat vehetünk fel.

Befejezésül nyomjuk meg a ''Create subnet'' gombot, így az összes definiált alhálózat létrejön a kiválasztott VPC-hez.

===== Publikus/Privát alhálózat beállítása =====
Az alhálózat típusának átállításához navigáljunk a ''Subnets'' menüpontra. Kattintsunk jobb gombbal a kívánt alhálózat során és válasszuk ki az ''Edit subnet settings'' opciót. 
[[Fájl:GAMFAWS vpc subnet edit s settings.png]]

Az űrlapon keressük meg az ''Auto-assign IP settings'' blokkot és a kívánt típusnak megfelelően módosítsuk azt.
[[Fájl:GAMFAWS vpc subnet edit type.png]]

===== Különböző route tábla minden alhálózaton =====
A VPC támogatja, hogy minden subnet saját route táblával rendelkezzen. Ez lehet akár egy biztonsági funkció is, hogy ne ismerje minden EC2 az útvonalat egy adott szerverhez, de egyes esetekben kötelezően létre kell hoznunk. A route táblákat a ''Route tables'' menüpontban hozhatjuk létre és a ''Subnets'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Edit route table association'' opciót kiválasztva szerkeszthetjük.

'''Figyelem!''' A route táblák cseréje okozhat internetelérési problémákat szerver oldalon, aminek következtében a futó szolgáltatások számunkra is elérhetetlenekké válnak (pl. SSH és/vagy HTTP/HTTPS stb.), így legyünk körültekintőek.

==== Internet Gateway ====
Ahhoz, hogy a VPC-n belül legyen internet, ahhoz egy IGW-t kell hozzá csatolnunk. Ezt megelőzően azonban létre kell hoznunk egyet.
'''Figyelem!''' A VPC-hez nem kapcsolt IGW-k pénzbe kerülhetnek, mivel feleslegesen foglalnak le egy publikus IPv4 címet.

[[Fájl:GAMFAWS vpc igw setup.png|bélyegkép|Internet Gateway létrehozás]]
Az IGW az ''Internet Gateways'' menüpont alatt érhető el és a jobb felső sarokban található ''Create internet gateway'' gombbal hozhatunk létre újat. Csupán egy nevet kell megadnunk, illetve rakhatunk rá tag-eket igény szerint.

A létrehozást követően hozzá kell rendelnünk egy létező VPC-hez, amit az ''Internet Gateways'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Attach to VPC'' opciót kiválasztva tudunk megtenni. Amennyiben a soron az ''Attached'' (zöld színű) felirat jelenik meg a (szürke színű) ''Detached'' helyett, akkor nem tudjuk VPC-hez csatolni (ilyenkor először a ''Detach from VPC'' opciót kell választanunk). 
[[Fájl:GAMFAWS vpc igw attach.png]]

Az IGW VPC-hez rendelése után a kívánt route táblákba fel kell vennünk, hogy minden csomagot arra irányítson.
[[Fájl:GAMFAWS vpc igw route setup.png]]

==== NAT Gateway ====
Lehetőség van Internet Gateway helyett NAT Gateway létrehozására is, de ez egy fizetős szolgáltatás. A nevének megfelelően ez lehetőséget biztosít, hogy azok az EC2-k, amelyek privát alhálózatba kerültek, kilássanak az internet felé (pl. frissítések keresése, telepítése), miközben védve vannak a kívülről érkező támadásoktól.
'''Ez egy lehetséges oka lehet, hogy külön válasszuk a route táblákat az alhálózatokon, hiszen az egyiknek minden csomagot az IGW felé, míg a másiknak minden csomagot a NAT Gateway felé kell továbbítania.''' ''Ha nem használunk NAT Gatewayt, akkor is érdemes lehet leválasztani az IGW-ről a privát alhálózatokat.''

=== AWSCLI ===
Az AWSCLI egy konzolos alkalmazás, amelynek segítségével menedzselhetjük környezetünket: hozhatunk létre új EC2-t akár, vagy kapcsolhatunk hozzá egyéb szolgáltatásokat (Security Group, ASG, LB stb.).

Az awscli program elérhető linux és windows környezetben egyaránt.

==== AWSCLI telepítése ====
A program telepítéséhez a következő parancsot kell futtatnunk: '''apt install awscli'''.
==== Access Key management ====
Az ''awscli'' hozzáférési kulcsokon keresztül kap jogosultságot a szolgáltatások adataihoz, így használata előtt készítenünk kell egy újat. Ez a nevünkre kattintva (jobb felül), majd a ''Security credentials'' menüpontot kiválasztva tehetjük meg, az ''Access keys'' szekcióban. Nyissuk ezt le és kattintsunk a ''Create New Access Key'' gombra. 
<center>
{|
| [[Fájl:GAMFAWS UserMenu.png|150px|keretnélküli]] || [[Fájl:GAMFAWS SecurityCredentials.png|keretnélküli]]
|}
</center>

A gomb megnyomása után egy felugró ablak fogad, amelyben megtalálható az ''Access Key'' és a ''Security Access Key'' értéke. Érdemes a fájlt letölteni, hogy később is elérhetők legyenek ezek az adatok, '''az AWS többet nem fogja engedélyezni ezek megjelenítését!''' Ha az adatokat később nem tudjuk megadni, akkor újat kell készíteni.
[[Fájl:GAMFAWS SecurityCredentials ShowData.png|középre]]

==== AWS CLI konfigurálás autentikációs adatokkal ====
Az eszköz telepítése annak konfigurálásával ér véget: meg kell adnunk az autentikációs tokeneket. 
Ezt az '''aws configure''' parancs kiadásával tehetjük meg, ahol egyesével bekéri a szükséges adatokat. Ahol nem szeretnénk változtatni az előző értéken (szögletes zárójelek között láthatjuk ezt), ott hagyjuk üresen a sort és csupán entert nyomjunk.
[[Fájl:GAMFAWS AWSCLI config.png|középre]]

Az adatok megadása után menedzselhetjük az aws parancsokkal a környezetünket. Az aws parancsairól az '''aws help''' szolgáltat információt.

=== S3 ===
Ez a szolgáltatás fájlok tárolására alkalmas.

Több típusa is elérhető:
* Standard:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban sűrűn használt objektumok tárolására alkalmas
** A régiók közötti szinkronizáció megoldott
* Instant Glacier:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban ritkábban használt, hosszú élettartamú, de azonnali hozzáférést igénylő objektumok tárolására alkalmas
* Flexible Glacier:
** Magas rendelkezésre állás jellemzi
** Az alkalmazásban ritkán használt (évente 1x-2x), a mérettől független költséggel rendelkező megoldás
* Deep Archive Glacier:
** 7-10 évig tárolt adatokhoz optimalizált költségvonzat
** Előnyös a backup adatok tárolásához

A szolgáltatás a keresőben ''S3'' füzérrel kereshető.

==== Bucket létrehozása ====
Új tárolót a ''Create bucket'' gomb segítségével hozhatunk létre. A megjelenő űrlapon a nevet kell kitölteni és érdemes egy pillantást vetni a publikusság beállításaira is, hogy ez ténylegesen a célunknak megfelelő legyen.

'''Figyelem!''' A névnek nem csupán a mi környezetünkön belül kell egyedinek lennie, hanem a teljes AWS-en belül.

{| style="margin:auto"
| [[Fájl:GAMFAWS S3 new name.png|bélyegkép]] || [[Fájl:GAMFAWS S3 new public.png|bélyegkép]]
|}

==== Bucket kezelése ''awscli'' programmal ====
Az '''aws s3 help''' parancs segítségével további információt szerezhetünk az egyes utasításokról.

'''Bucket tartalmának listázása''' 
<syntaxhighlight lang="bash">
aws s3 ls [bucket_name]
</syntaxhighlight>
[[Fájl:GAMFAWS S3 CLI LS.png|középre]]

'''Adatok másolása Bucket-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* LOCAL_PATH a lokális fájlrendszeren belüli elérési útvonala a forrásfájlnak (vagy könyvtárnak)
* REMOTE_PATH a cél helye az S3-ban
** Az s3:// jelzi, hogy a cél az S3-ban van (S3Uri)
** A mappák helyett PREFIX-ek vannak (/folder/to/my/file esetében /folder/to/my a PREFIX)
** A mappákat nem kell S3-ban létrehoznunk (az előző pontból következik), a fájlnév előtti prefix dönti el a hova tartozását
** A PREFIX-eket az '''ls''' úgy kezeli, mint egy mappát
[[Fájl:GAMFAWS S3 AWSCLI cp2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* --recursive jelzi, hogy a LOCAL_PATH alatt minden bejegyzést töltsön fel
[[Fájl:GAMFAWS S3 AWSCLI copy recursive2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ból helyi fájlrendszerbe''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive s3://REMOTE_PATH LOCAL_PATH
</syntaxhighlight>
[[Fájl:GAMFAWS S3 AWSCLI cp2local.png|középre]]

==== Bucket kezelése grafikus felületen keresztül ====
Az S3 tartalmát elérhetjük az AWS grafikus felületén keresztül is, így tölthetünk fel, törölhetünk és módosíthatunk fájlokat anélkül, hogy saját számítógépünkre telepítenénk az ''awscli'' programot.

# Nyissuk meg az S3 szolgáltatás vezérlőpultját
# Kattintsunk a szerkeszteni kívánt tárhely nevére [[Fájl:GAMFAWS S3f list.png]] 
# A vezérlőgombok segítségével végezzük el a kívánt műveletet (feltöltés, törlés), vagy válasszunk ki egy PREFIX-et az „almappák” tartalmának megtekintéséhez. [[Fájl:GAMFAWS S3 control.png|középre]]

= Alkalmazások telepítése =
== UI ==
== API ==

= Indítást gyorsító scriptek =
== UI indítás ==
<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun code
API_LB_DOMAIN="localhost" # api server IP

apt update
apt install wget unzip apache2 libapache2-mod-php8.3 php8.3 php8.3-curl -y

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui.php
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui_newproduct.php
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv ui.php /srv/$NEPTUN/index.php
mv ui_newproduct.php /srv/$NEPTUN/newproduct.php

# remove tmp directory
cd /
rm /tmp/code

cat << EOF > /etc/apache2/sites-enabled/000-default.conf
<VirtualHost *:80>
#ServerName www.example.com

ServerAdmin webmaster@localhost
DocumentRoot /srv/$NEPTUN

<Directory /srv/$NEPTUN/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>

ErrorLog \${APACHE_LOG_DIR}/error.log
CustomLog \${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

systemctl restart apache2
</syntaxhighlight>

== API indítás ==

<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun
MYSQL_DOMAIN="localhost" # RDS mysql domain

apt update
apt install wget unzip python3 python3-pip python3-flask -y
pip3 install mysql-connector-python --break-system-packages

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$MYSQL_DOMAIN/g" api.py
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv api.py /srv/$NEPTUN/

# remove tmp directory
cd /
rm /tmp/code

echo "@reboot root sleep 10s && python3 /srv/$NEPTUN/api.py &" >> /etc/crontab
cd /srv/$NEPTUN && python3 api.py &
‎</syntaxhighlight>

EDU::GAMF::Felhőalapú-szolgáltatások::AWS

2025-10-14T06:23:39Z

ApelPro: /* UI indítás */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
[[category:GAMF AWS|AWS]]
== Amazon Web Services regisztráció ==
Az AWS mindenki számára biztosít 1 év ingyenes próbaverziót. Ehhez regisztrálnunk kell a rendszerbe, amihez szükségünk lesz egy email címre, egy telefonszámra a megerősítéshez és egy netes vásárlásra alkalmas bankkártyára. A regisztráció során az AWS 1$-ral meg terheli a számlát, de később erre nem tart igény, így a tranzakció lejáratakor jóváíródik a számlán.

== Ingyenes verzió korlátai ==
Az ingyenes verzióban nem minden érhető el és ami mégis, az sem korlátlan ideig (750 óra EC2 futási idő például), amit ha átlépünk, akkor fizetési kötelezettségünk jelentkezik a szolgáltató felé. Igyekezzünk mindent leállítani az órai munka illetve az otthoni gyakorlás után, hogy lehetőleg ne kerüljön pénzbe a féléves munkánk. A hallgatók által elszenvedett károkért sem az iskola sem Én nem tudunk felelősséget vállalni, de azt meg tudjuk ígérni, hogy fizetős szolgáltatást nem használunk és nem is kérünk számon.

== AWS alapok ==
'''Figyelem!''' Az iskolai hálózatból csak az eu-west-1 és az eu-central-1, azaz Írország és Frankfurt IP címei vannak engedélyezve, ezekre fogunk tudni SSH kapcsolaton keresztül csatlakozni. 
'''Figyelem!''' Próbaidőszak alatt minden szolgáltatás mellett keressük a ''Free tier eligible'' megjegyzést, különben fizetési kötelezettségünk adódhat!

=== EC2 szolgáltatásai ===
Az ''EC2'' gyakorlatilag egy VPS-nek feleltethető meg és nem is tévedünk vele hatalmasat. A neve az ''Elastic Cloud Compute'' szavak kezdőbetűiből kialakuló ''ECC''-ből fakad, a ''2''-es a végén jelzi, hogy a ''C'' betűből kettő van.

A különbséget a VPS-hez az EC2 futási ideje okozza: bár nem feltétlen, de meg van a lehetősége, hogy egyik napról a másikra megszűnjön egy EC2 úgy, hogy az alkalmazásunk mégis működőképes marad. E tulajdonsága miatt kapta az ''Elastic'' nevet, amit körültekintően kell kezelni: semmilyen adatot nem tárolhatunk úgy egy alkalmazáson belül, mint egy VPS esetén: a dinamikus adatok (pl. PHP Session, feltöltött fájok) egy EC2 csere esetén elvesznek, így ezeket nem helyben fogjuk tárolni.

Az EC2 szolgáltatásait a keresőmezőbe írt ''„EC2”'' kulcsszóval és az eredményekben megjelenő ''EC2''-re való kattintással érhetjük el.

[[Fájl:GAMFAWS search EC2.png.png]]

Az alapértelmezetten megjelenő menüpont a ''Dashboard'', ahol információkat találhatunk az ''EC2'' köré felhúzható szolgáltatásokról, melyeknek egy részét a továbbiakban tárgyalni is fogunk. Az összefoglaló táblázat az alább látható módon jelenik meg. '''Figyelem''', a táblázat csak az adott régióban elindított/elérhető szolgáltatásokat mutatja, régió váltása előtt érdemes az esetlegesen létrehozott, régió függő elemeket leállítani, hogy később ne jelenjen meg fizetési kötelezettség.

[[Fájl:GAMFAWS ec2 dashboard.png]]

==== EC2 telepítése és beállítása ====
EC2 létrehozásához meg kell nyomnunk a ''Launch instance'' gombot, melyet több helyen is elérhetünk:
* A Dashboardon
* A bal oldali menüben található ''Intances'' menüpont megnyitása után jobb felül
A gomb minden esetben a következőképp néz ki: [[Fájl:GAMFAWS ec2 launch instance button.png]]

A gombra kattintva egy űrlap jelenik meg, amely segítségével elvégezhetjük a szükséges beállításokat: 
======Név és tag beállítok======
Megadása nem kötelező, de több szerver futtatása esetén könnyebben azonosíthatjuk be őket ezek segítségével
[[Fájl:GAMFAWS ec2 setup name and tags.png]]

Az ''Add additional tags'' gombra kattintva további kulcs=érték párokat adhatunk hozzá, amivel dinamikusan csatolhatjuk össze egyéb szolgáltatásokkal, amelyek egy-egy kulcsot keresve döntik el, hogy melyik szolgáltatásokkal kell együttműködniük (például monitorozás bekapcsolása 'monitoring=true' kulcs=érték pár alapján.

======Kezdeti képfájl kiválasztása======
Az Amazon többféle indítóképpel is rendelkezik, így nagy valószínűséggel meg fogjuk találni a hozzánk közelálló operációs rendszert. Új hozzáadására nincs lehetőségünk, de készíthetünk az alapképfájlokból olyan verziót, ami már tartalmazza a saját konfigurációnkat (lásd [[GAMF :: Felhőalapú-szolgáltatások :: AWS#AMI_létrehozása|itt]]). 
[[Fájl:GAMFAWS ec2 setup AMI choose2.png]] 
Az órákon az Ubuntu legújabb verzióját használjuk, mivel ennek a Desktop változata az egyik legelterjedtebb a Linux felhasználók körében, így nem kell más környezetet megszoknia egy átlag hallgatónak. Érdemes lehet azonban egyéb disztribúciók kipróbálása is, különösen a '''Debian'''-t, '''Suse'''-t/'''OpenSuse'''-t, '''ReadHat'''-et és annak ingyenes változatait ('''AlmaLinux''', '''RockyLinuxtm''', amelyek az egykori '''CentOS'''-t hivatottak váltani), mivel céges környezetben ezek sűrűbben előfordulnak: némelyik a kisebb erőforrásigénye, míg másik az Enterprise szolgáltatásai miatt.

======Szerver típusának meghatározása======
Különböző erősségű szerverkonfigurációk közül választhatunk, de természetesen nem mindegyik érhető el az ingyenes verzióban. A számítógépek ára a konfiguráció függvényében változik, de csak azért az időért kell fizetni, amíg a szerver ''Running'' állapotban volt. Az órán az alapértelmezett ''t2.micro''-t használjuk. 
[[Fájl:GAMFAWS ec2 setup instance type.png]]

======Kulcspár hozzárendelése======
Az Amazonon belüli szolgáltatásokat felhasználónév/jelszó páros helyett SSH kulcspárok segítségével érjük el. Minden felhasználó számára készíthetünk egyet és jogosultságok segítségével korlátozhatjuk, hogy mihez férhet hozzá (IAM). 
Ebben a szekcióban ki kell választanunk, hogy a telepíteni kívánt EC2-höz milyen kulcspárral lehet majd hozzáférni. Amennyiben nem rendelkezünk még kulcspárral, úgy van lehetőségünk helyben elkészíteni a ''Create new keypair'' gomb segítségével, amelynek lépési megegyeznek az [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Kulcspár_létrehozása|itt]] leírtakkal. 
[[Fájl:GAMFAWS ec2 setup keypair.png]]

======Hálózati és biztonsági beállítások======
Az EC2-k közötti kommunikációs csatornák kialakításához definiálnunk kell, hogy melyik virtuális hálózatba akarjuk elhelyezni és milyen alkalmazásokat szeretnénk elérhetővé tenni. Ezt a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#VPC_beállításai|VPC]] és a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Security_Group|Security Group]] beállításával tehetjük meg. Előbbi a virtuális hálózatnak felel meg, míg utóbbi hasonlóan egy tűzfalhoz, meghatározza, hogy a szerveren milyen portokat érhetünk el. Érdemes az SSH-t engedélyezni és ha webes alkalmazást szeretnénk rajta futtatni a későbbiekben, akkor a HTTP és/vagy HTTPS szolgáltatást/szolgáltatásokat is, így később nem kell szerkeszteni ezeket a beállításokat. 
[[Fájl:GAMFAWS ec2 setup networking.png]]

======Tárhely beállítások======
Ebben a részben adhatjuk meg, hogy a szerverünk mekkora tárhellyel rendelkezzen. Egy Linux alapú operációs rendszernek nem kell 8GB-nél több, így az alapértéken hagyhatjuk. Az itt megadott érték inkább csak egy korlát, valójában csak akkora tárhelyet vesz igénybe, amennyire ténylegesen szüksége van a rendszernek. Ez az érték alatt látható figyelmeztetés miatt lényeges, hiszen a 30GB-t elhagyva fizetőssé válik a tárterület is, ám ez nem jelenti, hogy csak 4 szervert tudnánk elindítani az ingyenes keretek között. 
[[Fájl:GAMFAWS ec2 setup ebs.png]]

Ezt a szolgáltatást EBS-nek nevezik (''Elastic Block Store'') és az EC2 megszűnésekor minden erre mentett adat elveszik, így általában az OS-t és az applikáció kódját tároljuk ezen - semmi dinamikus adatot.

======Haladó beállítások======
Ebben a szekcióban különböző beállításokat végezhetünk el, ám ezeket az órán nem módosítjuk. Érdekes lehet azonban a menüt lenyitva legalul található ''User data'' opció, amivel parancsokat adhatunk meg az új operációs rendszer számára, hogy miket futtasson le. Ennek segítségével lehetőségünk nyílik applikációk telepítésére - pl. git - és a kód letöltésére egy másik szerverről, amennyiben a kiválasztott képfájl nem tartalmazta azt. 
''Az órai keretek között ezt a funkciót nem használjuk ki, de érdemes lehet kipróbálni, mivel valós alkalmazások üzemeltetésekor jól jöhet.'' 
[[Fájl:GAMFAWS ec2 setup userdata.png]]

======Összefoglaló======
A beállító panel mellett jobbra találhatjuk az összefoglaló ablakot, amelyben megtalálható a ''Launch Instance'' gomb. Ennek segítségével kezdhetjük meg a végleges telepítést, ha erre rá nyomunk, akkor a rendszer megkezdi a kiválasztott konfiguráció telepítését. Ha ebben az ablakban pénzösszegeket látunk, akkor az egészen biztosan fizetési kötelezettséget vonz magával, legyünk körültekintőek. 
[[Fájl:GAMFAWS ec2 setup summary.png]]

======Az elkészült instance tulajdonságai======
A futó szerverek az ''Instances'' menüpontban érhetők el. Az egyes sorokra kattintva alul megtekinthetjük a beállításait, amely tartalmazza az AWS által kiosztott publikus és privát IP címeket és domain neveket. Ezeken keresztül tudunk kommunikálni szerverünkkel. 
[[Fájl:GAMFAWS ec2 properties.png]] 
''Jelen példában a külső IP címünk: 3.252.168.207, amit a mellette található ikonnal egyszerűen a vágólapra másolhatunk.''

======Csatlakozás Linux terminálból======
A csatlakozáshoz nyissunk meg egy terminált a CTRL+T billentyűkombinációval, majd navigáljunk a ''cd'' parancs segítségével a letöltött kulcsfájl mappájába. Az SSH megköveteli, hogy a csatlakozáshoz használt kulcsfájlhoz csak a tulajdonos felhasználó férjen hozzá, így a következő parancsot futtassuk le rajta: ''chmod 600 test.pem''

A következő paranccsal tudunk kapcsolódni: ''ssh -i test.pem ubuntu@3.252.168.207'' 
Ha a fenti parancs kéri, fogadjuk el a tanúsítványt. Amennyiben ''Permission error'' hibát kapunk, akkor a fenti ''chmod'' parancsra van szükségünk, vagy nem mi vagyunk a kulcsfájl tulajdonosai (''ls -l'' segíthet). 
A ''test.pem'' az AWS rendszerből letöltött .pem formátumú kulcsfájl, az ''ubuntu'' a szerveren elérhető felhasználó. A különböző disztribúcióknál használt felhasználónevekről [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connection-prereqs.html ezen] a linken tájékozódhatsz. 
[[Fájl:GAMFAWS ec2 connect linux.png]]

======Csatlakozás Putty használatával======
Amennyiben a .pem kiterjesztésű állományt töltöttük le az AWS rendszeréből, akkor a '''puttygen''' eszköz segítségével ki kell exportálni belőle a privát kulcsot. [https://www.ssh.com/academy/ssh/putty/windows/puttygen Ezen a linken] részletes segédlet található a programcsomaghoz, ahol további funkciók is bemutatásra kerülnek (pl. kulcsgenerálás).

==== Kulcspár létrehozása ====
A kulcspárok kezeléséhez a ''Key Pairs'' linket nyissuk meg a bal oldali menüből. Újat a jobb oldalon látható ''Create key pair'' gomb segítségével készíthetünk. [[Fájl:GAMFAWS ec2 keypair create.png]]

A gombra kattintva egy űrlapot kapunk, amely végig vezet minket a létrehozás lépésein.
# Név megadása
# Típus kiválasztása - ''RSA-val dolgozunk az órán''
# Letöltendő kulcs típusa - ''Linux terminálból való csatlakozáshoz a .pem fájlra lesz szükségünk''
# Esetleges tag-ek hozzárendelése
# A ''Create key pair'' gombra kattintva letölthetjük a kulcspárt

[[Fájl:GAMFAWS ec2 keypair setup.png|Kulcspár létrehozása]]

'''Figyelem!''' A kulcspár csak a létrehozás után tölthető le '''egyetlen egyszer''', az elvesztett fájlok nem reprodukálhatók! Amennyiben egy EC2 csak az elhagyott kulcspárral érhető el, úgy annak (EC2) törlése és újrakonfigurálása szükséges egy új kulccsal.

==== Security Group ====
A Security Group-ok segítségével kontrollálhatjuk, hogy a szervereinkhez milyen portokon férhetnek hozzá, tehát mintegy tűzfal működik. Egy Security Group több gépre is ráhúzható és függetlenül működik, azaz a megadott szabályokat nem másolja át az operációs rendszer konfigurációs állományaiba, mintegy a szerver elé telepített eszköz működik. Ennek köszönhetően futási időben változtathatjuk a szabályokat, életbelépésükhöz nem kell újracsinálni az EC2-ket.

A bal oldali sávban, a ''Network & Security'' csoportban érhető el.

===== Security Group hozzáadása =====
Egy új szabályrendszer felvételét kezdeményezhetjük az EC2 telepítésekor, ahogyan azt [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Hálózati_és_biztonsági_beállítások|itt]] is láthattuk, de készíthetünk előre meghatározottakat is.

Az előre definiált csoportokat a ''Create Security Group'' gomb segítségével hozhatjuk létre, amelyet a jobb felső sarokban találhatunk meg. 
[[Fájl:GAMFAWS ec2 secg new button.png|bélyeg]sdfsad] 

A gomb megnyomását követően egy űrlapot kapunk, melynek 3 fő része van:
# Általános adatok [[Fájl:GAMFAWS ec2 secg new basic.png|bélyeg|Általános adatok]]
#* '''A név és a leírás mező megadása is kötelező'''
#* Itt választhatjuk ki, hogy mely VPC-ben szeretnénk elérhetővé tenni.
# Bejövő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg inbound.png|bélyegkép|Inbound rules]]
#* '''Az itt megjelenő szabályok lesznek engedélyezve a szerverünk felé, minden más csomag eldobásra kerül'''
#* Háromféle szabályból választhatunk:
#** '''Anywhere''' (IPv4, IPv6): A megadott IP típusból mindenhonnan elfogadjuk a csomagokat
#** '''Custom''': Csak a megadott IP címekről/IP tartományokból érjük el az adott portot
#** '''MyIP''': automatikusan beillesztésre kerül az felhasználó aktuális IP címe (hasonló a custom lehetőséghez)
# Kimenő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg outbound.png|bélyegkép|Outbound rules]]
#* A kimenő forgalom szabályozása biztonsági szempontból megfontolandó, de természetesen a publikus alkalmazások esetében (pl. web) nem tudunk ilyen szűrést alkalmazni.
#* Alkalmazhatjuk például SSH-ra, hogy megszüntessük annak a lehetőségét, hogy egy esetleges fertőzésből kifolyólag SSH-t hackelgető botnetté változzunk (volt már hasonló tapasztalat).
#* Az órán ezzel bővebben nem foglalkozunk, de éles környezetben ne felejtsünk el ezen szabályok definiálására időt szánni.
# Tag-ek megadása

===== Security Group szerkesztése =====
A szerkeszteni kívánt soron kattintsunk jobb gombbal és válasszuk ki a szerkeszteni kívánt szabályok csoportját:
* '''Edit inbound rules''', ha a bejövő csomagok szűrését szeretnénk módosítani,
* ''' Edit outbound rules''', ha a kimenő forgalmat szeretnénk szűrni.
A megnyíló ablakban ugyanazon a módon vehetünk fel szabályokat, ahogyan a létrehozásnál. A módosítások mentés után életbe lépnek. 
[[Fájl:GAMFAWS ec2 secg context menu.png]]

==== Terheléselosztás vázlat ====
[[Fájl:EC2LoadBalancingRequirements.png|középre]]

==== AMI ====
Az AMI gyakorlatilag egy bitről-bitre lemásolt HDD képfájl, amely tömörítve lett. Így tárolja az összes elmentett adat- és konfigurációs állományt. Ha egy alkalmazást készítünk, akkor a következő okokból készítünk ilyen képfájlt:
# Biztonsági mentés a telepített szolgáltatásokról, így később nem kell egy esetleges hiba miatt újrakonfigurálni az egészet
# AutoScaling group-ba szeretnénk rendezni az alkalmazásunkat, annak pedig meg kell mondani, hogy melyik képfájlt indítsa el

'''Figyelem!''' A képfájlok úgynevezett snapshot-okat hoznak létre, amelyek tárolásáért fizetni kell, ha az összméret meghaladja a 8GB-ot. (A snapshotok az éppen futó rendszer miatt készülnek: minden írási műveletet lezár, majd a snapshot készítés után elindított írási műveletek már a háttértár egyéb területeire történik, amelyet a mentés nem fog tartalmazni, így garantálható, hogy nem lesznek félig lezárt fájlok a mentésben. Lásd bővebben: BTRFS (linux) és NTFS support). A pillanatképek nem törölhetők, amíg a belőlük készült AMI létezik!

===== AMI létrehozás lépései =====
'''Navigáljunk az Instances menüpontra, ahol láthatjuk, hogy milyen EC2 szolgáltatások vannak a rendszerünkben.'''
# Kattintsunk jobb gombbal azon az elemen, amelyet menteni szeretnénk
# Nyissuk ki az ''Image and templates'' menüpontot
# Kattintsunk a ''Create image'' lehetőségre 
[[Fájl:GAMFAWS ec2 ami create.png]]

'''Nevezzük el a képfájlt tetszés szerint''' 
[[Fájl:GAMFAWS ec2 ami setup.png]]

'''Navigáljunk a bal oldalon található menüben az ''Images'' szekcióhoz és válasszuk ki az ''AMIs'' elemet. Itt megtekinthetjük és törölhetjük a létrehozott képfájljainkat.''' 
[[Fájl:GAMFAWS ec2 ami list.png]]

'''Ha a mentés sikeresen elkészült, akkor az EC2 létrehozásánál kiválaszthatjuk azt.''' 
[[Fájl:GAMFAWS ec2 setup own ami select.png]]

==== Indítási konfigurációk elkészítése ====
Az indítási konfigurációk mind egy célt szolgálnak: egységes profilba rendezi az EC2-ről készült képfájlokat. Míg az AMI nem tárolt információt a mentett gép erőforrásáról, egy indítási konfigurációban megadhatjuk ezeket. Később ezek felhasználásával egyszerűbben indíthatunk újabb szervereket és vannak olyan esetek is, amikor a rendszer megköveteli, hogy a képfájl megadása helyett konkrét, hardverinformációkat is tároló konfigurációs sablonokat adjunk meg.

''Az Auto Scaling Group például megköveteli, hogy a következő kettő elem közül az egyiket megadjuk, ebből fogja tudni, hogy milyen típusú EC2-t, mekkora tárhellyel és milyen VPC-ben indítson el.''

===== Launch configuration =====
'''Egy kifutóban lévő konfigurációs séma, amely 2022. December 31-e után nem kapja meg a frissítéseket. Az AWS javaslata szerint érdemes ezeket a beállításokat a következőkben tárgyalt ''Launch template'' alá migrálni.

A ''Launch configuration'-nek nevezett séma egy egyszerűsített változata a sablonoknak. Jóval kevesebb beállítási lehetőséget tartalmaz, mint a párja, de tökéletesen elegendőt az ''Auto Scaling Group''hoz.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Auto Scaling group'' szekciót és válasszuk ki a ''Launch Configuration'' menüpontot. A jobb felső sarokban található ''Create launch configuration'' gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''Név megadása''', aminek segítségével később hivatkozhatunk erre az elemre. Kitöltése kötelező! 
[[Fájl:GAMFAWS ec2 launch conf setup name.png]]

''AMI kiválasztása'', tehát azok képfájl megadása, amit a kiválasztott EC2 konfiguráció futtatni fog. Lehetőségünk van a saját készítésű (''My AMIs'') és a közösségi képfájlok közül választani (''Marketplace''). 
[[Fájl:GAMFAWS ec2 launch conf setup ami.png]]

'''Instance típus''' alatt megadhatjuk, hogy a konfiguráció milyen teljesítményű legyen.
'''Ne feledjük el, hogy a t2.micro az ingyenes, a többi használata után fizetési kötelezettségünk jelenhet meg.'''
[[Fájl:GAMFAWS ec2 launch conf setup instance type.png]]

'''Az Additional configruation''' részben megadhatunk különböző paramétereket, amelyeket az EC2 fog felvenni - pl. mindenképp kapjon IP címet, a subnet beállításaitól függetlenül, vagy éppen ne kapjon; itt adhatjuk meg a telepítéskor lefuttatott scripteket (User data).

'''A Storage''' szekcióban megadhatjuk, hogy milyen lemezek és milyen méretűek legyenek a rendszerhez csatolva.

'''A Security Group''' részben kiválaszthatunk egy már meglévő szabályrendszert, vagy készíthetünk újat. 
[[Fájl:GAMFAWS ec2 launch conf setup secg.png]]

'''A Key pairs''' blokkban megadhatjuk, hogy milyen privát kulccsal léphetnek be a szerverekre. Ennek meglétét jóvá kell hagyni az alul található checkbox-szal. 
[[Fájl:GAMFAWS ec2 launch conf setup keypair.png]]

'''Végül kattintsunk a ''Create launch confgiration'' gombra a létrehozáshoz.'''

===== Launch template =====
A Launch template jóval gazdagabb a beállítási lehetőségekben, mint párja. A konfigurációs adatlap tartalmaz segédletet az AutoScaling Group-pal történő használathoz, amely ''required'', azaz kötelező mezőként jelöli meg azokat az adatbeviteli elemeket, amelyeket az automata skálázó rendszer használ. Érdemes ezt bekapcsolni, amennyiben ilyen célzattal készítjük el a sablonunkat.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Instances'' szekciót és válasszuk ki a ''Launch template'' menüpontot. Az oldal közepén vagy a jobb felső sarokban található Create launch configuration gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''A sablon neve és leírása''' blokkban megadhatjuk a nevet és a leírást, de ugyanakkor itt választhatjuk ki azt a checkboxot is, ami később a segítségünkre lesz a konfigurációs sablon AutoScaling Group-hoz való illesztését is (''Auto Scaling guidence''). 
[[Fájl:GAMFAWS ec2 launch templ setup name.png]]

'''Az Application and OS images''' szekcióban megadhatjuk, hogy milyen AMI-val települjön az EC2. Itt választhatunk a sajátunkból, vagy az EC2-nél is megtalálható egyebekből. 
[[Fájl:GAMFAWS ec2 launch templ setup ami.png]]

'''Az Instance type''' csoportban megadhatjuk, hogy milyen teljesítményű gépet szeretnénk indítani.
'''Ne feledjük el, hogy az ingyenes változatban a t2.micro érhető el, másik lehetőség választása esetén fizetési kötelezettségek léphetnek fel!''' 
[[Fájl:GAMFAWS ec2 launch templ setup instancetype.png]]

'''A Key Pair''' blokkban megadhatjuk, hogy a gépek milyen kulcspárral engedélyezzék a belépést. 
[[Fájl:GAMFAWS ec2 launch templ setup key pair.png]]

'''A Network Confguration''' részben definiálhatjuk, hogy milyen VPC-be szeretnénk lerakni az EC2-ket, milyen security group legyen rajtuk. Természetesen utóbbi helyben is létrehozható, ha korábban ezt nem készítettük volna el. 
[[Fájl:GAMFAWS ec2 launch templ setup network.png]]

'''A Storage'''-nél megadhatjuk, hogy milyen kötetek, milyen méretben legyenek hozzácsatolva a rendszerhez.

'''A Tags''' blokkban felvehetjük a kívánt ''kulcs=érték'' párokat.

'''Az Additional Configuration''' szekcióban különböző haladó beállításokat eszközölhetünk a sablon által létrehozott EC2-n, többet között itt adhatjuk meg az indításkor lefuttatandó parancsok listáját (''User data'').

'''Végül kattintsunk a Create launch template nyomógombra a mentéshez!'''.

==== Target Group ====
A target group EC2-k azon csoportja, amelyeken valamilyen ''health check'' algoritmust futtatunk, ezzel meghatározva, hogy az adott csoportban hány használható, működő szerver fut. Ezt az információt elsőként a Load balancer használja ki.

A Target Group a bal oldali menüben, a ''Load Balancing'' szekcióban érhető el ''Target Groups'' néven.

Létrehozhatunk új csoportot, de meg kell adnunk, hogy milyen módon kerüljenek bele az EC2-k. Erre a következő metódusokat ajánlja fel az Amazon:
# Konkrét EC2 (Instance) kiválasztása
# EC2-k definiálása IP tartománnyal
# Lambda függvény hozzáadása
# Alkalmazás LoadBalancer, amely egy teljes VPC tartalmát magába foglalja.

Az űrlap alján megadhatjuk, hogy milyen életjel ellenőrzés történjen.

Általában nem mi vesszük fel egyesével az Instancokat ebbe a csoportba, hanem az AutoScaling group regisztrálja őket bele. '''Ezért ezt az űrlapot nem használjuk'''.

==== Load Balancer ====
A Load Balancer terheléselosztást jelent, tehát a bejövő forgalmat több gép között osztjuk el. Ezzel növekszik a felhasználói élmény, ráadásul a rendszer megállítása (egy hacker által) nehezebbé válik: ha kettő t2.micro teljesítményű szerver fut, amelyek között elosztjuk a bejövő forgalmat, akkor a rendszerünk valójában 2xt2.micro teljesítményű.

Terheléselosztót a bal oldali menü ''Load Balancing'' szekciójának ''Load Balancers'' menüpontjában hozhatunk létre.

'''A támogatott szolgáltatási szintek:'''
# Alkalmazás terheléselosztás (HTTP, HTTPS)
# Hálózati terheléselosztás (TCP, UDP)
# Átjáró terheléselosztása (GW)

===== Alkalmazás terheléselosztása =====
Ebben a formában konfigurálhatjuk az eszközt úgy, hogy az internet felől elérhető legyen (internet-facing) és úgy, hogy csak belső hálózaton működjön (internal). A belső hálózatot mindig az aktuális VPC-re kell érteni, tehát annak minden alhálózatából elérhető alapértelmezetten.
[[Fájl:GAMFAWS ec2 loadbalancer setup basic.png]]

A hálózati beállításoknál választhatunk, hogy mely alhálózatokban szeretnénk végrehajtani a terheléselosztást, így csak az azokban futó EC2-k kaphatnak ezen keresztül csomagokat. Arra kell ügyelnünk, hogy legalább kettő különböző zónában lévő alhálózatot kell kiválasztanunk (pl. eu-west-1a, eu-west-1b stb.).
[[Fájl:GAMFAWS ec2 loadbalancer setup network.png]]

Természetesen a LoadBalancer internetfelőli végpontján létrehozhatunk ''Security Group''okat, amelyet szabályozzák, hogy milyen IP címről fogadunk el csomagokat.
[[Fájl:GAMFAWS ec2 loadbalancer setup secg.png]]

A ''Listeners and routing'' résznél megadhatjuk, hogy melyik target group fogja a terhelést fogadni, tehát hogy mely EC2-k között tudunk ténylegesen terhelést elosztani. Amennyiben a target group egy darab EC2-t tartalmaz, akkor a terheléselosztás gyakorlatilag nem valósul meg, csak az elméleti esélyét adtuk meg, hogy ''„amennyiben lenne még egy EC2 a target group-ban, akkor a terhelés egy részét az vinné el”''.
[[Fájl:GAMFAWS ec2 loadbalancer setup routing.png]]

Végül kattintsunk a ''Create load balancer'' gombra, amennyiben a kívánt tag-eket is rögzítettük.

==== Auto Scaling Group ====
A szolgáltatás segítségével automatikusan skálázott rendszereket építhetünk ki, ahol a szerverek által nyújtott elérhető erőforrásokat minél közelebb tartja a bejövő terhelés által meghatározott erőforrásigényhez. Természetesen mindez akkor igaz, ha az ''Auto Scaling Group'' be regisztrálja az általa létrehozott ''EC2''-ket egy ''Target Group''-ba, ami felett ''Load Balancing'' van definiálva.

'''Előnyei''':
* Amikor nincs bejövő terhelés, akkor nincsenek nagy költségek
* Amikor nagy a bejövő terhelés, akkor a költségek megugranak ugyan, de az ügyfeleket ki tudtuk szolgálni úgy, hogy elégedettek voltak a rendszer teljesítményével.

'''Hátrányai''':
* Kaotikus számlák, nem előre tervezhető költségek
* Megnövekedett költségek DDoS és egyéb támadások esetén

===== A beállítás lépései =====
A szolgáltatást a bal oldali menü ''Auto Scaling Group'' szekciójában érjük el, az ''Auto Scaling Group'' menüpontban. A képernyő közepén vagy a képernyő jobb felső sarkában megjelenő ''Create auto scaling group'' gombra kattintva egy űrlap jelenik meg, ami végig vezet minket a telepítés lépésein.

'''A Name''' szekcióban elnevezzük az új group-ot.
[[Fájl:GAMFAWS ec2 autoscaling setup name.png]]

'''A következő szekcióban''' két választási lehetőségünk van:
* Launch Template-tel telepítjük az új group-ot, ez esetben csak ki kell választanunk a korábban létrehozott sablont, vagy az alatta található link segítségével készíthetünk újat. ''Amennyiben újat készítünk, a sablon létrehozása új ablakban nyílik meg, így a befejezést követően vissza kéne térnünk erre és a frissítést gombot megnyomva látni fogjuk az új lehetősége(ke)t.
[[Fájl:GAMFAWS ec2 autoscaling setup lt.png]]

* Launch Configuration-nel telepítjük az új group-ot, ez esetben át kell váltatnunk a ''Switch to launch configuration'' link segítségével a blokkot. A váltást követően hasonlóan az előzőekhez: vagy kiválasztjuk a már meglévő konfigurációs sémát, vagy hozhatunk létre újat.
[[Fájl:GAMFAWS ec2 autoscaling setup lc.png]]

'''A Next gombra kattintva a hálózati beállítások''' szekcióhoz érünk, ahol megadhatjuk, hogy az indított EC2 milyen VPC-be kerüljön és azon belül milyen alhálózatokba. VPC-ből egy, alhálózatból több is kiválasztható. Ügyeljünk rá, hogy ha később erre Load Balancer szolgáltatás is kerül, akkor legalább kettő zónát jelöljünk ki!
'''Figyelem!''' A zóna nem egyezik meg az alhálózattal!
[[Fájl:GAMFAWS ec2 autoscaling setup network.png]]

'''A Next gombra kattintva a Load Balancing beállítások''' következnek, ahol választhatunk:
* Nincs terheléselosztás opciót,
* Létező Load Balancer hozzáillesztését,
* Új Load Balancer létrehozását.

Utóbbi esetében a Load Balancer konfigurálásánál leírt módon ki kell töltenünk a Load Balancer űrlapját is helyben. 
[[Fájl:GAMFAWS ec2 autoscaling setup lb setup.png]]

Hasonlóan a ''Target Group''-ot is létrehozhatjuk helyben, amennyiben ezt nem tettük meg korábban.
[[Fájl:GAMFAWS ece autoscaling setup new lb new tg.png]]

'''A Next gombra kattintva a csoport méretét definiálhatjuk''', azaz megszabhatjuk, hogy hány darab szervertől, hány darab szerverig engedélyezzük az automatikus skálázást. Ez egy hasznos funkció, hiszen ezzel korlátok közé szoríthatjuk a költségeinket, miközben a legkisebb terhelés esetén is előkészülhetünk egy hirtelen bejövő nagyobb terhelésre (ha a minimum nem 1).
* Desired capacity: ennyi szervert fog elindítani az ASG mentés után
* Minimum capacity: ennyi szerver esetén már nem állít le semmit az ASG
* Maximum capacity: ennyi szerver esetén már nem indít el újabbat az ASG
[[Fájl:GAMFAWS ec2 autoscaling setup group.png]]

'''Alatta a Scaling Policy''' blokkban megadhatjuk, hogy milyen paraméterek mentén indítson vagy épp állítson le szervereket az ASG. Ehhez aktiválnunk kell a szolgáltatást és a ''Metric type'' listából ki kell választani az számunkra megfelelőt. Mi általában CPU terhelés alapján döntünk az órán.
[[Fájl:GAMFAWS ec2 autoscaling setup scaling.png]]

'''A Next gombokkal lépkedve hozhatunk létre Tag-eket, majd végül létrehozhatjuk az ASG-t is és az ''Instances'' menüpontban ellenőrizhetjük, hogy ténylegesen elindult a kívánt darabszámú szerver.'''

=== RDS szolgáltatások ===
A ''Relational Database Service'' foglalja magában a különböző adatbázisokat:
* MariaDB
* MySQL
* Aurora
* Oracle
* PostgreSQL
* MSSQL

'''Figyelem!''' Az itt felsorolt szerverek között lehetnek fizetősek is. Mindig járjunk el figyelmesen, kövessük a költségeket. Az RDS az amazon egyik legdrágább szolgáltatása.

==== MySQL adatbázis telepítése ====
==== Csatlakozás MySQL adatbázishoz CLI-ből ====
<syntaxhighlight lang="bash">
apt install mysql-client -y
# mysql -h<rds_endpoint> -u<rds_user> -p<rds_password>
mysql -hwebshop-989.rds.amazon.com -uadmin -p123456789
</syntaxhighlight>

A megnyíló '''mysql>''' PROMPT-ot tartalmazó sor azt jelenti, hogy sikeresen csatlakoztunk az SQL szerverhez. Amennyiben a csatlakozás sikertelen, akkor valószínűleg az RDS-hez kapcsolt Security Group beállításai nem engedik az EC2-ről a kapcsolódást - tipikusan a mi saját publikus IP címünk kerül bele az engedélyezett tartományba (pl. iskolai IP vagy otthoni) és ez nem került átírásra az amazonos tartománynak megfelelően.

A konzolra be kell illeszteni a ''networks.sql'' fájl tartalmát. A végén '''exit''' paranccsal léphetünk vissza a BASH környezetbe.

=== VPC ===
A '''V'''irtual '''P'''rivate '''C'''loud egy szolgáltatás, melynek segítségével össze köthetjük az összetartozó komponenseket, alkalmazásokat. A VPC-t modellezhetjük hétköznapibb értelemben, mint egy routert, amelynek vannak alhálózatai, route táblája és valamilyen gateway címe, amin keresztül a kliensei az internet más résztvevőivel tudnak kommunikálni.

A VPC szolgáltatásait a keresőbe írt ''VPC'' kulccsal érhetjük el.
==== VPC létrehozása ====
Navigáljunk a 'Your VPCs' menüpontra a bal oldali menüben és kattintsunk a jobb felső sarokban látható ''Create VPC' gombra. Ezután megnyílik egy űrlap, amely végig vezet minket a telepítés lépésein.

Az űrlap elején választhatunk, hogy ''VPC only'' vagy ''VPC and more'' módban szeretnénk folytatni. Előbbi csak a VPC-t hozza létre nevéből is adódóan, míg a másik opcióval létrehozhatjuk az alhálózatokat is, igaz, a tervezés szabadságáról le kell ilyenkor mondanunk, cserébe grafikán láthatjuk az eredményt. Számunkra az órán utóbbi nem lesz megfelelő, hiszen szükségünk lesz a ''tervezés szabadságára''. 
[[Fájl:GAMFAWS vpc setup.png]]

A VPC beállításainál mindig a teljes hálózatot átfogó IP/MASZK párost kell megadnunk, később az alhálózatok nem lóghatnak ki az itt megadott tartományból.

==== Alhálózatok ====
Az alhálózatok lehetőséget biztosítanak arra, hogy az egyes komponenseket el is szigeteljük egymástól, meg engedélyezzünk is közöttük bizonyos kommunikációt.

Alhálózatok típusai:
* Publikus: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten kapnak publikus IP címet
* Privát: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten nem kapnak publikus IP címet

===== Alhálózatok létrehozása =====
Navigáljunk a ''Subnets'' menüpontra. A képernyő jobb felső sarkában kattintsunk a ''Create subnet'' gombra, így megkapjuk a létrehozási űrlapot.

'''Először''' a VPC-t kell kiválasztanunk, aminek eredményeképp kiírja segítségképp annak tartományát. Ezen a tartományon kívül nem léphetünk. 
[[Fájl:GAMFAWS vpc subnet setup.png]]

A VPC kiválasztása után aktívvá válik az alhálózatok űrlap, ahol megadhatjuk annak nevét, hálózati címét és maszkját. 
[[Fájl:GAMFAWS vpc subnet setup new.png]]

'''Figyelem!''' A rendszer csak hálózati címet fogad el! Minden más esetben hibát ír ki.

A ''Remove'' gombbal eltávolíthatjuk az aktuális konfigurációt a listából, míg a lentebb található ''Add new subnet'' segítségével újabbat vehetünk fel.

Befejezésül nyomjuk meg a ''Create subnet'' gombot, így az összes definiált alhálózat létrejön a kiválasztott VPC-hez.

===== Publikus/Privát alhálózat beállítása =====
Az alhálózat típusának átállításához navigáljunk a ''Subnets'' menüpontra. Kattintsunk jobb gombbal a kívánt alhálózat során és válasszuk ki az ''Edit subnet settings'' opciót. 
[[Fájl:GAMFAWS vpc subnet edit s settings.png]]

Az űrlapon keressük meg az ''Auto-assign IP settings'' blokkot és a kívánt típusnak megfelelően módosítsuk azt.
[[Fájl:GAMFAWS vpc subnet edit type.png]]

===== Különböző route tábla minden alhálózaton =====
A VPC támogatja, hogy minden subnet saját route táblával rendelkezzen. Ez lehet akár egy biztonsági funkció is, hogy ne ismerje minden EC2 az útvonalat egy adott szerverhez, de egyes esetekben kötelezően létre kell hoznunk. A route táblákat a ''Route tables'' menüpontban hozhatjuk létre és a ''Subnets'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Edit route table association'' opciót kiválasztva szerkeszthetjük.

'''Figyelem!''' A route táblák cseréje okozhat internetelérési problémákat szerver oldalon, aminek következtében a futó szolgáltatások számunkra is elérhetetlenekké válnak (pl. SSH és/vagy HTTP/HTTPS stb.), így legyünk körültekintőek.

==== Internet Gateway ====
Ahhoz, hogy a VPC-n belül legyen internet, ahhoz egy IGW-t kell hozzá csatolnunk. Ezt megelőzően azonban létre kell hoznunk egyet.
'''Figyelem!''' A VPC-hez nem kapcsolt IGW-k pénzbe kerülhetnek, mivel feleslegesen foglalnak le egy publikus IPv4 címet.

[[Fájl:GAMFAWS vpc igw setup.png|bélyegkép|Internet Gateway létrehozás]]
Az IGW az ''Internet Gateways'' menüpont alatt érhető el és a jobb felső sarokban található ''Create internet gateway'' gombbal hozhatunk létre újat. Csupán egy nevet kell megadnunk, illetve rakhatunk rá tag-eket igény szerint.

A létrehozást követően hozzá kell rendelnünk egy létező VPC-hez, amit az ''Internet Gateways'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Attach to VPC'' opciót kiválasztva tudunk megtenni. Amennyiben a soron az ''Attached'' (zöld színű) felirat jelenik meg a (szürke színű) ''Detached'' helyett, akkor nem tudjuk VPC-hez csatolni (ilyenkor először a ''Detach from VPC'' opciót kell választanunk). 
[[Fájl:GAMFAWS vpc igw attach.png]]

Az IGW VPC-hez rendelése után a kívánt route táblákba fel kell vennünk, hogy minden csomagot arra irányítson.
[[Fájl:GAMFAWS vpc igw route setup.png]]

==== NAT Gateway ====
Lehetőség van Internet Gateway helyett NAT Gateway létrehozására is, de ez egy fizetős szolgáltatás. A nevének megfelelően ez lehetőséget biztosít, hogy azok az EC2-k, amelyek privát alhálózatba kerültek, kilássanak az internet felé (pl. frissítések keresése, telepítése), miközben védve vannak a kívülről érkező támadásoktól.
'''Ez egy lehetséges oka lehet, hogy külön válasszuk a route táblákat az alhálózatokon, hiszen az egyiknek minden csomagot az IGW felé, míg a másiknak minden csomagot a NAT Gateway felé kell továbbítania.''' ''Ha nem használunk NAT Gatewayt, akkor is érdemes lehet leválasztani az IGW-ről a privát alhálózatokat.''

=== AWSCLI ===
Az AWSCLI egy konzolos alkalmazás, amelynek segítségével menedzselhetjük környezetünket: hozhatunk létre új EC2-t akár, vagy kapcsolhatunk hozzá egyéb szolgáltatásokat (Security Group, ASG, LB stb.).

Az awscli program elérhető linux és windows környezetben egyaránt.

==== AWSCLI telepítése ====
A program telepítéséhez a következő parancsot kell futtatnunk: '''apt install awscli'''.
==== Access Key management ====
Az ''awscli'' hozzáférési kulcsokon keresztül kap jogosultságot a szolgáltatások adataihoz, így használata előtt készítenünk kell egy újat. Ez a nevünkre kattintva (jobb felül), majd a ''Security credentials'' menüpontot kiválasztva tehetjük meg, az ''Access keys'' szekcióban. Nyissuk ezt le és kattintsunk a ''Create New Access Key'' gombra. 
<center>
{|
| [[Fájl:GAMFAWS UserMenu.png|150px|keretnélküli]] || [[Fájl:GAMFAWS SecurityCredentials.png|keretnélküli]]
|}
</center>

A gomb megnyomása után egy felugró ablak fogad, amelyben megtalálható az ''Access Key'' és a ''Security Access Key'' értéke. Érdemes a fájlt letölteni, hogy később is elérhetők legyenek ezek az adatok, '''az AWS többet nem fogja engedélyezni ezek megjelenítését!''' Ha az adatokat később nem tudjuk megadni, akkor újat kell készíteni.
[[Fájl:GAMFAWS SecurityCredentials ShowData.png|középre]]

==== AWS CLI konfigurálás autentikációs adatokkal ====
Az eszköz telepítése annak konfigurálásával ér véget: meg kell adnunk az autentikációs tokeneket. 
Ezt az '''aws configure''' parancs kiadásával tehetjük meg, ahol egyesével bekéri a szükséges adatokat. Ahol nem szeretnénk változtatni az előző értéken (szögletes zárójelek között láthatjuk ezt), ott hagyjuk üresen a sort és csupán entert nyomjunk.
[[Fájl:GAMFAWS AWSCLI config.png|középre]]

Az adatok megadása után menedzselhetjük az aws parancsokkal a környezetünket. Az aws parancsairól az '''aws help''' szolgáltat információt.

=== S3 ===
Ez a szolgáltatás fájlok tárolására alkalmas.

Több típusa is elérhető:
* Standard:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban sűrűn használt objektumok tárolására alkalmas
** A régiók közötti szinkronizáció megoldott
* Instant Glacier:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban ritkábban használt, hosszú élettartamú, de azonnali hozzáférést igénylő objektumok tárolására alkalmas
* Flexible Glacier:
** Magas rendelkezésre állás jellemzi
** Az alkalmazásban ritkán használt (évente 1x-2x), a mérettől független költséggel rendelkező megoldás
* Deep Archive Glacier:
** 7-10 évig tárolt adatokhoz optimalizált költségvonzat
** Előnyös a backup adatok tárolásához

A szolgáltatás a keresőben ''S3'' füzérrel kereshető.

==== Bucket létrehozása ====
Új tárolót a ''Create bucket'' gomb segítségével hozhatunk létre. A megjelenő űrlapon a nevet kell kitölteni és érdemes egy pillantást vetni a publikusság beállításaira is, hogy ez ténylegesen a célunknak megfelelő legyen.

'''Figyelem!''' A névnek nem csupán a mi környezetünkön belül kell egyedinek lennie, hanem a teljes AWS-en belül.

{| style="margin:auto"
| [[Fájl:GAMFAWS S3 new name.png|bélyegkép]] || [[Fájl:GAMFAWS S3 new public.png|bélyegkép]]
|}

==== Bucket kezelése ''awscli'' programmal ====
Az '''aws s3 help''' parancs segítségével további információt szerezhetünk az egyes utasításokról.

'''Bucket tartalmának listázása''' 
<syntaxhighlight lang="bash">
aws s3 ls [bucket_name]
</syntaxhighlight>
[[Fájl:GAMFAWS S3 CLI LS.png|középre]]

'''Adatok másolása Bucket-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* LOCAL_PATH a lokális fájlrendszeren belüli elérési útvonala a forrásfájlnak (vagy könyvtárnak)
* REMOTE_PATH a cél helye az S3-ban
** Az s3:// jelzi, hogy a cél az S3-ban van (S3Uri)
** A mappák helyett PREFIX-ek vannak (/folder/to/my/file esetében /folder/to/my a PREFIX)
** A mappákat nem kell S3-ban létrehoznunk (az előző pontból következik), a fájlnév előtti prefix dönti el a hova tartozását
** A PREFIX-eket az '''ls''' úgy kezeli, mint egy mappát
[[Fájl:GAMFAWS S3 AWSCLI cp2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* --recursive jelzi, hogy a LOCAL_PATH alatt minden bejegyzést töltsön fel
[[Fájl:GAMFAWS S3 AWSCLI copy recursive2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ból helyi fájlrendszerbe''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive s3://REMOTE_PATH LOCAL_PATH
</syntaxhighlight>
[[Fájl:GAMFAWS S3 AWSCLI cp2local.png|középre]]

==== Bucket kezelése grafikus felületen keresztül ====
Az S3 tartalmát elérhetjük az AWS grafikus felületén keresztül is, így tölthetünk fel, törölhetünk és módosíthatunk fájlokat anélkül, hogy saját számítógépünkre telepítenénk az ''awscli'' programot.

# Nyissuk meg az S3 szolgáltatás vezérlőpultját
# Kattintsunk a szerkeszteni kívánt tárhely nevére [[Fájl:GAMFAWS S3f list.png]] 
# A vezérlőgombok segítségével végezzük el a kívánt műveletet (feltöltés, törlés), vagy válasszunk ki egy PREFIX-et az „almappák” tartalmának megtekintéséhez. [[Fájl:GAMFAWS S3 control.png|középre]]

= Alkalmazások telepítése =
== UI ==
== API ==

= Indítást gyorsító scriptek =
== UI indítás ==
<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun code
API_LB_DOMAIN="localhost" # api server IP

apt update
apt install wget unzip apache2 libapache2-mod-php8.3 php8.3 php8.3-curl -y

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui.php
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui_newproduct.php
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv ui.php /srv/$NEPTUN/index.php
mv ui_newproduct.php /srv/$NEPTUN/newproduct.php

# remove tmp directory
cd /
rm /tmp/code

cat << EOF > /etc/apache2/sites-enabled/000-default.conf
<VirtualHost *:80>
#ServerName www.example.com

ServerAdmin webmaster@localhost
DocumentRoot /srv/$NEPTUN

<Directory /srv/$NEPTUN/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>

ErrorLog \$\{APACHE_LOG_DIR\}/error.log
CustomLog \$\{APACHE_LOG_DIR\}/access.log combined
</VirtualHost>
EOF

systemctl restart apache2
</syntaxhighlight>

== API indítás ==

<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun
MYSQL_DOMAIN="localhost" # RDS mysql domain

apt update
apt install wget unzip python3 python3-pip python3-flask -y
pip3 install mysql-connector-python --break-system-packages

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$MYSQL_DOMAIN/g" api.py
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv api.py /srv/$NEPTUN/

# remove tmp directory
cd /
rm /tmp/code

echo "@reboot root sleep 10s && python3 /srv/$NEPTUN/api.py &" >> /etc/crontab
cd /srv/$NEPTUN && python3 api.py &
‎</syntaxhighlight>

EDU::GAMF::Felhőalapú-szolgáltatások::AWS

2025-10-14T06:18:45Z

ApelPro: /* API indítás */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
[[category:GAMF AWS|AWS]]
== Amazon Web Services regisztráció ==
Az AWS mindenki számára biztosít 1 év ingyenes próbaverziót. Ehhez regisztrálnunk kell a rendszerbe, amihez szükségünk lesz egy email címre, egy telefonszámra a megerősítéshez és egy netes vásárlásra alkalmas bankkártyára. A regisztráció során az AWS 1$-ral meg terheli a számlát, de később erre nem tart igény, így a tranzakció lejáratakor jóváíródik a számlán.

== Ingyenes verzió korlátai ==
Az ingyenes verzióban nem minden érhető el és ami mégis, az sem korlátlan ideig (750 óra EC2 futási idő például), amit ha átlépünk, akkor fizetési kötelezettségünk jelentkezik a szolgáltató felé. Igyekezzünk mindent leállítani az órai munka illetve az otthoni gyakorlás után, hogy lehetőleg ne kerüljön pénzbe a féléves munkánk. A hallgatók által elszenvedett károkért sem az iskola sem Én nem tudunk felelősséget vállalni, de azt meg tudjuk ígérni, hogy fizetős szolgáltatást nem használunk és nem is kérünk számon.

== AWS alapok ==
'''Figyelem!''' Az iskolai hálózatból csak az eu-west-1 és az eu-central-1, azaz Írország és Frankfurt IP címei vannak engedélyezve, ezekre fogunk tudni SSH kapcsolaton keresztül csatlakozni. 
'''Figyelem!''' Próbaidőszak alatt minden szolgáltatás mellett keressük a ''Free tier eligible'' megjegyzést, különben fizetési kötelezettségünk adódhat!

=== EC2 szolgáltatásai ===
Az ''EC2'' gyakorlatilag egy VPS-nek feleltethető meg és nem is tévedünk vele hatalmasat. A neve az ''Elastic Cloud Compute'' szavak kezdőbetűiből kialakuló ''ECC''-ből fakad, a ''2''-es a végén jelzi, hogy a ''C'' betűből kettő van.

A különbséget a VPS-hez az EC2 futási ideje okozza: bár nem feltétlen, de meg van a lehetősége, hogy egyik napról a másikra megszűnjön egy EC2 úgy, hogy az alkalmazásunk mégis működőképes marad. E tulajdonsága miatt kapta az ''Elastic'' nevet, amit körültekintően kell kezelni: semmilyen adatot nem tárolhatunk úgy egy alkalmazáson belül, mint egy VPS esetén: a dinamikus adatok (pl. PHP Session, feltöltött fájok) egy EC2 csere esetén elvesznek, így ezeket nem helyben fogjuk tárolni.

Az EC2 szolgáltatásait a keresőmezőbe írt ''„EC2”'' kulcsszóval és az eredményekben megjelenő ''EC2''-re való kattintással érhetjük el.

[[Fájl:GAMFAWS search EC2.png.png]]

Az alapértelmezetten megjelenő menüpont a ''Dashboard'', ahol információkat találhatunk az ''EC2'' köré felhúzható szolgáltatásokról, melyeknek egy részét a továbbiakban tárgyalni is fogunk. Az összefoglaló táblázat az alább látható módon jelenik meg. '''Figyelem''', a táblázat csak az adott régióban elindított/elérhető szolgáltatásokat mutatja, régió váltása előtt érdemes az esetlegesen létrehozott, régió függő elemeket leállítani, hogy később ne jelenjen meg fizetési kötelezettség.

[[Fájl:GAMFAWS ec2 dashboard.png]]

==== EC2 telepítése és beállítása ====
EC2 létrehozásához meg kell nyomnunk a ''Launch instance'' gombot, melyet több helyen is elérhetünk:
* A Dashboardon
* A bal oldali menüben található ''Intances'' menüpont megnyitása után jobb felül
A gomb minden esetben a következőképp néz ki: [[Fájl:GAMFAWS ec2 launch instance button.png]]

A gombra kattintva egy űrlap jelenik meg, amely segítségével elvégezhetjük a szükséges beállításokat: 
======Név és tag beállítok======
Megadása nem kötelező, de több szerver futtatása esetén könnyebben azonosíthatjuk be őket ezek segítségével
[[Fájl:GAMFAWS ec2 setup name and tags.png]]

Az ''Add additional tags'' gombra kattintva további kulcs=érték párokat adhatunk hozzá, amivel dinamikusan csatolhatjuk össze egyéb szolgáltatásokkal, amelyek egy-egy kulcsot keresve döntik el, hogy melyik szolgáltatásokkal kell együttműködniük (például monitorozás bekapcsolása 'monitoring=true' kulcs=érték pár alapján.

======Kezdeti képfájl kiválasztása======
Az Amazon többféle indítóképpel is rendelkezik, így nagy valószínűséggel meg fogjuk találni a hozzánk közelálló operációs rendszert. Új hozzáadására nincs lehetőségünk, de készíthetünk az alapképfájlokból olyan verziót, ami már tartalmazza a saját konfigurációnkat (lásd [[GAMF :: Felhőalapú-szolgáltatások :: AWS#AMI_létrehozása|itt]]). 
[[Fájl:GAMFAWS ec2 setup AMI choose2.png]] 
Az órákon az Ubuntu legújabb verzióját használjuk, mivel ennek a Desktop változata az egyik legelterjedtebb a Linux felhasználók körében, így nem kell más környezetet megszoknia egy átlag hallgatónak. Érdemes lehet azonban egyéb disztribúciók kipróbálása is, különösen a '''Debian'''-t, '''Suse'''-t/'''OpenSuse'''-t, '''ReadHat'''-et és annak ingyenes változatait ('''AlmaLinux''', '''RockyLinuxtm''', amelyek az egykori '''CentOS'''-t hivatottak váltani), mivel céges környezetben ezek sűrűbben előfordulnak: némelyik a kisebb erőforrásigénye, míg másik az Enterprise szolgáltatásai miatt.

======Szerver típusának meghatározása======
Különböző erősségű szerverkonfigurációk közül választhatunk, de természetesen nem mindegyik érhető el az ingyenes verzióban. A számítógépek ára a konfiguráció függvényében változik, de csak azért az időért kell fizetni, amíg a szerver ''Running'' állapotban volt. Az órán az alapértelmezett ''t2.micro''-t használjuk. 
[[Fájl:GAMFAWS ec2 setup instance type.png]]

======Kulcspár hozzárendelése======
Az Amazonon belüli szolgáltatásokat felhasználónév/jelszó páros helyett SSH kulcspárok segítségével érjük el. Minden felhasználó számára készíthetünk egyet és jogosultságok segítségével korlátozhatjuk, hogy mihez férhet hozzá (IAM). 
Ebben a szekcióban ki kell választanunk, hogy a telepíteni kívánt EC2-höz milyen kulcspárral lehet majd hozzáférni. Amennyiben nem rendelkezünk még kulcspárral, úgy van lehetőségünk helyben elkészíteni a ''Create new keypair'' gomb segítségével, amelynek lépési megegyeznek az [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Kulcspár_létrehozása|itt]] leírtakkal. 
[[Fájl:GAMFAWS ec2 setup keypair.png]]

======Hálózati és biztonsági beállítások======
Az EC2-k közötti kommunikációs csatornák kialakításához definiálnunk kell, hogy melyik virtuális hálózatba akarjuk elhelyezni és milyen alkalmazásokat szeretnénk elérhetővé tenni. Ezt a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#VPC_beállításai|VPC]] és a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Security_Group|Security Group]] beállításával tehetjük meg. Előbbi a virtuális hálózatnak felel meg, míg utóbbi hasonlóan egy tűzfalhoz, meghatározza, hogy a szerveren milyen portokat érhetünk el. Érdemes az SSH-t engedélyezni és ha webes alkalmazást szeretnénk rajta futtatni a későbbiekben, akkor a HTTP és/vagy HTTPS szolgáltatást/szolgáltatásokat is, így később nem kell szerkeszteni ezeket a beállításokat. 
[[Fájl:GAMFAWS ec2 setup networking.png]]

======Tárhely beállítások======
Ebben a részben adhatjuk meg, hogy a szerverünk mekkora tárhellyel rendelkezzen. Egy Linux alapú operációs rendszernek nem kell 8GB-nél több, így az alapértéken hagyhatjuk. Az itt megadott érték inkább csak egy korlát, valójában csak akkora tárhelyet vesz igénybe, amennyire ténylegesen szüksége van a rendszernek. Ez az érték alatt látható figyelmeztetés miatt lényeges, hiszen a 30GB-t elhagyva fizetőssé válik a tárterület is, ám ez nem jelenti, hogy csak 4 szervert tudnánk elindítani az ingyenes keretek között. 
[[Fájl:GAMFAWS ec2 setup ebs.png]]

Ezt a szolgáltatást EBS-nek nevezik (''Elastic Block Store'') és az EC2 megszűnésekor minden erre mentett adat elveszik, így általában az OS-t és az applikáció kódját tároljuk ezen - semmi dinamikus adatot.

======Haladó beállítások======
Ebben a szekcióban különböző beállításokat végezhetünk el, ám ezeket az órán nem módosítjuk. Érdekes lehet azonban a menüt lenyitva legalul található ''User data'' opció, amivel parancsokat adhatunk meg az új operációs rendszer számára, hogy miket futtasson le. Ennek segítségével lehetőségünk nyílik applikációk telepítésére - pl. git - és a kód letöltésére egy másik szerverről, amennyiben a kiválasztott képfájl nem tartalmazta azt. 
''Az órai keretek között ezt a funkciót nem használjuk ki, de érdemes lehet kipróbálni, mivel valós alkalmazások üzemeltetésekor jól jöhet.'' 
[[Fájl:GAMFAWS ec2 setup userdata.png]]

======Összefoglaló======
A beállító panel mellett jobbra találhatjuk az összefoglaló ablakot, amelyben megtalálható a ''Launch Instance'' gomb. Ennek segítségével kezdhetjük meg a végleges telepítést, ha erre rá nyomunk, akkor a rendszer megkezdi a kiválasztott konfiguráció telepítését. Ha ebben az ablakban pénzösszegeket látunk, akkor az egészen biztosan fizetési kötelezettséget vonz magával, legyünk körültekintőek. 
[[Fájl:GAMFAWS ec2 setup summary.png]]

======Az elkészült instance tulajdonságai======
A futó szerverek az ''Instances'' menüpontban érhetők el. Az egyes sorokra kattintva alul megtekinthetjük a beállításait, amely tartalmazza az AWS által kiosztott publikus és privát IP címeket és domain neveket. Ezeken keresztül tudunk kommunikálni szerverünkkel. 
[[Fájl:GAMFAWS ec2 properties.png]] 
''Jelen példában a külső IP címünk: 3.252.168.207, amit a mellette található ikonnal egyszerűen a vágólapra másolhatunk.''

======Csatlakozás Linux terminálból======
A csatlakozáshoz nyissunk meg egy terminált a CTRL+T billentyűkombinációval, majd navigáljunk a ''cd'' parancs segítségével a letöltött kulcsfájl mappájába. Az SSH megköveteli, hogy a csatlakozáshoz használt kulcsfájlhoz csak a tulajdonos felhasználó férjen hozzá, így a következő parancsot futtassuk le rajta: ''chmod 600 test.pem''

A következő paranccsal tudunk kapcsolódni: ''ssh -i test.pem ubuntu@3.252.168.207'' 
Ha a fenti parancs kéri, fogadjuk el a tanúsítványt. Amennyiben ''Permission error'' hibát kapunk, akkor a fenti ''chmod'' parancsra van szükségünk, vagy nem mi vagyunk a kulcsfájl tulajdonosai (''ls -l'' segíthet). 
A ''test.pem'' az AWS rendszerből letöltött .pem formátumú kulcsfájl, az ''ubuntu'' a szerveren elérhető felhasználó. A különböző disztribúcióknál használt felhasználónevekről [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connection-prereqs.html ezen] a linken tájékozódhatsz. 
[[Fájl:GAMFAWS ec2 connect linux.png]]

======Csatlakozás Putty használatával======
Amennyiben a .pem kiterjesztésű állományt töltöttük le az AWS rendszeréből, akkor a '''puttygen''' eszköz segítségével ki kell exportálni belőle a privát kulcsot. [https://www.ssh.com/academy/ssh/putty/windows/puttygen Ezen a linken] részletes segédlet található a programcsomaghoz, ahol további funkciók is bemutatásra kerülnek (pl. kulcsgenerálás).

==== Kulcspár létrehozása ====
A kulcspárok kezeléséhez a ''Key Pairs'' linket nyissuk meg a bal oldali menüből. Újat a jobb oldalon látható ''Create key pair'' gomb segítségével készíthetünk. [[Fájl:GAMFAWS ec2 keypair create.png]]

A gombra kattintva egy űrlapot kapunk, amely végig vezet minket a létrehozás lépésein.
# Név megadása
# Típus kiválasztása - ''RSA-val dolgozunk az órán''
# Letöltendő kulcs típusa - ''Linux terminálból való csatlakozáshoz a .pem fájlra lesz szükségünk''
# Esetleges tag-ek hozzárendelése
# A ''Create key pair'' gombra kattintva letölthetjük a kulcspárt

[[Fájl:GAMFAWS ec2 keypair setup.png|Kulcspár létrehozása]]

'''Figyelem!''' A kulcspár csak a létrehozás után tölthető le '''egyetlen egyszer''', az elvesztett fájlok nem reprodukálhatók! Amennyiben egy EC2 csak az elhagyott kulcspárral érhető el, úgy annak (EC2) törlése és újrakonfigurálása szükséges egy új kulccsal.

==== Security Group ====
A Security Group-ok segítségével kontrollálhatjuk, hogy a szervereinkhez milyen portokon férhetnek hozzá, tehát mintegy tűzfal működik. Egy Security Group több gépre is ráhúzható és függetlenül működik, azaz a megadott szabályokat nem másolja át az operációs rendszer konfigurációs állományaiba, mintegy a szerver elé telepített eszköz működik. Ennek köszönhetően futási időben változtathatjuk a szabályokat, életbelépésükhöz nem kell újracsinálni az EC2-ket.

A bal oldali sávban, a ''Network & Security'' csoportban érhető el.

===== Security Group hozzáadása =====
Egy új szabályrendszer felvételét kezdeményezhetjük az EC2 telepítésekor, ahogyan azt [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Hálózati_és_biztonsági_beállítások|itt]] is láthattuk, de készíthetünk előre meghatározottakat is.

Az előre definiált csoportokat a ''Create Security Group'' gomb segítségével hozhatjuk létre, amelyet a jobb felső sarokban találhatunk meg. 
[[Fájl:GAMFAWS ec2 secg new button.png|bélyeg]sdfsad] 

A gomb megnyomását követően egy űrlapot kapunk, melynek 3 fő része van:
# Általános adatok [[Fájl:GAMFAWS ec2 secg new basic.png|bélyeg|Általános adatok]]
#* '''A név és a leírás mező megadása is kötelező'''
#* Itt választhatjuk ki, hogy mely VPC-ben szeretnénk elérhetővé tenni.
# Bejövő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg inbound.png|bélyegkép|Inbound rules]]
#* '''Az itt megjelenő szabályok lesznek engedélyezve a szerverünk felé, minden más csomag eldobásra kerül'''
#* Háromféle szabályból választhatunk:
#** '''Anywhere''' (IPv4, IPv6): A megadott IP típusból mindenhonnan elfogadjuk a csomagokat
#** '''Custom''': Csak a megadott IP címekről/IP tartományokból érjük el az adott portot
#** '''MyIP''': automatikusan beillesztésre kerül az felhasználó aktuális IP címe (hasonló a custom lehetőséghez)
# Kimenő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg outbound.png|bélyegkép|Outbound rules]]
#* A kimenő forgalom szabályozása biztonsági szempontból megfontolandó, de természetesen a publikus alkalmazások esetében (pl. web) nem tudunk ilyen szűrést alkalmazni.
#* Alkalmazhatjuk például SSH-ra, hogy megszüntessük annak a lehetőségét, hogy egy esetleges fertőzésből kifolyólag SSH-t hackelgető botnetté változzunk (volt már hasonló tapasztalat).
#* Az órán ezzel bővebben nem foglalkozunk, de éles környezetben ne felejtsünk el ezen szabályok definiálására időt szánni.
# Tag-ek megadása

===== Security Group szerkesztése =====
A szerkeszteni kívánt soron kattintsunk jobb gombbal és válasszuk ki a szerkeszteni kívánt szabályok csoportját:
* '''Edit inbound rules''', ha a bejövő csomagok szűrését szeretnénk módosítani,
* ''' Edit outbound rules''', ha a kimenő forgalmat szeretnénk szűrni.
A megnyíló ablakban ugyanazon a módon vehetünk fel szabályokat, ahogyan a létrehozásnál. A módosítások mentés után életbe lépnek. 
[[Fájl:GAMFAWS ec2 secg context menu.png]]

==== Terheléselosztás vázlat ====
[[Fájl:EC2LoadBalancingRequirements.png|középre]]

==== AMI ====
Az AMI gyakorlatilag egy bitről-bitre lemásolt HDD képfájl, amely tömörítve lett. Így tárolja az összes elmentett adat- és konfigurációs állományt. Ha egy alkalmazást készítünk, akkor a következő okokból készítünk ilyen képfájlt:
# Biztonsági mentés a telepített szolgáltatásokról, így később nem kell egy esetleges hiba miatt újrakonfigurálni az egészet
# AutoScaling group-ba szeretnénk rendezni az alkalmazásunkat, annak pedig meg kell mondani, hogy melyik képfájlt indítsa el

'''Figyelem!''' A képfájlok úgynevezett snapshot-okat hoznak létre, amelyek tárolásáért fizetni kell, ha az összméret meghaladja a 8GB-ot. (A snapshotok az éppen futó rendszer miatt készülnek: minden írási műveletet lezár, majd a snapshot készítés után elindított írási műveletek már a háttértár egyéb területeire történik, amelyet a mentés nem fog tartalmazni, így garantálható, hogy nem lesznek félig lezárt fájlok a mentésben. Lásd bővebben: BTRFS (linux) és NTFS support). A pillanatképek nem törölhetők, amíg a belőlük készült AMI létezik!

===== AMI létrehozás lépései =====
'''Navigáljunk az Instances menüpontra, ahol láthatjuk, hogy milyen EC2 szolgáltatások vannak a rendszerünkben.'''
# Kattintsunk jobb gombbal azon az elemen, amelyet menteni szeretnénk
# Nyissuk ki az ''Image and templates'' menüpontot
# Kattintsunk a ''Create image'' lehetőségre 
[[Fájl:GAMFAWS ec2 ami create.png]]

'''Nevezzük el a képfájlt tetszés szerint''' 
[[Fájl:GAMFAWS ec2 ami setup.png]]

'''Navigáljunk a bal oldalon található menüben az ''Images'' szekcióhoz és válasszuk ki az ''AMIs'' elemet. Itt megtekinthetjük és törölhetjük a létrehozott képfájljainkat.''' 
[[Fájl:GAMFAWS ec2 ami list.png]]

'''Ha a mentés sikeresen elkészült, akkor az EC2 létrehozásánál kiválaszthatjuk azt.''' 
[[Fájl:GAMFAWS ec2 setup own ami select.png]]

==== Indítási konfigurációk elkészítése ====
Az indítási konfigurációk mind egy célt szolgálnak: egységes profilba rendezi az EC2-ről készült képfájlokat. Míg az AMI nem tárolt információt a mentett gép erőforrásáról, egy indítási konfigurációban megadhatjuk ezeket. Később ezek felhasználásával egyszerűbben indíthatunk újabb szervereket és vannak olyan esetek is, amikor a rendszer megköveteli, hogy a képfájl megadása helyett konkrét, hardverinformációkat is tároló konfigurációs sablonokat adjunk meg.

''Az Auto Scaling Group például megköveteli, hogy a következő kettő elem közül az egyiket megadjuk, ebből fogja tudni, hogy milyen típusú EC2-t, mekkora tárhellyel és milyen VPC-ben indítson el.''

===== Launch configuration =====
'''Egy kifutóban lévő konfigurációs séma, amely 2022. December 31-e után nem kapja meg a frissítéseket. Az AWS javaslata szerint érdemes ezeket a beállításokat a következőkben tárgyalt ''Launch template'' alá migrálni.

A ''Launch configuration'-nek nevezett séma egy egyszerűsített változata a sablonoknak. Jóval kevesebb beállítási lehetőséget tartalmaz, mint a párja, de tökéletesen elegendőt az ''Auto Scaling Group''hoz.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Auto Scaling group'' szekciót és válasszuk ki a ''Launch Configuration'' menüpontot. A jobb felső sarokban található ''Create launch configuration'' gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''Név megadása''', aminek segítségével később hivatkozhatunk erre az elemre. Kitöltése kötelező! 
[[Fájl:GAMFAWS ec2 launch conf setup name.png]]

''AMI kiválasztása'', tehát azok képfájl megadása, amit a kiválasztott EC2 konfiguráció futtatni fog. Lehetőségünk van a saját készítésű (''My AMIs'') és a közösségi képfájlok közül választani (''Marketplace''). 
[[Fájl:GAMFAWS ec2 launch conf setup ami.png]]

'''Instance típus''' alatt megadhatjuk, hogy a konfiguráció milyen teljesítményű legyen.
'''Ne feledjük el, hogy a t2.micro az ingyenes, a többi használata után fizetési kötelezettségünk jelenhet meg.'''
[[Fájl:GAMFAWS ec2 launch conf setup instance type.png]]

'''Az Additional configruation''' részben megadhatunk különböző paramétereket, amelyeket az EC2 fog felvenni - pl. mindenképp kapjon IP címet, a subnet beállításaitól függetlenül, vagy éppen ne kapjon; itt adhatjuk meg a telepítéskor lefuttatott scripteket (User data).

'''A Storage''' szekcióban megadhatjuk, hogy milyen lemezek és milyen méretűek legyenek a rendszerhez csatolva.

'''A Security Group''' részben kiválaszthatunk egy már meglévő szabályrendszert, vagy készíthetünk újat. 
[[Fájl:GAMFAWS ec2 launch conf setup secg.png]]

'''A Key pairs''' blokkban megadhatjuk, hogy milyen privát kulccsal léphetnek be a szerverekre. Ennek meglétét jóvá kell hagyni az alul található checkbox-szal. 
[[Fájl:GAMFAWS ec2 launch conf setup keypair.png]]

'''Végül kattintsunk a ''Create launch confgiration'' gombra a létrehozáshoz.'''

===== Launch template =====
A Launch template jóval gazdagabb a beállítási lehetőségekben, mint párja. A konfigurációs adatlap tartalmaz segédletet az AutoScaling Group-pal történő használathoz, amely ''required'', azaz kötelező mezőként jelöli meg azokat az adatbeviteli elemeket, amelyeket az automata skálázó rendszer használ. Érdemes ezt bekapcsolni, amennyiben ilyen célzattal készítjük el a sablonunkat.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Instances'' szekciót és válasszuk ki a ''Launch template'' menüpontot. Az oldal közepén vagy a jobb felső sarokban található Create launch configuration gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''A sablon neve és leírása''' blokkban megadhatjuk a nevet és a leírást, de ugyanakkor itt választhatjuk ki azt a checkboxot is, ami később a segítségünkre lesz a konfigurációs sablon AutoScaling Group-hoz való illesztését is (''Auto Scaling guidence''). 
[[Fájl:GAMFAWS ec2 launch templ setup name.png]]

'''Az Application and OS images''' szekcióban megadhatjuk, hogy milyen AMI-val települjön az EC2. Itt választhatunk a sajátunkból, vagy az EC2-nél is megtalálható egyebekből. 
[[Fájl:GAMFAWS ec2 launch templ setup ami.png]]

'''Az Instance type''' csoportban megadhatjuk, hogy milyen teljesítményű gépet szeretnénk indítani.
'''Ne feledjük el, hogy az ingyenes változatban a t2.micro érhető el, másik lehetőség választása esetén fizetési kötelezettségek léphetnek fel!''' 
[[Fájl:GAMFAWS ec2 launch templ setup instancetype.png]]

'''A Key Pair''' blokkban megadhatjuk, hogy a gépek milyen kulcspárral engedélyezzék a belépést. 
[[Fájl:GAMFAWS ec2 launch templ setup key pair.png]]

'''A Network Confguration''' részben definiálhatjuk, hogy milyen VPC-be szeretnénk lerakni az EC2-ket, milyen security group legyen rajtuk. Természetesen utóbbi helyben is létrehozható, ha korábban ezt nem készítettük volna el. 
[[Fájl:GAMFAWS ec2 launch templ setup network.png]]

'''A Storage'''-nél megadhatjuk, hogy milyen kötetek, milyen méretben legyenek hozzácsatolva a rendszerhez.

'''A Tags''' blokkban felvehetjük a kívánt ''kulcs=érték'' párokat.

'''Az Additional Configuration''' szekcióban különböző haladó beállításokat eszközölhetünk a sablon által létrehozott EC2-n, többet között itt adhatjuk meg az indításkor lefuttatandó parancsok listáját (''User data'').

'''Végül kattintsunk a Create launch template nyomógombra a mentéshez!'''.

==== Target Group ====
A target group EC2-k azon csoportja, amelyeken valamilyen ''health check'' algoritmust futtatunk, ezzel meghatározva, hogy az adott csoportban hány használható, működő szerver fut. Ezt az információt elsőként a Load balancer használja ki.

A Target Group a bal oldali menüben, a ''Load Balancing'' szekcióban érhető el ''Target Groups'' néven.

Létrehozhatunk új csoportot, de meg kell adnunk, hogy milyen módon kerüljenek bele az EC2-k. Erre a következő metódusokat ajánlja fel az Amazon:
# Konkrét EC2 (Instance) kiválasztása
# EC2-k definiálása IP tartománnyal
# Lambda függvény hozzáadása
# Alkalmazás LoadBalancer, amely egy teljes VPC tartalmát magába foglalja.

Az űrlap alján megadhatjuk, hogy milyen életjel ellenőrzés történjen.

Általában nem mi vesszük fel egyesével az Instancokat ebbe a csoportba, hanem az AutoScaling group regisztrálja őket bele. '''Ezért ezt az űrlapot nem használjuk'''.

==== Load Balancer ====
A Load Balancer terheléselosztást jelent, tehát a bejövő forgalmat több gép között osztjuk el. Ezzel növekszik a felhasználói élmény, ráadásul a rendszer megállítása (egy hacker által) nehezebbé válik: ha kettő t2.micro teljesítményű szerver fut, amelyek között elosztjuk a bejövő forgalmat, akkor a rendszerünk valójában 2xt2.micro teljesítményű.

Terheléselosztót a bal oldali menü ''Load Balancing'' szekciójának ''Load Balancers'' menüpontjában hozhatunk létre.

'''A támogatott szolgáltatási szintek:'''
# Alkalmazás terheléselosztás (HTTP, HTTPS)
# Hálózati terheléselosztás (TCP, UDP)
# Átjáró terheléselosztása (GW)

===== Alkalmazás terheléselosztása =====
Ebben a formában konfigurálhatjuk az eszközt úgy, hogy az internet felől elérhető legyen (internet-facing) és úgy, hogy csak belső hálózaton működjön (internal). A belső hálózatot mindig az aktuális VPC-re kell érteni, tehát annak minden alhálózatából elérhető alapértelmezetten.
[[Fájl:GAMFAWS ec2 loadbalancer setup basic.png]]

A hálózati beállításoknál választhatunk, hogy mely alhálózatokban szeretnénk végrehajtani a terheléselosztást, így csak az azokban futó EC2-k kaphatnak ezen keresztül csomagokat. Arra kell ügyelnünk, hogy legalább kettő különböző zónában lévő alhálózatot kell kiválasztanunk (pl. eu-west-1a, eu-west-1b stb.).
[[Fájl:GAMFAWS ec2 loadbalancer setup network.png]]

Természetesen a LoadBalancer internetfelőli végpontján létrehozhatunk ''Security Group''okat, amelyet szabályozzák, hogy milyen IP címről fogadunk el csomagokat.
[[Fájl:GAMFAWS ec2 loadbalancer setup secg.png]]

A ''Listeners and routing'' résznél megadhatjuk, hogy melyik target group fogja a terhelést fogadni, tehát hogy mely EC2-k között tudunk ténylegesen terhelést elosztani. Amennyiben a target group egy darab EC2-t tartalmaz, akkor a terheléselosztás gyakorlatilag nem valósul meg, csak az elméleti esélyét adtuk meg, hogy ''„amennyiben lenne még egy EC2 a target group-ban, akkor a terhelés egy részét az vinné el”''.
[[Fájl:GAMFAWS ec2 loadbalancer setup routing.png]]

Végül kattintsunk a ''Create load balancer'' gombra, amennyiben a kívánt tag-eket is rögzítettük.

==== Auto Scaling Group ====
A szolgáltatás segítségével automatikusan skálázott rendszereket építhetünk ki, ahol a szerverek által nyújtott elérhető erőforrásokat minél közelebb tartja a bejövő terhelés által meghatározott erőforrásigényhez. Természetesen mindez akkor igaz, ha az ''Auto Scaling Group'' be regisztrálja az általa létrehozott ''EC2''-ket egy ''Target Group''-ba, ami felett ''Load Balancing'' van definiálva.

'''Előnyei''':
* Amikor nincs bejövő terhelés, akkor nincsenek nagy költségek
* Amikor nagy a bejövő terhelés, akkor a költségek megugranak ugyan, de az ügyfeleket ki tudtuk szolgálni úgy, hogy elégedettek voltak a rendszer teljesítményével.

'''Hátrányai''':
* Kaotikus számlák, nem előre tervezhető költségek
* Megnövekedett költségek DDoS és egyéb támadások esetén

===== A beállítás lépései =====
A szolgáltatást a bal oldali menü ''Auto Scaling Group'' szekciójában érjük el, az ''Auto Scaling Group'' menüpontban. A képernyő közepén vagy a képernyő jobb felső sarkában megjelenő ''Create auto scaling group'' gombra kattintva egy űrlap jelenik meg, ami végig vezet minket a telepítés lépésein.

'''A Name''' szekcióban elnevezzük az új group-ot.
[[Fájl:GAMFAWS ec2 autoscaling setup name.png]]

'''A következő szekcióban''' két választási lehetőségünk van:
* Launch Template-tel telepítjük az új group-ot, ez esetben csak ki kell választanunk a korábban létrehozott sablont, vagy az alatta található link segítségével készíthetünk újat. ''Amennyiben újat készítünk, a sablon létrehozása új ablakban nyílik meg, így a befejezést követően vissza kéne térnünk erre és a frissítést gombot megnyomva látni fogjuk az új lehetősége(ke)t.
[[Fájl:GAMFAWS ec2 autoscaling setup lt.png]]

* Launch Configuration-nel telepítjük az új group-ot, ez esetben át kell váltatnunk a ''Switch to launch configuration'' link segítségével a blokkot. A váltást követően hasonlóan az előzőekhez: vagy kiválasztjuk a már meglévő konfigurációs sémát, vagy hozhatunk létre újat.
[[Fájl:GAMFAWS ec2 autoscaling setup lc.png]]

'''A Next gombra kattintva a hálózati beállítások''' szekcióhoz érünk, ahol megadhatjuk, hogy az indított EC2 milyen VPC-be kerüljön és azon belül milyen alhálózatokba. VPC-ből egy, alhálózatból több is kiválasztható. Ügyeljünk rá, hogy ha később erre Load Balancer szolgáltatás is kerül, akkor legalább kettő zónát jelöljünk ki!
'''Figyelem!''' A zóna nem egyezik meg az alhálózattal!
[[Fájl:GAMFAWS ec2 autoscaling setup network.png]]

'''A Next gombra kattintva a Load Balancing beállítások''' következnek, ahol választhatunk:
* Nincs terheléselosztás opciót,
* Létező Load Balancer hozzáillesztését,
* Új Load Balancer létrehozását.

Utóbbi esetében a Load Balancer konfigurálásánál leírt módon ki kell töltenünk a Load Balancer űrlapját is helyben. 
[[Fájl:GAMFAWS ec2 autoscaling setup lb setup.png]]

Hasonlóan a ''Target Group''-ot is létrehozhatjuk helyben, amennyiben ezt nem tettük meg korábban.
[[Fájl:GAMFAWS ece autoscaling setup new lb new tg.png]]

'''A Next gombra kattintva a csoport méretét definiálhatjuk''', azaz megszabhatjuk, hogy hány darab szervertől, hány darab szerverig engedélyezzük az automatikus skálázást. Ez egy hasznos funkció, hiszen ezzel korlátok közé szoríthatjuk a költségeinket, miközben a legkisebb terhelés esetén is előkészülhetünk egy hirtelen bejövő nagyobb terhelésre (ha a minimum nem 1).
* Desired capacity: ennyi szervert fog elindítani az ASG mentés után
* Minimum capacity: ennyi szerver esetén már nem állít le semmit az ASG
* Maximum capacity: ennyi szerver esetén már nem indít el újabbat az ASG
[[Fájl:GAMFAWS ec2 autoscaling setup group.png]]

'''Alatta a Scaling Policy''' blokkban megadhatjuk, hogy milyen paraméterek mentén indítson vagy épp állítson le szervereket az ASG. Ehhez aktiválnunk kell a szolgáltatást és a ''Metric type'' listából ki kell választani az számunkra megfelelőt. Mi általában CPU terhelés alapján döntünk az órán.
[[Fájl:GAMFAWS ec2 autoscaling setup scaling.png]]

'''A Next gombokkal lépkedve hozhatunk létre Tag-eket, majd végül létrehozhatjuk az ASG-t is és az ''Instances'' menüpontban ellenőrizhetjük, hogy ténylegesen elindult a kívánt darabszámú szerver.'''

=== RDS szolgáltatások ===
A ''Relational Database Service'' foglalja magában a különböző adatbázisokat:
* MariaDB
* MySQL
* Aurora
* Oracle
* PostgreSQL
* MSSQL

'''Figyelem!''' Az itt felsorolt szerverek között lehetnek fizetősek is. Mindig járjunk el figyelmesen, kövessük a költségeket. Az RDS az amazon egyik legdrágább szolgáltatása.

==== MySQL adatbázis telepítése ====
==== Csatlakozás MySQL adatbázishoz CLI-ből ====
<syntaxhighlight lang="bash">
apt install mysql-client -y
# mysql -h<rds_endpoint> -u<rds_user> -p<rds_password>
mysql -hwebshop-989.rds.amazon.com -uadmin -p123456789
</syntaxhighlight>

A megnyíló '''mysql>''' PROMPT-ot tartalmazó sor azt jelenti, hogy sikeresen csatlakoztunk az SQL szerverhez. Amennyiben a csatlakozás sikertelen, akkor valószínűleg az RDS-hez kapcsolt Security Group beállításai nem engedik az EC2-ről a kapcsolódást - tipikusan a mi saját publikus IP címünk kerül bele az engedélyezett tartományba (pl. iskolai IP vagy otthoni) és ez nem került átírásra az amazonos tartománynak megfelelően.

A konzolra be kell illeszteni a ''networks.sql'' fájl tartalmát. A végén '''exit''' paranccsal léphetünk vissza a BASH környezetbe.

=== VPC ===
A '''V'''irtual '''P'''rivate '''C'''loud egy szolgáltatás, melynek segítségével össze köthetjük az összetartozó komponenseket, alkalmazásokat. A VPC-t modellezhetjük hétköznapibb értelemben, mint egy routert, amelynek vannak alhálózatai, route táblája és valamilyen gateway címe, amin keresztül a kliensei az internet más résztvevőivel tudnak kommunikálni.

A VPC szolgáltatásait a keresőbe írt ''VPC'' kulccsal érhetjük el.
==== VPC létrehozása ====
Navigáljunk a 'Your VPCs' menüpontra a bal oldali menüben és kattintsunk a jobb felső sarokban látható ''Create VPC' gombra. Ezután megnyílik egy űrlap, amely végig vezet minket a telepítés lépésein.

Az űrlap elején választhatunk, hogy ''VPC only'' vagy ''VPC and more'' módban szeretnénk folytatni. Előbbi csak a VPC-t hozza létre nevéből is adódóan, míg a másik opcióval létrehozhatjuk az alhálózatokat is, igaz, a tervezés szabadságáról le kell ilyenkor mondanunk, cserébe grafikán láthatjuk az eredményt. Számunkra az órán utóbbi nem lesz megfelelő, hiszen szükségünk lesz a ''tervezés szabadságára''. 
[[Fájl:GAMFAWS vpc setup.png]]

A VPC beállításainál mindig a teljes hálózatot átfogó IP/MASZK párost kell megadnunk, később az alhálózatok nem lóghatnak ki az itt megadott tartományból.

==== Alhálózatok ====
Az alhálózatok lehetőséget biztosítanak arra, hogy az egyes komponenseket el is szigeteljük egymástól, meg engedélyezzünk is közöttük bizonyos kommunikációt.

Alhálózatok típusai:
* Publikus: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten kapnak publikus IP címet
* Privát: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten nem kapnak publikus IP címet

===== Alhálózatok létrehozása =====
Navigáljunk a ''Subnets'' menüpontra. A képernyő jobb felső sarkában kattintsunk a ''Create subnet'' gombra, így megkapjuk a létrehozási űrlapot.

'''Először''' a VPC-t kell kiválasztanunk, aminek eredményeképp kiírja segítségképp annak tartományát. Ezen a tartományon kívül nem léphetünk. 
[[Fájl:GAMFAWS vpc subnet setup.png]]

A VPC kiválasztása után aktívvá válik az alhálózatok űrlap, ahol megadhatjuk annak nevét, hálózati címét és maszkját. 
[[Fájl:GAMFAWS vpc subnet setup new.png]]

'''Figyelem!''' A rendszer csak hálózati címet fogad el! Minden más esetben hibát ír ki.

A ''Remove'' gombbal eltávolíthatjuk az aktuális konfigurációt a listából, míg a lentebb található ''Add new subnet'' segítségével újabbat vehetünk fel.

Befejezésül nyomjuk meg a ''Create subnet'' gombot, így az összes definiált alhálózat létrejön a kiválasztott VPC-hez.

===== Publikus/Privát alhálózat beállítása =====
Az alhálózat típusának átállításához navigáljunk a ''Subnets'' menüpontra. Kattintsunk jobb gombbal a kívánt alhálózat során és válasszuk ki az ''Edit subnet settings'' opciót. 
[[Fájl:GAMFAWS vpc subnet edit s settings.png]]

Az űrlapon keressük meg az ''Auto-assign IP settings'' blokkot és a kívánt típusnak megfelelően módosítsuk azt.
[[Fájl:GAMFAWS vpc subnet edit type.png]]

===== Különböző route tábla minden alhálózaton =====
A VPC támogatja, hogy minden subnet saját route táblával rendelkezzen. Ez lehet akár egy biztonsági funkció is, hogy ne ismerje minden EC2 az útvonalat egy adott szerverhez, de egyes esetekben kötelezően létre kell hoznunk. A route táblákat a ''Route tables'' menüpontban hozhatjuk létre és a ''Subnets'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Edit route table association'' opciót kiválasztva szerkeszthetjük.

'''Figyelem!''' A route táblák cseréje okozhat internetelérési problémákat szerver oldalon, aminek következtében a futó szolgáltatások számunkra is elérhetetlenekké válnak (pl. SSH és/vagy HTTP/HTTPS stb.), így legyünk körültekintőek.

==== Internet Gateway ====
Ahhoz, hogy a VPC-n belül legyen internet, ahhoz egy IGW-t kell hozzá csatolnunk. Ezt megelőzően azonban létre kell hoznunk egyet.
'''Figyelem!''' A VPC-hez nem kapcsolt IGW-k pénzbe kerülhetnek, mivel feleslegesen foglalnak le egy publikus IPv4 címet.

[[Fájl:GAMFAWS vpc igw setup.png|bélyegkép|Internet Gateway létrehozás]]
Az IGW az ''Internet Gateways'' menüpont alatt érhető el és a jobb felső sarokban található ''Create internet gateway'' gombbal hozhatunk létre újat. Csupán egy nevet kell megadnunk, illetve rakhatunk rá tag-eket igény szerint.

A létrehozást követően hozzá kell rendelnünk egy létező VPC-hez, amit az ''Internet Gateways'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Attach to VPC'' opciót kiválasztva tudunk megtenni. Amennyiben a soron az ''Attached'' (zöld színű) felirat jelenik meg a (szürke színű) ''Detached'' helyett, akkor nem tudjuk VPC-hez csatolni (ilyenkor először a ''Detach from VPC'' opciót kell választanunk). 
[[Fájl:GAMFAWS vpc igw attach.png]]

Az IGW VPC-hez rendelése után a kívánt route táblákba fel kell vennünk, hogy minden csomagot arra irányítson.
[[Fájl:GAMFAWS vpc igw route setup.png]]

==== NAT Gateway ====
Lehetőség van Internet Gateway helyett NAT Gateway létrehozására is, de ez egy fizetős szolgáltatás. A nevének megfelelően ez lehetőséget biztosít, hogy azok az EC2-k, amelyek privát alhálózatba kerültek, kilássanak az internet felé (pl. frissítések keresése, telepítése), miközben védve vannak a kívülről érkező támadásoktól.
'''Ez egy lehetséges oka lehet, hogy külön válasszuk a route táblákat az alhálózatokon, hiszen az egyiknek minden csomagot az IGW felé, míg a másiknak minden csomagot a NAT Gateway felé kell továbbítania.''' ''Ha nem használunk NAT Gatewayt, akkor is érdemes lehet leválasztani az IGW-ről a privát alhálózatokat.''

=== AWSCLI ===
Az AWSCLI egy konzolos alkalmazás, amelynek segítségével menedzselhetjük környezetünket: hozhatunk létre új EC2-t akár, vagy kapcsolhatunk hozzá egyéb szolgáltatásokat (Security Group, ASG, LB stb.).

Az awscli program elérhető linux és windows környezetben egyaránt.

==== AWSCLI telepítése ====
A program telepítéséhez a következő parancsot kell futtatnunk: '''apt install awscli'''.
==== Access Key management ====
Az ''awscli'' hozzáférési kulcsokon keresztül kap jogosultságot a szolgáltatások adataihoz, így használata előtt készítenünk kell egy újat. Ez a nevünkre kattintva (jobb felül), majd a ''Security credentials'' menüpontot kiválasztva tehetjük meg, az ''Access keys'' szekcióban. Nyissuk ezt le és kattintsunk a ''Create New Access Key'' gombra. 
<center>
{|
| [[Fájl:GAMFAWS UserMenu.png|150px|keretnélküli]] || [[Fájl:GAMFAWS SecurityCredentials.png|keretnélküli]]
|}
</center>

A gomb megnyomása után egy felugró ablak fogad, amelyben megtalálható az ''Access Key'' és a ''Security Access Key'' értéke. Érdemes a fájlt letölteni, hogy később is elérhetők legyenek ezek az adatok, '''az AWS többet nem fogja engedélyezni ezek megjelenítését!''' Ha az adatokat később nem tudjuk megadni, akkor újat kell készíteni.
[[Fájl:GAMFAWS SecurityCredentials ShowData.png|középre]]

==== AWS CLI konfigurálás autentikációs adatokkal ====
Az eszköz telepítése annak konfigurálásával ér véget: meg kell adnunk az autentikációs tokeneket. 
Ezt az '''aws configure''' parancs kiadásával tehetjük meg, ahol egyesével bekéri a szükséges adatokat. Ahol nem szeretnénk változtatni az előző értéken (szögletes zárójelek között láthatjuk ezt), ott hagyjuk üresen a sort és csupán entert nyomjunk.
[[Fájl:GAMFAWS AWSCLI config.png|középre]]

Az adatok megadása után menedzselhetjük az aws parancsokkal a környezetünket. Az aws parancsairól az '''aws help''' szolgáltat információt.

=== S3 ===
Ez a szolgáltatás fájlok tárolására alkalmas.

Több típusa is elérhető:
* Standard:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban sűrűn használt objektumok tárolására alkalmas
** A régiók közötti szinkronizáció megoldott
* Instant Glacier:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban ritkábban használt, hosszú élettartamú, de azonnali hozzáférést igénylő objektumok tárolására alkalmas
* Flexible Glacier:
** Magas rendelkezésre állás jellemzi
** Az alkalmazásban ritkán használt (évente 1x-2x), a mérettől független költséggel rendelkező megoldás
* Deep Archive Glacier:
** 7-10 évig tárolt adatokhoz optimalizált költségvonzat
** Előnyös a backup adatok tárolásához

A szolgáltatás a keresőben ''S3'' füzérrel kereshető.

==== Bucket létrehozása ====
Új tárolót a ''Create bucket'' gomb segítségével hozhatunk létre. A megjelenő űrlapon a nevet kell kitölteni és érdemes egy pillantást vetni a publikusság beállításaira is, hogy ez ténylegesen a célunknak megfelelő legyen.

'''Figyelem!''' A névnek nem csupán a mi környezetünkön belül kell egyedinek lennie, hanem a teljes AWS-en belül.

{| style="margin:auto"
| [[Fájl:GAMFAWS S3 new name.png|bélyegkép]] || [[Fájl:GAMFAWS S3 new public.png|bélyegkép]]
|}

==== Bucket kezelése ''awscli'' programmal ====
Az '''aws s3 help''' parancs segítségével további információt szerezhetünk az egyes utasításokról.

'''Bucket tartalmának listázása''' 
<syntaxhighlight lang="bash">
aws s3 ls [bucket_name]
</syntaxhighlight>
[[Fájl:GAMFAWS S3 CLI LS.png|középre]]

'''Adatok másolása Bucket-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* LOCAL_PATH a lokális fájlrendszeren belüli elérési útvonala a forrásfájlnak (vagy könyvtárnak)
* REMOTE_PATH a cél helye az S3-ban
** Az s3:// jelzi, hogy a cél az S3-ban van (S3Uri)
** A mappák helyett PREFIX-ek vannak (/folder/to/my/file esetében /folder/to/my a PREFIX)
** A mappákat nem kell S3-ban létrehoznunk (az előző pontból következik), a fájlnév előtti prefix dönti el a hova tartozását
** A PREFIX-eket az '''ls''' úgy kezeli, mint egy mappát
[[Fájl:GAMFAWS S3 AWSCLI cp2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* --recursive jelzi, hogy a LOCAL_PATH alatt minden bejegyzést töltsön fel
[[Fájl:GAMFAWS S3 AWSCLI copy recursive2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ból helyi fájlrendszerbe''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive s3://REMOTE_PATH LOCAL_PATH
</syntaxhighlight>
[[Fájl:GAMFAWS S3 AWSCLI cp2local.png|középre]]

==== Bucket kezelése grafikus felületen keresztül ====
Az S3 tartalmát elérhetjük az AWS grafikus felületén keresztül is, így tölthetünk fel, törölhetünk és módosíthatunk fájlokat anélkül, hogy saját számítógépünkre telepítenénk az ''awscli'' programot.

# Nyissuk meg az S3 szolgáltatás vezérlőpultját
# Kattintsunk a szerkeszteni kívánt tárhely nevére [[Fájl:GAMFAWS S3f list.png]] 
# A vezérlőgombok segítségével végezzük el a kívánt műveletet (feltöltés, törlés), vagy válasszunk ki egy PREFIX-et az „almappák” tartalmának megtekintéséhez. [[Fájl:GAMFAWS S3 control.png|középre]]

= Alkalmazások telepítése =
== UI ==
== API ==

= Indítást gyorsító scriptek =
== UI indítás ==
<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun code
API_LB_DOMAIN="localhost" # api server IP

apt update
apt install wget unzip apache2 libapache2-mod-php8.3 php8.3 php8.3-curl -y

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui.php
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui_newproduct.php
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv ui.php /srv/$NEPTUN/index.php
mv ui_newproduct.php /srv/$NEPTUN/newproduct.php

# remove tmp directory
cd /
rm /tmp/code

cat << EOF > /etc/apache2/sites-enabled/000-default.conf
<VirtualHost *:80>
#ServerName www.example.com

ServerAdmin webmaster@localhost
DocumentRoot /srv/$NEPTUN

<Directory /srv/$NEPTUN/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>

ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

systemctl restart apache2
</syntaxhighlight>

== API indítás ==

<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun
MYSQL_DOMAIN="localhost" # RDS mysql domain

apt update
apt install wget unzip python3 python3-pip python3-flask -y
pip3 install mysql-connector-python --break-system-packages

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$MYSQL_DOMAIN/g" api.py
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv api.py /srv/$NEPTUN/

# remove tmp directory
cd /
rm /tmp/code

echo "@reboot root sleep 10s && python3 /srv/$NEPTUN/api.py &" >> /etc/crontab
cd /srv/$NEPTUN && python3 api.py &
‎</syntaxhighlight>

EDU::GAMF::Felhőalapú-szolgáltatások::AWS

2025-10-14T06:08:44Z

ApelPro: /* UI indítás */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
[[category:GAMF AWS|AWS]]
== Amazon Web Services regisztráció ==
Az AWS mindenki számára biztosít 1 év ingyenes próbaverziót. Ehhez regisztrálnunk kell a rendszerbe, amihez szükségünk lesz egy email címre, egy telefonszámra a megerősítéshez és egy netes vásárlásra alkalmas bankkártyára. A regisztráció során az AWS 1$-ral meg terheli a számlát, de később erre nem tart igény, így a tranzakció lejáratakor jóváíródik a számlán.

== Ingyenes verzió korlátai ==
Az ingyenes verzióban nem minden érhető el és ami mégis, az sem korlátlan ideig (750 óra EC2 futási idő például), amit ha átlépünk, akkor fizetési kötelezettségünk jelentkezik a szolgáltató felé. Igyekezzünk mindent leállítani az órai munka illetve az otthoni gyakorlás után, hogy lehetőleg ne kerüljön pénzbe a féléves munkánk. A hallgatók által elszenvedett károkért sem az iskola sem Én nem tudunk felelősséget vállalni, de azt meg tudjuk ígérni, hogy fizetős szolgáltatást nem használunk és nem is kérünk számon.

== AWS alapok ==
'''Figyelem!''' Az iskolai hálózatból csak az eu-west-1 és az eu-central-1, azaz Írország és Frankfurt IP címei vannak engedélyezve, ezekre fogunk tudni SSH kapcsolaton keresztül csatlakozni. 
'''Figyelem!''' Próbaidőszak alatt minden szolgáltatás mellett keressük a ''Free tier eligible'' megjegyzést, különben fizetési kötelezettségünk adódhat!

=== EC2 szolgáltatásai ===
Az ''EC2'' gyakorlatilag egy VPS-nek feleltethető meg és nem is tévedünk vele hatalmasat. A neve az ''Elastic Cloud Compute'' szavak kezdőbetűiből kialakuló ''ECC''-ből fakad, a ''2''-es a végén jelzi, hogy a ''C'' betűből kettő van.

A különbséget a VPS-hez az EC2 futási ideje okozza: bár nem feltétlen, de meg van a lehetősége, hogy egyik napról a másikra megszűnjön egy EC2 úgy, hogy az alkalmazásunk mégis működőképes marad. E tulajdonsága miatt kapta az ''Elastic'' nevet, amit körültekintően kell kezelni: semmilyen adatot nem tárolhatunk úgy egy alkalmazáson belül, mint egy VPS esetén: a dinamikus adatok (pl. PHP Session, feltöltött fájok) egy EC2 csere esetén elvesznek, így ezeket nem helyben fogjuk tárolni.

Az EC2 szolgáltatásait a keresőmezőbe írt ''„EC2”'' kulcsszóval és az eredményekben megjelenő ''EC2''-re való kattintással érhetjük el.

[[Fájl:GAMFAWS search EC2.png.png]]

Az alapértelmezetten megjelenő menüpont a ''Dashboard'', ahol információkat találhatunk az ''EC2'' köré felhúzható szolgáltatásokról, melyeknek egy részét a továbbiakban tárgyalni is fogunk. Az összefoglaló táblázat az alább látható módon jelenik meg. '''Figyelem''', a táblázat csak az adott régióban elindított/elérhető szolgáltatásokat mutatja, régió váltása előtt érdemes az esetlegesen létrehozott, régió függő elemeket leállítani, hogy később ne jelenjen meg fizetési kötelezettség.

[[Fájl:GAMFAWS ec2 dashboard.png]]

==== EC2 telepítése és beállítása ====
EC2 létrehozásához meg kell nyomnunk a ''Launch instance'' gombot, melyet több helyen is elérhetünk:
* A Dashboardon
* A bal oldali menüben található ''Intances'' menüpont megnyitása után jobb felül
A gomb minden esetben a következőképp néz ki: [[Fájl:GAMFAWS ec2 launch instance button.png]]

A gombra kattintva egy űrlap jelenik meg, amely segítségével elvégezhetjük a szükséges beállításokat: 
======Név és tag beállítok======
Megadása nem kötelező, de több szerver futtatása esetén könnyebben azonosíthatjuk be őket ezek segítségével
[[Fájl:GAMFAWS ec2 setup name and tags.png]]

Az ''Add additional tags'' gombra kattintva további kulcs=érték párokat adhatunk hozzá, amivel dinamikusan csatolhatjuk össze egyéb szolgáltatásokkal, amelyek egy-egy kulcsot keresve döntik el, hogy melyik szolgáltatásokkal kell együttműködniük (például monitorozás bekapcsolása 'monitoring=true' kulcs=érték pár alapján.

======Kezdeti képfájl kiválasztása======
Az Amazon többféle indítóképpel is rendelkezik, így nagy valószínűséggel meg fogjuk találni a hozzánk közelálló operációs rendszert. Új hozzáadására nincs lehetőségünk, de készíthetünk az alapképfájlokból olyan verziót, ami már tartalmazza a saját konfigurációnkat (lásd [[GAMF :: Felhőalapú-szolgáltatások :: AWS#AMI_létrehozása|itt]]). 
[[Fájl:GAMFAWS ec2 setup AMI choose2.png]] 
Az órákon az Ubuntu legújabb verzióját használjuk, mivel ennek a Desktop változata az egyik legelterjedtebb a Linux felhasználók körében, így nem kell más környezetet megszoknia egy átlag hallgatónak. Érdemes lehet azonban egyéb disztribúciók kipróbálása is, különösen a '''Debian'''-t, '''Suse'''-t/'''OpenSuse'''-t, '''ReadHat'''-et és annak ingyenes változatait ('''AlmaLinux''', '''RockyLinuxtm''', amelyek az egykori '''CentOS'''-t hivatottak váltani), mivel céges környezetben ezek sűrűbben előfordulnak: némelyik a kisebb erőforrásigénye, míg másik az Enterprise szolgáltatásai miatt.

======Szerver típusának meghatározása======
Különböző erősségű szerverkonfigurációk közül választhatunk, de természetesen nem mindegyik érhető el az ingyenes verzióban. A számítógépek ára a konfiguráció függvényében változik, de csak azért az időért kell fizetni, amíg a szerver ''Running'' állapotban volt. Az órán az alapértelmezett ''t2.micro''-t használjuk. 
[[Fájl:GAMFAWS ec2 setup instance type.png]]

======Kulcspár hozzárendelése======
Az Amazonon belüli szolgáltatásokat felhasználónév/jelszó páros helyett SSH kulcspárok segítségével érjük el. Minden felhasználó számára készíthetünk egyet és jogosultságok segítségével korlátozhatjuk, hogy mihez férhet hozzá (IAM). 
Ebben a szekcióban ki kell választanunk, hogy a telepíteni kívánt EC2-höz milyen kulcspárral lehet majd hozzáférni. Amennyiben nem rendelkezünk még kulcspárral, úgy van lehetőségünk helyben elkészíteni a ''Create new keypair'' gomb segítségével, amelynek lépési megegyeznek az [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Kulcspár_létrehozása|itt]] leírtakkal. 
[[Fájl:GAMFAWS ec2 setup keypair.png]]

======Hálózati és biztonsági beállítások======
Az EC2-k közötti kommunikációs csatornák kialakításához definiálnunk kell, hogy melyik virtuális hálózatba akarjuk elhelyezni és milyen alkalmazásokat szeretnénk elérhetővé tenni. Ezt a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#VPC_beállításai|VPC]] és a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Security_Group|Security Group]] beállításával tehetjük meg. Előbbi a virtuális hálózatnak felel meg, míg utóbbi hasonlóan egy tűzfalhoz, meghatározza, hogy a szerveren milyen portokat érhetünk el. Érdemes az SSH-t engedélyezni és ha webes alkalmazást szeretnénk rajta futtatni a későbbiekben, akkor a HTTP és/vagy HTTPS szolgáltatást/szolgáltatásokat is, így később nem kell szerkeszteni ezeket a beállításokat. 
[[Fájl:GAMFAWS ec2 setup networking.png]]

======Tárhely beállítások======
Ebben a részben adhatjuk meg, hogy a szerverünk mekkora tárhellyel rendelkezzen. Egy Linux alapú operációs rendszernek nem kell 8GB-nél több, így az alapértéken hagyhatjuk. Az itt megadott érték inkább csak egy korlát, valójában csak akkora tárhelyet vesz igénybe, amennyire ténylegesen szüksége van a rendszernek. Ez az érték alatt látható figyelmeztetés miatt lényeges, hiszen a 30GB-t elhagyva fizetőssé válik a tárterület is, ám ez nem jelenti, hogy csak 4 szervert tudnánk elindítani az ingyenes keretek között. 
[[Fájl:GAMFAWS ec2 setup ebs.png]]

Ezt a szolgáltatást EBS-nek nevezik (''Elastic Block Store'') és az EC2 megszűnésekor minden erre mentett adat elveszik, így általában az OS-t és az applikáció kódját tároljuk ezen - semmi dinamikus adatot.

======Haladó beállítások======
Ebben a szekcióban különböző beállításokat végezhetünk el, ám ezeket az órán nem módosítjuk. Érdekes lehet azonban a menüt lenyitva legalul található ''User data'' opció, amivel parancsokat adhatunk meg az új operációs rendszer számára, hogy miket futtasson le. Ennek segítségével lehetőségünk nyílik applikációk telepítésére - pl. git - és a kód letöltésére egy másik szerverről, amennyiben a kiválasztott képfájl nem tartalmazta azt. 
''Az órai keretek között ezt a funkciót nem használjuk ki, de érdemes lehet kipróbálni, mivel valós alkalmazások üzemeltetésekor jól jöhet.'' 
[[Fájl:GAMFAWS ec2 setup userdata.png]]

======Összefoglaló======
A beállító panel mellett jobbra találhatjuk az összefoglaló ablakot, amelyben megtalálható a ''Launch Instance'' gomb. Ennek segítségével kezdhetjük meg a végleges telepítést, ha erre rá nyomunk, akkor a rendszer megkezdi a kiválasztott konfiguráció telepítését. Ha ebben az ablakban pénzösszegeket látunk, akkor az egészen biztosan fizetési kötelezettséget vonz magával, legyünk körültekintőek. 
[[Fájl:GAMFAWS ec2 setup summary.png]]

======Az elkészült instance tulajdonságai======
A futó szerverek az ''Instances'' menüpontban érhetők el. Az egyes sorokra kattintva alul megtekinthetjük a beállításait, amely tartalmazza az AWS által kiosztott publikus és privát IP címeket és domain neveket. Ezeken keresztül tudunk kommunikálni szerverünkkel. 
[[Fájl:GAMFAWS ec2 properties.png]] 
''Jelen példában a külső IP címünk: 3.252.168.207, amit a mellette található ikonnal egyszerűen a vágólapra másolhatunk.''

======Csatlakozás Linux terminálból======
A csatlakozáshoz nyissunk meg egy terminált a CTRL+T billentyűkombinációval, majd navigáljunk a ''cd'' parancs segítségével a letöltött kulcsfájl mappájába. Az SSH megköveteli, hogy a csatlakozáshoz használt kulcsfájlhoz csak a tulajdonos felhasználó férjen hozzá, így a következő parancsot futtassuk le rajta: ''chmod 600 test.pem''

A következő paranccsal tudunk kapcsolódni: ''ssh -i test.pem ubuntu@3.252.168.207'' 
Ha a fenti parancs kéri, fogadjuk el a tanúsítványt. Amennyiben ''Permission error'' hibát kapunk, akkor a fenti ''chmod'' parancsra van szükségünk, vagy nem mi vagyunk a kulcsfájl tulajdonosai (''ls -l'' segíthet). 
A ''test.pem'' az AWS rendszerből letöltött .pem formátumú kulcsfájl, az ''ubuntu'' a szerveren elérhető felhasználó. A különböző disztribúcióknál használt felhasználónevekről [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connection-prereqs.html ezen] a linken tájékozódhatsz. 
[[Fájl:GAMFAWS ec2 connect linux.png]]

======Csatlakozás Putty használatával======
Amennyiben a .pem kiterjesztésű állományt töltöttük le az AWS rendszeréből, akkor a '''puttygen''' eszköz segítségével ki kell exportálni belőle a privát kulcsot. [https://www.ssh.com/academy/ssh/putty/windows/puttygen Ezen a linken] részletes segédlet található a programcsomaghoz, ahol további funkciók is bemutatásra kerülnek (pl. kulcsgenerálás).

==== Kulcspár létrehozása ====
A kulcspárok kezeléséhez a ''Key Pairs'' linket nyissuk meg a bal oldali menüből. Újat a jobb oldalon látható ''Create key pair'' gomb segítségével készíthetünk. [[Fájl:GAMFAWS ec2 keypair create.png]]

A gombra kattintva egy űrlapot kapunk, amely végig vezet minket a létrehozás lépésein.
# Név megadása
# Típus kiválasztása - ''RSA-val dolgozunk az órán''
# Letöltendő kulcs típusa - ''Linux terminálból való csatlakozáshoz a .pem fájlra lesz szükségünk''
# Esetleges tag-ek hozzárendelése
# A ''Create key pair'' gombra kattintva letölthetjük a kulcspárt

[[Fájl:GAMFAWS ec2 keypair setup.png|Kulcspár létrehozása]]

'''Figyelem!''' A kulcspár csak a létrehozás után tölthető le '''egyetlen egyszer''', az elvesztett fájlok nem reprodukálhatók! Amennyiben egy EC2 csak az elhagyott kulcspárral érhető el, úgy annak (EC2) törlése és újrakonfigurálása szükséges egy új kulccsal.

==== Security Group ====
A Security Group-ok segítségével kontrollálhatjuk, hogy a szervereinkhez milyen portokon férhetnek hozzá, tehát mintegy tűzfal működik. Egy Security Group több gépre is ráhúzható és függetlenül működik, azaz a megadott szabályokat nem másolja át az operációs rendszer konfigurációs állományaiba, mintegy a szerver elé telepített eszköz működik. Ennek köszönhetően futási időben változtathatjuk a szabályokat, életbelépésükhöz nem kell újracsinálni az EC2-ket.

A bal oldali sávban, a ''Network & Security'' csoportban érhető el.

===== Security Group hozzáadása =====
Egy új szabályrendszer felvételét kezdeményezhetjük az EC2 telepítésekor, ahogyan azt [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Hálózati_és_biztonsági_beállítások|itt]] is láthattuk, de készíthetünk előre meghatározottakat is.

Az előre definiált csoportokat a ''Create Security Group'' gomb segítségével hozhatjuk létre, amelyet a jobb felső sarokban találhatunk meg. 
[[Fájl:GAMFAWS ec2 secg new button.png|bélyeg]sdfsad] 

A gomb megnyomását követően egy űrlapot kapunk, melynek 3 fő része van:
# Általános adatok [[Fájl:GAMFAWS ec2 secg new basic.png|bélyeg|Általános adatok]]
#* '''A név és a leírás mező megadása is kötelező'''
#* Itt választhatjuk ki, hogy mely VPC-ben szeretnénk elérhetővé tenni.
# Bejövő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg inbound.png|bélyegkép|Inbound rules]]
#* '''Az itt megjelenő szabályok lesznek engedélyezve a szerverünk felé, minden más csomag eldobásra kerül'''
#* Háromféle szabályból választhatunk:
#** '''Anywhere''' (IPv4, IPv6): A megadott IP típusból mindenhonnan elfogadjuk a csomagokat
#** '''Custom''': Csak a megadott IP címekről/IP tartományokból érjük el az adott portot
#** '''MyIP''': automatikusan beillesztésre kerül az felhasználó aktuális IP címe (hasonló a custom lehetőséghez)
# Kimenő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg outbound.png|bélyegkép|Outbound rules]]
#* A kimenő forgalom szabályozása biztonsági szempontból megfontolandó, de természetesen a publikus alkalmazások esetében (pl. web) nem tudunk ilyen szűrést alkalmazni.
#* Alkalmazhatjuk például SSH-ra, hogy megszüntessük annak a lehetőségét, hogy egy esetleges fertőzésből kifolyólag SSH-t hackelgető botnetté változzunk (volt már hasonló tapasztalat).
#* Az órán ezzel bővebben nem foglalkozunk, de éles környezetben ne felejtsünk el ezen szabályok definiálására időt szánni.
# Tag-ek megadása

===== Security Group szerkesztése =====
A szerkeszteni kívánt soron kattintsunk jobb gombbal és válasszuk ki a szerkeszteni kívánt szabályok csoportját:
* '''Edit inbound rules''', ha a bejövő csomagok szűrését szeretnénk módosítani,
* ''' Edit outbound rules''', ha a kimenő forgalmat szeretnénk szűrni.
A megnyíló ablakban ugyanazon a módon vehetünk fel szabályokat, ahogyan a létrehozásnál. A módosítások mentés után életbe lépnek. 
[[Fájl:GAMFAWS ec2 secg context menu.png]]

==== Terheléselosztás vázlat ====
[[Fájl:EC2LoadBalancingRequirements.png|középre]]

==== AMI ====
Az AMI gyakorlatilag egy bitről-bitre lemásolt HDD képfájl, amely tömörítve lett. Így tárolja az összes elmentett adat- és konfigurációs állományt. Ha egy alkalmazást készítünk, akkor a következő okokból készítünk ilyen képfájlt:
# Biztonsági mentés a telepített szolgáltatásokról, így később nem kell egy esetleges hiba miatt újrakonfigurálni az egészet
# AutoScaling group-ba szeretnénk rendezni az alkalmazásunkat, annak pedig meg kell mondani, hogy melyik képfájlt indítsa el

'''Figyelem!''' A képfájlok úgynevezett snapshot-okat hoznak létre, amelyek tárolásáért fizetni kell, ha az összméret meghaladja a 8GB-ot. (A snapshotok az éppen futó rendszer miatt készülnek: minden írási műveletet lezár, majd a snapshot készítés után elindított írási műveletek már a háttértár egyéb területeire történik, amelyet a mentés nem fog tartalmazni, így garantálható, hogy nem lesznek félig lezárt fájlok a mentésben. Lásd bővebben: BTRFS (linux) és NTFS support). A pillanatképek nem törölhetők, amíg a belőlük készült AMI létezik!

===== AMI létrehozás lépései =====
'''Navigáljunk az Instances menüpontra, ahol láthatjuk, hogy milyen EC2 szolgáltatások vannak a rendszerünkben.'''
# Kattintsunk jobb gombbal azon az elemen, amelyet menteni szeretnénk
# Nyissuk ki az ''Image and templates'' menüpontot
# Kattintsunk a ''Create image'' lehetőségre 
[[Fájl:GAMFAWS ec2 ami create.png]]

'''Nevezzük el a képfájlt tetszés szerint''' 
[[Fájl:GAMFAWS ec2 ami setup.png]]

'''Navigáljunk a bal oldalon található menüben az ''Images'' szekcióhoz és válasszuk ki az ''AMIs'' elemet. Itt megtekinthetjük és törölhetjük a létrehozott képfájljainkat.''' 
[[Fájl:GAMFAWS ec2 ami list.png]]

'''Ha a mentés sikeresen elkészült, akkor az EC2 létrehozásánál kiválaszthatjuk azt.''' 
[[Fájl:GAMFAWS ec2 setup own ami select.png]]

==== Indítási konfigurációk elkészítése ====
Az indítási konfigurációk mind egy célt szolgálnak: egységes profilba rendezi az EC2-ről készült képfájlokat. Míg az AMI nem tárolt információt a mentett gép erőforrásáról, egy indítási konfigurációban megadhatjuk ezeket. Később ezek felhasználásával egyszerűbben indíthatunk újabb szervereket és vannak olyan esetek is, amikor a rendszer megköveteli, hogy a képfájl megadása helyett konkrét, hardverinformációkat is tároló konfigurációs sablonokat adjunk meg.

''Az Auto Scaling Group például megköveteli, hogy a következő kettő elem közül az egyiket megadjuk, ebből fogja tudni, hogy milyen típusú EC2-t, mekkora tárhellyel és milyen VPC-ben indítson el.''

===== Launch configuration =====
'''Egy kifutóban lévő konfigurációs séma, amely 2022. December 31-e után nem kapja meg a frissítéseket. Az AWS javaslata szerint érdemes ezeket a beállításokat a következőkben tárgyalt ''Launch template'' alá migrálni.

A ''Launch configuration'-nek nevezett séma egy egyszerűsített változata a sablonoknak. Jóval kevesebb beállítási lehetőséget tartalmaz, mint a párja, de tökéletesen elegendőt az ''Auto Scaling Group''hoz.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Auto Scaling group'' szekciót és válasszuk ki a ''Launch Configuration'' menüpontot. A jobb felső sarokban található ''Create launch configuration'' gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''Név megadása''', aminek segítségével később hivatkozhatunk erre az elemre. Kitöltése kötelező! 
[[Fájl:GAMFAWS ec2 launch conf setup name.png]]

''AMI kiválasztása'', tehát azok képfájl megadása, amit a kiválasztott EC2 konfiguráció futtatni fog. Lehetőségünk van a saját készítésű (''My AMIs'') és a közösségi képfájlok közül választani (''Marketplace''). 
[[Fájl:GAMFAWS ec2 launch conf setup ami.png]]

'''Instance típus''' alatt megadhatjuk, hogy a konfiguráció milyen teljesítményű legyen.
'''Ne feledjük el, hogy a t2.micro az ingyenes, a többi használata után fizetési kötelezettségünk jelenhet meg.'''
[[Fájl:GAMFAWS ec2 launch conf setup instance type.png]]

'''Az Additional configruation''' részben megadhatunk különböző paramétereket, amelyeket az EC2 fog felvenni - pl. mindenképp kapjon IP címet, a subnet beállításaitól függetlenül, vagy éppen ne kapjon; itt adhatjuk meg a telepítéskor lefuttatott scripteket (User data).

'''A Storage''' szekcióban megadhatjuk, hogy milyen lemezek és milyen méretűek legyenek a rendszerhez csatolva.

'''A Security Group''' részben kiválaszthatunk egy már meglévő szabályrendszert, vagy készíthetünk újat. 
[[Fájl:GAMFAWS ec2 launch conf setup secg.png]]

'''A Key pairs''' blokkban megadhatjuk, hogy milyen privát kulccsal léphetnek be a szerverekre. Ennek meglétét jóvá kell hagyni az alul található checkbox-szal. 
[[Fájl:GAMFAWS ec2 launch conf setup keypair.png]]

'''Végül kattintsunk a ''Create launch confgiration'' gombra a létrehozáshoz.'''

===== Launch template =====
A Launch template jóval gazdagabb a beállítási lehetőségekben, mint párja. A konfigurációs adatlap tartalmaz segédletet az AutoScaling Group-pal történő használathoz, amely ''required'', azaz kötelező mezőként jelöli meg azokat az adatbeviteli elemeket, amelyeket az automata skálázó rendszer használ. Érdemes ezt bekapcsolni, amennyiben ilyen célzattal készítjük el a sablonunkat.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Instances'' szekciót és válasszuk ki a ''Launch template'' menüpontot. Az oldal közepén vagy a jobb felső sarokban található Create launch configuration gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''A sablon neve és leírása''' blokkban megadhatjuk a nevet és a leírást, de ugyanakkor itt választhatjuk ki azt a checkboxot is, ami később a segítségünkre lesz a konfigurációs sablon AutoScaling Group-hoz való illesztését is (''Auto Scaling guidence''). 
[[Fájl:GAMFAWS ec2 launch templ setup name.png]]

'''Az Application and OS images''' szekcióban megadhatjuk, hogy milyen AMI-val települjön az EC2. Itt választhatunk a sajátunkból, vagy az EC2-nél is megtalálható egyebekből. 
[[Fájl:GAMFAWS ec2 launch templ setup ami.png]]

'''Az Instance type''' csoportban megadhatjuk, hogy milyen teljesítményű gépet szeretnénk indítani.
'''Ne feledjük el, hogy az ingyenes változatban a t2.micro érhető el, másik lehetőség választása esetén fizetési kötelezettségek léphetnek fel!''' 
[[Fájl:GAMFAWS ec2 launch templ setup instancetype.png]]

'''A Key Pair''' blokkban megadhatjuk, hogy a gépek milyen kulcspárral engedélyezzék a belépést. 
[[Fájl:GAMFAWS ec2 launch templ setup key pair.png]]

'''A Network Confguration''' részben definiálhatjuk, hogy milyen VPC-be szeretnénk lerakni az EC2-ket, milyen security group legyen rajtuk. Természetesen utóbbi helyben is létrehozható, ha korábban ezt nem készítettük volna el. 
[[Fájl:GAMFAWS ec2 launch templ setup network.png]]

'''A Storage'''-nél megadhatjuk, hogy milyen kötetek, milyen méretben legyenek hozzácsatolva a rendszerhez.

'''A Tags''' blokkban felvehetjük a kívánt ''kulcs=érték'' párokat.

'''Az Additional Configuration''' szekcióban különböző haladó beállításokat eszközölhetünk a sablon által létrehozott EC2-n, többet között itt adhatjuk meg az indításkor lefuttatandó parancsok listáját (''User data'').

'''Végül kattintsunk a Create launch template nyomógombra a mentéshez!'''.

==== Target Group ====
A target group EC2-k azon csoportja, amelyeken valamilyen ''health check'' algoritmust futtatunk, ezzel meghatározva, hogy az adott csoportban hány használható, működő szerver fut. Ezt az információt elsőként a Load balancer használja ki.

A Target Group a bal oldali menüben, a ''Load Balancing'' szekcióban érhető el ''Target Groups'' néven.

Létrehozhatunk új csoportot, de meg kell adnunk, hogy milyen módon kerüljenek bele az EC2-k. Erre a következő metódusokat ajánlja fel az Amazon:
# Konkrét EC2 (Instance) kiválasztása
# EC2-k definiálása IP tartománnyal
# Lambda függvény hozzáadása
# Alkalmazás LoadBalancer, amely egy teljes VPC tartalmát magába foglalja.

Az űrlap alján megadhatjuk, hogy milyen életjel ellenőrzés történjen.

Általában nem mi vesszük fel egyesével az Instancokat ebbe a csoportba, hanem az AutoScaling group regisztrálja őket bele. '''Ezért ezt az űrlapot nem használjuk'''.

==== Load Balancer ====
A Load Balancer terheléselosztást jelent, tehát a bejövő forgalmat több gép között osztjuk el. Ezzel növekszik a felhasználói élmény, ráadásul a rendszer megállítása (egy hacker által) nehezebbé válik: ha kettő t2.micro teljesítményű szerver fut, amelyek között elosztjuk a bejövő forgalmat, akkor a rendszerünk valójában 2xt2.micro teljesítményű.

Terheléselosztót a bal oldali menü ''Load Balancing'' szekciójának ''Load Balancers'' menüpontjában hozhatunk létre.

'''A támogatott szolgáltatási szintek:'''
# Alkalmazás terheléselosztás (HTTP, HTTPS)
# Hálózati terheléselosztás (TCP, UDP)
# Átjáró terheléselosztása (GW)

===== Alkalmazás terheléselosztása =====
Ebben a formában konfigurálhatjuk az eszközt úgy, hogy az internet felől elérhető legyen (internet-facing) és úgy, hogy csak belső hálózaton működjön (internal). A belső hálózatot mindig az aktuális VPC-re kell érteni, tehát annak minden alhálózatából elérhető alapértelmezetten.
[[Fájl:GAMFAWS ec2 loadbalancer setup basic.png]]

A hálózati beállításoknál választhatunk, hogy mely alhálózatokban szeretnénk végrehajtani a terheléselosztást, így csak az azokban futó EC2-k kaphatnak ezen keresztül csomagokat. Arra kell ügyelnünk, hogy legalább kettő különböző zónában lévő alhálózatot kell kiválasztanunk (pl. eu-west-1a, eu-west-1b stb.).
[[Fájl:GAMFAWS ec2 loadbalancer setup network.png]]

Természetesen a LoadBalancer internetfelőli végpontján létrehozhatunk ''Security Group''okat, amelyet szabályozzák, hogy milyen IP címről fogadunk el csomagokat.
[[Fájl:GAMFAWS ec2 loadbalancer setup secg.png]]

A ''Listeners and routing'' résznél megadhatjuk, hogy melyik target group fogja a terhelést fogadni, tehát hogy mely EC2-k között tudunk ténylegesen terhelést elosztani. Amennyiben a target group egy darab EC2-t tartalmaz, akkor a terheléselosztás gyakorlatilag nem valósul meg, csak az elméleti esélyét adtuk meg, hogy ''„amennyiben lenne még egy EC2 a target group-ban, akkor a terhelés egy részét az vinné el”''.
[[Fájl:GAMFAWS ec2 loadbalancer setup routing.png]]

Végül kattintsunk a ''Create load balancer'' gombra, amennyiben a kívánt tag-eket is rögzítettük.

==== Auto Scaling Group ====
A szolgáltatás segítségével automatikusan skálázott rendszereket építhetünk ki, ahol a szerverek által nyújtott elérhető erőforrásokat minél közelebb tartja a bejövő terhelés által meghatározott erőforrásigényhez. Természetesen mindez akkor igaz, ha az ''Auto Scaling Group'' be regisztrálja az általa létrehozott ''EC2''-ket egy ''Target Group''-ba, ami felett ''Load Balancing'' van definiálva.

'''Előnyei''':
* Amikor nincs bejövő terhelés, akkor nincsenek nagy költségek
* Amikor nagy a bejövő terhelés, akkor a költségek megugranak ugyan, de az ügyfeleket ki tudtuk szolgálni úgy, hogy elégedettek voltak a rendszer teljesítményével.

'''Hátrányai''':
* Kaotikus számlák, nem előre tervezhető költségek
* Megnövekedett költségek DDoS és egyéb támadások esetén

===== A beállítás lépései =====
A szolgáltatást a bal oldali menü ''Auto Scaling Group'' szekciójában érjük el, az ''Auto Scaling Group'' menüpontban. A képernyő közepén vagy a képernyő jobb felső sarkában megjelenő ''Create auto scaling group'' gombra kattintva egy űrlap jelenik meg, ami végig vezet minket a telepítés lépésein.

'''A Name''' szekcióban elnevezzük az új group-ot.
[[Fájl:GAMFAWS ec2 autoscaling setup name.png]]

'''A következő szekcióban''' két választási lehetőségünk van:
* Launch Template-tel telepítjük az új group-ot, ez esetben csak ki kell választanunk a korábban létrehozott sablont, vagy az alatta található link segítségével készíthetünk újat. ''Amennyiben újat készítünk, a sablon létrehozása új ablakban nyílik meg, így a befejezést követően vissza kéne térnünk erre és a frissítést gombot megnyomva látni fogjuk az új lehetősége(ke)t.
[[Fájl:GAMFAWS ec2 autoscaling setup lt.png]]

* Launch Configuration-nel telepítjük az új group-ot, ez esetben át kell váltatnunk a ''Switch to launch configuration'' link segítségével a blokkot. A váltást követően hasonlóan az előzőekhez: vagy kiválasztjuk a már meglévő konfigurációs sémát, vagy hozhatunk létre újat.
[[Fájl:GAMFAWS ec2 autoscaling setup lc.png]]

'''A Next gombra kattintva a hálózati beállítások''' szekcióhoz érünk, ahol megadhatjuk, hogy az indított EC2 milyen VPC-be kerüljön és azon belül milyen alhálózatokba. VPC-ből egy, alhálózatból több is kiválasztható. Ügyeljünk rá, hogy ha később erre Load Balancer szolgáltatás is kerül, akkor legalább kettő zónát jelöljünk ki!
'''Figyelem!''' A zóna nem egyezik meg az alhálózattal!
[[Fájl:GAMFAWS ec2 autoscaling setup network.png]]

'''A Next gombra kattintva a Load Balancing beállítások''' következnek, ahol választhatunk:
* Nincs terheléselosztás opciót,
* Létező Load Balancer hozzáillesztését,
* Új Load Balancer létrehozását.

Utóbbi esetében a Load Balancer konfigurálásánál leírt módon ki kell töltenünk a Load Balancer űrlapját is helyben. 
[[Fájl:GAMFAWS ec2 autoscaling setup lb setup.png]]

Hasonlóan a ''Target Group''-ot is létrehozhatjuk helyben, amennyiben ezt nem tettük meg korábban.
[[Fájl:GAMFAWS ece autoscaling setup new lb new tg.png]]

'''A Next gombra kattintva a csoport méretét definiálhatjuk''', azaz megszabhatjuk, hogy hány darab szervertől, hány darab szerverig engedélyezzük az automatikus skálázást. Ez egy hasznos funkció, hiszen ezzel korlátok közé szoríthatjuk a költségeinket, miközben a legkisebb terhelés esetén is előkészülhetünk egy hirtelen bejövő nagyobb terhelésre (ha a minimum nem 1).
* Desired capacity: ennyi szervert fog elindítani az ASG mentés után
* Minimum capacity: ennyi szerver esetén már nem állít le semmit az ASG
* Maximum capacity: ennyi szerver esetén már nem indít el újabbat az ASG
[[Fájl:GAMFAWS ec2 autoscaling setup group.png]]

'''Alatta a Scaling Policy''' blokkban megadhatjuk, hogy milyen paraméterek mentén indítson vagy épp állítson le szervereket az ASG. Ehhez aktiválnunk kell a szolgáltatást és a ''Metric type'' listából ki kell választani az számunkra megfelelőt. Mi általában CPU terhelés alapján döntünk az órán.
[[Fájl:GAMFAWS ec2 autoscaling setup scaling.png]]

'''A Next gombokkal lépkedve hozhatunk létre Tag-eket, majd végül létrehozhatjuk az ASG-t is és az ''Instances'' menüpontban ellenőrizhetjük, hogy ténylegesen elindult a kívánt darabszámú szerver.'''

=== RDS szolgáltatások ===
A ''Relational Database Service'' foglalja magában a különböző adatbázisokat:
* MariaDB
* MySQL
* Aurora
* Oracle
* PostgreSQL
* MSSQL

'''Figyelem!''' Az itt felsorolt szerverek között lehetnek fizetősek is. Mindig járjunk el figyelmesen, kövessük a költségeket. Az RDS az amazon egyik legdrágább szolgáltatása.

==== MySQL adatbázis telepítése ====
==== Csatlakozás MySQL adatbázishoz CLI-ből ====
<syntaxhighlight lang="bash">
apt install mysql-client -y
# mysql -h<rds_endpoint> -u<rds_user> -p<rds_password>
mysql -hwebshop-989.rds.amazon.com -uadmin -p123456789
</syntaxhighlight>

A megnyíló '''mysql>''' PROMPT-ot tartalmazó sor azt jelenti, hogy sikeresen csatlakoztunk az SQL szerverhez. Amennyiben a csatlakozás sikertelen, akkor valószínűleg az RDS-hez kapcsolt Security Group beállításai nem engedik az EC2-ről a kapcsolódást - tipikusan a mi saját publikus IP címünk kerül bele az engedélyezett tartományba (pl. iskolai IP vagy otthoni) és ez nem került átírásra az amazonos tartománynak megfelelően.

A konzolra be kell illeszteni a ''networks.sql'' fájl tartalmát. A végén '''exit''' paranccsal léphetünk vissza a BASH környezetbe.

=== VPC ===
A '''V'''irtual '''P'''rivate '''C'''loud egy szolgáltatás, melynek segítségével össze köthetjük az összetartozó komponenseket, alkalmazásokat. A VPC-t modellezhetjük hétköznapibb értelemben, mint egy routert, amelynek vannak alhálózatai, route táblája és valamilyen gateway címe, amin keresztül a kliensei az internet más résztvevőivel tudnak kommunikálni.

A VPC szolgáltatásait a keresőbe írt ''VPC'' kulccsal érhetjük el.
==== VPC létrehozása ====
Navigáljunk a 'Your VPCs' menüpontra a bal oldali menüben és kattintsunk a jobb felső sarokban látható ''Create VPC' gombra. Ezután megnyílik egy űrlap, amely végig vezet minket a telepítés lépésein.

Az űrlap elején választhatunk, hogy ''VPC only'' vagy ''VPC and more'' módban szeretnénk folytatni. Előbbi csak a VPC-t hozza létre nevéből is adódóan, míg a másik opcióval létrehozhatjuk az alhálózatokat is, igaz, a tervezés szabadságáról le kell ilyenkor mondanunk, cserébe grafikán láthatjuk az eredményt. Számunkra az órán utóbbi nem lesz megfelelő, hiszen szükségünk lesz a ''tervezés szabadságára''. 
[[Fájl:GAMFAWS vpc setup.png]]

A VPC beállításainál mindig a teljes hálózatot átfogó IP/MASZK párost kell megadnunk, később az alhálózatok nem lóghatnak ki az itt megadott tartományból.

==== Alhálózatok ====
Az alhálózatok lehetőséget biztosítanak arra, hogy az egyes komponenseket el is szigeteljük egymástól, meg engedélyezzünk is közöttük bizonyos kommunikációt.

Alhálózatok típusai:
* Publikus: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten kapnak publikus IP címet
* Privát: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten nem kapnak publikus IP címet

===== Alhálózatok létrehozása =====
Navigáljunk a ''Subnets'' menüpontra. A képernyő jobb felső sarkában kattintsunk a ''Create subnet'' gombra, így megkapjuk a létrehozási űrlapot.

'''Először''' a VPC-t kell kiválasztanunk, aminek eredményeképp kiírja segítségképp annak tartományát. Ezen a tartományon kívül nem léphetünk. 
[[Fájl:GAMFAWS vpc subnet setup.png]]

A VPC kiválasztása után aktívvá válik az alhálózatok űrlap, ahol megadhatjuk annak nevét, hálózati címét és maszkját. 
[[Fájl:GAMFAWS vpc subnet setup new.png]]

'''Figyelem!''' A rendszer csak hálózati címet fogad el! Minden más esetben hibát ír ki.

A ''Remove'' gombbal eltávolíthatjuk az aktuális konfigurációt a listából, míg a lentebb található ''Add new subnet'' segítségével újabbat vehetünk fel.

Befejezésül nyomjuk meg a ''Create subnet'' gombot, így az összes definiált alhálózat létrejön a kiválasztott VPC-hez.

===== Publikus/Privát alhálózat beállítása =====
Az alhálózat típusának átállításához navigáljunk a ''Subnets'' menüpontra. Kattintsunk jobb gombbal a kívánt alhálózat során és válasszuk ki az ''Edit subnet settings'' opciót. 
[[Fájl:GAMFAWS vpc subnet edit s settings.png]]

Az űrlapon keressük meg az ''Auto-assign IP settings'' blokkot és a kívánt típusnak megfelelően módosítsuk azt.
[[Fájl:GAMFAWS vpc subnet edit type.png]]

===== Különböző route tábla minden alhálózaton =====
A VPC támogatja, hogy minden subnet saját route táblával rendelkezzen. Ez lehet akár egy biztonsági funkció is, hogy ne ismerje minden EC2 az útvonalat egy adott szerverhez, de egyes esetekben kötelezően létre kell hoznunk. A route táblákat a ''Route tables'' menüpontban hozhatjuk létre és a ''Subnets'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Edit route table association'' opciót kiválasztva szerkeszthetjük.

'''Figyelem!''' A route táblák cseréje okozhat internetelérési problémákat szerver oldalon, aminek következtében a futó szolgáltatások számunkra is elérhetetlenekké válnak (pl. SSH és/vagy HTTP/HTTPS stb.), így legyünk körültekintőek.

==== Internet Gateway ====
Ahhoz, hogy a VPC-n belül legyen internet, ahhoz egy IGW-t kell hozzá csatolnunk. Ezt megelőzően azonban létre kell hoznunk egyet.
'''Figyelem!''' A VPC-hez nem kapcsolt IGW-k pénzbe kerülhetnek, mivel feleslegesen foglalnak le egy publikus IPv4 címet.

[[Fájl:GAMFAWS vpc igw setup.png|bélyegkép|Internet Gateway létrehozás]]
Az IGW az ''Internet Gateways'' menüpont alatt érhető el és a jobb felső sarokban található ''Create internet gateway'' gombbal hozhatunk létre újat. Csupán egy nevet kell megadnunk, illetve rakhatunk rá tag-eket igény szerint.

A létrehozást követően hozzá kell rendelnünk egy létező VPC-hez, amit az ''Internet Gateways'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Attach to VPC'' opciót kiválasztva tudunk megtenni. Amennyiben a soron az ''Attached'' (zöld színű) felirat jelenik meg a (szürke színű) ''Detached'' helyett, akkor nem tudjuk VPC-hez csatolni (ilyenkor először a ''Detach from VPC'' opciót kell választanunk). 
[[Fájl:GAMFAWS vpc igw attach.png]]

Az IGW VPC-hez rendelése után a kívánt route táblákba fel kell vennünk, hogy minden csomagot arra irányítson.
[[Fájl:GAMFAWS vpc igw route setup.png]]

==== NAT Gateway ====
Lehetőség van Internet Gateway helyett NAT Gateway létrehozására is, de ez egy fizetős szolgáltatás. A nevének megfelelően ez lehetőséget biztosít, hogy azok az EC2-k, amelyek privát alhálózatba kerültek, kilássanak az internet felé (pl. frissítések keresése, telepítése), miközben védve vannak a kívülről érkező támadásoktól.
'''Ez egy lehetséges oka lehet, hogy külön válasszuk a route táblákat az alhálózatokon, hiszen az egyiknek minden csomagot az IGW felé, míg a másiknak minden csomagot a NAT Gateway felé kell továbbítania.''' ''Ha nem használunk NAT Gatewayt, akkor is érdemes lehet leválasztani az IGW-ről a privát alhálózatokat.''

=== AWSCLI ===
Az AWSCLI egy konzolos alkalmazás, amelynek segítségével menedzselhetjük környezetünket: hozhatunk létre új EC2-t akár, vagy kapcsolhatunk hozzá egyéb szolgáltatásokat (Security Group, ASG, LB stb.).

Az awscli program elérhető linux és windows környezetben egyaránt.

==== AWSCLI telepítése ====
A program telepítéséhez a következő parancsot kell futtatnunk: '''apt install awscli'''.
==== Access Key management ====
Az ''awscli'' hozzáférési kulcsokon keresztül kap jogosultságot a szolgáltatások adataihoz, így használata előtt készítenünk kell egy újat. Ez a nevünkre kattintva (jobb felül), majd a ''Security credentials'' menüpontot kiválasztva tehetjük meg, az ''Access keys'' szekcióban. Nyissuk ezt le és kattintsunk a ''Create New Access Key'' gombra. 
<center>
{|
| [[Fájl:GAMFAWS UserMenu.png|150px|keretnélküli]] || [[Fájl:GAMFAWS SecurityCredentials.png|keretnélküli]]
|}
</center>

A gomb megnyomása után egy felugró ablak fogad, amelyben megtalálható az ''Access Key'' és a ''Security Access Key'' értéke. Érdemes a fájlt letölteni, hogy később is elérhetők legyenek ezek az adatok, '''az AWS többet nem fogja engedélyezni ezek megjelenítését!''' Ha az adatokat később nem tudjuk megadni, akkor újat kell készíteni.
[[Fájl:GAMFAWS SecurityCredentials ShowData.png|középre]]

==== AWS CLI konfigurálás autentikációs adatokkal ====
Az eszköz telepítése annak konfigurálásával ér véget: meg kell adnunk az autentikációs tokeneket. 
Ezt az '''aws configure''' parancs kiadásával tehetjük meg, ahol egyesével bekéri a szükséges adatokat. Ahol nem szeretnénk változtatni az előző értéken (szögletes zárójelek között láthatjuk ezt), ott hagyjuk üresen a sort és csupán entert nyomjunk.
[[Fájl:GAMFAWS AWSCLI config.png|középre]]

Az adatok megadása után menedzselhetjük az aws parancsokkal a környezetünket. Az aws parancsairól az '''aws help''' szolgáltat információt.

=== S3 ===
Ez a szolgáltatás fájlok tárolására alkalmas.

Több típusa is elérhető:
* Standard:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban sűrűn használt objektumok tárolására alkalmas
** A régiók közötti szinkronizáció megoldott
* Instant Glacier:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban ritkábban használt, hosszú élettartamú, de azonnali hozzáférést igénylő objektumok tárolására alkalmas
* Flexible Glacier:
** Magas rendelkezésre állás jellemzi
** Az alkalmazásban ritkán használt (évente 1x-2x), a mérettől független költséggel rendelkező megoldás
* Deep Archive Glacier:
** 7-10 évig tárolt adatokhoz optimalizált költségvonzat
** Előnyös a backup adatok tárolásához

A szolgáltatás a keresőben ''S3'' füzérrel kereshető.

==== Bucket létrehozása ====
Új tárolót a ''Create bucket'' gomb segítségével hozhatunk létre. A megjelenő űrlapon a nevet kell kitölteni és érdemes egy pillantást vetni a publikusság beállításaira is, hogy ez ténylegesen a célunknak megfelelő legyen.

'''Figyelem!''' A névnek nem csupán a mi környezetünkön belül kell egyedinek lennie, hanem a teljes AWS-en belül.

{| style="margin:auto"
| [[Fájl:GAMFAWS S3 new name.png|bélyegkép]] || [[Fájl:GAMFAWS S3 new public.png|bélyegkép]]
|}

==== Bucket kezelése ''awscli'' programmal ====
Az '''aws s3 help''' parancs segítségével további információt szerezhetünk az egyes utasításokról.

'''Bucket tartalmának listázása''' 
<syntaxhighlight lang="bash">
aws s3 ls [bucket_name]
</syntaxhighlight>
[[Fájl:GAMFAWS S3 CLI LS.png|középre]]

'''Adatok másolása Bucket-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* LOCAL_PATH a lokális fájlrendszeren belüli elérési útvonala a forrásfájlnak (vagy könyvtárnak)
* REMOTE_PATH a cél helye az S3-ban
** Az s3:// jelzi, hogy a cél az S3-ban van (S3Uri)
** A mappák helyett PREFIX-ek vannak (/folder/to/my/file esetében /folder/to/my a PREFIX)
** A mappákat nem kell S3-ban létrehoznunk (az előző pontból következik), a fájlnév előtti prefix dönti el a hova tartozását
** A PREFIX-eket az '''ls''' úgy kezeli, mint egy mappát
[[Fájl:GAMFAWS S3 AWSCLI cp2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* --recursive jelzi, hogy a LOCAL_PATH alatt minden bejegyzést töltsön fel
[[Fájl:GAMFAWS S3 AWSCLI copy recursive2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ból helyi fájlrendszerbe''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive s3://REMOTE_PATH LOCAL_PATH
</syntaxhighlight>
[[Fájl:GAMFAWS S3 AWSCLI cp2local.png|középre]]

==== Bucket kezelése grafikus felületen keresztül ====
Az S3 tartalmát elérhetjük az AWS grafikus felületén keresztül is, így tölthetünk fel, törölhetünk és módosíthatunk fájlokat anélkül, hogy saját számítógépünkre telepítenénk az ''awscli'' programot.

# Nyissuk meg az S3 szolgáltatás vezérlőpultját
# Kattintsunk a szerkeszteni kívánt tárhely nevére [[Fájl:GAMFAWS S3f list.png]] 
# A vezérlőgombok segítségével végezzük el a kívánt műveletet (feltöltés, törlés), vagy válasszunk ki egy PREFIX-et az „almappák” tartalmának megtekintéséhez. [[Fájl:GAMFAWS S3 control.png|középre]]

= Alkalmazások telepítése =
== UI ==
== API ==

= Indítást gyorsító scriptek =
== UI indítás ==
<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun code
API_LB_DOMAIN="localhost" # api server IP

apt update
apt install wget unzip apache2 libapache2-mod-php8.3 php8.3 php8.3-curl -y

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui.php
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui_newproduct.php
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv ui.php /srv/$NEPTUN/index.php
mv ui_newproduct.php /srv/$NEPTUN/newproduct.php

# remove tmp directory
cd /
rm /tmp/code

cat << EOF > /etc/apache2/sites-enabled/000-default.conf
<VirtualHost *:80>
#ServerName www.example.com

ServerAdmin webmaster@localhost
DocumentRoot /srv/$NEPTUN

<Directory /srv/$NEPTUN/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>

ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

systemctl restart apache2
</syntaxhighlight>

== API indítás ==

<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun
MYSQL_DOMAIN="localhost" # RDS mysql domain

apt update
apt install wget unzip python3 python3-pip -y
pip3 install flask mysql-connector-python --break-system-packages

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$MYSQL_DOMAIN/g" api.py
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv api.py /srv/$NEPTUN/

# remove tmp directory
cd /
rm /tmp/code

echo "@reboot root sleep 10s && python3 /srv/$NEPTUN/api.py &" >> /etc/crontab
cd /srv/$NEPTUN && python3 api.py &
‎</syntaxhighlight>

EDU::GAMF::Felhőalapú-szolgáltatások

2025-09-15T08:15:01Z

ApelPro: /* A gyakorlat menete */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a ZH-ból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy teljesítéséhez szükséges idő ==
Az állami elvárás szerint minden kredit megszerzése egy átlagos hallgató számára 30 óra ráfordítást vesz igénybe - beleértve a tanórákat, ZH és vizsgaalkalmakat, valamint az otthoni önálló tanulást is. Ez a tárgy 5 kreditet ér, tehát a félév során összesen 150 órát kell a hallgatóknak ezzel foglalkozniuk, ami sokszor a pótZH-ban (és manapság a pót-pót ZH-ban) csapódik le.
Mivel a félév során 13 hét áll rendelkezésünkre és mind az előadás, mind a gyakorlat 1,5 óra időtartamú, így összesen 39 órát ölel fel a tanórai képzés (ZH-val együtt). Rossz hír, hogy ez esetben egy gyakorlati jegyes tárgyról van szó, így a maradék időt legkésőbb a 13. hét végéig kell eltölteni otthoni tanulással, nem lehet a vizsgaidőszakra csúsztatni azt. Ez alapján heti 8.5, azaz valamivel több, mint napi 1,5 órát (heti 5 nappal számolva) a tárggyal kapcsolatos ismeretanyagok gyűjtésével és megértésével kellene a hallgatónak foglalkoznia. Mivel ezen számítás alapján a hallgatóknak napi 13,5 órát kellene 30 kredit felvétele esetén tanulással tölteni, így természetesen ez egy irreális elvárásnak bizonyul. Azonban kreditarányosan számolva, ezen tárgy esetében '''heti 2 óra''' ráfordítással éri el a hallgató a napi 8 órás munkaidőt (tanórák közötti szüneteket pihenőidőként kezelve) 30 kredit esetén, ami a normális szint. Ez tehát '''elvárhatónak és számon kérhetőnek bizonyul''' nappali tagozaton annak érdekében, hogy a hallgatók a lehető legnagyobb felkészültségben üljenek az órákon.

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email]
# EC2 létrehozása, szolgáltatások áttekintése, Linux alapismeretek ismétlése
# EC2 létrehozása, alkalmazások telepítése és konfigurálása, apache2 kiszolgáló, PHP környezet
# UI felület élesztése: AMI létrehozás, Auto Scaling Group, Load Balancer
# Teljes alkalmazás élesztése: MySQL adatbázis (RDS), Python környezet telepítés
# Teljes alkalmazás élesztése: VPC-be szervezés, eszközök kommunikációjának szabályozása
# Docker telepítés, első konténerek elindítása, Dockerfile felépítése, docker.io regisztráció, image feltöltés
# Dockerfile felépítése, alkalmazások létrehozása, indítása
# Docker Compose felépítés, networking, debuggolás
# Teljes alkalmazás élesztése Docker Compose segítségével
# Készülés ZH-ra, kérdések megbeszélése
# '''Projekt bemutató'''

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj mamximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Felhőalapú-szolgáltatások

2025-09-15T08:14:18Z

ApelPro: /* Kiselőadás témák */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a ZH-ból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy teljesítéséhez szükséges idő ==
Az állami elvárás szerint minden kredit megszerzése egy átlagos hallgató számára 30 óra ráfordítást vesz igénybe - beleértve a tanórákat, ZH és vizsgaalkalmakat, valamint az otthoni önálló tanulást is. Ez a tárgy 5 kreditet ér, tehát a félév során összesen 150 órát kell a hallgatóknak ezzel foglalkozniuk, ami sokszor a pótZH-ban (és manapság a pót-pót ZH-ban) csapódik le.
Mivel a félév során 13 hét áll rendelkezésünkre és mind az előadás, mind a gyakorlat 1,5 óra időtartamú, így összesen 39 órát ölel fel a tanórai képzés (ZH-val együtt). Rossz hír, hogy ez esetben egy gyakorlati jegyes tárgyról van szó, így a maradék időt legkésőbb a 13. hét végéig kell eltölteni otthoni tanulással, nem lehet a vizsgaidőszakra csúsztatni azt. Ez alapján heti 8.5, azaz valamivel több, mint napi 1,5 órát (heti 5 nappal számolva) a tárggyal kapcsolatos ismeretanyagok gyűjtésével és megértésével kellene a hallgatónak foglalkoznia. Mivel ezen számítás alapján a hallgatóknak napi 13,5 órát kellene 30 kredit felvétele esetén tanulással tölteni, így természetesen ez egy irreális elvárásnak bizonyul. Azonban kreditarányosan számolva, ezen tárgy esetében '''heti 2 óra''' ráfordítással éri el a hallgató a napi 8 órás munkaidőt (tanórák közötti szüneteket pihenőidőként kezelve) 30 kredit esetén, ami a normális szint. Ez tehát '''elvárhatónak és számon kérhetőnek bizonyul''' nappali tagozaton annak érdekében, hogy a hallgatók a lehető legnagyobb felkészültségben üljenek az órákon.

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email]
# EC2 létrehozása, szolgáltatások áttekintése, Linux alapismeretek ismétlése
# EC2 létrehozása, alkalmazások telepítése és konfigurálása, apache2 kiszolgáló, PHP környezet
# UI felület élesztése: AMI létrehozás, Auto Scaling Group, Load Balancer
# Teljes alkalmazás élesztése: MySQL adatbázis (RDS), Python környezet telepítés
# Teljes alkalmazás élesztése: VPC-be szervezés, eszközök kommunikációjának szabályozása
# Docker telepítés, első konténerek elindítása, Dockerfile felépítése, docker.io regisztráció, image feltöltés
# Dockerfile felépítése, alkalmazások létrehozása, indítása
# Docker Compose felépítés, networking, debuggolás
# Teljes alkalmazás élesztése Docker Compose segítségével
# Készülés ZH-ra, kérdések megbeszélése
# ZH
# PótZH

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj mamximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Felhőalapú-szolgáltatások

2025-09-15T08:13:23Z

ApelPro: /* A tantárgy követelményei - nem hivatalos */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.

A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a ZH-ból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy teljesítéséhez szükséges idő ==
Az állami elvárás szerint minden kredit megszerzése egy átlagos hallgató számára 30 óra ráfordítást vesz igénybe - beleértve a tanórákat, ZH és vizsgaalkalmakat, valamint az otthoni önálló tanulást is. Ez a tárgy 5 kreditet ér, tehát a félév során összesen 150 órát kell a hallgatóknak ezzel foglalkozniuk, ami sokszor a pótZH-ban (és manapság a pót-pót ZH-ban) csapódik le.
Mivel a félév során 13 hét áll rendelkezésünkre és mind az előadás, mind a gyakorlat 1,5 óra időtartamú, így összesen 39 órát ölel fel a tanórai képzés (ZH-val együtt). Rossz hír, hogy ez esetben egy gyakorlati jegyes tárgyról van szó, így a maradék időt legkésőbb a 13. hét végéig kell eltölteni otthoni tanulással, nem lehet a vizsgaidőszakra csúsztatni azt. Ez alapján heti 8.5, azaz valamivel több, mint napi 1,5 órát (heti 5 nappal számolva) a tárggyal kapcsolatos ismeretanyagok gyűjtésével és megértésével kellene a hallgatónak foglalkoznia. Mivel ezen számítás alapján a hallgatóknak napi 13,5 órát kellene 30 kredit felvétele esetén tanulással tölteni, így természetesen ez egy irreális elvárásnak bizonyul. Azonban kreditarányosan számolva, ezen tárgy esetében '''heti 2 óra''' ráfordítással éri el a hallgató a napi 8 órás munkaidőt (tanórák közötti szüneteket pihenőidőként kezelve) 30 kredit esetén, ami a normális szint. Ez tehát '''elvárhatónak és számon kérhetőnek bizonyul''' nappali tagozaton annak érdekében, hogy a hallgatók a lehető legnagyobb felkészültségben üljenek az órákon.

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email]
# EC2 létrehozása, szolgáltatások áttekintése, Linux alapismeretek ismétlése
# EC2 létrehozása, alkalmazások telepítése és konfigurálása, apache2 kiszolgáló, PHP környezet
# UI felület élesztése: AMI létrehozás, Auto Scaling Group, Load Balancer
# Teljes alkalmazás élesztése: MySQL adatbázis (RDS), Python környezet telepítés
# Teljes alkalmazás élesztése: VPC-be szervezés, eszközök kommunikációjának szabályozása
# Docker telepítés, első konténerek elindítása, Dockerfile felépítése, docker.io regisztráció, image feltöltés
# Dockerfile felépítése, alkalmazások létrehozása, indítása
# Docker Compose felépítés, networking, debuggolás
# Teljes alkalmazás élesztése Docker Compose segítségével
# Készülés ZH-ra, kérdések megbeszélése
# ZH
# PótZH

== Kiselőadás témák ==

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj mamximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Felhőalapú-szolgáltatások

2025-09-15T08:11:00Z

ApelPro: /* A tantárgy követelményei - nem hivatalos */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell.
A kiselőadásra járó pont: '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.
A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a ZH-ból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy teljesítéséhez szükséges idő ==
Az állami elvárás szerint minden kredit megszerzése egy átlagos hallgató számára 30 óra ráfordítást vesz igénybe - beleértve a tanórákat, ZH és vizsgaalkalmakat, valamint az otthoni önálló tanulást is. Ez a tárgy 5 kreditet ér, tehát a félév során összesen 150 órát kell a hallgatóknak ezzel foglalkozniuk, ami sokszor a pótZH-ban (és manapság a pót-pót ZH-ban) csapódik le.
Mivel a félév során 13 hét áll rendelkezésünkre és mind az előadás, mind a gyakorlat 1,5 óra időtartamú, így összesen 39 órát ölel fel a tanórai képzés (ZH-val együtt). Rossz hír, hogy ez esetben egy gyakorlati jegyes tárgyról van szó, így a maradék időt legkésőbb a 13. hét végéig kell eltölteni otthoni tanulással, nem lehet a vizsgaidőszakra csúsztatni azt. Ez alapján heti 8.5, azaz valamivel több, mint napi 1,5 órát (heti 5 nappal számolva) a tárggyal kapcsolatos ismeretanyagok gyűjtésével és megértésével kellene a hallgatónak foglalkoznia. Mivel ezen számítás alapján a hallgatóknak napi 13,5 órát kellene 30 kredit felvétele esetén tanulással tölteni, így természetesen ez egy irreális elvárásnak bizonyul. Azonban kreditarányosan számolva, ezen tárgy esetében '''heti 2 óra''' ráfordítással éri el a hallgató a napi 8 órás munkaidőt (tanórák közötti szüneteket pihenőidőként kezelve) 30 kredit esetén, ami a normális szint. Ez tehát '''elvárhatónak és számon kérhetőnek bizonyul''' nappali tagozaton annak érdekében, hogy a hallgatók a lehető legnagyobb felkészültségben üljenek az órákon.

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email]
# EC2 létrehozása, szolgáltatások áttekintése, Linux alapismeretek ismétlése
# EC2 létrehozása, alkalmazások telepítése és konfigurálása, apache2 kiszolgáló, PHP környezet
# UI felület élesztése: AMI létrehozás, Auto Scaling Group, Load Balancer
# Teljes alkalmazás élesztése: MySQL adatbázis (RDS), Python környezet telepítés
# Teljes alkalmazás élesztése: VPC-be szervezés, eszközök kommunikációjának szabályozása
# Docker telepítés, első konténerek elindítása, Dockerfile felépítése, docker.io regisztráció, image feltöltés
# Dockerfile felépítése, alkalmazások létrehozása, indítása
# Docker Compose felépítés, networking, debuggolás
# Teljes alkalmazás élesztése Docker Compose segítségével
# Készülés ZH-ra, kérdések megbeszélése
# ZH
# PótZH

== Kiselőadás témák ==

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj mamximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Felhőalapú-szolgáltatások

2025-09-15T08:09:42Z

ApelPro: /* A tantárgy követelményei - nem hivatalos */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
Az Előadás második felében a hallgatók előadják korábban elkészített munkájukat egy a felhővel kapcsolatban saját maguk által kiválasztott témában. A kiselőadás nem lehet csupán bemutató jellegű, technikai információkat is tartalmaznia kell. Ennek értékelése '''30p''',

A gyakorlati részhez kapcsolódóan a hallgatók csoportos munkában készítenek el egy projektfeladatot, amelyben a következő pontok közül legalább 5-nek teljesülnie kell:
* legyen benne ASG és LB
* Legyen benne tárolás S3-ra
* Legyen legalább 2 EC2 szolgáltatás (pl. api, ui)
* Használjon RDS-t
* Használjon VPC
* Docker környezetben fusson az alkalmazás (akár az AWS ECS-ben is)
* Serverless megoldás
* Valamilyen orchestrator használata (kubernetes, swarm stb., akár beépített verziót is)

A projektfeladat végrehajtása során a generatív mesterséges intelligencia használata '''engedélyezett''' és '''javasolt'''.
A projektfeladatra járó pont: '''70p'''

'''A kiselőadásból és a ZH-ból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

== A tárgy teljesítéséhez szükséges idő ==
Az állami elvárás szerint minden kredit megszerzése egy átlagos hallgató számára 30 óra ráfordítást vesz igénybe - beleértve a tanórákat, ZH és vizsgaalkalmakat, valamint az otthoni önálló tanulást is. Ez a tárgy 5 kreditet ér, tehát a félév során összesen 150 órát kell a hallgatóknak ezzel foglalkozniuk, ami sokszor a pótZH-ban (és manapság a pót-pót ZH-ban) csapódik le.
Mivel a félév során 13 hét áll rendelkezésünkre és mind az előadás, mind a gyakorlat 1,5 óra időtartamú, így összesen 39 órát ölel fel a tanórai képzés (ZH-val együtt). Rossz hír, hogy ez esetben egy gyakorlati jegyes tárgyról van szó, így a maradék időt legkésőbb a 13. hét végéig kell eltölteni otthoni tanulással, nem lehet a vizsgaidőszakra csúsztatni azt. Ez alapján heti 8.5, azaz valamivel több, mint napi 1,5 órát (heti 5 nappal számolva) a tárggyal kapcsolatos ismeretanyagok gyűjtésével és megértésével kellene a hallgatónak foglalkoznia. Mivel ezen számítás alapján a hallgatóknak napi 13,5 órát kellene 30 kredit felvétele esetén tanulással tölteni, így természetesen ez egy irreális elvárásnak bizonyul. Azonban kreditarányosan számolva, ezen tárgy esetében '''heti 2 óra''' ráfordítással éri el a hallgató a napi 8 órás munkaidőt (tanórák közötti szüneteket pihenőidőként kezelve) 30 kredit esetén, ami a normális szint. Ez tehát '''elvárhatónak és számon kérhetőnek bizonyul''' nappali tagozaton annak érdekében, hogy a hallgatók a lehető legnagyobb felkészültségben üljenek az órákon.

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email]
# EC2 létrehozása, szolgáltatások áttekintése, Linux alapismeretek ismétlése
# EC2 létrehozása, alkalmazások telepítése és konfigurálása, apache2 kiszolgáló, PHP környezet
# UI felület élesztése: AMI létrehozás, Auto Scaling Group, Load Balancer
# Teljes alkalmazás élesztése: MySQL adatbázis (RDS), Python környezet telepítés
# Teljes alkalmazás élesztése: VPC-be szervezés, eszközök kommunikációjának szabályozása
# Docker telepítés, első konténerek elindítása, Dockerfile felépítése, docker.io regisztráció, image feltöltés
# Dockerfile felépítése, alkalmazások létrehozása, indítása
# Docker Compose felépítés, networking, debuggolás
# Teljes alkalmazás élesztése Docker Compose segítségével
# Készülés ZH-ra, kérdések megbeszélése
# ZH
# PótZH

== Kiselőadás témák ==

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj mamximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

EDU::GAMF::Operációs rendszerek::Gyakorlatok

2024-10-09T12:15:27Z

ApelPro: /* MAC cím parser */

== 1. óra ==
Az első óra a tantárgy és annak követelményeinek ismertetésével kezdődik, majd egy-két alap utasítást tekintünk meg. Ezután a programok csatornáival folytatjuk.

=== Parancsok és példák ===
==== man ====
A ''man'' parancs segítségével megtekinthetjük egy-egy alkalmazás, parancs, esetleg külső könyvtár függvényeinek dokumentációját. 

'''Használata:'''
A program neve után írhatjuk, hogy melyik alkalmazás, parancs vagy esetleg külső könyvtár függvényének dokumentációját szeretnénk megtekinteni. Megtekinthetjük ily módon a ''man'' parancs használati útmutatóját is a következő utasítás kiadásával:
<syntaxhighlight lang="bash">
man man
</syntaxhighlight>

Hasonló módon alkalmazhatjuk bármelyik parancsra, amelyek ezen a weboldalon felsorolásra kerültek. Pl. a ''head'' utasítás dokumentációját az alábbi módon érhetjük el
<syntaxhighlight lang="bash">
man head
</syntaxhighlight>

==== ls ====
Érdemes megtekinteni a parancs dokumentációját a ''man ls'' utasítás kiadásával, tisztában legyünk ez elérhető kapcsolókkal és funkciókkal.
Az '''ls''' parancs segítségével listázhatjuk a mappa tartalmát. Alapértelmezetten a '''.''', tehát a jelenlegi könyvtárat listázza.
<syntaxhighlight lang="bash">
# meghívás paraméter nélkül
ls

# meghívás . paraméterrel - ugyanaz az eredmény
ls .
</syntaxhighlight>

A listázni kívánt könyvtár nevét megadhatjuk paraméterben:
<syntaxhighlight lang="bash">
# root könyvtár listázása
ls /

# a /usr/local/bin könyvtár listázása
ls /usr/local/bin
</syntaxhighlight>

Érdemes megjegyezni a hosszú formátumú kiírást, aminek segítségével a fájlrendszer bejegyzések jogosultságait és méretét kérhetjük le.
<syntaxhighlight lang="bash">
# Jelenlegi könyvtárban listáz minden elemet és azok tulajdonságait
ls -l

# A /bin/ls fájl jogosultságainak lekérdezése
ls -l /bin/ls
</syntaxhighlight>

Próbáljuk ki, hogy ha egy mappa nevével futtatjuk le a parancsot, akkor az '''ls''' megnyitja a könyvtárat és annak tartalmát listázza ki.
<syntaxhighlight lang="bash">
# a /bin könyvtár tartalma listázódik, nem a /bin könyvtár maga
ls /bin
</syntaxhighlight>
Ez különösen akkor okoz problémát, ha például az adott könyvtár jogosultságait szeretnénk megtekinteni. Ekkor két választási lehetőségünk adódik:
<syntaxhighlight lang="bash">
# A felette lévő könyvtárat listázzuk és kikeressük a megfelelő bejegyzést
ls / -l

# használjuk a -d kapcsolót, aminek segítségével felszólítjuk az ls-t, hogy ne nyissa meg az adott könyvtárat
# Ekkor a könyvtár listázódik, nem a tartalma
ls -d /bin
</syntaxhighlight>

==== pwd ====
A '''pwd''' parancs segítségével lekérdezhetjük annak a könyvtárnak az abszolút elérési útvonalát, amelyben éppen benne vagyunk.

A parancsot főleg arra használjuk, hogy aktuálisan mellettünk elhelyezett fájlok és könyvtárak abszolút útvonalát ki tudjuk alakítani.

<syntaxhighlight lang="bash">
pwd
</syntaxhighlight>

==== cd ====
A '''cd''' parancs segítségével könyvtárat válthatunk (''changedir''). A cél könyvtár nevét paraméterben kell megadnunk.
<syntaxhighlight lang="bash">
# root könyvtár megnyitása
cd /

# HOME könyvtár megnyitása
# ~ egy alias
cd ~

# /usr/bin megnyitása
cd /usr/bin
</syntaxhighlight>

A hivatkozásoknál, így a ''cd'' esetében is lehetőségünk van relatív és abszolút hivatkozásokat használni:
* Az abszolút hivatkozás / elérési út mindig ''/'' jellel kezdődik. pl.: ''cd /home/'', ''cd /usr/bin''
* A relatív hivatkozás vagy nem rendelkezik kezdőkarakterrel: ''cd home'', ''cd bin'', vagy ''.'' illetve ''..'' karakterekkel kezdődnek.
** A ''.'' könyvtár jelenti az aktuális könyvtárat
** A ''..'' könyvtár jelenti a szülő könyvtárat

<syntaxhighlight lang="bash">
# szülő könyvtár megnyitása
cd ../

# a szülőkönyvtárban található bin könyvtár megnyitása
cd ../bin

# az aktuális könyvtárban található bin könyvtár megnyitása
cd ./bin
cd bin # vegyük észre: a ./ ez esetben elhagyható
</syntaxhighlight>

==== mkdir ====
Az '''mkdir''' parancs segítségével könyvtárakat hozhatunk létre (''make directory''). Alapértelmezetten a ''.'' könyvtáron (tehát ahol éppen tartózkodunk, azon a könyvtáron) belül hozza létre az új mappát, de lehetőségünk van mind relatív, mind abszolút hivatkozások használatára.
<syntaxhighlight lang="bash">
# folder könyvtár létrehozása az aktuális könyvtárban
mkdir folder
mkdir ./folder2
# subfolder létrehozása a folder könyvtáron belül.
mkdir folder/subfolder

# létrehozás a /tmp könyvtáron belül, akárhol is vagyunk
mkdir /tmp/folder

# folder létrehozása a szülőkönyvtárban
mkdir ../folder
</syntaxhighlight>

A fentebb leírtak alapján egyetlen könyvtárat hozhatunk létre, egy már létező könyvtáron belül, legyen az éppen az, amiben tartózkodunk, vagy valahol máshol a fájlrendszerben. Azonban előfordul, hogy egyszerre több mappát szeretnénk elkészíteni, például egy mélyebb struktúrát szeretnénk kialakítani, mint ami a rendelkezésünkre áll. Ezt természetesen megtehetjük úgy, hogy az egyes szinteket egyesével hozzuk létre, de alkalmazhatunk kapcsolót, amelynek segítségével a nem létező szülőkönyvtárakat is létrehozza, amennyiben nem léteznek.
<syntaxhighlight lang="bash">
# root könyvtáron belül létrejön egy ''test'' könyvtár és azon belül jön létre a ''folder'' könyvtár.
mkdir /test/folder/ -p

# az aktuális könyvtárban jön létre egy ''test'' könyvtár és azon belül a ''folder'' könyvtár
mkdir -p test/folder

# a jelenlegi könyvtárban létrejon a ''test'' könyvtár,
# azon belül létrejön egy ''folder1'' és egy ''folder2'' könyvtár,
# majd mind a kettőben létrejön a ''work'' könyvtár.
mkdir -p test/{folder1,folder2}/work
</syntaxhighlight>

Természetesen ahhoz, hogy egy könyvtárban további fájlokat vagy könyvtárakat hozzunk létre jogosultság szükséges.

==== rmdir ====
Az '''rmdir''' parancs segítségével üres könyvtárakat törölhetünk.

'''Figyelem'''! Ha a könyvtár nem üres (fájlok vagy egyéb könyvtárak találhatók benne, akkor hibaüzenetet kapunk és nem csinál semmit!

<syntaxhighlight lang="bash">
# relatív hivatkozással
rmdir test/folder

# abszolút hivatkozással
rmdir /test/folder
</syntaxhighlight>

==== cp ====
A '''cp''' parancs segítségével fájlokat és könyvtárakat másolhatunk a fájlrendszer egy pontjáról a másikra.

<syntaxhighlight lang="bash">
# /etc/passwd fájl lemásolása a jelenlegi könyvtárba - ls paranccsal ellenőrízhető
cp /etc/passwd ./

# /etc/passwd lemásolása a jelenlegi könyvtárba és közben átnevezés file-ra
cp /etc/passwd ./file

# /etc/passwd lemásolása a /tmp könyvtárba
cp /etc/passwd /tmp/

# /etc/passwd lemásolása a /tmp könyvtárba és közben átnevezés file-ra
cp /etc/passwd /tmp/file
</syntaxhighlight>

Könyvtárak másolása esetén a ''-r'' kapcsoló használata szükséges (''recursive'').
<syntaxhighlight lang="bash">
# /etc/network könyvtár és annak tartalmát másolja a /tmp könyvtárba
cp /etc/network /tmp/ -r
</syntaxhighlight>

==== mv ====
Az '''mv''' parancs segítségével fájlokat és könyvtárakat mozgathatunk. Ezzel a paranccsal nevezhetjük át a fájlrendszer elemeit.

A próbálkozáshoz másoljuk le a /etc/passwd állományt, ha eddig nem tettük meg!
<syntaxhighlight lang="bash">
cp /etc/passwd ./
</syntaxhighlight>

<syntaxhighlight lang="bash">
# passwd állomány átnevezése file-ra
mv passwd file

# nem fut le!
# /etc/passwd állomány átnevezése file-ra
mv /etc/passwd /etc/file

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be
mv /etc/passwd /tmp

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be és közben átnevezés file-ra
mv /etc/passwd /tmp/file
</syntaxhighlight>

A könyvtárak áthelyezéséhez (vagy átnevezéséhez) ez esetben nincs szükségünk a ''recursive'' (''-r'') jelölésre.

==== rm ====
Az '''rm''' parancs segítségével fájlokat és könyvtárakat törölhetünk.

<syntaxhighlight lang="bash">
rm file
</syntaxhighlight>

Könyvtárak törléséhez alkalmaznunk kell a rekurzív jelölést: ''-r''.
<syntaxhighlight lang="bash">
rm folder -r
</syntaxhighlight>

==== less ====
A '''less''' egy fájlnézegető, amelynek segítségével lapozhatunk billentyűzet segítségével a fájlokban.

<syntaxhighlight lang="bash">
less /etc/passwd
</syntaxhighlight>

==== more ====
A '''more''' szintén egy fájlnézegető, de ennek segítségével csak előre lapozhatunk, visszafelé nem.

<syntaxhighlight lang="bash">
more /etc/passwd
</syntaxhighlight>

==== which ====
A '''which'' program segítségével lekérdezhetjük, hogy az adott utasításhoz tartozó állomány melyik mappában található.

<syntaxhighlight lang="bash">
# az ls parancs abszolút elérési útvonala
which ls

# a which parancs abszolút elérési útvonala
which which

# a man parancs elérési útvonala
which man
</syntaxhighlight>

==== file ====
A '''file''' utasítás segítségével lekérdezhetjük, hogy egy adott állomány milyen típusú: futtatható állomány (ELF), ASCII stb.

<syntaxhighlight lang="bash">
file /etc/passwd
file /bin/ls
</syntaxhighlight>

==== echo ====
Az '''echo''' mindent kiír a képernyőre, amit parancssori argumentumként adunk át neki.

<syntaxhighlight lang="bash">
echo "Hello World"
echo Hello World
echo Ez egy teszt üzenet
echo "Ez egy teszt üzenet"
</syntaxhighlight>

Láthatjuk, hogy idézőjeltől függetlenül minden megjelenik a képernyőn. Észrevehetjük azt is, hogy minden sor végén új sor karakter (enter) található, amit a "-n" kapcsoló segítségével kapcsolhatunk ki.

<syntaxhighlight lang="bash">
echo -n "Hello world"
</syntaxhighlight>

==== cat ====
A '''cat''' utasítás fájlokat képes összefűzni és az eredményt a képernyőre írja ki.

<syntaxhighlight lang="bash">
# /etc/passwd és a /etc/profile fájlok összefűzése a képernyőn (ebben a sorrendben)
cat /etc/passwd /etc/profile
</syntaxhighlight>

Egy gyakoribb felhasználási módja, hogy a fájlok tartalmát a képernyőre vessük - ez esetben nem fűzünk hozzá semmit a fájlhoz.
<syntaxhighlight lang="bash">
# /etc/passwd és a <semmi> összefűzése és megjelenítése a képernyőn
cat /etc/passwd
</syntaxhighlight>

==== head ====
A '''head''' utasítás segítségével a fájlok első N során írhatjuk ki a képernyőre. Alapértelmezetten N=10, így ha csak egy fájlnevet adunk neki, akkor annak legfeljebb 10 sorát fogja kiírni (ha van annyi).

<syntaxhighlight lang="bash">
head /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
head -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
head -5 /etc/passwd
</syntaxhighlight>

==== tail ====
A '''tail''' hasonlóan működik, mint a '''head''', de ez esetben nem a fájl elejéről ír ki N sort, hanem a végéről.
<syntaxhighlight lang="bash">
tail /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
tail -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
tail -5 /etc/passwd
</syntaxhighlight>

==== wc ====
A '''wc''' utasítás segítségével statisztikai adatokat nyerhetünk ki egy fájlból (''word counter''): sorok, szavak, karakterek és bájtok száma.

<syntaxhighlight lang="bash">
wc /etc/passwd
</syntaxhighlight>

Van lehetőségünk szűkíteni a visszaadott adatokat kapcsolók segítségével:
{| class="wikitable" style="margin: 0px auto"
|+
|-
! Rövid kapcsoló !! Hosszú kapcsoló !! Leírás
|-
| -l || --lines || sorok számát adja vissza
|-
| -w || --words || szavak számát adja vissza
|-
| -c || --chars || karakterek számát adja vissza
|-
| || --bytes || bájtok számát adja vissza
|}

<syntaxhighlight lang="bash">
# sorok számát írja ki
wc -l /etc/passwd
# szavak számát írja ki
wc -w /etc/passwd
# bájtok számát írja ki
wc --bytes /etc/passwd

# sorok és szavak számát írja ki a képernyőre
wc -l -w /etc/passwd
</syntaxhighlight>

==== find ====
A '''find''' utasítás segítségével kereshetünk a fájlrendszerben különböző attribútumok alapján.

<syntaxhighlight lang="bash">
# passwd nevű fájl keresése a /etc könyvtárban
find /etc -name passwd
</syntaxhighlight>

=== Programok csatornái ===
==== STDIN ====
==== STDOUT ====
==== STDERR ====

=== Pipeline ===

=== Parancsbehelyettesítés ===
=== Feladatok ===
==== Szedjük ki a ''/etc/passwd'' állomány 20. sorát ====
<syntaxhighlight lang="bash">
# beolvassuk az első 20 sort és levágjuk az utolsót
head -20 /etc/passwd | tail -1
</syntaxhighlight>

==== Mondjuk meg egy keresett bináris típusát ====
<syntaxhighlight lang="bash">
# fájl elérési út lekérdezése
# STDOUT => /bin/ls
which ls

# fájl típusának lekérdezése
file /bin/ls

# rakjuk össze:
file `which ls`
</syntaxhighlight>

== 2. óra ==
A második órát az alap utasításokkal folytatjuk. Utána scriptek írásával foglalkozunk, amelyben megtekintjük a különböző vezérlési szerkezeteket is.

=== Parancsok és példák ===

==== mcedit ====
Az '''mcedit''' az '''mc''' (''Midnight Commander'') szerkesztője. A Midnight Commander testvére a Total Commander ősének, a Volkov Commandernek, ami szintén egy konzolos alkalmazás. A közös gyökerek miatt nagyon hasonló funkcionalitásokat érhetünk el ebben is, mint a TC-ben - érdemes megnyitni az '''mc''' utasítással, amit később az '''F10''' billentyűvel, vagy az alsó sorban arra a gombra kattintással tudunk bezárni. Ebben az alkalmazásban működik az egér is, így kényelmes használatot eredményez. Érdekesség, hogy a "tálcára helyezés" is megoldott, így a '''Ctrl+O''' billentyűkombinációkkal háttérbe küldhetjük és folytathatjuk dolgunkat a terminálon, majd ugyanezzel a kombinációval előtérbe is hívhatjuk.

Az mcedit megnyitható az ''mc''-ből is, a szokásos F4-es billentyűvel - vagy az arra való kattintással.

Az egér az mcedit-ben is működik!

A másolás a szerkesztőben is hasonlóan működik, mint a kétpaneles fájltallózóban: F5 és F6 billentyűkkel másolhatunk illetve áthelyezhetünk sorokat. Kilépni az F10 billentyűvel, ESC-el tudunk, de ezt az ablakot is a háttérbe küldhetjük, ha szerkesztés közben terminált szeretnénk elérni (''CTRL+O'').

<syntaxhighlight lang="bash">
mcedit /etc/passwd
</syntaxhighlight>

==== nano ====
A '''nano''' szintén egy szövegszerkesztő alkalmazás.

Alul láthatjuk a segédletet, hogy milyen kombinációkkal milyen funkcionalitás érhető el. A szükségesebbek:
* CTRL+K segítségével kivághatunk sorokat a vágólapra (shift+kurzorbillentyűk segítségével tört sorok is kijelölhetők)
* CTRL+U Beilleszti a vágólap tartalmát az aktuális sorba
* CTRL+O Menti a változásokat
* CTRL+X Kilép, de megkérdezi, hogy menteni akarunk-e, ha vannak mentetlen változások

<syntaxhighlight lang="bash">
nano /etc/passwd
</syntaxhighlight>

==== chmod ====
==== shift ====
==== cut ====
A '''cut''' parancs segítségével táblázatos adatokat szűrhetünk: kiválaszthatjuk, hogy mely oszlopokat szeretnénk megjeleníteni. A két legfontosabb kapcsolója a ''-f'' (''field''), ahol a megjelenítendő oszlopokat adhatjuk meg és a ''-d'' (''delimiter''), ahol az elválasztó karaktert állíthatjuk be.

Általában a ''/etc/passwd'' állományon dolgozunk, mert ebben egy '':''-al elválasztott táblázat található.

<syntaxhighlight lang="bash">
# a fájl első oszlopát szedi ki :-nál elválasztva,
# tehát a felhasználónevet
cut -f1 -d':' /etc/passwd

# a fájl első és harmadik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet és az id-ját
cut -f1,3 -d':' /etc/passwd

# a fájl első három és hatodik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet, jelszót és a felhasználó id-ját, valamint a home könyvtárát
cut -f1-3,6 -d':' /etc/passwd
</syntaxhighlight>

==== sort ====
A '''sort''' utasítás segítségével rendezhetjük az adattömböt.
<syntaxhighlight lang="bash">
# a passwd állomány rendezése a felhasználónév szerint - ez van elől
sort /etc/passwd
# fordított sorrend - reverse
sort -r /etc/passwd
</syntaxhighlight>

Alapértelmezetten karakterek szerint rendez, tehát a számokat tartalmazó adatsorokat nem helyes sorrendben adja vissza. Ha számérték szerinti rendezést szeretnénk végrehajtani, akkor használjuk a ''-n'' opciót.
<syntaxhighlight lang="bash">
# file egy számokat tartalmazó fájl - egy sor egy fájl
sort -n file
# fordított sorrend
sort -r -n file
</syntaxhighlight>

==== tr ====
A '''tr''' parancs segítségével karaktereket cserélhetünk ki egy fájlban. Ezen kívül nagyon hasznos tulajdonsága, hogy a kívánt ismétlődéseket el tudja távolítani, mintegy megtisztítva az adatsort.
<syntaxhighlight lang="bash">
# az e betűt o-ra, az o betűt e-re cseréli ki
echo "hello" | tr eo oe

# A T betűt K-ra, az n betűt p-re cseréli ki
echo "Tanar" | tr Tn Kp
</syntaxhighlight>
A fenti példák alapján nézzük meg, hogy mi történik:
# A tr két pozicionális paraméterrel lett meghívva
## Az első paraméter adja meg a lecserélendő karakterek halmazát
## A második paraméter adja meg az új karakterek halmazát
# A program végig megy a bemeneten és közben megvizsgálja, hogy az adott karakter megtalálható-e az első paraméterben
## ha megtalálható, akkor lecseréli a karakterrel azonos pozícióban álló második paraméterben található értékre
## ha nincs benne, akkor megy tovább
# a metodika miatt keresztbe is lehet cserélni (pl. ''o''-t ''e''-re, ''e''-t ''o''-ra, mint az első példában). Gondoljuk végig, hogy ha nem így lenne, akkor az először lecserélt ''e'' betűnek a végén ''o'' betűre kéne cserélődnie.

==== if ====
Az '''if''' segítségével elágazásokat hozhatunk létre, mint minden más programozási nyelven. A szerkezet a következőképp néz ki:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
elif KIFEJEZÉS
elif KIFEJEZÉS
else
fi
</syntaxhighlight>

Természetesen az egyes feltételek kihagyhatók, így készíthetünk egy egyszerű '''if''' elágazást is:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
fi
</syntaxhighlight>

Ha egy sorban szeretnénk leírni (nem scriptben), akkor a következőképpen tehetjük meg:
<syntaxhighlight lang="bash">
if KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; elif KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; else UTASÍTÁS; fi
</syntaxhighlight>

<big>'''KIFEJEZÉS'''</big> 
Egy olyan program, amelynek a visszatérési értéke hasznos információkat hordoz a futás eredményét tekintve. Ne feledjük el, hogy a '''return''' kulcsszóval tudunk ilyen értéket generálni C/C++ kódok esetében. Lássunk egy példát:

<syntaxhighlight lang="c">
#include <stdio.h>

int main() {
if ( 10 % 2 == 0 ) return 0;
else return 1;
}
</syntaxhighlight>

A fenti program visszatérési értéke információval szolgál számunkra, hogy a 10 osztható-e kettővel, avagy sem. Ez az érték vizsgálható az '''if''' segítségével és a válasz függvényében más-más kódokat hajthatunk végre.

A kiértékelés ellentétes a megszokott módszerhez képest (ahol minden igaz, aminek az értéke nem 0).
<syntaxhighlight lang="bash">
# ha a KIFEJEZÉS 0 értéket ad vissza, akkor IGAZ az állítás, tehát az if-en belüli kód fut
if KIFEJEZÉS => 0
then
....
else
....
fi

# ha a KIFEJEZÉS nem 0 értéket ad vissza, akkor HAMIS az állítás, tehát az else-n belüli kód fut
if KIFEJEZÉS => != 0
then
...
else
...
fi
</syntaxhighlight>

A programozási nyelvek tanításakor ezért térünk vissza 0-s értékkel ('''return 0;'''), a programunk végén, és hiba esetén 1, vagy annál nagyobb értékkel.

==== test ====
A '''test''' parancs logikai függvényeket értékel ki és
* '''0''' értéket ad vissza, ha az eredmény '''IGAZ''',
* '''1''' értéket ad vissza, ha az eredmény '''HAMIS'''

Az '''if''' utasítással együtt szoktuk használni, de természetesen ettől független is meghívható.
<syntaxhighlight lang="bash">
# megtörténik a logikai kiértékelés, eldől, hogy a két string egyezik-e
test "text1" == "text2"
# kiírjuk a képernyőre a test utasítás visszatérési értékét
echo $?
</syntaxhighlight>

'''if''' utasítással a következőképp használhatjuk:
<syntaxhighlight lang="bash">
# hamis
if test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

# igaz
if ! test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

#igaz
if test "text1" != "text2"
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

Elérhető egy ''alias'', aminek segítségével olvashatóbbá tehetjük a '''test''' utasítást. Ez a '''[ ]''' pár.
<syntaxhighlight lang="bash">
if [ "text1" == "text2" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

'''Ügyeljünk rá, hogy a ''['' és a '']'' zárójelek mellett ''whitespace'' karakterek vannak. Ha ezeket kihagyjuk, akkor hibát fogunk kapni!'''

A számok ellenőrzése BASH környezetben körülményesebb, mivel itt minden karakterláncnak számít. Emiatt a következő utasítás sorozat nem várt eredménnyel zárul:
<syntaxhighlight lang="bash">
if [ "1000" <= "20" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': igaz. De tudjuk, hogy ez az eredmény nem igaz, a BASH mégis így értékelte ki. Az oka, hogy az első karaktereket tekintve (''1'' és ''2'') elmondható, hogy az ''1''-es hamarabb van az ABC-ben (kódtáblában), mint a ''2'', így az ''1000''-nek kisebbnek kell lennie (mintha a "alma" és "körte" lenne összehasonlítva, hogy melyik következik előbb az ABC-ben).

Ahhoz, hogy a '''test''' utasítás karakterek helyett számként dolgozza fel a paramétert, kapcsolót kell használnunk:

{| class="wikitable" style="margin: 0px auto;"
|+
|-
! Kapcsoló !! Angol megnevezés !! Magyar megnevezés
|-
| -eq || Equals || Egyenlő
|-
| -ne || Not Equals || Nem egyenlő
|-
| -lt || Lower than || Kisebb, mint
|-
| -le || Lower than or equals || Kisebb vagy egyenlő
|-
| -gt || Greather than || nagyobb, mint
|-
| -ge || Greather than or equals || Nagyobb vagy egyenlő
|}

<syntaxhighlight lang="bash">
if [ 1000 -le 20 ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': Az elvártaknak megfelelően HAMIS.

==== for ====
A '''for''' utasítás segítségével egy lista elemein mehetünk végig. Hasonlóan működik, mint a modern programozási nyelvekben a ''foreach''.

Legegyszerűbben a következő utasítással tesztelhetjük, ahol a bemeneti listát soronként látjuk viszont a képernyőn:
<syntaxhighlight lang="bash">
for i in 1 2 3 4 5 6
do
echo $i
done
</syntaxhighlight>

Természetesen van lehetőségünk a listát más program kimenetéből kinyerni a parancsbehelyettesítés segítségével:
<syntaxhighlight lang="bash">
for i in `ls`
do
echo $i
done
</syntaxhighlight>

A '''for''' gyakorlatilag a pozicionális paramétereken megy végig, tehát egy lista elem a $1, egy másik listaelem a $2. Tudjuk, hogy ha szóközök között adjuk meg, akkor szóközt is tartalmazhat a paraméterünk. Lássunk egy példát:
<syntaxhighlight lang="bash">
for i in "1 2 3" "4 5 6"
do
echo $i
done
</syntaxhighlight>
Ez esetben a képernyőn két sor jelenik meg: ''1 2 3'' és ''4 5 6''. Azonban a parancsbehelyettesítés nem alkalmaz az idézőjelhez hasonló technikát, tehát azt alkalmazva minden szó (szóközökkel határolt karaktersorozat) új pozicionális paramétert jelent. Lássunk egy az előzőhöz hasonló példát:
<syntaxhighlight lang="bash">
for i in `echo "1 2 3 4 5 6"`
do
echo $i
done
</syntaxhighlight>
Ez esetben hat sor jelenik meg, benne egy-egy számmal, tehát az '''echo "1 2 3 4 5 6"''' kimenetét szóközönként vágta fel.

==== while ====
A '''while''' utasítás, mint minden programozási nyelvben, itt is felfogható úgy, mint egy többször lefutó '''if'''. Éppen ezért a szintaktikájuk megegyezik, csupán a feltételek megírásával kell óvatosan bánnunk, hogy a ciklus mag akkor és addig fusson, ameddig mi azt szeretnénk. A '''while''' ciklusnál ugyanazokat az alkalmazásokat írhatjuk be a '''KIFEJEZÉS''' helyére, mint az '''if''' esetében.

<syntaxhighlight lang="bash">
while KIFEJEZÉS
do
done
</syntaxhighlight>

Például ha azt akarjuk, hogy egy ciklus addig fusson, amíg meg nem jelenik egy fájl a fájlrendszerben, akkor azt a következőképp vezethetjük le:
<syntaxhighlight lang="bash">
# ellenőrzi, hogy a fájl elérhető-e
test -f "file.txt"

# ez esetben egyetlen kísérletet teszünk, de nem várjuk meg, hogy oda kerüljön, amennyiben nincs ott
if test -f "file.txt"
then
echo "a fájl létezik"
else
echo "A fájl nem létezik"
fi

# várakozunk, amíg a feltétel nem lesz igaz, tehát a fájl nem kerül oda
while ! test -f "file.txt"
do
echo "várakozunk"
done
echo "a fájl létezik"

# test parancs helyettesítése []-el
while ! [ -f "file.txt" ]
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

A while ciklusnál érdemes megemlíteni a '''until''' utasítást, ami annyiban tér el, hogy a feltétel kiértékelését invertálni kell - tehát ami igaz a '''while''' esetében, az hamis az '''until''' esetében és fordítva. Így a fenti feladatot megvalósíthatjuk invertálás nélkül, az until utasítással is:

<syntaxhighlight lang="bash">
until test -f "file.txt"
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

==== seq ====
A '''seq''' utasítás egy listát generál számunkra, amelyben a megadott lépésszámmal, a megadott legkisebb értéktől a megadott legnagyobb értékig szerepelnek a számok.

<syntaxhighlight lang="bash">
# számok 1-10-ig
seq 10

# számok 5-10-ig
seq 5 10

# számok 3-tól 10-ig 2-esével
seq 3 2 10
</syntaxhighlight>

A '''seq''' utasítást általában a '''for''' ciklus listájában használjuk, hogy elő tudjuk állítani az indexeket.
<syntaxhighlight lang="bash">
for i in `seq 3 2 10`
do
echo $i
done
</syntaxhighlight>

==== read ====
A '''read''' utasítás segítségével a STDIN-ről kérhetünk be információt változóba/változókba. Ha több változót sorolunk fel, akkor a bemenetet szóközöknél vágja el.
<syntaxhighlight lang="bash">
# beolvasás var-ba
# STDIN => teszt
# var => teszt
# STDIN => teszt szöveg
# var => teszt szöveg
read var

# beolvasás fname és lname változókba
# STDIN => Attila Farkas
# fname => Attila
# lname = Farkas
# STDIN => Attila
# fname => Attila
# lname => <üres>
# STDIN => Attila Farkas OPSYS
# fname => Attila
# lname => Farkas OPSYS
read fname lname

# beolvasás három változóba. Ha a felhasználó az utasításokkal szemben több szót adott meg, akkor így biztosíthatjuk, hogy ne legyen szóköz az első két változóban
# STDIN => Attila Farkas
# fname => Attila
# lname => Farkas
# tmp => <üres>
# STDIN => Attila Farkas OPSYS meg valami más
# fname => Attila
# lname => Farkas
# tmp => OPSYS meg valami más
read fname lname tmp
</syntaxhighlight>

Az utóbbi esetben hibaüzenet is generálható, ha megvizsgáljuk, hogy a ''tmp'' változó értéke üres-e:
<syntaxhighlight lang="bash">
echo -n "Adja meg a teljes nevét: "
read fname lname tmp

# -n => nem üres?
# -z => üres?
if [ -n "$tmp" ]
then
echo "Valamit elhibáztál"
exit 1
fi
</syntaxhighlight>

Ha szeretnénk ellenőrzött bekérést végrehajtani:
<syntaxhighlight lang="bash">
tmp="start value"
while [ -n "$tmp" ]
do
echo -n "Adja meg a teljes nevét FNAME LNAME formátumban: "
read fname lname tmp
if [ -n "$tmp" ]
then
echo "Valamit elrontottál!"
# ez esetben nem lépünk ki, mert bekérjük újra
fi
done
</syntaxhighlight>

==== expr ====
Az '''expr''' parancs segítségével tudunk matematikai műveleteket végrehajtani. Mivel a BASH-ben minden változó karakterlánc, így nem tudunk közöttük műveletet végezni. Az '''expr''' a paramétereket belül számként kezeli. '''Csak egész számokkal tud dolgozni!'''

<syntaxhighlight lang="bash">
# a képernyőre kerül az eredmény
expr 1 + 2
expr 4 * 4

# csak egész számot ír ki
expr 3 / 2
</syntaxhighlight>

Ha tört számokkal kell dolgoznunk, akkor a következőket tehetjük:
# eltávolítjuk a törtrészt
# felszorozzuk 10^n-nel, ahol n a törtrész számjegyeivel egyezik meg (pl. 10.02-t 100-al kell szorozni). Az egész térben elvégzett művelet eredményét később vissza osztjuk ugyanannyival, amennyivel korábban felszoroztuk. '''Ez nem egy egyszerű feladat, hiszen a tört számot egyáltalán nem kezeli az expr, tehát cut, wc és egyéb parancsokkal kell kialakítanunk a számot, ahogy utána szét is kell darabolnunk azt.'''
# Másik környezetet használunk, ahol tudunk számokat is kezelni - '''ez a ZH-n nem elfogadott'''

A lehetőségek közül csak az elsőt, a ZH-n teljes mértékben elfogadott megoldást mutatom be:
<syntaxhighlight lang="bash">
# a 3.4-et és a 1.2-őt kell összeadnunk.

# ennek eredménye 3
echo "3.4" | cut -d'.' -f1

# ennek eredménye 1
echo "1.2" | cut -d'.' -f1

# rakjuk össze
expr `echo "3.4" | cut -d'.' -f1` + `echo "1.2" | cut -d'.' -f1`
</syntaxhighlight>

=== Feladatok parancsokhoz ===
==== Írassuk ki a /etc/passwd több sorát ====
Több választási lehetőségünk van:
* ha a kiírandó sorszámok valamilyen logikát követnek (minden második, harmadik stb.), akkor használhatjuk a '''seq''' utasítást
* ha nincs logika a sorszámokban, akkor kézzel kell elkészítenünk a listát

<big>'''Logikát tartalmazó sorszámok'''</big> 
''Írassuk ki minden harmadik sor tartalmát'' 
<syntaxhighlight lang="bash">
# határozzuk meg a seq tartományát
# min: 1
# max: ahány sora van a fájlnak

# max érték meghatározás
# a változó létrehozást lentebb tárgyaljuk
max=`cat /etc/passwd | wc -l`

# lista meghatározása for ciklushoz
# 1-től $max-ig hármasával
seq 1 3 $max

# Rakjuk össze
for i in `seq 1 3 $max`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

<big>'''Logikát nem tartalmazó sorszámok'''</big> 
''Írassuk ki a 2., 5., 10. és 11. sorokat'' 
<syntaxhighlight lang="bash">
for i in `2 5 10 11`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

==== Fájlok ellenőrzése és másolása ====
Másoljuk át a /etc/passwd állományt egy könyvtárba (~/test/destination). Ha a célkönyvtár nem létezik, akkor hozzuk létre. Ha a célkönyvtár és a fájl is létezik, akkor írjunk ki hibaüzenetet.

<syntaxhighlight lang="bash">
# forrás fájl létezésének vizsgálata
test -f /etc/passwd

# célfájl létezésének vizsgálata
test -f ~/test/destination/passwd

# mappa létezésének vizsgálata
test -d ~/test/destination

# rakjuk össze

# ha a forrásfájl nem létezik
if ! test -f /etc/passwd
then
echo "A forrásfájl nem létezik"
# ha a célfájl létezik
elif test -f ~/test/destination/passwd
then
echo "A fájl már létezik"
# ha a cél mappa nem létezik
elif ! test -d ~/test/destination
then
# mappa létrehozás - szülőkönyvtárakat is, ha nem léteznek
mkdir -p ~/test/destination
# fájl belemásolása
cp /etc/passwd ~/test/destination
# ha a célfájl nem létezik, de a célmappa igen
else
# a fájlt bemásoljuk a könyvtárba
cp /etc/passwd ~/test/destination
fi
</syntaxhighlight>

=== Script létrehozása ===
* Script megírása
* Futási jog

=== Pozicionális paraméterek ===

=== Változók ===

== 3. óra ==
A harmadik órán reguláris nyelvekkel foglalkozunk. A nyelv szintaktikai elemzése után a BASH-ben erre alkalmas szoftvert, a ''grep''-et foguk megvizsgálni.

=== Reguláris kifejezés szerkezete ===
A reguláris nyelvek atomokból, lezártakból épül fel, amelynek az eredménye az úgynevezett „összetettek”.

==== Atomok ====
Az atomok egy karakterre illeszkednek a sorban.
{| class="wikitable" style="margin: 0px auto;"
|-
! Atom !! jelentés
|-
| betűk, számok || saját magukra illeszkednek
|-
| ^ || sor elejére illeszkedik (csak egyszer lehet a legelején)
|-
| $ || sor végére illeszkedik (csak egyszer lehet a legvégén)
|-
| [abc] || halmaz: minden benne lévő elemre illeszkedik
|-
| [^abc] || inverz halmaz: egyetlen benne lévő elemre sem illeszkedik
|-
| . || mindenre illeszkedik
|-
|}

==== Lezártak ====
A lezártak ismétlődéseket fogalmaznak meg egy atomra vonatkozóan. '''Lezárt csak atom után helyezkedhet el!'''
{| class="wikitable" style="margin: 0px auto;"
|-
! Lezárt !! jelentés
|-
| * || az atomot 0 és végtelen között akárhányszor ismételheti
|-
| + || az atomot 1 és végtelen között akárhányszor ismételheti
|-
| ? || az atomot 0 és 1 között akárhányszor ismételheti
|-
| {n} || az atom pontosan n-szer fordul elő egymás mellett
|-
| {n,m} || az atomot n és m között akárhányszor ismételheti
|-
| {n,} || az atomot n és végtelen között akárhányszor ismételheti
|-
| {,m} || az atomot 0 és m között akárhányszor ismételheti
|-
|}

==== Összefűzöttek ====
Az atomok és a lezártak egymás után írt sorozata.
A lezártaknál fontos kitétel volt, hogy csak atom után lehet írni. '''Egy összefűzött újra atomizálható''' a ( ) karakterekkel.
Az összefűzöttek tartalmazhatnak uniót (|), ahol több szabály közül bármelyik megvalósulhat egy sikeres illesztéshez.

=== Parancsok és példák ===
Ez egy teszt szöveg, amin próbálkozunk.
A fenti szöveget alapul véve, a következő reguláris kifejezéseket hozhatjuk létre:
{| class="wikitable" style="margin: 0px auto;"
! Reguláris kifejezés !! Illeszkedik? || Magyarázat
|-
| E || Igen || Van a sorban E betű
|-
| a || Igen || Van a sorban a betű
|-
| b || Nem || Nincs a sorban b betű
|-
| ^E || Igen || A sor elején van az E betű
|-
| ^A || Nem || Nincs a sor elején A betű
|-
| ^e || Nem || nincs a sor elején e betű
|-
| .$ || Igen || Bármilyen karakter lehet a sor végén
|-
| \. || Igen || . van a sor végén
|-
| k$ || Nem || Nincs k a sor végén
|-
| egy || igen || Van a sorban „egy” string
|-
| egység || Nem || Nincs a sorban egység string
|-
| egy* || Igen || eg kötelező, y 0 vagy végtelenszer lehet (egy, egyy, egyyy, egyyyy ...)
|-
| l*egy || Igen || l 0 vagy végtelen, eg kötelező (eg, leg, lleg, llleg, lllleg ...)
|-
| l+egy || Nem || Nincs a szövegben "l+egy" string
|-
| l\+egy || Nem || l 1 vagy végtelen hosszú, egy kötelező (legy, llegy, lllegy, llllegy ...)
|-
| (egy) || Nem || Nincs a sorban "(egy)" string
|-
| $egy$ || Igen || Van a sorban "egy" string
|-
| $egy$* || Igen || Van a sorban legalább 0-szor "egy" string
|-
| $egy$\+ || Igen || Van a sorban legalább 1-szer "egy" string
|-
| $egy$\{2\} || Nem || Nincs a sorban pontosan kétszer "egy" string
|-
| [a-z] || Igen || Vannak benne kisbetűk
|-
| [A-Z] || Igen || Van benne nagy betű
|-
| ^[A-D] || Nem || Nincs a sor elején A-D tartományban betű
|-
| ^[A-Z] || Igen || Nagy betű van a sor elején
|-
| ^[A-Z].*\.$ || Igen || Nagybetűvel kezdőik, középen bármi lehet és ponttal végződik a sor.
|-
| [0-9] || Nem || Nincs számjegy a sorban
|-
| .* || Igen || Mindenre illeszkedik, bármilyen hosszan (üres sorra is)
|-
| ^$ || Nem || Csak az üres sorra illeszkedik
|-
| ^.\+$ || Igen || Mindenre illeszkedik, kivéve az üres sorra
|}

A következő kifejezés szintén illeszkedik:
^[A-Z].*$egy$\|$kettő$.*\.$ => A sor elején nagybetűvel kezdődik, van a közepén valahol benne "egy" vagy "kettő" karakterlánc és ponttal végződik. A köztes karakterek értéke nincs megszabva.

==== grep ====
A '''grep''' utasítás segítségével végezhetünk el reguláris kifejezés, tehát minta illesztést fájlokon. Amennyiben nem adunk meg fájl paramétert, a STDIN csatornát olvassa. Az eredmények a STDOUT-ra íródnak.

{| class="wikitable" style="margin: 0px auto"
|+ Fontosabb kapcsolók
|-
! Rövid név !! Hosszú név !! Magyarázat
|-
| -c || --count || Megszámolja az illeszkedő sorokat
|-
| -o || --only-matching || Csak a mintára illeszkedő részt írja ki (nem a teljes sort)
|-
| -n || --line-number || Megszámozza a sorokat (a fájl alapján, nem a megjelenítés szerint)
|}

===== Példa =====
<syntaxhighlight lang="bash">
# nologin környezetet futtató felhasználók listája a rendszerben
grep "nologin" /etc/passwd
cat /etc/passwd | grep "nologin" # STDIN-en érkező adatok szűrése

# bash környezetet futtató felhasználók listája a rendszerben
grep "bash" /etc/passwd
cat /etc/passwd | grep "bash" # STDIN-en érkező adatok szűrése
</syntaxhighlight>

===== Példa 2 =====
Írjunk egy scriptet, amely a /bin/bash futtatási környezetet kapó felhasználók nevét kiírja a képernyőre.

<syntaxhighlight lang="bash">
#!/bin/bash

# a fájl, amin dolgozunk
file="/etc/passwd"
# a fájl sorainak száma
lines=`cat $file | wc -l`

# végig megyünk a fájl sorain
for i in `seq 1 $lines`; do
# itt kapjuk meg az i. sort
line=`head -$i $file | tail -1`
# kiszedjük a shell környezetet
shell=`echo $line | cut -f7 -d':'`
# ha ez "/bin/bash", akkor kivágjuk a sor első oszlopát, ezt írhatjuk a képernyőre
if test $shell == "/bin/bash"; then
echo $line | cut -f1 -d':'
fi
done
</syntaxhighlight>
A fenti script futási ideje: 0.227s

<syntaxhighlight lang="bash">
#!/bin/bash
# a fájl, amin dolgozunk
file="/etc/passwd"
# szűrjük ki a sorokat, amelyeknek a végén a "/bin/bash" karakterlánc található
# és a kapott eredményhalmaznak vágjuk ki az első oszlopát
# a kapott eredményhalmaz még mindig megfelel a /etc/passwd eredeti formátumának,
# csak a sorok számát csökkentettük a szűrési feltételnek megfelelően!
grep "/bin/bash$" $file | cut -f1 -d':'
</syntaxhighlight>
A fenti script futási ideje: 0.003s

===== MAC cím parser =====
Legyen egy MAC címeket tartalmazó fáljunk - mac-cimek.txt:
<syntaxhighlight lang="bash">
00:0C:42:AB:CD:EF
00:0c:42:ab:cd:ef
00-0C-42-AB-CD-EF
00-0c-42-ab-cd-ef
000c42abcdef
000C42ABCDEF
00:0C:42:AB:CD:EF:AB
00:0C:42:AB:CD:EF:
0G:0C:42:AB:CD:EF
00.0C.42.AB.CD.EF
00:0C:42:AB:CD:EG
</syntaxhighlight>
Ebben a fájlban vannak megfelelő és hibás szintaktikájú címek is. A feladat, hogy készítsünk reguláris kifejezést, amely megjeleníti a helyeseket a képernyőn.

<syntaxhighlight lang="bash">
grep "^$[[:xdigit:]]\{2\}[-:]\?$\{5\}[[:xdigit:]]\{2\}$" mac-cimek.txt
</syntaxhighlight>

Érdekességképp beletehetünk a fájlba a MAC címek elé és/vagy után véletlenszerű (megjeleníthető) karaktereket.
Mit tapasztalunk? Miért?

Távolítsuk el a sor eleje és a sor vége illesztéseket és futtassuk a grep-et a -o kapcsolóval? Mi változik?
(''grep -o "$'''['''[:xdigit:]''']'''\{2\}[-:]\?$\{5\}'''['''[:xdigit:]''']'''\{2\}" mac-cimek.txt'')

== 4. óra ==
A negyedik órán a reguláris kifejezések elkészítését gyakoroljuk különböző példákon keresztül. Főleg scripten belül használjuk.

== 5. óra ==
Az ötödik órán minta ZH feladatsort oldunk meg.

EDU::GAMF::Operációs rendszerek::Gyakorlatok

2024-10-09T12:09:20Z

ApelPro: /* MAC cím parser */

== 1. óra ==
Az első óra a tantárgy és annak követelményeinek ismertetésével kezdődik, majd egy-két alap utasítást tekintünk meg. Ezután a programok csatornáival folytatjuk.

=== Parancsok és példák ===
==== man ====
A ''man'' parancs segítségével megtekinthetjük egy-egy alkalmazás, parancs, esetleg külső könyvtár függvényeinek dokumentációját. 

'''Használata:'''
A program neve után írhatjuk, hogy melyik alkalmazás, parancs vagy esetleg külső könyvtár függvényének dokumentációját szeretnénk megtekinteni. Megtekinthetjük ily módon a ''man'' parancs használati útmutatóját is a következő utasítás kiadásával:
<syntaxhighlight lang="bash">
man man
</syntaxhighlight>

Hasonló módon alkalmazhatjuk bármelyik parancsra, amelyek ezen a weboldalon felsorolásra kerültek. Pl. a ''head'' utasítás dokumentációját az alábbi módon érhetjük el
<syntaxhighlight lang="bash">
man head
</syntaxhighlight>

==== ls ====
Érdemes megtekinteni a parancs dokumentációját a ''man ls'' utasítás kiadásával, tisztában legyünk ez elérhető kapcsolókkal és funkciókkal.
Az '''ls''' parancs segítségével listázhatjuk a mappa tartalmát. Alapértelmezetten a '''.''', tehát a jelenlegi könyvtárat listázza.
<syntaxhighlight lang="bash">
# meghívás paraméter nélkül
ls

# meghívás . paraméterrel - ugyanaz az eredmény
ls .
</syntaxhighlight>

A listázni kívánt könyvtár nevét megadhatjuk paraméterben:
<syntaxhighlight lang="bash">
# root könyvtár listázása
ls /

# a /usr/local/bin könyvtár listázása
ls /usr/local/bin
</syntaxhighlight>

Érdemes megjegyezni a hosszú formátumú kiírást, aminek segítségével a fájlrendszer bejegyzések jogosultságait és méretét kérhetjük le.
<syntaxhighlight lang="bash">
# Jelenlegi könyvtárban listáz minden elemet és azok tulajdonságait
ls -l

# A /bin/ls fájl jogosultságainak lekérdezése
ls -l /bin/ls
</syntaxhighlight>

Próbáljuk ki, hogy ha egy mappa nevével futtatjuk le a parancsot, akkor az '''ls''' megnyitja a könyvtárat és annak tartalmát listázza ki.
<syntaxhighlight lang="bash">
# a /bin könyvtár tartalma listázódik, nem a /bin könyvtár maga
ls /bin
</syntaxhighlight>
Ez különösen akkor okoz problémát, ha például az adott könyvtár jogosultságait szeretnénk megtekinteni. Ekkor két választási lehetőségünk adódik:
<syntaxhighlight lang="bash">
# A felette lévő könyvtárat listázzuk és kikeressük a megfelelő bejegyzést
ls / -l

# használjuk a -d kapcsolót, aminek segítségével felszólítjuk az ls-t, hogy ne nyissa meg az adott könyvtárat
# Ekkor a könyvtár listázódik, nem a tartalma
ls -d /bin
</syntaxhighlight>

==== pwd ====
A '''pwd''' parancs segítségével lekérdezhetjük annak a könyvtárnak az abszolút elérési útvonalát, amelyben éppen benne vagyunk.

A parancsot főleg arra használjuk, hogy aktuálisan mellettünk elhelyezett fájlok és könyvtárak abszolút útvonalát ki tudjuk alakítani.

<syntaxhighlight lang="bash">
pwd
</syntaxhighlight>

==== cd ====
A '''cd''' parancs segítségével könyvtárat válthatunk (''changedir''). A cél könyvtár nevét paraméterben kell megadnunk.
<syntaxhighlight lang="bash">
# root könyvtár megnyitása
cd /

# HOME könyvtár megnyitása
# ~ egy alias
cd ~

# /usr/bin megnyitása
cd /usr/bin
</syntaxhighlight>

A hivatkozásoknál, így a ''cd'' esetében is lehetőségünk van relatív és abszolút hivatkozásokat használni:
* Az abszolút hivatkozás / elérési út mindig ''/'' jellel kezdődik. pl.: ''cd /home/'', ''cd /usr/bin''
* A relatív hivatkozás vagy nem rendelkezik kezdőkarakterrel: ''cd home'', ''cd bin'', vagy ''.'' illetve ''..'' karakterekkel kezdődnek.
** A ''.'' könyvtár jelenti az aktuális könyvtárat
** A ''..'' könyvtár jelenti a szülő könyvtárat

<syntaxhighlight lang="bash">
# szülő könyvtár megnyitása
cd ../

# a szülőkönyvtárban található bin könyvtár megnyitása
cd ../bin

# az aktuális könyvtárban található bin könyvtár megnyitása
cd ./bin
cd bin # vegyük észre: a ./ ez esetben elhagyható
</syntaxhighlight>

==== mkdir ====
Az '''mkdir''' parancs segítségével könyvtárakat hozhatunk létre (''make directory''). Alapértelmezetten a ''.'' könyvtáron (tehát ahol éppen tartózkodunk, azon a könyvtáron) belül hozza létre az új mappát, de lehetőségünk van mind relatív, mind abszolút hivatkozások használatára.
<syntaxhighlight lang="bash">
# folder könyvtár létrehozása az aktuális könyvtárban
mkdir folder
mkdir ./folder2
# subfolder létrehozása a folder könyvtáron belül.
mkdir folder/subfolder

# létrehozás a /tmp könyvtáron belül, akárhol is vagyunk
mkdir /tmp/folder

# folder létrehozása a szülőkönyvtárban
mkdir ../folder
</syntaxhighlight>

A fentebb leírtak alapján egyetlen könyvtárat hozhatunk létre, egy már létező könyvtáron belül, legyen az éppen az, amiben tartózkodunk, vagy valahol máshol a fájlrendszerben. Azonban előfordul, hogy egyszerre több mappát szeretnénk elkészíteni, például egy mélyebb struktúrát szeretnénk kialakítani, mint ami a rendelkezésünkre áll. Ezt természetesen megtehetjük úgy, hogy az egyes szinteket egyesével hozzuk létre, de alkalmazhatunk kapcsolót, amelynek segítségével a nem létező szülőkönyvtárakat is létrehozza, amennyiben nem léteznek.
<syntaxhighlight lang="bash">
# root könyvtáron belül létrejön egy ''test'' könyvtár és azon belül jön létre a ''folder'' könyvtár.
mkdir /test/folder/ -p

# az aktuális könyvtárban jön létre egy ''test'' könyvtár és azon belül a ''folder'' könyvtár
mkdir -p test/folder

# a jelenlegi könyvtárban létrejon a ''test'' könyvtár,
# azon belül létrejön egy ''folder1'' és egy ''folder2'' könyvtár,
# majd mind a kettőben létrejön a ''work'' könyvtár.
mkdir -p test/{folder1,folder2}/work
</syntaxhighlight>

Természetesen ahhoz, hogy egy könyvtárban további fájlokat vagy könyvtárakat hozzunk létre jogosultság szükséges.

==== rmdir ====
Az '''rmdir''' parancs segítségével üres könyvtárakat törölhetünk.

'''Figyelem'''! Ha a könyvtár nem üres (fájlok vagy egyéb könyvtárak találhatók benne, akkor hibaüzenetet kapunk és nem csinál semmit!

<syntaxhighlight lang="bash">
# relatív hivatkozással
rmdir test/folder

# abszolút hivatkozással
rmdir /test/folder
</syntaxhighlight>

==== cp ====
A '''cp''' parancs segítségével fájlokat és könyvtárakat másolhatunk a fájlrendszer egy pontjáról a másikra.

<syntaxhighlight lang="bash">
# /etc/passwd fájl lemásolása a jelenlegi könyvtárba - ls paranccsal ellenőrízhető
cp /etc/passwd ./

# /etc/passwd lemásolása a jelenlegi könyvtárba és közben átnevezés file-ra
cp /etc/passwd ./file

# /etc/passwd lemásolása a /tmp könyvtárba
cp /etc/passwd /tmp/

# /etc/passwd lemásolása a /tmp könyvtárba és közben átnevezés file-ra
cp /etc/passwd /tmp/file
</syntaxhighlight>

Könyvtárak másolása esetén a ''-r'' kapcsoló használata szükséges (''recursive'').
<syntaxhighlight lang="bash">
# /etc/network könyvtár és annak tartalmát másolja a /tmp könyvtárba
cp /etc/network /tmp/ -r
</syntaxhighlight>

==== mv ====
Az '''mv''' parancs segítségével fájlokat és könyvtárakat mozgathatunk. Ezzel a paranccsal nevezhetjük át a fájlrendszer elemeit.

A próbálkozáshoz másoljuk le a /etc/passwd állományt, ha eddig nem tettük meg!
<syntaxhighlight lang="bash">
cp /etc/passwd ./
</syntaxhighlight>

<syntaxhighlight lang="bash">
# passwd állomány átnevezése file-ra
mv passwd file

# nem fut le!
# /etc/passwd állomány átnevezése file-ra
mv /etc/passwd /etc/file

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be
mv /etc/passwd /tmp

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be és közben átnevezés file-ra
mv /etc/passwd /tmp/file
</syntaxhighlight>

A könyvtárak áthelyezéséhez (vagy átnevezéséhez) ez esetben nincs szükségünk a ''recursive'' (''-r'') jelölésre.

==== rm ====
Az '''rm''' parancs segítségével fájlokat és könyvtárakat törölhetünk.

<syntaxhighlight lang="bash">
rm file
</syntaxhighlight>

Könyvtárak törléséhez alkalmaznunk kell a rekurzív jelölést: ''-r''.
<syntaxhighlight lang="bash">
rm folder -r
</syntaxhighlight>

==== less ====
A '''less''' egy fájlnézegető, amelynek segítségével lapozhatunk billentyűzet segítségével a fájlokban.

<syntaxhighlight lang="bash">
less /etc/passwd
</syntaxhighlight>

==== more ====
A '''more''' szintén egy fájlnézegető, de ennek segítségével csak előre lapozhatunk, visszafelé nem.

<syntaxhighlight lang="bash">
more /etc/passwd
</syntaxhighlight>

==== which ====
A '''which'' program segítségével lekérdezhetjük, hogy az adott utasításhoz tartozó állomány melyik mappában található.

<syntaxhighlight lang="bash">
# az ls parancs abszolút elérési útvonala
which ls

# a which parancs abszolút elérési útvonala
which which

# a man parancs elérési útvonala
which man
</syntaxhighlight>

==== file ====
A '''file''' utasítás segítségével lekérdezhetjük, hogy egy adott állomány milyen típusú: futtatható állomány (ELF), ASCII stb.

<syntaxhighlight lang="bash">
file /etc/passwd
file /bin/ls
</syntaxhighlight>

==== echo ====
Az '''echo''' mindent kiír a képernyőre, amit parancssori argumentumként adunk át neki.

<syntaxhighlight lang="bash">
echo "Hello World"
echo Hello World
echo Ez egy teszt üzenet
echo "Ez egy teszt üzenet"
</syntaxhighlight>

Láthatjuk, hogy idézőjeltől függetlenül minden megjelenik a képernyőn. Észrevehetjük azt is, hogy minden sor végén új sor karakter (enter) található, amit a "-n" kapcsoló segítségével kapcsolhatunk ki.

<syntaxhighlight lang="bash">
echo -n "Hello world"
</syntaxhighlight>

==== cat ====
A '''cat''' utasítás fájlokat képes összefűzni és az eredményt a képernyőre írja ki.

<syntaxhighlight lang="bash">
# /etc/passwd és a /etc/profile fájlok összefűzése a képernyőn (ebben a sorrendben)
cat /etc/passwd /etc/profile
</syntaxhighlight>

Egy gyakoribb felhasználási módja, hogy a fájlok tartalmát a képernyőre vessük - ez esetben nem fűzünk hozzá semmit a fájlhoz.
<syntaxhighlight lang="bash">
# /etc/passwd és a <semmi> összefűzése és megjelenítése a képernyőn
cat /etc/passwd
</syntaxhighlight>

==== head ====
A '''head''' utasítás segítségével a fájlok első N során írhatjuk ki a képernyőre. Alapértelmezetten N=10, így ha csak egy fájlnevet adunk neki, akkor annak legfeljebb 10 sorát fogja kiírni (ha van annyi).

<syntaxhighlight lang="bash">
head /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
head -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
head -5 /etc/passwd
</syntaxhighlight>

==== tail ====
A '''tail''' hasonlóan működik, mint a '''head''', de ez esetben nem a fájl elejéről ír ki N sort, hanem a végéről.
<syntaxhighlight lang="bash">
tail /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
tail -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
tail -5 /etc/passwd
</syntaxhighlight>

==== wc ====
A '''wc''' utasítás segítségével statisztikai adatokat nyerhetünk ki egy fájlból (''word counter''): sorok, szavak, karakterek és bájtok száma.

<syntaxhighlight lang="bash">
wc /etc/passwd
</syntaxhighlight>

Van lehetőségünk szűkíteni a visszaadott adatokat kapcsolók segítségével:
{| class="wikitable" style="margin: 0px auto"
|+
|-
! Rövid kapcsoló !! Hosszú kapcsoló !! Leírás
|-
| -l || --lines || sorok számát adja vissza
|-
| -w || --words || szavak számát adja vissza
|-
| -c || --chars || karakterek számát adja vissza
|-
| || --bytes || bájtok számát adja vissza
|}

<syntaxhighlight lang="bash">
# sorok számát írja ki
wc -l /etc/passwd
# szavak számát írja ki
wc -w /etc/passwd
# bájtok számát írja ki
wc --bytes /etc/passwd

# sorok és szavak számát írja ki a képernyőre
wc -l -w /etc/passwd
</syntaxhighlight>

==== find ====
A '''find''' utasítás segítségével kereshetünk a fájlrendszerben különböző attribútumok alapján.

<syntaxhighlight lang="bash">
# passwd nevű fájl keresése a /etc könyvtárban
find /etc -name passwd
</syntaxhighlight>

=== Programok csatornái ===
==== STDIN ====
==== STDOUT ====
==== STDERR ====

=== Pipeline ===

=== Parancsbehelyettesítés ===
=== Feladatok ===
==== Szedjük ki a ''/etc/passwd'' állomány 20. sorát ====
<syntaxhighlight lang="bash">
# beolvassuk az első 20 sort és levágjuk az utolsót
head -20 /etc/passwd | tail -1
</syntaxhighlight>

==== Mondjuk meg egy keresett bináris típusát ====
<syntaxhighlight lang="bash">
# fájl elérési út lekérdezése
# STDOUT => /bin/ls
which ls

# fájl típusának lekérdezése
file /bin/ls

# rakjuk össze:
file `which ls`
</syntaxhighlight>

== 2. óra ==
A második órát az alap utasításokkal folytatjuk. Utána scriptek írásával foglalkozunk, amelyben megtekintjük a különböző vezérlési szerkezeteket is.

=== Parancsok és példák ===

==== mcedit ====
Az '''mcedit''' az '''mc''' (''Midnight Commander'') szerkesztője. A Midnight Commander testvére a Total Commander ősének, a Volkov Commandernek, ami szintén egy konzolos alkalmazás. A közös gyökerek miatt nagyon hasonló funkcionalitásokat érhetünk el ebben is, mint a TC-ben - érdemes megnyitni az '''mc''' utasítással, amit később az '''F10''' billentyűvel, vagy az alsó sorban arra a gombra kattintással tudunk bezárni. Ebben az alkalmazásban működik az egér is, így kényelmes használatot eredményez. Érdekesség, hogy a "tálcára helyezés" is megoldott, így a '''Ctrl+O''' billentyűkombinációkkal háttérbe küldhetjük és folytathatjuk dolgunkat a terminálon, majd ugyanezzel a kombinációval előtérbe is hívhatjuk.

Az mcedit megnyitható az ''mc''-ből is, a szokásos F4-es billentyűvel - vagy az arra való kattintással.

Az egér az mcedit-ben is működik!

A másolás a szerkesztőben is hasonlóan működik, mint a kétpaneles fájltallózóban: F5 és F6 billentyűkkel másolhatunk illetve áthelyezhetünk sorokat. Kilépni az F10 billentyűvel, ESC-el tudunk, de ezt az ablakot is a háttérbe küldhetjük, ha szerkesztés közben terminált szeretnénk elérni (''CTRL+O'').

<syntaxhighlight lang="bash">
mcedit /etc/passwd
</syntaxhighlight>

==== nano ====
A '''nano''' szintén egy szövegszerkesztő alkalmazás.

Alul láthatjuk a segédletet, hogy milyen kombinációkkal milyen funkcionalitás érhető el. A szükségesebbek:
* CTRL+K segítségével kivághatunk sorokat a vágólapra (shift+kurzorbillentyűk segítségével tört sorok is kijelölhetők)
* CTRL+U Beilleszti a vágólap tartalmát az aktuális sorba
* CTRL+O Menti a változásokat
* CTRL+X Kilép, de megkérdezi, hogy menteni akarunk-e, ha vannak mentetlen változások

<syntaxhighlight lang="bash">
nano /etc/passwd
</syntaxhighlight>

==== chmod ====
==== shift ====
==== cut ====
A '''cut''' parancs segítségével táblázatos adatokat szűrhetünk: kiválaszthatjuk, hogy mely oszlopokat szeretnénk megjeleníteni. A két legfontosabb kapcsolója a ''-f'' (''field''), ahol a megjelenítendő oszlopokat adhatjuk meg és a ''-d'' (''delimiter''), ahol az elválasztó karaktert állíthatjuk be.

Általában a ''/etc/passwd'' állományon dolgozunk, mert ebben egy '':''-al elválasztott táblázat található.

<syntaxhighlight lang="bash">
# a fájl első oszlopát szedi ki :-nál elválasztva,
# tehát a felhasználónevet
cut -f1 -d':' /etc/passwd

# a fájl első és harmadik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet és az id-ját
cut -f1,3 -d':' /etc/passwd

# a fájl első három és hatodik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet, jelszót és a felhasználó id-ját, valamint a home könyvtárát
cut -f1-3,6 -d':' /etc/passwd
</syntaxhighlight>

==== sort ====
A '''sort''' utasítás segítségével rendezhetjük az adattömböt.
<syntaxhighlight lang="bash">
# a passwd állomány rendezése a felhasználónév szerint - ez van elől
sort /etc/passwd
# fordított sorrend - reverse
sort -r /etc/passwd
</syntaxhighlight>

Alapértelmezetten karakterek szerint rendez, tehát a számokat tartalmazó adatsorokat nem helyes sorrendben adja vissza. Ha számérték szerinti rendezést szeretnénk végrehajtani, akkor használjuk a ''-n'' opciót.
<syntaxhighlight lang="bash">
# file egy számokat tartalmazó fájl - egy sor egy fájl
sort -n file
# fordított sorrend
sort -r -n file
</syntaxhighlight>

==== tr ====
A '''tr''' parancs segítségével karaktereket cserélhetünk ki egy fájlban. Ezen kívül nagyon hasznos tulajdonsága, hogy a kívánt ismétlődéseket el tudja távolítani, mintegy megtisztítva az adatsort.
<syntaxhighlight lang="bash">
# az e betűt o-ra, az o betűt e-re cseréli ki
echo "hello" | tr eo oe

# A T betűt K-ra, az n betűt p-re cseréli ki
echo "Tanar" | tr Tn Kp
</syntaxhighlight>
A fenti példák alapján nézzük meg, hogy mi történik:
# A tr két pozicionális paraméterrel lett meghívva
## Az első paraméter adja meg a lecserélendő karakterek halmazát
## A második paraméter adja meg az új karakterek halmazát
# A program végig megy a bemeneten és közben megvizsgálja, hogy az adott karakter megtalálható-e az első paraméterben
## ha megtalálható, akkor lecseréli a karakterrel azonos pozícióban álló második paraméterben található értékre
## ha nincs benne, akkor megy tovább
# a metodika miatt keresztbe is lehet cserélni (pl. ''o''-t ''e''-re, ''e''-t ''o''-ra, mint az első példában). Gondoljuk végig, hogy ha nem így lenne, akkor az először lecserélt ''e'' betűnek a végén ''o'' betűre kéne cserélődnie.

==== if ====
Az '''if''' segítségével elágazásokat hozhatunk létre, mint minden más programozási nyelven. A szerkezet a következőképp néz ki:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
elif KIFEJEZÉS
elif KIFEJEZÉS
else
fi
</syntaxhighlight>

Természetesen az egyes feltételek kihagyhatók, így készíthetünk egy egyszerű '''if''' elágazást is:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
fi
</syntaxhighlight>

Ha egy sorban szeretnénk leírni (nem scriptben), akkor a következőképpen tehetjük meg:
<syntaxhighlight lang="bash">
if KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; elif KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; else UTASÍTÁS; fi
</syntaxhighlight>

<big>'''KIFEJEZÉS'''</big> 
Egy olyan program, amelynek a visszatérési értéke hasznos információkat hordoz a futás eredményét tekintve. Ne feledjük el, hogy a '''return''' kulcsszóval tudunk ilyen értéket generálni C/C++ kódok esetében. Lássunk egy példát:

<syntaxhighlight lang="c">
#include <stdio.h>

int main() {
if ( 10 % 2 == 0 ) return 0;
else return 1;
}
</syntaxhighlight>

A fenti program visszatérési értéke információval szolgál számunkra, hogy a 10 osztható-e kettővel, avagy sem. Ez az érték vizsgálható az '''if''' segítségével és a válasz függvényében más-más kódokat hajthatunk végre.

A kiértékelés ellentétes a megszokott módszerhez képest (ahol minden igaz, aminek az értéke nem 0).
<syntaxhighlight lang="bash">
# ha a KIFEJEZÉS 0 értéket ad vissza, akkor IGAZ az állítás, tehát az if-en belüli kód fut
if KIFEJEZÉS => 0
then
....
else
....
fi

# ha a KIFEJEZÉS nem 0 értéket ad vissza, akkor HAMIS az állítás, tehát az else-n belüli kód fut
if KIFEJEZÉS => != 0
then
...
else
...
fi
</syntaxhighlight>

A programozási nyelvek tanításakor ezért térünk vissza 0-s értékkel ('''return 0;'''), a programunk végén, és hiba esetén 1, vagy annál nagyobb értékkel.

==== test ====
A '''test''' parancs logikai függvényeket értékel ki és
* '''0''' értéket ad vissza, ha az eredmény '''IGAZ''',
* '''1''' értéket ad vissza, ha az eredmény '''HAMIS'''

Az '''if''' utasítással együtt szoktuk használni, de természetesen ettől független is meghívható.
<syntaxhighlight lang="bash">
# megtörténik a logikai kiértékelés, eldől, hogy a két string egyezik-e
test "text1" == "text2"
# kiírjuk a képernyőre a test utasítás visszatérési értékét
echo $?
</syntaxhighlight>

'''if''' utasítással a következőképp használhatjuk:
<syntaxhighlight lang="bash">
# hamis
if test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

# igaz
if ! test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

#igaz
if test "text1" != "text2"
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

Elérhető egy ''alias'', aminek segítségével olvashatóbbá tehetjük a '''test''' utasítást. Ez a '''[ ]''' pár.
<syntaxhighlight lang="bash">
if [ "text1" == "text2" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

'''Ügyeljünk rá, hogy a ''['' és a '']'' zárójelek mellett ''whitespace'' karakterek vannak. Ha ezeket kihagyjuk, akkor hibát fogunk kapni!'''

A számok ellenőrzése BASH környezetben körülményesebb, mivel itt minden karakterláncnak számít. Emiatt a következő utasítás sorozat nem várt eredménnyel zárul:
<syntaxhighlight lang="bash">
if [ "1000" <= "20" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': igaz. De tudjuk, hogy ez az eredmény nem igaz, a BASH mégis így értékelte ki. Az oka, hogy az első karaktereket tekintve (''1'' és ''2'') elmondható, hogy az ''1''-es hamarabb van az ABC-ben (kódtáblában), mint a ''2'', így az ''1000''-nek kisebbnek kell lennie (mintha a "alma" és "körte" lenne összehasonlítva, hogy melyik következik előbb az ABC-ben).

Ahhoz, hogy a '''test''' utasítás karakterek helyett számként dolgozza fel a paramétert, kapcsolót kell használnunk:

{| class="wikitable" style="margin: 0px auto;"
|+
|-
! Kapcsoló !! Angol megnevezés !! Magyar megnevezés
|-
| -eq || Equals || Egyenlő
|-
| -ne || Not Equals || Nem egyenlő
|-
| -lt || Lower than || Kisebb, mint
|-
| -le || Lower than or equals || Kisebb vagy egyenlő
|-
| -gt || Greather than || nagyobb, mint
|-
| -ge || Greather than or equals || Nagyobb vagy egyenlő
|}

<syntaxhighlight lang="bash">
if [ 1000 -le 20 ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': Az elvártaknak megfelelően HAMIS.

==== for ====
A '''for''' utasítás segítségével egy lista elemein mehetünk végig. Hasonlóan működik, mint a modern programozási nyelvekben a ''foreach''.

Legegyszerűbben a következő utasítással tesztelhetjük, ahol a bemeneti listát soronként látjuk viszont a képernyőn:
<syntaxhighlight lang="bash">
for i in 1 2 3 4 5 6
do
echo $i
done
</syntaxhighlight>

Természetesen van lehetőségünk a listát más program kimenetéből kinyerni a parancsbehelyettesítés segítségével:
<syntaxhighlight lang="bash">
for i in `ls`
do
echo $i
done
</syntaxhighlight>

A '''for''' gyakorlatilag a pozicionális paramétereken megy végig, tehát egy lista elem a $1, egy másik listaelem a $2. Tudjuk, hogy ha szóközök között adjuk meg, akkor szóközt is tartalmazhat a paraméterünk. Lássunk egy példát:
<syntaxhighlight lang="bash">
for i in "1 2 3" "4 5 6"
do
echo $i
done
</syntaxhighlight>
Ez esetben a képernyőn két sor jelenik meg: ''1 2 3'' és ''4 5 6''. Azonban a parancsbehelyettesítés nem alkalmaz az idézőjelhez hasonló technikát, tehát azt alkalmazva minden szó (szóközökkel határolt karaktersorozat) új pozicionális paramétert jelent. Lássunk egy az előzőhöz hasonló példát:
<syntaxhighlight lang="bash">
for i in `echo "1 2 3 4 5 6"`
do
echo $i
done
</syntaxhighlight>
Ez esetben hat sor jelenik meg, benne egy-egy számmal, tehát az '''echo "1 2 3 4 5 6"''' kimenetét szóközönként vágta fel.

==== while ====
A '''while''' utasítás, mint minden programozási nyelvben, itt is felfogható úgy, mint egy többször lefutó '''if'''. Éppen ezért a szintaktikájuk megegyezik, csupán a feltételek megírásával kell óvatosan bánnunk, hogy a ciklus mag akkor és addig fusson, ameddig mi azt szeretnénk. A '''while''' ciklusnál ugyanazokat az alkalmazásokat írhatjuk be a '''KIFEJEZÉS''' helyére, mint az '''if''' esetében.

<syntaxhighlight lang="bash">
while KIFEJEZÉS
do
done
</syntaxhighlight>

Például ha azt akarjuk, hogy egy ciklus addig fusson, amíg meg nem jelenik egy fájl a fájlrendszerben, akkor azt a következőképp vezethetjük le:
<syntaxhighlight lang="bash">
# ellenőrzi, hogy a fájl elérhető-e
test -f "file.txt"

# ez esetben egyetlen kísérletet teszünk, de nem várjuk meg, hogy oda kerüljön, amennyiben nincs ott
if test -f "file.txt"
then
echo "a fájl létezik"
else
echo "A fájl nem létezik"
fi

# várakozunk, amíg a feltétel nem lesz igaz, tehát a fájl nem kerül oda
while ! test -f "file.txt"
do
echo "várakozunk"
done
echo "a fájl létezik"

# test parancs helyettesítése []-el
while ! [ -f "file.txt" ]
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

A while ciklusnál érdemes megemlíteni a '''until''' utasítást, ami annyiban tér el, hogy a feltétel kiértékelését invertálni kell - tehát ami igaz a '''while''' esetében, az hamis az '''until''' esetében és fordítva. Így a fenti feladatot megvalósíthatjuk invertálás nélkül, az until utasítással is:

<syntaxhighlight lang="bash">
until test -f "file.txt"
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

==== seq ====
A '''seq''' utasítás egy listát generál számunkra, amelyben a megadott lépésszámmal, a megadott legkisebb értéktől a megadott legnagyobb értékig szerepelnek a számok.

<syntaxhighlight lang="bash">
# számok 1-10-ig
seq 10

# számok 5-10-ig
seq 5 10

# számok 3-tól 10-ig 2-esével
seq 3 2 10
</syntaxhighlight>

A '''seq''' utasítást általában a '''for''' ciklus listájában használjuk, hogy elő tudjuk állítani az indexeket.
<syntaxhighlight lang="bash">
for i in `seq 3 2 10`
do
echo $i
done
</syntaxhighlight>

==== read ====
A '''read''' utasítás segítségével a STDIN-ről kérhetünk be információt változóba/változókba. Ha több változót sorolunk fel, akkor a bemenetet szóközöknél vágja el.
<syntaxhighlight lang="bash">
# beolvasás var-ba
# STDIN => teszt
# var => teszt
# STDIN => teszt szöveg
# var => teszt szöveg
read var

# beolvasás fname és lname változókba
# STDIN => Attila Farkas
# fname => Attila
# lname = Farkas
# STDIN => Attila
# fname => Attila
# lname => <üres>
# STDIN => Attila Farkas OPSYS
# fname => Attila
# lname => Farkas OPSYS
read fname lname

# beolvasás három változóba. Ha a felhasználó az utasításokkal szemben több szót adott meg, akkor így biztosíthatjuk, hogy ne legyen szóköz az első két változóban
# STDIN => Attila Farkas
# fname => Attila
# lname => Farkas
# tmp => <üres>
# STDIN => Attila Farkas OPSYS meg valami más
# fname => Attila
# lname => Farkas
# tmp => OPSYS meg valami más
read fname lname tmp
</syntaxhighlight>

Az utóbbi esetben hibaüzenet is generálható, ha megvizsgáljuk, hogy a ''tmp'' változó értéke üres-e:
<syntaxhighlight lang="bash">
echo -n "Adja meg a teljes nevét: "
read fname lname tmp

# -n => nem üres?
# -z => üres?
if [ -n "$tmp" ]
then
echo "Valamit elhibáztál"
exit 1
fi
</syntaxhighlight>

Ha szeretnénk ellenőrzött bekérést végrehajtani:
<syntaxhighlight lang="bash">
tmp="start value"
while [ -n "$tmp" ]
do
echo -n "Adja meg a teljes nevét FNAME LNAME formátumban: "
read fname lname tmp
if [ -n "$tmp" ]
then
echo "Valamit elrontottál!"
# ez esetben nem lépünk ki, mert bekérjük újra
fi
done
</syntaxhighlight>

==== expr ====
Az '''expr''' parancs segítségével tudunk matematikai műveleteket végrehajtani. Mivel a BASH-ben minden változó karakterlánc, így nem tudunk közöttük műveletet végezni. Az '''expr''' a paramétereket belül számként kezeli. '''Csak egész számokkal tud dolgozni!'''

<syntaxhighlight lang="bash">
# a képernyőre kerül az eredmény
expr 1 + 2
expr 4 * 4

# csak egész számot ír ki
expr 3 / 2
</syntaxhighlight>

Ha tört számokkal kell dolgoznunk, akkor a következőket tehetjük:
# eltávolítjuk a törtrészt
# felszorozzuk 10^n-nel, ahol n a törtrész számjegyeivel egyezik meg (pl. 10.02-t 100-al kell szorozni). Az egész térben elvégzett művelet eredményét később vissza osztjuk ugyanannyival, amennyivel korábban felszoroztuk. '''Ez nem egy egyszerű feladat, hiszen a tört számot egyáltalán nem kezeli az expr, tehát cut, wc és egyéb parancsokkal kell kialakítanunk a számot, ahogy utána szét is kell darabolnunk azt.'''
# Másik környezetet használunk, ahol tudunk számokat is kezelni - '''ez a ZH-n nem elfogadott'''

A lehetőségek közül csak az elsőt, a ZH-n teljes mértékben elfogadott megoldást mutatom be:
<syntaxhighlight lang="bash">
# a 3.4-et és a 1.2-őt kell összeadnunk.

# ennek eredménye 3
echo "3.4" | cut -d'.' -f1

# ennek eredménye 1
echo "1.2" | cut -d'.' -f1

# rakjuk össze
expr `echo "3.4" | cut -d'.' -f1` + `echo "1.2" | cut -d'.' -f1`
</syntaxhighlight>

=== Feladatok parancsokhoz ===
==== Írassuk ki a /etc/passwd több sorát ====
Több választási lehetőségünk van:
* ha a kiírandó sorszámok valamilyen logikát követnek (minden második, harmadik stb.), akkor használhatjuk a '''seq''' utasítást
* ha nincs logika a sorszámokban, akkor kézzel kell elkészítenünk a listát

<big>'''Logikát tartalmazó sorszámok'''</big> 
''Írassuk ki minden harmadik sor tartalmát'' 
<syntaxhighlight lang="bash">
# határozzuk meg a seq tartományát
# min: 1
# max: ahány sora van a fájlnak

# max érték meghatározás
# a változó létrehozást lentebb tárgyaljuk
max=`cat /etc/passwd | wc -l`

# lista meghatározása for ciklushoz
# 1-től $max-ig hármasával
seq 1 3 $max

# Rakjuk össze
for i in `seq 1 3 $max`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

<big>'''Logikát nem tartalmazó sorszámok'''</big> 
''Írassuk ki a 2., 5., 10. és 11. sorokat'' 
<syntaxhighlight lang="bash">
for i in `2 5 10 11`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

==== Fájlok ellenőrzése és másolása ====
Másoljuk át a /etc/passwd állományt egy könyvtárba (~/test/destination). Ha a célkönyvtár nem létezik, akkor hozzuk létre. Ha a célkönyvtár és a fájl is létezik, akkor írjunk ki hibaüzenetet.

<syntaxhighlight lang="bash">
# forrás fájl létezésének vizsgálata
test -f /etc/passwd

# célfájl létezésének vizsgálata
test -f ~/test/destination/passwd

# mappa létezésének vizsgálata
test -d ~/test/destination

# rakjuk össze

# ha a forrásfájl nem létezik
if ! test -f /etc/passwd
then
echo "A forrásfájl nem létezik"
# ha a célfájl létezik
elif test -f ~/test/destination/passwd
then
echo "A fájl már létezik"
# ha a cél mappa nem létezik
elif ! test -d ~/test/destination
then
# mappa létrehozás - szülőkönyvtárakat is, ha nem léteznek
mkdir -p ~/test/destination
# fájl belemásolása
cp /etc/passwd ~/test/destination
# ha a célfájl nem létezik, de a célmappa igen
else
# a fájlt bemásoljuk a könyvtárba
cp /etc/passwd ~/test/destination
fi
</syntaxhighlight>

=== Script létrehozása ===
* Script megírása
* Futási jog

=== Pozicionális paraméterek ===

=== Változók ===

== 3. óra ==
A harmadik órán reguláris nyelvekkel foglalkozunk. A nyelv szintaktikai elemzése után a BASH-ben erre alkalmas szoftvert, a ''grep''-et foguk megvizsgálni.

=== Reguláris kifejezés szerkezete ===
A reguláris nyelvek atomokból, lezártakból épül fel, amelynek az eredménye az úgynevezett „összetettek”.

==== Atomok ====
Az atomok egy karakterre illeszkednek a sorban.
{| class="wikitable" style="margin: 0px auto;"
|-
! Atom !! jelentés
|-
| betűk, számok || saját magukra illeszkednek
|-
| ^ || sor elejére illeszkedik (csak egyszer lehet a legelején)
|-
| $ || sor végére illeszkedik (csak egyszer lehet a legvégén)
|-
| [abc] || halmaz: minden benne lévő elemre illeszkedik
|-
| [^abc] || inverz halmaz: egyetlen benne lévő elemre sem illeszkedik
|-
| . || mindenre illeszkedik
|-
|}

==== Lezártak ====
A lezártak ismétlődéseket fogalmaznak meg egy atomra vonatkozóan. '''Lezárt csak atom után helyezkedhet el!'''
{| class="wikitable" style="margin: 0px auto;"
|-
! Lezárt !! jelentés
|-
| * || az atomot 0 és végtelen között akárhányszor ismételheti
|-
| + || az atomot 1 és végtelen között akárhányszor ismételheti
|-
| ? || az atomot 0 és 1 között akárhányszor ismételheti
|-
| {n} || az atom pontosan n-szer fordul elő egymás mellett
|-
| {n,m} || az atomot n és m között akárhányszor ismételheti
|-
| {n,} || az atomot n és végtelen között akárhányszor ismételheti
|-
| {,m} || az atomot 0 és m között akárhányszor ismételheti
|-
|}

==== Összefűzöttek ====
Az atomok és a lezártak egymás után írt sorozata.
A lezártaknál fontos kitétel volt, hogy csak atom után lehet írni. '''Egy összefűzött újra atomizálható''' a ( ) karakterekkel.
Az összefűzöttek tartalmazhatnak uniót (|), ahol több szabály közül bármelyik megvalósulhat egy sikeres illesztéshez.

=== Parancsok és példák ===
Ez egy teszt szöveg, amin próbálkozunk.
A fenti szöveget alapul véve, a következő reguláris kifejezéseket hozhatjuk létre:
{| class="wikitable" style="margin: 0px auto;"
! Reguláris kifejezés !! Illeszkedik? || Magyarázat
|-
| E || Igen || Van a sorban E betű
|-
| a || Igen || Van a sorban a betű
|-
| b || Nem || Nincs a sorban b betű
|-
| ^E || Igen || A sor elején van az E betű
|-
| ^A || Nem || Nincs a sor elején A betű
|-
| ^e || Nem || nincs a sor elején e betű
|-
| .$ || Igen || Bármilyen karakter lehet a sor végén
|-
| \. || Igen || . van a sor végén
|-
| k$ || Nem || Nincs k a sor végén
|-
| egy || igen || Van a sorban „egy” string
|-
| egység || Nem || Nincs a sorban egység string
|-
| egy* || Igen || eg kötelező, y 0 vagy végtelenszer lehet (egy, egyy, egyyy, egyyyy ...)
|-
| l*egy || Igen || l 0 vagy végtelen, eg kötelező (eg, leg, lleg, llleg, lllleg ...)
|-
| l+egy || Nem || Nincs a szövegben "l+egy" string
|-
| l\+egy || Nem || l 1 vagy végtelen hosszú, egy kötelező (legy, llegy, lllegy, llllegy ...)
|-
| (egy) || Nem || Nincs a sorban "(egy)" string
|-
| $egy$ || Igen || Van a sorban "egy" string
|-
| $egy$* || Igen || Van a sorban legalább 0-szor "egy" string
|-
| $egy$\+ || Igen || Van a sorban legalább 1-szer "egy" string
|-
| $egy$\{2\} || Nem || Nincs a sorban pontosan kétszer "egy" string
|-
| [a-z] || Igen || Vannak benne kisbetűk
|-
| [A-Z] || Igen || Van benne nagy betű
|-
| ^[A-D] || Nem || Nincs a sor elején A-D tartományban betű
|-
| ^[A-Z] || Igen || Nagy betű van a sor elején
|-
| ^[A-Z].*\.$ || Igen || Nagybetűvel kezdőik, középen bármi lehet és ponttal végződik a sor.
|-
| [0-9] || Nem || Nincs számjegy a sorban
|-
| .* || Igen || Mindenre illeszkedik, bármilyen hosszan (üres sorra is)
|-
| ^$ || Nem || Csak az üres sorra illeszkedik
|-
| ^.\+$ || Igen || Mindenre illeszkedik, kivéve az üres sorra
|}

A következő kifejezés szintén illeszkedik:
^[A-Z].*$egy$\|$kettő$.*\.$ => A sor elején nagybetűvel kezdődik, van a közepén valahol benne "egy" vagy "kettő" karakterlánc és ponttal végződik. A köztes karakterek értéke nincs megszabva.

==== grep ====
A '''grep''' utasítás segítségével végezhetünk el reguláris kifejezés, tehát minta illesztést fájlokon. Amennyiben nem adunk meg fájl paramétert, a STDIN csatornát olvassa. Az eredmények a STDOUT-ra íródnak.

{| class="wikitable" style="margin: 0px auto"
|+ Fontosabb kapcsolók
|-
! Rövid név !! Hosszú név !! Magyarázat
|-
| -c || --count || Megszámolja az illeszkedő sorokat
|-
| -o || --only-matching || Csak a mintára illeszkedő részt írja ki (nem a teljes sort)
|-
| -n || --line-number || Megszámozza a sorokat (a fájl alapján, nem a megjelenítés szerint)
|}

===== Példa =====
<syntaxhighlight lang="bash">
# nologin környezetet futtató felhasználók listája a rendszerben
grep "nologin" /etc/passwd
cat /etc/passwd | grep "nologin" # STDIN-en érkező adatok szűrése

# bash környezetet futtató felhasználók listája a rendszerben
grep "bash" /etc/passwd
cat /etc/passwd | grep "bash" # STDIN-en érkező adatok szűrése
</syntaxhighlight>

===== Példa 2 =====
Írjunk egy scriptet, amely a /bin/bash futtatási környezetet kapó felhasználók nevét kiírja a képernyőre.

<syntaxhighlight lang="bash">
#!/bin/bash

# a fájl, amin dolgozunk
file="/etc/passwd"
# a fájl sorainak száma
lines=`cat $file | wc -l`

# végig megyünk a fájl sorain
for i in `seq 1 $lines`; do
# itt kapjuk meg az i. sort
line=`head -$i $file | tail -1`
# kiszedjük a shell környezetet
shell=`echo $line | cut -f7 -d':'`
# ha ez "/bin/bash", akkor kivágjuk a sor első oszlopát, ezt írhatjuk a képernyőre
if test $shell == "/bin/bash"; then
echo $line | cut -f1 -d':'
fi
done
</syntaxhighlight>
A fenti script futási ideje: 0.227s

<syntaxhighlight lang="bash">
#!/bin/bash
# a fájl, amin dolgozunk
file="/etc/passwd"
# szűrjük ki a sorokat, amelyeknek a végén a "/bin/bash" karakterlánc található
# és a kapott eredményhalmaznak vágjuk ki az első oszlopát
# a kapott eredményhalmaz még mindig megfelel a /etc/passwd eredeti formátumának,
# csak a sorok számát csökkentettük a szűrési feltételnek megfelelően!
grep "/bin/bash$" $file | cut -f1 -d':'
</syntaxhighlight>
A fenti script futási ideje: 0.003s

===== MAC cím parser =====
Legyen egy MAC címeket tartalmazó fáljunk - mac-cimek.txt:
<syntaxhighlight lang="bash">
00:0C:42:AB:CD:EF
00:0c:42:ab:cd:ef
00-0C-42-AB-CD-EF
00-0c-42-ab-cd-ef
000c42abcdef
000C42ABCDEF
00:0C:42:AB:CD:EF:AB
00:0C:42:AB:CD:EF:
0G:0C:42:AB:CD:EF
00.0C.42.AB.CD.EF
00:0C:42:AB:CD:EG
</syntaxhighlight>
Ebben a fájlban vannak megfelelő és hibás szintaktikájú címek is. A feladat, hogy készítsünk reguláris kifejezést, amely megjeleníti a helyeseket a képernyőn.

<syntaxhighlight lang="bash">
grep "^$[[:xdigit:]]\{2\}[-:]\?$\{5\}[[:xdigit:]]\{2\}$" mac-cimek.txt
</syntaxhighlight>

Érdekességképp beletehetünk a fájlba a MAC címek elé és/vagy után véletlenszerű (megjeleníthető) karaktereket.
Mit tapasztalunk? Miért?

Távolítsuk el a sor eleje és a sor vége illesztéseket és futtassuk a grep-et a -o kapcsolóval? Mi változik?
(''grep -o "$[[:xdigit:]]\{2\}[-:]\?$\{5\}[[:xdigit:]]\{2\}" mac-cimek.txt'')

== 4. óra ==
A negyedik órán a reguláris kifejezések elkészítését gyakoroljuk különböző példákon keresztül. Főleg scripten belül használjuk.

== 5. óra ==
Az ötödik órán minta ZH feladatsort oldunk meg.

EDU::GAMF::Operációs rendszerek::Gyakorlatok

2024-10-09T12:08:27Z

ApelPro: /* MAC cím parser */

== 1. óra ==
Az első óra a tantárgy és annak követelményeinek ismertetésével kezdődik, majd egy-két alap utasítást tekintünk meg. Ezután a programok csatornáival folytatjuk.

=== Parancsok és példák ===
==== man ====
A ''man'' parancs segítségével megtekinthetjük egy-egy alkalmazás, parancs, esetleg külső könyvtár függvényeinek dokumentációját. 

'''Használata:'''
A program neve után írhatjuk, hogy melyik alkalmazás, parancs vagy esetleg külső könyvtár függvényének dokumentációját szeretnénk megtekinteni. Megtekinthetjük ily módon a ''man'' parancs használati útmutatóját is a következő utasítás kiadásával:
<syntaxhighlight lang="bash">
man man
</syntaxhighlight>

Hasonló módon alkalmazhatjuk bármelyik parancsra, amelyek ezen a weboldalon felsorolásra kerültek. Pl. a ''head'' utasítás dokumentációját az alábbi módon érhetjük el
<syntaxhighlight lang="bash">
man head
</syntaxhighlight>

==== ls ====
Érdemes megtekinteni a parancs dokumentációját a ''man ls'' utasítás kiadásával, tisztában legyünk ez elérhető kapcsolókkal és funkciókkal.
Az '''ls''' parancs segítségével listázhatjuk a mappa tartalmát. Alapértelmezetten a '''.''', tehát a jelenlegi könyvtárat listázza.
<syntaxhighlight lang="bash">
# meghívás paraméter nélkül
ls

# meghívás . paraméterrel - ugyanaz az eredmény
ls .
</syntaxhighlight>

A listázni kívánt könyvtár nevét megadhatjuk paraméterben:
<syntaxhighlight lang="bash">
# root könyvtár listázása
ls /

# a /usr/local/bin könyvtár listázása
ls /usr/local/bin
</syntaxhighlight>

Érdemes megjegyezni a hosszú formátumú kiírást, aminek segítségével a fájlrendszer bejegyzések jogosultságait és méretét kérhetjük le.
<syntaxhighlight lang="bash">
# Jelenlegi könyvtárban listáz minden elemet és azok tulajdonságait
ls -l

# A /bin/ls fájl jogosultságainak lekérdezése
ls -l /bin/ls
</syntaxhighlight>

Próbáljuk ki, hogy ha egy mappa nevével futtatjuk le a parancsot, akkor az '''ls''' megnyitja a könyvtárat és annak tartalmát listázza ki.
<syntaxhighlight lang="bash">
# a /bin könyvtár tartalma listázódik, nem a /bin könyvtár maga
ls /bin
</syntaxhighlight>
Ez különösen akkor okoz problémát, ha például az adott könyvtár jogosultságait szeretnénk megtekinteni. Ekkor két választási lehetőségünk adódik:
<syntaxhighlight lang="bash">
# A felette lévő könyvtárat listázzuk és kikeressük a megfelelő bejegyzést
ls / -l

# használjuk a -d kapcsolót, aminek segítségével felszólítjuk az ls-t, hogy ne nyissa meg az adott könyvtárat
# Ekkor a könyvtár listázódik, nem a tartalma
ls -d /bin
</syntaxhighlight>

==== pwd ====
A '''pwd''' parancs segítségével lekérdezhetjük annak a könyvtárnak az abszolút elérési útvonalát, amelyben éppen benne vagyunk.

A parancsot főleg arra használjuk, hogy aktuálisan mellettünk elhelyezett fájlok és könyvtárak abszolút útvonalát ki tudjuk alakítani.

<syntaxhighlight lang="bash">
pwd
</syntaxhighlight>

==== cd ====
A '''cd''' parancs segítségével könyvtárat válthatunk (''changedir''). A cél könyvtár nevét paraméterben kell megadnunk.
<syntaxhighlight lang="bash">
# root könyvtár megnyitása
cd /

# HOME könyvtár megnyitása
# ~ egy alias
cd ~

# /usr/bin megnyitása
cd /usr/bin
</syntaxhighlight>

A hivatkozásoknál, így a ''cd'' esetében is lehetőségünk van relatív és abszolút hivatkozásokat használni:
* Az abszolút hivatkozás / elérési út mindig ''/'' jellel kezdődik. pl.: ''cd /home/'', ''cd /usr/bin''
* A relatív hivatkozás vagy nem rendelkezik kezdőkarakterrel: ''cd home'', ''cd bin'', vagy ''.'' illetve ''..'' karakterekkel kezdődnek.
** A ''.'' könyvtár jelenti az aktuális könyvtárat
** A ''..'' könyvtár jelenti a szülő könyvtárat

<syntaxhighlight lang="bash">
# szülő könyvtár megnyitása
cd ../

# a szülőkönyvtárban található bin könyvtár megnyitása
cd ../bin

# az aktuális könyvtárban található bin könyvtár megnyitása
cd ./bin
cd bin # vegyük észre: a ./ ez esetben elhagyható
</syntaxhighlight>

==== mkdir ====
Az '''mkdir''' parancs segítségével könyvtárakat hozhatunk létre (''make directory''). Alapértelmezetten a ''.'' könyvtáron (tehát ahol éppen tartózkodunk, azon a könyvtáron) belül hozza létre az új mappát, de lehetőségünk van mind relatív, mind abszolút hivatkozások használatára.
<syntaxhighlight lang="bash">
# folder könyvtár létrehozása az aktuális könyvtárban
mkdir folder
mkdir ./folder2
# subfolder létrehozása a folder könyvtáron belül.
mkdir folder/subfolder

# létrehozás a /tmp könyvtáron belül, akárhol is vagyunk
mkdir /tmp/folder

# folder létrehozása a szülőkönyvtárban
mkdir ../folder
</syntaxhighlight>

A fentebb leírtak alapján egyetlen könyvtárat hozhatunk létre, egy már létező könyvtáron belül, legyen az éppen az, amiben tartózkodunk, vagy valahol máshol a fájlrendszerben. Azonban előfordul, hogy egyszerre több mappát szeretnénk elkészíteni, például egy mélyebb struktúrát szeretnénk kialakítani, mint ami a rendelkezésünkre áll. Ezt természetesen megtehetjük úgy, hogy az egyes szinteket egyesével hozzuk létre, de alkalmazhatunk kapcsolót, amelynek segítségével a nem létező szülőkönyvtárakat is létrehozza, amennyiben nem léteznek.
<syntaxhighlight lang="bash">
# root könyvtáron belül létrejön egy ''test'' könyvtár és azon belül jön létre a ''folder'' könyvtár.
mkdir /test/folder/ -p

# az aktuális könyvtárban jön létre egy ''test'' könyvtár és azon belül a ''folder'' könyvtár
mkdir -p test/folder

# a jelenlegi könyvtárban létrejon a ''test'' könyvtár,
# azon belül létrejön egy ''folder1'' és egy ''folder2'' könyvtár,
# majd mind a kettőben létrejön a ''work'' könyvtár.
mkdir -p test/{folder1,folder2}/work
</syntaxhighlight>

Természetesen ahhoz, hogy egy könyvtárban további fájlokat vagy könyvtárakat hozzunk létre jogosultság szükséges.

==== rmdir ====
Az '''rmdir''' parancs segítségével üres könyvtárakat törölhetünk.

'''Figyelem'''! Ha a könyvtár nem üres (fájlok vagy egyéb könyvtárak találhatók benne, akkor hibaüzenetet kapunk és nem csinál semmit!

<syntaxhighlight lang="bash">
# relatív hivatkozással
rmdir test/folder

# abszolút hivatkozással
rmdir /test/folder
</syntaxhighlight>

==== cp ====
A '''cp''' parancs segítségével fájlokat és könyvtárakat másolhatunk a fájlrendszer egy pontjáról a másikra.

<syntaxhighlight lang="bash">
# /etc/passwd fájl lemásolása a jelenlegi könyvtárba - ls paranccsal ellenőrízhető
cp /etc/passwd ./

# /etc/passwd lemásolása a jelenlegi könyvtárba és közben átnevezés file-ra
cp /etc/passwd ./file

# /etc/passwd lemásolása a /tmp könyvtárba
cp /etc/passwd /tmp/

# /etc/passwd lemásolása a /tmp könyvtárba és közben átnevezés file-ra
cp /etc/passwd /tmp/file
</syntaxhighlight>

Könyvtárak másolása esetén a ''-r'' kapcsoló használata szükséges (''recursive'').
<syntaxhighlight lang="bash">
# /etc/network könyvtár és annak tartalmát másolja a /tmp könyvtárba
cp /etc/network /tmp/ -r
</syntaxhighlight>

==== mv ====
Az '''mv''' parancs segítségével fájlokat és könyvtárakat mozgathatunk. Ezzel a paranccsal nevezhetjük át a fájlrendszer elemeit.

A próbálkozáshoz másoljuk le a /etc/passwd állományt, ha eddig nem tettük meg!
<syntaxhighlight lang="bash">
cp /etc/passwd ./
</syntaxhighlight>

<syntaxhighlight lang="bash">
# passwd állomány átnevezése file-ra
mv passwd file

# nem fut le!
# /etc/passwd állomány átnevezése file-ra
mv /etc/passwd /etc/file

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be
mv /etc/passwd /tmp

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be és közben átnevezés file-ra
mv /etc/passwd /tmp/file
</syntaxhighlight>

A könyvtárak áthelyezéséhez (vagy átnevezéséhez) ez esetben nincs szükségünk a ''recursive'' (''-r'') jelölésre.

==== rm ====
Az '''rm''' parancs segítségével fájlokat és könyvtárakat törölhetünk.

<syntaxhighlight lang="bash">
rm file
</syntaxhighlight>

Könyvtárak törléséhez alkalmaznunk kell a rekurzív jelölést: ''-r''.
<syntaxhighlight lang="bash">
rm folder -r
</syntaxhighlight>

==== less ====
A '''less''' egy fájlnézegető, amelynek segítségével lapozhatunk billentyűzet segítségével a fájlokban.

<syntaxhighlight lang="bash">
less /etc/passwd
</syntaxhighlight>

==== more ====
A '''more''' szintén egy fájlnézegető, de ennek segítségével csak előre lapozhatunk, visszafelé nem.

<syntaxhighlight lang="bash">
more /etc/passwd
</syntaxhighlight>

==== which ====
A '''which'' program segítségével lekérdezhetjük, hogy az adott utasításhoz tartozó állomány melyik mappában található.

<syntaxhighlight lang="bash">
# az ls parancs abszolút elérési útvonala
which ls

# a which parancs abszolút elérési útvonala
which which

# a man parancs elérési útvonala
which man
</syntaxhighlight>

==== file ====
A '''file''' utasítás segítségével lekérdezhetjük, hogy egy adott állomány milyen típusú: futtatható állomány (ELF), ASCII stb.

<syntaxhighlight lang="bash">
file /etc/passwd
file /bin/ls
</syntaxhighlight>

==== echo ====
Az '''echo''' mindent kiír a képernyőre, amit parancssori argumentumként adunk át neki.

<syntaxhighlight lang="bash">
echo "Hello World"
echo Hello World
echo Ez egy teszt üzenet
echo "Ez egy teszt üzenet"
</syntaxhighlight>

Láthatjuk, hogy idézőjeltől függetlenül minden megjelenik a képernyőn. Észrevehetjük azt is, hogy minden sor végén új sor karakter (enter) található, amit a "-n" kapcsoló segítségével kapcsolhatunk ki.

<syntaxhighlight lang="bash">
echo -n "Hello world"
</syntaxhighlight>

==== cat ====
A '''cat''' utasítás fájlokat képes összefűzni és az eredményt a képernyőre írja ki.

<syntaxhighlight lang="bash">
# /etc/passwd és a /etc/profile fájlok összefűzése a képernyőn (ebben a sorrendben)
cat /etc/passwd /etc/profile
</syntaxhighlight>

Egy gyakoribb felhasználási módja, hogy a fájlok tartalmát a képernyőre vessük - ez esetben nem fűzünk hozzá semmit a fájlhoz.
<syntaxhighlight lang="bash">
# /etc/passwd és a <semmi> összefűzése és megjelenítése a képernyőn
cat /etc/passwd
</syntaxhighlight>

==== head ====
A '''head''' utasítás segítségével a fájlok első N során írhatjuk ki a képernyőre. Alapértelmezetten N=10, így ha csak egy fájlnevet adunk neki, akkor annak legfeljebb 10 sorát fogja kiírni (ha van annyi).

<syntaxhighlight lang="bash">
head /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
head -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
head -5 /etc/passwd
</syntaxhighlight>

==== tail ====
A '''tail''' hasonlóan működik, mint a '''head''', de ez esetben nem a fájl elejéről ír ki N sort, hanem a végéről.
<syntaxhighlight lang="bash">
tail /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
tail -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
tail -5 /etc/passwd
</syntaxhighlight>

==== wc ====
A '''wc''' utasítás segítségével statisztikai adatokat nyerhetünk ki egy fájlból (''word counter''): sorok, szavak, karakterek és bájtok száma.

<syntaxhighlight lang="bash">
wc /etc/passwd
</syntaxhighlight>

Van lehetőségünk szűkíteni a visszaadott adatokat kapcsolók segítségével:
{| class="wikitable" style="margin: 0px auto"
|+
|-
! Rövid kapcsoló !! Hosszú kapcsoló !! Leírás
|-
| -l || --lines || sorok számát adja vissza
|-
| -w || --words || szavak számát adja vissza
|-
| -c || --chars || karakterek számát adja vissza
|-
| || --bytes || bájtok számát adja vissza
|}

<syntaxhighlight lang="bash">
# sorok számát írja ki
wc -l /etc/passwd
# szavak számát írja ki
wc -w /etc/passwd
# bájtok számát írja ki
wc --bytes /etc/passwd

# sorok és szavak számát írja ki a képernyőre
wc -l -w /etc/passwd
</syntaxhighlight>

==== find ====
A '''find''' utasítás segítségével kereshetünk a fájlrendszerben különböző attribútumok alapján.

<syntaxhighlight lang="bash">
# passwd nevű fájl keresése a /etc könyvtárban
find /etc -name passwd
</syntaxhighlight>

=== Programok csatornái ===
==== STDIN ====
==== STDOUT ====
==== STDERR ====

=== Pipeline ===

=== Parancsbehelyettesítés ===
=== Feladatok ===
==== Szedjük ki a ''/etc/passwd'' állomány 20. sorát ====
<syntaxhighlight lang="bash">
# beolvassuk az első 20 sort és levágjuk az utolsót
head -20 /etc/passwd | tail -1
</syntaxhighlight>

==== Mondjuk meg egy keresett bináris típusát ====
<syntaxhighlight lang="bash">
# fájl elérési út lekérdezése
# STDOUT => /bin/ls
which ls

# fájl típusának lekérdezése
file /bin/ls

# rakjuk össze:
file `which ls`
</syntaxhighlight>

== 2. óra ==
A második órát az alap utasításokkal folytatjuk. Utána scriptek írásával foglalkozunk, amelyben megtekintjük a különböző vezérlési szerkezeteket is.

=== Parancsok és példák ===

==== mcedit ====
Az '''mcedit''' az '''mc''' (''Midnight Commander'') szerkesztője. A Midnight Commander testvére a Total Commander ősének, a Volkov Commandernek, ami szintén egy konzolos alkalmazás. A közös gyökerek miatt nagyon hasonló funkcionalitásokat érhetünk el ebben is, mint a TC-ben - érdemes megnyitni az '''mc''' utasítással, amit később az '''F10''' billentyűvel, vagy az alsó sorban arra a gombra kattintással tudunk bezárni. Ebben az alkalmazásban működik az egér is, így kényelmes használatot eredményez. Érdekesség, hogy a "tálcára helyezés" is megoldott, így a '''Ctrl+O''' billentyűkombinációkkal háttérbe küldhetjük és folytathatjuk dolgunkat a terminálon, majd ugyanezzel a kombinációval előtérbe is hívhatjuk.

Az mcedit megnyitható az ''mc''-ből is, a szokásos F4-es billentyűvel - vagy az arra való kattintással.

Az egér az mcedit-ben is működik!

A másolás a szerkesztőben is hasonlóan működik, mint a kétpaneles fájltallózóban: F5 és F6 billentyűkkel másolhatunk illetve áthelyezhetünk sorokat. Kilépni az F10 billentyűvel, ESC-el tudunk, de ezt az ablakot is a háttérbe küldhetjük, ha szerkesztés közben terminált szeretnénk elérni (''CTRL+O'').

<syntaxhighlight lang="bash">
mcedit /etc/passwd
</syntaxhighlight>

==== nano ====
A '''nano''' szintén egy szövegszerkesztő alkalmazás.

Alul láthatjuk a segédletet, hogy milyen kombinációkkal milyen funkcionalitás érhető el. A szükségesebbek:
* CTRL+K segítségével kivághatunk sorokat a vágólapra (shift+kurzorbillentyűk segítségével tört sorok is kijelölhetők)
* CTRL+U Beilleszti a vágólap tartalmát az aktuális sorba
* CTRL+O Menti a változásokat
* CTRL+X Kilép, de megkérdezi, hogy menteni akarunk-e, ha vannak mentetlen változások

<syntaxhighlight lang="bash">
nano /etc/passwd
</syntaxhighlight>

==== chmod ====
==== shift ====
==== cut ====
A '''cut''' parancs segítségével táblázatos adatokat szűrhetünk: kiválaszthatjuk, hogy mely oszlopokat szeretnénk megjeleníteni. A két legfontosabb kapcsolója a ''-f'' (''field''), ahol a megjelenítendő oszlopokat adhatjuk meg és a ''-d'' (''delimiter''), ahol az elválasztó karaktert állíthatjuk be.

Általában a ''/etc/passwd'' állományon dolgozunk, mert ebben egy '':''-al elválasztott táblázat található.

<syntaxhighlight lang="bash">
# a fájl első oszlopát szedi ki :-nál elválasztva,
# tehát a felhasználónevet
cut -f1 -d':' /etc/passwd

# a fájl első és harmadik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet és az id-ját
cut -f1,3 -d':' /etc/passwd

# a fájl első három és hatodik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet, jelszót és a felhasználó id-ját, valamint a home könyvtárát
cut -f1-3,6 -d':' /etc/passwd
</syntaxhighlight>

==== sort ====
A '''sort''' utasítás segítségével rendezhetjük az adattömböt.
<syntaxhighlight lang="bash">
# a passwd állomány rendezése a felhasználónév szerint - ez van elől
sort /etc/passwd
# fordított sorrend - reverse
sort -r /etc/passwd
</syntaxhighlight>

Alapértelmezetten karakterek szerint rendez, tehát a számokat tartalmazó adatsorokat nem helyes sorrendben adja vissza. Ha számérték szerinti rendezést szeretnénk végrehajtani, akkor használjuk a ''-n'' opciót.
<syntaxhighlight lang="bash">
# file egy számokat tartalmazó fájl - egy sor egy fájl
sort -n file
# fordított sorrend
sort -r -n file
</syntaxhighlight>

==== tr ====
A '''tr''' parancs segítségével karaktereket cserélhetünk ki egy fájlban. Ezen kívül nagyon hasznos tulajdonsága, hogy a kívánt ismétlődéseket el tudja távolítani, mintegy megtisztítva az adatsort.
<syntaxhighlight lang="bash">
# az e betűt o-ra, az o betűt e-re cseréli ki
echo "hello" | tr eo oe

# A T betűt K-ra, az n betűt p-re cseréli ki
echo "Tanar" | tr Tn Kp
</syntaxhighlight>
A fenti példák alapján nézzük meg, hogy mi történik:
# A tr két pozicionális paraméterrel lett meghívva
## Az első paraméter adja meg a lecserélendő karakterek halmazát
## A második paraméter adja meg az új karakterek halmazát
# A program végig megy a bemeneten és közben megvizsgálja, hogy az adott karakter megtalálható-e az első paraméterben
## ha megtalálható, akkor lecseréli a karakterrel azonos pozícióban álló második paraméterben található értékre
## ha nincs benne, akkor megy tovább
# a metodika miatt keresztbe is lehet cserélni (pl. ''o''-t ''e''-re, ''e''-t ''o''-ra, mint az első példában). Gondoljuk végig, hogy ha nem így lenne, akkor az először lecserélt ''e'' betűnek a végén ''o'' betűre kéne cserélődnie.

==== if ====
Az '''if''' segítségével elágazásokat hozhatunk létre, mint minden más programozási nyelven. A szerkezet a következőképp néz ki:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
elif KIFEJEZÉS
elif KIFEJEZÉS
else
fi
</syntaxhighlight>

Természetesen az egyes feltételek kihagyhatók, így készíthetünk egy egyszerű '''if''' elágazást is:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
fi
</syntaxhighlight>

Ha egy sorban szeretnénk leírni (nem scriptben), akkor a következőképpen tehetjük meg:
<syntaxhighlight lang="bash">
if KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; elif KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; else UTASÍTÁS; fi
</syntaxhighlight>

<big>'''KIFEJEZÉS'''</big> 
Egy olyan program, amelynek a visszatérési értéke hasznos információkat hordoz a futás eredményét tekintve. Ne feledjük el, hogy a '''return''' kulcsszóval tudunk ilyen értéket generálni C/C++ kódok esetében. Lássunk egy példát:

<syntaxhighlight lang="c">
#include <stdio.h>

int main() {
if ( 10 % 2 == 0 ) return 0;
else return 1;
}
</syntaxhighlight>

A fenti program visszatérési értéke információval szolgál számunkra, hogy a 10 osztható-e kettővel, avagy sem. Ez az érték vizsgálható az '''if''' segítségével és a válasz függvényében más-más kódokat hajthatunk végre.

A kiértékelés ellentétes a megszokott módszerhez képest (ahol minden igaz, aminek az értéke nem 0).
<syntaxhighlight lang="bash">
# ha a KIFEJEZÉS 0 értéket ad vissza, akkor IGAZ az állítás, tehát az if-en belüli kód fut
if KIFEJEZÉS => 0
then
....
else
....
fi

# ha a KIFEJEZÉS nem 0 értéket ad vissza, akkor HAMIS az állítás, tehát az else-n belüli kód fut
if KIFEJEZÉS => != 0
then
...
else
...
fi
</syntaxhighlight>

A programozási nyelvek tanításakor ezért térünk vissza 0-s értékkel ('''return 0;'''), a programunk végén, és hiba esetén 1, vagy annál nagyobb értékkel.

==== test ====
A '''test''' parancs logikai függvényeket értékel ki és
* '''0''' értéket ad vissza, ha az eredmény '''IGAZ''',
* '''1''' értéket ad vissza, ha az eredmény '''HAMIS'''

Az '''if''' utasítással együtt szoktuk használni, de természetesen ettől független is meghívható.
<syntaxhighlight lang="bash">
# megtörténik a logikai kiértékelés, eldől, hogy a két string egyezik-e
test "text1" == "text2"
# kiírjuk a képernyőre a test utasítás visszatérési értékét
echo $?
</syntaxhighlight>

'''if''' utasítással a következőképp használhatjuk:
<syntaxhighlight lang="bash">
# hamis
if test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

# igaz
if ! test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

#igaz
if test "text1" != "text2"
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

Elérhető egy ''alias'', aminek segítségével olvashatóbbá tehetjük a '''test''' utasítást. Ez a '''[ ]''' pár.
<syntaxhighlight lang="bash">
if [ "text1" == "text2" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

'''Ügyeljünk rá, hogy a ''['' és a '']'' zárójelek mellett ''whitespace'' karakterek vannak. Ha ezeket kihagyjuk, akkor hibát fogunk kapni!'''

A számok ellenőrzése BASH környezetben körülményesebb, mivel itt minden karakterláncnak számít. Emiatt a következő utasítás sorozat nem várt eredménnyel zárul:
<syntaxhighlight lang="bash">
if [ "1000" <= "20" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': igaz. De tudjuk, hogy ez az eredmény nem igaz, a BASH mégis így értékelte ki. Az oka, hogy az első karaktereket tekintve (''1'' és ''2'') elmondható, hogy az ''1''-es hamarabb van az ABC-ben (kódtáblában), mint a ''2'', így az ''1000''-nek kisebbnek kell lennie (mintha a "alma" és "körte" lenne összehasonlítva, hogy melyik következik előbb az ABC-ben).

Ahhoz, hogy a '''test''' utasítás karakterek helyett számként dolgozza fel a paramétert, kapcsolót kell használnunk:

{| class="wikitable" style="margin: 0px auto;"
|+
|-
! Kapcsoló !! Angol megnevezés !! Magyar megnevezés
|-
| -eq || Equals || Egyenlő
|-
| -ne || Not Equals || Nem egyenlő
|-
| -lt || Lower than || Kisebb, mint
|-
| -le || Lower than or equals || Kisebb vagy egyenlő
|-
| -gt || Greather than || nagyobb, mint
|-
| -ge || Greather than or equals || Nagyobb vagy egyenlő
|}

<syntaxhighlight lang="bash">
if [ 1000 -le 20 ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': Az elvártaknak megfelelően HAMIS.

==== for ====
A '''for''' utasítás segítségével egy lista elemein mehetünk végig. Hasonlóan működik, mint a modern programozási nyelvekben a ''foreach''.

Legegyszerűbben a következő utasítással tesztelhetjük, ahol a bemeneti listát soronként látjuk viszont a képernyőn:
<syntaxhighlight lang="bash">
for i in 1 2 3 4 5 6
do
echo $i
done
</syntaxhighlight>

Természetesen van lehetőségünk a listát más program kimenetéből kinyerni a parancsbehelyettesítés segítségével:
<syntaxhighlight lang="bash">
for i in `ls`
do
echo $i
done
</syntaxhighlight>

A '''for''' gyakorlatilag a pozicionális paramétereken megy végig, tehát egy lista elem a $1, egy másik listaelem a $2. Tudjuk, hogy ha szóközök között adjuk meg, akkor szóközt is tartalmazhat a paraméterünk. Lássunk egy példát:
<syntaxhighlight lang="bash">
for i in "1 2 3" "4 5 6"
do
echo $i
done
</syntaxhighlight>
Ez esetben a képernyőn két sor jelenik meg: ''1 2 3'' és ''4 5 6''. Azonban a parancsbehelyettesítés nem alkalmaz az idézőjelhez hasonló technikát, tehát azt alkalmazva minden szó (szóközökkel határolt karaktersorozat) új pozicionális paramétert jelent. Lássunk egy az előzőhöz hasonló példát:
<syntaxhighlight lang="bash">
for i in `echo "1 2 3 4 5 6"`
do
echo $i
done
</syntaxhighlight>
Ez esetben hat sor jelenik meg, benne egy-egy számmal, tehát az '''echo "1 2 3 4 5 6"''' kimenetét szóközönként vágta fel.

==== while ====
A '''while''' utasítás, mint minden programozási nyelvben, itt is felfogható úgy, mint egy többször lefutó '''if'''. Éppen ezért a szintaktikájuk megegyezik, csupán a feltételek megírásával kell óvatosan bánnunk, hogy a ciklus mag akkor és addig fusson, ameddig mi azt szeretnénk. A '''while''' ciklusnál ugyanazokat az alkalmazásokat írhatjuk be a '''KIFEJEZÉS''' helyére, mint az '''if''' esetében.

<syntaxhighlight lang="bash">
while KIFEJEZÉS
do
done
</syntaxhighlight>

Például ha azt akarjuk, hogy egy ciklus addig fusson, amíg meg nem jelenik egy fájl a fájlrendszerben, akkor azt a következőképp vezethetjük le:
<syntaxhighlight lang="bash">
# ellenőrzi, hogy a fájl elérhető-e
test -f "file.txt"

# ez esetben egyetlen kísérletet teszünk, de nem várjuk meg, hogy oda kerüljön, amennyiben nincs ott
if test -f "file.txt"
then
echo "a fájl létezik"
else
echo "A fájl nem létezik"
fi

# várakozunk, amíg a feltétel nem lesz igaz, tehát a fájl nem kerül oda
while ! test -f "file.txt"
do
echo "várakozunk"
done
echo "a fájl létezik"

# test parancs helyettesítése []-el
while ! [ -f "file.txt" ]
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

A while ciklusnál érdemes megemlíteni a '''until''' utasítást, ami annyiban tér el, hogy a feltétel kiértékelését invertálni kell - tehát ami igaz a '''while''' esetében, az hamis az '''until''' esetében és fordítva. Így a fenti feladatot megvalósíthatjuk invertálás nélkül, az until utasítással is:

<syntaxhighlight lang="bash">
until test -f "file.txt"
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

==== seq ====
A '''seq''' utasítás egy listát generál számunkra, amelyben a megadott lépésszámmal, a megadott legkisebb értéktől a megadott legnagyobb értékig szerepelnek a számok.

<syntaxhighlight lang="bash">
# számok 1-10-ig
seq 10

# számok 5-10-ig
seq 5 10

# számok 3-tól 10-ig 2-esével
seq 3 2 10
</syntaxhighlight>

A '''seq''' utasítást általában a '''for''' ciklus listájában használjuk, hogy elő tudjuk állítani az indexeket.
<syntaxhighlight lang="bash">
for i in `seq 3 2 10`
do
echo $i
done
</syntaxhighlight>

==== read ====
A '''read''' utasítás segítségével a STDIN-ről kérhetünk be információt változóba/változókba. Ha több változót sorolunk fel, akkor a bemenetet szóközöknél vágja el.
<syntaxhighlight lang="bash">
# beolvasás var-ba
# STDIN => teszt
# var => teszt
# STDIN => teszt szöveg
# var => teszt szöveg
read var

# beolvasás fname és lname változókba
# STDIN => Attila Farkas
# fname => Attila
# lname = Farkas
# STDIN => Attila
# fname => Attila
# lname => <üres>
# STDIN => Attila Farkas OPSYS
# fname => Attila
# lname => Farkas OPSYS
read fname lname

# beolvasás három változóba. Ha a felhasználó az utasításokkal szemben több szót adott meg, akkor így biztosíthatjuk, hogy ne legyen szóköz az első két változóban
# STDIN => Attila Farkas
# fname => Attila
# lname => Farkas
# tmp => <üres>
# STDIN => Attila Farkas OPSYS meg valami más
# fname => Attila
# lname => Farkas
# tmp => OPSYS meg valami más
read fname lname tmp
</syntaxhighlight>

Az utóbbi esetben hibaüzenet is generálható, ha megvizsgáljuk, hogy a ''tmp'' változó értéke üres-e:
<syntaxhighlight lang="bash">
echo -n "Adja meg a teljes nevét: "
read fname lname tmp

# -n => nem üres?
# -z => üres?
if [ -n "$tmp" ]
then
echo "Valamit elhibáztál"
exit 1
fi
</syntaxhighlight>

Ha szeretnénk ellenőrzött bekérést végrehajtani:
<syntaxhighlight lang="bash">
tmp="start value"
while [ -n "$tmp" ]
do
echo -n "Adja meg a teljes nevét FNAME LNAME formátumban: "
read fname lname tmp
if [ -n "$tmp" ]
then
echo "Valamit elrontottál!"
# ez esetben nem lépünk ki, mert bekérjük újra
fi
done
</syntaxhighlight>

==== expr ====
Az '''expr''' parancs segítségével tudunk matematikai műveleteket végrehajtani. Mivel a BASH-ben minden változó karakterlánc, így nem tudunk közöttük műveletet végezni. Az '''expr''' a paramétereket belül számként kezeli. '''Csak egész számokkal tud dolgozni!'''

<syntaxhighlight lang="bash">
# a képernyőre kerül az eredmény
expr 1 + 2
expr 4 * 4

# csak egész számot ír ki
expr 3 / 2
</syntaxhighlight>

Ha tört számokkal kell dolgoznunk, akkor a következőket tehetjük:
# eltávolítjuk a törtrészt
# felszorozzuk 10^n-nel, ahol n a törtrész számjegyeivel egyezik meg (pl. 10.02-t 100-al kell szorozni). Az egész térben elvégzett művelet eredményét később vissza osztjuk ugyanannyival, amennyivel korábban felszoroztuk. '''Ez nem egy egyszerű feladat, hiszen a tört számot egyáltalán nem kezeli az expr, tehát cut, wc és egyéb parancsokkal kell kialakítanunk a számot, ahogy utána szét is kell darabolnunk azt.'''
# Másik környezetet használunk, ahol tudunk számokat is kezelni - '''ez a ZH-n nem elfogadott'''

A lehetőségek közül csak az elsőt, a ZH-n teljes mértékben elfogadott megoldást mutatom be:
<syntaxhighlight lang="bash">
# a 3.4-et és a 1.2-őt kell összeadnunk.

# ennek eredménye 3
echo "3.4" | cut -d'.' -f1

# ennek eredménye 1
echo "1.2" | cut -d'.' -f1

# rakjuk össze
expr `echo "3.4" | cut -d'.' -f1` + `echo "1.2" | cut -d'.' -f1`
</syntaxhighlight>

=== Feladatok parancsokhoz ===
==== Írassuk ki a /etc/passwd több sorát ====
Több választási lehetőségünk van:
* ha a kiírandó sorszámok valamilyen logikát követnek (minden második, harmadik stb.), akkor használhatjuk a '''seq''' utasítást
* ha nincs logika a sorszámokban, akkor kézzel kell elkészítenünk a listát

<big>'''Logikát tartalmazó sorszámok'''</big> 
''Írassuk ki minden harmadik sor tartalmát'' 
<syntaxhighlight lang="bash">
# határozzuk meg a seq tartományát
# min: 1
# max: ahány sora van a fájlnak

# max érték meghatározás
# a változó létrehozást lentebb tárgyaljuk
max=`cat /etc/passwd | wc -l`

# lista meghatározása for ciklushoz
# 1-től $max-ig hármasával
seq 1 3 $max

# Rakjuk össze
for i in `seq 1 3 $max`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

<big>'''Logikát nem tartalmazó sorszámok'''</big> 
''Írassuk ki a 2., 5., 10. és 11. sorokat'' 
<syntaxhighlight lang="bash">
for i in `2 5 10 11`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

==== Fájlok ellenőrzése és másolása ====
Másoljuk át a /etc/passwd állományt egy könyvtárba (~/test/destination). Ha a célkönyvtár nem létezik, akkor hozzuk létre. Ha a célkönyvtár és a fájl is létezik, akkor írjunk ki hibaüzenetet.

<syntaxhighlight lang="bash">
# forrás fájl létezésének vizsgálata
test -f /etc/passwd

# célfájl létezésének vizsgálata
test -f ~/test/destination/passwd

# mappa létezésének vizsgálata
test -d ~/test/destination

# rakjuk össze

# ha a forrásfájl nem létezik
if ! test -f /etc/passwd
then
echo "A forrásfájl nem létezik"
# ha a célfájl létezik
elif test -f ~/test/destination/passwd
then
echo "A fájl már létezik"
# ha a cél mappa nem létezik
elif ! test -d ~/test/destination
then
# mappa létrehozás - szülőkönyvtárakat is, ha nem léteznek
mkdir -p ~/test/destination
# fájl belemásolása
cp /etc/passwd ~/test/destination
# ha a célfájl nem létezik, de a célmappa igen
else
# a fájlt bemásoljuk a könyvtárba
cp /etc/passwd ~/test/destination
fi
</syntaxhighlight>

=== Script létrehozása ===
* Script megírása
* Futási jog

=== Pozicionális paraméterek ===

=== Változók ===

== 3. óra ==
A harmadik órán reguláris nyelvekkel foglalkozunk. A nyelv szintaktikai elemzése után a BASH-ben erre alkalmas szoftvert, a ''grep''-et foguk megvizsgálni.

=== Reguláris kifejezés szerkezete ===
A reguláris nyelvek atomokból, lezártakból épül fel, amelynek az eredménye az úgynevezett „összetettek”.

==== Atomok ====
Az atomok egy karakterre illeszkednek a sorban.
{| class="wikitable" style="margin: 0px auto;"
|-
! Atom !! jelentés
|-
| betűk, számok || saját magukra illeszkednek
|-
| ^ || sor elejére illeszkedik (csak egyszer lehet a legelején)
|-
| $ || sor végére illeszkedik (csak egyszer lehet a legvégén)
|-
| [abc] || halmaz: minden benne lévő elemre illeszkedik
|-
| [^abc] || inverz halmaz: egyetlen benne lévő elemre sem illeszkedik
|-
| . || mindenre illeszkedik
|-
|}

==== Lezártak ====
A lezártak ismétlődéseket fogalmaznak meg egy atomra vonatkozóan. '''Lezárt csak atom után helyezkedhet el!'''
{| class="wikitable" style="margin: 0px auto;"
|-
! Lezárt !! jelentés
|-
| * || az atomot 0 és végtelen között akárhányszor ismételheti
|-
| + || az atomot 1 és végtelen között akárhányszor ismételheti
|-
| ? || az atomot 0 és 1 között akárhányszor ismételheti
|-
| {n} || az atom pontosan n-szer fordul elő egymás mellett
|-
| {n,m} || az atomot n és m között akárhányszor ismételheti
|-
| {n,} || az atomot n és végtelen között akárhányszor ismételheti
|-
| {,m} || az atomot 0 és m között akárhányszor ismételheti
|-
|}

==== Összefűzöttek ====
Az atomok és a lezártak egymás után írt sorozata.
A lezártaknál fontos kitétel volt, hogy csak atom után lehet írni. '''Egy összefűzött újra atomizálható''' a ( ) karakterekkel.
Az összefűzöttek tartalmazhatnak uniót (|), ahol több szabály közül bármelyik megvalósulhat egy sikeres illesztéshez.

=== Parancsok és példák ===
Ez egy teszt szöveg, amin próbálkozunk.
A fenti szöveget alapul véve, a következő reguláris kifejezéseket hozhatjuk létre:
{| class="wikitable" style="margin: 0px auto;"
! Reguláris kifejezés !! Illeszkedik? || Magyarázat
|-
| E || Igen || Van a sorban E betű
|-
| a || Igen || Van a sorban a betű
|-
| b || Nem || Nincs a sorban b betű
|-
| ^E || Igen || A sor elején van az E betű
|-
| ^A || Nem || Nincs a sor elején A betű
|-
| ^e || Nem || nincs a sor elején e betű
|-
| .$ || Igen || Bármilyen karakter lehet a sor végén
|-
| \. || Igen || . van a sor végén
|-
| k$ || Nem || Nincs k a sor végén
|-
| egy || igen || Van a sorban „egy” string
|-
| egység || Nem || Nincs a sorban egység string
|-
| egy* || Igen || eg kötelező, y 0 vagy végtelenszer lehet (egy, egyy, egyyy, egyyyy ...)
|-
| l*egy || Igen || l 0 vagy végtelen, eg kötelező (eg, leg, lleg, llleg, lllleg ...)
|-
| l+egy || Nem || Nincs a szövegben "l+egy" string
|-
| l\+egy || Nem || l 1 vagy végtelen hosszú, egy kötelező (legy, llegy, lllegy, llllegy ...)
|-
| (egy) || Nem || Nincs a sorban "(egy)" string
|-
| $egy$ || Igen || Van a sorban "egy" string
|-
| $egy$* || Igen || Van a sorban legalább 0-szor "egy" string
|-
| $egy$\+ || Igen || Van a sorban legalább 1-szer "egy" string
|-
| $egy$\{2\} || Nem || Nincs a sorban pontosan kétszer "egy" string
|-
| [a-z] || Igen || Vannak benne kisbetűk
|-
| [A-Z] || Igen || Van benne nagy betű
|-
| ^[A-D] || Nem || Nincs a sor elején A-D tartományban betű
|-
| ^[A-Z] || Igen || Nagy betű van a sor elején
|-
| ^[A-Z].*\.$ || Igen || Nagybetűvel kezdőik, középen bármi lehet és ponttal végződik a sor.
|-
| [0-9] || Nem || Nincs számjegy a sorban
|-
| .* || Igen || Mindenre illeszkedik, bármilyen hosszan (üres sorra is)
|-
| ^$ || Nem || Csak az üres sorra illeszkedik
|-
| ^.\+$ || Igen || Mindenre illeszkedik, kivéve az üres sorra
|}

A következő kifejezés szintén illeszkedik:
^[A-Z].*$egy$\|$kettő$.*\.$ => A sor elején nagybetűvel kezdődik, van a közepén valahol benne "egy" vagy "kettő" karakterlánc és ponttal végződik. A köztes karakterek értéke nincs megszabva.

==== grep ====
A '''grep''' utasítás segítségével végezhetünk el reguláris kifejezés, tehát minta illesztést fájlokon. Amennyiben nem adunk meg fájl paramétert, a STDIN csatornát olvassa. Az eredmények a STDOUT-ra íródnak.

{| class="wikitable" style="margin: 0px auto"
|+ Fontosabb kapcsolók
|-
! Rövid név !! Hosszú név !! Magyarázat
|-
| -c || --count || Megszámolja az illeszkedő sorokat
|-
| -o || --only-matching || Csak a mintára illeszkedő részt írja ki (nem a teljes sort)
|-
| -n || --line-number || Megszámozza a sorokat (a fájl alapján, nem a megjelenítés szerint)
|}

===== Példa =====
<syntaxhighlight lang="bash">
# nologin környezetet futtató felhasználók listája a rendszerben
grep "nologin" /etc/passwd
cat /etc/passwd | grep "nologin" # STDIN-en érkező adatok szűrése

# bash környezetet futtató felhasználók listája a rendszerben
grep "bash" /etc/passwd
cat /etc/passwd | grep "bash" # STDIN-en érkező adatok szűrése
</syntaxhighlight>

===== Példa 2 =====
Írjunk egy scriptet, amely a /bin/bash futtatási környezetet kapó felhasználók nevét kiírja a képernyőre.

<syntaxhighlight lang="bash">
#!/bin/bash

# a fájl, amin dolgozunk
file="/etc/passwd"
# a fájl sorainak száma
lines=`cat $file | wc -l`

# végig megyünk a fájl sorain
for i in `seq 1 $lines`; do
# itt kapjuk meg az i. sort
line=`head -$i $file | tail -1`
# kiszedjük a shell környezetet
shell=`echo $line | cut -f7 -d':'`
# ha ez "/bin/bash", akkor kivágjuk a sor első oszlopát, ezt írhatjuk a képernyőre
if test $shell == "/bin/bash"; then
echo $line | cut -f1 -d':'
fi
done
</syntaxhighlight>
A fenti script futási ideje: 0.227s

<syntaxhighlight lang="bash">
#!/bin/bash
# a fájl, amin dolgozunk
file="/etc/passwd"
# szűrjük ki a sorokat, amelyeknek a végén a "/bin/bash" karakterlánc található
# és a kapott eredményhalmaznak vágjuk ki az első oszlopát
# a kapott eredményhalmaz még mindig megfelel a /etc/passwd eredeti formátumának,
# csak a sorok számát csökkentettük a szűrési feltételnek megfelelően!
grep "/bin/bash$" $file | cut -f1 -d':'
</syntaxhighlight>
A fenti script futási ideje: 0.003s

===== MAC cím parser =====
Legyen egy MAC címeket tartalmazó fáljunk - mac-cimek.txt:
<syntaxhighlight lang="bash">
00:0C:42:AB:CD:EF
00:0c:42:ab:cd:ef
00-0C-42-AB-CD-EF
00-0c-42-ab-cd-ef
000c42abcdef
000C42ABCDEF
00:0C:42:AB:CD:EF:AB
00:0C:42:AB:CD:EF:
0G:0C:42:AB:CD:EF
00.0C.42.AB.CD.EF
00:0C:42:AB:CD:EG
</syntaxhighlight>
Ebben a fájlban vannak megfelelő és hibás szintaktikájú címek is. A feladat, hogy készítsünk reguláris kifejezést, amely megjeleníti a helyeseket a képernyőn.

<syntaxhighlight lang="bash">
grep "^$[[:xdigit:]]\{2\}[-:]\?$\{5\}[[:xdigit:]]\{2\}$" mac-cimek.txt
</syntaxhighlight>

Érdekességképp beletehetünk a fájlba a MAC címek elé és/vagy után véletlenszerű (megjeleníthető) karaktereket.
Mit tapasztalunk? Miért?

Távolítsuk el a sor eleje és a sor vége illesztéseket és futtassuk a grep-et a -o kapcsolóval? Mi változik?
//(grep -o "$[[:xdigit:]]\{2\}[-:]\?$\{5\}[[:xdigit:]]\{2\}" mac-cimek.txt)//

== 4. óra ==
A negyedik órán a reguláris kifejezések elkészítését gyakoroljuk különböző példákon keresztül. Főleg scripten belül használjuk.

== 5. óra ==
Az ötödik órán minta ZH feladatsort oldunk meg.

EDU::GAMF::Operációs rendszerek::Gyakorlatok

2024-10-09T12:06:07Z

ApelPro: /* Példa 2 */

== 1. óra ==
Az első óra a tantárgy és annak követelményeinek ismertetésével kezdődik, majd egy-két alap utasítást tekintünk meg. Ezután a programok csatornáival folytatjuk.

=== Parancsok és példák ===
==== man ====
A ''man'' parancs segítségével megtekinthetjük egy-egy alkalmazás, parancs, esetleg külső könyvtár függvényeinek dokumentációját. 

'''Használata:'''
A program neve után írhatjuk, hogy melyik alkalmazás, parancs vagy esetleg külső könyvtár függvényének dokumentációját szeretnénk megtekinteni. Megtekinthetjük ily módon a ''man'' parancs használati útmutatóját is a következő utasítás kiadásával:
<syntaxhighlight lang="bash">
man man
</syntaxhighlight>

Hasonló módon alkalmazhatjuk bármelyik parancsra, amelyek ezen a weboldalon felsorolásra kerültek. Pl. a ''head'' utasítás dokumentációját az alábbi módon érhetjük el
<syntaxhighlight lang="bash">
man head
</syntaxhighlight>

==== ls ====
Érdemes megtekinteni a parancs dokumentációját a ''man ls'' utasítás kiadásával, tisztában legyünk ez elérhető kapcsolókkal és funkciókkal.
Az '''ls''' parancs segítségével listázhatjuk a mappa tartalmát. Alapértelmezetten a '''.''', tehát a jelenlegi könyvtárat listázza.
<syntaxhighlight lang="bash">
# meghívás paraméter nélkül
ls

# meghívás . paraméterrel - ugyanaz az eredmény
ls .
</syntaxhighlight>

A listázni kívánt könyvtár nevét megadhatjuk paraméterben:
<syntaxhighlight lang="bash">
# root könyvtár listázása
ls /

# a /usr/local/bin könyvtár listázása
ls /usr/local/bin
</syntaxhighlight>

Érdemes megjegyezni a hosszú formátumú kiírást, aminek segítségével a fájlrendszer bejegyzések jogosultságait és méretét kérhetjük le.
<syntaxhighlight lang="bash">
# Jelenlegi könyvtárban listáz minden elemet és azok tulajdonságait
ls -l

# A /bin/ls fájl jogosultságainak lekérdezése
ls -l /bin/ls
</syntaxhighlight>

Próbáljuk ki, hogy ha egy mappa nevével futtatjuk le a parancsot, akkor az '''ls''' megnyitja a könyvtárat és annak tartalmát listázza ki.
<syntaxhighlight lang="bash">
# a /bin könyvtár tartalma listázódik, nem a /bin könyvtár maga
ls /bin
</syntaxhighlight>
Ez különösen akkor okoz problémát, ha például az adott könyvtár jogosultságait szeretnénk megtekinteni. Ekkor két választási lehetőségünk adódik:
<syntaxhighlight lang="bash">
# A felette lévő könyvtárat listázzuk és kikeressük a megfelelő bejegyzést
ls / -l

# használjuk a -d kapcsolót, aminek segítségével felszólítjuk az ls-t, hogy ne nyissa meg az adott könyvtárat
# Ekkor a könyvtár listázódik, nem a tartalma
ls -d /bin
</syntaxhighlight>

==== pwd ====
A '''pwd''' parancs segítségével lekérdezhetjük annak a könyvtárnak az abszolút elérési útvonalát, amelyben éppen benne vagyunk.

A parancsot főleg arra használjuk, hogy aktuálisan mellettünk elhelyezett fájlok és könyvtárak abszolút útvonalát ki tudjuk alakítani.

<syntaxhighlight lang="bash">
pwd
</syntaxhighlight>

==== cd ====
A '''cd''' parancs segítségével könyvtárat válthatunk (''changedir''). A cél könyvtár nevét paraméterben kell megadnunk.
<syntaxhighlight lang="bash">
# root könyvtár megnyitása
cd /

# HOME könyvtár megnyitása
# ~ egy alias
cd ~

# /usr/bin megnyitása
cd /usr/bin
</syntaxhighlight>

A hivatkozásoknál, így a ''cd'' esetében is lehetőségünk van relatív és abszolút hivatkozásokat használni:
* Az abszolút hivatkozás / elérési út mindig ''/'' jellel kezdődik. pl.: ''cd /home/'', ''cd /usr/bin''
* A relatív hivatkozás vagy nem rendelkezik kezdőkarakterrel: ''cd home'', ''cd bin'', vagy ''.'' illetve ''..'' karakterekkel kezdődnek.
** A ''.'' könyvtár jelenti az aktuális könyvtárat
** A ''..'' könyvtár jelenti a szülő könyvtárat

<syntaxhighlight lang="bash">
# szülő könyvtár megnyitása
cd ../

# a szülőkönyvtárban található bin könyvtár megnyitása
cd ../bin

# az aktuális könyvtárban található bin könyvtár megnyitása
cd ./bin
cd bin # vegyük észre: a ./ ez esetben elhagyható
</syntaxhighlight>

==== mkdir ====
Az '''mkdir''' parancs segítségével könyvtárakat hozhatunk létre (''make directory''). Alapértelmezetten a ''.'' könyvtáron (tehát ahol éppen tartózkodunk, azon a könyvtáron) belül hozza létre az új mappát, de lehetőségünk van mind relatív, mind abszolút hivatkozások használatára.
<syntaxhighlight lang="bash">
# folder könyvtár létrehozása az aktuális könyvtárban
mkdir folder
mkdir ./folder2
# subfolder létrehozása a folder könyvtáron belül.
mkdir folder/subfolder

# létrehozás a /tmp könyvtáron belül, akárhol is vagyunk
mkdir /tmp/folder

# folder létrehozása a szülőkönyvtárban
mkdir ../folder
</syntaxhighlight>

A fentebb leírtak alapján egyetlen könyvtárat hozhatunk létre, egy már létező könyvtáron belül, legyen az éppen az, amiben tartózkodunk, vagy valahol máshol a fájlrendszerben. Azonban előfordul, hogy egyszerre több mappát szeretnénk elkészíteni, például egy mélyebb struktúrát szeretnénk kialakítani, mint ami a rendelkezésünkre áll. Ezt természetesen megtehetjük úgy, hogy az egyes szinteket egyesével hozzuk létre, de alkalmazhatunk kapcsolót, amelynek segítségével a nem létező szülőkönyvtárakat is létrehozza, amennyiben nem léteznek.
<syntaxhighlight lang="bash">
# root könyvtáron belül létrejön egy ''test'' könyvtár és azon belül jön létre a ''folder'' könyvtár.
mkdir /test/folder/ -p

# az aktuális könyvtárban jön létre egy ''test'' könyvtár és azon belül a ''folder'' könyvtár
mkdir -p test/folder

# a jelenlegi könyvtárban létrejon a ''test'' könyvtár,
# azon belül létrejön egy ''folder1'' és egy ''folder2'' könyvtár,
# majd mind a kettőben létrejön a ''work'' könyvtár.
mkdir -p test/{folder1,folder2}/work
</syntaxhighlight>

Természetesen ahhoz, hogy egy könyvtárban további fájlokat vagy könyvtárakat hozzunk létre jogosultság szükséges.

==== rmdir ====
Az '''rmdir''' parancs segítségével üres könyvtárakat törölhetünk.

'''Figyelem'''! Ha a könyvtár nem üres (fájlok vagy egyéb könyvtárak találhatók benne, akkor hibaüzenetet kapunk és nem csinál semmit!

<syntaxhighlight lang="bash">
# relatív hivatkozással
rmdir test/folder

# abszolút hivatkozással
rmdir /test/folder
</syntaxhighlight>

==== cp ====
A '''cp''' parancs segítségével fájlokat és könyvtárakat másolhatunk a fájlrendszer egy pontjáról a másikra.

<syntaxhighlight lang="bash">
# /etc/passwd fájl lemásolása a jelenlegi könyvtárba - ls paranccsal ellenőrízhető
cp /etc/passwd ./

# /etc/passwd lemásolása a jelenlegi könyvtárba és közben átnevezés file-ra
cp /etc/passwd ./file

# /etc/passwd lemásolása a /tmp könyvtárba
cp /etc/passwd /tmp/

# /etc/passwd lemásolása a /tmp könyvtárba és közben átnevezés file-ra
cp /etc/passwd /tmp/file
</syntaxhighlight>

Könyvtárak másolása esetén a ''-r'' kapcsoló használata szükséges (''recursive'').
<syntaxhighlight lang="bash">
# /etc/network könyvtár és annak tartalmát másolja a /tmp könyvtárba
cp /etc/network /tmp/ -r
</syntaxhighlight>

==== mv ====
Az '''mv''' parancs segítségével fájlokat és könyvtárakat mozgathatunk. Ezzel a paranccsal nevezhetjük át a fájlrendszer elemeit.

A próbálkozáshoz másoljuk le a /etc/passwd állományt, ha eddig nem tettük meg!
<syntaxhighlight lang="bash">
cp /etc/passwd ./
</syntaxhighlight>

<syntaxhighlight lang="bash">
# passwd állomány átnevezése file-ra
mv passwd file

# nem fut le!
# /etc/passwd állomány átnevezése file-ra
mv /etc/passwd /etc/file

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be
mv /etc/passwd /tmp

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be és közben átnevezés file-ra
mv /etc/passwd /tmp/file
</syntaxhighlight>

A könyvtárak áthelyezéséhez (vagy átnevezéséhez) ez esetben nincs szükségünk a ''recursive'' (''-r'') jelölésre.

==== rm ====
Az '''rm''' parancs segítségével fájlokat és könyvtárakat törölhetünk.

<syntaxhighlight lang="bash">
rm file
</syntaxhighlight>

Könyvtárak törléséhez alkalmaznunk kell a rekurzív jelölést: ''-r''.
<syntaxhighlight lang="bash">
rm folder -r
</syntaxhighlight>

==== less ====
A '''less''' egy fájlnézegető, amelynek segítségével lapozhatunk billentyűzet segítségével a fájlokban.

<syntaxhighlight lang="bash">
less /etc/passwd
</syntaxhighlight>

==== more ====
A '''more''' szintén egy fájlnézegető, de ennek segítségével csak előre lapozhatunk, visszafelé nem.

<syntaxhighlight lang="bash">
more /etc/passwd
</syntaxhighlight>

==== which ====
A '''which'' program segítségével lekérdezhetjük, hogy az adott utasításhoz tartozó állomány melyik mappában található.

<syntaxhighlight lang="bash">
# az ls parancs abszolút elérési útvonala
which ls

# a which parancs abszolút elérési útvonala
which which

# a man parancs elérési útvonala
which man
</syntaxhighlight>

==== file ====
A '''file''' utasítás segítségével lekérdezhetjük, hogy egy adott állomány milyen típusú: futtatható állomány (ELF), ASCII stb.

<syntaxhighlight lang="bash">
file /etc/passwd
file /bin/ls
</syntaxhighlight>

==== echo ====
Az '''echo''' mindent kiír a képernyőre, amit parancssori argumentumként adunk át neki.

<syntaxhighlight lang="bash">
echo "Hello World"
echo Hello World
echo Ez egy teszt üzenet
echo "Ez egy teszt üzenet"
</syntaxhighlight>

Láthatjuk, hogy idézőjeltől függetlenül minden megjelenik a képernyőn. Észrevehetjük azt is, hogy minden sor végén új sor karakter (enter) található, amit a "-n" kapcsoló segítségével kapcsolhatunk ki.

<syntaxhighlight lang="bash">
echo -n "Hello world"
</syntaxhighlight>

==== cat ====
A '''cat''' utasítás fájlokat képes összefűzni és az eredményt a képernyőre írja ki.

<syntaxhighlight lang="bash">
# /etc/passwd és a /etc/profile fájlok összefűzése a képernyőn (ebben a sorrendben)
cat /etc/passwd /etc/profile
</syntaxhighlight>

Egy gyakoribb felhasználási módja, hogy a fájlok tartalmát a képernyőre vessük - ez esetben nem fűzünk hozzá semmit a fájlhoz.
<syntaxhighlight lang="bash">
# /etc/passwd és a <semmi> összefűzése és megjelenítése a képernyőn
cat /etc/passwd
</syntaxhighlight>

==== head ====
A '''head''' utasítás segítségével a fájlok első N során írhatjuk ki a képernyőre. Alapértelmezetten N=10, így ha csak egy fájlnevet adunk neki, akkor annak legfeljebb 10 sorát fogja kiírni (ha van annyi).

<syntaxhighlight lang="bash">
head /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
head -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
head -5 /etc/passwd
</syntaxhighlight>

==== tail ====
A '''tail''' hasonlóan működik, mint a '''head''', de ez esetben nem a fájl elejéről ír ki N sort, hanem a végéről.
<syntaxhighlight lang="bash">
tail /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
tail -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
tail -5 /etc/passwd
</syntaxhighlight>

==== wc ====
A '''wc''' utasítás segítségével statisztikai adatokat nyerhetünk ki egy fájlból (''word counter''): sorok, szavak, karakterek és bájtok száma.

<syntaxhighlight lang="bash">
wc /etc/passwd
</syntaxhighlight>

Van lehetőségünk szűkíteni a visszaadott adatokat kapcsolók segítségével:
{| class="wikitable" style="margin: 0px auto"
|+
|-
! Rövid kapcsoló !! Hosszú kapcsoló !! Leírás
|-
| -l || --lines || sorok számát adja vissza
|-
| -w || --words || szavak számát adja vissza
|-
| -c || --chars || karakterek számát adja vissza
|-
| || --bytes || bájtok számát adja vissza
|}

<syntaxhighlight lang="bash">
# sorok számát írja ki
wc -l /etc/passwd
# szavak számát írja ki
wc -w /etc/passwd
# bájtok számát írja ki
wc --bytes /etc/passwd

# sorok és szavak számát írja ki a képernyőre
wc -l -w /etc/passwd
</syntaxhighlight>

==== find ====
A '''find''' utasítás segítségével kereshetünk a fájlrendszerben különböző attribútumok alapján.

<syntaxhighlight lang="bash">
# passwd nevű fájl keresése a /etc könyvtárban
find /etc -name passwd
</syntaxhighlight>

=== Programok csatornái ===
==== STDIN ====
==== STDOUT ====
==== STDERR ====

=== Pipeline ===

=== Parancsbehelyettesítés ===
=== Feladatok ===
==== Szedjük ki a ''/etc/passwd'' állomány 20. sorát ====
<syntaxhighlight lang="bash">
# beolvassuk az első 20 sort és levágjuk az utolsót
head -20 /etc/passwd | tail -1
</syntaxhighlight>

==== Mondjuk meg egy keresett bináris típusát ====
<syntaxhighlight lang="bash">
# fájl elérési út lekérdezése
# STDOUT => /bin/ls
which ls

# fájl típusának lekérdezése
file /bin/ls

# rakjuk össze:
file `which ls`
</syntaxhighlight>

== 2. óra ==
A második órát az alap utasításokkal folytatjuk. Utána scriptek írásával foglalkozunk, amelyben megtekintjük a különböző vezérlési szerkezeteket is.

=== Parancsok és példák ===

==== mcedit ====
Az '''mcedit''' az '''mc''' (''Midnight Commander'') szerkesztője. A Midnight Commander testvére a Total Commander ősének, a Volkov Commandernek, ami szintén egy konzolos alkalmazás. A közös gyökerek miatt nagyon hasonló funkcionalitásokat érhetünk el ebben is, mint a TC-ben - érdemes megnyitni az '''mc''' utasítással, amit később az '''F10''' billentyűvel, vagy az alsó sorban arra a gombra kattintással tudunk bezárni. Ebben az alkalmazásban működik az egér is, így kényelmes használatot eredményez. Érdekesség, hogy a "tálcára helyezés" is megoldott, így a '''Ctrl+O''' billentyűkombinációkkal háttérbe küldhetjük és folytathatjuk dolgunkat a terminálon, majd ugyanezzel a kombinációval előtérbe is hívhatjuk.

Az mcedit megnyitható az ''mc''-ből is, a szokásos F4-es billentyűvel - vagy az arra való kattintással.

Az egér az mcedit-ben is működik!

A másolás a szerkesztőben is hasonlóan működik, mint a kétpaneles fájltallózóban: F5 és F6 billentyűkkel másolhatunk illetve áthelyezhetünk sorokat. Kilépni az F10 billentyűvel, ESC-el tudunk, de ezt az ablakot is a háttérbe küldhetjük, ha szerkesztés közben terminált szeretnénk elérni (''CTRL+O'').

<syntaxhighlight lang="bash">
mcedit /etc/passwd
</syntaxhighlight>

==== nano ====
A '''nano''' szintén egy szövegszerkesztő alkalmazás.

Alul láthatjuk a segédletet, hogy milyen kombinációkkal milyen funkcionalitás érhető el. A szükségesebbek:
* CTRL+K segítségével kivághatunk sorokat a vágólapra (shift+kurzorbillentyűk segítségével tört sorok is kijelölhetők)
* CTRL+U Beilleszti a vágólap tartalmát az aktuális sorba
* CTRL+O Menti a változásokat
* CTRL+X Kilép, de megkérdezi, hogy menteni akarunk-e, ha vannak mentetlen változások

<syntaxhighlight lang="bash">
nano /etc/passwd
</syntaxhighlight>

==== chmod ====
==== shift ====
==== cut ====
A '''cut''' parancs segítségével táblázatos adatokat szűrhetünk: kiválaszthatjuk, hogy mely oszlopokat szeretnénk megjeleníteni. A két legfontosabb kapcsolója a ''-f'' (''field''), ahol a megjelenítendő oszlopokat adhatjuk meg és a ''-d'' (''delimiter''), ahol az elválasztó karaktert állíthatjuk be.

Általában a ''/etc/passwd'' állományon dolgozunk, mert ebben egy '':''-al elválasztott táblázat található.

<syntaxhighlight lang="bash">
# a fájl első oszlopát szedi ki :-nál elválasztva,
# tehát a felhasználónevet
cut -f1 -d':' /etc/passwd

# a fájl első és harmadik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet és az id-ját
cut -f1,3 -d':' /etc/passwd

# a fájl első három és hatodik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet, jelszót és a felhasználó id-ját, valamint a home könyvtárát
cut -f1-3,6 -d':' /etc/passwd
</syntaxhighlight>

==== sort ====
A '''sort''' utasítás segítségével rendezhetjük az adattömböt.
<syntaxhighlight lang="bash">
# a passwd állomány rendezése a felhasználónév szerint - ez van elől
sort /etc/passwd
# fordított sorrend - reverse
sort -r /etc/passwd
</syntaxhighlight>

Alapértelmezetten karakterek szerint rendez, tehát a számokat tartalmazó adatsorokat nem helyes sorrendben adja vissza. Ha számérték szerinti rendezést szeretnénk végrehajtani, akkor használjuk a ''-n'' opciót.
<syntaxhighlight lang="bash">
# file egy számokat tartalmazó fájl - egy sor egy fájl
sort -n file
# fordított sorrend
sort -r -n file
</syntaxhighlight>

==== tr ====
A '''tr''' parancs segítségével karaktereket cserélhetünk ki egy fájlban. Ezen kívül nagyon hasznos tulajdonsága, hogy a kívánt ismétlődéseket el tudja távolítani, mintegy megtisztítva az adatsort.
<syntaxhighlight lang="bash">
# az e betűt o-ra, az o betűt e-re cseréli ki
echo "hello" | tr eo oe

# A T betűt K-ra, az n betűt p-re cseréli ki
echo "Tanar" | tr Tn Kp
</syntaxhighlight>
A fenti példák alapján nézzük meg, hogy mi történik:
# A tr két pozicionális paraméterrel lett meghívva
## Az első paraméter adja meg a lecserélendő karakterek halmazát
## A második paraméter adja meg az új karakterek halmazát
# A program végig megy a bemeneten és közben megvizsgálja, hogy az adott karakter megtalálható-e az első paraméterben
## ha megtalálható, akkor lecseréli a karakterrel azonos pozícióban álló második paraméterben található értékre
## ha nincs benne, akkor megy tovább
# a metodika miatt keresztbe is lehet cserélni (pl. ''o''-t ''e''-re, ''e''-t ''o''-ra, mint az első példában). Gondoljuk végig, hogy ha nem így lenne, akkor az először lecserélt ''e'' betűnek a végén ''o'' betűre kéne cserélődnie.

==== if ====
Az '''if''' segítségével elágazásokat hozhatunk létre, mint minden más programozási nyelven. A szerkezet a következőképp néz ki:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
elif KIFEJEZÉS
elif KIFEJEZÉS
else
fi
</syntaxhighlight>

Természetesen az egyes feltételek kihagyhatók, így készíthetünk egy egyszerű '''if''' elágazást is:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
fi
</syntaxhighlight>

Ha egy sorban szeretnénk leírni (nem scriptben), akkor a következőképpen tehetjük meg:
<syntaxhighlight lang="bash">
if KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; elif KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; else UTASÍTÁS; fi
</syntaxhighlight>

<big>'''KIFEJEZÉS'''</big> 
Egy olyan program, amelynek a visszatérési értéke hasznos információkat hordoz a futás eredményét tekintve. Ne feledjük el, hogy a '''return''' kulcsszóval tudunk ilyen értéket generálni C/C++ kódok esetében. Lássunk egy példát:

<syntaxhighlight lang="c">
#include <stdio.h>

int main() {
if ( 10 % 2 == 0 ) return 0;
else return 1;
}
</syntaxhighlight>

A fenti program visszatérési értéke információval szolgál számunkra, hogy a 10 osztható-e kettővel, avagy sem. Ez az érték vizsgálható az '''if''' segítségével és a válasz függvényében más-más kódokat hajthatunk végre.

A kiértékelés ellentétes a megszokott módszerhez képest (ahol minden igaz, aminek az értéke nem 0).
<syntaxhighlight lang="bash">
# ha a KIFEJEZÉS 0 értéket ad vissza, akkor IGAZ az állítás, tehát az if-en belüli kód fut
if KIFEJEZÉS => 0
then
....
else
....
fi

# ha a KIFEJEZÉS nem 0 értéket ad vissza, akkor HAMIS az állítás, tehát az else-n belüli kód fut
if KIFEJEZÉS => != 0
then
...
else
...
fi
</syntaxhighlight>

A programozási nyelvek tanításakor ezért térünk vissza 0-s értékkel ('''return 0;'''), a programunk végén, és hiba esetén 1, vagy annál nagyobb értékkel.

==== test ====
A '''test''' parancs logikai függvényeket értékel ki és
* '''0''' értéket ad vissza, ha az eredmény '''IGAZ''',
* '''1''' értéket ad vissza, ha az eredmény '''HAMIS'''

Az '''if''' utasítással együtt szoktuk használni, de természetesen ettől független is meghívható.
<syntaxhighlight lang="bash">
# megtörténik a logikai kiértékelés, eldől, hogy a két string egyezik-e
test "text1" == "text2"
# kiírjuk a képernyőre a test utasítás visszatérési értékét
echo $?
</syntaxhighlight>

'''if''' utasítással a következőképp használhatjuk:
<syntaxhighlight lang="bash">
# hamis
if test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

# igaz
if ! test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

#igaz
if test "text1" != "text2"
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

Elérhető egy ''alias'', aminek segítségével olvashatóbbá tehetjük a '''test''' utasítást. Ez a '''[ ]''' pár.
<syntaxhighlight lang="bash">
if [ "text1" == "text2" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

'''Ügyeljünk rá, hogy a ''['' és a '']'' zárójelek mellett ''whitespace'' karakterek vannak. Ha ezeket kihagyjuk, akkor hibát fogunk kapni!'''

A számok ellenőrzése BASH környezetben körülményesebb, mivel itt minden karakterláncnak számít. Emiatt a következő utasítás sorozat nem várt eredménnyel zárul:
<syntaxhighlight lang="bash">
if [ "1000" <= "20" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': igaz. De tudjuk, hogy ez az eredmény nem igaz, a BASH mégis így értékelte ki. Az oka, hogy az első karaktereket tekintve (''1'' és ''2'') elmondható, hogy az ''1''-es hamarabb van az ABC-ben (kódtáblában), mint a ''2'', így az ''1000''-nek kisebbnek kell lennie (mintha a "alma" és "körte" lenne összehasonlítva, hogy melyik következik előbb az ABC-ben).

Ahhoz, hogy a '''test''' utasítás karakterek helyett számként dolgozza fel a paramétert, kapcsolót kell használnunk:

{| class="wikitable" style="margin: 0px auto;"
|+
|-
! Kapcsoló !! Angol megnevezés !! Magyar megnevezés
|-
| -eq || Equals || Egyenlő
|-
| -ne || Not Equals || Nem egyenlő
|-
| -lt || Lower than || Kisebb, mint
|-
| -le || Lower than or equals || Kisebb vagy egyenlő
|-
| -gt || Greather than || nagyobb, mint
|-
| -ge || Greather than or equals || Nagyobb vagy egyenlő
|}

<syntaxhighlight lang="bash">
if [ 1000 -le 20 ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': Az elvártaknak megfelelően HAMIS.

==== for ====
A '''for''' utasítás segítségével egy lista elemein mehetünk végig. Hasonlóan működik, mint a modern programozási nyelvekben a ''foreach''.

Legegyszerűbben a következő utasítással tesztelhetjük, ahol a bemeneti listát soronként látjuk viszont a képernyőn:
<syntaxhighlight lang="bash">
for i in 1 2 3 4 5 6
do
echo $i
done
</syntaxhighlight>

Természetesen van lehetőségünk a listát más program kimenetéből kinyerni a parancsbehelyettesítés segítségével:
<syntaxhighlight lang="bash">
for i in `ls`
do
echo $i
done
</syntaxhighlight>

A '''for''' gyakorlatilag a pozicionális paramétereken megy végig, tehát egy lista elem a $1, egy másik listaelem a $2. Tudjuk, hogy ha szóközök között adjuk meg, akkor szóközt is tartalmazhat a paraméterünk. Lássunk egy példát:
<syntaxhighlight lang="bash">
for i in "1 2 3" "4 5 6"
do
echo $i
done
</syntaxhighlight>
Ez esetben a képernyőn két sor jelenik meg: ''1 2 3'' és ''4 5 6''. Azonban a parancsbehelyettesítés nem alkalmaz az idézőjelhez hasonló technikát, tehát azt alkalmazva minden szó (szóközökkel határolt karaktersorozat) új pozicionális paramétert jelent. Lássunk egy az előzőhöz hasonló példát:
<syntaxhighlight lang="bash">
for i in `echo "1 2 3 4 5 6"`
do
echo $i
done
</syntaxhighlight>
Ez esetben hat sor jelenik meg, benne egy-egy számmal, tehát az '''echo "1 2 3 4 5 6"''' kimenetét szóközönként vágta fel.

==== while ====
A '''while''' utasítás, mint minden programozási nyelvben, itt is felfogható úgy, mint egy többször lefutó '''if'''. Éppen ezért a szintaktikájuk megegyezik, csupán a feltételek megírásával kell óvatosan bánnunk, hogy a ciklus mag akkor és addig fusson, ameddig mi azt szeretnénk. A '''while''' ciklusnál ugyanazokat az alkalmazásokat írhatjuk be a '''KIFEJEZÉS''' helyére, mint az '''if''' esetében.

<syntaxhighlight lang="bash">
while KIFEJEZÉS
do
done
</syntaxhighlight>

Például ha azt akarjuk, hogy egy ciklus addig fusson, amíg meg nem jelenik egy fájl a fájlrendszerben, akkor azt a következőképp vezethetjük le:
<syntaxhighlight lang="bash">
# ellenőrzi, hogy a fájl elérhető-e
test -f "file.txt"

# ez esetben egyetlen kísérletet teszünk, de nem várjuk meg, hogy oda kerüljön, amennyiben nincs ott
if test -f "file.txt"
then
echo "a fájl létezik"
else
echo "A fájl nem létezik"
fi

# várakozunk, amíg a feltétel nem lesz igaz, tehát a fájl nem kerül oda
while ! test -f "file.txt"
do
echo "várakozunk"
done
echo "a fájl létezik"

# test parancs helyettesítése []-el
while ! [ -f "file.txt" ]
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

A while ciklusnál érdemes megemlíteni a '''until''' utasítást, ami annyiban tér el, hogy a feltétel kiértékelését invertálni kell - tehát ami igaz a '''while''' esetében, az hamis az '''until''' esetében és fordítva. Így a fenti feladatot megvalósíthatjuk invertálás nélkül, az until utasítással is:

<syntaxhighlight lang="bash">
until test -f "file.txt"
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

==== seq ====
A '''seq''' utasítás egy listát generál számunkra, amelyben a megadott lépésszámmal, a megadott legkisebb értéktől a megadott legnagyobb értékig szerepelnek a számok.

<syntaxhighlight lang="bash">
# számok 1-10-ig
seq 10

# számok 5-10-ig
seq 5 10

# számok 3-tól 10-ig 2-esével
seq 3 2 10
</syntaxhighlight>

A '''seq''' utasítást általában a '''for''' ciklus listájában használjuk, hogy elő tudjuk állítani az indexeket.
<syntaxhighlight lang="bash">
for i in `seq 3 2 10`
do
echo $i
done
</syntaxhighlight>

==== read ====
A '''read''' utasítás segítségével a STDIN-ről kérhetünk be információt változóba/változókba. Ha több változót sorolunk fel, akkor a bemenetet szóközöknél vágja el.
<syntaxhighlight lang="bash">
# beolvasás var-ba
# STDIN => teszt
# var => teszt
# STDIN => teszt szöveg
# var => teszt szöveg
read var

# beolvasás fname és lname változókba
# STDIN => Attila Farkas
# fname => Attila
# lname = Farkas
# STDIN => Attila
# fname => Attila
# lname => <üres>
# STDIN => Attila Farkas OPSYS
# fname => Attila
# lname => Farkas OPSYS
read fname lname

# beolvasás három változóba. Ha a felhasználó az utasításokkal szemben több szót adott meg, akkor így biztosíthatjuk, hogy ne legyen szóköz az első két változóban
# STDIN => Attila Farkas
# fname => Attila
# lname => Farkas
# tmp => <üres>
# STDIN => Attila Farkas OPSYS meg valami más
# fname => Attila
# lname => Farkas
# tmp => OPSYS meg valami más
read fname lname tmp
</syntaxhighlight>

Az utóbbi esetben hibaüzenet is generálható, ha megvizsgáljuk, hogy a ''tmp'' változó értéke üres-e:
<syntaxhighlight lang="bash">
echo -n "Adja meg a teljes nevét: "
read fname lname tmp

# -n => nem üres?
# -z => üres?
if [ -n "$tmp" ]
then
echo "Valamit elhibáztál"
exit 1
fi
</syntaxhighlight>

Ha szeretnénk ellenőrzött bekérést végrehajtani:
<syntaxhighlight lang="bash">
tmp="start value"
while [ -n "$tmp" ]
do
echo -n "Adja meg a teljes nevét FNAME LNAME formátumban: "
read fname lname tmp
if [ -n "$tmp" ]
then
echo "Valamit elrontottál!"
# ez esetben nem lépünk ki, mert bekérjük újra
fi
done
</syntaxhighlight>

==== expr ====
Az '''expr''' parancs segítségével tudunk matematikai műveleteket végrehajtani. Mivel a BASH-ben minden változó karakterlánc, így nem tudunk közöttük műveletet végezni. Az '''expr''' a paramétereket belül számként kezeli. '''Csak egész számokkal tud dolgozni!'''

<syntaxhighlight lang="bash">
# a képernyőre kerül az eredmény
expr 1 + 2
expr 4 * 4

# csak egész számot ír ki
expr 3 / 2
</syntaxhighlight>

Ha tört számokkal kell dolgoznunk, akkor a következőket tehetjük:
# eltávolítjuk a törtrészt
# felszorozzuk 10^n-nel, ahol n a törtrész számjegyeivel egyezik meg (pl. 10.02-t 100-al kell szorozni). Az egész térben elvégzett művelet eredményét később vissza osztjuk ugyanannyival, amennyivel korábban felszoroztuk. '''Ez nem egy egyszerű feladat, hiszen a tört számot egyáltalán nem kezeli az expr, tehát cut, wc és egyéb parancsokkal kell kialakítanunk a számot, ahogy utána szét is kell darabolnunk azt.'''
# Másik környezetet használunk, ahol tudunk számokat is kezelni - '''ez a ZH-n nem elfogadott'''

A lehetőségek közül csak az elsőt, a ZH-n teljes mértékben elfogadott megoldást mutatom be:
<syntaxhighlight lang="bash">
# a 3.4-et és a 1.2-őt kell összeadnunk.

# ennek eredménye 3
echo "3.4" | cut -d'.' -f1

# ennek eredménye 1
echo "1.2" | cut -d'.' -f1

# rakjuk össze
expr `echo "3.4" | cut -d'.' -f1` + `echo "1.2" | cut -d'.' -f1`
</syntaxhighlight>

=== Feladatok parancsokhoz ===
==== Írassuk ki a /etc/passwd több sorát ====
Több választási lehetőségünk van:
* ha a kiírandó sorszámok valamilyen logikát követnek (minden második, harmadik stb.), akkor használhatjuk a '''seq''' utasítást
* ha nincs logika a sorszámokban, akkor kézzel kell elkészítenünk a listát

<big>'''Logikát tartalmazó sorszámok'''</big> 
''Írassuk ki minden harmadik sor tartalmát'' 
<syntaxhighlight lang="bash">
# határozzuk meg a seq tartományát
# min: 1
# max: ahány sora van a fájlnak

# max érték meghatározás
# a változó létrehozást lentebb tárgyaljuk
max=`cat /etc/passwd | wc -l`

# lista meghatározása for ciklushoz
# 1-től $max-ig hármasával
seq 1 3 $max

# Rakjuk össze
for i in `seq 1 3 $max`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

<big>'''Logikát nem tartalmazó sorszámok'''</big> 
''Írassuk ki a 2., 5., 10. és 11. sorokat'' 
<syntaxhighlight lang="bash">
for i in `2 5 10 11`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

==== Fájlok ellenőrzése és másolása ====
Másoljuk át a /etc/passwd állományt egy könyvtárba (~/test/destination). Ha a célkönyvtár nem létezik, akkor hozzuk létre. Ha a célkönyvtár és a fájl is létezik, akkor írjunk ki hibaüzenetet.

<syntaxhighlight lang="bash">
# forrás fájl létezésének vizsgálata
test -f /etc/passwd

# célfájl létezésének vizsgálata
test -f ~/test/destination/passwd

# mappa létezésének vizsgálata
test -d ~/test/destination

# rakjuk össze

# ha a forrásfájl nem létezik
if ! test -f /etc/passwd
then
echo "A forrásfájl nem létezik"
# ha a célfájl létezik
elif test -f ~/test/destination/passwd
then
echo "A fájl már létezik"
# ha a cél mappa nem létezik
elif ! test -d ~/test/destination
then
# mappa létrehozás - szülőkönyvtárakat is, ha nem léteznek
mkdir -p ~/test/destination
# fájl belemásolása
cp /etc/passwd ~/test/destination
# ha a célfájl nem létezik, de a célmappa igen
else
# a fájlt bemásoljuk a könyvtárba
cp /etc/passwd ~/test/destination
fi
</syntaxhighlight>

=== Script létrehozása ===
* Script megírása
* Futási jog

=== Pozicionális paraméterek ===

=== Változók ===

== 3. óra ==
A harmadik órán reguláris nyelvekkel foglalkozunk. A nyelv szintaktikai elemzése után a BASH-ben erre alkalmas szoftvert, a ''grep''-et foguk megvizsgálni.

=== Reguláris kifejezés szerkezete ===
A reguláris nyelvek atomokból, lezártakból épül fel, amelynek az eredménye az úgynevezett „összetettek”.

==== Atomok ====
Az atomok egy karakterre illeszkednek a sorban.
{| class="wikitable" style="margin: 0px auto;"
|-
! Atom !! jelentés
|-
| betűk, számok || saját magukra illeszkednek
|-
| ^ || sor elejére illeszkedik (csak egyszer lehet a legelején)
|-
| $ || sor végére illeszkedik (csak egyszer lehet a legvégén)
|-
| [abc] || halmaz: minden benne lévő elemre illeszkedik
|-
| [^abc] || inverz halmaz: egyetlen benne lévő elemre sem illeszkedik
|-
| . || mindenre illeszkedik
|-
|}

==== Lezártak ====
A lezártak ismétlődéseket fogalmaznak meg egy atomra vonatkozóan. '''Lezárt csak atom után helyezkedhet el!'''
{| class="wikitable" style="margin: 0px auto;"
|-
! Lezárt !! jelentés
|-
| * || az atomot 0 és végtelen között akárhányszor ismételheti
|-
| + || az atomot 1 és végtelen között akárhányszor ismételheti
|-
| ? || az atomot 0 és 1 között akárhányszor ismételheti
|-
| {n} || az atom pontosan n-szer fordul elő egymás mellett
|-
| {n,m} || az atomot n és m között akárhányszor ismételheti
|-
| {n,} || az atomot n és végtelen között akárhányszor ismételheti
|-
| {,m} || az atomot 0 és m között akárhányszor ismételheti
|-
|}

==== Összefűzöttek ====
Az atomok és a lezártak egymás után írt sorozata.
A lezártaknál fontos kitétel volt, hogy csak atom után lehet írni. '''Egy összefűzött újra atomizálható''' a ( ) karakterekkel.
Az összefűzöttek tartalmazhatnak uniót (|), ahol több szabály közül bármelyik megvalósulhat egy sikeres illesztéshez.

=== Parancsok és példák ===
Ez egy teszt szöveg, amin próbálkozunk.
A fenti szöveget alapul véve, a következő reguláris kifejezéseket hozhatjuk létre:
{| class="wikitable" style="margin: 0px auto;"
! Reguláris kifejezés !! Illeszkedik? || Magyarázat
|-
| E || Igen || Van a sorban E betű
|-
| a || Igen || Van a sorban a betű
|-
| b || Nem || Nincs a sorban b betű
|-
| ^E || Igen || A sor elején van az E betű
|-
| ^A || Nem || Nincs a sor elején A betű
|-
| ^e || Nem || nincs a sor elején e betű
|-
| .$ || Igen || Bármilyen karakter lehet a sor végén
|-
| \. || Igen || . van a sor végén
|-
| k$ || Nem || Nincs k a sor végén
|-
| egy || igen || Van a sorban „egy” string
|-
| egység || Nem || Nincs a sorban egység string
|-
| egy* || Igen || eg kötelező, y 0 vagy végtelenszer lehet (egy, egyy, egyyy, egyyyy ...)
|-
| l*egy || Igen || l 0 vagy végtelen, eg kötelező (eg, leg, lleg, llleg, lllleg ...)
|-
| l+egy || Nem || Nincs a szövegben "l+egy" string
|-
| l\+egy || Nem || l 1 vagy végtelen hosszú, egy kötelező (legy, llegy, lllegy, llllegy ...)
|-
| (egy) || Nem || Nincs a sorban "(egy)" string
|-
| $egy$ || Igen || Van a sorban "egy" string
|-
| $egy$* || Igen || Van a sorban legalább 0-szor "egy" string
|-
| $egy$\+ || Igen || Van a sorban legalább 1-szer "egy" string
|-
| $egy$\{2\} || Nem || Nincs a sorban pontosan kétszer "egy" string
|-
| [a-z] || Igen || Vannak benne kisbetűk
|-
| [A-Z] || Igen || Van benne nagy betű
|-
| ^[A-D] || Nem || Nincs a sor elején A-D tartományban betű
|-
| ^[A-Z] || Igen || Nagy betű van a sor elején
|-
| ^[A-Z].*\.$ || Igen || Nagybetűvel kezdőik, középen bármi lehet és ponttal végződik a sor.
|-
| [0-9] || Nem || Nincs számjegy a sorban
|-
| .* || Igen || Mindenre illeszkedik, bármilyen hosszan (üres sorra is)
|-
| ^$ || Nem || Csak az üres sorra illeszkedik
|-
| ^.\+$ || Igen || Mindenre illeszkedik, kivéve az üres sorra
|}

A következő kifejezés szintén illeszkedik:
^[A-Z].*$egy$\|$kettő$.*\.$ => A sor elején nagybetűvel kezdődik, van a közepén valahol benne "egy" vagy "kettő" karakterlánc és ponttal végződik. A köztes karakterek értéke nincs megszabva.

==== grep ====
A '''grep''' utasítás segítségével végezhetünk el reguláris kifejezés, tehát minta illesztést fájlokon. Amennyiben nem adunk meg fájl paramétert, a STDIN csatornát olvassa. Az eredmények a STDOUT-ra íródnak.

{| class="wikitable" style="margin: 0px auto"
|+ Fontosabb kapcsolók
|-
! Rövid név !! Hosszú név !! Magyarázat
|-
| -c || --count || Megszámolja az illeszkedő sorokat
|-
| -o || --only-matching || Csak a mintára illeszkedő részt írja ki (nem a teljes sort)
|-
| -n || --line-number || Megszámozza a sorokat (a fájl alapján, nem a megjelenítés szerint)
|}

===== Példa =====
<syntaxhighlight lang="bash">
# nologin környezetet futtató felhasználók listája a rendszerben
grep "nologin" /etc/passwd
cat /etc/passwd | grep "nologin" # STDIN-en érkező adatok szűrése

# bash környezetet futtató felhasználók listája a rendszerben
grep "bash" /etc/passwd
cat /etc/passwd | grep "bash" # STDIN-en érkező adatok szűrése
</syntaxhighlight>

===== Példa 2 =====
Írjunk egy scriptet, amely a /bin/bash futtatási környezetet kapó felhasználók nevét kiírja a képernyőre.

<syntaxhighlight lang="bash">
#!/bin/bash

# a fájl, amin dolgozunk
file="/etc/passwd"
# a fájl sorainak száma
lines=`cat $file | wc -l`

# végig megyünk a fájl sorain
for i in `seq 1 $lines`; do
# itt kapjuk meg az i. sort
line=`head -$i $file | tail -1`
# kiszedjük a shell környezetet
shell=`echo $line | cut -f7 -d':'`
# ha ez "/bin/bash", akkor kivágjuk a sor első oszlopát, ezt írhatjuk a képernyőre
if test $shell == "/bin/bash"; then
echo $line | cut -f1 -d':'
fi
done
</syntaxhighlight>
A fenti script futási ideje: 0.227s

<syntaxhighlight lang="bash">
#!/bin/bash
# a fájl, amin dolgozunk
file="/etc/passwd"
# szűrjük ki a sorokat, amelyeknek a végén a "/bin/bash" karakterlánc található
# és a kapott eredményhalmaznak vágjuk ki az első oszlopát
# a kapott eredményhalmaz még mindig megfelel a /etc/passwd eredeti formátumának,
# csak a sorok számát csökkentettük a szűrési feltételnek megfelelően!
grep "/bin/bash$" $file | cut -f1 -d':'
</syntaxhighlight>
A fenti script futási ideje: 0.003s

===== MAC cím parser =====
Legyen egy MAC címeket tartalmazó fáljunk - mac-cimek.txt:
<syntaxhighlight lang="bash">
00:0C:42:AB:CD:EF
00:0c:42:ab:cd:ef
00-0C-42-AB-CD-EF
00-0c-42-ab-cd-ef
000c42abcdef
000C42ABCDEF
00:0C:42:AB:CD:EF:AB
00:0C:42:AB:CD:EF:
0G:0C:42:AB:CD:EF
00.0C.42.AB.CD.EF
00:0C:42:AB:CD:EG
</syntaxhighlight>
Ebben a fájlban vannak megfelelő és hibás szintaktikájú címek is. A feladat, hogy készítsünk reguláris kifejezést, amely megjeleníti a helyeseket a képernyőn.

<syntaxhighlight lang="bash">
grep "^$[[:xdigit:]]\{2\}[-:]\?$\{5\}[[:xdigit:]]\{2\}$" mac-cimek.txt
</syntaxhighlight>

Érdekességképp beletehetünk a fájlba a MAC címek elé és/vagy után véletlenszerű (megjeleníthető) karaktereket. Mit tapasztalunk? Miért?
Próbáljuk ki a -o kapcsolót? Mi változik?

== 4. óra ==
A negyedik órán a reguláris kifejezések elkészítését gyakoroljuk különböző példákon keresztül. Főleg scripten belül használjuk.

== 5. óra ==
Az ötödik órán minta ZH feladatsort oldunk meg.

EDU::GAMF::Operációs rendszerek::Gyakorlatok

2024-10-09T11:53:23Z

ApelPro: /* Példa 2 */

== 1. óra ==
Az első óra a tantárgy és annak követelményeinek ismertetésével kezdődik, majd egy-két alap utasítást tekintünk meg. Ezután a programok csatornáival folytatjuk.

=== Parancsok és példák ===
==== man ====
A ''man'' parancs segítségével megtekinthetjük egy-egy alkalmazás, parancs, esetleg külső könyvtár függvényeinek dokumentációját. 

'''Használata:'''
A program neve után írhatjuk, hogy melyik alkalmazás, parancs vagy esetleg külső könyvtár függvényének dokumentációját szeretnénk megtekinteni. Megtekinthetjük ily módon a ''man'' parancs használati útmutatóját is a következő utasítás kiadásával:
<syntaxhighlight lang="bash">
man man
</syntaxhighlight>

Hasonló módon alkalmazhatjuk bármelyik parancsra, amelyek ezen a weboldalon felsorolásra kerültek. Pl. a ''head'' utasítás dokumentációját az alábbi módon érhetjük el
<syntaxhighlight lang="bash">
man head
</syntaxhighlight>

==== ls ====
Érdemes megtekinteni a parancs dokumentációját a ''man ls'' utasítás kiadásával, tisztában legyünk ez elérhető kapcsolókkal és funkciókkal.
Az '''ls''' parancs segítségével listázhatjuk a mappa tartalmát. Alapértelmezetten a '''.''', tehát a jelenlegi könyvtárat listázza.
<syntaxhighlight lang="bash">
# meghívás paraméter nélkül
ls

# meghívás . paraméterrel - ugyanaz az eredmény
ls .
</syntaxhighlight>

A listázni kívánt könyvtár nevét megadhatjuk paraméterben:
<syntaxhighlight lang="bash">
# root könyvtár listázása
ls /

# a /usr/local/bin könyvtár listázása
ls /usr/local/bin
</syntaxhighlight>

Érdemes megjegyezni a hosszú formátumú kiírást, aminek segítségével a fájlrendszer bejegyzések jogosultságait és méretét kérhetjük le.
<syntaxhighlight lang="bash">
# Jelenlegi könyvtárban listáz minden elemet és azok tulajdonságait
ls -l

# A /bin/ls fájl jogosultságainak lekérdezése
ls -l /bin/ls
</syntaxhighlight>

Próbáljuk ki, hogy ha egy mappa nevével futtatjuk le a parancsot, akkor az '''ls''' megnyitja a könyvtárat és annak tartalmát listázza ki.
<syntaxhighlight lang="bash">
# a /bin könyvtár tartalma listázódik, nem a /bin könyvtár maga
ls /bin
</syntaxhighlight>
Ez különösen akkor okoz problémát, ha például az adott könyvtár jogosultságait szeretnénk megtekinteni. Ekkor két választási lehetőségünk adódik:
<syntaxhighlight lang="bash">
# A felette lévő könyvtárat listázzuk és kikeressük a megfelelő bejegyzést
ls / -l

# használjuk a -d kapcsolót, aminek segítségével felszólítjuk az ls-t, hogy ne nyissa meg az adott könyvtárat
# Ekkor a könyvtár listázódik, nem a tartalma
ls -d /bin
</syntaxhighlight>

==== pwd ====
A '''pwd''' parancs segítségével lekérdezhetjük annak a könyvtárnak az abszolút elérési útvonalát, amelyben éppen benne vagyunk.

A parancsot főleg arra használjuk, hogy aktuálisan mellettünk elhelyezett fájlok és könyvtárak abszolút útvonalát ki tudjuk alakítani.

<syntaxhighlight lang="bash">
pwd
</syntaxhighlight>

==== cd ====
A '''cd''' parancs segítségével könyvtárat válthatunk (''changedir''). A cél könyvtár nevét paraméterben kell megadnunk.
<syntaxhighlight lang="bash">
# root könyvtár megnyitása
cd /

# HOME könyvtár megnyitása
# ~ egy alias
cd ~

# /usr/bin megnyitása
cd /usr/bin
</syntaxhighlight>

A hivatkozásoknál, így a ''cd'' esetében is lehetőségünk van relatív és abszolút hivatkozásokat használni:
* Az abszolút hivatkozás / elérési út mindig ''/'' jellel kezdődik. pl.: ''cd /home/'', ''cd /usr/bin''
* A relatív hivatkozás vagy nem rendelkezik kezdőkarakterrel: ''cd home'', ''cd bin'', vagy ''.'' illetve ''..'' karakterekkel kezdődnek.
** A ''.'' könyvtár jelenti az aktuális könyvtárat
** A ''..'' könyvtár jelenti a szülő könyvtárat

<syntaxhighlight lang="bash">
# szülő könyvtár megnyitása
cd ../

# a szülőkönyvtárban található bin könyvtár megnyitása
cd ../bin

# az aktuális könyvtárban található bin könyvtár megnyitása
cd ./bin
cd bin # vegyük észre: a ./ ez esetben elhagyható
</syntaxhighlight>

==== mkdir ====
Az '''mkdir''' parancs segítségével könyvtárakat hozhatunk létre (''make directory''). Alapértelmezetten a ''.'' könyvtáron (tehát ahol éppen tartózkodunk, azon a könyvtáron) belül hozza létre az új mappát, de lehetőségünk van mind relatív, mind abszolút hivatkozások használatára.
<syntaxhighlight lang="bash">
# folder könyvtár létrehozása az aktuális könyvtárban
mkdir folder
mkdir ./folder2
# subfolder létrehozása a folder könyvtáron belül.
mkdir folder/subfolder

# létrehozás a /tmp könyvtáron belül, akárhol is vagyunk
mkdir /tmp/folder

# folder létrehozása a szülőkönyvtárban
mkdir ../folder
</syntaxhighlight>

A fentebb leírtak alapján egyetlen könyvtárat hozhatunk létre, egy már létező könyvtáron belül, legyen az éppen az, amiben tartózkodunk, vagy valahol máshol a fájlrendszerben. Azonban előfordul, hogy egyszerre több mappát szeretnénk elkészíteni, például egy mélyebb struktúrát szeretnénk kialakítani, mint ami a rendelkezésünkre áll. Ezt természetesen megtehetjük úgy, hogy az egyes szinteket egyesével hozzuk létre, de alkalmazhatunk kapcsolót, amelynek segítségével a nem létező szülőkönyvtárakat is létrehozza, amennyiben nem léteznek.
<syntaxhighlight lang="bash">
# root könyvtáron belül létrejön egy ''test'' könyvtár és azon belül jön létre a ''folder'' könyvtár.
mkdir /test/folder/ -p

# az aktuális könyvtárban jön létre egy ''test'' könyvtár és azon belül a ''folder'' könyvtár
mkdir -p test/folder

# a jelenlegi könyvtárban létrejon a ''test'' könyvtár,
# azon belül létrejön egy ''folder1'' és egy ''folder2'' könyvtár,
# majd mind a kettőben létrejön a ''work'' könyvtár.
mkdir -p test/{folder1,folder2}/work
</syntaxhighlight>

Természetesen ahhoz, hogy egy könyvtárban további fájlokat vagy könyvtárakat hozzunk létre jogosultság szükséges.

==== rmdir ====
Az '''rmdir''' parancs segítségével üres könyvtárakat törölhetünk.

'''Figyelem'''! Ha a könyvtár nem üres (fájlok vagy egyéb könyvtárak találhatók benne, akkor hibaüzenetet kapunk és nem csinál semmit!

<syntaxhighlight lang="bash">
# relatív hivatkozással
rmdir test/folder

# abszolút hivatkozással
rmdir /test/folder
</syntaxhighlight>

==== cp ====
A '''cp''' parancs segítségével fájlokat és könyvtárakat másolhatunk a fájlrendszer egy pontjáról a másikra.

<syntaxhighlight lang="bash">
# /etc/passwd fájl lemásolása a jelenlegi könyvtárba - ls paranccsal ellenőrízhető
cp /etc/passwd ./

# /etc/passwd lemásolása a jelenlegi könyvtárba és közben átnevezés file-ra
cp /etc/passwd ./file

# /etc/passwd lemásolása a /tmp könyvtárba
cp /etc/passwd /tmp/

# /etc/passwd lemásolása a /tmp könyvtárba és közben átnevezés file-ra
cp /etc/passwd /tmp/file
</syntaxhighlight>

Könyvtárak másolása esetén a ''-r'' kapcsoló használata szükséges (''recursive'').
<syntaxhighlight lang="bash">
# /etc/network könyvtár és annak tartalmát másolja a /tmp könyvtárba
cp /etc/network /tmp/ -r
</syntaxhighlight>

==== mv ====
Az '''mv''' parancs segítségével fájlokat és könyvtárakat mozgathatunk. Ezzel a paranccsal nevezhetjük át a fájlrendszer elemeit.

A próbálkozáshoz másoljuk le a /etc/passwd állományt, ha eddig nem tettük meg!
<syntaxhighlight lang="bash">
cp /etc/passwd ./
</syntaxhighlight>

<syntaxhighlight lang="bash">
# passwd állomány átnevezése file-ra
mv passwd file

# nem fut le!
# /etc/passwd állomány átnevezése file-ra
mv /etc/passwd /etc/file

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be
mv /etc/passwd /tmp

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be és közben átnevezés file-ra
mv /etc/passwd /tmp/file
</syntaxhighlight>

A könyvtárak áthelyezéséhez (vagy átnevezéséhez) ez esetben nincs szükségünk a ''recursive'' (''-r'') jelölésre.

==== rm ====
Az '''rm''' parancs segítségével fájlokat és könyvtárakat törölhetünk.

<syntaxhighlight lang="bash">
rm file
</syntaxhighlight>

Könyvtárak törléséhez alkalmaznunk kell a rekurzív jelölést: ''-r''.
<syntaxhighlight lang="bash">
rm folder -r
</syntaxhighlight>

==== less ====
A '''less''' egy fájlnézegető, amelynek segítségével lapozhatunk billentyűzet segítségével a fájlokban.

<syntaxhighlight lang="bash">
less /etc/passwd
</syntaxhighlight>

==== more ====
A '''more''' szintén egy fájlnézegető, de ennek segítségével csak előre lapozhatunk, visszafelé nem.

<syntaxhighlight lang="bash">
more /etc/passwd
</syntaxhighlight>

==== which ====
A '''which'' program segítségével lekérdezhetjük, hogy az adott utasításhoz tartozó állomány melyik mappában található.

<syntaxhighlight lang="bash">
# az ls parancs abszolút elérési útvonala
which ls

# a which parancs abszolút elérési útvonala
which which

# a man parancs elérési útvonala
which man
</syntaxhighlight>

==== file ====
A '''file''' utasítás segítségével lekérdezhetjük, hogy egy adott állomány milyen típusú: futtatható állomány (ELF), ASCII stb.

<syntaxhighlight lang="bash">
file /etc/passwd
file /bin/ls
</syntaxhighlight>

==== echo ====
Az '''echo''' mindent kiír a képernyőre, amit parancssori argumentumként adunk át neki.

<syntaxhighlight lang="bash">
echo "Hello World"
echo Hello World
echo Ez egy teszt üzenet
echo "Ez egy teszt üzenet"
</syntaxhighlight>

Láthatjuk, hogy idézőjeltől függetlenül minden megjelenik a képernyőn. Észrevehetjük azt is, hogy minden sor végén új sor karakter (enter) található, amit a "-n" kapcsoló segítségével kapcsolhatunk ki.

<syntaxhighlight lang="bash">
echo -n "Hello world"
</syntaxhighlight>

==== cat ====
A '''cat''' utasítás fájlokat képes összefűzni és az eredményt a képernyőre írja ki.

<syntaxhighlight lang="bash">
# /etc/passwd és a /etc/profile fájlok összefűzése a képernyőn (ebben a sorrendben)
cat /etc/passwd /etc/profile
</syntaxhighlight>

Egy gyakoribb felhasználási módja, hogy a fájlok tartalmát a képernyőre vessük - ez esetben nem fűzünk hozzá semmit a fájlhoz.
<syntaxhighlight lang="bash">
# /etc/passwd és a <semmi> összefűzése és megjelenítése a képernyőn
cat /etc/passwd
</syntaxhighlight>

==== head ====
A '''head''' utasítás segítségével a fájlok első N során írhatjuk ki a képernyőre. Alapértelmezetten N=10, így ha csak egy fájlnevet adunk neki, akkor annak legfeljebb 10 sorát fogja kiírni (ha van annyi).

<syntaxhighlight lang="bash">
head /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
head -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
head -5 /etc/passwd
</syntaxhighlight>

==== tail ====
A '''tail''' hasonlóan működik, mint a '''head''', de ez esetben nem a fájl elejéről ír ki N sort, hanem a végéről.
<syntaxhighlight lang="bash">
tail /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
tail -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
tail -5 /etc/passwd
</syntaxhighlight>

==== wc ====
A '''wc''' utasítás segítségével statisztikai adatokat nyerhetünk ki egy fájlból (''word counter''): sorok, szavak, karakterek és bájtok száma.

<syntaxhighlight lang="bash">
wc /etc/passwd
</syntaxhighlight>

Van lehetőségünk szűkíteni a visszaadott adatokat kapcsolók segítségével:
{| class="wikitable" style="margin: 0px auto"
|+
|-
! Rövid kapcsoló !! Hosszú kapcsoló !! Leírás
|-
| -l || --lines || sorok számát adja vissza
|-
| -w || --words || szavak számát adja vissza
|-
| -c || --chars || karakterek számát adja vissza
|-
| || --bytes || bájtok számát adja vissza
|}

<syntaxhighlight lang="bash">
# sorok számát írja ki
wc -l /etc/passwd
# szavak számát írja ki
wc -w /etc/passwd
# bájtok számát írja ki
wc --bytes /etc/passwd

# sorok és szavak számát írja ki a képernyőre
wc -l -w /etc/passwd
</syntaxhighlight>

==== find ====
A '''find''' utasítás segítségével kereshetünk a fájlrendszerben különböző attribútumok alapján.

<syntaxhighlight lang="bash">
# passwd nevű fájl keresése a /etc könyvtárban
find /etc -name passwd
</syntaxhighlight>

=== Programok csatornái ===
==== STDIN ====
==== STDOUT ====
==== STDERR ====

=== Pipeline ===

=== Parancsbehelyettesítés ===
=== Feladatok ===
==== Szedjük ki a ''/etc/passwd'' állomány 20. sorát ====
<syntaxhighlight lang="bash">
# beolvassuk az első 20 sort és levágjuk az utolsót
head -20 /etc/passwd | tail -1
</syntaxhighlight>

==== Mondjuk meg egy keresett bináris típusát ====
<syntaxhighlight lang="bash">
# fájl elérési út lekérdezése
# STDOUT => /bin/ls
which ls

# fájl típusának lekérdezése
file /bin/ls

# rakjuk össze:
file `which ls`
</syntaxhighlight>

== 2. óra ==
A második órát az alap utasításokkal folytatjuk. Utána scriptek írásával foglalkozunk, amelyben megtekintjük a különböző vezérlési szerkezeteket is.

=== Parancsok és példák ===

==== mcedit ====
Az '''mcedit''' az '''mc''' (''Midnight Commander'') szerkesztője. A Midnight Commander testvére a Total Commander ősének, a Volkov Commandernek, ami szintén egy konzolos alkalmazás. A közös gyökerek miatt nagyon hasonló funkcionalitásokat érhetünk el ebben is, mint a TC-ben - érdemes megnyitni az '''mc''' utasítással, amit később az '''F10''' billentyűvel, vagy az alsó sorban arra a gombra kattintással tudunk bezárni. Ebben az alkalmazásban működik az egér is, így kényelmes használatot eredményez. Érdekesség, hogy a "tálcára helyezés" is megoldott, így a '''Ctrl+O''' billentyűkombinációkkal háttérbe küldhetjük és folytathatjuk dolgunkat a terminálon, majd ugyanezzel a kombinációval előtérbe is hívhatjuk.

Az mcedit megnyitható az ''mc''-ből is, a szokásos F4-es billentyűvel - vagy az arra való kattintással.

Az egér az mcedit-ben is működik!

A másolás a szerkesztőben is hasonlóan működik, mint a kétpaneles fájltallózóban: F5 és F6 billentyűkkel másolhatunk illetve áthelyezhetünk sorokat. Kilépni az F10 billentyűvel, ESC-el tudunk, de ezt az ablakot is a háttérbe küldhetjük, ha szerkesztés közben terminált szeretnénk elérni (''CTRL+O'').

<syntaxhighlight lang="bash">
mcedit /etc/passwd
</syntaxhighlight>

==== nano ====
A '''nano''' szintén egy szövegszerkesztő alkalmazás.

Alul láthatjuk a segédletet, hogy milyen kombinációkkal milyen funkcionalitás érhető el. A szükségesebbek:
* CTRL+K segítségével kivághatunk sorokat a vágólapra (shift+kurzorbillentyűk segítségével tört sorok is kijelölhetők)
* CTRL+U Beilleszti a vágólap tartalmát az aktuális sorba
* CTRL+O Menti a változásokat
* CTRL+X Kilép, de megkérdezi, hogy menteni akarunk-e, ha vannak mentetlen változások

<syntaxhighlight lang="bash">
nano /etc/passwd
</syntaxhighlight>

==== chmod ====
==== shift ====
==== cut ====
A '''cut''' parancs segítségével táblázatos adatokat szűrhetünk: kiválaszthatjuk, hogy mely oszlopokat szeretnénk megjeleníteni. A két legfontosabb kapcsolója a ''-f'' (''field''), ahol a megjelenítendő oszlopokat adhatjuk meg és a ''-d'' (''delimiter''), ahol az elválasztó karaktert állíthatjuk be.

Általában a ''/etc/passwd'' állományon dolgozunk, mert ebben egy '':''-al elválasztott táblázat található.

<syntaxhighlight lang="bash">
# a fájl első oszlopát szedi ki :-nál elválasztva,
# tehát a felhasználónevet
cut -f1 -d':' /etc/passwd

# a fájl első és harmadik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet és az id-ját
cut -f1,3 -d':' /etc/passwd

# a fájl első három és hatodik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet, jelszót és a felhasználó id-ját, valamint a home könyvtárát
cut -f1-3,6 -d':' /etc/passwd
</syntaxhighlight>

==== sort ====
A '''sort''' utasítás segítségével rendezhetjük az adattömböt.
<syntaxhighlight lang="bash">
# a passwd állomány rendezése a felhasználónév szerint - ez van elől
sort /etc/passwd
# fordított sorrend - reverse
sort -r /etc/passwd
</syntaxhighlight>

Alapértelmezetten karakterek szerint rendez, tehát a számokat tartalmazó adatsorokat nem helyes sorrendben adja vissza. Ha számérték szerinti rendezést szeretnénk végrehajtani, akkor használjuk a ''-n'' opciót.
<syntaxhighlight lang="bash">
# file egy számokat tartalmazó fájl - egy sor egy fájl
sort -n file
# fordított sorrend
sort -r -n file
</syntaxhighlight>

==== tr ====
A '''tr''' parancs segítségével karaktereket cserélhetünk ki egy fájlban. Ezen kívül nagyon hasznos tulajdonsága, hogy a kívánt ismétlődéseket el tudja távolítani, mintegy megtisztítva az adatsort.
<syntaxhighlight lang="bash">
# az e betűt o-ra, az o betűt e-re cseréli ki
echo "hello" | tr eo oe

# A T betűt K-ra, az n betűt p-re cseréli ki
echo "Tanar" | tr Tn Kp
</syntaxhighlight>
A fenti példák alapján nézzük meg, hogy mi történik:
# A tr két pozicionális paraméterrel lett meghívva
## Az első paraméter adja meg a lecserélendő karakterek halmazát
## A második paraméter adja meg az új karakterek halmazát
# A program végig megy a bemeneten és közben megvizsgálja, hogy az adott karakter megtalálható-e az első paraméterben
## ha megtalálható, akkor lecseréli a karakterrel azonos pozícióban álló második paraméterben található értékre
## ha nincs benne, akkor megy tovább
# a metodika miatt keresztbe is lehet cserélni (pl. ''o''-t ''e''-re, ''e''-t ''o''-ra, mint az első példában). Gondoljuk végig, hogy ha nem így lenne, akkor az először lecserélt ''e'' betűnek a végén ''o'' betűre kéne cserélődnie.

==== if ====
Az '''if''' segítségével elágazásokat hozhatunk létre, mint minden más programozási nyelven. A szerkezet a következőképp néz ki:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
elif KIFEJEZÉS
elif KIFEJEZÉS
else
fi
</syntaxhighlight>

Természetesen az egyes feltételek kihagyhatók, így készíthetünk egy egyszerű '''if''' elágazást is:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
fi
</syntaxhighlight>

Ha egy sorban szeretnénk leírni (nem scriptben), akkor a következőképpen tehetjük meg:
<syntaxhighlight lang="bash">
if KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; elif KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; else UTASÍTÁS; fi
</syntaxhighlight>

<big>'''KIFEJEZÉS'''</big> 
Egy olyan program, amelynek a visszatérési értéke hasznos információkat hordoz a futás eredményét tekintve. Ne feledjük el, hogy a '''return''' kulcsszóval tudunk ilyen értéket generálni C/C++ kódok esetében. Lássunk egy példát:

<syntaxhighlight lang="c">
#include <stdio.h>

int main() {
if ( 10 % 2 == 0 ) return 0;
else return 1;
}
</syntaxhighlight>

A fenti program visszatérési értéke információval szolgál számunkra, hogy a 10 osztható-e kettővel, avagy sem. Ez az érték vizsgálható az '''if''' segítségével és a válasz függvényében más-más kódokat hajthatunk végre.

A kiértékelés ellentétes a megszokott módszerhez képest (ahol minden igaz, aminek az értéke nem 0).
<syntaxhighlight lang="bash">
# ha a KIFEJEZÉS 0 értéket ad vissza, akkor IGAZ az állítás, tehát az if-en belüli kód fut
if KIFEJEZÉS => 0
then
....
else
....
fi

# ha a KIFEJEZÉS nem 0 értéket ad vissza, akkor HAMIS az állítás, tehát az else-n belüli kód fut
if KIFEJEZÉS => != 0
then
...
else
...
fi
</syntaxhighlight>

A programozási nyelvek tanításakor ezért térünk vissza 0-s értékkel ('''return 0;'''), a programunk végén, és hiba esetén 1, vagy annál nagyobb értékkel.

==== test ====
A '''test''' parancs logikai függvényeket értékel ki és
* '''0''' értéket ad vissza, ha az eredmény '''IGAZ''',
* '''1''' értéket ad vissza, ha az eredmény '''HAMIS'''

Az '''if''' utasítással együtt szoktuk használni, de természetesen ettől független is meghívható.
<syntaxhighlight lang="bash">
# megtörténik a logikai kiértékelés, eldől, hogy a két string egyezik-e
test "text1" == "text2"
# kiírjuk a képernyőre a test utasítás visszatérési értékét
echo $?
</syntaxhighlight>

'''if''' utasítással a következőképp használhatjuk:
<syntaxhighlight lang="bash">
# hamis
if test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

# igaz
if ! test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

#igaz
if test "text1" != "text2"
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

Elérhető egy ''alias'', aminek segítségével olvashatóbbá tehetjük a '''test''' utasítást. Ez a '''[ ]''' pár.
<syntaxhighlight lang="bash">
if [ "text1" == "text2" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

'''Ügyeljünk rá, hogy a ''['' és a '']'' zárójelek mellett ''whitespace'' karakterek vannak. Ha ezeket kihagyjuk, akkor hibát fogunk kapni!'''

A számok ellenőrzése BASH környezetben körülményesebb, mivel itt minden karakterláncnak számít. Emiatt a következő utasítás sorozat nem várt eredménnyel zárul:
<syntaxhighlight lang="bash">
if [ "1000" <= "20" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': igaz. De tudjuk, hogy ez az eredmény nem igaz, a BASH mégis így értékelte ki. Az oka, hogy az első karaktereket tekintve (''1'' és ''2'') elmondható, hogy az ''1''-es hamarabb van az ABC-ben (kódtáblában), mint a ''2'', így az ''1000''-nek kisebbnek kell lennie (mintha a "alma" és "körte" lenne összehasonlítva, hogy melyik következik előbb az ABC-ben).

Ahhoz, hogy a '''test''' utasítás karakterek helyett számként dolgozza fel a paramétert, kapcsolót kell használnunk:

{| class="wikitable" style="margin: 0px auto;"
|+
|-
! Kapcsoló !! Angol megnevezés !! Magyar megnevezés
|-
| -eq || Equals || Egyenlő
|-
| -ne || Not Equals || Nem egyenlő
|-
| -lt || Lower than || Kisebb, mint
|-
| -le || Lower than or equals || Kisebb vagy egyenlő
|-
| -gt || Greather than || nagyobb, mint
|-
| -ge || Greather than or equals || Nagyobb vagy egyenlő
|}

<syntaxhighlight lang="bash">
if [ 1000 -le 20 ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': Az elvártaknak megfelelően HAMIS.

==== for ====
A '''for''' utasítás segítségével egy lista elemein mehetünk végig. Hasonlóan működik, mint a modern programozási nyelvekben a ''foreach''.

Legegyszerűbben a következő utasítással tesztelhetjük, ahol a bemeneti listát soronként látjuk viszont a képernyőn:
<syntaxhighlight lang="bash">
for i in 1 2 3 4 5 6
do
echo $i
done
</syntaxhighlight>

Természetesen van lehetőségünk a listát más program kimenetéből kinyerni a parancsbehelyettesítés segítségével:
<syntaxhighlight lang="bash">
for i in `ls`
do
echo $i
done
</syntaxhighlight>

A '''for''' gyakorlatilag a pozicionális paramétereken megy végig, tehát egy lista elem a $1, egy másik listaelem a $2. Tudjuk, hogy ha szóközök között adjuk meg, akkor szóközt is tartalmazhat a paraméterünk. Lássunk egy példát:
<syntaxhighlight lang="bash">
for i in "1 2 3" "4 5 6"
do
echo $i
done
</syntaxhighlight>
Ez esetben a képernyőn két sor jelenik meg: ''1 2 3'' és ''4 5 6''. Azonban a parancsbehelyettesítés nem alkalmaz az idézőjelhez hasonló technikát, tehát azt alkalmazva minden szó (szóközökkel határolt karaktersorozat) új pozicionális paramétert jelent. Lássunk egy az előzőhöz hasonló példát:
<syntaxhighlight lang="bash">
for i in `echo "1 2 3 4 5 6"`
do
echo $i
done
</syntaxhighlight>
Ez esetben hat sor jelenik meg, benne egy-egy számmal, tehát az '''echo "1 2 3 4 5 6"''' kimenetét szóközönként vágta fel.

==== while ====
A '''while''' utasítás, mint minden programozási nyelvben, itt is felfogható úgy, mint egy többször lefutó '''if'''. Éppen ezért a szintaktikájuk megegyezik, csupán a feltételek megírásával kell óvatosan bánnunk, hogy a ciklus mag akkor és addig fusson, ameddig mi azt szeretnénk. A '''while''' ciklusnál ugyanazokat az alkalmazásokat írhatjuk be a '''KIFEJEZÉS''' helyére, mint az '''if''' esetében.

<syntaxhighlight lang="bash">
while KIFEJEZÉS
do
done
</syntaxhighlight>

Például ha azt akarjuk, hogy egy ciklus addig fusson, amíg meg nem jelenik egy fájl a fájlrendszerben, akkor azt a következőképp vezethetjük le:
<syntaxhighlight lang="bash">
# ellenőrzi, hogy a fájl elérhető-e
test -f "file.txt"

# ez esetben egyetlen kísérletet teszünk, de nem várjuk meg, hogy oda kerüljön, amennyiben nincs ott
if test -f "file.txt"
then
echo "a fájl létezik"
else
echo "A fájl nem létezik"
fi

# várakozunk, amíg a feltétel nem lesz igaz, tehát a fájl nem kerül oda
while ! test -f "file.txt"
do
echo "várakozunk"
done
echo "a fájl létezik"

# test parancs helyettesítése []-el
while ! [ -f "file.txt" ]
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

A while ciklusnál érdemes megemlíteni a '''until''' utasítást, ami annyiban tér el, hogy a feltétel kiértékelését invertálni kell - tehát ami igaz a '''while''' esetében, az hamis az '''until''' esetében és fordítva. Így a fenti feladatot megvalósíthatjuk invertálás nélkül, az until utasítással is:

<syntaxhighlight lang="bash">
until test -f "file.txt"
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

==== seq ====
A '''seq''' utasítás egy listát generál számunkra, amelyben a megadott lépésszámmal, a megadott legkisebb értéktől a megadott legnagyobb értékig szerepelnek a számok.

<syntaxhighlight lang="bash">
# számok 1-10-ig
seq 10

# számok 5-10-ig
seq 5 10

# számok 3-tól 10-ig 2-esével
seq 3 2 10
</syntaxhighlight>

A '''seq''' utasítást általában a '''for''' ciklus listájában használjuk, hogy elő tudjuk állítani az indexeket.
<syntaxhighlight lang="bash">
for i in `seq 3 2 10`
do
echo $i
done
</syntaxhighlight>

==== read ====
A '''read''' utasítás segítségével a STDIN-ről kérhetünk be információt változóba/változókba. Ha több változót sorolunk fel, akkor a bemenetet szóközöknél vágja el.
<syntaxhighlight lang="bash">
# beolvasás var-ba
# STDIN => teszt
# var => teszt
# STDIN => teszt szöveg
# var => teszt szöveg
read var

# beolvasás fname és lname változókba
# STDIN => Attila Farkas
# fname => Attila
# lname = Farkas
# STDIN => Attila
# fname => Attila
# lname => <üres>
# STDIN => Attila Farkas OPSYS
# fname => Attila
# lname => Farkas OPSYS
read fname lname

# beolvasás három változóba. Ha a felhasználó az utasításokkal szemben több szót adott meg, akkor így biztosíthatjuk, hogy ne legyen szóköz az első két változóban
# STDIN => Attila Farkas
# fname => Attila
# lname => Farkas
# tmp => <üres>
# STDIN => Attila Farkas OPSYS meg valami más
# fname => Attila
# lname => Farkas
# tmp => OPSYS meg valami más
read fname lname tmp
</syntaxhighlight>

Az utóbbi esetben hibaüzenet is generálható, ha megvizsgáljuk, hogy a ''tmp'' változó értéke üres-e:
<syntaxhighlight lang="bash">
echo -n "Adja meg a teljes nevét: "
read fname lname tmp

# -n => nem üres?
# -z => üres?
if [ -n "$tmp" ]
then
echo "Valamit elhibáztál"
exit 1
fi
</syntaxhighlight>

Ha szeretnénk ellenőrzött bekérést végrehajtani:
<syntaxhighlight lang="bash">
tmp="start value"
while [ -n "$tmp" ]
do
echo -n "Adja meg a teljes nevét FNAME LNAME formátumban: "
read fname lname tmp
if [ -n "$tmp" ]
then
echo "Valamit elrontottál!"
# ez esetben nem lépünk ki, mert bekérjük újra
fi
done
</syntaxhighlight>

==== expr ====
Az '''expr''' parancs segítségével tudunk matematikai műveleteket végrehajtani. Mivel a BASH-ben minden változó karakterlánc, így nem tudunk közöttük műveletet végezni. Az '''expr''' a paramétereket belül számként kezeli. '''Csak egész számokkal tud dolgozni!'''

<syntaxhighlight lang="bash">
# a képernyőre kerül az eredmény
expr 1 + 2
expr 4 * 4

# csak egész számot ír ki
expr 3 / 2
</syntaxhighlight>

Ha tört számokkal kell dolgoznunk, akkor a következőket tehetjük:
# eltávolítjuk a törtrészt
# felszorozzuk 10^n-nel, ahol n a törtrész számjegyeivel egyezik meg (pl. 10.02-t 100-al kell szorozni). Az egész térben elvégzett művelet eredményét később vissza osztjuk ugyanannyival, amennyivel korábban felszoroztuk. '''Ez nem egy egyszerű feladat, hiszen a tört számot egyáltalán nem kezeli az expr, tehát cut, wc és egyéb parancsokkal kell kialakítanunk a számot, ahogy utána szét is kell darabolnunk azt.'''
# Másik környezetet használunk, ahol tudunk számokat is kezelni - '''ez a ZH-n nem elfogadott'''

A lehetőségek közül csak az elsőt, a ZH-n teljes mértékben elfogadott megoldást mutatom be:
<syntaxhighlight lang="bash">
# a 3.4-et és a 1.2-őt kell összeadnunk.

# ennek eredménye 3
echo "3.4" | cut -d'.' -f1

# ennek eredménye 1
echo "1.2" | cut -d'.' -f1

# rakjuk össze
expr `echo "3.4" | cut -d'.' -f1` + `echo "1.2" | cut -d'.' -f1`
</syntaxhighlight>

=== Feladatok parancsokhoz ===
==== Írassuk ki a /etc/passwd több sorát ====
Több választási lehetőségünk van:
* ha a kiírandó sorszámok valamilyen logikát követnek (minden második, harmadik stb.), akkor használhatjuk a '''seq''' utasítást
* ha nincs logika a sorszámokban, akkor kézzel kell elkészítenünk a listát

<big>'''Logikát tartalmazó sorszámok'''</big> 
''Írassuk ki minden harmadik sor tartalmát'' 
<syntaxhighlight lang="bash">
# határozzuk meg a seq tartományát
# min: 1
# max: ahány sora van a fájlnak

# max érték meghatározás
# a változó létrehozást lentebb tárgyaljuk
max=`cat /etc/passwd | wc -l`

# lista meghatározása for ciklushoz
# 1-től $max-ig hármasával
seq 1 3 $max

# Rakjuk össze
for i in `seq 1 3 $max`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

<big>'''Logikát nem tartalmazó sorszámok'''</big> 
''Írassuk ki a 2., 5., 10. és 11. sorokat'' 
<syntaxhighlight lang="bash">
for i in `2 5 10 11`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

==== Fájlok ellenőrzése és másolása ====
Másoljuk át a /etc/passwd állományt egy könyvtárba (~/test/destination). Ha a célkönyvtár nem létezik, akkor hozzuk létre. Ha a célkönyvtár és a fájl is létezik, akkor írjunk ki hibaüzenetet.

<syntaxhighlight lang="bash">
# forrás fájl létezésének vizsgálata
test -f /etc/passwd

# célfájl létezésének vizsgálata
test -f ~/test/destination/passwd

# mappa létezésének vizsgálata
test -d ~/test/destination

# rakjuk össze

# ha a forrásfájl nem létezik
if ! test -f /etc/passwd
then
echo "A forrásfájl nem létezik"
# ha a célfájl létezik
elif test -f ~/test/destination/passwd
then
echo "A fájl már létezik"
# ha a cél mappa nem létezik
elif ! test -d ~/test/destination
then
# mappa létrehozás - szülőkönyvtárakat is, ha nem léteznek
mkdir -p ~/test/destination
# fájl belemásolása
cp /etc/passwd ~/test/destination
# ha a célfájl nem létezik, de a célmappa igen
else
# a fájlt bemásoljuk a könyvtárba
cp /etc/passwd ~/test/destination
fi
</syntaxhighlight>

=== Script létrehozása ===
* Script megírása
* Futási jog

=== Pozicionális paraméterek ===

=== Változók ===

== 3. óra ==
A harmadik órán reguláris nyelvekkel foglalkozunk. A nyelv szintaktikai elemzése után a BASH-ben erre alkalmas szoftvert, a ''grep''-et foguk megvizsgálni.

=== Reguláris kifejezés szerkezete ===
A reguláris nyelvek atomokból, lezártakból épül fel, amelynek az eredménye az úgynevezett „összetettek”.

==== Atomok ====
Az atomok egy karakterre illeszkednek a sorban.
{| class="wikitable" style="margin: 0px auto;"
|-
! Atom !! jelentés
|-
| betűk, számok || saját magukra illeszkednek
|-
| ^ || sor elejére illeszkedik (csak egyszer lehet a legelején)
|-
| $ || sor végére illeszkedik (csak egyszer lehet a legvégén)
|-
| [abc] || halmaz: minden benne lévő elemre illeszkedik
|-
| [^abc] || inverz halmaz: egyetlen benne lévő elemre sem illeszkedik
|-
| . || mindenre illeszkedik
|-
|}

==== Lezártak ====
A lezártak ismétlődéseket fogalmaznak meg egy atomra vonatkozóan. '''Lezárt csak atom után helyezkedhet el!'''
{| class="wikitable" style="margin: 0px auto;"
|-
! Lezárt !! jelentés
|-
| * || az atomot 0 és végtelen között akárhányszor ismételheti
|-
| + || az atomot 1 és végtelen között akárhányszor ismételheti
|-
| ? || az atomot 0 és 1 között akárhányszor ismételheti
|-
| {n} || az atom pontosan n-szer fordul elő egymás mellett
|-
| {n,m} || az atomot n és m között akárhányszor ismételheti
|-
| {n,} || az atomot n és végtelen között akárhányszor ismételheti
|-
| {,m} || az atomot 0 és m között akárhányszor ismételheti
|-
|}

==== Összefűzöttek ====
Az atomok és a lezártak egymás után írt sorozata.
A lezártaknál fontos kitétel volt, hogy csak atom után lehet írni. '''Egy összefűzött újra atomizálható''' a ( ) karakterekkel.
Az összefűzöttek tartalmazhatnak uniót (|), ahol több szabály közül bármelyik megvalósulhat egy sikeres illesztéshez.

=== Parancsok és példák ===
Ez egy teszt szöveg, amin próbálkozunk.
A fenti szöveget alapul véve, a következő reguláris kifejezéseket hozhatjuk létre:
{| class="wikitable" style="margin: 0px auto;"
! Reguláris kifejezés !! Illeszkedik? || Magyarázat
|-
| E || Igen || Van a sorban E betű
|-
| a || Igen || Van a sorban a betű
|-
| b || Nem || Nincs a sorban b betű
|-
| ^E || Igen || A sor elején van az E betű
|-
| ^A || Nem || Nincs a sor elején A betű
|-
| ^e || Nem || nincs a sor elején e betű
|-
| .$ || Igen || Bármilyen karakter lehet a sor végén
|-
| \. || Igen || . van a sor végén
|-
| k$ || Nem || Nincs k a sor végén
|-
| egy || igen || Van a sorban „egy” string
|-
| egység || Nem || Nincs a sorban egység string
|-
| egy* || Igen || eg kötelező, y 0 vagy végtelenszer lehet (egy, egyy, egyyy, egyyyy ...)
|-
| l*egy || Igen || l 0 vagy végtelen, eg kötelező (eg, leg, lleg, llleg, lllleg ...)
|-
| l+egy || Nem || Nincs a szövegben "l+egy" string
|-
| l\+egy || Nem || l 1 vagy végtelen hosszú, egy kötelező (legy, llegy, lllegy, llllegy ...)
|-
| (egy) || Nem || Nincs a sorban "(egy)" string
|-
| $egy$ || Igen || Van a sorban "egy" string
|-
| $egy$* || Igen || Van a sorban legalább 0-szor "egy" string
|-
| $egy$\+ || Igen || Van a sorban legalább 1-szer "egy" string
|-
| $egy$\{2\} || Nem || Nincs a sorban pontosan kétszer "egy" string
|-
| [a-z] || Igen || Vannak benne kisbetűk
|-
| [A-Z] || Igen || Van benne nagy betű
|-
| ^[A-D] || Nem || Nincs a sor elején A-D tartományban betű
|-
| ^[A-Z] || Igen || Nagy betű van a sor elején
|-
| ^[A-Z].*\.$ || Igen || Nagybetűvel kezdőik, középen bármi lehet és ponttal végződik a sor.
|-
| [0-9] || Nem || Nincs számjegy a sorban
|-
| .* || Igen || Mindenre illeszkedik, bármilyen hosszan (üres sorra is)
|-
| ^$ || Nem || Csak az üres sorra illeszkedik
|-
| ^.\+$ || Igen || Mindenre illeszkedik, kivéve az üres sorra
|}

A következő kifejezés szintén illeszkedik:
^[A-Z].*$egy$\|$kettő$.*\.$ => A sor elején nagybetűvel kezdődik, van a közepén valahol benne "egy" vagy "kettő" karakterlánc és ponttal végződik. A köztes karakterek értéke nincs megszabva.

==== grep ====
A '''grep''' utasítás segítségével végezhetünk el reguláris kifejezés, tehát minta illesztést fájlokon. Amennyiben nem adunk meg fájl paramétert, a STDIN csatornát olvassa. Az eredmények a STDOUT-ra íródnak.

{| class="wikitable" style="margin: 0px auto"
|+ Fontosabb kapcsolók
|-
! Rövid név !! Hosszú név !! Magyarázat
|-
| -c || --count || Megszámolja az illeszkedő sorokat
|-
| -o || --only-matching || Csak a mintára illeszkedő részt írja ki (nem a teljes sort)
|-
| -n || --line-number || Megszámozza a sorokat (a fájl alapján, nem a megjelenítés szerint)
|}

===== Példa =====
<syntaxhighlight lang="bash">
# nologin környezetet futtató felhasználók listája a rendszerben
grep "nologin" /etc/passwd
cat /etc/passwd | grep "nologin" # STDIN-en érkező adatok szűrése

# bash környezetet futtató felhasználók listája a rendszerben
grep "bash" /etc/passwd
cat /etc/passwd | grep "bash" # STDIN-en érkező adatok szűrése
</syntaxhighlight>

===== Példa 2 =====
Írjunk egy scriptet, amely a /bin/bash futtatási környezetet kapó felhasználók nevét kiírja a képernyőre.

<syntaxhighlight lang="bash">
#!/bin/bash

# a fájl, amin dolgozunk
file="/etc/passwd"
# a fájl sorainak száma
lines=`cat $file | wc -l`

# végig megyünk a fájl sorain
for i in `seq 1 $lines`; do
# itt kapjuk meg az i. sort
line=`head -$i $file | tail -1`
# kiszedjük a shell környezetet
shell=`echo $line | cut -f7 -d':'`
# ha ez "/bin/bash", akkor kivágjuk a sor első oszlopát, ezt írhatjuk a képernyőre
if test $shell == "/bin/bash"; then
echo $line | cut -f1 -d':'
fi
done
</syntaxhighlight>
A fenti script futási ideje: 0.227s

<syntaxhighlight lang="bash">
#!/bin/bash
# a fájl, amin dolgozunk
file="/etc/passwd"
# szűrjük ki a sorokat, amelyeknek a végén a "/bin/bash" karakterlánc található
# és a kapott eredményhalmaznak vágjuk ki az első oszlopát
# a kapott eredményhalmaz még mindig megfelel a /etc/passwd eredeti formátumának,
# csak a sorok számát csökkentettük a szűrési feltételnek megfelelően!
grep "/bin/bash$" $file | cut -f1 -d':'
</syntaxhighlight>
A fenti script futási ideje: 0.003s

== 4. óra ==
A negyedik órán a reguláris kifejezések elkészítését gyakoroljuk különböző példákon keresztül. Főleg scripten belül használjuk.

== 5. óra ==
Az ötödik órán minta ZH feladatsort oldunk meg.

EDU::GAMF::Operációs rendszerek::Gyakorlatok

2024-10-09T11:51:18Z

ApelPro: /* Példa */

== 1. óra ==
Az első óra a tantárgy és annak követelményeinek ismertetésével kezdődik, majd egy-két alap utasítást tekintünk meg. Ezután a programok csatornáival folytatjuk.

=== Parancsok és példák ===
==== man ====
A ''man'' parancs segítségével megtekinthetjük egy-egy alkalmazás, parancs, esetleg külső könyvtár függvényeinek dokumentációját. 

'''Használata:'''
A program neve után írhatjuk, hogy melyik alkalmazás, parancs vagy esetleg külső könyvtár függvényének dokumentációját szeretnénk megtekinteni. Megtekinthetjük ily módon a ''man'' parancs használati útmutatóját is a következő utasítás kiadásával:
<syntaxhighlight lang="bash">
man man
</syntaxhighlight>

Hasonló módon alkalmazhatjuk bármelyik parancsra, amelyek ezen a weboldalon felsorolásra kerültek. Pl. a ''head'' utasítás dokumentációját az alábbi módon érhetjük el
<syntaxhighlight lang="bash">
man head
</syntaxhighlight>

==== ls ====
Érdemes megtekinteni a parancs dokumentációját a ''man ls'' utasítás kiadásával, tisztában legyünk ez elérhető kapcsolókkal és funkciókkal.
Az '''ls''' parancs segítségével listázhatjuk a mappa tartalmát. Alapértelmezetten a '''.''', tehát a jelenlegi könyvtárat listázza.
<syntaxhighlight lang="bash">
# meghívás paraméter nélkül
ls

# meghívás . paraméterrel - ugyanaz az eredmény
ls .
</syntaxhighlight>

A listázni kívánt könyvtár nevét megadhatjuk paraméterben:
<syntaxhighlight lang="bash">
# root könyvtár listázása
ls /

# a /usr/local/bin könyvtár listázása
ls /usr/local/bin
</syntaxhighlight>

Érdemes megjegyezni a hosszú formátumú kiírást, aminek segítségével a fájlrendszer bejegyzések jogosultságait és méretét kérhetjük le.
<syntaxhighlight lang="bash">
# Jelenlegi könyvtárban listáz minden elemet és azok tulajdonságait
ls -l

# A /bin/ls fájl jogosultságainak lekérdezése
ls -l /bin/ls
</syntaxhighlight>

Próbáljuk ki, hogy ha egy mappa nevével futtatjuk le a parancsot, akkor az '''ls''' megnyitja a könyvtárat és annak tartalmát listázza ki.
<syntaxhighlight lang="bash">
# a /bin könyvtár tartalma listázódik, nem a /bin könyvtár maga
ls /bin
</syntaxhighlight>
Ez különösen akkor okoz problémát, ha például az adott könyvtár jogosultságait szeretnénk megtekinteni. Ekkor két választási lehetőségünk adódik:
<syntaxhighlight lang="bash">
# A felette lévő könyvtárat listázzuk és kikeressük a megfelelő bejegyzést
ls / -l

# használjuk a -d kapcsolót, aminek segítségével felszólítjuk az ls-t, hogy ne nyissa meg az adott könyvtárat
# Ekkor a könyvtár listázódik, nem a tartalma
ls -d /bin
</syntaxhighlight>

==== pwd ====
A '''pwd''' parancs segítségével lekérdezhetjük annak a könyvtárnak az abszolút elérési útvonalát, amelyben éppen benne vagyunk.

A parancsot főleg arra használjuk, hogy aktuálisan mellettünk elhelyezett fájlok és könyvtárak abszolút útvonalát ki tudjuk alakítani.

<syntaxhighlight lang="bash">
pwd
</syntaxhighlight>

==== cd ====
A '''cd''' parancs segítségével könyvtárat válthatunk (''changedir''). A cél könyvtár nevét paraméterben kell megadnunk.
<syntaxhighlight lang="bash">
# root könyvtár megnyitása
cd /

# HOME könyvtár megnyitása
# ~ egy alias
cd ~

# /usr/bin megnyitása
cd /usr/bin
</syntaxhighlight>

A hivatkozásoknál, így a ''cd'' esetében is lehetőségünk van relatív és abszolút hivatkozásokat használni:
* Az abszolút hivatkozás / elérési út mindig ''/'' jellel kezdődik. pl.: ''cd /home/'', ''cd /usr/bin''
* A relatív hivatkozás vagy nem rendelkezik kezdőkarakterrel: ''cd home'', ''cd bin'', vagy ''.'' illetve ''..'' karakterekkel kezdődnek.
** A ''.'' könyvtár jelenti az aktuális könyvtárat
** A ''..'' könyvtár jelenti a szülő könyvtárat

<syntaxhighlight lang="bash">
# szülő könyvtár megnyitása
cd ../

# a szülőkönyvtárban található bin könyvtár megnyitása
cd ../bin

# az aktuális könyvtárban található bin könyvtár megnyitása
cd ./bin
cd bin # vegyük észre: a ./ ez esetben elhagyható
</syntaxhighlight>

==== mkdir ====
Az '''mkdir''' parancs segítségével könyvtárakat hozhatunk létre (''make directory''). Alapértelmezetten a ''.'' könyvtáron (tehát ahol éppen tartózkodunk, azon a könyvtáron) belül hozza létre az új mappát, de lehetőségünk van mind relatív, mind abszolút hivatkozások használatára.
<syntaxhighlight lang="bash">
# folder könyvtár létrehozása az aktuális könyvtárban
mkdir folder
mkdir ./folder2
# subfolder létrehozása a folder könyvtáron belül.
mkdir folder/subfolder

# létrehozás a /tmp könyvtáron belül, akárhol is vagyunk
mkdir /tmp/folder

# folder létrehozása a szülőkönyvtárban
mkdir ../folder
</syntaxhighlight>

A fentebb leírtak alapján egyetlen könyvtárat hozhatunk létre, egy már létező könyvtáron belül, legyen az éppen az, amiben tartózkodunk, vagy valahol máshol a fájlrendszerben. Azonban előfordul, hogy egyszerre több mappát szeretnénk elkészíteni, például egy mélyebb struktúrát szeretnénk kialakítani, mint ami a rendelkezésünkre áll. Ezt természetesen megtehetjük úgy, hogy az egyes szinteket egyesével hozzuk létre, de alkalmazhatunk kapcsolót, amelynek segítségével a nem létező szülőkönyvtárakat is létrehozza, amennyiben nem léteznek.
<syntaxhighlight lang="bash">
# root könyvtáron belül létrejön egy ''test'' könyvtár és azon belül jön létre a ''folder'' könyvtár.
mkdir /test/folder/ -p

# az aktuális könyvtárban jön létre egy ''test'' könyvtár és azon belül a ''folder'' könyvtár
mkdir -p test/folder

# a jelenlegi könyvtárban létrejon a ''test'' könyvtár,
# azon belül létrejön egy ''folder1'' és egy ''folder2'' könyvtár,
# majd mind a kettőben létrejön a ''work'' könyvtár.
mkdir -p test/{folder1,folder2}/work
</syntaxhighlight>

Természetesen ahhoz, hogy egy könyvtárban további fájlokat vagy könyvtárakat hozzunk létre jogosultság szükséges.

==== rmdir ====
Az '''rmdir''' parancs segítségével üres könyvtárakat törölhetünk.

'''Figyelem'''! Ha a könyvtár nem üres (fájlok vagy egyéb könyvtárak találhatók benne, akkor hibaüzenetet kapunk és nem csinál semmit!

<syntaxhighlight lang="bash">
# relatív hivatkozással
rmdir test/folder

# abszolút hivatkozással
rmdir /test/folder
</syntaxhighlight>

==== cp ====
A '''cp''' parancs segítségével fájlokat és könyvtárakat másolhatunk a fájlrendszer egy pontjáról a másikra.

<syntaxhighlight lang="bash">
# /etc/passwd fájl lemásolása a jelenlegi könyvtárba - ls paranccsal ellenőrízhető
cp /etc/passwd ./

# /etc/passwd lemásolása a jelenlegi könyvtárba és közben átnevezés file-ra
cp /etc/passwd ./file

# /etc/passwd lemásolása a /tmp könyvtárba
cp /etc/passwd /tmp/

# /etc/passwd lemásolása a /tmp könyvtárba és közben átnevezés file-ra
cp /etc/passwd /tmp/file
</syntaxhighlight>

Könyvtárak másolása esetén a ''-r'' kapcsoló használata szükséges (''recursive'').
<syntaxhighlight lang="bash">
# /etc/network könyvtár és annak tartalmát másolja a /tmp könyvtárba
cp /etc/network /tmp/ -r
</syntaxhighlight>

==== mv ====
Az '''mv''' parancs segítségével fájlokat és könyvtárakat mozgathatunk. Ezzel a paranccsal nevezhetjük át a fájlrendszer elemeit.

A próbálkozáshoz másoljuk le a /etc/passwd állományt, ha eddig nem tettük meg!
<syntaxhighlight lang="bash">
cp /etc/passwd ./
</syntaxhighlight>

<syntaxhighlight lang="bash">
# passwd állomány átnevezése file-ra
mv passwd file

# nem fut le!
# /etc/passwd állomány átnevezése file-ra
mv /etc/passwd /etc/file

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be
mv /etc/passwd /tmp

# nem fut le!
# /etc/passwd állomány áthelyezése /tmp-be és közben átnevezés file-ra
mv /etc/passwd /tmp/file
</syntaxhighlight>

A könyvtárak áthelyezéséhez (vagy átnevezéséhez) ez esetben nincs szükségünk a ''recursive'' (''-r'') jelölésre.

==== rm ====
Az '''rm''' parancs segítségével fájlokat és könyvtárakat törölhetünk.

<syntaxhighlight lang="bash">
rm file
</syntaxhighlight>

Könyvtárak törléséhez alkalmaznunk kell a rekurzív jelölést: ''-r''.
<syntaxhighlight lang="bash">
rm folder -r
</syntaxhighlight>

==== less ====
A '''less''' egy fájlnézegető, amelynek segítségével lapozhatunk billentyűzet segítségével a fájlokban.

<syntaxhighlight lang="bash">
less /etc/passwd
</syntaxhighlight>

==== more ====
A '''more''' szintén egy fájlnézegető, de ennek segítségével csak előre lapozhatunk, visszafelé nem.

<syntaxhighlight lang="bash">
more /etc/passwd
</syntaxhighlight>

==== which ====
A '''which'' program segítségével lekérdezhetjük, hogy az adott utasításhoz tartozó állomány melyik mappában található.

<syntaxhighlight lang="bash">
# az ls parancs abszolút elérési útvonala
which ls

# a which parancs abszolút elérési útvonala
which which

# a man parancs elérési útvonala
which man
</syntaxhighlight>

==== file ====
A '''file''' utasítás segítségével lekérdezhetjük, hogy egy adott állomány milyen típusú: futtatható állomány (ELF), ASCII stb.

<syntaxhighlight lang="bash">
file /etc/passwd
file /bin/ls
</syntaxhighlight>

==== echo ====
Az '''echo''' mindent kiír a képernyőre, amit parancssori argumentumként adunk át neki.

<syntaxhighlight lang="bash">
echo "Hello World"
echo Hello World
echo Ez egy teszt üzenet
echo "Ez egy teszt üzenet"
</syntaxhighlight>

Láthatjuk, hogy idézőjeltől függetlenül minden megjelenik a képernyőn. Észrevehetjük azt is, hogy minden sor végén új sor karakter (enter) található, amit a "-n" kapcsoló segítségével kapcsolhatunk ki.

<syntaxhighlight lang="bash">
echo -n "Hello world"
</syntaxhighlight>

==== cat ====
A '''cat''' utasítás fájlokat képes összefűzni és az eredményt a képernyőre írja ki.

<syntaxhighlight lang="bash">
# /etc/passwd és a /etc/profile fájlok összefűzése a képernyőn (ebben a sorrendben)
cat /etc/passwd /etc/profile
</syntaxhighlight>

Egy gyakoribb felhasználási módja, hogy a fájlok tartalmát a képernyőre vessük - ez esetben nem fűzünk hozzá semmit a fájlhoz.
<syntaxhighlight lang="bash">
# /etc/passwd és a <semmi> összefűzése és megjelenítése a képernyőn
cat /etc/passwd
</syntaxhighlight>

==== head ====
A '''head''' utasítás segítségével a fájlok első N során írhatjuk ki a képernyőre. Alapértelmezetten N=10, így ha csak egy fájlnevet adunk neki, akkor annak legfeljebb 10 sorát fogja kiírni (ha van annyi).

<syntaxhighlight lang="bash">
head /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
head -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
head -5 /etc/passwd
</syntaxhighlight>

==== tail ====
A '''tail''' hasonlóan működik, mint a '''head''', de ez esetben nem a fájl elejéről ír ki N sort, hanem a végéről.
<syntaxhighlight lang="bash">
tail /etc/passwd
</syntaxhighlight>

Az alapértelmezett N=10 értéket a ''-n'' kapcsoló segítségével módosíthatjuk
<syntaxhighlight lang="bash">
tail -n 5 /etc/passwd

# a -n a dokumentáció elhagyható, ha a - után szám található
tail -5 /etc/passwd
</syntaxhighlight>

==== wc ====
A '''wc''' utasítás segítségével statisztikai adatokat nyerhetünk ki egy fájlból (''word counter''): sorok, szavak, karakterek és bájtok száma.

<syntaxhighlight lang="bash">
wc /etc/passwd
</syntaxhighlight>

Van lehetőségünk szűkíteni a visszaadott adatokat kapcsolók segítségével:
{| class="wikitable" style="margin: 0px auto"
|+
|-
! Rövid kapcsoló !! Hosszú kapcsoló !! Leírás
|-
| -l || --lines || sorok számát adja vissza
|-
| -w || --words || szavak számát adja vissza
|-
| -c || --chars || karakterek számát adja vissza
|-
| || --bytes || bájtok számát adja vissza
|}

<syntaxhighlight lang="bash">
# sorok számát írja ki
wc -l /etc/passwd
# szavak számát írja ki
wc -w /etc/passwd
# bájtok számát írja ki
wc --bytes /etc/passwd

# sorok és szavak számát írja ki a képernyőre
wc -l -w /etc/passwd
</syntaxhighlight>

==== find ====
A '''find''' utasítás segítségével kereshetünk a fájlrendszerben különböző attribútumok alapján.

<syntaxhighlight lang="bash">
# passwd nevű fájl keresése a /etc könyvtárban
find /etc -name passwd
</syntaxhighlight>

=== Programok csatornái ===
==== STDIN ====
==== STDOUT ====
==== STDERR ====

=== Pipeline ===

=== Parancsbehelyettesítés ===
=== Feladatok ===
==== Szedjük ki a ''/etc/passwd'' állomány 20. sorát ====
<syntaxhighlight lang="bash">
# beolvassuk az első 20 sort és levágjuk az utolsót
head -20 /etc/passwd | tail -1
</syntaxhighlight>

==== Mondjuk meg egy keresett bináris típusát ====
<syntaxhighlight lang="bash">
# fájl elérési út lekérdezése
# STDOUT => /bin/ls
which ls

# fájl típusának lekérdezése
file /bin/ls

# rakjuk össze:
file `which ls`
</syntaxhighlight>

== 2. óra ==
A második órát az alap utasításokkal folytatjuk. Utána scriptek írásával foglalkozunk, amelyben megtekintjük a különböző vezérlési szerkezeteket is.

=== Parancsok és példák ===

==== mcedit ====
Az '''mcedit''' az '''mc''' (''Midnight Commander'') szerkesztője. A Midnight Commander testvére a Total Commander ősének, a Volkov Commandernek, ami szintén egy konzolos alkalmazás. A közös gyökerek miatt nagyon hasonló funkcionalitásokat érhetünk el ebben is, mint a TC-ben - érdemes megnyitni az '''mc''' utasítással, amit később az '''F10''' billentyűvel, vagy az alsó sorban arra a gombra kattintással tudunk bezárni. Ebben az alkalmazásban működik az egér is, így kényelmes használatot eredményez. Érdekesség, hogy a "tálcára helyezés" is megoldott, így a '''Ctrl+O''' billentyűkombinációkkal háttérbe küldhetjük és folytathatjuk dolgunkat a terminálon, majd ugyanezzel a kombinációval előtérbe is hívhatjuk.

Az mcedit megnyitható az ''mc''-ből is, a szokásos F4-es billentyűvel - vagy az arra való kattintással.

Az egér az mcedit-ben is működik!

A másolás a szerkesztőben is hasonlóan működik, mint a kétpaneles fájltallózóban: F5 és F6 billentyűkkel másolhatunk illetve áthelyezhetünk sorokat. Kilépni az F10 billentyűvel, ESC-el tudunk, de ezt az ablakot is a háttérbe küldhetjük, ha szerkesztés közben terminált szeretnénk elérni (''CTRL+O'').

<syntaxhighlight lang="bash">
mcedit /etc/passwd
</syntaxhighlight>

==== nano ====
A '''nano''' szintén egy szövegszerkesztő alkalmazás.

Alul láthatjuk a segédletet, hogy milyen kombinációkkal milyen funkcionalitás érhető el. A szükségesebbek:
* CTRL+K segítségével kivághatunk sorokat a vágólapra (shift+kurzorbillentyűk segítségével tört sorok is kijelölhetők)
* CTRL+U Beilleszti a vágólap tartalmát az aktuális sorba
* CTRL+O Menti a változásokat
* CTRL+X Kilép, de megkérdezi, hogy menteni akarunk-e, ha vannak mentetlen változások

<syntaxhighlight lang="bash">
nano /etc/passwd
</syntaxhighlight>

==== chmod ====
==== shift ====
==== cut ====
A '''cut''' parancs segítségével táblázatos adatokat szűrhetünk: kiválaszthatjuk, hogy mely oszlopokat szeretnénk megjeleníteni. A két legfontosabb kapcsolója a ''-f'' (''field''), ahol a megjelenítendő oszlopokat adhatjuk meg és a ''-d'' (''delimiter''), ahol az elválasztó karaktert állíthatjuk be.

Általában a ''/etc/passwd'' állományon dolgozunk, mert ebben egy '':''-al elválasztott táblázat található.

<syntaxhighlight lang="bash">
# a fájl első oszlopát szedi ki :-nál elválasztva,
# tehát a felhasználónevet
cut -f1 -d':' /etc/passwd

# a fájl első és harmadik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet és az id-ját
cut -f1,3 -d':' /etc/passwd

# a fájl első három és hatodik oszlopát adja vissza :-nál elválasztva,
# tehát a felhasználónevet, jelszót és a felhasználó id-ját, valamint a home könyvtárát
cut -f1-3,6 -d':' /etc/passwd
</syntaxhighlight>

==== sort ====
A '''sort''' utasítás segítségével rendezhetjük az adattömböt.
<syntaxhighlight lang="bash">
# a passwd állomány rendezése a felhasználónév szerint - ez van elől
sort /etc/passwd
# fordított sorrend - reverse
sort -r /etc/passwd
</syntaxhighlight>

Alapértelmezetten karakterek szerint rendez, tehát a számokat tartalmazó adatsorokat nem helyes sorrendben adja vissza. Ha számérték szerinti rendezést szeretnénk végrehajtani, akkor használjuk a ''-n'' opciót.
<syntaxhighlight lang="bash">
# file egy számokat tartalmazó fájl - egy sor egy fájl
sort -n file
# fordított sorrend
sort -r -n file
</syntaxhighlight>

==== tr ====
A '''tr''' parancs segítségével karaktereket cserélhetünk ki egy fájlban. Ezen kívül nagyon hasznos tulajdonsága, hogy a kívánt ismétlődéseket el tudja távolítani, mintegy megtisztítva az adatsort.
<syntaxhighlight lang="bash">
# az e betűt o-ra, az o betűt e-re cseréli ki
echo "hello" | tr eo oe

# A T betűt K-ra, az n betűt p-re cseréli ki
echo "Tanar" | tr Tn Kp
</syntaxhighlight>
A fenti példák alapján nézzük meg, hogy mi történik:
# A tr két pozicionális paraméterrel lett meghívva
## Az első paraméter adja meg a lecserélendő karakterek halmazát
## A második paraméter adja meg az új karakterek halmazát
# A program végig megy a bemeneten és közben megvizsgálja, hogy az adott karakter megtalálható-e az első paraméterben
## ha megtalálható, akkor lecseréli a karakterrel azonos pozícióban álló második paraméterben található értékre
## ha nincs benne, akkor megy tovább
# a metodika miatt keresztbe is lehet cserélni (pl. ''o''-t ''e''-re, ''e''-t ''o''-ra, mint az első példában). Gondoljuk végig, hogy ha nem így lenne, akkor az először lecserélt ''e'' betűnek a végén ''o'' betűre kéne cserélődnie.

==== if ====
Az '''if''' segítségével elágazásokat hozhatunk létre, mint minden más programozási nyelven. A szerkezet a következőképp néz ki:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
elif KIFEJEZÉS
elif KIFEJEZÉS
else
fi
</syntaxhighlight>

Természetesen az egyes feltételek kihagyhatók, így készíthetünk egy egyszerű '''if''' elágazást is:
<syntaxhighlight lang="bash">
if KIFEJEZÉS
then
fi
</syntaxhighlight>

Ha egy sorban szeretnénk leírni (nem scriptben), akkor a következőképpen tehetjük meg:
<syntaxhighlight lang="bash">
if KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; elif KIFEJEZÉS; then UTASÍTÁS1; UTASÍTÁS2; else UTASÍTÁS; fi
</syntaxhighlight>

<big>'''KIFEJEZÉS'''</big> 
Egy olyan program, amelynek a visszatérési értéke hasznos információkat hordoz a futás eredményét tekintve. Ne feledjük el, hogy a '''return''' kulcsszóval tudunk ilyen értéket generálni C/C++ kódok esetében. Lássunk egy példát:

<syntaxhighlight lang="c">
#include <stdio.h>

int main() {
if ( 10 % 2 == 0 ) return 0;
else return 1;
}
</syntaxhighlight>

A fenti program visszatérési értéke információval szolgál számunkra, hogy a 10 osztható-e kettővel, avagy sem. Ez az érték vizsgálható az '''if''' segítségével és a válasz függvényében más-más kódokat hajthatunk végre.

A kiértékelés ellentétes a megszokott módszerhez képest (ahol minden igaz, aminek az értéke nem 0).
<syntaxhighlight lang="bash">
# ha a KIFEJEZÉS 0 értéket ad vissza, akkor IGAZ az állítás, tehát az if-en belüli kód fut
if KIFEJEZÉS => 0
then
....
else
....
fi

# ha a KIFEJEZÉS nem 0 értéket ad vissza, akkor HAMIS az állítás, tehát az else-n belüli kód fut
if KIFEJEZÉS => != 0
then
...
else
...
fi
</syntaxhighlight>

A programozási nyelvek tanításakor ezért térünk vissza 0-s értékkel ('''return 0;'''), a programunk végén, és hiba esetén 1, vagy annál nagyobb értékkel.

==== test ====
A '''test''' parancs logikai függvényeket értékel ki és
* '''0''' értéket ad vissza, ha az eredmény '''IGAZ''',
* '''1''' értéket ad vissza, ha az eredmény '''HAMIS'''

Az '''if''' utasítással együtt szoktuk használni, de természetesen ettől független is meghívható.
<syntaxhighlight lang="bash">
# megtörténik a logikai kiértékelés, eldől, hogy a két string egyezik-e
test "text1" == "text2"
# kiírjuk a képernyőre a test utasítás visszatérési értékét
echo $?
</syntaxhighlight>

'''if''' utasítással a következőképp használhatjuk:
<syntaxhighlight lang="bash">
# hamis
if test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

# igaz
if ! test "text1" == "text2"
then
echo "igaz"
else
echo "hamis"
fi

#igaz
if test "text1" != "text2"
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

Elérhető egy ''alias'', aminek segítségével olvashatóbbá tehetjük a '''test''' utasítást. Ez a '''[ ]''' pár.
<syntaxhighlight lang="bash">
if [ "text1" == "text2" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>

'''Ügyeljünk rá, hogy a ''['' és a '']'' zárójelek mellett ''whitespace'' karakterek vannak. Ha ezeket kihagyjuk, akkor hibát fogunk kapni!'''

A számok ellenőrzése BASH környezetben körülményesebb, mivel itt minden karakterláncnak számít. Emiatt a következő utasítás sorozat nem várt eredménnyel zárul:
<syntaxhighlight lang="bash">
if [ "1000" <= "20" ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': igaz. De tudjuk, hogy ez az eredmény nem igaz, a BASH mégis így értékelte ki. Az oka, hogy az első karaktereket tekintve (''1'' és ''2'') elmondható, hogy az ''1''-es hamarabb van az ABC-ben (kódtáblában), mint a ''2'', így az ''1000''-nek kisebbnek kell lennie (mintha a "alma" és "körte" lenne összehasonlítva, hogy melyik következik előbb az ABC-ben).

Ahhoz, hogy a '''test''' utasítás karakterek helyett számként dolgozza fel a paramétert, kapcsolót kell használnunk:

{| class="wikitable" style="margin: 0px auto;"
|+
|-
! Kapcsoló !! Angol megnevezés !! Magyar megnevezés
|-
| -eq || Equals || Egyenlő
|-
| -ne || Not Equals || Nem egyenlő
|-
| -lt || Lower than || Kisebb, mint
|-
| -le || Lower than or equals || Kisebb vagy egyenlő
|-
| -gt || Greather than || nagyobb, mint
|-
| -ge || Greather than or equals || Nagyobb vagy egyenlő
|}

<syntaxhighlight lang="bash">
if [ 1000 -le 20 ]
then
echo "igaz"
else
echo "hamis"
fi
</syntaxhighlight>
'''Az eredmény''': Az elvártaknak megfelelően HAMIS.

==== for ====
A '''for''' utasítás segítségével egy lista elemein mehetünk végig. Hasonlóan működik, mint a modern programozási nyelvekben a ''foreach''.

Legegyszerűbben a következő utasítással tesztelhetjük, ahol a bemeneti listát soronként látjuk viszont a képernyőn:
<syntaxhighlight lang="bash">
for i in 1 2 3 4 5 6
do
echo $i
done
</syntaxhighlight>

Természetesen van lehetőségünk a listát más program kimenetéből kinyerni a parancsbehelyettesítés segítségével:
<syntaxhighlight lang="bash">
for i in `ls`
do
echo $i
done
</syntaxhighlight>

A '''for''' gyakorlatilag a pozicionális paramétereken megy végig, tehát egy lista elem a $1, egy másik listaelem a $2. Tudjuk, hogy ha szóközök között adjuk meg, akkor szóközt is tartalmazhat a paraméterünk. Lássunk egy példát:
<syntaxhighlight lang="bash">
for i in "1 2 3" "4 5 6"
do
echo $i
done
</syntaxhighlight>
Ez esetben a képernyőn két sor jelenik meg: ''1 2 3'' és ''4 5 6''. Azonban a parancsbehelyettesítés nem alkalmaz az idézőjelhez hasonló technikát, tehát azt alkalmazva minden szó (szóközökkel határolt karaktersorozat) új pozicionális paramétert jelent. Lássunk egy az előzőhöz hasonló példát:
<syntaxhighlight lang="bash">
for i in `echo "1 2 3 4 5 6"`
do
echo $i
done
</syntaxhighlight>
Ez esetben hat sor jelenik meg, benne egy-egy számmal, tehát az '''echo "1 2 3 4 5 6"''' kimenetét szóközönként vágta fel.

==== while ====
A '''while''' utasítás, mint minden programozási nyelvben, itt is felfogható úgy, mint egy többször lefutó '''if'''. Éppen ezért a szintaktikájuk megegyezik, csupán a feltételek megírásával kell óvatosan bánnunk, hogy a ciklus mag akkor és addig fusson, ameddig mi azt szeretnénk. A '''while''' ciklusnál ugyanazokat az alkalmazásokat írhatjuk be a '''KIFEJEZÉS''' helyére, mint az '''if''' esetében.

<syntaxhighlight lang="bash">
while KIFEJEZÉS
do
done
</syntaxhighlight>

Például ha azt akarjuk, hogy egy ciklus addig fusson, amíg meg nem jelenik egy fájl a fájlrendszerben, akkor azt a következőképp vezethetjük le:
<syntaxhighlight lang="bash">
# ellenőrzi, hogy a fájl elérhető-e
test -f "file.txt"

# ez esetben egyetlen kísérletet teszünk, de nem várjuk meg, hogy oda kerüljön, amennyiben nincs ott
if test -f "file.txt"
then
echo "a fájl létezik"
else
echo "A fájl nem létezik"
fi

# várakozunk, amíg a feltétel nem lesz igaz, tehát a fájl nem kerül oda
while ! test -f "file.txt"
do
echo "várakozunk"
done
echo "a fájl létezik"

# test parancs helyettesítése []-el
while ! [ -f "file.txt" ]
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

A while ciklusnál érdemes megemlíteni a '''until''' utasítást, ami annyiban tér el, hogy a feltétel kiértékelését invertálni kell - tehát ami igaz a '''while''' esetében, az hamis az '''until''' esetében és fordítva. Így a fenti feladatot megvalósíthatjuk invertálás nélkül, az until utasítással is:

<syntaxhighlight lang="bash">
until test -f "file.txt"
do
echo "várakozás"
done
echo "a fájl létezik"
</syntaxhighlight>

==== seq ====
A '''seq''' utasítás egy listát generál számunkra, amelyben a megadott lépésszámmal, a megadott legkisebb értéktől a megadott legnagyobb értékig szerepelnek a számok.

<syntaxhighlight lang="bash">
# számok 1-10-ig
seq 10

# számok 5-10-ig
seq 5 10

# számok 3-tól 10-ig 2-esével
seq 3 2 10
</syntaxhighlight>

A '''seq''' utasítást általában a '''for''' ciklus listájában használjuk, hogy elő tudjuk állítani az indexeket.
<syntaxhighlight lang="bash">
for i in `seq 3 2 10`
do
echo $i
done
</syntaxhighlight>

==== read ====
A '''read''' utasítás segítségével a STDIN-ről kérhetünk be információt változóba/változókba. Ha több változót sorolunk fel, akkor a bemenetet szóközöknél vágja el.
<syntaxhighlight lang="bash">
# beolvasás var-ba
# STDIN => teszt
# var => teszt
# STDIN => teszt szöveg
# var => teszt szöveg
read var

# beolvasás fname és lname változókba
# STDIN => Attila Farkas
# fname => Attila
# lname = Farkas
# STDIN => Attila
# fname => Attila
# lname => <üres>
# STDIN => Attila Farkas OPSYS
# fname => Attila
# lname => Farkas OPSYS
read fname lname

# beolvasás három változóba. Ha a felhasználó az utasításokkal szemben több szót adott meg, akkor így biztosíthatjuk, hogy ne legyen szóköz az első két változóban
# STDIN => Attila Farkas
# fname => Attila
# lname => Farkas
# tmp => <üres>
# STDIN => Attila Farkas OPSYS meg valami más
# fname => Attila
# lname => Farkas
# tmp => OPSYS meg valami más
read fname lname tmp
</syntaxhighlight>

Az utóbbi esetben hibaüzenet is generálható, ha megvizsgáljuk, hogy a ''tmp'' változó értéke üres-e:
<syntaxhighlight lang="bash">
echo -n "Adja meg a teljes nevét: "
read fname lname tmp

# -n => nem üres?
# -z => üres?
if [ -n "$tmp" ]
then
echo "Valamit elhibáztál"
exit 1
fi
</syntaxhighlight>

Ha szeretnénk ellenőrzött bekérést végrehajtani:
<syntaxhighlight lang="bash">
tmp="start value"
while [ -n "$tmp" ]
do
echo -n "Adja meg a teljes nevét FNAME LNAME formátumban: "
read fname lname tmp
if [ -n "$tmp" ]
then
echo "Valamit elrontottál!"
# ez esetben nem lépünk ki, mert bekérjük újra
fi
done
</syntaxhighlight>

==== expr ====
Az '''expr''' parancs segítségével tudunk matematikai műveleteket végrehajtani. Mivel a BASH-ben minden változó karakterlánc, így nem tudunk közöttük műveletet végezni. Az '''expr''' a paramétereket belül számként kezeli. '''Csak egész számokkal tud dolgozni!'''

<syntaxhighlight lang="bash">
# a képernyőre kerül az eredmény
expr 1 + 2
expr 4 * 4

# csak egész számot ír ki
expr 3 / 2
</syntaxhighlight>

Ha tört számokkal kell dolgoznunk, akkor a következőket tehetjük:
# eltávolítjuk a törtrészt
# felszorozzuk 10^n-nel, ahol n a törtrész számjegyeivel egyezik meg (pl. 10.02-t 100-al kell szorozni). Az egész térben elvégzett művelet eredményét később vissza osztjuk ugyanannyival, amennyivel korábban felszoroztuk. '''Ez nem egy egyszerű feladat, hiszen a tört számot egyáltalán nem kezeli az expr, tehát cut, wc és egyéb parancsokkal kell kialakítanunk a számot, ahogy utána szét is kell darabolnunk azt.'''
# Másik környezetet használunk, ahol tudunk számokat is kezelni - '''ez a ZH-n nem elfogadott'''

A lehetőségek közül csak az elsőt, a ZH-n teljes mértékben elfogadott megoldást mutatom be:
<syntaxhighlight lang="bash">
# a 3.4-et és a 1.2-őt kell összeadnunk.

# ennek eredménye 3
echo "3.4" | cut -d'.' -f1

# ennek eredménye 1
echo "1.2" | cut -d'.' -f1

# rakjuk össze
expr `echo "3.4" | cut -d'.' -f1` + `echo "1.2" | cut -d'.' -f1`
</syntaxhighlight>

=== Feladatok parancsokhoz ===
==== Írassuk ki a /etc/passwd több sorát ====
Több választási lehetőségünk van:
* ha a kiírandó sorszámok valamilyen logikát követnek (minden második, harmadik stb.), akkor használhatjuk a '''seq''' utasítást
* ha nincs logika a sorszámokban, akkor kézzel kell elkészítenünk a listát

<big>'''Logikát tartalmazó sorszámok'''</big> 
''Írassuk ki minden harmadik sor tartalmát'' 
<syntaxhighlight lang="bash">
# határozzuk meg a seq tartományát
# min: 1
# max: ahány sora van a fájlnak

# max érték meghatározás
# a változó létrehozást lentebb tárgyaljuk
max=`cat /etc/passwd | wc -l`

# lista meghatározása for ciklushoz
# 1-től $max-ig hármasával
seq 1 3 $max

# Rakjuk össze
for i in `seq 1 3 $max`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

<big>'''Logikát nem tartalmazó sorszámok'''</big> 
''Írassuk ki a 2., 5., 10. és 11. sorokat'' 
<syntaxhighlight lang="bash">
for i in `2 5 10 11`
do
head -$i /etc/passwd | tail -1
done
</syntaxhighlight>

==== Fájlok ellenőrzése és másolása ====
Másoljuk át a /etc/passwd állományt egy könyvtárba (~/test/destination). Ha a célkönyvtár nem létezik, akkor hozzuk létre. Ha a célkönyvtár és a fájl is létezik, akkor írjunk ki hibaüzenetet.

<syntaxhighlight lang="bash">
# forrás fájl létezésének vizsgálata
test -f /etc/passwd

# célfájl létezésének vizsgálata
test -f ~/test/destination/passwd

# mappa létezésének vizsgálata
test -d ~/test/destination

# rakjuk össze

# ha a forrásfájl nem létezik
if ! test -f /etc/passwd
then
echo "A forrásfájl nem létezik"
# ha a célfájl létezik
elif test -f ~/test/destination/passwd
then
echo "A fájl már létezik"
# ha a cél mappa nem létezik
elif ! test -d ~/test/destination
then
# mappa létrehozás - szülőkönyvtárakat is, ha nem léteznek
mkdir -p ~/test/destination
# fájl belemásolása
cp /etc/passwd ~/test/destination
# ha a célfájl nem létezik, de a célmappa igen
else
# a fájlt bemásoljuk a könyvtárba
cp /etc/passwd ~/test/destination
fi
</syntaxhighlight>

=== Script létrehozása ===
* Script megírása
* Futási jog

=== Pozicionális paraméterek ===

=== Változók ===

== 3. óra ==
A harmadik órán reguláris nyelvekkel foglalkozunk. A nyelv szintaktikai elemzése után a BASH-ben erre alkalmas szoftvert, a ''grep''-et foguk megvizsgálni.

=== Reguláris kifejezés szerkezete ===
A reguláris nyelvek atomokból, lezártakból épül fel, amelynek az eredménye az úgynevezett „összetettek”.

==== Atomok ====
Az atomok egy karakterre illeszkednek a sorban.
{| class="wikitable" style="margin: 0px auto;"
|-
! Atom !! jelentés
|-
| betűk, számok || saját magukra illeszkednek
|-
| ^ || sor elejére illeszkedik (csak egyszer lehet a legelején)
|-
| $ || sor végére illeszkedik (csak egyszer lehet a legvégén)
|-
| [abc] || halmaz: minden benne lévő elemre illeszkedik
|-
| [^abc] || inverz halmaz: egyetlen benne lévő elemre sem illeszkedik
|-
| . || mindenre illeszkedik
|-
|}

==== Lezártak ====
A lezártak ismétlődéseket fogalmaznak meg egy atomra vonatkozóan. '''Lezárt csak atom után helyezkedhet el!'''
{| class="wikitable" style="margin: 0px auto;"
|-
! Lezárt !! jelentés
|-
| * || az atomot 0 és végtelen között akárhányszor ismételheti
|-
| + || az atomot 1 és végtelen között akárhányszor ismételheti
|-
| ? || az atomot 0 és 1 között akárhányszor ismételheti
|-
| {n} || az atom pontosan n-szer fordul elő egymás mellett
|-
| {n,m} || az atomot n és m között akárhányszor ismételheti
|-
| {n,} || az atomot n és végtelen között akárhányszor ismételheti
|-
| {,m} || az atomot 0 és m között akárhányszor ismételheti
|-
|}

==== Összefűzöttek ====
Az atomok és a lezártak egymás után írt sorozata.
A lezártaknál fontos kitétel volt, hogy csak atom után lehet írni. '''Egy összefűzött újra atomizálható''' a ( ) karakterekkel.
Az összefűzöttek tartalmazhatnak uniót (|), ahol több szabály közül bármelyik megvalósulhat egy sikeres illesztéshez.

=== Parancsok és példák ===
Ez egy teszt szöveg, amin próbálkozunk.
A fenti szöveget alapul véve, a következő reguláris kifejezéseket hozhatjuk létre:
{| class="wikitable" style="margin: 0px auto;"
! Reguláris kifejezés !! Illeszkedik? || Magyarázat
|-
| E || Igen || Van a sorban E betű
|-
| a || Igen || Van a sorban a betű
|-
| b || Nem || Nincs a sorban b betű
|-
| ^E || Igen || A sor elején van az E betű
|-
| ^A || Nem || Nincs a sor elején A betű
|-
| ^e || Nem || nincs a sor elején e betű
|-
| .$ || Igen || Bármilyen karakter lehet a sor végén
|-
| \. || Igen || . van a sor végén
|-
| k$ || Nem || Nincs k a sor végén
|-
| egy || igen || Van a sorban „egy” string
|-
| egység || Nem || Nincs a sorban egység string
|-
| egy* || Igen || eg kötelező, y 0 vagy végtelenszer lehet (egy, egyy, egyyy, egyyyy ...)
|-
| l*egy || Igen || l 0 vagy végtelen, eg kötelező (eg, leg, lleg, llleg, lllleg ...)
|-
| l+egy || Nem || Nincs a szövegben "l+egy" string
|-
| l\+egy || Nem || l 1 vagy végtelen hosszú, egy kötelező (legy, llegy, lllegy, llllegy ...)
|-
| (egy) || Nem || Nincs a sorban "(egy)" string
|-
| $egy$ || Igen || Van a sorban "egy" string
|-
| $egy$* || Igen || Van a sorban legalább 0-szor "egy" string
|-
| $egy$\+ || Igen || Van a sorban legalább 1-szer "egy" string
|-
| $egy$\{2\} || Nem || Nincs a sorban pontosan kétszer "egy" string
|-
| [a-z] || Igen || Vannak benne kisbetűk
|-
| [A-Z] || Igen || Van benne nagy betű
|-
| ^[A-D] || Nem || Nincs a sor elején A-D tartományban betű
|-
| ^[A-Z] || Igen || Nagy betű van a sor elején
|-
| ^[A-Z].*\.$ || Igen || Nagybetűvel kezdőik, középen bármi lehet és ponttal végződik a sor.
|-
| [0-9] || Nem || Nincs számjegy a sorban
|-
| .* || Igen || Mindenre illeszkedik, bármilyen hosszan (üres sorra is)
|-
| ^$ || Nem || Csak az üres sorra illeszkedik
|-
| ^.\+$ || Igen || Mindenre illeszkedik, kivéve az üres sorra
|}

A következő kifejezés szintén illeszkedik:
^[A-Z].*$egy$\|$kettő$.*\.$ => A sor elején nagybetűvel kezdődik, van a közepén valahol benne "egy" vagy "kettő" karakterlánc és ponttal végződik. A köztes karakterek értéke nincs megszabva.

==== grep ====
A '''grep''' utasítás segítségével végezhetünk el reguláris kifejezés, tehát minta illesztést fájlokon. Amennyiben nem adunk meg fájl paramétert, a STDIN csatornát olvassa. Az eredmények a STDOUT-ra íródnak.

{| class="wikitable" style="margin: 0px auto"
|+ Fontosabb kapcsolók
|-
! Rövid név !! Hosszú név !! Magyarázat
|-
| -c || --count || Megszámolja az illeszkedő sorokat
|-
| -o || --only-matching || Csak a mintára illeszkedő részt írja ki (nem a teljes sort)
|-
| -n || --line-number || Megszámozza a sorokat (a fájl alapján, nem a megjelenítés szerint)
|}

===== Példa =====
<syntaxhighlight lang="bash">
# nologin környezetet futtató felhasználók listája a rendszerben
grep "nologin" /etc/passwd
cat /etc/passwd | grep "nologin" # STDIN-en érkező adatok szűrése

# bash környezetet futtató felhasználók listája a rendszerben
grep "bash" /etc/passwd
cat /etc/passwd | grep "bash" # STDIN-en érkező adatok szűrése
</syntaxhighlight>

===== Példa 2 =====
Írjunk egy scriptet, amely a /bin/bash futtatási környezetet kapó felhasználók nevét kiírja a képernyőre.

<syntaxhighlight lang="bash">
#!/bin/bash

# a fájl, amin dolgozunk
file="/etc/passwd"
# a fájl sorainak száma
lines=`cat $file | wc -l`

# végig megyünk a fájl sorain
for i in `seq 1 $lines`; do
# itt kapjuk meg az i. sort
line=`head -$i $file | tail -1`
# kiszedjük a shell környezetet
shell=`echo $line | cut -f7 -d':'`
# ha ez "/bin/bash", akkor kivágjuk a sor első oszlopát, ezt írhatjuk a képernyőre
if test $shell == "/bin/bash"; then
echo $line | cut -f1 -d':'
fi
done
</syntaxhighlight>
A fenti script futási ideje: 0.227s

<syntaxhighlight lang="bash">
#!/bin/bash
# a fájl, amin dolgozunk
file="/etc/passwd"
# szűrjük ki a sorokat, amelyeknek a végén a "/bin/bash" karakterlánc található és a kapott eredményhalmaznak vágjuk ki az első oszlopát
# a kapott eredményhalmaz még mindig megfelel a /etc/passwd eredeti formátumának, csak a sorok számát csökkentettük a szűrési feltételnek megfelelően!
grep "/bin/bash$" $file | cut -f1 -d':'
</syntaxhighlight>
A fenti script futási ideje: 0.003s

== 4. óra ==
A negyedik órán a reguláris kifejezések elkészítését gyakoroljuk különböző példákon keresztül. Főleg scripten belül használjuk.

== 5. óra ==
Az ötödik órán minta ZH feladatsort oldunk meg.

EDU::GAMF::Felhőalapú-szolgáltatások::AWS

2024-10-08T11:52:26Z

ApelPro: /* API indítás */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
[[category:GAMF AWS|AWS]]
== Amazon Web Services regisztráció ==
Az AWS mindenki számára biztosít 1 év ingyenes próbaverziót. Ehhez regisztrálnunk kell a rendszerbe, amihez szükségünk lesz egy email címre, egy telefonszámra a megerősítéshez és egy netes vásárlásra alkalmas bankkártyára. A regisztráció során az AWS 1$-ral meg terheli a számlát, de később erre nem tart igény, így a tranzakció lejáratakor jóváíródik a számlán.

== Ingyenes verzió korlátai ==
Az ingyenes verzióban nem minden érhető el és ami mégis, az sem korlátlan ideig (750 óra EC2 futási idő például), amit ha átlépünk, akkor fizetési kötelezettségünk jelentkezik a szolgáltató felé. Igyekezzünk mindent leállítani az órai munka illetve az otthoni gyakorlás után, hogy lehetőleg ne kerüljön pénzbe a féléves munkánk. A hallgatók által elszenvedett károkért sem az iskola sem Én nem tudunk felelősséget vállalni, de azt meg tudjuk ígérni, hogy fizetős szolgáltatást nem használunk és nem is kérünk számon.

== AWS alapok ==
'''Figyelem!''' Az iskolai hálózatból csak az eu-west-1 és az eu-central-1, azaz Írország és Frankfurt IP címei vannak engedélyezve, ezekre fogunk tudni SSH kapcsolaton keresztül csatlakozni. 
'''Figyelem!''' Próbaidőszak alatt minden szolgáltatás mellett keressük a ''Free tier eligible'' megjegyzést, különben fizetési kötelezettségünk adódhat!

=== EC2 szolgáltatásai ===
Az ''EC2'' gyakorlatilag egy VPS-nek feleltethető meg és nem is tévedünk vele hatalmasat. A neve az ''Elastic Cloud Compute'' szavak kezdőbetűiből kialakuló ''ECC''-ből fakad, a ''2''-es a végén jelzi, hogy a ''C'' betűből kettő van.

A különbséget a VPS-hez az EC2 futási ideje okozza: bár nem feltétlen, de meg van a lehetősége, hogy egyik napról a másikra megszűnjön egy EC2 úgy, hogy az alkalmazásunk mégis működőképes marad. E tulajdonsága miatt kapta az ''Elastic'' nevet, amit körültekintően kell kezelni: semmilyen adatot nem tárolhatunk úgy egy alkalmazáson belül, mint egy VPS esetén: a dinamikus adatok (pl. PHP Session, feltöltött fájok) egy EC2 csere esetén elvesznek, így ezeket nem helyben fogjuk tárolni.

Az EC2 szolgáltatásait a keresőmezőbe írt ''„EC2”'' kulcsszóval és az eredményekben megjelenő ''EC2''-re való kattintással érhetjük el.

[[Fájl:GAMFAWS search EC2.png.png]]

Az alapértelmezetten megjelenő menüpont a ''Dashboard'', ahol információkat találhatunk az ''EC2'' köré felhúzható szolgáltatásokról, melyeknek egy részét a továbbiakban tárgyalni is fogunk. Az összefoglaló táblázat az alább látható módon jelenik meg. '''Figyelem''', a táblázat csak az adott régióban elindított/elérhető szolgáltatásokat mutatja, régió váltása előtt érdemes az esetlegesen létrehozott, régió függő elemeket leállítani, hogy később ne jelenjen meg fizetési kötelezettség.

[[Fájl:GAMFAWS ec2 dashboard.png]]

==== EC2 telepítése és beállítása ====
EC2 létrehozásához meg kell nyomnunk a ''Launch instance'' gombot, melyet több helyen is elérhetünk:
* A Dashboardon
* A bal oldali menüben található ''Intances'' menüpont megnyitása után jobb felül
A gomb minden esetben a következőképp néz ki: [[Fájl:GAMFAWS ec2 launch instance button.png]]

A gombra kattintva egy űrlap jelenik meg, amely segítségével elvégezhetjük a szükséges beállításokat: 
======Név és tag beállítok======
Megadása nem kötelező, de több szerver futtatása esetén könnyebben azonosíthatjuk be őket ezek segítségével
[[Fájl:GAMFAWS ec2 setup name and tags.png]]

Az ''Add additional tags'' gombra kattintva további kulcs=érték párokat adhatunk hozzá, amivel dinamikusan csatolhatjuk össze egyéb szolgáltatásokkal, amelyek egy-egy kulcsot keresve döntik el, hogy melyik szolgáltatásokkal kell együttműködniük (például monitorozás bekapcsolása 'monitoring=true' kulcs=érték pár alapján.

======Kezdeti képfájl kiválasztása======
Az Amazon többféle indítóképpel is rendelkezik, így nagy valószínűséggel meg fogjuk találni a hozzánk közelálló operációs rendszert. Új hozzáadására nincs lehetőségünk, de készíthetünk az alapképfájlokból olyan verziót, ami már tartalmazza a saját konfigurációnkat (lásd [[GAMF :: Felhőalapú-szolgáltatások :: AWS#AMI_létrehozása|itt]]). 
[[Fájl:GAMFAWS ec2 setup AMI choose2.png]] 
Az órákon az Ubuntu legújabb verzióját használjuk, mivel ennek a Desktop változata az egyik legelterjedtebb a Linux felhasználók körében, így nem kell más környezetet megszoknia egy átlag hallgatónak. Érdemes lehet azonban egyéb disztribúciók kipróbálása is, különösen a '''Debian'''-t, '''Suse'''-t/'''OpenSuse'''-t, '''ReadHat'''-et és annak ingyenes változatait ('''AlmaLinux''', '''RockyLinuxtm''', amelyek az egykori '''CentOS'''-t hivatottak váltani), mivel céges környezetben ezek sűrűbben előfordulnak: némelyik a kisebb erőforrásigénye, míg másik az Enterprise szolgáltatásai miatt.

======Szerver típusának meghatározása======
Különböző erősségű szerverkonfigurációk közül választhatunk, de természetesen nem mindegyik érhető el az ingyenes verzióban. A számítógépek ára a konfiguráció függvényében változik, de csak azért az időért kell fizetni, amíg a szerver ''Running'' állapotban volt. Az órán az alapértelmezett ''t2.micro''-t használjuk. 
[[Fájl:GAMFAWS ec2 setup instance type.png]]

======Kulcspár hozzárendelése======
Az Amazonon belüli szolgáltatásokat felhasználónév/jelszó páros helyett SSH kulcspárok segítségével érjük el. Minden felhasználó számára készíthetünk egyet és jogosultságok segítségével korlátozhatjuk, hogy mihez férhet hozzá (IAM). 
Ebben a szekcióban ki kell választanunk, hogy a telepíteni kívánt EC2-höz milyen kulcspárral lehet majd hozzáférni. Amennyiben nem rendelkezünk még kulcspárral, úgy van lehetőségünk helyben elkészíteni a ''Create new keypair'' gomb segítségével, amelynek lépési megegyeznek az [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Kulcspár_létrehozása|itt]] leírtakkal. 
[[Fájl:GAMFAWS ec2 setup keypair.png]]

======Hálózati és biztonsági beállítások======
Az EC2-k közötti kommunikációs csatornák kialakításához definiálnunk kell, hogy melyik virtuális hálózatba akarjuk elhelyezni és milyen alkalmazásokat szeretnénk elérhetővé tenni. Ezt a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#VPC_beállításai|VPC]] és a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Security_Group|Security Group]] beállításával tehetjük meg. Előbbi a virtuális hálózatnak felel meg, míg utóbbi hasonlóan egy tűzfalhoz, meghatározza, hogy a szerveren milyen portokat érhetünk el. Érdemes az SSH-t engedélyezni és ha webes alkalmazást szeretnénk rajta futtatni a későbbiekben, akkor a HTTP és/vagy HTTPS szolgáltatást/szolgáltatásokat is, így később nem kell szerkeszteni ezeket a beállításokat. 
[[Fájl:GAMFAWS ec2 setup networking.png]]

======Tárhely beállítások======
Ebben a részben adhatjuk meg, hogy a szerverünk mekkora tárhellyel rendelkezzen. Egy Linux alapú operációs rendszernek nem kell 8GB-nél több, így az alapértéken hagyhatjuk. Az itt megadott érték inkább csak egy korlát, valójában csak akkora tárhelyet vesz igénybe, amennyire ténylegesen szüksége van a rendszernek. Ez az érték alatt látható figyelmeztetés miatt lényeges, hiszen a 30GB-t elhagyva fizetőssé válik a tárterület is, ám ez nem jelenti, hogy csak 4 szervert tudnánk elindítani az ingyenes keretek között. 
[[Fájl:GAMFAWS ec2 setup ebs.png]]

Ezt a szolgáltatást EBS-nek nevezik (''Elastic Block Store'') és az EC2 megszűnésekor minden erre mentett adat elveszik, így általában az OS-t és az applikáció kódját tároljuk ezen - semmi dinamikus adatot.

======Haladó beállítások======
Ebben a szekcióban különböző beállításokat végezhetünk el, ám ezeket az órán nem módosítjuk. Érdekes lehet azonban a menüt lenyitva legalul található ''User data'' opció, amivel parancsokat adhatunk meg az új operációs rendszer számára, hogy miket futtasson le. Ennek segítségével lehetőségünk nyílik applikációk telepítésére - pl. git - és a kód letöltésére egy másik szerverről, amennyiben a kiválasztott képfájl nem tartalmazta azt. 
''Az órai keretek között ezt a funkciót nem használjuk ki, de érdemes lehet kipróbálni, mivel valós alkalmazások üzemeltetésekor jól jöhet.'' 
[[Fájl:GAMFAWS ec2 setup userdata.png]]

======Összefoglaló======
A beállító panel mellett jobbra találhatjuk az összefoglaló ablakot, amelyben megtalálható a ''Launch Instance'' gomb. Ennek segítségével kezdhetjük meg a végleges telepítést, ha erre rá nyomunk, akkor a rendszer megkezdi a kiválasztott konfiguráció telepítését. Ha ebben az ablakban pénzösszegeket látunk, akkor az egészen biztosan fizetési kötelezettséget vonz magával, legyünk körültekintőek. 
[[Fájl:GAMFAWS ec2 setup summary.png]]

======Az elkészült instance tulajdonságai======
A futó szerverek az ''Instances'' menüpontban érhetők el. Az egyes sorokra kattintva alul megtekinthetjük a beállításait, amely tartalmazza az AWS által kiosztott publikus és privát IP címeket és domain neveket. Ezeken keresztül tudunk kommunikálni szerverünkkel. 
[[Fájl:GAMFAWS ec2 properties.png]] 
''Jelen példában a külső IP címünk: 3.252.168.207, amit a mellette található ikonnal egyszerűen a vágólapra másolhatunk.''

======Csatlakozás Linux terminálból======
A csatlakozáshoz nyissunk meg egy terminált a CTRL+T billentyűkombinációval, majd navigáljunk a ''cd'' parancs segítségével a letöltött kulcsfájl mappájába. Az SSH megköveteli, hogy a csatlakozáshoz használt kulcsfájlhoz csak a tulajdonos felhasználó férjen hozzá, így a következő parancsot futtassuk le rajta: ''chmod 600 test.pem''

A következő paranccsal tudunk kapcsolódni: ''ssh -i test.pem ubuntu@3.252.168.207'' 
Ha a fenti parancs kéri, fogadjuk el a tanúsítványt. Amennyiben ''Permission error'' hibát kapunk, akkor a fenti ''chmod'' parancsra van szükségünk, vagy nem mi vagyunk a kulcsfájl tulajdonosai (''ls -l'' segíthet). 
A ''test.pem'' az AWS rendszerből letöltött .pem formátumú kulcsfájl, az ''ubuntu'' a szerveren elérhető felhasználó. A különböző disztribúcióknál használt felhasználónevekről [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connection-prereqs.html ezen] a linken tájékozódhatsz. 
[[Fájl:GAMFAWS ec2 connect linux.png]]

======Csatlakozás Putty használatával======
Amennyiben a .pem kiterjesztésű állományt töltöttük le az AWS rendszeréből, akkor a '''puttygen''' eszköz segítségével ki kell exportálni belőle a privát kulcsot. [https://www.ssh.com/academy/ssh/putty/windows/puttygen Ezen a linken] részletes segédlet található a programcsomaghoz, ahol további funkciók is bemutatásra kerülnek (pl. kulcsgenerálás).

==== Kulcspár létrehozása ====
A kulcspárok kezeléséhez a ''Key Pairs'' linket nyissuk meg a bal oldali menüből. Újat a jobb oldalon látható ''Create key pair'' gomb segítségével készíthetünk. [[Fájl:GAMFAWS ec2 keypair create.png]]

A gombra kattintva egy űrlapot kapunk, amely végig vezet minket a létrehozás lépésein.
# Név megadása
# Típus kiválasztása - ''RSA-val dolgozunk az órán''
# Letöltendő kulcs típusa - ''Linux terminálból való csatlakozáshoz a .pem fájlra lesz szükségünk''
# Esetleges tag-ek hozzárendelése
# A ''Create key pair'' gombra kattintva letölthetjük a kulcspárt

[[Fájl:GAMFAWS ec2 keypair setup.png|Kulcspár létrehozása]]

'''Figyelem!''' A kulcspár csak a létrehozás után tölthető le '''egyetlen egyszer''', az elvesztett fájlok nem reprodukálhatók! Amennyiben egy EC2 csak az elhagyott kulcspárral érhető el, úgy annak (EC2) törlése és újrakonfigurálása szükséges egy új kulccsal.

==== Security Group ====
A Security Group-ok segítségével kontrollálhatjuk, hogy a szervereinkhez milyen portokon férhetnek hozzá, tehát mintegy tűzfal működik. Egy Security Group több gépre is ráhúzható és függetlenül működik, azaz a megadott szabályokat nem másolja át az operációs rendszer konfigurációs állományaiba, mintegy a szerver elé telepített eszköz működik. Ennek köszönhetően futási időben változtathatjuk a szabályokat, életbelépésükhöz nem kell újracsinálni az EC2-ket.

A bal oldali sávban, a ''Network & Security'' csoportban érhető el.

===== Security Group hozzáadása =====
Egy új szabályrendszer felvételét kezdeményezhetjük az EC2 telepítésekor, ahogyan azt [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Hálózati_és_biztonsági_beállítások|itt]] is láthattuk, de készíthetünk előre meghatározottakat is.

Az előre definiált csoportokat a ''Create Security Group'' gomb segítségével hozhatjuk létre, amelyet a jobb felső sarokban találhatunk meg. 
[[Fájl:GAMFAWS ec2 secg new button.png|bélyeg]sdfsad] 

A gomb megnyomását követően egy űrlapot kapunk, melynek 3 fő része van:
# Általános adatok [[Fájl:GAMFAWS ec2 secg new basic.png|bélyeg|Általános adatok]]
#* '''A név és a leírás mező megadása is kötelező'''
#* Itt választhatjuk ki, hogy mely VPC-ben szeretnénk elérhetővé tenni.
# Bejövő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg inbound.png|bélyegkép|Inbound rules]]
#* '''Az itt megjelenő szabályok lesznek engedélyezve a szerverünk felé, minden más csomag eldobásra kerül'''
#* Háromféle szabályból választhatunk:
#** '''Anywhere''' (IPv4, IPv6): A megadott IP típusból mindenhonnan elfogadjuk a csomagokat
#** '''Custom''': Csak a megadott IP címekről/IP tartományokból érjük el az adott portot
#** '''MyIP''': automatikusan beillesztésre kerül az felhasználó aktuális IP címe (hasonló a custom lehetőséghez)
# Kimenő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg outbound.png|bélyegkép|Outbound rules]]
#* A kimenő forgalom szabályozása biztonsági szempontból megfontolandó, de természetesen a publikus alkalmazások esetében (pl. web) nem tudunk ilyen szűrést alkalmazni.
#* Alkalmazhatjuk például SSH-ra, hogy megszüntessük annak a lehetőségét, hogy egy esetleges fertőzésből kifolyólag SSH-t hackelgető botnetté változzunk (volt már hasonló tapasztalat).
#* Az órán ezzel bővebben nem foglalkozunk, de éles környezetben ne felejtsünk el ezen szabályok definiálására időt szánni.
# Tag-ek megadása

===== Security Group szerkesztése =====
A szerkeszteni kívánt soron kattintsunk jobb gombbal és válasszuk ki a szerkeszteni kívánt szabályok csoportját:
* '''Edit inbound rules''', ha a bejövő csomagok szűrését szeretnénk módosítani,
* ''' Edit outbound rules''', ha a kimenő forgalmat szeretnénk szűrni.
A megnyíló ablakban ugyanazon a módon vehetünk fel szabályokat, ahogyan a létrehozásnál. A módosítások mentés után életbe lépnek. 
[[Fájl:GAMFAWS ec2 secg context menu.png]]

==== Terheléselosztás vázlat ====
[[Fájl:EC2LoadBalancingRequirements.png|középre]]

==== AMI ====
Az AMI gyakorlatilag egy bitről-bitre lemásolt HDD képfájl, amely tömörítve lett. Így tárolja az összes elmentett adat- és konfigurációs állományt. Ha egy alkalmazást készítünk, akkor a következő okokból készítünk ilyen képfájlt:
# Biztonsági mentés a telepített szolgáltatásokról, így később nem kell egy esetleges hiba miatt újrakonfigurálni az egészet
# AutoScaling group-ba szeretnénk rendezni az alkalmazásunkat, annak pedig meg kell mondani, hogy melyik képfájlt indítsa el

'''Figyelem!''' A képfájlok úgynevezett snapshot-okat hoznak létre, amelyek tárolásáért fizetni kell, ha az összméret meghaladja a 8GB-ot. (A snapshotok az éppen futó rendszer miatt készülnek: minden írási műveletet lezár, majd a snapshot készítés után elindított írási műveletek már a háttértár egyéb területeire történik, amelyet a mentés nem fog tartalmazni, így garantálható, hogy nem lesznek félig lezárt fájlok a mentésben. Lásd bővebben: BTRFS (linux) és NTFS support). A pillanatképek nem törölhetők, amíg a belőlük készült AMI létezik!

===== AMI létrehozás lépései =====
'''Navigáljunk az Instances menüpontra, ahol láthatjuk, hogy milyen EC2 szolgáltatások vannak a rendszerünkben.'''
# Kattintsunk jobb gombbal azon az elemen, amelyet menteni szeretnénk
# Nyissuk ki az ''Image and templates'' menüpontot
# Kattintsunk a ''Create image'' lehetőségre 
[[Fájl:GAMFAWS ec2 ami create.png]]

'''Nevezzük el a képfájlt tetszés szerint''' 
[[Fájl:GAMFAWS ec2 ami setup.png]]

'''Navigáljunk a bal oldalon található menüben az ''Images'' szekcióhoz és válasszuk ki az ''AMIs'' elemet. Itt megtekinthetjük és törölhetjük a létrehozott képfájljainkat.''' 
[[Fájl:GAMFAWS ec2 ami list.png]]

'''Ha a mentés sikeresen elkészült, akkor az EC2 létrehozásánál kiválaszthatjuk azt.''' 
[[Fájl:GAMFAWS ec2 setup own ami select.png]]

==== Indítási konfigurációk elkészítése ====
Az indítási konfigurációk mind egy célt szolgálnak: egységes profilba rendezi az EC2-ről készült képfájlokat. Míg az AMI nem tárolt információt a mentett gép erőforrásáról, egy indítási konfigurációban megadhatjuk ezeket. Később ezek felhasználásával egyszerűbben indíthatunk újabb szervereket és vannak olyan esetek is, amikor a rendszer megköveteli, hogy a képfájl megadása helyett konkrét, hardverinformációkat is tároló konfigurációs sablonokat adjunk meg.

''Az Auto Scaling Group például megköveteli, hogy a következő kettő elem közül az egyiket megadjuk, ebből fogja tudni, hogy milyen típusú EC2-t, mekkora tárhellyel és milyen VPC-ben indítson el.''

===== Launch configuration =====
'''Egy kifutóban lévő konfigurációs séma, amely 2022. December 31-e után nem kapja meg a frissítéseket. Az AWS javaslata szerint érdemes ezeket a beállításokat a következőkben tárgyalt ''Launch template'' alá migrálni.

A ''Launch configuration'-nek nevezett séma egy egyszerűsített változata a sablonoknak. Jóval kevesebb beállítási lehetőséget tartalmaz, mint a párja, de tökéletesen elegendőt az ''Auto Scaling Group''hoz.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Auto Scaling group'' szekciót és válasszuk ki a ''Launch Configuration'' menüpontot. A jobb felső sarokban található ''Create launch configuration'' gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''Név megadása''', aminek segítségével később hivatkozhatunk erre az elemre. Kitöltése kötelező! 
[[Fájl:GAMFAWS ec2 launch conf setup name.png]]

''AMI kiválasztása'', tehát azok képfájl megadása, amit a kiválasztott EC2 konfiguráció futtatni fog. Lehetőségünk van a saját készítésű (''My AMIs'') és a közösségi képfájlok közül választani (''Marketplace''). 
[[Fájl:GAMFAWS ec2 launch conf setup ami.png]]

'''Instance típus''' alatt megadhatjuk, hogy a konfiguráció milyen teljesítményű legyen.
'''Ne feledjük el, hogy a t2.micro az ingyenes, a többi használata után fizetési kötelezettségünk jelenhet meg.'''
[[Fájl:GAMFAWS ec2 launch conf setup instance type.png]]

'''Az Additional configruation''' részben megadhatunk különböző paramétereket, amelyeket az EC2 fog felvenni - pl. mindenképp kapjon IP címet, a subnet beállításaitól függetlenül, vagy éppen ne kapjon; itt adhatjuk meg a telepítéskor lefuttatott scripteket (User data).

'''A Storage''' szekcióban megadhatjuk, hogy milyen lemezek és milyen méretűek legyenek a rendszerhez csatolva.

'''A Security Group''' részben kiválaszthatunk egy már meglévő szabályrendszert, vagy készíthetünk újat. 
[[Fájl:GAMFAWS ec2 launch conf setup secg.png]]

'''A Key pairs''' blokkban megadhatjuk, hogy milyen privát kulccsal léphetnek be a szerverekre. Ennek meglétét jóvá kell hagyni az alul található checkbox-szal. 
[[Fájl:GAMFAWS ec2 launch conf setup keypair.png]]

'''Végül kattintsunk a ''Create launch confgiration'' gombra a létrehozáshoz.'''

===== Launch template =====
A Launch template jóval gazdagabb a beállítási lehetőségekben, mint párja. A konfigurációs adatlap tartalmaz segédletet az AutoScaling Group-pal történő használathoz, amely ''required'', azaz kötelező mezőként jelöli meg azokat az adatbeviteli elemeket, amelyeket az automata skálázó rendszer használ. Érdemes ezt bekapcsolni, amennyiben ilyen célzattal készítjük el a sablonunkat.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Instances'' szekciót és válasszuk ki a ''Launch template'' menüpontot. Az oldal közepén vagy a jobb felső sarokban található Create launch configuration gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''A sablon neve és leírása''' blokkban megadhatjuk a nevet és a leírást, de ugyanakkor itt választhatjuk ki azt a checkboxot is, ami később a segítségünkre lesz a konfigurációs sablon AutoScaling Group-hoz való illesztését is (''Auto Scaling guidence''). 
[[Fájl:GAMFAWS ec2 launch templ setup name.png]]

'''Az Application and OS images''' szekcióban megadhatjuk, hogy milyen AMI-val települjön az EC2. Itt választhatunk a sajátunkból, vagy az EC2-nél is megtalálható egyebekből. 
[[Fájl:GAMFAWS ec2 launch templ setup ami.png]]

'''Az Instance type''' csoportban megadhatjuk, hogy milyen teljesítményű gépet szeretnénk indítani.
'''Ne feledjük el, hogy az ingyenes változatban a t2.micro érhető el, másik lehetőség választása esetén fizetési kötelezettségek léphetnek fel!''' 
[[Fájl:GAMFAWS ec2 launch templ setup instancetype.png]]

'''A Key Pair''' blokkban megadhatjuk, hogy a gépek milyen kulcspárral engedélyezzék a belépést. 
[[Fájl:GAMFAWS ec2 launch templ setup key pair.png]]

'''A Network Confguration''' részben definiálhatjuk, hogy milyen VPC-be szeretnénk lerakni az EC2-ket, milyen security group legyen rajtuk. Természetesen utóbbi helyben is létrehozható, ha korábban ezt nem készítettük volna el. 
[[Fájl:GAMFAWS ec2 launch templ setup network.png]]

'''A Storage'''-nél megadhatjuk, hogy milyen kötetek, milyen méretben legyenek hozzácsatolva a rendszerhez.

'''A Tags''' blokkban felvehetjük a kívánt ''kulcs=érték'' párokat.

'''Az Additional Configuration''' szekcióban különböző haladó beállításokat eszközölhetünk a sablon által létrehozott EC2-n, többet között itt adhatjuk meg az indításkor lefuttatandó parancsok listáját (''User data'').

'''Végül kattintsunk a Create launch template nyomógombra a mentéshez!'''.

==== Target Group ====
A target group EC2-k azon csoportja, amelyeken valamilyen ''health check'' algoritmust futtatunk, ezzel meghatározva, hogy az adott csoportban hány használható, működő szerver fut. Ezt az információt elsőként a Load balancer használja ki.

A Target Group a bal oldali menüben, a ''Load Balancing'' szekcióban érhető el ''Target Groups'' néven.

Létrehozhatunk új csoportot, de meg kell adnunk, hogy milyen módon kerüljenek bele az EC2-k. Erre a következő metódusokat ajánlja fel az Amazon:
# Konkrét EC2 (Instance) kiválasztása
# EC2-k definiálása IP tartománnyal
# Lambda függvény hozzáadása
# Alkalmazás LoadBalancer, amely egy teljes VPC tartalmát magába foglalja.

Az űrlap alján megadhatjuk, hogy milyen életjel ellenőrzés történjen.

Általában nem mi vesszük fel egyesével az Instancokat ebbe a csoportba, hanem az AutoScaling group regisztrálja őket bele. '''Ezért ezt az űrlapot nem használjuk'''.

==== Load Balancer ====
A Load Balancer terheléselosztást jelent, tehát a bejövő forgalmat több gép között osztjuk el. Ezzel növekszik a felhasználói élmény, ráadásul a rendszer megállítása (egy hacker által) nehezebbé válik: ha kettő t2.micro teljesítményű szerver fut, amelyek között elosztjuk a bejövő forgalmat, akkor a rendszerünk valójában 2xt2.micro teljesítményű.

Terheléselosztót a bal oldali menü ''Load Balancing'' szekciójának ''Load Balancers'' menüpontjában hozhatunk létre.

'''A támogatott szolgáltatási szintek:'''
# Alkalmazás terheléselosztás (HTTP, HTTPS)
# Hálózati terheléselosztás (TCP, UDP)
# Átjáró terheléselosztása (GW)

===== Alkalmazás terheléselosztása =====
Ebben a formában konfigurálhatjuk az eszközt úgy, hogy az internet felől elérhető legyen (internet-facing) és úgy, hogy csak belső hálózaton működjön (internal). A belső hálózatot mindig az aktuális VPC-re kell érteni, tehát annak minden alhálózatából elérhető alapértelmezetten.
[[Fájl:GAMFAWS ec2 loadbalancer setup basic.png]]

A hálózati beállításoknál választhatunk, hogy mely alhálózatokban szeretnénk végrehajtani a terheléselosztást, így csak az azokban futó EC2-k kaphatnak ezen keresztül csomagokat. Arra kell ügyelnünk, hogy legalább kettő különböző zónában lévő alhálózatot kell kiválasztanunk (pl. eu-west-1a, eu-west-1b stb.).
[[Fájl:GAMFAWS ec2 loadbalancer setup network.png]]

Természetesen a LoadBalancer internetfelőli végpontján létrehozhatunk ''Security Group''okat, amelyet szabályozzák, hogy milyen IP címről fogadunk el csomagokat.
[[Fájl:GAMFAWS ec2 loadbalancer setup secg.png]]

A ''Listeners and routing'' résznél megadhatjuk, hogy melyik target group fogja a terhelést fogadni, tehát hogy mely EC2-k között tudunk ténylegesen terhelést elosztani. Amennyiben a target group egy darab EC2-t tartalmaz, akkor a terheléselosztás gyakorlatilag nem valósul meg, csak az elméleti esélyét adtuk meg, hogy ''„amennyiben lenne még egy EC2 a target group-ban, akkor a terhelés egy részét az vinné el”''.
[[Fájl:GAMFAWS ec2 loadbalancer setup routing.png]]

Végül kattintsunk a ''Create load balancer'' gombra, amennyiben a kívánt tag-eket is rögzítettük.

==== Auto Scaling Group ====
A szolgáltatás segítségével automatikusan skálázott rendszereket építhetünk ki, ahol a szerverek által nyújtott elérhető erőforrásokat minél közelebb tartja a bejövő terhelés által meghatározott erőforrásigényhez. Természetesen mindez akkor igaz, ha az ''Auto Scaling Group'' be regisztrálja az általa létrehozott ''EC2''-ket egy ''Target Group''-ba, ami felett ''Load Balancing'' van definiálva.

'''Előnyei''':
* Amikor nincs bejövő terhelés, akkor nincsenek nagy költségek
* Amikor nagy a bejövő terhelés, akkor a költségek megugranak ugyan, de az ügyfeleket ki tudtuk szolgálni úgy, hogy elégedettek voltak a rendszer teljesítményével.

'''Hátrányai''':
* Kaotikus számlák, nem előre tervezhető költségek
* Megnövekedett költségek DDoS és egyéb támadások esetén

===== A beállítás lépései =====
A szolgáltatást a bal oldali menü ''Auto Scaling Group'' szekciójában érjük el, az ''Auto Scaling Group'' menüpontban. A képernyő közepén vagy a képernyő jobb felső sarkában megjelenő ''Create auto scaling group'' gombra kattintva egy űrlap jelenik meg, ami végig vezet minket a telepítés lépésein.

'''A Name''' szekcióban elnevezzük az új group-ot.
[[Fájl:GAMFAWS ec2 autoscaling setup name.png]]

'''A következő szekcióban''' két választási lehetőségünk van:
* Launch Template-tel telepítjük az új group-ot, ez esetben csak ki kell választanunk a korábban létrehozott sablont, vagy az alatta található link segítségével készíthetünk újat. ''Amennyiben újat készítünk, a sablon létrehozása új ablakban nyílik meg, így a befejezést követően vissza kéne térnünk erre és a frissítést gombot megnyomva látni fogjuk az új lehetősége(ke)t.
[[Fájl:GAMFAWS ec2 autoscaling setup lt.png]]

* Launch Configuration-nel telepítjük az új group-ot, ez esetben át kell váltatnunk a ''Switch to launch configuration'' link segítségével a blokkot. A váltást követően hasonlóan az előzőekhez: vagy kiválasztjuk a már meglévő konfigurációs sémát, vagy hozhatunk létre újat.
[[Fájl:GAMFAWS ec2 autoscaling setup lc.png]]

'''A Next gombra kattintva a hálózati beállítások''' szekcióhoz érünk, ahol megadhatjuk, hogy az indított EC2 milyen VPC-be kerüljön és azon belül milyen alhálózatokba. VPC-ből egy, alhálózatból több is kiválasztható. Ügyeljünk rá, hogy ha később erre Load Balancer szolgáltatás is kerül, akkor legalább kettő zónát jelöljünk ki!
'''Figyelem!''' A zóna nem egyezik meg az alhálózattal!
[[Fájl:GAMFAWS ec2 autoscaling setup network.png]]

'''A Next gombra kattintva a Load Balancing beállítások''' következnek, ahol választhatunk:
* Nincs terheléselosztás opciót,
* Létező Load Balancer hozzáillesztését,
* Új Load Balancer létrehozását.

Utóbbi esetében a Load Balancer konfigurálásánál leírt módon ki kell töltenünk a Load Balancer űrlapját is helyben. 
[[Fájl:GAMFAWS ec2 autoscaling setup lb setup.png]]

Hasonlóan a ''Target Group''-ot is létrehozhatjuk helyben, amennyiben ezt nem tettük meg korábban.
[[Fájl:GAMFAWS ece autoscaling setup new lb new tg.png]]

'''A Next gombra kattintva a csoport méretét definiálhatjuk''', azaz megszabhatjuk, hogy hány darab szervertől, hány darab szerverig engedélyezzük az automatikus skálázást. Ez egy hasznos funkció, hiszen ezzel korlátok közé szoríthatjuk a költségeinket, miközben a legkisebb terhelés esetén is előkészülhetünk egy hirtelen bejövő nagyobb terhelésre (ha a minimum nem 1).
* Desired capacity: ennyi szervert fog elindítani az ASG mentés után
* Minimum capacity: ennyi szerver esetén már nem állít le semmit az ASG
* Maximum capacity: ennyi szerver esetén már nem indít el újabbat az ASG
[[Fájl:GAMFAWS ec2 autoscaling setup group.png]]

'''Alatta a Scaling Policy''' blokkban megadhatjuk, hogy milyen paraméterek mentén indítson vagy épp állítson le szervereket az ASG. Ehhez aktiválnunk kell a szolgáltatást és a ''Metric type'' listából ki kell választani az számunkra megfelelőt. Mi általában CPU terhelés alapján döntünk az órán.
[[Fájl:GAMFAWS ec2 autoscaling setup scaling.png]]

'''A Next gombokkal lépkedve hozhatunk létre Tag-eket, majd végül létrehozhatjuk az ASG-t is és az ''Instances'' menüpontban ellenőrizhetjük, hogy ténylegesen elindult a kívánt darabszámú szerver.'''

=== RDS szolgáltatások ===
A ''Relational Database Service'' foglalja magában a különböző adatbázisokat:
* MariaDB
* MySQL
* Aurora
* Oracle
* PostgreSQL
* MSSQL

'''Figyelem!''' Az itt felsorolt szerverek között lehetnek fizetősek is. Mindig járjunk el figyelmesen, kövessük a költségeket. Az RDS az amazon egyik legdrágább szolgáltatása.

==== MySQL adatbázis telepítése ====
==== Csatlakozás MySQL adatbázishoz CLI-ből ====
<syntaxhighlight lang="bash">
apt install mysql-client -y
# mysql -h<rds_endpoint> -u<rds_user> -p<rds_password>
mysql -hwebshop-989.rds.amazon.com -uadmin -p123456789
</syntaxhighlight>

A megnyíló '''mysql>''' PROMPT-ot tartalmazó sor azt jelenti, hogy sikeresen csatlakoztunk az SQL szerverhez. Amennyiben a csatlakozás sikertelen, akkor valószínűleg az RDS-hez kapcsolt Security Group beállításai nem engedik az EC2-ről a kapcsolódást - tipikusan a mi saját publikus IP címünk kerül bele az engedélyezett tartományba (pl. iskolai IP vagy otthoni) és ez nem került átírásra az amazonos tartománynak megfelelően.

A konzolra be kell illeszteni a ''networks.sql'' fájl tartalmát. A végén '''exit''' paranccsal léphetünk vissza a BASH környezetbe.

=== VPC ===
A '''V'''irtual '''P'''rivate '''C'''loud egy szolgáltatás, melynek segítségével össze köthetjük az összetartozó komponenseket, alkalmazásokat. A VPC-t modellezhetjük hétköznapibb értelemben, mint egy routert, amelynek vannak alhálózatai, route táblája és valamilyen gateway címe, amin keresztül a kliensei az internet más résztvevőivel tudnak kommunikálni.

A VPC szolgáltatásait a keresőbe írt ''VPC'' kulccsal érhetjük el.
==== VPC létrehozása ====
Navigáljunk a 'Your VPCs' menüpontra a bal oldali menüben és kattintsunk a jobb felső sarokban látható ''Create VPC' gombra. Ezután megnyílik egy űrlap, amely végig vezet minket a telepítés lépésein.

Az űrlap elején választhatunk, hogy ''VPC only'' vagy ''VPC and more'' módban szeretnénk folytatni. Előbbi csak a VPC-t hozza létre nevéből is adódóan, míg a másik opcióval létrehozhatjuk az alhálózatokat is, igaz, a tervezés szabadságáról le kell ilyenkor mondanunk, cserébe grafikán láthatjuk az eredményt. Számunkra az órán utóbbi nem lesz megfelelő, hiszen szükségünk lesz a ''tervezés szabadságára''. 
[[Fájl:GAMFAWS vpc setup.png]]

A VPC beállításainál mindig a teljes hálózatot átfogó IP/MASZK párost kell megadnunk, később az alhálózatok nem lóghatnak ki az itt megadott tartományból.

==== Alhálózatok ====
Az alhálózatok lehetőséget biztosítanak arra, hogy az egyes komponenseket el is szigeteljük egymástól, meg engedélyezzünk is közöttük bizonyos kommunikációt.

Alhálózatok típusai:
* Publikus: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten kapnak publikus IP címet
* Privát: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten nem kapnak publikus IP címet

===== Alhálózatok létrehozása =====
Navigáljunk a ''Subnets'' menüpontra. A képernyő jobb felső sarkában kattintsunk a ''Create subnet'' gombra, így megkapjuk a létrehozási űrlapot.

'''Először''' a VPC-t kell kiválasztanunk, aminek eredményeképp kiírja segítségképp annak tartományát. Ezen a tartományon kívül nem léphetünk. 
[[Fájl:GAMFAWS vpc subnet setup.png]]

A VPC kiválasztása után aktívvá válik az alhálózatok űrlap, ahol megadhatjuk annak nevét, hálózati címét és maszkját. 
[[Fájl:GAMFAWS vpc subnet setup new.png]]

'''Figyelem!''' A rendszer csak hálózati címet fogad el! Minden más esetben hibát ír ki.

A ''Remove'' gombbal eltávolíthatjuk az aktuális konfigurációt a listából, míg a lentebb található ''Add new subnet'' segítségével újabbat vehetünk fel.

Befejezésül nyomjuk meg a ''Create subnet'' gombot, így az összes definiált alhálózat létrejön a kiválasztott VPC-hez.

===== Publikus/Privát alhálózat beállítása =====
Az alhálózat típusának átállításához navigáljunk a ''Subnets'' menüpontra. Kattintsunk jobb gombbal a kívánt alhálózat során és válasszuk ki az ''Edit subnet settings'' opciót. 
[[Fájl:GAMFAWS vpc subnet edit s settings.png]]

Az űrlapon keressük meg az ''Auto-assign IP settings'' blokkot és a kívánt típusnak megfelelően módosítsuk azt.
[[Fájl:GAMFAWS vpc subnet edit type.png]]

===== Különböző route tábla minden alhálózaton =====
A VPC támogatja, hogy minden subnet saját route táblával rendelkezzen. Ez lehet akár egy biztonsági funkció is, hogy ne ismerje minden EC2 az útvonalat egy adott szerverhez, de egyes esetekben kötelezően létre kell hoznunk. A route táblákat a ''Route tables'' menüpontban hozhatjuk létre és a ''Subnets'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Edit route table association'' opciót kiválasztva szerkeszthetjük.

'''Figyelem!''' A route táblák cseréje okozhat internetelérési problémákat szerver oldalon, aminek következtében a futó szolgáltatások számunkra is elérhetetlenekké válnak (pl. SSH és/vagy HTTP/HTTPS stb.), így legyünk körültekintőek.

==== Internet Gateway ====
Ahhoz, hogy a VPC-n belül legyen internet, ahhoz egy IGW-t kell hozzá csatolnunk. Ezt megelőzően azonban létre kell hoznunk egyet.
'''Figyelem!''' A VPC-hez nem kapcsolt IGW-k pénzbe kerülhetnek, mivel feleslegesen foglalnak le egy publikus IPv4 címet.

[[Fájl:GAMFAWS vpc igw setup.png|bélyegkép|Internet Gateway létrehozás]]
Az IGW az ''Internet Gateways'' menüpont alatt érhető el és a jobb felső sarokban található ''Create internet gateway'' gombbal hozhatunk létre újat. Csupán egy nevet kell megadnunk, illetve rakhatunk rá tag-eket igény szerint.

A létrehozást követően hozzá kell rendelnünk egy létező VPC-hez, amit az ''Internet Gateways'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Attach to VPC'' opciót kiválasztva tudunk megtenni. Amennyiben a soron az ''Attached'' (zöld színű) felirat jelenik meg a (szürke színű) ''Detached'' helyett, akkor nem tudjuk VPC-hez csatolni (ilyenkor először a ''Detach from VPC'' opciót kell választanunk). 
[[Fájl:GAMFAWS vpc igw attach.png]]

Az IGW VPC-hez rendelése után a kívánt route táblákba fel kell vennünk, hogy minden csomagot arra irányítson.
[[Fájl:GAMFAWS vpc igw route setup.png]]

==== NAT Gateway ====
Lehetőség van Internet Gateway helyett NAT Gateway létrehozására is, de ez egy fizetős szolgáltatás. A nevének megfelelően ez lehetőséget biztosít, hogy azok az EC2-k, amelyek privát alhálózatba kerültek, kilássanak az internet felé (pl. frissítések keresése, telepítése), miközben védve vannak a kívülről érkező támadásoktól.
'''Ez egy lehetséges oka lehet, hogy külön válasszuk a route táblákat az alhálózatokon, hiszen az egyiknek minden csomagot az IGW felé, míg a másiknak minden csomagot a NAT Gateway felé kell továbbítania.''' ''Ha nem használunk NAT Gatewayt, akkor is érdemes lehet leválasztani az IGW-ről a privát alhálózatokat.''

=== AWSCLI ===
Az AWSCLI egy konzolos alkalmazás, amelynek segítségével menedzselhetjük környezetünket: hozhatunk létre új EC2-t akár, vagy kapcsolhatunk hozzá egyéb szolgáltatásokat (Security Group, ASG, LB stb.).

Az awscli program elérhető linux és windows környezetben egyaránt.

==== AWSCLI telepítése ====
A program telepítéséhez a következő parancsot kell futtatnunk: '''apt install awscli'''.
==== Access Key management ====
Az ''awscli'' hozzáférési kulcsokon keresztül kap jogosultságot a szolgáltatások adataihoz, így használata előtt készítenünk kell egy újat. Ez a nevünkre kattintva (jobb felül), majd a ''Security credentials'' menüpontot kiválasztva tehetjük meg, az ''Access keys'' szekcióban. Nyissuk ezt le és kattintsunk a ''Create New Access Key'' gombra. 
<center>
{|
| [[Fájl:GAMFAWS UserMenu.png|150px|keretnélküli]] || [[Fájl:GAMFAWS SecurityCredentials.png|keretnélküli]]
|}
</center>

A gomb megnyomása után egy felugró ablak fogad, amelyben megtalálható az ''Access Key'' és a ''Security Access Key'' értéke. Érdemes a fájlt letölteni, hogy később is elérhetők legyenek ezek az adatok, '''az AWS többet nem fogja engedélyezni ezek megjelenítését!''' Ha az adatokat később nem tudjuk megadni, akkor újat kell készíteni.
[[Fájl:GAMFAWS SecurityCredentials ShowData.png|középre]]

==== AWS CLI konfigurálás autentikációs adatokkal ====
Az eszköz telepítése annak konfigurálásával ér véget: meg kell adnunk az autentikációs tokeneket. 
Ezt az '''aws configure''' parancs kiadásával tehetjük meg, ahol egyesével bekéri a szükséges adatokat. Ahol nem szeretnénk változtatni az előző értéken (szögletes zárójelek között láthatjuk ezt), ott hagyjuk üresen a sort és csupán entert nyomjunk.
[[Fájl:GAMFAWS AWSCLI config.png|középre]]

Az adatok megadása után menedzselhetjük az aws parancsokkal a környezetünket. Az aws parancsairól az '''aws help''' szolgáltat információt.

=== S3 ===
Ez a szolgáltatás fájlok tárolására alkalmas.

Több típusa is elérhető:
* Standard:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban sűrűn használt objektumok tárolására alkalmas
** A régiók közötti szinkronizáció megoldott
* Instant Glacier:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban ritkábban használt, hosszú élettartamú, de azonnali hozzáférést igénylő objektumok tárolására alkalmas
* Flexible Glacier:
** Magas rendelkezésre állás jellemzi
** Az alkalmazásban ritkán használt (évente 1x-2x), a mérettől független költséggel rendelkező megoldás
* Deep Archive Glacier:
** 7-10 évig tárolt adatokhoz optimalizált költségvonzat
** Előnyös a backup adatok tárolásához

A szolgáltatás a keresőben ''S3'' füzérrel kereshető.

==== Bucket létrehozása ====
Új tárolót a ''Create bucket'' gomb segítségével hozhatunk létre. A megjelenő űrlapon a nevet kell kitölteni és érdemes egy pillantást vetni a publikusság beállításaira is, hogy ez ténylegesen a célunknak megfelelő legyen.

'''Figyelem!''' A névnek nem csupán a mi környezetünkön belül kell egyedinek lennie, hanem a teljes AWS-en belül.

{| style="margin:auto"
| [[Fájl:GAMFAWS S3 new name.png|bélyegkép]] || [[Fájl:GAMFAWS S3 new public.png|bélyegkép]]
|}

==== Bucket kezelése ''awscli'' programmal ====
Az '''aws s3 help''' parancs segítségével további információt szerezhetünk az egyes utasításokról.

'''Bucket tartalmának listázása''' 
<syntaxhighlight lang="bash">
aws s3 ls [bucket_name]
</syntaxhighlight>
[[Fájl:GAMFAWS S3 CLI LS.png|középre]]

'''Adatok másolása Bucket-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* LOCAL_PATH a lokális fájlrendszeren belüli elérési útvonala a forrásfájlnak (vagy könyvtárnak)
* REMOTE_PATH a cél helye az S3-ban
** Az s3:// jelzi, hogy a cél az S3-ban van (S3Uri)
** A mappák helyett PREFIX-ek vannak (/folder/to/my/file esetében /folder/to/my a PREFIX)
** A mappákat nem kell S3-ban létrehoznunk (az előző pontból következik), a fájlnév előtti prefix dönti el a hova tartozását
** A PREFIX-eket az '''ls''' úgy kezeli, mint egy mappát
[[Fájl:GAMFAWS S3 AWSCLI cp2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* --recursive jelzi, hogy a LOCAL_PATH alatt minden bejegyzést töltsön fel
[[Fájl:GAMFAWS S3 AWSCLI copy recursive2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ból helyi fájlrendszerbe''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive s3://REMOTE_PATH LOCAL_PATH
</syntaxhighlight>
[[Fájl:GAMFAWS S3 AWSCLI cp2local.png|középre]]

==== Bucket kezelése grafikus felületen keresztül ====
Az S3 tartalmát elérhetjük az AWS grafikus felületén keresztül is, így tölthetünk fel, törölhetünk és módosíthatunk fájlokat anélkül, hogy saját számítógépünkre telepítenénk az ''awscli'' programot.

# Nyissuk meg az S3 szolgáltatás vezérlőpultját
# Kattintsunk a szerkeszteni kívánt tárhely nevére [[Fájl:GAMFAWS S3f list.png]] 
# A vezérlőgombok segítségével végezzük el a kívánt műveletet (feltöltés, törlés), vagy válasszunk ki egy PREFIX-et az „almappák” tartalmának megtekintéséhez. [[Fájl:GAMFAWS S3 control.png|középre]]

= Alkalmazások telepítése =
== UI ==
== API ==

= Indítást gyorsító scriptek =
== UI indítás ==
<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun code
API_LB_DOMAIN="localhost" # api server IP

apt update
apt install wget unzip apache2 libapache2-mod-php8.1 php8.1 php8.1-curl -y

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui.php
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui_newproduct.php
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv ui.php /srv/$NEPTUN/index.php
mv ui_newproduct.php /srv/$NEPTUN/newproduct.php

# remove tmp directory
cd /
rm /tmp/code

cat << EOF > /etc/apache2/sites-enabled/000-default.conf
<VirtualHost *:80>
#ServerName www.example.com

ServerAdmin webmaster@localhost
DocumentRoot /srv/$NEPTUN

<Directory /srv/$NEPTUN/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>

ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

systemctl restart apache2
</syntaxhighlight>

== API indítás ==

<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun
MYSQL_DOMAIN="localhost" # RDS mysql domain

apt update
apt install wget unzip python3 python3-pip -y
pip3 install flask mysql-connector-python --break-system-packages

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$MYSQL_DOMAIN/g" api.py
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv api.py /srv/$NEPTUN/

# remove tmp directory
cd /
rm /tmp/code

echo "@reboot root sleep 10s && python3 /srv/$NEPTUN/api.py &" >> /etc/crontab
cd /srv/$NEPTUN && python3 api.py &
‎</syntaxhighlight>

EDU::GAMF::Felhőalapú-szolgáltatások::AWS

2024-10-08T11:50:50Z

ApelPro: /* API indítás */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
[[category:GAMF AWS|AWS]]
== Amazon Web Services regisztráció ==
Az AWS mindenki számára biztosít 1 év ingyenes próbaverziót. Ehhez regisztrálnunk kell a rendszerbe, amihez szükségünk lesz egy email címre, egy telefonszámra a megerősítéshez és egy netes vásárlásra alkalmas bankkártyára. A regisztráció során az AWS 1$-ral meg terheli a számlát, de később erre nem tart igény, így a tranzakció lejáratakor jóváíródik a számlán.

== Ingyenes verzió korlátai ==
Az ingyenes verzióban nem minden érhető el és ami mégis, az sem korlátlan ideig (750 óra EC2 futási idő például), amit ha átlépünk, akkor fizetési kötelezettségünk jelentkezik a szolgáltató felé. Igyekezzünk mindent leállítani az órai munka illetve az otthoni gyakorlás után, hogy lehetőleg ne kerüljön pénzbe a féléves munkánk. A hallgatók által elszenvedett károkért sem az iskola sem Én nem tudunk felelősséget vállalni, de azt meg tudjuk ígérni, hogy fizetős szolgáltatást nem használunk és nem is kérünk számon.

== AWS alapok ==
'''Figyelem!''' Az iskolai hálózatból csak az eu-west-1 és az eu-central-1, azaz Írország és Frankfurt IP címei vannak engedélyezve, ezekre fogunk tudni SSH kapcsolaton keresztül csatlakozni. 
'''Figyelem!''' Próbaidőszak alatt minden szolgáltatás mellett keressük a ''Free tier eligible'' megjegyzést, különben fizetési kötelezettségünk adódhat!

=== EC2 szolgáltatásai ===
Az ''EC2'' gyakorlatilag egy VPS-nek feleltethető meg és nem is tévedünk vele hatalmasat. A neve az ''Elastic Cloud Compute'' szavak kezdőbetűiből kialakuló ''ECC''-ből fakad, a ''2''-es a végén jelzi, hogy a ''C'' betűből kettő van.

A különbséget a VPS-hez az EC2 futási ideje okozza: bár nem feltétlen, de meg van a lehetősége, hogy egyik napról a másikra megszűnjön egy EC2 úgy, hogy az alkalmazásunk mégis működőképes marad. E tulajdonsága miatt kapta az ''Elastic'' nevet, amit körültekintően kell kezelni: semmilyen adatot nem tárolhatunk úgy egy alkalmazáson belül, mint egy VPS esetén: a dinamikus adatok (pl. PHP Session, feltöltött fájok) egy EC2 csere esetén elvesznek, így ezeket nem helyben fogjuk tárolni.

Az EC2 szolgáltatásait a keresőmezőbe írt ''„EC2”'' kulcsszóval és az eredményekben megjelenő ''EC2''-re való kattintással érhetjük el.

[[Fájl:GAMFAWS search EC2.png.png]]

Az alapértelmezetten megjelenő menüpont a ''Dashboard'', ahol információkat találhatunk az ''EC2'' köré felhúzható szolgáltatásokról, melyeknek egy részét a továbbiakban tárgyalni is fogunk. Az összefoglaló táblázat az alább látható módon jelenik meg. '''Figyelem''', a táblázat csak az adott régióban elindított/elérhető szolgáltatásokat mutatja, régió váltása előtt érdemes az esetlegesen létrehozott, régió függő elemeket leállítani, hogy később ne jelenjen meg fizetési kötelezettség.

[[Fájl:GAMFAWS ec2 dashboard.png]]

==== EC2 telepítése és beállítása ====
EC2 létrehozásához meg kell nyomnunk a ''Launch instance'' gombot, melyet több helyen is elérhetünk:
* A Dashboardon
* A bal oldali menüben található ''Intances'' menüpont megnyitása után jobb felül
A gomb minden esetben a következőképp néz ki: [[Fájl:GAMFAWS ec2 launch instance button.png]]

A gombra kattintva egy űrlap jelenik meg, amely segítségével elvégezhetjük a szükséges beállításokat: 
======Név és tag beállítok======
Megadása nem kötelező, de több szerver futtatása esetén könnyebben azonosíthatjuk be őket ezek segítségével
[[Fájl:GAMFAWS ec2 setup name and tags.png]]

Az ''Add additional tags'' gombra kattintva további kulcs=érték párokat adhatunk hozzá, amivel dinamikusan csatolhatjuk össze egyéb szolgáltatásokkal, amelyek egy-egy kulcsot keresve döntik el, hogy melyik szolgáltatásokkal kell együttműködniük (például monitorozás bekapcsolása 'monitoring=true' kulcs=érték pár alapján.

======Kezdeti képfájl kiválasztása======
Az Amazon többféle indítóképpel is rendelkezik, így nagy valószínűséggel meg fogjuk találni a hozzánk közelálló operációs rendszert. Új hozzáadására nincs lehetőségünk, de készíthetünk az alapképfájlokból olyan verziót, ami már tartalmazza a saját konfigurációnkat (lásd [[GAMF :: Felhőalapú-szolgáltatások :: AWS#AMI_létrehozása|itt]]). 
[[Fájl:GAMFAWS ec2 setup AMI choose2.png]] 
Az órákon az Ubuntu legújabb verzióját használjuk, mivel ennek a Desktop változata az egyik legelterjedtebb a Linux felhasználók körében, így nem kell más környezetet megszoknia egy átlag hallgatónak. Érdemes lehet azonban egyéb disztribúciók kipróbálása is, különösen a '''Debian'''-t, '''Suse'''-t/'''OpenSuse'''-t, '''ReadHat'''-et és annak ingyenes változatait ('''AlmaLinux''', '''RockyLinuxtm''', amelyek az egykori '''CentOS'''-t hivatottak váltani), mivel céges környezetben ezek sűrűbben előfordulnak: némelyik a kisebb erőforrásigénye, míg másik az Enterprise szolgáltatásai miatt.

======Szerver típusának meghatározása======
Különböző erősségű szerverkonfigurációk közül választhatunk, de természetesen nem mindegyik érhető el az ingyenes verzióban. A számítógépek ára a konfiguráció függvényében változik, de csak azért az időért kell fizetni, amíg a szerver ''Running'' állapotban volt. Az órán az alapértelmezett ''t2.micro''-t használjuk. 
[[Fájl:GAMFAWS ec2 setup instance type.png]]

======Kulcspár hozzárendelése======
Az Amazonon belüli szolgáltatásokat felhasználónév/jelszó páros helyett SSH kulcspárok segítségével érjük el. Minden felhasználó számára készíthetünk egyet és jogosultságok segítségével korlátozhatjuk, hogy mihez férhet hozzá (IAM). 
Ebben a szekcióban ki kell választanunk, hogy a telepíteni kívánt EC2-höz milyen kulcspárral lehet majd hozzáférni. Amennyiben nem rendelkezünk még kulcspárral, úgy van lehetőségünk helyben elkészíteni a ''Create new keypair'' gomb segítségével, amelynek lépési megegyeznek az [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Kulcspár_létrehozása|itt]] leírtakkal. 
[[Fájl:GAMFAWS ec2 setup keypair.png]]

======Hálózati és biztonsági beállítások======
Az EC2-k közötti kommunikációs csatornák kialakításához definiálnunk kell, hogy melyik virtuális hálózatba akarjuk elhelyezni és milyen alkalmazásokat szeretnénk elérhetővé tenni. Ezt a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#VPC_beállításai|VPC]] és a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Security_Group|Security Group]] beállításával tehetjük meg. Előbbi a virtuális hálózatnak felel meg, míg utóbbi hasonlóan egy tűzfalhoz, meghatározza, hogy a szerveren milyen portokat érhetünk el. Érdemes az SSH-t engedélyezni és ha webes alkalmazást szeretnénk rajta futtatni a későbbiekben, akkor a HTTP és/vagy HTTPS szolgáltatást/szolgáltatásokat is, így később nem kell szerkeszteni ezeket a beállításokat. 
[[Fájl:GAMFAWS ec2 setup networking.png]]

======Tárhely beállítások======
Ebben a részben adhatjuk meg, hogy a szerverünk mekkora tárhellyel rendelkezzen. Egy Linux alapú operációs rendszernek nem kell 8GB-nél több, így az alapértéken hagyhatjuk. Az itt megadott érték inkább csak egy korlát, valójában csak akkora tárhelyet vesz igénybe, amennyire ténylegesen szüksége van a rendszernek. Ez az érték alatt látható figyelmeztetés miatt lényeges, hiszen a 30GB-t elhagyva fizetőssé válik a tárterület is, ám ez nem jelenti, hogy csak 4 szervert tudnánk elindítani az ingyenes keretek között. 
[[Fájl:GAMFAWS ec2 setup ebs.png]]

Ezt a szolgáltatást EBS-nek nevezik (''Elastic Block Store'') és az EC2 megszűnésekor minden erre mentett adat elveszik, így általában az OS-t és az applikáció kódját tároljuk ezen - semmi dinamikus adatot.

======Haladó beállítások======
Ebben a szekcióban különböző beállításokat végezhetünk el, ám ezeket az órán nem módosítjuk. Érdekes lehet azonban a menüt lenyitva legalul található ''User data'' opció, amivel parancsokat adhatunk meg az új operációs rendszer számára, hogy miket futtasson le. Ennek segítségével lehetőségünk nyílik applikációk telepítésére - pl. git - és a kód letöltésére egy másik szerverről, amennyiben a kiválasztott képfájl nem tartalmazta azt. 
''Az órai keretek között ezt a funkciót nem használjuk ki, de érdemes lehet kipróbálni, mivel valós alkalmazások üzemeltetésekor jól jöhet.'' 
[[Fájl:GAMFAWS ec2 setup userdata.png]]

======Összefoglaló======
A beállító panel mellett jobbra találhatjuk az összefoglaló ablakot, amelyben megtalálható a ''Launch Instance'' gomb. Ennek segítségével kezdhetjük meg a végleges telepítést, ha erre rá nyomunk, akkor a rendszer megkezdi a kiválasztott konfiguráció telepítését. Ha ebben az ablakban pénzösszegeket látunk, akkor az egészen biztosan fizetési kötelezettséget vonz magával, legyünk körültekintőek. 
[[Fájl:GAMFAWS ec2 setup summary.png]]

======Az elkészült instance tulajdonságai======
A futó szerverek az ''Instances'' menüpontban érhetők el. Az egyes sorokra kattintva alul megtekinthetjük a beállításait, amely tartalmazza az AWS által kiosztott publikus és privát IP címeket és domain neveket. Ezeken keresztül tudunk kommunikálni szerverünkkel. 
[[Fájl:GAMFAWS ec2 properties.png]] 
''Jelen példában a külső IP címünk: 3.252.168.207, amit a mellette található ikonnal egyszerűen a vágólapra másolhatunk.''

======Csatlakozás Linux terminálból======
A csatlakozáshoz nyissunk meg egy terminált a CTRL+T billentyűkombinációval, majd navigáljunk a ''cd'' parancs segítségével a letöltött kulcsfájl mappájába. Az SSH megköveteli, hogy a csatlakozáshoz használt kulcsfájlhoz csak a tulajdonos felhasználó férjen hozzá, így a következő parancsot futtassuk le rajta: ''chmod 600 test.pem''

A következő paranccsal tudunk kapcsolódni: ''ssh -i test.pem ubuntu@3.252.168.207'' 
Ha a fenti parancs kéri, fogadjuk el a tanúsítványt. Amennyiben ''Permission error'' hibát kapunk, akkor a fenti ''chmod'' parancsra van szükségünk, vagy nem mi vagyunk a kulcsfájl tulajdonosai (''ls -l'' segíthet). 
A ''test.pem'' az AWS rendszerből letöltött .pem formátumú kulcsfájl, az ''ubuntu'' a szerveren elérhető felhasználó. A különböző disztribúcióknál használt felhasználónevekről [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connection-prereqs.html ezen] a linken tájékozódhatsz. 
[[Fájl:GAMFAWS ec2 connect linux.png]]

======Csatlakozás Putty használatával======
Amennyiben a .pem kiterjesztésű állományt töltöttük le az AWS rendszeréből, akkor a '''puttygen''' eszköz segítségével ki kell exportálni belőle a privát kulcsot. [https://www.ssh.com/academy/ssh/putty/windows/puttygen Ezen a linken] részletes segédlet található a programcsomaghoz, ahol további funkciók is bemutatásra kerülnek (pl. kulcsgenerálás).

==== Kulcspár létrehozása ====
A kulcspárok kezeléséhez a ''Key Pairs'' linket nyissuk meg a bal oldali menüből. Újat a jobb oldalon látható ''Create key pair'' gomb segítségével készíthetünk. [[Fájl:GAMFAWS ec2 keypair create.png]]

A gombra kattintva egy űrlapot kapunk, amely végig vezet minket a létrehozás lépésein.
# Név megadása
# Típus kiválasztása - ''RSA-val dolgozunk az órán''
# Letöltendő kulcs típusa - ''Linux terminálból való csatlakozáshoz a .pem fájlra lesz szükségünk''
# Esetleges tag-ek hozzárendelése
# A ''Create key pair'' gombra kattintva letölthetjük a kulcspárt

[[Fájl:GAMFAWS ec2 keypair setup.png|Kulcspár létrehozása]]

'''Figyelem!''' A kulcspár csak a létrehozás után tölthető le '''egyetlen egyszer''', az elvesztett fájlok nem reprodukálhatók! Amennyiben egy EC2 csak az elhagyott kulcspárral érhető el, úgy annak (EC2) törlése és újrakonfigurálása szükséges egy új kulccsal.

==== Security Group ====
A Security Group-ok segítségével kontrollálhatjuk, hogy a szervereinkhez milyen portokon férhetnek hozzá, tehát mintegy tűzfal működik. Egy Security Group több gépre is ráhúzható és függetlenül működik, azaz a megadott szabályokat nem másolja át az operációs rendszer konfigurációs állományaiba, mintegy a szerver elé telepített eszköz működik. Ennek köszönhetően futási időben változtathatjuk a szabályokat, életbelépésükhöz nem kell újracsinálni az EC2-ket.

A bal oldali sávban, a ''Network & Security'' csoportban érhető el.

===== Security Group hozzáadása =====
Egy új szabályrendszer felvételét kezdeményezhetjük az EC2 telepítésekor, ahogyan azt [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Hálózati_és_biztonsági_beállítások|itt]] is láthattuk, de készíthetünk előre meghatározottakat is.

Az előre definiált csoportokat a ''Create Security Group'' gomb segítségével hozhatjuk létre, amelyet a jobb felső sarokban találhatunk meg. 
[[Fájl:GAMFAWS ec2 secg new button.png|bélyeg]sdfsad] 

A gomb megnyomását követően egy űrlapot kapunk, melynek 3 fő része van:
# Általános adatok [[Fájl:GAMFAWS ec2 secg new basic.png|bélyeg|Általános adatok]]
#* '''A név és a leírás mező megadása is kötelező'''
#* Itt választhatjuk ki, hogy mely VPC-ben szeretnénk elérhetővé tenni.
# Bejövő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg inbound.png|bélyegkép|Inbound rules]]
#* '''Az itt megjelenő szabályok lesznek engedélyezve a szerverünk felé, minden más csomag eldobásra kerül'''
#* Háromféle szabályból választhatunk:
#** '''Anywhere''' (IPv4, IPv6): A megadott IP típusból mindenhonnan elfogadjuk a csomagokat
#** '''Custom''': Csak a megadott IP címekről/IP tartományokból érjük el az adott portot
#** '''MyIP''': automatikusan beillesztésre kerül az felhasználó aktuális IP címe (hasonló a custom lehetőséghez)
# Kimenő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg outbound.png|bélyegkép|Outbound rules]]
#* A kimenő forgalom szabályozása biztonsági szempontból megfontolandó, de természetesen a publikus alkalmazások esetében (pl. web) nem tudunk ilyen szűrést alkalmazni.
#* Alkalmazhatjuk például SSH-ra, hogy megszüntessük annak a lehetőségét, hogy egy esetleges fertőzésből kifolyólag SSH-t hackelgető botnetté változzunk (volt már hasonló tapasztalat).
#* Az órán ezzel bővebben nem foglalkozunk, de éles környezetben ne felejtsünk el ezen szabályok definiálására időt szánni.
# Tag-ek megadása

===== Security Group szerkesztése =====
A szerkeszteni kívánt soron kattintsunk jobb gombbal és válasszuk ki a szerkeszteni kívánt szabályok csoportját:
* '''Edit inbound rules''', ha a bejövő csomagok szűrését szeretnénk módosítani,
* ''' Edit outbound rules''', ha a kimenő forgalmat szeretnénk szűrni.
A megnyíló ablakban ugyanazon a módon vehetünk fel szabályokat, ahogyan a létrehozásnál. A módosítások mentés után életbe lépnek. 
[[Fájl:GAMFAWS ec2 secg context menu.png]]

==== Terheléselosztás vázlat ====
[[Fájl:EC2LoadBalancingRequirements.png|középre]]

==== AMI ====
Az AMI gyakorlatilag egy bitről-bitre lemásolt HDD képfájl, amely tömörítve lett. Így tárolja az összes elmentett adat- és konfigurációs állományt. Ha egy alkalmazást készítünk, akkor a következő okokból készítünk ilyen képfájlt:
# Biztonsági mentés a telepített szolgáltatásokról, így később nem kell egy esetleges hiba miatt újrakonfigurálni az egészet
# AutoScaling group-ba szeretnénk rendezni az alkalmazásunkat, annak pedig meg kell mondani, hogy melyik képfájlt indítsa el

'''Figyelem!''' A képfájlok úgynevezett snapshot-okat hoznak létre, amelyek tárolásáért fizetni kell, ha az összméret meghaladja a 8GB-ot. (A snapshotok az éppen futó rendszer miatt készülnek: minden írási műveletet lezár, majd a snapshot készítés után elindított írási műveletek már a háttértár egyéb területeire történik, amelyet a mentés nem fog tartalmazni, így garantálható, hogy nem lesznek félig lezárt fájlok a mentésben. Lásd bővebben: BTRFS (linux) és NTFS support). A pillanatképek nem törölhetők, amíg a belőlük készült AMI létezik!

===== AMI létrehozás lépései =====
'''Navigáljunk az Instances menüpontra, ahol láthatjuk, hogy milyen EC2 szolgáltatások vannak a rendszerünkben.'''
# Kattintsunk jobb gombbal azon az elemen, amelyet menteni szeretnénk
# Nyissuk ki az ''Image and templates'' menüpontot
# Kattintsunk a ''Create image'' lehetőségre 
[[Fájl:GAMFAWS ec2 ami create.png]]

'''Nevezzük el a képfájlt tetszés szerint''' 
[[Fájl:GAMFAWS ec2 ami setup.png]]

'''Navigáljunk a bal oldalon található menüben az ''Images'' szekcióhoz és válasszuk ki az ''AMIs'' elemet. Itt megtekinthetjük és törölhetjük a létrehozott képfájljainkat.''' 
[[Fájl:GAMFAWS ec2 ami list.png]]

'''Ha a mentés sikeresen elkészült, akkor az EC2 létrehozásánál kiválaszthatjuk azt.''' 
[[Fájl:GAMFAWS ec2 setup own ami select.png]]

==== Indítási konfigurációk elkészítése ====
Az indítási konfigurációk mind egy célt szolgálnak: egységes profilba rendezi az EC2-ről készült képfájlokat. Míg az AMI nem tárolt információt a mentett gép erőforrásáról, egy indítási konfigurációban megadhatjuk ezeket. Később ezek felhasználásával egyszerűbben indíthatunk újabb szervereket és vannak olyan esetek is, amikor a rendszer megköveteli, hogy a képfájl megadása helyett konkrét, hardverinformációkat is tároló konfigurációs sablonokat adjunk meg.

''Az Auto Scaling Group például megköveteli, hogy a következő kettő elem közül az egyiket megadjuk, ebből fogja tudni, hogy milyen típusú EC2-t, mekkora tárhellyel és milyen VPC-ben indítson el.''

===== Launch configuration =====
'''Egy kifutóban lévő konfigurációs séma, amely 2022. December 31-e után nem kapja meg a frissítéseket. Az AWS javaslata szerint érdemes ezeket a beállításokat a következőkben tárgyalt ''Launch template'' alá migrálni.

A ''Launch configuration'-nek nevezett séma egy egyszerűsített változata a sablonoknak. Jóval kevesebb beállítási lehetőséget tartalmaz, mint a párja, de tökéletesen elegendőt az ''Auto Scaling Group''hoz.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Auto Scaling group'' szekciót és válasszuk ki a ''Launch Configuration'' menüpontot. A jobb felső sarokban található ''Create launch configuration'' gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''Név megadása''', aminek segítségével később hivatkozhatunk erre az elemre. Kitöltése kötelező! 
[[Fájl:GAMFAWS ec2 launch conf setup name.png]]

''AMI kiválasztása'', tehát azok képfájl megadása, amit a kiválasztott EC2 konfiguráció futtatni fog. Lehetőségünk van a saját készítésű (''My AMIs'') és a közösségi képfájlok közül választani (''Marketplace''). 
[[Fájl:GAMFAWS ec2 launch conf setup ami.png]]

'''Instance típus''' alatt megadhatjuk, hogy a konfiguráció milyen teljesítményű legyen.
'''Ne feledjük el, hogy a t2.micro az ingyenes, a többi használata után fizetési kötelezettségünk jelenhet meg.'''
[[Fájl:GAMFAWS ec2 launch conf setup instance type.png]]

'''Az Additional configruation''' részben megadhatunk különböző paramétereket, amelyeket az EC2 fog felvenni - pl. mindenképp kapjon IP címet, a subnet beállításaitól függetlenül, vagy éppen ne kapjon; itt adhatjuk meg a telepítéskor lefuttatott scripteket (User data).

'''A Storage''' szekcióban megadhatjuk, hogy milyen lemezek és milyen méretűek legyenek a rendszerhez csatolva.

'''A Security Group''' részben kiválaszthatunk egy már meglévő szabályrendszert, vagy készíthetünk újat. 
[[Fájl:GAMFAWS ec2 launch conf setup secg.png]]

'''A Key pairs''' blokkban megadhatjuk, hogy milyen privát kulccsal léphetnek be a szerverekre. Ennek meglétét jóvá kell hagyni az alul található checkbox-szal. 
[[Fájl:GAMFAWS ec2 launch conf setup keypair.png]]

'''Végül kattintsunk a ''Create launch confgiration'' gombra a létrehozáshoz.'''

===== Launch template =====
A Launch template jóval gazdagabb a beállítási lehetőségekben, mint párja. A konfigurációs adatlap tartalmaz segédletet az AutoScaling Group-pal történő használathoz, amely ''required'', azaz kötelező mezőként jelöli meg azokat az adatbeviteli elemeket, amelyeket az automata skálázó rendszer használ. Érdemes ezt bekapcsolni, amennyiben ilyen célzattal készítjük el a sablonunkat.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Instances'' szekciót és válasszuk ki a ''Launch template'' menüpontot. Az oldal közepén vagy a jobb felső sarokban található Create launch configuration gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''A sablon neve és leírása''' blokkban megadhatjuk a nevet és a leírást, de ugyanakkor itt választhatjuk ki azt a checkboxot is, ami később a segítségünkre lesz a konfigurációs sablon AutoScaling Group-hoz való illesztését is (''Auto Scaling guidence''). 
[[Fájl:GAMFAWS ec2 launch templ setup name.png]]

'''Az Application and OS images''' szekcióban megadhatjuk, hogy milyen AMI-val települjön az EC2. Itt választhatunk a sajátunkból, vagy az EC2-nél is megtalálható egyebekből. 
[[Fájl:GAMFAWS ec2 launch templ setup ami.png]]

'''Az Instance type''' csoportban megadhatjuk, hogy milyen teljesítményű gépet szeretnénk indítani.
'''Ne feledjük el, hogy az ingyenes változatban a t2.micro érhető el, másik lehetőség választása esetén fizetési kötelezettségek léphetnek fel!''' 
[[Fájl:GAMFAWS ec2 launch templ setup instancetype.png]]

'''A Key Pair''' blokkban megadhatjuk, hogy a gépek milyen kulcspárral engedélyezzék a belépést. 
[[Fájl:GAMFAWS ec2 launch templ setup key pair.png]]

'''A Network Confguration''' részben definiálhatjuk, hogy milyen VPC-be szeretnénk lerakni az EC2-ket, milyen security group legyen rajtuk. Természetesen utóbbi helyben is létrehozható, ha korábban ezt nem készítettük volna el. 
[[Fájl:GAMFAWS ec2 launch templ setup network.png]]

'''A Storage'''-nél megadhatjuk, hogy milyen kötetek, milyen méretben legyenek hozzácsatolva a rendszerhez.

'''A Tags''' blokkban felvehetjük a kívánt ''kulcs=érték'' párokat.

'''Az Additional Configuration''' szekcióban különböző haladó beállításokat eszközölhetünk a sablon által létrehozott EC2-n, többet között itt adhatjuk meg az indításkor lefuttatandó parancsok listáját (''User data'').

'''Végül kattintsunk a Create launch template nyomógombra a mentéshez!'''.

==== Target Group ====
A target group EC2-k azon csoportja, amelyeken valamilyen ''health check'' algoritmust futtatunk, ezzel meghatározva, hogy az adott csoportban hány használható, működő szerver fut. Ezt az információt elsőként a Load balancer használja ki.

A Target Group a bal oldali menüben, a ''Load Balancing'' szekcióban érhető el ''Target Groups'' néven.

Létrehozhatunk új csoportot, de meg kell adnunk, hogy milyen módon kerüljenek bele az EC2-k. Erre a következő metódusokat ajánlja fel az Amazon:
# Konkrét EC2 (Instance) kiválasztása
# EC2-k definiálása IP tartománnyal
# Lambda függvény hozzáadása
# Alkalmazás LoadBalancer, amely egy teljes VPC tartalmát magába foglalja.

Az űrlap alján megadhatjuk, hogy milyen életjel ellenőrzés történjen.

Általában nem mi vesszük fel egyesével az Instancokat ebbe a csoportba, hanem az AutoScaling group regisztrálja őket bele. '''Ezért ezt az űrlapot nem használjuk'''.

==== Load Balancer ====
A Load Balancer terheléselosztást jelent, tehát a bejövő forgalmat több gép között osztjuk el. Ezzel növekszik a felhasználói élmény, ráadásul a rendszer megállítása (egy hacker által) nehezebbé válik: ha kettő t2.micro teljesítményű szerver fut, amelyek között elosztjuk a bejövő forgalmat, akkor a rendszerünk valójában 2xt2.micro teljesítményű.

Terheléselosztót a bal oldali menü ''Load Balancing'' szekciójának ''Load Balancers'' menüpontjában hozhatunk létre.

'''A támogatott szolgáltatási szintek:'''
# Alkalmazás terheléselosztás (HTTP, HTTPS)
# Hálózati terheléselosztás (TCP, UDP)
# Átjáró terheléselosztása (GW)

===== Alkalmazás terheléselosztása =====
Ebben a formában konfigurálhatjuk az eszközt úgy, hogy az internet felől elérhető legyen (internet-facing) és úgy, hogy csak belső hálózaton működjön (internal). A belső hálózatot mindig az aktuális VPC-re kell érteni, tehát annak minden alhálózatából elérhető alapértelmezetten.
[[Fájl:GAMFAWS ec2 loadbalancer setup basic.png]]

A hálózati beállításoknál választhatunk, hogy mely alhálózatokban szeretnénk végrehajtani a terheléselosztást, így csak az azokban futó EC2-k kaphatnak ezen keresztül csomagokat. Arra kell ügyelnünk, hogy legalább kettő különböző zónában lévő alhálózatot kell kiválasztanunk (pl. eu-west-1a, eu-west-1b stb.).
[[Fájl:GAMFAWS ec2 loadbalancer setup network.png]]

Természetesen a LoadBalancer internetfelőli végpontján létrehozhatunk ''Security Group''okat, amelyet szabályozzák, hogy milyen IP címről fogadunk el csomagokat.
[[Fájl:GAMFAWS ec2 loadbalancer setup secg.png]]

A ''Listeners and routing'' résznél megadhatjuk, hogy melyik target group fogja a terhelést fogadni, tehát hogy mely EC2-k között tudunk ténylegesen terhelést elosztani. Amennyiben a target group egy darab EC2-t tartalmaz, akkor a terheléselosztás gyakorlatilag nem valósul meg, csak az elméleti esélyét adtuk meg, hogy ''„amennyiben lenne még egy EC2 a target group-ban, akkor a terhelés egy részét az vinné el”''.
[[Fájl:GAMFAWS ec2 loadbalancer setup routing.png]]

Végül kattintsunk a ''Create load balancer'' gombra, amennyiben a kívánt tag-eket is rögzítettük.

==== Auto Scaling Group ====
A szolgáltatás segítségével automatikusan skálázott rendszereket építhetünk ki, ahol a szerverek által nyújtott elérhető erőforrásokat minél közelebb tartja a bejövő terhelés által meghatározott erőforrásigényhez. Természetesen mindez akkor igaz, ha az ''Auto Scaling Group'' be regisztrálja az általa létrehozott ''EC2''-ket egy ''Target Group''-ba, ami felett ''Load Balancing'' van definiálva.

'''Előnyei''':
* Amikor nincs bejövő terhelés, akkor nincsenek nagy költségek
* Amikor nagy a bejövő terhelés, akkor a költségek megugranak ugyan, de az ügyfeleket ki tudtuk szolgálni úgy, hogy elégedettek voltak a rendszer teljesítményével.

'''Hátrányai''':
* Kaotikus számlák, nem előre tervezhető költségek
* Megnövekedett költségek DDoS és egyéb támadások esetén

===== A beállítás lépései =====
A szolgáltatást a bal oldali menü ''Auto Scaling Group'' szekciójában érjük el, az ''Auto Scaling Group'' menüpontban. A képernyő közepén vagy a képernyő jobb felső sarkában megjelenő ''Create auto scaling group'' gombra kattintva egy űrlap jelenik meg, ami végig vezet minket a telepítés lépésein.

'''A Name''' szekcióban elnevezzük az új group-ot.
[[Fájl:GAMFAWS ec2 autoscaling setup name.png]]

'''A következő szekcióban''' két választási lehetőségünk van:
* Launch Template-tel telepítjük az új group-ot, ez esetben csak ki kell választanunk a korábban létrehozott sablont, vagy az alatta található link segítségével készíthetünk újat. ''Amennyiben újat készítünk, a sablon létrehozása új ablakban nyílik meg, így a befejezést követően vissza kéne térnünk erre és a frissítést gombot megnyomva látni fogjuk az új lehetősége(ke)t.
[[Fájl:GAMFAWS ec2 autoscaling setup lt.png]]

* Launch Configuration-nel telepítjük az új group-ot, ez esetben át kell váltatnunk a ''Switch to launch configuration'' link segítségével a blokkot. A váltást követően hasonlóan az előzőekhez: vagy kiválasztjuk a már meglévő konfigurációs sémát, vagy hozhatunk létre újat.
[[Fájl:GAMFAWS ec2 autoscaling setup lc.png]]

'''A Next gombra kattintva a hálózati beállítások''' szekcióhoz érünk, ahol megadhatjuk, hogy az indított EC2 milyen VPC-be kerüljön és azon belül milyen alhálózatokba. VPC-ből egy, alhálózatból több is kiválasztható. Ügyeljünk rá, hogy ha később erre Load Balancer szolgáltatás is kerül, akkor legalább kettő zónát jelöljünk ki!
'''Figyelem!''' A zóna nem egyezik meg az alhálózattal!
[[Fájl:GAMFAWS ec2 autoscaling setup network.png]]

'''A Next gombra kattintva a Load Balancing beállítások''' következnek, ahol választhatunk:
* Nincs terheléselosztás opciót,
* Létező Load Balancer hozzáillesztését,
* Új Load Balancer létrehozását.

Utóbbi esetében a Load Balancer konfigurálásánál leírt módon ki kell töltenünk a Load Balancer űrlapját is helyben. 
[[Fájl:GAMFAWS ec2 autoscaling setup lb setup.png]]

Hasonlóan a ''Target Group''-ot is létrehozhatjuk helyben, amennyiben ezt nem tettük meg korábban.
[[Fájl:GAMFAWS ece autoscaling setup new lb new tg.png]]

'''A Next gombra kattintva a csoport méretét definiálhatjuk''', azaz megszabhatjuk, hogy hány darab szervertől, hány darab szerverig engedélyezzük az automatikus skálázást. Ez egy hasznos funkció, hiszen ezzel korlátok közé szoríthatjuk a költségeinket, miközben a legkisebb terhelés esetén is előkészülhetünk egy hirtelen bejövő nagyobb terhelésre (ha a minimum nem 1).
* Desired capacity: ennyi szervert fog elindítani az ASG mentés után
* Minimum capacity: ennyi szerver esetén már nem állít le semmit az ASG
* Maximum capacity: ennyi szerver esetén már nem indít el újabbat az ASG
[[Fájl:GAMFAWS ec2 autoscaling setup group.png]]

'''Alatta a Scaling Policy''' blokkban megadhatjuk, hogy milyen paraméterek mentén indítson vagy épp állítson le szervereket az ASG. Ehhez aktiválnunk kell a szolgáltatást és a ''Metric type'' listából ki kell választani az számunkra megfelelőt. Mi általában CPU terhelés alapján döntünk az órán.
[[Fájl:GAMFAWS ec2 autoscaling setup scaling.png]]

'''A Next gombokkal lépkedve hozhatunk létre Tag-eket, majd végül létrehozhatjuk az ASG-t is és az ''Instances'' menüpontban ellenőrizhetjük, hogy ténylegesen elindult a kívánt darabszámú szerver.'''

=== RDS szolgáltatások ===
A ''Relational Database Service'' foglalja magában a különböző adatbázisokat:
* MariaDB
* MySQL
* Aurora
* Oracle
* PostgreSQL
* MSSQL

'''Figyelem!''' Az itt felsorolt szerverek között lehetnek fizetősek is. Mindig járjunk el figyelmesen, kövessük a költségeket. Az RDS az amazon egyik legdrágább szolgáltatása.

==== MySQL adatbázis telepítése ====
==== Csatlakozás MySQL adatbázishoz CLI-ből ====
<syntaxhighlight lang="bash">
apt install mysql-client -y
# mysql -h<rds_endpoint> -u<rds_user> -p<rds_password>
mysql -hwebshop-989.rds.amazon.com -uadmin -p123456789
</syntaxhighlight>

A megnyíló '''mysql>''' PROMPT-ot tartalmazó sor azt jelenti, hogy sikeresen csatlakoztunk az SQL szerverhez. Amennyiben a csatlakozás sikertelen, akkor valószínűleg az RDS-hez kapcsolt Security Group beállításai nem engedik az EC2-ről a kapcsolódást - tipikusan a mi saját publikus IP címünk kerül bele az engedélyezett tartományba (pl. iskolai IP vagy otthoni) és ez nem került átírásra az amazonos tartománynak megfelelően.

A konzolra be kell illeszteni a ''networks.sql'' fájl tartalmát. A végén '''exit''' paranccsal léphetünk vissza a BASH környezetbe.

=== VPC ===
A '''V'''irtual '''P'''rivate '''C'''loud egy szolgáltatás, melynek segítségével össze köthetjük az összetartozó komponenseket, alkalmazásokat. A VPC-t modellezhetjük hétköznapibb értelemben, mint egy routert, amelynek vannak alhálózatai, route táblája és valamilyen gateway címe, amin keresztül a kliensei az internet más résztvevőivel tudnak kommunikálni.

A VPC szolgáltatásait a keresőbe írt ''VPC'' kulccsal érhetjük el.
==== VPC létrehozása ====
Navigáljunk a 'Your VPCs' menüpontra a bal oldali menüben és kattintsunk a jobb felső sarokban látható ''Create VPC' gombra. Ezután megnyílik egy űrlap, amely végig vezet minket a telepítés lépésein.

Az űrlap elején választhatunk, hogy ''VPC only'' vagy ''VPC and more'' módban szeretnénk folytatni. Előbbi csak a VPC-t hozza létre nevéből is adódóan, míg a másik opcióval létrehozhatjuk az alhálózatokat is, igaz, a tervezés szabadságáról le kell ilyenkor mondanunk, cserébe grafikán láthatjuk az eredményt. Számunkra az órán utóbbi nem lesz megfelelő, hiszen szükségünk lesz a ''tervezés szabadságára''. 
[[Fájl:GAMFAWS vpc setup.png]]

A VPC beállításainál mindig a teljes hálózatot átfogó IP/MASZK párost kell megadnunk, később az alhálózatok nem lóghatnak ki az itt megadott tartományból.

==== Alhálózatok ====
Az alhálózatok lehetőséget biztosítanak arra, hogy az egyes komponenseket el is szigeteljük egymástól, meg engedélyezzünk is közöttük bizonyos kommunikációt.

Alhálózatok típusai:
* Publikus: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten kapnak publikus IP címet
* Privát: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten nem kapnak publikus IP címet

===== Alhálózatok létrehozása =====
Navigáljunk a ''Subnets'' menüpontra. A képernyő jobb felső sarkában kattintsunk a ''Create subnet'' gombra, így megkapjuk a létrehozási űrlapot.

'''Először''' a VPC-t kell kiválasztanunk, aminek eredményeképp kiírja segítségképp annak tartományát. Ezen a tartományon kívül nem léphetünk. 
[[Fájl:GAMFAWS vpc subnet setup.png]]

A VPC kiválasztása után aktívvá válik az alhálózatok űrlap, ahol megadhatjuk annak nevét, hálózati címét és maszkját. 
[[Fájl:GAMFAWS vpc subnet setup new.png]]

'''Figyelem!''' A rendszer csak hálózati címet fogad el! Minden más esetben hibát ír ki.

A ''Remove'' gombbal eltávolíthatjuk az aktuális konfigurációt a listából, míg a lentebb található ''Add new subnet'' segítségével újabbat vehetünk fel.

Befejezésül nyomjuk meg a ''Create subnet'' gombot, így az összes definiált alhálózat létrejön a kiválasztott VPC-hez.

===== Publikus/Privát alhálózat beállítása =====
Az alhálózat típusának átállításához navigáljunk a ''Subnets'' menüpontra. Kattintsunk jobb gombbal a kívánt alhálózat során és válasszuk ki az ''Edit subnet settings'' opciót. 
[[Fájl:GAMFAWS vpc subnet edit s settings.png]]

Az űrlapon keressük meg az ''Auto-assign IP settings'' blokkot és a kívánt típusnak megfelelően módosítsuk azt.
[[Fájl:GAMFAWS vpc subnet edit type.png]]

===== Különböző route tábla minden alhálózaton =====
A VPC támogatja, hogy minden subnet saját route táblával rendelkezzen. Ez lehet akár egy biztonsági funkció is, hogy ne ismerje minden EC2 az útvonalat egy adott szerverhez, de egyes esetekben kötelezően létre kell hoznunk. A route táblákat a ''Route tables'' menüpontban hozhatjuk létre és a ''Subnets'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Edit route table association'' opciót kiválasztva szerkeszthetjük.

'''Figyelem!''' A route táblák cseréje okozhat internetelérési problémákat szerver oldalon, aminek következtében a futó szolgáltatások számunkra is elérhetetlenekké válnak (pl. SSH és/vagy HTTP/HTTPS stb.), így legyünk körültekintőek.

==== Internet Gateway ====
Ahhoz, hogy a VPC-n belül legyen internet, ahhoz egy IGW-t kell hozzá csatolnunk. Ezt megelőzően azonban létre kell hoznunk egyet.
'''Figyelem!''' A VPC-hez nem kapcsolt IGW-k pénzbe kerülhetnek, mivel feleslegesen foglalnak le egy publikus IPv4 címet.

[[Fájl:GAMFAWS vpc igw setup.png|bélyegkép|Internet Gateway létrehozás]]
Az IGW az ''Internet Gateways'' menüpont alatt érhető el és a jobb felső sarokban található ''Create internet gateway'' gombbal hozhatunk létre újat. Csupán egy nevet kell megadnunk, illetve rakhatunk rá tag-eket igény szerint.

A létrehozást követően hozzá kell rendelnünk egy létező VPC-hez, amit az ''Internet Gateways'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Attach to VPC'' opciót kiválasztva tudunk megtenni. Amennyiben a soron az ''Attached'' (zöld színű) felirat jelenik meg a (szürke színű) ''Detached'' helyett, akkor nem tudjuk VPC-hez csatolni (ilyenkor először a ''Detach from VPC'' opciót kell választanunk). 
[[Fájl:GAMFAWS vpc igw attach.png]]

Az IGW VPC-hez rendelése után a kívánt route táblákba fel kell vennünk, hogy minden csomagot arra irányítson.
[[Fájl:GAMFAWS vpc igw route setup.png]]

==== NAT Gateway ====
Lehetőség van Internet Gateway helyett NAT Gateway létrehozására is, de ez egy fizetős szolgáltatás. A nevének megfelelően ez lehetőséget biztosít, hogy azok az EC2-k, amelyek privát alhálózatba kerültek, kilássanak az internet felé (pl. frissítések keresése, telepítése), miközben védve vannak a kívülről érkező támadásoktól.
'''Ez egy lehetséges oka lehet, hogy külön válasszuk a route táblákat az alhálózatokon, hiszen az egyiknek minden csomagot az IGW felé, míg a másiknak minden csomagot a NAT Gateway felé kell továbbítania.''' ''Ha nem használunk NAT Gatewayt, akkor is érdemes lehet leválasztani az IGW-ről a privát alhálózatokat.''

=== AWSCLI ===
Az AWSCLI egy konzolos alkalmazás, amelynek segítségével menedzselhetjük környezetünket: hozhatunk létre új EC2-t akár, vagy kapcsolhatunk hozzá egyéb szolgáltatásokat (Security Group, ASG, LB stb.).

Az awscli program elérhető linux és windows környezetben egyaránt.

==== AWSCLI telepítése ====
A program telepítéséhez a következő parancsot kell futtatnunk: '''apt install awscli'''.
==== Access Key management ====
Az ''awscli'' hozzáférési kulcsokon keresztül kap jogosultságot a szolgáltatások adataihoz, így használata előtt készítenünk kell egy újat. Ez a nevünkre kattintva (jobb felül), majd a ''Security credentials'' menüpontot kiválasztva tehetjük meg, az ''Access keys'' szekcióban. Nyissuk ezt le és kattintsunk a ''Create New Access Key'' gombra. 
<center>
{|
| [[Fájl:GAMFAWS UserMenu.png|150px|keretnélküli]] || [[Fájl:GAMFAWS SecurityCredentials.png|keretnélküli]]
|}
</center>

A gomb megnyomása után egy felugró ablak fogad, amelyben megtalálható az ''Access Key'' és a ''Security Access Key'' értéke. Érdemes a fájlt letölteni, hogy később is elérhetők legyenek ezek az adatok, '''az AWS többet nem fogja engedélyezni ezek megjelenítését!''' Ha az adatokat később nem tudjuk megadni, akkor újat kell készíteni.
[[Fájl:GAMFAWS SecurityCredentials ShowData.png|középre]]

==== AWS CLI konfigurálás autentikációs adatokkal ====
Az eszköz telepítése annak konfigurálásával ér véget: meg kell adnunk az autentikációs tokeneket. 
Ezt az '''aws configure''' parancs kiadásával tehetjük meg, ahol egyesével bekéri a szükséges adatokat. Ahol nem szeretnénk változtatni az előző értéken (szögletes zárójelek között láthatjuk ezt), ott hagyjuk üresen a sort és csupán entert nyomjunk.
[[Fájl:GAMFAWS AWSCLI config.png|középre]]

Az adatok megadása után menedzselhetjük az aws parancsokkal a környezetünket. Az aws parancsairól az '''aws help''' szolgáltat információt.

=== S3 ===
Ez a szolgáltatás fájlok tárolására alkalmas.

Több típusa is elérhető:
* Standard:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban sűrűn használt objektumok tárolására alkalmas
** A régiók közötti szinkronizáció megoldott
* Instant Glacier:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban ritkábban használt, hosszú élettartamú, de azonnali hozzáférést igénylő objektumok tárolására alkalmas
* Flexible Glacier:
** Magas rendelkezésre állás jellemzi
** Az alkalmazásban ritkán használt (évente 1x-2x), a mérettől független költséggel rendelkező megoldás
* Deep Archive Glacier:
** 7-10 évig tárolt adatokhoz optimalizált költségvonzat
** Előnyös a backup adatok tárolásához

A szolgáltatás a keresőben ''S3'' füzérrel kereshető.

==== Bucket létrehozása ====
Új tárolót a ''Create bucket'' gomb segítségével hozhatunk létre. A megjelenő űrlapon a nevet kell kitölteni és érdemes egy pillantást vetni a publikusság beállításaira is, hogy ez ténylegesen a célunknak megfelelő legyen.

'''Figyelem!''' A névnek nem csupán a mi környezetünkön belül kell egyedinek lennie, hanem a teljes AWS-en belül.

{| style="margin:auto"
| [[Fájl:GAMFAWS S3 new name.png|bélyegkép]] || [[Fájl:GAMFAWS S3 new public.png|bélyegkép]]
|}

==== Bucket kezelése ''awscli'' programmal ====
Az '''aws s3 help''' parancs segítségével további információt szerezhetünk az egyes utasításokról.

'''Bucket tartalmának listázása''' 
<syntaxhighlight lang="bash">
aws s3 ls [bucket_name]
</syntaxhighlight>
[[Fájl:GAMFAWS S3 CLI LS.png|középre]]

'''Adatok másolása Bucket-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* LOCAL_PATH a lokális fájlrendszeren belüli elérési útvonala a forrásfájlnak (vagy könyvtárnak)
* REMOTE_PATH a cél helye az S3-ban
** Az s3:// jelzi, hogy a cél az S3-ban van (S3Uri)
** A mappák helyett PREFIX-ek vannak (/folder/to/my/file esetében /folder/to/my a PREFIX)
** A mappákat nem kell S3-ban létrehoznunk (az előző pontból következik), a fájlnév előtti prefix dönti el a hova tartozását
** A PREFIX-eket az '''ls''' úgy kezeli, mint egy mappát
[[Fájl:GAMFAWS S3 AWSCLI cp2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* --recursive jelzi, hogy a LOCAL_PATH alatt minden bejegyzést töltsön fel
[[Fájl:GAMFAWS S3 AWSCLI copy recursive2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ból helyi fájlrendszerbe''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive s3://REMOTE_PATH LOCAL_PATH
</syntaxhighlight>
[[Fájl:GAMFAWS S3 AWSCLI cp2local.png|középre]]

==== Bucket kezelése grafikus felületen keresztül ====
Az S3 tartalmát elérhetjük az AWS grafikus felületén keresztül is, így tölthetünk fel, törölhetünk és módosíthatunk fájlokat anélkül, hogy saját számítógépünkre telepítenénk az ''awscli'' programot.

# Nyissuk meg az S3 szolgáltatás vezérlőpultját
# Kattintsunk a szerkeszteni kívánt tárhely nevére [[Fájl:GAMFAWS S3f list.png]] 
# A vezérlőgombok segítségével végezzük el a kívánt műveletet (feltöltés, törlés), vagy válasszunk ki egy PREFIX-et az „almappák” tartalmának megtekintéséhez. [[Fájl:GAMFAWS S3 control.png|középre]]

= Alkalmazások telepítése =
== UI ==
== API ==

= Indítást gyorsító scriptek =
== UI indítás ==
<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun code
API_LB_DOMAIN="localhost" # api server IP

apt update
apt install wget unzip apache2 libapache2-mod-php8.1 php8.1 php8.1-curl -y

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui.php
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui_newproduct.php
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv ui.php /srv/$NEPTUN/index.php
mv ui_newproduct.php /srv/$NEPTUN/newproduct.php

# remove tmp directory
cd /
rm /tmp/code

cat << EOF > /etc/apache2/sites-enabled/000-default.conf
<VirtualHost *:80>
#ServerName www.example.com

ServerAdmin webmaster@localhost
DocumentRoot /srv/$NEPTUN

<Directory /srv/$NEPTUN/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>

ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

systemctl restart apache2
</syntaxhighlight>

== API indítás ==

<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun
MYSQL_DOMAIN="localhost" # RDS mysql domain

apt update
apt install wget unzip python3 python3-pip -y
python3-flask python3-mysql.connector --break-system-packages

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$MYSQL_DOMAIN/g" api.py
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv api.py /srv/$NEPTUN/

# remove tmp directory
cd /
rm /tmp/code

echo "@reboot root sleep 10s && python3 /srv/$NEPTUN/api.py &" >> /etc/crontab
cd /srv/$NEPTUN && python3 api.py &
‎</syntaxhighlight>

EDU::GAMF::Felhőalapú-szolgáltatások::AWS

2024-10-01T07:22:35Z

ApelPro: /* API indítás */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
[[category:GAMF AWS|AWS]]
== Amazon Web Services regisztráció ==
Az AWS mindenki számára biztosít 1 év ingyenes próbaverziót. Ehhez regisztrálnunk kell a rendszerbe, amihez szükségünk lesz egy email címre, egy telefonszámra a megerősítéshez és egy netes vásárlásra alkalmas bankkártyára. A regisztráció során az AWS 1$-ral meg terheli a számlát, de később erre nem tart igény, így a tranzakció lejáratakor jóváíródik a számlán.

== Ingyenes verzió korlátai ==
Az ingyenes verzióban nem minden érhető el és ami mégis, az sem korlátlan ideig (750 óra EC2 futási idő például), amit ha átlépünk, akkor fizetési kötelezettségünk jelentkezik a szolgáltató felé. Igyekezzünk mindent leállítani az órai munka illetve az otthoni gyakorlás után, hogy lehetőleg ne kerüljön pénzbe a féléves munkánk. A hallgatók által elszenvedett károkért sem az iskola sem Én nem tudunk felelősséget vállalni, de azt meg tudjuk ígérni, hogy fizetős szolgáltatást nem használunk és nem is kérünk számon.

== AWS alapok ==
'''Figyelem!''' Az iskolai hálózatból csak az eu-west-1 és az eu-central-1, azaz Írország és Frankfurt IP címei vannak engedélyezve, ezekre fogunk tudni SSH kapcsolaton keresztül csatlakozni. 
'''Figyelem!''' Próbaidőszak alatt minden szolgáltatás mellett keressük a ''Free tier eligible'' megjegyzést, különben fizetési kötelezettségünk adódhat!

=== EC2 szolgáltatásai ===
Az ''EC2'' gyakorlatilag egy VPS-nek feleltethető meg és nem is tévedünk vele hatalmasat. A neve az ''Elastic Cloud Compute'' szavak kezdőbetűiből kialakuló ''ECC''-ből fakad, a ''2''-es a végén jelzi, hogy a ''C'' betűből kettő van.

A különbséget a VPS-hez az EC2 futási ideje okozza: bár nem feltétlen, de meg van a lehetősége, hogy egyik napról a másikra megszűnjön egy EC2 úgy, hogy az alkalmazásunk mégis működőképes marad. E tulajdonsága miatt kapta az ''Elastic'' nevet, amit körültekintően kell kezelni: semmilyen adatot nem tárolhatunk úgy egy alkalmazáson belül, mint egy VPS esetén: a dinamikus adatok (pl. PHP Session, feltöltött fájok) egy EC2 csere esetén elvesznek, így ezeket nem helyben fogjuk tárolni.

Az EC2 szolgáltatásait a keresőmezőbe írt ''„EC2”'' kulcsszóval és az eredményekben megjelenő ''EC2''-re való kattintással érhetjük el.

[[Fájl:GAMFAWS search EC2.png.png]]

Az alapértelmezetten megjelenő menüpont a ''Dashboard'', ahol információkat találhatunk az ''EC2'' köré felhúzható szolgáltatásokról, melyeknek egy részét a továbbiakban tárgyalni is fogunk. Az összefoglaló táblázat az alább látható módon jelenik meg. '''Figyelem''', a táblázat csak az adott régióban elindított/elérhető szolgáltatásokat mutatja, régió váltása előtt érdemes az esetlegesen létrehozott, régió függő elemeket leállítani, hogy később ne jelenjen meg fizetési kötelezettség.

[[Fájl:GAMFAWS ec2 dashboard.png]]

==== EC2 telepítése és beállítása ====
EC2 létrehozásához meg kell nyomnunk a ''Launch instance'' gombot, melyet több helyen is elérhetünk:
* A Dashboardon
* A bal oldali menüben található ''Intances'' menüpont megnyitása után jobb felül
A gomb minden esetben a következőképp néz ki: [[Fájl:GAMFAWS ec2 launch instance button.png]]

A gombra kattintva egy űrlap jelenik meg, amely segítségével elvégezhetjük a szükséges beállításokat: 
======Név és tag beállítok======
Megadása nem kötelező, de több szerver futtatása esetén könnyebben azonosíthatjuk be őket ezek segítségével
[[Fájl:GAMFAWS ec2 setup name and tags.png]]

Az ''Add additional tags'' gombra kattintva további kulcs=érték párokat adhatunk hozzá, amivel dinamikusan csatolhatjuk össze egyéb szolgáltatásokkal, amelyek egy-egy kulcsot keresve döntik el, hogy melyik szolgáltatásokkal kell együttműködniük (például monitorozás bekapcsolása 'monitoring=true' kulcs=érték pár alapján.

======Kezdeti képfájl kiválasztása======
Az Amazon többféle indítóképpel is rendelkezik, így nagy valószínűséggel meg fogjuk találni a hozzánk közelálló operációs rendszert. Új hozzáadására nincs lehetőségünk, de készíthetünk az alapképfájlokból olyan verziót, ami már tartalmazza a saját konfigurációnkat (lásd [[GAMF :: Felhőalapú-szolgáltatások :: AWS#AMI_létrehozása|itt]]). 
[[Fájl:GAMFAWS ec2 setup AMI choose2.png]] 
Az órákon az Ubuntu legújabb verzióját használjuk, mivel ennek a Desktop változata az egyik legelterjedtebb a Linux felhasználók körében, így nem kell más környezetet megszoknia egy átlag hallgatónak. Érdemes lehet azonban egyéb disztribúciók kipróbálása is, különösen a '''Debian'''-t, '''Suse'''-t/'''OpenSuse'''-t, '''ReadHat'''-et és annak ingyenes változatait ('''AlmaLinux''', '''RockyLinuxtm''', amelyek az egykori '''CentOS'''-t hivatottak váltani), mivel céges környezetben ezek sűrűbben előfordulnak: némelyik a kisebb erőforrásigénye, míg másik az Enterprise szolgáltatásai miatt.

======Szerver típusának meghatározása======
Különböző erősségű szerverkonfigurációk közül választhatunk, de természetesen nem mindegyik érhető el az ingyenes verzióban. A számítógépek ára a konfiguráció függvényében változik, de csak azért az időért kell fizetni, amíg a szerver ''Running'' állapotban volt. Az órán az alapértelmezett ''t2.micro''-t használjuk. 
[[Fájl:GAMFAWS ec2 setup instance type.png]]

======Kulcspár hozzárendelése======
Az Amazonon belüli szolgáltatásokat felhasználónév/jelszó páros helyett SSH kulcspárok segítségével érjük el. Minden felhasználó számára készíthetünk egyet és jogosultságok segítségével korlátozhatjuk, hogy mihez férhet hozzá (IAM). 
Ebben a szekcióban ki kell választanunk, hogy a telepíteni kívánt EC2-höz milyen kulcspárral lehet majd hozzáférni. Amennyiben nem rendelkezünk még kulcspárral, úgy van lehetőségünk helyben elkészíteni a ''Create new keypair'' gomb segítségével, amelynek lépési megegyeznek az [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Kulcspár_létrehozása|itt]] leírtakkal. 
[[Fájl:GAMFAWS ec2 setup keypair.png]]

======Hálózati és biztonsági beállítások======
Az EC2-k közötti kommunikációs csatornák kialakításához definiálnunk kell, hogy melyik virtuális hálózatba akarjuk elhelyezni és milyen alkalmazásokat szeretnénk elérhetővé tenni. Ezt a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#VPC_beállításai|VPC]] és a [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Security_Group|Security Group]] beállításával tehetjük meg. Előbbi a virtuális hálózatnak felel meg, míg utóbbi hasonlóan egy tűzfalhoz, meghatározza, hogy a szerveren milyen portokat érhetünk el. Érdemes az SSH-t engedélyezni és ha webes alkalmazást szeretnénk rajta futtatni a későbbiekben, akkor a HTTP és/vagy HTTPS szolgáltatást/szolgáltatásokat is, így később nem kell szerkeszteni ezeket a beállításokat. 
[[Fájl:GAMFAWS ec2 setup networking.png]]

======Tárhely beállítások======
Ebben a részben adhatjuk meg, hogy a szerverünk mekkora tárhellyel rendelkezzen. Egy Linux alapú operációs rendszernek nem kell 8GB-nél több, így az alapértéken hagyhatjuk. Az itt megadott érték inkább csak egy korlát, valójában csak akkora tárhelyet vesz igénybe, amennyire ténylegesen szüksége van a rendszernek. Ez az érték alatt látható figyelmeztetés miatt lényeges, hiszen a 30GB-t elhagyva fizetőssé válik a tárterület is, ám ez nem jelenti, hogy csak 4 szervert tudnánk elindítani az ingyenes keretek között. 
[[Fájl:GAMFAWS ec2 setup ebs.png]]

Ezt a szolgáltatást EBS-nek nevezik (''Elastic Block Store'') és az EC2 megszűnésekor minden erre mentett adat elveszik, így általában az OS-t és az applikáció kódját tároljuk ezen - semmi dinamikus adatot.

======Haladó beállítások======
Ebben a szekcióban különböző beállításokat végezhetünk el, ám ezeket az órán nem módosítjuk. Érdekes lehet azonban a menüt lenyitva legalul található ''User data'' opció, amivel parancsokat adhatunk meg az új operációs rendszer számára, hogy miket futtasson le. Ennek segítségével lehetőségünk nyílik applikációk telepítésére - pl. git - és a kód letöltésére egy másik szerverről, amennyiben a kiválasztott képfájl nem tartalmazta azt. 
''Az órai keretek között ezt a funkciót nem használjuk ki, de érdemes lehet kipróbálni, mivel valós alkalmazások üzemeltetésekor jól jöhet.'' 
[[Fájl:GAMFAWS ec2 setup userdata.png]]

======Összefoglaló======
A beállító panel mellett jobbra találhatjuk az összefoglaló ablakot, amelyben megtalálható a ''Launch Instance'' gomb. Ennek segítségével kezdhetjük meg a végleges telepítést, ha erre rá nyomunk, akkor a rendszer megkezdi a kiválasztott konfiguráció telepítését. Ha ebben az ablakban pénzösszegeket látunk, akkor az egészen biztosan fizetési kötelezettséget vonz magával, legyünk körültekintőek. 
[[Fájl:GAMFAWS ec2 setup summary.png]]

======Az elkészült instance tulajdonságai======
A futó szerverek az ''Instances'' menüpontban érhetők el. Az egyes sorokra kattintva alul megtekinthetjük a beállításait, amely tartalmazza az AWS által kiosztott publikus és privát IP címeket és domain neveket. Ezeken keresztül tudunk kommunikálni szerverünkkel. 
[[Fájl:GAMFAWS ec2 properties.png]] 
''Jelen példában a külső IP címünk: 3.252.168.207, amit a mellette található ikonnal egyszerűen a vágólapra másolhatunk.''

======Csatlakozás Linux terminálból======
A csatlakozáshoz nyissunk meg egy terminált a CTRL+T billentyűkombinációval, majd navigáljunk a ''cd'' parancs segítségével a letöltött kulcsfájl mappájába. Az SSH megköveteli, hogy a csatlakozáshoz használt kulcsfájlhoz csak a tulajdonos felhasználó férjen hozzá, így a következő parancsot futtassuk le rajta: ''chmod 600 test.pem''

A következő paranccsal tudunk kapcsolódni: ''ssh -i test.pem ubuntu@3.252.168.207'' 
Ha a fenti parancs kéri, fogadjuk el a tanúsítványt. Amennyiben ''Permission error'' hibát kapunk, akkor a fenti ''chmod'' parancsra van szükségünk, vagy nem mi vagyunk a kulcsfájl tulajdonosai (''ls -l'' segíthet). 
A ''test.pem'' az AWS rendszerből letöltött .pem formátumú kulcsfájl, az ''ubuntu'' a szerveren elérhető felhasználó. A különböző disztribúcióknál használt felhasználónevekről [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connection-prereqs.html ezen] a linken tájékozódhatsz. 
[[Fájl:GAMFAWS ec2 connect linux.png]]

======Csatlakozás Putty használatával======
Amennyiben a .pem kiterjesztésű állományt töltöttük le az AWS rendszeréből, akkor a '''puttygen''' eszköz segítségével ki kell exportálni belőle a privát kulcsot. [https://www.ssh.com/academy/ssh/putty/windows/puttygen Ezen a linken] részletes segédlet található a programcsomaghoz, ahol további funkciók is bemutatásra kerülnek (pl. kulcsgenerálás).

==== Kulcspár létrehozása ====
A kulcspárok kezeléséhez a ''Key Pairs'' linket nyissuk meg a bal oldali menüből. Újat a jobb oldalon látható ''Create key pair'' gomb segítségével készíthetünk. [[Fájl:GAMFAWS ec2 keypair create.png]]

A gombra kattintva egy űrlapot kapunk, amely végig vezet minket a létrehozás lépésein.
# Név megadása
# Típus kiválasztása - ''RSA-val dolgozunk az órán''
# Letöltendő kulcs típusa - ''Linux terminálból való csatlakozáshoz a .pem fájlra lesz szükségünk''
# Esetleges tag-ek hozzárendelése
# A ''Create key pair'' gombra kattintva letölthetjük a kulcspárt

[[Fájl:GAMFAWS ec2 keypair setup.png|Kulcspár létrehozása]]

'''Figyelem!''' A kulcspár csak a létrehozás után tölthető le '''egyetlen egyszer''', az elvesztett fájlok nem reprodukálhatók! Amennyiben egy EC2 csak az elhagyott kulcspárral érhető el, úgy annak (EC2) törlése és újrakonfigurálása szükséges egy új kulccsal.

==== Security Group ====
A Security Group-ok segítségével kontrollálhatjuk, hogy a szervereinkhez milyen portokon férhetnek hozzá, tehát mintegy tűzfal működik. Egy Security Group több gépre is ráhúzható és függetlenül működik, azaz a megadott szabályokat nem másolja át az operációs rendszer konfigurációs állományaiba, mintegy a szerver elé telepített eszköz működik. Ennek köszönhetően futási időben változtathatjuk a szabályokat, életbelépésükhöz nem kell újracsinálni az EC2-ket.

A bal oldali sávban, a ''Network & Security'' csoportban érhető el.

===== Security Group hozzáadása =====
Egy új szabályrendszer felvételét kezdeményezhetjük az EC2 telepítésekor, ahogyan azt [[GAMF :: Felhőalapú-szolgáltatások :: AWS#Hálózati_és_biztonsági_beállítások|itt]] is láthattuk, de készíthetünk előre meghatározottakat is.

Az előre definiált csoportokat a ''Create Security Group'' gomb segítségével hozhatjuk létre, amelyet a jobb felső sarokban találhatunk meg. 
[[Fájl:GAMFAWS ec2 secg new button.png|bélyeg]sdfsad] 

A gomb megnyomását követően egy űrlapot kapunk, melynek 3 fő része van:
# Általános adatok [[Fájl:GAMFAWS ec2 secg new basic.png|bélyeg|Általános adatok]]
#* '''A név és a leírás mező megadása is kötelező'''
#* Itt választhatjuk ki, hogy mely VPC-ben szeretnénk elérhetővé tenni.
# Bejövő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg inbound.png|bélyegkép|Inbound rules]]
#* '''Az itt megjelenő szabályok lesznek engedélyezve a szerverünk felé, minden más csomag eldobásra kerül'''
#* Háromféle szabályból választhatunk:
#** '''Anywhere''' (IPv4, IPv6): A megadott IP típusból mindenhonnan elfogadjuk a csomagokat
#** '''Custom''': Csak a megadott IP címekről/IP tartományokból érjük el az adott portot
#** '''MyIP''': automatikusan beillesztésre kerül az felhasználó aktuális IP címe (hasonló a custom lehetőséghez)
# Kimenő csomagok szabályozása [[Fájl:GAMFAWS ec2 secg outbound.png|bélyegkép|Outbound rules]]
#* A kimenő forgalom szabályozása biztonsági szempontból megfontolandó, de természetesen a publikus alkalmazások esetében (pl. web) nem tudunk ilyen szűrést alkalmazni.
#* Alkalmazhatjuk például SSH-ra, hogy megszüntessük annak a lehetőségét, hogy egy esetleges fertőzésből kifolyólag SSH-t hackelgető botnetté változzunk (volt már hasonló tapasztalat).
#* Az órán ezzel bővebben nem foglalkozunk, de éles környezetben ne felejtsünk el ezen szabályok definiálására időt szánni.
# Tag-ek megadása

===== Security Group szerkesztése =====
A szerkeszteni kívánt soron kattintsunk jobb gombbal és válasszuk ki a szerkeszteni kívánt szabályok csoportját:
* '''Edit inbound rules''', ha a bejövő csomagok szűrését szeretnénk módosítani,
* ''' Edit outbound rules''', ha a kimenő forgalmat szeretnénk szűrni.
A megnyíló ablakban ugyanazon a módon vehetünk fel szabályokat, ahogyan a létrehozásnál. A módosítások mentés után életbe lépnek. 
[[Fájl:GAMFAWS ec2 secg context menu.png]]

==== Terheléselosztás vázlat ====
[[Fájl:EC2LoadBalancingRequirements.png|középre]]

==== AMI ====
Az AMI gyakorlatilag egy bitről-bitre lemásolt HDD képfájl, amely tömörítve lett. Így tárolja az összes elmentett adat- és konfigurációs állományt. Ha egy alkalmazást készítünk, akkor a következő okokból készítünk ilyen képfájlt:
# Biztonsági mentés a telepített szolgáltatásokról, így később nem kell egy esetleges hiba miatt újrakonfigurálni az egészet
# AutoScaling group-ba szeretnénk rendezni az alkalmazásunkat, annak pedig meg kell mondani, hogy melyik képfájlt indítsa el

'''Figyelem!''' A képfájlok úgynevezett snapshot-okat hoznak létre, amelyek tárolásáért fizetni kell, ha az összméret meghaladja a 8GB-ot. (A snapshotok az éppen futó rendszer miatt készülnek: minden írási műveletet lezár, majd a snapshot készítés után elindított írási műveletek már a háttértár egyéb területeire történik, amelyet a mentés nem fog tartalmazni, így garantálható, hogy nem lesznek félig lezárt fájlok a mentésben. Lásd bővebben: BTRFS (linux) és NTFS support). A pillanatképek nem törölhetők, amíg a belőlük készült AMI létezik!

===== AMI létrehozás lépései =====
'''Navigáljunk az Instances menüpontra, ahol láthatjuk, hogy milyen EC2 szolgáltatások vannak a rendszerünkben.'''
# Kattintsunk jobb gombbal azon az elemen, amelyet menteni szeretnénk
# Nyissuk ki az ''Image and templates'' menüpontot
# Kattintsunk a ''Create image'' lehetőségre 
[[Fájl:GAMFAWS ec2 ami create.png]]

'''Nevezzük el a képfájlt tetszés szerint''' 
[[Fájl:GAMFAWS ec2 ami setup.png]]

'''Navigáljunk a bal oldalon található menüben az ''Images'' szekcióhoz és válasszuk ki az ''AMIs'' elemet. Itt megtekinthetjük és törölhetjük a létrehozott képfájljainkat.''' 
[[Fájl:GAMFAWS ec2 ami list.png]]

'''Ha a mentés sikeresen elkészült, akkor az EC2 létrehozásánál kiválaszthatjuk azt.''' 
[[Fájl:GAMFAWS ec2 setup own ami select.png]]

==== Indítási konfigurációk elkészítése ====
Az indítási konfigurációk mind egy célt szolgálnak: egységes profilba rendezi az EC2-ről készült képfájlokat. Míg az AMI nem tárolt információt a mentett gép erőforrásáról, egy indítási konfigurációban megadhatjuk ezeket. Később ezek felhasználásával egyszerűbben indíthatunk újabb szervereket és vannak olyan esetek is, amikor a rendszer megköveteli, hogy a képfájl megadása helyett konkrét, hardverinformációkat is tároló konfigurációs sablonokat adjunk meg.

''Az Auto Scaling Group például megköveteli, hogy a következő kettő elem közül az egyiket megadjuk, ebből fogja tudni, hogy milyen típusú EC2-t, mekkora tárhellyel és milyen VPC-ben indítson el.''

===== Launch configuration =====
'''Egy kifutóban lévő konfigurációs séma, amely 2022. December 31-e után nem kapja meg a frissítéseket. Az AWS javaslata szerint érdemes ezeket a beállításokat a következőkben tárgyalt ''Launch template'' alá migrálni.

A ''Launch configuration'-nek nevezett séma egy egyszerűsített változata a sablonoknak. Jóval kevesebb beállítási lehetőséget tartalmaz, mint a párja, de tökéletesen elegendőt az ''Auto Scaling Group''hoz.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Auto Scaling group'' szekciót és válasszuk ki a ''Launch Configuration'' menüpontot. A jobb felső sarokban található ''Create launch configuration'' gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''Név megadása''', aminek segítségével később hivatkozhatunk erre az elemre. Kitöltése kötelező! 
[[Fájl:GAMFAWS ec2 launch conf setup name.png]]

''AMI kiválasztása'', tehát azok képfájl megadása, amit a kiválasztott EC2 konfiguráció futtatni fog. Lehetőségünk van a saját készítésű (''My AMIs'') és a közösségi képfájlok közül választani (''Marketplace''). 
[[Fájl:GAMFAWS ec2 launch conf setup ami.png]]

'''Instance típus''' alatt megadhatjuk, hogy a konfiguráció milyen teljesítményű legyen.
'''Ne feledjük el, hogy a t2.micro az ingyenes, a többi használata után fizetési kötelezettségünk jelenhet meg.'''
[[Fájl:GAMFAWS ec2 launch conf setup instance type.png]]

'''Az Additional configruation''' részben megadhatunk különböző paramétereket, amelyeket az EC2 fog felvenni - pl. mindenképp kapjon IP címet, a subnet beállításaitól függetlenül, vagy éppen ne kapjon; itt adhatjuk meg a telepítéskor lefuttatott scripteket (User data).

'''A Storage''' szekcióban megadhatjuk, hogy milyen lemezek és milyen méretűek legyenek a rendszerhez csatolva.

'''A Security Group''' részben kiválaszthatunk egy már meglévő szabályrendszert, vagy készíthetünk újat. 
[[Fájl:GAMFAWS ec2 launch conf setup secg.png]]

'''A Key pairs''' blokkban megadhatjuk, hogy milyen privát kulccsal léphetnek be a szerverekre. Ennek meglétét jóvá kell hagyni az alul található checkbox-szal. 
[[Fájl:GAMFAWS ec2 launch conf setup keypair.png]]

'''Végül kattintsunk a ''Create launch confgiration'' gombra a létrehozáshoz.'''

===== Launch template =====
A Launch template jóval gazdagabb a beállítási lehetőségekben, mint párja. A konfigurációs adatlap tartalmaz segédletet az AutoScaling Group-pal történő használathoz, amely ''required'', azaz kötelező mezőként jelöli meg azokat az adatbeviteli elemeket, amelyeket az automata skálázó rendszer használ. Érdemes ezt bekapcsolni, amennyiben ilyen célzattal készítjük el a sablonunkat.

====== A beállítás menete ======
Keressük meg a bal oldali menüben az ''Instances'' szekciót és válasszuk ki a ''Launch template'' menüpontot. Az oldal közepén vagy a jobb felső sarokban található Create launch configuration gombra kattintva egy űrlapot kapunk, ami végig vezet minket a telepítés menetén.

'''A sablon neve és leírása''' blokkban megadhatjuk a nevet és a leírást, de ugyanakkor itt választhatjuk ki azt a checkboxot is, ami később a segítségünkre lesz a konfigurációs sablon AutoScaling Group-hoz való illesztését is (''Auto Scaling guidence''). 
[[Fájl:GAMFAWS ec2 launch templ setup name.png]]

'''Az Application and OS images''' szekcióban megadhatjuk, hogy milyen AMI-val települjön az EC2. Itt választhatunk a sajátunkból, vagy az EC2-nél is megtalálható egyebekből. 
[[Fájl:GAMFAWS ec2 launch templ setup ami.png]]

'''Az Instance type''' csoportban megadhatjuk, hogy milyen teljesítményű gépet szeretnénk indítani.
'''Ne feledjük el, hogy az ingyenes változatban a t2.micro érhető el, másik lehetőség választása esetén fizetési kötelezettségek léphetnek fel!''' 
[[Fájl:GAMFAWS ec2 launch templ setup instancetype.png]]

'''A Key Pair''' blokkban megadhatjuk, hogy a gépek milyen kulcspárral engedélyezzék a belépést. 
[[Fájl:GAMFAWS ec2 launch templ setup key pair.png]]

'''A Network Confguration''' részben definiálhatjuk, hogy milyen VPC-be szeretnénk lerakni az EC2-ket, milyen security group legyen rajtuk. Természetesen utóbbi helyben is létrehozható, ha korábban ezt nem készítettük volna el. 
[[Fájl:GAMFAWS ec2 launch templ setup network.png]]

'''A Storage'''-nél megadhatjuk, hogy milyen kötetek, milyen méretben legyenek hozzácsatolva a rendszerhez.

'''A Tags''' blokkban felvehetjük a kívánt ''kulcs=érték'' párokat.

'''Az Additional Configuration''' szekcióban különböző haladó beállításokat eszközölhetünk a sablon által létrehozott EC2-n, többet között itt adhatjuk meg az indításkor lefuttatandó parancsok listáját (''User data'').

'''Végül kattintsunk a Create launch template nyomógombra a mentéshez!'''.

==== Target Group ====
A target group EC2-k azon csoportja, amelyeken valamilyen ''health check'' algoritmust futtatunk, ezzel meghatározva, hogy az adott csoportban hány használható, működő szerver fut. Ezt az információt elsőként a Load balancer használja ki.

A Target Group a bal oldali menüben, a ''Load Balancing'' szekcióban érhető el ''Target Groups'' néven.

Létrehozhatunk új csoportot, de meg kell adnunk, hogy milyen módon kerüljenek bele az EC2-k. Erre a következő metódusokat ajánlja fel az Amazon:
# Konkrét EC2 (Instance) kiválasztása
# EC2-k definiálása IP tartománnyal
# Lambda függvény hozzáadása
# Alkalmazás LoadBalancer, amely egy teljes VPC tartalmát magába foglalja.

Az űrlap alján megadhatjuk, hogy milyen életjel ellenőrzés történjen.

Általában nem mi vesszük fel egyesével az Instancokat ebbe a csoportba, hanem az AutoScaling group regisztrálja őket bele. '''Ezért ezt az űrlapot nem használjuk'''.

==== Load Balancer ====
A Load Balancer terheléselosztást jelent, tehát a bejövő forgalmat több gép között osztjuk el. Ezzel növekszik a felhasználói élmény, ráadásul a rendszer megállítása (egy hacker által) nehezebbé válik: ha kettő t2.micro teljesítményű szerver fut, amelyek között elosztjuk a bejövő forgalmat, akkor a rendszerünk valójában 2xt2.micro teljesítményű.

Terheléselosztót a bal oldali menü ''Load Balancing'' szekciójának ''Load Balancers'' menüpontjában hozhatunk létre.

'''A támogatott szolgáltatási szintek:'''
# Alkalmazás terheléselosztás (HTTP, HTTPS)
# Hálózati terheléselosztás (TCP, UDP)
# Átjáró terheléselosztása (GW)

===== Alkalmazás terheléselosztása =====
Ebben a formában konfigurálhatjuk az eszközt úgy, hogy az internet felől elérhető legyen (internet-facing) és úgy, hogy csak belső hálózaton működjön (internal). A belső hálózatot mindig az aktuális VPC-re kell érteni, tehát annak minden alhálózatából elérhető alapértelmezetten.
[[Fájl:GAMFAWS ec2 loadbalancer setup basic.png]]

A hálózati beállításoknál választhatunk, hogy mely alhálózatokban szeretnénk végrehajtani a terheléselosztást, így csak az azokban futó EC2-k kaphatnak ezen keresztül csomagokat. Arra kell ügyelnünk, hogy legalább kettő különböző zónában lévő alhálózatot kell kiválasztanunk (pl. eu-west-1a, eu-west-1b stb.).
[[Fájl:GAMFAWS ec2 loadbalancer setup network.png]]

Természetesen a LoadBalancer internetfelőli végpontján létrehozhatunk ''Security Group''okat, amelyet szabályozzák, hogy milyen IP címről fogadunk el csomagokat.
[[Fájl:GAMFAWS ec2 loadbalancer setup secg.png]]

A ''Listeners and routing'' résznél megadhatjuk, hogy melyik target group fogja a terhelést fogadni, tehát hogy mely EC2-k között tudunk ténylegesen terhelést elosztani. Amennyiben a target group egy darab EC2-t tartalmaz, akkor a terheléselosztás gyakorlatilag nem valósul meg, csak az elméleti esélyét adtuk meg, hogy ''„amennyiben lenne még egy EC2 a target group-ban, akkor a terhelés egy részét az vinné el”''.
[[Fájl:GAMFAWS ec2 loadbalancer setup routing.png]]

Végül kattintsunk a ''Create load balancer'' gombra, amennyiben a kívánt tag-eket is rögzítettük.

==== Auto Scaling Group ====
A szolgáltatás segítségével automatikusan skálázott rendszereket építhetünk ki, ahol a szerverek által nyújtott elérhető erőforrásokat minél közelebb tartja a bejövő terhelés által meghatározott erőforrásigényhez. Természetesen mindez akkor igaz, ha az ''Auto Scaling Group'' be regisztrálja az általa létrehozott ''EC2''-ket egy ''Target Group''-ba, ami felett ''Load Balancing'' van definiálva.

'''Előnyei''':
* Amikor nincs bejövő terhelés, akkor nincsenek nagy költségek
* Amikor nagy a bejövő terhelés, akkor a költségek megugranak ugyan, de az ügyfeleket ki tudtuk szolgálni úgy, hogy elégedettek voltak a rendszer teljesítményével.

'''Hátrányai''':
* Kaotikus számlák, nem előre tervezhető költségek
* Megnövekedett költségek DDoS és egyéb támadások esetén

===== A beállítás lépései =====
A szolgáltatást a bal oldali menü ''Auto Scaling Group'' szekciójában érjük el, az ''Auto Scaling Group'' menüpontban. A képernyő közepén vagy a képernyő jobb felső sarkában megjelenő ''Create auto scaling group'' gombra kattintva egy űrlap jelenik meg, ami végig vezet minket a telepítés lépésein.

'''A Name''' szekcióban elnevezzük az új group-ot.
[[Fájl:GAMFAWS ec2 autoscaling setup name.png]]

'''A következő szekcióban''' két választási lehetőségünk van:
* Launch Template-tel telepítjük az új group-ot, ez esetben csak ki kell választanunk a korábban létrehozott sablont, vagy az alatta található link segítségével készíthetünk újat. ''Amennyiben újat készítünk, a sablon létrehozása új ablakban nyílik meg, így a befejezést követően vissza kéne térnünk erre és a frissítést gombot megnyomva látni fogjuk az új lehetősége(ke)t.
[[Fájl:GAMFAWS ec2 autoscaling setup lt.png]]

* Launch Configuration-nel telepítjük az új group-ot, ez esetben át kell váltatnunk a ''Switch to launch configuration'' link segítségével a blokkot. A váltást követően hasonlóan az előzőekhez: vagy kiválasztjuk a már meglévő konfigurációs sémát, vagy hozhatunk létre újat.
[[Fájl:GAMFAWS ec2 autoscaling setup lc.png]]

'''A Next gombra kattintva a hálózati beállítások''' szekcióhoz érünk, ahol megadhatjuk, hogy az indított EC2 milyen VPC-be kerüljön és azon belül milyen alhálózatokba. VPC-ből egy, alhálózatból több is kiválasztható. Ügyeljünk rá, hogy ha később erre Load Balancer szolgáltatás is kerül, akkor legalább kettő zónát jelöljünk ki!
'''Figyelem!''' A zóna nem egyezik meg az alhálózattal!
[[Fájl:GAMFAWS ec2 autoscaling setup network.png]]

'''A Next gombra kattintva a Load Balancing beállítások''' következnek, ahol választhatunk:
* Nincs terheléselosztás opciót,
* Létező Load Balancer hozzáillesztését,
* Új Load Balancer létrehozását.

Utóbbi esetében a Load Balancer konfigurálásánál leírt módon ki kell töltenünk a Load Balancer űrlapját is helyben. 
[[Fájl:GAMFAWS ec2 autoscaling setup lb setup.png]]

Hasonlóan a ''Target Group''-ot is létrehozhatjuk helyben, amennyiben ezt nem tettük meg korábban.
[[Fájl:GAMFAWS ece autoscaling setup new lb new tg.png]]

'''A Next gombra kattintva a csoport méretét definiálhatjuk''', azaz megszabhatjuk, hogy hány darab szervertől, hány darab szerverig engedélyezzük az automatikus skálázást. Ez egy hasznos funkció, hiszen ezzel korlátok közé szoríthatjuk a költségeinket, miközben a legkisebb terhelés esetén is előkészülhetünk egy hirtelen bejövő nagyobb terhelésre (ha a minimum nem 1).
* Desired capacity: ennyi szervert fog elindítani az ASG mentés után
* Minimum capacity: ennyi szerver esetén már nem állít le semmit az ASG
* Maximum capacity: ennyi szerver esetén már nem indít el újabbat az ASG
[[Fájl:GAMFAWS ec2 autoscaling setup group.png]]

'''Alatta a Scaling Policy''' blokkban megadhatjuk, hogy milyen paraméterek mentén indítson vagy épp állítson le szervereket az ASG. Ehhez aktiválnunk kell a szolgáltatást és a ''Metric type'' listából ki kell választani az számunkra megfelelőt. Mi általában CPU terhelés alapján döntünk az órán.
[[Fájl:GAMFAWS ec2 autoscaling setup scaling.png]]

'''A Next gombokkal lépkedve hozhatunk létre Tag-eket, majd végül létrehozhatjuk az ASG-t is és az ''Instances'' menüpontban ellenőrizhetjük, hogy ténylegesen elindult a kívánt darabszámú szerver.'''

=== RDS szolgáltatások ===
A ''Relational Database Service'' foglalja magában a különböző adatbázisokat:
* MariaDB
* MySQL
* Aurora
* Oracle
* PostgreSQL
* MSSQL

'''Figyelem!''' Az itt felsorolt szerverek között lehetnek fizetősek is. Mindig járjunk el figyelmesen, kövessük a költségeket. Az RDS az amazon egyik legdrágább szolgáltatása.

==== MySQL adatbázis telepítése ====
==== Csatlakozás MySQL adatbázishoz CLI-ből ====
<syntaxhighlight lang="bash">
apt install mysql-client -y
# mysql -h<rds_endpoint> -u<rds_user> -p<rds_password>
mysql -hwebshop-989.rds.amazon.com -uadmin -p123456789
</syntaxhighlight>

A megnyíló '''mysql>''' PROMPT-ot tartalmazó sor azt jelenti, hogy sikeresen csatlakoztunk az SQL szerverhez. Amennyiben a csatlakozás sikertelen, akkor valószínűleg az RDS-hez kapcsolt Security Group beállításai nem engedik az EC2-ről a kapcsolódást - tipikusan a mi saját publikus IP címünk kerül bele az engedélyezett tartományba (pl. iskolai IP vagy otthoni) és ez nem került átírásra az amazonos tartománynak megfelelően.

A konzolra be kell illeszteni a ''networks.sql'' fájl tartalmát. A végén '''exit''' paranccsal léphetünk vissza a BASH környezetbe.

=== VPC ===
A '''V'''irtual '''P'''rivate '''C'''loud egy szolgáltatás, melynek segítségével össze köthetjük az összetartozó komponenseket, alkalmazásokat. A VPC-t modellezhetjük hétköznapibb értelemben, mint egy routert, amelynek vannak alhálózatai, route táblája és valamilyen gateway címe, amin keresztül a kliensei az internet más résztvevőivel tudnak kommunikálni.

A VPC szolgáltatásait a keresőbe írt ''VPC'' kulccsal érhetjük el.
==== VPC létrehozása ====
Navigáljunk a 'Your VPCs' menüpontra a bal oldali menüben és kattintsunk a jobb felső sarokban látható ''Create VPC' gombra. Ezután megnyílik egy űrlap, amely végig vezet minket a telepítés lépésein.

Az űrlap elején választhatunk, hogy ''VPC only'' vagy ''VPC and more'' módban szeretnénk folytatni. Előbbi csak a VPC-t hozza létre nevéből is adódóan, míg a másik opcióval létrehozhatjuk az alhálózatokat is, igaz, a tervezés szabadságáról le kell ilyenkor mondanunk, cserébe grafikán láthatjuk az eredményt. Számunkra az órán utóbbi nem lesz megfelelő, hiszen szükségünk lesz a ''tervezés szabadságára''. 
[[Fájl:GAMFAWS vpc setup.png]]

A VPC beállításainál mindig a teljes hálózatot átfogó IP/MASZK párost kell megadnunk, később az alhálózatok nem lóghatnak ki az itt megadott tartományból.

==== Alhálózatok ====
Az alhálózatok lehetőséget biztosítanak arra, hogy az egyes komponenseket el is szigeteljük egymástól, meg engedélyezzünk is közöttük bizonyos kommunikációt.

Alhálózatok típusai:
* Publikus: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten kapnak publikus IP címet
* Privát: az alhálózatban létrehozott EC2-k és egyéb szolgáltatások alapértelmezetten nem kapnak publikus IP címet

===== Alhálózatok létrehozása =====
Navigáljunk a ''Subnets'' menüpontra. A képernyő jobb felső sarkában kattintsunk a ''Create subnet'' gombra, így megkapjuk a létrehozási űrlapot.

'''Először''' a VPC-t kell kiválasztanunk, aminek eredményeképp kiírja segítségképp annak tartományát. Ezen a tartományon kívül nem léphetünk. 
[[Fájl:GAMFAWS vpc subnet setup.png]]

A VPC kiválasztása után aktívvá válik az alhálózatok űrlap, ahol megadhatjuk annak nevét, hálózati címét és maszkját. 
[[Fájl:GAMFAWS vpc subnet setup new.png]]

'''Figyelem!''' A rendszer csak hálózati címet fogad el! Minden más esetben hibát ír ki.

A ''Remove'' gombbal eltávolíthatjuk az aktuális konfigurációt a listából, míg a lentebb található ''Add new subnet'' segítségével újabbat vehetünk fel.

Befejezésül nyomjuk meg a ''Create subnet'' gombot, így az összes definiált alhálózat létrejön a kiválasztott VPC-hez.

===== Publikus/Privát alhálózat beállítása =====
Az alhálózat típusának átállításához navigáljunk a ''Subnets'' menüpontra. Kattintsunk jobb gombbal a kívánt alhálózat során és válasszuk ki az ''Edit subnet settings'' opciót. 
[[Fájl:GAMFAWS vpc subnet edit s settings.png]]

Az űrlapon keressük meg az ''Auto-assign IP settings'' blokkot és a kívánt típusnak megfelelően módosítsuk azt.
[[Fájl:GAMFAWS vpc subnet edit type.png]]

===== Különböző route tábla minden alhálózaton =====
A VPC támogatja, hogy minden subnet saját route táblával rendelkezzen. Ez lehet akár egy biztonsági funkció is, hogy ne ismerje minden EC2 az útvonalat egy adott szerverhez, de egyes esetekben kötelezően létre kell hoznunk. A route táblákat a ''Route tables'' menüpontban hozhatjuk létre és a ''Subnets'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Edit route table association'' opciót kiválasztva szerkeszthetjük.

'''Figyelem!''' A route táblák cseréje okozhat internetelérési problémákat szerver oldalon, aminek következtében a futó szolgáltatások számunkra is elérhetetlenekké válnak (pl. SSH és/vagy HTTP/HTTPS stb.), így legyünk körültekintőek.

==== Internet Gateway ====
Ahhoz, hogy a VPC-n belül legyen internet, ahhoz egy IGW-t kell hozzá csatolnunk. Ezt megelőzően azonban létre kell hoznunk egyet.
'''Figyelem!''' A VPC-hez nem kapcsolt IGW-k pénzbe kerülhetnek, mivel feleslegesen foglalnak le egy publikus IPv4 címet.

[[Fájl:GAMFAWS vpc igw setup.png|bélyegkép|Internet Gateway létrehozás]]
Az IGW az ''Internet Gateways'' menüpont alatt érhető el és a jobb felső sarokban található ''Create internet gateway'' gombbal hozhatunk létre újat. Csupán egy nevet kell megadnunk, illetve rakhatunk rá tag-eket igény szerint.

A létrehozást követően hozzá kell rendelnünk egy létező VPC-hez, amit az ''Internet Gateways'' menüben, a módosítani kívánt soron jobb gombbal kattintva és az ''Attach to VPC'' opciót kiválasztva tudunk megtenni. Amennyiben a soron az ''Attached'' (zöld színű) felirat jelenik meg a (szürke színű) ''Detached'' helyett, akkor nem tudjuk VPC-hez csatolni (ilyenkor először a ''Detach from VPC'' opciót kell választanunk). 
[[Fájl:GAMFAWS vpc igw attach.png]]

Az IGW VPC-hez rendelése után a kívánt route táblákba fel kell vennünk, hogy minden csomagot arra irányítson.
[[Fájl:GAMFAWS vpc igw route setup.png]]

==== NAT Gateway ====
Lehetőség van Internet Gateway helyett NAT Gateway létrehozására is, de ez egy fizetős szolgáltatás. A nevének megfelelően ez lehetőséget biztosít, hogy azok az EC2-k, amelyek privát alhálózatba kerültek, kilássanak az internet felé (pl. frissítések keresése, telepítése), miközben védve vannak a kívülről érkező támadásoktól.
'''Ez egy lehetséges oka lehet, hogy külön válasszuk a route táblákat az alhálózatokon, hiszen az egyiknek minden csomagot az IGW felé, míg a másiknak minden csomagot a NAT Gateway felé kell továbbítania.''' ''Ha nem használunk NAT Gatewayt, akkor is érdemes lehet leválasztani az IGW-ről a privát alhálózatokat.''

=== AWSCLI ===
Az AWSCLI egy konzolos alkalmazás, amelynek segítségével menedzselhetjük környezetünket: hozhatunk létre új EC2-t akár, vagy kapcsolhatunk hozzá egyéb szolgáltatásokat (Security Group, ASG, LB stb.).

Az awscli program elérhető linux és windows környezetben egyaránt.

==== AWSCLI telepítése ====
A program telepítéséhez a következő parancsot kell futtatnunk: '''apt install awscli'''.
==== Access Key management ====
Az ''awscli'' hozzáférési kulcsokon keresztül kap jogosultságot a szolgáltatások adataihoz, így használata előtt készítenünk kell egy újat. Ez a nevünkre kattintva (jobb felül), majd a ''Security credentials'' menüpontot kiválasztva tehetjük meg, az ''Access keys'' szekcióban. Nyissuk ezt le és kattintsunk a ''Create New Access Key'' gombra. 
<center>
{|
| [[Fájl:GAMFAWS UserMenu.png|150px|keretnélküli]] || [[Fájl:GAMFAWS SecurityCredentials.png|keretnélküli]]
|}
</center>

A gomb megnyomása után egy felugró ablak fogad, amelyben megtalálható az ''Access Key'' és a ''Security Access Key'' értéke. Érdemes a fájlt letölteni, hogy később is elérhetők legyenek ezek az adatok, '''az AWS többet nem fogja engedélyezni ezek megjelenítését!''' Ha az adatokat később nem tudjuk megadni, akkor újat kell készíteni.
[[Fájl:GAMFAWS SecurityCredentials ShowData.png|középre]]

==== AWS CLI konfigurálás autentikációs adatokkal ====
Az eszköz telepítése annak konfigurálásával ér véget: meg kell adnunk az autentikációs tokeneket. 
Ezt az '''aws configure''' parancs kiadásával tehetjük meg, ahol egyesével bekéri a szükséges adatokat. Ahol nem szeretnénk változtatni az előző értéken (szögletes zárójelek között láthatjuk ezt), ott hagyjuk üresen a sort és csupán entert nyomjunk.
[[Fájl:GAMFAWS AWSCLI config.png|középre]]

Az adatok megadása után menedzselhetjük az aws parancsokkal a környezetünket. Az aws parancsairól az '''aws help''' szolgáltat információt.

=== S3 ===
Ez a szolgáltatás fájlok tárolására alkalmas.

Több típusa is elérhető:
* Standard:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban sűrűn használt objektumok tárolására alkalmas
** A régiók közötti szinkronizáció megoldott
* Instant Glacier:
** Magas rendelkezésre állás jellemzi (99.99%)
** Az alkalmazásban ritkábban használt, hosszú élettartamú, de azonnali hozzáférést igénylő objektumok tárolására alkalmas
* Flexible Glacier:
** Magas rendelkezésre állás jellemzi
** Az alkalmazásban ritkán használt (évente 1x-2x), a mérettől független költséggel rendelkező megoldás
* Deep Archive Glacier:
** 7-10 évig tárolt adatokhoz optimalizált költségvonzat
** Előnyös a backup adatok tárolásához

A szolgáltatás a keresőben ''S3'' füzérrel kereshető.

==== Bucket létrehozása ====
Új tárolót a ''Create bucket'' gomb segítségével hozhatunk létre. A megjelenő űrlapon a nevet kell kitölteni és érdemes egy pillantást vetni a publikusság beállításaira is, hogy ez ténylegesen a célunknak megfelelő legyen.

'''Figyelem!''' A névnek nem csupán a mi környezetünkön belül kell egyedinek lennie, hanem a teljes AWS-en belül.

{| style="margin:auto"
| [[Fájl:GAMFAWS S3 new name.png|bélyegkép]] || [[Fájl:GAMFAWS S3 new public.png|bélyegkép]]
|}

==== Bucket kezelése ''awscli'' programmal ====
Az '''aws s3 help''' parancs segítségével további információt szerezhetünk az egyes utasításokról.

'''Bucket tartalmának listázása''' 
<syntaxhighlight lang="bash">
aws s3 ls [bucket_name]
</syntaxhighlight>
[[Fájl:GAMFAWS S3 CLI LS.png|középre]]

'''Adatok másolása Bucket-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* LOCAL_PATH a lokális fájlrendszeren belüli elérési útvonala a forrásfájlnak (vagy könyvtárnak)
* REMOTE_PATH a cél helye az S3-ban
** Az s3:// jelzi, hogy a cél az S3-ban van (S3Uri)
** A mappák helyett PREFIX-ek vannak (/folder/to/my/file esetében /folder/to/my a PREFIX)
** A mappákat nem kell S3-ban létrehoznunk (az előző pontból következik), a fájlnév előtti prefix dönti el a hova tartozását
** A PREFIX-eket az '''ls''' úgy kezeli, mint egy mappát
[[Fájl:GAMFAWS S3 AWSCLI cp2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ba''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive LOCAL_PATH s3://REMOTE_PATH
</syntaxhighlight>
Ahol:
* --recursive jelzi, hogy a LOCAL_PATH alatt minden bejegyzést töltsön fel
[[Fájl:GAMFAWS S3 AWSCLI copy recursive2s3.png|középre]]

'''Adatok másolása rekurzívan S3-ból helyi fájlrendszerbe''' 
<syntaxhighlight lang="bash">
aws s3 cp --recursive s3://REMOTE_PATH LOCAL_PATH
</syntaxhighlight>
[[Fájl:GAMFAWS S3 AWSCLI cp2local.png|középre]]

==== Bucket kezelése grafikus felületen keresztül ====
Az S3 tartalmát elérhetjük az AWS grafikus felületén keresztül is, így tölthetünk fel, törölhetünk és módosíthatunk fájlokat anélkül, hogy saját számítógépünkre telepítenénk az ''awscli'' programot.

# Nyissuk meg az S3 szolgáltatás vezérlőpultját
# Kattintsunk a szerkeszteni kívánt tárhely nevére [[Fájl:GAMFAWS S3f list.png]] 
# A vezérlőgombok segítségével végezzük el a kívánt műveletet (feltöltés, törlés), vagy válasszunk ki egy PREFIX-et az „almappák” tartalmának megtekintéséhez. [[Fájl:GAMFAWS S3 control.png|középre]]

= Alkalmazások telepítése =
== UI ==
== API ==

= Indítást gyorsító scriptek =
== UI indítás ==
<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun code
API_LB_DOMAIN="localhost" # api server IP

apt update
apt install wget unzip apache2 libapache2-mod-php8.1 php8.1 php8.1-curl -y

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui.php
sed -i "s/<ip>/$API_LB_DOMAIN/g" ui_newproduct.php
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv ui.php /srv/$NEPTUN/index.php
mv ui_newproduct.php /srv/$NEPTUN/newproduct.php

# remove tmp directory
cd /
rm /tmp/code

cat << EOF > /etc/apache2/sites-enabled/000-default.conf
<VirtualHost *:80>
#ServerName www.example.com

ServerAdmin webmaster@localhost
DocumentRoot /srv/$NEPTUN

<Directory /srv/$NEPTUN/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>

ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

systemctl restart apache2
</syntaxhighlight>

== API indítás ==

<syntaxhighlight lang="bash">
#!/bin/bash

# variables
NEPTUN="neptun" # your neptun
MYSQL_DOMAIN="localhost" # RDS mysql domain

apt update
apt install wget unzip python3 python3-pip python3-flask python3-mysql.connector -y

# get code
mkdir /tmp/code
cd /tmp/code
wget https://wiki.farkas-attila.hu/images/c/c7/Weboldal.zip
unzip Weboldal.zip
#

# change <ip> tag in code
sed -i "s/<ip>/$MYSQL_DOMAIN/g" api.py
#

# create directory for server
mkdir -p /srv/$NEPTUN

mv api.py /srv/$NEPTUN/

# remove tmp directory
cd /
rm /tmp/code

echo "@reboot root sleep 10s && python3 /srv/$NEPTUN/api.py &" >> /etc/crontab
cd /srv/$NEPTUN && python3 api.py &
‎</syntaxhighlight>

EDU::GAMF::Felhőalapú-szolgáltatások

2024-09-16T07:14:35Z

ApelPro: /* A tantárgy követelményei - nem hivatalos */

[[category:GAMF]]
[[category:GAMF tantárgyak|Tantárgyak]]
== A tantárgy leírása - '''nem hivatalos''' ==
A tantárgy során alkalmazások felhőben történő üzemeltetéséről tanulhatnak a hallgatók. A piacon elérhető összes szolgáltatót nincs lehetőségünk tanulmányozni, de az Amazon Web Services (AWS) világában mélyebben elmerülünk és egy alkalmazást telepítünk bele.
A tárgy során a hallgatónak el kell sajátítania azt a készséget, hogy egy jól dokumentált alkalmazást (a csomag szükségletek közel teljes egészében meg vannak adva a fejlesztők által) elhelyezzenek amazonos környezetben, ismernie kell az elérhető eszközöket és a biztonsági funkciókat.

A félév második felében a Docker kapja a főszerepet, mivel manapság a legtöbb alkalmazás ebben készül. Ennek oka, hogy a fejlesztői környezet és a végleges környezet egyezősége garantálható. A hallgatók a tárgy teljesítése után képesek lesznek egy jól dokumentált alkalmazás telepítésére Docker környezetben, ami magában foglalja a képfájlok létrehozását és a futási környezetének kialakítását is.

== A tantárgy előfeltételei - '''nem hivatalos''' ==
A tantárgy épít a következő tantárgyakon tanultakra:
* '''Hálózati alapismeretek'''
** IP címek típusai (publikus, privát)
** Alhálózatok kialakítása
** Kis mértékben packet flow ismeretek
* '''Operációs rendszerek'''
** Linux CLI ismeretek
** BASH parancsok
** ''man'' készségszintű használata
** Konfigurációs állományok szerkesztésére alkalmas eszközök ismerete (vi, nano, mcedit stb.)
** LOG fájlok olvasása, tartalmuk szűrése
* '''Webes alkalmazásfejlesztés'''
** Webes applikációk forráskódjának értelmezése
** Infrastruktúra függő értékek felismerése és aktualizálása
* '''Haladó programozás'''
** python szintaktika
** Forráskód értelmezése

== A tantárgy követelményei - '''nem hivatalos''' ==
A tantárgy '''1db 70 pontos''' ZH-t és egy '''30 pontos kiselőadást''' foglal magában. A ZH-t a 11. vagy a 12. héten írják meg a hallgatók annak függvényében, hogy melyik héten van kevesebb ZH-juk az előzetes egyeztetések alapján.
A dolgozat során a hallgatók egyedi IP tartományt kapnak, amelyben egy VPC-t kell működtetniük AWS környezetben. Megkapják az alkalmazás kódját, az alkalmazás leírását - milyen komponensekből kell állnia - és az alhálózatok sorrendjét, amennyiben az értelmezhető a kiadott feladatban. A feladat megoldására a teljes óra rendelkezésre áll, segítségként a lentebb megjelölt források használhatók, minden más tiltott. A hallgatók a dolgozat során word-ben dokumentálják a lépéseket, a végén csak ezt kell beadni.

'''A kiselőadásból és a ZH-ból 50-50% el kell érni a félév sikeres teljesítéséhez.'''

A tantárgy értékelése szigorú, a mérnöki gondolkozást megköveteli (ha az alkalmazás nem működik, akkor a hallgató nem teljesítette az elvárásokat), ezért a működő alkalmazás is pontot ér (20-25p), amit képpel tud bizonyítani. Kivételt képez ez alól, amikor az AWS valamilyen hibája miatt (általában LoadBalancernél tud ez a hiba jelentkezni) nem működik. Ekkor a megelőző lépések alapján járhat a pont.

== A tárgy teljesítéséhez szükséges idő ==
Az állami elvárás szerint minden kredit megszerzése egy átlagos hallgató számára 30 óra ráfordítást vesz igénybe - beleértve a tanórákat, ZH és vizsgaalkalmakat, valamint az otthoni önálló tanulást is. Ez a tárgy 5 kreditet ér, tehát a félév során összesen 150 órát kell a hallgatóknak ezzel foglalkozniuk, ami sokszor a pótZH-ban (és manapság a pót-pót ZH-ban) csapódik le.
Mivel a félév során 13 hét áll rendelkezésünkre és mind az előadás, mind a gyakorlat 1,5 óra időtartamú, így összesen 39 órát ölel fel a tanórai képzés (ZH-val együtt). Rossz hír, hogy ez esetben egy gyakorlati jegyes tárgyról van szó, így a maradék időt legkésőbb a 13. hét végéig kell eltölteni otthoni tanulással, nem lehet a vizsgaidőszakra csúsztatni azt. Ez alapján heti 8.5, azaz valamivel több, mint napi 1,5 órát (heti 5 nappal számolva) a tárggyal kapcsolatos ismeretanyagok gyűjtésével és megértésével kellene a hallgatónak foglalkoznia. Mivel ezen számítás alapján a hallgatóknak napi 13,5 órát kellene 30 kredit felvétele esetén tanulással tölteni, így természetesen ez egy irreális elvárásnak bizonyul. Azonban kreditarányosan számolva, ezen tárgy esetében '''heti 2 óra''' ráfordítással éri el a hallgató a napi 8 órás munkaidőt (tanórák közötti szüneteket pihenőidőként kezelve) 30 kredit esetén, ami a normális szint. Ez tehát '''elvárhatónak és számon kérhetőnek bizonyul''' nappali tagozaton annak érdekében, hogy a hallgatók a lehető legnagyobb felkészültségben üljenek az órákon.

== A tárgy során használt dokumentumok ==
{| class="wikitable" style="margin:0px auto"
|-
! Elérési útvonal || Fájlnév !! cél alkalmazás || Cél fájlnév
|-
| rowspan=4 | [[file:weboldal.zip|weboldal.zip]]
| ui.php || Felhasználói felület (UI) || index.php
|-
| ui_newproduct.php || Felhasználói felület (UI) || newproduct.php
|-
| api.py || API || api.py
|-
| networks.sql || MySQL import || -
|-
| [[Fájl:Zhminta.pdf|Minta feladatsor]] || - || - || -
|-
| [[Fájl:Gamf-aws-docker-buil.zip|Docker fájlok]] || - || - || -
|-
|}

== Ajánlott irodalom lista ==
* Tanenbaum - Operációs rendszerek
* Tanenbaum - Számítógépes hálózatok
* Emett Dulaney - Linux All in One
* Kónya László - Számítógépes hálózatok
* Petrényi József
** TCP/IP 1 óra alatt
** TCP/IP alapok I. kötet
** TCP/IP alapok II. kötet
* Dr. Guta Gábor - Szoftverfejlesztés okosan Pythonnal
* Brad Dayley - Python zsebkönyv
* Kozmayer Viktor - PHP és MySQL az alapoktól
* Richard Blum - PHP, MySQL & Javascript 7 könyv az 1-ben
* Bódy Bence - Az SQL példákon keresztül (MSSQL)
* Dan C. Marinescu - Cloud Computing (Theory and Practice)

== Ajánlott online források, hivatkozások ==
* PHP dokumentáció: [https://php.net php.net]
* MySQL dokumentáció: [https://dev.mysql.com dev.mysql.com]
* Python dokumentáció: [https://python.org python.org]
* AWS dokumentáció: [https://docs.aws.amazon.com docs.aws.amazon.com]
* Ubuntu Segédlet: [https://help.ubuntu.com help.ubuntu.com]
* Ubuntu Tutorial: [https://ubuntu.com/tutorials ubuntu.com/tutorials]

== Az előadás menete ==
# összetett:
#* Regisztráció AWS felületen
#* követelmények ismertetése
#* bérelt szervertől (VPS) a felhő megoldásokig
# Felhő ökoszisztéma
# Adatközpontok belső hálózata
# Erőforrás virtualizálás
# Adattárolás a felhőben
# Felhőbiztonság
# Docker
# Kiselőadások
# Kiselőadások
# Kiselőadások
# Kiselőadások

Az előadás menete a ''Dan C. Marinescu - Cloud Computing (Theory and Practice)'' című könyv alapján került kidolgozásra, mely a könyvtárban megtekinthető / kölcsönözhető. Az általunk érintett témakörök nagyjából 150 oldalnyi terjedelemben jelennek meg a könyvben. Az oldalszámok az előadásjegyzetek oldalon találhatók.

== A gyakorlat menete ==
# Regisztráció az AWS rendszerében [https://portal.aws.amazon.com/billing/signup#/start/email]
# EC2 létrehozása, szolgáltatások áttekintése, Linux alapismeretek ismétlése
# EC2 létrehozása, alkalmazások telepítése és konfigurálása, apache2 kiszolgáló, PHP környezet
# UI felület élesztése: AMI létrehozás, Auto Scaling Group, Load Balancer
# Teljes alkalmazás élesztése: MySQL adatbázis (RDS), Python környezet telepítés
# Teljes alkalmazás élesztése: VPC-be szervezés, eszközök kommunikációjának szabályozása
# Docker telepítés, első konténerek elindítása, Dockerfile felépítése, docker.io regisztráció, image feltöltés
# Dockerfile felépítése, alkalmazások létrehozása, indítása
# Docker Compose felépítés, networking, debuggolás
# Teljes alkalmazás élesztése Docker Compose segítségével
# Készülés ZH-ra, kérdések megbeszélése
# ZH
# PótZH

== Kiselőadás témák ==

== Docker beadandó leírása ==
A feladat célja, hogy a hallgatók találkozzanak azokkal a pozitívumokkal, amelyeket a Docker környezet nyújt számunkra. Ezt olyan két - igen egyszerű - alkalmazáson keresztül szeretném szemléltetni, amelyek nem azonos PHP verzióval működnek, de azokat egy szerveren szeretnénk telepíteni.

Bár a PHP nyelv a nagy hangok szerint kihaló félben van, a régi alkalmazások üzemeltetése ma is elvárható feladat, ráadásul a hangokkal ellentétben ma is készülnek új alkalmazások a környezetben.

'''Figyelem!!''' A példában egy egyszerű kód szerepel, de a feladat hétköznapi problémát dolgoz fel!

'''Feladatpontok docker nélküli megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziók integrálása a kiszolgálóba
# Kód telepítése a kiszolgálónak megfelelő helyre
# Mindkét alkalmazásnak „OK” üzenetet kell mutatnia

'''Feladatpontok dockerrel történő megoldáshoz'''
# Apache2 / Nginx kiszolgáló telepítése
# Különböző PHP verziójú Docker image keresése / telepítése
# Kód injektálása a megfelelő könyvtárba a konténeren belül
# Reverse Proxy konfigurálása kiszolgálón
# Mindkét alkalmazásnak „OK” üzenetet kel mutatnia

A forráskódban egyszerűen elérhető, hogy mindkét kód „OK” üzenetet mutasson, de annak módosításával történő megoldás azonos a bonyoultabb (több 1000, akár több 10.000-1.000.000) soros kódok migrálásával az új PHP verziónak megfelelően, így amikor ezt a lépést választjuk, akkor gondoljuk át, hogy ez mennyire lehet egyszerű feladat!

=== Forrás ===
'''PHP5'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '5.6.40', '>')) {
printf("Az általad használt PHP verzió túl magas! Használj mamximum 5-ös verziót!");
} else {
printf("OK");
}
?>
</syntaxhighlight>

'''PHP7'''
<syntaxhighlight lang='php'>
<?php
if (version_compare(phpversion(), '7.0.0', '<')) {
printf("Az általad használt PHP verzió túl alacsony! Használj minimum 7-es verziót!");
} else {
printf("OK");
}
?>

</syntaxhighlight>

== Jegyzetek ==
* [[GAMF::Felhőalapú-szolgáltatások::Előadás|Előadás]]
* Gyakorlat
** [[EDU::GAMF::Felhőalapú-szolgáltatások::AWS|AWS]]
** [[EDU::GAMF::Felhőalapú-szolgáltatások::Docker|Docker]]
* [[EDU::GAMF::Felhőalapú-szolgáltatások::Rövidítések|Rövidítések]]

MediaWiki:Sidebar

2024-09-16T07:13:33Z

ApelPro:

* navigation
** mainpage|mainpage-description
* SEARCH

* GAMF
** EDU::GAMF::Felhőalapú-szolgáltatások|Felhőalapú-szolgáltatások
** EDU::GAMF::Operációs rendszerek|Operációs rendszerek
** EDU::GAMF::MikroTik-szabvál|MikroTik (SZ)

* MikroTik
** MikroTik::Scripting|Script

* Cégek
** OmegaByte
*** COMP::OmegaByte|OmegaByte

* Egyéb
** Hálózatok: fraktál|Hálózatok: fraktál
** ISP csatlakozási típusok|ISP csatlakozási típusok
** Hálózat rendelkezésreállás számítás|Hálózat rendelkezésreállás számítás
** Tipikus vállalati hálózati struktúra|Tipikus vállalati hálózati struktúra
** BGP protokoll|BGP protokoll