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。

其他資源