Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erste Schritte mit Beispielanwendungen und -mustern
Die folgenden Ressourcen können verwendet werden, um schnell Serverless-Apps zu erstellen und bereitzustellen, die einige gängige Lambda-Anwendungsfälle implementieren. Für jede der Beispiel-Apps bieten wir Anweisungen, um Ressourcen entweder manuell mithilfe von zu erstellen und zu konfigurieren oder AWS Serverless Application Model um die Ressourcen mithilfe von IaC bereitzustellen. AWS-Managementkonsole Folgen Sie den Anweisungen auf der Konsole, um mehr über die Konfiguration der einzelnen AWS Ressourcen für jede App zu erfahren, oder verwenden Sie sie, AWS SAM um Ressourcen schnell bereitzustellen, wie Sie es in einer Produktionsumgebung tun würden.
## Dateiverarbeitung
+ **[PDF-Verschlüsselungsanwendung](file-processing-app.md)**: Erstellen Sie eine Serverless-Anwendung, die PDF-Dateien beim Hochladen in einen Bucket in Amazon Simple Storage Service verschlüsselt und in einem anderen Bucket speichert. Dies ist nützlich, um vertrauliche Dokumente beim Hochladen zu schützen.
+ **[Bildanalyseanwendung](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-example-s3.html)**: Erstellen Sie eine Serverless-Anwendung, die mithilfe von Amazon Rekognition Text aus Bildern extrahiert. Dies ist nützlich für die Dokumentverarbeitung, Inhaltsmoderation und automatisierte Bildanalyse.
## Datenbankintegration
+ **[Queue-to-Database Anwendung](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-lambda-tutorial.html)**: Erstellen Sie eine serverlose Anwendung, die Warteschlangennachrichten in eine Amazon RDS-Datenbank schreibt. Dies ist nützlich für die Verarbeitung von Benutzerregistrierungen und die Bearbeitung von Auftragseinsendungen.
+ **[Datenbankereignis-Handler](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-example-ddb.html)**: Erstellen Sie eine Serverless-Anwendung, die auf Änderungen in Amazon-DynamoDB-Tabellen reagiert. Dies ist nützlich für Audit-Protokollierung, Datenreplikation und automatisierte Workflows.
## Geplante Aufgaben
+ **[Anwendung zur Datenbankwartung](scheduled-task-app.md)**: Erstellen Sie eine Serverless-Anwendung, die mithilfe eines Cron-Zeitplans automatisch Einträge, die älter als 12 Monate sind, aus einer Amazon-DynamoDB-Tabelle löscht. Dies ist für die automatisierte Datenbankwartung und das Datenlebenszyklusmanagement nützlich.
+ **[Erstellen Sie eine EventBridge geplante Regel für Lambda-Funktionen](https://docs.aws.amazon.com/eventbridge/latest/userguide/run-lambda-schedule.html)**: Verwenden Sie geplante Ausdrücke für Regeln EventBridge , um eine Lambda-Funktion nach einem Zeitplan auszulösen. Dieses Format verwendet die Cron-Syntax und kann mit einer Granularität von einer Minute festgelegt werden.
## Workflows mit langer Laufzeit
+ **[Anwendung zur Auftragsabwicklung](order-processing-app.md)**: Erstellen Sie eine serverlose Anwendung mit Durable Functions, die komplexe Auftragsabwicklung, einschließlich Zahlungsabwicklung, Inventarprüfungen und Versandkoordination, abwickelt. Dieses Beispiel zeigt, wie Workflows erstellt werden, die über einen längeren Zeitraum ausgeführt werden können und gleichzeitig den Status beibehalten.
## Weitere Ressourcen
Die folgenden Ressourcen enthalten weitere Informationen zu Lambda und zur Entwicklung von Serverless-Anwendungen:
+ **[Serverless Land](https://serverlessland.com/)**: Eine Bibliothek mit ready-to-use Mustern für die Erstellung serverloser Apps. Es hilft Entwicklern, Anwendungen mithilfe von AWS Diensten wie Lambda, API Gateway und EventBridge schneller zu erstellen. Die Website bietet vorgefertigte Lösungen und bewährte Methoden, die die Entwicklung von Serverless-Systemen erleichtern.
+ **[Lambda-Beispielanwendungen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-samples.html)**: Anwendungen, die im GitHub Repository für dieses Handbuch verfügbar sind. Diese Beispiele demonstrieren die Verwendung verschiedener Sprachen und AWS Dienste. Jede Beispielanwendung enthält Skripts für die einfache Bereitstellung und Bereinigung und unterstützende Ressourcen.
+ **[Codebeispiele für die Verwendung von Lambda AWS SDKs](https://docs.aws.amazon.com/lambda/latest/dg/service_code_examples.html)**: Beispiele, die Ihnen zeigen, wie Sie Lambda mit AWS Software Development Kits verwenden ()SDKs. Diese Beispiele beinhalten Grundlagen, Aktionen, Szenarien und Beiträge aus der AWS Community. Beispiele umfassen grundlegende Operationen, einzelne Servicefunktionen und spezifische Aufgaben, bei denen mehrere Funktionen oder AWS Dienste verwendet werden.
# Erstellen Sie eine Serverless-Dateiverarbeitungs-App
Einer der häufigsten Anwendungsfälle für Lambda ist die Ausführung von Dateiverarbeitungsaufgaben. Sie können beispielsweise eine Lambda-Funktion verwenden, um automatisch PDF-Dateien aus HTML-Dateien oder Bildern zu erstellen oder um Miniaturansichten zu erstellen, wenn ein Benutzer ein Bild hochlädt.
In diesem Beispiel erstellen Sie eine App, die PDF-Dateien automatisch verschlüsselt, wenn sie in einen Amazon Simple Storage Service (Amazon S3)-Bucket uploaden. Um diese Anwendung zu implementieren, erstellen Sie die folgenden Ressourcen:
+ Ein S3-Bucket, in das Benutzer PDF-Dateien hochladen können
+ Eine Lambda-Funktion in Python, die die hochgeladene Datei liest und eine verschlüsselte, passwortgeschützte Version davon erstellt
+ Ein zweiter S3-Bucket für Lambda zum Speichern der verschlüsselten Datei
Sie erstellen auch eine AWS Identity and Access Management (IAM-) Richtlinie, um Ihrer Lambda-Funktion die Erlaubnis zu erteilen, Lese- und Schreibvorgänge auf Ihren S3-Buckets durchzuführen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/ExampleApps/file_process_resources.png)
**Tipp**
Wenn Sie ganz neu bei Lambda sind, empfehlen wir Ihnen, vor der Erstellung dieser Beispiel-App mit dem Tutorial [Erstellen Sie Ihre erste Lambda-Funktion](getting-started.md) zu beginnen.
Sie können Ihre App manuell bereitstellen, indem Sie Ressourcen mit dem AWS-Managementkonsole oder dem AWS Command Line Interface () erstellen und konfigurieren.AWS CLI Sie können die App auch mithilfe von AWS Serverless Application Model (AWS SAM) bereitstellen. AWS SAM ist ein Tool für Infrastruktur als Code (IaC). Mit IaC erstellen Sie Ressourcen nicht manuell, sondern definieren sie im Code und stellen sie dann automatisch bereit.
Wenn Sie mehr über die Verwendung von Lambda mit IaC erfahren möchten, bevor Sie diese Beispiel-App bereitstellen, finden Sie unter [Verwenden von Lambda mit Infrastructure as Code (IaC)](foundation-iac.md).
## Erstellen der Quellcodedateien für die Lambda-Funktion
Erstellen Sie die folgenden Dateien in Ihrem Projektverzeichnis:
+ `lambda_function.py` - Python-Funktionscode für die Lambda-Funktion, die die Dateiverschlüsselung durchführt
+ `requirements.txt` - eine Manifestdatei, die die Abhängigkeiten definiert, die Ihr Python-Funktionscode benötigt
Erweitern Sie die folgenden Abschnitte, um den Code anzusehen und mehr über die Rolle der einzelnen Dateien zu erfahren. Um die Dateien auf Ihrem lokalen Computer zu erstellen, kopieren Sie entweder den folgenden Code und fügen Sie ihn ein, oder laden Sie die Dateien aus dem [aws-lambda-developer-guide GitHub Repository](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/file-processing-python) herunter.
### Python-Funktionscode
Kopieren Sie den folgenden Code und fügen Sie ihn in eine Datei mit dem Namen `lambda_function.py` ein.
```
from pypdf import PdfReader, PdfWriter
import uuid
import os
from urllib.parse import unquote_plus
import boto3
# Create the S3 client to download and upload objects from S3
s3_client = boto3.client('s3')
def lambda_handler(event, context):
# Iterate over the S3 event object and get the key for all uploaded files
for record in event['Records']:
bucket = record['s3']['bucket']['name']
key = unquote_plus(record['s3']['object']['key']) # Decode the S3 object key to remove any URL-encoded characters
download_path = f'/tmp/{uuid.uuid4()}.pdf' # Create a path in the Lambda tmp directory to save the file to
upload_path = f'/tmp/converted-{uuid.uuid4()}.pdf' # Create another path to save the encrypted file to
# If the file is a PDF, encrypt it and upload it to the destination S3 bucket
if key.lower().endswith('.pdf'):
s3_client.download_file(bucket, key, download_path)
encrypt_pdf(download_path, upload_path)
encrypted_key = add_encrypted_suffix(key)
s3_client.upload_file(upload_path, f'{bucket}-encrypted', encrypted_key)
# Define the function to encrypt the PDF file with a password
def encrypt_pdf(file_path, encrypted_file_path):
reader = PdfReader(file_path)
writer = PdfWriter()
for page in reader.pages:
writer.add_page(page)
# Add a password to the new PDF
writer.encrypt("my-secret-password")
# Save the new PDF to a file
with open(encrypted_file_path, "wb") as file:
writer.write(file)
# Define a function to add a suffix to the original filename after encryption
def add_encrypted_suffix(original_key):
filename, extension = original_key.rsplit('.', 1)
return f'{filename}_encrypted.{extension}'
```
**Anmerkung**
In diesem Beispielcode ist ein Passwort für die verschlüsselte Datei (`my-secret-password`) fest im Funktionscode codiert. Schließen Sie in einer Produktionsanwendung keine sensiblen Informationen wie Passwörter in Ihren Funktionscode ein. [Erstellen Sie stattdessen ein AWS Secrets Manager Geheimnis](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) und [verwenden Sie dann die Lambda-Erweiterung AWS Parameters and Secrets](with-secrets-manager.md), um Ihre Anmeldeinformationen in Ihrer Lambda-Funktion abzurufen.
Der Python-Funktionscode enthält drei Funktionen: die [Handler-Funktion](python-handler.md), die Lambda ausführt, wenn Ihre Funktion aufgerufen wird und zwei separate Funktionen mit dem Namen `add_encrypted_suffix` und `encrypt_pdf`, die der Handler aufruft, um die PDF-Verschlüsselung durchzuführen.
Wenn Ihre Funktion von Amazon S3 aufgerufen wird, übergibt Lambda ein JSON-formatiertes *Ereignis*argument an die Funktion, das Details zu dem Ereignis enthält, das den Aufruf verursacht hat. In diesem Fall umfassen die Informationen den Namen des S3-Buckets und die Objektschlüssel für die hochgeladenen Dateien. Weitere Informationen zum Format des Ereignisobjekts für Amazon S3 finden Sie unter [Verarbeitung von Amazon-S3-Ereignisbenachrichtigungen mit Lambda](with-s3.md).
Ihre Funktion verwendet dann die AWS SDK für Python (Boto3) , um die im Ereignisobjekt angegebenen PDF-Dateien in ihr lokales temporäres Speicherverzeichnis herunterzuladen, bevor sie sie mithilfe der Bibliothek verschlüsselt. [https://pypi.org/project/pypdf/](https://pypi.org/project/pypdf/)
Schließlich verwendet die Funktion das Boto3-SDK, um die verschlüsselte Datei in Ihrem S3-Ziel-Bucket zu speichern.
### `requirements.txt`-Manifestdatei
Kopieren Sie den folgenden Code und fügen Sie ihn in eine Datei mit dem Namen `requirements.txt` ein.
```
boto3
pypdf
```
In diesem Beispiel hat Ihr Funktionscode nur zwei Abhängigkeiten, die nicht Teil der Standard-Python-Bibliothek sind: das SDK für Python (Boto3) und das `pypdf`-Paket, das die Funktion zur Durchführung der PDF-Verschlüsselung verwendet.
**Anmerkung**
Eine Version des SDK für Python (Boto3) ist Teil der Lambda-Laufzeit, sodass Ihr Code ausgeführt werden kann, ohne Boto3 zum Bereitstellungspaket Ihrer Funktion hinzuzufügen. Um jedoch die volle Kontrolle über die Abhängigkeiten Ihrer Funktion zu behalten und mögliche Probleme mit Versionsfehlern zu vermeiden, empfiehlt es sich für Python, alle Funktionsabhängigkeiten in das Bereitstellungspaket Ihrer Funktion aufzunehmen. Weitere Informationen hierzu finden Sie unter [Laufzeitabhängigkeiten in Python](python-package.md#python-package-dependencies).
## Bereitstellen der App
Sie können die Ressourcen für diese Beispiel-App entweder manuell oder mithilfe AWS SAM von erstellen und bereitstellen. In einer Produktionsumgebung empfehlen wir, ein IaC-Tool zu verwenden, AWS SAM um ganze serverlose Anwendungen schnell und wiederholbar bereitzustellen, ohne manuelle Prozesse zu verwenden.
### Stellen Sie die Ressourcen manuell bereit
So stellen Sie Ihre App manuell bereit:
+ Erstellen Sie Quell- und Ziel-Amazon-S3-Buckets
+ Erstellen Sie eine Lambda-Funktion, die eine PDF-Datei verschlüsselt und die verschlüsselte Version in einem S3-Bucket speichert
+ Konfigurieren Sie einen Lambda-Auslöser, der Ihre Funktion aufruft, wenn Objekte in Ihren Quell-Bucket hochgeladen werden
Stellen Sie zunächst sicher, dass [Python](https://www.python.org/downloads/) auf Ihrer Build-Maschine installiert ist.
#### Erstellen Sie zwei S3-Buckets
Erstellen Sie zuerst zwei S3-Buckets. Der erste Bucket ist der Quell-Bucket, in den Sie Ihre PDF-Dateien hochladen. Der zweite Bucket wird von Lambda zum Speichern der verschlüsselten Datei verwendet, wenn Sie Ihre Funktion aufrufen.
------
#### [ Console ]
**So erstellen Sie die S3-Buckets (Konsole)**
1. Öffnen Sie die Seite [Allzweck-Buckets](https://console.aws.amazon.com/s3/buckets) in der Amazon-S3-Konsole.
1. Wählen Sie die Option aus, die Ihrem AWS-Region geografischen Standort am nächsten liegt. Sie können Ihre Region mithilfe der Dropdown-Liste am oberen Bildschirmrand ändern.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/console_region_select.png)
1. Wählen Sie **Create Bucket** (Bucket erstellen) aus.
1. Führen Sie unter **Allgemeine Konfiguration** die folgenden Schritte aus:
1. Stellen Sie sicher, dass für **Bucket-Typ** die Option **Allzweck** ausgewählt ist.
1. Geben Sie für den **Bucket-Namen** einen global eindeutigen Namen ein, der den [Regeln für die Bucket-Benennung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) von Amazon S3 entspricht. Bucket-Namen dürfen nur aus Kleinbuchstaben, Zahlen, Punkten (.) und Bindestrichen (-) bestehen.
1. Belassen Sie alle anderen Optionen auf ihren Standardwerten und wählen Sie **Bucket erstellen** aus.
1. Wiederholen Sie die Schritte 1 bis 4, um Ihren Ziel-Bucket zu erstellen. Geben Sie unter **Bucket-Name** den Namen `amzn-s3-demo-bucket-encrypted` ein. `amzn-s3-demo-bucket` ist hierbei der Name des Quell-Buckets, den Sie soeben erstellt haben.
------
#### [ AWS CLI ]
Stellen Sie zunächst sicher, dass die [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) auf Ihrer Build-Maschine installiert ist.
**So erstellen Sie die Amazon-S3-Buckets (AWS CLI)**
1. Führen Sie den folgenden CLI-Befehl aus, um Ihren Quell-Bucket zu erstellen. Der gewählte Name für Ihren Bucket muss global eindeutig sein und den [Regeln für die Benennung von Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) von Amazon S3 entsprechen. Namen dürfen nur Kleinbuchstaben, Zahlen, Punkte (.) und Bindestriche (-) enthalten. Wählen Sie für `region` und `LocationConstraint` die [AWS-Region](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html) aus, die Ihrem geografischen Standort am nächsten ist.
```
aws s3api create-bucket --bucket amzn-s3-demo-bucket --region us-east-2 \
--create-bucket-configuration LocationConstraint=us-east-2
```
Später im Tutorial müssen Sie Ihre Lambda-Funktion im selben Verzeichnis AWS-Region wie in Ihrem Quell-Bucket erstellen. Notieren Sie sich also die Region, die Sie ausgewählt haben.
1. Führen Sie den folgenden Befehl aus, um Ihren Ziel-Bucket zu erstellen. Verwenden Sie für den Bucket-Namen `amzn-s3-demo-bucket-encrypted`. `amzn-s3-demo-bucket` ist hierbei der Name des Quell-Buckets, den Sie in Schritt 1 erstellt haben. Wählen Sie für `region` und dasselbe aus`LocationConstraint`, das AWS-Region Sie zur Erstellung Ihres Quell-Buckets verwendet haben.
```
aws s3api create-bucket --bucket amzn-s3-demo-bucket-encrypted --region us-east-2 \
--create-bucket-configuration LocationConstraint=us-east-2
```
------
#### Erstellen einer Ausführungsrolle
Eine Ausführungsrolle ist eine IAM-Rolle, die einer Lambda-Funktion Zugriff AWS-Services und Ressourcen gewährt. Fügen Sie die [AWS -verwaltete Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) `AmazonS3FullAccess` an, um Ihrer Funktion Lese- und Schreibzugriff auf Amazon S3 zu erteilen.
------
#### [ Console ]
**So erstellen Sie eine Ausführungsrolle und fügen die verwaltete `AmazonS3FullAccess`-Richtlinie an (Konsole)**
1. Öffnen Sie die Seite [Roles (Rollen)](https://console.aws.amazon.com/iam/home/roles) in der IAM-Konsole.
1. Wählen Sie **Rolle erstellen** aus.
1. Wählen Sie unter **Vertrauenswürdiger Entitätstyp** die Option **AWS -Service** und dann für **Anwendungsfall** die Option **Lambda** aus.
1. Wählen Sie **Weiter** aus.
1. Fügen Sie die verwaltete `AmazonS3FullAccess`-Richtlinie wie folgt hinzu:
1. Geben Sie unter **Berechtigungsrichtlinien** die Zeichenfolge **AmazonS3FullAccess** in das Suchfeld ein.
1. Aktivieren Sie das Kontrollkästchen neben der Richtlinie.
1. Wählen Sie **Weiter** aus.
1. Geben Sie unter **Rollendetails** für **Rollenname** den Namen **LambdaS3Role** ein.
1. Wählen Sie **Rolle erstellen** aus.
------
#### [ AWS CLI ]
**So erstellen Sie eine Ausführungsrolle und fügen die `AmazonS3FullAccess`-verwaltete Richtlinie an (AWS CLI)**
1. Speichern Sie den folgenden JSON-Code in einer Datei mit dem Namen `trust-policy.json`: Diese Vertrauensrichtlinie ermöglicht es Lambda, die Berechtigungen der Rolle zu verwenden, indem dem Dienstprinzipal die `lambda.amazonaws.com` Erlaubnis erteilt wird, die `AssumeRole` Aktion AWS -Security-Token-Service (AWS STS) aufzurufen.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Führen Sie in dem Verzeichnis, in dem Sie das JSON-Vertrauensrichtliniendokument gespeichert haben, den folgenden CLI-Befehl aus, um die Ausführungsrolle zu erstellen:
```
aws iam create-role --role-name LambdaS3Role --assume-role-policy-document file://trust-policy.json
```
1. Führen Sie den folgenden CLI-Befehl aus, um die `AmazonS3FullAccess`-verwaltete Richtlinie anzuhängen.
```
aws iam attach-role-policy --role-name LambdaS3Role --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
```
------
#### Erstellen des Bereitstellungspakets für die Funktion
Um Ihre Funktion zu erstellen, erstellen Sie ein *Bereitstellungspaket*, das Ihren Funktionscode und die zugehörigen Abhängigkeiten enthält. Bei der hier verwendeten Anwendung verwendet Ihr Funktionscode eine separate Bibliothek für die PDF-Verschlüsselung.
**Erstellen des Bereitstellungspakets**
1. Navigieren Sie zu dem Projektverzeichnis mit den `lambda_function.py` `requirements.txt` Dateien, die Sie GitHub zuvor erstellt oder heruntergeladen haben, und erstellen Sie ein neues Verzeichnis mit dem Namen`package`.
1. Installieren Sie die in der `requirements.txt`-Datei angegebenen Abhängigkeiten in Ihrem `package`-Verzeichnis, indem Sie den folgenden Befehl ausführen.
```
pip install -r requirements.txt --target ./package/
```
1. Erstellen Sie eine .zip-Datei, die Ihren Anwendungscode und seine Abhängigkeiten enthält. Führen Sie unter Linux oder MacOS die folgenden Befehle über Ihre Befehlszeilenschnittstelle aus:
```
cd package
zip -r ../lambda_function.zip .
cd ..
zip lambda_function.zip lambda_function.py
```
Verwenden Sie unter Windows Ihr bevorzugtes ZIP-Tool, um die `lambda_function.zip`-Datei zu erstellen. Achten Sie darauf, dass sich die Datei `lambda_function.py` und die Ordner, die Ihre Abhängigkeiten enthalten, im Stammverzeichnis der ZIP-Datei befinden.
Sie können Ihr Bereitstellungspaket auch in einer virtuellen Python-Umgebung erstellen. Siehe [Arbeiten mit ZIP-Dateiarchiven und Python-Lambda-Funktionen](python-package.md)
#### So erstellen Sie die Lambda-Funktion:
Sie verwenden jetzt das Bereitstellungspaket, das Sie im vorherigen Schritt erstellt haben, um Ihre Lambda-Funktion bereitzustellen.
------
#### [ Console ]
**So erstellen Sie die Funktion (Konsole)**
Wenn Sie Ihre Lambda-Funktion über die Konsole erstellen möchten, erstellen Sie zunächst eine Basisfunktion, die etwas Hello-World-Code enthält. Anschließend ersetzen Sie diesen Code durch Ihren eigenen Funktionscode, indem Sie die im vorherigen Schritt erstellte ZIP- oder Datei hochladen.
Um sicherzustellen, dass Ihre Funktion beim Verschlüsseln großer PDF-Dateien nicht zu einem Timeout kommt, konfigurieren Sie die Speicher- und Timeout-Einstellungen der Funktion. Sie legen auch das Protokollformat der Funktion auf JSON fest. Die Konfiguration von Protokollen im JSON-Format ist erforderlich, wenn Sie das mitgelieferte Testskript verwenden, damit es den Aufrufstatus der Funktion aus den CloudWatch Protokollen lesen kann, um den erfolgreichen Aufruf zu bestätigen.
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Stellen Sie sicher, dass Sie in demselben Modus arbeiten, in dem AWS-Region Sie Ihren S3-Bucket erstellt haben. Sie können Ihre Region mithilfe der Dropdown-Liste am oberen Bildschirmrand ändern.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/console_region_select.png)
1. Wählen Sie **Funktion erstellen**.
1. Wählen Sie **Author from scratch** aus.
1. Führen Sie unter **Basic information** (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie für **Function name** (Funktionsname) `EncryptPDF` ein.
1. Wählen Sie für **Laufzeit** die Option **Python 3.12** aus.
1. Wählen Sie für **Architektur** **x86\$164** aus.
1. Fügen Sie die Ausführungsrolle, die Sie im vorherigen Schritt erstellt haben, wie folgt hinzu:
1. Erweitern Sie den Abschnitt **Ändern der standardmäßigen Ausführungsrolle**.
1. Wählen Sie **Eine vorhandene Rolle verwenden** aus.
1. Wählen Sie unter **Bestehende Rolle** Ihre Rolle (`LambdaS3Role`) aus.
1. Wählen Sie **Funktion erstellen**.
**So laden Sie den Funktionscode hoch (Konsole)**
1. Wählen Sie im Bereich **Codequelle** die Option **Hochladen von** aus.
1. Wählen Sie die **ZIP-Datei** aus.
1. Klicken Sie auf **Upload**.
1. Wählen Sie in der Dateiauswahl Ihre ZIP-Datei und anschließend **Öffnen** aus.
1. Wählen Sie **Speichern**.
**Um den Funktionsspeicher und das Timeout (Konsole) zu konfigurieren**
1. Wählen Sie die Registerkarte **Konfiguration** für Ihre Funktion.
1. Wählen Sie im Bereich **Allgemeine Konfiguration** die Option **Bearbeiten** aus.
1. Stellen Sie **Speicher** auf 256 MB und **Timeout** auf 15 Sekunden ein.
1. Wählen Sie **Speichern**.
**So konfigurieren Sie das Protokollformat (Konsole)**
1. Wählen Sie die Registerkarte **Konfiguration** für Ihre Funktion.
1. Wählen Sie **Überwachungs- und Betriebstools** aus.
1. Wählen Sie im Bereich **Protokollierungskonfiguration** die Option **Bearbeiten** aus.
1. Wählen Sie für die **Konfiguration der Protokollierung** **JSON** aus.
1. Wählen Sie **Speichern**.
------
#### [ AWS CLI ]
**So erstellen Sie die Funktion (AWS CLI)**
+ Führen Sie den folgenden Befehl in dem Verzeichnis aus, das Ihre `lambda_function.zip`-Datei enthält. Ersetzen Sie `region` für den Parameter `us-east-2` durch die Region, in der Sie Ihre S3-Buckets erstellt haben.
```
aws lambda create-function --function-name EncryptPDF \
--zip-file fileb://lambda_function.zip --handler lambda_function.lambda_handler \
--runtime python3.12 --timeout 15 --memory-size 256 \
--role arn:aws:iam::123456789012:role/LambdaS3Role --region us-east-2 \
--logging-config LogFormat=JSON
```
------
#### Konfigurieren von Amazon-S3-Auslöser zum Aufrufen der Funktion
Damit Ihre Lambda-Funktion ausgeführt wird, wenn Sie eine Datei in Ihren Quell-Bucket hochladen, müssen Sie einen Auslöser für Ihre Funktion konfigurieren. Sie können den Amazon-S3-Auslöser entweder über die Konsole oder mithilfe der AWS CLI konfigurieren.
**Wichtig**
Mit diesem Verfahren wird der S3-Bucket so konfiguriert, dass die Funktion jedes Mal aufgerufen wird, wenn ein Objekt im Bucket erstellt wird. Konfigurieren Sie dieses Verhalten nur für den Quell-Bucket. Wenn Ihre Lambda-Funktion Objekte in dem Bucket erstellt, der sie aufruft, kann es passieren, dass Ihre Funktion [kontinuierlich in einer Schleife aufgerufen](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway) wird. Dies kann dazu führen, dass Ihnen AWS-Konto unerwartete Gebühren in Rechnung gestellt werden.
------
#### [ Console ]
**So konfigurieren Sie den Amazon-S3-Auslöser (Konsole)**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie Ihre Funktion (`EncryptPDF`) aus.
1. Wählen Sie **Add trigger**.
1. Wählen Sie **S3** aus.
1. Wählen Sie unter **Bucket** Ihren Quell-Bucket aus.
1. Wählen Sie unter **Ereignistypen** die Option **Alle Objekterstellungsereignisse** aus.
1. Aktivieren Sie unter **Rekursiver Aufruf** das Kontrollkästchen, um zu bestätigen, dass die Verwendung desselben S3-Buckets für die Ein- und Ausgabe nicht empfohlen wird. Weitere Informationen zu rekursiven Aufrufmustern in Lambda finden Sie bei Serverless Land unter [Recursive patterns that cause run-away Lambda functions](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway).
1. Wählen Sie **Hinzufügen** aus.
Wenn Sie einen Auslöser über die Lambda-Konsole erstellen, erstellt Lambda automatisch eine [ressourcenbasierte Richtlinie](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html), um dem von Ihnen ausgewählten Dienst die Berechtigung zum Aufrufen Ihrer Funktion zu erteilen.
------
#### [ AWS CLI ]
**So konfigurieren Sie den Amazon-S3-Auslöser (AWS CLI)**
1. Fügen Sie Ihrer Funktion eine [ressourcenbasierte Richtlinie](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) hinzu, die es Ihrem Amazon-S3-Quell-Bucket ermöglicht, Ihre Funktion aufzurufen, wenn Sie eine Datei hinzufügen. Eine ressourcenbasierte Grundsatzerklärung erteilt anderen Personen die AWS-Services Erlaubnis, Ihre Funktion aufzurufen. Führen Sie den folgenden CLI-Befehl aus, um Amazon S3 die Berechtigung zum Aufrufen Ihrer Funktion zu erteilen. Achten Sie darauf, den `source-account` Parameter durch Ihre eigene AWS-Konto ID zu ersetzen und Ihren eigenen Quell-Bucket-Namen zu verwenden.
```
aws lambda add-permission --function-name EncryptPDF \
--principal s3.amazonaws.com --statement-id s3invoke --action "lambda:InvokeFunction" \
--source-arn arn:aws:s3:::amzn-s3-demo-bucket \
--source-account 123456789012
```
Die mit diesem Befehl definierte Richtlinie ermöglicht es Amazon S3 nur, Ihre Funktion aufzurufen, wenn eine Aktion in Ihrem Quell-Bucket ausgeführt wird.
**Anmerkung**
Namen von S3-Buckets sind zwar global eindeutig, trotzdem empfiehlt es sich, bei der Verwendung ressourcenbasierter Richtlinien anzugeben, dass der Bucket zu Ihrem Konto gehören muss. Denn wenn Sie einen Bucket löschen, kann ein anderer AWS-Konto Bucket einen Bucket mit demselben Amazon-Ressourcennamen (ARN) erstellen.
1. Speichern Sie den folgenden JSON-Code in einer Datei mit dem Namen `notification.json`: Wenn dieser JSON-Code auf Ihren Quell-Bucket angewendet wird, wird der Bucket so konfiguriert, dass er jedes Mal, wenn ein neues Objekt hinzugefügt wird, eine Benachrichtigung an Ihre Lambda-Funktion sendet. Ersetzen Sie die AWS-Konto Nummer und AWS-Region in der Lambda-Funktion ARN durch Ihre eigene Kontonummer und Region.
```
{
"LambdaFunctionConfigurations": [
{
"Id": "EncryptPDFEventConfiguration",
"LambdaFunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:EncryptPDF",
"Events": [ "s3:ObjectCreated:Put" ]
}
]
}
```
1. Führen Sie den folgenden CLI-Befehl aus, um die Benachrichtigungseinstellungen in der von Ihnen erstellten JSON-Datei auf Ihren Quell-Bucket anzuwenden. Ersetzen Sie dabei `amzn-s3-demo-bucket` durch den Namen Ihres Quell-Buckets.
```
aws s3api put-bucket-notification-configuration --bucket amzn-s3-demo-bucket \
--notification-configuration file://notification.json
```
Weitere Informationen zu dem `put-bucket-notification-configuration` Befehl und der `notification-configuration` Option finden Sie [put-bucket-notification-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-notification-configuration.html)in der *AWS CLI-Befehlsreferenz*.
------
### Stellen Sie die Ressourcen bereit mit AWS SAM
Stellen Sie zunächst sicher, dass [Docker](https://docs.docker.com/get-docker/) und [die neueste Version von AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) auf Ihrer Build-Maschine installiert sind.
1. Kopieren Sie im Projektverzeichnis den folgenden Code und fügen Sie ihn in eine Datei namens `template.yaml` ein. Ersetzen Sie die Platzhalter-Bucket-Namen:
+ Ersetzen Sie für den Quell-Bucket `amzn-s3-demo-bucket` durch einen beliebigen Namen, der den [Benennungsregeln für S3-Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) entspricht.
+ Ersetzen Sie für den Zielbereich `amzn-s3-demo-bucket-encrypted` durch `-encrypted`, wobei `` der Name ist, den Sie für Ihren Quellbereich gewählt haben.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
EncryptPDFFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: EncryptPDF
Architectures: [x86_64]
CodeUri: ./
Handler: lambda_function.lambda_handler
Runtime: python3.12
Timeout: 15
MemorySize: 256
LoggingConfig:
LogFormat: JSON
Policies:
- AmazonS3FullAccess
Events:
S3Event:
Type: S3
Properties:
Bucket: !Ref PDFSourceBucket
Events: s3:ObjectCreated:*
PDFSourceBucket:
Type: AWS::S3::Bucket
Properties:
BucketName: amzn-s3-demo-bucket
EncryptedPDFBucket:
Type: AWS::S3::Bucket
Properties:
BucketName: amzn-s3-demo-bucket-encrypted
```
Die AWS SAM Vorlage definiert die Ressourcen, die Sie für Ihre App erstellen. In diesem Beispiel definiert die Vorlage eine Lambda-Funktion unter Verwendung des `AWS::Serverless::Function`-Typs und zwei S3-Buckets unter Verwendung des `AWS::S3::Bucket`-Typs. Die in der Vorlage angegebenen Bucket-Namen sind Platzhalter. Bevor Sie die App mithilfe bereitstellen AWS SAM, müssen Sie die Vorlage bearbeiten, um die Buckets mit global eindeutigen Namen umzubenennen, die den [S3-Bucket-Namensregeln](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) entsprechen. Dieser Schritt wird unter [Stellen Sie die Ressourcen bereit mit AWS SAM](#file-processing-app-deploy-sam) näher erläutert.
Die Definition der Lambda-Funktionsressource konfiguriert einen Trigger für die Funktion mithilfe der `S3Event`-Event-Eigenschaft. Dieser Trigger bewirkt, dass Ihre Funktion immer dann aufgerufen wird, wenn ein Objekt in Ihrem Quell-Bucket erstellt wird.
Die Funktionsdefinition spezifiziert auch eine AWS Identity and Access Management (IAM-) Richtlinie, die der [Ausführungsrolle](lambda-intro-execution-role.md) der Funktion zugeordnet werden soll. Die [AWS -verwaltete Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) `AmazonS3FullAccess` gibt Ihrer Funktion die Berechtigungen, die sie zum Lesen und Schreiben von Objekten in Amazon S3 benötigt.
1. Führen Sie den folgenden Befehl in dem Verzeichnis aus, in dem Sie Ihre `template.yaml`-, `lambda_function.py`- und `requirements.txt`-Dateien gespeichert haben.
```
sam build --use-container
```
Dieser Befehl sammelt die Build-Artefakte für Ihre Anwendung und platziert sie im richtigen Format und am richtigen Ort, um sie bereitzustellen. Wenn Sie die Option `--use-container` angeben, wird Ihre Funktion innerhalb eines Lambda-ähnlichen Docker-Containers erstellt. Wir verwenden es hier, sodass Sie Python 3.12 nicht auf Ihrem lokalen Computer installiert haben müssen, damit der Build funktioniert.
Sucht während des Erstellungsvorgangs nach dem Lambda-Funktionscode an der Stelle, die Sie mit der `CodeUri` Eigenschaft in der Vorlage angegeben haben. AWS SAM In diesem Fall haben wir das aktuelle Verzeichnis als Standort (`./`) angegeben.
Wenn eine `requirements.txt` Datei vorhanden ist, AWS SAM verwendet sie, um die angegebenen Abhängigkeiten zu sammeln. AWS SAM Erstellt standardmäßig ein ZIP-Bereitstellungspaket mit Ihrem Funktionscode und Ihren Abhängigkeiten. Mithilfe der [PackageType](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-packagetype)Eigenschaft können Sie Ihre Funktion auch als Container-Image bereitstellen.
1. Führen Sie den folgenden Befehl aus, um Ihre Anwendung bereitzustellen und die in Ihrer AWS SAM Vorlage angegebenen Lambda- und Amazon S3 S3-Ressourcen zu erstellen.
```
sam deploy --guided
```
Wenn Sie die `--guided` Markierung verwenden, AWS SAM werden Ihnen Eingabeaufforderungen angezeigt, die Sie durch den Bereitstellungsprozess führen. Akzeptieren Sie für diese Bereitstellung die Standardoptionen, indem Sie die Eingabetaste drücken.
AWS SAM Erstellt während des Bereitstellungsprozesses die folgenden Ressourcen in Ihrem AWS-Konto:
+ Ein CloudFormation [Stack](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-whatis-concepts.html#cfn-concepts-stacks) mit dem Namen `sam-app`
+ Eine Lambda-Funktion mit dem Namen `EncryptPDF`
+ Zwei S3-Buckets mit den Namen, die Sie bei der Bearbeitung der `template.yaml` AWS SAM Vorlagendatei ausgewählt haben
+ Eine IAM-Ausführungsrolle für Ihre Funktion mit dem Namensformat `sam-app-EncryptPDFFunctionRole-2qGaapHFWOQ8`
Wenn Sie mit der Erstellung Ihrer Ressourcen AWS SAM fertig sind, sollte die folgende Meldung angezeigt werden:
```
Successfully created/updated stack - sam-app in us-east-2
```
## Testen der Anwendung
Um Ihre App zu testen, laden Sie eine PDF-Datei in Ihren Quell-Bucket hoch und bestätigen, dass Lambda eine verschlüsselte Version der Datei in Ihrem Ziel-Bucket erstellt. In diesem Beispiel können Sie dies entweder manuell mit der Konsole oder dem AWS CLI oder mithilfe des bereitgestellten Testskripts testen.
Für Produktionsanwendungen können Sie herkömmliche Testmethoden und -techniken wie Modultests verwenden, um die korrekte Funktionsweise Ihres Lambda-Funktionscodes zu überprüfen. Es empfiehlt sich auch, Tests wie die im bereitgestellten Testskript enthaltenen durchzuführen, bei denen Integrationstests mit echten, cloudbasierten Ressourcen durchgeführt werden. Integrationstests in der Cloud bestätigen, dass Ihre Infrastruktur korrekt bereitgestellt wurde und dass Ereignisse erwartungsgemäß zwischen verschiedenen Diensten ablaufen. Weitere Informationen hierzu finden Sie unter [Wie man Serverless-Funktionen und Anwendungen testet](testing-guide.md).
### Manuelles Testen der App
Sie können Ihre Funktion manuell testen, indem Sie Ihrem Amazon-S3-Quell-Bucket eine PDF-Datei hinzufügen. Wenn Sie Ihre Datei dem Quell-Bucket hinzufügen, sollte Ihre Lambda-Funktion automatisch aufgerufen werden und eine verschlüsselte Version der Datei in Ihrem Ziel-Bucket speichern.
------
#### [ Console ]
**So testen Sie Ihre Anwendung, indem Sie eine Datei hochladen (Konsole)**
1. Um eine PDF-Datei in Ihren S3-Bucket hochzuladen, gehen Sie wie folgt vor:
1. Öffnen Sie die Seite [Buckets](https://console.aws.amazon.com/s3/buckets) der Amazon-S3-Konsole und wählen Sie Ihren Quell-Bucket aus.
1. Klicken Sie auf **Upload**.
1. Wählen Sie **Dateien hinzufügen** und anschließend über die Dateiauswahl die PDF-Datei aus, die Sie hochladen möchten.
1. Wählen Sie **Öffnen** und anschließend **Hochladen** aus.
1. Überprüfen Sie, ob Lambda eine verschlüsselte Version Ihrer PDF-Datei in Ihrem Ziel-Bucket gespeichert hat, indem Sie Folgendes tun:
1. Navigieren Sie wieder zur Seite [Buckets](https://console.aws.amazon.com/s3/buckets) der Amazon-S3-Konsole und wählen Sie Ihren Ziel-Bucket aus.
1. Im **Objekt**bereich sollten Sie nun eine Datei mit dem Namen `filename_encrypted.pdf`-Format sehen (wobei `filename.pdf` der Name der Datei ist, die Sie in Ihren Quell-Bucket hochgeladen haben). Um Ihre verschlüsselte PDF-Datei herunterzuladen, wählen Sie die Datei aus und wählen Sie dann **Herunterladen** aus.
1. Bestätigen Sie, dass Sie die heruntergeladene Datei mit dem Passwort öffnen können, mit dem Ihre Lambda-Funktion sie geschützt hat (`my-secret-password`).
------
#### [ AWS CLI ]
**So testen Sie Ihre Anwendung, indem Sie eine Datei hochladen (AWS CLI)**
1. Führen Sie in dem Verzeichnis, das die hochzuladende PDF-Datei enthält, den folgenden CLI-Befehl aus. Ersetzen Sie dabei den Parameter `--bucket` durch den Namen Ihres Quell-Buckets. Verwenden Sie für die `--key`- und `--body`-Parameter den Dateinamen Ihres Testbilds.
```
aws s3api put-object --bucket amzn-s3-demo-bucket --key test.pdf --body ./test.pdf
```
1. Vergewissern Sie sich, dass Ihre Funktion eine verschlüsselte Version Ihrer Datei erstellt und in Ihrem S3-Ziel-Bucket gespeichert hat. Führen Sie den folgenden CLI-Befehl aus und ersetzen Sie dabei `amzn-s3-demo-bucket-encrypted` durch den Namen Ihres eigenen Ziel-Buckets:
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-bucket-encrypted
```
Wenn Ihre Funktion erfolgreich ausgeführt wird, erhalten Sie eine Ausgabe wie die folgende. Ihr Ziel-Bucket sollte eine Datei mit dem Namensformat `_encrypted.pdf` enthalten, wobei `` der Name der von Ihnen hochgeladenen Datei ist.
```
{
"Contents": [
{
"Key": "test_encrypted.pdf",
"LastModified": "2023-06-07T00:15:50+00:00",
"ETag": "\"7781a43e765a8301713f533d70968a1e\"",
"Size": 2763,
"StorageClass": "STANDARD"
}
]
}
```
1. Führen Sie den folgenden CLI-Befehl aus, um die Datei herunterzuladen, die Lambda in Ihrem Ziel-Bucket gespeichert hat. Ersetzen Sie den `--bucket`-Parameter durch den Namen Ihres Ziel-Buckets. Verwenden Sie für den Parameter `--key` den Dateinamen `_encrypted.pdf`, wobei `` der Name der von Ihnen hochgeladenen Testdatei ist.
```
aws s3api get-object --bucket amzn-s3-demo-bucket-encrypted --key test_encrypted.pdf my_encrypted_file.pdf
```
Dieser Befehl lädt die Datei in Ihr aktuelles Verzeichnis herunter und speichert sie als `my_encrypted_file.pdf`.
1. Bestätigen Sie, dass Sie die heruntergeladene Datei mit dem Passwort öffnen können, mit dem Ihre Lambda-Funktion sie geschützt hat (`my-secret-password`).
------
### Testen Sie die App mit dem automatisierten Skript
Erstellen Sie die folgenden Dateien in Ihrem Projektverzeichnis:
+ `test_pdf_encrypt.py` - ein Testskript, mit dem Sie Ihre Anwendung automatisch testen können
+ `pytest.ini` - eine Konfigurationsdatei für das Testskript
Erweitern Sie die folgenden Abschnitte, um den Code anzusehen und mehr über die Rolle der einzelnen Dateien zu erfahren.
#### Automatisierte Testskripte
Kopieren Sie den folgenden Code und fügen Sie ihn in eine Datei mit dem Namen `test_pdf_encrypt.py` ein. Ersetzen Sie unbedingt die Platzhalter-Bucket-Namen:
+ Ersetzen Sie in der `test_source_bucket_available`-Funktion `amzn-s3-demo-bucket` durch den Namen Ihres Quell-Eimers.
+ Ersetzen Sie in der Funktion `test_encrypted_file_in_bucket` `amzn-s3-demo-bucket-encrypted` durch `source-bucket-encrypted`, wobei `source-bucket>` der Name Ihres Quell-Eimers ist.
+ Ersetzen Sie in der `cleanup`-Funktion `amzn-s3-demo-bucket` durch den Namen Ihres Quell-Buckets und ersetzen Sie `amzn-s3-demo-bucket-encrypted` durch den Namen Ihres Ziel-Buckets.
```
import boto3
import json
import pytest
import time
import os
@pytest.fixture
def lambda_client():
return boto3.client('lambda')
@pytest.fixture
def s3_client():
return boto3.client('s3')
@pytest.fixture
def logs_client():
return boto3.client('logs')
@pytest.fixture(scope='session')
def cleanup():
# Create a new S3 client for cleanup
s3_client = boto3.client('s3')
yield
# Cleanup code will be executed after all tests have finished
# Delete test.pdf from the source bucket
source_bucket = 'amzn-s3-demo-bucket'
source_file_key = 'test.pdf'
s3_client.delete_object(Bucket=source_bucket, Key=source_file_key)
print(f"\nDeleted {source_file_key} from {source_bucket}")
# Delete test_encrypted.pdf from the destination bucket
destination_bucket = 'amzn-s3-demo-bucket-encrypted'
destination_file_key = 'test_encrypted.pdf'
s3_client.delete_object(Bucket=destination_bucket, Key=destination_file_key)
print(f"Deleted {destination_file_key} from {destination_bucket}")
@pytest.mark.order(1)
def test_source_bucket_available(s3_client):
s3_bucket_name = 'amzn-s3-demo-bucket'
file_name = 'test.pdf'
file_path = os.path.join(os.path.dirname(__file__), file_name)
file_uploaded = False
try:
s3_client.upload_file(file_path, s3_bucket_name, file_name)
file_uploaded = True
except:
print("Error: couldn't upload file")
assert file_uploaded, "Could not upload file to S3 bucket"
@pytest.mark.order(2)
def test_lambda_invoked(logs_client):
# Wait for a few seconds to make sure the logs are available
time.sleep(5)
# Get the latest log stream for the specified log group
log_streams = logs_client.describe_log_streams(
logGroupName='/aws/lambda/EncryptPDF',
orderBy='LastEventTime',
descending=True,
limit=1
)
latest_log_stream_name = log_streams['logStreams'][0]['logStreamName']
# Retrieve the log events from the latest log stream
log_events = logs_client.get_log_events(
logGroupName='/aws/lambda/EncryptPDF',
logStreamName=latest_log_stream_name
)
success_found = False
for event in log_events['events']:
message = json.loads(event['message'])
status = message.get('record', {}).get('status')
if status == 'success':
success_found = True
break
assert success_found, "Lambda function execution did not report 'success' status in logs."
@pytest.mark.order(3)
def test_encrypted_file_in_bucket(s3_client):
# Specify the destination S3 bucket and the expected converted file key
destination_bucket = 'amzn-s3-demo-bucket-encrypted'
converted_file_key = 'test_encrypted.pdf'
try:
# Attempt to retrieve the metadata of the converted file from the destination S3 bucket
s3_client.head_object(Bucket=destination_bucket, Key=converted_file_key)
except s3_client.exceptions.ClientError as e:
# If the file is not found, the test will fail
pytest.fail(f"Converted file '{converted_file_key}' not found in the destination bucket: {str(e)}")
def test_cleanup(cleanup):
# This test uses the cleanup fixture and will be executed last
pass
```
Das automatisierte Testskript führt drei Testfunktionen aus, um den korrekten Betrieb Ihrer App zu bestätigen:
+ Der Test `test_source_bucket_available` bestätigt, dass Ihr Quell-Bucket erfolgreich erstellt wurde, indem eine Test-PDF-Datei in den Bucket hochgeladen wird.
+ Der Test `test_lambda_invoked` fragt den neuesten CloudWatch Log-Protokollstream für Ihre Funktion ab, um zu bestätigen, dass Ihre Lambda-Funktion beim Hochladen der Testdatei ausgeführt wurde und erfolgreich gemeldet wurde.
+ Der Test `test_encrypted_file_in_bucket` bestätigt, dass Ihr Ziel-Bucket die verschlüsselte `test_encrypted.pdf`-Datei enthält.
Nachdem all diese Tests ausgeführt wurden, führt das Skript einen zusätzlichen Bereinigungsschritt aus, um die `test.pdf`- und `test_encrypted.pdf`-Dateien sowohl aus Ihrem Quell- als auch aus Ihrem Ziel-Bucket zu löschen.
Wie bei der AWS SAM Vorlage sind die in dieser Datei angegebenen Bucket-Namen Platzhalter. Bevor Sie den Test ausführen, müssen Sie diese Datei mit den echten Bucket-Namen Ihrer App bearbeiten. Dieser Schritt wird unter [Testen Sie die App mit dem automatisierten Skript](#file-processing-app-test-auto) näher erläutert
#### Testskript-Konfigurationsdatei
Kopieren Sie den folgenden Code und fügen Sie ihn in eine Datei mit dem Namen `pytest.ini` ein.
```
[pytest]
markers =
order: specify test execution order
```
Dies ist erforderlich, um die Reihenfolge anzugeben, in der die Tests im `test_pdf_encrypt.py`-Skript ausgeführt werden.
Um die Tests durchzuführen, gehen Sie wie folgt vor:
1. Stellen Sie sicher, dass das `pytest`-Modul in Ihrer lokalen Umgebung installiert ist. Sie können `pytest` installieren, indem Sie den folgenden Befehl ausführen:
```
pip install pytest
```
1. Speichern Sie eine PDF-Datei mit dem Namen `test.pdf` in dem Verzeichnis, das die `test_pdf_encrypt.py`- und `pytest.ini`-Dateien enthält.
1. Öffnen Sie ein Terminal- oder Shell-Programm und führen Sie den folgenden Befehl in dem Verzeichnis aus, das die Testdateien enthält.
```
pytest -s -v
```
Wenn der Test abgeschlossen ist, sollten Sie eine Ausgabe wie die folgende sehen:
```
============================================================== test session starts =========================================================
platform linux -- Python 3.12.2, pytest-7.2.2, pluggy-1.0.0 -- /usr/bin/python3
cachedir: .pytest_cache
hypothesis profile 'default' -> database=DirectoryBasedExampleDatabase('/home/pdf_encrypt_app/.hypothesis/examples')
Test order randomisation NOT enabled. Enable with --random-order or --random-order-bucket=
rootdir: /home/pdf_encrypt_app, configfile: pytest.ini
plugins: anyio-3.7.1, hypothesis-6.70.0, localserver-0.7.1, random-order-1.1.0
collected 4 items
test_pdf_encrypt.py::test_source_bucket_available PASSED
test_pdf_encrypt.py::test_lambda_invoked PASSED
test_pdf_encrypt.py::test_encrypted_file_in_bucket PASSED
test_pdf_encrypt.py::test_cleanup PASSED
Deleted test.pdf from amzn-s3-demo-bucket
Deleted test_encrypted.pdf from amzn-s3-demo-bucket-encrypted
=============================================================== 4 passed in 7.32s ==========================================================
```
## Nächste Schritte
Nachdem Sie diese Beispiel-App erstellt haben, können Sie den bereitgestellten Code als Grundlage verwenden, um andere Arten von Dateiverarbeitungsanwendungen zu erstellen. Ändern Sie den Code in der `lambda_function.py`-Datei, um die Dateiverarbeitungslogik für Ihren Anwendungsfall zu implementieren.
Viele typische Anwendungsfälle für die Dateiverarbeitung beinhalten Bildverarbeitung. Bei der Verwendung von Python enthalten die beliebtesten Bildverarbeitungsbibliotheken wie [Pillow](https://pypi.org/project/pillow/) typischerweise C- oder C\$1\$1-Komponenten. Um sicherzustellen, dass das Bereitstellungspaket Ihrer Funktion mit der Lambda-Ausführungsumgebung kompatibel ist, ist es wichtig, die richtige Binärdatei für die Quelldistribution zu verwenden.
Bei der Bereitstellung Ihrer Ressourcen mit müssen Sie einige zusätzliche Schritte unternehmen AWS SAM, um die richtige Quelldistribution in Ihr Bereitstellungspaket aufzunehmen. Da AWS SAM keine Abhängigkeiten für eine andere Plattform als Ihre Build-Maschine installiert werden, funktioniert die Angabe der richtigen Quelldistribution (`.whl`Datei) in Ihrer `requirements.txt` Datei nicht, wenn Ihre Build-Maschine ein Betriebssystem oder eine Architektur verwendet, die sich von der Lambda-Ausführungsumgebung unterscheidet. Stattdessen sollten Sie eine der folgenden Möglichkeiten nutzen:
+ Verwenden Sie die `--use-container`-Option beim Ausführen von `sam build`. Wenn Sie diese Option angeben, wird ein Container-Basis-Image AWS SAM heruntergeladen, das mit der Lambda-Ausführungsumgebung kompatibel ist, und erstellt das Bereitstellungspaket Ihrer Funktion mithilfe dieses Images in einem Docker-Container. Weitere Informationen finden Sie unter [Eine Lambda-Funktion in einem bereitgestellten Container erstellen](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/using-sam-cli-build.html#using-sam-cli-build-options-container).
+ Erstellen Sie das ZIP-Bereitstellungspaket Ihrer Funktion mithilfe der richtigen Binärdatei für die Quelldistribution selbst und speichern Sie die ZIP-Datei in dem Verzeichnis, das Sie in der `CodeUri` Vorlage angeben. AWS SAM Weitere Informationen zum Erstellen von .zip-Bereitstellungspaketen für Python mithilfe von Binärverteilungen finden Sie unter [ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen](python-package.md#python-package-create-dependencies) und [ZIP-Bereitstellungspakete mit nativen Bibliotheken erstellen](python-package.md#python-package-native-libraries).
# Erstellen Sie eine App, um eine geplante Datenbankwartung durchzuführen
Sie können AWS Lambda es verwenden, um geplante Prozesse wie automatisierte Systemsicherungen, Dateikonvertierungen und Wartungsaufgaben zu ersetzen. In diesem Beispiel erstellen Sie eine Serverless-Anwendung, die regelmäßig geplante Wartungsarbeiten an einer DynamoDB-Tabelle durchführt, indem alte Einträge gelöscht werden. Die App verwendet EventBridge Scheduler, um eine Lambda-Funktion nach einem Cron-Zeitplan aufzurufen. Wenn die Funktion aufgerufen wird, fragt sie die Tabelle nach Elementen ab, die älter als ein Jahr sind und löscht sie. Die Funktion protokolliert jedes gelöschte Element in Logs. CloudWatch
Um dieses Beispiel zu implementieren, erstellen Sie zunächst eine DynamoDB-Tabelle und füllen Sie sie mit einigen Testdaten auf, damit Ihre Funktion sie abfragen kann. Erstellen Sie dann eine Python-Lambda-Funktion mit einem EventBridge Scheduler-Trigger und einer IAM-Ausführungsrolle, die der Funktion die Berechtigung erteilt, Elemente aus Ihrer Tabelle zu lesen und zu löschen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/ExampleApps/cron_app.png)
**Tipp**
Wenn Sie neu bei Lambda sind, empfehlen wir Ihnen, vor der Erstellung dieser Beispielanwendung das Tutorial [Erstellen Sie Ihre erste Lambda-Funktion](getting-started.md) zu absolvieren.
Sie können Ihre App manuell bereitstellen, indem Sie Ressourcen mit dem erstellen und konfigurieren. AWS-Managementkonsole Sie können die App auch mithilfe von AWS Serverless Application Model (AWS SAM) bereitstellen. AWS SAM ist ein Tool für Infrastruktur als Code (IaC). Mit IaC erstellen Sie Ressourcen nicht manuell, sondern definieren sie im Code und stellen sie dann automatisch bereit.
Wenn Sie mehr über die Verwendung von Lambda mit IaC erfahren möchten, bevor Sie diese Beispiel-App bereitstellen, finden Sie unter [Verwenden von Lambda mit Infrastructure as Code (IaC)](foundation-iac.md).
## Voraussetzungen
Bevor Sie die Beispiel-App erstellen können, stellen Sie sicher, dass Sie die erforderlichen Befehlszeilentools und Programme installiert haben.
+ **Python**
Um die DynamoDB-Tabelle zu füllen, die Sie zum Testen Ihrer App erstellen, verwendet dieses Beispiel ein Python-Skript und eine CSV-Datei, um Daten in die Tabelle zu schreiben. Stellen Sie sicher, dass Python Version 3.8 oder höher auf Ihrem Computer installiert ist.
+ **AWS SAM CLI**
Wenn Sie die DynamoDB-Tabelle erstellen und die Beispiel-App mithilfe bereitstellen möchten AWS SAM, müssen Sie die AWS SAM CLI installieren. Folgen Sie den [Installationsanweisungen](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) im *AWS SAM Benutzerhandbuch*.
+ **AWS CLI**
Um das bereitgestellte Python-Skript zum Auffüllen Ihrer Testtabelle zu verwenden, müssen Sie das AWS CLI installiert und konfiguriert haben. Das liegt daran, dass das Skript die verwendet AWS SDK für Python (Boto3), die Zugriff auf Ihre AWS Identity and Access Management (IAM-) Anmeldeinformationen benötigt. Sie benötigen außerdem die AWS CLI Installation, um Ressourcen mithilfe AWS SAM von bereitzustellen. Installieren Sie die Befehlszeilenschnittstelle, indem Sie die [Installationsanweisungen](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) im *AWS Command Line Interface -Benutzerhandbuch* befolgen.
+ **Docker**
Um die App mithilfe von bereitstellen zu können AWS SAM, muss Docker auch auf Ihrem Build-Computer installiert sein. Befolgen Sie die Anweisungen in [Installieren der Docker-Engine](https://docs.docker.com/engine/install/) auf der Docker-Dokumentations-Website.
## Die Beispiel-App-Dateien werden heruntergeladen
Um die Beispieldatenbank und die Anwendung für die geplante Wartung zu erstellen, müssen Sie die folgenden Dateien in Ihrem Projektverzeichnis erstellen:
**Beispieldatenbankdateien**
+ `template.yaml`- eine AWS SAM Vorlage, mit der Sie die DynamoDB-Tabelle erstellen können
+ `sample_data.csv` - eine CSV-Datei mit Beispieldaten, die Sie in Ihre Tabelle laden können
+ `load_sample_data.py` - ein Python-Skript, das die Daten in der CSV-Datei in die Tabelle schreibt
**Anwendungsdateien für die planmäßige Wartung**
+ `lambda_function.py` - den Python-Funktionscode für die Lambda-Funktion, die die Datenbankwartung durchführt
+ `requirements.txt` - eine Manifestdatei, die die Abhängigkeiten definiert, die Ihr Python-Funktionscode benötigt
+ `template.yaml`- eine AWS SAM Vorlage, die Sie für die Bereitstellung der App verwenden können
**Datei testen**
+ `test_app.py` - ein Python-Skript, das die Tabelle scannt und den erfolgreichen Betrieb Ihrer Funktion bestätigt, indem es alle Datensätze ausgibt, die älter als ein Jahr sind
Erweitern Sie die folgenden Abschnitte, um den Code anzusehen und mehr über die Rolle der einzelnen Dateien beim Erstellen und Testen Ihrer App zu erfahren. Um die Dateien auf Ihrem lokalen Computer zu erstellen, kopieren Sie den folgenden Code und fügen Sie ihn ein.
### AWS SAM Vorlage (Beispiel für eine DynamoDB-Tabelle)
Kopieren Sie den folgenden Code und fügen Sie ihn in eine Datei mit dem Namen `template.yaml` ein.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: SAM Template for DynamoDB Table with Order_number as Partition Key and Date as Sort Key
Resources:
MyDynamoDBTable:
Type: AWS::DynamoDB::Table
DeletionPolicy: Retain
UpdateReplacePolicy: Retain
Properties:
TableName: MyOrderTable
BillingMode: PAY_PER_REQUEST
AttributeDefinitions:
- AttributeName: Order_number
AttributeType: S
- AttributeName: Date
AttributeType: S
KeySchema:
- AttributeName: Order_number
KeyType: HASH
- AttributeName: Date
KeyType: RANGE
SSESpecification:
SSEEnabled: true
GlobalSecondaryIndexes:
- IndexName: Date-index
KeySchema:
- AttributeName: Date
KeyType: HASH
Projection:
ProjectionType: ALL
PointInTimeRecoverySpecification:
PointInTimeRecoveryEnabled: true
Outputs:
TableName:
Description: DynamoDB Table Name
Value: !Ref MyDynamoDBTable
TableArn:
Description: DynamoDB Table ARN
Value: !GetAtt MyDynamoDBTable.Arn
```
**Anmerkung**
AWS SAM Vorlagen verwenden eine standardmäßige Benennungskonvention von. `template.yaml` In diesem Beispiel haben Sie zwei Vorlagendateien - eine zur Erstellung der Beispieldatenbank und eine weitere zur Erstellung der Anwendung selbst. Speichern Sie sie in separaten Unterverzeichnissen im Projektordner.
Diese AWS SAM Vorlage definiert die DynamoDB-Tabellenressource, die Sie zum Testen Ihrer App erstellen. Die Tabelle verwendet einen Primärschlüssel von `Order_number` mit einem Sortierschlüssel von `Date`. Damit Ihre Lambda-Funktion Elemente direkt nach Datum finden kann, definieren wir auch einen [globalen Sekundärindex](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html) mit dem Namen `Date-index`.
Weitere Informationen zum Erstellen und Konfigurieren einer DynamoDB-Tabelle mithilfe der `AWS::DynamoDB::Table`-Ressource finden Sie unter [AWS::DynamoDB::Table](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html) im *AWS CloudFormation Benutzerhandbuch*.
### Beispiel für Datenbankdatendatei
Kopieren Sie den folgenden Code und fügen Sie ihn in eine Datei mit dem Namen `sample_data.csv` ein.
```
Date,Order_number,CustomerName,ProductID,Quantity,TotalAmount
2023-09-01,ORD001,Alejandro Rosalez,PROD123,2,199.98
2023-09-01,ORD002,Akua Mansa,PROD456,1,49.99
2023-09-02,ORD003,Ana Carolina Silva,PROD789,3,149.97
2023-09-03,ORD004,Arnav Desai,PROD123,1,99.99
2023-10-01,ORD005,Carlos Salazar,PROD456,2,99.98
2023-10-02,ORD006,Diego Ramirez,PROD789,1,49.99
2023-10-03,ORD007,Efua Owusu,PROD123,4,399.96
2023-10-04,ORD008,John Stiles,PROD456,2,99.98
2023-10-05,ORD009,Jorge Souza,PROD789,3,149.97
2023-10-06,ORD010,Kwaku Mensah,PROD123,1,99.99
2023-11-01,ORD011,Li Juan,PROD456,5,249.95
2023-11-02,ORD012,Marcia Oliveria,PROD789,2,99.98
2023-11-03,ORD013,Maria Garcia,PROD123,3,299.97
2023-11-04,ORD014,Martha Rivera,PROD456,1,49.99
2023-11-05,ORD015,Mary Major,PROD789,4,199.96
2023-12-01,ORD016,Mateo Jackson,PROD123,2,199.99
2023-12-02,ORD017,Nikki Wolf,PROD456,3,149.97
2023-12-03,ORD018,Pat Candella,PROD789,1,49.99
2023-12-04,ORD019,Paulo Santos,PROD123,5,499.95
2023-12-05,ORD020,Richard Roe,PROD456,2,99.98
2024-01-01,ORD021,Saanvi Sarkar,PROD789,3,149.97
2024-01-02,ORD022,Shirley Rodriguez,PROD123,1,99.99
2024-01-03,ORD023,Sofia Martinez,PROD456,4,199.96
2024-01-04,ORD024,Terry Whitlock,PROD789,2,99.98
2024-01-05,ORD025,Wang Xiulan,PROD123,3,299.97
```
Diese Datei enthält einige Beispieltestdaten, mit denen Sie Ihre DynamoDB-Tabelle im CSV-Standardformat (durch Komma getrennte Werte) füllen können.
### Python-Skript zum Laden von Beispieldaten
Kopieren Sie den folgenden Code und fügen Sie ihn in eine Datei mit dem Namen `load_sample_data.py` ein.
```
import boto3
import csv
from decimal import Decimal
# Initialize the DynamoDB client
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('MyOrderTable')
print("DDB client initialized.")
def load_data_from_csv(filename):
with open(filename, 'r') as file:
csv_reader = csv.DictReader(file)
for row in csv_reader:
item = {
'Order_number': row['Order_number'],
'Date': row['Date'],
'CustomerName': row['CustomerName'],
'ProductID': row['ProductID'],
'Quantity': int(row['Quantity']),
'TotalAmount': Decimal(str(row['TotalAmount']))
}
table.put_item(Item=item)
print(f"Added item: {item['Order_number']} - {item['Date']}")
if __name__ == "__main__":
load_data_from_csv('sample_data.csv')
print("Data loading completed.")
```
Dieses Python-Skript verwendet zunächst die AWS SDK für Python (Boto3) , um eine Verbindung zu Ihrer DynamoDB-Tabelle herzustellen. Anschließend wird jede Zeile in der CSV-Datei mit den Beispieldaten durchlaufen, ein Element aus dieser Zeile erstellt und das Element mithilfe des boto3-SDK in die DynamoDB-Tabelle geschrieben.
### Python-Funktionscode
Kopieren Sie den folgenden Code und fügen Sie ihn in eine Datei mit dem Namen `lambda_function.py` ein.
```
import boto3
from datetime import datetime, timedelta
from boto3.dynamodb.conditions import Key, Attr
import logging
logger = logging.getLogger()
logger.setLevel("INFO")
def lambda_handler(event, context):
# Initialize the DynamoDB client
dynamodb = boto3.resource('dynamodb')
# Specify the table name
table_name = 'MyOrderTable'
table = dynamodb.Table(table_name)
# Get today's date
today = datetime.now()
# Calculate the date one year ago
one_year_ago = (today - timedelta(days=365)).strftime('%Y-%m-%d')
# Scan the table using a global secondary index
response = table.scan(
IndexName='Date-index',
FilterExpression='#date < :one_year_ago',
ExpressionAttributeNames={
'#date': 'Date'
},
ExpressionAttributeValues={
':one_year_ago': one_year_ago
}
)
# Delete old items
with table.batch_writer() as batch:
for item in response['Items']:
Order_number = item['Order_number']
batch.delete_item(
Key={
'Order_number': Order_number,
'Date': item['Date']
}
)
logger.info(f'deleted order number {Order_number}')
# Check if there are more items to scan
while 'LastEvaluatedKey' in response:
response = table.scan(
IndexName='DateIndex',
FilterExpression='#date < :one_year_ago',
ExpressionAttributeNames={
'#date': 'Date'
},
ExpressionAttributeValues={
':one_year_ago': one_year_ago
},
ExclusiveStartKey=response['LastEvaluatedKey']
)
# Delete old items
with table.batch_writer() as batch:
for item in response['Items']:
batch.delete_item(
Key={
'Order_number': item['Order_number'],
'Date': item['Date']
}
)
return {
'statusCode': 200,
'body': 'Cleanup completed successfully'
}
```
Der Python-Funktionscode enthält die [Handler-Funktion](python-handler.md) (`lambda_handler`), die Lambda ausführt, wenn Ihre Funktion aufgerufen wird.
Wenn die Funktion vom EventBridge Scheduler aufgerufen wird, verwendet sie die, um eine Verbindung AWS SDK für Python (Boto3) zu der DynamoDB-Tabelle herzustellen, für die die geplante Wartungsaufgabe ausgeführt werden soll. Anschließend wird mit Hilfe der Python `datetime`-Bibliothek das Datum vor einem Jahr berechnet, bevor die Tabelle nach Einträgen durchsucht wird, die älter als dieses Datum sind und diese gelöscht werden.
Beachten Sie, dass Antworten von DynamoDB-Abfrage- und Scanvorgängen auf eine maximale Größe von 1 MB begrenzt sind. Wenn die Antwort größer als 1 MB ist, paginiert DynamoDB die Daten und gibt ein `LastEvaluatedKey`-Element in der Antwort zurück. Um sicherzustellen, dass unsere Funktion alle Datensätze in der Tabelle verarbeitet, prüfen wir, ob dieser Schlüssel vorhanden ist und führen weiterhin Tabellenscans von der zuletzt ausgewerteten Position aus, bis die gesamte Tabelle gescannt wurde.
### `requirements.txt`-Manifestdatei
Kopieren Sie den folgenden Code und fügen Sie ihn in eine Datei mit dem Namen `requirements.txt` ein.
```
boto3
```
In diesem Beispiel hat Ihr Funktionscode nur eine Abhängigkeit, die nicht Teil der Standard-Python-Bibliothek ist: das SDK für Python (Boto3), das die Funktion zum Scannen und Löschen von Elementen aus der DynamoDB-Tabelle verwendet.
**Anmerkung**
Eine Version des SDK für Python (Boto3) ist Teil der Lambda-Laufzeit, sodass Ihr Code ausgeführt werden kann, ohne Boto3 zum Bereitstellungspaket Ihrer Funktion hinzuzufügen. Um jedoch die volle Kontrolle über die Abhängigkeiten Ihrer Funktion zu behalten und mögliche Probleme mit Versionsfehlern zu vermeiden, empfiehlt es sich für Python, alle Funktionsabhängigkeiten in das Bereitstellungspaket Ihrer Funktion aufzunehmen. Weitere Informationen hierzu finden Sie unter [Laufzeitabhängigkeiten in Python](python-package.md#python-package-dependencies).
### AWS SAM Vorlage (App für geplante Wartungsarbeiten)
Kopieren Sie den folgenden Code und fügen Sie ihn in eine Datei mit dem Namen `template.yaml` ein.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: SAM Template for Lambda function and EventBridge Scheduler rule
Resources:
MyLambdaFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: ScheduledDBMaintenance
CodeUri: ./
Handler: lambda_function.lambda_handler
Runtime: python3.11
Architectures:
- x86_64
Events:
ScheduleEvent:
Type: ScheduleV2
Properties:
ScheduleExpression: cron(0 3 1 * ? *)
Description: Run on the first day of every month at 03:00 AM
Policies:
- CloudWatchLogsFullAccess
- Statement:
- Effect: Allow
Action:
- dynamodb:Scan
- dynamodb:BatchWriteItem
Resource: !Sub 'arn:aws:dynamodb:${AWS::Region}:${AWS::AccountId}:table/MyOrderTable'
LambdaLogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub /aws/lambda/${MyLambdaFunction}
RetentionInDays: 30
Outputs:
LambdaFunctionName:
Description: Lambda Function Name
Value: !Ref MyLambdaFunction
LambdaFunctionArn:
Description: Lambda Function ARN
Value: !GetAtt MyLambdaFunction.Arn
```
**Anmerkung**
AWS SAM Vorlagen verwenden eine Standardbenennungskonvention von. `template.yaml` In diesem Beispiel haben Sie zwei Vorlagendateien - eine zur Erstellung der Beispieldatenbank und eine weitere zur Erstellung der Anwendung selbst. Speichern Sie sie in separaten Unterverzeichnissen im Projektordner.
Diese AWS SAM Vorlage definiert die Ressourcen für Ihre App. Wir definieren die Lambda-Funktion mithilfe der `AWS::Serverless::Function`-Ressource. Der EventBridge Scheduler-Zeitplan und der Trigger zum Aufrufen der Lambda-Funktion werden mithilfe der `Events` Eigenschaft dieser Ressource unter Verwendung eines Typs von erstellt. `ScheduleV2` *Weitere Informationen zum Definieren von EventBridge Scheduler-Zeitplänen in AWS SAM Vorlagen finden Sie unter [ScheduleV2](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-schedulev2.html) im Entwicklerhandbuch.AWS Serverless Application Model *
Zusätzlich zur Lambda-Funktion und dem EventBridge Scheduler-Zeitplan definieren wir auch eine CloudWatch Protokollgruppe für Ihre Funktion, an die Datensätze gelöschter Elemente gesendet werden sollen.
### Skript testen
Kopieren Sie den folgenden Code und fügen Sie ihn in eine Datei mit dem Namen `test_app.py` ein.
```
import boto3
from datetime import datetime, timedelta
import json
# Initialize the DynamoDB client
dynamodb = boto3.resource('dynamodb')
# Specify your table name
table_name = 'YourTableName'
table = dynamodb.Table(table_name)
# Get the current date
current_date = datetime.now()
# Calculate the date one year ago
one_year_ago = current_date - timedelta(days=365)
# Convert the date to string format (assuming the date in DynamoDB is stored as a string)
one_year_ago_str = one_year_ago.strftime('%Y-%m-%d')
# Scan the table
response = table.scan(
FilterExpression='#date < :one_year_ago',
ExpressionAttributeNames={
'#date': 'Date'
},
ExpressionAttributeValues={
':one_year_ago': one_year_ago_str
}
)
# Process the results
old_records = response['Items']
# Continue scanning if we have more items (pagination)
while 'LastEvaluatedKey' in response:
response = table.scan(
FilterExpression='#date < :one_year_ago',
ExpressionAttributeNames={
'#date': 'Date'
},
ExpressionAttributeValues={
':one_year_ago': one_year_ago_str
},
ExclusiveStartKey=response['LastEvaluatedKey']
)
old_records.extend(response['Items'])
for record in old_records:
print(json.dumps(record))
# The total number of old records should be zero.
print(f"Total number of old records: {len(old_records)}")
```
Dieses Testskript verwendet die AWS SDK für Python (Boto3) , um eine Verbindung zu Ihrer DynamoDB-Tabelle herzustellen und nach Elementen zu suchen, die älter als ein Jahr sind. Um zu überprüfen, ob die Lambda-Funktion erfolgreich ausgeführt wurde, druckt die Funktion am Ende des Tests die Anzahl der Datensätze, die älter als ein Jahr sind, noch in der Tabelle aus. Wenn die Lambda-Funktion erfolgreich war, sollte die Anzahl der alten Datensätze in der Tabelle Null sein.
## DynamoDB-Beispieltabelle erstellen und auffüllen
Um Ihre App für geplante Wartungsarbeiten zu testen, erstellen Sie zunächst eine DynamoDB-Tabelle und füllen sie mit einigen Beispieldaten. Sie können die Tabelle entweder manuell mithilfe von AWS-Managementkonsole oder mithilfe von AWS SAM erstellen. Wir empfehlen Ihnen, die Tabelle mithilfe einiger AWS CLI Befehle schnell AWS SAM zu erstellen und zu konfigurieren.
------
#### [ Console ]
**Erstellen einer DynamoDB-Tabelle**
1. Öffnen Sie die Seite [Tables (Tabellen)](https://console.aws.amazon.com/dynamodbv2/home#tables) in der DynamoDB-Konsole.
1. Wählen Sie **Create table** (Tabelle erstellen) aus.
1. Erstellen Sie die Tabelle folgendermaßen:
1. Geben Sie unter **Tabellendetails** für **Tabellenname** den Wert **MyOrderTable** ein.
1. Geben Sie für **Partitionsschlüssel** **Order\$1number** ein und behalten Sie den Datentyp als **Zeichenfolge** bei.
1. Geben Sie für **Sortierschlüssel** **Date** ein und behalten Sie den Datentyp als **Zeichenfolge** bei.
1. Lassen Sie die **Tabelleneinstellungen** auf **Standardeinstellungen** eingestellt und wählen Sie **Tabelle erstellen**.
1. Wenn Ihre Tabelle mit der Erstellung fertig ist und ihr **Status** als **Aktiv** angezeigt wird, erstellen Sie einen globalen sekundären Index (GSI), indem Sie wie folgt vorgehen. Ihre App verwendet diesen globalen Index, um direkt anhand des Datums nach Elementen zu suchen, um zu bestimmen, welche gelöscht werden sollen.
1. Wählen Sie **MyOrderTable**aus der Liste der Tabellen aus.
1. Wählen Sie die Registerkarte **Indizes**.
1. Wählen Sie unter **Globale Sekundärindizes** die Option **Index erstellen** aus.
1. Geben Sie unter **Indexdetails** **Date** für den **Partitionsschlüssel** ein und lassen Sie den **Datentyp** auf **String** eingestellt.
1. Geben Sie für **Indexname** **Date-index** ein.
1. Verwenden Sie für alle anderen Parameter die Standardwerte, scrollen Sie ans Seitenende und wählen Sie **Index erstellen** aus.
------
#### [ AWS SAM ]
**Erstellen einer DynamoDB-Tabelle**
1. Navigieren Sie zu dem Ordner, in dem Sie die `template.yaml`-Datei für die DynamoDB-Tabelle gespeichert haben. Beachten Sie, dass in diesem Beispiel zwei `template.yaml`-Dateien verwendet werden. Vergewissern Sie sich, dass sie in separaten Unterordnern gespeichert sind und dass Sie sich im richtigen Ordner befinden, der die Vorlage zur Erstellung Ihrer DynamoDB-Tabelle enthält.
1. Führen Sie den folgenden Befehl aus.
```
sam build
```
Dieser Befehl sammelt die Build-Artefakte für die Ressourcen, die Sie bereitstellen möchten und platziert sie im richtigen Format und am richtigen Ort, um sie bereitzustellen.
1. Führen Sie den folgenden Befehl aus, um die in der `template.yaml`-Datei angegebene DynamoDB-Ressource zu erstellen.
```
sam deploy --guided
```
Wenn Sie die `--guided` Flagge verwenden, AWS SAM werden Ihnen Eingabeaufforderungen angezeigt, die Sie durch den Bereitstellungsprozess führen. Geben Sie für diese Bereitstellung ein `Stack name` von **cron-app-test-db** ein und akzeptieren Sie die Standardeinstellungen für alle anderen Optionen mit der Eingabetaste.
Wenn AWS SAM die Erstellung der DynamoDB-Ressource abgeschlossen ist, sollte die folgende Meldung angezeigt werden.
```
Successfully created/updated stack - cron-app-test-db in us-west-2
```
1. Sie können außerdem überprüfen, ob die DynamoDB-Tabelle erstellt wurde, indem Sie die [Tabellen](https://console.aws.amazon.com/dynamodbv2/home#tables)seite der DynamoDB-Konsole öffnen. Sie sollten eine Tabelle mit dem Namen `MyOrderTable` sehen.
------
Nachdem Sie Ihre Tabelle erstellt haben, fügen Sie als Nächstes einige Beispieldaten hinzu, um Ihre App zu testen. Die CSV-Datei `sample_data.csv`, die Sie zuvor heruntergeladen haben, enthält eine Reihe von Beispieleinträgen, die aus Bestellnummern, Daten sowie Kunden- und Bestellinformationen bestehen. Verwenden Sie das bereitgestellte Python-Skript `load_sample_data.py`, um diese Daten zu Ihrer Tabelle hinzuzufügen.
**So fügen Sie der Tabelle die Beispieldaten hinzu**
1. Wechseln Sie in das Verzeichnis, das die `sample_data.csv`- und `load_sample_data.py`-Dateien enthält. Wenn sich diese Dateien in separaten Verzeichnissen befinden, verschieben Sie sie so, dass sie am selben Ort gespeichert werden.
1. Erstellen Sie eine virtuelle Python-Umgebung zur Ausführung des Skripts, indem Sie den folgenden Befehl ausführen. Wir empfehlen Ihnen, eine virtuelle Umgebung zu verwenden, da Sie im nächsten Schritt das AWS SDK für Python (Boto3) installieren müssen.
```
python -m venv venv
```
1. Aktivieren Sie die virtuelle Umgebung, indem Sie den folgenden Befehl ausführen.
```
source venv/bin/activate
```
1. Installieren Sie das SDK für Python (Boto3) in Ihrer virtuellen Umgebung, indem Sie den folgenden Befehl ausführen. Das Skript verwendet diese Bibliothek, um eine Verbindung zu Ihrer DynamoDB-Tabelle herzustellen und die Elemente hinzuzufügen.
```
pip install boto3
```
1. Führen Sie das Skript aus, um die Tabelle zu füllen, indem Sie den folgenden Befehl ausführen.
```
python load_sample_data.py
```
Wenn das Skript erfolgreich läuft, sollte es jedes Element beim Laden auf der Konsole ausgeben und `Data loading completed` melden.
1. Deaktivieren Sie die virtuelle Umgebung, indem Sie den folgenden Befehl ausführen.
```
deactivate
```
1. Sie können überprüfen, ob die Daten in Ihre DynamoDB-Tabelle geladen wurden, indem Sie Folgendes tun:
1. Öffnen Sie die Seite [Elemente untersuchen](https://console.aws.amazon.com/dynamodbv2/home#item-explorer) der DynamoDB-Konsole und wählen Sie Ihre Tabelle (`MyOrderTable`).
1. Im Bereich **Zurückgegebene Elemente** sollten Sie die 25 Elemente aus der CSV-Datei sehen, die das Skript der Tabelle hinzugefügt hat.
## Die App für geplante Wartungsarbeiten erstellen
Sie können die Ressourcen für diese Beispiel-App Schritt für Schritt mithilfe von AWS-Managementkonsole oder mithilfe von erstellen und bereitstellen. AWS SAM In einer Produktionsumgebung empfehlen wir die Verwendung eines Infrustracture-as-Code (IaC-) Tools, mit dem Sie wiederholt serverlose Anwendungen bereitstellen können, ohne manuelle Prozesse AWS SAM zu verwenden.
Folgen Sie in diesem Beispiel den Anweisungen auf der Konsole, um zu erfahren, wie Sie jede AWS Ressource separat konfigurieren, oder folgen Sie den AWS SAM Anweisungen, um die App mithilfe von Befehlen schnell bereitzustellen. AWS CLI
------
#### [ Console ]
**Um die Funktion mit dem zu erstellen AWS-Managementkonsole**
Erstellen Sie zunächst eine Funktion, die den grundlegenden Startercode enthält. Anschließend ersetzen Sie diesen Code durch Ihren eigenen Funktionscode, indem Sie den Code entweder kopieren und direkt im Lambda-Code-Editor einfügen oder Ihren Code als `.zip`-Paket hochladen. Für diese Aufgabe empfehlen wir, den Code zu kopieren und einzufügen.
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie **Funktion erstellen**.
1. Wählen Sie **Author from scratch** aus.
1. Führen Sie unter **Basic information** (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie für **Function name** (Funktionsname) `ScheduledDBMaintenance` ein.
1. Für **Laufzeit** wählen Sie die neueste Python-Version.
1. Wählen Sie für **Architektur** **x86\$164** aus.
1. Wählen Sie **Funktion erstellen**.
1. Nachdem Ihre Funktion erstellt wurde, können Sie Ihre Funktion mit dem bereitgestellten Funktionscode konfigurieren.
1. Ersetzen Sie im Bereich **Codequelle** den Hello World-Code, den Lambda erstellt hat, durch den Python-Funktionscode aus der `lambda_function.py`-Datei, die Sie zuvor gespeichert haben.
1. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**Um den Funktionsspeicher und das Timeout (Konsole) zu konfigurieren**
1. Wählen Sie die Registerkarte **Konfiguration** für Ihre Funktion.
1. Wählen Sie im Bereich **Allgemeine Konfiguration** die Option **Bearbeiten** aus.
1. Stellen Sie **Speicher** auf 256 MB und **Timeout** auf 15 Sekunden ein. Wenn Sie eine große Tabelle mit vielen Datensätzen verarbeiten, z. B. in einer Produktionsumgebung, sollten Sie in Erwägung ziehen, **Timeout** auf einen höheren Wert festzulegen. Dadurch hat Ihre Funktion mehr Zeit zum Scannen und Bereinigen der Datenbank.
1. Wählen Sie **Speichern**.
**So konfigurieren Sie das Protokollformat (Konsole)**
Sie können Lambda-Funktionen so konfigurieren, dass sie Protokolle entweder im unstrukturierten Text- oder im JSON-Format ausgeben. Wir empfehlen, das JSON-Format für Protokolle zu verwenden, um die Protokolldaten einfacher durchsuchen und filtern zu können. Weitere Informationen über die Optionen für die Konfiguration des Lambda-Protokolls finden Sie unter [Konfigurieren erweiterter Protokollierungsoptionen für Lambda-Funktionen](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).
1. Wählen Sie die Registerkarte **Konfiguration** für Ihre Funktion.
1. Wählen Sie **Überwachungs- und Betriebstools** aus.
1. Wählen Sie im Bereich **Protokollierungskonfiguration** die Option **Bearbeiten** aus.
1. Wählen Sie für die **Konfiguration der Protokollierung** **JSON** aus.
1. Wählen Sie **Speichern**.
**So richten Sie IAM-Berechtigungen ein**
Um Ihrer Funktion die erforderlichen Berechtigungen zum Lesen und Löschen von DynamoDB-Elementen zu erteilen, müssen Sie der [Ausführungsrolle](lambda-intro-execution-role.md) Ihrer Funktion eine Richtlinie hinzufügen, die die erforderlichen Berechtigungen definiert.
1. Öffnen Sie die Registerkarte **Konfiguration** und wählen Sie dann in der linken Navigationsleiste **Berechtigungen** aus.
1. Wählen Sie den Rollennamen unter **Ausführungsrolle**.
1. Wählen Sie in der IAM-Konsole **Berechtigungen hinzufügen** und dann **Inline-Richtlinie erstellen** aus.
1. Verwenden Sie den JSON-Editor und geben Sie die folgenden Richtlinien ein:
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:Scan",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/MyOrderTable"
}
]
}
```
1. Geben Sie der Richtlinie **DynamoDBCleanupPolicy** einen Namen und erstellen Sie sie dann.
**Um den EventBridge Scheduler als Trigger einzurichten (Konsole)**
1. Öffnen Sie die [EventBridge -Konsole](https://console.aws.amazon.com/events/home).
1. Wählen Sie im linken Navigationsbereich im Bereich **Scheduler** die Option **Schedulers** aus.
1. Wählen Sie **Zeitplan erstellen** aus.
1. Konfigurieren Sie den Zeitplan, indem Sie wie folgt vorgehen:
1. Geben Sie unter **Zeitplanname** einen Namen für Ihren Zeitplan ein (z. B. **DynamoDBCleanupSchedule**).
1. Wählen Sie unter **Zeitplanmuster** die Option **Wiederkehrender Zeitplan** aus.
1. Belassen Sie für **Zeitplantyp** die Standardeinstellung **Cron-basierter Zeitplan** und geben Sie dann die folgenden Zeitplandetails ein:
+ **Minuten**: **0**
+ **Stunden**: **3**
+ **Tag des Monats**: **1**
+ **Monat**: **\$1**
+ **Wochentag**: **?**
+ **Jahr**: **\$1**
Bei der Auswertung wird dieser Cron-Ausdruck am ersten Tag jedes Monats um 03:00 Uhr ausgeführt.
1. Wählen Sie für **Flexibles Zeitfenster** die Option **Aus**.
1. Wählen Sie **Weiter** aus.
1. Konfigurieren Sie den Auslöser für Ihre Lambda-Funktion folgendermaßen:
1. Lassen Sie im Bereich **Zieldetails** die Einstellung **Ziel-API** auf **Vorgefertigte Ziele** eingestellt und wählen Sie dann **AWS Lambda aufrufen** aus.
1. Wählen Sie unter **Aufrufen** Ihre Lambda-Funktion (`ScheduledDBMaintenance`) aus der Dropdown-Liste aus.
1. Lassen Sie das Feld **Payload** leer und wählen Sie **Weiter**.
1. Scrollen Sie nach unten zu **Berechtigungen** und wählen Sie **Neue Rolle für diesen Zeitplan erstellen** aus. Wenn Sie mit der Konsole einen neuen EventBridge Scheduler-Zeitplan erstellen, erstellt EventBridge Scheduler eine neue Richtlinie mit den erforderlichen Berechtigungen, die der Zeitplan benötigt, um Ihre Funktion aufzurufen. *Weitere Informationen zur Verwaltung Ihrer Zeitplanberechtigungen finden Sie unter [Cron-basierte Zeitpläne. im Scheduler-Benutzerhandbuch](https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html#cron-based). EventBridge *
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie Ihre Einstellungen und wählen Sie **Zeitplan erstellen**, um die Erstellung des Zeitplans und des Lambda-Triggers abzuschließen.
------
#### [ AWS SAM ]
**Um die App bereitzustellen mit AWS SAM**
1. Navigieren Sie zu dem Ordner, in dem Sie die `template.yaml`-Datei für die App gespeichert haben. Beachten Sie, dass in diesem Beispiel zwei `template.yaml`-Dateien verwendet werden. Vergewissern Sie sich, dass sie in separaten Unterordnern gespeichert sind und dass Sie sich im richtigen Ordner befinden, der die Vorlage zur Erstellung Ihrer App enthält.
1. Kopieren Sie die `lambda_function.py`- und `requirements.txt`-Dateien, die Sie zuvor heruntergeladen haben, in denselben Ordner. Der in der AWS SAM Vorlage angegebene Codespeicherort ist`./`, d. h. der aktuelle Standort. AWS SAM sucht in diesem Ordner nach dem Lambda-Funktionscode, wenn Sie versuchen, die App bereitzustellen.
1. Führen Sie den folgenden Befehl aus.
```
sam build --use-container
```
Dieser Befehl sammelt die Build-Artefakte für die Ressourcen, die Sie bereitstellen möchten und platziert sie im richtigen Format und am richtigen Ort, um sie bereitzustellen. Wenn Sie die Option `--use-container` angeben, wird Ihre Funktion innerhalb eines Lambda-ähnlichen Docker-Containers erstellt. Wir verwenden es hier, sodass Sie Python 3.12 nicht auf Ihrem lokalen Computer installiert haben müssen, damit der Build funktioniert.
1. Führen Sie den folgenden Befehl aus, um die in der `template.yaml` Datei angegebenen Lambda- und EventBridge Scheduler-Ressourcen zu erstellen.
```
sam deploy --guided
```
Wenn Sie die `--guided` Markierung verwenden, AWS SAM werden Ihnen Eingabeaufforderungen angezeigt, die Sie durch den Bereitstellungsprozess führen. Geben Sie für diese Bereitstellung ein `Stack name` von **cron-maintenance-app** ein und akzeptieren Sie die Standardeinstellungen für alle anderen Optionen mit der Eingabetaste.
Wenn AWS SAM die Erstellung der Lambda- und EventBridge Scheduler-Ressourcen abgeschlossen ist, sollte die folgende Meldung angezeigt werden.
```
Successfully created/updated stack - cron-maintenance-app in us-west-2
```
1. Sie können außerdem überprüfen, ob die Lambda-Funktion erstellt wurde, indem Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole öffnen. Sie sollten eine Funktion mit dem Namen `ScheduledDBMaintenance` sehen.
------
## Testen der App
Um zu testen, ob Ihr Zeitplan Ihre Funktion korrekt auslöst und ob Ihre Funktion die Datensätze in der Datenbank korrekt bereinigt, können Sie Ihren Zeitplan vorübergehend so ändern, dass er einmal zu einer bestimmten Zeit ausgeführt wird. Sie können dann `sam deploy` erneut ausführen, um Ihren Wiederholungsplan so zurückzusetzen, dass er einmal pro Monat ausgeführt wird.
**Um die Anwendung mit dem auszuführen AWS-Managementkonsole**
1. Navigieren Sie zurück zur EventBridge Scheduler-Konsolenseite.
1. **Wählen Sie Ihren Zeitplan aus und klicken Sie dann auf Bearbeiten**.
1. Wählen Sie im Abschnitt **Zeitplanmuster** unter **Wiederholung** die Option **Einmaliger Zeitplan** aus.
1. Stellen Sie Ihre Aufrufzeit auf ein paar Minuten ein, überprüfen Sie Ihre Einstellungen und wählen Sie dann **Speichern**.
Nachdem der Zeitplan ausgeführt und sein Ziel aufgerufen wurde, führen Sie das `test_app.py`-Skript aus, um zu überprüfen, ob Ihre Funktion erfolgreich alle alten Datensätze aus der DynamoDB-Tabelle entfernt hat.
**Um zu überprüfen, ob alte Datensätze mit einem Python-Skript gelöscht wurden**
1. Navigieren Sie in Ihrer Befehlszeile zu dem Ordner, in dem Sie `test_app.py` gespeichert haben.
1. Führen Sie das Skript aus.
```
python test_app.py
```
Bei Erfolg erhalten Sie die folgende Ausgabe.
```
Total number of old records: 0
```
## Nächste Schritte
Sie können den EventBridge Scheduler-Zeitplan jetzt an Ihre speziellen Anwendungsanforderungen anpassen. EventBridge Scheduler unterstützt die folgenden Zeitplanausdrücke: Cron, Rate und One-Time Schedules.
Weitere Informationen zu EventBridge Scheduler-Zeitplanausdrücken finden Sie unter [Zeitplantypen](https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html) im *EventBridge Scheduler-Benutzerhandbuch*. [Zugriffsverwaltung](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) im *IAM-Benutzerhandbuch*
# Erstellung eines Auftragsabwicklungssystems mit Lambda Durable-Funktionen
**Anmerkung**
ERFORDERLICH: Fügen Sie ein Architekturdiagramm hinzu, das das API Gateway, den Durable Function-Workflow und die unterstützenden Dienste zeigt (DynamoDB,) EventBridge
## Voraussetzungen
+ AWS CLI installiert und konfiguriert
+ BEDARF: Spezifische Anforderungen an langlebige Funktionen
## Erstellen Sie die Quellcodedateien
Erstellen Sie die folgenden Dateien in Ihrem Projektverzeichnis:
+ `lambda_function.py`- der Funktionscode
+ `requirements.txt`- Abhängigkeiten manifestieren sich
### Funktionscode
```
# NEED: Verify correct imports
import boto3
import json
def lambda_handler(event, context):
# NEED: Verify DurableContext syntax
durable = context.durable
try:
# Validate and store order
order = await durable.step('validate', async () => {
return validate_order(event['order'])
})
# Process payment
# NEED: Verify wait syntax
await durable.wait(/* wait configuration */)
# Additional steps
# NEED: Complete implementation
except Exception as e:
# NEED: Error handling patterns
raise e
def validate_order(order_data):
# NEED: Implementation
pass
```
### Anforderungsdatei
```
# NEED: List of required packages
```
## Bereitstellen der Anwendung
### Erstellen Sie eine DynamoDB-Tabelle für Bestellungen
1. Öffnen Sie die DynamoDB-Konsole unter [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. **Wählen Sie Tabelle erstellen**
1. Geben Sie als **Tabellenname** ein **Orders**
1. Geben Sie für **Partitionsschlüssel** Folgendes ein **orderId**
1. Belassen Sie andere Einstellungen als Standard
1. Wählen Sie **Tabelle erstellen**
### So erstellen Sie die Lambda-Funktion:
1. Öffnen Sie die Lambda-Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. Wählen Sie **Create function (Funktion erstellen)**.
1. Wählen Sie **Autor von Grund auf**
1. Geben Sie unter **Funktionsname** **ProcessOrder** ein.
1. Wählen Sie für **Runtime** Ihre bevorzugte Laufzeit
1. ERFORDERLICH: Fügen Sie eine für Durable Functions spezifische Konfiguration hinzu
1. Wählen Sie **Create function (Funktion erstellen)**.
### Erstellen Sie den API-Gateway-Endpunkt
1. Öffnen Sie die API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigateway/](https://console.aws.amazon.com/apigateway/)
1. Wählen Sie **Create API**
1. Wählen Sie **HTTP-API**
1. Wählen Sie **Build**
1. Fügen Sie eine Integration mit Ihrer Lambda-Funktion hinzu
1. Konfigurieren Sie Routen für die Auftragsabwicklung
1. Bereitstellen der API
## Testen der Anwendung
Reichen Sie eine Testbestellung ein:
```
{
"orderId": "12345",
"items": [
{
"productId": "ABC123",
"quantity": 1
}
]
}
```
ERFORDERLICH: Fügen Sie spezifische Überwachungsanweisungen für langlebige Funktionen hinzu
## Nächste Schritte
### Geschäftslogik hinzufügen
Implementieren Sie die Inventarverwaltung:
```
async def check_inventory(order):
# Add inventory check logic
pass
```
Preisberechnungen hinzufügen:
```
async def calculate_total(order):
# Add pricing logic
pass
```
### Verbessern Sie die Fehlerbehandlung
Vergütungslogik hinzufügen:
```
async def reverse_payment(order):
# Add payment reversal logic
pass
```
Stornierungen von Bestellungen bearbeiten:
```
async def cancel_order(order):
# Add cancellation logic
pass
```
### Integrieren Sie externe Systeme
```
async def notify_shipping_provider(order):
# Add shipping integration
pass
async def send_customer_notification(order):
# Add notification logic
pass
```
### Verbessern Sie die Überwachung
+ Erstellen Sie CloudWatch Dashboards
+ Richten Sie Kennzahlen für die Bearbeitungszeiten von Bestellungen ein
+ Konfigurieren Sie Benachrichtigungen für verspätete Bestellungen