Verwenden von Lambda mit Infrastructure as Code (IaC) - AWS Lambda
IaC-Tools für LambdaErste Schritte mit IaC für LambdaNächste SchritteUnterstützte Regionen für die Lambda-Integration mit Application Composer

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.

Verwenden von Lambda mit Infrastructure as Code (IaC)

Lambda bietet verschiedene Möglichkeiten, Ihren Code bereitzustellen und Funktionen zu erstellen. Sie können beispielsweise die Lambda-Konsole oder die AWS Command Line Interface (AWS CLI) verwenden, um Lambda-Funktionen manuell zu erstellen oder zu aktualisieren. Zusätzlich zu diesen manuellen Optionen bietet AWS eine Reihe von Lösungen für die Bereitstellung von Lambda-Funktionen und Serverless-Anwendungen mithilfe von Infrastructure as Code (IaC). Mit IaC können Sie Lambda-Funktionen und andere AWS-Ressourcen mithilfe von Code bereitstellen und verwalten, anstatt manuelle Prozesse und Einstellungen zu verwenden.

In den meisten Fällen werden Lambda-Funktionen nicht isoliert ausgeführt. Stattdessen sind sie Teil einer Serverless-Anwendung, zu der auch andere Ressourcen wie Datenbanken, Warteschlangen und Speicher gehören. Mit IaC können Sie Ihre Bereitstellungsprozesse automatisieren, um ganze Serverless-Anwendungen mit vielen separaten AWS-Ressourcen schnell und wiederholbar bereitzustellen und zu aktualisieren. Dieser Ansatz beschleunigt Ihren Entwicklungszyklus, erleichtert die Konfigurationsverwaltung und stellt sicher, dass Ihre Ressourcen jedes Mal auf die gleiche Weise bereitgestellt werden.

IaC-Tools für Lambda

Um Lambda-Funktionen und Serverless-Anwendungen mithilfe von IaC bereitzustellen, bietet AWS eine Reihe verschiedener Tools und Services.

AWS CloudFormation war der erste Service, der von AWS zur Erstellung und Konfiguration von Cloud-Ressourcen angeboten wurde. Mit AWS CloudFormation erstellen Sie Textvorlagen zur Definition von Infrastruktur und Code. Als in AWS immer mehr neue Services eingeführt wurden und die Erstellung von AWS CloudFormation-Vorlagen immer komplexer wurde, wurden zwei weitere Tools veröffentlicht. AWS SAM ist ein weiteres auf Vorlagen basierendes Framework zur Definition von Serverless-Anwendungen. Bei AWS Cloud Development Kit (AWS CDK) handelt es sich um einen Ansatz, bei dem der Code an erster Stelle steht, um Infrastruktur mithilfe von Code-Konstrukten in vielen gängigen Programmiersprachen zu definieren und bereitzustellen.

Mit sowohl AWS SAM als auch AWS CDK arbeitet AWS CloudFormation im Hintergrund, um Ihre Infrastruktur aufzubauen und bereitzustellen. Die folgende Abbildung veranschaulicht die Beziehung zwischen diesen Tools und in den Absätzen nach dem Diagramm werden ihre wichtigsten Funktionen erläutert.

Das Diagramm zeigt, wie AWS SAM und AWS CDK sowohl AWS-Ressourcen als auch Code mithilfe von AWS CloudFormation bereitstellen, wodurch der Anwendungs-Stack entsteht.

  • AWS CloudFormation – Wenn CloudFormation Sie Ihre AWS Ressourcen mithilfe einer YAML- oder JSON-Vorlage modellieren und einrichten, die Ihre Ressourcen und deren Eigenschaften beschreibt. CloudFormation stellt Ihre Ressourcen auf sichere, wiederholbare Weise bereit, sodass Sie Ihre Infrastruktur und Anwendungen häufig ohne manuelle Schritte erstellen können. Wenn Sie die Konfiguration ändern, CloudFormation bestimmt die richtigen Operationen, die zum Aktualisieren Ihres Stacks ausgeführt werden sollen. CloudFormation kann Änderungen sogar rückgängig machen.

  • AWS Serverless Application Model (AWS SAM) – AWS SAM ist ein Open-Source-Framework für die Definition von Serverless-Anwendungen. In den AWS SAM-Vorlagen wird eine Kurzsyntax verwendet, um Funktionen, APIs, Datenbanken und Zuordnungen von Ereignisquellen mit nur wenigen Textzeilen (YAML) pro Ressource zu definieren. Während der Bereitstellung transformiert und erweitert AWS SAM die AWS SAM-Syntax in eine AWS CloudFormation-Syntax. Aus diesem Grund kann jede CloudFormation Syntax zu AWS SAM Vorlagen hinzugefügt werden. Dies bietet die AWS SAM volle Leistung von CloudFormation, jedoch mit weniger Konfigurationszeilen.

  • AWS Cloud Development Kit (AWS CDK) – Mit der definieren AWS CDKSie Ihre Infrastruktur mithilfe von Codekonstrukten und stellen sie über bereitAWS CloudFormation. AWS CDK ermöglicht es Ihnen, die Anwendungsinfrastruktur mit TypeScript, Python, Java, .NET und Go (in der Entwicklervorschau) mithilfe Ihrer vorhandenen IDE, Testtools und Workflow-Muster zu modellieren. Sie erhalten alle Vorteile von AWS CloudFormation, einschließlich wiederholbarer Bereitstellung, einfachem Rollback und Erkennung von Abweichungen.

AWS bietet außerdem einen Service namens AWS Application Composer zur Entwicklung von IaC-Vorlagen mithilfe einer einfachen grafischen Oberfläche. Mit Application Composer entwerfen Sie eine Anwendungsarchitektur, indem Sie AWS-Services auf einer visuellen Zeichenfläche ziehen, gruppieren und verbinden. Application Composer erstellt dann eine AWS SAM-Vorlage oder eine AWS CloudFormation-Vorlage aus Ihrem Entwurf, die Sie zur Bereitstellung Ihrer Anwendung verwenden können.

Im folgenden Abschnitt Erste Schritte mit IaC für Lambda verwenden Sie Application Composer, um eine Vorlage für eine Serverless-Anwendung zu entwickeln, die auf einer vorhandenen Lambda-Funktion basiert.

Erste Schritte mit IaC für Lambda

In diesem Tutorial können Sie mit der Verwendung von IaC mit Lambda beginnen, indem Sie eine AWS SAM-Vorlage aus einer vorhandenen Lambda-Funktion erstellen und dann eine Serverless-Anwendung in Application Composer erstellen, indem Sie weitere AWS-Ressourcen hinzufügen.

Wenn Sie lieber mit einem AWS SAM- oder AWS CloudFormation-Tutorial beginnen möchten, um zu lernen, wie Sie mit Vorlagen arbeiten können, ohne Application Composer zu verwenden, finden Sie im Abschnitt Nächste Schritte am Ende dieser Seite Links zu anderen Ressourcen.

Während Sie dieses Tutorial durchführen, lernen Sie einige grundlegende Konzepte kennen, z. B. wie AWS-Ressourcen in AWS SAM angegeben werden. Zudem erfahren Sie, wie Sie mit Application Composer eine Serverless-Anwendung erstellen, die Sie mit AWS SAM oder AWS CloudFormation bereitstellen können.

Führen Sie für dieses Tutorial die folgenden Schritte aus:

  • Erstellen Sie eine Beispiel-Lambda-Funktion.

  • Verwenden Sie die Lambda-Konsole, um die AWS SAM-Vorlage für die Funktion anzuzeigen.

  • Exportieren Sie die Konfiguration Ihrer Funktion nach AWS Application Composer und entwerfen Sie eine einfache Serverless-Anwendung, die auf der Konfiguration Ihrer Funktion basiert.

  • Speichern Sie eine aktualisierte AWS SAM-Vorlage, die Sie als Grundlage für die Bereitstellung Ihrer Serverless-Anwendung verwenden können.

Im Abschnitt Nächste Schritte finden Sie Ressourcen, mit denen Sie mehr über AWS SAM und Application Composer erfahren können. Diese Ressourcen enthalten Links zu Tutorials für Fortgeschrittene, in denen Sie lernen, wie Sie eine Serverless-Anwendung mit AWS SAM bereitstellen.

Voraussetzungen

In diesem Tutorial verwenden Sie die Funktion für die lokale Synchronisierung von Application Composer, um Ihre Vorlagen- und Codedateien auf Ihrem lokalen Build-Computer zu speichern. Um diese Funktion nutzen zu können, benötigen Sie einen Browser, der die File System Access-API unterstützt. Damit können Webanwendungen Dateien in Ihrem lokalen Dateisystem lesen, schreiben und speichern. Wir empfehlen, entweder Google Chrome oder Microsoft Edge zu verwenden. Weitere Informationen zur File System Access-API finden Sie unter Was ist die File System Access-API?.

Erstellen einer Lambda-Funktion

In diesem ersten Schritt erstellen Sie eine Lambda-Funktion, mit der Sie den Rest des Tutorials abschließen können. Der Einfachheit halber verwenden Sie die Lambda-Konsole, um mithilfe der Python 3.11-Laufzeit eine grundlegende „Hello World“-Funktion zu erstellen.

So erstellen Sie eine „Hello World“-Lambda-Funktion mit der Konsole

  1. Öffnen Sie die Lambda-Konsole.

  2. Wählen Sie Funktion erstellen.

  3. Lassen Sie Ohne Vorgabe erstellen ausgewählt. Geben Sie im Feld Grundlegende Informationen für Funktionsname LambdaIaCDemo ein.

  4. Wählen Sie für Laufzeit die Option Python 3.11 aus.

  5. Wählen Sie Funktion erstellen.

Sehen Sie sich die AWS SAM-Vorlage für Ihre Funktion an.

Bevor Sie die Konfiguration Ihrer Funktion nach Application Composer exportieren, verwenden Sie die Lambda-Konsole, um die aktuelle Konfiguration Ihrer Funktion als AWS SAM-Vorlage anzuzeigen. Wenn Sie die Schritte in diesem Abschnitt befolgen, erfahren Sie mehr über den Aufbau einer AWS SAM-Vorlage und darüber, wie Sie Ressourcen wie Lambda-Funktionen definieren, um mit der Spezifizierung einer Serverless-Anwendung zu beginnen.

So sehen Sie sich die AWS SAM-Vorlage für Ihre Funktion an

  1. Öffnen Sie die Seite Funktionen der Lambda-Konsole.

  2. Wählen Sie die Funktion aus, die Sie gerade erstellt haben (LambdaIaCDemo).

  3. Wählen Sie im Bereich Funktionsübersicht die Option Vorlage.

    Anstelle des Diagramms, das die Konfiguration Ihrer Funktion darstellt, wird eine AWS SAM-Vorlage für Ihre Funktion angezeigt. Die Vorlage sollte jetzt wie folgt aussehen:

    # This AWS SAM template has been generated from your function's 
# configuration. If your function has one or more triggers, note 
# that the AWS resources associated with these triggers aren't fully 
# specified in this template and include placeholder values.Open this template 
# in AWS Application Composer or your favorite IDE and modify 
# it to specify a serverless application with other AWS resources. 
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Specification template describing your function.
Resources:
  LambdaIaCDemo:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: .
      Description: ''
      MemorySize: 128
      Timeout: 3
      Handler: lambda_function.lambda_handler
      Runtime: python3.11
      Architectures:
        - x86_64
      EventInvokeConfig:
        MaximumEventAgeInSeconds: 21600
        MaximumRetryAttempts: 2
      EphemeralStorage:
        Size: 512
      RuntimeManagementConfig:
        UpdateRuntimeOn: Auto
      SnapStart:
        ApplyOn: None
      PackageType: Zip
      Policies:
        Statement:
          - Effect: Allow
            Action:
              - logs:CreateLogGroup
            Resource: arn:aws:logs:us-east-1:123456789012:*
          - Effect: Allow
            Action:
              - logs:CreateLogStream
              - logs:PutLogEvents
            Resource:
              - >-
                arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/LambdaIaCDemo:*

Nehmen wir uns einen Moment Zeit, um uns die YAML-Vorlage für Ihre Funktion anzusehen und einige wichtige Konzepte zu verstehen.

Die Vorlage beginnt mit der Deklaration Transform: AWS::Serverless-2016-10-31. Diese Deklaration ist erforderlich, weil im Hintergrund AWS SAM-Vorlagen über AWS CloudFormation bereitgestellt werden. Mithilfe der Transform-Anweisung wird die Vorlage als AWS SAM-Vorlagendatei identifiziert.

Nach der Transform-Deklaration folgt der Resources-Abschnitt. Hier werden die AWS-Ressourcen definiert, die Sie mit Ihrer AWS SAM-Vorlage bereitstellen möchten. AWS SAM-Vorlagen können eine Kombination aus AWS SAM-Ressourcen und AWS CloudFormation-Ressourcen enthalten. Das liegt daran, dass AWS SAM-Vorlagen bei der Bereitstellung zu AWS CloudFormation-Vorlagen erweitert werden, sodass jeder AWS SAM-Vorlage jede gültige AWS CloudFormation-Syntax hinzugefügt werden kann.

Im Moment ist im Abschnitt Resources der Vorlage nur eine Ressource definiert, Ihre Lambda-Funktion LambdaIaCDemo. Um einer AWS SAM-Vorlage eine Lambda-Funktion hinzuzufügen, verwenden Sie den AWS::Serverless::Function-Ressourcentyp. Die Properties der Ressource einer Lambda-Funktion definieren die Laufzeit, den Funktionshandler und andere Konfigurationsoptionen der Funktion. Der Pfad zum Quellcode Ihrer Funktion, den AWS SAM für die Bereitstellung der Funktion verwenden soll, ist hier ebenfalls definiert. Weitere Informationen zu Lambda-Funktionsressourcen in finden Sie AWS SAMunter AWS::Serverless::Function im AWS SAM -Entwicklerhandbuch.

Neben den Funktionseigenschaften und Konfigurationen ist in der Vorlage auch eine AWS Identity and Access Management-Richtlinie (IAM) für Ihre Funktion angegeben. Diese Richtlinie erteilt Ihrer Funktion die Berechtigung, Protokolle in Amazon CloudWatch Logs zu schreiben. Wenn Sie eine Funktion in der Lambda-Konsole erstellen, hängt Lambda diese Richtlinie automatisch an Ihre Funktion an. Weitere Informationen zum Angeben einer IAM-Richtlinie für eine Funktion in einer -AWS SAMVorlage finden Sie in der -policiesEigenschaft auf der -AWS::Serverless::FunctionSeite des AWS SAM -Entwicklerhandbuchs.

Weitere Informationen zur Struktur von AWS SAM-Vorlagen finden Sie unter AWS SAM-Vorlagenaufbau.

Verwenden von AWS Application Composer zum Entwerfen einer Serverless-Anwendung

Um mit der Erstellung einer einfachen Serverless-Anwendung zu beginnen, die die AWS SAM-Vorlage Ihrer Funktion als Ausgangspunkt verwendet, exportieren Sie Ihre Funktionskonfiguration nach Application Composer und aktivieren den lokalen Synchronisierungsmodus von Application Composer. Die Funktion für die lokale Synchronisierung speichert den Code Ihrer Funktion und Ihre AWS SAM-Vorlage automatisch auf Ihrem lokalen Build-Computer und sorgt dafür, dass Ihre gespeicherte Vorlage synchronisiert wird, wenn Sie weitere AWS-Ressourcen in Application Composer hinzufügen.

So exportieren Sie Ihre Funktion nach Application Composer

  1. Wählen Sie im Bereich Funktionsübersicht die Option Nach Application Composer exportieren aus.

    Um die Konfiguration und den Code Ihrer Funktion nach Application Composer zu exportieren, erstellt Lambda einen Amazon-S3-Bucket in Ihrem Konto, um diese Daten vorübergehend zu speichern.

  2. Wählen Sie im Dialogfeld Projekt bestätigen und erstellen aus, um den Standardnamen für diesen Bucket zu akzeptieren und die Konfiguration und den Code Ihrer Funktion nach Application Composer zu exportieren.

  3. (Optional) Um einen anderen Namen für den von Lambda erstellten Amazon-S3-Bucket auszuwählen, geben Sie einen neuen Namen ein und wählen Sie Projekt bestätigen und erstellen aus. Die Amazon-S3-Bucket-Namen müssen global eindeutig sein und den Regeln für die Benennung von Buckets entsprechen.

    Wenn Sie Projekt bestätigen und erstellen auswählen, wird die Application-Composer-Konsole geöffnet. Auf der Zeichenfläche sehen Sie Ihre Lambda-Funktion.

  4. Wählen Sie in der Menü-Dropdown-Liste die Option Lokale Synchronisierung aktivieren aus.

  5. Wählen Sie in dem sich öffnenden Dialogfeld die Option Ordner auswählen aus und wählen Sie einen Ordner auf Ihrem lokalen Build-Computer aus.

  6. Wählen Sie Aktivieren aus, um die lokale Synchronisierung zu aktivieren.

Zum Exportieren Ihrer Funktion nach Application Composer benötigen Sie die Berechtigung zur Verwendung von bestimmten API-Aktionen. Wenn Sie Ihre Funktion nicht exportieren können, beachten Sie Erforderliche Berechtigungen und stellen Sie sicher, dass Sie über die erforderlichen Berechtigungen verfügen.

Anmerkung

Für den Bucket, den Lambda erstellt, wenn Sie eine Funktion nach Application Composer exportieren, gelten die Amazon-S3-Standardpreise. Die Objekte, die Lambda in den Bucket einfügt, werden nach 10 Tagen automatisch gelöscht, aber Lambda löscht den Bucket selbst nicht.

Folgen Sie den Anweisungen unter Löschen eines Buckets, nachdem Sie Ihre Funktion nach Application Composer exportiert haben, um zu vermeiden, dass für Ihr AWS-Konto zusätzliche Kosten anfallen. Weitere Informationen zum Amazon-S3-Bucket-Namen, den Lamda erstellt, finden Sie unter Verwenden AWS Lambda mit AWS Application Composer.

So entwerfen Sie Ihre Serverless-Anwendung in Application Composer

Nach der Aktivierung der lokalen Synchronisierung werden die Änderungen, die Sie in Application Composer vornehmen, in der AWS SAM-Vorlage widergespiegelt, die auf Ihrer lokalen Build-Maschine gespeichert ist. Sie können jetzt zusätzliche AWS-Ressourcen per Drag-and-Drop auf die Application-Composer-Zeichenfläche ziehen, um Ihre Anwendung zu erstellen. In diesem Beispiel fügen Sie eine einfache Amazon-SQS-Warteschlange als Trigger für Ihre Lambda-Funktion und eine DynamoDB-Tabelle für die Funktion hinzu, in die Daten geschrieben werden sollen.

  1. Fügen Sie Ihrer Lambda-Funktion einen Amazon-SQS-Trigger hinzu, indem Sie wie folgt vorgehen:

    1. Geben Sie im Suchfeld in der Ressourcenpalette SQS ein.

    2. Ziehen Sie die Ressource SQS-Warteschlange auf Ihre Zeichenfläche und positionieren Sie sie links neben Ihrer Lambda-Funktion.

    3. Wählen Sie Details und geben Sie LambdaIaCQueue als Logische ID ein.

    4. Wählen Sie Speichern.

    5. Verbinden Sie Ihre Amazon-SQS- und Lambda-Ressourcen, indem Sie auf der SQS-Warteschlangenkarte auf den Port Abonnement klicken und ihn auf den linken Port auf der Lambda-Funktionskarte ziehen. Das Erscheinen einer Linie zwischen den beiden Ressourcen weist auf eine erfolgreiche Verbindung hin. Application Composer zeigt außerdem unten auf der Zeichenfläche eine Meldung an, die darauf hinweist, dass die beiden Ressourcen erfolgreich verbunden wurden.

  2. Fügen Sie eine Amazon-DynamoDB-Tabelle für Ihre Lambda-Funktion hinzu, in die Daten geschrieben werden sollen, indem Sie so vorgehen:

    1. Geben Sie im Suchfeld in der Ressourcenpalette DynamoDB ein.

    2. Ziehen Sie die Ressource DynamoDB-Tabelle auf Ihre Zeichenfläche und positionieren Sie sie rechts neben Ihrer Lambda-Funktion.

    3. Wählen Sie Details und geben Sie LambdaIaCTable als Logische ID ein.

    4. Wählen Sie Speichern.

    5. Verbinden Sie die DynamoDB-Tabelle mit Ihrer Lambda-Funktion, indem Sie auf den rechten Port der Lambda-Funktionskarte klicken und ihn auf den linken Port der DynamoDB-Karte ziehen.

Nachdem Sie diese zusätzlichen Ressourcen hinzugefügt haben, werfen wir einen Blick auf die aktualisierte AWS SAM-Vorlage, die Application Composer erstellt hat.

So zeigen Sie Ihre aktualisierte AWS SAM-Vorlage an

  • Wählen Sie auf der Application-Composer-Zeichenfläche Vorlage, um von der Zeichenflächenansicht zur Vorlagenansicht zu wechseln.

Ihre AWS SAM-Vorlage sollte jetzt die folgenden zusätzlichen Ressourcen und Eigenschaften enthalten:

  • Eine Amazon-SQS-Warteschlange mit der ID LambdaIaCQueue

    LambdaIaCQueue:
    Type: AWS::SQS::Queue
    Properties:
      MessageRetentionPeriod: 345600

    Wenn Sie mit Application Composer eine Amazon-SQS-Warteschlange hinzufügen, legt Application Composer die MessageRetentionPeriod-Eigenschaft fest. Sie können die FifoQueue-Eigenschaft auch festlegen, indem Sie auf der SQS-Warteschlangenkarte Details auswählen und die Fifo-Warteschlange aktivieren oder deaktivieren.

    Um weitere Eigenschaften für Ihre Warteschlange festzulegen, können Sie die Vorlage manuell bearbeiten, um sie hinzuzufügen. Weitere Informationen zur AWS::SQS::Queue-Ressource und ihre verfügbaren Eigenschaften finden Sie unter AWS::SQS::Queue im AWS CloudFormation-Benutzerhandbuch.

  • Eine Events-Eigenschaft in Ihrer Lambda-Funktionsdefinition, die die Amazon-SQS-Warteschlange als Trigger für die Funktion angibt

    Events:
  LambdaIaCQueue:
    Type: SQS
    Properties:
      Queue: !GetAtt LambdaIaCQueue.Arn
      BatchSize: 1

    Die Events-Eigenschaft besteht aus einem Ereignistyp und einer Reihe von Eigenschaften, die vom Typ abhängen. Weitere Informationen zu den verschiedenen , die AWS-Services Sie konfigurieren können, um eine Lambda-Funktion auszulösen, und zu den Eigenschaften, die Sie festlegen können, finden Sie EventSource unter im AWS SAM -Entwicklerhandbuch.

  • Eine DynamoDB-Tabelle mit dem Bezeichner LambdaIaCTable

    LambdaIaCTable:
    Type: AWS::DynamoDB::Table
    Properties:
      AttributeDefinitions:
        - AttributeName: id
          AttributeType: S
      BillingMode: PAY_PER_REQUEST
      KeySchema:
        - AttributeName: id
          KeyType: HASH
      StreamSpecification:
        StreamViewType: NEW_AND_OLD_IMAGES

    Wenn Sie mit Application Composer eine DynamoDB-Tabelle hinzufügen, können Sie die Schlüssel Ihrer Tabelle festlegen, indem Sie auf der DynamoDB-Tabellenkarte Details auswählen und die Schlüsselwerte bearbeiten. Application Composer legt auch Standardwerte für eine Reihe anderer Eigenschaften fest, darunter BillingMode und StreamViewType.

    Weitere Informationen zu diesen und anderen Eigenschaften, die Sie Ihrer AWS SAM-Vorlage hinzufügen können, finden Sie unter AWS::DynamoDB::Table im AWS CloudFormation-Benutzerhandbuch.

  • Eine neue IAM-Richtlinie, die Ihrer Funktion die Berechtigung gewährt, CRUD-Operationen für die von Ihnen hinzugefügte DynamoDB-Tabelle auszuführen.

    Policies:
...
  - DynamoDBCrudPolicy:
    TableName: !Ref LambdaIaCTable

Die endgültige vollständige AWS SAM-Vorlage sollte jetzt so aussehen:

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Specification template describing your function.
Resources:
  LambdaIaCDemo:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: .
      Description: ''
      MemorySize: 128
      Timeout: 3
      Handler: lambda_function.lambda_handler
      Runtime: python3.11
      Architectures:
        - x86_64
      EventInvokeConfig:
        MaximumEventAgeInSeconds: 21600
        MaximumRetryAttempts: 2
      EphemeralStorage:
        Size: 512
      RuntimeManagementConfig:
        UpdateRuntimeOn: Auto
      SnapStart:
        ApplyOn: None
      PackageType: Zip
      Policies:
        - Statement:
            - Effect: Allow
              Action:
                - logs:CreateLogGroup
              Resource: arn:aws:logs:us-east-1:594035263019:*
            - Effect: Allow
              Action:
                - logs:CreateLogStream
                - logs:PutLogEvents
              Resource:
                - arn:aws:logs:us-east-1:594035263019:log-group:/aws/lambda/LambdaIaCDemo:*
        - DynamoDBCrudPolicy:
            TableName: !Ref LambdaIaCTable
      Events:
        LambdaIaCQueue:
          Type: SQS
          Properties:
            Queue: !GetAtt LambdaIaCQueue.Arn
            BatchSize: 1
      Environment:
        Variables:
          LAMBDAIACTABLE_TABLE_NAME: !Ref LambdaIaCTable
          LAMBDAIACTABLE_TABLE_ARN: !GetAtt LambdaIaCTable.Arn
  LambdaIaCQueue:
    Type: AWS::SQS::Queue
    Properties:
      MessageRetentionPeriod: 345600
  LambdaIaCTable:
    Type: AWS::DynamoDB::Table
    Properties:
      AttributeDefinitions:
        - AttributeName: id
          AttributeType: S
      BillingMode: PAY_PER_REQUEST
      KeySchema:
        - AttributeName: id
          KeyType: HASH
      StreamSpecification:
        StreamViewType: NEW_AND_OLD_IMAGES

Stellen Sie Ihre Serverless-Anwendung mithilfe von AWS SAM (optional) bereit

Wenn Sie AWS SAM verwenden möchten, um eine Serverless-Anwendung mithilfe der Vorlage bereitzustellen, die Sie gerade in Application Composer erstellt haben, müssen Sie zuerst die AWS SAM-CLI installieren. Befolgen Sie hierzu die Anweisungen unter Installieren der AWS SAM-CLI.

Bevor Sie Ihre Anwendung bereitstellen, müssen Sie auch den Funktionscode aktualisieren, den Application Composer zusammen mit Ihrer Vorlage gespeichert hat. Derzeit enthält die von Application Composer gespeicherte lambda_function.py-Datei nur den grundlegenden „Hello World“-Code, den Lambda bei der Erstellung der Funktion bereitgestellt hat.

Um Ihren Funktionscode zu aktualisieren, kopieren Sie den folgenden Code und fügen Sie ihn in die lambda_function.py-Datei ein, die Application Composer auf Ihrer lokalen Build-Maschine gespeichert hat. Sie haben das Verzeichnis, in dem Application Composer diese Datei speichern soll, beim Aktivieren des Modus „Lokale Synchronisation“ angegeben.

Dieser Code akzeptiert ein Schlüssel-Wert-Paar in einer Nachricht von der Amazon-SQS-Warteschlange, die Sie in Application Composer erstellt haben. Wenn sowohl der Schlüssel als auch der Wert Zeichenfolgen sind, verwendet der Code diese Werte, um ein Element in die in Ihrer Vorlage definierte DynamoDB-Tabelle zu schreiben.

import boto3
import os
import json

# define the DynamoDB table that Lambda will connect to
tablename = os.environ['LAMBDAIACTABLE_TABLE_NAME']

# create the DynamoDB resource
dynamo = boto3.client('dynamodb')

def lambda_handler(event, context):
    # get the message out of the SQS event
    message = event['Records'][0]['body']
    data = json.loads(message)
    # write event data to DDB table
    if check_message_format(data):
        key = next(iter(data))
        value = data[key]
        dynamo.put_item(
            TableName=tablename,
            Item={
                'id': {'S': key},
                'Value': {'S': value}
            }
        )
    else:
        raise ValueError("Input data not in the correct format")

# check that the event object contains a single key value  
# pair that can be written to the database
def check_message_format(message):
    if len(message) != 1:
        return False
        
    key, value = next(iter(message.items()))
    
    if not (isinstance(key, str) and isinstance(value, str)):
        return False

    else:
        return True
So stellen Sie Ihre Serverless-Anwendung bereit

Gehen Sie wie folgt vor, um Ihre Anwendung mithilfe der AWS SAM-CLI bereitzustellen. Damit Ihre Funktion korrekt erstellt und bereitgestellt werden kann, muss die Python-Version 3.11 auf Ihrem Build-Computer und in Ihrem PATH installiert sein.

  1. Führen Sie den folgenden Befehl in dem Verzeichnis aus, in dem Application Composer Ihre Dateien template.yaml und lambda_function.py gespeichert hat.

    sam build

    Dieser Befehl sammelt die Build-Artefakte für Ihre Anwendung und platziert sie im richtigen Format und am richtigen Ort, um sie bereitzustellen.

  2. Führen Sie den folgenden Befehl aus, um Ihre Anwendung bereitzustellen und die in Ihrer AWS SAM-Vorlage angegebenen Lambda-, Amazon-SQS- und DynamoDB-Ressourcen zu erstellen.

    sam deploy --guided

    Wenn Sie die --guided-Markierung verwenden, werden Ihnen in AWS SAM 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 AWS CloudFormation-Stack mit dem Namen sam-app

  • Eine Lambda-Funktion mit dem Namensformat sam-app-LambdaIaCDemo-99VXPpYQVv1M

  • Eine Amazon-SQS-Warteschlange mit dem Namensformat sam-app-LambdaIaCQueue-xL87VeKsGiIo

  • Eine DynamoDB-Tabelle mit dem Namensformat sam-app-LambdaIaCTable-CN0S66C0VLNV

AWS SAM erstellt auch die erforderlichen IAM-Rollen und -Richtlinien, sodass Ihre Lambda-Funktion Nachrichten aus der Amazon-SQS-Warteschlange lesen und CRUD-Operationen in der DynamoDB-Tabelle ausführen kann.

Weitere Informationen zur Bereitstellung von Serverless-Anwendungen mithilfe von AWS SAM finden Sie in den Ressourcen im Abschnitt Nächste Schritte.

Testen der bereitgestellten Anwendung (optional)

Um zu überprüfen, ob Ihre Serverless-Anwendung korrekt bereitgestellt wurde, senden Sie eine Nachricht an Ihre Amazon-SQS-Warteschlange, die ein Schlüssel-Wert-Paar enthält, und überprüfen Sie, ob Lambda mit diesen Werten ein Element in Ihre DynamoDB-Tabelle schreibt.

So testen Sie Ihre Serverless-Anwendung

  1. Öffnen Sie die Seite Warteschlangen der Amazon-SQS-Konsole und wählen Sie die Warteschlange aus, die AWS SAM aus Ihrer Vorlage erstellt hat. Der Name weist das Format sam-app-LambdaIaCQueue-xL87VeKsGiIo auf.

  2. Wählen Sie Nachrichten senden und empfangen aus und fügen Sie den folgenden JSON in den Nachrichtentext im Abschnitt Nachricht senden ein.

    {
    "myKey": "myValue"
}

  3. Klicken Sie auf Send Message (Nachricht senden).

    Wenn Sie Ihre Nachricht an die Warteschlange senden, ruft Lambda Ihre Funktion über Ihre Zuordnung von Ereignisquellen auf, die in Ihrer AWS SAM-Vorlage definiert ist. Um zu bestätigen, dass Lambda Ihre Funktion wie erwartet aufgerufen hat, vergewissern Sie sich, dass Ihrer DynamoDB-Tabelle ein Element hinzugefügt wurde.

  4. Öffnen Sie die Seite Tabellen der DynamoDB-Konsole und wählen Sie Ihre Tabelle aus. Der Name weist das Format sam-app-LambdaIaCTable-CN0S66C0VLNV auf.

  5. Wählen Sie Explore Table Items (Tabellenelemente erkudnen) aus. Im Bereich Zurückgegebene Elemente sollten Sie ein Element mit der ID myKey und dem Wert myValue sehen.

Nächste Schritte

Um mehr über die Verwendung von Application Composer mit AWS SAM und AWS CloudFormation zu erfahren, beginnen Sie mit Verwenden von Application Composer mit AWS CloudFormation und AWS SAM.

Für ein geführtes Tutorial, bei dem AWS SAM zur Bereitstellung einer in Application Composer entwickelten Serverless-Anwendung verwendet wird, empfehlen wir Ihnen außerdem, das AWS Application Composer-Tutorial im AWS-Workshop für Serverless-Muster durchzuführen.

AWS SAM bietet eine Befehlszeilenschnittstelle (CLI), die Sie zusammen mit AWS SAM-Vorlagen und unterstützten Integrationen von Drittanbietern verwenden können, um Ihre Serverless-Anwendungen zu erstellen und auszuführen. Mit der AWS SAM-CLI können Sie Ihre Anwendung erstellen und bereitstellen, lokale Tests und Debugging durchführen, CI/CD-Pipelines konfigurieren und vieles mehr. Weitere Informationen zur Verwendung der AWS SAM-CLI finden Sie unter Erste Schritte mit AWS SAM im AWS Serverless Application Model-Entwicklerleitfaden.

Um zu erfahren, wie Sie mithilfe der AWS CloudFormation-Konsole eine Serverless-Anwendung mit einer AWS SAM-Vorlage bereitstellen, beginnen Sie mit Verwenden der AWS CloudFormation-Konsole im AWS CloudFormation-Benutzerhandbuch.

Unterstützte Regionen für die Lambda-Integration mit Application Composer

Die Lambda-Integration in Application Composer wird in den folgenden AWS-Regionen unterstützt:

  • USA Ost (Nord-Virginia)

  • USA Ost (Ohio)

  • USA West (Nordkalifornien)

  • USA West (Oregon)

  • Africa (Cape Town)

  • Asien-Pazifik (Hongkong)

  • Asien-Pazifik (Hyderabad)

  • Asien-Pazifik (Jakarta)

  • Asien-Pazifik (Melbourne)

  • Asien-Pazifik (Mumbai)

  • Asia Pacific (Osaka)

  • Asia Pacific (Seoul)

  • Asien-Pazifik (Singapur)

  • Asien-Pazifik (Sydney)

  • Asien-Pazifik (Tokio)

  • Canada (Central)

  • Europa (Frankfurt)

  • Europa (Zürich)

  • Europa (Irland)

  • Europe (London)

  • Europa (Stockholm)

  • Naher Osten (VAE)