Zum Hauptinhalt springen
Du siehst gerade die Entwicklerdokumentation
Diese Dokumentation richtet sich an Entwickler, die mit der Base44-Entwicklerplattform arbeiten. Informationen zu Backend-Funktionen im App-Editor findest du unterIntegrationen verwenden.
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, einer modernen TypeScript-Laufzeit. Rufe Funktionen aus deinem Frontend über das SDK 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 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.
Jedes Projekt unterstützt maximal 50 Backend-Funktionen.

​
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 anpassen. Jede Funktion lebt in ihrem eigenen Unterverzeichnis mit einer entry.ts- oder entry.js-Datei:
functions
<function-name>
entry.ts
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 füge eine function.jsonc-Datei hinzu:
functions
<function-name>
entry.ts
function.jsonc
Die Konfigurationsdatei definiert den Namen der Funktion und ihren Einstiegspunkt: 
{
  "name": "sendWelcomeEmail",
  "entry": "entry.ts",
}
EigenschaftBeschreibung
nameOptional. Eindeutige Kennung für die Funktion. Wird beim Aufruf über SDK oder HTTP verwendet. Standardwert ist der Verzeichnispfad relativ zum Funktions-Stammverzeichnis.
entryDie Datei mit dem Funktionscode.
automationsOptional. Array von Automationskonfigurationen, um die Funktion nach einem Zeitplan oder als Reaktion auf Datenbankereignisse auszuführen. Siehe Automationen 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: 
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 lokal aus, um Änderungen ohne Deployment zu testen. Details unter Lokale Entwicklung.

​
Funktionen deployen

Deploye Funktionen mit functions deploy oder 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. Um zu sehen, was aktuell deployed ist, verwende 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(), um Funktionen aus deinem Frontend aufzurufen. Das SDK übernimmt die Authentifizierung automatisch und übergibt die Anmeldedaten des aktuellen Benutzers an deine Funktion. 
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 
curl -X POST https://your-app.base44.app/functions/sendWelcomeEmail \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice"}'
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.

​
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(), 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.
  • 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. Sie sind ideal, wenn du volle Kontrolle über Requests benötigst oder API-Schlüssel sicher als Umgebungsvariablen speichern möchtest. Verwende secrets set, um Umgebungsvariablen über die CLI zu konfigurieren.

​
Logs ansehen

Während der lokalen Entwicklung 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-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 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.

​
Siehe auch

Diese Seite wurde mit KI übersetzt. Für die genauesten und aktuellsten Informationen siehe die englische Version.