serverless/serverlessCLI-Framework zum Bereitstellen und Verwalten serverloser Anwendungen auf AWS Lambda mit YAML-Infrastruktur, lokaler Entwicklung und Unterstützung für mehrsprachige Laufzeitumgebungen.
Das Serverless Framework – Macht es einfach, AWS Lambda und andere verwaltete Cloud-Dienste zu nutzen, um Anwendungen zu erstellen, die automatisch skalieren, im Leerlauf nichts kosten und einen radikal geringen Wartungsaufwand erfordern.
Das Serverless Framework ist ein Kommandozeilen-Tool mit einer zugänglichen YAML-Syntax, um sowohl Ihren Code als auch die benötigte Cloud-Infrastruktur für zahlreiche Serverless-Anwendungsfälle bereitzustellen – etwa APIs, Frontends, Datenpipelines und geplante Aufgaben. Es ist ein mehrsprachiges Framework, das Node.js, Typescript, Python, Go, Java und mehr unterstützt. Es ist außerdem vollständig erweiterbar durch über 1.000 Plugins, die dem Framework weitere Serverless-Anwendungsfälle und Workflows hinzufügen.
Aktiv gepflegt von Serverless Inc.
Juli 2026 – V.4 enthält weiterhin bedeutende Aktualisierungen. Sehen Sie sich unten alle an. Aktuelle Releases haben Sandboxes (isolierte, kurzlebige Rechenumgebungen auf AWS Lambda), native Unterstützung für Amazon Bedrock AgentCore, verwaltete Instanzen, durable Functions und ein integriertes AWS Login & SSO hinzugefügt. Wie immer freuen wir uns mehr denn je auf die Serverless-Zukunft.
Hier ist eine Liste von allem, was es in V.4 bisher Neues gibt:
serverless.yml über die Eigenschaft ai und verwalten Sie sie mit den serverless agent-Befehlen. Weitere Informationen hier.serverless login aws und serverless login aws sso.serverless diff.serverless reconcile.Wir bemühen uns, bahnbrechende Änderungen für den „aws“-Provider zu vermeiden. Es gibt jedoch einige größere Dinge, die sich ändern und die Sie kennen sollten:
Wenn Sie auf weitere bahnbrechende Änderungen stoßen, erstellen Sie bitte ein Issue. Um mehr über die Unterschiede und mögliche bahnbrechende Änderungen zu erfahren, lesen Sie unsere Dokumentation zum Upgrade auf Serverless Framework V4.
Bitte beachten Sie, dass sich Struktur und Lizenzierung des V.4-Repositorys vom V.4-npm-Modul unterscheiden. Das npm-Modul enthält einige proprietär lizenzierte Software, da V.4 zu einem allgemeinen SaaS-Produkt übergeht, wie zuvor angekündigt. Der ursprüngliche Quellcode des Serverless Frameworks und mehr werden weiterhin unter der MIT-Lizenz bleiben, und das Repository ist so strukturiert, dass klar zwischen proprietären und Open-Source-Komponenten unterschieden wird – der MIT-lizenzierte Code trägt seine eigene LICENSE-Datei in packages/serverless, während die LICENSE im Repository-Stammverzeichnis die proprietären Komponenten abdeckt.
So installieren Sie das Serverless Framework, richten ein Projekt ein und stellen es auf Amazon Web Services auf Serverless-Infrastruktur wie AWS Lambda, AWS DynamoDB, AWS S3 und mehr bereit.
Zuerst müssen Sie die Node.js-Laufzeit installiert haben, Version 18.17.0 oder höher. Danach können Sie das Serverless Framework über NPM installieren.
Öffnen Sie Ihre CLI und führen Sie den folgenden Befehl aus, um das Serverless Framework global zu installieren.```text npm i serverless -g
Führe `serverless` aus, um zu überprüfen, dass deine Installation funktioniert, und um die aktuelle Version anzuzeigen.
<br/>
## Serverless Framework aktualisieren
Seit Version 4 aktualisiert sich das Serverless Framework automatisch und führt alle 24 Stunden eine entsprechende Prüfung durch.
Du kannst ein Update erzwingen, indem du diesen Befehl ausführst:```text
serverless update
Alternativ können Sie diese Umgebungsvariable festlegen:```text SERVERLESS_FRAMEWORK_FORCE_UPDATE=true
<br/>
## Der `serverless`-Befehl
Das Serverless Framework wird mit einem `serverless`-Befehl ausgeliefert, der Sie durch das Erstellen und Bereitstellen eines Projekts auf AWS führt. Er hilft beim Herunterladen einer Vorlage, beim Einrichten von AWS-Anmeldeinformationen, beim Einrichten des Serverless Framework Dashboards und vielem mehr, während er jedes Konzept auf dem Weg erklärt.
Dieser Leitfaden führt Sie ebenfalls durch die ersten Schritte mit dem Serverless Framework, aber bitte beachten Sie, dass das bloße Eintippen des `serverless`-Befehls möglicherweise das bessere Erlebnis ist.```text
serverless
Das zentrale Konzept für ein Projekt im Serverless Framework ist als „Service“ bekannt und wird durch eine serverless.yml-Datei deklariert. Diese enthält eine vereinfachte Syntax für die Bereitstellung von Cloud-Infrastruktur, wie AWS Lambda-Funktionen, Infrastruktur, die diese Funktionen über Ereignisse auslöst, sowie zusätzliche Infrastruktur, die deine AWS Lambda-Funktionen für verschiedene Anwendungsfälle benötigen könnten (z. B. AWS DynamoDB-Datenbanktabellen, AWS S3-Speicher-Buckets, AWS API-Gateways zum Empfangen von HTTP-Anfragen und deren Weiterleitung an AWS Lambda).
Ein Service kann eine gesamte Anwendung sein, die Logik für eine bestimmte Domäne (z. B. „Blog“, „Benutzer“, „Produkte“) oder ein Microservice, der eine einzelne Aufgabe übernimmt. Du entscheidest, wie du dein Projekt organisierst. Generell empfehlen wir, mit einem monolithischen Ansatz für alles zu beginnen, um die Komplexität zu reduzieren, bis die Aufteilung der Logik unbedingt erforderlich ist.
Um einen Serverless Framework Service zu erstellen und vollständig einzurichten, verwende den Befehl serverless, der einen interaktiven Einrichtungsablauf bietet.```text
serverless
Hier werden Ihnen mehrere Vorlagen angezeigt. Wählen Sie eine aus, die zur gewünschten Sprache und zum gewünschten Anwendungsfall passt.```text
Serverless ϟ Framework
Welcome to Serverless Framework V.4
Create a new project by selecting a Template to generate scaffolding for a specific use-case.
? Select A Template: …
❯ AWS / Node.js / HTTP API
AWS / Node.js / Express API
AWS / Node.js / Express API with DynamoDB
AWS / Node.js / Scheduled Task
AWS / Node.js / Simple Function
AWS / Python / HTTP API
AWS / Python / Flask API
AWS / Python / Flask API with DynamoDB
AWS / Python / Scheduled Task
AWS / Python / Simple Function
(Scroll for more)
Nach der Auswahl einer Service-Vorlage werden deren Dateien heruntergeladen und Sie haben die Möglichkeit, Ihrem Service einen Namen zu geben.```text ? Name Your Service: ›
Bitte verwende nur Kleinbuchstaben, Zahlen und Bindestriche. Halte Servicenamen außerdem kurz, da sie in den Namen jeder Cloud-Ressource aufgenommen werden, die das Serverless Framework erstellt, und einige Cloud-Ressourcen Längenbeschränkungen in ihren Namen haben.
Erfahre mehr über Services und mehr in der [Core Concepts-Dokumentation](https://www.serverless.com/framework/docs/providers/aws/guide/intro).
<br/>
## Anmeldung
Ab Serverless Framework V.4 wirst du, wenn du den `serverless`-Befehl zum Einrichten eines Service verwendest, irgendwann aufgefordert, dich anzumelden.
Wenn du dich außerhalb dessen anmelden musst, führe `serverless login` aus.
Beim Anmelden wirst du in deinem Browser zum [Serverless Framework Dashboard](https://app.serverless.com) weitergeleitet. Nach der Registrierung oder Anmeldung gehe zurück zu deiner CLI und du bist angemeldet.
Bitte beachte, dass du kostenlos mit der Serverless Framework CLI und dem Dashboard loslegen kannst, und die CLI wird für kleine Organisationen und Indie-Hacker immer kostenlos sein. Weitere Informationen zu Preisen findest du auf unserer [Preisseite](https://serverless.com/pricing).
<br/>
## Erstellen einer App
Das Konzept „App“ ist ein übergeordneter Container für einen oder mehrere „Services“, die du optional über die `app`-Eigenschaft in deiner `serverless.yml` festlegen kannst. Das Festlegen einer `app` aktiviert außerdem Serverless Framework Dashboard-Funktionen für diesen Service, wie das Verfolgen deiner Services und ihrer Deployments im Serverless Framework Dashboard, das Teilen von Outputs zwischen ihnen, das Teilen von Geheimnissen zwischen ihnen sowie das Aktivieren von Metriken, Traces und Logs.
Wenn du den `serverless`-Onboarding-Befehl verwendest, hilft er dir dabei, eine `app` einzurichten und sie zu deinem Service hinzuzufügen. Du kannst den Befehl `serverless` auch verwenden, um eine App für einen bestehenden Service zu erstellen, oder eine App im Dashboard erstellen.```text
❯ Create A New App
ecommerce
blog
acmeinc
Skip Adding An App
Die App kann auch manuell in serverless.yml über die app-Eigenschaft festgelegt werden:```yaml
service: my-service
app: my-app
Wenn Sie die Funktionen des Serverless Framework Dashboards nicht nutzen möchten, fügen Sie einfach keine `app`-Eigenschaft hinzu. Apps sind nicht erforderlich.
<br/>
## Einrichten von AWS-Anmeldeinformationen
Um Cloud-Infrastruktur auf AWS bereitzustellen, müssen Sie dem Serverless Framework Zugriff auf Ihre AWS-Anmeldeinformationen gewähren.
Durch Ausführen des `serverless`-Befehls des Serverless Frameworks in einem neuen oder vorhandenen Service können Sie feststellen, ob AWS-Anmeldeinformationen korrekt festgelegt wurden oder abgelaufen sind, oder Sie können sie von Grund auf einrichten.```text
No valid AWS Credentials were found in your environment variables or on your machine. Serverless Framework needs these to access your AWS account and deploy resources to it. Choose an option below to set up AWS Credentials.
❯ Create AWS IAM Role (Easy & Recommended)
Save AWS Credentials in a Local Profile
Skip & Set Later (AWS SSO, ENV Vars)
Wir empfehlen, eine AWS-IAM-Rolle zu erstellen, die im Serverless Framework Dashboard gespeichert wird. Wir werden in naher Zukunft viele Provider-Anmeldedaten unterstützen, und das Dashboard ist ein großartiger Ort, um diese zentral für Ihr Team aufzubewahren, damit Sie organisiert bleiben und die Notwendigkeit entfällt, Anmeldedaten auf den Maschinen Ihrer Teammitglieder zu speichern.
Wenn Sie AWS SSO verwenden, können Sie serverless login aws sso ausführen, um sich über Ihren Browser anzumelden, oder einfach Ihre temporären SSO-Anmeldedaten als Umgebungsvariablen im Terminal einfügen.
Weitere Informationen zum Einrichten Ihrer AWS-Anmeldedaten finden Sie in diesem Leitfaden.
Nachdem Sie mit dem Befehl serverless alles eingerichtet haben, ist es Zeit, Ihren Service in AWS bereitzustellen.
Stellen Sie sicher, dass sich Ihre Terminalsitzung in dem Verzeichnis befindet, das Ihre serverless.yml-Datei enthält. Wenn Sie gerade einen Service erstellt haben, vergessen Sie nicht, mit cd hineinzuwechseln.```text
cd [your-new-service-name]
Das Bereitstellen erstellt/aktualisiert Cloud-Infrastruktur und Code auf AWS, alles gleichzeitig.
Führen Sie den Befehl `deploy` aus:```text
serverless deploy
Weitere Details zur Bereitstellung finden Sie hier.
Viele Serverless-Framework- und Serverless-Entwickler entscheiden sich in der Regel dafür, in der Cloud zu entwickeln, da dies der Realität (d. h. Ihrer Produktionsumgebung) entspricht und die lokale Emulation von Lambda und anderen Infrastrukturabhängigkeiten komplex sein kann.
In Serverless Framework V.4 haben wir einen hybriden Ansatz für die Entwicklung geschaffen, um Entwicklern zu helfen, schnell mit der Genauigkeit der realen Cloud-Umgebung zu entwickeln. Das ist der neue dev-Befehl:```text
serverless dev
Wenn Sie diesen Befehl ausführen, geschieht Folgendes ...
Eine AWS CloudFormation-Bereitstellung wird durchgeführt, um alle AWS Lambda-Funktionen innerhalb Ihres Service geringfügig zu verändern, sodass sie einen leichtgewichtigen Wrapper enthalten.
Sobald diese AWS CloudFormation-Bereitstellung abgeschlossen ist, können Ihre live AWS Lambda-Funktionen innerhalb Ihres Service weiterhin Ereignisse empfangen und innerhalb von AWS aufgerufen werden.
Die Ereignisse werden jedoch sicher und sofort an Ihre Maschine weitergeleitet, und der Code auf Ihrer Maschine wird ausgeführt, anstatt des Codes innerhalb Ihrer live AWS Lambda-Funktionen.
Dies ermöglicht es Ihnen, Änderungen an Ihrem Code vorzunehmen, ohne Ihre gesamte Architektur lokal bereitstellen oder neu erstellen zu müssen, sodass Sie sich schnell entwickeln können.
Logs von Ihrem lokalen Code werden ebenfalls in Ihrer Terminal-`dev`-Sitzung angezeigt.
Sobald Ihr Code abgeschlossen ist, wird die Antwort von Ihrem lokalen Code zurück an Ihre live AWS Lambda-Funktionen gesendet, und diese geben die Antwort zurück – genau wie es eine normale AWS Lambda-Funktion in der Cloud tun würde.
Bitte beachten Sie: `dev` ist nur für Entwicklungs- oder persönliche Stages/Umgebungen gedacht und sollte nicht in Produktion oder in einer Stage ausgeführt werden, in der eine hohe Anzahl von Ereignissen verarbeitet wird.
Sobald Sie Ihre `dev`-Sitzung beendet haben, MÜSSEN Sie erneut mit `serverless deploy` bereitstellen, um Ihre aktuellen lokalen Änderungen zurück zu Ihren live AWS Lambda-Funktionen zu pushen – andernfalls schlagen Ihre AWS Lambda-Funktionen fehl(!)
Weitere Details zum dev-Modus finden Sie [hier](https://www.serverless.com/framework/docs/providers/aws/cli-reference/dev).
<br/>
## Aufrufen
Um Ihre AWS Lambda-Funktion in der Cloud aufzurufen, finden Sie URLs für Ihre Funktionen mit API-Endpunkten in der `serverless deploy`-Ausgabe oder rufen Sie sie über `serverless info` ab. Wenn Ihre Funktionen keine API-Endpunkte haben, können Sie den Befehl `invoke` wie folgt verwenden:```bash
sls invoke -f hello
# Invoke and display logs:
serverless invoke -f hello --log
Weitere Details zum Befehl invoke finden Sie hier.
Um Codeänderungen schnell bereitzustellen, können Sie den Befehl serverless deploy überspringen, der deutlich langsamer ist, da er ein vollständiges AWS-CloudFormation-Update auslöst, und nur Code- und Konfigurationsänderungen für eine bestimmte AWS-Lambda-Funktion bereitstellen.
Um Code- und Konfigurationsänderungen in Sekundenschnelle für einzelne AWS-Lambda-Funktionen bereitzustellen, verwenden Sie den Befehl deploy function und setzen Sie -f [function name in serverless.yml] auf die Funktion, die Sie bereitstellen möchten.```text
serverless deploy function -f my-api
Weitere Details zum Befehl `deploy function` finden Sie [hier](https://www.serverless.com/framework/docs/providers/aws/cli-reference/deploy-function).
<br/>
## Streaming-Logs
Sie können das Serverless Framework verwenden, um Logs von AWS Cloudwatch direkt in Ihr Terminal zu streamen. Verwenden Sie den Befehl `sls logs` in einem separaten Terminalfenster:```bash
sls logs -f [Function name in serverless.yml] -t
Geben Sie eine bestimmte Funktion über die Option -f an und aktivieren Sie das Tailing (d. h. Streaming) über die Option -t.
Viele Serverless-Framework-Nutzer entscheiden sich dafür, ihre gesamte Serverless-Architektur lokal zu emulieren. Bitte beachten Sie, dass die Emulation von AWS Lambda und anderen Cloud-Diensten nie exakt ist und der Prozess komplex sein kann, insbesondere wenn Ihr Projekt und Ihr Team wachsen. Ab V.4 empfehlen wir dringend, den neuen dev-Modus mit persönlichen Stages zu verwenden.
Wenn Sie sich dennoch dazu entscheiden, lokal zu entwickeln, empfehlen wir den folgenden Workflow...
Verwenden Sie den Befehl invoke local, um Ihre Funktion lokal aufzurufen:```bash
sls invoke local -f my-api
Sie können dieser lokalen Invocation auch auf verschiedene Arten Daten übergeben. Hier ist eine davon:```bash
sls invoke local --function functionName --data '{"a":"bar"}'
Weitere Details zum Befehl invoke local findest du hier.
Das Serverless Framework bietet außerdem ein großartiges Plugin, mit dem du einen Server lokal ausführen und AWS API Gateway emulieren kannst. Dies ist das Plugin serverless-offline.
Weitere Details findest du in der serverless-offline-Dokumentation.
Ein großer Vorteil des Serverless Frameworks liegt in seinem Plugin-Ökosystem.
Plugins erweitern oder überschreiben das Serverless Framework, verleihen ihm neue Anwendungsfälle oder Fähigkeiten – und es gibt hunderte davon.
Beachte, dass einige früher beliebte Plugins nicht mehr benötigt werden — ihre Funktionalität ist inzwischen direkt im Framework integriert, darunter Python-Requirements, Custom Domains, AppSync, Prune und API Gateway Service Proxy.
Einige der häufigsten Plugins sind:
Du kannst ein Plugin mit serverless plugin install --name pluginName zu deinem Service hinzufügen. Dabei wird es über npm installiert und in deiner serverless.yml registriert.
Mit Serverless Framework Compose kannst du mit mehreren Serverless-Framework-Services gleichzeitig arbeiten und Folgendes tun...
So könnte eine Projektstruktur aussehen:```bash my-app/ service-a/ src/ ... serverless.yml service-b/ src/ ... serverless.yml
Die Verwendung von Serverless Framework Compose erfordert eine `serverless-compose.yml`-Datei. Darin geben Sie an, welche Services Sie bereitstellen möchten. Sie können außerdem Daten von einem Service zu einem anderen teilen, wodurch ebenfalls eine Bereitstellungsreihenfolge entsteht.```yaml
# serverless-compose.yml
services:
service-a:
path: service-a
service-b:
path: service-b
params:
queueUrl: ${service-a.queueUrl}
Outputs, die von einem anderen Service übernommen werden sollen, werden in der Regel als AWS CloudFormation Outputs definiert:```yaml
resources: Resources: MyQueue: Type: AWS::SQS::Queue # ... Outputs: queueUrl: Value: !Ref MyQueue
Der Wert wird an `service-b` [als Parameter](https://www.serverless.com/framework/docs/guides/parameters) namens `queueUrl` übergeben. Parameter können in der Serverless-Framework-Konfiguration über die Syntax `${param:xxx}` referenziert werden:```yaml
# service-b/serverless.yml
provider:
...
environment:
# Here we inject the queue URL as a Lambda environment variable
SERVICE_A_QUEUE_URL: ${param:queueUrl}
Mehr Details zu Serverless Framework Compose finden Sie hier.
In Serverless Framework V.4 haben wir den Befehl serverless support eingeführt, ein herausragendes Feature, mit dem Sie Problemberichte erstellen oder direkt mit unserem Support-Team in Kontakt treten können. Er fügt automatisch relevanten Kontext hinzu und lässt vertrauliche Details wie Geheimnisse und Kontoinformationen aus, die Sie vor dem Absenden überprüfen können. Dieser optimierte Prozess stellt sicher, dass Ihre Anliegen schnell und sicher bearbeitet werden.
Um diese Funktion zu nutzen, führen Sie nach einem Fehler oder einem beliebigen Befehl Folgendes aus:```bash sls support
Nach jedem Befehl, unabhängig davon, ob er erfolgreich war oder nicht, wird der Kontext in Ihrem aktuellen Arbeitsverzeichnis im Ordner `.serverless` gespeichert.
Um ein neues Support-Ticket zu eröffnen, führen Sie den Befehl `sls support` aus und wählen Sie `Get priority support...`. Optional können Sie den generierten Bericht überprüfen und bearbeiten. Das Eröffnen von Support-Tickets ist nur für Benutzer verfügbar, die ein Abonnement abgeschlossen haben.
Sie können auch Berichte generieren, ohne ein neues Support-Ticket einzureichen. Dies ist nützlich, um Kontext mit anderen zu teilen, Github-Issues zu eröffnen oder mit einem KI-Prompt wie ChatGPT zu verwenden. Führen Sie dazu den Befehl `sls support` aus und wählen Sie `Create a summary report...` oder `Create a comprehensive report..`. Sie können die Eingabeaufforderung überspringen, indem Sie `sls support --summary` oder `sls support --all` ausführen. Dies ist besonders nützlich, um den Bericht in die Zwischenablage zu kopieren (z. B. `sls support --summary | pbcopy`).
<br/>
## Entfernen Sie Ihren Service
Wenn Sie Ihren Service löschen möchten, führen Sie `remove` aus. Dadurch werden alle von Ihrem Projekt erstellten AWS-Ressourcen gelöscht und sichergestellt, dass Ihnen keine unerwarteten Kosten entstehen. Außerdem wird der Service aus dem Serverless Dashboard entfernt.```bash
sls remove
More details on the remove command can be found here.
Hier sind einige hilfreiche Ressourcen, um mit dem Serverless Framework fortzufahren:
serverless.yml-Leitfaden des Serverless Framework zu Ihren Lesezeichen hinzuWir nehmen Sicherheit ernst. Wenn Sie ein Sicherheitsproblem entdecken, melden Sie es bitte verantwortungsvoll, indem Sie uns unter [email protected] kontaktieren. Bitte machen Sie Schwachstellen nicht öffentlich, bevor wir sie behoben haben.
Weitere Details finden Sie in unserer Sicherheitsrichtlinie.
.ts-Handler in Ihren AWS-Lambda-Funktionen in serverless.yml verwenden und sie beim Deployment automatisch erstellen lassen. ESBuild ist jetzt im Framework enthalten und macht dies möglich. Weitere Informationen hier.serverless dev aus, um Ereignisse aus Ihrer Live-Architektur an Ihren lokalen Code weiterzuleiten, sodass Sie schnelle Änderungen ohne Deployment vornehmen können. Weitere Informationen hier.nodejs24.x), Python 3.14 (python3.14) und Java 25 (java25) auf AWS Lambda.ap-southeast-6 in Neuseeland.stages und legen Sie eine default-Konfiguration als Fallback fest.serverless support --ai ausführen, um einen prägnanten Bericht zu Ihrem letzten Fehler mit dem gesamten notwendigen Kontext zu erstellen, optimiert zum Einfügen in KI-Tools wie ChatGPT.serverless wurde neu geschrieben, um beim Einrichten eines neuen oder bestehenden Projekts hilfreicher zu sein.nodejs22.x).