Rust Serverless 實戰：建構 AWS Lambda 高效能應用程式

– 12 分鐘閱讀

當企業應用程式需要快速擴展以應對不可預測的流量變化時，傳統的伺服器架構往往面臨諸多挑戰。需要預先配置足夠的伺服器容量來處理尖峰流量，但這些資源在流量低谷時期會造成浪費。伺服器的維護、修補與監控也需要持續的人力投入。Serverless 架構提供了一種革命性的解決方案，開發者只需要專注於撰寫業務邏輯程式碼，雲端服務供應商會自動處理擴展、高可用性與基礎設施管理。

AWS Lambda 作為 Serverless 運算的先驅，支援多種程式語言，但 Rust 作為後起之秀，在 Lambda 環境中展現出獨特的優勢。Rust 編譯後的二進位檔案執行速度快，記憶體使用量少，這在按執行時間與記憶體使用量計費的 Lambda 環境中能夠顯著降低成本。Rust 的所有權系統與借用檢查器確保了記憶體安全，消除了許多常見的程式錯誤。零成本抽象讓開發者能夠撰寫高階程式碼而不犧牲效能。

然而使用 Rust 開發 Lambda 函數並非沒有挑戰。Lambda 本身並不直接支援 Rust 執行環境，開發者需要使用自訂執行環境。程式碼需要編譯為特定的目標平台，打包與部署流程也比直譯語言複雜。這時 Cargo Lambda 工具鏈就顯得特別重要，它簡化了整個開發流程，從專案建立到編譯部署都提供了完善的支援。

本文將帶領讀者從零開始建構一個完整的 Rust Serverless 應用程式。我們將從最簡單的 Hello World 函數開始，逐步深入到使用 AWS SAM 定義基礎設施，整合 API Gateway 提供 RESTful API，並連接 DynamoDB 作為持久化儲存。透過詳細的程式碼範例與解說，讀者將掌握 Rust Serverless 開發的核心技術。

Cargo Lambda 工具鏈建置

在開始開發 Rust Lambda 函數之前，需要先建立適當的開發環境。Cargo Lambda 是專為 Lambda 開發設計的 Cargo 子命令工具，它提供了專案建立、本地測試、編譯打包與部署等完整功能。這個工具大幅簡化了 Rust Lambda 開發的複雜度，讓開發者能夠專注於業務邏輯的實作。

# 安裝 Cargo Lambda
# 對於 Debian/Ubuntu 系統，先安裝 pip 套件管理工具
sudo apt update
sudo apt install python3-pip

# 使用 pip 安裝 Cargo Lambda
# 這會將 Cargo Lambda 安裝為全域可用的命令列工具
sudo pip3 install cargo-lambda

# 驗證安裝
# 顯示 Cargo Lambda 的版本資訊
cargo lambda --version

# 對於 macOS 使用者
# 可以使用 Homebrew 安裝
brew tap cargo-lambda/cargo-lambda
brew install cargo-lambda

# 對於 Windows 使用者
# 建議使用 WSL2 (Windows Subsystem for Linux)
# 然後按照 Linux 的安裝步驟進行

安裝完成後可以使用 Cargo Lambda 建立新專案。這個工具提供了互動式的專案建立流程，會詢問一些關鍵問題來決定專案的初始配置。是否建立 HTTP 函數決定了專案會使用哪些相依套件，選擇事件來源則會影響函數的輸入輸出格式。

# 建立新的 Lambda 專案
# 這會建立一個名為 serverless-hello-world 的目錄
cargo lambda new serverless-hello-world

# 互動式問答過程
# Is this function an HTTP function? (y/N)
# 如果選擇 y，會使用 lambda_http 套件
# 如果選擇 N，會使用 lambda_runtime 套件

# Which service is this function receiving events from?
# 這個問題會影響事件的型別定義
# 可以選擇 API Gateway、EventBridge、S3 等

# 進入專案目錄
cd serverless-hello-world

# 檢視專案結構
# Cargo.toml 包含相依套件定義
# src/main.rs 包含 Lambda 函數程式碼
tree .

專案建立後會得到一個完整的 Rust 專案結構，包含 Cargo.toml 相依套件定義檔與 src/main.rs 主程式檔案。Cargo Lambda 會根據你的選擇自動加入適當的相依套件，例如 lambda_runtime 用於基本的 Lambda 執行環境，tokio 提供非同步執行環境，serde 處理 JSON 序列化。

Hello World Lambda 函數實作

一個基本的 Lambda 函數需要能夠接收事件、處理邏輯並回傳結果。Rust 的型別系統讓我們可以精確地定義輸入與輸出的資料結構，確保在編譯時期就能捕捉到型別錯誤。以下是一個簡單但完整的 Hello World 實作，展示了 Lambda 函數的核心概念。

/**
 * Rust AWS Lambda Hello World 函數
 * 
 * 這是一個簡單的 Lambda 函數範例
 * 接收包含 first_name 的 JSON 請求，回傳個人化的問候訊息
 * 
 * @author 玄貓（BlackCat）
 */

// 引入必要的套件
// lambda_runtime 提供 Lambda 執行環境的核心功能
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
// serde 提供 JSON 序列化與反序列化功能
use serde::{Deserialize, Serialize};

/**
 * 請求資料結構
 * 
 * 定義 Lambda 函數接收的輸入格式
 * Deserialize trait 讓 Rust 能夠從 JSON 自動解析為這個結構
 */
#[derive(Deserialize)]
struct Request {
    // 使用者的名字
    // 如果 JSON 中沒有這個欄位，會導致反序列化失敗
    first_name: String,
}

/**
 * 回應資料結構
 * 
 * 定義 Lambda 函數回傳的輸出格式
 * Serialize trait 讓 Rust 能夠將這個結構自動轉換為 JSON
 */
#[derive(Serialize)]
struct Response {
    // 問候訊息
    message: String,
}

/**
 * Lambda 函數處理器
 * 
 * 這是實際處理業務邏輯的函數
 * async 關鍵字表示這是一個非同步函數
 * 
 * @param event Lambda 事件，包含請求資料與上下文資訊
 * @return Result 型別，成功時包含 Response，失敗時包含 Error
 */
async fn function_handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
    // 從事件中提取請求資料
    // event.payload 包含反序列化後的 Request 結構
    let name = event.payload.first_name;
    
    // 建立回應訊息
    // 如果名字為空字串，使用預設的問候對象
    let message = if name.is_empty() {
        // 空字串時的預設訊息
        "Hello, Serverless World".to_string()
    } else {
        // 使用 format! 巨集建立個人化問候
        // 這類似於其他語言的字串插值或格式化
        format!("Hello, {}", name)
    };
    
    // 建立回應結構
    let response = Response { message };
    
    // 使用 Ok 包裝回應，表示成功執行
    // Lambda 會自動將這個結構序列化為 JSON 回傳
    Ok(response)
}

/**
 * 主函數
 * 
 * Lambda 函數的進入點
 * tokio::main 巨集建立 Tokio 非同步執行環境
 */
#[tokio::main]
async fn main() -> Result<(), Error> {
    // 初始化日誌系統
    // tracing_subscriber 提供結構化的日誌記錄
    tracing_subscriber::fmt()
        // 設定日誌層級為 INFO
        // 這會記錄 INFO、WARN 與 ERROR 層級的訊息
        .with_max_level(tracing::Level::INFO)
        // 不顯示目標模組名稱，簡化輸出
        .with_target(false)
        // 不顯示時間戳記
        // Lambda 執行環境會自動加入時間戳記
        .without_time()
        // 啟動日誌系統
        .init();
    
    // 執行 Lambda 函數
    // service_fn 將我們的處理器函數轉換為 Lambda 服務
    // run 啟動 Lambda 執行環境並開始處理事件
    run(service_fn(function_handler)).await
}

程式碼完成後需要編譯為適合 Lambda 執行環境的格式。Lambda 支援 x86_64 與 arm64 兩種架構，arm64 通常能提供更好的效能價格比。編譯過程會產生一個名為 bootstrap 的二進位檔案，這是 Lambda 自訂執行環境的標準進入點。

# 編譯 Lambda 函數
# --release 啟用最佳化編譯，產生更小更快的二進位檔案
# --arm64 指定目標架構為 ARM64
# --output-format zip 直接產生可上傳的 ZIP 檔案
cargo lambda build --release --arm64 --output-format zip

# 編譯產物位置
# target/lambda/serverless-hello-world/bootstrap.zip
# 這個 ZIP 檔案包含編譯好的二進位檔案

# 本地測試（可選）
# Cargo Lambda 提供本地測試功能
# 模擬 Lambda 執行環境來測試函數
cargo lambda watch

# 在另一個終端機視窗中發送測試請求
cargo lambda invoke --data-ascii '{"first_name": "Ferris"}'

@startuml
!define PLANTUML_FORMAT svg
!theme _none_

skinparam dpi auto
skinparam shadowing false
skinparam linetype ortho
skinparam roundcorner 5
skinparam defaultFontName "Microsoft JhengHei UI"
skinparam defaultFontSize 14
skinparam minClassWidth 100

|開發者|
start

:撰寫 Rust 程式碼;
note right
  定義 Request、Response 結構
  實作 function_handler
end note

:執行 cargo lambda build;

|Cargo Lambda|
:編譯 Rust 程式碼;

:針對 arm64 架構編譯;

:產生 bootstrap 二進位檔案;

:打包為 ZIP 格式;

|開發者|
:取得 bootstrap.zip;

:上傳到 AWS Lambda;

|AWS Lambda|
:解壓縮 ZIP 檔案;

:載入 bootstrap 執行檔;

:等待事件觸發;

|AWS 服務|
:發送事件到 Lambda;
note right
  事件可能來自
  API Gateway、S3、DynamoDB 等
end note

|AWS Lambda|
:啟動執行環境;

:執行 bootstrap;

|Rust Lambda 函數|
:反序列化事件為 Request;

:執行 function_handler;

:建立 Response;

:序列化 Response 為 JSON;

|AWS Lambda|
:回傳結果;

|AWS 服務|
:接收回應;

stop

@enduml

AWS SAM 基礎設施即程式碼

在雲端環境中手動透過控制台建立與配置資源是一個容易出錯且難以追蹤的過程。基礎設施即程式碼（Infrastructure as Code, IaC）透過程式碼來定義基礎設施，讓整個環境可以版本控制、自動化部署與快速重建。AWS SAM（Serverless Application Model）是 AWS 提供的 Serverless 應用程式框架，它擴展了 AWS CloudFormation 範本，提供了更簡潔的語法來定義 Lambda 函數、API Gateway 與其他 Serverless 資源。

# 安裝 AWS SAM CLI
# 下載最新版本的安裝檔案
wget https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip

# 解壓縮安裝檔案
unzip aws-sam-cli-linux-x86_64.zip -d sam-installation

# 執行安裝腳本
sudo ./sam-installation/install

# 驗證安裝
sam --version

# 配置 AWS 認證
# SAM CLI 需要 AWS 認證資訊來管理資源
# 可以使用 AWS CLI 來配置
aws configure
# 輸入 Access Key ID
# 輸入 Secret Access Key
# 輸入預設區域（例如 us-east-1）
# 輸入預設輸出格式（例如 json）

AWS SAM 範本是一個 YAML 檔案，定義了應用程式需要的所有資源與它們之間的關係。範本分為幾個主要區段：Globals 定義全域配置，Resources 定義各種 AWS 資源，Outputs 定義部署後要輸出的資訊。以下是一個完整的範例，展示如何定義 Lambda 函數、DynamoDB 資料表與 API Gateway。

# template.yaml
# AWS SAM 範本定義 Serverless 應用程式的基礎設施

# CloudFormation 範本版本
# 這是固定的版本號碼，表示範本格式的版本
AWSTemplateFormatVersion: '2010-09-09'

# SAM 轉換
# 這個指令告訴 CloudFormation 使用 SAM 轉換器
# 轉換器會將 SAM 的簡化語法擴展為完整的 CloudFormation 資源
Transform: AWS::Serverless-2016-10-31

# 範本描述
# 提供這個範本的簡短說明
Description: >
  catdex-serverless
  一個使用 Rust 開發的 Serverless 貓咪目錄應用程式
  展示 Lambda、API Gateway 與 DynamoDB 的整合

# 全域配置
# 這些設定會自動套用到所有支援的資源
Globals:
  Function:
    # Lambda 函數的預設逾時時間（秒）
    # 所有 Lambda 函數都會繼承這個設定
    # 可以在個別函數中覆寫
    Timeout: 3
    
    # 記憶體配置（MB）
    # 更多記憶體也會分配更多 CPU 資源
    MemorySize: 128
    
    # 執行環境
    # provided.al2 表示自訂執行環境，基於 Amazon Linux 2
    Runtime: provided.al2
    
    # 架構
    # arm64 (Graviton2) 通常比 x86_64 更便宜且效能更好
    Architectures:
      - arm64

# 資源定義
# 定義應用程式需要的所有 AWS 資源
Resources:
  # DynamoDB 資料表
  # 用於儲存貓咪資料
  CatTable:
    # 資源類型
    # SimpleTable 是 SAM 提供的簡化型別
    # 它會建立一個具有單一主鍵的 DynamoDB 資料表
    Type: AWS::Serverless::SimpleTable
    
    Properties:
      # 主鍵定義
      PrimaryKey:
        # 主鍵名稱
        Name: cat_id
        # 主鍵型別
        # String 表示字串型別
        Type: String
      
      # 資料表名稱（可選）
      # 如果不指定，CloudFormation 會自動產生唯一名稱
      TableName: CatdexTable
  
  # Lambda 函數：新增貓咪
  # 處理 POST /cat 請求，將貓咪資料寫入 DynamoDB
  PostCatFunction:
    # 資源類型
    # Serverless::Function 是 SAM 提供的簡化型別
    Type: AWS::Serverless::Function
    
    Properties:
      # 程式碼位置
      # 指向包含編譯後 Lambda 函數的目錄
      # 這個目錄應該包含 bootstrap 執行檔
      CodeUri: target/lambda/catdex-serverless/
      
      # 處理器
      # 對於自訂執行環境，處理器名稱固定為 bootstrap
      Handler: bootstrap
      
      # 事件觸發器
      # 定義什麼事件會觸發這個函數
      Events:
        # 事件名稱
        PostCat:
          # 事件類型：API Gateway
          Type: Api
          Properties:
            # API 路徑
            Path: /cat
            # HTTP 方法
            Method: post
      
      # 環境變數
      # 傳遞給 Lambda 函數的環境變數
      Environment:
        Variables:
          # DynamoDB 資料表名稱
          # !Ref 是 CloudFormation 的內建函數
          # 它會引用其他資源的邏輯 ID
          TABLE_NAME: !Ref CatTable
      
      # IAM 政策
      # 定義函數可以存取哪些 AWS 服務
      Policies:
        # DynamoDB 寫入權限
        # SAM 提供的政策範本
        - DynamoDBWritePolicy:
            # 指定可以寫入的資料表
            TableName: !Ref CatTable
  
  # Lambda 函數：取得貓咪列表
  # 處理 GET /cats 請求，從 DynamoDB 讀取所有貓咪資料
  GetCatsFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: target/lambda/catdex-serverless/
      Handler: bootstrap
      Events:
        GetCats:
          Type: Api
          Properties:
            Path: /cats
            Method: get
      Environment:
        Variables:
          TABLE_NAME: !Ref CatTable
      Policies:
        # DynamoDB 讀取權限
        - DynamoDBReadPolicy:
            TableName: !Ref CatTable

# 輸出
# 部署完成後要顯示的資訊
Outputs:
  # API Gateway 端點 URL
  ApiEndpoint:
    Description: "API Gateway endpoint URL for Prod stage"
    # !Sub 是字串替換函數
    # ${} 中的變數會被實際值替換
    # ServerlessRestApi 是 SAM 自動建立的 API Gateway
    Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/"
  
  # Lambda 函數 ARN
  PostCatFunctionArn:
    Description: "Post Cat Lambda Function ARN"
    # !GetAtt 取得資源的屬性
    Value: !GetAtt PostCatFunction.Arn
  
  # DynamoDB 資料表名稱
  CatTableName:
    Description: "DynamoDB Cat Table Name"
    Value: !Ref CatTable

範本定義完成後可以使用 SAM CLI 進行部署。首次部署時使用 guided 模式，SAM 會互動式地詢問各種配置選項，並將選擇儲存到 samconfig.toml 檔案中，方便後續的自動化部署。

# 首次部署：引導模式
# SAM 會詢問一系列問題來配置部署
sam deploy --guided

# 互動式問答過程：
# Stack Name: 輸入 CloudFormation 堆疊名稱（例如 catdex-serverless）
# AWS Region: 選擇部署的 AWS 區域（例如 us-east-1）
# Confirm changes before deploy: 是否在部署前確認變更（建議選 Y）
# Allow SAM CLI IAM role creation: 允許建立 IAM 角色（必須選 Y）
# Save arguments to configuration file: 儲存配置（選 Y）
# SAM configuration file: 配置檔名稱（使用預設的 samconfig.toml）
# SAM configuration environment: 環境名稱（使用預設的 default）

# 後續部署：使用儲存的配置
# 直接使用 samconfig.toml 中的配置進行部署
sam deploy

# 刪除整個堆疊
# 這會刪除所有由 SAM 建立的資源
sam delete

完整 Serverless 架構整合

一個完整的 Serverless 應用程式通常包含多個元件：API Gateway 處理 HTTP 請求並路由到適當的 Lambda 函數，Lambda 函數執行業務邏輯，DynamoDB 提供持久化儲存，S3 儲存桶託管靜態前端檔案。這些元件透過 AWS IAM 政策進行安全控制，確保每個服務只有必要的權限。

以下範例展示如何在 Rust Lambda 函數中操作 DynamoDB，實作基本的 CRUD 操作。這需要使用 AWS SDK for Rust，它提供了型別安全的 API 來存取各種 AWS 服務。

/**
 * Rust Lambda 函數：DynamoDB 整合
 * 
 * 展示如何在 Lambda 函數中讀寫 DynamoDB
 * 實作貓咪資料的新增與查詢功能
 */

use aws_sdk_dynamodb::{Client, Error as DynamoError};
use lambda_http::{run, service_fn, Body, Error, Request, Response};
use serde::{Deserialize, Serialize};
use std::env;

/**
 * 貓咪資料結構
 * 
 * 定義儲存在 DynamoDB 中的貓咪資訊
 */
#[derive(Serialize, Deserialize, Clone)]
struct Cat {
    // 貓咪 ID（主鍵）
    cat_id: String,
    // 貓咪名字
    name: String,
    // 品種
    breed: String,
    // 年齡
    age: u8,
}

/**
 * 新增貓咪到 DynamoDB
 * 
 * @param client DynamoDB 客戶端
 * @param table_name 資料表名稱
 * @param cat 貓咪資料
 */
async fn add_cat(
    client: &Client,
    table_name: &str,
    cat: &Cat,
) -> Result<(), DynamoError> {
    // 建立 PutItem 請求
    // 將 Rust 結構轉換為 DynamoDB 的 AttributeValue
    client
        .put_item()
        .table_name(table_name)
        .item("cat_id", aws_sdk_dynamodb::types::AttributeValue::S(cat.cat_id.clone()))
        .item("name", aws_sdk_dynamodb::types::AttributeValue::S(cat.name.clone()))
        .item("breed", aws_sdk_dynamodb::types::AttributeValue::S(cat.breed.clone()))
        .item("age", aws_sdk_dynamodb::types::AttributeValue::N(cat.age.to_string()))
        .send()
        .await?;
    
    Ok(())
}

/**
 * 從 DynamoDB 取得所有貓咪
 * 
 * @param client DynamoDB 客戶端
 * @param table_name 資料表名稱
 * @return 貓咪資料向量
 */
async fn get_cats(
    client: &Client,
    table_name: &str,
) -> Result<Vec<Cat>, DynamoError> {
    // 執行 Scan 操作取得所有項目
    // 注意：Scan 會讀取整個資料表，成本較高
    // 生產環境應該使用分頁或 Query
    let result = client
        .scan()
        .table_name(table_name)
        .send()
        .await?;
    
    // 將 DynamoDB 項目轉換為 Cat 結構
    let mut cats = Vec::new();
    
    if let Some(items) = result.items {
        for item in items {
            // 從 HashMap 中提取屬性值
            let cat_id = item.get("cat_id")
                .and_then(|v| v.as_s().ok())
                .cloned()
                .unwrap_or_default();
            
            let name = item.get("name")
                .and_then(|v| v.as_s().ok())
                .cloned()
                .unwrap_or_default();
            
            let breed = item.get("breed")
                .and_then(|v| v.as_s().ok())
                .cloned()
                .unwrap_or_default();
            
            let age = item.get("age")
                .and_then(|v| v.as_n().ok())
                .and_then(|s| s.parse().ok())
                .unwrap_or(0);
            
            cats.push(Cat {
                cat_id,
                name,
                breed,
                age,
            });
        }
    }
    
    Ok(cats)
}

/**
 * Lambda 函數處理器
 * 
 * 根據 HTTP 方法路由到不同的處理邏輯
 */
async fn function_handler(
    event: Request,
    client: &Client,
) -> Result<Response<Body>, Error> {
    // 從環境變數取得資料表名稱
    let table_name = env::var("TABLE_NAME")
        .expect("TABLE_NAME environment variable not set");
    
    // 根據 HTTP 方法路由
    match event.method().as_str() {
        "POST" => {
            // 處理 POST 請求：新增貓咪
            let body = event.body();
            let cat: Cat = serde_json::from_slice(body.as_ref())?;
            
            add_cat(&client, &table_name, &cat).await?;
            
            Ok(Response::builder()
                .status(201)
                .header("Content-Type", "application/json")
                .body(Body::from(serde_json::to_string(&cat)?))?)
        }
        "GET" => {
            // 處理 GET 請求：取得所有貓咪
            let cats = get_cats(&client, &table_name).await?;
            
            Ok(Response::builder()
                .status(200)
                .header("Content-Type", "application/json")
                .body(Body::from(serde_json::to_string(&cats)?))?)
        }
        _ => {
            // 不支援的方法
            Ok(Response::builder()
                .status(405)
                .body(Body::from("Method Not Allowed"))?)
        }
    }
}

/**
 * 主函數
 */
#[tokio::main]
async fn main() -> Result<(), Error> {
    // 初始化 AWS SDK
    let config = aws_config::load_from_env().await;
    let client = Client::new(&config);
    
    // 執行 Lambda 函數
    // 使用閉包來傳遞 DynamoDB 客戶端
    run(service_fn(|event| async {
        function_handler(event, &client).await
    }))
    .await
}

@startuml
!define PLANTUML_FORMAT svg
!theme _none_

skinparam dpi auto
skinparam shadowing false
skinparam linetype ortho
skinparam roundcorner 5
skinparam defaultFontName "Microsoft JhengHei UI"
skinparam defaultFontSize 14
skinparam minClassWidth 100

|使用者|
start

:發送 HTTP 請求;
note right
  POST /cat
  或
  GET /cats
end note

|API Gateway|
:接收 HTTP 請求;

:驗證請求格式;

:路由到對應的 Lambda 函數;

|Lambda 函數|
:載入執行環境;

:初始化 AWS SDK;

:從環境變數取得\nDynamoDB 資料表名稱;

if (請求方法?) then (POST)
  :解析請求 Body\n取得貓咪資料;
  
  :呼叫 add_cat();
  
  |DynamoDB|
  :執行 PutItem 操作;
  
  :寫入貓咪資料;
  
  :回傳成功;
  
  |Lambda 函數|
  :建立 201 Created 回應;
elseif (GET)
  :呼叫 get_cats();
  
  |DynamoDB|
  :執行 Scan 操作;
  
  :讀取所有貓咪資料;
  
  :回傳項目列表;
  
  |Lambda 函數|
  :轉換為 Cat 結構;
  
  :序列化為 JSON;
  
  :建立 200 OK 回應;
else (其他)
  :建立 405 Method Not Allowed 回應;
endif

:回傳 HTTP 回應;

|API Gateway|
:接收 Lambda 回應;

:轉換為 HTTP 回應格式;

|使用者|
:接收回應;

stop

@enduml

從實務角度來看，使用 Rust 開發 AWS Lambda 應用程式帶來了顯著的效能與成本優勢。Rust 編譯後的二進位檔案冷啟動時間短，執行速度快，記憶體使用量低。這在按執行時間與記憶體計費的 Serverless 環境中能夠直接轉化為成本節省。Cargo Lambda 工具鏈大幅簡化了開發流程，從本地測試到生產部署都提供了良好的支援。

AWS SAM 作為基礎設施即程式碼工具，讓整個應用架構可以版本控制與自動化部署。這消除了手動配置的錯誤，也讓環境的建立與銷毀變得簡單。透過 SAM 範本可以清楚地定義各個資源之間的關係與相依性，CloudFormation 會自動處理資源的建立順序與更新邏輯。

展望未來，隨著 Rust 生態系統的成熟與 AWS 對 Rust 支援的加強，使用 Rust 開發 Serverless 應用將變得更加普及。AWS Lambda 已經宣布對 Rust 的官方支援，這意味著開發者將不再需要使用自訂執行環境。Rust 的 async/await 語法與強大的型別系統，配合 AWS SDK 的持續改進，將讓開發者能夠更輕鬆地建構高效能且可靠的雲端原生應用程式。

玄貓 BlackCat

玄貓 BlackCat

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。