本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 執行 AWS Lambda 函數
**注意**
AWS IoT Greengrass 目前不支援 Windows 核心裝置上的此功能。
您可以將 AWS Lambda 函數匯入為在 AWS IoT Greengrass 核心裝置上執行的元件。在下列情況中，您可能想要執行此操作：
+ 您在 Lambda 函數中具有應用程式碼，而您要部署到核心裝置。
+ 您有要在 AWS IoT Greengrass V2 核心裝置上執行的 AWS IoT Greengrass V1 應用程式。如需詳細資訊，請參閱[步驟 2：建立和部署 AWS IoT Greengrass V2 元件以遷移 AWS IoT Greengrass V1 應用程式](set-up-v2-test-device.md#run-v1-applications)。
Lambda 函數包含下列元件的相依性。匯入函數時，您不需要將這些元件定義為相依性。當您部署 Lambda 函數元件時，部署會包含這些 Lambda 元件相依性。
+ [Lambda 啟動器元件](lambda-launcher-component.md) (`aws.greengrass.LambdaLauncher`) 會處理程序和環境組態。
+ [Lambda 管理員元件](lambda-manager-component.md) (`aws.greengrass.LambdaManager`) 會處理程序間通訊和擴展。
+ [Lambda 執行期元件](lambda-runtimes-component.md) (`aws.greengrass.LambdaRuntimes`) 為每個支援的 Lambda 執行期提供成品。
**Topics**
+ [要求](#run-lambda-functions-requirements)
+ [設定 Lambda 函數生命週期](#lambda-lifecycle)
+ [設定 Lambda 函數容器化](#lambda-containerization)
+ [將 Lambda 函數匯入為元件 （主控台）](import-lambda-function-console.md)
+ [將 Lambda 函數匯入為元件 (AWS CLI)](import-lambda-function-cli.md)
## 要求
您的核心裝置和 Lambda 函數必須符合下列要求，才能在 AWS IoT Greengrass Core 軟體上執行函數：
+ 您的核心裝置必須符合執行 Lambda 函數的要求。如果您想要核心裝置執行容器化 Lambda 函數，裝置必須符合執行此作業的要求。如需詳細資訊，請參閱[Lambda 函數需求](setting-up.md#greengrass-v2-lambda-requirements)。
+ 您必須安裝 Lambda 函數在核心裝置上使用的程式設計語言。
**提示**
您可以建立安裝程式設計語言的元件，然後將該元件指定為 Lambda 函數元件的相依性。Greengrass 支援所有 Lambda 支援的 Python、Node.js 和 Java 執行時間版本。Greengrass 不會對已取代的 Lambda 執行時間版本套用任何其他限制。您可以在 上執行使用這些已棄用執行時間的 Lambda 函數 AWS IoT Greengrass，但無法在 中建立它們 AWS Lambda。如需 AWS IoT Greengrass 支援 Lambda 執行時間的詳細資訊，請參閱[執行 AWS Lambda 函數](#run-lambda-functions)。
## 設定 Lambda 函數生命週期
Greengrass Lambda 函數生命週期會決定函數何時啟動，以及它如何建立和使用容器。生命週期也會決定 AWS IoT Greengrass Core 軟體如何保留函數處理常式外部的變數和預先處理邏輯。
AWS IoT Greengrass 支援隨需 （預設） 和長期生命週期：
+ 隨**需**函數會在叫用時啟動，並在沒有任務剩餘時停止。除非現有容器可供重複使用，否則函數的每次調用都會建立個別容器，也稱為沙盒，以處理調用。任何容器都可能處理您傳送至 函數的資料。
隨需函數的多個調用可以同時執行。
建立新容器時，不會保留您在函數處理常式外定義的變數和預先處理邏輯。
+ **長期 **（或*固定*) 函數會在 AWS IoT Greengrass Core 軟體在單一容器中啟動和執行時啟動。相同的容器會處理您傳送至 函數的所有資料。
多個調用會排入佇列，直到 AWS IoT Greengrass 核心軟體提早執行調用。
您於函數處理常式外部定義的變數和預先處理邏輯，會在每次呼叫處理常式時保留。
當您需要在沒有任何初始輸入的情況下開始工作時，請使用長期 Lambda 函數。例如，長期函數可以載入並開始處理機器學習模型，以便在函數接收裝置資料時準備就緒。
**注意**
長期函數具有與其處理常式的每個調用相關聯的逾時。如果您想要叫用無限期執行的程式碼，您必須在處理常式外部啟動它。請確定處理常式外部沒有封鎖碼，而可能使函數無法初始化。
除非 AWS IoT Greengrass 核心軟體停止，否則這些函數會執行，例如在部署或重新啟動期間。如果函數遇到未攔截的例外狀況、超過其記憶體限制，或輸入錯誤狀態，例如處理常式逾時，則不會執行這些函數。
如需容器重複使用的詳細資訊，請參閱*AWS 運算部落格*中的[了解 中的容器重複使用 AWS Lambda](https://aws.amazon.com/blogs/compute/container-reuse-in-lambda/)。
## 設定 Lambda 函數容器化
根據預設，Lambda 函數會在 AWS IoT Greengrass 容器內執行。Greengrass 容器可在函數和主機之間提供隔離。此隔離可提高主機和容器中函數的安全性。
建議您在 Greengrass 容器中執行 Lambda 函數，除非您的使用案例需要它們在沒有容器化的情況下執行。透過在 Greengrass 容器中執行 Lambda 函數，您可以更好地控制如何限制對資源的存取。
在下列情況下，您可以執行 Lambda 函數而不進行容器化：
+ 您想要 AWS IoT Greengrass 在不支援容器模式的裝置上執行 。例如，如果您想要使用特殊的 Linux 發行版本，或是舊版的核心版本已過期。
+ 您想要在另一個容器環境中使用自己的 OverlayFS 執行 Lambda 函數，但當您在 Greengrass 容器中執行 時，會遇到 OverlayFS 衝突。
+ 您需要使用無法在部署時間確定的路徑，或其路徑在部署後可能會變更的路徑來存取本機資源。此資源的範例為可插入裝置。
+ 您有一個先前以程序形式寫入的應用程式，當您在 Greengrass 容器中執行時遇到問題。
**容器化差異**
| 容器化 | 備註 |
| --- | --- |
| Greengrass 容器 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/run-lambda-functions.html) |
| 沒有容器 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/run-lambda-functions.html) |
如果您在部署 Lambda 函數時變更其容器化，該函數可能無法如預期般運作。如果 Lambda 函數使用不再可用於新容器化設定的本機資源，則部署會失敗。
+ 當您將 Lambda 函數從在 Greengrass 容器中執行變更為在沒有容器化的情況下執行時，函數的記憶體限制會遭到捨棄。您必須直接存取檔案系統，而不是使用連接的本機資源。部署 Lambda 函數之前，您必須先移除任何連接的資源。
+ 當您將 Lambda 函數從在沒有容器化的情況下執行變更為在容器中執行時，您的 Lambda 函數會失去檔案系統的直接存取權。您必須為每個函數定義記憶體限制，或接受預設的 16 MB 記憶體限制。您可以在部署時為每個 Lambda 函數設定這些設定。
若要變更 Lambda 函數元件的容器化設定，請在部署元件時，將`containerMode`組態參數的值設定為下列其中一個選項。
+ `NoContainer` – 元件不會在隔離的執行時間環境中執行。
+ `GreengrassContainer` – 元件會在 AWS IoT Greengrass 容器內的隔離執行期環境中執行。
如需如何部署和設定元件的詳細資訊，請參閱 [將 AWS IoT Greengrass 元件部署至裝置](manage-deployments.md)和 [更新元件組態](update-component-configurations.md)。
# 將 Lambda 函數匯入為元件 （主控台）
當您使用[AWS IoT Greengrass 主控台](https://console.aws.amazon.com/greengrass)建立 Lambda 函數元件時，您可以匯入現有的 AWS Lambda 函數，然後將其設定為建立在 Greengrass 裝置上執行的元件。
開始之前，請檢閱在 Greengrass 裝置上執行 Lambda 函數[的需求](https://docs.aws.amazon.com/greengrass/v2/developerguide/run-lambda-functions.html#run-lambda-functions-requirements)。
**Topics**
+ [步驟 1：選擇要匯入的 Lambda 函數](#import-lambda-console-choose-function)
+ [步驟 2：設定 Lambda 函數參數](#import-lambda-console-configure-function-parameters)
+ [步驟 3：（選用） 指定 Lambda 函數支援的平台](#import-lambda-console-configure-platforms)
+ [步驟 4：（選用） 指定 Lambda 函數的元件相依性](#import-lambda-console-configure-dependencies)
+ [步驟 5：（選用） 在容器中執行 Lambda 函數](#import-lambda-console-run-isolated)
+ [步驟 6：建立 Lambda 函數元件](#import-lambda-console-create-deploy)
## 步驟 1：選擇要匯入的 Lambda 函數
1. 在[AWS IoT Greengrass 主控台](https://console.aws.amazon.com/greengrass)導覽功能表中，選擇**元件**。
1. 在**元件**頁面上，選擇**建立元件**。
1. 在**建立元件**頁面的**元件資訊**下，選擇**匯入 Lambda 函數**。
1. 在 **Lambda 函數**中，搜尋並選擇您要匯入的 Lambda 函數。
AWS IoT Greengrass 會使用 Lambda 函數的名稱建立元件。
1. 在 **Lambda 函數版本**中，選擇要匯入的版本。您無法選擇 Lambda 別名，例如 `$LATEST`。
AWS IoT Greengrass 會使用 Lambda 函數的 版本建立元件，做為有效的語意版本。例如，如果您的函數版本為 `3`，則元件版本會變成 `3.0.0`。
## 步驟 2：設定 Lambda 函數參數
在**建立元件**頁面的 **Lambda 函數組態**下，設定下列參數以用於執行 Lambda 函數。
1. （選用） 新增 Lambda 函數訂閱工作訊息的事件來源清單。您可以指定事件來源，將此函數訂閱本機發佈/訂閱訊息和 AWS IoT Core MQTT 訊息。從事件來源接收訊息時，會呼叫 Lambda 函數。
**注意**
若要將此函數訂閱其他 Lambda 函數或元件的訊息，請在部署此 Lambda 函數元件時部署[舊版訂閱路由器](legacy-subscription-router-component.md)元件。部署舊版訂閱路由器元件時，請指定 Lambda 函數使用的訂閱。
在**事件來源**下，執行下列動作來新增事件來源：
1. 針對您新增的每個事件來源，指定下列選項：
+ **主題** – 訂閱訊息的主題。
+ **類型** – 事件來源的類型。您可以從以下選項中選擇：
+ **本機發佈/訂閱** – 訂閱本機發佈/訂閱訊息。
如果您使用 [Greengrass 核 v](greengrass-nucleus-component.md)2.6.0 或更新版本，以及 [Lambda Manager](lambda-manager-component.md) v2.2.5 或更新版本，則可以在指定此類型時使用**主題**中的 MQTT 主題萬用字元 (`+` 和 `#`)。
+ **AWS IoT Core MQTT** – 訂閱 AWS IoT Core MQTT 訊息。
當您指定此類型時，您可以在**主題**中使用 MQTT 主題萬用字元 (`+` 和 `#`)。
1. 若要新增另一個事件來源，請選擇**新增事件來源**並重複上一個步驟。若要移除事件來源，請選擇您要**移除**的事件來源旁的移除。
1. 針對**逾時 （秒）**，輸入非固定 Lambda 函數在逾時之前可執行的時間上限，以秒為單位。預設為 3 秒。
1. 針對**固定**，選擇是否固定 Lambda 函數元件。預設值為 **True**。
+ 固定 （或長期） Lambda 函數會在 AWS IoT Greengrass 啟動時啟動，並在自己的容器中持續執行。
+ 非固定 （或隨需） Lambda 函數只會在接收工作項目時啟動，並在閒置達指定的閒置時間上限後結束。如果函數有多個工作項目，則 AWS IoT Greengrass Core 軟體會建立函數的多個執行個體。
1. （選用） **在其他參數**下，設定下列 Lambda 函數參數。
+ **狀態逾時 （秒）** – Lambda 函數元件將狀態更新傳送至 Lambda 管理員元件的間隔，以秒為單位。此參數僅適用於固定函數。預設值為 60 秒。
+ **最大佇列大小** – Lambda 函數元件的訊息佇列大小上限。Core AWS IoT Greengrass 軟體會將訊息存放在 FIFO （先進先出） 佇列中，直到可以執行 Lambda 函數來取用每個訊息為止。預設值為 1，000 則訊息。
+ **執行個體數目上限** – 非固定 Lambda 函數可同時執行的執行個體數目上限。預設值為 100 個執行個體。
+ **閒置時間上限 （秒）** – 在 AWS IoT Greengrass 核心軟體停止其程序之前，非固定 Lambda 函數可以閒置的時間上限，以秒為單位。預設值為 60 秒。
+ **編碼類型** – Lambda 函數支援的承載類型。您可以從以下選項中選擇：
+ **JSON**
+ **：二進位**
預設值為 JSON。
1. （選用） 指定命令列引數清單，以在執行時傳遞至 Lambda 函數。
1. 在**其他參數、程序引數**下，選擇**新增引數**。
1. 針對您新增的每個引數，輸入您要傳遞至函數的引數。
1. 若要移除引數，請選擇您要**移除**的引數旁的移除。
1. （選用） 指定 Lambda 函數在執行時可用的環境變數。環境變數可讓您儲存和更新組態設定，而不需要變更函數程式碼。
1. 在**其他參數、環境變數**下，選擇**新增環境變數**。
1. 針對您新增的每個環境變數，指定下列選項：
+ **索引鍵** – 變數名稱。
+ **值** – 此變數的預設值。
1. 若要移除環境變數，請選擇您要**移除**的環境變數旁的移除。
## 步驟 3：（選用） 指定 Lambda 函數支援的平台
所有核心裝置都有作業系統和架構的屬性。當您部署 Lambda 函數元件時， AWS IoT Greengrass Core 軟體會將您指定的平台值與核心裝置上的平台屬性進行比較，以判斷該裝置上是否支援 Lambda 函數。
**注意**
您也可以在將 Greengrass 核元件部署至核心裝置時指定自訂平台屬性。如需詳細資訊，請參閱 [平台覆寫 Greengrass 核元件的參數](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-platform-overrides)。 [Greengrass 核](greengrass-nucleus-component.md)
在 **Lambda 函數組態下，其他參數、平台**會執行下列動作，以指定此 Lambda 函數支援的平台。
1. 針對每個平台，指定下列選項：
+ **作業系統** – 平台的作業系統名稱。目前，僅支援的值為 `linux`。
+ **架構** – 平台的處理器架構。支援的值如下：
+ `amd64`
+ `arm`
+ `aarch64`
+ `x86`
1. 若要新增另一個平台，請選擇**新增平台**並重複上一個步驟。若要移除支援的平台，請選擇您要**移除**之平台旁的移除。
## 步驟 4：（選用） 指定 Lambda 函數的元件相依性
元件相依性會識別函數使用的其他 AWS提供的元件或自訂元件。當您部署 Lambda 函數元件時，部署會包含要讓函數執行的這些相依性。
**重要**
若要匯入您建立以在 AWS IoT Greengrass V1 上執行的 Lambda 函數，您必須為函數使用的功能定義個別元件相依性，例如秘密、本機陰影和串流管理員。將這些元件定義為[硬相依性](component-recipe-reference.md)，以便在相依性變更狀態時重新啟動 Lambda 函數元件。如需詳細資訊，請參閱[匯入 V1 Lambda 函數](set-up-v2-test-device.md#run-v1-lambda-functions)。
在 **Lambda 函數組態、其他參數、元件相依性**下，完成下列步驟以指定 Lambda 函數的元件相依性。
1. 選擇**新增相依性**。
1. 針對您新增的每個元件相依性，指定下列選項：
+ **元件名稱** – 元件名稱。例如，輸入 **aws.greengrass.StreamManager**以包含[串流管理員元件](stream-manager-component.md)。
+ **版本需求** – 識別此元件相依性的相容版本的 npm 樣式語意版本限制。您可以指定單一版本或一系列版本。例如，輸入 **^1.0.0** 指定此 Lambda 函數取決於串流管理員元件第一個主要版本中的任何版本。如需語意版本限制的詳細資訊，請參閱 [npm 轉換器計算器](https://semver.npmjs.com/)。
+ **類型** — 相依性的類型。您可以從以下選項中選擇：
+ **硬** – 如果相依性變更狀態，Lambda 函數元件會重新啟動。這是預設選擇。
+ **軟** – 如果相依性變更狀態，Lambda 函數元件不會重新啟動。
1. 若要移除元件相依性，請選擇元件相依性旁的**移除**
## 步驟 5：（選用） 在容器中執行 Lambda 函數
根據預設，Lambda 函數會在 AWS IoT Greengrass Core 軟體內的隔離執行期環境中執行。您也可以選擇執行 Lambda 函數作為不隔離的程序 （即**無容器**模式）。
在 **Linux 程序組態**下，對於**隔離模式**，從下列選項中選擇 Lambda 函數的容器化：
+ **Greengrass 容器** – Lambda 函數會在容器中執行。這是預設選擇。
+ **無容器** – Lambda 函數執行為沒有任何隔離的程序。
如果您在容器中執行 Lambda 函數，請完成下列步驟來設定 Lambda 函數的程序組態。
1. 設定記憶體和系統資源的數量，例如磁碟區和裝置，以便可供容器使用。
在**容器參數**下，執行下列動作。
1. 針對**記憶體大小**，輸入您要配置給容器的記憶體大小。您可以指定記憶體大小，以 **MB** 或 **kB** 為單位。
1. 對於**唯讀 sys 資料夾**，選擇容器是否可以從裝置`/sys`資料夾讀取資訊。預設值為 **False**。
1. （選用） 設定容器化 Lambda 函數可存取的本機磁碟區。當您定義磁碟區時， AWS IoT Greengrass 核心軟體會將來源檔案掛載到容器內的目的地。
1. 在**磁碟區**下，選擇**新增磁碟區**。
1. 針對您新增的每個磁碟區，指定下列選項：
+ **實體磁碟區** – 核心裝置上的來源資料夾路徑。
+ **邏輯磁碟區** – 容器中目的地資料夾的路徑。
+ **許可** – （選用） 從容器存取來源資料夾的許可。您可以從以下選項中選擇：
+ **唯讀** – Lambda 函數具有來源資料夾的唯讀存取權。這是預設選擇。
+ **讀寫** – Lambda 函數具有來源資料夾的讀寫存取權。
+ **新增群組擁有者** – （選用） 是否要將執行 Lambda 函數元件的系統群組新增為來源資料夾的擁有者。預設值為 **False**。
1. 若要移除磁碟區，請選擇您要**移除**的磁碟區旁的移除。
1. （選用） 設定容器化 Lambda 函數可存取的本機系統裝置。
1. 在**裝置**下，選擇**新增裝置**。
1. 針對您新增的每個裝置，指定下列選項：
+ **掛載路徑** – 核心裝置上的系統裝置的路徑。
+ **許可** – （選用） 從容器存取系統裝置的許可。您可以從以下選項中選擇：
+ **唯讀** – Lambda 函數具有系統裝置的唯讀存取權。這是預設選擇。
+ **讀寫** – Lambda 函數具有來源資料夾的讀寫存取權。
+ **新增群組擁有者** – （選用） 是否要將執行 Lambda 函數元件的系統群組新增為系統裝置的擁有者。預設值為 **False**。
## 步驟 6：建立 Lambda 函數元件
設定 Lambda 函數元件的設定後，請選擇**建立**以完成建立新元件。
若要在核心裝置上執行 Lambda 函數，您可以將新元件部署至核心裝置。如需詳細資訊，請參閱[將 AWS IoT Greengrass 元件部署至裝置](manage-deployments.md)。
# 將 Lambda 函數匯入為元件 (AWS CLI)
使用 [CreateComponentVersion](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateComponentVersion.html) 操作從 Lambda 函數建立元件。當您呼叫此操作時，請指定 `lambdaFunction`以匯入 Lambda 函數。
**Topics**
+ [步驟 1：定義 Lambda 函數組態](#create-lambda-function-configuration-cli)
+ [步驟 2：建立 Lambda 函數元件](#create-lambda-component-cli)
## 步驟 1：定義 Lambda 函數組態
1. 建立名為 的檔案`lambda-function-component.json`，然後將下列 JSON 物件複製到 檔案。將 取代`lambdaArn`為要匯入之 Lambda 函數的 ARN。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1"
}
}
```
**重要**
您必須指定包含要匯入之函數版本的 ARN。您不能使用 `$LATEST` 之類的版本別名。
1. （選用） 指定元件的名稱 (`componentName`)。如果您省略此參數， 會使用 Lambda 函數的名稱 AWS IoT Greengrass 建立元件。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda"
}
}
```
1. （選用） 指定元件的版本 (`componentVersion`)。如果您省略此參數， 會使用 Lambda 函數的 版本 AWS IoT Greengrass 建立元件，做為有效的語意版本。例如，如果您的函數版本為 `3`，則元件版本會變成 `3.0.0`。
**注意**
您上傳的每個元件版本都必須是唯一的。請務必上傳正確的元件版本，因為您在上傳之後無法編輯。
AWS IoT Greengrass 使用元件的語意版本。語意版本遵循 *major*.*minor*.*patch* 號碼系統。例如，版本`1.0.0`代表元件的第一個主要版本。如需詳細資訊，請參閱[語意版本規格](https://semver.org/)。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0"
}
}
```
1. （選用） 指定此 Lambda 函數支援的平台。每個平台都包含識別平台的屬性映射。所有核心裝置都有作業系統 (`os`) 和架構 () 的屬性`architecture`。Core AWS IoT Greengrass 軟體可能會新增其他平台屬性。您也可以在將 [Greengrass 核元件](greengrass-nucleus-component.md)部署至核心裝置時指定自訂平台屬性。請執行下列操作：
1. 將平台清單 (`componentPlatforms`) 新增至 中的 Lambda 函數`lambda-function-component.json`。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
]
}
}
```
1. 將每個支援的平台新增至清單。每個平台都有一個易於`name`識別的 和屬性映射。下列範例指定此函數支援執行 Linux 的 x86 裝置。
```
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
```
您的 `lambda-function-component.json`可能包含類似下列範例的文件。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
]
}
}
```
1. （選用） 指定 Lambda 函數的元件相依性。當您部署 Lambda 函數元件時，部署會包含要讓函數執行的這些相依性。
**重要**
若要匯入您建立以在 AWS IoT Greengrass V1 上執行的 Lambda 函數，您必須為函數使用的功能定義個別元件相依性，例如秘密、本機陰影和串流管理員。將這些元件定義為[硬相依性](component-recipe-reference.md)，以便在相依性變更狀態時重新啟動 Lambda 函數元件。如需詳細資訊，請參閱[匯入 V1 Lambda 函數](set-up-v2-test-device.md#run-v1-lambda-functions)。
請執行下列操作：
1. 將元件相依性 (`componentDependencies`) 的映射新增至 中的 Lambda 函數`lambda-function-component.json`。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
}
}
}
```
1. 將每個元件相依性新增至映射。指定元件名稱做為金鑰，並使用下列參數指定物件：
+ `versionRequirement` – 識別元件相依性相容版本的 npm 樣式語意版本限制。您可以指定單一版本或一系列版本。如需語意版本限制的詳細資訊，請參閱 [npm 轉換器計算器](https://semver.npmjs.com/)。
+ `dependencyType` – （選用） 相依性的類型。請選擇下列項目：
+ `SOFT` – 如果相依性變更狀態，Lambda 函數元件不會重新啟動。
+ `HARD` – 如果相依性變更狀態，Lambda 函數元件會重新啟動。
預設值為 `HARD`。
下列範例指定此 Lambda 函數取決於[串流管理員元件](stream-manager-component.md)第一個主要版本中的任何版本。當串流管理員重新啟動或更新時，Lambda 函數元件會重新啟動。
```
{
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
}
```
您的 `lambda-function-component.json`可能包含類似下列範例的文件。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
}
}
}
```
1. （選用） 設定 Lambda 函數參數以用來執行函數。您可以設定選項，例如環境變數、訊息事件來源、逾時和容器設定。請執行下列操作：
1. 將 Lambda 參數物件 (`componentLambdaParameters`) 新增至 中的 Lambda 函數`lambda-function-component.json`。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
},
"componentLambdaParameters": {
}
}
}
```
1. （選用） 指定 Lambda 函數訂閱工作訊息的事件來源。您可以指定事件來源，將此函數訂閱本機發佈/訂閱訊息和 AWS IoT Core MQTT 訊息。從事件來源接收訊息時，會呼叫 Lambda 函數。
**注意**
若要將此函數訂閱其他 Lambda 函數或元件的訊息，請在部署此 Lambda 函數元件時部署[舊版訂閱路由器](legacy-subscription-router-component.md)元件。部署舊版訂閱路由器元件時，請指定 Lambda 函數使用的訂閱。
請執行下列操作：
1. 將事件來源清單 (`eventSources`) 新增至 Lambda 函數參數。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
},
"componentLambdaParameters": {
"eventSources": [
]
}
}
}
```
1. 將每個事件來源新增至清單。每個事件來源都有下列參數：
+ `topic` – 要訂閱訊息的主題。
+ `type` – 事件來源的類型。您可以從以下選項中選擇：
+ `PUB_SUB` - 訂閱本機發佈/訂閱訊息。
如果您使用 [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 或更新版本，以及 [Lambda Manager](lambda-manager-component.md) v2.2.5 或更新版本，您可以在指定此類型`topic`時使用 中的 MQTT 主題萬用字元 (`+` 和 `#`)。
+ `IOT_CORE` – 訂閱 AWS IoT Core MQTT 訊息。
當您指定此類型`topic`時，您可以在 中使用 MQTT 主題萬用字元 (`+` 和 `#`)。
下列範例會針對符合主題篩選條件`hello/world/+`的主題訂閱 AWS IoT Core MQTT。
```
{
"topic": "hello/world/+",
"type": "IOT_CORE"
}
```
您的 `lambda-function-component.json`可能看起來類似下列範例。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
},
"componentLambdaParameters": {
"eventSources": [
{
"topic": "hello/world/+",
"type": "IOT_CORE"
}
]
}
}
}
```
1. （選用） 在 Lambda 函數參數物件中指定下列任何參數：
+ `environmentVariables` – Lambda 函數執行時可用的環境變數映射。
+ `execArgs` – 執行時要傳遞給 Lambda 函數的引數清單。
+ `inputPayloadEncodingType` – Lambda 函數支援的承載類型。您可以從以下選項中選擇：
+ `json`
+ `binary`
預設：`json`
+ `pinned` – 是否固定 Lambda 函數。預設值為 `true`。
+ 固定 （或長期） Lambda 函數會在 AWS IoT Greengrass 啟動時啟動，並在自己的容器中持續執行。
+ 非固定 （或隨需） Lambda 函數只會在接收工作項目時啟動，並在閒置達指定的閒置時間上限後結束。如果函數有多個工作項目，則 AWS IoT Greengrass Core 軟體會建立函數的多個執行個體。
使用 `maxIdleTimeInSeconds`來設定函數的閒置時間上限。
+ `timeoutInSeconds` – Lambda 函數在逾時之前可執行的秒數上限。預設為 3 秒。
+ `statusTimeoutInSeconds` – Lambda 函數元件將狀態更新傳送至 Lambda 管理員元件的間隔，以秒為單位。此參數僅適用於固定函數。預設值為 60 秒。
+ `maxIdleTimeInSeconds` – 在 AWS IoT Greengrass 核心軟體停止其程序之前，非固定 Lambda 函數可以閒置的時間上限，以秒為單位。預設值為 60 秒。
+ `maxInstancesCount` – 非固定 Lambda 函數可同時執行的執行個體數目上限。預設值為 100 個執行個體。
+ `maxQueueSize` – Lambda 函數元件的訊息佇列大小上限。Core AWS IoT Greengrass 軟體會將訊息存放在 FIFO first-in-first-out佇列中，直到可以執行 Lambda 函數來取用每個訊息為止。預設值為 1，000 則訊息。
您的 `lambda-function-component.json`可能包含類似下列範例的文件。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
},
"componentLambdaParameters": {
"eventSources": [
{
"topic": "hello/world/+",
"type": "IOT_CORE"
}
],
"environmentVariables": {
"LIMIT": "300"
},
"execArgs": [
"-d"
],
"inputPayloadEncodingType": "json",
"pinned": true,
"timeoutInSeconds": 120,
"statusTimeoutInSeconds": 30,
"maxIdleTimeInSeconds": 30,
"maxInstancesCount": 50,
"maxQueueSize": 500
}
}
}
```
1. （選用） 設定 Lambda 函數的容器設定。根據預設，Lambda 函數會在 AWS IoT Greengrass Core 軟體內的隔離執行期環境中執行。您也可以選擇執行 Lambda 函數作為程序，無需任何隔離。如果您在容器中執行 Lambda 函數，您可以設定容器的記憶體大小，以及 Lambda 函數可用的系統資源。請執行下列操作：
1. 將 Linux 程序參數物件 (`linuxProcessParams`) 新增至 中的 Lambda 參數物件`lambda-function-component.json`。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
},
"componentLambdaParameters": {
"eventSources": [
{
"topic": "hello/world/+",
"type": "IOT_CORE"
}
],
"environmentVariables": {
"LIMIT": "300"
},
"execArgs": [
"-d"
],
"inputPayloadEncodingType": "json",
"pinned": true,
"timeoutInSeconds": 120,
"statusTimeoutInSeconds": 30,
"maxIdleTimeInSeconds": 30,
"maxInstancesCount": 50,
"maxQueueSize": 500,
"linuxProcessParams": {
}
}
}
}
```
1. （選用） 指定 Lambda 函數是否在容器中執行。將 `isolationMode` 參數新增至程序參數物件，然後從下列選項中選擇：
+ `GreengrassContainer` – Lambda 函數會在容器中執行。
+ `NoContainer` – Lambda 函數會以無任何隔離的程序執行。
預設值為 `GreengrassContainer`。
1. （選用） 如果您在容器中執行 Lambda 函數，您可以設定記憶體數量和系統資源，例如磁碟區和裝置，以便可供容器使用。請執行下列操作：
1. 將容器參數物件 (`containerParams`) 新增至 中的 Linux 程序參數物件`lambda-function-component.json`。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
},
"componentLambdaParameters": {
"eventSources": [
{
"topic": "hello/world/+",
"type": "IOT_CORE"
}
],
"environmentVariables": {
"LIMIT": "300"
},
"execArgs": [
"-d"
],
"inputPayloadEncodingType": "json",
"pinned": true,
"timeoutInSeconds": 120,
"statusTimeoutInSeconds": 30,
"maxIdleTimeInSeconds": 30,
"maxInstancesCount": 50,
"maxQueueSize": 500,
"linuxProcessParams": {
"containerParams": {
}
}
}
}
}
```
1. （選用） 新增 `memorySizeInKB` 參數以指定容器的記憶體大小。預設值為 16，384 KB (16 MB)。
1. （選用） 新增 `mountROSysfs` 參數，以指定容器是否可以從裝置`/sys`資料夾讀取資訊。預設值為 `false`。
1. （選用） 設定容器化 Lambda 函數可存取的本機磁碟區。當您定義磁碟區時， AWS IoT Greengrass 核心軟體會將來源檔案掛載到容器內的目的地。請執行下列操作：
1. 將磁碟區清單 (`volumes`) 新增至容器參數。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
},
"componentLambdaParameters": {
"eventSources": [
{
"topic": "hello/world/+",
"type": "IOT_CORE"
}
],
"environmentVariables": {
"LIMIT": "300"
},
"execArgs": [
"-d"
],
"inputPayloadEncodingType": "json",
"pinned": true,
"timeoutInSeconds": 120,
"statusTimeoutInSeconds": 30,
"maxIdleTimeInSeconds": 30,
"maxInstancesCount": 50,
"maxQueueSize": 500,
"linuxProcessParams": {
"containerParams": {
"memorySizeInKB": 32768,
"mountROSysfs": true,
"volumes": [
]
}
}
}
}
}
```
1. 將每個磁碟區新增至清單。每個磁碟區都有下列參數：
+ `sourcePath` – 核心裝置上的來源資料夾路徑。
+ `destinationPath` – 容器中目的地資料夾的路徑。
+ `permission` – （選用） 從容器存取來源資料夾的許可。您可以從以下選項中選擇：
+ `ro` – Lambda 函數具有來源資料夾的唯讀存取權。
+ `rw` – Lambda 函數具有來源資料夾的讀寫存取權。
預設值為 `ro`。
+ `addGroupOwner` – （選用） 是否要將執行 Lambda 函數元件的系統群組新增為來源資料夾的擁有者。預設值為 `false`。
您的 `lambda-function-component.json`可能包含類似下列範例的文件。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
},
"componentLambdaParameters": {
"eventSources": [
{
"topic": "hello/world/+",
"type": "IOT_CORE"
}
],
"environmentVariables": {
"LIMIT": "300"
},
"execArgs": [
"-d"
],
"inputPayloadEncodingType": "json",
"pinned": true,
"timeoutInSeconds": 120,
"statusTimeoutInSeconds": 30,
"maxIdleTimeInSeconds": 30,
"maxInstancesCount": 50,
"maxQueueSize": 500,
"linuxProcessParams": {
"containerParams": {
"memorySizeInKB": 32768,
"mountROSysfs": true,
"volumes": [
{
"sourcePath": "/var/data/src",
"destinationPath": "/var/data/dest",
"permission": "rw",
"addGroupOwner": true
}
]
}
}
}
}
}
```
1. （選用） 設定容器化 Lambda 函數可存取的本機系統裝置。請執行下列操作：
1. 將系統裝置清單 (`devices`) 新增至容器參數。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
},
"componentLambdaParameters": {
"eventSources": [
{
"topic": "hello/world/+",
"type": "IOT_CORE"
}
],
"environmentVariables": {
"LIMIT": "300"
},
"execArgs": [
"-d"
],
"inputPayloadEncodingType": "json",
"pinned": true,
"timeoutInSeconds": 120,
"statusTimeoutInSeconds": 30,
"maxIdleTimeInSeconds": 30,
"maxInstancesCount": 50,
"maxQueueSize": 500,
"linuxProcessParams": {
"containerParams": {
"memorySizeInKB": 32768,
"mountROSysfs": true,
"volumes": [
{
"sourcePath": "/var/data/src",
"destinationPath": "/var/data/dest",
"permission": "rw",
"addGroupOwner": true
}
],
"devices": [
]
}
}
}
}
}
```
1. 將每個系統裝置新增至清單。每個系統裝置都有下列參數：
+ `path` – 核心裝置上的系統裝置的路徑。
+ `permission` – （選用） 從容器存取系統裝置的許可。您可以從以下選項中選擇：
+ `ro` – Lambda 函數具有系統裝置的唯讀存取權。
+ `rw` – Lambda 函數具有系統裝置的讀寫存取權。
預設值為 `ro`。
+ `addGroupOwner` – （選用） 是否要將執行 Lambda 函數元件的系統群組新增為系統裝置的擁有者。預設值為 `false`。
您的 `lambda-function-component.json`可能包含類似下列範例的文件。
```
{
"lambdaFunction": {
"lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"componentPlatforms": [
{
"name": "Linux x86",
"attributes": {
"os": "linux",
"architecture": "x86"
}
}
],
"componentDependencies": {
"aws.greengrass.StreamManager": {
"versionRequirement": "^1.0.0",
"dependencyType": "HARD"
}
},
"componentLambdaParameters": {
"eventSources": [
{
"topic": "hello/world/+",
"type": "IOT_CORE"
}
],
"environmentVariables": {
"LIMIT": "300"
},
"execArgs": [
"-d"
],
"inputPayloadEncodingType": "json",
"pinned": true,
"timeoutInSeconds": 120,
"statusTimeoutInSeconds": 30,
"maxIdleTimeInSeconds": 30,
"maxInstancesCount": 50,
"maxQueueSize": 500,
"linuxProcessParams": {
"containerParams": {
"memorySizeInKB": 32768,
"mountROSysfs": true,
"volumes": [
{
"sourcePath": "/var/data/src",
"destinationPath": "/var/data/dest",
"permission": "rw",
"addGroupOwner": true
}
],
"devices": [
{
"path": "/dev/sda3",
"permission": "rw",
"addGroupOwner": true
}
]
}
}
}
}
}
```
1. （選用） 為元件新增標籤 (`tags`)。如需詳細資訊，請參閱[標記您的 AWS IoT Greengrass Version 2 資源](tag-resources.md)。
## 步驟 2：建立 Lambda 函數元件
1. 執行下列命令，從 建立 Lambda 函數元件`lambda-function-component.json`。
```
aws greengrassv2 create-component-version --cli-input-json file://lambda-function-component.json
```
如果請求成功，回應看起來與下列範例類似。
```
{
"arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorldLambda:versions:1.0.0",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"creationTimestamp": "Mon Dec 15 20:56:34 UTC 2020",
"status": {
"componentState": "REQUESTED",
"message": "NONE",
"errors": {}
}
}
```
`arn` 從輸出複製 ，以在下一個步驟中檢查元件的狀態。
1. 當您建立元件時，其狀態為 `REQUESTED`。然後， AWS IoT Greengrass 驗證元件可部署。您可以執行下列命令來查詢元件狀態，並確認元件可部署。將 取代`arn`為上一個步驟的 ARN。
```
aws greengrassv2 describe-component \
--arn "arn:aws:greengrass:region:account-id:components:com.example.HelloWorldLambda:versions:1.0.0"
```
如果元件驗證，回應會指出元件狀態為 `DEPLOYABLE`。
```
{
"arn": "arn:aws:greengrass:region:account-id:components:com.example.HelloWorldLambda:versions:1.0.0",
"componentName": "com.example.HelloWorldLambda",
"componentVersion": "1.0.0",
"creationTimestamp": "2020-12-15T20:56:34.376000-08:00",
"publisher": "AWS Lambda",
"status": {
"componentState": "DEPLOYABLE",
"message": "NONE",
"errors": {}
},
"platforms": [
{
"name": "Linux x86",
"attributes": {
"architecture": "x86",
"os": "linux"
}
}
]
}
```
元件為 之後`DEPLOYABLE`，您可以將 Lambda 函數部署至核心裝置。如需詳細資訊，請參閱[將 AWS IoT Greengrass 元件部署至裝置](manage-deployments.md)。