> ## 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.

# Übersicht Backend-Funktionen

> Schreibe eigene Backend-Logik mit Deno-basierten Serverless-Funktionen

<div className="dev-docs-banner">
  <div className="dev-docs-banner-content">
    <div className="dev-docs-banner-title">
      Du siehst gerade die Entwicklerdokumentation
    </div>

    <div className="dev-docs-banner-text">
      Diese Dokumentation richtet sich an Entwickler, die mit der Base44-Entwicklerplattform arbeiten. Informationen zu Backend-Funktionen im App-Editor findest du unter{" "}

      <a href="/Integrations/Using-integrations#activating-backend-functions">
        Integrationen verwenden
      </a>

      .
    </div>
  </div>
</div>

Backend-Funktionen ermöglichen es dir, eigenen Backend-Code in einer sicheren, isolierten Umgebung auszuführen. Verwende Funktionen, um Geschäftslogik zu implementieren, die nicht im Browser laufen sollte, dich mit Drittanbieter-APIs mit geschützten Anmeldedaten zu verbinden, Webhooks zu verarbeiten oder deine App mit eigenen Endpunkten zu erweitern.

Backend-Funktionen laufen auf [Deno](https://docs.deno.com/runtime/), einer modernen TypeScript-Laufzeit. Rufe Funktionen aus deinem Frontend [über das SDK](/developers/references/sdk/docs/interfaces/functions) auf, das die Authentifizierung automatisch übernimmt. Jede Funktion erhält außerdem ihren eigenen HTTP-Endpunkt für Webhooks und externe Integrationen.

Funktionen können auch automatisch über [Automationen](/developers/backend/resources/backend-functions/automations) laufen. Plane Funktionen für bestimmte Zeitpunkte oder löse sie als Reaktion auf Datenbankereignisse aus, etwa beim Erstellen, Aktualisieren oder Löschen von Datensätzen.

<Note>Jedes Projekt unterstützt maximal 50 Backend-Funktionen.</Note>

## Funktionen erstellen

Erstelle Backend-Funktionen als TypeScript-Dateien im Funktionsverzeichnis deines Projekts. Standardmäßig ist das Funktionsverzeichnis `base44/functions/`, aber du kannst den Pfad in deiner [Projektkonfiguration](/developers/backend/overview/project-structure#config-jsonc) anpassen.

Jede Funktion lebt in ihrem eigenen Unterverzeichnis mit einer `entry.ts`- oder `entry.js`-Datei:

<Tree>
  <Tree.Folder name="functions" defaultOpen>
    <Tree.Folder name="<function-name>" defaultOpen>
      <Tree.File name="entry.ts" />
    </Tree.Folder>
  </Tree.Folder>
</Tree>

Die CLI verwendet den Verzeichnispfad relativ zum Funktions-Stammverzeichnis als Funktionsnamen. Zum Beispiel erstellt `functions/sendWelcomeEmail/entry.ts` eine Funktion namens `sendWelcomeEmail`. Du kannst Funktionen auch zur Organisation in Unterverzeichnissen verschachteln. `functions/email/send/entry.ts` erstellt eine Funktion namens `email/send`.

### Eine Konfigurationsdatei hinzufügen

Für erweiterte Anforderungen wie eigene Funktionsnamen oder [Automationen](/developers/backend/resources/backend-functions/automations) füge eine `function.jsonc`-Datei hinzu:

<Tree>
  <Tree.Folder name="functions" defaultOpen>
    <Tree.Folder name="<function-name>" defaultOpen>
      <Tree.File name="entry.ts" />

      <Tree.File name="function.jsonc" />
    </Tree.Folder>
  </Tree.Folder>
</Tree>

Die Konfigurationsdatei definiert den Namen der Funktion und ihren Einstiegspunkt:

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

| Eigenschaft   | Beschreibung                                                                                                                                                                                                                              |
| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name`        | Optional. Eindeutige Kennung für die Funktion. Wird beim Aufruf über SDK oder HTTP verwendet. Standardwert ist der Verzeichnispfad relativ zum Funktions-Stammverzeichnis.                                                                |
| `entry`       | Die Datei mit dem Funktionscode.                                                                                                                                                                                                          |
| `automations` | Optional. Array von Automationskonfigurationen, um die Funktion nach einem Zeitplan oder als Reaktion auf Datenbankereignisse auszuführen. Siehe [Automationen](/developers/backend/resources/backend-functions/automations) für Details. |

### entry.ts

Die Code-Datei enthält deine Funktionslogik. Funktionen müssen den `Deno.serve()`-Wrapper verwenden und `Response`-Objekte zurückgeben:

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

Deno.serve(async (req) => {
  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 });
  }
});
```

## Lokal testen

Führe deine Funktionen mit [`base44 dev`](/developers/references/cli/commands/dev) lokal aus, um Änderungen ohne Deployment zu testen. Details unter [Lokale Entwicklung](/developers/backend/overview/local-dev/local-development-overview).

## Funktionen deployen

Deploye Funktionen mit [`functions deploy`](/developers/references/cli/commands/functions-deploy) oder [`deploy`](/developers/references/cli/commands/deploy), um alle Projektressourcen auf einmal zu pushen. Du kannst bestimmte Funktionen nach Namen mit `functions deploy <names...>` deployen oder `--force` verwenden, um Remote-Funktionen zu entfernen, die lokal nicht vorhanden sind.

Um deployed Funktionen in dein lokales Projekt herunterzuladen, verwende [`functions pull`](/developers/references/cli/commands/functions-pull). Um zu sehen, was aktuell deployed ist, verwende [`functions list`](/developers/references/cli/commands/functions-list).

## Funktionen aufrufen

Rufe Backend-Funktionen aus deinem Frontend über das SDK auf oder über HTTP für Webhooks und externe Integrationen.

### Über das SDK

Verwende [`base44.functions.invoke()`](/developers/references/sdk/docs/interfaces/functions), um Funktionen aus deinem Frontend aufzurufen. Das SDK übernimmt die Authentifizierung automatisch und übergibt die Anmeldedaten des aktuellen Benutzers an deine Funktion.

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

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

### Über HTTP

Jede deployed Funktion erhält einen HTTP-Endpunkt unter:

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

Das ist nützlich für:

* **Webhooks:** Empfang von Callbacks von externen Diensten wie Stripe oder GitHub.
* **Externe Integrationen:** Anderen Systemen die Interaktion mit deiner App ermöglichen.
* **Testen:** Funktionen direkt mit Tools wie cURL oder Postman aufrufen.

**Beispielverwendung**

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

<Note>
  Beim Aufruf von Funktionen über direktes HTTP (wie cURL oder Webhooks) gibt es
  keinen authentifizierten Benutzerkontext. Verwende in diesen Fällen
  `asServiceRole` für alle Operationen.
</Note>

## Das SDK in Funktionen verwenden

In deinen Backend-Funktionen kannst du über das Base44-SDK auf die Daten, die Authentifizierung und die Integrationen deiner App zugreifen. Verwende [`createClientFromRequest()`](/developers/references/sdk/docs/functions/createClientFromRequest), um einen Client aus dem eingehenden Request zu erstellen.

Der Authentifizierungskontext hängt davon ab, wie die Funktion aufgerufen wurde:

* **Beim Aufruf über das SDK aus deinem Frontend:** Die Authentifizierung des Benutzers wird automatisch durchgereicht. Du kannst auf den aktuellen Benutzer mit `base44.auth.me()` zugreifen und Operationen mit seinen Berechtigungen durchführen. Für Operationen auf Admin-Ebene verwende [`asServiceRole`](/developers/references/sdk/docs/functions/createClientFromRequest#asservicerole).

* **Beim Aufruf über direktes HTTP (cURL, Webhooks, externe Dienste):** Es gibt keinen authentifizierten Benutzer, also verwende `asServiceRole` für alle Operationen.

## Mit Drittanbieter-APIs verbinden

Backend-Funktionen sind eine von mehreren Möglichkeiten, [sich mit Drittanbieter-APIs zu verbinden](/developers/references/sdk/getting-started/third-party-apis). Sie sind ideal, wenn du volle Kontrolle über Requests benötigst oder API-Schlüssel sicher als Umgebungsvariablen speichern möchtest. Verwende [`secrets set`](/developers/references/cli/commands/secrets-set), um Umgebungsvariablen über die CLI zu konfigurieren.

## Logs ansehen

Während der [lokalen Entwicklung](/developers/backend/overview/local-dev/local-development-overview) wird die Funktionsausgabe direkt in deinem Terminal ausgegeben, ohne den `logs`-Befehl zu benötigen.

Für deployed Funktionen sieh dir die Logs mit dem [`logs`](/developers/references/cli/commands/logs)-Befehl an. Die Logs enthalten Konsolenausgaben, Fehler und Zeitinformationen. Du kannst nach Funktionsname oder Zeitraum filtern. Wenn du einen KI-Coding-Agenten verwendest, kann die Skill [base44-troubleshooter](/developers/backend/overview/skills#base44-troubleshooter) diese Logs automatisch abrufen und analysieren.

## TypeScript-Typen

Generiere TypeScript-Typen aus deinen Funktionskonfigurationen, um Typsicherheit und Autovervollständigung für Funktionsnamen in deinem SDK-Code zu erhalten. Erfahre mehr über [dynamische Typen](/developers/references/sdk/getting-started/dynamic-types).

## Siehe auch

* [Automationen](/developers/backend/resources/backend-functions/automations): Funktionen planen oder bei Datenbankereignissen auslösen
* [`functions`-Modul](/developers/references/sdk/docs/interfaces/functions): SDK-Referenz zum Aufrufen von Funktionen
* [`createClientFromRequest`](/developers/references/sdk/docs/functions/createClientFromRequest): Einen Client in Backend-Funktionen erstellen
* [`functions deploy`](/developers/references/cli/commands/functions-deploy): Lokale Funktionen zu Base44 deployen
* [`functions pull`](/developers/references/cli/commands/functions-pull): Deployed Funktionen in dein lokales Projekt herunterladen
* [`functions list`](/developers/references/cli/commands/functions-list): Alle deployed Funktionen auflisten
* [`functions delete`](/developers/references/cli/commands/functions-delete): Deployed Funktionen löschen
* [`logs`](/developers/references/cli/commands/logs): Funktionslogs ansehen
* [`exec`](/developers/references/cli/commands/exec): Funktionen isoliert aus eigenständigen Skripten testen

<Note>Diese Seite wurde mit KI übersetzt. Für die genauesten und aktuellsten Informationen siehe die [englische Version](/). </Note>