Firebase Cloud Functions — mi ez, triggerek és hogyan írjunk függvényeket

Mi a Firebase Cloud Functions és hogyan épül fel

A Firebase Cloud Functions egy számítási platform, amely a Google Cloud Functions (GCF) alapjaira épül, és a Firebase-ökoszisztémához lett igazítva. A függvények hétköznapi JavaScript- vagy TypeScript-kódot jelentenek, amelyet modulból exportálnak és egy adott eseménytípusra regisztrálnak. Amikor az esemény bekövetkezik (például a felhasználó regisztrál vagy fájlt tölt fel), a Firebase Cloud Functions elindítja a megfelelő kódot, átadva neki az esemény kontextusát.

A Cloud Functions architektúrája a felelősség egységének elvét követi: egy függvény egy eseménytípust dolgoz fel és egy atomi műveletet hajt végre. Például a sendWelcomeEmail függvényt új felhasználó létrehozásakor hívják meg a Firebase Authentication szolgáltatásban, és üdvözlőlevelet küld. Az ilyen izoláció leegyszerűsíti a hibakeresést, a tesztelést és a függvények újrafelhasználását különböző projektekben.

Minden függvény izolált konténerben fut, ideiglenes életciklussal. A maximális futási idő alapértelmezés szerint 60 másodperc (HTTPS-függvények — 9 perc). Ha a függvény nem fér bele az időkorlátba, a kérés 500-as hibával zárul. Hosszú műveletekhez használja a Cloud Tasks vagy a Pub/Sub szolgáltatást ismételt próbálkozásokkal. A konténerek a későbbi hívásokhoz újra felhasználhatók (keep-alive), ami csökkenti az első hívás utáni hidegindítások késleltetését.

Futási környezet és Node.js-verziók

A Firebase Cloud Functions több Node.js-verziót támogat: 18, 20 és 22 (új projektekhez ajánlott). A verzió kiválasztását a package.json fájl engines mezőjében állítják be. A Firebase CLI automatikusan konfigurálja a futási környezetet a megadott verzió alapján. Fontos: a Firebase Cloud Functions nem támogatja tetszőleges Docker-konténerek futtatását — a környezetet szigorúan a Google Cloud Functions határozza meg.

Új projektekhez a Node.js 22 ajánlott, mivel tartalmazza a legújabb V8-optimalizációkat, a továbbfejlesztett ESM-modulokkal való munkát és a WebSocket-támogatást platformszinten. Ha a projekt egy adott Node-verzióhoz fordított függőségeket használ (például natív C++-modulokat), a kompatibilitást külön kell ellenőrizni — nem minden natív modul fordul le a GCF-környezetben.

Különbség a Firebase Cloud Functions és a Google Cloud Functions között

A Firebase Cloud Functions egy burkolóréteg a Google Cloud Functions körül, előre telepített Firebase SDK-val és Firebase-szolgáltatásokkal való integrációval. A fejlesztő a firebase-functions SDK-t használva ír kódot, amely típusos triggereket biztosít az összes Firebase-szolgáltatáshoz. A Google Cloud Functions egy alacsonyabb szintű platform, ahol a triggereket kifejezetten az Eventarc vagy a Pub/Sub segítségével konfigurálják.

A kulcsfontosságú különbség: a Firebase Cloud Functions-ban a triggert deklaratívan regisztrálják a functions.firestore.document('path').onWrite() hívással, a Google Cloud Functions-ban pedig — az Eventarc-konfigurációval, eseményattribútumokra szűrve. A Firebase Cloud Functions emellett automatikusan tartalmazza az Admin SDK-t, amely a projekt szolgáltatásfiókjának jogosultságaival van inicializálva, így teljes hozzáférést biztosít az összes Firebase-szolgáltatáshoz további konfiguráció nélkül.

Triggertípusok: mely események támogatottak

A Firebase Cloud Functions 8 triggertípust támogat, amelyek mindegyike egy adott Firebase- vagy Google Cloud-szolgáltatásnak felel meg. A trigger egy olyan feltétel, amelynek bekövetkezésekor a függvény automatikusan meghívásra kerül. A fejlesztő nem közvetlenül kezeli a függvény életciklusát: a Firebase CLI regisztrálja a triggert a Google Cloud Eventarc-ban, és a felhőplatform maga indítja el a függvényt az esemény bekövetkezésekor.

A legnépszerűbb triggerek — Firestore-triggerek: onWrite, onCreate, onUpdate, onDelete. A Firestore-gyűjtemények dokumentumainak módosulásakor aktiválódnak. A függvény a dokumentum pillanatképeit kapja a módosítás előtt és után, ami lehetővé teszi az értékek összehasonlítását és csak meghatározott módosulásokra való reagálást. Például a rendelés állapotának „pending”-ről „shipped”-re való változásakor push-értesítést küldhet a felhasználónak.

A Authentication-triggerek (onCreate, onDelete) a fiók létrehozásakor vagy törlésekor aktiválódnak. A felhasználói adatok inicializálására használják őket: felhasználói dokumentum létrehozása a Firestore-ban, üdvözlő e-mail küldése, adatok írása az analitikába. Fontos: a függvény nem tudja visszavonni a felhasználó létrehozását — azután fut, hogy a fiók már létrejött. Az előzetes ellenőrzéshez használjon blokkoló függvényeket (Blocking Functions), amelyek az Identity Platform platformon érhetők el.

HTTPS-triggerek és CORS

A HTTPS-függvények (onRequest) lehetővé teszik teljes értékű, HTTP-n keresztül elérhető REST API-végpontok létrehozását. Az eseménytriggerekkel ellentétben a HTTPS-függvényeket https://{region}-{project}.cloudfunctions.net/{functionName} formátumú URL-en keresztül hívják meg. Fontos a CORS helyes konfigurálása, ha a végpontot böngészőből vagy mobilalkalmazásból hívják. A Firebase SDK nem ad hozzá automatikusan CORS-fejléceket — azokat manuálisan, middleware segítségével kell hozzáadni.

Mobilkliensek (Android, iOS) esetén CORS nem szükséges, mivel a natív HTTP-klienseket nem korlátozza a Cross-Origin-házirend. A CORS csak webes kéréseknél releváns. Ha a HTTPS-függvényt alkalmazásból és webből is hívják, adjon hozzá univerzális CORS-kezelést: res.set('Access-Control-Allow-Origin', '*') development esetén, vagy az engedélyezett domainek listáját production esetén.

Ütemezés a Pub/Sub és a Cloud Scheduler segítségével

Időszakos futtatáshoz (cron-feladatok) használja a Cloud Scheduler és a Pub/Sub kombinációját. A Cloud Scheduler ütemezés szerint üzenetet küld a Pub/Sub-témába, a onPublish trigger pedig feldolgozza ezt az üzenetet. A Firebase CLI nem támogatja a közvetlen cron-szintaxist — az ütemezést a Google Cloud-konzolon vagy a Terraformmal állítják be unix-cron formátumban: 0 3 * * * (minden nap 3:00-kor).

Példafeladatok: napi hírlevél, elavult adatok tisztítása, jelentések generálása, külső API-kkal való szinkronizálás. Fontos: a Cloud Scheduler fizetős Google Cloud-szolgáltatás (körülbelül 2 $ havonta egy job-ért). Minden aktiválás külön függvényhívásnak számít, és a Cloud Functions szabványos árai szerint számlázzák.

Hogyan írjunk és telepítsünk függvényeket

A Cloud Functions fejlesztése a projekt inicializálásával kezdődik a Firebase CLI-n keresztül: firebase init functions. Ez a parancs létrehozza a functions/ könyvtárat az index.js (vagy index.ts) sablonnal, a package.json fájllal és a TypeScript-konfigurációval (ha ki van választva). Az inicializálás után elég megírni egy függvényt, exportálni a modulból, és a telepítéshez futtatni a firebase deploy --only functions parancsot.

Minden függvényt a megfelelő trigger metódusának meghívásával regisztrálnak. HTTPS-függvény példa: exports.helloWorld = functions.https.onRequest((req, res) => { res.send("Hello!"); }). A Firebase-függvények aszinkron modellt használnak: az eseménytriggerek (nem HTTPS) esetén a függvénynek Promise-t kell visszaadnia. A Firebase a konténer bezárása előtt megvárja a Promise befejezését. Ha a Promise nem kerül visszaadásra, a függvény megszakadhat az aszinkron műveletek befejezése előtt.

A helyi fejlesztés a Firebase Emulator Suite segítségével történik, amely tartalmazza a Cloud Functions-emulátort. A firebase emulators:start parancs egy helyi szervert indít a függvényekkel, amely a http://localhost:5001 címen érhető el. Az emulátor támogatja a kódváltozás utáni hot reloadot, és teljesen izolált a production-környezettől, így a függvények tesztelhetők a valós adatok befolyásolásának kockázata nélkül.

Függőségek és konfiguráció kezelése

A Cloud Functions függőségeit a package.json fájlon keresztül kezelik. A Firebase csak production-függőségeket telepít (dependencies, nem devDependencies). A függvénycsomag mérete befolyásolja a hidegindítási időt: ajánlott minimalizálni a függőségek számát. A Firebase Admin SDK-val való munkához a firebase-admin függőség már előre telepítve van — nem kell manuálisan hozzáadni.

Bizalmas adatok (API-kulcsok, tokenek) nem tárolhatók a függvény kódjában. Használja a functions.config() parancsot a konfiguráció tárolásához: firebase functions:config:set stripe.key="sk_...". Az értékek titkosítva vannak, és futásidőben a functions.config().stripe.key segítségével érhetők el. Nagy mennyiségű szerializált konfigurációhoz használja a Google Cloud Secret Manager szolgáltatást.

Hibakezelés és naplózás

A Cloud Functions naplózása a console.log, console.warn és console.error parancsokon keresztül történik. Minden napló automatikusan a Google Cloud Logging szolgáltatásba kerül, és a Firebase-konzolon érhető el (Functions > Logs szakasz). Strukturált naplózáshoz használja a winston vagy a pino könyvtárat, amelyek támogatják a JSON-formázást és a naplózási szinteket.

A hibakezelés kritikus fontosságú a megbízhatóság szempontjából: a Promise-ban kezeletlen kivétel hibával zárja a függvényt, majd a Firebase automatikusan, exponenciális késleltetéssel megismétli a hívást (retry). A retry-k száma konfigurálható: 0-tól végtelenig. Eseménytriggereknél ajánlott bekapcsolni a retry-t, hogy minden esemény feldolgozása garantált legyen akkor is, ha a külső szolgáltatások átmenetileg meghibásodnak.

Hidegindítás és méretezés

A hidegindítás (cold start) az első függvényhívás késleltetése az inaktivitás időszaka után, amikor a kódot tartalmazó konténert újratöltik és újra inicializálják. A Firebase documentation (2026) adatai szerint a hidegindítás 200 ms-tól 2 másodpercig tart, a csomag méretétől, a függőségek számától és a régiótól függően. A felhasználói felület számára az 1 másodpercnél hosszabb késleltetés észrevehető, és befolyásolhatja a user experience-et.

A hidegindítás minimalizálásának módjai: a függőségek minimalizálása, TypeScript használata CommonJS-be való fordításával, a függvénycsomag méretének csökkentése, az aktív példányok minimális számának beállítása. A Firebase Cloud Functions v2 (2nd gen) lehetővé teszi a minInstances beállítását — a felmelegített konténerek minimális számát, amelyek mindig készen állnak a kérések feldolgozására. A konténerek felmelegítéséért az állásidőre díjat számítanak fel.

A Cloud Functions méretezése automatikusan történik: a kérések számának növekedésével a Firebase új konténereket hoz létre. Alapértelmezés szerint a párhuzamos példányok maximális száma 3000 (a Google Cloud-projekt kvótája). Minden példány egyszerre egy kérést dolgoz fel. Ha a függvény gyors (kevesebb mint 100 ms), egy példány akár 10 kérést is feldolgozhat másodpercenként, ami akár 30 000 kérést jelent másodpercenként projektenként.

A minInstances és maxInstances beállítása

A minInstances egy olyan paraméter, amely lefoglalja a megadott számú konténert, és felmelegítve tartja őket. Kritikus HTTPS-függvényekhez ajánlott, ahol a hidegindítási késleltetés elfogadhatatlan. Például egy hitelesítési végponthoz állítsa be a minInstances: 1 értéket. A maxInstances a párhuzamos példányok maximális számának korlátja, amely a költségek ellenőrizetlen növekedésének megakadályozására hasznos a forgalom hirtelen megugrásakor.

A beállítás a kódban történik: functions.runWith({ minInstances: 1, maxInstances: 10 }). Fontos: a minInstances növeli a költségeket, mivel a konténer folyamatosan működik. Tesztprojekteknél a minInstances-t ki kell kapcsolni. Production esetén a minInstances az összes nyilvános HTTPS-függvényhez ajánlott, és 0 az eseménytriggerekhez, ahol az 1 másodperces késleltetés nem kritikus.

Telepítési régiók

A telepítési régió befolyásolja a végfelhasználókhoz vezető késleltetést és a kimenő forgalom költségét. A Firebase Cloud Functions több mint 30 Google Cloud-régióban érhető el. Mobilalkalmazásokhoz a célközönséghez legközelebbi régiót válassza: us-central1 Amerikához, europe-west1 Európához, asia-east2 Ázsiához. A régió a telepítés után a függvény újratelepítése nélkül nem módosítható.

A régióváltás a region paraméteren keresztül történik a kódban: functions.region('europe-west1'). Egy fájl összes függvénye eltérő régióval rendelkezhet. Globális projektekhez ajánlott a függvényeket több régióban telepíteni, és a Cloud Load Balancing szolgáltatást használni a forgalom elosztására, bár a legtöbb mobilalkalmazásnál egy régió is elegendő, ha helyesen választják ki.

Kódpéldák a Firebase Cloud Functions-hoz

Nézzük meg a Cloud Functions gyakorlati példáit TypeScript-ben. A kód a Firebase Functions SDK v2 (2nd gen) szolgáltatást használja moduláris ES-szintaxissal. A példák tartalmazzák a felhasználó létrehozásának eseményét, a thumbnail generálását képfeltöltéskor és egy egyszerű HTTPS-végpontot a REST API-hoz. Minden függvény aszinkron, és a konténer helyes befejezéséhez Promise-t ad vissza.

Futtatás előtt győződjön meg róla, hogy a Firebase CLI a 13+ verzióra frissült: npm install -g firebase-tools. A v2-függvények a Blaze tarifacsomagot igénylik. Inicializálás: firebase init functions a TypeScript kiválasztásával.

A felhasználói regisztráció feldolgozása

Az első példa — dokumentum létrehozása a Firestore-ban új felhasználó regisztrációjakor. A függvényt az auth.user().onCreate esemény indítja el, és alapprofilt ír a users/{uid} gyűjteménybe. Ez lehetővé teszi annak garantálását, hogy minden regisztrált felhasználóhoz létezik a szükséges mezőket tartalmazó dokumentum.

import * as functions from "firebase-functions"
import * as admin from "firebase-admin"

admin.initializeApp()

export const createUserProfile = functions.auth
    .user()
    .onCreate(async (user) => {
        const profile = {
            email: user.email,
            displayName: user.displayName ?? "User",
            createdAt: admin.firestore.Timestamp.now(),
            role: "free",
            avatarUrl: null,
        }

        await admin.firestore()
            .collection("users")
            .doc(user.uid)
            .set(profile)

        console.log(`Profile created for ${user.uid}`)
    })

A createUserProfile függvény aszinkron — Promise-t ad vissza, amelyet a Firebase a befejezés előtt megvár. Ha a Firestore-ba való írás hibával zárul (például jogosultság hiánya miatt), a függvény automatikusan megismétlődik (ha a retry be van kapcsolva). A "free" értékű role mező lehetővé teszi az ingyenes csomag korlátainak közvetlen megvalósítását a Firestore Security Rules-ban, a resource.data.role összehasonlításával a szükséges hozzáférési szinttel.

Thumbnail generálása képfeltöltéskor

A második példa — Storage-trigger a miniatűr (thumbnail) automatikus generálásához a kép feltöltése után. A függvény 200x200 képpontos, kicsinyített másolatot hoz létre, és a forrásfájl elérési útjára menti a thumb_ előtaggal. A képek feldolgozásához a sharp könyvtárat használják, amely minden elterjedt formátumot támogat, és rendszerfüggőségek nélkül működik a Node.js-környezetben.

import * as path from "path"
import * as os from "os"
import * as sharp from "sharp"

export const generateThumbnail = functions.storage
    .object()
    .onFinalize(async (object) => {
        if (!object.contentType?.startsWith("image/")) return

        const filePath = object.name!
        const thumbPath = filePath.replace(
            /(\.\w+)$/, "_thumb$1"
        )

        const bucket = admin.storage().bucket()
        const tempDir = os.tmpdir()
        const tempFile = path.join(tempDir, path.basename(filePath))

        await bucket.file(filePath).download({ destination: tempFile })
        await sharp(tempFile)
            .resize(200, 200, { fit: "cover" })
            .toFile(tempFile.replace(/(\.\w+)$/, "_thumb$1"))

        await bucket.upload(tempFile.replace(
            /(\.\w+)$/, "_thumb$1"
        ), { destination: thumbPath })
    })

A generateThumbnail függvény ellenőrzi az objektum Content-Type-jét, és figyelmen kívül hagyja a nem képeket, ami erőforrásokat takarít meg. A sharp használatához a függőséget hozzá kell adni a package.json fájlhoz. A thumbnail a fit: "cover" paraméterrel jön létre, amely a képet középen 200x200 képpontos négyzetre vágja. A létrehozás után a thumbnailt módosított névvel töltik vissza ugyanabba a bucketbe.

HTTPS-végpont nyilvános API-hoz

A harmadik példa — HTTPS-függvény, amely a szerver állapotának ellenőrzésére szolgáló REST API-végpontot valósít meg. A függvény GET-kérést fogad, és JSON-t ad vissza a projekthez csatlakoztatott Firebase-szolgáltatások állapotáról. A végpont hasznos a monitorozáshoz és azoknak a külső rendszereknek, amelyeknek az adatküldés előtt ellenőrizniük kell a backend elérhetőségét.

import * as express from "express"

const app = express.Router()

app.get("/status", async (req, res) => {
    try {
        const db = admin.firestore()
        await db.collection("_health").doc("check").get()
        res.json({ status: "ok", timestamp: Date.now() })
    } catch (error) {
        res.status(503).json({ status: "error", message: error })
    }
})

export const api = functions.https.onRequest(app)

A api függvény express Router-t használ az útválasztáshoz, ami kényelmes több végpont létrehozásakor egy függvényben. A health check a Firestore-ba, a _health gyűjteménybe kerül, ami lehetővé teszi a Firestore elérhetőségének egyidejű ellenőrzését. Production esetén ajánlott a kérés hitelesítését API-kulccsal vagy Firebase Auth-tokennal hozzáadni, hogy megakadályozzák a nyilvános végpont visszaéléseit.

Tipikus felhasználási forgatókönyvek mobilalkalmazásokban

A Cloud Functions-t leggyakrabban olyan feladatokra használják, amelyeket a kliensen nem lehet vagy nem érdemes elvégezni: push-értesítések küldése, feltöltött képek előnézetének generálása, külső fizetési rendszerekkel való integráció, tartalommoderálás, adatok szinkronizálása a Firebase és harmadik fél szolgáltatásai között. A szerver nélküli modell gazdaságossá teszi ezeket a feladatokat: a díjat csak a kód tényleges futási idejéért számítják fel.

A fizetési rendszerekkel való integráció tipikus forgatókönyv az in-app vásárlásokat tartalmazó alkalmazásoknál. A Cloud Functions webhookot kap a fizetési szolgáltatótól (Stripe, PayPal), ellenőrzi a kérés aláírását, frissíti az előfizetés állapotát a Firestore-ban, és visszaigazolást küld a felhasználónak. A teljes kód a szerveren fut, a kliensen történő adatcsere kockázata nélkül. A Stripe documentation (2026) adatai szerint a webhook feldolgozása kevesebb mint 500 ms-ig tart.

A kifinomult tartalommoderálás a Cloud Functions Storage-triggerét használja a feltöltött képek automatikus ellenőrzésére a Google Cloud Vision API segítségével. A függvény a képet a Vision API-ba küldi a nem biztonságos tartalom (erőszak, felnőtt tartalom) észlelésére, és ha a küszöbérték meghaladja, törli a fájlt, és értesíti a rendszergazdát. Ez a forgatókönyv kritikus a felhasználói galériákkal rendelkező UGC-alkalmazásoknál.

A dátum-aggregáció — a Cloud Functions a Firebase Realtime Database számlálóinak helyettesítője. A számláló kliensen történő olvasása és írása helyett (ami race conditions-hoz vezet) használja a Firestore onWrite triggerét az összesített mezők atomi frissítéséhez. Például a függvény minden egyes dokumentum hozzáadásakor vagy törlésekor kiszámolja a bejegyzés lájkjainak számát a /posts/{postId}/likes/{userId} alkollekcióban, és frissíti a likesCount mezőt a szülő dokumentumban.