翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# を使用してアプリケーションを構築する AWS SAM
AWS SAM テンプレートに Infrastructure as Code (IaC) を追加したら、 **sam build** コマンドを使用してアプリケーションの構築を開始する準備が整います。このコマンドは、アプリケーションプロジェクトディレクトリ内のファイル ( AWS SAM テンプレートファイル、アプリケーションコード、および該当する言語固有のファイルと依存関係) からビルドアーティファクトを作成します。これらのビルドアーティファクトは、ローカルテストや AWS クラウドへのデプロイなど、アプリケーション開発の後のステップのためにサーバーレスアプリケーションを準備します。テストとデプロイの両方で、ビルドアーティファクトは入力として使用されます。
**sam build** を使用して、サーバーレスアプリケーション全体を構築できます。さらに、特定の関数、レイヤー、カスタムランタイムなど、カスタマイズされたビルドを作成できます。**sam build** の使用方法と理由の詳細については、このセクションのトピックを参照してください。`sam build` コマンドの使用方法の概要については、「[を使用した の構築の概要 AWS SAM](using-sam-cli-build.md)」を参照してください。
**Topics**
+ [を使用した の構築の概要 AWS SAM](using-sam-cli-build.md)
+ [を使用したデフォルトのビルド AWS SAM](serverless-sam-cli-using-build.md)
+ [でビルドをカスタマイズする AWS SAM](building-lambda-functions.md)
# を使用した の構築の概要 AWS SAM
AWS Serverless Application Model コマンドラインインターフェイス (AWS SAM CLI) `sam build` コマンドを使用して、ローカルテストや へのデプロイなど、開発ワークフローの後続のステップのためにサーバーレスアプリケーションを準備します AWS クラウド。このコマンドは、`sam local` および `sam deploy` が必要とする形式と場所でアプリケーションを構造化する `.aws-sam` ディレクトリを作成します。
+ の概要については AWS SAM CLI、「」を参照してください[とは AWS SAM CLI](what-is-sam-overview.md#what-is-sam-cli)。
+ `sam build` コマンドオプションのリストについては、「[sam build](sam-cli-command-reference-sam-build.md)」を参照してください。
+ 一般的な開発ワークフローでの `sam build` の使用例については、「[ステップ 2: アプリケーションを構築する](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-build)」を参照してください。
**注記**
`sam build` を使用するには、開発マシン上のサーバーレスアプリケーションの基本コンポーネントから始める必要があります。これには、 AWS SAM テンプレート、 AWS Lambda 関数コード、言語固有のファイルと依存関係が含まれます。詳細については[でアプリケーションを作成する AWS SAM](using-sam-cli-init.md)を参照してください。
**Topics**
+ [sam build を使用したアプリケーションの構築](#using-sam-cli-build-apps)
+ [ローカルでのテストとデプロイ](#using-sam-cli-build-test-deploy)
+ [ベストプラクティス](#using-sam-cli-build-best)
+ [sam build のオプション](#using-sam-cli-build-options)
+ [トラブルシューティング](#using-sam-cli-build-troubleshooting)
+ [例](#using-sam-cli-build-examples)
+ [詳細情報](#using-sam-cli-build-learn)
## sam build を使用したアプリケーションの構築
`sam build` を使用する前に、次を設定することを検討してください。
1. **Lambda 関数とレイヤー** – `sam build` コマンドは Lambda 関数とレイヤーを構築できます。Lambda レイヤーの詳細については、「[での Lambda レイヤーの構築 AWS SAM](building-layers.md)」を参照してください。
1. **Lambda ランタイム** – ランタイムは、呼び出されたときに実行環境で関数を実行する言語固有の環境を提供します。ネイティブランタイムとカスタムランタイムを設定できます。
1. **ネイティブランタイム** – サポートされている Lambda ランタイムで Lambda 関数を作成し、 AWS クラウドでネイティブ Lambda ランタイムを使用する関数を構築します。
1. **カスタムランタイム** – 任意のプログラミング言語を使用して Lambda 関数を作成し、esbuild など、makefile やサードパーティービルダーで定義されたカスタムプロセスを使用してランタイムを構築します。詳細については[でのカスタムランタイムを使用した Lambda 関数の構築 AWS SAM](building-custom-runtimes.md)を参照してください。
1. **Lambda パッケージタイプ** – Lambda 関数は、次の Lambda デプロイパッケージタイプにパッケージ化できます。
1. **.zip ファイルアーカイブ** – アプリケーション コードとその依存関係が含まれます。
1. **コンテナイメージ** – 基本オペレーティングシステム、ランタイム、Lambda 拡張機能、アプリケーションコードとその依存関係が含まれています。
これらのアプリケーション設定は、`sam init` を使用してアプリケーションを初期化するときに設定できます。
+ `sam init` の使用の詳細については、「[でアプリケーションを作成する AWS SAM](using-sam-cli-init.md)」を参照してください。
+ アプリケーションでのこれらの設定の詳細については、「[を使用したデフォルトのビルド AWS SAM](serverless-sam-cli-using-build.md)」を参照してください。
**アプリケーションを構築するには**
1. `cd` を実行してプロジェクトのルートに移動します。これは AWS SAM テンプレートと同じ場所です。
```
$ cd sam-app
```
1. 下記を実行します。
```
sam-app $ sam build
```
**注記**
一般的に使用されるオプションは `--use-container` です。詳細については[指定されたコンテナ内における Lambda 関数の構築](#using-sam-cli-build-options-container)を参照してください。
次は AWS SAM CLI 出力の例です。
```
sam-app $ sam build
Starting Build use cache
Manifest file is changed (new hash: 3298f1304...d4d421) or dependency folder (.aws-sam/deps/4d3dfad6-a267-47a6-a6cd-e07d6fae318c) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../sam-app/hello_world runtime: python3.12 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CleanUp
Running PythonPipBuilder:ResolveDependencies
Running PythonPipBuilder:CopySource
Running PythonPipBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
1. AWS SAM CLI は `.aws-sam` ビルドディレクトリを作成します。以下に例を示します。
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ ├── __init__.py
│ │ ├── app.py
│ │ └── requirements.txt
│ └── template.yaml
└── build.toml
```
アプリケーションの設定に応じて、 AWS SAM CLI は次を実行します。
1. `.aws-sam/build` ディレクトリ内の依存関係をダウンロード、インストール、整理します。
1. Lambda コードを準備します。これには、コードのコンパイル、実行可能バイナリの作成、コンテナイメージの構築などが含まれます。
1. ビルドアーティファクトを `.aws-sam` ディレクトリにコピーします。形式はアプリケーションパッケージの種類によって異なります。
1. .zip パッケージタイプの場合、アーティファクトはローカルテストに使用できるようにまだ圧縮されていません。 AWS SAM CLI は、`sam deploy` を使用するときにアプリケーションを圧縮します。
1. コンテナイメージパッケージタイプの場合、コンテナイメージはローカルで作成され、`.aws-sam/build.toml` ファイル内で参照されます。
1. AWS SAM テンプレートを `.aws-sam` ディレクトリにコピーし、必要に応じて新しいファイルパスで変更します。
`.aws-sam` ディレクトリ内のビルドアーティファクトを構成する主要なコンポーネントを次に示します。
+ **ビルドディレクトリ** – Lambda 関数と、互いに独立して構造化されたレイヤーが含まれます。これにより、`.aws-sam/build` ディレクトリ内の各関数またはレイヤー用に固有の構造が作成されます。
+ ** AWS SAM テンプレート** – ビルドプロセス中の変更に基づいて更新された値で変更されました。
+ **build.toml ファイル** – で使用されるビルド設定を含む設定ファイル AWS SAM CLI。
## ローカルでのテストとデプロイ
`sam local` を使用してローカルテストを実行する場合、または `sam deploy` を使用してデプロイを実行する場合、 AWS SAM CLI は次を実行します。
1. まず、 `.aws-sam` ディレクトリが存在するかどうか、および AWS SAM テンプレートがそのディレクトリ内にあるかどうかを確認します。これらの条件が満たされる場合、 AWS SAM CLI はこれをアプリケーションのルートディレクトリとみなします。
1. これらの条件が満たされない場合、 AWS SAM CLI は AWS SAM テンプレートの元の場所をアプリケーションのルートディレクトリと見なします。
開発中、元のアプリケーションファイルに変更が加えられた場合は、ローカルでテストする前に、`sam build` を実行して `.aws-sam` ディレクトリを更新します。
## ベストプラクティス
+ `.aws-sam/build` ディレクトリ内のコードは編集しないでください。代わりに、プロジェクトフォルダ内の元のソースコードを更新し、`sam build` を実行して `.aws-sam/build` ディレクトリを更新します。
+ 元のファイルを変更する場合は、`sam build` を実行して `.aws-sam/build` ディレクトリを更新します。
+ `sam local` を使用して開発およびテストする場合など、 AWS SAM CLI が `.aws-sam` ディレクトリではなくプロジェクトの元のルートディレクトリを参照するようにしたい場合があります。`.aws-sam` ディレクトリまたは`.aws-sam`ディレクトリ内の AWS SAM テンプレートを削除して、 AWS SAM CLIが元のプロジェクトディレクトリをルートプロジェクトディレクトリとして認識するようにします。準備ができたら、再度 `sam build` を実行して `.aws-sam` ディレクトリを作成します。
+ `sam build` を実行すると、`.aws-sam/build` ディレクトリは毎回上書きされます。`.aws-sam` ディレクトリは毎回上書きしません。ログなどのファイルを保存する場合は、上書きされないように `.aws-sam` に保存します。
## sam build のオプション
### 単一のリソースの構築
リソースの論理 ID を指定して、そのリソースのみを構築します。以下に例を示します。
```
$ sam build HelloWorldFunction
```
ネストされたアプリケーションまたはスタックのリソースを構築するには、`/` 形式を使用して、リソースの論理 ID と共に、アプリケーションまたはスタックの論理 ID を指定します。
```
$ sam build MyNestedStack/MyFunction
```
### 指定されたコンテナ内における Lambda 関数の構築
`--use-container` オプションはコンテナイメージをダウンロードし、それを使用して Lambda 関数を構築します。その後、ローカルコンテナが `.aws-sam/build.toml` ファイル内で参照されます。
このオプションでは Docker をインストールする必要があります。手順については、「[Docker のインストール](install-docker.md)」を参照してください。
このコマンドの例を次に示します。
```
$ sam build --use-container
```
`--build-image` オプションで使用するコンテナイメージを指定できます。以下に例を示します。
```
$ sam build --use-container --build-image amazon/aws-sam-cli-build-image-nodejs20.x
```
単一の関数に使用するコンテナイメージを指定するには、関数の論理 ID を指定します。以下に例を示します。
```
$ sam build --use-container --build-image Function1=amazon/aws-sam-cli-build-image-python3.12
```
### 環境変数をビルドコンテナに渡す
`--container-env-var` を使用して、環境変数をビルドコンテナに渡します。以下に例を示します。
```
$ sam build --use-container --container-env-var Function1.GITHUB_TOKEN= --container-env-var GLOBAL_ENV_VAR=
```
ファイルから環境変数を渡すには、`--container-env-var-file` オプションを使用します。以下に例を示します。
```
$ sam build --use-container --container-env-var-file
```
`env.json` ファイルの例:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
### 複数の関数を含むアプリケーションの構築を高速化する
複数の関数を含むアプリケーションで `sam build` を実行する場合、 AWS SAM CLI は各関数を一度に 1 つずつ構築します。構築プロセスを高速化するには、`--parallel` オプションを使用します。これにより、すべての関数とレイヤーが同時に構築されます。
このコマンドの例を次に示します。
```
$ sam build —-parallel
```
### ソースフォルダにプロジェクトを構築することでビルド時間を短縮する
サポートされているランタイムとビルドメソッドについては、`--build-in-source` オプションを使用してプロジェクトをソースフォルダに直接構築できます。デフォルトでは、 は一時ディレクトリに AWS SAM CLIビルドされます。これには、ソースコードとプロジェクトファイルのコピーが含まれます。を使用すると`--build-in-source` AWS SAM 、 はソースフォルダに直接CLIビルドされるため、一時ディレクトリにファイルをコピーする必要がなくなるため、ビルドプロセスが高速化されます。
サポートされているランタイムとビルドメソッドのリストについては、「`--build-in-source`」を参照してください。
## トラブルシューティング
のトラブルシューティングについては AWS SAM CLI、「」を参照してください[AWS SAMCLI トラブルシューティング](sam-cli-troubleshooting.md)。
## 例
### ネイティブランタイムと .zip パッケージタイプを使用するアプリケーションの構築
この例については、「[チュートリアル: を使用して Hello World アプリケーションをデプロイする AWS SAM](serverless-getting-started-hello-world.md)」を参照してください。
### ネイティブランタイムとイメージパッケージタイプを使用するアプリケーションの構築
まず、新しいアプリケーションを初期化するために `sam init` を実行します。インタラクティブなフロー中に、`Image` パッケージタイプを選択します。以下に例を示します。
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
4 - Scheduled task
5 - Standalone function
6 - Data processing
7 - Hello World Example With Powertools
8 - Infrastructure event management
9 - Serverless Connector Hello World Example
10 - Multi-step workflow with Connectors
11 - Lambda EFS example
12 - DynamoDB Example
13 - Machine Learning
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
...
10 - java8
11 - nodejs20.x
12 - nodejs18.x
13 - nodejs16.x
...
Runtime: 12
What package type would you like to use?
1 - Zip
2 - Image
Package type: 2
Based on your selections, the only dependency manager available is npm.
We will proceed copying the template using npm.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Base Image: amazon/nodejs18.x-base
Architectures: x86_64
Dependency Manager: npm
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app/README.md
...
```
はアプリケーションを AWS SAM CLI初期化し、次のプロジェクトディレクトリを作成します。
```
sam-app
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── Dockerfile
│ ├── app.mjs
│ ├── package.json
│ └── tests
│ └── unit
│ └── test-handler.mjs
├── samconfig.toml
└── template.yaml
```
次に、アプリケーションを構築するために `sam build` を実行します。
```
sam-app $ sam build
Building codeuri: /Users/.../build-demo/sam-app runtime: None metadata: {'DockerTag': 'nodejs18.x-v1', 'DockerContext': '/Users/.../build-demo/sam-app/hello-world', 'Dockerfile': 'Dockerfile'} architecture: arm64 functions: HelloWorldFunction
Building image for HelloWorldFunction function
Setting DockerBuildArgs: {} for HelloWorldFunction function
Step 1/4 : FROM public.ecr.aws/lambda/nodejs:18
---> f5b68038c080
Step 2/4 : COPY app.mjs package*.json ./
---> Using cache
---> 834e565aae80
Step 3/4 : RUN npm install
---> Using cache
---> 31c2209dd7b5
Step 4/4 : CMD ["app.lambdaHandler"]
---> Using cache
---> 2ce2a438e89d
Successfully built 2ce2a438e89d
Successfully tagged helloworldfunction:nodejs18.x-v1
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
### コンパイルされたプログラミング言語を含むアプリケーションの構築
この例では、Go ランタイムを使用して Lambda 関数を含むアプリケーションを構築します。
まず、`sam init` を使用して新しいアプリケーションを初期化し、アプリケーションが Go を使用するように設定します。
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
...
4 - dotnetcore3.1
5 - go1.x
6 - go (provided.al2)
...
Runtime: 5
What package type would you like to use?
1 - Zip
2 - Image
Package type: 1
Based on your selections, the only dependency manager available is mod.
We will proceed copying the template using mod.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Runtime: go1.x
Architectures: x86_64
Dependency Manager: mod
Application Template: hello-world
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app-go/README.md
...
```
はアプリケーションを AWS SAM CLI初期化します。アプリケーションのディレクトリ構造の例を次に示します。
```
sam-app
├── Makefile
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── go.mod
│ ├── go.sum
│ ├── main.go
│ └── main_test.go
├── samconfig.toml
└── template.yaml
```
このアプリケーションの要件については、`README.md` ファイルを参照します。
```
...
## Requirements
* AWS CLI already configured with Administrator permission
* [Docker installed](https://www.docker.com/community-edition)
* [Golang](https://golang.org)
* SAM CLI - [Install the SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
...
```
次に、関数をテストするために `sam local invoke` を実行します。Go がローカルマシンにインストールされていないため、このコマンドはエラーになります。
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-go1.x
Building image.................................................................................................................................................................................................................................................
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/hello-world as /var/task:ro,delegated inside runtime container
START RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Version: $LATEST
fork/exec /var/task/hello-world: no such file or directory: PathError
null
END RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31
REPORT RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Init Duration: 0.88 ms Duration: 175.75 ms Billed Duration: 176 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"errorMessage":"fork/exec /var/task/hello-world: no such file or directory","errorType":"PathError"}%
```
次に、アプリケーションを構築するために `sam build` を実行します。Go がローカルマシンにインストールされていないため、エラーが発生しました:
```
sam-app $ sam build
Starting Build use cache
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../Playground/build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Build Failed
Error: GoModulesBuilder:Resolver - Path resolution for runtime: go1.x of binary: go was not successful
```
関数を適切に構築するようにローカルマシンを設定することもできますが、代わりに `sam build` で `--use-container` オプションを使用します。はコンテナイメージ AWS SAM CLIをダウンロードし、ネイティブ GoModulesBuilder を使用して関数を構築し、結果のバイナリを `.aws-sam/build/HelloWorldFunction` ディレクトリにコピーします。
```
sam-app $ sam build --use-container
Starting Build use cache
Starting Build inside a container
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Fetching public.ecr.aws/sam/build-go1.x:latest-x86_64 Docker container image.....................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Mounting /Users/.../build/sam-app/hello-world as /tmp/samcli/source:ro,delegated inside runtime container
Running GoModulesBuilder:Build
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
`.aws-sam` ディレクトリの例を次に示します。
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ └── hello-world
│ └── template.yaml
├── build.toml
├── cache
│ └── c860d011-4147-4010-addb-2eaa289f4d95
│ └── hello-world
└── deps
```
次に、`sam local invoke` を実行します。関数は正常に呼び出されます。
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image is up-to-date
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container
START RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Version: $LATEST
END RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479
REPORT RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Init Duration: 1.20 ms Duration: 1782.46 ms Billed Duration: 1783 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"statusCode":200,"headers":null,"multiValueHeaders":null,"body":"Hello, 72.21.198.67\n"}%
```
## 詳細情報
`sam build` コマンドの使用方法の詳細については、次を参照してください。
+ **[Learning AWS SAM: sam build](https://www.youtube.com/watch?v=fDhYKp4op_g)** – での Serverless Land の「Learning AWS SAM」シリーズYouTube。
+ **[Learning AWS SAM \$1 sam build \$1 E3 ](https://www.youtube.com/watch?v=vsAvRyLnB7Y)** – での Serverless Land の「Learning AWS SAM」シリーズYouTube。
+ **[AWS SAM build: how it provides artifacts for deployment (Sessions with SAM S2E8)](https://www.youtube.com/watch?v=bNbBd6XoDHg)** — Sessions with AWS SAM series on YouTube。
+ **[AWS SAM カスタムビルド: Makefiles を使用して SAM (S2E9) でビルドをカスタマイズする方法](https://www.youtube.com/watch?v=wpccutnSbAk)** – で AWS SAM シリーズを使用するセッションYouTube。
# を使用したデフォルトのビルド AWS SAM
サーバーレスアプリケーションを構築するには、`sam build` コマンドを使用します。このコマンドは、アプリケーションの依存関係のビルドアーティファクトも収集して、ローカルでのテスト、パッケージ化、およびデプロイなどの次のステップのために、それらを適切な形式と場所に設定します。
アプリケーションの依存関係は、マニフェストファイル (`requirements.txt` (Python) または `package.json` (Node.js) など) で指定するか、関数リソースの `Layers` プロパティを使用して指定します。`Layers` プロパティには、Lambda 関数が依存する [AWS Lambda レイヤー](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)リソースのリストが含まれています。
アプリケーションのビルドアーティファクトの形式は、各関数の `PackageType` プロパティに応じて異なります。このプロパティのオプションには次のものがあります。
+ **`Zip`** - アプリケーションコードとその依存関係が含まれる .zip ファイルアーカイブ。コードを .zip ファイルアーカイブとしてパッケージ化する場合は、関数の Lambda ランタイムを指定する必要があります。
+ **`Image`** - アプリケーションコードとその依存関係に加えて、ベースオペレーティングシステム、ランタイム、および拡張機能が含まれているコンテナイメージ。
Lambda パッケージタイプに関する詳細については、*AWS Lambda デベロッパーガイド*の「[Lambda デプロイパッケージ](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html)」を参照してください。
**Topics**
+ [.zip ファイルアーカイブの構築](#build-zip-archive)
+ [コンテナイメージの構築](#build-container-image)
+ [コンテナ環境変数ファイル](#serverless-sam-cli-using-container-environment-file)
+ [ソースフォルダにプロジェクトを構築することでビルド時間を短縮する](#serverless-sam-cli-using-build-in-source)
+ [例](#building-applications-examples)
+ [の外部で関数を構築する AWS SAM](#building-applications-skip)
## .zip ファイルアーカイブの構築
サーバーレスアプリケーションを.zip ファイルアーカイブとして構築するには、サーバーレス関数に `PackageType: Zip` を宣言します。
AWS SAM は、指定した[アーキテクチャ](sam-resource-function.md#sam-function-architectures)用にアプリケーションを構築します。アーキテクチャを指定しない場合、 `x86_64` はデフォルトで AWS SAM を使用します。
ネイティブにコンパイルされたプログラムが含まれるパッケージに Lambda 関数が依存する場合は、`--use-container` フラグを使用します。このフラグは、Lambda 環境のように動作するコンテナで関数をローカルにコンパイルするため、 AWS クラウドにデプロイするときに適切な形式になります。
`--use-container` オプションを使用すると、 はデフォルトで [Amazon ECR Public](https://docs.aws.amazon.com/AmazonECR/latest/public/what-is-ecr.html) からコンテナイメージを AWS SAM プルします。別のリポジトリまたは特定のバージョンの CLI AWS SAM からコンテナイメージをプルする場合は、 `--build-image`オプションを使用して代替コンテナイメージの URI を指定できます。以下は、特定のバージョンの CLI のコンテナイメージを使用してアプリケーションを構築するための 2 AWS SAM つのコマンドの例です。
```
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
```
.zip ファイルアーカイブアプリケーションのその他の構築例については、このトピックの後半にある「例」セクションを参照してください。
## コンテナイメージの構築
サーバーレスアプリケーションをコンテナイメージとして構築するには、サーバーレス関数に `PackageType: Image` を宣言します。また、以下のエントリを使って `Metadata` リソース属性を宣言する必要もあります。
`Dockerfile`
Lambda 関数に関連付けられた Dockerfile の名前。
`DockerContext`
Dockerfile の場所。
`DockerTag`
(オプション) 構築されたイメージに適用するタグ。
`DockerBuildArgs`
ビルド用のビルド引数。
AWS SAM CLI では、`DockerBuildArgs` 引数に含める情報の編集または難読化は行われません。このセクションを使用してパスワードやシークレットなどの機密情報を保存しないことを強くお勧めします。
以下は、`Metadata` リソース属性セクションの例です。
```
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
`Image` パッケージタイプで設定されたサンプルアプリケーションをダウンロードするには、「[チュートリアル: を使用して Hello World アプリケーションをデプロイする AWS SAM](serverless-getting-started-hello-world.md)」を参照してください。インストールしたいパッケージタイプをたずねるプロンプトで、[`Image`] を選択します。
**注記**
Dockerfile でマルチアーキテクチャベースイメージを指定すると、 はホストマシンのアーキテクチャ用のコンテナイメージ AWS SAM を構築します。別のアーキテクチャ用に構築するには、特定のターゲットアーキテクチャを使用するベースイメージを指定します。
## コンテナ環境変数ファイル
ビルドコンテナの環境変数が含まれた JSON ファイルを提供するには、`sam build` コマンドで `--container-env-var-file` 引数を使用します。すべてのサーバーレスリソースに適用される単一の環境変数を提供する、または各リソースに異なる環境変数を提供することができます。
### 形式
環境変数をビルドコンテナに渡す形式は、リソースに提供する環境変数の数に応じて異なります。
すべてのリソースに対して単一の環境変数を提供するには、以下のように `Parameters` オブジェクトを指定します。
```
{
"Parameters": {
"GITHUB_TOKEN": "TOKEN_GLOBAL"
}
}
```
各リソースに異なる環境変数を提供するには、以下のようにリソースごとにオブジェクトを指定します。
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
環境変数をファイル (`env.json` と命名されたファイルなど) として保存します。以下のコマンドは、このファイルを使用して環境変数をビルドコンテナに渡します。
```
sam build --use-container --container-env-var-file env.json
```
### 優先順位
+ すべてのリソースに対する単一の環境変数よりも、特定のリソースに提供する環境変数が優先されます。
+ ファイル内の環境変数よりも、コマンドラインで提供する環境変数が優先されます。
## ソースフォルダにプロジェクトを構築することでビルド時間を短縮する
サポートされているランタイムとビルドメソッドについては、`--build-in-source` オプションを使用してプロジェクトをソースフォルダに直接構築できます。デフォルトでは、 は一時ディレクトリに AWS SAM CLIビルドされます。これには、ソースコードとプロジェクトファイルのコピーが含まれます。を使用すると`--build-in-source` AWS SAM 、 はソースフォルダに直接CLIビルドされるため、一時ディレクトリにファイルをコピーする必要がなくなるため、ビルドプロセスが高速化されます。
サポートされているランタイムとビルドメソッドのリストについては、「`--build-in-source`」を参照してください。
## 例
### 例 1。 .zip ファイルアーカイブ
以下の `sam build` コマンドは、.zip ファイルアーカイブを構築します。
```
# Build all functions and layers, and their dependencies
sam build
# Run the build process inside a Docker container that functions like a Lambda environment
sam build --use-container
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
# Build and run your functions locally
sam build && sam local invoke
# For more options
sam build --help
```
### 例 2: コンテナイメージ
次の AWS SAM テンプレートはコンテナイメージとしてビルドされます。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
PackageType: Image
ImageConfig:
Command: ["app.lambda_handler"]
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
以下は、Dockerfile 例です。
```
FROM public.ecr.aws/lambda/python:3.12
COPY app.py requirements.txt ./
RUN python3.12 -m pip install -r requirements.txt
# Overwrite the command by providing a different command directly in the template.
CMD ["app.lambda_handler"]
```
### 例 3: npm ci
Node.js アプリケーションでは、`npm install`の代わりに、`npm ci`を使用して依存関係をインストールします。`npm ci` を使用するには、Lambda 関数の `Metadata` リソース属性の `BuildProperties` の下に `UseNpmCi: True` を指定します。`npm ci` を使用するには、アプリケーションは Lambda 関数の `CodeUri` に `package-lock.json` または `npm-shrinkwrap.json` ファイルが必要です。
次の例では、`sam build` を実行するときに、`npm ci` を使用して依存関係をインストールします。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.handler
Runtime: nodejs20.x
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Properties:
Path: /hello
Method: get
Metadata:
BuildProperties:
UseNpmCi: True
```
### Python 親パッケージ
Python アプリケーションでは、構築プロセス中にパッケージ構造を保持して絶対インポートを有効にすることができます。パッケージ構造を保持するには、Lambda 関数の `Metadata` リソース属性にある `BuildProperties` で `ParentPackageMode` を指定します。
次の例では、`sam build` を実行するときに `app` パッケージ構造が保持されます。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.main.handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildProperties:
ParentPackageMode: explicit
ParentPackages: app
```
この設定では、コードが `from .utils import logger` のような相対インポートではなく、`from app.utils import logger` のような絶対インポートを使用できます。
## の外部で関数を構築する AWS SAM
デフォルトでは、 を実行すると**sam build**、 はすべての関数リソース AWS SAM を構築します。その他のオプションには以下が含まれます。
+ **の外部ですべての関数リソースを構築する AWS SAM** – すべての関数リソースを手動で構築する場合、または別のツールを使用して構築する場合、 **sam build**は必要ありません。**sam build** をスキップして、ローカルテストの実行やアプリケーションのデプロイなど、プロセスの次のステップに進むことができます。
+ **の外部で一部の関数リソースを構築する AWS SAM** – の外部で他の関数リソース AWS SAM を構築しながら、関数リソースの一部を構築する場合は AWS SAM、 AWS SAM テンプレートで指定できます。
### の外部で一部の関数リソースを構築する AWS SAM
の使用時に で関数を AWS SAM スキップするには**sam build**、 AWS SAM テンプレートで以下を設定します。
1. `SkipBuild: True` メタデータプロパティを関数に追加します。
1. 構築した関数リソースへのパスを指定します。
`TestFunction` がスキップされるように設定した例を次に示します。構築されたリソースは `built-resources/TestFunction.zip` にあります。
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
これで、 を実行すると**sam build**、 AWS SAM は以下を実行します。
1. AWS SAM は、 で設定された関数をスキップします`SkipBuild: True`。
1. AWS SAM は、他のすべての関数リソースをビルドし、`.aws-sam`ビルドディレクトリにキャッシュします。
1. スキップされた関数の場合、`.aws-sam` ビルドディレクトリ内のテンプレートは、構築された関数リソースへの指定されたパスを参照するように自動的に更新されます。
`.aws-sam` ビルドディレクトリの `TestFunction` についてキャッシュされたテンプレートの例を次に示します。
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ../../built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
# でビルドをカスタマイズする AWS SAM
ビルドをカスタマイズして、特定の Lambda 関数または Lambda レイヤーを含めることができます。関数とは、Lambda でコードを実行するために呼び出すことができるリソースです。Lambda レイヤーを使用すると、Lambda 関数からコードを抽出し、複数の Lambda 関数で再利用できます。共有の依存関係やリソースの管理を複雑にすることなく、個々のサーバーレス関数の開発とデプロイに集中する場合は、特定の Lambda 関数を使用してビルドをカスタマイズできます。さらに、デプロイパッケージのサイズを縮小し、コア関数ロジックを依存関係から分離し、複数の関数間で依存関係を共有できるように、Lambda レイヤーを構築することもできます。
このセクションのトピックでは、Lambda 関数を構築するさまざまな方法について説明します AWS SAM。これには、カスタマーランタイムを使用して Lambda 関数を構築し、Lambda レイヤーを構築することが含まれます。カスタムランタイムを使用すると、 AWS Lambda デベロッパーガイドの Lambda ランタイムにリストされていない言語をインストールして使用できます。これにより、サーバーレス関数およびアプリケーションを実行するための特殊な実行環境を作成できます。(アプリケーション全体を構築するのではなく) Lambda レイヤーのみを構築すると、いくつかの点で利点があります。これにより、デプロイパッケージのサイズを縮小し、コア関数ロジックを依存関係から分離し、複数の関数間で依存関係を共有できます。
詳細については、「AWS Lambda デベロッパーガイド」の「[Lambda の概念](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html)」を参照してください。
**Topics**
+ [で esbuild を使用して Node.js Lambda 関数を構築する AWS SAM](serverless-sam-cli-using-build-typescript.md)
+ [でのネイティブ AOT コンパイルを使用した .NET Lambda 関数の構築 AWS SAM](build-dotnet7.md)
+ [Cargo Lambda で を使用して Rust Lambda 関数を構築する AWS SAM](building-rust.md)
+ [uv で を使用して Python Lambda 関数を構築する AWS SAM](building-python-uv.md)
+ [でのカスタムランタイムを使用した Lambda 関数の構築 AWS SAM](building-custom-runtimes.md)
+ [での Lambda レイヤーの構築 AWS SAM](building-layers.md)
# で esbuild を使用して Node.js Lambda 関数を構築する AWS SAM
Node.js AWS Lambda 関数を構築してパッケージ化するには、esbuild AWS SAM CLIJavaScript バンドルャで を使用できます。esbuild バンドラーは TypeScript で記述されて Lambda 関数をサポートします。
esbuild を使用して Node.js Lambda 関数を構築するには、`AWS:Serverless::Function` リソースに `Metadata` オブジェクトを追加し、`BuildMethod` に `esbuild` を指定します。**sam build** コマンドを実行すると、 は esbuild AWS SAM を使用して Lambda 関数コードをバンドルします。
## Metadata プロパティ
`Metadata` オブジェクトは esbuild の以下のプロパティをサポートします。
### BuildMethod
アプリケーションのバンドルを指定します。`esbuild` はサポートされる唯一の値です。
### BuildProperties
Lambda 関数コードの構築プロパティを指定します。
`BuildProperties` オブジェクトは esbuild の以下のプロパティをサポートします。プロパティはすべてオプションです。デフォルトでは、 はエントリポイントに Lambda 関数ハンドラー AWS SAM を使用します。
**EntryPoint**
アプリケーションのエントリポイントを指定します。
**外部**
構築から除外するパッケージのリストを指定します。詳細については、esbuild ウェブサイトの「[External](https://esbuild.github.io/api/#external)」を参照してください。
**形式**
アプリケーションで生成される JavaScript ファイルの出力形式を指定します。詳細については、*esbuild ウェブサイト*で「[Format](https://esbuild.github.io/api/#format)」を参照してください。
**[ローダー]**
特定のファイルタイプのデータをロードするための設定のリストを指定します。
**MainFields**
パッケージを解決する際にインポートを試行する `package.json` フィールドを指定します。デフォルト値は `main,module` です。
**Minify**
バンドルされた出力コードを縮小するかどうかを指定します。デフォルト値は `true` です。
**OutExtension**
esbuild が生成するファイルのファイル拡張子をカスタマイズします。詳細については、*esbuild ウェブサイト*で「[Out extension](https://esbuild.github.io/api/#out-extension)」を参照してください。
**Sourcemap**
バンドラーでソースマップファイルを生成するかどうかを指定します。デフォルト値は `false` です。
`true` に設定すると、`NODE_OPTIONS: --enable-source-maps` が Lambda 関数の環境変数に追加され、ソースマップが生成されて関数に含まれます。
また、`NODE_OPTIONS: --enable-source-maps` が関数の環境変数に含まれると、`Sourcemap` が自動的に `true` に設定されます。
競合する場合、`Sourcemap: false` は `NODE_OPTIONS: --enable-source-maps` より優先されます。
デフォルトでは、Lambda は保存中のすべての環境変数を AWS Key Management Service (AWS KMS) で暗号化します。デプロイを正常に行うには、ソースマップを使用するとき、関数の実行ロールに `kms:Encrypt` アクションを実行するアクセス許可が必要です。
**SourcesContent**
ソースマップファイルにソースコードを含めるかどうかを指定します。`Sourcemap` が `'true'` に設定されている場合、このプロパティを設定します。
+ すべてのソースコードを含めるには `SourcesContent: 'true'` を指定します。
+ すべてのソースコードを除外するには `SourcesContent: 'false'` を指定します。これにより、ソースマップのファイルサイズが小さくなり、起動時間が短縮されるため本番環境で役立ちます。ただし、ソースコードはデバッガーでは使用できません。
デフォルト値は `SourcesContent: true` です。
詳細については、*esbuild ウェブサイト*で「[ソースコンテンツ](https://esbuild.github.io/api/#sources-content)」を参照してください。
**ターゲット**
ターゲットの ECMAScript バージョンを指定します。デフォルト値は `es2020` です。
## TypeScript Lambda 関数の例
次の AWS SAM テンプレートスニペット例では、esbuild を使用して、 の TypeScript コードから Node.js Lambda 関数を作成します`hello-world/app.ts`。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.handler
Runtime: nodejs20.x
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Properties:
Path: /hello
Method: get
Environment:
Variables:
NODE_OPTIONS: --enable-source-maps
Metadata:
BuildMethod: esbuild
BuildProperties:
Format: esm
Minify: false
OutExtension:
- .js=.mjs
Target: "es2020"
Sourcemap: true
EntryPoints:
- app.ts
External:
- ""
```
# でのネイティブ AOT コンパイルを使用した .NET Lambda 関数の構築 AWS SAM
( AWS Serverless Application Model AWS SAM) を使用して .NET 8 AWS Lambda 関数を構築およびパッケージ化し、ネイティブAhead-of-TimeAOT) コンパイルを利用して AWS Lambda コールドスタート時間を短縮します。
**Topics**
+ [.NET 8 ネイティブ AOT の概要](#build-dotnet7-overview)
+ [.NET 8 Lambda 関数 AWS SAM での の使用](#build-dotnet7-sam)
+ [インストール条件](#build-dotnet7-prerequisites)
+ [AWS SAM テンプレートで .NET 8 Lambda 関数を定義する](#build-dotnet7-sam-define)
+ [AWS SAM CLI を使用してアプリケーションを構築する](#build-dotnet7-sam-build)
+ [詳細情報](#build-dotnet7-learn-more)
## .NET 8 ネイティブ AOT の概要
従来の .NET Lambda 関数にはコールドスタート時間があり、それがユーザーエクスペリエンスを損ね、システムのレイテンシーやサーバーレスアプリケーションの使用コストに影響を及ぼしていました。.NET ネイティブ AOT コンパイルを使用すると、Lambda 関数のコールドスタート時間を短縮できます。.NET 8 のネイティブ AOT の詳細については、GitHub の dotnet リポジトリで「[ネイティブ AOT の使用](https://github.com/dotnet/runtime/tree/main/src/coreclr/nativeaot#readme)」を参照してください。
## .NET 8 Lambda 関数 AWS SAM での の使用
AWS Serverless Application Model (AWS SAM) を使用して.NET 8 Lambda 関数を設定するには、次の手順を実行します。
+ 開発マシンに前提条件をインストールする。
+ AWS SAM テンプレートで .NET 8 Lambda 関数を定義します。
+ を使用してアプリケーションを構築します AWS SAM CLI。
## インストール条件
以下がインストールの前提条件となります。
+ AWS SAM CLI「��
+ .NET Core CLI
+ Amazon.Lambda.Tools .NET Core Global Tool
+ Docker
**AWS SAM CLI のインストール**
1. AWS SAM CLI がインストールされているかを確認するには、次のコマンドを実行します。
```
sam --version
```
1. をインストールするには AWS SAM CLI、「」を参照してください[AWS SAM CLI のインストール](install-sam-cli.md)。
1. のインストール済みバージョンをアップグレードするには AWS SAM CLI、「」を参照してください[AWS SAM CLI のアップグレード](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade)。
**.NET Core CLI をインストールする**
1. .NET Core CLI をダウンロードしてインストールするには、Microsoft の Web サイトで「[.NET のダウンロード](https://dotnet.microsoft.com/download)」を参照してください。
1. NET Core CLI の詳細については、「*AWS Lambda デベロッパーガイド*」の「[.NET Core CLI](https://docs.aws.amazon.com/lambda/latest/dg/csharp-package-cli.html)」を参照してください。
**Amazon.Lambda.Tools .NET Core Global Tool をインストールする**
1. 次のコマンドを実行します。
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. ツールがすでにインストールされている場合には、次のコマンドを実行し、最新バージョンを使用していることを確認します。
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Amazon.Lambda.Tools の .NET Core Global Tool の詳細については、GitHub の [AWS Extensions for .NET CLI](https://github.com/aws/aws-extensions-for-dotnet-cli) リポジトリを参照してください。
**Docker をインストールする**
+ ネイティブ AOT を構築に使用するには、Docker をインストールする必要があります。インストール手順については、「[AWS SAM CLI で Docker を使用するためのインストール方法](install-docker.md)」を参照してください。
## AWS SAM テンプレートで .NET 8 Lambda 関数を定義する
AWS SAM テンプレートで .NET8 Lambda 関数を定義するには、次の手順を実行します。
1. 選択した開始ディレクトリから次のコマンドを実行します。
```
sam init
```
1. `AWS Quick Start Templates` を選択して開始テンプレートを選択します。
1. `Hello World Example` テンプレートを選択します。
1. `n` を入力して、最も人気のあるランタイムとパッケージタイプを使用しないことを選択します。
1. ランタイムで、`dotnet8` を選択します。
1. パッケージタイプで、`Zip` を選択します。
1. スターターテンプレートで、`Hello World Example using native AOT` を選択します。
**Docker をインストールする**
+ ネイティブ AOT を構築に使用するには、Docker をインストールする必要があります。インストール手順については、「[AWS SAM CLI で Docker を使用するためのインストール方法](install-docker.md)」を参照してください。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src/HelloWorldAot/
Handler: bootstrap
Runtime: dotnet8
Architectures:
- x86_64
Events:
HelloWorldAot:
Type: Api
Properties:
Path: /hello
Method: get
```
**注記**
の `Event`プロパティ`AWS::Serverless::Function`が に設定されているが`Api`、 `RestApiId`プロパティが指定されていない場合、 は`AWS::ApiGateway::RestApi` CloudFormation リソース AWS SAM を生成します。
## AWS SAM CLI を使用してアプリケーションを構築する
プロジェクトのルートディレクトリから `sam build` コマンドを実行して、アプリケーションの構築を開始します。.NET 8 プロジェクトファイルで `PublishAot` プロパティを定義済みの場合、 AWS SAM CLI はネイティブ AOT コンパイルにより構築されます。`PublishAot` プロパティの詳細については、Microsoft の「*.NET ドキュメント*」で「[ネイティブ AOT デプロイ](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/)」を参照してください。
関数を構築する際、 AWS SAM CLI は Amazon.Lambda.Tools .NET Core Global Tool を使用する .NET Core CLI を呼び出します。
**注記**
構築時にプロジェクトの同じディレクトリか親ディレクトリに `.sln` ファイルが存在する場合、`.sln` ファイルが格納されたディレクトリがコンテナにマウントされます。`.sln` ファイルが見つからない場合は、プロジェクトフォルダだけがマウントされます。そのためマルチプロジェクトアプリケーションを構築する場合は、`.sln` ファイルが存在することを確認してください。
## 詳細情報
.NET 8 Lambda 関数の構築の詳細については、「[AWS Lambdaの .NET 8 ランタイムの紹介](https://aws.amazon.com/blogs/compute/introducing-the-net-8-runtime-for-aws-lambda/)」を参照してください。
**sam build** コマンドのリファレンスについては、「[sam build](sam-cli-command-reference-sam-build.md)」を参照してください。
# Cargo Lambda で を使用して Rust Lambda 関数を構築する AWS SAM
| |
| --- |
| この機能は のプレビューリリースであり AWS SAM 、変更される可能性があります。 |
Rust AWS Lambda 関数で AWS Serverless Application Model コマンドラインインターフェイス (AWS SAM CLI) を使用します。
**Topics**
+ [前提条件](#building-rust-prerequisites)
+ [Rust Lambda 関数で使用する AWS SAM ための の設定](#building-rust-configure)
+ [例](#building-rust-examples)
## 前提条件
**Rust 言語**
Rust をインストールするには、Rust 言語ウェブサイトの「[Rust をインストールする](https://www.rust-lang.org/tools/install)」を参照してください。
**Cargo Lambda**
AWS SAM CLI では、Cargo のサブコマンドである [https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html) のインストールが必要です。インストール手順については、「*Cargo Lambda ドキュメント*」で「[Installation](https://www.cargo-lambda.info/guide/installation.html)」を参照してください。
**Docker**
Rust Lambda 関数の構築とテストには Docker が必要です。インストール手順については、「[Docker のインストール](install-docker.md)」を参照してください。
** AWS SAM CLI ベータ機能にオプトインする**
この機能はプレビュー段階にあるため、次のいずれかの方法を使用してオプトインする必要があります。
1. 次の環境変数を使用します: `SAM_CLI_BETA_RUST_CARGO_LAMBDA=1`。
1. 次のコードを `samconfig.toml` ファイルに追加します。
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. サポートされている AWS SAM CLI のコマンドを使用する場合は、`--beta-features` オプションを使用します。例えば、次のようになります。
```
$ sam build --beta-features
```
1. AWS SAM CLI でオプトインするよう促すプロンプトが表示されたら、オプション `y` を選択します。以下に例を示します。
```
$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Rust Lambda 関数で使用する AWS SAM ための の設定
### ステップ 1: AWS SAM テンプレートを設定する
以下を使用して AWS SAM テンプレートを設定します。
+ **Binary** – オプション。テンプレートに複数の Rust Lambda 関数が含まれる場合に指定します。
+ **BuildMethod** – `rust-cargolambda`。
+ **CodeUri** – `Cargo.toml` ファイルへのパス。
+ **Handler** – `bootstrap`。
+ **Runtime** – `provided.al2`。
カスタムランタイムの詳細については、「 *AWS Lambda デベロッパーガイド*」の[「カスタム AWS Lambda ランタイム](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html)」を参照してください。
設定済み AWS SAM テンプレートの例を次に示します。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties: function_a
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
...
```
### ステップ 2: Rust Lambda 関数で AWS SAM CLI を使用する
AWS SAM テンプレートで任意の AWS SAM CLIコマンドを使用します。詳細については、「[AWS SAM CLI](using-sam-cli.md)」を参照してください。
## 例
### Hello World の例
**この例では、ランタイムとして Rust を使用してサンプルの Hello World アプリケーションを構築します。**
まず、`sam init` を使用して新しいサーバーレスアプリケーションを初期化します。インタラクティブフロー中に、**[Hello World アプリケーション]** を選択し、**[Rust]** ランタイムを選択します。
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
1 - dotnet8
2 - dotnet6
3 - go (provided.al2)
...
18 - python3.11
19 - python3.10
20 - ruby3.3
21 - ruby3.2
22 - rust (provided.al2)
23 - rust (provided.al2023)
Runtime: 22
Based on your selections, the only Package type available is Zip.
We will proceed to selecting the Package type as Zip.
Based on your selections, the only dependency manager available is cargo.
We will proceed copying the template using cargo.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: hello-rust
-----------------------
Generating application:
-----------------------
Name: hello-rust
Runtime: rust (provided.al2)
Architectures: x86_64
Dependency Manager: cargo
Application Template: hello-world
Output Directory: .
Configuration file: hello-rust/samconfig.toml
Next steps can be found in the README file at hello-rust/README.md
Commands you can use next
=========================
[*] Create pipeline: cd hello-rust && sam pipeline init --bootstrap
[*] Validate SAM template: cd hello-rust && sam validate
[*] Test Function in the Cloud: cd hello-rust && sam sync --stack-name {stack-name} --watch
```
Hello World アプリケーションの構造を次に示します。
```
hello-rust
├── README.md
├── events
│ └── event.json
├── rust_app
│ ├── Cargo.toml
│ └── src
│ └── main.rs
├── samconfig.toml
└── template.yaml
```
AWS SAM テンプレートでは、Rust関数は次のように定義されます。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Path: /hello
Method: get
```
次に、`sam build` を実行してアプリケーションを構築し、デプロイの準備をします。 AWS SAM CLI は `.aws-sam` ディレクトリを作成し、そこにビルドアーティファクトを整理します。関数は Cargo Lambda を使用して構築され、実行可能バイナリとして `.aws-sam/build/HelloWorldFunction/bootstrap` に保存されます。
**注記**
MacOS で **sam local invoke** コマンドを実行する予定がある場合は、呼び出す前に関数を別の方法で構築する必要があります。これを行うには、次のコマンドを使用します。
**SAM\$1BUILD\$1MODE=debug sam build**
このコマンドは、ローカルテストが行われる場合にのみ必要です。これは、デプロイ用に構築する場合は推奨されません。
```
hello-rust$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-rust/rust_app runtime: provided.al2 metadata: {'BuildMethod': 'rust-cargolambda'} architecture: x86_64 functions: HelloWorldFunction
Running RustCargoLambdaBuilder:CargoLambdaBuild
Running RustCargoLambdaBuilder:RustCopyAndRename
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
次に、`sam deploy --guided` を使用してアプリケーションをデプロイします。
```
hello-rust$ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [hello-rust]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: ENTER
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
Looking for resources needed for deployment:
...
Uploading to hello-rust/56ba6585d80577dd82a7eaaee5945c0b 817973 / 817973 (100.00%)
Deploying with following values
===============================
Stack name : hello-rust
Region : us-west-2
Confirm changeset : True
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
Uploading to hello-rust/a4fc54cb6ab75dd0129e4cdb564b5e89.template 1239 / 1239 (100.00%)
Waiting for changeset to be created..
CloudFormation stack changeset
---------------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
---------------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHelloW AWS::Lambda::Permission N/A
orldPermissionProd
...
---------------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1681427201/f0ef1563-5ab6-4b07-9361-864ca3de6ad6
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-13 13:07:17 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
---------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
...
---------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
---------------------------------------------------------------------------------------------------------
Outputs
---------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/hello-rust-HelloWorldFunctionRole-10II2P13AUDUY
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:hello-rust-HelloWorldFunction-
yk4HzGzYeZBj
---------------------------------------------------------------------------------------------------------
Successfully created/updated stack - hello-rust in us-west-2
```
テストするには、API エンドポイントを使用して Lambda 関数を呼び出します。
```
$ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Hello World!%
```
関数をローカルでテストするには、まず関数の `Architectures` プロパティがローカルマシンと一致するようにします。
```
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
Metadata:
BuildMethod: rust-cargolambda # More info about Cargo Lambda: https://github.com/cargo-lambda/cargo-lambda
Properties:
CodeUri: ./rust_app # Points to dir of Cargo.toml
Handler: bootstrap # Do not change, as this is the default executable name produced by Cargo Lambda
Runtime: provided.al2
Architectures:
- arm64
...
```
この例ではアーキテクチャを `x86_64` から `arm64` に変更したため、ビルドアーティファクトを更新するために `sam build` を実行します。その後、ローカルで関数を呼び出すために `sam local invoke` を実行します。
```
hello-rust$ sam local invoke
Invoking bootstrap (provided.al2)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-provided.al2
Building image.....................................................................................................................................
Using local image: public.ecr.aws/lambda/provided:al2-rapid-arm64.
Mounting /Users/.../hello-rust/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
START RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Version: $LATEST
{"statusCode":200,"body":"Hello World!"}END RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6
REPORT RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Init Duration: 0.68 ms Duration: 130.63 ms Billed Duration: 131 ms Memory Size: 128 MB Max Memory Used: 128 MB
```
### 単一 Lambda 関数プロジェクト
**1 つの Rust Lambda 関数を含むサーバーレスアプリケーションの例を次に示します。**
プロジェクトのディレクトリ構造:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ └── main.rs
└── template.yaml
```
AWS SAM テンプレート:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
...
```
### 複数の Lambda 関数プロジェクト
**複数の Rust Lambda 関数を含むサーバーレスアプリケーションの例を次に示します。**
プロジェクトのディレクトリ構造:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ ├── function_a.rs
│ └── function_b.rs
└── template.yaml
```
AWS SAM テンプレート:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
FunctionA:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_a
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
FunctionB:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_b
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
```
`Cargo.toml` ファイル:
```
[package]
name = "test-handler"
version = "0.1.0"
edition = "2021"
[dependencies]
lambda_runtime = "0.6.0"
serde = "1.0.136"
tokio = { version = "1", features = ["macros"] }
tracing = { version = "0.1", features = ["log"] }
tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
[[bin]]
name = "function_a"
path = "src/function_a.rs"
[[bin]]
name = "function_b"
path = "src/function_b.rs"
```
# uv で を使用して Python Lambda 関数を構築する AWS SAM
| |
| --- |
| この機能は のプレビューリリースであり AWS SAM 、変更される可能性があります。 |
高速 Python パッケージインストーラおよびリゾルバーuvである で AWS Serverless Application Model コマンドラインインターフェイス (AWS SAM CLI) を使用して、Python AWS Lambda 関数を構築します。
**Topics**
+ [前提条件](#building-python-uv-prerequisites)
+ [Python Lambda 関数と で使用する AWS SAM ように を設定する uv](#building-python-uv-configure)
+ [例](#building-python-uv-examples)
## 前提条件
**Python**
Python をインストールするには、[Python ウェブサイトの「Python のダウンロード](https://www.python.org/downloads/)」を参照してください。 **
**uv**
には[https://docs.astral.sh/uv/](https://docs.astral.sh/uv/)、非常に高速な Python パッケージインストーラおよびリゾルバーである のインストール AWS SAM CLIが必要です。インストール手順については、「*uv ドキュメント*」で「[Installation](https://docs.astral.sh/uv/getting-started/installation/)」を参照してください。
** AWS SAM CLI ベータ機能にオプトインする**
この機能はプレビュー段階にあるため、次のいずれかの方法を使用してオプトインする必要があります。
1. 次の環境変数を使用します: `SAM_CLI_BETA_PYTHON_UV=1`。
1. 次のコードを `samconfig.toml` ファイルに追加します。
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. サポートされている AWS SAM CLI のコマンドを使用する場合は、`--beta-features` オプションを使用します。例えば、次のようになります。
```
$ sam build --beta-features
```
1. AWS SAM CLI でオプトインするよう促すプロンプトが表示されたら、オプション `y` を選択します。以下に例を示します。
```
$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Python Lambda 関数と で使用する AWS SAM ように を設定する uv
### ステップ 1: AWS SAM テンプレートを設定する
以下を使用して AWS SAM テンプレートを設定します。
+ **BuildMethod** – `python-uv`。
+ **CodeUri** – `pyproject.toml`または を含む関数コードディレクトリへのパス`requirements.txt`。
+ **ハンドラー** – 関数ハンドラー (例: `app.lambda_handler`)。
+ **ランタイム** – Python ランタイムバージョン (例: `python3.12`)。
設定済みの AWS SAM テンプレートの例を次に示します。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./my_function
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: python-uv
...
```
## 例
### Hello World の例
**この例では、Python をパッケージマネージャーuvとして使用してサンプル Hello World アプリケーションを構築します。**
uv は、 `pyproject.toml`または `requirements.txt` を使用して依存関係を読み取ることができます。両方が指定されている場合、 `sam build`は依存関係`requirements.txt`の から読み取ります。
Hello World アプリケーションの構造を次に示します。
```
hello-python-uv
├── README.md
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── pyproject.toml
├── samconfig.toml
└── template.yaml
```
`pyproject.toml` ファイル:
```
[project]
name = "my-function"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
"requests>=2.31.0",
"boto3>=1.28.0",
]
```
AWS SAM テンプレートでは、Python 関数は次のように定義されます。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildMethod: python-uv
```
次に、`sam build` を実行してアプリケーションを構築し、デプロイの準備をします。 AWS SAM CLI は `.aws-sam` ディレクトリを作成し、そこにビルドアーティファクトを整理します。関数の依存関係は、 を使用してインストールuvされ、 に保存されます`.aws-sam/build/HelloWorldFunction/`。
```
hello-python-uv$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-python-uv/hello_world runtime: python3.12 metadata: {'BuildMethod': 'python-uv'} architecture: x86_64 functions: HelloWorldFunction
Running PythonUvBuilder:UvBuild
Running PythonUvBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
**注記**
`python-uv` ビルドメソッドは、 `Metadata`セクションの関数ごとに設定されます。テンプレート内の各関数は異なるビルドメソッドを使用できるため、 uvベースの関数を同じ AWS SAM テンプレート内の `pip`ベースの関数と混在させることができます。ビルドメソッドが指定されていない場合は、デフォルトで `pip` が使用されます。
# でのカスタムランタイムを使用した Lambda 関数の構築 AWS SAM
`sam build` コマンドを使用して、Lambda 関数に必要なカスタムランタイムを構築できます。Lambda 関数に `Runtime: provided` を指定することによって、その関数がカスタムランタイムを使用するように宣言します。
カスタムランタイムを構築するには、`BuildMethod: makefile` エントリを使用して `Metadata` リソース属性を宣言します。ユーザーは、ランタイムの build コマンドが含まれた `build-function-logical-id` フォームのビルドターゲットを宣言するカスタム makefile を提供します。Makefile は、必要に応じてカスタムランタイムをコンパイルして、ワークフローにおける後続のステップに必要となる適切な場所にビルドアーティファクトをコピーする責任を担います。Makefile の場所は、関数リソースの `CodeUri` プロパティによって指定され、`Makefile` と命名される必要があります。
## 例
### 例 1: Rust で記述された関数用のカスタムランタイム
**注記**
Cargo Lambda を使用して Lambda 関数を構築することをお勧めします。詳細については[Cargo Lambda で を使用して Rust Lambda 関数を構築する AWS SAM](building-rust.md)を参照してください。
次の AWS SAM テンプレートは、Rust で記述された Lambda 関数にカスタムランタイムを使用する関数を宣言し、`build-HelloRustFunction`ビルドターゲットのコマンドを実行する`sam build`ように に指示します。
```
Resources:
HelloRustFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: HelloRust
Handler: bootstrap.is.real.handler
Runtime: provided
MemorySize: 512
CodeUri: .
Metadata:
BuildMethod: makefile
```
以下の makefile には、ビルドターゲットと実行されるコマンドが含まれています。`CodeUri` プロパティが `.` に設定されていることから、makefile がプロジェクトのルートディレクトリ (つまり、アプリケーションの AWS SAM テンプレートファイルと同じディレクトリ) に置かれている必要があることに注意してください。ファイル名は `Makefile` にする必要があります。
```
build-HelloRustFunction:
cargo build --release --target x86_64-unknown-linux-musl
cp ./target/x86_64-unknown-linux-musl/release/bootstrap $(ARTIFACTS_DIR)
```
上記の `makefile` で `cargo build` コマンドを実行するための開発環境のセットアップに関する詳細については、「[Rust Runtime for AWS Lambda](https://aws.amazon.com/blogs/opensource/rust-runtime-for-aws-lambda/)」ブログ記事を参照してください。
### 例 2: Python 3.12 用の makefile ビルダー (バンドルされたビルダーの代わりに使用)
バンドルされたビルダーに含まれていないライブラリやモジュールを使用したい場合があります。この例では、makefile ビルダーを使用した Python3.12 ランタイムの AWS SAM テンプレートを示しています。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: makefile
```
以下の makefile には、ビルドターゲットと実行されるコマンドが含まれています。`CodeUri` プロパティが `hello_world` に設定されているため、makefile は `hello_world` サブディレクトリのルートに置き、ファイル名を `Makefile` にする必要があることに注意してください。
```
build-HelloWorldFunction:
cp *.py $(ARTIFACTS_DIR)
cp requirements.txt $(ARTIFACTS_DIR)
python -m pip install -r requirements.txt -t $(ARTIFACTS_DIR)
rm -rf $(ARTIFACTS_DIR)/bin
```
# での Lambda レイヤーの構築 AWS SAM
を使用して AWS SAM カスタム Lambda レイヤーを構築できます。Lambda レイヤーを使用すると、Lambda 関数からコードを抽出し、複数の Lambda 関数で再利用できます。(アプリケーション全体を構築するのではなく) Lambda レイヤーのみを構築すると、いくつかの点で利点があります。これにより、デプロイパッケージのサイズを縮小し、コア関数ロジックを依存関係から分離し、複数の関数間で依存関係を共有できます。レイヤーの詳細については、*AWS Lambda デベロッパーガイド*の「[AWS Lambda レイヤー](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)」参照してください。
## で Lambda レイヤーを構築する方法 AWS SAM
**注記**
Lambda レイヤーを構築する前に、まず AWS SAM テンプレートに Lambda レイヤーを記述する必要があります。これを行う方法についての詳細と例については、「[で Lambda レイヤーを使用して効率を向上させる AWS SAM](serverless-sam-cli-layers.md)」を参照してください。
カスタムレイヤーを構築するには、それを AWS Serverless Application Model (AWS SAM) テンプレートファイルに宣言し、`Metadata`リソース属性セクションを`BuildMethod`エントリに含めます。`BuildMethod` に有効な値は、[AWS Lambda ランタイム](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html)の識別子、または `makefile` です。`BuildArchitecture` エントリを含めて、レイヤーがサポートする命令セットアーキテクチャを指定します。`BuildArchitecture` の有効値は、[Lambda 命令セットアーキテクチャ](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html)です。
`makefile` を指定する場合は、レイヤーの build コマンドが含まれた `build-layer-logical-id` フォームのビルドターゲットを宣言するカスタム makefile を提供します。Makefile は、必要に応じてレイヤーをコンパイルして、ワークフローにおける後続のステップに必要となる適切な場所にビルドアーティファクトをコピーする責任を担います。Makefile の場所は、レイヤーリソースの `ContentUri` プロパティによって指定され、`Makefile` と命名される必要があります。
**注記**
カスタムレイヤーを作成すると、 は環境変数 AWS Lambda に応じてレイヤーコードを見つけます。Lambda ランタイムは、レイヤーコードがコピーされた `/opt` ディレクトリにパスを含めます。カスタムレイヤーコードを見つけられるようにするため、プロジェクトのビルドアーティファクトのフォルダ構造が、ランタイムが期待するフォルダ構造と一致している必要があります。
例えば、Python ではコードを `python/` サブディレクトリに置くことができます。NodeJS では、コードを `nodejs/node_modules/` サブディレクトリに置くことができます。
詳細については、*AWS Lambda デベロッパーガイド*の「[ライブラリの依存関係をレイヤーに含める](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-path)」を参照してください。
以下は、`Metadata` リソース属性セクションの例です。
```
Metadata:
BuildMethod: python3.12
BuildArchitecture: arm64
```
**注記**
`Metadata` リソース属性セクションを含めない場合、 AWS SAM はレイヤーを構築しません。その代わりに、レイヤーリソースの `CodeUri` プロパティで指定された場所からビルドアーティファクトをコピーします。詳細については、`AWS::Serverless::LayerVersion` リソースタイプの「[ContentUri](sam-resource-layerversion.md#sam-layerversion-contenturi)」プロパティを参照してください。
`Metadata` リソース属性セクションを含めると、 `sam build` コマンドを使用して、独立したオブジェクトとして、または AWS Lambda 関数の依存関係としてレイヤーを構築できます。
+ ****独立したオブジェクトとして。****レイヤーに対するコード変更をローカルでテストしており、アプリケーション全体を構築する必要がないときなど、レイヤーオブジェクトだけを構築したい場合があります。レイヤーを個別に構築するには、`sam build layer-logical-id` コマンドでレイヤーリソースを指定します。
+ **Lambda 関数の依存関係として。**同じ AWS SAM テンプレートファイルにある Lambda 関数の `Layers` プロパティにレイヤーの論理 ID を含めると、レイヤーはその Lambda 関数の依存関係になります。そのレイヤーに `BuildMethod` エントリがある `Metadata` リソース属性セクションも含める場合は、`sam build` コマンドを使用してアプリケーション全体を構築する、または `sam build function-logical-id` コマンドで関数リソースを指定することによってレイヤーを構築します。
## 例
### テンプレート例 1: Python 3.12 ランタイム環境に対してレイヤーを構築する
次のサンプル AWS SAM テンプレートは、Python 3.12 ランタイム環境に対してレイヤーを構築します。
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: python3.12 # Required to have AWS SAM build this layer
```
### テンプレート例 2: カスタム makefile を使用してレイヤーを構築する
次のサンプル AWS SAM テンプレートでは、カスタム `makefile` を使用してレイヤーを構築します。
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: makefile
```
以下の `makefile` には、ビルドターゲットと実行されるコマンドが含まれています。`ContentUri` プロパティが `my_layer` に設定されているため、makefile は `my_layer` サブディレクトリのルートに置き、ファイル名を `Makefile` にする必要があることに注意してください。また、ビルドアーティファクトは `python/`サブディレクトリにコピーされるため、 AWS Lambda はレイヤーコードを見つけることができます。
```
build-MyLayer:
mkdir -p "$(ARTIFACTS_DIR)/python"
cp *.py "$(ARTIFACTS_DIR)/python"
python -m pip install -r requirements.txt -t "$(ARTIFACTS_DIR)/python"
```
**注記**
`makefile` が呼び出されると、適切なターゲットがトリガーされ、アーティファクトが公開された環境変数 `$ARTIFACTS_DIR` にコピーされます。詳細については、GitHub で「[aws-lambda-builders](https://github.com/aws/aws-lambda-builders/blob/develop/aws_lambda_builders/workflows/custom_make/DESIGN.md)」を参照してください。
### sam build コマンドの例
以下の `sam build` コマンドは、`Metadata` リソース属性セクションが含まれたレイヤーを構築します。
```
# Build the 'layer-logical-id' resource independently
$ sam build layer-logical-id
# Build the 'function-logical-id' resource and layers that this function depends on
$ sam build function-logical-id
# Build the entire application, including the layers that any function depends on
$ sam build
```