AWS Lambda

AWS 适配器采用 Spring Cloud Function 应用程序，并将其转换为可在 AWS Lambda 中运行的形式。

通常，有两种方法可以在 AWS Lambda 上运行 Spring 应用程序

  1. 使用 Spring Cloud Function 的 AWS Lambda 适配器实现如下所述的函数式方法。这非常适合单一职责的 API 以及基于事件和消息传递的系统，例如处理来自 Amazon SQS 或 Amazon MQ 队列的消息、Apache Kafka 流，或对 Amazon S3 中的文件上传做出反应。

  2. 通过 Serverless Java container 项目在 AWS Lambda 上运行 Spring Boot Web 应用程序。这非常适合将现有 Spring 应用程序迁移到 AWS Lambda，或者构建具有多个 API 端点的复杂 API 并希望保持熟悉的 RestController 方法。此方法在 Serverless Java container for Spring Boot Web 中有更详细的介绍。

以下指南假设您对 AWS 和 AWS Lambda 有基本了解，并重点介绍 Spring 提供的附加价值。如何开始使用 AWS Lambda 的详细信息不在此文档范围内。如果您想了解更多信息，可以查阅 AWS Lambda 基本概念 或完整的 Java on AWS 概述。

入门

Spring Cloud Function 框架的目标之一是提供必要的基础设施元素，使简单的函数式应用程序能够与特定环境（如 AWS Lambda）兼容。

在 Spring 的上下文中，一个简单的函数式应用程序包含类型为 Supplier、Function 或 Consumer 的 bean。

我们来看一个例子

@SpringBootApplication
public class FunctionConfiguration {

	public static void main(String[] args) {
		SpringApplication.run(FunctionConfiguration.class, args);
	}

	@Bean
	public Function<String, String> uppercase() {
		return value -> value.toUpperCase();
	}
}

您可以看到一个完整的 Spring Boot 应用程序，其中定义了一个函数 bean。从表面上看，这只是另一个 Spring Boot 应用程序。然而，当将 Spring Cloud Function AWS Adapter 添加到项目中时，它将成为一个完全有效的 AWS Lambda 应用程序

<dependencies>
 <dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-function-adapter-aws</artifactId>
 </dependency>
</dependencies>

不需要其他代码或配置。我们提供了一个可直接构建和部署的示例项目。您可以在 官方 Spring Cloud function 示例仓库 中找到它。

您只需执行 mvn clean package 来生成 JAR 文件。所有必要的 Maven 插件已经设置好，用于生成适合 AWS 部署的 JAR 文件。（您可以在 JAR 文件布局注意事项 中阅读有关 JAR 布局的更多详细信息）。

AWS Lambda 函数处理程序

与通过指定 HTTP 端口（80、443）上的监听器暴露其功能的传统 Web 应用程序不同，AWS Lambda 函数在预定义的入口点被调用，该入口点称为 Lambda 函数处理程序。

我们建议使用内置的 org.springframework.cloud.function.adapter.aws.FunctionInvoker 处理程序来简化与 AWS Lambda 的集成。它提供了多函数路由、与 AWS 特定性解耦以及开箱即用的 POJO 序列化等高级功能。请参考 AWS 请求处理程序 和 AWS 函数路由 部分了解更多信息。

部署

构建应用程序后，您可以通过 AWS 控制台、AWS 命令行界面 (CLI) 或基础设施即代码 (IaC) 工具（例如 AWS Serverless Application Model (AWS SAM)、AWS Cloud Development Kit (AWS CDK)、AWS CloudFormation 或 Terraform）手动部署 JAR 文件。

使用 AWS 控制台创建 Hello world Lambda 函数

  1. 打开 Lambda 控制台的功能页面。

  2. 选择 创建函数。

  3. 选择 从头开始创建。

  4. 对于 函数名称，输入 MySpringLambdaFunction。

  5. 对于 运行时，选择 Java 21。

  6. 选择 创建函数。

上传代码并测试函数

  1. 上传先前创建的 JAR 文件，例如 target/function-sample-aws-0.0.1-SNAPSHOT-aws.jar。

  2. 提供入口处理程序方法 org.springframework.cloud.function.adapter.aws.FunctionInvoker::handleRequest。

  3. 导航到“测试”选项卡并点击“测试”按钮。函数应该返回提供的 JSON 有效载荷的大写形式。

aws spring lambda edit
aws spring lambda test

要使用基础设施即代码 (IaC) 工具自动化部署，请参考 AWS 官方文档。

AWS 请求处理程序

如入门部分所述，AWS Lambda 函数在预定义的入口点被调用，该入口点称为 Lambda 函数处理程序。最简单的形式可以是 Java 方法引用。在上面的示例中，它将是 com.my.package.FunctionConfiguration::uppercase。此配置用于告知 AWS Lambda 在提供的 JAR 中调用哪个 Java 方法。

当调用 Lambda 函数时，它会向此处理程序方法传递附加的请求有效载荷和上下文对象。请求有效载荷根据触发函数的 AWS 服务（Amazon API Gateway、Amazon S3、Amazon SQS、Apache Kafka 等）而异。上下文对象提供有关 Lambda 函数、调用和环境的附加信息，例如唯一的请求 ID（另请参阅官方文档中的 Java 上下文）。

AWS 提供预定义的处理程序接口（称为 RequestHandler 或 RequestStreamHandler），通过 aws-lambda-java-events 和 aws-lambda-java-core 库处理有效载荷和上下文对象。

Spring Cloud Function 已实现这些接口，并提供了 org.springframework.cloud.function.adapter.aws.FunctionInvoker，以完全将您的函数代码与 AWS Lambda 的特定性解耦。这使您只需根据运行函数的平台切换入口点即可。

但是，在某些用例中，您希望与 AWS 环境深度集成。例如，当您的函数由 Amazon S3 文件上传触发时，您可能希望访问特定的 Amazon S3 属性。或者，如果您在处理 Amazon SQS 队列中的项目时想返回部分批量响应。在这种情况下，您仍然可以利用通用的 org.springframework.cloud.function.adapter.aws.FunctionInvoker，但您将在函数代码中直接使用专门的 AWS 对象

@Bean
public Function<S3Event, String> processS3Event() {}

@Bean
public Function<SQSEvent, SQSBatchResponse> processSQSEvent() {}

类型转换

利用内置 FunctionInvoker 的另一个好处是，Spring Cloud Function 将尝试透明地处理原始输入流与您的函数声明的类型之间的类型转换。

例如，如果您的函数签名是 Function<Foo, Bar>，它将尝试将传入的流事件转换为 Foo 的实例。这在 API 触发的 Lambda 函数中特别有用，其中请求体代表一个业务对象，并且与 AWS 特定性无关。

如果事件类型未知或无法确定（例如，Function<?, ?>），Spring Cloud Function 将尝试将传入的流事件转换为一个通用的 Map。

原始输入

有时您可能希望访问原始输入。在这种情况下，您只需声明您的函数签名以接受 InputStream，例如 Function<InputStream, ?>。如果指定了此类型，Spring Cloud Function 将不会尝试任何转换，并将原始输入直接传递给函数。

AWS 函数路由

Spring Cloud Function 的核心特性之一是 路由。此功能允许您使用一个特殊的 Java 方法（充当 Lambda 函数处理程序）委托给其他内部方法。您已经在 入门 部分看到，通用的 FunctionInvoker 自动将请求路由到您的 uppercase 函数。

默认情况下，如果您的应用程序有多个 @Bean 的类型为 Function 等，它们将从 Spring Cloud FunctionCatalog 中提取，并且框架将尝试按照搜索顺序查找默认值，该顺序首先搜索 Function，然后是 Consumer，最后是 Supplier。需要这些默认路由能力是因为 FunctionInvoker 无法确定要绑定哪个函数，因此它在内部默认为 RoutingFunction。建议使用 多种机制 提供附加的路由指令（请参阅 示例 了解更多详细信息）。

选择正确的路由机制取决于您偏好将 Spring Cloud Function 项目部署为单个还是多个 Lambda 函数。

单个函数与多个函数

如果您在同一个 Spring Cloud Function 项目中实现了多个 Java 方法，例如 uppercase 和 lowercase，您可以部署两个带有静态路由信息的单独 Lambda 函数，或者提供一个在运行时决定调用哪个方法的动态路由方法。让我们看看这两种方法。

  1. 如果您对每个函数有不同的扩缩、配置或权限要求，则部署两个单独的 AWS Lambda 函数是有意义的。例如，如果您在同一个 Spring Cloud Function 项目中创建了两个 Java 方法 readObjectFromAmazonS3 和 writeToAmazonDynamoDB，您可能希望创建两个单独的 Lambda 函数。这是因为它们需要不同的权限才能与 S3 或 DynamoDB 通信，或者它们的负载模式和内存配置差异很大。通常，对于基于消息传递的应用程序，您从流或队列中读取数据时也推荐使用此方法，因为您可以为每个 Lambda 事件源映射 进行专门配置。

  2. 当多个 Java 方法共享相同的权限集或提供内聚的业务功能时，单个 Lambda 函数是有效的方法。例如，一个基于 CRUD 的 Spring Cloud Function 项目，包含 createPet、updatePet、readPet 和 deletePet 方法，这些方法都与同一个 DynamoDB 表交互并具有相似的使用模式。使用单个 Lambda 函数将提高部署简单性、内聚性以及共享类（PetEntity）的代码重用。此外，它可以减少连续调用之间的冷启动，因为 readPet 后跟 writePet 很可能会命中已在运行的 Lambda 执行环境。但是，当您构建更复杂的 API 或希望利用 @RestController 方法时，您可能还需要评估 Serverless Java container for Spring Boot Web 选项。

如果您偏好第一种方法，您也可以创建两个独立的 Spring Cloud Function 项目并单独部署它们。如果不同的团队负责维护和部署函数，这会很有益。但是，在这种情况下，您需要处理它们之间共享横切关注点的问题，例如辅助方法或实体类。总的来说，我们建议您将应用于传统 Web 应用程序的软件模块化原则也应用于您的函数项目。有关如何选择正确方法的更多信息，您可以参考 无服务器微服务设计方法比较。

做出决定后，您可以利用以下路由机制。

针对多个 Lambda 函数进行路由

如果您决定将单个 Spring Cloud Function 项目（JAR）部署到多个 Lambda 函数，您需要提供一个提示，说明要调用哪个特定方法，例如 uppercase 或 lowercase。您可以使用 AWS Lambda 环境变量 来提供路由指令。

请注意，AWS 不允许在环境变量名称中使用点 . 和/或连字符 -。您可以利用 Spring Boot 的支持，简单地用下划线替换点，用驼峰命名法替换连字符。例如，spring.cloud.function.definition 变成 spring_cloud_function_definition，而 spring.cloud.function.routing-expression 变成 spring_cloud_function_routingExpression。

因此，一个包含两个方法并部署到独立 AWS Lambda 函数的单个 Spring Cloud 项目的配置可能如下所示

@SpringBootApplication
public class FunctionConfiguration {

	public static void main(String[] args) {
		SpringApplication.run(FunctionConfiguration.class, args);
	}

	@Bean
	public Function<String, String> uppercase() {
		return value -> value.toUpperCase();
	}

    @Bean
	public Function<String, String> lowercase() {
		return value -> value.toLowerCase();
	}
}
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  MyUpperCaseLambda:
    Type: AWS::Serverless::Function
    Properties:
      Handler: org.springframework.cloud.function.adapter.aws.FunctionInvoker
      Runtime: java21
      MemorySize: 512
      CodeUri: target/function-sample-aws-0.0.1-SNAPSHOT-aws.jar
      Environment:
        Variables:
          spring_cloud_function_definition: uppercase

  MyLowerCaseLambda:
    Type: AWS::Serverless::Function
    Properties:
      Handler: org.springframework.cloud.function.adapter.aws.FunctionInvoker
      Runtime: java21
      MemorySize: 512
      CodeUri: target/function-sample-aws-0.0.1-SNAPSHOT-aws.jar
      Environment:
        Variables:
          spring_cloud_function_definition: lowercase

您可能会问——为什么不直接使用 Lambda 函数处理程序并将入口方法指向 uppercase 和 lowercase 呢？在 Spring Cloud Function 项目中，建议使用 AWS 请求处理程序 中概述的内置 FunctionInvoker。因此，我们通过环境变量提供路由定义。

在单个 Lambda 函数内部进行路由

如果您决定将包含多个方法（uppercase 或 lowercase）的 Spring Cloud Function 项目部署到单个 Lambda 函数，则需要采用更动态的路由方法。由于 application.properties 和环境变量是在构建或部署时定义的，因此不能用于单个函数场景。在这种情况下，您可以利用 Spring Cloud Function Routing 部分 概述的 MessagingRoutingCallback 或 Message Headers。

提供的 示例 中有更多详细信息。

性能考量

无服务器函数的核心特性之一是能够缩放到零并处理突发流量高峰。为了处理请求，AWS Lambda 会启动新的 执行环境。这些环境需要初始化，需要下载您的代码，并且需要启动 JVM + 您的应用程序。这被称为冷启动。为了减少冷启动时间，您可以依靠以下机制来优化性能。

  1. 利用 AWS Lambda SnapStart 从预初始化的快照启动您的 Lambda 函数。

  2. 通过 AWS Lambda Power Tuning 调整内存配置，找到性能和成本之间的最佳权衡。

  3. 遵循 AWS SDK 最佳实践，例如在处理程序代码外部定义 SDK 客户端或利用更高级的预热技术。

  4. 实现额外的 Spring 机制以减少 Spring 启动和初始化时间，例如 函数式 bean 注册。

请参考 官方指南 了解更多信息。

GraalVM Native Image

Spring Cloud Function 为在 AWS Lambda 上运行的函数提供 GraalVM Native Image 支持。由于 GraalVM native images 不在传统的 Java 虚拟机 (JVM) 上运行，您必须将您的原生 Spring Cloud Function 部署到 AWS Lambda custom runtime。最显着的区别是您不再提供 JAR 文件，而是将 native-image 和包含启动指令的 bootstrap 文件打包在 ZIP 包中

lambda-custom-runtime.zip
  |-- bootstrap
  |-- function-sample-aws-native

Bootstrap 文件

#!/bin/sh

cd ${LAMBDA_TASK_ROOT:-.}

./function-sample-aws-native

您可以在 GitHub 上找到一个完整的 Spring Cloud Function GraalVM native-image 示例。要深入了解，您还可以参考 Java on AWS Lambda workshop 的 GraalVM 模块。

Custom Runtime

Lambda 专注于提供稳定的长期支持 (LTS) Java 运行时版本。官方的 Lambda 运行时围绕操作系统、编程语言和软件库的组合构建，这些组合会接受维护和安全更新。例如，适用于 Java 的 Lambda 运行时支持 Java 17 Corretto 和 Java 21 Corretto 等 LTS 版本。您可以在 这里 找到完整列表。对于 Java 22、Java 23 或 Java 24 等非 LTS 版本，没有提供的运行时。

要使用其他语言版本、JVM 或 GraalVM native-images，Lambda 允许您 创建 custom runtimes。Custom runtimes 允许您提供和配置自己的运行时来运行应用程序代码。Spring Cloud Function 提供了所有必要的组件，使其变得容易。

从代码角度来看，您的应用程序与任何其他 Spring Cloud Function 应用程序看起来没有什么不同。您只需在 ZIP/JAR 的根目录中提供一个运行 Spring Boot 应用程序的 bootstrap 脚本，并在 AWS 中创建函数时选择“Custom Runtime”。这是一个 'bootstrap' 文件示例

#!/bin/sh

cd ${LAMBDA_TASK_ROOT:-.}

java -Dspring.main.web-application-type=none -Dspring.jmx.enabled=false \
  -noverify -XX:TieredStopAtLevel=1 -Xss256K -XX:MaxMetaspaceSize=128M \
  -Djava.security.egd=file:/dev/./urandom \
  -cp .:`echo lib/*.jar | tr ' ' :` com.example.LambdaApplication

com.example.LambdaApplication 代表您的应用程序，其中包含函数 bean。

在 AWS 中将处理程序名称设置为您的函数名称。您也可以在此处使用函数组合（例如，uppercase|reverse）。一旦您将 ZIP/JAR 上传到 AWS，您的函数将在 custom runtime 中运行。我们提供了一个 示例项目，您可以在其中看到如何配置 POM 以正确生成 ZIP 文件。

函数式 bean 定义风格也适用于 custom runtimes，并且比 @Bean 风格更快。Custom runtime 的启动速度甚至比 Java lambda 的函数式 bean 实现要快得多——这主要取决于您在运行时需要加载的类数量。Spring 在这方面做得不多，因此您可以通过仅在函数中使用基本类型（例如）以及不在自定义 @PostConstruct 初始化器中执行任何工作来减少冷启动时间。

使用 Custom Runtime 进行 AWS 函数路由

使用 Custom Runtime 时，函数路由的工作方式相同。您只需像使用函数名称作为处理程序一样，将 functionRouter 指定为 AWS 处理程序即可。

将 Lambda 函数部署为容器镜像

与基于 JAR 或 ZIP 的部署不同，您还可以通过镜像注册表将 Lambda 函数部署为容器镜像。有关更多详细信息，请参考 AWS Lambda 官方文档。

当以 这里 的方式部署容器镜像时，请务必记住设置一个环境变量 DEFAULT_HANDLER，其值为函数名称。

例如，对于下面显示的函数 bean，DEFAULT_HANDLER 的值将是 readMessageFromSQS。

@Bean
public Consumer<Message<SQSMessageEvent>> readMessageFromSQS() {
	return incomingMessage -> {..}
}

此外，请务必记住确保 spring_cloud_function_web_export_enabled 也设置为 false。默认情况下它是 true。

JAR 文件布局注意事项

在 Lambda 运行时，您不需要 Spring Cloud Function Web 或 Stream 适配器，因此在创建要发送到 AWS 的 JAR 文件之前，您可能需要将它们排除。Lambda 应用程序需要进行 shading，而 Spring Boot 独立应用程序不需要，因此您可以使用 2 个独立的 JAR 文件运行同一个应用程序（如示例所示）。示例应用程序创建了 2 个 JAR 文件，一个带有 aws 分类器，用于在 Lambda 中部署，另一个是可执行（瘦）JAR，其中包含 spring-cloud-function-web 运行时库。Spring Cloud Function 将尝试使用 Start-Class 属性（如果您使用 starter parent，Spring Boot 工具将为您添加此属性）从 JAR 文件清单中为您定位一个“主类”。如果您的清单中没有 Start-Class，您可以在将函数部署到 AWS 时使用环境变量或系统属性 MAIN_CLASS。

如果您未使用函数式 bean 定义，而是依赖于 Spring Boot 的自动配置，并且不依赖于 spring-boot-starter-parent，则必须将额外的 transformer 配置为 maven-shade-plugin 执行的一部分。

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-shade-plugin</artifactId>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
			<version>3.4.2</version>
		</dependency>
	</dependencies>
	<executions>
		<execution>
			<goals>
			     <goal>shade</goal>
			</goals>
			<configuration>
				<createDependencyReducedPom>false</createDependencyReducedPom>
				<shadedArtifactAttached>true</shadedArtifactAttached>
				<shadedClassifierName>aws</shadedClassifierName>
				<transformers>
					<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
						<resource>META-INF/spring.handlers</resource>
					</transformer>
					<transformer implementation="org.springframework.boot.maven.PropertiesMergingResourceTransformer">
						<resource>META-INF/spring.factories</resource>
					</transformer>
					<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
						<resource>META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports</resource>
					</transformer>
					<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
						<resource>META-INF/spring/org.springframework.boot.actuate.autoconfigure.web.ManagementContextConfiguration.imports</resource>
					</transformer>
					<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
						<resource>META-INF/spring.schemas</resource>
					</transformer>
					<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
						<resource>META-INF/spring.components</resource>
					</transformer>
				</transformers>
			</configuration>
		</execution>
	</executions>
</plugin>

构建文件设置

为了在 AWS Lambda 上运行 Spring Cloud Function 应用程序，您可以利用 Maven 或 Gradle 插件。

Maven

为了使用 Maven 的适配器插件，将插件依赖项添加到您的 pom.xml 文件中

<dependencies>
	<dependency>
		<groupId>org.springframework.cloud</groupId>
		<artifactId>spring-cloud-function-adapter-aws</artifactId>
	</dependency>
</dependencies>

如 JAR 文件布局注意事项 中所述，您需要一个 shaded jar 才能将其上传到 AWS Lambda。您可以使用 Maven Shade Plugin 来完成此操作。设置示例 可在上方找到。

您可以使用 Spring Boot Maven 插件生成瘦 JAR。

<plugin>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-maven-plugin</artifactId>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot.experimental</groupId>
			<artifactId>spring-boot-thin-layout</artifactId>
			<version>${wrapper.version}</version>
		</dependency>
	</dependencies>
</plugin>

您可以在 这里 找到使用 Maven 将 Spring Cloud Function 应用程序部署到 AWS Lambda 的完整示例 pom.xml 文件。

Gradle

为了使用 Gradle 的适配器插件，将依赖项添加到您的 build.gradle 文件中

dependencies {
	compile("org.springframework.cloud:spring-cloud-function-adapter-aws:${version}")
}

如 JAR 文件布局注意事项 中所述，您需要一个 shaded jar 才能将其上传到 AWS Lambda。您可以使用 Gradle Shadow Plugin 来完成此操作

您可以使用 Spring Boot Gradle 插件和 Spring Boot Thin Gradle 插件生成瘦 JAR。

以下是一个完整的 Gradle 文件

plugins {
	id 'java'
	id 'org.springframework.boot' version '3.4.2'
	id 'io.spring.dependency-management' version '1.1.3'
	id 'com.github.johnrengelman.shadow' version '8.1.1'
	id 'maven-publish'
	id 'org.springframework.boot.experimental.thin-launcher' version "1.0.31.RELEASE"
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

java {
	sourceCompatibility = '17'
}

repositories {
	mavenCentral()
	mavenLocal()
	maven { url 'https://repo.spring.io/milestone' }
}

ext {
	set('springCloudVersion', "2024.0.0")
}

assemble.dependsOn = [thinJar, shadowJar]

publishing {
	publications {
		maven(MavenPublication) {
			from components.java
			versionMapping {
				usage('java-api') {
					fromResolutionOf('runtimeClasspath')
				}
				usage('java-runtime') {
					fromResolutionResult()
				}
			}
		}
	}
}

shadowJar.mustRunAfter thinJar


import com.github.jengelman.gradle.plugins.shadow.transformers.*

shadowJar {
	archiveClassifier = 'aws'
	manifest {
    	inheritFrom(project.tasks.thinJar.manifest)
  	}
  	// Required for Spring
	mergeServiceFiles()
	append 'META-INF/spring.handlers'
	append 'META-INF/spring.schemas'
	append 'META-INF/spring.tooling'
	append 'META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports'
	append 'META-INF/spring/org.springframework.boot.actuate.autoconfigure.web.ManagementContextConfiguration.imports'
	transform(PropertiesFileTransformer) {
		paths = ['META-INF/spring.factories']
		mergeStrategy = "append"
	}
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter'
	implementation 'org.springframework.cloud:spring-cloud-function-adapter-aws'
	implementation 'org.springframework.cloud:spring-cloud-function-context'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

dependencyManagement {
	imports {
		mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
	}
}

tasks.named('test') {
	useJUnitPlatform()
}

您可以在此处找到使用 Gradle 将 Spring Cloud Function 应用部署到 AWS Lambda 的完整示例 build.gradle 文件。

用于 Spring Boot Web 的 Serverless Java 容器

您可以使用 aws-serverless-java-container 库在 AWS Lambda 中运行 Spring Boot 3 应用程序。这非常适合将现有的 Spring 应用程序迁移到 AWS Lambda，或者如果您构建具有多个 API 端点的复杂 API 并希望保持熟悉的 RestController 方法。以下部分提供了该过程的高级概述。有关其他信息，请参阅官方示例代码。

  1. 将 Serverless Java Container 库导入您现有的 Spring Boot 3 Web 应用程序

    <dependency>
 <groupId>com.amazonaws.serverless</groupId>
 <artifactId>aws-serverless-java-container-springboot3</artifactId>
 <version>2.1.2</version>
</dependency>

  2. 使用内置的 Lambda 函数处理程序作为入口点

    com.amazonaws.serverless.proxy.spring.SpringDelegatingLambdaContainerHandler

  3. 配置名为 MAIN_CLASS 的环境变量，以让通用处理程序知道在哪里找到您的原始应用程序主类。通常是使用 @SpringBootApplication 注解的类。

MAIN_CLAS = com.my.package.MySpringBootApplication

下面您可以看到一个示例部署配置

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  MySpringBootLambdaFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: com.amazonaws.serverless.proxy.spring.SpringDelegatingLambdaContainerHandler
      Runtime: java21
      MemorySize: 1024
      CodeUri: target/lambda-spring-boot-app-0.0.1-SNAPSHOT.jar #Must be a shaded Jar
      Environment:
        Variables:
          MAIN_CLASS: com.amazonaws.serverless.sample.springboot3.Application #Class annotated with @SpringBootApplication

请在此处查找所有示例，包括 GraalVM native-image。

其他资源