Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Membangun aplikasi Anda dengan AWS SAM
Setelah Anda menambahkan infrastruktur sebagai kode (IAc) ke AWS SAM template Anda, Anda akan siap untuk mulai membangun aplikasi Anda menggunakan **sam build** perintah. Perintah ini membuat artefak build dari file di direktori proyek aplikasi Anda (yaitu, file AWS SAM template Anda, kode aplikasi, dan file dan dependensi khusus bahasa yang berlaku). Artefak build ini mempersiapkan aplikasi tanpa server Anda untuk langkah-langkah selanjutnya dari pengembangan aplikasi Anda, seperti pengujian lokal dan penerapan ke Cloud. AWS Baik pengujian maupun penerapan menggunakan artefak build sebagai input.
Anda dapat menggunakan **sam build** untuk membangun seluruh aplikasi tanpa server Anda. Selain itu, Anda dapat membuat build yang disesuaikan, seperti versi dengan fungsi, lapisan, atau runtime khusus tertentu. Untuk membaca lebih lanjut tentang bagaimana dan mengapa Anda menggunakan**sam build**, lihat topik di bagian ini. Untuk pengantar menggunakan `sam build` perintah, lihat[Pengantar bangunan dengan AWS SAM](using-sam-cli-build.md).
**Topics**
+ [Pengantar bangunan dengan AWS SAM](using-sam-cli-build.md)
+ [Membangun default dengan AWS SAM](serverless-sam-cli-using-build.md)
+ [Sesuaikan build dengan AWS SAM](building-lambda-functions.md)
# Pengantar bangunan dengan AWS SAM
Gunakan AWS Serverless Application Model perintah Command Line Interface (AWS SAMCLI) `sam build` untuk mempersiapkan aplikasi tanpa server Anda untuk langkah-langkah selanjutnya dalam alur kerja pengembangan Anda, seperti pengujian lokal atau penerapan ke file. AWS Cloud Perintah ini membuat `.aws-sam` direktori yang menyusun aplikasi Anda dalam format dan lokasi yang `sam local` `sam deploy` dibutuhkan.
+ Untuk pengantar AWS SAMCLI, lihat[Apa itu AWS SAMCLI?](what-is-sam-overview.md#what-is-sam-cli).
+ Untuk daftar opsi `sam build` perintah, lihat[sam build](sam-cli-command-reference-sam-build.md).
+ Untuk contoh penggunaan `sam build` selama alur kerja pengembangan tipikal, lihat[Langkah 2: Bangun aplikasi Anda](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-build).
**catatan**
Menggunakan `sam build` mengharuskan Anda memulai dengan komponen dasar aplikasi tanpa server pada mesin pengembangan Anda. Ini termasuk AWS SAM template, kode AWS Lambda fungsi, dan file dan dependensi khusus bahasa apa pun. Untuk mempelajari selengkapnya, lihat [Buat aplikasi Anda di AWS SAM](using-sam-cli-init.md).
**Topics**
+ [Membangun aplikasi dengan sam build](#using-sam-cli-build-apps)
+ [Pengujian dan penyebaran lokal](#using-sam-cli-build-test-deploy)
+ [Praktik terbaik](#using-sam-cli-build-best)
+ [Opsi untuk sam build](#using-sam-cli-build-options)
+ [Pemecahan masalah](#using-sam-cli-build-troubleshooting)
+ [Contoh](#using-sam-cli-build-examples)
+ [Pelajari selengkapnya](#using-sam-cli-build-learn)
## Membangun aplikasi dengan sam build
Sebelum menggunakan`sam build`, pertimbangkan untuk mengonfigurasi hal berikut:
1. **Fungsi dan lapisan Lambda** — `sam build` Perintah dapat membangun fungsi dan lapisan Lambda. Untuk mempelajari lebih lanjut tentang lapisan Lambda, lihat. [Membangun lapisan Lambda di AWS SAM](building-layers.md)
1. **Lambda runtime** — *Runtime* menyediakan lingkungan khusus bahasa yang menjalankan fungsi Anda di lingkungan eksekusi saat dipanggil. Anda dapat mengonfigurasi runtime asli dan kustom.
1. **Runtime asli** - Buat fungsi Lambda Anda dalam runtime Lambda yang didukung dan buat fungsi Anda untuk menggunakan runtime Lambda asli di. AWS Cloud
1. **Custom runtime** - Buat fungsi Lambda Anda menggunakan bahasa pemrograman apa pun dan buat runtime Anda menggunakan proses kustom yang ditentukan dalam pembuat atau pihak ketiga makefile seperti. esbuild Untuk mempelajari selengkapnya, lihat [Membangun fungsi Lambda dengan runtime khusus di AWS SAM](building-custom-runtimes.md).
1. **Jenis paket Lambda** - Fungsi Lambda dapat dikemas dalam jenis paket penyebaran Lambda berikut:
1. **.zip file archive** - Berisi kode aplikasi Anda dan dependensinya.
1. **Gambar kontainer** - Berisi sistem operasi dasar, runtime, ekstensi Lambda, kode aplikasi Anda dan dependensinya.
Pengaturan aplikasi ini dapat dikonfigurasi saat menginisialisasi aplikasi menggunakan`sam init`.
+ Untuk mempelajari lebih lanjut tentang menggunakan`sam init`, lihat[Buat aplikasi Anda di AWS SAM](using-sam-cli-init.md).
+ Untuk mempelajari lebih lanjut tentang mengonfigurasi setelan ini di aplikasi Anda, lihat[Membangun default dengan AWS SAM](serverless-sam-cli-using-build.md).
**Untuk membangun aplikasi**
1. `cd`ke akar proyek Anda. Ini adalah lokasi yang sama dengan AWS SAM template Anda.
```
$ cd sam-app
```
1. Jalankan hal berikut:
```
sam-app $ sam build
```
**catatan**
Opsi yang umum digunakan adalah`--use-container`. Untuk mempelajari selengkapnya, lihat [Membangun fungsi Lambda di dalam wadah yang disediakan](#using-sam-cli-build-options-container).
Berikut ini adalah contoh dari AWS SAMCLI output:
```
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 SAMCLIMembuat direktori `.aws-sam` build. Berikut ini adalah contohnya:
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ ├── __init__.py
│ │ ├── app.py
│ │ └── requirements.txt
│ └── template.yaml
└── build.toml
```
Tergantung pada bagaimana aplikasi Anda dikonfigurasi, AWS SAMCLI melakukan hal berikut:
1. Mengunduh, menginstal, dan mengatur dependensi di direktori. `.aws-sam/build`
1. Siapkan kode Lambda Anda. Ini dapat mencakup kompilasi kode Anda, membuat binari yang dapat dieksekusi, dan membangun gambar kontainer.
1. Salinan membangun artefak ke `.aws-sam` direktori. Formatnya akan bervariasi berdasarkan jenis paket aplikasi Anda.
1. Untuk jenis paket.zip, artefak belum di-zip sehingga dapat digunakan untuk pengujian lokal. AWS SAMCLIRitsleting aplikasi Anda saat menggunakan`sam deploy`.
1. Untuk jenis paket gambar kontainer, gambar kontainer dibuat secara lokal dan direferensikan dalam file. `.aws-sam/build.toml`
1. Salin AWS SAM template ke `.aws-sam` direktori dan memodifikasinya dengan jalur file baru bila diperlukan.
Berikut ini adalah komponen utama yang membentuk artefak build Anda di `.aws-sam` direktori:
+ **Direktori build** — Berisi fungsi dan lapisan Lambda Anda yang terstruktur secara independen satu sama lain. Ini menghasilkan struktur unik untuk setiap fungsi atau lapisan dalam `.aws-sam/build` direktori.
+ ** AWS SAM Template** — Dimodifikasi dengan nilai yang diperbarui berdasarkan perubahan selama proses pembuatan.
+ File **BUILD.TOLL — File** konfigurasi yang berisi pengaturan build yang digunakan oleh file. AWS SAMCLI
## Pengujian dan penyebaran lokal
Saat melakukan pengujian lokal dengan `sam local` atau penerapan dengan`sam deploy`, AWS SAMCLI melakukan hal berikut:
1. Ini pertama memeriksa untuk melihat apakah `.aws-sam` direktori ada dan apakah AWS SAM template terletak di dalam direktori itu. Jika kondisi ini terpenuhi, AWS SAMCLI menganggap ini sebagai direktori root aplikasi Anda.
1. Jika kondisi ini tidak terpenuhi, AWS SAMCLI menganggap lokasi asli AWS SAM template Anda sebagai direktori root aplikasi Anda.
Saat mengembangkan, jika perubahan dilakukan pada file aplikasi asli Anda, jalankan `sam build` untuk memperbarui `.aws-sam` direktori sebelum menguji secara lokal.
## Praktik terbaik
+ Jangan mengedit kode apa pun di bawah `.aws-sam/build` direktori. Sebagai gantinya, perbarui kode sumber asli Anda di folder proyek Anda dan jalankan `sam build` untuk memperbarui `.aws-sam/build` direktori.
+ Saat Anda memodifikasi file asli Anda, jalankan `sam build` untuk memperbarui `.aws-sam/build` direktori.
+ Anda mungkin AWS SAMCLI ingin mereferensikan direktori root asli proyek Anda alih-alih `.aws-sam` direktori, seperti saat mengembangkan dan menguji dengan`sam local`. Hapus `.aws-sam` direktori atau AWS SAM template dalam `.aws-sam` direktori untuk AWS SAMCLI mengenali direktori proyek asli Anda sebagai direktori proyek root. Saat siap, jalankan `sam build` lagi untuk membuat `.aws-sam` direktori.
+ Ketika Anda menjalankan`sam build`, `.aws-sam/build` direktori akan ditimpa setiap kali. `.aws-sam`Direktori tidak. Jika Anda ingin menyimpan file, seperti log, simpan `.aws-sam` untuk mencegahnya ditimpa.
## Opsi untuk sam build
### Membangun sumber daya tunggal
Berikan ID logis sumber daya untuk hanya membangun sumber daya itu. Berikut ini adalah contohnya:
```
$ sam build HelloWorldFunction
```
Untuk membangun sumber daya aplikasi atau tumpukan bersarang, berikan ID logis aplikasi atau tumpukan bersama dengan ID logis sumber daya menggunakan format`/`:
```
$ sam build MyNestedStack/MyFunction
```
### Membangun fungsi Lambda di dalam wadah yang disediakan
`--use-container`Opsi mengunduh gambar kontainer dan menggunakannya untuk membangun fungsi Lambda Anda. Wadah lokal kemudian direferensikan dalam `.aws-sam/build.toml` file Anda.
Opsi ini Docker harus diinstal. Untuk petunjuk, lihat [Menginstal Docker](install-docker.md).
Berikut ini adalah contoh dari perintah ini:
```
$ sam build --use-container
```
Anda dapat menentukan gambar kontainer yang akan digunakan dengan `--build-image` opsi. Berikut ini adalah contohnya:
```
$ sam build --use-container --build-image amazon/aws-sam-cli-build-image-nodejs20.x
```
Untuk menentukan gambar kontainer yang akan digunakan untuk satu fungsi, berikan fungsi ID logis. Berikut ini adalah contohnya:
```
$ sam build --use-container --build-image Function1=amazon/aws-sam-cli-build-image-python3.12
```
### Teruskan variabel lingkungan ke wadah build
Gunakan `--container-env-var` untuk meneruskan variabel lingkungan ke wadah build. Berikut ini adalah contohnya:
```
$ sam build --use-container --container-env-var Function1.GITHUB_TOKEN= --container-env-var GLOBAL_ENV_VAR=
```
Untuk meneruskan variabel lingkungan dari file, gunakan `--container-env-var-file` opsi. Berikut ini adalah contohnya:
```
$ sam build --use-container --container-env-var-file
```
Contoh `env.json` file:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
### Mempercepat pembangunan aplikasi yang berisi banyak fungsi
Ketika Anda menjalankan `sam build` aplikasi dengan beberapa fungsi, AWS SAMCLI membangun setiap fungsi satu per satu. Untuk mempercepat proses pembuatan, gunakan `--parallel` opsi. Ini membangun semua fungsi dan lapisan Anda secara bersamaan.
Berikut ini adalah contoh dari perintah ini:
```
$ sam build —-parallel
```
### Mempercepat waktu pembuatan dengan membangun proyek Anda di folder sumber
Untuk runtime dan metode build yang didukung, Anda dapat menggunakan `--build-in-source` opsi untuk membangun proyek secara langsung di folder sumber. Secara default, AWS SAM CLI build dalam direktori sementara, yang melibatkan penyalinan kode sumber dan file proyek. Dengan`--build-in-source`, AWS SAM CLI build langsung di folder sumber Anda, yang mempercepat proses pembuatan dengan menghapus kebutuhan untuk menyalin file ke direktori sementara.
Untuk daftar runtime dan metode build yang didukung, lihat`--build-in-source`.
## Pemecahan masalah
Untuk memecahkan masalah AWS SAMCLI, lihat. [AWS SAMCLIpemecahan masalah](sam-cli-troubleshooting.md)
## Contoh
### Membangun aplikasi yang menggunakan runtime asli dan tipe paket.zip
Untuk contoh ini, lihat[Tutorial: Menyebarkan aplikasi Hello World dengan AWS SAM](serverless-getting-started-hello-world.md).
### Membangun aplikasi yang menggunakan runtime asli dan tipe paket gambar
Pertama, kita jalankan `sam init` untuk menginisialisasi aplikasi baru. Selama aliran interaktif, kami memilih jenis `Image` paket. Berikut ini adalah contohnya:
```
$ 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 SAMCLIMenginisialisasi aplikasi dan membuat direktori proyek berikut:
```
sam-app
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── Dockerfile
│ ├── app.mjs
│ ├── package.json
│ └── tests
│ └── unit
│ └── test-handler.mjs
├── samconfig.toml
└── template.yaml
```
Selanjutnya, kami menjalankan `sam build` untuk membangun aplikasi kami:
```
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
```
### Membangun aplikasi yang mencakup bahasa pemrograman yang dikompilasi
Dalam contoh ini, kita membangun sebuah aplikasi yang berisi fungsi Lambda menggunakan runtime. Go
Pertama, kami menginisialisasi aplikasi baru menggunakan `sam init` dan mengonfigurasi aplikasi kami untuk digunakanGo:
```
$ 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 SAMCLIMenginisialisasi aplikasi. Berikut ini adalah contoh struktur direktori aplikasi:
```
sam-app
├── Makefile
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── go.mod
│ ├── go.sum
│ ├── main.go
│ └── main_test.go
├── samconfig.toml
└── template.yaml
```
Kami mereferensikan `README.md` file untuk persyaratan aplikasi ini.
```
...
## 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)
...
```
Selanjutnya, kita jalankan `sam local invoke` untuk menguji fungsi kita. Kesalahan perintah ini sejak Go tidak diinstal pada mesin lokal kami:
```
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"}%
```
Selanjutnya, kita jalankan `sam build` untuk membangun aplikasi kita. Kami menemukan kesalahan karena Go tidak diinstal pada mesin lokal kami:
```
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
```
Meskipun kami dapat mengonfigurasi mesin lokal kami untuk membangun fungsi kami dengan benar, kami malah menggunakan `--use-container` opsi dengan`sam build`. AWS SAMCLIDownload gambar kontainer, membangun fungsi kita menggunakan native GoModulesBuilder, dan menyalin biner yang dihasilkan ke `.aws-sam/build/HelloWorldFunction` direktori kita.
```
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
```
Berikut ini adalah contoh `.aws-sam` direktori:
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ └── hello-world
│ └── template.yaml
├── build.toml
├── cache
│ └── c860d011-4147-4010-addb-2eaa289f4d95
│ └── hello-world
└── deps
```
Selanjutnya, kita lari`sam local invoke`. Fungsi kami berhasil dipanggil:
```
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"}%
```
## Pelajari selengkapnya
Untuk mempelajari lebih lanjut tentang menggunakan `sam build` perintah, lihat berikut ini:
+ **[Pembelajaran AWS SAM: sam build](https://www.youtube.com/watch?v=fDhYKp4op_g)** — Seri “Pembelajaran AWS SAM” Tanah Tanpa Server aktif. YouTube
+ **[Belajar AWS SAM \$1 sam build \$1 E3 — Seri](https://www.youtube.com/watch?v=vsAvRyLnB7Y)** “Pembelajaran AWS SAM” Tanah Tanpa Server di. YouTube
+ **[AWS SAM build: bagaimana menyediakan artefak untuk penerapan (Sesi Dengan SAM S2E8) — Sesi](https://www.youtube.com/watch?v=bNbBd6XoDHg)** dengan seri aktif. AWS SAM YouTube
+ **[AWS SAM build kustom: Cara menggunakan Makefiles untuk menyesuaikan build di SAM (S2E9) - Sesi](https://www.youtube.com/watch?v=wpccutnSbAk)** dengan seri aktif. AWS SAM YouTube
# Membangun default dengan AWS SAM
Untuk membangun aplikasi nirserver Anda, gunakan perintah `sam build`. Perintah ini juga mengumpulkan artefak bangunan dependensi aplikasi Anda dan menempatkannya dalam format dan lokasi yang tepat untuk langkah berikutnya, seperti pengujian lokal, pengemasan, dan deployment.
Anda menentukan dependensi aplikasi dalam file manifes, seperti `requirements.txt` (Python) atau `package.json` (Node.js), atau dengan menggunakan properti `Layers` dari sumber daya fungsi. Properti `Layers` berisi daftar sumber daya [lapisan AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) yang fungsi Lambda-nya bergantung pada lapisan tersebut.
Format artefak bangunan aplikasi Anda bergantung pada setiap fungsi properti `PackageType`. Opsi untuk properti ini adalah:
+ **`Zip`** - Arsip file .zip yang berisi kode aplikasi Anda dan dependensinya. Jika Anda mengemas kode Anda sebagai arsip file .zip, Anda harus menentukan waktu aktif Lambda untuk fungsi Anda.
+ **`Image`** – Citra kontainer termasuk sistem operasi dasar, waktu aktif, dan ekstensi, selain kode aplikasi Anda dan dependensinya.
Untuk informasi selengkapnya tentang tipe paket Lambda, lihat [Paket deployment Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) di *Panduan Developer AWS Lambda *.
**Topics**
+ [Membangun arsip file .zip](#build-zip-archive)
+ [Membangun citra kontainer](#build-container-image)
+ [File variabel lingkungan kontainer](#serverless-sam-cli-using-container-environment-file)
+ [Mempercepat waktu pembuatan dengan membangun proyek Anda di folder sumber](#serverless-sam-cli-using-build-in-source)
+ [Contoh](#building-applications-examples)
+ [Membangun fungsi di luar AWS SAM](#building-applications-skip)
## Membangun arsip file .zip
Untuk membangun aplikasi nirserver Anda sebagai arsip file .zip, nyatakan `PackageType: Zip` untuk fungsi nirserver Anda.
AWS SAM membangun aplikasi Anda untuk [arsitektur](sam-resource-function.md#sam-function-architectures) yang Anda tentukan. Jika Anda tidak menentukan arsitektur, AWS SAM gunakan secara `x86_64` default.
Jika fungsi Lambda Anda bergantung pada paket yang telah dikompilasi secara native, gunakan bendera `--use-container`. Bendera ini secara lokal mengompilasi fungsi Anda dalam wadah yang berperilaku seperti lingkungan Lambda, sehingga mereka berada dalam format yang tepat saat Anda menerapkannya ke Cloud. AWS
Saat Anda menggunakan `--use-container` opsi, secara default AWS SAM menarik gambar kontainer dari [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/public/what-is-ecr.html) Public. Jika Anda ingin menarik gambar kontainer dari repositori lain atau untuk versi AWS SAM CLI tertentu, Anda dapat menggunakan `--build-image` opsi dan memberikan URI gambar kontainer alternatif. Berikut adalah dua contoh perintah untuk membangun aplikasi menggunakan gambar kontainer dari versi AWS SAM CLI tertentu:
```
# 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
```
Untuk contoh tambahan membangun aplikasi arsip file .zip, nanti Anda dapat melihatnya di bagian Contoh dalam topik ini.
## Membangun citra kontainer
Untuk membangun aplikasi nirserver Anda sebagai citra kontainer, nyatakan `PackageType: Image` untuk fungsi nirserver Anda. Anda juga harus menyatakan atribut sumber daya `Metadata` dengan entri berikut:
`Dockerfile`
Nama Dockerfile yang berkaitan dengan fungsi Lambda.
`DockerContext`
Lokasi Dockerfile.
`DockerTag`
(Opsional) tanda untuk diterapkan pada citra yang dibangun.
`DockerBuildArgs`
Bangun argumen untuk bangunan tersebut.
AWS SAMCLIItu tidak menyunting atau mengaburkan informasi apa pun yang Anda sertakan dalam argumen. `DockerBuildArgs` Kami sangat menyarankan Anda tidak menggunakan bagian ini untuk menyimpan informasi sensitif, seperti sandi atau rahasia.
Berikut ini adalah contoh bagian atribut sumber daya `Metadata`:
```
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
Untuk mengunduh contoh aplikasi yang dikonfigurasi dengan jenis `Image` paket, lihat[Tutorial: Menyebarkan aplikasi Hello World dengan AWS SAM](serverless-getting-started-hello-world.md). Saat prompt mempertanyakan tipe paket yang ingin Anda instal, pilih `Image`.
**catatan**
Jika Anda menentukan image dasar multi-arsitektur di Dockerfile Anda, AWS SAM buat image container Anda untuk arsitektur mesin host Anda. Untuk membangun arsitektur yang berbeda, tentukan gambar dasar yang menggunakan arsitektur target tertentu.
## File variabel lingkungan kontainer
Untuk menyediakan file JSON yang berisi variabel lingkungan untuk kontainer bangunan, gunakan argumen `--container-env-var-file` dengan perintah `sam build`. Anda dapat memberikan variabel lingkungan tunggal yang berlaku untuk semua sumber daya nirserver, atau variabel lingkungan yang berbeda untuk setiap sumber daya.
### Format
Format untuk meneruskan variabel lingkungan ke kontainer bangunan tergantung pada berapa banyak variabel lingkungan yang Anda berikan untuk sumber daya Anda.
Untuk menyediakan variabel lingkungan tunggal pada semua sumber daya, tentukan objek `Parameters` seperti berikut:
```
{
"Parameters": {
"GITHUB_TOKEN": "TOKEN_GLOBAL"
}
}
```
Untuk menyediakan variabel lingkungan yang berbeda pada setiap sumber daya, tentukan objek untuk setiap sumber daya seperti berikut:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
Simpan variabel lingkungan Anda sebagai file, misalnya, dengan nama `env.json`. Perintah berikut ini menggunakan file ini untuk meneruskan variabel lingkungan Anda ke kontainer bangunan:
```
sam build --use-container --container-env-var-file env.json
```
### Precedence
+ Variabel lingkungan yang Anda berikan untuk sumber daya tertentu lebih diutamakan daripada variabel lingkungan tunggal untuk semua sumber daya.
+ Variabel lingkungan yang Anda berikan pada baris perintah lebih diutamakan daripada variabel lingkungan dalam sebuah file.
## Mempercepat waktu pembuatan dengan membangun proyek Anda di folder sumber
Untuk runtime dan metode build yang didukung, Anda dapat menggunakan `--build-in-source` opsi untuk membangun proyek secara langsung di folder sumber. Secara default, AWS SAM CLI build dalam direktori sementara, yang melibatkan penyalinan kode sumber dan file proyek. Dengan`--build-in-source`, AWS SAM CLI build langsung di folder sumber Anda, yang mempercepat proses pembuatan dengan menghapus kebutuhan untuk menyalin file ke direktori sementara.
Untuk daftar runtime dan metode build yang didukung, lihat`--build-in-source`.
## Contoh
### Contoh 1: Arsip file .zip
Perintah `sam build` berikut membangun arsip file .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
```
### Contoh 2: Citra kontainer
AWS SAM Template berikut dibangun sebagai gambar kontainer:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
PackageType: Image
ImageConfig:
Command: ["app.lambda_handler"]
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
Berikut ini adalah contoh 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"]
```
### Contoh 3: npm ci
Untuk aplikasi Node.js, Anda dapat menggunakan `npm ci` alih-alih `npm install` menginstal dependensi. Untuk menggunakan`npm ci`, tentukan `UseNpmCi: True` `BuildProperties` di bawah atribut `Metadata` sumber daya fungsi Lambda Anda. Untuk menggunakannya`npm ci`, aplikasi Anda harus memiliki `npm-shrinkwrap.json` file `package-lock.json` atau yang ada di fungsi `CodeUri` untuk Lambda Anda.
Contoh berikut digunakan `npm ci` untuk menginstal dependensi saat Anda menjalankan: `sam build`
```
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
```
### Paket induk Python
Untuk aplikasi Python, Anda dapat mempertahankan struktur paket Anda selama proses build untuk mengaktifkan impor absolut. Untuk mempertahankan struktur paket, tentukan `ParentPackageMode` `BuildProperties` di bawah atribut `Metadata` sumber daya fungsi Lambda Anda.
Contoh berikut mempertahankan struktur `app` paket saat Anda menjalankan`sam build`:
```
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
```
Dengan konfigurasi ini, kode Anda dapat menggunakan impor absolut seperti `from app.utils import logger` alih-alih impor relatif seperti. `from .utils import logger`
## Membangun fungsi di luar AWS SAM
Secara default, saat Anda menjalankan**sam build**, AWS SAM membangun semua sumber daya fungsi Anda. Pilihan lain termasuk:
+ **Membangun semua sumber daya fungsi di luar AWS SAM** — Jika Anda membangun semua sumber daya fungsi Anda secara manual atau melalui alat lain, tidak **sam build** diperlukan. Anda dapat melewati **sam build** dan melanjutkan ke langkah berikutnya dalam proses Anda, seperti melakukan pengujian lokal atau menerapkan aplikasi Anda.
+ **Bangun beberapa sumber daya fungsi di luar AWS SAM** — Jika Anda AWS SAM ingin membangun beberapa sumber daya fungsi Anda sambil memiliki sumber daya fungsi lain yang dibangun di luar AWS SAM, Anda dapat menentukan ini di AWS SAM template Anda.
### Membangun beberapa sumber daya fungsi di luar AWS SAM
Untuk AWS SAM melewatkan fungsi saat menggunakan**sam build**, konfigurasikan yang berikut ini di AWS SAM template Anda:
1. Tambahkan properti `SkipBuild: True` metadata ke fungsi Anda.
1. Tentukan jalur ke sumber daya fungsi bawaan Anda.
Berikut adalah contoh, dengan `TestFunction` dikonfigurasi untuk dilewati. Sumber daya yang dibangun terletak di`built-resources/TestFunction.zip`.
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
Sekarang, ketika Anda menjalankan**sam build**, AWS SAM akan melakukan hal berikut:
1. AWS SAM akan melewati fungsi yang dikonfigurasi dengan`SkipBuild: True`.
1. AWS SAM akan membangun semua sumber daya fungsi lainnya dan menyimpannya di direktori `.aws-sam` build.
1. Untuk fungsi yang dilewati, templatnya di direktori `.aws-sam` build akan diperbarui secara otomatis untuk mereferensikan jalur yang ditentukan ke sumber daya fungsi bawaan Anda.
Berikut adalah contoh template cache untuk `TestFunction` di direktori `.aws-sam` build:
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ../../built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
# Sesuaikan build dengan AWS SAM
Anda dapat menyesuaikan build Anda untuk menyertakan fungsi Lambda tertentu atau lapisan Lambda. Fungsi adalah sumber daya yang dapat Anda panggil untuk menjalankan kode Anda di Lambda. Lapisan Lambda memungkinkan Anda mengekstrak kode dari fungsi Lambda yang kemudian dapat digunakan kembali di beberapa fungsi Lambda. Anda dapat memilih untuk menyesuaikan build Anda dengan fungsi Lambda tertentu ketika Anda ingin fokus pada pengembangan dan penerapan fungsi tanpa server individual tanpa kerumitan mengelola dependensi atau sumber daya bersama. Selain itu, Anda dapat memilih untuk membangun lapisan Lambda untuk membantu Anda mengurangi ukuran paket penerapan Anda, memisahkan logika fungsi inti dari dependensi, dan memungkinkan Anda untuk berbagi dependensi di beberapa fungsi.
Topik di bagian ini mengeksplorasi beberapa cara berbeda yang dapat Anda gunakan untuk membangun fungsi Lambda. AWS SAM Ini termasuk membangun fungsi Lambda dengan runtime pelanggan dan membangun lapisan Lambda. Runtime kustom memungkinkan Anda menginstal dan menggunakan bahasa yang tidak tercantum dalam runtime Lambda di Panduan Pengembang. AWS Lambda Ini memungkinkan Anda membuat lingkungan eksekusi khusus untuk menjalankan fungsi dan aplikasi tanpa server. Membangun hanya lapisan Lambda (alih-alih membangun seluruh aplikasi Anda) dapat menguntungkan Anda dalam beberapa cara. Ini dapat membantu Anda mengurangi ukuran paket penerapan Anda, memisahkan logika fungsi inti dari dependensi, dan memungkinkan Anda untuk berbagi dependensi di beberapa fungsi.
Untuk informasi selengkapnya tentang fungsi, lihat [Konsep Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html) di Panduan *AWS Lambda Pengembang*.
**Topics**
+ [Membangun fungsi Lambda Node.js dengan esbuild di AWS SAM](serverless-sam-cli-using-build-typescript.md)
+ [Membangun fungsi.NET Lambda dengan kompilasi AOT Asli di AWS SAM](build-dotnet7.md)
+ [Membangun fungsi Lambda Karat dengan in Cargo Lambda AWS SAM](building-rust.md)
+ [Membangun fungsi Lambda Python dengan in uv AWS SAM](building-python-uv.md)
+ [Membangun fungsi Lambda dengan runtime khusus di AWS SAM](building-custom-runtimes.md)
+ [Membangun lapisan Lambda di AWS SAM](building-layers.md)
# Membangun fungsi Lambda Node.js dengan esbuild di AWS SAM
Untuk membangun dan mengemas AWS Lambda fungsi Node.js, Anda dapat menggunakan AWS SAMCLI JavaScript bundler dengan esbuild. Bundler esbuild mendukung fungsi Lambda yang Anda tulis. TypeScript
Untuk membangun fungsi Lambda Node.js dengan esbuild, tambahkan `Metadata` objek ke `AWS:Serverless::Function` sumber daya Anda dan tentukan `esbuild` untuk. `BuildMethod` Saat Anda menjalankan **sam build** perintah, AWS SAM gunakan esbuild untuk menggabungkan kode fungsi Lambda Anda.
## Properti metadata
`Metadata`Objek mendukung properti berikut untuk esbuild.
### BuildMethod
Menentukan bundler untuk aplikasi Anda. Satu-satunya nilai yang di-support adalah `esbuild`.
### BuildProperties
Menentukan properti build untuk kode fungsi Lambda Anda.
`BuildProperties`Objek mendukung properti berikut untuk esbuild. Semua properti adalah opsional. Secara default, AWS SAM gunakan penangan fungsi Lambda Anda untuk titik masuk.
**EntryPoints**
Menentukan titik masuk untuk aplikasi Anda.
**Eksternal**
Menentukan daftar paket untuk menghilangkan dari build. Untuk informasi lebih lanjut, lihat [Eksternal](https://esbuild.github.io/api/#external) di *esbuildsitus web*.
**Format**
Menentukan format output dari JavaScript file yang dihasilkan dalam aplikasi Anda. Untuk informasi selengkapnya, lihat [Format](https://esbuild.github.io/api/#format) di *situs web esbuild*.
**Loader**
Menentukan daftar konfigurasi untuk memuat data untuk jenis file tertentu.
**MainFields**
Menentukan `package.json` bidang untuk mencoba mengimpor ketika menyelesaikan paket. Nilai default-nya adalah `main,module`.
**Mengecilkan**
Menentukan apakah untuk mengecilkan kode output dibundel. Nilai default-nya adalah `true`.
**OutExtension**
Kustomisasi ekstensi file dari file yang dihasilkan esBUILD. Untuk informasi lebih lanjut, lihat [Ekstensi keluar](https://esbuild.github.io/api/#out-extension) di *situs web esbuild*.
**Peta sumber**
Menentukan apakah bundler menghasilkan file peta sumber. Nilai default-nya adalah `false`.
Ketika diatur ke`true`, `NODE_OPTIONS: --enable-source-maps` ditambahkan ke variabel lingkungan fungsi Lambda, dan peta sumber dihasilkan dan disertakan dalam fungsi.
Atau, ketika `NODE_OPTIONS: --enable-source-maps` disertakan dalam variabel lingkungan fungsi, secara otomatis `Sourcemap` diatur ke`true`.
Saat berkonflik, lebih `Sourcemap: false` diutamakan. `NODE_OPTIONS: --enable-source-maps`
Secara default, Lambda mengenkripsi semua variabel lingkungan saat istirahat dengan (). AWS Key Management Service AWS KMS Saat menggunakan peta sumber, agar penerapan berhasil, peran eksekusi fungsi Anda harus memiliki izin untuk melakukan `kms:Encrypt` tindakan.
**SourcesContent**
Menentukan apakah akan menyertakan kode sumber Anda dalam file peta sumber Anda. Konfigurasikan properti ini saat `Sourcemap` disetel ke`'true'`.
+ Tentukan `SourcesContent: 'true'` untuk menyertakan semua kode sumber.
+ Tentukan `SourcesContent: 'false'` untuk mengecualikan semua kode sumber. Ini menghasilkan ukuran file peta sumber yang lebih kecil, yang berguna dalam produksi dengan mengurangi waktu start-up. Namun, kode sumber tidak akan tersedia di debugger.
Nilai default-nya adalah `SourcesContent: true`.
Untuk informasi selengkapnya, lihat [Konten sumber](https://esbuild.github.io/api/#sources-content) di *situs web esbuild*.
**Target**
Menentukan ECMAScript versi target. Nilai default-nya adalah `es2020`.
## TypeScript Contoh fungsi Lambda
Contoh cuplikan AWS SAM template berikut menggunakan esbuild untuk membuat fungsi Lambda Node.js dari kode di. TypeScript `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:
- ""
```
# Membangun fungsi.NET Lambda dengan kompilasi AOT Asli di AWS SAM
Bangun dan kemas AWS Lambda fungsi.NET 8 Anda dengan AWS Serverless Application Model (AWS SAM), menggunakan kompilasi Native Ahead-of-Time (AOT) untuk meningkatkan waktu mulai AWS Lambda dingin.
**Topics**
+ [.NET 8 Ikhtisar AOT asli](#build-dotnet7-overview)
+ [Menggunakan AWS SAM dengan fungsi.NET 8 Lambda](#build-dotnet7-sam)
+ [Instal prasyarat](#build-dotnet7-prerequisites)
+ [Tentukan fungsi.NET 8 Lambda di template Anda AWS SAM](#build-dotnet7-sam-define)
+ [Membangun aplikasi Anda dengan AWS SAMCLI](#build-dotnet7-sam-build)
+ [Pelajari selengkapnya](#build-dotnet7-learn-more)
## .NET 8 Ikhtisar AOT asli
Secara historis, fungsi.NET Lambda memiliki waktu mulai dingin yang memengaruhi pengalaman pengguna, latensi sistem, dan biaya penggunaan aplikasi tanpa server Anda. Dengan kompilasi .NET Native AOT, Anda dapat meningkatkan waktu mulai dingin dari fungsi Lambda Anda. Untuk mempelajari lebih lanjut tentang Native AOT untuk.NET 8, lihat [Menggunakan AOT Asli](https://github.com/dotnet/runtime/tree/main/src/coreclr/nativeaot#readme) di repositori * GitHub Dotnet*.
## Menggunakan AWS SAM dengan fungsi.NET 8 Lambda
Lakukan hal berikut untuk mengonfigurasi fungsi.NET 8 Lambda Anda dengan AWS Serverless Application Model ()AWS SAM:
+ Instal prasyarat pada mesin pengembangan Anda.
+ Tentukan fungsi.NET 8 Lambda di template Anda AWS SAM .
+ Bangun aplikasi Anda dengan AWS SAMCLI.
## Instal prasyarat
Berikut ini adalah prasyarat yang diperlukan:
+ The AWS SAMCLI
+ CLI INTI .NET
+ Alat Global Inti Amazon.Lambda.Tools .NET
+ Docker
**Instal AWS SAMCLI**
1. Untuk memeriksa apakah Anda sudah AWS SAMCLI menginstal, jalankan yang berikut ini:
```
sam --version
```
1. Untuk menginstal AWS SAMCLI, lihat[Instal AWS SAMCLI](install-sam-cli.md).
1. Untuk memutakhirkan versi terinstal AWS SAMCLI, lihat[Upgrade AWS SAMCLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade).
**Instal CLI CLI.NET**
1. Untuk mengunduh dan menginstal .NET Core CLI, lihat [Mengunduh.NET](https://dotnet.microsoft.com/download) dari situs web Microsoft.
1. *Untuk informasi selengkapnya tentang.NET Core CLI, lihat [.NET Core CLI](https://docs.aws.amazon.com/lambda/latest/dg/csharp-package-cli.html) di Panduan Pengembang.AWS Lambda *
**Instal Amazon.Lambda.Tools .NET Core Global Tool**
1. Jalankan perintah berikut:
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. Jika Anda sudah menginstal alat tersebut, Anda dapat memastikan alat tersebut menggunakan versi terbaru dengan perintah berikut.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Untuk informasi selengkapnya tentang Amazon.Lambda.Tools .NET Core Global Tool, lihat Extensions [AWS for](https://github.com/aws/aws-extensions-for-dotnet-cli) .NET CLI repositori.NET di. GitHub
**Instal Docker**
+ Membangun dengan Native AOT, Docker harus diinstal. Untuk instruksi instalasi, lihat [Menginstal Docker untuk digunakan dengan AWS SAMCLI](install-docker.md).
## Tentukan fungsi.NET 8 Lambda di template Anda AWS SAM
Untuk mendefinisikan a. NET8 Fungsi Lambda di AWS SAM template Anda, lakukan hal berikut:
1. Jalankan perintah berikut dari direktori awal pilihan Anda:
```
sam init
```
1. Pilih `AWS Quick Start Templates` untuk memilih template awal.
1. Pilih `Hello World Example` template.
1. Pilih untuk tidak menggunakan runtime dan jenis paket paling populer dengan memasukkan`n`.
1. Untuk runtime, pilih`dotnet8`.
1. Untuk jenis paket, pilih`Zip`.
1. Untuk template pemula Anda, pilih`Hello World Example using native AOT`.
**Instal Docker**
+ Membangun dengan Native AOT, Docker harus diinstal. Untuk instruksi instalasi, lihat [Menginstal Docker untuk digunakan dengan AWS SAMCLI](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
```
**catatan**
Ketika `Event` properti `AWS::Serverless::Function` diatur ke`Api`, tetapi `RestApiId` properti tidak ditentukan, AWS SAM menghasilkan `AWS::ApiGateway::RestApi` CloudFormation sumber daya.
## Membangun aplikasi Anda dengan AWS SAMCLI
Dari direktori root proyek Anda, jalankan `sam build` perintah untuk mulai membangun aplikasi Anda. Jika `PublishAot` properti telah ditentukan dalam file proyek.NET 8 Anda, AWS SAMCLI akan dibangun dengan kompilasi AOT Asli. Untuk mempelajari lebih lanjut tentang `PublishAot` properti, lihat [Penerapan AOT Asli](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/) di dokumentasi *.NET* Microsoft.
Untuk membangun fungsi Anda, AWS SAMCLI memanggil CLI CLI .NET yang menggunakan Amazon.Lambda.Tools .NET Core Global Tool.
**catatan**
Saat membangun, jika `.sln` file ada di direktori yang sama atau induk proyek Anda, direktori yang berisi `.sln` file akan dipasang ke wadah. Jika `.sln` file tidak ditemukan, hanya folder proyek yang dipasang. Oleh karena itu, jika Anda sedang membangun aplikasi multi-proyek, pastikan `.sln` file tersebut berada di properti.
## Pelajari selengkapnya
Untuk informasi selengkapnya tentang membangun fungsi.NET 8 Lambda, lihat [Memperkenalkan runtime .NET 8](https://aws.amazon.com/blogs/compute/introducing-the-net-8-runtime-for-aws-lambda/) untuk. AWS Lambda
Untuk referensi **sam build** perintah, lihat[sam build](sam-cli-command-reference-sam-build.md).
# Membangun fungsi Lambda Karat dengan in Cargo Lambda AWS SAM
| |
| --- |
| Fitur ini dalam rilis pratinjau untuk AWS SAM dan dapat berubah. |
Gunakan AWS Serverless Application Model Command Line Interface (AWS SAMCLI) dengan AWS Lambda fungsi Rust Anda.
**Topics**
+ [Prasyarat](#building-rust-prerequisites)
+ [Mengkonfigurasi AWS SAM untuk digunakan dengan fungsi Rust Lambda](#building-rust-configure)
+ [Contoh](#building-rust-examples)
## Prasyarat
**Rustbahasa**
Untuk menginstalRust, lihat [Menginstal Rust](https://www.rust-lang.org/tools/install) di *situs web Rust bahasa*.
**Cargo Lambda**
AWS SAMCLIMemerlukan instalasi [https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), subperintah untukCargo. Untuk petunjuk penginstalan, lihat [Instalasi](https://www.cargo-lambda.info/guide/installation.html) dalam *Cargo Lambdadokumentasi*.
**Docker**
Membangun dan menguji fungsi Rust Lambda membutuhkan. Docker Untuk instruksi instalasi, lihat [Menginstal Docker](install-docker.md).
**Ikut serta dalam fitur AWS SAMCLI beta**
Karena fitur ini dalam pratinjau, Anda harus memilih untuk menggunakan salah satu metode berikut:
1. Gunakan variabel lingkungan:`SAM_CLI_BETA_RUST_CARGO_LAMBDA=1`.
1. Tambahkan hal berikut ke file `samconfig.toml` Anda:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Gunakan `--beta-features` opsi saat menggunakan AWS SAMCLI perintah yang didukung. Contoh:
```
$ sam build --beta-features
```
1. Pilih opsi `y` saat AWS SAMCLI meminta Anda untuk ikut serta. Berikut ini adalah contohnya:
```
$ 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
```
## Mengkonfigurasi AWS SAM untuk digunakan dengan fungsi Rust Lambda
### Langkah 1: Konfigurasikan AWS SAM template Anda
Konfigurasikan AWS SAM template Anda dengan yang berikut ini:
+ **Biner** - Opsional. Tentukan kapan template Anda berisi beberapa fungsi Rust Lambda.
+ **BuildMethod** – `rust-cargolambda`.
+ **CodeUri**— jalur ke `Cargo.toml` file Anda.
+ **Pawang** —`bootstrap`.
+ **Runtime** —`provided.al2`.
Untuk mempelajari selengkapnya tentang runtime kustom, lihat [AWS Lambda Waktu proses kustom](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html) di Panduan *AWS Lambda Pengembang*.
Berikut adalah contoh AWS SAM template yang dikonfigurasi:
```
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
...
```
### Langkah 2: Gunakan AWS SAMCLI dengan fungsi Rust Lambda Anda
Gunakan AWS SAMCLI perintah apa pun dengan AWS SAM template Anda. Untuk informasi selengkapnya, lihat [AWS SAM CLI](using-sam-cli.md).
## Contoh
### Contoh Hello World
**Dalam contoh ini, kita membangun contoh aplikasi Hello World menggunakan Rust sebagai runtime kita.**
Pertama, kami menginisialisasi aplikasi tanpa server baru menggunakan. `sam init` Selama aliran interaktif, kami memilih **aplikasi Hello World** dan memilih runtime **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
```
Berikut ini adalah struktur aplikasi Hello World kami:
```
hello-rust
├── README.md
├── events
│ └── event.json
├── rust_app
│ ├── Cargo.toml
│ └── src
│ └── main.rs
├── samconfig.toml
└── template.yaml
```
Dalam AWS SAM template kami, Rust fungsi kami didefinisikan sebagai berikut:
```
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
```
Selanjutnya, kami menjalankan `sam build` untuk membangun aplikasi kami dan mempersiapkan penerapan. AWS SAMCLIMembuat `.aws-sam` direktori dan mengatur artefak build kami di sana. Fungsi kami dibangun menggunakan Cargo Lambda dan disimpan sebagai biner yang dapat dieksekusi di. `.aws-sam/build/HelloWorldFunction/bootstrap`
**catatan**
Jika Anda berencana menjalankan **sam local invoke** perintah di macOS, Anda perlu membangun fungsi yang berbeda sebelum menjalankan. Untuk melakukan ini, gunakan perintah berikut:
**SAM\$1BUILD\$1MODE=debug sam build**
Perintah ini hanya diperlukan jika pengujian lokal akan dilakukan. Ini tidak disarankan saat membangun untuk penerapan.
```
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
```
Selanjutnya, kami menerapkan aplikasi kami menggunakan`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
```
Untuk menguji, kita dapat memanggil fungsi Lambda kita menggunakan titik akhir API.
```
$ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Hello World!%
```
Untuk menguji fungsi kami secara lokal, pertama-tama kami memastikan `Architectures` properti fungsi kami cocok dengan mesin lokal kami.
```
...
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
...
```
Karena kami memodifikasi arsitektur kami dari `x86_64` ke `arm64` dalam contoh ini, kami menjalankan `sam build` untuk memperbarui artefak build kami. Kami kemudian menjalankan `sam local invoke` untuk memanggil fungsi kami secara lokal.
```
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
```
### Proyek fungsi Lambda Tunggal
**Berikut adalah contoh aplikasi tanpa server yang berisi satu fungsi Rust Lambda.**
Struktur direktori proyek:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ └── main.rs
└── template.yaml
```
AWS SAM Template:
```
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
...
```
### Beberapa proyek fungsi Lambda
**Berikut adalah contoh aplikasi tanpa server yang berisi beberapa fungsi Rust Lambda.**
Struktur direktori proyek:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ ├── function_a.rs
│ └── function_b.rs
└── template.yaml
```
AWS SAM Template:
```
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`berkas:
```
[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"
```
# Membangun fungsi Lambda Python dengan in uv AWS SAM
| |
| --- |
| Fitur ini dalam rilis pratinjau untuk AWS SAM dan dapat berubah. |
Gunakan AWS Serverless Application Model Command Line Interface (AWS SAMCLI) denganuv, installer dan resolver paket Python cepat, untuk membangun fungsi Python Anda. AWS Lambda
**Topics**
+ [Prasyarat](#building-python-uv-prerequisites)
+ [Mengkonfigurasi AWS SAM untuk digunakan dengan fungsi Python Lambda dan uv](#building-python-uv-configure)
+ [Contoh](#building-python-uv-examples)
## Prasyarat
**Python**
*Untuk menginstal Python, lihat Unduh [Python di situs web Python](https://www.python.org/downloads/).*
**uv**
AWS SAMCLIMemerlukan instalasi [https://docs.astral.sh/uv/](https://docs.astral.sh/uv/), penginstal dan resolver paket Python yang sangat cepat. Untuk petunjuk penginstalan, lihat [Instalasi](https://docs.astral.sh/uv/getting-started/installation/) dalam *uvdokumentasi*.
**Ikut serta dalam fitur AWS SAMCLI beta**
Karena fitur ini dalam pratinjau, Anda harus memilih untuk menggunakan salah satu metode berikut:
1. Gunakan variabel lingkungan:`SAM_CLI_BETA_PYTHON_UV=1`.
1. Tambahkan hal berikut ke file `samconfig.toml` Anda:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Gunakan `--beta-features` opsi saat menggunakan AWS SAMCLI perintah yang didukung. Contoh:
```
$ sam build --beta-features
```
1. Pilih opsi `y` saat AWS SAMCLI meminta Anda untuk ikut serta. Berikut ini adalah contohnya:
```
$ 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
```
## Mengkonfigurasi AWS SAM untuk digunakan dengan fungsi Python Lambda dan uv
### Langkah 1: Konfigurasikan AWS SAM template Anda
Konfigurasikan AWS SAM template Anda dengan yang berikut ini:
+ **BuildMethod** – `python-uv`.
+ **CodeUri**— jalur ke direktori kode fungsi Anda yang berisi `pyproject.toml` atau`requirements.txt`.
+ **Handler** — handler fungsi Anda (misalnya,`app.lambda_handler`).
+ **Runtime** - Versi runtime Python (misalnya,). `python3.12`
Berikut adalah contoh AWS SAM template yang dikonfigurasi:
```
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
...
```
## Contoh
### Contoh Hello World
**Dalam contoh ini, kita membangun contoh aplikasi Hello World menggunakan Python dengan uv sebagai manajer paket.**
uvdapat menggunakan salah satu `pyproject.toml` atau `requirements.txt` untuk membaca dependensi. Jika keduanya diberikan, `sam build` akan dibaca dari `requirements.txt` untuk dependensi.
Berikut ini adalah struktur aplikasi Hello World kami:
```
hello-python-uv
├── README.md
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── pyproject.toml
├── samconfig.toml
└── template.yaml
```
`pyproject.toml`berkas:
```
[project]
name = "my-function"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
"requests>=2.31.0",
"boto3>=1.28.0",
]
```
Dalam AWS SAM template kami, fungsi Python kami didefinisikan sebagai berikut:
```
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
```
Selanjutnya, kami menjalankan `sam build` untuk membangun aplikasi kami dan mempersiapkan penerapan. AWS SAMCLIMembuat `.aws-sam` direktori dan mengatur artefak build kami di sana. Dependensi fungsi kami diinstal menggunakan uv dan disimpan di. `.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
```
**catatan**
Metode `python-uv` build dikonfigurasi per fungsi di `Metadata` bagian. Setiap fungsi dalam template Anda dapat menggunakan metode build yang berbeda, memungkinkan Anda untuk mencampur fungsi uv berbasis dengan fungsi `pip` berbasis dalam AWS SAM template yang sama. Jika tidak ada metode build yang `pip` ditentukan, digunakan secara default.
# Membangun fungsi Lambda dengan runtime khusus di AWS SAM
Anda dapat menggunakan perintah `sam build` untuk membangun waktu aktif kustom yang diperlukan untuk fungsi Lambda Anda. Anda menyatakan fungsi Lambda untuk menggunakan waktu aktif kustom dengan menentukan `Runtime: provided` pada fungsi terebut.
Untuk membangun waktu aktif kustom, nyatakan atribut sumber daya `Metadata` dengan entri `BuildMethod: makefile`. Anda menyediakan makefile kustom, tempat Anda menyatakan target bangunan formulir `build-function-logical-id` yang mencakup perintah pembangunan untuk waktu aktif Anda. Makefile Anda bertanggung jawab untuk menyusun waktu aktif kustom jika diperlukan, dan menyalin artefak bangunan ke lokasi yang tepat yang diperlukan untuk langkah-langkah berikutnya dalam alur kerja Anda. Lokasi makefile ditentukan oleh properti `CodeUri` dari sumber daya fungsi dan harus bernama `Makefile`.
## Contoh
### Contoh 1: Waktu aktif kustom untuk fungsi yang ditulis dalam Rust
**catatan**
Kami merekomendasikan membangun fungsi Lambda dengan. Cargo Lambda Untuk mempelajari selengkapnya, lihat [Membangun fungsi Lambda Karat dengan in Cargo Lambda AWS SAM](building-rust.md).
AWS SAM Template berikut mendeklarasikan fungsi yang menggunakan runtime kustom untuk fungsi Lambda yang ditulis dalam Rust, dan menginstruksikan `sam build` untuk menjalankan perintah untuk target build. `build-HelloRustFunction`
```
Resources:
HelloRustFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: HelloRust
Handler: bootstrap.is.real.handler
Runtime: provided
MemorySize: 512
CodeUri: .
Metadata:
BuildMethod: makefile
```
Makefile berikut berisi target bangunan dan perintah yang akan dieksekusi. Perhatikan bahwa properti `CodeUri` diatur ke `.`, maka makefile harus terletak di direktori root proyek (yaitu, direktori yang sama dengan file templat AWS SAM aplikasi). Nama file tersebut harus `Makefile`.
```
build-HelloRustFunction:
cargo build --release --target x86_64-unknown-linux-musl
cp ./target/x86_64-unknown-linux-musl/release/bootstrap $(ARTIFACTS_DIR)
```
Untuk informasi selengkapnya tentang pengaturan lingkungan pengembangan Anda agar dapat mengeksekusi perintah `cargo build` di `makefile` sebelumnya, lihat postingan blog [Waktu aktif Rust untuk AWS Lambda](https://aws.amazon.com/blogs/opensource/rust-runtime-for-aws-lambda/).
### Contoh 2: Pembuat makefile untuk Python3.12 (alternatif untuk menggunakan pembuat yang dibundel)
Anda mungkin ingin menggunakan pustaka atau modul yang tidak disertakan dalam pembangun yang dipaketkan bersama. Contoh ini menunjukkan AWS SAM template untuk runtime Python3.12 dengan pembuat makefile.
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: makefile
```
Makefile berikut berisi target bangunan dan perintah yang akan dieksekusi. Perhatikan bahwa properti `CodeUri` diatur ke `hello_world`, sehingga makefile harus terletak di root subdirektori `hello_world`, dan nama file harus `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
```
# Membangun lapisan Lambda di AWS SAM
Anda dapat menggunakan AWS SAM untuk membangun lapisan Lambda kustom. Lapisan Lambda memungkinkan Anda mengekstrak kode dari fungsi Lambda yang kemudian dapat digunakan kembali di beberapa fungsi Lambda. Membangun hanya lapisan Lambda (alih-alih membangun seluruh aplikasi Anda) dapat menguntungkan Anda dalam beberapa cara. Ini dapat membantu Anda mengurangi ukuran paket penerapan Anda, memisahkan logika fungsi inti dari dependensi, dan memungkinkan Anda untuk berbagi dependensi di beberapa fungsi. Untuk informasi tentang lapisan, lihat [Lapisan Lambda AWS](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) di *Panduan Developer AWS Lambda *.
## Cara membangun lapisan Lambda di AWS SAM
**catatan**
Sebelum Anda dapat membangun layer Lambda, Anda harus terlebih dahulu menulis layer Lambda di template Anda. AWS SAM Untuk informasi dan contoh tentang melakukan ini, lihat[Tingkatkan efisiensi menggunakan lapisan Lambda dengan AWS SAM](serverless-sam-cli-layers.md).
Untuk membangun lapisan kustom, deklarasikan dalam file template AWS Serverless Application Model (AWS SAM) Anda dan sertakan bagian atribut `Metadata` resource dengan entri. `BuildMethod` Nilai yang valid untuk `BuildMethod` adalah pengidentifikasi pada [waktu aktif AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html), atau `makefile`. Sertakan `BuildArchitecture` entri untuk menentukan arsitektur set instruksi yang didukung lapisan Anda. Nilai yang valid untuk `BuildArchitecture` adalah arsitektur [set instruksi Lambda](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html).
Jika Anda menentukan `makefile`, sediakan makefile kustom, tempat Anda menyatakan target bangunan formulir `build-layer-logical-id` yang berisi perintah pembangunan untuk lapisan Anda. Makefile Anda bertanggung jawab untuk menyusun lapisan jika diperlukan, dan menyalin artefak bangunan ke lokasi yang tepat yang diperlukan untuk langkah-langkah berikutnya dalam alur kerja Anda. Lokasi makefile ditentukan oleh properti `ContentUri` dari sumber daya lapisan dan harus diberi nama `Makefile`.
**catatan**
Ketika Anda membuat lapisan kustom, AWS Lambda tergantung pada variabel lingkungan untuk menemukan kode lapisan Anda. Waktu aktif Lambda termasuk jalur di direktori `/opt` tempat kode lapisan Anda disalin. Struktur folder artefak bangunan Anda harus sesuai dengan struktur folder yang diharapkan waktu aktif sehingga kode lapisan kustom Anda dapat ditemukan.
Contohnya, untuk Python, Anda dapat menempatkan kode di subdirektori `python/`. Untuk NodeJS, Anda dapat menempatkan kode Anda di subdirektori `nodejs/node_modules/`.
Untuk informasi selengkapnya, lihat [Menyertakan dependensi pustaka dalam lapisan](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-path) di *Panduan Developer AWS Lambda *.
Berikut ini adalah contoh bagian atribut sumber daya `Metadata`.
```
Metadata:
BuildMethod: python3.12
BuildArchitecture: arm64
```
**catatan**
Jika Anda tidak menyertakan bagian atribut `Metadata` sumber daya, AWS SAM tidak membangun lapisan. Sebaliknya, artefak bangunan akan disalin dari lokasi yang ditentukan dalam properti `CodeUri` sumber daya lapisan. Untuk informasi selengkapnya, lihat properti [ContentUri](sam-resource-layerversion.md#sam-layerversion-contenturi) tipe sumber daya `AWS::Serverless::LayerVersion`.
Ketika Anda menyertakan bagian atribut `Metadata` sumber daya, Anda dapat menggunakan `sam build` perintah untuk membangun lapisan, baik sebagai objek independen, atau sebagai ketergantungan AWS Lambda fungsi.
+ ****Sebagai objek independen.**** Anda mungkin hanya ingin membangun objek lapisan, misalnya ketika Anda sedang menguji perubahan kode secara lokal pada lapisan dan tidak perlu membangun seluruh aplikasi Anda. Untuk membangun lapisan secara independen, tentukan sumber daya lapisan dengan perintah `sam build layer-logical-id`.
+ **Sebagai ketergantungan fungsi Lambda.** Bila Anda menyertakan ID logis lapisan di properti `Layers` dari fungsi Lambda di file templat AWS SAM yang sama, lapisan merupakan dependensi dari fungsi Lambda tersebut. Ketika lapisan tersebut juga menyertakan bagian atribut sumber daya `Metadata` dengan entri `BuildMethod`, Anda membangun lapisan baik dengan membangun seluruh aplikasi menggunakan perintah `sam build` atau dengan menentukan sumber daya fungsi menggunakan perintah `sam build function-logical-id`.
## Contoh
### Contoh template 1: Bangun layer terhadap lingkungan runtime Python 3.12
Contoh AWS SAM template berikut membangun lapisan terhadap lingkungan runtime 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
```
### Contoh templat 2: Bangun lapisan menggunakan makefile kustom
Contoh AWS SAM template berikut menggunakan custom `makefile` untuk membangun layer.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: makefile
```
Hal `makefile` berikut berisi target build dan perintah yang akan dieksekusi. Perhatikan bahwa properti `ContentUri` diatur ke `my_layer`, sehingga makefile harus terletak di root subdirektori `my_layer`, dan nama file harus `Makefile`. Perhatikan juga bahwa artefak build disalin ke `python/` subdirektori sehingga AWS Lambda akan dapat menemukan kode layer.
```
build-MyLayer:
mkdir -p "$(ARTIFACTS_DIR)/python"
cp *.py "$(ARTIFACTS_DIR)/python"
python -m pip install -r requirements.txt -t "$(ARTIFACTS_DIR)/python"
```
**catatan**
Ketika `makefile` dipanggil, target yang sesuai dipicu dan artefak harus disalin ke variabel lingkungan yang terbuka. `$ARTIFACTS_DIR` Untuk informasi lebih lanjut, lihat [aws-lambda-builders di GitHub](https://github.com/aws/aws-lambda-builders/blob/develop/aws_lambda_builders/workflows/custom_make/DESIGN.md).
### Contoh perintah pembangunan sam
Perintah `sam build` berikut ini membangun lapisan yang mencakup bagian atribut sumber daya `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
```