此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 spring-cloud-function 4.2.1！spring-doc.cadn.net.cn

AWS Lambda

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

通常，有两种方法可以在 AWS Lambda 上运行 Spring 应用程序：spring-doc.cadn.net.cn

通过 Spring Cloud Function 使用 AWS Lambda 适配器来实现功能方法，如下所述。这非常适合单职责API和基于事件和消息的系统，例如处理来自Amazon SQS或Amazon MQ队列的消息、Apache Kafka流，或者对Amazon S3中的文件上传做出反应。spring-doc.cadn.net.cn
通过无服务器 Java 容器项目在 AWS Lambda 上运行 Spring Boot Web 应用程序。这非常适合将现有 Spring 应用程序迁移到 AWS Lambda，或者如果您构建具有多个 API 终端节点的复杂 API 并希望保持熟悉的 APIRestController方法。适用于 Spring Boot Web 的无服务器 Java 容器中更详细地概述了此方法。spring-doc.cadn.net.cn

以下指南要求您对 AWS 和 AWS Lambda 有基本的了解，并重点介绍 Spring 提供的额外价值。有关如何开始使用 AWS Lambda 的详细信息不在本文档的讨论范围之内。如果您想了解更多信息，可以导航到基本的 AWS Lambda 概念或完整的 AWS 上的 Java 概述。spring-doc.cadn.net.cn

开始

Spring Cloud Function 框架的目标之一是提供必要的基础设施元素，使简单的功能应用程序能够与特定环境（例如 AWS Lambda）兼容。spring-doc.cadn.net.cn

在 Spring 的上下文中，一个简单的函数式应用程序包含以下类型的 beanSupplier,Function或Consumer.spring-doc.cadn.net.cn

让我们看一下这个例子：spring-doc.cadn.net.cn

@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 应用程序：spring-doc.cadn.net.cn

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

不需要其他代码或配置。我们提供了一个示例项目，可供构建和部署。您可以在官方 Spring Cloud 函数示例存储库中访问它。spring-doc.cadn.net.cn

您只需执行mvn clean package生成 JAR 文件。所有必要的 maven 插件都已设置好以生成适当的 AWS 可部署 JAR 文件。（您可以在 JAR 布局说明中阅读有关 JAR 布局的更多详细信息）。spring-doc.cadn.net.cn

AWS Lambda 函数处理程序

与通过给定 HTTP 端口（80， 443）上的侦听器公开其功能的传统 Web 应用程序相比，AWS Lambda 函数在预定义的入口点（称为 Lambda 函数处理程序）调用。spring-doc.cadn.net.cn

我们建议使用内置的org.springframework.cloud.function.adapter.aws.FunctionInvoker处理程序来简化与 AWS Lambda 的集成。它提供高级功能，例如多功能路由、与 AWS 细节解耦以及开箱即用的 POJO 序列化。请参阅 AWS 请求处理程序和 AWS 函数路由部分以了解更多信息。spring-doc.cadn.net.cn

部署

构建应用程序后，您可以通过 AWS 控制台、AWS 命令行界面（CLI）或基础设施即代码（IaC）工具（如 AWS 无服务器应用程序模型（AWS SAM）、AWS Cloud Development Kit （AWS CDK）、AWS CloudFormation 或 Terraform）手动部署 JAR 文件。spring-doc.cadn.net.cn

使用 AWS 控制台创建 Hello world Lambda 函数spring-doc.cadn.net.cn

打开 Lambda 控制台的 Functions （函数）页面。spring-doc.cadn.net.cn
选择 Create function （创建函数）。spring-doc.cadn.net.cn
选择 Author from scratch（从头开始创作）。spring-doc.cadn.net.cn
对于 Function name （函数名称），输入MySpringLambdaFunction.spring-doc.cadn.net.cn
对于 Runtime （运行时），选择 Java 21。spring-doc.cadn.net.cn
选择 Create function （创建函数）。spring-doc.cadn.net.cn

要上传您的代码并测试函数，请执行以下作：spring-doc.cadn.net.cn

例如，上传之前创建的 JAR 文件target/function-sample-aws-0.0.1-SNAPSHOT-aws.jar.spring-doc.cadn.net.cn
提供入口处理程序方法org.springframework.cloud.function.adapter.aws.FunctionInvoker::handleRequest.spring-doc.cadn.net.cn
导航到 “Test” 选项卡，然后单击 “Test” 按钮。该函数应以大写形式返回提供的 JSON 有效负载。spring-doc.cadn.net.cn

要使用基础设施即代码（IaC）工具自动进行部署，请参阅官方 AWS 文档。spring-doc.cadn.net.cn

AWS 请求处理程序

如入门部分所述，AWS Lambda 函数在预定义的入口点（称为 Lambda 函数处理程序）调用。在最简单的形式中，这可以是 Java 方法引用。在上面的示例中，这将是com.my.package.FunctionConfiguration::uppercase.需要此配置来通知 AWS Lambda 在提供的 JAR 中调用哪个 Java 方法。spring-doc.cadn.net.cn

调用 Lambda 函数时，它会将额外的请求负载和上下文对象传递给此处理程序方法。请求负载因触发函数的 AWS 服务（Amazon API Gateway、Amazon S3、Amazon SQS、Apache Kafka 等）而异。context 对象提供有关 Lambda 函数、调用和环境的其他信息，例如唯一请求 ID（另请参阅官方文档中的 Java 上下文）。spring-doc.cadn.net.cn

AWS提供预定义的处理程序接口（称为RequestHandler或RequestStreamHandler）通过 aws-lambda-java-events 和 aws-lambda-java-core 库处理负载和上下文对象。spring-doc.cadn.net.cn

Spring Cloud Function 已经实现了这些接口，并提供了org.springframework.cloud.function.adapter.aws.FunctionInvoker完全抽象函数代码来自 AWS Lambda 的具体内容。这允许您根据运行函数的平台来切换入口点。spring-doc.cadn.net.cn

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

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

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

类型转换

利用内置FunctionInvoker是 Spring Cloud Function 将尝试透明地处理原始 input stream 和函数声明的类型。spring-doc.cadn.net.cn

例如，如果您的函数签名是Function<Foo, Bar>它将尝试将传入的 Stream 事件转换为Foo.这在 API 触发的 Lambda 函数中特别有用，其中请求正文表示业务对象，并且与 AWS 细节无关。spring-doc.cadn.net.cn

如果事件类型未知或无法确定（例如，Function<?, ?>） Spring Cloud 函数将尝试将传入流事件转换为泛型Map.spring-doc.cadn.net.cn

原始输入

有时您可能希望访问原始输入。在这种情况下，您只需声明要接受的函数签名InputStream例如Function<InputStream, ?>. 如果指定，Spring Cloud 函数将不会尝试任何转换，而是将原始 Importing 直接传递给函数。spring-doc.cadn.net.cn

AWS 函数路由

Spring Cloud Function 的核心功能之一是路由。此功能允许您将一个特殊的 Java 方法（充当 Lambda 函数处理程序）委托给其他内部方法。您已经在作中看到了这一点，当泛型FunctionInvoker自动将请求路由到您的uppercase功能。spring-doc.cadn.net.cn

默认情况下，如果您的应用有多个@Bean的类型Function等等，它们是从 Spring Cloud 中提取的FunctionCatalog框架将尝试按照它首先搜索的搜索顺序查找默认值Function然后Consumer最后Supplier.需要这些默认路由功能，因为FunctionInvoker无法确定要绑定哪个函数，所以内部默认为RoutingFunction.建议使用多种机制提供额外的 routing 指令（有关更多详细信息，请参阅 sample ）。spring-doc.cadn.net.cn

正确的路由机制取决于您将 Spring Cloud 函数项目部署为单个或多个 Lambda 函数的偏好。spring-doc.cadn.net.cn

单一功能与多种功能

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

如果每个函数的扩展、配置或权限要求不同，则部署两个单独的 AWS Lambda 函数是有意义的。例如，如果您创建两个 Java 方法readObjectFromAmazonS3和writeToAmazonDynamoDB在同一个 Spring Cloud Function 项目中，您可能希望创建两个单独的 Lambda 函数。这是因为它们需要不同的权限才能与 S3 或 DynamoDB 通信，或者它们的负载模式和内存配置差异很大。通常，对于基于消息收发的应用程序，也建议使用此方法，在这些应用程序中，您可以从流或队列中读取数据，因为每个 Lambda 事件源映射都有专用配置。spring-doc.cadn.net.cn
当多个 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-doc.cadn.net.cn

如果您喜欢第一种方法，您还可以创建两个单独的 Spring Cloud Function 项目并单独部署它们。如果不同的团队负责维护和部署功能，这可能是有益的。但是，在这种情况下，您需要处理共享横切关注点，例如它们之间的帮助程序方法或实体类。一般来说，我们建议将相同的软件模块化原则应用于您的功能项目，就像您对传统的基于 Web 的应用程序所做的那样。有关如何选择正确方法的更多信息，您可以参考比较无服务器微服务的设计方法。spring-doc.cadn.net.cn

做出决策后，您可以从以下路由机制中受益。spring-doc.cadn.net.cn

多个 Lambda 函数的路由

例如，如果您决定将单个 Spring Cloud 函数项目（JAR）部署到多个 Lambda 函数，则需要提供有关要调用哪个特定方法的提示uppercase或lowercase.您可以使用 AWS Lambda 环境变量来提供路由说明。spring-doc.cadn.net.cn

请注意，AWS 不允许使用点.和/或环境变量名称中的连字符。您可以从 Spring Boot 支持中受益，只需将点替换为下划线，将连字符替换为驼峰式大小写。例如，-spring.cloud.function.definition成为spring_cloud_function_definition和spring.cloud.function.routing-expression成为spring_cloud_function_routingExpression.spring-doc.cadn.net.cn

因此，单个 Spring Cloud 项目的配置（其中部署了两个方法以分隔 AWS Lambda 函数）可能如下所示：spring-doc.cadn.net.cn

@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 项目中，建议使用内置的FunctionInvoker如 AWS 请求处理程序中所述。因此，我们通过环境变量提供路由定义。spring-doc.cadn.net.cn

在单个 Lambda 函数中路由

如果您决定使用多种方法（uppercase或lowercase）添加到单个 Lambda 函数，您需要一种更动态的路由方法。因为application.properties环境变量是在构建或部署时定义的，您不能将它们用于单个函数场景。在这种情况下，您可以利用MessagingRoutingCallback或Message Headers如 Spring Cloud 函数路由部分所述。spring-doc.cadn.net.cn

提供的示例中提供了更多详细信息。spring-doc.cadn.net.cn

性能注意事项

Serverless Functions 的一个核心特征是能够扩展到零并处理突然的流量峰值。为了处理请求，AWS Lambda 启动了新的执行环境。这些环境需要初始化，需要下载您的代码，并且需要启动 JVM + 您的应用程序。这也称为冷启动。要缩短此冷启动时间，您可以依靠以下机制来优化性能。spring-doc.cadn.net.cn

利用 AWS Lambda SnapStart 从预初始化的快照启动 Lambda 函数。spring-doc.cadn.net.cn
通过 AWS Lambda Power Tuning 优化内存配置，以找到性能和成本之间的最佳平衡。spring-doc.cadn.net.cn
遵循 AWS 开发工具包最佳实践，例如在处理程序代码之外定义开发工具包客户端或利用更高级的启动技术。spring-doc.cadn.net.cn
实现其他 Spring 机制以减少 Spring 启动和初始化时间，例如功能性 Bean 注册。spring-doc.cadn.net.cn

有关更多信息，请参阅官方指南。spring-doc.cadn.net.cn

GraalVM 原生镜像

Spring Cloud Function 为在 AWS Lambda 上运行的函数提供 GraalVM Native Image 支持。由于 GraalVM 原生映像不在传统的 Java 虚拟机（JVM）上运行，因此您必须将原生 Spring Cloud Function 部署到 AWS Lambda 自定义运行时。最显著的区别是，您不再提供 JAR 文件，而是提供 native-image 和带有启动说明的引导文件，这些文件捆绑在一个 zip 包中：spring-doc.cadn.net.cn

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

Bootstrap 文件：spring-doc.cadn.net.cn

#!/bin/sh

cd ${LAMBDA_TASK_ROOT:-.}

./function-sample-aws-native

您可以在 GitHub 上找到带有 Spring Cloud Function 的完整 GraalVM 原生映像示例。要深入了解，您还可以参考 AWS Lambda 研讨会上的 Java 的 GraalVM 模块。spring-doc.cadn.net.cn

自定义运行时

Lambda 专注于提供稳定的长期支持（LTS） Java 运行时版本。官方 Lambda 运行时是围绕作系统、编程语言和软件库的组合构建的，这些库需要维护和安全更新。例如，适用于 Java 的 Lambda 运行时支持 LTS 版本，例如 Java 17 Corretto 和 Java 21 Corretto。您可以在此处找到完整列表。对于 Java 22、Java 23 或 Java 24 等非 LTS 版本，没有提供运行时。spring-doc.cadn.net.cn

要使用其他语言版本、JVM 或 GraalVM 本机映像，Lambda 允许您创建自定义运行时。自定义运行时允许您提供和配置自己的运行时来运行其应用程序代码。Spring Cloud Function 提供了所有必要的组件来简化它。spring-doc.cadn.net.cn

从代码的角度来看，该应用程序看起来应该与任何其他 Spring Cloud Function 应用程序没有什么不同。您唯一需要做的就是提供bootstrapscript 的 ZIP/ JAR 的根目录中，用于运行 Spring Boot 应用程序。，然后在 AWS 中创建函数时选择“自定义运行时”。下面是一个 'bootstrap' 文件示例：spring-doc.cadn.net.cn

#!/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 的应用程序。spring-doc.cadn.net.cn

将 AWS 中的处理程序名称设置为您的函数的名称。您也可以在此处使用函数组合（例如uppercase|reverse). 将 ZIP/JAR 上传到 AWS 后，您的函数将在自定义运行时中运行。我们提供了一个示例项目，您还可以在其中了解如何配置 POM 以正确生成 ZIP 文件。spring-doc.cadn.net.cn

函数式 Bean 定义样式也适用于自定义运行时，并且比@Bean风格。自定义运行时的启动速度甚至比功能性 bean 实现快得多的 Java lambda 中，这主要取决于运行时需要加载的类的数量。 Spring 在这里没有做太多事情，因此你可以通过在函数中仅使用原始类型来减少冷启动时间，例如，并且不做任何自定义工作@PostConstruct初始化器。spring-doc.cadn.net.cn

使用自定义运行时的 AWS 函数路由

使用 Custom Runtime Function 时，Routing 的工作方式相同。您只需指定functionRouter作为 AWS Handler 使用函数名称作为 handler。spring-doc.cadn.net.cn

将 Lambda 函数部署为容器映像

与基于 JAR 或 ZIP 的部署相比，您还可以通过映像注册表将 Lambda 函数部署为容器映像。有关更多详细信息，请参阅官方 AWS Lambda 文档。spring-doc.cadn.net.cn

当以类似于此处描述的方式部署容器镜像时，请务必要记住设置和环境变量DEFAULT_HANDLER替换为函数的名称。spring-doc.cadn.net.cn

例如，对于下面显示的函数 Bean ，DEFAULT_HANDLERvalue 将为readMessageFromSQS.spring-doc.cadn.net.cn

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

此外，重要的是要记住确保spring_cloud_function_web_export_enabled也被设置为false.是的true默认情况下。spring-doc.cadn.net.cn

有关 JAR 布局的说明

在 Lambda 中，运行时不需要 Spring Cloud Function Web 或 Stream 适配器，因此您可能需要在创建发送到 AWS 的 JAR 之前，需要排除这些 JAR。Lambda 应用程序必须 shaded，但 Spring Boot 独立应用程序没有，因此您可以使用 2 单独的罐子（根据 Samples）。示例应用程序创建 2 个 jar 文件，其中一个文件带有aws用于在 Lambda 中部署的分类器，以及一个可执行（精简）jar，其中包括spring-cloud-function-web在运行时。Spring Cloud Function 将尝试从 JAR 文件中找到一个 “main class” manifest 中，使用Start-Class属性（将由 Spring Boot 为您添加工具（如果使用 Starter 父级）。如果没有Start-Class在您的清单中，您可以使用环境变量或系统属性MAIN_CLASS当您将函数部署到 AWS 时。spring-doc.cadn.net.cn

如果您不使用函数式 bean 定义，而是依赖 Spring Boot 的自动配置，则并且不依赖于spring-boot-starter-parent, 然后，必须将其他转换器配置为 maven-shade-plugin 执行的一部分。spring-doc.cadn.net.cn

<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 插件。spring-doc.cadn.net.cn

Maven 系列

为了使用 Maven 的适配器插件，请将插件依赖项添加到您的pom.xml文件：spring-doc.cadn.net.cn

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

如 JAR 布局说明中所述，您需要一个带阴影的 jar 才能上传它到 AWS Lambda。为此，您可以使用 Maven Shade 插件。设置示例可以在上面找到。spring-doc.cadn.net.cn

您可以使用 Spring Boot Maven 插件生成精简的 jar。spring-doc.cadn.net.cn

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

您可以找到整个样本pom.xml用于部署 Spring Cloud Function 的文件使用 Maven 将应用程序迁移到 AWS Lambda。spring-doc.cadn.net.cn

Gradle

为了使用 Gradle 的适配器插件，请将依赖项添加到您的build.gradle文件：spring-doc.cadn.net.cn

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

如 JAR 布局说明中所述，您需要一个带阴影的 jar 才能上传它到 AWS Lambda。您可以使用 Gradle Shadow 插件来实现：spring-doc.cadn.net.cn

你可以使用 Spring Boot Gradle Plugin 和 Spring Boot Thin Gradle Plugin 来生成那个薄罐子。spring-doc.cadn.net.cn

下面是一个完整的 gradle 文件spring-doc.cadn.net.cn

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()
}



You can find the entire sample build.gradle file for deploying Spring Cloud Function
applications to AWS Lambda with Gradle here.spring-doc.cadn.net.cn



Serverless Java container for Spring Boot Web


You can use the aws-serverless-java-container library to run a Spring Boot 3 applications in AWS Lambda. This is a good fit for migrations of existing Spring applications to AWS Lambda or if you build sophisticated APIs with multiple API endpoints and want to maintain the familiar RestController approach. The following section provides a high-level overview of the process. Please refer to the official sample code for additional information.spring-doc.cadn.net.cn




Import the Serverless Java Container library to your existing Spring Boot 3 web appspring-doc.cadn.net.cn


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




Use the built-in Lambda function handler that serves as an entrypointspring-doc.cadn.net.cn

com.amazonaws.serverless.proxy.spring.SpringDelegatingLambdaContainerHandlerspring-doc.cadn.net.cn



Configure an environment variable named MAIN_CLASS to let the generic handler know where to find your original application main class. Usually that is the class annotated with @SpringBootApplication.spring-doc.cadn.net.cn




MAIN_CLAS = com.my.package.MySpringBootApplicationspring-doc.cadn.net.cn


Below you can see an example deployment configuration:spring-doc.cadn.net.cn



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



Please find all the examples including GraalVM native-image here.spring-doc.cadn.net.cn




Additional resources




Official Example Repositories on GitHubspring-doc.cadn.net.cn


Java on AWS Lambda workshop with dedicated Spring examplesspring-doc.cadn.net.cn


Java on AWS Immersion Dayspring-doc.cadn.net.cn


Java Replatforming Guidespring-doc.cadn.net.cn


Talk: Spring I/O 2024 - Serverless Java with Springspring-doc.cadn.net.cn