# Ruby による Lambda 関数の構築
Ruby コードは AWS Lambda で実行できます。Lambda は、コードを実行してイベントを処理する Ruby 用の[ランタイム](lambda-runtimes.md)を提供します。コードは、管理している AWS Identity and Access Management (IAM) ロールの認証情報を使用して、AWS SDK for Ruby を含む環境で実行されます。Ruby ランタイムに含まれている SDK バージョンの詳細については、「[ランタイムに含まれる SDK バージョン](#ruby-sdk-included)」を参照してください。
Lambda は以下の Ruby ランタイムをサポートします。
| 名前 | 識別子 | オペレーティングシステム | 廃止日 | 関数の作成をブロックする | 関数の更新をブロックする |
| --- | --- | --- | --- | --- | --- |
| Ruby 3.4 | `ruby3.4` | Amazon Linux 2023 | 2028 年 3 月 31 日 | 2028 年 4 月 30 日 | 2028 年 5 月 31 日 |
| Ruby 3.3 | `ruby3.3` | Amazon Linux 2023 | 2027 年 3 月 31 日 | 2027 年 4 月 30 日 | 2027 年 5 月 31 日 |
| Ruby 3.2 | `ruby3.2` | Amazon Linux 2 | 2026 年 3 月 31 日 | 2026 年 8 月 31 日 | 2026 年 9 月 30 日 |
**Ruby 関数を作成するには**
1. [Lambda コンソール](https://console.aws.amazon.com/lambda)を開きます。
1. [**Create function**] (関数の作成) をクリックします。
1. 以下の設定を行います。
+ **[関数名]**: 関数名を入力します。
+ **[ランタイム]**: **[Ruby 3.4]** を選択します。
1. [**関数の作成**] を選択してください。
コンソールで、`lambda_function.rb` という名前の単一のソースファイルを含む Lambda 関数が作成されます。このファイルを編集し、組み込みのコードエディタでファイルをさらに追加することができます。**[DEPLOY]** セクションで **[デプロイ]** を選択して関数のコードを更新します。次に、コードを実行するには、**[TEST EVENTS]** セクションで **[テストイベントを作成]** を選択します。
`lambda_function.rb` ファイルは、イベントオブジェクトおよびコンテキストオブジェクトを取得する `lambda_handler` という名前の関数をエクスポートします。これは、関数が呼び出されるときに Lambda が呼び出す[ハンドラー関数](ruby-handler.md)です。Ruby 関数のランタイムは、Lambda から呼び出しイベントを取得し、ハンドラーに渡します。関数設定で、ハンドラ値は `lambda_function.lambda_handler` です。
関数コードを保存すると、Lambda コンソールは .zip ファイルアーカイブのデプロイパッケージを作成します。コンソール外で (SDE を使用して) 関数コードを開発するときは、[デプロイパッケージを作成](ruby-package.md)して、Lambda 関数にコードをアップロードします。
関数のランタイムによって、呼び出しイベントに加えて、コンテキストオブジェクトがハンドラに渡されます。[コンテキストオブジェクト](ruby-context.md)には、呼び出し、関数、および実行環境に関する追加情報が含まれます。詳細情報は、環境変数から入手できます。
Lambda 関数には CloudWatch Logs ロググループが付属しています。関数のランタイムは、各呼び出しに関する詳細を CloudWatch Logs に送信します。これは呼び出し時に、任意の[関数が出力するログ](ruby-logging.md)を中継します。関数がエラーを返す場合、Lambda はエラー形式を整え、それを呼び出し元に返します。
**Topics**
+ [
## ランタイムに含まれる SDK バージョン
](#ruby-sdk-included)
+ [
## もうひとつの Ruby JIT (YJIT) を有効にする
](#ruby-yjit)
+ [
# Ruby の Lambda 関数ハンドラーの定義
](ruby-handler.md)
+ [
# .zip ファイルアーカイブで Ruby Lambda 関数をデプロイする
](ruby-package.md)
+ [
# コンテナイメージで Ruby Lambda 関数をデプロイする
](ruby-image.md)
+ [
# Ruby Lambda 関数のレイヤーを操作する
](ruby-layers.md)
+ [
# Lambda コンテキストオブジェクトを使用して Ruby 関数の情報を取得する
](ruby-context.md)
+ [
# Ruby Lambda 関数のログ記録とモニタリング
](ruby-logging.md)
+ [
# AWS Lambda での Ruby の作成
](ruby-tracing.md)
## ランタイムに含まれる SDK バージョン
Ruby ランタイムに含まれる AWS SDK のバージョンは、ランタイムバージョンと AWS リージョン によって異なります。AWS SDK for Ruby はモジュール式に設計されており、AWS のサービス ごとに分かれています。使用しているランタイムに含まれている特定のサービス gem のバージョン番号を確認するには、次の形式のコードを使用して Lambda 関数を作成します。`aws-sdk-s3` と `Aws::S3` を、コードが使用するサービス gem の名前に置き換えます。
```
require 'aws-sdk-s3'
def lambda_handler(event:, context:)
puts "Service gem version: #{Aws::S3::GEM_VERSION}"
puts "Core version: #{Aws::CORE_GEM_VERSION}"
end
```
## もうひとつの Ruby JIT (YJIT) を有効にする
Ruby ランタイムは、軽量でミニマルな Ruby JIT コンパイラである [YJIT](https://docs.ruby-lang.org/en/master/jit/yjit_md.html) をサポートしています。YJIT はパフォーマンスを大幅に向上しますが、Ruby インタープリタよりも多くのメモリを消費します。Ruby on Rails のワークロードには YJIT が推奨されます。
YJIT は、デフォルトでは有効になっていません。Ruby 関数で YJIT を有効にするには、`RUBY_YJIT_ENABLE` 環境変数を `1` に設定します。YJIT が有効であることを確認するには、`RubyVM::YJIT.enabled?` メソッドの結果を出力します。
**Example — YJIT が有効になっていることの確認**
```
puts(RubyVM::YJIT.enabled?())
# => true
```
# Ruby の Lambda 関数ハンドラーの定義
Lambda 関数*ハンドラー*は、イベントを処理する関数コード内のメソッドです。関数が呼び出されると、Lambda はハンドラーメソッドを実行します。関数は、ハンドラーが応答を返すか、終了するか、タイムアウトするまで実行されます。
**Topics**
+ [
## Ruby ハンドラーの基本
](#ruby-handler-basics)
+ [
## Ruby Lambda 関数のベストプラクティスに従ってください。
](#ruby-best-practices)
## Ruby ハンドラーの基本
次の例では、`function.rb` は、`handler` という名前のハンドラメソッドを定義します。ハンドラ関数は、2 つのオブジェクトを入力として識別し、JSON ドキュメントを返します。
**Example function.rb**
```
require 'json'
def handler(event:, context:)
{ event: JSON.generate(event), context: JSON.generate(context.inspect) }
end
```
関数設定の `handler` 設定は、ハンドラーの場所を Lambda に伝えます。前述の例では、この設定の適切な値は **function.handler** です。ドットで区切られた 2 つの名前 (ファイルの名前とハンドラメソッドの名前) が含まれています。
また、クラス内のハンドラメソッドを定義することもできます。以下の例では、モジュール `LambdaFunctions` のクラス `Handler` の ハンドラメソッド `process` を定義します。
**Example source.rb**
```
module LambdaFunctions
class Handler
def self.process(event:,context:)
"Hello!"
end
end
end
```
この場合、ハンドラ設定は **source.LambdaFunctions::Handler.process** です。
ハンドラは、呼び出しイベントとコンテキストの 2 つのオブジェクトを受け入れます。このイベントは、呼び出し元が提供するペイロードを含む Ruby オブジェクトです。ペイロードが JSON ドキュメントの場合、イベントオブジェクトは Ruby ハッシュです。それ以外の場合は、文字列です。[コンテキストオブジェクト](ruby-context.md)には、呼び出し、関数、および実行関数に関する情報を示すメソッドおよびプロパティがあります。
関数ハンドラーは、Lambda 関数が呼び出されるたびに実行されます。ハンドラの外側の静的コードは、関数のインスタンスごとに 1 回実行されます。ハンドラで SDK クライアントやデータベース接続などのリソースが使用される場合、ハンドラメソッドは、ハンドラメソッドの外で作成して複数の呼び出しに再利用することができます。
関数の各インスタンスで複数の呼び出しイベントを処理することはできますが、処理されるのは一度に 1 つのイベントのみです。任意の時点でイベントを処理するインスタンス数は、関数の*同時実行数*です。Lambda の実行環境の詳細については、[Lambda 実行環境のライフサイクルの概要](lambda-runtime-environment.md) を参照してください。
## Ruby Lambda 関数のベストプラクティスに従ってください。
Lambda 関数をビルドするときは、次のリストのガイドラインに従って、コーディングのベストプラクティスを実行してください。
+ **Lambda ハンドラーをコアロジックから分離します。**これにより、関数の単体テストが実行しやすくなります。例えば、Ruby では次のようになります。
```
def lambda_handler(event:, context:)
foo = event['foo']
bar = event['bar']
result = my_lambda_function(foo:, bar:)
end
def my_lambda_function(foo:, bar:)
// MyLambdaFunction logic here
end
```
+ **関数のデプロイパッケージ内で依存関係を制御します。**AWS Lambda 実行環境には多数のライブラリが含まれています。Ruby ランタイムの場合、これらには AWS SDK が含まれます。最新の機能やセキュリティ更新プログラムを有効にするために、Lambda はこれらのライブラリを定期的に更新します。この更新により、Lambda 関数の動作が微妙に変化する場合があります。関数で使用する依存関係を完全に制御するには、すべての依存関係をデプロイパッケージでパッケージングします。
+ **依存関係の複雑さを最小限に抑えます。**フレームワークを単純化して、[実行環境](lambda-runtime-environment.md)起動時のロードを高速化します。
+ **デプロイパッケージをランタイムに必要な最小限のサイズにします。**これにより、呼び出しに先立ってデプロイパッケージをダウンロードして解凍する所要時間が短縮されます。Ruby で作成した関数の場合は、デプロイパッケージの一環として AWS SDK ライブラリ全体をアップロードしないようにします。代わりに、SDK のコンポーネントを必要に応じて選別する gem (DynamoDB、Amazon S3 SDK gem) を使用します。
**実行環境の再利用を活用して関数のパフォーマンスを向上させます。**関数ハンドラー外で SDK クライアントとデータベース接続を初期化し、静的なアセットを `/tmp` ディレクトリにローカルにキャッシュします。関数の同じインスタンスで処理された後続の呼び出しは、これらのリソースを再利用できます。これにより、関数の実行時間が短縮され、コストが節約されます。
呼び出し間でデータが漏れるのを防ぐため、実行環境を使用してセキュリティ上の懸念があるユーザーデータ、イベント、またはその他の情報を保存しないでください。関数がハンドラー内のメモリに保存できない変更可能な状態に依存している場合は、ユーザーごとに個別の関数または個別のバージョンの関数を作成することを検討してください。
**keep-alive ディレクティブを使用して永続的な接続を維持します。**Lambda は、時間の経過とともにアイドル状態の接続を消去します。関数を呼び出すときにアイドル状態の接続を再利用しようとすると、接続エラーが発生します。永続的な接続を維持するには、ランタイムに関連付けられている keep-alive ディレクティブを使用します。例については、「[Node.js で Keep-alive を使用して接続を再利用する](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html)」を参照してください。
**[環境変数](configuration-envvars.md)を使用して、オペレーショナルパラメータを関数に渡します。**たとえば、Amazon S3 バケットに書き込む場合、書き込み先のバケット名はハードコーディングせずに、環境変数として設定します。
Lambda 関数では、**再帰呼び出しを使用しないでください**。関数が自身を呼び出すこともあれば、新たに開始されたプロセスで関数が再度呼び出される可能性もあります。これを行うと意図しないボリュームで関数が呼び出され、料金が急増する可能性があります。意図しない呼び出しがいくつも見つかった場合は、すぐに関数の予約済同時実行数を `0` に設定して、コードを更新している間のすべての関数の呼び出しをスロットリングします。
Lambda 関数コードで**文書化されていない非公開の API を使用しないでください**。AWS Lambda マネージドランタイムでは、Lambda が Lambda の内部 API にセキュリティと機能面の更新を定期的に適用します。これらの内部 API 更新には後方互換性がないことがあり、関数にこれらの非公開 API に対する依存関係がある場合、呼び出しの失敗などの意図しない結果につながります。公開されている API のリストについては、「[API リファレンス](https://docs.aws.amazon.com/lambda/latest/api/welcome.html)」を参照してください。
**冪等性コードを記述します。**関数の記述に冪等性コードを使用すると、重複するイベントが同じ方法で処理されるようになります。コードでは、イベントを適切に検証し、重複するイベントを適切に処理する必要があります。詳細については、「[Lambda 関数を冪等にするにはどうすればよいですか?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/)」を参照してください。
# .zip ファイルアーカイブで Ruby Lambda 関数をデプロイする
AWS Lambda 関数のコードは、関数のハンドラーコードを含む .rb ファイルと、そのコードが依存する追加の依存関係 (gem) で構成されています。この関数コードを Lambda にデプロイするには、*デプロイパッケージ*を使用します。このパッケージは、.zip ファイルアーカイブでもコンテナイメージでもかまいません。Ruby でコンテナイメージを使用する方法の詳細については、「[コンテナイメージで Ruby Lambda 関数をデプロイする](https://docs.aws.amazon.com/lambda/latest/dg/ruby-image.html)」を参照してください。
.zip ファイルのデプロイパッケージを .zip ファイルアーカイブとして作成するには、コマンドラインツール用の組み込み .zip ファイルアーカイブユーティリティ、または他の .zip ファイルユーティリティ ([7zip](https://www.7-zip.org/download.html) など) を使用します。次のセクションに示す例では、Linux または macOS 環境でコマンドライン `zip` ツールを使用していることを前提としています。Windows で同じコマンドを使用するには、[Windows Subsystem for Linux をインストールして](https://docs.microsoft.com/en-us/windows/wsl/install-win10)、Windows 統合バージョンの Ubuntu と Bash を取得します
Lambda は POSIX ファイルアクセス許可を使用するため、.zip ファイルアーカイブを作成する前に、[デプロイパッケージフォルダのアクセス許可を設定する](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/)ことが必要になる場合があります。
以下のセクションのコマンド例では、[バンドラー](https://bundler.io/)ユーティリティを使用してデプロイパッケージに依存関係を追加します。バンドラーをインストールするには、以下のコマンドを実行します。
```
gem install bundler
```
**Topics**
+ [
## Ruby の依存関係
](#ruby-package-runtime-dependencies)
+ [
## 依存関係のない .zip デプロイパッケージを作成する
](#ruby-package-codeonly)
+ [
## 依存関係を含めて .zip デプロイパッケージを作成する
](#ruby-package-dependencies)
+ [
## 依存関係の Ruby レイヤーを作成する
](#ruby-package-dependencies-layers)
+ [
## ネイティブライブラリとともに .zip デプロイパッケージを作成する
](#ruby-package-native)
+ [
## .zip ファイルを使用した Ruby Lambda 関数の作成と更新
](#ruby-package-create-functions)
## Ruby の依存関係
Ruby ランタイムを使用する Lambda 関数の場合、依存関係には任意の Ruby gem を使用できます。.zip アーカイブを使用して関数をデプロイするとき、関数コードでこれらの依存関係を .zip ファイルに追加するか、Lambda レイヤー を使用できます。レイヤーは、追加のコードまたはその他のコンテンツを含むことができる個別の .zip ファイルです。Lambda レイヤーの使用の詳細については、「[レイヤーによる Lambda 依存関係の管理](chapter-layers.md)」を参照してください。
Ruby ランタイムには AWS SDK for Ruby が含まれます。関数で SDK を使用する場合は、それをコードにバンドルする必要はありません。ただし、依存関係を完全に制御したり、特定のバージョンの SDK を使用したりするには、関数のデプロイパッケージに追加することができます。SDK は .zip ファイルに含めるか、Lambda レイヤーを使用して追加することができます。.zip ファイルまたは Lambda レイヤー内の依存関係は、ランタイムに含まれるバージョンよりも優先されます。ご使用のランタイムバージョンに含まれている SDK for Ruby のバージョンを確認するには、「[ランタイムに含まれる SDK バージョン](lambda-ruby.md#ruby-sdk-included)」を参照してください。
[AWS 責任分担モデル](lambda-runtimes.md#runtimes-shared-responsibility)では、関数のデプロイパッケージに含まれる依存関係を管理する責任があります。これには、更新とセキュリティパッチの適用が含まれます。関数のデプロイパッケージ内の依存関係を更新するには、まず新しい .zip ファイルを作成し、そのファイルを Lambda にアップロードします。詳細については、「[依存関係を含めて .zip デプロイパッケージを作成する](#ruby-package-dependencies)」と「[.zip ファイルを使用した Ruby Lambda 関数の作成と更新](#ruby-package-create-functions)」を参照してください。
## 依存関係のない .zip デプロイパッケージを作成する
関数コードに依存関係がない場合、.zip ファイルには関数のハンドラーコードを含む .rb ファイルのみが含まれます。任意の zip ユーティリティを使用して、.rb ファイルをルートとする .zip ファイルを作成します。.rb ファイルが .zip ファイルのルートにない場合、Lambda はコードを実行できません。
.zip ファイルをデプロイして新しい Lambda 関数を作成する方法の詳細、既存の Lambda 関数を更新する方法の詳細については、「[.zip ファイルを使用した Ruby Lambda 関数の作成と更新](#ruby-package-create-functions)」を参照してください。
## 依存関係を含めて .zip デプロイパッケージを作成する
関数コードが追加の Ruby gem に依存している場合、これらの依存関係を関数コードとともに .zip ファイルに追加するか、[Lambda レイヤー](chapter-layers.md)を使用できます。このセクションでは、依存関係を .zip デプロイパッケージに含める方法について説明します。依存関係をレイヤーに含める方法については、「[依存関係の Ruby レイヤーを作成する](#ruby-package-dependencies-layers)」を参照してください。
関数コードがプロジェクトディレクトリの `lambda_function.rb` という名前のファイルに保存されているとします。次の CLI コマンドの例では、関数コードとその依存関係を格納している `my_deployment_package.zip` という名前の .zip ファイルを作成します。
**デプロイパッケージを作成するには**
1. プロジェクトディレクトリに、依存関係を指定する `Gemfile` を作成します。
```
bundle init
```
1. 任意のテキストエディタを使用して、`Gemfile` を編集して関数の依存関係を指定します。例えば、TZInfo gem を使用するには、`Gemfile` を次のように編集します。
```
source "https://rubygems.org"
gem "tzinfo"
```
1. 次のコマンドを実行して、`Gemfile` で指定した gem をプロジェクトディレクトリにインストールします。このコマンドでは `vendor/bundle` を gem インストールのデフォルトパスとして設定します。
```
bundle config set --local path 'vendor/bundle' && bundle install
```
次のような出力が表示されます。
```
Fetching gem metadata from https://rubygems.org/...........
Resolving dependencies...
Using bundler 2.4.13
Fetching tzinfo 2.0.6
Installing tzinfo 2.0.6
...
```
**注記**
後で gem をグローバルにインストールし直すには、次のコマンドを実行します。
```
bundle config set --local system 'true'
```
1. 関数のハンドラーコードを含む `lambda_function.rb` ファイルと、前のステップでインストールした依存関係を格納した .zip ファイルアーカイブを作成します。
```
zip -r my_deployment_package.zip lambda_function.rb vendor
```
次のような出力が表示されます。
```
adding: lambda_function.rb (deflated 37%)
adding: vendor/ (stored 0%)
adding: vendor/bundle/ (stored 0%)
adding: vendor/bundle/ruby/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/build_info/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/cache/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/cache/aws-eventstream-1.0.1.gem (deflated 36%)
...
```
## 依存関係の Ruby レイヤーを作成する
Ruby の依存関係を Lambda レイヤーにパッケージ化する方法については、「[Ruby Lambda 関数のレイヤーを操作する](ruby-layers.md)」を参照してください。
## ネイティブライブラリとともに .zip デプロイパッケージを作成する
`nokogiri`、`nio4r`、`mysql` などの多くの一般的な Ruby gem には、C で書かれたネイティブの拡張機能が含まれています。C コードを含むライブラリをデプロイパッケージに追加するときは、パッケージを正しく構築し、Lambda 実行環境と互換性があることを確認する必要があります。
本番環境のアプリケーションでは、AWS Serverless Application Model (AWS SAM) を使用してコードをビルドしてデプロイすることをお勧めします。AWS SAM では、Lambda のような Docker コンテナ内部に関数を構築するのに、`sam build --use-container` オプションを使用します。AWS SAM を使用して関数コードをデプロイする方法の詳細については、「AWS SAM デベロッパーガイド」の「[アプリケーションの構築](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-using-build.html)」を参照してください。
AWS SAM を使用せずに gem を含む .zip デプロイパッケージをネイティブ拡張で作成するには、代わりにコンテナを使用して Lambda Ruby ランタイム環境と同じ環境に依存関係をバンドルすることもできます。これらの手順を完了するには、ビルドマシンに Docker がインストールされている必要があります。Docker のインストールの詳細については、「[Docker Engine のインストール](https://docs.docker.com/engine/install/)」を参照してください。
**Docker コンテナに.zip デプロイパッケージを作成するには**
1. コンテナを保存するフォルダをローカルビルドマシンに作成します。そのフォルダ内に、`dockerfile` という名前のファイルを作成し、次のコードを貼り付けます。
```
FROM public.ecr.aws/sam/build-ruby3.2:latest-x86_64
RUN gem update bundler
CMD "/bin/bash"
```
1. `dockerfile` を作成したフォルダ内で、次のコマンドを実行して Docker コンテナを作成します。
```
docker build -t awsruby32 .
```
1. 関数のハンドラーコードが記載された `.rb` ファイルと関数の依存関係を指定した `Gemfile` を含むプロジェクトディレクトリに移動します。そのディレクトリ内から、次のコマンドを実行して Lambda Ruby コンテナを起動します。
------
#### [ Linux/MacOS ]
```
docker run --rm -it -v $PWD:/var/task -w /var/task awsruby32
```
**注記**
MacOS では、リクエストされたイメージのプラットフォームが検出されたホストプラットフォームと一致しないという警告が表示されることがあります。この警告は無視してください。
------
#### [ Windows PowerShell ]
```
docker run --rm -it -v ${pwd}:var/task -w /var/task awsruby32
```
------
コンテナが起動すると、bash プロンプトが表示されます。
```
bash-4.2#
```
1. バンドルユーティリティを設定して、`Gemfile` で指定した gem をローカルの `vendor/bundle` ディレクトリにインストールし、依存関係をインストールします。
```
bash-4.2# bundle config set --local path 'vendor/bundle' && bundle install
```
1. 関数コードとその依存関係を含む .zip デプロイパッケージを作成します。この例では、関数のハンドラーコードを含むファイルには `lambda_function.rb` という名前が付けられています。
```
bash-4.2# zip -r my_deployment_package.zip lambda_function.rb vendor
```
1. コンテナを終了し、ローカルプロジェクトディレクトリに戻ります。
```
bash-4.2# exit
```
これで、.zip ファイルデプロイパッケージを使用して Lambda 関数を作成または更新できます。「[.zip ファイルを使用した Ruby Lambda 関数の作成と更新](#ruby-package-create-functions)」を参照してください。
## .zip ファイルを使用した Ruby Lambda 関数の作成と更新
.zip デプロイパッケージを作成したら、このパッケージを使用して新しい Lambda 関数を作成するか、既存の関数を更新できます。.zip パッケージをデプロイするには、Lambda コンソール、AWS Command Line Interface、Lambda API を使用します。AWS Serverless Application Model (AWS SAM) および CloudFormation を使用して、Lambda 関数を作成および更新することもできます。
Lambda の .zip デプロイパッケージの最大サイズは 250 MB (解凍) です。この制限は、Lambda レイヤーを含む、更新するすべてのファイルの合計サイズに適用されることに注意してください。
Lambda ランタイムには、デプロイパッケージ内のファイルを読み取るアクセス許可が必要です。Linux のアクセス権限の 8 進表記では、Lambda には非実行ファイル用に 644 のアクセス権限 (rw-r--r--) が必要であり、ディレクトリと実行可能ファイル用に 755 のアクセス権限 (rwxr-xr-x) が必要です。
Linux と MacOS で、デプロイパッケージ内のファイルやディレクトリのファイルアクセス権限を変更するには、`chmod` コマンドを使用します。例えば、実行可能でないファイルに正しいアクセス許可を付与するには、次のコマンドを実行します。
```
chmod 644
```
Windows でファイルアクセス許可を変更するには、「Microsoft Windows ドキュメント」の「[Set, View, Change, or Remove Permissions on an Object](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10))」を参照してください。
**注記**
デプロイパッケージのディレクトリにアクセスするために必要なアクセス許可を Lambda に付与しない場合、Lambda はそれらのディレクトリのアクセス許可を 755 (rwxr-xr-x) に設定します。
### コンソールを使用して .zip ファイルの関数を作成、更新する
新しい関数を作成するには、まずコンソールで関数を作成し、次に .zip アーカイブをアップロードする必要があります。既存の関数を更新するには、その関数のページを開き、同じ手順に従って更新した .zip ファイルを追加します。
.zip ファイルが 50 MB 未満の場合は、ローカルマシンから直接ファイルをアップロードして関数を作成または更新できます。50 MB を超える .zip ファイルの場合は、まず Amazon S3 バケットにパッケージをアップロードする必要があります。AWS マネジメントコンソール を使用して Amazon S3 バケットにファイルをアップロードする手順については、「[Amazon S3 の開始方法](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html)」を参照してください。AWS CLI を使用してファイルをアップロードするには、「AWS CLI ユーザーガイド」の「[オブジェクトの移動](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move)」を参照してください。
**注記**
既存の関数の[デプロイパッケージタイプ](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip またはコンテナイメージ) を変更することはできません。例えば、既存のコンテナイメージ関数を、.zip ファイルアーカイブを使用するように変換することはできません。この場合は、新しい関数を作成する必要があります。
**新しい関数を作成するには (コンソール)**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開き、**[関数の作成]** を選択します。
1. **[一から作成]** を選択します。
1. **[基本的な情報]** で、以下を行います。
1. **[関数名]** に、関数名を入力します。
1. **[ランタイム]** で、使用するランタイムを選択します。
1. (オプション) **[アーキテクチャ]**で、関数の命令セットアーキテクチャを選択します。デフォルトのアーキテクチャは x86\$164 です。関数用の .zip デプロイパッケージと選択した命令セットのアーキテクチャに互換性があることを確認してください。
1. (オプション) **[アクセス権限]** で、**[デフォルトの実行ロールの変更]** を展開します。新しい **[実行ロール]** を作成することも、既存のロールを使用することもできます。
1. **[関数の作成]**を選択します。Lambda は、選択したランタイムを使用して基本的な「Hello world」関数を作成します。
**ローカルマシンから zip アーカイブをアップロードするには (コンソール)**
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) で、.zip ファイルをアップロードする関数を選択します。
1. **[コード]** タブを選択します。
1. **[コードソース]** ペインで、**[アップロード元]** をクリックします。
1. **[.zip ファイル]** をクリックします。
1. .zip ファイルをアップロードするには、次の操作を行います。
1. **[アップロード]** をクリックし、ファイルセレクターで .zip ファイルを選択します。
1. **[開く]** をクリックします。
1. **[保存]** をクリックします。
**Amazon S3 バケットから .zip アーカイブをアップロードするには (コンソール)**
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) で、新しい .zip ファイルをアップロードする関数を選択します。
1. **[コード]** タブを選択します。
1. **[コードソース]** ペインで、**[アップロード元]** をクリックします。
1. **[Amazon S3 ロケーション]** を選択します。
1. .zip ファイルの Amazon S3 リンク URL を貼り付けて、**[保存]** を選択します。
### コンソールコードエディタを使用して .zip ファイル関数を更新する
.zip デプロイパッケージを使用する一部の関数では、Lambda コンソールの組み込みコードエディタを使用して、関数コードを直接更新できます。この機能を使用するには、関数が次の基準を満たしている必要があります。
+ 関数が、インタープリター言語ランタイムのいずれか (Python、Node.js、Ruby) を使用する必要があります。
+ 関数のデプロイパッケージが 50 MB (解凍時)未満である必要があります。
コンテナイメージデプロイパッケージを含む関数の関数コードは、コンソールで直接編集することはできません。
**コンソールのコードエディタを使用して関数コードを更新するには**
1. Lambda コンソールの「[関数ページ](https://console.aws.amazon.com/lambda/home#/functions)」を開き、関数を選択します。
1. **[コード]** タブを選択します。
1. **[コードソース]** ペインでソースコードファイルを選択し、統合コードエディタで編集します。
1. **[DEPLOY]** セクションで、**[デプロイ]** を選択して関数のコードを更新します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
### AWS CLI を使用して .zip ファイルで関数を作成、更新する
[AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) を使用して新しい関数を作成したり、.zip ファイルを使用して既存の関数を更新したりできます。[create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) コマンドと [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) を使用して、.zip パッケージをデプロイします。.zip ファイルが 50 MB 未満の場合は、ローカルビルドマシン上のファイルの場所から .zip パッケージをアップロードできます。サイズの大きいファイルの場合は、Amazon S3 バケットから .zip パッケージをアップロードする必要があります。AWS CLI を使用して Amazon S3 バケットにファイルをアップロードする方法については、「AWS CLI ユーザーガイド」の「[オブジェクトの移動](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move)」を参照してください。
**注記**
AWS CLI を使用して Amazon S3 バケットから .zip ファイルをアップロードする場合、このバケットは関数と同じ AWS リージョン に配置する必要があります。
AWS CLI を含む .zip ファイルを使用して新しい関数を作成するには、以下を指定する必要があります。
+ 関数の名前 (`--function-name`)
+ 関数のランタイム (`--runtime`)
+ 関数の[実行ロール](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) (`--role`) の Amazon リソースネーム (ARN)
+ 関数コード内のハンドラーメソッド (`--handler`) の名前
.zip ファイルの場所も指定する必要があります。.zip ファイルがローカルビルドマシン上のフォルダにある場合は、次のコマンド例に示すように、`--zip-file` オプションを使用してファイルパスを指定します。
```
aws lambda create-function --function-name myFunction \
--runtime ruby3.2 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```
Amazon S3 バケット内の .zip ファイルの場所を指定するには、以下のコマンド例にある `--code` オプションを使用します。`S3ObjectVersion` パラメータは、バージョン管理下のオブジェクトにのみ使用する必要があります。
```
aws lambda create-function --function-name myFunction \
--runtime ruby3.2 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```
CLI を使用して既存の関数を更新するには、`--function-name` パラメータを使用して関数の名前を指定します。関数コードの更新に使用する .zip ファイルの場所も指定する必要があります。.zip ファイルがローカルビルドマシン上のフォルダにある場合は、次のコマンド例に示すように、`--zip-file` オプションを使用してファイルパスを指定します。
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Amazon S3 バケット内の .zip ファイルの場所を指定するには、以下のコマンド例にある `--s3-bucket` および `--s3-key` オプションを使用します。`--s3-object-version` パラメータは、バージョン管理下のオブジェクトにのみ使用する必要があります。
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Lambda API を使用して .zip ファイルで関数を作成、更新する
.zip ファイルアーカイブを使用して関数を作成および更新するには、以下の API オペレーションを使用します。
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
### AWS SAM を使用して .zip ファイルで関数を作成、更新する
AWS Serverless Application Model (AWS SAM) は、AWS のサーバーレスアプリケーションの構築と実行のプロセスを合理化するのに役立つツールキットです。YAML または JSON テンプレートでアプリケーションのリソースを定義し、AWS SAM コマンドラインインターフェイス (AWS SAM CLI) を使用して、アプリケーションを構築、パッケージ化、デプロイします。AWS SAM テンプレートから Lambda 関数を構築すると、AWS SAM は関数コードと指定した任意の依存関係を含む .zip デプロイパッケージまたはコンテナイメージを自動的に作成します。AWS SAM を使用して Lambda 関数を構築およびデプロイする方法の詳細については、「AWS Serverless Application Model 開発者ガイドの」の「[AWS SAM の開始方法](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html)」を参照してください。
AWS SAM を使用して、既存の .zip ファイルアーカイブを使用する Lambda 関数を作成できます。AWS SAM を使用して Lambda 関数を作成するには、.zip ファイルを Amazon S3 バケットまたはビルドマシンのローカルフォルダに保存します。AWS CLI を使用して Amazon S3 バケットにファイルをアップロードする方法については、「AWS CLI ユーザーガイド」の「[オブジェクトの移動](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move)」を参照してください。
AWS SAM テンプレートでは、Lambda 関数は `AWS::Serverless::Function` のリソースにより指定されます。このリソースで次のプロパティを設定し、.zip ファイルアーカイブを使用して関数を作成します。
+ `PackageType` - `Zip` に設定
+ `CodeUri` - 関数コードの Amazon S3 URI、ローカルフォルダへのパス、または [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html) オブジェクトに設定
+ `Runtime` - 選択したランタイムに設定
AWS SAM では、.zip ファイルが 50 MB を超える場合、この .zip ファイルを最初に Amazon S3 バケットにアップロードする必要はありません。AWS SAM では、ローカルビルドマシン上の場所から、最大許容サイズ 250 MB (解凍) の .zip パッケージをアップロードできます。
AWS SAM で .zip ファイルを使用して関数をデプロイする方法の詳細については、「AWS SAM 開発者ガイド」の「[AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)」を参照してください。
### CloudFormation を使用して .zip ファイルで関数を作成、更新する
CloudFormation を使用して、.zip ファイルアーカイブを使用する Lambda 関数を作成できます。.zip ファイルから Lambda 関数を作成するには、最初にファイルを Amazon S3 バケットにアップロードする必要があります。AWS CLI を使用して Amazon S3 バケットにファイルをアップロードする方法については、「AWS CLI ユーザーガイド」の「[オブジェクトの移動](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move)」を参照してください。
CloudFormation テンプレートでは、Lambda 関数は `AWS::Lambda::Function` のリソースにより指定されます。このリソースで次のプロパティを設定し、.zip ファイルアーカイブを使用して関数を作成します。
+ `PackageType` - `Zip` に設定
+ `Code` - `S3Bucket` および `S3Key` フィールドに Amazon S3 バケット名と .zip ファイル名を入力
+ `Runtime` - 選択したランタイムに設定
CloudFormation が生成する .zip ファイルは、4 MB を超えることはできません。CloudFormation で .zip ファイルを使用して関数をデプロイする方法の詳細については、「CloudFormation ユーザーガイド」の「[AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)」を参照してください。
# コンテナイメージで Ruby Lambda 関数をデプロイする
Ruby Lambda 関数のコンテナイメージを構築するには 3 つの方法があります。
+ [Ruby の AWS ベースイメージを使用する](#ruby-image-instructions)
[AWS ベースイメージ](images-create.md#runtimes-images-lp)には、言語ランタイム、Lambda と関数コード間のやり取りを管理するランタイムインターフェースクライアント、ローカルテスト用のランタイムインターフェースエミュレーターがあらかじめロードされています。
+ [AWS の OS 専用ベースイメージを使用する](images-create.md#runtimes-images-provided)
[AWS OS 専用ベースイメージ](https://gallery.ecr.aws/lambda/provided)には、Amazon Linux ディストリビューションおよび[ランタイムインターフェイスエミュレータ](https://github.com/aws/aws-lambda-runtime-interface-emulator/)が含まれています。これらのイメージは、[Go](go-image.md#go-image-provided) や [Rust](lambda-rust.md) などのコンパイル済み言語や、Lambda がベースイメージを提供していない言語または言語バージョン (Node.js 19 など) のコンテナイメージの作成によく使用されます。OS 専用のベースイメージを使用して[カスタムランタイム](runtimes-custom.md)を実装することもできます。イメージに Lambda との互換性を持たせるには、[Ruby のランタイムインターフェイスクライアント](#ruby-image-clients)をイメージに含める必要があります。
+ [非 AWS ベースイメージを使用する](#ruby-image-clients)
Alpine Linux や Debian など、別のコンテナレジストリの代替ベースイメージを使用することができます。組織が作成したカスタムイメージを使用することもできます。イメージに Lambda との互換性を持たせるには、[Ruby のランタイムインターフェイスクライアント](#ruby-image-clients)をイメージに含める必要があります。
**ヒント**
Lambda コンテナ関数がアクティブになるまでの時間を短縮するには、「Docker ドキュメント」の「[マルチステージビルドを使用する](https://docs.docker.com/build/building/multi-stage/)」を参照してください。効率的なコンテナイメージを構築するには、「[Dockerfiles を記述するためのベストプラクティス](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/)」に従ってください。
このページでは、Lambda のコンテナイメージを構築、テスト、デプロイする方法について説明します。
**Topics**
+ [
## Ruby の AWS ベースイメージ
](#ruby-image-base)
+ [
## Ruby の AWS ベースイメージを使用する
](#ruby-image-instructions)
+ [
## ランタイムインターフェイスクライアントで代替ベースイメージを使用する
](#ruby-image-clients)
## Ruby の AWS ベースイメージ
AWS は、Ruby の次のベースイメージを提供します。
| タグ | ランタイム | オペレーティングシステム | Dockerfile | 非推奨 |
| --- | --- | --- | --- | --- |
| 3.4 | Ruby 3.4 | Amazon Linux 2023 | [GitHub の Ruby 3.4 用 Dockerfile](https://github.com/aws/aws-lambda-base-images/blob/ruby3.4/Dockerfile.ruby3.4) | 2028 年 3 月 31 日 |
| 3.3 | Ruby 3.3 | Amazon Linux 2023 | [GitHub の Ruby 3.3 用 Dockerfile](https://github.com/aws/aws-lambda-base-images/blob/ruby3.3/Dockerfile.ruby3.3) | 2027 年 3 月 31 日 |
| 3.2 | Ruby 3.2 | Amazon Linux 2 | [GitHub の Ruby 3.2 用 Dockerfile](https://github.com/aws/aws-lambda-base-images/blob/ruby3.2/Dockerfile.ruby3.2) | 2026 年 3 月 31 日 |
Amazon ECR リポジトリ: [gallery.ecr.aws/lambda/ruby](https://gallery.ecr.aws/lambda/ruby)
## Ruby の AWS ベースイメージを使用する
### 前提条件
このセクションの手順を完了するには、以下が必要です。
+ [AWS CLI バージョン 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (最小バージョン 25.0.0)
+ Docker [buildx プラグイン](https://github.com/docker/buildx/blob/master/README.md)。
+ Ruby
### ベースイメージからイメージを作成する
**Ruby のコンテナイメージを作成するには**
1. プロジェクト用のディレクトリを作成し、そのディレクトリに切り替えます。
```
mkdir example
cd example
```
1. `Gemfile` という名前の新しいファイルを作成します。ここでは、アプリケーションに必要な RubyGems パッケージを一覧表示します。AWS SDK for Ruby は RubyGems から入手できます。インストールする特定の AWS サービス gem を選択する必要があります。例えば、[Lambda 用 Ruby gem](https://rubygems.org/gems/aws-sdk-lambda/) を使用するには、Gemfile は次のようになるはずです。
```
source 'https://rubygems.org'
gem 'aws-sdk-lambda'
```
あるいは、[aws-sdk](https://rubygems.org/gems/aws-sdk/) gem には利用可能なすべての AWS サービス gem が含まれています。この gem はとても大きいことが特徴です。多くの AWS サービスを利用している場合にのみ使用することを推奨します。
1. [バンドルインストール](https://bundler.io/v2.4/man/bundle-install.1.html)を使用して、Gemfile で指定された依存関係をインストールします。
```
bundle install
```
1. `lambda_function.rb` という名前の新しいファイルを作成します。テスト用に次のサンプル関数コードをファイルに追加することも、独自のコードを使用することもできます。
**Example Ruby 関数**
```
module LambdaFunction
class Handler
def self.process(event:,context:)
"Hello from Lambda!"
end
end
end
```
1. 新しい Dockerfile を作成します。次に、[AWS ベースイメージ ](images-create.md#runtimes-images-lp)を使用した Dockerfile の例を示します。この Dockerfile では次の設定を使用します。
+ ベースイメージの URI に `FROM` プロパティを設定します。
+ COPY コマンドを使用し、関数コードおよびランタイムの依存関係を `{LAMBDA_TASK_ROOT}` ([Lambda 定義の環境変数](configuration-envvars.md#configuration-envvars-runtime)) にコピーします。
+ `CMD` 引数を Lambda 関数ハンドラーに設定します。
この例の Dockerfile には [USER 命令](https://docs.docker.com/reference/dockerfile/#user)が含まれていないことに注意してください。コンテナイメージを Lambda にデプロイすると、最小特権のアクセス許可を付与したデフォルトの Linux ユーザーを Lambda が自動的に定義します。これは標準の Docker 動作とは異なります。標準の動作とは、`USER` 命令を指定しなかったときに `root` ユーザーのデフォルトとなる動作のことです。
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/ruby:3.4
# Copy Gemfile and Gemfile.lock
COPY Gemfile Gemfile.lock ${LAMBDA_TASK_ROOT}/
# Install Bundler and the specified gems
RUN gem install bundler:2.4.20 && \
bundle config set --local path 'vendor/bundle' && \
bundle install
# Copy function code
COPY lambda_function.rb ${LAMBDA_TASK_ROOT}/
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.LambdaFunction::Handler.process" ]
```
1. Docker イメージを「[Docker の構築](https://docs.docker.com/engine/reference/commandline/build/)」コマンドで構築します。次の例では、イメージを `docker-image` と名付けて `test` [タグ](https://docs.docker.com/engine/reference/commandline/build/#tag)を付けます。Lambda互換のイメージを作成するには、 `--provenance=false` オプションを使用する必要があります。
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**注記**
このコマンドは、ビルドマシンのアーキテクチャに関係なく、コンテナが Lambda の実行環境と互換性があることを確認する `--platform linux/amd64` オプションを特定します。ARM64 命令セットアーキテクチャを使用して Lambda 関数を作成する場合は、代わりに `--platform linux/arm64` オプションを使用するようにコマンドを変更してください。
### (オプション) イメージをローカルでテストする
1. **docker run** コマンドを使用して、Docker イメージを起動します。この例では、`docker-image` はイメージ名、`test` はタグです。
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
このコマンドはイメージをコンテナとして実行し、`localhost:9000/2015-03-31/functions/function/invocations` でローカルエンドポイントを作成します。
**注記**
ARM64 命令セットアーキテクチャ用に Docker イメージをビルドした場合は、`--platform linux/amd64` の代わりに `--platform linux/arm64` オプションを使用してください。
1. 新しいターミナルウィンドウから、イベントをローカルエンドポイントにポストします。
------
#### [ Linux/macOS ]
Linux および macOS では、次の `curl` コマンドを実行します。
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
このコマンドは、空のイベントで関数を呼び出し、応答を返します。サンプル関数コードではなく独自の関数コードを使用している場合は、JSON ペイロードを使用して関数を呼び出すことをお勧めします。例:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
PowerShell で次の `Invoke-WebRequest` コマンドを実行します。
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
このコマンドは、空のイベントで関数を呼び出し、応答を返します。サンプル関数コードではなく独自の関数コードを使用している場合は、JSON ペイロードを使用して関数を呼び出すことをお勧めします。例:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. コンテナ ID を取得します。
```
docker ps
```
1. 「[docker kill](https://docs.docker.com/engine/reference/commandline/kill/)」コマンドを使用してコンテナを停止します。このコマンドでは、`3766c4ab331c` を前のステップのコンテナ ID で置き換えます。
```
docker kill 3766c4ab331c
```
### イメージのデプロイ
**Amazon ECR にイメージをアップロードして Lambda 関数を作成するには**
1. 「[get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)」コマンドを実行して Amazon ECR レジストリに Docker CLI を認証します。
+ `--region` 値を Amazon ECR リポジトリを作成する AWS リージョン に設定します。
+ `111122223333` を AWS アカウント ID に置き換えます。
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. 「[create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html)」コマンドを使用して Amazon ECR にリポジトリを作成します。
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**注記**
Amazon ECR リポジトリは Lambda 関数と同じ AWS リージョン に配置されている必要があります。
成功すると、次のようなレスポンスが表示されます。
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. 前のステップの出力から `repositoryUri` をコピーします。
1. 「[docker tag](https://docs.docker.com/engine/reference/commandline/tag/)」コマンドを実行して、最新バージョンとしてローカルイメージを Amazon ECR リポジトリにタグ付けします。このコマンドで:
+ `docker-image:test` は、Docker イメージの名前と[タグ](https://docs.docker.com/engine/reference/commandline/build/#tag)です。これは、`docker build` コマンドに指定したイメージの名前とタグです。
+ `` を、コピーした `repositoryUri` に置き換えます。URI の末尾には必ず `:latest` を含めてください。
```
docker tag docker-image:test :latest
```
例:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. 「[docker push](https://docs.docker.com/engine/reference/commandline/push/)」コマンドを実行して Amazon ECR リポジトリにローカルイメージをデプロイします リポジトリ URI の末尾には必ず `:latest` を含めてください。
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. まだ作成済みでない場合、関数に「[実行ロールの作成](lambda-intro-execution-role.md#permissions-executionrole-api)」を実行してください。次のステップではロールの Amazon リソースネーム (ARN) が必要です。
1. Lambda 関数を作成します。`ImageUri` には、先ほど使用したリポジトリ URI を指定します。URI の末尾には必ず `:latest` を含めてください。
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**注記**
イメージが Lambda 関数と同じリージョンに配置されていれば、別の AWS アカウントのイメージを使用して関数を作成することができます。詳細については、「[Amazon ECR クロスアカウント許可](images-create.md#configuration-images-xaccount-permissions)」を参照してください。
1. 関数を呼び出します。
```
aws lambda invoke --function-name hello-world response.json
```
次のような結果が表示されます。
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. 関数の出力を確認するには、`response.json` ファイルをチェックします。
関数コードを更新するには、イメージを再構築し、新しいイメージを Amazon ECR リポジトリにアップロードしてから、[update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) コマンドを使用してイメージを Lambda 関数にデプロイする必要があります。
Lambda は、イメージタグを特定のイメージダイジェストに解決します。これは、関数のデプロイに使用されたイメージタグを Amazon ECR 内の新しいイメージを指すように変更しても、Lambda は新しいイメージを使用するように自動的に関数を更新しないことを意味します。
新しいイメージを同じ Lambda 関数にデプロイするには、Amazon ECR のイメージタグが同じままであっても、[update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) コマンドを使用する必要があります。次の例では、`--publish` オプションが最新のコンテナイメージを使用して関数の新しいバージョンを作成しています。
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## ランタイムインターフェイスクライアントで代替ベースイメージを使用する
[OS 専用ベースイメージ](images-create.md#runtimes-images-provided)または代替のベースイメージを使用する場合、イメージにランタイムインターフェイスクライアントを含める必要があります。ランタイムインターフェイスクライアントは、Lambda と関数コード間の相互作用を管理する [ランタイム API](runtimes-api.md) を拡張します。
RubyGems.org パッケージマネージャーを使用して、[Ruby 用の Lambda ランタイムインターフェイスクライアント](https://rubygems.org/gems/aws_lambda_ric)をインストールします。
```
gem install aws_lambda_ric
```
[Ruby ランタイムインターフェイスクライアント](https://github.com/aws/aws-lambda-ruby-runtime-interface-client)を GitHub からダウンロードすることもできます。
次の例は、非 AWS ベースイメージを使用して Ruby 用のコンテナイメージを構築する方法を示しています。サンプルの Dockerfile は公式の Ruby ベースイメージを使用しています。Dockerfile には、ランタイムインターフェイスクライアントが含まれています。
### 前提条件
このセクションの手順を完了するには、以下が必要です。
+ [AWS CLI バージョン 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (最小バージョン 25.0.0)
+ Docker [buildx プラグイン](https://github.com/docker/buildx/blob/master/README.md)。
+ Ruby
### 代替ベースイメージからイメージを作成する
**代替のベースイメージを使用して Ruby 用のコンテナイメージを作成するには**
1. プロジェクト用のディレクトリを作成し、そのディレクトリに切り替えます。
```
mkdir example
cd example
```
1. `Gemfile` という名前の新しいファイルを作成します。ここでは、アプリケーションに必要な RubyGems パッケージを一覧表示します。AWS SDK for Ruby は RubyGems から入手できます。インストールする特定の AWS サービス gem を選択する必要があります。例えば、[Lambda 用 Ruby gem](https://rubygems.org/gems/aws-sdk-lambda/) を使用するには、Gemfile は次のようになるはずです。
```
source 'https://rubygems.org'
gem 'aws-sdk-lambda'
```
あるいは、[aws-sdk](https://rubygems.org/gems/aws-sdk/) gem には利用可能なすべての AWS サービス gem が含まれています。この gem はとても大きいことが特徴です。多くの AWS サービスを利用している場合にのみ使用することを推奨します。
1. [バンドルインストール](https://bundler.io/v2.4/man/bundle-install.1.html)を使用して、Gemfile で指定された依存関係をインストールします。
```
bundle install
```
1. `lambda_function.rb` という名前の新しいファイルを作成します。テスト用に次のサンプル関数コードをファイルに追加することも、独自のコードを使用することもできます。
**Example Ruby 関数**
```
module LambdaFunction
class Handler
def self.process(event:,context:)
"Hello from Lambda!"
end
end
end
```
1. 新しい Dockerfile を作成します。次の Dockerfile は、[AWS ベースイメージ](images-create.md#runtimes-images-lp)の代わりに Ruby ベースイメージを使用しています。Dockerfile には [Ruby 用のランタイムインターフェースクライアントが](https://github.com/aws/aws-lambda-ruby-runtime-interface-client)含まれており、イメージに Lambda との互換性を持たせています。あるいは、ランタイムインターフェースクライアントをアプリケーションの Gemfile に追加することもできます。
+ `FROM` プロパティに Ruby ベースイメージを設定します。
+ 関数コードのディレクトリを作成し、そのディレクトリを指す環境変数を作成します。この例では、ディレクトリは `/var/task` であり、Lambda 実行環境をミラーリングします。ただし、Dockerfile は AWS ベースイメージを使用しないため、関数コードには任意のディレクトリを選択できます。
+ `ENTRYPOINT` を、Docker コンテナの起動時に実行させるモジュールに設定します。この場合、モジュールはランタイムインターフェイスクライアントです。
+ `CMD` 引数を Lambda 関数ハンドラーに設定します。
この例の Dockerfile には [USER 命令](https://docs.docker.com/reference/dockerfile/#user)が含まれていないことに注意してください。コンテナイメージを Lambda にデプロイすると、最小特権のアクセス許可を付与したデフォルトの Linux ユーザーを Lambda が自動的に定義します。これは標準の Docker 動作とは異なります。標準の動作とは、`USER` 命令を指定しなかったときに `root` ユーザーのデフォルトとなる動作のことです。
**Example Dockerfile**
```
FROM ruby:2.7
# Install the runtime interface client for Ruby
RUN gem install aws_lambda_ric
# Add the runtime interface client to the PATH
ENV PATH="/usr/local/bundle/bin:${PATH}"
# Create a directory for the Lambda function
ENV LAMBDA_TASK_ROOT=/var/task
RUN mkdir -p ${LAMBDA_TASK_ROOT}
WORKDIR ${LAMBDA_TASK_ROOT}
# Copy Gemfile and Gemfile.lock
COPY Gemfile Gemfile.lock ${LAMBDA_TASK_ROOT}/
# Install Bundler and the specified gems
RUN gem install bundler:2.4.20 && \
bundle config set --local path 'vendor/bundle' && \
bundle install
# Copy function code
COPY lambda_function.rb ${LAMBDA_TASK_ROOT}/
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "aws_lambda_ric" ]
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.LambdaFunction::Handler.process" ]
```
1. Docker イメージを「[Docker の構築](https://docs.docker.com/engine/reference/commandline/build/)」コマンドで構築します。次の例では、イメージを `docker-image` と名付けて `test` [タグ](https://docs.docker.com/engine/reference/commandline/build/#tag)を付けます。Lambda互換のイメージを作成するには、 `--provenance=false` オプションを使用する必要があります。
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**注記**
このコマンドは、ビルドマシンのアーキテクチャに関係なく、コンテナが Lambda の実行環境と互換性があることを確認する `--platform linux/amd64` オプションを特定します。ARM64 命令セットアーキテクチャを使用して Lambda 関数を作成する場合は、代わりに `--platform linux/arm64` オプションを使用するようにコマンドを変更してください。
### (オプション) イメージをローカルでテストする
[ランタイムインターフェイスエミュレーター](https://github.com/aws/aws-lambda-runtime-interface-emulator/)を使用して、イメージをローカルでテストします。[エミュレーターはイメージに組み込むことも](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image)、次の手順を使用してローカルマシンにインストールすることもできます。
**ローカルマシンにランタイムインターフェイスエミュレーターをインストールして実行するには**
1. プロジェクトディレクトリから次のコマンドを実行して、GitHub からランタイムインターフェイスエミュレーター (x86-64 アーキテクチャ) をダウンロードし、ローカルマシンにインストールします。
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
arm64 エミュレータをインストールするには、前のコマンドの GitHub リポジトリ URL を次のように置き換えます。
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
arm64 エミュレーターをインストールするには、`$downloadLink` を次のように置き換えます。
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. **docker run** コマンドを使用して、Docker イメージを起動します。次の点に注意してください。
+ `docker-image` はイメージ名、`test` はタグです。
+ `aws_lambda_ric lambda_function.LambdaFunction::Handler.process` は `ENTRYPOINT` で、その後に Dockerfile の `CMD` が続きます。
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
docker-image:test \
aws_lambda_ric lambda_function.LambdaFunction::Handler.process
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
aws_lambda_ric lambda_function.LambdaFunction::Handler.process
```
------
このコマンドはイメージをコンテナとして実行し、`localhost:9000/2015-03-31/functions/function/invocations` でローカルエンドポイントを作成します。
**注記**
ARM64 命令セットアーキテクチャ用に Docker イメージをビルドした場合は、`--platform linux/amd64` の代わりに `--platform linux/arm64` オプションを使用してください。
1. イベントをローカルエンドポイントにポストします。
------
#### [ Linux/macOS ]
Linux および macOS では、次の `curl` コマンドを実行します。
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
このコマンドは、空のイベントで関数を呼び出し、応答を返します。サンプル関数コードではなく独自の関数コードを使用している場合は、JSON ペイロードを使用して関数を呼び出すことをお勧めします。例:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
PowerShell で次の `Invoke-WebRequest` コマンドを実行します。
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
このコマンドは、空のイベントで関数を呼び出し、応答を返します。サンプル関数コードではなく独自の関数コードを使用している場合は、JSON ペイロードを使用して関数を呼び出すことをお勧めします。例:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. コンテナ ID を取得します。
```
docker ps
```
1. 「[docker kill](https://docs.docker.com/engine/reference/commandline/kill/)」コマンドを使用してコンテナを停止します。このコマンドでは、`3766c4ab331c` を前のステップのコンテナ ID で置き換えます。
```
docker kill 3766c4ab331c
```
### イメージのデプロイ
**Amazon ECR にイメージをアップロードして Lambda 関数を作成するには**
1. 「[get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)」コマンドを実行して Amazon ECR レジストリに Docker CLI を認証します。
+ `--region` 値を Amazon ECR リポジトリを作成する AWS リージョン に設定します。
+ `111122223333` を AWS アカウント ID に置き換えます。
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. 「[create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html)」コマンドを使用して Amazon ECR にリポジトリを作成します。
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**注記**
Amazon ECR リポジトリは Lambda 関数と同じ AWS リージョン に配置されている必要があります。
成功すると、次のようなレスポンスが表示されます。
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. 前のステップの出力から `repositoryUri` をコピーします。
1. 「[docker tag](https://docs.docker.com/engine/reference/commandline/tag/)」コマンドを実行して、最新バージョンとしてローカルイメージを Amazon ECR リポジトリにタグ付けします。このコマンドで:
+ `docker-image:test` は、Docker イメージの名前と[タグ](https://docs.docker.com/engine/reference/commandline/build/#tag)です。これは、`docker build` コマンドに指定したイメージの名前とタグです。
+ `` を、コピーした `repositoryUri` に置き換えます。URI の末尾には必ず `:latest` を含めてください。
```
docker tag docker-image:test :latest
```
例:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. 「[docker push](https://docs.docker.com/engine/reference/commandline/push/)」コマンドを実行して Amazon ECR リポジトリにローカルイメージをデプロイします リポジトリ URI の末尾には必ず `:latest` を含めてください。
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. まだ作成済みでない場合、関数に「[実行ロールの作成](lambda-intro-execution-role.md#permissions-executionrole-api)」を実行してください。次のステップではロールの Amazon リソースネーム (ARN) が必要です。
1. Lambda 関数を作成します。`ImageUri` には、先ほど使用したリポジトリ URI を指定します。URI の末尾には必ず `:latest` を含めてください。
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**注記**
イメージが Lambda 関数と同じリージョンに配置されていれば、別の AWS アカウントのイメージを使用して関数を作成することができます。詳細については、「[Amazon ECR クロスアカウント許可](images-create.md#configuration-images-xaccount-permissions)」を参照してください。
1. 関数を呼び出します。
```
aws lambda invoke --function-name hello-world response.json
```
次のような結果が表示されます。
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. 関数の出力を確認するには、`response.json` ファイルをチェックします。
関数コードを更新するには、イメージを再構築し、新しいイメージを Amazon ECR リポジトリにアップロードしてから、[update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) コマンドを使用してイメージを Lambda 関数にデプロイする必要があります。
Lambda は、イメージタグを特定のイメージダイジェストに解決します。これは、関数のデプロイに使用されたイメージタグを Amazon ECR 内の新しいイメージを指すように変更しても、Lambda は新しいイメージを使用するように自動的に関数を更新しないことを意味します。
新しいイメージを同じ Lambda 関数にデプロイするには、Amazon ECR のイメージタグが同じままであっても、[update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) コマンドを使用する必要があります。次の例では、`--publish` オプションが最新のコンテナイメージを使用して関数の新しいバージョンを作成しています。
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
# Ruby Lambda 関数のレイヤーを操作する
[Lambda レイヤー](chapter-layers.md)を使用して、複数の関数間で再利用するコードおよび依存関係をパッケージ化できます。レイヤーには通常、ライブラリの依存関係、[カスタムランタイム](runtimes-custom.md)、または設定ファイルが含まれています。レイヤーの作成には、次の 3 つの一般的な手順が含まれます。
1. レイヤーコンテンツのパッケージ化。これは、関数で使用する依存関係を含む .zip ファイルアーカイブを作成することを意味します。
1. Lambda でレイヤーを作成します。
1. レイヤーを関数に追加します。
**Topics**
+ [
## レイヤーコンテンツのパッケージ化
](#ruby-layers-package)
+ [
## Lambda でレイヤーを作成する
](#publishing-layer)
+ [
## 関数内のレイヤーからの gem の使用
](#ruby-layers-bundler-limitations)
+ [
## レイヤーを関数に追加する
](#ruby-layer-adding)
+ [
## サンプルアプリ
](#ruby-layer-sample-app)
## レイヤーコンテンツのパッケージ化
レイヤーを作成するには、次の要件を満たす .zip ファイルのアーカイブにパッケージをバンドルします。
+ Lambda 関数に使用する予定のものと同じ Ruby バージョンを使用するレイヤーを作成する。例えば、Ruby 3.4 向けのレイヤーを作成する場合は、関数にも Ruby 3.4 ランタイムを使用します。
+ Layer の .zip ファイルは、次のいずれかのディレクトリ構造を使用する必要があります。
+ `ruby/gems/x.x.x` (*x.x.x* は、`3.4.0` などの Ruby バージョン)
+ `ruby/lib`
詳細については、「[各 Lambda ランタイムのレイヤーパス](packaging-layers.md#packaging-layers-paths)」を参照してください。
+ レイヤーのパッケージは Linux と互換性がある必要があります。Lambda 関数は Amazon Linux 上で動作します。
サードパーティーの Ruby gem、または独自の Ruby モジュールとクラスが含まれるレイヤーを作成できます。一般的な Ruby gem の多くには、ネイティブ拡張機能 (C コード) が含まれています。これらは、Lambda Linux 環境用にコンパイルする必要があります。
### Pure Ruby gem
Pure Ruby gem には Ruby コードのみが含まれており、コンパイルは必要ありません。これらの gem は、さまざまなプラットフォームでより簡単にパッケージ化して使用できます。
**Pure Ruby gem を使用してレイヤーを作成する**
1. `Gemfile` を作成して、レイヤーに含める pure Ruby gem を指定します。
**Example Gemfile**
```
source 'https://rubygems.org'
gem 'tzinfo'
```
1. Bundler を使用して、gem を `vendor/bundle` ディレクトリにインストールします。
```
bundle config set --local path vendor/bundle
bundle install
```
1. インストールされた gem を、Lambda が必要とするディレクトリ構造 (`ruby/gems/3.4.0`) にコピーします。
```
mkdir -p ruby/gems/3.4.0
cp -r vendor/bundle/ruby/3.4.0*/* ruby/gems/3.4.0/
```
1. レイヤーコンテンツを圧縮します。
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
.zip ファイルのディレクトリ構造は次のようになります。
```
ruby/
└── gems/
└── 3.4.0/
├── gems/
│ ├── concurrent-ruby-1.3.5/
│ └── tzinfo-2.0.6/
├── specifications/
├── cache/
├── build_info/
└── (other bundler directories)
```
**注記**
関数コードでは、各 gem を個別に require する必要があります。`bundler/setup` や `Bundler.require` を使用することはできません。詳細については、「[関数内のレイヤーからの gem の使用](#ruby-layers-bundler-limitations)」を参照してください。
### ネイティブ拡張機能が含まれる gem
一般的な Ruby gem の多くには、ネイティブ拡張機能 (C コード) が含まれています。これらは、ターゲットプラットフォーム用にコンパイルする必要があります。ネイティブ拡張機能が含まれる一般的な gem には、[nokogiri](https://rubygems.org/gems/nokogiri/)、[pg](https://rubygems.org/gems/pg/)、[mysql2](https://rubygems.org/gems/mysql2/)、[sqlite3](https://rubygems.org/gems/sqlite3/)、[ffi](https://rubygems.org/gems/ffi/) などがあります。これらの gem は、Lambda ランタイムとの互換性がある Linux 環境内で構築する必要があります。
**ネイティブ拡張機能が含まれる gem を使用してレイヤーを作成する**
1. `Gemfile` を作成します。
**Example Gemfile**
```
source 'https://rubygems.org'
gem 'nokogiri'
gem 'httparty'
```
1. Docker を使用して、Lambda との互換性がある Linux 環境内で gem を構築します。Dockerfile で [AWS ベースイメージ](ruby-image.md#ruby-image-base)を指定します。
**Example Ruby 3.4 用の Dockerfile**
```
FROM public.ecr.aws/lambda/ruby:3.4
# Copy Gemfile
COPY Gemfile ./
# Install system dependencies for native extensions
RUN dnf update -y && \
dnf install -y gcc gcc-c++ make
# Configure bundler and install gems
RUN bundle config set --local path vendor/bundle && \
bundle install
# Create the layer structure
RUN mkdir -p ruby/gems/3.4.0 && \
cp -r vendor/bundle/ruby/3.4.0*/* ruby/gems/3.4.0/
# Create the layer zip file
RUN zip -r layer.zip ruby/
```
1. イメージを構築し、レイヤーを抽出します。
```
docker build -t ruby-layer-builder .
docker run --rm -v $(pwd):/output --entrypoint cp ruby-layer-builder layer.zip /output/
```
そうすることで、正しい Linux 環境に gem が構築され、ローカルディレクトリに `layer.zip` ファイルがコピーされます。.zip ファイルのディレクトリ構造は次のようになります。
```
ruby/
└── gems/
└── 3.4.0/
├── gems/
│ ├── bigdecimal-3.2.2/
│ ├── csv-3.3.5/
│ ├── httparty-0.23.1/
│ ├── mini_mime-1.1.5/
│ ├── multi_xml-0.7.2/
│ ├── nokogiri-1.18.8-x86_64-linux-gnu/
│ └── racc-1.8.1/
├── build_info/
├── cache/
├── specifications/
└── (other bundler directories)
```
**注記**
関数コードでは、各 gem を個別に require する必要があります。`bundler/setup` や `Bundler.require` を使用することはできません。詳細については、「[関数内のレイヤーからの gem の使用](#ruby-layers-bundler-limitations)」を参照してください。
### カスタム Ruby モジュール
**ユーザー独自のコードを使用してレイヤーを作成する方法**
1. レイヤーに必要なディレクトリ構造を作成します。
```
mkdir -p ruby/lib
```
1. `ruby/lib` ディレクトリに Ruby モジュールを作成します。次のモジュール例は、必要な情報が含まれていることを確認して注文をバリデーションします。
**Example ruby/lib/order\$1validator.rb**
```
require 'json'
module OrderValidator
class ValidationError < StandardError; end
def self.validate_order(order_data)
# Validates an order and returns formatted data
required_fields = %w[product_id quantity]
# Check required fields
missing_fields = required_fields.reject { |field| order_data.key?(field) }
unless missing_fields.empty?
raise ValidationError, "Missing required fields: #{missing_fields.join(', ')}"
end
# Validate quantity
quantity = order_data['quantity']
unless quantity.is_a?(Integer) && quantity > 0
raise ValidationError, 'Quantity must be a positive integer'
end
# Format and return the validated data
{
'product_id' => order_data['product_id'].to_s,
'quantity' => quantity,
'shipping_priority' => order_data.fetch('priority', 'standard')
}
end
def self.format_response(status_code, body)
# Formats the API response
{
statusCode: status_code,
body: JSON.generate(body)
}
end
end
```
1. レイヤーコンテンツを圧縮します。
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
.zip ファイルのディレクトリ構造は次のようになります。
```
ruby/
└── lib/
└── order_validator.rb
```
1. 関数内でモジュールを require し、使用します。関数コードでは、各 gem を個別に require する必要があります。`bundler/setup` や `Bundler.require` を使用することはできません。詳細については、「[関数内のレイヤーからの gem の使用](#ruby-layers-bundler-limitations)」を参照してください。例:
```
require 'json'
require 'order_validator'
def lambda_handler(event:, context:)
begin
# Parse the order data from the event body
order_data = JSON.parse(event['body'] || '{}')
# Validate and format the order
validated_order = OrderValidator.validate_order(order_data)
OrderValidator.format_response(200, {
message: 'Order validated successfully',
order: validated_order
})
rescue OrderValidator::ValidationError => e
OrderValidator.format_response(400, {
error: e.message
})
rescue => e
OrderValidator.format_response(500, {
error: 'Internal server error'
})
end
end
```
次の[テストイベント](testing-functions.md#invoke-with-event)を使用して関数を呼び出すことができます。
```
{
"body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
}
```
予想されるレスポンス
```
{
"statusCode": 200,
"body": "{\"message\":\"Order validated successfully\",\"order\":{\"product_id\":\"ABC123\",\"quantity\":2,\"shipping_priority\":\"express\"}}"
}
```
## Lambda でレイヤーを作成する
AWS CLI または Lambda コンソールを使用して、レイヤーを発行できます。
------
#### [ AWS CLI ]
[publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) AWS CLI コマンドを実行して Lambda レイヤーを作成します。
```
aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes ruby3.4
```
[互換性のあるランタイム](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes)パラメータの使用は任意です。指定すると、Lambda はこのパラメータを使用して Lambda コンソールのレイヤーをフィルタリングします。
------
#### [ Console ]
**レイヤーを作成するには (コンソール)**
1. Lambda コンソールの [[Layers (レイヤー)] ページ](https://console.aws.amazon.com/lambda/home#/layers)を開きます。
1. [**Create layer**] (レイヤーの作成) を選択します。
1. **[.zip ファイルをアップロードする]**を選択し、前の手順で作成しておいた .zip アーカイブをアップロードします。
1. (オプション) **[互換性のあるランタイム]** で、レイヤーを構築するために使用した Ruby バージョンに対応する Ruby ランタイムを選択します。
1. **[作成]** を選択します。
------
## 関数内のレイヤーからの gem の使用
関数コードでは、使用する各 gem を明示的に require する必要があります。`bundler/setup` や `Bundler.require` などの Bundler コマンドはサポートされていません。以下は、Lambda 関数内のレイヤーから gem を適切に使用する方法です。
```
# Correct: Use explicit requires for each gem
require 'nokogiri'
require 'httparty'
def lambda_handler(event:, context:)
# Use the gems directly
doc = Nokogiri::HTML(event['html'])
response = HTTParty.get(event['url'])
# ... rest of your function
end
# Incorrect: These Bundler commands will not work
# require 'bundler/setup'
# Bundler.require
```
## レイヤーを関数に追加する
------
#### [ AWS CLI ]
レイヤーを関数にアタッチするには、[update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) AWS CLI コマンドを実行します。`--layers` パラメータには、レイヤー ARN を使用します。ARN はバージョンを指定する必要があります (`arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1` など)。詳細については、「[レイヤーとレイヤーバージョン](chapter-layers.md#lambda-layer-versions)」を参照してください。
```
aws lambda update-function-configuration --function-name my-function --cli-binary-format raw-in-base64-out --layers "arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1"
```
AWS CLI バージョン 2 を使用している場合、**cli-binary-format** オプションは必須です。これをデフォルト設定にするには、`aws configure set cli-binary-format raw-in-base64-out` を実行します。詳細については、バージョン 2 の AWS Command Line Interface ユーザーガイドの「[AWS CLI でサポートされているグローバルコマンドラインオプション](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list)」を参照してください。
------
#### [ Console ]
**関数にレイヤーを追加する方法**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 関数を選択します。
1. **[レイヤー]** セクションまで下にスクロールし、**[レイヤーの追加]** を選択します。
1. **[レイヤーの選択]** で **[カスタムレイヤー]** を選択し、レイヤーを指定します。
**注記**
レイヤーの作成時に[互換性のあるランタイム](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes)を追加しなかった場合、レイヤーはここには表示されません。代わりにレイヤー ARN を指定できます。
1. **[Add]** (追加) を選択します。
------
## サンプルアプリ
Lambda レイヤーのさらなる使用方法例については、「AWS Lambda デベロッパーガイド」の GitHub リポジトリにある [layer-nodejs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-ruby) サンプルアプリケーションを参照してください。このアプリケーションには、[lodash](https://rubygems.org/gems/tzinfo) ライブラリが含まれるレイヤーがあります。各レイヤーを作成したら、対応する関数をデプロイして呼び出し、レイヤーが期待どおりに動作するかどうかを確認できます。
# Lambda コンテキストオブジェクトを使用して Ruby 関数の情報を取得する
Lambda で関数が実行されると、コンテキストオブジェクトが[ハンドラー](ruby-handler.md)に渡されます。このオブジェクトは、呼び出し、関数、および実行関数に関する情報を示すメソッドおよびプロパティを提供します。
**context メソッド**
+ `get_remaining_time_in_millis` — 実行がタイムアウトするまでの残り時間をミリ秒で返します。
**context プロパティ**
+ `function_name` － Lambda 関数の名前。
+ `function_version` － 関数の[バージョン](configuration-versions.md)。
+ `invoked_function_arn` － 関数を呼び出すために使用される Amazon リソースネーム (ARN)。呼び出し元でバージョン番号またはエイリアスが指定されているかどうかを示します。
+ `memory_limit_in_mb` － 関数に割り当てられたメモリの量。
+ `aws_request_id` － 呼び出しリクエストの ID。
+ `log_group_name` － 関数のロググループ。
+ `log_stream_name` — 関数インスタンスのログストリーム。
+ `deadline_ms` - 関数がタイムアウトした日付 (Unix 時間のミリ秒)。
+ `identity` — (モバイルアプリケーション) リクエストを認可した Amazon Cognito ID に関する情報。
+ `client_context` —（モバイルアプリケーション）クライアントアプリケーションが Lambda に提供したクライアントコンテキスト。
# Ruby Lambda 関数のログ記録とモニタリング
AWS Lambda は、ユーザーに代わって Lambda 関数を自動的にモニタリングし、Amazon CloudWatch にログを送信します。Lambda 関数には、関数のインスタンスごとに CloudWatch Logs ロググループとログストリームが用意されています。Lambda ランタイム環境は、各呼び出しの詳細をログストリームに送信し、関数のコードからのログやその他の出力を中継します。詳細については、「[Lambda 関数ログを CloudWatch Logs に送信する](monitoring-cloudwatchlogs.md)」を参照してください。
このページでは、AWS Command Line Interface、Lambda コンソール、または CloudWatch コンソールを使用して、Lambda 関数のコードからログ出力を生成する方法、およびアクセスログを生成する方法について説明します。
**Topics**
+ [
## ログを返す関数の作成
](#ruby-logging-output)
+ [
## Lambda コンソールでログを表示する
](#ruby-logging-console)
+ [
## CloudWatch コンソールでの ログの表示
](#ruby-logging-cwconsole)
+ [
## AWS Command Line Interface (AWS CLI) を使用してログを表示する
](#ruby-logging-cli)
+ [
## ログの削除
](#ruby-logging-delete)
+ [
## Ruby ロガーライブラリの使用方法
](#ruby-logging-lib)
## ログを返す関数の作成
関数コードからログを出力するには、`puts` ステートメントか、`stdout` または `stderr` に書き込むログ記録ライブラリを使用します。次の例では、環境変数の値とイベントオブジェクトをログに記録します。
**Example lambda\$1function.rb**
```
# lambda_function.rb
def handler(event:, context:)
puts "## ENVIRONMENT VARIABLES"
puts ENV.to_a
puts "## EVENT"
puts event.to_a
end
```
**Example ログの形式**
```
START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled: true
```
Ruby ランタイムは、呼び出しごとに `START`、`END`、および `REPORT` の各行を記録します。レポート行には、次の詳細が示されます。
**REPORT 行のデータフィールド**
+ **RequestId** － 呼び出しの一意のリクエスト ID。
+ **所要時間** － 関数のハンドラーメソッドがイベントの処理に要した時間。
+ **課金期間** － 呼び出しの課金対象の時間。
+ **メモリサイズ** － 関数に割り当てられたメモリの量。
+ **使用中の最大メモリ** － 関数によって使用されているメモリの量。呼び出しが実行環境を共有すると、Lambda はすべての呼び出しで使用される最大メモリを報告します。この動作により、予想よりも高い報告値が発生する可能性があります。
+ **初期所要時間** － 最初に処理されたリクエストについて、ハンドラーメソッド外で関数をロードしてコードを実行するためにランタイムにかかった時間。
+ **XRAY TraceId** － トレースされたリクエストの場合、[AWS X-Ray のトレース ID](services-xray.md)。
+ **SegmentId** － トレースされたリクエストの場合、X-Ray のセグメント ID。
+ **サンプリング済み** － トレースされたリクエストの場合、サンプリング結果。
詳細なログについては、[Ruby ロガーライブラリの使用方法](#ruby-logging-lib) を使用します。
## Lambda コンソールでログを表示する
Lambda コンソールを使用して、Lambda 関数を呼び出した後のログ出力を表示できます。
組み込み **Code** エディタからコードがテスト可能である場合、**[実行結果]** でログを確認できます。コンソールのテスト機能を使用して関数を呼び出すと、**[詳細]** セクションで **[ログ出力]** を確認できます。
## CloudWatch コンソールでの ログの表示
Amazon CloudWatch コンソールを使用して、すべての Lambda 関数呼び出しのログを表示できます。
**CloudWatch コンソールでログを表示するには**
1. CloudWatch コンソールの [[Log groups (ロググループ)] ページ](https://console.aws.amazon.com/cloudwatch/home?#logs:)を開きます。
1. 機能のロググループを選択します( **/aws/lambda/*関数名***)
1. ログストリームを選択します
各ログストリームは、[関数のインスタンス](lambda-runtime-environment.md)に相当します。ログストリームは、Lambda 関数を更新したとき、および同時呼び出しを処理するために追加のインスタンスが作成されたときに表示されます。特定の呼び出しのログを検索するために、AWS X-Ray を使って関数をインストルメント化することをお勧めします。 X-Ray は、リクエストとログストリームの詳細をトレースに記録します。
## AWS Command Line Interface (AWS CLI) を使用してログを表示する
AWS CLI は、コマンドラインシェルでコマンドを使用して AWS サービスとやり取りするためのオープンソースツールです。このセクションの手順を完了するには、[AWS CLIバージョン 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) が必要です。
[AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) および `--log-type` コマンドオプションを使用して、呼び出しのログを取得します。レスポンスには、`LogResult`フィールドが含まれ、このフィールドには、呼び出しから base64 コードされた最大 4 KB のログが含まれます。
**Example ログ ID を取得します**
次の例は、`LogResult`という名前の関数の`my-function`フィールドから*ログ ID * を取得する方法を示しています。
```
aws lambda invoke --function-name my-function out --log-type Tail
```
次のような出力が表示されます。
```
{
"StatusCode": 200,
"LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}
```
**Example ログをデコードします**
同じコマンドプロンプトで、`base64` ユーティリティを使用してログをデコードします。次の例は、`my-function`の base64 でエンコードされたログを取得する方法を示しています 。
```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
AWS CLI バージョン 2 を使用している場合、**cli-binary-format** オプションは必須です。これをデフォルト設定にするには、`aws configure set cli-binary-format raw-in-base64-out` を実行します。詳細については、「*AWS Command Line Interface バージョン 2 用ユーザーガイド*」の「[AWS CLI でサポートされているグローバルコマンドラインオプション](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list)」を参照してください。
以下の出力が表示されます。
```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed Duration: 80 ms Memory Size: 128 MB Max Memory Used: 73 MB
```
`base64`このユーティリティは、Linux、macOS、および [ Windows の Ubuntu ](https://docs.microsoft.com/en-us/windows/wsl/install-win10) で使用できます。macOS ユーザーは、`base64 -D`を使用する必要があります 。
**Example get-logs.sh スクリプト**
同じコマンドプロンプトで、次のスクリプトを使用して、最後の 5 つのログイベントをダウンロードします。このスクリプトは `sed` を使用して出力ファイルから引用符を削除し、ログが使用可能になるまで 15 秒待機します。この出力には Lambda からのレスポンスと、`get-log-events` コマンドからの出力が含まれます。
次のコードサンプルの内容をコピーし、Lambda プロジェクトディレクトリに `get-logs.sh` として保存します。
AWS CLI バージョン 2 を使用している場合、**cli-binary-format** オプションは必須です。これをデフォルト設定にするには、`aws configure set cli-binary-format raw-in-base64-out` を実行します。詳細については、「*AWS Command Line Interface バージョン 2 用ユーザーガイド*」の「[AWS CLI でサポートされているグローバルコマンドラインオプション](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list)」を参照してください。
```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```
**Example macOS および Linux (専用)**
同じコマンドプロンプトで、macOS と Linux ユーザーが次のコマンドを実行して、スクリプトが実行可能であることを確認する必要があります。
```
chmod -R 755 get-logs.sh
```
**Example 最後の 5 つのログイベントを取得します**
同じコマンドプロンプトで、次のスクリプトを実行して、最後の 5 つのログイベントを取得します。
```
./get-logs.sh
```
次のような出力が表示されます。
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```
## ログの削除
関数を削除しても、ロググループは自動的には削除されません。ログが無期限に保存されないようにするには、ロググループを削除するか、ログが自動的に削除されるまでの[保存期間を設定](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention)します。
## Ruby ロガーライブラリの使用方法
Ruby [ロガーライブラリは](https://ruby-doc.org/stdlib-2.7.0/libdoc/logger/rdoc/index.html)、読みやすい効率的なログを返します。ロガーユーティリティを使用して、関数に関連する詳細情報、メッセージ、およびエラーコードを出力します。
```
# lambda_function.rb
require 'logger'
def handler(event:, context:)
logger = Logger.new($stdout)
logger.info('## ENVIRONMENT VARIABLES')
logger.info(ENV.to_a)
logger.info('## EVENT')
logger.info(event)
event.to_a
end
```
`logger` からの出力には、ログレベル、タイムスタンプおよびリクエスト ID が含まれています。
```
START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST
[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT VARIABLES
[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key': 'value'}
END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125
REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled: true
```
# AWS Lambda での Ruby の作成
Lambda が AWS X-Ray と統合され、Lambda アプリケーションのトレース、デバッグ、および最適化が可能になりました。X-Ray を使用して、フロントエンド API からバックエンドのストレージとデータベースまで、アプリケーション内のリソースを通過する際にリクエストをトレースできます。X-Ray SDK ライブラリをビルド設定に追加するだけで、関数が AWS のサービスに対して行う呼び出しのエラーとレイテンシーを記録できます。
アクティブトレースの設定後は、アプリケーションを通じて特定のリクエストの観測が行えるようになります。[[X-Ray サービスグラフ]](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) には、アプリケーションとそのすべてのコンポーネントに関する情報が表示されます。次の例は、2 つの関数を持つアプリケーションを示しています。プライマリ関数はイベントを処理し、エラーを返す場合があります。上位 2 番目の関数は、最初のロググループに表示されるエラーを処理し、AWS SDK を使用して X-Ray、Amazon Simple Storage Service (Amazon S3)、および Amazon CloudWatch Logs を呼び出します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
コンソールを使用して Lambda 関数のアクティブトレースを切り替えるには、以下のステップに従います。
**アクティブトレースをオンにするには**
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択します。
1. **[設定]** を選択してから、**[モニタリングおよび運用ツール]** を選択します。
1. **[その他の監視ツール]** で、**[編集]** を選択します。
1. **[CloudWatch Application Signals と AWS X-Ray]** で、**[Lambda サービストレース]** の **[有効]** を選択します。
1. **[保存]** を選択します。
**料金**
X-Ray トレースは、毎月、AWS 無料利用枠で設定された一定限度まで無料で利用できます。X-Ray の利用がこの上限を超えた場合は、トレースによる保存と取得に対する料金が発生します。詳細については、「[AWS X-Ray 料金表](https://aws.amazon.com/xray/pricing/)」を参照してください。
関数には、トレースデータを X-Ray にアップロードするためのアクセス許可が必要です。Lambda コンソールでトレースを有効にすると、Lambda は必要な権限を関数の [[実行ロール]](lambda-intro-execution-role.md) に追加します。それ以外の場合は、[AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess) ポリシーを実行ロールに追加します。
X-Ray は、アプリケーションへのすべてのリクエストをトレースするとは限りません。X-Ray は、サンプリングアルゴリズムを適用することで効率的なトレースを行うと同時に、すべてのリクエストについての代表的なサンプルを示します。サンプルレートは 1 秒あたり 1 回のリクエストで、追加リクエストの 5％ です。関数の X-Ray サンプルレートを設定することはできません。
X-Ray では、*トレース*は 1 つ以上の*サービス*によって処理されるリクエストに関する情報を記録します。Lambda はトレースごとに 2 つのセグメントを記録します。これにより、サービスグラフに 2 つのノードが作成されます。次の図は、これら 2 つのノードを強調表示しています。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/xray-servicemap-function.png)
左に示された 1 つめのノードは、呼び出しリクエストを受信する Lambda サービスを表しています。2 つめのノードは、特定の Lambda 関数を表しています。次の例は、これら 2 つのセグメントを使用したトレースを示しています。いずれも **my-function** と名付けられていますが、1 つは `AWS::Lambda` の起点があり、もう 1 つは `AWS::Lambda::Function` の起点があります。`AWS::Lambda` セグメントにエラーが表示される場合は、Lambda サービスに問題があります。`AWS::Lambda::Function` セグメントにエラーが表示される場合、関数に問題があります。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
この例では、`AWS::Lambda::Function` セグメントを展開して、それの 3 つのサブセグメントが表示されています。
**注記**
AWS は現在、Lambda サービスに変更を実装しています。これらの変更により、AWS アカウント のさまざまな Lambda 関数によって出力されるシステムログメッセージとトレースセグメントの構造と内容にわずかな違いが生じる場合があります。
ここで示すトレースの例は、古いスタイルの関数セグメントを示しています。古いスタイルのセグメントと新しいスタイルのセグメントの違いについては、次の段落で説明します。
これらの変更は今後数週間に実装され、中国および GovCloud リージョンを除くすべての AWS リージョンのすべての関数は、新しい形式のログメッセージとトレースセグメントを使用するように移行されます。
古いスタイルの関数セグメントには、次のサブセグメントが含まれます。
+ **初期化** － 関数のロードと[初期化コード](foundation-progmodel.md)の実行に要した時間を表します。このサブセグメントは、関数の各インスタンスが処理する最初のイベントに対してのみ表示されます。
+ **[呼び出し]** - ハンドラーコードの実行に要した時間を表します。
+ **[オーバーヘッド]** - Lambda ランタイムが次のイベントを処理するための準備に要する時間を表します。
新しいスタイルの関数セグメントには `Invocation` サブセグメントが含まれていません。代わりに、顧客サブセグメントが関数セグメントに直接アタッチされます。古いスタイルの関数セグメントと新しいスタイルの関数セグメントの構造の詳細については、「」を参照してください[X-Ray トレースを理解する](services-xray.md#services-xray-traces)。
ハンドラーコードを実装して、メタデータを記録し、ダウンストリームコールをトレースできます。ハンドラーが他のリソースやサービスに対して行うコールの詳細を記録するには、X-Ray SDK for Ruby を使用します。SDK を取得するには、アプリケーションの依存関係に `aws-xray-sdk` パッケージを追加します。
**Example [blank-ruby/function/Gemfile](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/function/Gemfile)**
```
# Gemfile
source 'https://rubygems.org'
gem 'aws-xray-sdk', '0.11.4'
gem 'aws-sdk-lambda', '1.39.0'
gem 'test-unit', '3.3.5'
```
AWS SDK クライアントを実装するには、初期化コードでクライアントを作成した後、`aws-xray-sdk/lambda` モジュールが必要です。
**Example [blank-ruby/function/lambda\$1function.rb](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/function/lambda_function.rb) - AWS SDK クライアントのトレース**
```
# lambda_function.rb
require 'logger'
require 'json'
require 'aws-sdk-lambda'
$client = Aws::Lambda::Client.new()
$client.get_account_settings()
require 'aws-xray-sdk/lambda'
def lambda_handler(event:, context:)
logger = Logger.new($stdout)
...
```
X-Ray では、*トレース*は 1 つ以上の*サービス*によって処理されるリクエストに関する情報を記録します。Lambda はトレースごとに 2 つのセグメントを記録します。これにより、サービスグラフに 2 つのノードが作成されます。次の図は、これら 2 つのノードを強調表示しています。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/xray-servicemap-function.png)
左に示された 1 つめのノードは、呼び出しリクエストを受信する Lambda サービスを表しています。2 つめのノードは、特定の Lambda 関数を表しています。次の例は、これら 2 つのセグメントを使用したトレースを示しています。いずれも **my-function** と名付けられていますが、1 つは `AWS::Lambda` の起点があり、もう 1 つは `AWS::Lambda::Function` の起点があります。`AWS::Lambda` セグメントにエラーが表示される場合は、Lambda サービスに問題があります。`AWS::Lambda::Function` セグメントにエラーが表示される場合、関数に問題があります。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
この例では、`AWS::Lambda::Function` セグメントを展開して、それの 3 つのサブセグメントが表示されています。
**注記**
AWS は現在、Lambda サービスに変更を実装しています。これらの変更により、AWS アカウント のさまざまな Lambda 関数によって出力されるシステムログメッセージとトレースセグメントの構造と内容にわずかな違いが生じる場合があります。
ここで示すトレースの例は、古いスタイルの関数セグメントを示しています。古いスタイルのセグメントと新しいスタイルのセグメントの違いについては、次の段落で説明します。
これらの変更は今後数週間に実装され、中国および GovCloud リージョンを除くすべての AWS リージョンのすべての関数は、新しい形式のログメッセージとトレースセグメントを使用するように移行されます。
古いスタイルの関数セグメントには、次のサブセグメントが含まれます。
+ **初期化** － 関数のロードと[初期化コード](foundation-progmodel.md)の実行に要した時間を表します。このサブセグメントは、関数の各インスタンスが処理する最初のイベントに対してのみ表示されます。
+ **[呼び出し]** - ハンドラーコードの実行に要した時間を表します。
+ **[オーバーヘッド]** - Lambda ランタイムが次のイベントを処理するための準備に要する時間を表します。
新しいスタイルの関数セグメントには `Invocation` サブセグメントが含まれていません。代わりに、顧客サブセグメントが関数セグメントに直接アタッチされます。古いスタイルの関数セグメントと新しいスタイルの関数セグメントの構造の詳細については、「」を参照してください[X-Ray トレースを理解する](services-xray.md#services-xray-traces)。
HTTP クライアントをインストルメント化し、SQL クエリを記録して、注釈とメタデータからカスタムサブセグメントを作成することもできます。詳細については、AWS X-Ray デベロッパーガイドの [The X-Ray SDK for Ruby](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-ruby.html) を参照してください。
**Topics**
+ [
## Lambda API でのアクティブトレースの有効化
](#ruby-tracing-api)
+ [
## CloudFormation でのアクティブトレースの有効化
](#ruby-tracing-cloudformation)
+ [
## ランタイム依存関係をレイヤーに保存する
](#ruby-tracing-layers)
## Lambda API でのアクティブトレースの有効化
AWS CLI または AWS SDK を使用してトレース設定を管理するには、以下の API オペレーションを使用します。
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
以下の例の AWS CLI コマンドは、**my-function** という名前の関数に対するアクティブトレースを有効にします。
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
トレースモードは、関数のバージョンを公開するときのバージョン固有の設定の一部です。公開後のバージョンのトレースモードを変更することはできません。
## CloudFormation でのアクティブトレースの有効化
CloudFormation テンプレート内で `AWS::Lambda::Function` リソースに対するアクティブトレースを有効化するには、`TracingConfig` プロパティを使用します。
**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) － トレース設定**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
AWS Serverless Application Model (AWS SAM) `AWS::Serverless::Function` リソースに、`Tracing` プロパティを使用します。
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) － トレース設定**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## ランタイム依存関係をレイヤーに保存する
X-Ray SDK を使用して AWS SDK クライアントを関数コードに埋め込むと、デプロイパッケージが巨大になる可能性があります。機能コードを更新するたびに実行時の依存関係がアップロードされないようにするには、X-Ray SDK を [[Lambda layer]](chapter-layers.md) (Lambda レイヤー) にパッケージ化します。
以下の例は、X-Ray SDK for Ruby を保存する `AWS::Serverless::LayerVersion` リソースを示しています。
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/template.yml) - 依存関係レイヤー**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
CodeUri: function/.
Tracing: Active
Layers:
- !Ref libs
...
libs:
Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
Properties:
LayerName: blank-ruby-lib
Description: Dependencies for the blank-ruby sample app.
ContentUri: lib/.
CompatibleRuntimes:
- ruby2.5
```
この設定では、ランタイム依存関係を変更した場合にのみ、ライブラリレイヤーの更新が必要です。関数のデプロイパッケージにはユーザーのコードのみが含まれるため、アップロード時間を短縮できます。
依存関係のレイヤーを作成するには、デプロイ前にレイヤーアーカイブを生成するようにビルドを変更する必要があります。実際の例については、[blank-ruby](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby) サンプルアプリケーションを参照してください。