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 AWS bietet es eine Reihe von Lösungen für die Bereitstellung von Lambda-Funktionen und serverlosen 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 serverlose Anwendungen mit vielen separaten Ressourcen schnell und wiederholbar bereitzustellen und zu aktualisieren. AWS 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 serverlose Anwendungen mithilfe von IaC bereitzustellen, AWS bietet eine Reihe verschiedener Tools und Dienste.

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 immer mehr neue Dienste AWS eingeführt wurden und die Komplexität der Erstellung von AWS CloudFormation Vorlagen zunahm, wurden zwei weitere Tools veröffentlicht. AWS SAM ist ein weiteres auf Vorlagen basierendes Framework zur Definition serverloser Anwendungen. AWS Cloud Development Kit (AWS CDK) Es handelt sich um einen Ansatz, bei dem der Code an erster Stelle steht, um Infrastruktur mithilfe von Codekonstrukten in vielen gängigen Programmiersprachen zu definieren und bereitzustellen.

Mit both AWS SAM and the AWS CloudFormation arbeitet hinter den Kulissen AWS CDK, 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.

AWS bietet außerdem einen Dienst AWS Application Composer zur Entwicklung von IaC-Vorlagen mithilfe einer einfachen grafischen Oberfläche. Mit Application Composer entwerfen Sie eine Anwendungsarchitektur, indem Sie sie auf einer visuellen Leinwand ziehen, gruppieren und verbinden AWS -Services . Application Composer erstellt dann eine AWS SAM Vorlage oder eine AWS CloudFormation Vorlage aus Ihrem Design, 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 serverlose Anwendung in Application Composer erstellen, indem Sie weitere Ressourcen hinzufügen. AWS

Wenn Sie lieber mit einem AWS SAM AWS CloudFormation OR-Tutorial beginnen möchten, um zu lernen, wie Sie mit Vorlagen arbeiten können, ohne Application Composer zu verwenden, finden Sie im Nächste Schritte Abschnitt 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 spezifiziert werden AWS SAM. Außerdem erfahren Sie, wie Sie mit Application Composer eine serverlose Anwendung erstellen, die Sie mit AWS SAM oder AWS CloudFormation bereitstellen können.

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

In Nächste Schritte diesem Abschnitt finden Sie Ressourcen, mit denen Sie mehr über AWS SAM Application Composer erfahren können. Diese Ressourcen enthalten Links zu Tutorials für Fortgeschrittene, in denen Sie lernen, wie Sie eine serverlose Anwendung mithilfe von 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 den Dateisystemzugriff unterstütztAPI, der es Webanwendungen ermöglicht, Dateien in Ihrem lokalen Dateisystem zu lesen, zu schreiben und zu speichern. Wir empfehlen, entweder Google Chrome oder Microsoft Edge zu verwenden. Weitere Informationen zum Dateisystemzugriff API finden Sie unter Was ist der DateisystemzugriffAPI?

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.

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 serverlosen Anwendung zu beginnen.

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, da AWS SAM Vorlagen hinter den Kulissen bereitgestellt werden AWS CloudFormation. 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 während 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, der für die Bereitstellung der Funktion verwendet werden AWS SAM soll, ist hier ebenfalls definiert. Weitere Informationen zu Lambda-Funktionsressourcen finden Sie unter AWS: :Serverless: :Function im Developer Guide. AWS SAMAWS SAM

Neben den Funktionseigenschaften und Konfigurationen gibt die Vorlage auch eine AWS Identity and Access Management (IAM) -Richtlinie für Ihre Funktion an. Diese Richtlinie gibt Ihrer Funktion die Erlaubnis, 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 zur Angabe einer IAM Richtlinie für eine Funktion in einer AWS SAM Vorlage finden Sie in der entsprechenden policies Eigenschaft auf der Seite AWS: :Serverless: :Function im AWS SAM Developer Guide.

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

Wird verwendet AWS Application Composer , um eine serverlose Anwendung zu entwerfen

Um mit der Erstellung einer einfachen serverlosen Anwendung zu beginnen, die die AWS SAM Vorlage Ihrer Funktion als Ausgangspunkt verwendet, exportieren Sie Ihre Funktionskonfiguration in Application Composer und aktivieren den lokalen Synchronisierungsmodus von Application Composer. Local Sync 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.

Um Ihre Funktion nach Application Composer zu exportieren, benötigen Sie die Erlaubnis, bestimmte API Aktionen zu verwenden. Wenn Sie Ihre Funktion nicht exportieren können, beachten Sie Erforderliche Berechtigungen und stellen Sie sicher, dass Sie über die erforderlichen Berechtigungen verfügen.

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

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

Die vollständige endgültige AWS SAM Vorlage sollte wie folgt 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 serverlose Anwendung mithilfe von AWS SAM (optional) bereit

Wenn Sie eine serverlose Anwendung mithilfe der Vorlage bereitstellen AWS SAM möchten, die Sie gerade in Application Composer erstellt haben, müssen Sie zuerst die installieren. AWS SAM CLI Folgen Sie dazu den Anweisungen unter Installation von. 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 aus der SQS Amazon-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

AWS SAM Erstellt während des Bereitstellungsprozesses die folgenden Ressourcen in Ihrem AWS-Konto:

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

Weitere Informationen AWS SAM zur Bereitstellung serverloser Anwendungen finden Sie in den Ressourcen im Abschnitt. Nächste Schritte

Testen der bereitgestellten Anwendung (optional)

Um zu überprüfen, ob Ihre serverlose Anwendung korrekt bereitgestellt wurde, senden Sie eine Nachricht an Ihre SQS Amazon-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.

Nächste Schritte

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

Für ein Tutorial mit Anleitung AWS SAM zur Bereitstellung einer in Application Composer entwickelten serverlosen Anwendung empfehlen wir Ihnen außerdem, das AWS Application Composer Tutorial im AWS Serverless Patterns Workshop 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 serverlosen Anwendungen zu erstellen und auszuführen. Mit dem können Sie Ihre Anwendung erstellen und bereitstellen AWS SAM CLI, lokale Tests und Debugging durchführen, CI/CD-Pipelines konfigurieren und vieles mehr. Weitere Informationen zur Verwendung von finden Sie unter Erste Schritte mit AWS SAM im Entwicklerhandbuch. AWS SAM CLIAWS Serverless Application Model

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

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

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