Backend elméleti alapok · 1. tananyag
Eddig olyan oldalakat készítettél, amelyek a böngészőben futottak: ha bezártad a lapot, minden elveszett. Egy webshopban viszont a rendelésed megmarad, egy naplóban a tanár ír be jegyet, te pedig csak olvasod. Mindezt a backend teszi lehetővé — egy program, ami nem a te gépeden fut, tárolja az adatokat, és eldönti, ki mit tehet meg.
A web működésének alapja a kliens–szerver modell:
A „szerver” szó két dolgot is jelenthet: a gépet (egy adatközpontban álló számítógép) és a programot (ami azon fut, és kéréseket szolgál ki). Amikor mi „szervert írunk”, a programra gondolunk. Egy gépen sok szerverprogram futhat egyszerre.
Fontos: a kliens–szerver szerep, nem eszköz. Ugyanaz a program az egyik kapcsolatban szerver, a másikban kliens: a webshop backendje szerver a böngésző felé, de kliens a fizetési szolgáltató API-ja felé.
| Fogalom | Mit azonosít? | Példa | Hasonlat |
|---|---|---|---|
| IP-cím Internet Protocol | Egy gépet a hálózaton | 93.184.216.34 | A ház utcai címe |
| Port | Egy programot a gépen belül | 3000, 443 | A lakás ajtószáma |
| Domain (DNS) Domain Name System | Emberi nevet ad az IP-nek | webshop. | A telefonkönyv |
Fejlesztés közben a saját gépünket a localhost névvel (IP-ben:
127.0.0.1) érjük el, és általában a 3000-es portot használjuk:
http://localhost:3000.
| Port | Mire használjuk |
|---|---|
| 80 | HTTP (titkosítatlan web) |
| 443 | HTTPS (titkosított web) |
| 3000 | Node.js fejlesztői szerver (bevett szokás, nem szabály) |
| 3306 | MySQL adatbázis |
| 5432 | PostgreSQL adatbázis |
| Szempont | Frontend | Backend |
|---|---|---|
| Hol fut? | A felhasználó eszközén, a böngészőben | Egy szerveren, távol a felhasználótól |
| Mit lát a felhasználó? | Mindent: a kódot is megnézheti | Semmit: csak a válaszokat |
| Fő felelősség | Megjelenítés, felhasználói élmény | Adat, logika, biztonság |
| Technológiák | HTML, CSS, JavaScript, React, Vue | Node.js, PHP, Java, Python, C#, Go |
| Adatbázis-hozzáférés | Nincs (közvetlenül soha) | Van |
| Ki futtatja? | Bárki, a saját gépén | A fejlesztő által ellenőrzött gép |
A full-stack fejlesztő mindkét oldalhoz ért. Ez a kurzus a backendről szól, de a végén összekötjük egy egyszerű frontenddel is.
„Amit a felhasználó lát és megérinthet, az frontend. Amit a felhasználónak nem szabad megváltoztatnia, az backend.”
Döntsd el, melyik oldal felelős a feladatért! Van, ami mindkettőé — nézd meg, miért.
Ez a fejezet legfontosabb ábrája — érdemes a lépéseit fejből tudni.
Egyetlen weboldal megnyitása jellemzően több tucat HTTP-kérést jelent: külön kérés megy a
HTML-ért, minden CSS- és JS-fájlért, képért, betűtípusért. Ezt a böngésző fejlesztői eszközeiben
(F12 → Network fül) végig is nézheted.
| Feladat | Példa a webshopból |
|---|---|
| Adattárolás és -lekérdezés | Termékek, vásárlók, rendelések mentése MySQL-be |
| Üzleti logika | Kosárérték számítása, kedvezmény alkalmazása, készlet csökkentése |
| Hitelesítés (authentication) | „Ki vagy te?” — bejelentkezés jelszóval, JWT (JSON Web Token) kiadása |
| Jogosultság (authorization) | „Mit tehetsz meg?” — csak admin törölhet terméket |
| Validáció | Az ár nem lehet negatív, az e-mail formátuma helyes |
| Külső szolgáltatások hívása | Bankkártyás fizetés, e-mail küldés, szállítmánykövetés |
| Fájlkezelés | Termékképek feltöltése, számla PDF generálása |
| Ütemezett feladatok | Éjszakai készletriport, lejárt kosarak törlése |
| Naplózás, monitorozás | Hibák rögzítése, ki mit csinált és mikor |
| Biztonság | Jelszavak hashelése, támadások kivédése, kérésszám-korlátozás |
A backend az egyetlen igazságforrás (single source of truth). Ha a frontend és a backend mást állít, mindig a backendé az utolsó szó.
Ez a fejezet gerince — sok kezdő itt hibázik. A böngészőben futó kód teljesen a felhasználó kezében van. Megnyithatja a fejlesztői eszközöket, elolvashatja a JavaScript-forrást, átírhatja a memóriában lévő értékeket, és akár a böngésző megkerülésével is küldhet kérést a szervernek.
Ha az adatbázis jelszava vagy egy fizetési API kulcsa bekerül a frontend kódjába, azt bárki elolvashatja. A titkoknak a szerveren a helyük.
Az űrlap-validáció (required, „az ár legyen pozitív”) kényelmi
funkció, nem védelem. Aki akar, közvetlenül küld kérést a szervernek, űrlap nélkül.
Minden kliensoldali ellenőrzést meg kell ismételni a szerveren. A frontend validáció a felhasználót segíti; a backend validáció az adatokat védi.
Ha az lenne, bárki írhatna SQL-t a te adataidra. A böngésző csak HTTP-kérést küldhet a backendnek, amely aztán ellenőrzött módon fordul az adatbázishoz.
Ha három ember nézi ugyanazt a terméket, mindenkinek ugyanazt a készletet kell látnia. A közös állapot csak egy központi helyen tárolható.
Képzeld el, hogy a webshopban a fizetendő összeget a böngésző számolja ki, és így küldi el:
// A böngészőből érkező kérés törzse — a felhasználó átírta! { "termekId": 42, "darab": 1, "fizetendo": 1 // ← 34 990 Ft helyett 1 Ft }
Ha a backend elhiszi neki, a bolt tönkremegy. A helyes viselkedés: a backend az árat mindig az adatbázisból veszi ki, és az összeget maga számolja ki — a klienstől érkező összeget egyszerűen figyelmen kívül hagyja.
// Nagyjából így fog kinézni a szerveroldali logika (a részleteket később tanuljuk). // A "rendeles" a böngészőből érkezett kérés törzse — vagyis a fenti JSON. const termek = await adatbazisbolLekerdez(rendeles.termekId); // az igazi ár innen jön const fizetendo = termek.ar * rendeles.darab; // a szerver maga számol // A rendeles.fizetendo mezőt MEG SEM NÉZZÜK.
Érkezik egy rendelés a böngészőből. Döntsd el minden mezőről, hogy bemenetként elfogadható-e (persze ellenőrzés után), vagy a szervernek magának kell előállítania. Ha kész vagy, kérd a kiértékelést.
POST /api/orders
{
"termekId": 42, "darab": 2,
"egysegar": 34990, "vegosszeg": 69980,
"felhasznaloId": 7, "kedvezmeny": 0.5
}
| Mező | A te döntésed | Kiértékelés |
|---|
| Architektúra | Lényege | Előny | Hátrány | Mikor? |
|---|---|---|---|---|
| Monolit | Egy alkalmazás, egy kódbázis, minden benne | Egyszerű fejleszteni, indítani, hibát keresni | Nagy méretnél nehezen kezelhető | Kis/közepes projekt, tanulás — mi ezt használjuk |
| Moduláris monolit | Egy alkalmazás, de tiszta modulhatárokkal | Rendezettség monolit-egyszerűséggel | Fegyelem kell hozzá | Növekvő projekt (a Nest.js ezt támogatja) |
| Mikroszolgáltatások | Sok kicsi, önállóan futó szolgáltatás | Külön skálázható, külön csapatok | Bonyolult üzemeltetés, hálózati hibák | Nagy rendszer, nagy csapat |
| Serverless FaaS – Function as a Service | Csak függvényeket írsz, a szolgáltató futtat | Nincs szerver-üzemeltetés, használat alapú díj | Hidegindítás, szolgáltatóhoz kötöttség | Ritka, tüskés terhelés |
| BaaS (pl. Firebase) Backend as a Service | Kész backend-szolgáltatás | Nagyon gyors indulás | Kevés kontroll | Prototípus, kis alkalmazás |
Kezdd monolittal. A mikroszolgáltatás nem „fejlettebb”, hanem más problémára való megoldás. Sok cég a szükségesnél korábban vágott bele, és megbánta.
Ezt a felosztást fogjuk használni a webshopnál:
Miért jó ez? Mert ha az árszámítás hibás, tudod, hol keresd (service). Ha rossz URL-en van a végpont, tudod, hol keresd (router). És a service-t tesztelni tudod anélkül, hogy HTTP-kérést kellene küldened.
| Stílus | Lényeg | Tipikus felhasználás |
|---|---|---|
| REST Representational State Transfer | Erőforrások URL-eken, HTTP-metódusokkal | Általános web-API — ezt tanuljuk |
| GraphQL Graph Query Language | A kliens írja le, pontosan milyen adatot kér | Sokféle kliens, túl sok/kevés adat problémája |
| gRPC Remote Procedure Call | Bináris, gyors, szigorú szerződéssel | Szolgáltatások közti belső kommunikáció |
| WebSocket | Kétirányú, folyamatos kapcsolat | Chat, valós idejű játék, élő értesítés |
| SSE Server-Sent Events | A szerver küld folyamatosan, a kliens hallgat | Élő eredmény, tőzsdei árfolyam |
| Üzenetsor | Nem közvetlen hívás: üzenetek sorban | Háttérfeladatok, rendszerek összekötése |
A következő fejezet teljes egészében a REST-ről szól.
| Modell | Ki állítja elő a HTML-t? | A backend szerepe |
|---|---|---|
| SSR — szerveroldali renderelés Server-Side Rendering | A szerver | Kész HTML-t küld |
| CSR / SPA — böngészőoldali renderelés Client-Side Rendering / Single Page Application | A böngésző JavaScriptje | Csak JSON-adatot ad (API) |
| SSG — statikus generálás Static Site Generation | Előre, buildeléskor | Csak a dinamikus részeknél kell |
Mi a SPA + REST API modellre készülünk: a backend JSON-t szolgáltat, a megjelenítés a frontend dolga. Ennek az az előnye, hogy ugyanazt az API-t használhatja weboldal, mobilalkalmazás és külső partner is.
A Node.js egy futtatókörnyezet, amely lehetővé teszi, hogy JavaScript-kód a böngészőn kívül, közvetlenül az operációs rendszeren fusson.
| Böngészőben van, Node-ban nincs | Node-ban van, böngészőben nincs |
|---|---|
window, document, DOM | process, globalThis |
alert, prompt | fs (fájlrendszer), http, path, os |
localStorage | Környezeti változók (process.) |
A JavaScript nyelv ugyanaz a két helyen. Ami eltér, az a környezet: milyen beépített
objektumok érhetők el. Ezért nem tudsz Node-ban document.-t
használni — nincs weboldal, amin dolgozhatna.
A Node.js egy szálon futtatja a te JavaScript-kódodat, mégis képes egyszerre több ezer felhasználót kiszolgálni. A titok: nem várakozik.
Hasonlat — a pincér:
Ha a te kódod hosszan számol (pl. milliós ciklus, nagy kép átméretezése), az
blokkolja az egy szálat, és közben senki mást nem tud kiszolgálni a szerver.
Ezért a Node.js kiváló I/O-igényes (Input/Output — be- és kimenet: adatbázis,
API-hívás, fájl) feladatokra, és kevésbé jó nyers
CPU-számításra. Az aszinkron kódot (Promise,
async/await) külön fejezetben tanuljuk majd —
most elég, ha a fogalmat érted.
| ✅ Jól illik rá | ❌ Kevésbé illik rá |
|---|---|
| REST API-k, mikroszolgáltatások | Nehéz matematikai/tudományos számítás |
| Valós idejű alkalmazások (chat, értesítés) | Nagy méretű videó- vagy képfeldolgozás |
| Sok párhuzamos, rövid kérés | Hosszan futó, CPU-t terhelő batch-feladat |
| Frontenddel közös nyelv (JavaScript) | Ahol a nyelvi szigorúság elsődleges |
| Platform | Erőssége | Jellemző környezet |
|---|---|---|
| Node.js | Egy nyelv a teljes stackre, hatalmas npm-ökoszisztéma | Startupok, API-k, valós idejű app |
| PHP (Laravel) | Elterjedt webhoszting, gyors CRUD-fejlesztés | Klasszikus weboldalak, CMS |
| Java (Spring) | Stabilitás, szigorú típusok, vállalati eszközök | Bank, biztosító, nagyrendszer |
| Python (Django, FastAPI) | Adattudomány és AI közelsége, olvasható kód | Adatelemzés, gépi tanulás mögötti API |
| C# (.NET) | Erős eszköztár, Microsoft-ökoszisztéma | Vállalati rendszerek |
| Go | Nagy teljesítmény, egyszerű párhuzamosság | Infrastruktúra, nagy terhelésű szolgáltatás |
Nincs „legjobb” backend-nyelv. A választást a feladat, a csapat tudása és a meglévő rendszer határozza meg. Amit itt megtanulsz — HTTP, REST, adatbázis, hitelesítés, rétegezés — minden nyelvben ugyanúgy érvényes.
Fejlesztés közben a saját gépeden fut (localhost:3000). Élesben
(„production”) valahol folyamatosan futnia kell:
| Megoldás | Mit jelent? | Példa |
|---|---|---|
| VPS / dedikált szerver Virtual Private Server | Bérelt gép, mindent te állítasz be | Hetzner, DigitalOcean |
| PaaS Platform as a Service | Feltöltöd a kódot, a többit ők intézik | Render, Railway |
| Konténer | Az alkalmazás „dobozban”, mindenütt egyformán fut | Docker + Kubernetes |
| Serverless | Csak függvények, igény szerint indul | AWS Lambda, Cloudflare Workers |
.env ): a titkok nem a kódban vannak, hanem
a környezetből érkeznek. A .env fájl sosem kerül verziókezelőbe!| Tévhit | Valóság |
|---|---|
| „A Node.js egy programozási nyelv.” | Nem: a nyelv a JavaScript. A Node egy futtatókörnyezet. |
| „A Node.js többszálú, azért gyors.” | A te kódod egy szálon fut; a gyorsaság a nem blokkoló I/O-ból jön. |
| „Ha a frontend validál, a backendnek nem kell.” | A kliensoldali ellenőrzés megkerülhető — a backendé a valódi védelem. |
| „Az API és a backend ugyanaz.” | Az API a backend felülete; a backend ennél több. |
| „A mikroszolgáltatás jobb, mint a monolit.” | Más problémára való. Kis projektnél csak bonyolít. |
„A . fájlban biztonságban vannak a titkok.” | Csak akkor, ha nem tölti fel senki a GitHubra. Ez az egyik leggyakoribb hiba. |
Besorolás. Döntsd el minden feladatról, hogy frontend, backend vagy mindkettő, és indokold egy mondatban!
Útvonal. Írd le saját szavaiddal, mi történik attól a pillanattól, hogy beírod a
https://webshop. címet, addig, amíg megjelenik az oldal!
Legalább 6 lépés legyen.
Támadás. Egy webshopban a frontend így küldi el a rendelést:
{ "termekId": 42, "darab": 2, "egysegar": 100, "vegosszeg": 200 }.
Melyik mezőket nem szabad elhinnie a backendnek, és honnan szerezze meg helyettük az
adatot? Írd le, mit ellenőrizzen a szerver!
Pincér-hasonlat. Magyarázd el egy nem programozó ismerősödnek, miért tud a Node.js egy szálon sok felhasználót kiszolgálni! Találj ki saját hasonlatot a pincér helyett.
Felelősségtérkép. Készíts listát arról, milyen feladatai lennének egy iskolai napló backendjének! Csoportosítsd őket: adattárolás, üzleti logika, hitelesítés, jogosultság, külső szolgáltatás. Legalább 10 elem legyen.
Hálózati fül. Nyiss meg egy tetszőleges weboldalt, majd F12 →
Network. Frissítsd az oldalt, és válaszolj:
API a valóságban. Nyisd meg a böngészőben:
https://jsonplaceholder.
/users/1 és a /posts?userId=1 címeket
is. Mit vettél észre az URL felépítésében?Nyomozás. Válassz egy általad ismert webhelyet vagy alkalmazást. Írj róla fél oldalt: mit gondolsz, mi zajlik a backendjén, amikor bejelentkezel, feltöltesz egy képet, vagy kedvelsz egy bejegyzést?
Nyolc kérdés. Válassz, és azonnal megtudod, jó volt-e — magyarázattal.
| Fogalom | Jelentés |
|---|---|
| Kliens | A kérést küldő program (böngésző, mobilapp, másik szerver) |
| Szerver | A kérést kiszolgáló program vagy gép |
| Backend | A szerveroldali alkalmazás: adat, logika, biztonság |
| Frontend | A felhasználó eszközén futó, megjelenítésért felelős rész |
| API Application Programming Interface | Programozói felület: két program „szerződése” arról, hogyan beszélnek |
| Végpont (endpoint) | Az API egy konkrét elérési pontja (pl. GET /api/products) |
| Port | Számmal azonosított „ajtó”, amelyen egy program a hálózaton hallgatózik |
| localhost | A saját géped (IP: 127.0.0.1) |
| Node.js | JavaScript-futtatókörnyezet a böngészőn kívül, V8 motorral |
| Eseményhurok | A Node.js működési elve: nem várakozik a lassú műveletekre |
| Nem blokkoló I/O | A lassú műveletek a háttérben zajlanak, a szerver közben más kérést szolgál ki |
| Monolit | Egyetlen alkalmazásban megvalósított backend |
| Hitelesítés | „Ki vagy?” (bejelentkezés) |
| Jogosultság | „Mit tehetsz meg?” (szerepkörök, engedélyek) |
| Single source of truth | Az adat egyetlen mérvadó helye — a backend |