Verwenden von Lambda mit Infrastructure as Code (IaC)

Lambda-Funktionen werden selten isoliert ausgeführt. Stattdessen sind sie often Teil einer Serverless-Anwendung, zu der auch andere Ressourcen wie Datenbanken, Warteschlangen und Speicher gehören. Mit infrastructure as code (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

AWS bietet außerdem einen Service namens AWS-Infrastruktur-Composer zur Entwicklung von IaC-Vorlagen mithilfe einer einfachen grafischen Oberfläche. Mit Infrastructure Composer entwerfen Sie eine Anwendungsarchitektur, indem Sie AWS-Services auf einer visuellen Zeichenfläche ziehen, gruppieren und verbinden. Infrastructure 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 Infrastructure 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 Infrastructure Composer erstellen, indem Sie weitere AWS-Ressourcen hinzufügen.

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 Infrastructure 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:

Voraussetzungen

In diesem Tutorial verwenden Sie die Funktion für die lokale Synchronisierung von Infrastructure 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.

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

Bevor Sie die Konfiguration Ihrer Funktion nach Infrastructure 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.

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 AWS SAM finden Sie unter 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 gibt Ihrer Funktion die Berechtigung zum Schreiben von Protokollen in Amazon CloudWatch Logs. 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 policies-Eigenschaft auf der Seite AWS::Serverless::Function im AWS SAM-Entwicklerleitfaden.

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

Verwenden von AWS-Infrastruktur-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 Infrastructure Composer und aktivieren den lokalen Synchronisierungsmodus von Infrastructure 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 Infrastructure Composer hinzufügen.

Zum Exportieren Ihrer Funktion nach Infrastructure 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.

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

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

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 Infrastructure 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 Infrastructure Composer zusammen mit Ihrer Vorlage gespeichert hat. Derzeit enthält die von Infrastructure 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 Infrastructure Composer auf Ihrer lokalen Build-Maschine gespeichert hat. Sie haben das Verzeichnis, in dem Infrastructure 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 Infrastructure 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, sodass Ihre Lambda-Funktion Nachrichten aus der Amazon-SQS-Warteschlange lesen und CRUD-Operationen in der DynamoDB-Tabelle ausführen kann.

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.