Voraussetzungen Schritt 1: Einrichten des Projekts Schritt 2: Definieren Sie den Stack Schritt 3: Die Funktion erstellen Schritt 4: Bereitstellen des Stacks Schritt 5: Testen der Funktion Schritt 6: Bereinigen Nächste Schritte

Bereitstellen von Lambda-Funktionen mit AWS CDK

AWS Cloud Development Kit (AWS CDK) ist ein Infrastructure as Code (IaC)-Framework, mit dem Sie die AWS-Cloud-Infrastruktur mit einer Programmiersprache Ihrer Wahl definieren können. Um Ihre eigene Cloud-Infrastruktur zu definieren, schreiben Sie zunächst eine App (in einer der unterstützten Sprachen des CDK), die einen oder mehrere Stacks enthält. Dann synthetisieren Sie es zu einem CloudFormation und stellen Sie Ihre Ressourcen in Ihr AWS-Konto. Folgen Sie den Schritten in diesem Thema, um eine Lambda-Funktion bereitzustellen, die ein Ereignis von einem Amazon-API-Gateway-Endpunkt zurückgibt.

Die AWS-Construct Library, die im CDK enthalten ist, stellt Module bereit, mit denen Sie die von AWS-Services bereitgestellten Ressourcen modellieren können. Für die gängigen Dienste stellt die Bibliothek kuratierte Konstrukte bereit, die intelligente Standards und bewährte Methoden bereitstellen. Sie können das Modul aws_lambda verwenden, um Ihre Funktion und die unterstützenden Ressourcen mit nur wenigen Codezeilen zu definieren.

Voraussetzungen

Bevor Sie mit diesem Lernprogramm beginnen, installieren Sie AWS CDK, indem Sie den folgenden Befehl ausführen.


npm install -g aws-cdk

Schritt 1: Einrichten des Projekts AWS CDK

Erstellen Sie ein Verzeichnis für Ihre neue AWS CDK-App und initialisieren Sie das Projekt.

Anmerkung

Die AWS CDK-Anwendungsvorlage verwendet den Namen des Projektverzeichnisses, um Namen für Quelldateien und -klassen zu generieren. In diesem Beispiel trägt das Verzeichnis den Namen hello-lambda. Wenn Sie einen anderen Projektverzeichnisnamen verwenden, stimmt Ihre App nicht mit diesen Anweisungen überein.

AWS CDK v2 enthält stabile Konstrukte für alle AWS-Services in einem einzigen Paket, genannt aws-cdk-lib. Dieses Paket wird als Abhängigkeit installiert, wenn Sie das Projekt initialisieren. Wenn Sie mit bestimmten Programmiersprachen arbeiten, wird das Paket installiert, wenn Sie das Projekt zum ersten Mal erstellen.

Schritt 2: Definieren Sie den AWS CDK-Stack

Ein CDK-Stack ist eine Sammlung von einem oder mehreren Konstrukten, die AWS-Ressourcen definieren. Jeder CDK-Stack steht für einen CloudFormation-Stack in Ihrer CDK-App.

Um Ihren CDK-Stack zu definieren, folgen Sie den Anweisungen für Ihre bevorzugte Programmiersprache. Dieser Stack definiert das Folgende:

Der logische Name der Funktion: MyFunction
Der Speicherort des Funktionscodes, der in der code-Eigenschaft angegeben ist. Weitere Informationen finden Sie unter Handler-Code in der AWS Cloud Development Kit (AWS CDK)-API-Referenz.
Der logische Name der REST-API: HelloApi
Der logische Name des API-Gateway-Endpunkts: ApiGwEndpoint

Beachten Sie, dass alle CDK-Stacks in diesem Tutorial die Laufzeit-Node.js für die Lambda-Funktion verwenden. Sie können verschiedene Programmiersprachen für den CDK-Stack und die Lambda-Funktion verwenden, um die Stärken der einzelnen Sprachen zu nutzen. Sie können beispielsweise TypeScript für den CDK-Stack verwenden, um die Vorteile der statischen Typisierung für Ihren Infrastrukturcode zu nutzen. Sie können JavaScript für die Lambda-Funktion verwenden, um die Flexibilität und schnelle Entwicklung einer dynamisch typisierten Sprache zu nutzen.

JavaScript

Öffnen Sie die Datei lib/hello-lambda-stack.js und ersetzen Sie den Inhalt durch Folgendes.


const { Stack } = require('aws-cdk-lib');
const lambda = require('aws-cdk-lib/aws-lambda');
const apigw = require('aws-cdk-lib/aws-apigateway');

class HelloLambdaStack extends Stack {
  /**
   *
   * @param {Construct} scope
   * @param {string} id
   * @param {StackProps=} props
   */
  constructor(scope, id, props) {
    super(scope, id, props);
    const fn = new lambda.Function(this, 'MyFunction', {
      code: lambda.Code.fromAsset('lib/lambda-handler'),
      runtime: lambda.Runtime.NODEJS_LATEST,
      handler: 'index.handler'
    });

    const endpoint = new apigw.LambdaRestApi(this, 'MyEndpoint', {
      handler: fn,
      restApiName: "HelloApi"
    });

  }
}

module.exports = { HelloLambdaStack }

TypeScript

Öffnen Sie die Datei lib/hello-lambda-stack.ts und ersetzen Sie den Inhalt durch Folgendes.


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as apigw from "aws-cdk-lib/aws-apigateway";
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as path from 'node:path';

export class HelloLambdaStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps){
    super(scope, id, props)
    const fn = new lambda.Function(this, 'MyFunction', {
      runtime: lambda.Runtime.NODEJS_LATEST,
      handler: 'index.handler',
      code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')),
    });

    const endpoint = new apigw.LambdaRestApi(this, `ApiGwEndpoint`, {
      handler: fn,
      restApiName: `HelloApi`,
    });

  }
}

Python

Öffnen Sie die Datei /hello-lambda/hello_lambda/hello_lambda_stack.py und ersetzen Sie den Inhalt durch Folgendes.


from aws_cdk import (
    Stack,
    aws_apigateway as apigw,
    aws_lambda as _lambda
)
from constructs import Construct

class HelloLambdaStack(Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        fn = _lambda.Function(
            self,
            "MyFunction",
            runtime=_lambda.Runtime.NODEJS_LATEST,
            handler="index.handler",
            code=_lambda.Code.from_asset("lib/lambda-handler")
        )

        endpoint = apigw.LambdaRestApi(
            self,
            "ApiGwEndpoint",
            handler=fn,
            rest_api_name="HelloApi"
        )

Java

Öffnen Sie die Datei /hello-lambda/src/main/java/com/myorg/HelloLambdaStack.java und ersetzen Sie den Inhalt durch Folgendes.


package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.services.apigateway.LambdaRestApi;
import software.amazon.awscdk.services.lambda.Function;

public class HelloLambdaStack extends Stack {
    public HelloLambdaStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public HelloLambdaStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        Function hello = Function.Builder.create(this, "MyFunction")
                            .runtime(software.amazon.awscdk.services.lambda.Runtime.NODEJS_LATEST)
                            .code(software.amazon.awscdk.services.lambda.Code.fromAsset("lib/lambda-handler"))
                            .handler("index.handler")
                            .build();

        LambdaRestApi api = LambdaRestApi.Builder.create(this, "ApiGwEndpoint")
                                .restApiName("HelloApi")
                                .handler(hello)
                                .build();

    }
}

C#

Öffnen Sie die Datei src/HelloLambda/HelloLambdaStack.cs und ersetzen Sie den Inhalt durch Folgendes.


using Amazon.CDK;
using Amazon.CDK.AWS.APIGateway;
using Amazon.CDK.AWS.Lambda;
using Constructs;

namespace HelloLambda
{
    public class HelloLambdaStack : Stack
    {
        internal HelloLambdaStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            var fn = new Function(this, "MyFunction", new FunctionProps
            {
                Runtime = Runtime.NODEJS_LATEST,
                Code = Code.FromAsset("lib/lambda-handler"),
                Handler = "index.handler"
            });

            var api = new LambdaRestApi(this, "ApiGwEndpoint", new LambdaRestApiProps
            {
                Handler = fn
            });
        }
    }
}

Schritt 3: Den Lambda-Funktionscode erstellen

Erstellen Sie im Stammverzeichnis Ihres Projekts (hello-lambda) das /lib/lambda-handler-Verzeichnis für den Lambda-Funktionscode. Dieses Verzeichnis ist in der code-Eigenschaft Ihres AWS CDK-Stacks angegeben.

Erstellen Sie in dem Verzeichnis /lib/lambda-handler eine neue Datei namens index.js. Fügen Sie folgenden Code in die Datei ein. Die Funktion extrahiert bestimmte Eigenschaften aus der API-Anfrage und gibt sie als JSON-Antwort zurück.


exports.handler = async (event) => {
  // Extract specific properties from the event object
  const { resource, path, httpMethod, headers, queryStringParameters, body } = event;
  const response = {
    resource,
    path,
    httpMethod,
    headers,
    queryStringParameters,
    body,
  };
  return {
    body: JSON.stringify(response, null, 2),
    statusCode: 200,
  };
};

Schritt 4: Bereitstellen des AWS CDK-Stacks

Führen Sie im Stammverzeichnis Ihres Projekts den Befehl cdk synth aus:


cdk synth

Dieser Befehl synthetisiert eine AWS CloudFormation-Vorlage aus Ihrem CDK-Stack. Die Vorlage ist eine ca. 400 Zeilen lange YAML-Datei, ähnlich der folgenden.

Anmerkung

Wenn Sie die folgende Fehlermeldung erhalten, vergewissern Sie sich, dass Sie sich im Stammverzeichnis Ihres Projektverzeichnisses befinden.


--app is required either in command-line, in cdk.json or in ~/.cdk.json

Beispiel CloudFormation-Vorlage


Resources:
  MyFunctionServiceRole3C357FF2:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Action: sts:AssumeRole
            Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
        Version: "2012-10-17"		 	 	 
      ManagedPolicyArns:
        - Fn::Join:
            - ""
            - - "arn:"
              - Ref: AWS::Partition
              - :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
    Metadata:
      aws:cdk:path: HelloLambdaStack/MyFunction/ServiceRole/Resource
  MyFunction1BAA52E7:
    Type: AWS::Lambda::Function
    Properties:
      Code:
        S3Bucket:
          Fn::Sub: cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}
        S3Key: ab1111111cd32708dc4b83e81a21c296d607ff2cdef00f1d7f48338782f92l3901.zip
      Handler: index.handler
      Role:
        Fn::GetAtt:
          - MyFunctionServiceRole3C357FF2
          - Arn
      Runtime: nodejs22.x
      ...

Führen Sie den Befehl cdk deploy aus:
```
cdk deploy
```
Warten Sie, bis Ihre Ressourcen erstellt wurden. Die endgültige Ausgabe enthält die URL für Ihren API-Gateway-Endpunkt. Beispiel:
```
Outputs:
HelloLambdaStack.ApiGwEndpoint77F417B1 = https://abcd1234.execute-api.us-east-1.amazonaws.com/prod/
```

Schritt 5: Testen der Funktion

Um die Lambda-Funktion aufzurufen, kopieren Sie den API Gateway-Endpunkt und fügen Sie ihn in einen Webbrowser ein oder führen Sie einen curl-Befehl aus:


curl -s https://abcd1234.execute-api.us-east-1.amazonaws.com/prod/

Die Antwort ist eine JSON-Darstellung ausgewählter Eigenschaften aus dem ursprünglichen Ereignisobjekt, das Informationen über die Anfrage an den API-Gateway-Endpunkt enthält. Beispiel:


{
  "resource": "/",
  "path": "/",
  "httpMethod": "GET",
  "headers": {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
    "Accept-Encoding": "gzip, deflate, br, zstd",
    "Accept-Language": "en-US,en;q=0.9",
    "CloudFront-Forwarded-Proto": "https",
    "CloudFront-Is-Desktop-Viewer": "true",
    "CloudFront-Is-Mobile-Viewer": "false",
    "CloudFront-Is-SmartTV-Viewer": "false",
    "CloudFront-Is-Tablet-Viewer": "false",
    "CloudFront-Viewer-ASN": "16509",
    "CloudFront-Viewer-Country": "US",
    "Host": "abcd1234.execute-api.us-east-1.amazonaws.com",
     ...

Schritt 6: Bereinigen Ihrer Ressourcen

Der API-Gateway-Endpunkt ist öffentlich zugänglich. Um unerwartete Gebühren zu vermeiden, führen Sie den Befehl cdk destroy aus, um den Stack und alle zugehörigen Ressourcen zu löschen.


cdk destroy

Nächste Schritte

Informationen zum Schreiben von AWS CDK-Apps in der Sprache Ihrer Wahl finden Sie nachfolgend:

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Verwenden von AWS SAM und Infrastructure Composer

Powertools for AWS Lambda