翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# AWS Lambda 関数を実行する
**注記**
AWS IoT Greengrass は、現在 Windows コアデバイスにこの機能をサポートしていません。
AWS Lambda 関数を AWS IoT Greengrass コアデバイスで実行されるコンポーネントとしてインポートできます。このようにするのは、次のような場合です。
+ コアデバイスにデプロイする Lambda 関数にアプリケーションコードがあります。
+ AWS IoT Greengrass V2 コアデバイスで実行する AWS IoT Greengrass V1 アプリケーションがあります。詳細については、「[ステップ 2: AWS IoT Greengrass V1 アプリケーションを移行する AWS IoT Greengrass V2 コンポーネントを作成してデプロイする](set-up-v2-test-device.md#run-v1-applications)」を参照してください。
Lambda 関数には以下のコンポーネントに依存関係が含まれています。関数のインポート時に、これらのコンポーネントを依存関係として定義する必要はありません。Lambda 関数コンポーネントをデプロイすると、デプロイにはこれらの Lambda コンポーネントの依存関係が含まれます。
+ [Lambda ランチャーコンポーネント](lambda-launcher-component.md) (`aws.greengrass.LambdaLauncher`) は、プロセスと環境設定を処理します。
+ -[[Lambda manager component]](lambda-manager-component.md) (Lambda マネージャーコンポーネント) (`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 で作成することはできません。Lambda ランタイムの AWS IoT Greengrass サポートの詳細については、「[AWS Lambda 関数を実行する](#run-lambda-functions)」を参照してください。
## Lambda 関数のライフサイクルを設定する
Greengrass Lambda 関数ライフサイクルは、関数が開始する時期とどのようにコンテナを作成して使用するかを定義します。また、ライフサイクルでは、AWS IoT Greengrass Core ソフトウェアがファンクションハンドラーの外部にある変数や前処理ロジックをどのように保持するかも決定されます。
AWS IoT Greengrass は、オンデマンド (デフォルト) および長い存続期間のライフサイクルをサポートしています。
+ **オンデマンド** 関数は、呼び出されたときに起動し、実行するタスクが残っていないときに停止します。関数を呼び出すたびに、サンドボックスとも呼ばれる個別のコンテナが作成され、既存のコンテナが再利用可能でない限り、呼び出しが処理されます。どのコンテナでも、関数に送信したデータを処理することがあります。
オンデマンド関数の複数の呼び出しを同時に実行できます。
関数ハンドラーの外部で定義した変数や前処理ロジックは、新しいコンテナが作成されるときに保持されません。
+ **存続期間が長い** (または*固定された*) 関数は、AWS IoT Greengrass Core ソフトウェアが起動すると開始され、単一のコンテナで実行されます。同じコンテナが、関数に送信するすべてのデータを処理します。
AWS IoT Greengrass Core ソフトウェアが以前の呼び出しを実行するまでキュー状態になります。
関数ハンドラーの外部で定義する変数と事前処理ロジックは、このハンドラーの毎回の呼び出しのために保持されます。
初期入力なしで作業を開始する必要がある場合は、長い存続期間の Lambda 関数を使用してください。例えば、存続期間が長い関数は、機械学習モデルを読み込んで処理を開始し、関数がデバイスデータを受信したときに準備が整うようにすることができます。
**注記**
長い存続期間の関数には、ハンドラーの各呼び出しに関連付けられたタイムアウトがあります。無期限に実行されるコードを呼び出す場合は、ハンドラーの外部で開始する必要があります。関数の初期化を妨げる可能性のあるブロッキングコードがハンドラーの外部にないことを確認してください。
これらの機能は、デプロイ中や 再起動中など、AWS IoT Greengrass Core ソフトウェアが停止しない限り実行されます。これらの関数は、関数がキャッチされない例外に遭遇した場合、そのメモリ制限を超過した場合、またはハンドラータイムアウトなどのエラー状態に入った場合は実行されません。
コンテナの再利用の詳細については、「*AWS Compute Blog*」の「[Understanding Container Reuse in AWS Lambda](https://aws.amazon.com/blogs/compute/container-reuse-in-lambda/)」を参照してください。
## Lambda 関数のコンテナ化を設定する
デフォルトでは、Lambda 関数は AWS IoT Greengrass コンテナ内で実行されます。Greengrass コンテナは、関数とホスト間の分離を提供します。この分離により、ホストとコンテナ内の関数の両方でセキュリティが向上します。
ユースケースでコンテナ化せずに実行する必要がある場合を除き、Lambda 関数を Greengrass コンテナで実行することをお勧めします。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/ja_jp/greengrass/v2/developerguide/run-lambda-functions.html) |
| コンテナなし | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v2/developerguide/run-lambda-functions.html) |
Lambda 関数をデプロイするときにコンテナ化を変更すると、関数が期待通りに動作しない場合があります。Lambda 関数が、新しいコンテナ化設定で利用できなくなったローカルリソースを使用する場合、デプロイは失敗します。
+ Greengrass コンテナでの実行からコンテナ化を使用しない実行へと Lambda 関数を変更すると、関数のメモリ制限は破棄されます。アタッチ済みのローカルリソースを使用する代わりに、ファイルシステムに直接アクセスする必要があります。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)のナビゲーションメニューで、**[Components]** (コンポーネント) を選択します。
1. **[Components]** (コンポーネント) ページで、**[Create component]** (コンポーネントの作成) を選択します。
1. **[Component information]** (コンポーネント情報) の **[Create component]** (コンポーネントの作成) ページで、**[Import Lambda function]** (Lambda 関数のインポート) を選択します。
1. **[Lambda function]** (Lambda 関数) で、インポートする Lambda 関数を検索して選択します。
AWS IoT Greengrass は、Lambda 関数の名前でコンポーネントを作成します。
1. **[Lambda function version]** (Lambda 関数のバージョン) で、インポートするバージョンを選択します。`$LATEST` などの Lambda エイリアスを選択することはできません。
AWS IoT Greengrass は、Lambda 関数のバージョンを有効なセマンティックバージョンとしてコンポーネントを作成します。例えば、関数のバージョンが `3` である場合、コンポーネントのバージョンは `3.0.0` になります。
## ステップ 2: Lambda 関数パラメータを設定する
**[Lambda function configuration]** (Lambda 関数の設定) の **[Create component]** (コンポーネントの作成) ページで、Lambda 関数の実行に使用する次のパラメータを設定します。
1. (オプション) Lambda 関数が作業メッセージのためにサブスクライブするイベントソースのリストを追加します。イベントソースを指定して、この関数をローカルのパブリッシュ/サブスクライブメッセージと AWS IoT Core MQTT メッセージにサブスクライブできます。Lambda 関数は、イベントソースからメッセージを受信したときに呼び出されます。
**注記**
この関数を他の Lambda 関数またはコンポーネントからのメッセージにサブスクライブするには、この Lambda 関数コンポーネントをデプロイするときに[レガシーサブスクリプションルーターコンポーネント](legacy-subscription-router-component.md)をデプロイしてください。レガシーサブスクリプションルーターコンポーネントをデプロイするときは、Lambda 関数が使用するサブスクリプションを指定します。
**[Event sources]** (イベントソース) で以下を実行して、イベントソースを追加します。
1. 追加したイベントソースごとに、次のオプションを指定します。
+ **[Topic]** (トピック) – メッセージをサブスクライブするためのトピック。
+ **[Type]** (タイプ) – イベントソースのタイプ。次のオプションから選択します。
+ **ローカルの公開/サブスクライブ** – ローカルの公開/サブスクライブメッセージに対するサブスクライブ。
[Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 以降、または [Lambda マネージャー](lambda-manager-component.md) v2.2.5 以降を使用する場合、**[Topic]** (トピック) でタイプを指定する際に、MQTT トピックのワイルドカード (`+` および `#`) を使用できます。
+ **AWS IoT Core MQTT** – AWS IoT Core MQTT メッセージをサブスクライブします。
**[Topic]** (トピック) でタイプを指定する際に、MQTT ワイルドカード (`+` および `#`) を使用できます。
1. 別のイベントソースを追加するには、**[Add event source]** (イベントソースの追加) をクリックし、前の手順を繰り返します。イベントソースを削除するには、削除するイベントソースの横にある **[Remove]** (削除) を選択します。
1. **[Timeout (seconds)]** (タイムアウト (秒)) には、ピン留めされていない Lambda 関数のタイムアウトまでの最大実行時間 (秒) を入力してください。デフォルト値は 3 秒です。
1. **[Pinned]** (ピン留め) では、Lambda 関数コンポーネントをピン留めするかどうかを選択します。デフォルトは **[True]** (真) です。
+ 固定 (または存続期間の長い) Lambda 関数は、 AWS IoT Greengrass が起動したときに開始され、独自のコンテナで実行され続けます。
+ ピン留めされていない (またはオンデマンドの) Lambda 関数は、作業項目を受け取ったときのみ開始し、アイドル状態のまま指定された最大アイドル時間を過ぎると終了します。関数に複数の作業項目がある場合、 AWS IoT Greengrass Core ソフトウェアは関数の複数のインスタンスを作成します。
1. (オプション) **[Additional parameters]** (その他のパラメータ) で、以下の Lambda 関数パラメータを設定します。
+ **[Status timeout (seconds)]** (ステータスタイムアウト (秒)) – Lambda 関数のコンポーネントが Lambda マネージャーコンポーネントにステータスの更新を送信する間隔 (秒)。このパラメータは、ピン留めされた関数にのみ適用されます。デフォルト値は 60 秒です。
+ **[Maximum queue size]** (最大キューサイズ) – Lambda 関数コンポーネントのメッセージキューの最大サイズ。 AWS IoT Greengrass Core ソフトウェアは、Lambda 関数を実行して各メッセージを消費できるようになるまで、メッセージを FIFO (先入れ先出し) キューに保存します。デフォルトはメッセージ 1,000 件です。
+ **[Maximum number of instances]** (インスタンスの最大数) – ピン留めされていない Lambda 関数が同時に実行できるインスタンスの最大数。デフォルトは 100 件です。
+ **最大アイドル時間 (秒)** — AWS IoT Greengrass Core ソフトウェアがプロセスを停止するまでに、ピン留めされていない Lambda 関数がアイドル状態になる最大時間を秒単位で表します。デフォルト値は 60 秒です。
+ **[Encoding type]** (エンコードタイプ) – Lambda 関数がサポートするペイロードのタイプ。次のオプションから選択します。
+ **JSON**
+ **バイナリ**
デフォルトは JSON です。
1. (オプション) 実行時に Lambda 関数に渡すコマンドライン引数のリストを指定します。
1. **[Additional parameters, Process arguments]** (追加パラメータ、プロセス引数) で **[Add argument]** (引数を追加) を選択します。
1. 追加する引数ごとに、関数に渡す引数を入力します。
1. 引数を削除するには、削除する引数の横にある **[Remove]** (削除) を選択します。
1. (オプション) 実行時に Lambda 関数を利用できる環境変数を指定してください。環境変数を使用すると、関数コードを変更することなく設定を保存および更新できます。
1. **[Additional parameters, Environment variables]** (追加パラメータ、環境変数) で、**[Add environment variables]** (環境変数を追加) を選択します。
1. 追加する環境変数ごとに、次のオプションを指定します。
+ **[Key]** (キー) – 変数名。
+ **[Value]** (値) – この変数のデフォルト値。
1. 環境変数を削除するには、削除する環境変数の横にある **[Remove]** (削除) を選択します。
## ステップ 3: (オプション) Lambda 関数がサポートするプラットフォームを指定します。
すべてのコアデバイスには、オペレーティングシステムとアーキテクチャの属性があります。Lambda 関数コンポーネントをデプロイすると、 AWS IoT Greengrass Core ソフトウェアは指定したプラットフォーム値とコアデバイスのプラットフォーム属性を比較して、Lambda 関数がそのデバイスでサポートされているかどうかを判断します。
**注記**
コアデバイスに Greengrass nucleus コンポーネント をデプロイする際、カスタムのプラットフォーム属性を指定することもできます。詳細については、「[Greengrass nucleus コンポーネント](greengrass-nucleus-component.md)」の「[プラットフォームの上書きパラメータ](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-platform-overrides)」を参照してください。
**[Lambda function configuration, Additional parameters, Platforms]** (Lambda 関数の設定、追加パラメータ、プラットフォーム) で以下の手順を実行して、この Lambda 関数がサポートするプラットフォームを指定します。
1. プラットフォームごとに以下のオプションを指定します。
+ **[Operating system]** (オペレーティングシステム) – プラットフォームのオペレーティングシステムの名前。現在、サポートされている値は `linux` のみです。
+ **[Architecture]** (アーキテクチャ) – プラットフォームのプロセッサアーキテクチャ。サポートされている値は以下のとおりです。
+ `amd64`
+ `arm`
+ `aarch64`
+ `x86`
1. 別のプラットフォームを追加するには、**[Add platform]** (プラットフォームを追加) を選択して、先の手順を繰り返します。サポートされているプラットフォームを削除するには、削除するプラットフォームの横にある **[Remove]** (削除) を選択します。
## ステップ 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 function configuration, Additional parameters, Component dependencies]** (Lambda 関数の設定、追加パラメータ、コンポーネントの依存関係) で以下の手順を実行し、Lambda 関数のコンポーネントの依存関係を指定します。
1. **[Add dependency]** (依存関係の追加) を選択します。
1. 追加したコンポーネントの依存関係ごとに、以下のオプションを指定します。
+ **[Component name]** (コンポーネント名) – コンポーネント名。たとえば **aws.greengrass.StreamManager** と入力して[ストリームマネージャーコンポーネント](stream-manager-component.md)を含めます。
+ **[Version requirement]** (バージョン要件) – このコンポーネントの依存関係において互換性のあるバージョンを識別する npm スタイルのセマンティックバージョン制約。1 つのバージョンまたはバージョンの範囲を指定できます。たとえば **^1.0.0** と入力すると、この Lambda 関数がストリームマネージャーコンポーネントの最初のメジャーバージョンのすべてのバージョンに依存することを指定できます。セマンティックバージョン制約の詳細については、[npm semver calculator](https://semver.npmjs.com/) を参照してください。
+ **[Type]** (タイプ) – 依存関係のタイプ。次のオプションから選択します。
+ **[Hard]** (強) – 依存関係が状態を変化させると、Lambda 関数コンポーネントが再起動します。デフォルトではこれが選択されています。
+ **[Soft]** (弱) – 依存関係が状態を変化させても、Lambda 関数コンポーネントは再起動しません。
1. コンポーネントの依存関係を削除するには、コンポーネントの依存関係の横にある**[Remove]** (削除) を選択します。
## ステップ 5: (オプション) コンテナで Lambda 関数を実行する
デフォルトでは、Lambda 関数は AWS IoT Greengrass Core ソフトウェア内の分離されたランタイム環境で実行されます。また、Lambda 関数を分離されないプロセスとして (つまり**[No container]** (コンテナなし) モードで) 実行することもできます。
**[Linux process configuration]** (Linux プロセス設定) で、**[Isolation mode]** (分離モード) について、Lambda 関数のコンテナ化を以下のオプションから選択します。
+ **[Greengrass container]** (Greengrass コンテナ) – The Lambda 関数はコンテナで実行されます。デフォルトではこれが選択されています。
+ **[No container]** (コンテナなし) – Lambda 関数は分離されないプロセスとして実行されます。
コンテナで Lambda 関数を実行する場合は、以下の手順で Lambda 関数のプロセス設定を行います。
1. コンテナを利用できるメモリの量とシステムリソース (ボリュームやデバイスなど) を設定します。
**[Container parameters]** (コンテナパラメータ) で以下を行います。
1. **[Memory size]** (メモリサイズ) にはコンテナに割り当てるメモリサイズを入力します。メモリサイズは **[MB]** または **[KB]** で指定できます。
1. **[Read-only sys folder]** (読み取り専用の Sys フォルダ) について、コンテナがデバイスの `/sys` フォルダから情報を読み取れるかどうか指定します。デフォルトは **[False]** (偽) です。
1. (オプション) コンテナ化された Lambda 関数がアクセスできるローカルボリュームを設定します。ボリュームを定義すると、 AWS IoT Greengrass Core ソフトウェアはソースファイルをコンテナ内の宛先にマウントします。
1. **[Volumes]** (ボリューム) で、**[Add volume]** (ボリュームを追加) を選択します。
1. 追加したボリュームごとに、次のオプションを指定します。
+ **[Physical volume]** (物理ボリューム) –コアデバイスのソースフォルダへのパス。
+ **[Logical volume]** (論理ボリューム) – コンテナの保存先フォルダへのパス。
+ **[Permission]** (アクセス権限) – (オプション) コンテナからソースフォルダへのアクセス権限。次のオプションから選択します。
+ **[Read-only]** (読み取り専用) – Lambda 関数はソースフォルダへの読み取り専用アクセス権が与えられます。デフォルトではこれが選択されています。
+ **[Read-write]** (読み取り/書き取り) – Lambda 関数はソースフォルダへの読み取り/書き込みアクセス権が与えられます。
+ **[Add group owner]** (グループ所有者の追加) – (オプション) Lambda 関数コンポーネントを実行するシステムグループをソースフォルダの所有者として追加するかどうか。デフォルトは **[False]** (偽) です。
1. ボリュームを削除するには、削除するボリュームの横にある **[Remove]** (削除) を選択します。
1. (オプション) コンテナ化された Lambda 関数がアクセスできるローカルシステムデバイスを設定します。
1. **[Devices]** (デバイス) で、**[Add device]** (デバイスの追加) を選択します。
1. 追加したデバイスごとに、次のオプションを指定します。
+ **[Mount path]** (マウントパス) – コアデバイスのシステムデバイスへのパス。
+ **[Permission]** (アクセス権限) – (オプション) コンテナからシステムデバイスへのアクセス権限。次のオプションから選択します。
+ **[Read-only]** (読み取り専用) – Lambda 関数はシステムデバイスへの読み取り専用アクセス権が与えられます。デフォルトではこれが選択されています。
+ **[Read-write]** (読み取り/書き取り) – Lambda 関数はソースフォルダへの読み取り/書き込みアクセス権が与えられます。
+ **[Add group owner]** (グループ所有者の追加) – (オプション) Lambda 関数コンポーネントを実行するシステムグループをシステムデバイスの所有者として追加するかどうか。デフォルトは **[False]** (偽) です。
## ステップ 6: Lambda 関数コンポーネントを作成する
Lambda 関数コンポーネントを設定した後は、**[Create]** (作成) をクリックして新しいコンポーネントの作成を完了します。
コアデバイスで 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`) の属性があります。 AWS IoT Greengrass Core ソフトウェアは、他のプラットフォーム属性を追加する場合があります。コアデバイスに [Greengrass nucleus コンポーネント](greengrass-nucleus-component.md) をデプロイする際、カスタムのプラットフォーム属性を指定することもできます。以下の操作を実行します。
1. `lambda-function-component.json` の Lambda 関数にプラットフォームのリスト (`componentPlatforms`) を追加します。
```
{
"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. `lambda-function-component.json` の Lambda 関数にコンポーネントの依存関係 (`componentDependencies`) のマップを追加します。
```
{
"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 スタイルのセマンティックバージョン制約。1 つのバージョンまたはバージョンの範囲を指定できます。セマンティックバージョン制約の詳細については、[npm semver calculator](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-function-component.json` の 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": {
}
}
}
```
1. (オプション) Lambda 関数が作業メッセージのためにサブスクライブするイベントソースを指定します。イベントソースを指定して、この関数をローカルのパブリッシュ/サブスクライブメッセージと AWS IoT Core MQTT メッセージにサブスクライブできます。Lambda 関数は、イベントソースからメッセージを受信したときに呼び出されます。
**注記**
この関数を他の Lambda 関数またはコンポーネントからのメッセージにサブスクライブするには、この Lambda 関数コンポーネントをデプロイするときに[レガシーサブスクリプションルーターコンポーネント](legacy-subscription-router-component.md)をデプロイしてください。レガシーサブスクリプションルーターコンポーネントをデプロイするときは、Lambda 関数が使用するサブスクリプションを指定します。
以下の操作を実行します。
1. Lambda 関数のパラメータにイベントソース (`eventSources`) のリストを追加します。
```
{
"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 マネージャー](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 Core ソフトウェアがプロセスを停止するまでに、ピン留めされていない Lambda 関数がアイドル状態にできる秒単位の最大時間。デフォルト値は 60 秒です。
+ `maxInstancesCount` – ピン留めされていない Lambda 関数が同時に実行できるインスタンスの最大数。デフォルトは 100 件です。
+ `maxQueueSize` – Lambda 関数コンポーネントのメッセージキューの最大サイズ。 AWS IoT Greengrass Core ソフトウェアは、Lambda 関数を実行して各メッセージを消費できるようになるまで、メッセージを FIFO (first-in-first-outキューに保存します。デフォルトはメッセージ 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-function-component.json` の 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": [
{
"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`) を、`lambda-function-component.json` の Linux プロセスパラメータオブジェクトに追加します
```
{
"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 Core ソフトウェアはソースファイルをコンテナ内の宛先にマウントします。以下の操作を実行します。
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-function-component.json` から Lambda 関数コンポーネントを作成します。
```
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)」を参照してください。