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.

# Erstellen Sie eine App, um eine geplante Datenbankwartung durchzuführen
<a name="scheduled-task-app"></a>

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
<a name="scheduled-task-app-prereqs"></a>

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
<a name="scheduled-task-app-download"></a>

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)
<a name="scheduled-task-app-table-yaml"></a>

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
<a name="scheduled-task-app-csv-file"></a>

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
<a name="scheduled-task-app-load-script"></a>

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
<a name="scheduled-task-app-function-code"></a>

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
<a name="scheduled-task-app-dependencies"></a>

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)
<a name="scheduled-task-app-table-yaml"></a>

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
<a name="scheduled-task-app-test-script"></a>

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
<a name="scheduled-task-app-create-table"></a>

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
<a name="scheduled-task-app-create-app"></a>

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
<a name="scheduled-task-app-test-app"></a>

 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
<a name="scheduled-task-app-next-steps"></a>

 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*