AWS Lambda

AWS 介面卡接收一個 Spring Cloud Function 應用程式，並將其轉換為可在 AWS Lambda 中執行的形式。

通常，在 AWS Lambda 上執行 Spring 應用程式有兩種方式

透過 Spring Cloud Function 使用 AWS Lambda 介面卡實現下面概述的功能性方法。這非常適合單一職責 API 和基於事件和訊息傳遞的系統，例如處理來自 Amazon SQS 或 Amazon MQ 佇列、Apache Kafka 流的訊息，或對 Amazon S3 中的檔案上傳做出反應。
透過 Serverless Java container 專案在 AWS Lambda 上執行 Spring Boot Web 應用程式。這非常適合將現有 Spring 應用程式遷移到 AWS Lambda，或者如果您構建具有多個 API 端點的複雜 API 並希望保持熟悉的 RestController 方法。這種方法在用於 Spring Boot Web 的 Serverless Java 容器中進行了更詳細的概述。

以下指南假定您對 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 介面卡新增到專案中時，它將成為一個完全有效的 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 無伺服器應用程式模型 (AWS SAM)、AWS 雲開發工具包 (AWS CDK)、AWS CloudFormation 或 Terraform）手動部署 JAR 檔案。

使用 AWS 控制檯建立 Hello world Lambda 函式

開啟 Lambda 控制檯的函式頁面。
選擇建立函式。
選擇從頭開始創作。
對於函式名稱，輸入 MySpringLambdaFunction。
對於執行時，選擇Java 21。
選擇建立函式。

上傳您的程式碼並測試函式

上傳之前建立的 JAR 檔案，例如 target/function-sample-aws-0.0.1-SNAPSHOT-aws.jar。
提供入口處理方法 org.springframework.cloud.function.adapter.aws.FunctionInvoker::handleRequest。
導航到“測試”選項卡，然後單擊“測試”按鈕。函式應以大寫形式返回提供的 JSON 有效負載。

要使用基礎設施即程式碼 (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 函式將不會嘗試任何轉換，並將原始輸入直接傳遞給函式。

AWS 函式路由

Spring Cloud Function 的核心功能之一是路由。此功能允許您有一個特殊的 Java 方法（作為 Lambda 函式處理器）來委託給其他內部方法。您已經在入門部分中看到了這一點，當時通用 FunctionInvoker 自動將請求路由到您的 uppercase 函式。

預設情況下，如果您的應用程式有多個 Function 等型別的 @Bean，它們將從 Spring Cloud FunctionCatalog 中提取，框架將嘗試按照搜尋順序查詢預設值，首先搜尋 Function，然後是 Consumer，最後是 Supplier。這些預設路由功能是必需的，因為 FunctionInvoker 無法確定要繫結哪個函式，因此它內部預設為 RoutingFunction。建議使用多種機制提供額外的路由指令（有關詳細資訊，請參閱示例）。

正確的路由機制取決於您是將 Spring Cloud Function 專案部署為單個 Lambda 函式還是多個 Lambda 函式。

單個函式 vs. 多個函式

如果您在同一個 Spring Cloud Function 專案中實現多個 Java 方法，例如 uppercase 和 lowercase，您可以部署兩個具有靜態路由資訊的單獨 Lambda 函式，或者提供一個動態路由方法，在執行時決定呼叫哪個方法。讓我們看看這兩種方法。

如果您對每個函式有不同的擴充套件、配置或許可權要求，部署兩個單獨的 AWS Lambda 函式是合理的。例如，如果您在同一個 Spring Cloud Function 專案中建立兩個 Java 方法 readObjectFromAmazonS3 和 writeToAmazonDynamoDB，您可能希望建立兩個單獨的 Lambda 函式。這是因為它們需要不同的許可權才能與 S3 或 DynamoDB 通訊，或者它們的負載模式和記憶體配置差異很大。通常，對於基於訊息傳遞的應用程式（您從流或佇列中讀取資料），也建議採用這種方法，因為每個 Lambda 事件源對映都有一個專門的配置。
當多個 Java 方法共享相同的許可權集或提供內聚的業務功能時，單個 Lambda 函式是一種有效的方法。例如，一個基於 CRUD 的 Spring Cloud Function 專案，包含 createPet、updatePet、readPet 和 deletePet 方法，它們都與同一個 DynamoDB 表通訊，並且具有相似的使用模式。使用單個 Lambda 函式將提高部署的簡便性、內聚性和共享類 (PetEntity) 的程式碼重用。此外，它可以減少連續呼叫之間的冷啟動，因為 readPet 後跟 writePet 很可能會命中已在執行的 Lambda 執行環境。但是，當您構建更復雜的 API，或者希望利用 @RestController 方法時，您可能還需要評估用於 Spring Boot Web 的無伺服器 Java 容器選項。

如果您喜歡第一種方法，您還可以建立兩個獨立的 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 和環境變數是在構建或部署時定義的，因此您不能將它們用於單個函式場景。在這種情況下，您可以利用 MessagingRoutingCallback 或 Message Headers，如 Spring Cloud Function 路由部分中所述。

更多詳細資訊可在提供的示例中找到。

效能考量

無伺服器函式的一個核心特性是能夠擴充套件到零並處理突發流量高峰。為了處理請求，AWS Lambda 會啟動新的執行環境。這些環境需要初始化，您的程式碼需要下載，並且 JVM + 您的應用程式需要啟動。這也稱為冷啟動。為了減少冷啟動時間，您可以依靠以下機制來最佳化效能。

利用 AWS Lambda SnapStart 從預初始化快照啟動您的 Lambda 函式。
透過 AWS Lambda Power Tuning 調整記憶體配置，以在效能和成本之間找到最佳折衷。
遵循 AWS SDK 最佳實踐，例如在處理程式程式碼之外定義 SDK 客戶端或利用更高階的預熱技術。
實現額外的 Spring 機制以減少 Spring 啟動和初始化時間，例如功能性 Bean 註冊。

有關更多資訊，請參閱官方指南。

GraalVM 本機映像

Spring Cloud Function 為在 AWS Lambda 上執行的函式提供 GraalVM 本機映像支援。由於 GraalVM 本機映像不在傳統的 Java 虛擬機器 (JVM) 上執行，因此您必須將本機 Spring Cloud Function 部署到 AWS Lambda 自定義執行時。最顯著的區別是您不再提供 JAR 檔案，而是提供一個捆綁在 zip 包中的本機映像和帶有啟動指令的引導檔案

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

引導檔案

#!/bin/sh

cd ${LAMBDA_TASK_ROOT:-.}

./function-sample-aws-native

您可以在 GitHub 上找到帶有 Spring Cloud Function 的完整 GraalVM 本機映像示例。有關深入瞭解，您還可以參考 Java on AWS Lambda 工作坊的 GraalVM 模組。

自定義執行時

Lambda 專注於提供穩定的長期支援 (LTS) Java 執行時版本。官方 Lambda 執行時是圍繞作業系統、程式語言和軟體庫的組合構建的，這些組合會進行維護和安全更新。例如，Java 的 Lambda 執行時支援 LTS 版本，例如 Java 17 Corretto 和 Java 21 Corretto。您可以在此處找到完整列表。沒有為非 LTS 版本（如 Java 22、Java 23 或 Java 24）提供執行時。

要使用其他語言版本、JVM 或 GraalVM 本機映像，Lambda 允許您建立自定義執行時。自定義執行時允許您提供和配置自己的執行時以執行其應用程式程式碼。Spring Cloud Function 提供了所有必要的元件，使其變得簡單。

從程式碼角度來看，應用程式應與其他 Spring Cloud Function 應用程式沒有什麼不同。您唯一需要做的就是在 ZIP/JAR 的根目錄中提供一個執行 Spring Boot 應用程式的 bootstrap 指令碼，並在 AWS 中建立函式時選擇“自定義執行時”。這是一個“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，您的函式將在自定義執行時中執行。我們提供了一個示例專案，您還可以在其中檢視如何配置您的 POM 以正確生成 ZIP 檔案。

函式 Bean 定義樣式也適用於自定義執行時，並且比 @Bean 樣式更快。自定義執行時甚至比 Java Lambda 的函式 Bean 實現啟動更快——這主要取決於您需要在執行時載入的類數量。Spring 在這方面做得不多，因此您可以透過僅在函式中使用基本型別來減少冷啟動時間，例如，並且不在自定義 @PostConstruct 初始化器中執行任何工作。

帶有自定義執行時的 AWS 函式路由

使用自定義執行時時，函式路由的工作方式相同。您只需將 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 檔案，一個帶有用於 Lambda 部署的 aws 分類器，另一個是可執行（薄）JAR，在執行時包含 spring-cloud-function-web。Spring Cloud Function 將嘗試從 JAR 檔案清單中查詢“主類”，使用 Start-Class 屬性（如果您使用 starter parent，Spring Boot 工具將為您新增該屬性）。如果清單中沒有 Start-Class，您可以在將函式部署到 AWS 時使用環境變數或系統屬性 MAIN_CLASS。

如果您不使用功能性 Bean 定義，而是依賴 Spring Boot 的自動配置，並且不依賴於 spring-boot-starter-parent，則必須將額外的轉換器配置為 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 Plugin 生成瘦 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 Plugin 和 Spring Boot Thin Gradle Plugin 生成瘦 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 的無伺服器 Java 容器

您可以使用 aws-serverless-java-container 庫在 AWS Lambda 中執行 Spring Boot 3 應用程式。這非常適合將現有 Spring 應用程式遷移到 AWS Lambda，或者如果您構建具有多個 API 端點的複雜 API 並希望保持熟悉的 RestController 方法。以下部分提供了該過程的高階概述。請參閱官方示例程式碼以獲取更多資訊。

將無伺服器 Java 容器庫匯入您現有的 Spring Boot 3 Web 應用程式

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

使用內建的 Lambda 函式處理器作為入口點

com.amazonaws.serverless.proxy.spring.SpringDelegatingLambdaContainerHandler
配置名為 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 本機映像在內的所有示例。