Erste Schritte mit AWS Lambda: Ein Schritt-für-Schritt-Tutorial

AWS Lambda einrichten

Voraussetzungen

• AWS-Konto: Stelle sicher, dass du ein aktives AWS-Kontohast. Melde dich hier an.
• IAM-Benutzer einrichten: Erstelle einen IAM-Benutzer mit Berechtigungen für AWS Lambda. Follow the IAM guide.

Einrichten der Entwicklungsumgebung

• Installiere AWS CLI: Lade die AWS CLI herunter und installiere sie. Konfiguriere sie mit deinen IAM-Anmeldedaten.
• Richte Python oder Node.js ein: Install Python oder Node.js, je nachdem, welche Laufzeit du bevorzugst. AWS Lambda unterstützt mehrere runtimes. In diesem Lernprogramm werden wir Python als Laufzeitumgebung verwenden.

Schritt 1: Zugriff auf die AWS Lambda-Konsole

1. Melde dich bei der AWS Management Console an.
2. Navigiere zu dem Lambda-Dienst.

Navigations-Dashboard in der AWS-Konsole.

Klick auf Lambda im Navigationsmenü um das Dashboard zu sehen:

AWS Lambda Dashboard in der AWS Console.

Schritt 2: Eine neue Funktion erstellen

1. Klicke auf Funktion erstellen.
2. Wähle "Autor von Grund auf".
3. Gib einen Namen für deine Funktion an.
4. Wähle eine Laufzeit (z. B. Python 3.11).
5. Klicken Sie auf die Schaltfläche Funktion erstellen Schaltfläche.

Erstelle eine neue AWS Lambda-Funktion.

Es dauert ein paar Sekunden. Sobald die Funktion erstellt ist, siehst du oben eine Erfolgsmeldung.

Schritt 3: Schreibe deinen Funktionscode

AWS Lambda Browser IDE für die einfache Codebearbeitung.

Schritt 4: Teste deine Lambda-Funktion

An dieser Stelle gibt die Funktion einfach die Zeichenkette "Hallo aus Lambda!".

Es gibt keine Logik, keine Abhängigkeiten, nichts. 

Wir haben ein Python-Skript namens lambda_function.py, das die Funktion lambda_handler() enthält, die einen String zurückgibt. 

Wir können es jetzt testen, indem wir einfach auf die Schaltfläche Testen klicken.

Teste deine AWS-Lambda-Funktion im Browser.

Du kannst das "Event JSON" entfernen, da unsere Funktion keinen Input benötigt. Gib einen Ereignisnamen an und klicke auf die Schaltfläche Aufrufen.

Erfolgreicher Test der AWS Lambda-Funktion.

Die Funktion wurde erfolgreich ausgeführt und die Nachricht wurde zurückgegeben.

Juhu! Wir haben gerade eine serverlose Funktion mit AWS Lambda implementiert. Im Moment macht sie nicht viel, aber sie ist in Betrieb. Jedes Mal, wenn diese Funktion aufgerufen wird, gibt sie einen einfachen String zurück.

Lambda mit Ereignissen triggern

Wie bereits erwähnt, ermöglicht es die AWS Lambda-Architektur, Funktionen als Reaktion auf bestimmte Ereignisse von verschiedenen AWS-Services auszulösen, was sie zu einem vielseitigen Werkzeug für die Automatisierung von Arbeitsabläufen und die Integration von Systemen macht. 

Ereignisse wie Datei-Uploads in einen S3-Bucket, Aktualisierungen in einer DynamoDB-Tabelle oder API-Aufrufe über API Gateway können Lambda-Funktionen aufrufen und ermöglichen so Echtzeitverarbeitung und skalierbare Ausführung.

1. Einen S3-Trigger einrichten

1. Gehe zur S3-Konsole.
2. Wähle einen S3-Bucket aus.
3. Füge unter Eigenschaften eine Ereignisbenachrichtigung hinzu, um deine Lambda-Funktion bei der Erstellung eines Objekts auszulösen.Ereignisbenachrichtigung im AWS S3-Bucket.die Lambda-Funktion zum Auslösen in S3 aus.

Beispielhafte Anwendungsfälle:

• • Ändere die Größe von Bildern, die auf S3 hochgeladen werden, automatisch.
  • Konvertiere Videos in verschiedene Auflösungen oder Formate für das Streaming.
  • Überprüfe Dateiformate, Größen oder Metadaten beim Hochladen.
  • Nutze KI, um Text aus hochgeladenen Dokumenten zu extrahieren (z. B. über Amazon Textract).

2. API Gateway Integration

1. Navigiere zum API-Gateway-Dienst.

Das API Gateway Service Dashboard in der AWS Console.

2. Erstelle eine neue REST-API.

Erstelle eine neue REST-API über API Gateway.

3. Konfiguriere eine Methode (z.B. POST), um deine Lambda-Funktion auszulösen.

Beispielhafte Anwendungsfälle:

• • Baue eine serverlose API für Antworten in Echtzeit.
  • Löse eine Lambda-Funktion aus, um Benutzerdaten in einer Datenbank zu erstellen und zu speichern.
  • Bearbeite POST-Anfragen, um Kundenbestellungen in Echtzeit zu bearbeiten und zu validieren
  • Löse eine Lambda-Funktion aus, um Daten aus einer Datenbank oder API abzufragen und zurückzugeben.

Bereitstellen und Überwachen von AWS Lambdas

Die Bereitstellung von AWS Lambda-Funktionen ist unkompliziert und kann je nach Bedarf mit verschiedenen Methoden erfolgen, z. B. mit der AWS Management Console für manuelle Bereitstellungen oder mit der AWS CLI für automatische Bereitstellungen.

1. Manuelle Bereitstellung über die AWS-Konsole

Die AWS Management Console bietet eine intuitive Weboberfläche für die Bereitstellung von Lambda-Funktionen. Diese Methode ist ideal für kleine Projekte oder schnelle Änderungen. Hier erfährst du, wie du eine Lambda-Funktion über die Konsole bereitstellst:

1. Erstelle oder bearbeite eine Funktion:
• Melde dich bei der AWS Management Console an.
• Navigiere zu AWS Lambda.
• Klicke auf Funktion erstellen, um eine neue Funktion einzurichten oder wähle eine bestehende Funktion aus, die du aktualisieren möchtest.
2. Lade deinen Code hoch:
• Wähle Upload von und wähle eine .zip-Datei oder ein Container-Image.
• Du kannst deinen Funktionscode direkt im integrierten Code-Editor für die Entwicklung in kleinem Rahmen bearbeiten.
3. Richte die Funktion ein:
• Definiere Umgebungsvariablen, Speicherzuweisung und Timeout-Grenzen je nach Anwendungsfall.
• Füge mithilfe von AWS IAM-Rollen die erforderlichen Berechtigungen hinzu, damit die Funktion mit anderen AWS-Diensten interagieren kann.
4. Setze die Änderungen ein:
• Klicke auf Verteilen, um deine Änderungen zu speichern und zu aktivieren.
• Verwende die Testfunktion, um die Funktion manuell aufzurufen und zu überprüfen, ob sie wie erwartet funktioniert.

2. Automatisierte Bereitstellung mit der AWS CLI 

Die AWS CLI ist eine effiziente Methode zur Bereitstellung und Aktualisierung von Lambda-Funktionen für die Automatisierung oder häufige Aktualisierungen. Es sorgt für Konsistenz und reduziert manuelle Fehler, vor allem in größeren Projekten oder CI/CD-Pipelines.

Schritt 1 - Bereite das Einsatzpaket vor

Packe deinen Code und deine Abhängigkeiten in eine .zip-Datei. Zum Beispiel:

zip -r my-deployment-package.zip .

Schritt 2 - Einsetzen der Funktion über CLI

Verwenden Sie die update-function-code Befehl, um den neuen Code auf AWS Lambda hochzuladen:

aws lambda update-function-code \
    --function-name MyFunction \
    --zip-file fileb://my-deployment-package.zip

Schritt 3 - Überprüfe den Einsatz

Überprüfe nach dem Einsatz den Status der Funktion mit:

aws lambda get-function --function-name MyFunction

Dieser Befehl ruft die Konfiguration der Funktion ab und bestätigt den Einsatz.

Überwachung von Lambda mit CloudWatch

Die Überwachung ist entscheidend, um sicherzustellen, dass deine Lambda-Funktionen effizient laufen, Fehler elegant behandeln und die Leistungserwartungen erfüllen. AWS Lambda integriertsich mit Amazon CloudWatch, umÜberwachungs- und Protokollierungsfunktionen bereitzustellen.

Amazon CloudWatch sammelt automatisch wichtige Metriken für deine Lambda-Funktionen und zeigt sie an. Diese Metriken helfen dir, die Leistung deiner Funktion zu analysieren und Probleme zu beheben.

Zu überwachende Metriken:

1. Aufforderungen: Verfolgt, wie oft deine Funktion aufgerufen wird. Hilft dir, Verkehrsmuster und Nutzungstrends zu verstehen.
2. Fehler: Zeigt die Anzahl der Fehler bei der Ausführung der Funktion an. Nutze dies, um Fehlerquoten zu ermitteln und Probleme zu beheben.
3. Dauer: Misst die Zeit, die für die Ausführung der Funktion benötigt wird. Dies ist entscheidend für die Optimierung der Leistung und die Verwaltung der Kosten.
4. Drosseln: Zeigt die Anzahl der Aufrufe an, die aufgrund des Erreichens von Gleichzeitigkeitsgrenzen gedrosselt wurden.

Zugriff auf Metriken:

• Navigiere zur CloudWatch Metrics-Konsole.
• Wähle Lambda aus der Liste der Namespaces aus.
• Wähle die Funktion, die du überwachen willst, um detaillierte Metriken anzuzeigen.

AWS Lambda Best Practices

Jetzt, wo du deine erste Lambda-Funktion eingesetzt hast, ist es nützlich, einige Best Practices für zukünftige, komplexere Projekte zu kennen. In diesem Abschnitt stelle ich einige bewährte Verfahren vor, die du beachten solltest.

1. Optimiere die Funktion Kaltstarts

Kaltstarts treten auf, wenn eine Lambda-Funktion aufgerufen wird, nachdem sie im Leerlauf war, was zu einer leichten Latenz führt, da AWS die Ausführungsumgebung bereitstellt. Auch wenn AWS diesen Aufwand minimiert, gibt es Schritte, die du unternehmen kannst, um die Kaltstartzeit zu verkürzen:

Kleinere Einsatzpakete verwenden

• Halte dein Bereitstellungspaket schlank, indem du nur die notwendigen Abhängigkeiten einfügst.
• Nutze Tools wie AWS Lambda Layers, um gemeinsame Bibliotheken (z. B. AWS SDK) für Funktionen zu nutzen, ohne sie in einzelne Pakete einzubinden.
• Komprimiere und minifiziere den Code, wo immer es möglich ist, besonders bei JavaScript- oder Python-basierten Funktionen.

Vermeide umfangreiche Initialisierungen in deiner Funktion

Verschiebe ressourcenintensive Initialisierungen (z. B. von Datenbankverbindungen, API-Clients oder Bibliotheken von Drittanbietern) außerhalb des Funktionshandlers. Dadurch wird sichergestellt, dass der Code nur einmal pro Umgebung ausgeführt und über mehrere Aufrufe hinweg wiederverwendet wird.

Nutzung der bereitgestellten Gleichzeitigkeit

Für kritische Funktionen, die auf Latenzzeiten angewiesen sind, solltest du Provisioned Concurrency verwenden, um die Ausführungsumgebung für die Bearbeitung von Anfragen bereitzuhalten. Das verursacht zwar zusätzliche Kosten, garantiert aber niedrige Latenzzeiten für Workloads mit hoher Priorität.

2. Funktionen zustandslos halten

Die Zustandslosigkeit ist ein grundlegendes Prinzip der serverlosen Architektur und stellt sicher, dass deine Anwendung nahtlos skaliert:

Vermeiden Sie die Abhängigkeit von In-Memory-Daten

Lambda-Funktionen sind ephemer, d.h. ihre Ausführungsumgebung ist temporär und bleibt möglicherweise nicht über mehrere Aufrufe hinweg bestehen. Anstatt sich auf In-Memory-Variablen zu verlassen, solltest du Statusinformationen in externen Systemen wie DynamoDB, S3 oder Redis speichern.

Idempotenz aktivieren

Gestalte deine Funktionen so, dass sie mit doppelten Ereignissen gut umgehen können. Verwende eindeutige Bezeichner für Anfragen und überprüfe Protokolle oder Datenbanken, um sicherzustellen, dass ein und dasselbe Ereignis nicht mehrfach verarbeitet wird.

3. Umgebungsvariablen verwenden

Umgebungsvariablen sind ein sicherer und bequemer Weg, um deine Lambda-Funktionen zu konfigurieren:

Sensible Informationen speichern

• Speichere API-Schlüssel, Datenbankverbindungsstrings und andere Geheimnisse als Umgebungsvariablen. AWS Lambda verschlüsselt diese Variablen im Ruhezustand und entschlüsselt sie während der Ausführung.
• Für zusätzliche Sicherheit kannst du AWS Secrets Manager oder Systems Manager Parameter Store verwenden, um Geheimnisse dynamisch zu verwalten.

Vereinfache das Konfigurationsmanagement

Verwende Umgebungsvariablen, um Konfigurationen wie Protokollstufen, Regionseinstellungen oder URLs von Drittanbieterdiensten zu verwalten. Dadurch sind keine fest kodierten Werte mehr nötig, und deine Funktion ist in verschiedenen Umgebungen (z. B. Dev, Staging, Prod) besser einsetzbar.

Fazit

Dieses Tutorial bietet eine Anleitung für den Einstieg in AWS Lambda, vom Verständnis der Funktionen und Anwendungsfälle bis hin zur effektiven Bereitstellung und Überwachung der Funktionen. Du kannst robuste und wartbare serverlose Anwendungen erstellen, indem du dich an Best Practices hältst, wie z.B. die Optimierung von Kaltstarts, zustandslose Funktionen und die Verwendung von Umgebungsvariablen.

Mit AWS Lambda kannst du moderne, ereignisgesteuerte Architekturen aufbauen, die sich in das AWS-Ökosystem integrieren. Wenn du mehr darüber erfahren möchtest, empfehle ich dir die AWS-Kurse von DataCamp:ommend.