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