Serverless-APIs: Architektur, Best Practices und typische Fallstricke

Serverless-APIs: Architektur, Best Practices und typische Fallstricke

API-Gateway, Funktionszuschnitt, Kaltstarts, Authentifizierung, Rate Limiting, Versionierung, Datenbankverbindungen und Kosten – mit getestetem TypeScript-Code

Aktualisiert:

Abstract

Serverless-APIs richtig aufbauen: wie Gateway, Funktion und Datenbank zusammenspielen und wie Sie Kaltstarts, Sicherheit, Lastspitzen und Kosten beherrschen.
  • #Serverless
  • #API
  • #Cloud Computing
  • #REST
  • #Entwicklung
  • #API Gateway
  • #AWS Lambda

Eine HTTP-API ohne eigene Server ist schnell gebaut. Ob sie im Betrieb trägt, entscheidet sich an Gateway, Datenbank und Kostenmodell

Angenommen, ein Onlinehändler bietet seinen Kunden eine Schnittstelle an, über die Warenwirtschaft, App und Partnershops den Status einer Bestellung abfragen. An einem gewöhnlichen Dienstag kommen ein paar Anfragen pro Minute, in der Woche vor Weihnachten mehrere Hundert pro Sekunde. Ein klassischer Server müsste für die Spitze ausgelegt sein und würde den Rest des Jahres überwiegend warten. Eine Serverless-API wächst mit der Last mit und kostet in ruhigen Stunden fast nichts.

So weit das Versprechen. In der Praxis zeigt sich schnell, dass „ohne Server“ nicht „ohne Architektur“ heißt. Die erste Anfrage nach einer Pause dauert spürbar länger, die Datenbank meldet plötzlich zu viele Verbindungen, und ein schlecht geschützter Endpunkt kann bei einem Angriff die Rechnung in die Höhe treiben. Dieser Leitfaden zeigt, wie Sie eine HTTP-API auf Serverless-Basis so aufbauen, dass sie auch unter Last und nach dem dritten Release noch verlässlich funktioniert. Die Beispiele verwenden AWS Lambda und Amazon API Gateway, weil das die verbreitetste Kombination ist. Die Prinzipien gelten für Azure und Google Cloud genauso.

Was eine Serverless-API ausmacht

Eine Serverless-API besteht im Kern aus drei Teilen. Ein API-Gateway nimmt die HTTP-Anfrage entgegen, prüft sie und leitet sie weiter. Eine Funktion, etwa eine AWS-Lambda-Funktion, enthält die eigentliche Logik und läuft nur, solange eine Anfrage bearbeitet wird. Dahinter liegt ein Datenspeicher, häufig eine verwaltete Datenbank. Server im klassischen Sinn gibt es weiterhin, nur betreibt sie der Cloud-Anbieter. Sie kümmern sich weder um Betriebssystem-Updates noch um die Frage, wie viele Instanzen gerade laufen.

Typisch für HTTP-APIs ist die synchrone Arbeitsweise: Der Client wartet auf die Antwort. Das unterscheidet sie von ereignisgesteuerten Systemen, in denen eine Funktion etwa auf eine neue Nachricht in einer Warteschlange reagiert und niemand unmittelbar auf das Ergebnis wartet. Wie solche Architekturen mit Queues, Idempotenz und Dead-Letter-Queues funktionieren, beschreibt der Beitrag über ereignisgesteuerte Architekturen mit Serverless. Wenn eine Anfrage einen mehrstufigen Ablauf mit Wiederholungen und Kompensation auslöst, etwa Zahlung, Lager und Versand, hilft eine Orchestrierung; dazu mehr im Beitrag über Serverless-Orchestrierung und Cloud-Workflows. Allgemeine Grundsätze für Serverless-Anwendungen jenseits von APIs fasst der Leitfaden zu Best Practices für Serverless-Architekturen zusammen.

Diese Trennung hat einen praktischen Grund: Eine HTTP-API sollte schnell antworten. Alles, was länger dauert, gehört in eine Warteschlange oder einen Workflow. Die API nimmt den Auftrag an, antwortet mit dem Status 202 Accepted und einer Kennung, unter der der Client später nachfragen kann.

Das API-Gateway als Türsteher, Router und Zähler

Das Gateway ist mehr als eine Weiterleitung. Es ordnet Pfad und Methode einer Funktion zu (Routing), prüft Tokens, begrenzt die Zahl der Anfragen, setzt CORS-Header für Browser-Anwendungen und schreibt Zugriffsprotokolle. Alles, was das Gateway erledigt, muss Ihr Code nicht mehr leisten, und jede Anfrage, die es abweist, verursacht keine Funktionskosten.

Bei AWS gibt es zwei Varianten. Die HTTP API ist schlanker und günstiger, unterstützt JWT-Prüfung direkt und reicht für die meisten neuen Projekte. Die ältere REST API bietet mehr Funktionen, etwa API-Schlüssel mit Nutzungsplänen, Antwort-Caching, Validierung der Anfragen gegen ein Schema und die direkte Anbindung der Web Application Firewall AWS WAF. Wer diese Funktionen braucht, nimmt die REST API, alle anderen fahren mit der HTTP API gut.

Microsoft Azure geht einen anderen Weg. Azure Functions können über einen HTTP-Trigger direkt aufgerufen werden. Für Authentifizierung, Drosselung und Versionierung über mehrere Funktionen hinweg schaltet man Azure API Management davor. In Google Cloud lassen sich Cloud Run functions, die frühere Bezeichnung war Cloud Functions, ebenfalls direkt per HTTP aufrufen. Für eine gemeinsame Schnittstelle mit Schlüsseln und Kontingenten gibt es Google API Gateway, das über eine OpenAPI-Spezifikation konfiguriert wird, oder für größere Landschaften Apigee.

Eine Grenze sollten Sie früh kennen: Gateways haben ein Zeitlimit für die Antwort. Bei der AWS HTTP API liegt es bei 30 Sekunden, bei der REST API standardmäßig bei 29 Sekunden. Eine Lambda-Funktion dürfte zwar bis zu 15 Minuten laufen, aber der Client bekommt dann längst eine Fehlermeldung. Endpunkte, die regelmäßig mehr als wenige Sekunden brauchen, sind ein Zeichen dafür, dass die Arbeit asynchron erledigt werden sollte.

Wie groß eine Funktion sein sollte

Die Lehrbuchantwort lautet: eine Funktion pro Route. GET /orders/{orderId} bekommt eine eigene Funktion, POST /orders eine andere. Das hat Vorteile. Jede Funktion erhält nur die Rechte, die sie braucht, etwa Lesezugriff auf eine Tabelle. Sie lässt sich einzeln überwachen, skalieren und austauschen. Und das Deployment-Paket bleibt klein, was Kaltstarts verkürzt.

Der Nachteil zeigt sich bei größeren APIs. Fünfzig Endpunkte bedeuten fünfzig Funktionen mit eigener Konfiguration, eigenen Logs und eigenen Kaltstarts. Deshalb hat sich ein Mittelweg etabliert: eine Funktion pro fachlichem Bereich. Alle Routen unter /orders landen in einer Funktion, die intern mit einem kleinen Router arbeitet. Im Extremfall, scherzhaft „Lambdalith“ genannt, läuft eine komplette Express- oder Fastify-Anwendung in einer einzigen Funktion. Das erleichtert die Migration bestehender Anwendungen, verschenkt aber die feinen Berechtigungen und macht die Funktion träge beim Start.

Unsere Empfehlung: Schneiden Sie nach fachlichen Bereichen und Berechtigungen. Endpunkte, die dieselben Daten mit denselben Rechten verarbeiten, dürfen sich eine Funktion teilen. Ein Endpunkt, der etwa Zahlungsdaten anfasst oder deutlich mehr Speicher braucht, bekommt eine eigene.

Ein Handler im Detail

Wie ein schlanker Handler aussieht, zeigt das folgende Beispiel. Die Funktion beantwortet GET /orders/{orderId} hinter einer AWS HTTP API mit JWT-Prüfung und liest die Bestellung aus DynamoDB, der Schlüssel-Wert-Datenbank von AWS. Der Code wurde mit Node.js 24, TypeScript 7.0, AWS SDK for JavaScript v3 und den Typdefinitionen aus @types/aws-lambda geprüft und lokal mit Beispiel-Events aufgerufen; die Datenbank war dabei durch ein Mock ersetzt.

import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocumentClient, GetCommand } from '@aws-sdk/lib-dynamodb';
import type {
  APIGatewayProxyEventV2WithJWTAuthorizer,
  APIGatewayProxyResultV2,
} from 'aws-lambda';

// Außerhalb des Handlers: wird einmal pro Ausführungsumgebung angelegt
// und bei warmen Aufrufen wiederverwendet.
const db = DynamoDBDocumentClient.from(new DynamoDBClient({}));
const TABLE = process.env.ORDERS_TABLE ?? 'orders';

const json = (statusCode: number, body: unknown): APIGatewayProxyResultV2 => ({
  statusCode,
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify(body),
});

export const handler = async (
  event: APIGatewayProxyEventV2WithJWTAuthorizer,
): Promise<APIGatewayProxyResultV2> => {
  // Das Gateway hat das JWT bereits geprüft; hier steht nur noch der Inhalt.
  const customerId = event.requestContext.authorizer.jwt.claims.sub;
  const orderId = event.pathParameters?.orderId;

  if (typeof customerId !== 'string' || !orderId) {
    return json(400, { error: 'Ungültige Anfrage' });
  }

  const { Item } = await db.send(
    new GetCommand({ TableName: TABLE, Key: { customerId, orderId } }),
  );

  // Fremde und fehlende Bestellungen sehen gleich aus: kein Hinweis auf IDs.
  if (!Item) {
    return json(404, { error: 'Bestellung nicht gefunden' });
  }
  return json(200, { orderId, status: Item.status, total: Item.total });
};

Drei Details verdienen Aufmerksamkeit. Erstens entsteht der Datenbank-Client außerhalb des Handlers. Lambda hält eine Ausführungsumgebung nach einer Anfrage eine Weile vor; der nächste Aufruf nutzt Client und Verbindungen weiter. Zweitens kommt die Kundennummer aus dem geprüften Token und nie aus einem Parameter, den der Client frei wählen kann. Drittens ist die Tabelle so angelegt, dass Kundennummer und Bestellnummer gemeinsam den Schlüssel bilden. Eine Bestellung eines anderen Kunden kann der Handler deshalb gar nicht finden, und die Antwort 404 verrät nicht, ob es die Nummer gibt.

Weil der Handler eine gewöhnliche asynchrone Funktion ist, lässt er sich ohne Cloud-Konto testen: Ein Test baut ein Beispiel-Event, ersetzt den Datenbank-Client durch ein Mock, etwa mit der Bibliothek aws-sdk-client-mock, und prüft Statuscode und Antwort. Solche Tests laufen in Sekunden und decken den Großteil der Logik ab. Für das Zusammenspiel mit Gateway und Berechtigungen braucht es zusätzlich Tests gegen eine echte Testumgebung.

Kaltstarts: wann sie stören und was hilft

Kommt eine Anfrage und es gibt keine freie Ausführungsumgebung, muss Lambda eine neue anlegen: Laufzeit starten, Code laden, Initialisierungscode ausführen. Diese Verzögerung heißt Kaltstart. Schlanke Node.js- oder Python-Funktionen starten vergleichsweise schnell, bei Java ohne Optimierung oder bei großen Abhängigkeiten dauert es deutlich länger. Seit August 2025 berechnet AWS die Initialisierungsphase außerdem auch bei Funktionen mit verwalteten Laufzeiten wie normale Laufzeit, Kaltstarts kosten also auch Geld.

Ob Kaltstarts stören, hängt vom Einsatz ab. Eine API für Partnersysteme, die ohnehin stetig Last hat, bemerkt sie kaum, weil die meisten Anfragen auf warme Umgebungen treffen. Eine selten genutzte Funktion, hinter der ein Mensch auf eine Seite wartet, spürt jeden einzelnen. Diese Maßnahmen helfen, ungefähr nach Aufwand sortiert:

  • Weniger laden: Abhängigkeiten ausdünnen, den Code mit einem Bundler wie esbuild zusammenfassen und nur die SDK-Module importieren, die tatsächlich gebraucht werden.
  • Mehr Speicher zuweisen: Lambda teilt CPU-Leistung proportional zum Arbeitsspeicher zu. Eine Funktion mit mehr Speicher startet und rechnet schneller und ist dadurch nicht zwingend teurer.
  • SnapStart nutzen: Für Java, Python und .NET kann Lambda einen Speicherabzug der initialisierten Umgebung anlegen und daraus starten.
  • Provisioned Concurrency: Eine feste Zahl von Umgebungen wird dauerhaft warm gehalten. Das beseitigt Kaltstarts für diese Kapazität, kostet aber auch ohne Anfragen Geld.

Von selbstgebauten „Aufwärm-Pings“, die eine Funktion alle paar Minuten aufrufen, ist abzuraten. Sie halten nur eine einzige Umgebung warm und helfen bei der zweiten gleichzeitigen Anfrage schon nicht mehr.

Authentifizierung gehört ins Gateway, Berechtigung in den Code

Die Prüfung, wer anfragt, sollte das Gateway übernehmen. Bei der AWS HTTP API genügt ein JWT-Authorizer: Sie hinterlegen den Aussteller, etwa Amazon Cognito, Microsoft Entra ID, Auth0 oder Keycloak, und die erwartete Zielgruppe. Das Gateway prüft Signatur, Ablaufzeit und Berechtigungsumfang (Scopes) des Tokens, bevor die Funktion überhaupt startet. Ungültige Anfragen kosten so keine Funktionslaufzeit. Für Sonderfälle, etwa eigene Token-Formate oder eine Prüfung gegen eine Datenbank, gibt es Lambda-Authorizer, die das Ergebnis eine Zeit lang zwischenspeichern können.

API-Schlüssel sind dagegen kein Anmeldeverfahren. Sie eignen sich, um Kontingente pro Partner zu vergeben und Nutzung zuzuordnen, AWS selbst rät aber davon ab, sie als alleinigen Zugriffsschutz einzusetzen. Für Maschine-zu-Maschine-Kommunikation ist der OAuth-2.0-Ablauf „Client Credentials“ die bessere Wahl. Wie OAuth 2.0 und JWT in Microservices zusammenspielen, vertieft der Infothek-Beitrag über sichere RESTful APIs mit OAuth 2.0 und JWT.

Das Gateway kann allerdings nur prüfen, ob jemand angemeldet ist und welche Scopes er hat. Ob Kundin A die Bestellung von Kunde B lesen darf, weiß es nicht. Diese Prüfung auf Ebene des einzelnen Datensatzes führt die OWASP-Liste der häufigsten API-Sicherheitsrisiken als Punkt 1 („Broken Object Level Authorization“). Sie gehört in den Code, wie im Handler oben, oder besser noch in den Zuschnitt der Datenbankschlüssel.

Rate Limiting schützt API, Datenbank und Budget

Serverless skaliert schnell, und genau das wird zum Risiko, wenn ein fehlerhafter Client in einer Schleife Anfragen schickt oder ein Angreifer einen teuren Endpunkt bombardiert. Ohne Grenzen startet die Plattform bereitwillig Hunderte Funktionsinstanzen, die Datenbank dahinter bricht ein, und die Rechnung steigt.

Drosselung (Throttling) sollte deshalb auf mehreren Ebenen greifen:

  • Am Gateway: API Gateway arbeitet mit einem Token-Bucket-Verfahren, das eine dauerhafte Rate und einen kurzzeitigen Burst erlaubt. Grenzen lassen sich pro Stage und pro Route setzen; überzählige Anfragen erhalten den Status 429 Too Many Requests. Die REST API kann zusätzlich Kontingente pro API-Schlüssel und Partner vergeben.
  • An der Funktion: Mit Reserved Concurrency legen Sie fest, wie viele Instanzen einer Funktion höchstens gleichzeitig laufen. Das ist der wirksamste Schutz für eine Datenbank, die nur eine begrenzte Zahl von Verbindungen verträgt. Standardmäßig teilen sich alle Funktionen eines Kontos in einer Region ein gemeinsames Kontingent von 1.000 gleichzeitigen Ausführungen.
  • Vor dem Gateway: Eine Web Application Firewall mit ratenbasierten Regeln bremst einzelne IP-Adressen aus, bevor sie das Gateway erreichen.

Gut gebaute Clients reagieren auf 429 mit einer Wartezeit, die mit jedem Fehlversuch wächst. Teilen Sie Ihren API-Nutzern das in der Dokumentation mit.

Versionierung ohne Bruch für bestehende Clients

APIs werden länger genutzt, als ihre Entwickler planen. Eine Partnerintegration, die 2023 gebaut wurde, ruft vielleicht noch heute dieselben Endpunkte auf. Deshalb gilt: Änderungen möglichst so gestalten, dass sie bestehende Clients nicht brechen. Ein neues optionales Feld in der Antwort ist unkritisch, ein umbenanntes oder entferntes Feld nicht.

Für echte Brüche hat sich die Version im Pfad durchgesetzt, also /v1/orders und /v2/orders. Das ist im Gateway leicht zu routen, in Logs sofort sichtbar und für Partner verständlich. Versionen im Header sind eleganter, aber schwerer zu testen und zu debuggen. Davon zu trennen ist die Frage, wie Sie neue Codestände ausrollen. Lambda bietet dafür Versionen und Aliase: Ein Alias wie live zeigt auf eine bestimmte Version und kann einen Teil des Verkehrs, etwa zehn Prozent, auf eine neue Version lenken. So testen Sie einen neuen Stand an echtem Verkehr (Canary-Release) und schalten bei Fehlern in Sekunden zurück.

Grundlage für beides ist ein Vertrag, meist eine OpenAPI-Spezifikation, aus der sich Dokumentation, Client-Bibliotheken und Prüfungen erzeugen lassen. Legen Sie Gateway, Funktionen und Berechtigungen zudem als Code an, etwa mit AWS SAM, CDK, Terraform oder OpenTofu, damit jede Umgebung reproduzierbar ist. Wie sich der Lebenszyklus einer Schnittstelle von Entwurf bis Abschaltung organisieren lässt, ist Thema unserer Seite zu API Lifecycle Management.

Datenbanken: das unterschätzte Verbindungsproblem

Relationale Datenbanken wie PostgreSQL oder MySQL sind für eine überschaubare Zahl langlebiger Verbindungen gebaut. Serverless dreht das um: Bei einer Lastspitze starten vielleicht 300 Funktionsinstanzen gleichzeitig, jede öffnet eine eigene Verbindung, und die Datenbank lehnt weitere ab. Der Fehler zeigt sich typischerweise erst unter Last, also im ungünstigsten Moment.

Drei Maßnahmen helfen. Erstens einen Verbindungspool pro Ausführungsumgebung mit genau einer Verbindung, angelegt außerhalb des Handlers. Eine Lambda-Instanz bearbeitet ohnehin nur eine Anfrage gleichzeitig. Zweitens einen vorgeschalteten Verbindungs-Proxy, bei AWS etwa RDS Proxy, der viele kurzlebige Client-Verbindungen auf wenige Datenbankverbindungen bündelt. Drittens Reserved Concurrency, damit nie mehr Instanzen laufen, als Proxy und Datenbank verkraften. Das folgende Beispiel mit dem Paket pg (Version 8) wurde ebenfalls mit TypeScript geprüft und lokal gegen eine In-Memory-Datenbank aufgerufen:

import { Pool } from 'pg';

// Ein Pool pro Ausführungsumgebung, mit genau einer Verbindung:
// Eine Lambda-Instanz bearbeitet ohnehin nur eine Anfrage gleichzeitig.
export const pool = new Pool({
  host: process.env.DB_HOST, // Endpunkt des RDS Proxy, nicht der Datenbank
  database: process.env.DB_NAME,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  ssl: process.env.DB_HOST ? { rejectUnauthorized: true } : undefined,
  max: 1,
  idleTimeoutMillis: 60_000,
  connectionTimeoutMillis: 2_000,
});

export async function findOrder(customerId: string, orderId: string) {
  const { rows } = await pool.query(
    'SELECT order_id, status, total FROM orders WHERE customer_id = $1 AND order_id = $2',
    [customerId, orderId],
  );
  return rows[0] ?? null;
}

In der Praxis gehört das Passwort nicht in eine Umgebungsvariable, sondern in einen Secrets-Dienst wie AWS Secrets Manager; RDS Proxy unterstützt außerdem die Anmeldung über IAM. Die Alternative ist eine Datenbank, die über HTTP angesprochen wird und keine dauerhaften Verbindungen kennt, etwa DynamoDB wie im ersten Beispiel oder die Data API von Amazon Aurora. Dafür müssen Sie Ihr Datenmodell an die Zugriffsmuster der Datenbank anpassen, und Abfragen mit freien Filtern und Joins werden schwieriger.

Was eine Serverless-API kostet

Die Rechnung setzt sich aus mehreren Posten zusammen: Anfragen am Gateway, Aufrufe und Laufzeit der Funktionen (abgerechnet in Gigabyte-Sekunden, also Speichergröße mal Laufzeit), Datenbank, ausgehender Datenverkehr und Protokolle. Gerade der letzte Posten wird unterschätzt. Wer jede Anfrage ausführlich protokolliert, zahlt für das Speichern der Logs in CloudWatch unter Umständen mehr als für die Funktionen.

Eine Beispielrechnung nach den AWS-Listenpreisen für die Region us-east-1 macht die Größenordnung deutlich. Angenommen, die Bestell-API erhält zehn Millionen Anfragen im Monat, jede Funktion läuft im Schnitt 100 Millisekunden mit 512 MB Speicher. Die HTTP API kostet laut Preisliste rund einen US-Dollar pro Million Anfragen, also etwa 10 Dollar. Die Lambda-Aufrufe schlagen mit rund 2 Dollar zu Buche, die Laufzeit von 500.000 Gigabyte-Sekunden mit gut 8 Dollar. Zusammen sind das rund 20 Dollar im Monat, zuzüglich Datenbank, Logs und Datenverkehr. Mit der REST API läge allein der Gateway-Anteil mehr als dreimal so hoch.

Bei ungleichmäßiger und mittlerer Last ist das sehr günstig. Bei hoher, gleichmäßiger Dauerlast kann sich das Verhältnis umkehren: Dann kann ein Container-Dienst billiger sein, weil Sie für ausgelastete Kapazität zahlen statt für jede einzelne Anfrage. Behalten Sie die Kosten mit Budgetalarmen im Blick und rechnen Sie vor größeren Entscheidungen mit Ihren echten Lastprofilen.

Was das für Ihr Team bedeutet

Für die meisten neuen HTTP-APIs mit schwankender Last ist Serverless eine gute Standardwahl: wenig Betriebsaufwand, automatische Skalierung und niedrige Kosten bei geringer Nutzung. Die Technik selbst ist ausgereift. Projekte scheitern selten an Lambda, sondern an fehlenden Grenzen: kein Rate Limiting, keine Begrenzung der Parallelität, eine relationale Datenbank ohne Proxy, ein Endpunkt, der eigentlich ein Hintergrundjob sein müsste.

Unsere Empfehlung: Beginnen Sie mit einer HTTP API und JWT-Prüfung am Gateway, schneiden Sie Funktionen nach Fachbereichen, legen Sie alles als Code an und setzen Sie von Anfang an Grenzen für Anfragen und Parallelität. Überschätzt wird das Kaltstartproblem, das sich für die meisten APIs mit wenig Aufwand entschärfen lässt. Unterschätzt werden Datenbankverbindungen, Logkosten und die Bindung an einen Anbieter, denn Gateway-Konfiguration und Berechtigungsmodell lassen sich nicht ohne Weiteres zu einem anderen Cloud-Anbieter mitnehmen. Wer Serverless-APIs einführen oder eine bestehende Anwendung umstellen möchte, findet auf unserer Seite zu Serverless Computing Beratung und Seminare zum Thema.

Häufige Fragen zu Serverless-APIs

Braucht jede Serverless-API ein API-Gateway?

Nicht zwingend. AWS bietet mit Function URLs eine direkte HTTPS-Adresse für eine einzelne Lambda-Funktion, Azure und Google Cloud erlauben ebenfalls direkte HTTP-Aufrufe. Für interne Werkzeuge oder Webhooks reicht das oft. Sobald mehrere Endpunkte, Token-Prüfung, Drosselung oder eine eigene Domain mit Versionen ins Spiel kommen, ist ein Gateway die übersichtlichere Lösung.

Eignet sich Serverless auch für GraphQL-APIs?

Ja. Eine GraphQL-Schnittstelle kann in einer einzelnen Funktion hinter dem Gateway laufen; es gibt auch verwaltete Dienste wie AWS AppSync. Weil bei GraphQL alle Anfragen an denselben Endpunkt gehen, greifen Rate Limiting und Caching am Gateway weniger gut. Begrenzen Sie dann zusätzlich Tiefe und Umfang der Abfragen im Code.

Wie lassen sich Serverless-APIs lokal entwickeln?

Die Logik testen Sie am schnellsten wie oben gezeigt: Handler als Funktion aufrufen, Beispiel-Events übergeben, Cloud-Dienste durch Mocks ersetzen. Werkzeuge wie AWS SAM können Gateway und Funktion zusätzlich lokal in Containern nachbilden. Das Zusammenspiel von Berechtigungen, Gateway-Konfiguration und echten Diensten lässt sich aber nur in einer Cloud-Testumgebung verlässlich prüfen. Planen Sie deshalb eine eigene Testumgebung pro Team oder pro Branch ein.

Mehr aus „Cloud & DevOps“

Monolithen skalieren: Was Netflix und Prime Video wirklich zeigen

Auch Monolithen skalieren horizontal. Lesen Sie, was die Fälle Netflix und Prime Video wirklich zeigen und wann eine einzelne Anwendung große Last trägt.

mehr erfahren

Docker-Alternativen: Podman, containerd und CRI-O im Vergleich

Podman, containerd, CRI-O und nerdctl im sachlichen Vergleich mit Docker: Architektur, Lizenzen, Kubernetes und Compose. Wann sich ein Umstieg für Sie lohnt.

mehr erfahren

Local-First Software: Wie dezentrale Anwendungen funktionieren

Local-First Software speichert Daten zuerst auf dem Gerät und gleicht sie später ab. Wie CRDTs, Automerge und Yjs funktionieren und wann sich das lohnt.

mehr erfahren

DevOps in der Softwareentwicklung: Kultur, Praktiken, Messgrößen

DevOps verbindet Entwicklung und Betrieb zu gemeinsamer Verantwortung. Welche Prinzipien dahinterstehen, wie Fortschritt messbar wird und wo Teams scheitern.

mehr erfahren

Skalierbare Webanwendungen entwickeln: die wichtigsten Hebel

Skalierbare Webanwendungen brauchen zustandslose Server, Caching, eine wachsende Datenbank und Messungen. Lesen Sie, welche Hebel wann wirken.

mehr erfahren

Serverless Architecture: Best Practices für den Betrieb in der Cloud

Serverless-Anwendungen stabil betreiben: wie Sie Funktionen zuschneiden, Kaltstarts und doppelte Ereignisse beherrschen, Limits setzen und Kosten überwachen.

mehr erfahren

Weitere Blog-Artikel

Barrierefreies Web: Praxisleitfaden für Entwicklerinnen und Entwickler

Barrierefreiheit im Code: wie Sie mit semantischem HTML, ARIA-Mustern, Tastaturbedienung und Fokusführung bauen und mit axe-core und Screenreader testen.

mehr erfahren

Svelte 5 und Runes: Fortschritt oder Rückschritt für das Framework?

Svelte 5 ersetzt die implizite Reaktivität durch Runes wie $state und $derived. Sie erfahren, was sich ändert und wann sich der Umstieg lohnt.

mehr erfahren

Echtzeit mit Node.js: Server-Sent Events und WebSockets im Vergleich

Server-Sent Events oder WebSockets? Wie beide Protokolle arbeiten, wie Sie sie in Node.js umsetzen und was Proxys, HTTP/2 und Skalierung für die Wahl bedeuten.

mehr erfahren

Next.js 15 und React 19: Was das Update im Herbst 2024 brachte

Next.js 15 im Rückblick: Wie das Framework im Oktober 2024 React 19 einband, Turbopack stabilisierte, das Caching umstellte und Server Actions absicherte.

mehr erfahren

Express-Anwendungen absichern: Sicherheit für Node.js-Backends

Express-Anwendungen absichern: Eingabeprüfung, Schutz vor Injection und XSS, Content Security Policy mit helmet, Rate Limiting, Secrets und Fehlermeldungen.

mehr erfahren

Event-driven Architecture mit Serverless: Bausteine und Praxis

Event-driven Architecture mit Serverless: Wie Sie Event-Bus, Queues und Streams einsetzen und Idempotenz, Dead-Letter-Queues und Schemas im Griff behalten.

mehr erfahren

Aktuelle Blog-Artikel

PHP-Migration nach PHP2Shell: Upgrade oder Sprachwechsel?

PHP2Shell und das Support-Ende von PHP 8.2: Was Sie jetzt patchen sollten, wie ein Upgrade auf 8.4 oder 8.5 gelingt und wann ein Sprachwechsel sinnvoll ist.

mehr erfahren

Jev: Was ein KI-Modell für schnelles Denken anders macht als ChatGPT

Das System-1-KI-Modell Jev schreibt keinen Text, sondern beantwortet Fragen mit kalibrierten Wahrscheinlichkeiten. Wie das funktioniert und wofür es taugt.

mehr erfahren

Node.js ohne Ballast: 12 Bordmittel, die npm-Pakete ersetzen

Von fetch() über node:test bis Type Stripping: zwölf Node.js-Funktionen, die axios, dotenv, Jest und Co. ersetzen, mit Status in Node 24 und 26 und Grenzen.

mehr erfahren

KI-Agenten verstehen: MCP, A2A, AG-UI und A2UI einfach erklärt

MCP, A2A, AG-UI und A2UI verständlich erklärt: Wie KI-Agenten Werkzeuge nutzen, miteinander arbeiten und Oberflächen erzeugen – und wer die Standards betreut.

mehr erfahren

Rusts Lieferkette unter Beschuss: Warum ein Angriff nur der Anfang war

Ein Angriff auf Rust-Pakete war im August 2026 schnell gestoppt, das Grundproblem bleibt. Wie crates.io angreifbar ist und was Sie heute dagegen tun können.

mehr erfahren

Webentwicklung ohne SPA: Eine Web-App mit V, Veb, SQLite und htmx

Am Beispiel der Meetup-Plattform Clash zeigt sich, wie eine Web-App mit V, Veb, SQLite und htmx ohne SPA-Framework entsteht und wo der Ansatz an Grenzen stößt.

mehr erfahren

React-Performance: Warum weniger Optimierung mehr Tempo bringt

React-Performance heute: Wie Sie mit State am richtigen Ort, dem React Compiler, Transitions, Virtualisierung und Messung Ihre Anwendung spürbar beschleunigen.

mehr erfahren

React-Komponenten verbinden: Welcher Weg passt wann?

Props, Context, Zustand, TanStack Query, URL-Parameter oder Ereignisse: So wählen Sie den passenden Weg, damit zwei React-Komponenten Daten austauschen.

mehr erfahren

KI-Agenten in der Schleife: Loops in Claude Code und Codex

Was ein Loop bei KI-Agenten ist, welche Auslöser es gibt und wie Sie geplante Aufgaben in Claude Code und Codex mit Kostenkontrolle einrichten.

mehr erfahren

JavaScript 2026: Bun, Deno und TypeScript 7 läuten eine neue Ära ein

Node.js, Bun und Deno im Wettbewerb, TypeScript 7 mit Compiler in Go, Build-Werkzeuge in Rust: Was sich 2026 bei JavaScript ändert und was Sie davon übernehmen.

mehr erfahren

npm-Pakete sicher prüfen: So bewerten Sie ein Paket vor dem Einbau

npm-Pakete sicher prüfen: wie Sie Name, Wartung, Provenance, Install-Skripte, bekannte Lücken und Lizenz bewerten, bevor ein Paket in Ihr Projekt kommt.

mehr erfahren

npm install unter der Lupe: Wie Angreifer die Lieferkette kapern

Was npm install technisch tut, welche Angriffsmuster von Typosquatting bis Dependency Confusion es ausnutzen und wie Sie das Installieren absichern.

mehr erfahren

Programmiersprachen und KI: Warum Rust für Code-Agenten so gut passt

KI-Agenten schreiben in Rust oft verlässlicheren Code, weil der Compiler viele Fehler sofort meldet. Was dahinter steckt und wo das Argument endet.

mehr erfahren

Pi Agent vs. Claude Code: minimaler Open-Source-Agent im Vergleich

Pi Agent und Claude Code im Vergleich: Architektur, Erweiterungen, Modellwahl, Lizenz, Kosten und Sicherheit. Für wen sich der Open-Source-Agent lohnt.

mehr erfahren

Agentic Engine Optimization: Websites für KI-Agenten lesbar machen

Agentic Engine Optimization: Wie KI-Assistenten Ihre Website abrufen, welche Rolle robots.txt, llms.txt und strukturierte Daten spielen – und was belegt ist.

mehr erfahren

Claude Skills für Einsteiger: eigene KI-Workflows aufbauen

Claude Skills bündeln wiederkehrende Anweisungen in einer SKILL.md-Datei. So bauen Sie Skills auf und installieren sie in Claude und Claude Code.

mehr erfahren

Claude Code richtig nutzen: 15 Funktionen, die Profis kennen sollten

Claude Code kann mehr als chatten: So setzen Sie CLAUDE.md, Subagenten, Hooks, Skills, MCP und den Headless-Modus gezielt im Entwickleralltag ein.

mehr erfahren

Claude Code für Einsteiger: vom Terminal zur fertigen Anwendung

Claude Code arbeitet im Terminal direkt mit Ihren Dateien. So gelingen Installation, erste Aufträge, Planmodus, Skills und MCP auch ohne Programmiererfahrung.

mehr erfahren

OpenClaw im Praxistest: vom Chatbot zum digitalen Assistenten

OpenClaw macht ein Sprachmodell zum selbst gehosteten Agenten mit Zugriff auf Rechner und Messenger. Aufbau, Einrichtung, Skills und Sicherheitsregeln.

mehr erfahren

Das Ende der Menüs: Wie KI die digitale Arbeitsumgebung verändert

Seit Jahrzehnten bedienen wir Computer über Fenster, Menüs und Ordner. KI-Agenten verschieben das zu Aufträgen in Alltagssprache. Was sich ändert und was nicht.

mehr erfahren

Microsoft und Rust: Was hinter dem Ziel „C und C++ bis 2030“ steckt

Microsoft nutzt Rust im Windows-Kernel, der Ersatz von C und C++ bis 2030 ist aber ein Forschungsziel. Was belegt ist und was es für Entwickler bedeutet.

mehr erfahren

TanStack Start: Das React-Framework als Alternative zu Next.js

TanStack Start ist ein Fullstack-Framework für React auf Basis von TanStack Router und Vite. Was es kann und wann es eine Alternative zu Next.js ist.

mehr erfahren

Die Ralph-Wiggum-Technik: KI-Coding-Agenten, die nicht aufgeben

Die Ralph-Wiggum-Technik lässt einen Coding-Agenten denselben Auftrag wiederholen, bis die Tests bestehen. Wie sie funktioniert und worauf Sie achten sollten.

mehr erfahren

Warum KI Entwickler nicht ersetzt, aber ihre Rolle verändert

KI-Assistenten schreiben heute viel Code. Warum Fachwissen trotzdem wichtiger wird und welche Fähigkeiten Entwickler:innen jetzt gezielt ausbauen sollten.

mehr erfahren

Von Node.js zu Bun: Next.js-Projekte schrittweise umstellen

Wie Sie Bun in Next.js einsetzen: von bun install über bun --bun next dev bis zum Deployment. Was dabei schneller wird, was nicht und was Sie vorher prüfen.

mehr erfahren

Bun erklärt: JavaScript-Laufzeit, Paketmanager und Bundler in einem

Bun ist Laufzeitumgebung, Paketmanager, Bundler und Testrunner in einem. Wie es funktioniert, wie kompatibel es zu Node.js ist und für wen es sich lohnt.

mehr erfahren

KI-Agenten richtig anleiten: Spezifikationen, die funktionieren

Spezifikationen für KI-Coding-Agenten wie Claude Code oder GitHub Copilot: welche Angaben hineingehören, wie Sie Aufgaben aufteilen und Grenzen setzen.

mehr erfahren

Was ist .NET? Die Microsoft-Plattform einfach erklärt

.NET ist Microsofts quelloffene Entwicklungsplattform für Web, Cloud, Desktop und Apps. Sie erfahren, wie Laufzeit, SDK und Versionen zusammenhängen.

mehr erfahren

Künstliche Intelligenz 2026: Vom Chatbot zum digitalen Kollegen

Rückblick auf den KI-Ausblick vom Januar 2026: acht erwartete Trends von Multi-Agenten-Systemen über physische KI und EU AI Act bis zu Quanten-Utility.

mehr erfahren

KI-Jahr 2025: Vier Erkenntnisse und ein Ausblick auf 2026

Rückblick vom Januar 2026 auf das KI-Jahr 2025: vier Entwicklungen von unauffälligen Agenten bis zum Chipmangel und was sie damals für 2026 erwarten ließen.

mehr erfahren

REST und Event-Streams: Wann sich ereignisbasierte Backends lohnen

REST oder Event-Streams? Wie sich Request/Response und Publish/Subscribe unterscheiden, wann Kafka, SSE oder WebSockets passen und wo REST richtig bleibt.

mehr erfahren

Shai-Hulud 2.0: Wie sich ein Wurm im November 2025 durch npm fraß

Shai-Hulud 2.0 einfach erklärt: Rückblick auf den npm-Wurm vom November 2025, wie er Zugangsdaten stahl, sich selbst verbreitete und wie Sie sich schützten.

mehr erfahren

HTMX: Moderne Webanwendungen ohne JavaScript-Framework bauen

HTMX lädt Inhalte nach, sendet Formulare und tauscht Seitenteile per HTML-Attribut aus. Die Anleitung zeigt Browser- und Serverseite und den Stand von HTMX 4.

mehr erfahren

Electron vs. Tauri: Desktop-Apps mit Webtechnik im Vergleich

Electron bringt Chromium und Node.js mit, Tauri nutzt den Webview des Systems und einen Kern in Rust. Der Vergleich zeigt, wann sich welches Framework eignet.

mehr erfahren

Architekturkompetenz im KI-Zeitalter: Was Full-Stack heute heißt

Wenn KI-Werkzeuge Code schreiben, verschiebt sich die Arbeit zu Architekturentscheidungen. Welche Fähigkeiten zählen und wie Sie sie gezielt aufbauen.

mehr erfahren

Omarchy im Test: So macht Linux endlich wieder Spaß

Unser Test von Omarchy aus dem November 2025: Das Linux auf Basis von Arch und Hyprland setzt auf Tastatur, Kachelfenster und abgestimmte Themes.

mehr erfahren

JWT-Probleme: Warum Entwickler vor JSON Web Tokens warnen

JWT-Probleme im Überblick: Warum sich Tokens schwer widerrufen lassen, welche Prüffehler gefährlich sind und wann klassische Sessions die bessere Wahl sind.

mehr erfahren

7 KI-Begriffe erklärt: Von KI-Agenten bis Superintelligenz

Sieben KI-Begriffe von KI-Agenten über RAG und MCP bis Superintelligenz: was sie bedeuten, wie sie zusammenhängen und was davon für Unternehmen zählt.

mehr erfahren

Machine Learning verstehen: von den Grundlagen bis zu moderner KI

Machine Learning verständlich erklärt: welche Lernverfahren es gibt, wie Training mit Daten abläuft und wie Sie prüfen, ob ein Modell wirklich etwas taugt.

mehr erfahren

Scrum-Master-Rolle auf dem Prüfstand: ein Blick aus Architektursicht

Lohnt sich ein Scrum Master noch? Wir betrachten die Rolle aus Sicht der Softwarearchitektur, gleichen sie mit dem Scrum Guide 2020 ab und zeigen Alternativen.

mehr erfahren

Was dürfen wir für Sie tun?

So sind wir zu erreichen: