> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# A backend-függvények áttekintése

> Egyéni backend logika írása Deno-alapú, szerver nélküli függvényekkel

Ön a fejlesztői dokumentációt nézi

Ez a dokumentáció a Base44 fejlesztői
platformmal dolgozó fejlesztőknek szól. Az alkalmazásszerkesztőben használható backend-függvényekről lásd:&#x20;

[Integrációk használata](https://docs.base44.com/hu/Integrations/Using-integrations.md)

.

A backend-függvényekkel egyéni backend kódot futtathat biztonságos, elkülönített környezetben. Függvényekkel valósíthat meg olyan üzleti logikát, amely nem futhat a böngészőben, csatlakozhat külső API-khoz védett hitelesítő adatokkal, dolgozhat fel webhookokat, vagy bővítheti alkalmazását egyéni végpontokkal.

A backend-függvények a [Denón](https://docs.deno.com/runtime/), egy modern TypeScript-futtatókörnyezeten futnak. A függvényeket a frontendből [az SDK-val](https://docs.base44.com/developers/references/sdk/docs/interfaces/functions.md) hívhatja, amely automatikusan kezeli a hitelesítést. Minden függvény saját HTTP-végpontot is kap webhookokhoz és külső integrációkhoz.

Ha egy függvényt ütemezetten, adatváltozáskor vagy egy csatlakoztatott eszköz eseményére szeretne futtatni, adja hozzá lépésként egy [munkafolyamathoz](https://docs.base44.com/hu/Building-your-app/Creating-workflows.md).

> [!NOTE]
>
> Vegye figyelembe a következőket:
>
> * A függvények egyenkénti telepítésére nem vonatkozik az 50-es korlát. Egyetlen kérés, amely a projekt összes függvényét lecseréli, továbbra is legfeljebb 50 függvényt tartalmazhat. A korlát a kérésben szereplő függvényeket számolja, nem a már telepítetteket.
> * A backend-függvények maximális futási ideje 5 perc, amely ugyanúgy érvényes, akár közvetlenül hívják a függvényt, akár egy automatizálás indítja, akár munkafolyamat-lépésként fut. Az ezt túllépő kérések leállításra kerülnek. További információ a [futtatási korlátokról](#execution-limits).

## Függvények létrehozása

A backend-függvényeket TypeScript-fájlokként hozza létre a projekt functions könyvtárában. Ez alapértelmezés szerint a `base44/functions/` könyvtár, de az útvonalat a [projektkonfigurációban](https://docs.base44.com/hu/developers/backend/overview/project-structure.md#config-jsonc) módosíthatja.

Minden függvény saját alkönyvtárban található egy `entry.ts` vagy `entry.js` fájllal:

**functions**

**\<function-name>**

**entry.ts**

A CLI a functions gyökeréhez viszonyított könyvtárútvonalat használja függvénynévként. A `functions/sendWelcomeEmail/entry.ts` például egy `sendWelcomeEmail` nevű függvényt hoz létre. A rendszerezéshez alkönyvtárakba is ágyazhatja a függvényeket. A `functions/email/send/entry.ts` egy `email/send` nevű függvényt hoz létre.

### Konfigurációs fájl hozzáadása

Haladó igényekhez, például egyéni függvénynevekhez adjon hozzá egy `function.jsonc` fájlt:

**functions**

**\<function-name>**

**entry.ts**

**function.jsonc**

A konfigurációs fájl a függvény nevét és belépési pontját határozza meg:

```jsonc theme={null}
{
  "name": "sendWelcomeEmail",
  "entry": "entry.ts",
}
```

| Tulajdonság | Leírás |
| - | - |
| `name` | Nem kötelező. A függvény egyedi azonosítója. SDK-n vagy HTTP-n keresztüli meghíváskor használatos. Alapértelmezés szerint a functions gyökeréhez viszonyított könyvtárútvonal. |
| `entry` | A függvény kódját tartalmazó fájl. |
| `automations` | Nem kötelező. A függvényhez már hozzárendelt automatizálások. Újakat nem adhat hozzá. Lásd: [Automatizálások](https://docs.base44.com/hu/developers/backend/resources/backend-functions/automations.md). |

### entry.ts

A kódfájl tartalmazza a függvény logikáját. A függvény kezel egy beérkező kérést, és egy `Response` objektumot ad vissza. A kezelőt alapértelmezett exportként exportálja:

```typescript theme={null}
import { createClientFromRequest } from "npm:@base44/sdk";

export default async function (req: Request): Promise<Response> {
  try {
    const base44 = createClientFromRequest(req);
    const user = await base44.auth.me();

    if (!user) {
      return Response.json({ error: "Unauthorized" }, { status: 401 });
    }

    const { name } = await req.json();

    return Response.json({
      message: `Hello, ${name || user.full_name}!`,
    });
  } catch (error) {
    return Response.json({ error: error.message }, { status: 500 });
  }
}
```

### Több fájl egy függvényhez

Egy függvény nem korlátozódik egyetlen `entry.ts` fájlra. A logikát több fájlra bonthatja a függvény könyvtárán belül, és relatív útvonalakkal importálhatja őket. A függvény könyvtárában lévő minden `.js`, `.ts`, `.json` és `.jsonc` fájl a függvénnyel együtt telepítésre kerül.

**functions**

**process-order**

**entry.ts**

**validate.ts**

**types.ts**

```typescript theme={null}
// entry.ts
import { validate } from "./validate.ts";
```

> [!WARNING]
>
> A relatív importok a telepítéskor oldódnak fel. Az olyan import, amely egy
> a függvénnyel együtt nem telepített fájlra mutat, például egy másik függvény
> könyvtárában lévő fájlra, telepítéskor hibát okoz.

### Kód megosztása a függvények között

Ha kódot szeretne több függvényben újrahasználni, helyezze egy `shared` könyvtárba a `base44/` mappán belül.

Egy függvény telepítésekor a CLI vele együtt feltölti a `shared` könyvtárat, a szerver pedig csak azokat a megosztott fájlokat csomagolja be, amelyeket az adott függvény importál. Minden függvény a saját másolatával települ az általa használt megosztott kódból. Ez a következőket jelenti:

* Bármely függvény importálhat a `shared` könyvtárból relatív útvonallal.
* Különböző függvények ugyanannak a megosztott fájlnak különböző verzióit futtathatják. Ha módosít egy megosztott fájlt, és csak egy függvényt telepít, csak annak a függvénynek a másolata frissül. A többiek megtartják a régi verziót, amíg újra nem telepíti őket. Ha egy megosztott módosítást mindenhol érvényesíteni szeretne, futtassa a `base44 functions deploy` parancsot argumentumok nélkül, hogy egyszerre újratelepítse az összes függvényt.

**base44**

**shared**

**response.ts**

**functions**

**greet**

**entry.ts**

**farewell**

**entry.ts**

```typescript theme={null}
// base44/functions/greet/entry.ts
import { ok } from "../../shared/response.ts";

export default async function (req: Request): Promise<Response> {
  const { name } = await req.json();
  return ok({ message: `Hello, ${name}!` });
}
```

> [!WARNING]
>
> A relatív importok elérhetik a `base44/shared/` könyvtárat, de nem léphetnek ki a `base44/` könyvtárból. Ha
> a `base44/` könyvtáron kívüli kódot szeretne használni, helyezze át a `base44/shared/` könyvtárba, vagy importálja
> `npm:` vagy `jsr:` specifikátorral.

## Helyi tesztelés

Futtassa a függvényeket helyben a [`base44 dev`](https://docs.base44.com/developers/references/cli/commands/dev) paranccsal, hogy telepítés nélkül tesztelhesse a módosításokat. A részleteket a [Helyi fejlesztés](https://docs.base44.com/hu/developers/backend/overview/local-dev/local-development-overview.md) oldalon találja.

## Függvények telepítése

A függvényeket a [`functions deploy`](https://docs.base44.com/developers/references/cli/commands/functions-deploy) paranccsal telepítheti, vagy a [`deploy`](https://docs.base44.com/developers/references/cli/commands/deploy) paranccsal egyszerre feltöltheti a projekt összes erőforrását. A `functions deploy <names...>` paranccsal név szerint telepíthet konkrét függvényeket, a `--force` kapcsolóval pedig eltávolíthatja a helyben nem található távoli függvényeket.

A telepített függvények helyi projektbe való letöltéséhez használja a [`functions pull`](https://docs.base44.com/developers/references/cli/commands/functions-pull) parancsot. Hogy mi van jelenleg telepítve, a [`functions list`](https://docs.base44.com/developers/references/cli/commands/functions-list) paranccsal nézheti meg.

## Függvények hívása

A backend-függvényeket a frontendből az SDK-val, webhookokhoz és külső integrációkhoz pedig HTTP-n keresztül hívhatja.

### Az SDK-val

A [`base44.functions.invoke()`](https://docs.base44.com/developers/references/sdk/docs/interfaces/functions) metódussal hívhat függvényeket a frontendből. Az SDK automatikusan kezeli a hitelesítést, és átadja a függvénynek az aktuális felhasználó hitelesítő adatait.

```javascript theme={null}
import { base44 } from "@/api/base44Client";

const response = await base44.functions.invoke("sendWelcomeEmail", {
  name: "Alice",
});
```

### HTTP-n keresztül

Minden telepített függvény HTTP-végpontot kap a következő címen:

```
https://<your-app-domain>/functions/<function-name>
```

Ez a következőkhöz hasznos:

* **Webhookok:** Visszahívások fogadása külső szolgáltatásoktól, például a Stripe-tól vagy a GitHubtól.
* **Külső integrációk:** Más rendszerek kommunikálhatnak az alkalmazással.
* **Tesztelés:** Függvények közvetlen hívása olyan eszközökkel, mint a cURL vagy a Postman.

**Példa a használatra**

```bash theme={null}
curl -X POST https://your-app.base44.app/functions/sendWelcomeEmail \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice"}'
```

> [!NOTE]
>
> Közvetlen HTTP-hívás (például cURL vagy webhookok) esetén nincs
> hitelesített felhasználói kontextus. Ilyenkor minden művelethez
> használja az `asServiceRole` lehetőséget.

### Függvénylánc-korlát

Az egymást hívó függvények lánca legfeljebb hét függvény hosszú lehet, a láncot indító függvényt is beleszámítva. A nyolcadik függvény minden Base44-hívása 403-as hibával, `error code: 1000` kóddal meghiúsul. Ez az entitásokhoz és integrációkhoz intézett hívásokra is vonatkozik, és a láncon belüli újrapróbálkozás ugyanígy meghiúsul. Egy függvény akkor kerül a láncba, ha egy másik függvény a `base44.functions.invoke()` metódussal vagy az URL-jére irányuló `fetch()` hívással meghívja.

A korlát elkerülése:

* A több függvény által igényelt kódot helyezze a [`base44/shared/`](#share-code-between-functions) könyvtárba, és importálja, ahelyett hogy egyik függvényt a másikból hívná.
* Bontson egy hosszú feladatot külön lépésekre. Minden lépés mentse a haladását és térjen vissza, majd a következő lépést a frontendből vagy egy ütemezett [munkafolyamatból](https://docs.base44.com/hu/Building-your-app/Creating-workflows.md) indítsa, ne az előző lépésből.

## Futtatási korlátok

Egy backend-függvény minden hívása a következő korlátokon belül fut. Ezek ugyanúgy érvényesek, akár közvetlenül hívják a függvényt, akár egy automatizálás indítja, akár munkafolyamat-lépésként fut.

| Korlát | Érték | Ha egy hívás túllépi |
| - | - | - |
| Futási idő | 5 perc | A Base44 abbahagyja a várakozást, és 504-es hibát ad vissza `Timeout` törzzsel. |
| CPU-idő | 5 perc | A hívás 429-es hibával, `cpu-exceeded` kóddal meghiúsul. |
| Kimenő kérések | 10 000 hívásonként | A hívás 429-es hibával, `subrequests-exceeded` kóddal meghiúsul. Minden `fetch()` beleszámít, az SDK által a Base44-nek küldött hívásokat is beleértve. |
| Memória | 128 MB | A függvény leáll, és a naplóiban a `Worker exceeded memory limit.` üzenet jelenik meg. |

Ha egy feladat túllépheti az 5 percet, bontsa lépésekre. Minden lépés mentse a haladását és térjen vissza. Ezután a következő lépést a frontendből vagy egy ütemezett [automatizálásból](https://docs.base44.com/hu/developers/backend/resources/backend-functions/automations.md) indítsa.

## Az SDK használata a függvényekben

A backend-függvényekben a Base44 SDK-n keresztül érheti el az alkalmazás adatait, hitelesítését és integrációit. A [`createClientFromRequest()`](https://docs.base44.com/developers/references/sdk/docs/functions/createClientFromRequest) segítségével hozzon létre klienst a beérkező kérésből.

A hitelesítési kontextus attól függ, hogyan hívták a függvényt:

* **Ha a frontendből az SDK-val hívták:** A felhasználó hitelesítése automatikusan továbbítódik. Az aktuális felhasználót a `base44.auth.me()` metódussal érheti el, és az ő jogosultságaival végezhet műveleteket. Ha az entitás-hozzáférési szabályok alkalmazása nélkül szeretne adatokat olvasni vagy írni, használja az [`asServiceRole`](https://docs.base44.com/developers/references/sdk/docs/functions/createClientFromRequest#param-as-service-role) lehetőséget.

* **Ha közvetlen HTTP-n keresztül hívták (cURL, webhookok, külső szolgáltatások):** Nincs hitelesített felhasználó, ezért minden művelethez az `asServiceRole` lehetőséget használja.

## Futtatókörnyezeti API

A Base44 beépített `base44:runtime` modult biztosít platformszintű segédeszközökkel a függvényekhez. Közvetlenül importálhatja, telepítés nélkül:

```typescript theme={null}
import { waitUntil, secrets } from "base44:runtime";
```

A modul két segédeszközt exportál:

* `waitUntil()`: életben tartja a függvényt, hogy a válasz visszaadása után befejezhesse a háttérmunkát.
* `secrets`: az alkalmazás titkos adatainak olvasása futásidőben a `secrets.get()` metódussal.

### Háttérmunka futtatása a válasz után

A `waitUntil()` segítségével életben tarthatja a függvényt a háttérmunkához a válasz visszaadása után. Adjon át neki egy promise-t, és a függvény addig fut, amíg az a promise le nem zárul. Így gyorsan válaszolhat, és utána fejezheti be az olyan munkákat, mint a naplózás, az értesítések vagy a kimenő webhookok.

```typescript theme={null}
import { waitUntil } from "base44:runtime";

export default async function (req: Request): Promise<Response> {
  waitUntil(fetch("https://hooks.example.com/ping", { method: "POST" }));

  return Response.json({ status: "accepted" });
}
```

A `waitUntil()` ugyanazt a promise-t adja vissza, amelyet átad neki, így később ugyanabban a kezelőben összefűzheti vagy megvárhatja.

> [!NOTE]
>
> A háttérmunka a lehetőségekhez mérten fut. Nem garantált, hogy befejeződik vagy újrapróbálkozik, ezért
> ne támaszkodjon rá olyan kritikus műveleteknél, amelyek nem veszhetnek el.

### Titkos adatok olvasása

A `secrets.get()` metódussal futásidőben olvashatja az alkalmazás környezeti változóit. Az értéket szövegként adja vissza, vagy `undefined` értéket, ha a titkos adat nincs beállítva:

```typescript theme={null}
import { secrets } from "base44:runtime";

export default async function (req: Request): Promise<Response> {
  const apiKey = secrets.get("API_KEY");

  const res = await fetch("https://api.example.com/data", {
    headers: { Authorization: `Bearer ${apiKey}` },
  });

  return Response.json(await res.json());
}
```

A `secrets.get()` metódust a kezelőn belül hívja, ne a modul legfelső szintjén. A titkos adatok kérésenként oldódnak fel, így a modul betöltésekor, bármely kérés futása előtt végzett olvasás `undefined` értéket ad vissza.

A titkos adatokat a CLI-ből a [`secrets set`](https://docs.base44.com/developers/references/cli/commands/secrets-set) paranccsal konfigurálhatja.

## Csatlakozás külső API-khoz

A backend-függvények a [külső API-khoz való csatlakozás](https://docs.base44.com/developers/references/sdk/getting-started/third-party-apis.md) egyik módját jelentik. Ideálisak, ha teljes irányításra van szüksége a kérések felett, vagy az API-kulcsokat környezeti változóként szeretné biztonságosan tárolni. A környezeti változókat a CLI-ből a [`secrets set`](https://docs.base44.com/developers/references/cli/commands/secrets-set) paranccsal konfigurálhatja.

## Naplók megtekintése

[Helyi fejlesztés](https://docs.base44.com/hu/developers/backend/overview/local-dev/local-development-overview.md) közben a függvények kimenete közvetlenül a terminálban jelenik meg, a `logs` parancs nélkül.

A telepített függvények naplóit a [`logs`](https://docs.base44.com/developers/references/cli/commands/logs) paranccsal tekintheti meg. A naplók tartalmazzák a konzolkimenetet, a hibákat és az időzítési adatokat. Szűrhet függvénynév vagy időtartomány szerint. Ha MI-kódolóügynököt használ, a [base44-troubleshooter](https://docs.base44.com/hu/developers/backend/overview/skills.md#base44-troubleshooter) skill automatikusan lekérheti és elemezheti ezeket a naplókat.

## TypeScript-típusok

Generáljon TypeScript-típusokat a függvénykonfigurációkból, hogy típusbiztonságot és automatikus kiegészítést kapjon a függvénynevekhez az SDK-kódban. További információ a [dinamikus típusokról](https://docs.base44.com/developers/references/sdk/getting-started/dynamic-types.md).

## Lásd még

* [Munkafolyamatok létrehozása](https://docs.base44.com/hu/Building-your-app/Creating-workflows.md): Függvények futtatása ütemezetten, vagy adat- vagy eszközváltozáskor
* [`functions` modul](https://docs.base44.com/developers/references/sdk/docs/interfaces/functions): SDK-referencia a függvények meghívásához
* [`createClientFromRequest`](https://docs.base44.com/developers/references/sdk/docs/functions/createClientFromRequest): Kliens létrehozása backend-függvényekben
* [`functions deploy`](https://docs.base44.com/developers/references/cli/commands/functions-deploy): Helyi függvények telepítése a Base44-re
* [`functions pull`](https://docs.base44.com/developers/references/cli/commands/functions-pull): Telepített függvények letöltése a helyi projektbe
* [`functions list`](https://docs.base44.com/developers/references/cli/commands/functions-list): Az összes telepített függvény listázása
* [`functions delete`](https://docs.base44.com/developers/references/cli/commands/functions-delete): Telepített függvények törlése
* [`logs`](https://docs.base44.com/developers/references/cli/commands/logs): Függvénynaplók megtekintése
* [`exec`](https://docs.base44.com/developers/references/cli/commands/exec): Függvények elkülönített tesztelése önálló szkriptekből

> [!NOTE]
>
> Ezt az oldalt MI segítségével fordítottuk. A legpontosabb és legfrissebb információkért tekintse meg az [angol nyelvű változatot](https://docs.base44.com/index.md).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.