Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Kembangkan aplikasi tanpa server Anda dengan AWS SAM
Bagian ini berisi topik tentang memvalidasi AWS SAM template Anda dan membangun aplikasi Anda dengan dependensi. Ini juga berisi topik tentang penggunaan AWS SAM untuk kasus penggunaan tertentu seperti bekerja dengan lapisan Lambda, menggunakan aplikasi bersarang, mengontrol akses ke API Gateway, mengatur sumber daya AWS dengan Step Functions APIs, dan penandatanganan kode aplikasi Anda. Tiga tonggak utama yang perlu Anda selesaikan untuk mengembangkan aplikasi Anda tercantum di bawah ini.
**Topics**
+ [
# Buat aplikasi Anda di AWS SAM
](using-sam-cli-init.md)
+ [
# Tentukan infrastruktur Anda dengan AWS SAM
](serverless-authoring.md)
+ [
# Membangun aplikasi Anda dengan AWS SAM
](serverless-building.md)
# Buat aplikasi Anda di AWS SAM
Setelah selesai [Memulai](serverless-getting-started.md) dan membaca[Cara menggunakan AWS Serverless Application Model (AWS SAM)](chapter-using-sam.md), Anda akan siap untuk membuat AWS SAM proyek di lingkungan pengembang Anda. AWS SAM Proyek Anda akan berfungsi sebagai titik awal untuk menulis aplikasi tanpa server Anda. Untuk daftar opsi AWS SAMCLI `sam init` perintah, lihat[sam init](sam-cli-command-reference-sam-init.md).
AWS Serverless Application Model Perintah Command Line Interface (AWS SAMCLI) `sam init` menyediakan opsi untuk menginisialisasi aplikasi tanpa server baru yang terdiri dari:
+ AWS SAM Template untuk menentukan kode infrastruktur Anda.
+ Struktur folder yang mengatur aplikasi Anda.
+ Konfigurasi untuk AWS Lambda fungsi Anda.
Untuk membuat AWS SAM proyek, lihat topik di bagian ini.
**catatan**
`sam init`termasuk template proyek untuk fungsi tahan lama dalam runtime yang didukung (TypeScript, Python, Java). Template ini menyediakan kode awal dan konfigurasi untuk membangun aplikasi tanpa server stateful.
**Topics**
+ [
## Menginisialisasi aplikasi tanpa server baru
](#using-sam-cli-init-new)
+ [
## Opsi untuk sam init
](#using-sam-cli-init-options)
+ [
## Pemecahan masalah
](#using-sam-cli-init-troubleshooting)
+ [
## Contoh
](#using-sam-cli-init-examples)
+ [
## Pelajari selengkapnya
](#using-sam-cli-init-learn)
+ [
## Langkah selanjutnya
](#w2aac18c11c39)
## Menginisialisasi aplikasi tanpa server baru
**Untuk menginisialisasi aplikasi tanpa server baru menggunakan AWS SAMCLI**
1. `cd`ke direktori awal.
1. Jalankan yang berikut ini di baris perintah:
```
$ sam init
```
1. Ini AWS SAMCLI akan memandu Anda melalui aliran interaktif untuk membuat aplikasi tanpa server baru.
**catatan**
Seperti yang dijelaskan dalam[Tutorial: Menyebarkan aplikasi Hello World dengan AWS SAM](serverless-getting-started-hello-world.md), perintah ini menginisialisasi aplikasi tanpa server Anda, membuat direktori proyek Anda. Direktori ini akan berisi beberapa file dan folder. File yang paling penting adalah`template.yaml`. Ini adalah AWS SAM template Anda. Versi python Anda harus cocok dengan versi python yang tercantum dalam `template.yaml` file yang dibuat **sam init** perintah.
### Pilih template awal
*Template* terdiri dari yang berikut:
1. AWS SAM Template untuk kode infrastruktur Anda.
1. Direktori proyek awal yang mengatur file proyek Anda. Misalnya, ini mungkin termasuk:
1. Struktur untuk kode fungsi Lambda Anda dan dependensinya.
1. `events`Folder yang berisi peristiwa pengujian untuk pengujian lokal.
1. `tests`Folder untuk mendukung pengujian unit.
1. `samconfig.toml`File untuk mengkonfigurasi pengaturan proyek.
1. `ReadMe`File dan file proyek awal dasar lainnya.
Berikut ini adalah contoh direktori proyek awal:
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
Anda dapat memilih dari daftar *Template Mulai AWS Cepat* yang tersedia atau menyediakan *Lokasi Template Kustom* Anda sendiri.
**Untuk memilih Template Mulai AWS Cepat**
1. Saat diminta, pilih **Templat Mulai AWS Cepat**.
1. Pilih template Mulai AWS Cepat untuk memulai. Berikut ini adalah contohnya:
```
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: 4
```
**Untuk memilih lokasi template kustom Anda sendiri**
1. Saat diminta, pilih **Lokasi Template Kustom**.
```
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 2
```
1. Ini AWS SAMCLI akan meminta Anda untuk memberikan lokasi template.
```
Template location (git, mercurial, http(s), zip, path):
```
Berikan salah satu lokasi berikut ke arsip file.zip template Anda:
+ **GitHubrepositori** — Jalur ke file.zip di repositori Anda. GitHub File harus berada di root repositori Anda.
+ **Mercurialrepositori** — Jalur ke file.zip di repositori Anda. Mercurial File harus berada di root repositori Anda.
+ **.zip path** — HTTPS atau jalur lokal ke file.zip Anda.
1. Ini AWS SAMCLI akan menginisialisasi aplikasi tanpa server Anda menggunakan template kustom Anda.
### Pilih runtime
Ketika Anda memilih *Template Mulai AWS Cepat*, AWS SAMCLI meminta Anda untuk memilih runtime untuk fungsi Lambda Anda. Daftar opsi yang ditampilkan oleh adalah runtime AWS SAMCLI yang didukung secara native oleh Lambda.
+ [Runtime](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-runtime) menyediakan lingkungan khusus bahasa yang berjalan di lingkungan eksekusi.
+ [Saat di-deploy ke AWS Cloud, layanan Lambda akan memanggil fungsi Anda di lingkungan eksekusi.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html)
Anda dapat menggunakan bahasa pemrograman lain dengan runtime khusus. Untuk melakukan ini, Anda perlu membuat struktur aplikasi awal secara manual. Anda kemudian dapat menggunakan `sam init` untuk menginisialisasi aplikasi dengan cepat dengan mengonfigurasi lokasi template kustom.
Dari pilihan Anda, AWS SAMCLI membuat direktori awal untuk kode fungsi dan dependensi Lambda Anda.
Jika Lambda mendukung beberapa manajer ketergantungan untuk runtime Anda, Anda akan diminta untuk memilih manajer ketergantungan pilihan Anda.
### Pilih jenis paket
Bila Anda memilih *AWS Quick Start Template* dan *runtime*, AWS SAMCLI meminta Anda untuk memilih jenis *paket*. Jenis paket menentukan bagaimana fungsi Lambda Anda digunakan untuk digunakan dengan layanan Lambda. Dua jenis paket yang didukung adalah:
1. **Gambar kontainer** - Berisi sistem operasi dasar, runtime, ekstensi Lambda, kode aplikasi Anda, dan dependensinya.
1. **.zip file archive** - Berisi kode aplikasi Anda dan dependensinya.
*Untuk mempelajari lebih lanjut tentang jenis paket penerapan, lihat Paket penerapan [Lambda di AWS Lambda Panduan Pengembang](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html).*
Berikut ini adalah contoh struktur direktori aplikasi dengan fungsi Lambda dikemas sebagai gambar kontainer. AWS SAMCLIDownload gambar dan membuat `Dockerfile` dalam direktori fungsi untuk menentukan gambar.
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── Dockerfile
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
└── unit
├── __init__.py
└── test_handler.py
```
Berikut ini adalah contoh struktur direktori aplikasi dengan fungsi yang dikemas sebagai arsip file.zip.
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
### Konfigurasikan AWS X-Ray penelusuran
Anda dapat memilih untuk mengaktifkan AWS X-Ray tracing. Untuk mempelajari lebih lanjut, lihat [Apa itu AWS X-Ray?](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html) di *Panduan AWS X-Ray Pengembang*.
Jika Anda mengaktifkan, AWS SAMCLI mengkonfigurasi AWS SAM template Anda. Berikut ini adalah contohnya:
```
Globals:
Function:
...
Tracing: Active
Api:
TracingEnabled: True
```
### Konfigurasikan pemantauan dengan Amazon CloudWatch Application Insights
Anda dapat memilih untuk mengaktifkan pemantauan menggunakan Amazon CloudWatch Application Insights. Untuk mempelajari selengkapnya, lihat [Wawasan CloudWatch Aplikasi Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html) di *Panduan CloudWatch Pengguna Amazon*.
Jika Anda mengaktifkan, AWS SAMCLI mengkonfigurasi AWS SAM template Anda. Berikut ini adalah contohnya:
```
Resources:
ApplicationResourceGroup:
Type: AWS::ResourceGroups::Group
Properties:
Name:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
ResourceQuery:
Type: CLOUDFORMATION_STACK_1_0
ApplicationInsightsMonitoring:
Type: AWS::ApplicationInsights::Application
Properties:
ResourceGroupName:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
AutoConfigurationEnabled: 'true'
DependsOn: ApplicationResourceGroup
```
### Beri nama aplikasi Anda
Berikan nama untuk aplikasi Anda. AWS SAMCLIMembuat folder tingkat atas untuk aplikasi Anda menggunakan nama ini.
## Opsi untuk sam init
Berikut ini adalah beberapa opsi utama yang dapat Anda gunakan dengan `sam init` perintah. Untuk daftar semua opsi, lihat[sam init](sam-cli-command-reference-sam-init.md).
### Menginisialisasi aplikasi menggunakan lokasi template kustom
Gunakan `--location` opsi dan berikan lokasi template kustom yang didukung. Berikut ini adalah contohnya:
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
### Menginisialisasi aplikasi tanpa aliran interaktif
Gunakan `--no-interactive` opsi dan berikan pilihan konfigurasi Anda di baris perintah untuk melewati alur interaktif. Berikut ini adalah contohnya:
```
$ sam init --no-interactive --runtime go1.x --name go-demo --dependency-manager mod --app-template hello-world
```
## Pemecahan masalah
Untuk memecahkan masalah AWS SAMCLI, lihat. [AWS SAMCLIpemecahan masalah](sam-cli-troubleshooting.md)
## Contoh
### Menginisialisasi aplikasi tanpa server baru menggunakan Hello World Starter Template AWS
Untuk contoh ini, lihat [Langkah 1: Inisialisasi contoh aplikasi Hello World](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-init) di *Tutorial: Menyebarkan aplikasi Hello World*.
### Menginisialisasi aplikasi tanpa server baru dengan lokasi template kustom
Berikut ini adalah contoh penyediaan GitHub lokasi untuk template kustom Anda:
```
$ sam init --location gh:aws-samples/cookiecutter-aws-sam-python
$ sam init --location git+sh://git@github.com/aws-samples/cookiecutter-aws-sam-python.git
$ sam init --location hg+ssh://hg@bitbucket.org/repo/template-name
```
Berikut ini adalah contoh dari path file lokal:
```
$ sam init --location /path/to/template.zip
```
Berikut ini adalah contoh jalur yang dapat dijangkau oleh HTTPS:
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
## Pelajari selengkapnya
Untuk mempelajari lebih lanjut tentang menggunakan `sam init` perintah, lihat berikut ini:
+ **[Pembelajaran AWS SAM: sam init](https://www.youtube.com/watch?v=9m3R-leD5Xo)** — seri Serverless Land AWS SAM“Belajar” aktifYouTube.
+ **[Penataan aplikasi tanpa server untuk digunakan dengan AWS SAMCLI (Sesi dengan SAM S2E7) - Sesi dengan](https://www.youtube.com/watch?v=k9IRdgze9fQ)** seri aktif. AWS SAM YouTube
## Langkah selanjutnya
Sekarang setelah Anda membuat AWS SAM proyek Anda, Anda siap untuk mulai membuat aplikasi Anda. Lihat [Tentukan infrastruktur Anda dengan AWS SAM](serverless-authoring.md) instruksi terperinci tentang tugas yang perlu Anda selesaikan untuk melakukan ini.
# Tentukan infrastruktur Anda dengan AWS SAM
Sekarang Anda telah membuat proyek Anda, Anda siap untuk menentukan infrastruktur aplikasi Anda dengan AWS SAM. Lakukan ini dengan mengonfigurasi AWS SAM template Anda untuk menentukan sumber daya dan properti aplikasi Anda, yang merupakan `template.yaml` file dalam AWS SAM proyek Anda.
Topik di bagian ini menyediakan konten tentang mendefinisikan infrastruktur Anda di AWS SAM template Anda (`template.yaml`file Anda). Ini juga berisi topik tentang mendefinisikan sumber daya untuk kasus penggunaan tertentu, seperti bekerja dengan lapisan Lambda, menggunakan aplikasi bersarang, mengontrol akses ke API APIs Gateway, AWS mengatur sumber daya dengan Step Functions, menandatangani kode aplikasi Anda, dan memvalidasi template Anda. AWS SAM
**Topics**
+ [
# Tentukan sumber daya aplikasi dalam AWS SAM template Anda
](authoring-define-resources.md)
+ [
# Siapkan dan kelola akses sumber daya di AWS SAM template Anda
](sam-permissions.md)
+ [
# Kontrol akses API dengan AWS SAM template Anda
](serverless-controlling-access-to-apis.md)
+ [
# Tingkatkan efisiensi menggunakan lapisan Lambda dengan AWS SAM
](serverless-sam-cli-layers.md)
+ [
# Gunakan kembali kode dan sumber daya menggunakan aplikasi bersarang di AWS SAM
](serverless-sam-template-nested-applications.md)
+ [
# Kelola acara berbasis waktu dengan EventBridge Scheduler di AWS SAM
](using-eventbridge-scheduler.md)
+ [
# Mengatur sumber daya dengan AWS SAM AWS Step Functions
](serverless-step-functions-in-sam.md)
+ [
# Siapkan penandatanganan kode untuk AWS SAM aplikasi Anda
](authoring-codesigning.md)
+ [
# Validasi file AWS SAM template
](serverless-sam-cli-using-validate.md)
# Tentukan sumber daya aplikasi dalam AWS SAM template Anda
Anda menentukan AWS sumber daya yang digunakan aplikasi tanpa server Anda di `Resources` bagian template Anda AWS SAM . Ketika Anda mendefinisikan sumber daya, Anda mengidentifikasi apa sumber daya itu, bagaimana ia berinteraksi dengan sumber daya lain, dan bagaimana itu dapat diakses (yaitu, izin sumber daya).
`Resources`Bagian AWS SAM template Anda dapat berisi kombinasi CloudFormation sumber daya dan sumber AWS SAM daya. Selain itu, Anda dapat menggunakan AWS SAM sintaks singkat untuk sumber daya berikut:
| AWS SAM sintaks tangan pendek | Apa yang dilakukannya dengan AWS sumber daya terkait |
| --- | --- |
| [AWS::Serverless::Api](sam-resource-api.md) | Membuat kumpulan sumber daya API Gateway dan metode yang dapat dipanggil melalui titik akhir HTTPS. |
| [AWS::Serverless::Application](sam-resource-application.md) | Menyematkan aplikasi nirserver dari [AWS Serverless Application Repository](https://serverlessrepo.aws.amazon.com/applications) atau dari bucket Amazon S3 sebagai aplikasi yang di-nest. |
| [AWS::Serverless::Connector](sam-resource-connector.md) | Mengkonfigurasi izin antara dua sumber daya. Untuk pengenalan konektor, lihat[Mengelola izin sumber daya dengan konektor AWS SAM](managing-permissions-connectors.md). |
| [AWS::Serverless::Function](sam-resource-function.md) | Membuat AWS Lambda fungsi, peran eksekusi AWS Identity and Access Management (IAM), dan pemetaan sumber peristiwa yang memicu fungsi. |
| [AWS::Serverless::GraphQLApi](sam-resource-graphqlapi.md) | membuat dan mengonfigurasi AWS AppSync GraphQL API untuk aplikasi tanpa server Anda. |
| [AWS::Serverless::HttpApi](sam-resource-httpapi.md) | Membuat API HTTP Amazon API Gateway, yang memungkinkan Anda membuat RESTful APIs dengan latensi lebih rendah dan biaya lebih rendah daripada REST APIs. |
| [AWS::Serverless::LayerVersion](sam-resource-layerversion.md) | Membuat Lambda LayerVersion yang berisi pustaka atau kode runtime yang dibutuhkan oleh Fungsi Lambda. |
| [AWS::Serverless::SimpleTable](sam-resource-simpletable.md) | Membuat tabel DynamoDB dengan kunci primer atribut tunggal. |
| [AWS::Serverless::StateMachine](sam-resource-statemachine.md) | Membuat mesin AWS Step Functions status, yang dapat Anda gunakan untuk mengatur AWS Lambda fungsi dan AWS sumber daya lainnya untuk membentuk alur kerja yang kompleks dan kuat. |
Sumber daya di atas juga tercantum dalam[AWS SAM sumber daya dan properti](sam-specification-resources-and-properties.md).
Untuk informasi referensi untuk semua jenis dan AWS SAM dukungan AWS sumber daya CloudFormation dan properti, lihat [referensi jenis AWS sumber daya dan properti](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html) di *Panduan AWS CloudFormation Pengguna*.
# Siapkan dan kelola akses sumber daya di AWS SAM template Anda
Agar AWS sumber daya Anda berinteraksi satu sama lain, akses dan izin yang tepat harus dikonfigurasi di antara sumber daya Anda. Melakukan hal ini memerlukan konfigurasi AWS Identity and Access Management (IAM) pengguna, peran, dan kebijakan untuk menyelesaikan interaksi Anda dengan cara yang aman.
Topik di bagian ini semuanya terkait dengan pengaturan akses ke sumber daya yang ditentukan dalam template Anda. Bagian ini dimulai dengan praktik terbaik umum. Dua topik berikutnya meninjau dua opsi yang Anda miliki untuk menyiapkan akses dan izin antara sumber daya yang direferensikan dalam aplikasi tanpa server Anda: AWS SAM konektor dan templat kebijakan. AWS SAM Topik terakhir memberikan detail untuk mengelola akses pengguna CloudFormation menggunakan mekanisme yang sama yang digunakan untuk mengelola pengguna.
Untuk mempelajari lebih lanjut, lihat [Mengontrol akses dengan AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) di *Panduan AWS CloudFormation Pengguna*.
The AWS Serverless Application Model (AWS SAM) menyediakan dua opsi yang menyederhanakan pengelolaan akses dan izin untuk aplikasi tanpa server Anda.
1. AWS SAM konektor
1. AWS SAM templat kebijakan
## AWS SAM konektor
Konektor adalah cara penyediaan izin antara dua sumber daya. Anda melakukan ini dengan menjelaskan bagaimana mereka harus berinteraksi satu sama lain dalam AWS SAM template Anda. Mereka dapat didefinisikan menggunakan atribut `Connectors` sumber daya atau tipe `AWS::Serverless::Connector` sumber daya. Konektor mendukung penyediaan `Read` dan `Write` akses data dan peristiwa antara kombinasi sumber daya. AWS Untuk mempelajari lebih lanjut tentang AWS SAM konektor, lihat[Mengelola izin sumber daya dengan konektor AWS SAM](managing-permissions-connectors.md).
## AWS SAM templat kebijakan
AWS SAM templat kebijakan adalah kumpulan izin yang telah ditentukan sebelumnya yang dapat Anda tambahkan ke AWS SAM templat untuk mengelola akses dan izin antara AWS Lambda fungsi, mesin AWS Step Functions status, dan sumber daya yang berinteraksi dengannya. Untuk mempelajari lebih lanjut tentang templat AWS SAM kebijakan, lihat[AWS SAM templat kebijakan](serverless-policy-templates.md).
## AWS CloudFormation mekanisme
CloudFormation Mekanisme mencakup konfigurasi pengguna IAM, peran, dan kebijakan untuk mengelola izin antar sumber daya Anda. AWS Untuk mempelajari selengkapnya, lihat [Mengelola AWS SAM izin dengan mekanisme CloudFormation](sam-permissions-cloudformation.md).
## Praktik terbaik
Di seluruh aplikasi tanpa server, Anda dapat menggunakan beberapa metode untuk mengonfigurasi izin antar sumber daya Anda. Oleh karena itu, Anda dapat memilih opsi terbaik untuk setiap skenario dan menggunakan beberapa opsi bersama di seluruh aplikasi Anda. Berikut adalah beberapa hal yang perlu dipertimbangkan ketika memilih opsi terbaik untuk Anda:
+ AWS SAM konektor dan templat kebijakan mengurangi keahlian IAM yang diperlukan untuk memfasilitasi interaksi aman antara AWS sumber daya Anda. Gunakan konektor dan templat kebijakan saat didukung.
+ AWS SAM konektor menyediakan sintaks singkat yang sederhana dan intuitif untuk menentukan izin di AWS SAM template Anda dan membutuhkan keahlian IAM paling sedikit. Saat AWS SAM konektor dan templat kebijakan didukung, gunakan AWS SAM konektor.
+ AWS SAM konektor dapat menyediakan `Read` dan `Write` mengakses data dan peristiwa antara sumber yang didukung dan AWS SAM sumber daya tujuan. Untuk daftar sumber daya yang didukung, lihat[AWS SAM referensi konektor](reference-sam-connector.md). Saat didukung, gunakan AWS SAM konektor.
+ Meskipun templat AWS SAM kebijakan terbatas pada izin antara fungsi Lambda, mesin status Step Functions, dan sumber daya AWS yang berinteraksi dengannya, templat kebijakan mendukung semua operasi CRUD. Saat didukung, dan bila templat AWS SAM kebijakan untuk skenario Anda tersedia, gunakan templat AWS SAM kebijakan. Untuk daftar templat kebijakan yang tersedia, lihat[AWS SAM templat kebijakan](serverless-policy-templates.md).
+ Untuk semua skenario lain, atau ketika granularitas diperlukan, gunakan CloudFormation mekanisme.
# Mengelola izin sumber daya dengan konektor AWS SAM
Konektor adalah tipe sumber daya abstrak AWS Serverless Application Model (AWS SAM), diidentifikasi sebagai`AWS::Serverless::Connector`, yang menyediakan izin sederhana dan tercakup dengan baik antara sumber daya aplikasi tanpa server Anda.
## Manfaat AWS SAM konektor
Dengan secara otomatis menyusun kebijakan akses yang sesuai antar sumber daya, konektor memberi Anda kemampuan untuk membuat aplikasi tanpa server Anda dan fokus pada arsitektur aplikasi Anda tanpa memerlukan keahlian dalam kemampuan AWS otorisasi, bahasa kebijakan, dan pengaturan keamanan khusus layanan. Oleh karena itu, konektor adalah manfaat besar bagi pengembang yang mungkin baru dalam pengembangan tanpa server, atau pengembang berpengalaman yang ingin meningkatkan kecepatan pengembangan mereka.
## Menggunakan AWS SAM konektor
Gunakan atribut `Connectors` sumber daya dengan menyematkannya dalam **sumber daya sumber**. Kemudian, tentukan sumber daya **tujuan** Anda dan jelaskan bagaimana data atau peristiwa harus mengalir di antara sumber daya tersebut. AWS SAM kemudian menyusun kebijakan akses yang diperlukan untuk memfasilitasi interaksi yang diperlukan.
Berikut ini menguraikan bagaimana atribut resource ini ditulis:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
Destination:
Permissions:
...
```
## Cara kerja konektor
**catatan**
Bagian ini menjelaskan bagaimana konektor menyediakan sumber daya yang diperlukan di balik layar. Ini terjadi untuk Anda secara otomatis saat menggunakan konektor.
Pertama, atribut `Connectors` sumber daya tertanam diubah menjadi tipe `AWS::Serverless::Connector` sumber daya. ID logisnya secara otomatis dibuat sebagai**.
Misalnya, berikut adalah konektor tertanam:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Lambda::Function
Connectors:
MyConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
MyTable:
Type: AWS::DynamoDB::Table
```
Ini akan menghasilkan `AWS::Serverless::Connector` sumber daya berikut:
```
Transform: AWS::Serverless-2016-10-31
Resources:
...
MyFunctionMyConn:
Type: AWS::Serverless::Connector
Properties:
Source:
Id: MyFunction
Destination:
Id: MyTable
Permissions:
- Read
- Write
```
**catatan**
Anda juga dapat menentukan konektor dalam AWS SAM template Anda dengan menggunakan sintaks ini. Ini disarankan ketika sumber daya Anda ditentukan pada templat terpisah dari konektor Anda.
Selanjutnya, kebijakan akses yang diperlukan untuk koneksi ini disusun secara otomatis. Untuk informasi selengkapnya tentang sumber daya yang dihasilkan oleh konektor, lihat[CloudFormation sumber daya yang dihasilkan saat Anda menentukan AWS::Serverless::Connector](sam-specification-generated-resources-connector.md).
## Contoh konektor
Contoh berikut menunjukkan bagaimana Anda dapat menggunakan konektor untuk menulis data dari AWS Lambda fungsi ke tabel Amazon DynamoDB.
![\[Fungsi Lambda menulis data ke tabel DynamoDB menggunakan konektor. AWS SAM\]](http://docs.aws.amazon.com/id_id/serverless-application-model/latest/developerguide/images/managing-connectors-example.png)
```
Transform: AWS::Serverless-2016-10-31
Resources:
MyTable:
Type: AWS::Serverless::SimpleTable
MyFunction:
Type: AWS::Serverless::Function
Connectors:
MyConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Write
Properties:
Runtime: nodejs16.x
Handler: index.handler
InlineCode: |
const AWS = require("aws-sdk");
const docClient = new AWS.DynamoDB.DocumentClient();
exports.handler = async (event, context) => {
await docClient.put({
TableName: process.env.TABLE_NAME,
Item: {
id: context.awsRequestId,
event: JSON.stringify(event)
}
}).promise();
}
Environment:
Variables:
TABLE_NAME: !Ref MyTable
```
Atribut `Connectors` resource disematkan dalam sumber daya fungsi Lambda. Tabel DynamoDB didefinisikan sebagai sumber daya tujuan menggunakan properti. `Id` Konektor akan memberikan `Write` izin antara dua sumber daya ini.
Saat Anda menerapkan AWS SAM template Anda CloudFormation, secara otomatis AWS SAM akan menyusun kebijakan akses yang diperlukan yang diperlukan agar koneksi ini berfungsi.
## Koneksi yang didukung antara sumber dan sumber daya tujuan
Dukungan konektor `Read` dan jenis izin `Write` data dan acara antara kombinasi pilihan koneksi sumber dan sumber daya tujuan. Misalnya, konektor mendukung `Write` koneksi antara `AWS::ApiGateway::RestApi` sumber daya sumber dan sumber daya `AWS::Lambda::Function` tujuan.
Sumber dan sumber daya tujuan dapat didefinisikan dengan menggunakan kombinasi properti yang didukung. Persyaratan properti akan tergantung pada koneksi yang Anda buat dan di mana sumber daya ditentukan.
**catatan**
Konektor dapat menyediakan izin antara jenis sumber daya tanpa server dan non-server yang didukung.
Untuk daftar koneksi sumber daya yang didukung dan persyaratan propertinya, lihat[Jenis sumber daya dan tujuan yang didukung untuk konektor](reference-sam-connector.md#supported-connector-resource-types).
# Tentukan izin Baca dan Tulis di AWS SAM
In AWS SAM, `Read` dan `Write` izin dapat disediakan dalam satu konektor:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Lambda::Function
Connectors:
MyTableConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
MyTable:
Type: AWS::DynamoDB::Table
```
Untuk informasi lebih lanjut tentang penggunaan konektor, lihat[AWS SAM referensi konektor](reference-sam-connector.md).
# Tentukan sumber daya dengan menggunakan properti lain yang didukung di AWS SAM
Untuk sumber daya sumber dan tujuan, ketika didefinisikan dalam template yang sama, gunakan `Id` properti. Secara opsional, a `Qualifier` dapat ditambahkan untuk mempersempit ruang lingkup sumber daya yang Anda tentukan. Ketika sumber daya tidak berada dalam template yang sama, gunakan kombinasi properti yang didukung.
+ Untuk daftar kombinasi properti yang didukung untuk sumber daya sumber dan tujuan, lihat[Jenis sumber daya dan tujuan yang didukung untuk konektor](reference-sam-connector.md#supported-connector-resource-types).
+ Untuk deskripsi properti yang dapat Anda gunakan dengan konektor, lihat[AWS::Serverless::Connector](sam-resource-connector.md).
Saat Anda menentukan sumber daya sumber dengan properti selain`Id`, gunakan `SourceReference` properti tersebut.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
SourceReference:
Qualifier:
Destination:
Permissions:
```
Berikut adalah contoh, menggunakan a `Qualifier` untuk mempersempit cakupan sumber daya Amazon API Gateway:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyApi:
Type: AWS::Serverless::Api
Connectors:
ApiToLambdaConn:
Properties:
SourceReference:
Qualifier: Prod/GET/foobar
Destination:
Id: MyFunction
Permissions:
- Write
...
```
Berikut adalah contoh, menggunakan kombinasi yang didukung dari `Arn` dan `Type` untuk menentukan sumber daya tujuan dari template lain:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
TableConn:
Properties:
Destination:
Type: AWS::DynamoDB::Table
Arn: !GetAtt MyTable.Arn
...
```
Untuk informasi lebih lanjut tentang penggunaan konektor, lihat[AWS SAM referensi konektor](reference-sam-connector.md).
# Buat beberapa konektor dari satu sumber di AWS SAM
Dalam sumber daya sumber, Anda dapat menentukan beberapa konektor, masing-masing dengan sumber daya tujuan yang berbeda.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
BucketConn:
Properties:
Destination:
Id: amzn-s3-demo-bucket
Permissions:
- Read
- Write
SQSConn:
Properties:
Destination:
Id: MyQueue
Permissions:
- Read
- Write
TableConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
TableConnWithTableArn:
Properties:
Destination:
Type: AWS::DynamoDB::Table
Arn: !GetAtt MyTable.Arn
Permissions:
- Read
- Write
...
```
Untuk informasi lebih lanjut tentang penggunaan konektor, lihat[AWS SAM referensi konektor](reference-sam-connector.md).
# Buat konektor multi-tujuan di AWS SAM
Dalam sumber daya sumber, Anda dapat menentukan konektor tunggal dengan beberapa sumber daya tujuan. Berikut adalah contoh sumber daya fungsi Lambda yang terhubung ke bucket Amazon Simple Storage Service (Amazon S3) dan tabel DynamoDB:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
WriteAccessConn:
Properties:
Destination:
- Id: OutputBucket
- Id: CredentialTable
Permissions:
- Write
...
OutputBucket:
Type: AWS::S3::Bucket
CredentialTable:
Type: AWS::DynamoDB::Table
```
Untuk informasi lebih lanjut tentang penggunaan konektor, lihat[AWS SAM referensi konektor](reference-sam-connector.md).
# Tentukan atribut sumber daya dengan konektor di AWS SAM
Atribut sumber daya dapat didefinisikan untuk sumber daya untuk menentukan perilaku dan hubungan tambahan. Untuk mempelajari lebih lanjut tentang atribut sumber daya, lihat [Referensi atribut sumber daya](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-product-attribute-reference.html) di *Panduan AWS CloudFormation Pengguna*.
Anda dapat menambahkan atribut sumber daya ke konektor tertanam dengan mendefinisikannya pada level yang sama dengan properti konektor Anda. Saat AWS SAM template Anda diubah saat penerapan, atribut akan diteruskan ke sumber daya yang dihasilkan.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
MyConn:
DeletionPolicy: Retain
DependsOn: AnotherFunction
Properties:
...
```
Untuk informasi lebih lanjut tentang penggunaan konektor, lihat[AWS SAM referensi konektor](reference-sam-connector.md).
## Pelajari selengkapnya
Untuk informasi selengkapnya tentang penggunaan AWS SAM konektor, lihat topik berikut:
+ [AWS::Serverless::Connector](sam-resource-connector.md)
+ [Tentukan izin Baca dan Tulis di AWS SAM](connector-usage-define.md)
+ [Tentukan sumber daya dengan menggunakan properti lain yang didukung di AWS SAM](connector-usage-other-properties.md)
+ [Buat beberapa konektor dari satu sumber di AWS SAM](connector-usage-single-source.md)
+ [Buat konektor multi-tujuan di AWS SAM](connector-usage-multi-destination.md)
+ [Tentukan izin Baca dan Tulis di AWS SAM](connector-usage-define.md)
+ [Tentukan atribut sumber daya dengan konektor di AWS SAM](connector-usage-resource-attributes.md)
## Berikan umpan balik
Untuk memberikan umpan balik tentang konektor, [kirimkan masalah baru](https://github.com/aws/serverless-application-model/issues/new?assignees=&labels=area%2Fconnectors,stage%2Fneeds-triage&template=other.md&title=%28Feature%20Request%29) di *serverless-application-model AWS GitHubrepositori*.
# AWS SAM templat kebijakan
AWS Serverless Application Model (AWS SAM) memungkinkan Anda memilih dari daftar templat kebijakan untuk mencakup izin fungsi Lambda AWS Step Functions dan mesin status ke sumber daya yang digunakan oleh aplikasi Anda.
AWS SAM aplikasi dalam AWS Serverless Application Repository yang menggunakan templat kebijakan tidak memerlukan pengakuan pelanggan khusus untuk menyebarkan aplikasi dari. AWS Serverless Application Repository
Jika Anda ingin meminta agar templat kebijakan baru ditambahkan, lakukan hal berikut:
1. Kirim permintaan tarik terhadap file sumber policy\$1templates.json di cabang proyek. `develop` AWS SAM GitHub Anda dapat menemukan file sumber di [policy\$1templates.json](https://github.com/aws/serverless-application-model/blob/develop/samtranslator/policy_templates_data/policy_templates.json) di situs web. GitHub
1. Kirimkan masalah dalam AWS SAM GitHub proyek yang mencakup alasan permintaan tarik Anda dan tautan ke permintaan tersebut. Gunakan tautan ini untuk mengirimkan masalah baru: [AWS Serverless Application Model: Permasalahan](https://github.com/aws/serverless-application-model/issues/new).
## Sintaksis
Untuk setiap templat kebijakan yang Anda tentukan dalam file AWS SAM templat, Anda harus selalu menentukan objek yang berisi nilai placeholder templat kebijakan. Jika templat kebijakan tidak memerlukan nilai pengganti, Anda harus menentukan objek yang kosong.
### YAML
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Policies:
- PolicyTemplateName1: # Policy template with placeholder value
Key1: Value1
- PolicyTemplateName2: {} # Policy template with no placeholder value
```
**catatan**
Jika Anda telah menyiapkan kebijakan IAM reguler atau memiliki kebijakan terkelola melalui Lambda, templat kebijakan dapat disetel tanpa menggunakan objek kosong.
## Contoh
### Contoh 1: Templat kebijakan dengan nilai pengganti
Contoh berikut menunjukkan bahwa templat kebijakan [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) mengasumsikan `QueueName` sebagai sumber daya. AWS SAM Template mengambil nama antrian Amazon SQS `MyQueue` "", yang dapat Anda buat dalam aplikasi yang sama atau diminta sebagai parameter untuk aplikasi.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - SQSPollerPolicy:
9. QueueName:
10. !GetAtt MyQueue.QueueName
```
### Contoh 2: Templat kebijakan tanpa nilai pengganti
Contoh berikut berisi templat kebijakan [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy), yang tidak memiliki nilai pengganti.
**catatan**
Meskipun tidak ada nilai pengganti, Anda harus menentukan objek yang kosong, jika tidak ditentukan akan muncul sebuah kesalahan.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - CloudWatchPutMetricPolicy: {}
```
### Contoh 3: Template kebijakan dengan nilai placeholder dan kebijakan IAM reguler
Contoh berikut berisi kebijakan Amazon SQSFull Acess dan template [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) kebijakan. Kebijakan SQSFull Akses Amazon adalah kebijakan IAM dan bukan AWS SAM kebijakan, jadi Anda tidak perlu menentukan objek kosong karena kebijakan tersebut akan langsung diteruskan ke CloudFormation.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - AmazonSQSFullAccess // IAM policy could be set without passing an empty object
9. - DynamoDBCrudPolicy: // SAM specific policy, has a defined structure
10. TableName:
11. !Ref SampleTable
```
## Tabel templat kebijakan
Berikut ini adalah tabel templat kebijakan yang tersedia.
****
| Templat kebijakan | Deskripsi |
| --- | --- |
| [AcmGetCertificatePolicy](serverless-policy-template-list.md#acm-get-certificate-policy) | Memberikan izin untuk membaca sertifikat dari AWS Certificate Manager. |
| [AMIDescribePolicy](serverless-policy-template-list.md#ami-describe-policy) | Memberikan izin untuk mendeskripsikan Amazon Machine Images (AMIs). |
| [AthenaQueryPolicy](serverless-policy-template-list.md#athena-query-policy) | Memberikan izin untuk mengeksekusi kueri Athena. |
| [AWSSecretsManagerGetSecretValuePolicy](serverless-policy-template-list.md#secrets-manager-get-secret-value-policy) | Memberikan izin agar mendapatkan nilai rahasia untuk rahasia AWS Secrets Manager yang ditentukan. |
| [AWSSecretsManagerRotationPolicy](serverless-policy-template-list.md#secrets-manager-rotation-policy) | Memberikan izin untuk merotasi rahasia di AWS Secrets Manager. |
| [CloudFormationDescribeStacksPolicy](serverless-policy-template-list.md#cloud-formation-describe-stacks-policy) | Memberikan izin untuk menggambarkan CloudFormation tumpukan. |
| [CloudWatchDashboardPolicy](serverless-policy-template-list.md#cloudwatch-dashboard-policy) | Memberikan izin untuk menempatkan metrik untuk beroperasi di CloudWatch dasbor. |
| [CloudWatchDescribeAlarmHistoryPolicy](serverless-policy-template-list.md#cloudwatch-describe-alarm-history-policy) | Memberikan izin untuk menggambarkan riwayat CloudWatch alarm. |
| [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy) | Memberikan izin untuk mengirim metrik ke CloudWatch. |
| [CodeCommitCrudPolicy](serverless-policy-template-list.md#codecommit-crud-policy) | Memberikan izin ke create/read/update/delete objek dalam CodeCommit repositori tertentu. |
| [CodeCommitReadPolicy](serverless-policy-template-list.md#codecommit-read-policy) | Memberikan izin untuk membaca objek dalam CodeCommit repositori tertentu. |
| [CodePipelineLambdaExecutionPolicy](serverless-policy-template-list.md#code-pipeline-lambda-execution-policy) | Memberikan izin untuk fungsi Lambda yang dipanggil oleh CodePipeline untuk melaporkan status pekerjaan. |
| [CodePipelineReadOnlyPolicy](serverless-policy-template-list.md#code-pipeline-readonly-policy) | Memberikan izin baca untuk mendapatkan detail tentang CodePipeline pipa. |
| [ComprehendBasicAccessPolicy](serverless-policy-template-list.md#comprehend-basic-access-policy) | Memberikan izin untuk mendeteksi entitas, frasa kunci, bahasa, dan sentimen. |
| [CostExplorerReadOnlyPolicy](serverless-policy-template-list.md#cost-explorer-readonly-policy) | Memberikan izin hanya-baca ke Cost APIs Explorer hanya-baca untuk riwayat penagihan. |
| [DynamoDBBackupFullAccessPolicy](serverless-policy-template-list.md#ddb-back-full-policy) | Memberikan izin membaca dan menulis pada pencadangan sesuuai permintaan DynamoDB untuk tabel. |
| [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) | Memberikan izin untuk membuat, membaca, memperbarui, dan menghapus pada tabel Amazon DynamoDB. |
| [DynamoDBReadPolicy](serverless-policy-template-list.md#dynamo-db-read-policy) | Memberikan izin baca-saja pada tabel DynamoDB. |
| [DynamoDBReconfigurePolicy](serverless-policy-template-list.md#dynamo-db-reconfigure-policy) | Memberikan izin untuk mengonfigurasi ulang tabel DynamoDB. |
| [DynamoDBRestoreFromBackupPolicy](serverless-policy-template-list.md#ddb-restore-from-backup-policy) | Memberikan izin untuk memulihkan tabel DynamoDB dari cadangan. |
| [DynamoDBStreamReadPolicy](serverless-policy-template-list.md#dynamo-db-stream-read-policy) | Memberikan izin untuk menjelaskan dan membaca aliran dan catatan DynamoDB. |
| [DynamoDBWritePolicy](serverless-policy-template-list.md#dynamo-db-write-policy) | Memberikan izin tulis-saja pada tabel DynamoDB. |
| [EC2CopyImagePolicy](serverless-policy-template-list.md#ec2-copy-image-policy) | Memberikan izin untuk menyalin citra Amazon EC2. |
| [EC2DescribePolicy](serverless-policy-template-list.md#ec2-describe-policy) | Memberikan izin untuk menjelaskan instans Amazon Elastic Compute Cloud (Amazon EC2). |
| [EcsRunTaskPolicy](serverless-policy-template-list.md#ecs-run-task-policy) | Memberikan izin agar dapat memulai tugas baru untuk definisi tugas. |
| [EFSWriteAccessPolicy](serverless-policy-template-list.md#efs-write-access-policy) | Memberikan izin untuk memasang sistem file Amazon EFS dengan akses tulis. |
| [EKSDescribePolicy](serverless-policy-template-list.md#eks-describe-policy) | Memberikan izin untuk menjelaskan atau membuat daftar klaster Amazon EKS. |
| [ElasticMapReduceAddJobFlowStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-add-job-flows-policy) | Memberikan izin untuk menambahkan langkah-langkah baru agar dapat menjalankan klaster. |
| [ElasticMapReduceCancelStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-cancel-steps-policy) | Memberikan izin untuk membatalkan langkah yang tertunda atau langkah-langkah pada klaster yang sedang berjalan. |
| [ElasticMapReduceModifyInstanceFleetPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-fleet-policy) | Memberikan izin untuk membuat daftar detail dan mengubah kapasitas untuk armada instans dalam sebuah klaster. |
| [ElasticMapReduceModifyInstanceGroupsPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-groups-policy) | Memberikan izin untuk membuat daftar detail dan mengubah pengaturan pada grup instans dalam klaster. |
| [ElasticMapReduceSetTerminationProtectionPolicy](serverless-policy-template-list.md#elastic-map-reduce-set-termination-protection-policy) | Memberikan izin untuk mengatur perlindungan terminasi pada klaster. |
| [ElasticMapReduceTerminateJobFlowsPolicy](serverless-policy-template-list.md#elastic-map-reduce-terminate-job-flows-policy) | Memberikan izin untuk menutup klaster. |
| [ElasticsearchHttpPostPolicy](serverless-policy-template-list.md#elastic-search-http-post-policy) | Memberikan izin POST ke Amazon OpenSearch Service. |
| [EventBridgePutEventsPolicy](serverless-policy-template-list.md#eventbridge-put-events-policy) | Memberikan izin untuk mengirim acara ke EventBridge. |
| [FilterLogEventsPolicy](serverless-policy-template-list.md#filter-log-events-policy) | Memberikan izin untuk memfilter peristiwa CloudWatch Log dari grup log tertentu. |
| [FirehoseCrudPolicy](serverless-policy-template-list.md#firehose-crud-policy) | Memberikan izin untuk membuat, menulis, memperbarui, dan menghapus aliran pengiriman Firehose. |
| [FirehoseWritePolicy](serverless-policy-template-list.md#firehose-write-policy) | Memberikan izin untuk menulis ke aliran pengiriman Firehose. |
| [KinesisCrudPolicy](serverless-policy-template-list.md#kinesis-crud-policy) | Memberikan izin untuk membuat, memublikasikan, dan menghapus aliran Amazon Kinesis. |
| [KinesisStreamReadPolicy](serverless-policy-template-list.md#kinesis-stream-read-policy) | Memberikan izin untuk membuat daftar dan membaca aliran Amazon Kinesis. |
| [KMSDecryptPolicy](serverless-policy-template-list.md#kms-decrypt-policy) | Memberikan izin untuk mendekripsi dengan kunci AWS Key Management Service (AWS KMS). |
| [KMSEncryptPolicy](serverless-policy-template-list.md#kms-encrypt-policy) | Memberikan izin untuk mengenkripsi dengan kunci AWS Key Management Service (AWS KMS). |
| [LambdaInvokePolicy](serverless-policy-template-list.md#lambda-invoke-policy) | Memberikan izin untuk memanggil AWS Lambda fungsi, alias, atau versi. |
| [MobileAnalyticsWriteOnlyAccessPolicy](serverless-policy-template-list.md#mobile-analytics-write-only-access-policy) | Memberikan izin tulis-saja agar dapat menempatkan data kejadian untuk semua sumber daya aplikasi. |
| [OrganizationsListAccountsPolicy](serverless-policy-template-list.md#organizations-list-accounts-policy) | Memberikan izin hanya-baca untuk mencantumkan nama akun anak dan. IDs |
| [PinpointEndpointAccessPolicy](serverless-policy-template-list.md#pinpoint-endpoint-access-policy) | Memberikan izin agar mendapatkan serta memperbarui titik akhir untuk aplikasi Amazon Pinpoint. |
| [PollyFullAccessPolicy](serverless-policy-template-list.md#polly-full-access-policy) | Memberikan izin akses penuh ke sumber leksikon Amazon Polly. |
| [RekognitionDetectOnlyPolicy](serverless-policy-template-list.md#rekognition-detect-only-policy) | Memberikan izin untuk mendeteksi wajah, label, dan teks. |
| [RekognitionFacesManagementPolicy](serverless-policy-template-list.md#rekognition-face-management-policy) | Memberikan izin untuk menambah, menghapus, dan mencari wajah di koleksi Amazon Rekognition. |
| [RekognitionFacesPolicy](serverless-policy-template-list.md#rekognition-faces-policy) | Memberikan izin untuk membandingkan dan mendeteksi wajah serta label. |
| [RekognitionLabelsPolicy](serverless-policy-template-list.md#rekognition-labels-policy) | Memberikan izin untuk mendeteksi objek dan moderasi pada label. |
| [RekognitionNoDataAccessPolicy](serverless-policy-template-list.md#rekognition-no-data-access-policy) | Memberikan izin untuk membandingkan dan mendeteksi wajah serta label. |
| [RekognitionReadPolicy](serverless-policy-template-list.md#rekognition-read-policy) | Memberikan izin untuk membuat daftar dan mencari wajah. |
| [RekognitionWriteOnlyAccessPolicy](serverless-policy-template-list.md#rekognition-write-only-access-policy) | Memberikan izin untuk membuat koleksi dan indeks wajah. |
| [Route53ChangeResourceRecordSetsPolicy](serverless-policy-template-list.md#route53-change-resource-record-sets-policy) | Memberikan izin untuk mengubah set catatan sumber daya di Route 53. |
| [S3CrudPolicy](serverless-policy-template-list.md#s3-crud-policy) | Memberikan izin untuk membuat, membaca, memperbarui, dan menghapus untuk bertindak di objek dalam bucket Amazon S3. |
| [S3FullAccessPolicy](serverless-policy-template-list.md#s3-full-access-policy) | Memberikan izin akses penuh agar dapat bertindak pada objek dalam bucket Amazon S3. |
| [S3ReadPolicy](serverless-policy-template-list.md#s3-read-policy) | Memberikan izin baca-saja untuk membaca objek di bucket Amazon Simple Storage Service (Amazon S3). |
| [S3WritePolicy](serverless-policy-template-list.md#s3-write-policy) | Memberikan izin menulis untuk menulis objek ke dalam bucket Amazon S3. |
| [SageMakerCreateEndpointConfigPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-config-policy) | Memberikan izin untuk membuat konfigurasi titik akhir di SageMaker AI. |
| [SageMakerCreateEndpointPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-policy) | Memberikan izin untuk membuat titik akhir di SageMaker AI. |
| [ServerlessRepoReadWriteAccessPolicy](serverless-policy-template-list.md#serverlessrepo-read-write-access-policy) | Memberikan izin untuk membuat dan membuat daftar aplikasi dalam AWS Serverless Application Repository layanan. |
| [SESBulkTemplatedCrudPolicy](serverless-policy-template-list.md#ses-bulk-templated-crud-policy) | Memberikan izin untuk mengirimkan email, templat email, templat email massal, dan melakukan verifikasi identitas. |
| [SESBulkTemplatedCrudPolicy\$1v2](serverless-policy-template-list.md#ses-bulk-templated-crud-policy-v2) | Memberikan izin untuk mengirim email Amazon SES, email yang ditemplat, dan templat email massal serta agar menjalankan verifikasi identitas. |
| [SESCrudPolicy](serverless-policy-template-list.md#ses-crud-policy) | Memberikan izin untuk mengirim email dan memverifikasi identitas. |
| [SESEmailTemplateCrudPolicy](serverless-policy-template-list.md#ses-email-template-crud-policy) | Memberikan izin untuk membuat, mendapatkan, membuat daftar, memperbarui dan menghapus templat email Amazon SES. |
| [SESSendBouncePolicy](serverless-policy-template-list.md#ses-send-bounce-policy) | Memberikan SendBounce izin ke identitas Amazon Simple Email Service (Amazon SES). |
| [SNSCrudPolicy](serverless-policy-template-list.md#sns-crud-policy) | Memberikan izin untuk membuat, memublikasikan, dan berlangganan pada topik Amazon SNS. |
| [SNSPublishMessagePolicy](serverless-policy-template-list.md#sqs-publish-message-policy) | Memberikan izin untuk memublikasikan pesan ke topik Amazon Simple Notification Service (Amazon SNS). |
| [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) | Memberikan izin untuk polling antrean Amazon Simple Queue Service (Amazon SQS). |
| [SQSSendMessagePolicy](serverless-policy-template-list.md#sqs-send-message-policy) | Memberikan izin untuk mengirim pesan ke antrean Amazon SQS. |
| [SSMParameterReadPolicy](serverless-policy-template-list.md#ssm-parameter-read-policy) | Memberikan izin untuk mengakses parameter dari penyimpanan parameter Amazon EC2 Systems Manager (SSM) untuk memuat rahasia di akun ini. Gunakan ketika nama parameter tidak memiliki awalan garis miring. |
| [SSMParameterWithSlashPrefixReadPolicy](serverless-policy-template-list.md#ssm-parameter-slash-read-policy) | Memberikan izin untuk mengakses parameter dari penyimpanan parameter Amazon EC2 Systems Manager (SSM) untuk memuat rahasia di akun ini. Gunakan ketika nama parameter memiliki awalan garis miring. |
| [StepFunctionsExecutionPolicy](serverless-policy-template-list.md#stepfunctions-execution-policy) | Memberikan izin untuk memulai eksekusi pada mesin keadaan Step Functions. |
| [TextractDetectAnalyzePolicy](serverless-policy-template-list.md#textract-detect-analyze-policy) | Memberikan akses untuk mendeteksi dan menganalisia dokumen menggunakan Amazon Textract. |
| [TextractGetResultPolicy](serverless-policy-template-list.md#textract-get-result-policy) | Memberikan akses untuk mendapatkan dokumen yang terdeteksi dan teranalisis dari Amazon Textract. |
| [TextractPolicy](serverless-policy-template-list.md#textract-policy) | Memberikan akses penuh menuju Amazon Textract. |
| [VPCAccessPolicy](serverless-policy-template-list.md#vpc-access-policy) | Memberikan akses untuk membuat, menghapus, menjelaskan, dan melepaskan antarmuka jaringan elastis. |
## Pemecahan masalah
### Kesalahan SAM CLI: “Harus menentukan nilai parameter yang valid untuk templat kebijakan policy-template-name '< >'”
Saat mengeksekusi `sam build`, Anda akan melihat kesalahan berikut:
```
"Must specify valid parameter values for policy template ''"
```
Kesalahan tersebut berarti bahwa Anda tidak dapat melewati objek kosong ketika menyatakan templat kebijakan yang tidak memiliki nilai pengganti.
Untuk memperbaikinya, nyatakan kebijakan seperti contoh berikut untuk [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy).
```
1. MyFunction:
2. Policies:
3. - CloudWatchPutMetricPolicy: {}
```
# AWS SAM daftar templat kebijakan
Berikut ini adalah templat kebijakan yang tersedia, bersama dengan izin yang diterapkan untuk masing-masing templat kebijakan. AWS Serverless Application Model (AWS SAM) secara otomatis mengisi item placeholder (seperti AWS Wilayah dan ID akun) dengan informasi yang sesuai.
**Topics**
+ [
## AcmGetCertificatePolicy
](#acm-get-certificate-policy)
+ [
## AMIDescribePolicy
](#ami-describe-policy)
+ [
## AthenaQueryPolicy
](#athena-query-policy)
+ [
## AWSSecretsManagerGetSecretValuePolicy
](#secrets-manager-get-secret-value-policy)
+ [
## AWSSecretsManagerRotationPolicy
](#secrets-manager-rotation-policy)
+ [
## CloudFormationDescribeStacksPolicy
](#cloud-formation-describe-stacks-policy)
+ [
## CloudWatchDashboardPolicy
](#cloudwatch-dashboard-policy)
+ [
## CloudWatchDescribeAlarmHistoryPolicy
](#cloudwatch-describe-alarm-history-policy)
+ [
## CloudWatchPutMetricPolicy
](#cloudwatch-put-metric-policy)
+ [
## CodePipelineLambdaExecutionPolicy
](#code-pipeline-lambda-execution-policy)
+ [
## CodePipelineReadOnlyPolicy
](#code-pipeline-readonly-policy)
+ [
## CodeCommitCrudPolicy
](#codecommit-crud-policy)
+ [
## CodeCommitReadPolicy
](#codecommit-read-policy)
+ [
## ComprehendBasicAccessPolicy
](#comprehend-basic-access-policy)
+ [
## CostExplorerReadOnlyPolicy
](#cost-explorer-readonly-policy)
+ [
## DynamoDBBackupFullAccessPolicy
](#ddb-back-full-policy)
+ [
## DynamoDBCrudPolicy
](#dynamo-db-crud-policy)
+ [
## DynamoDBReadPolicy
](#dynamo-db-read-policy)
+ [
## DynamoDBReconfigurePolicy
](#dynamo-db-reconfigure-policy)
+ [
## DynamoDBRestoreFromBackupPolicy
](#ddb-restore-from-backup-policy)
+ [
## DynamoDBStreamReadPolicy
](#dynamo-db-stream-read-policy)
+ [
## DynamoDBWritePolicy
](#dynamo-db-write-policy)
+ [
## EC2CopyImagePolicy
](#ec2-copy-image-policy)
+ [
## EC2DescribePolicy
](#ec2-describe-policy)
+ [
## EcsRunTaskPolicy
](#ecs-run-task-policy)
+ [
## EFSWriteAccessPolicy
](#efs-write-access-policy)
+ [
## EKSDescribePolicy
](#eks-describe-policy)
+ [
## ElasticMapReduceAddJobFlowStepsPolicy
](#elastic-map-reduce-add-job-flows-policy)
+ [
## ElasticMapReduceCancelStepsPolicy
](#elastic-map-reduce-cancel-steps-policy)
+ [
## ElasticMapReduceModifyInstanceFleetPolicy
](#elastic-map-reduce-modify-instance-fleet-policy)
+ [
## ElasticMapReduceModifyInstanceGroupsPolicy
](#elastic-map-reduce-modify-instance-groups-policy)
+ [
## ElasticMapReduceSetTerminationProtectionPolicy
](#elastic-map-reduce-set-termination-protection-policy)
+ [
## ElasticMapReduceTerminateJobFlowsPolicy
](#elastic-map-reduce-terminate-job-flows-policy)
+ [
## ElasticsearchHttpPostPolicy
](#elastic-search-http-post-policy)
+ [
## EventBridgePutEventsPolicy
](#eventbridge-put-events-policy)
+ [
## FilterLogEventsPolicy
](#filter-log-events-policy)
+ [
## FirehoseCrudPolicy
](#firehose-crud-policy)
+ [
## FirehoseWritePolicy
](#firehose-write-policy)
+ [
## KinesisCrudPolicy
](#kinesis-crud-policy)
+ [
## KinesisStreamReadPolicy
](#kinesis-stream-read-policy)
+ [
## KMSDecryptPolicy
](#kms-decrypt-policy)
+ [
## KMSEncryptPolicy
](#kms-encrypt-policy)
+ [
## LambdaInvokePolicy
](#lambda-invoke-policy)
+ [
## MobileAnalyticsWriteOnlyAccessPolicy
](#mobile-analytics-write-only-access-policy)
+ [
## OrganizationsListAccountsPolicy
](#organizations-list-accounts-policy)
+ [
## PinpointEndpointAccessPolicy
](#pinpoint-endpoint-access-policy)
+ [
## PollyFullAccessPolicy
](#polly-full-access-policy)
+ [
## RekognitionDetectOnlyPolicy
](#rekognition-detect-only-policy)
+ [
## RekognitionFacesManagementPolicy
](#rekognition-face-management-policy)
+ [
## RekognitionFacesPolicy
](#rekognition-faces-policy)
+ [
## RekognitionLabelsPolicy
](#rekognition-labels-policy)
+ [
## RekognitionNoDataAccessPolicy
](#rekognition-no-data-access-policy)
+ [
## RekognitionReadPolicy
](#rekognition-read-policy)
+ [
## RekognitionWriteOnlyAccessPolicy
](#rekognition-write-only-access-policy)
+ [
## Route53ChangeResourceRecordSetsPolicy
](#route53-change-resource-record-sets-policy)
+ [
## S3CrudPolicy
](#s3-crud-policy)
+ [
## S3FullAccessPolicy
](#s3-full-access-policy)
+ [
## S3ReadPolicy
](#s3-read-policy)
+ [
## S3WritePolicy
](#s3-write-policy)
+ [
## SageMakerCreateEndpointConfigPolicy
](#sagemaker-create-endpoint-config-policy)
+ [
## SageMakerCreateEndpointPolicy
](#sagemaker-create-endpoint-policy)
+ [
## ServerlessRepoReadWriteAccessPolicy
](#serverlessrepo-read-write-access-policy)
+ [
## SESBulkTemplatedCrudPolicy
](#ses-bulk-templated-crud-policy)
+ [
## SESBulkTemplatedCrudPolicy\$1v2
](#ses-bulk-templated-crud-policy-v2)
+ [
## SESCrudPolicy
](#ses-crud-policy)
+ [
## SESEmailTemplateCrudPolicy
](#ses-email-template-crud-policy)
+ [
## SESSendBouncePolicy
](#ses-send-bounce-policy)
+ [
## SNSCrudPolicy
](#sns-crud-policy)
+ [
## SNSPublishMessagePolicy
](#sqs-publish-message-policy)
+ [
## SQSPollerPolicy
](#sqs-poller-policy)
+ [
## SQSSendMessagePolicy
](#sqs-send-message-policy)
+ [
## SSMParameterReadPolicy
](#ssm-parameter-read-policy)
+ [
## SSMParameterWithSlashPrefixReadPolicy
](#ssm-parameter-slash-read-policy)
+ [
## StepFunctionsExecutionPolicy
](#stepfunctions-execution-policy)
+ [
## TextractDetectAnalyzePolicy
](#textract-detect-analyze-policy)
+ [
## TextractGetResultPolicy
](#textract-get-result-policy)
+ [
## TextractPolicy
](#textract-policy)
+ [
## VPCAccessPolicy
](#vpc-access-policy)
## AcmGetCertificatePolicy
Memberikan izin untuk membaca sertifikat dari AWS Certificate Manager.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"acm:GetCertificate"
],
"Resource": {
"Fn::Sub": [
"${certificateArn}",
{
"certificateArn": {
"Ref": "CertificateArn"
}
}
]
}
}
]
```
## AMIDescribePolicy
Memberikan izin untuk mendeskripsikan Amazon Machine Images (AMIs).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeImages"
],
"Resource": "*"
}
]
```
## AthenaQueryPolicy
Memberikan izin untuk mengeksekusi kueri Athena.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListWorkGroups",
"athena:GetExecutionEngine",
"athena:GetExecutionEngines",
"athena:GetNamespace",
"athena:GetCatalogs",
"athena:GetNamespaces",
"athena:GetTables",
"athena:GetTable"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"athena:StartQueryExecution",
"athena:GetQueryResults",
"athena:DeleteNamedQuery",
"athena:GetNamedQuery",
"athena:ListQueryExecutions",
"athena:StopQueryExecution",
"athena:GetQueryResultsStream",
"athena:ListNamedQueries",
"athena:CreateNamedQuery",
"athena:GetQueryExecution",
"athena:BatchGetNamedQuery",
"athena:BatchGetQueryExecution",
"athena:GetWorkGroup"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:athena:${AWS::Region}:${AWS::AccountId}:workgroup/${workgroupName}",
{
"workgroupName": {
"Ref": "WorkGroupName"
}
}
]
}
}
]
```
## AWSSecretsManagerGetSecretValuePolicy
Memberikan izin untuk mendapatkan nilai rahasia untuk AWS Secrets Manager rahasia yang ditentukan.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": {
"Fn::Sub": [
"${secretArn}",
{
"secretArn": {
"Ref": "SecretArn"
}
}
]
}
}
]
```
## AWSSecretsManagerRotationPolicy
Memberikan izin untuk merotasi rahasia di AWS Secrets Manager.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:DescribeSecret",
"secretsmanager:GetSecretValue",
"secretsmanager:PutSecretValue",
"secretsmanager:UpdateSecretVersionStage"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:secretsmanager:${AWS::Region}:${AWS::AccountId}:secret:*"
},
"Condition": {
"StringEquals": {
"secretsmanager:resource/AllowRotationLambdaArn": {
"Fn::Sub": [
"arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}",
{
"functionName": {
"Ref": "FunctionName"
}
}
]
}
}
}
},
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword"
],
"Resource": "*"
}
]
```
## CloudFormationDescribeStacksPolicy
Memberikan izin untuk menggambarkan CloudFormation tumpukan.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:cloudformation:${AWS::Region}:${AWS::AccountId}:stack/*"
}
}
]
```
## CloudWatchDashboardPolicy
Memberikan izin untuk menempatkan metrik untuk beroperasi di CloudWatch dasbor.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetDashboard",
"cloudwatch:ListDashboards",
"cloudwatch:PutDashboard",
"cloudwatch:ListMetrics"
],
"Resource": "*"
}
]
```
## CloudWatchDescribeAlarmHistoryPolicy
Memberikan izin untuk menggambarkan riwayat CloudWatch alarm Amazon.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:DescribeAlarmHistory"
],
"Resource": "*"
}
]
```
## CloudWatchPutMetricPolicy
Memberikan izin untuk mengirim metrik ke CloudWatch.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*"
}
]
```
## CodePipelineLambdaExecutionPolicy
Memberikan izin untuk fungsi Lambda yang dipanggil oleh AWS CodePipeline untuk melaporkan status pekerjaan.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:PutJobSuccessResult",
"codepipeline:PutJobFailureResult"
],
"Resource": "*"
}
]
```
## CodePipelineReadOnlyPolicy
Memberikan izin baca untuk mendapatkan detail tentang CodePipeline pipa.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:ListPipelineExecutions"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codepipeline:${AWS::Region}:${AWS::AccountId}:${pipelinename}",
{
"pipelinename": {
"Ref": "PipelineName"
}
}
]
}
}
]
```
## CodeCommitCrudPolicy
Memberikan izin untuk membuat, membaca, memperbarui, dan menghapus objek dalam CodeCommit repositori tertentu.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull",
"codecommit:GitPush",
"codecommit:CreateBranch",
"codecommit:DeleteBranch",
"codecommit:GetBranch",
"codecommit:ListBranches",
"codecommit:MergeBranchesByFastForward",
"codecommit:MergeBranchesBySquash",
"codecommit:MergeBranchesByThreeWay",
"codecommit:UpdateDefaultBranch",
"codecommit:BatchDescribeMergeConflicts",
"codecommit:CreateUnreferencedMergeCommit",
"codecommit:DescribeMergeConflicts",
"codecommit:GetMergeCommit",
"codecommit:GetMergeOptions",
"codecommit:BatchGetPullRequests",
"codecommit:CreatePullRequest",
"codecommit:DescribePullRequestEvents",
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommitsFromMergeBase",
"codecommit:GetMergeConflicts",
"codecommit:GetPullRequest",
"codecommit:ListPullRequests",
"codecommit:MergePullRequestByFastForward",
"codecommit:MergePullRequestBySquash",
"codecommit:MergePullRequestByThreeWay",
"codecommit:PostCommentForPullRequest",
"codecommit:UpdatePullRequestDescription",
"codecommit:UpdatePullRequestStatus",
"codecommit:UpdatePullRequestTitle",
"codecommit:DeleteFile",
"codecommit:GetBlob",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:PutFile",
"codecommit:DeleteCommentContent",
"codecommit:GetComment",
"codecommit:GetCommentsForComparedCommit",
"codecommit:PostCommentForComparedCommit",
"codecommit:PostCommentReply",
"codecommit:UpdateComment",
"codecommit:BatchGetCommits",
"codecommit:CreateCommit",
"codecommit:GetCommit",
"codecommit:GetCommitHistory",
"codecommit:GetDifferences",
"codecommit:GetObjectIdentifier",
"codecommit:GetReferences",
"codecommit:GetTree",
"codecommit:GetRepository",
"codecommit:UpdateRepositoryDescription",
"codecommit:ListTagsForResource",
"codecommit:TagResource",
"codecommit:UntagResource",
"codecommit:GetRepositoryTriggers",
"codecommit:PutRepositoryTriggers",
"codecommit:TestRepositoryTriggers",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:UploadArchive",
"codecommit:GetUploadArchiveStatus",
"codecommit:CancelUploadArchive"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
{
"repositoryName": {
"Ref": "RepositoryName"
}
}
]
}
}
]
```
## CodeCommitReadPolicy
Memberikan izin untuk membaca objek dalam CodeCommit repositori tertentu.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull",
"codecommit:GetBranch",
"codecommit:ListBranches",
"codecommit:BatchDescribeMergeConflicts",
"codecommit:DescribeMergeConflicts",
"codecommit:GetMergeCommit",
"codecommit:GetMergeOptions",
"codecommit:BatchGetPullRequests",
"codecommit:DescribePullRequestEvents",
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommitsFromMergeBase",
"codecommit:GetMergeConflicts",
"codecommit:GetPullRequest",
"codecommit:ListPullRequests",
"codecommit:GetBlob",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:GetComment",
"codecommit:GetCommentsForComparedCommit",
"codecommit:BatchGetCommits",
"codecommit:GetCommit",
"codecommit:GetCommitHistory",
"codecommit:GetDifferences",
"codecommit:GetObjectIdentifier",
"codecommit:GetReferences",
"codecommit:GetTree",
"codecommit:GetRepository",
"codecommit:ListTagsForResource",
"codecommit:GetRepositoryTriggers",
"codecommit:TestRepositoryTriggers",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:GetUploadArchiveStatus"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
{
"repositoryName": {
"Ref": "RepositoryName"
}
}
]
}
}
]
```
## ComprehendBasicAccessPolicy
Memberikan izin untuk mendeteksi entitas, frasa kunci, bahasa, dan sentimen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"comprehend:BatchDetectKeyPhrases",
"comprehend:DetectDominantLanguage",
"comprehend:DetectEntities",
"comprehend:BatchDetectEntities",
"comprehend:DetectKeyPhrases",
"comprehend:DetectSentiment",
"comprehend:BatchDetectDominantLanguage",
"comprehend:BatchDetectSentiment"
],
"Resource": "*"
}
]
```
## CostExplorerReadOnlyPolicy
Memberikan izin hanya-baca ke read-only (Cost AWS Cost Explorer Explorer) APIs untuk riwayat penagihan.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ce:GetCostAndUsage",
"ce:GetDimensionValues",
"ce:GetReservationCoverage",
"ce:GetReservationPurchaseRecommendation",
"ce:GetReservationUtilization",
"ce:GetTags"
],
"Resource": "*"
}
]
```
## DynamoDBBackupFullAccessPolicy
Memberikan izin membaca dan menulis pada pencadangan sesuuai permintaan DynamoDB untuk tabel.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:CreateBackup",
"dynamodb:DescribeContinuousBackups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:DeleteBackup",
"dynamodb:DescribeBackup",
"dynamodb:ListBackups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBCrudPolicy
Memberikan izin untuk membuat, membaca, memperbarui, dan menghapus pada tabel Amazon DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:DeleteItem",
"dynamodb:PutItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:UpdateItem",
"dynamodb:BatchWriteItem",
"dynamodb:BatchGetItem",
"dynamodb:DescribeTable",
"dynamodb:ConditionCheckItem"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## DynamoDBReadPolicy
Memberikan izin baca-saja pada tabel DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:BatchGetItem",
"dynamodb:DescribeTable"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## DynamoDBReconfigurePolicy
Memberikan izin untuk mengonfigurasi ulang tabel DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateTable"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBRestoreFromBackupPolicy
Memberikan izin untuk memulihkan tabel DynamoDB dari cadangan.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:RestoreTableFromBackup"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:BatchWriteItem"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBStreamReadPolicy
Memberikan izin untuk menjelaskan dan membaca aliran dan catatan DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeStream",
"dynamodb:GetRecords",
"dynamodb:GetShardIterator"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/${streamName}",
{
"tableName": {
"Ref": "TableName"
},
"streamName": {
"Ref": "StreamName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:ListStreams"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBWritePolicy
Memberikan izin tulis-saja pada tabel DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:BatchWriteItem"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## EC2CopyImagePolicy
Memberikan izin untuk menyalin EC2 gambar Amazon.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CopyImage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ec2:${AWS::Region}:${AWS::AccountId}:image/${imageId}",
{
"imageId": {
"Ref": "ImageId"
}
}
]
}
}
]
```
## EC2DescribePolicy
Memberikan izin untuk mendeskripsikan instans Amazon Elastic Compute Cloud (Amazon EC2).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeRegions",
"ec2:DescribeInstances"
],
"Resource": "*"
}
]
```
## EcsRunTaskPolicy
Memberikan izin agar dapat memulai tugas baru untuk definisi tugas.
```
"Statement": [
{
"Action": [
"ecs:RunTask"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ecs:${AWS::Region}:${AWS::AccountId}:task-definition/${taskDefinition}",
{
"taskDefinition": {
"Ref": "TaskDefinition"
}
}
]
},
"Effect": "Allow"
}
]
```
## EFSWriteAccessPolicy
Memberikan izin untuk memasang sistem file Amazon EFS dengan akses tulis.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticfilesystem:ClientMount",
"elasticfilesystem:ClientWrite"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:file-system/${FileSystem}",
{
"FileSystem": {
"Ref": "FileSystem"
}
}
]
},
"Condition": {
"StringEquals": {
"elasticfilesystem:AccessPointArn": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:access-point/${AccessPoint}",
{
"AccessPoint": {
"Ref": "AccessPoint"
}
}
]
}
}
}
}
]
```
## EKSDescribePolicy
Memberikan izin untuk menjelaskan atau membuat daftar klaster Amazon Elastic Kubernetes Service (Amazon EKS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster",
"eks:ListClusters"
],
"Resource": "*"
}
]
```
## ElasticMapReduceAddJobFlowStepsPolicy
Memberikan izin untuk menambahkan langkah-langkah baru agar dapat menjalankan klaster.
```
"Statement": [
{
"Action": "elasticmapreduce:AddJobFlowSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceCancelStepsPolicy
Memberikan izin untuk membatalkan langkah yang tertunda atau langkah-langkah pada klaster yang sedang berjalan.
```
"Statement": [
{
"Action": "elasticmapreduce:CancelSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceFleetPolicy
Memberikan izin untuk membuat daftar detail dan mengubah kapasitas untuk armada instans dalam sebuah klaster.
```
"Statement": [
{
"Action": [
"elasticmapreduce:ModifyInstanceFleet",
"elasticmapreduce:ListInstanceFleets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceGroupsPolicy
Memberikan izin untuk membuat daftar detail dan mengubah pengaturan pada grup instans dalam klaster.
```
"Statement": [
{
"Action": [
"elasticmapreduce:ModifyInstanceGroups",
"elasticmapreduce:ListInstanceGroups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceSetTerminationProtectionPolicy
Memberikan izin untuk mengatur perlindungan terminasi pada klaster.
```
"Statement": [
{
"Action": "elasticmapreduce:SetTerminationProtection",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceTerminateJobFlowsPolicy
Memberikan izin untuk menutup klaster.
```
"Statement": [
{
"Action": "elasticmapreduce:TerminateJobFlows",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticsearchHttpPostPolicy
Memberikan izin POST dan PUT ke OpenSearch Layanan Amazon.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpPost",
"es:ESHttpPut"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:es:${AWS::Region}:${AWS::AccountId}:domain/${domainName}/*",
{
"domainName": {
"Ref": "DomainName"
}
}
]
}
}
]
```
## EventBridgePutEventsPolicy
Memberikan izin untuk mengirim acara ke Amazon EventBridge.
```
"Statement": [
{
"Effect": "Allow",
"Action": "events:PutEvents",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:events:${AWS::Region}:${AWS::AccountId}:event-bus/${eventBusName}",
{
"eventBusName": {
"Ref": "EventBusName"
}
}
]
}
}
]
```
## FilterLogEventsPolicy
Memberikan izin untuk memfilter peristiwa CloudWatch Log dari grup log tertentu.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:FilterLogEvents"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:logs:${AWS::Region}:${AWS::AccountId}:log-group:${logGroupName}:log-stream:*",
{
"logGroupName": {
"Ref": "LogGroupName"
}
}
]
}
}
]
```
## FirehoseCrudPolicy
Memberikan izin untuk membuat, menulis, memperbarui, dan menghapus aliran pengiriman Firehose.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"firehose:CreateDeliveryStream",
"firehose:DeleteDeliveryStream",
"firehose:DescribeDeliveryStream",
"firehose:PutRecord",
"firehose:PutRecordBatch",
"firehose:UpdateDestination"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
{
"deliveryStreamName": {
"Ref": "DeliveryStreamName"
}
}
]
}
}
]
```
## FirehoseWritePolicy
Memberikan izin untuk menulis ke aliran pengiriman Firehose.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"firehose:PutRecord",
"firehose:PutRecordBatch"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
{
"deliveryStreamName": {
"Ref": "DeliveryStreamName"
}
}
]
}
}
]
```
## KinesisCrudPolicy
Memberikan izin untuk membuat, memublikasikan, dan menghapus aliran Amazon Kinesis.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:AddTagsToStream",
"kinesis:CreateStream",
"kinesis:DecreaseStreamRetentionPeriod",
"kinesis:DeleteStream",
"kinesis:DescribeStream",
"kinesis:DescribeStreamSummary",
"kinesis:GetShardIterator",
"kinesis:IncreaseStreamRetentionPeriod",
"kinesis:ListTagsForStream",
"kinesis:MergeShards",
"kinesis:PutRecord",
"kinesis:PutRecords",
"kinesis:SplitShard",
"kinesis:RemoveTagsFromStream"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
{
"streamName": {
"Ref": "StreamName"
}
}
]
}
}
]
```
## KinesisStreamReadPolicy
Memberikan izin untuk membuat daftar dan membaca aliran Amazon Kinesis.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:ListStreams",
"kinesis:DescribeLimits"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/*"
}
},
{
"Effect": "Allow",
"Action": [
"kinesis:DescribeStream",
"kinesis:DescribeStreamSummary",
"kinesis:GetRecords",
"kinesis:GetShardIterator"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
{
"streamName": {
"Ref": "StreamName"
}
}
]
}
}
]
```
## KMSDecryptPolicy
Memberikan izin untuk mendekripsi dengan kunci AWS Key Management Service (AWS KMS). Perhatikan bahwa `keyId` harus berupa ID AWS KMS kunci, dan bukan alias kunci.
```
"Statement": [
{
"Action": "kms:Decrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## KMSEncryptPolicy
Memberikan izin untuk mengenkripsi dengan AWS KMS kunci. Perhatikan bahwa KeyID harus berupa ID AWS KMS kunci, dan bukan alias kunci.
```
"Statement": [
{
"Action": "kms:Encrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## LambdaInvokePolicy
Memberikan izin untuk memanggil AWS Lambda fungsi, alias, atau versi.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}*",
{
"functionName": {
"Ref": "FunctionName"
}
}
]
}
}
]
```
## MobileAnalyticsWriteOnlyAccessPolicy
Memberikan izin tulis-saja agar dapat menempatkan data kejadian untuk semua sumber daya aplikasi.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobileanalytics:PutEvents"
],
"Resource": "*"
}
]
```
## OrganizationsListAccountsPolicy
Memberikan izin hanya-baca untuk mencantumkan nama akun anak dan. IDs
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"organizations:ListAccounts"
],
"Resource": "*"
}
]
```
## PinpointEndpointAccessPolicy
Memberikan izin agar mendapatkan serta memperbarui titik akhir untuk aplikasi Amazon Pinpoint.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobiletargeting:GetEndpoint",
"mobiletargeting:UpdateEndpoint",
"mobiletargeting:UpdateEndpointsBatch"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:mobiletargeting:${AWS::Region}:${AWS::AccountId}:apps/${pinpointApplicationId}/endpoints/*",
{
"pinpointApplicationId": {
"Ref": "PinpointApplicationId"
}
}
]
}
}
]
```
## PollyFullAccessPolicy
Memberikan izin akses penuh ke sumber leksikon Amazon Polly.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"polly:GetLexicon",
"polly:DeleteLexicon"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/${lexiconName}",
{
"lexiconName": {
"Ref": "LexiconName"
}
}
]
}
]
},
{
"Effect": "Allow",
"Action": [
"polly:DescribeVoices",
"polly:ListLexicons",
"polly:PutLexicon",
"polly:SynthesizeSpeech"
],
"Resource": [
{
"Fn::Sub": "arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/*"
}
]
}
]
```
## RekognitionDetectOnlyPolicy
Memberikan izin untuk mendeteksi wajah, label, dan teks.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels",
"rekognition:DetectText"
],
"Resource": "*"
}
]
```
## RekognitionFacesManagementPolicy
Memberikan izin untuk menambah, menghapus, dan mencari wajah di koleksi Amazon Rekognition.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:IndexFaces",
"rekognition:DeleteFaces",
"rekognition:SearchFaces",
"rekognition:SearchFacesByImage",
"rekognition:ListFaces"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionFacesPolicy
Memberikan izin untuk membandingkan dan mendeteksi wajah serta label.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces"
],
"Resource": "*"
}
]
```
## RekognitionLabelsPolicy
Memberikan izin untuk mendeteksi objek dan moderasi pada label.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": "*"
}
]
```
## RekognitionNoDataAccessPolicy
Memberikan izin untuk membandingkan dan mendeteksi wajah serta label.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionReadPolicy
Memberikan izin untuk membuat daftar dan mencari wajah.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:ListCollections",
"rekognition:ListFaces",
"rekognition:SearchFaces",
"rekognition:SearchFacesByImage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionWriteOnlyAccessPolicy
Memberikan izin untuk membuat koleksi dan indeks wajah.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CreateCollection",
"rekognition:IndexFaces"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## Route53ChangeResourceRecordSetsPolicy
Memberikan izin untuk mengubah set catatan sumber daya di Route 53.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"route53:ChangeResourceRecordSets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:route53:::hostedzone/${HostedZoneId}",
{
"HostedZoneId": {
"Ref": "HostedZoneId"
}
}
]
}
}
]
```
## S3CrudPolicy
Memberikan izin untuk membuat, membaca, memperbarui, dan menghapus untuk bertindak di objek dalam bucket Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:PutObjectAcl",
"s3:GetLifecycleConfiguration",
"s3:PutLifecycleConfiguration",
"s3:DeleteObject"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3FullAccessPolicy
Memberikan izin akses penuh agar dapat bertindak pada objek dalam bucket Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectAcl",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:PutObjectAcl",
"s3:DeleteObject",
"s3:DeleteObjectTagging",
"s3:DeleteObjectVersionTagging",
"s3:GetObjectTagging",
"s3:GetObjectVersionTagging",
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetLifecycleConfiguration",
"s3:PutLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3ReadPolicy
Memberikan izin baca-saja untuk membaca objek di bucket Amazon Simple Storage Service (Amazon S3).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetObjectVersion",
"s3:GetLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3WritePolicy
Memberikan izin menulis untuk menulis objek ke dalam bucket Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:PutLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## SageMakerCreateEndpointConfigPolicy
Memberikan izin untuk membuat konfigurasi titik akhir di SageMaker AI.
```
"Statement": [
{
"Action": [
"sagemaker:CreateEndpointConfig"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint-config/${endpointConfigName}",
{
"endpointConfigName": {
"Ref": "EndpointConfigName"
}
}
]
},
"Effect": "Allow"
}
]
```
## SageMakerCreateEndpointPolicy
Memberikan izin untuk membuat titik akhir di SageMaker AI.
```
"Statement": [
{
"Action": [
"sagemaker:CreateEndpoint"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint/${endpointName}",
{
"endpointName": {
"Ref": "EndpointName"
}
}
]
},
"Effect": "Allow"
}
]
```
## ServerlessRepoReadWriteAccessPolicy
Memberikan izin untuk membuat dan mendaftar aplikasi di layanan AWS Serverless Application Repository (AWS SAM).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"serverlessrepo:CreateApplication",
"serverlessrepo:CreateApplicationVersion",
"serverlessrepo:GetApplication",
"serverlessrepo:ListApplications",
"serverlessrepo:ListApplicationVersions"
],
"Resource": [
{
"Fn::Sub": "arn:${AWS::Partition}:serverlessrepo:${AWS::Region}:${AWS::AccountId}:applications/*"
}
]
}
]
```
## SESBulkTemplatedCrudPolicy
Memberikan izin untuk mengirim email Amazon SES, email yang ditemplat, dan templat email massal serta agar menjalankan verifikasi identitas.
**catatan**
`ses:SendTemplatedEmail`Tindakan ini membutuhkan template ARN. Gunakan `SESBulkTemplatedCrudPolicy_v2` sebagai gantinya.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:SendEmail",
"ses:SendRawEmail",
"ses:SendTemplatedEmail",
"ses:SendBulkTemplatedEmail",
"ses:VerifyEmailIdentity"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SESBulkTemplatedCrudPolicy\$1v2
Memberikan izin untuk mengirim email Amazon SES, email yang ditemplat, dan templat email massal serta agar menjalankan verifikasi identitas.
```
"Statement": [
{
"Action": [
"ses:SendEmail",
"ses:SendRawEmail",
"ses:SendTemplatedEmail",
"ses:SendBulkTemplatedEmail"
],
"Effect": "Allow",
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:template/${templateName}",
{
"templateName": {
"Ref": "TemplateName"
}
}
]
}
]
},
{
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:VerifyEmailIdentity"
],
"Effect": "Allow",
"Resource": "*"
}
]
```
## SESCrudPolicy
Memberikan izin untuk mengirim email dan memverifikasi identitas.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:SendEmail",
"ses:SendRawEmail",
"ses:VerifyEmailIdentity"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SESEmailTemplateCrudPolicy
Memberikan izin untuk membuat, mendapatkan, mendaftar, memperbarui, dan menghapus templat email Amazon SES.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:CreateTemplate",
"ses:GetTemplate",
"ses:ListTemplates",
"ses:UpdateTemplate",
"ses:DeleteTemplate",
"ses:TestRenderTemplate"
],
"Resource": "*"
}
]
```
## SESSendBouncePolicy
Memberikan SendBounce izin ke identitas Amazon Simple Email Service (Amazon SES).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:SendBounce"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SNSCrudPolicy
Memberikan izin untuk membuat, memublikasikan, dan berlangganan pada topik Amazon SNS.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:ListSubscriptionsByTopic",
"sns:CreateTopic",
"sns:SetTopicAttributes",
"sns:Subscribe",
"sns:Publish"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}*",
{
"topicName": {
"Ref": "TopicName"
}
}
]
}
}
]
```
## SNSPublishMessagePolicy
Memberikan izin untuk memublikasikan pesan ke topik Amazon Simple Notification Service (Amazon SNS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:Publish"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}",
{
"topicName": {
"Ref": "TopicName"
}
}
]
}
}
]
```
## SQSPollerPolicy
Memberikan izin untuk polling antrean Amazon Simple Queue Service (Amazon SQS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:ChangeMessageVisibility",
"sqs:ChangeMessageVisibilityBatch",
"sqs:DeleteMessage",
"sqs:DeleteMessageBatch",
"sqs:GetQueueAttributes",
"sqs:ReceiveMessage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SQSSendMessagePolicy
Memberikan izin untuk mengirim pesan ke antrean Amazon SQS.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:SendMessage*"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SSMParameterReadPolicy
Memberikan izin untuk mengakses parameter dari penyimpanan parameter Amazon EC2 Systems Manager (SSM) untuk memuat rahasia di akun ini. Gunakan ketika nama parameter tidak memiliki awalan garis miring.
**catatan**
Jika Anda tidak menggunakan kunci default, Anda juga akan membutuhkan kebijakan `KMSDecryptPolicy`.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:DescribeParameters"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ssm:GetParameters",
"ssm:GetParameter",
"ssm:GetParametersByPath"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter/${parameterName}",
{
"parameterName": {
"Ref": "ParameterName"
}
}
]
}
}
]
```
## SSMParameterWithSlashPrefixReadPolicy
Memberikan izin untuk mengakses parameter dari penyimpanan parameter Amazon EC2 Systems Manager (SSM) untuk memuat rahasia di akun ini. Gunakan ketika nama parameter memiliki awalan garis miring.
**catatan**
Jika Anda tidak menggunakan kunci default, Anda juga akan membutuhkan kebijakan `KMSDecryptPolicy`.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:DescribeParameters"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ssm:GetParameters",
"ssm:GetParameter",
"ssm:GetParametersByPath"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter${parameterName}",
{
"parameterName": {
"Ref": "ParameterName"
}
}
]
}
}
]
```
## StepFunctionsExecutionPolicy
Memberikan izin untuk memulai eksekusi pada mesin keadaan Step Functions.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"states:StartExecution"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:states:${AWS::Region}:${AWS::AccountId}:stateMachine:${stateMachineName}",
{
"stateMachineName": {
"Ref": "StateMachineName"
}
}
]
}
}
]
```
## TextractDetectAnalyzePolicy
Memberikan akses untuk mendeteksi dan menganalisia dokumen menggunakan Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:DetectDocumentText",
"textract:StartDocumentTextDetection",
"textract:StartDocumentAnalysis",
"textract:AnalyzeDocument"
],
"Resource": "*"
}
]
```
## TextractGetResultPolicy
Memberikan akses untuk mendapatkan dokumen yang terdeteksi dan teranalisis dari Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:GetDocumentTextDetection",
"textract:GetDocumentAnalysis"
],
"Resource": "*"
}
]
```
## TextractPolicy
Memberikan akses penuh menuju Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:*"
],
"Resource": "*"
}
]
```
## VPCAccessPolicy
Memberikan akses untuk membuat, menghapus, menjelaskan, dan melepaskan antarmuka jaringan elastis.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DetachNetworkInterface"
],
"Resource": "*"
}
]
```
# Mengelola AWS SAM izin dengan mekanisme CloudFormation
Untuk mengontrol akses ke AWS sumber daya, AWS Serverless Application Model (AWS SAM) dapat menggunakan mekanisme yang sama seperti CloudFormation. Untuk informasi selengkapnya, lihat [Mengontrol akses dengan AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) dalam *Panduan Pengguna AWS CloudFormation *.
Ada tiga opsi utama untuk memberikan izin pengguna untuk mengelola aplikasi nirserver. Setiap opsi menyediakan pengguna dengan tingkat yang berbeda dari kontrol akses.
+ Berikan izin administrator.
+ Lampirkan kebijakan AWS terkelola yang diperlukan.
+ Berikan izin khusus AWS Identity and Access Management (IAM).
Bergantung pada opsi mana yang Anda pilih, pengguna hanya dapat mengelola aplikasi tanpa server yang berisi AWS sumber daya yang memiliki izin untuk mereka akses.
Bagian berikut menjelaskan setiap opsi secara lebih mendetail.
## Berikan izin administrator
Jika Anda memberikan izin administrator kepada pengguna, mereka dapat mengelola aplikasi tanpa server yang berisi kombinasi sumber daya apa pun. AWS Ini adalah opsi yang paling sederhana, namun juga memberi pengguna set izin terluas, yang karenanya memungkinkan administrator melakukan tindakan dengan dampak tertinggi.
Untuk informasi selengkapnya tentang memberikan izin administrator ke pengguna, lihat [Membuat pengguna dan grup admin IAM pertama Anda](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) dalam *Panduan Pengguna IAM*.
## Lampirkan kebijakan AWS terkelola yang diperlukan
Anda dapat memberikan pengguna subset izin menggunakan [Kebijakan terkelola AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies), daripada memberikan izin administrator penuh. Jika Anda menggunakan opsi ini, pastikan bahwa kumpulan kebijakan AWS terkelola mencakup semua tindakan dan sumber daya yang diperlukan untuk aplikasi tanpa server yang dikelola pengguna.
Misalnya, kebijakan AWS terkelola berikut ini cukup untuk [menerapkan contoh aplikasi Hello World](serverless-getting-started-hello-world.md):
+ AWSCloudFormationFullAccess
+ IAMFullAkses
+ AWSLambda\$1FullAccess
+ APIGatewayAdministrator Amazon
+ AmazonS3 FullAccess
+ Amazon EC2 ContainerRegistryFullAccess
Untuk informasi tentang melampirkan kebijakan ke pengguna IAM, lihat [Mengubah izin untuk pengguna IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) dalam *Panduan Pengguna IAM*.
## Berikan izin IAM tertentu
Untuk tingkat kontrol akses terperinci, Anda dapat memberikan izin IAM tertentu untuk pengguna yang menggunakan [pernyataan kebijakan](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_statement.html). Jika Anda menggunakan opsi ini, pastikan bahwa pernyataan kebijakan mencakup semua tindakan dan sumber daya yang diperlukan untuk aplikasi nirserver yang dikelola pengguna.
Praktik terbaik dengan opsi ini adalah menolak izin pengguna untuk membuat peran, termasuk peran eksekusi Lambda, sehingga peran tersebut tidak dapat memberikan izin yang meningkat. Jadi, Anda sebagai administrator harus membuat terlebih dahulu [Peran eksekusi Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) yang akan ditentukan dalam aplikasi nirserver yang akan pengguna kelola. Untuk informasi selengkapnya tentang membuat peran eksekusi Lambda, lihat [Membuat peran eksekusi di konsol IAM](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html#permissions-executionrole-console).
Untuk [contoh aplikasi Hello World **AWSLambdaBasicExecutionRole**](serverless-getting-started-hello-world.md)sudah cukup untuk menjalankan aplikasi. Setelah Anda membuat peran eksekusi Lambda, ubah file AWS SAM template dari contoh aplikasi Hello World untuk menambahkan properti berikut ke sumber daya: `AWS::Serverless::Function`
```
Role: lambda-execution-role-arn
```
Pernyataan kebijakan berikut memberikan izin yang cukup bagi pengguna untuk men-deploy, memperbarui, dan menghapus aplikasi dengan diubah aplikasi Hello World di tempat:
**catatan**
Pernyataan kebijakan contoh di bagian ini memberikan izin yang cukup bagi Anda untuk menyebarkan, memperbarui, dan menghapus [contoh aplikasi Hello World](serverless-getting-started-hello-world.md). Jika Anda menambahkan jenis sumber daya tambahan ke aplikasi Anda, Anda perlu memperbarui pernyataan kebijakan untuk menyertakan yang berikut:
Izin untuk aplikasi Anda untuk memanggil tindakan layanan.
Prinsipal layanan, jika diperlukan untuk tindakan layanan.
Misalnya, jika Anda menambahkan alur kerja Step Functions, Anda mungkin perlu menambahkan izin untuk tindakan yang tercantum [di sini](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsstepfunctions.html#awsstepfunctions-actions-as-permissions), dan prinsipal `states.amazonaws.com` layanan.
Untuk informasi selengkapnya tentang kebijakan IAM terkelola, lihat [Mengelola kebijakan IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) dalam *Panduan Pengguna IAM*.
# Kontrol akses API dengan AWS SAM template Anda
Mengontrol akses ke API Gateway APIs membantu memastikan aplikasi tanpa server Anda aman dan hanya dapat diakses melalui otorisasi yang Anda aktifkan. Anda dapat mengaktifkan otorisasi di AWS SAM template Anda untuk mengontrol siapa yang dapat mengakses API Gateway APIs Anda.
AWS SAM mendukung beberapa mekanisme untuk mengontrol akses ke API Gateway Anda APIs. Kumpulan mekanisme yang didukung berbeda antara tipe sumber daya `AWS::Serverless::HttpApi` dan `AWS::Serverless::Api`.
Tabel berikut merangkum mekanisme yang didukung oleh setiap tipe sumber daya.
| Mekanisme untuk mengendalikan akses | AWS::Serverless::HttpApi | AWS::Serverless::Api |
| --- | --- | --- |
| Otorisator Lambda | ✓ | ✓ |
| Izin IAM | | ✓ |
| Kumpulan pengguna Amazon Cognito | ✓ \$1 | ✓ |
| Kunci API | | ✓ |
| Kebijakan sumber daya | | ✓ |
| OAuth 2.0/JWT otorisasi | ✓ | |
\$1 Anda dapat menggunakan Amazon Cognito sebagai penerbit JSON Web Token (JWT) dengan tipe sumber daya `AWS::Serverless::HttpApi`.
+ **Otorisasi Lambda** – Otorisasi Lambda (sebelumnya dikenal sebagai *custom authorizer*) adalah fungsi Lambda yang Anda berikan untuk mengendalikan akses ke API Anda. Saat API Anda dipanggil, fungsi Lambda ini dipanggil dengan konteks permintaan atau token otorisasi yang disediakan aplikasi klien. Fungsi Lambda merespons apakah pemanggil diotorisasi untuk melakukan operasi yang diminta.
Tipe sumber daya `AWS::Serverless::HttpApi` dan `AWS::Serverless::Api` mendukung otorisasi Lambda.
Untuk informasi selengkapnya tentang otorisasi Lambda`AWS::Serverless::HttpApi`, lihat [Bekerja dengan AWS Lambda otorisasi untuk HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html) di Panduan Pengembang APIs *API* Gateway. Untuk informasi selengkapnya tentang otorisasi Lambda dengan `AWS::Serverless::Api`, lihat [Gunakan otorisasi Lambda API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) di *Panduan Developer API Gateway*.
Untuk contoh otorisasi Lambda untuk kedua tipe sumber daya, lihat [Contoh otorisasi Lambda untuk AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md).
+ **Izin IAM** – Anda dapat mengendalikan siapa saja yang dapat menggunakan API Anda menggunakan [Izin (IAM)AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html). Pengguna yang memanggil API Anda harus diautentikasi dengan kredensial IAM. Panggilan ke API Anda berhasil hanya jika ada kebijakan IAM yang dilampirkan ke pengguna IAM yang mewakili pemanggil API, grup IAM yang berisi pengguna, atau IAM role yang diasumsikan pengguna.
Hanya tipe sumber daya `AWS::Serverless::Api` yang mendukung izin IAM.
Untuk informasi selengkapnya, lihat [Mengendalikan akses ke API dengan izin IAM](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) di *Panduan Developer API Gateway*. Sebagai contoh, lihat [Contoh izin IAM untuk AWS SAM](serverless-controlling-access-to-apis-permissions.md).
+ **Kolam pengguna Amazon Cognito** – Kolam pengguna Amazon Cognito adalah direktori pengguna di Amazon Cognito. Klien API Anda harus terlebih dahulu membuat pengguna masuk ke kolam pengguna dan mendapatkan identitas atau token akses untuk pengguna tersebut. Kemudian klien memanggil API Anda dengan salah satu token yang dikembalikan. Panggilan API hanya berhasil jika token yang diperlukan valid.
Tipe sumber daya `AWS::Serverless::Api` mendukung kolam pengguna Amazon Cognito. Tipe sumber daya `AWS::Serverless::HttpApi` mendukung penggunaan Amazon Cognito sebagai penerbit JWT.
Untuk informasi selengkapnya, lihat [Mengendalikan akses ke REST API menggunakan kolam pengguna Amazon Cognito sebagai pemberi otorisasi](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) di *Panduan Developer API Gateway*. Sebagai contoh, lihat [Contoh kumpulan pengguna Amazon Cognito untuk AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md).
+ **Kunci API** – Kunci API adalah nilai string alfanumerik yang Anda distribusi ke pelanggan developer aplikasi untuk memberikan akses ke API Anda.
Hanya tipe sumber daya `AWS::Serverless::Api` yang mendukung kunci API.
Untuk informasi selengkapnya tentang kunci API, lihat [Membuat dan menggunakan rencana penggunaan dengan kunci API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) di *Panduan Developer API Gateway*. Untuk contoh kunci API, lihat [Contoh kunci API untuk AWS SAM](serverless-controlling-access-to-apis-keys.md).
+ **Kebijakan sumber daya** – Kebijakan sumber daya adalah dokumen kebijakan JSON yang dapat Anda lampirkan ke API dari API Gateway. Gunakan kebijakan sumber daya untuk mengendalikan apakah principal tertentu (biasanya pengguna atau peran IAM) dapat memanggil API.
Hanya tipe `AWS::Serverless::Api` sumber daya yang mendukung kebijakan sumber daya sebagai mekanisme untuk mengontrol akses ke API Gateway APIs.
Untuk informasi selengkapnya tentang kebijakan sumber daya, lihat [Mengendalikan akses ke API dengan kebijakan sumber daya API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) di *Panduan Developer API Gateway*. Untuk contoh kebijakan sumber daya, lihat [Contoh kebijakan sumber daya untuk AWS SAM](serverless-controlling-access-to-apis-resource-policies.md).
+ **OAuth 2.0/JWT authorizers** [- Anda dapat menggunakan JWTs sebagai bagian dari OpenID [Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) dan 2.0 framework untuk mengontrol akses ke Anda. OAuth ](https://oauth.net/2/) APIs API Gateway memvalidasi JWTs yang dikirimkan klien dengan permintaan API, dan mengizinkan atau menolak permintaan berdasarkan validasi token dan, secara opsional, cakupan dalam token.
Hanya jenis `AWS::Serverless::HttpApi` sumber daya yang mendukung otorisasi OAuth 2.0/JWT.
Untuk informasi selengkapnya, lihat [Mengontrol akses ke HTTP APIs dengan otorisasi JWT di Panduan Pengembang](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) *API Gateway*. Sebagai contoh, lihat [OAuth 2.0/JWT authorizer contoh untuk AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md).
## Memilih mekanisme untuk mengendalikan akses
Mekanisme yang Anda pilih untuk digunakan untuk mengontrol akses ke API Gateway Anda APIs bergantung pada beberapa faktor. Misalnya, jika Anda memiliki proyek greenfield tanpa menyiapkan otorisasi atau kendali akses, maka kolam pengguna Amazon Cognito mungkin menjadi pilihan terbaik Anda. Ini karena saat Anda menyiapkan kolam pengguna, Anda juga secara otomatis menyiapkan autentikasi dan kendali akses.
Namun, jika aplikasi Anda sudah menyiapkan autentikasi, maka menggunakan otorisasi Lambda mungkin merupakan pilihan terbaik Anda. Ini karena Anda dapat memanggil layanan autentikasi yang ada dan mengembalikan dokumen kebijakan berdasarkan respons. Selain itu, jika aplikasi Anda memerlukan autentikasi khusus atau logika kendali akses yang tidak didukung oleh kolam pengguna, maka otorisasi Lambda mungkin merupakan pilihan terbaik Anda.
Ketika Anda telah memilih mekanisme mana yang akan digunakan, lihat bagian yang sesuai [Contoh](#serverless-controlling-access-to-apis-examples) untuk cara menggunakan AWS SAM untuk mengonfigurasi aplikasi Anda untuk menggunakan mekanisme itu.
## Menyesuaikan respons kesalahan
Anda dapat menggunakan AWS SAM untuk menyesuaikan konten dari beberapa respons kesalahan API Gateway. Hanya tipe sumber daya `AWS::Serverless::Api` yang mendukung respons API Gateway yang disesuaikan.
Untuk informasi selengkapnya tentang respons API Gateway, lihat [Respon gateway di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) di *Panduan Developer API Gateway*. Untuk contoh respons yang disesuaikan, lihat [Contoh respons yang disesuaikan untuk AWS SAM](serverless-controlling-access-to-apis-customize-response.md).
## Contoh
+ [Contoh otorisasi Lambda untuk AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)
+ [Contoh izin IAM untuk AWS SAM](serverless-controlling-access-to-apis-permissions.md)
+ [Contoh kumpulan pengguna Amazon Cognito untuk AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md)
+ [Contoh kunci API untuk AWS SAM](serverless-controlling-access-to-apis-keys.md)
+ [Contoh kebijakan sumber daya untuk AWS SAM](serverless-controlling-access-to-apis-resource-policies.md)
+ [OAuth 2.0/JWT authorizer contoh untuk AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md)
+ [Contoh respons yang disesuaikan untuk AWS SAM](serverless-controlling-access-to-apis-customize-response.md)
# Contoh otorisasi Lambda untuk AWS SAM
Tipe sumber daya `AWS::Serverless::Api` yang mendukung dua tipe otorisasi Lambda: otorisasi `TOKEN` dan otorisasi `REQUEST`. Tipe sumber daya `AWS::Serverless::HttpApi` hanya mendukung otorisasi `REQUEST`. Berikut ini adalah contoh dari setiap tipe.
## Contoh `TOKEN` otorisasi Lambda () AWS::Serverless::Api
Anda dapat mengontrol akses ke Anda APIs dengan mendefinisikan otorisasi `TOKEN` Lambda dalam template Anda. AWS SAM Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).
Berikut ini adalah contoh bagian AWS SAM template untuk Authorizer Lambda`TOKEN`:
**catatan**
Dalam contoh berikut, SAM dihasilkan `FunctionRole` secara implisit.
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaTokenAuthorizer
Authorizers:
MyLambdaTokenAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
Untuk informasi selengkapnya tentang otorisasi Lambda, lihat [Gunakan otorisasi Lambda API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) di *Panduan Developer API Gateway*.
## Contoh `REQUEST` otorisasi Lambda () AWS::Serverless::Api
Anda dapat mengontrol akses ke Anda APIs dengan mendefinisikan otorisasi `REQUEST` Lambda dalam template Anda. AWS SAM Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).
Berikut ini adalah contoh bagian AWS SAM template untuk Authorizer Lambda`REQUEST`:
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionPayloadType: REQUEST
FunctionArn: !GetAtt MyAuthFunction.Arn
Identity:
QueryStrings:
- auth
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
Untuk informasi selengkapnya tentang otorisasi Lambda, lihat [Gunakan otorisasi Lambda API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) di *Panduan Developer API Gateway*.
## Contoh otorisasi Lambda () AWS::Serverless::HttpApi
Anda dapat mengontrol akses ke HTTP Anda APIs dengan mendefinisikan Lambda authorizer dalam template Anda. AWS SAM Untuk melakukannya, Anda menggunakan tipe data [HttpApiAuth](sam-property-httpapi-httpapiauth.md).
Berikut ini adalah contoh bagian AWS SAM template untuk Authorizer Lambda:
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
FunctionInvokeRole: !GetAtt MyAuthFunctionRole.Arn
Identity:
Headers:
- Authorization
AuthorizerPayloadFormatVersion: 2.0
EnableSimpleResponses: true
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: HttpApi
Properties:
ApiId: !Ref MyApi
Path: /
Method: get
PayloadFormatVersion: "2.0"
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
# Contoh izin IAM untuk AWS SAM
Anda dapat mengontrol akses ke Anda APIs dengan mendefinisikan izin IAM dalam template Anda. AWS SAM Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).
Berikut ini adalah contoh AWS SAM template yang digunakan untuk izin IAM:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Description: 'API with IAM authorization'
Auth:
DefaultAuthorizer: AWS_IAM #sets AWS_IAM auth for all methods in this API
MyFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.10
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
```
Untuk informasi selengkapnya tentang izin IAM, lihat [Mengendalikan akses untuk menerapkan API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html) di *Panduan Developer API Gateway*.
# Contoh kumpulan pengguna Amazon Cognito untuk AWS SAM
Anda dapat mengontrol akses ke Anda APIs dengan mendefinisikan kumpulan pengguna Amazon Cognito dalam AWS SAM template Anda. Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).
Berikut ini adalah contoh bagian AWS SAM template untuk kumpulan pengguna:
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Cors: "'*'"
Auth:
DefaultAuthorizer: MyCognitoAuthorizer
Authorizers:
MyCognitoAuthorizer:
UserPoolArn: !GetAtt MyCognitoUserPool.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: lambda.handler
Runtime: nodejs12.x
Events:
Root:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: GET
MyCognitoUserPool:
Type: AWS::Cognito::UserPool
Properties:
UserPoolName: !Ref CognitoUserPoolName
Policies:
PasswordPolicy:
MinimumLength: 8
UsernameAttributes:
- email
Schema:
- AttributeDataType: String
Name: email
Required: false
MyCognitoUserPoolClient:
Type: AWS::Cognito::UserPoolClient
Properties:
UserPoolId: !Ref MyCognitoUserPool
ClientName: !Ref CognitoUserPoolClientName
GenerateSecret: false
```
Untuk informasi selengkapnya tentang kolam pengguna Amazon Cognito, lihat [Mengendalikan akses ke REST API menggunakan kolam pengguna Amazon Cognito sebagai pemberi otorisasi](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) di *Panduan Developer API Gateway*.
# Contoh kunci API untuk AWS SAM
Anda dapat mengontrol akses ke Anda APIs dengan meminta kunci API dalam AWS SAM template Anda. Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).
Berikut ini adalah contoh bagian AWS SAM template untuk kunci API:
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
ApiKeyRequired: true # sets for all methods
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: index.handler
Runtime: nodejs12.x
Events:
ApiKey:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
Auth:
ApiKeyRequired: true
```
Untuk informasi selengkapnya tentang kunci API, lihat [Membuat dan menggunakan rencana penggunaan dengan kunci API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) di *Panduan Developer API Gateway*.
# Contoh kebijakan sumber daya untuk AWS SAM
Anda dapat mengontrol akses ke Anda APIs dengan melampirkan kebijakan sumber daya dalam AWS SAM template Anda. Untuk melakukannya, Anda menggunakan tipe data [ApiAuth](sam-property-api-apiauth.md).
Berikut ini adalah contoh AWS SAM template untuk API pribadi. API pribadi harus memiliki kebijakan sumber daya untuk diterapkan.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyPrivateApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
EndpointConfiguration: PRIVATE # Creates a private API. Resource policies are required for all private APIs.
Auth:
ResourcePolicy:
CustomStatements:
- Effect: 'Allow'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
- Effect: 'Deny'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
MyFunction:
Type: 'AWS::Serverless::Function'
Properties:
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
Handler: index.handler
Runtime: python3.10
Events:
AddItem:
Type: Api
Properties:
RestApiId:
Ref: MyPrivateApi
Path: /
Method: get
```
Untuk informasi selengkapnya tentang kebijakan sumber daya, lihat [Mengendalikan akses ke API dengan kebijakan sumber daya API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) di *Panduan Developer API Gateway*. Untuk informasi selengkapnya tentang privat APIs, lihat [Membuat API pribadi di Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) di *Panduan Pengembang API Gateway*.
# OAuth 2.0/JWT authorizer contoh untuk AWS SAM
[Anda dapat mengontrol akses ke APIs penggunaan Anda JWTs sebagai bagian dari [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) dan 2.0 framework. OAuth ](https://oauth.net/2/) Untuk melakukannya, Anda menggunakan tipe data [HttpApiAuth](sam-property-httpapi-httpapiauth.md).
Berikut ini adalah contoh bagian AWS SAM template untuk OAuth 2.0/JWT authorizer:
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
Auth:
Authorizers:
MyOauth2Authorizer:
AuthorizationScopes:
- scope
IdentitySource: $request.header.Authorization
JwtConfiguration:
audience:
- audience1
- audience2
issuer: "https://www.example.com/v1/connect/oidc"
DefaultAuthorizer: MyOauth2Authorizer
StageName: Prod
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Events:
GetRoot:
Properties:
ApiId: MyApi
Method: get
Path: /
PayloadFormatVersion: "2.0"
Type: HttpApi
Handler: index.handler
Runtime: nodejs12.x
```
*Untuk informasi selengkapnya tentang otorisasi OAuth 2.0/JWT, lihat [Mengontrol akses ke HTTP APIs dengan otorisasi JWT di Panduan Pengembang API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html).*
# Contoh respons yang disesuaikan untuk AWS SAM
Anda dapat menyesuaikan beberapa respons kesalahan API Gateway dengan menentukan header respons dalam templat AWS SAM Anda. Untuk melakukannya, Anda menggunakan tipe data [Gateway Response Object](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#gateway-response-object).
Berikut ini adalah contoh AWS SAM template yang membuat respons khusus untuk `DEFAULT_5XX` kesalahan tersebut.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
GatewayResponses:
DEFAULT_5XX:
ResponseParameters:
Headers:
Access-Control-Expose-Headers: "'WWW-Authenticate'"
Access-Control-Allow-Origin: "'*'"
ErrorHeader: "'MyCustomErrorHeader'"
ResponseTemplates:
application/json: "{\"message\": \"Error on the $context.resourcePath resource\" }"
GetFunction:
Type: AWS::Serverless::Function
Properties:
Runtime: python3.10
Handler: index.handler
InlineCode: |
def handler(event, context):
raise Exception('Check out the new response!')
Events:
GetResource:
Type: Api
Properties:
Path: /error
Method: get
RestApiId: !Ref MyApi
```
Untuk informasi selengkapnya tentang respons API Gateway, lihat [Respon gateway di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) di *Panduan Developer API Gateway*.
# Tingkatkan efisiensi menggunakan lapisan Lambda dengan AWS SAM
Menggunakan AWS SAM, Anda dapat menyertakan lapisan dalam aplikasi tanpa server Anda. AWS Lambda layer memungkinkan Anda untuk mengekstrak kode dari fungsi Lambda ke lapisan Lambda yang kemudian dapat digunakan di beberapa fungsi Lambda. Melakukan hal ini memungkinkan Anda untuk mengurangi ukuran paket penerapan Anda, memisahkan logika fungsi inti dari dependensi, dan berbagi dependensi di beberapa fungsi. Untuk informasi selengkapnya tentang layer, lihat [layer Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) di Panduan *AWS Lambda Pengembang*.
Bagian ini menyediakan informasi tentang hal berikut:
+ Termasuk lapisan dalam aplikasi Anda
+ Bagaimana lapisan di-cache secara lokal
Untuk informasi lebih lanjut tentang membuat lapisan kustom, lihat [Membangun lapisan Lambda di AWS SAM](building-layers.md).
## Termasuk lapisan dalam aplikasi Anda
Untuk menyertakan lapisan dalam aplikasi Anda, gunakan `Layers` Properti dari [AWS::Serverless::Function](sam-resource-function.md) jenis sumber daya.
Berikut ini adalah contoh AWS SAM template dengan fungsi Lambda yang mencakup lapisan:
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
-
```
## Bagaimana lapisan di-cache secara lokal
Ketika Anda meminta fungsi Anda menggunakan salah satu `sam local`, paket lapisan fungsi Anda diunduh dan di-cache pada host lokal Anda.
Tabel berikut menunjukkan lokasi direktori cache default untuk sistem operasi yang berbeda.
****
| OS | Lokasi |
| --- | --- |
| Windows 7 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 8 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 10 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| macOS | \$1/.aws-sam/layers-pkg |
| Unix | \$1/.aws-sam/layers-pkg |
Setelah paket di-cache, lapisan AWS SAMCLI melapisi layer ke image Docker yang digunakan untuk memanggil fungsi Anda. Itu AWS SAMCLI menghasilkan nama-nama gambar yang dibangunnya, serta LayerVersions yang disimpan di cache. Anda dapat menemukan detail lebih lanjut tentang skema di bagian berikut.
Untuk memeriksa lapisan overlay, jalankan perintah berikut untuk memulai sesi bash pada gambar yang ingin Anda periksa:
```
docker run -it --entrypoint=/bin/bash samcli/lambda: -i
```
**Skema nama Direktori Caching Layer**
Mengingat LayerVersionArn yang didefinisikan dalam template Anda, AWS SAMCLI ekstrak LayerName dan Versi dari ARN. Ini menciptakan sebuah direktori untuk menempatkan isi lapisan di dalam nama `LayerName-Version-`.
Contoh:
```
ARN = arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
Directory name = myLayer-1-926eeb5ff1
```
**Skema tag Gambar Docker**
Untuk menghitung hash layer unik, gabungkan semua nama layer unik dengan pembatas '-', ambil SHA256 hash, lalu ambil 10 karakter pertama.
Contoh:
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
- arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
- arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1
```
Nama-nama unik dikomputasi sama dengan skema nama pada Lapisan Direktori Caching:
```
arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1 = myLayer-1-926eeb5ff1
arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1 = mySecondLayer-1-6bc1022bdf
```
Untuk komputasi lapisan unik hash, gabungkan semua nama lapisan unik dengan tanda pembatas '-', ambil hash sha256, kemudian ambil 25 karakter pertama:
```
myLayer-1-926eeb5ff1-mySecondLayer-1-6bc1022bdf = 2dd7ac5ffb30d515926aef
```
Kemudian gabungkan nilai ini dengan runtime dan arsitektur fungsi, dengan pembatas '-':
```
python3.7-x86_64-2dd7ac5ffb30d515926aefffd
```
# Gunakan kembali kode dan sumber daya menggunakan aplikasi bersarang di AWS SAM
Sebuah aplikasi nirserver dapat mencakup satu **aplikasi nest** atau lebih. Aplikasi bersarang adalah bagian dari aplikasi yang lebih besar dan dapat dikemas dan digunakan baik sebagai artefak yang berdiri sendiri atau sebagai komponen dari aplikasi yang lebih besar. Aplikasi bersarang memungkinkan Anda mengubah kode yang sering digunakan dan menjadi aplikasinya sendiri yang kemudian dapat digunakan kembali di aplikasi tanpa server yang lebih besar atau beberapa aplikasi tanpa server.
Seiring berkembangnya arsitektur tanpa server Anda, pola umum biasanya muncul di mana komponen yang sama didefinisikan dalam beberapa templat aplikasi. Aplikasi bersarang memungkinkan Anda untuk menggunakan kembali kode umum, fungsionalitas, sumber daya, dan konfigurasi dalam AWS SAM templat terpisah, memungkinkan Anda untuk hanya mempertahankan kode dari satu sumber. Ini mengurangi kode dan konfigurasi duplikat. Selain itu, pendekatan modular ini merampingkan pengembangan, meningkatkan organisasi kode, dan memfasilitasi konsistensi di seluruh aplikasi tanpa server. Dengan aplikasi nest, Anda tetap dapat lebih fokus pada logika bisnis yang unik untuk aplikasi Anda.
Untuk menentukan aplikasi nest di aplikasi nirserver Anda, gunakan tipe sumber daya [AWS::Serverless::Application](sam-resource-application.md).
Anda dapat menentukan aplikasi nest dari dua sumber berikut:
+ **Aplikasi AWS Serverless Application Repository ** – Anda dapat menentukan aplikasi nest dengan menggunakan aplikasi yang tersedia untuk akun Anda di AWS Serverless Application Repository. Ini dapat berupa aplikasi *privat* di akun Anda, aplikasi yang *dibagikan secara privat* dengan akun Anda, atau aplikasi yang *dibagikan secara publik* di AWS Serverless Application Repository. Untuk informasi selengkapnya tentang tingkat izin deployment yang berbeda, lihat [Izin Deployment Aplikasi](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) dan [Memublikasikan Aplikasi](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) di *Panduan Developer AWS Serverless Application Repository *.
+ **Aplikasi lokal** – Anda dapat menentukan aplikasi nest dengan menggunakan aplikasi yang disimpan di sistem file lokal Anda.
Lihat bagian berikut untuk detail tentang cara menggunakan AWS SAM untuk menentukan kedua jenis aplikasi bersarang ini dalam aplikasi tanpa server Anda.
**catatan**
Jumlah maksimum aplikasi yang dapat di-nest dalam aplikasi nirserver adalah 200.
Jumlah maksimum parameter yang dapat dimiliki aplikasi nest adalah 60.
## Mendefinisikan aplikasi bersarang dari AWS Serverless Application Repository
Anda dapat menentukan aplikasi nest dengan menggunakan aplikasi yang tersedia di AWS Serverless Application Repository. Anda juga dapat menyimpan dan mendistribusikan aplikasi yang berisi aplikasi nest menggunakan AWS Serverless Application Repository. Untuk meninjau detail aplikasi bersarang di AWS Serverless Application Repository, Anda dapat menggunakan AWS SDK, konsol AWS CLI, atau Lambda.
Untuk menentukan aplikasi yang di-host AWS Serverless Application Repository di AWS SAM template aplikasi tanpa server Anda, gunakan tombol **Salin sebagai Sumber Daya SAM** pada halaman detail setiap AWS Serverless Application Repository aplikasi. Untuk melakukannya, ikuti langkah-langkah berikut:
1. Pastikan Anda masuk ke Konsol Manajemen AWS.
1. Temukan aplikasi yang ingin Anda sarang AWS Serverless Application Repository dengan menggunakan langkah-langkah di bagian [Browsing, Searching, dan Deploying Applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#browse-and-search-applications ) pada *Panduan AWS Serverless Application Repository Pengembang*.
1. Pilih tombol **Salin sebagai Sumber Daya SAM**. Bagian templat SAM untuk aplikasi yang Anda lihat sekarang ada di clipboard Anda.
1. Tempelkan bagian templat SAM ke bagian `Resources:` dari file templat SAM untuk aplikasi yang ingin Anda nest di aplikasi ini.
Berikut ini adalah contoh bagian templat SAM untuk aplikasi nest yang di-hosting di AWS Serverless Application Repository:
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location:
ApplicationId: arn:aws:serverlessrepo:us-east-1:123456789012:applications/application-alias-name
SemanticVersion: 1.0.0
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
Jika tidak ada pengaturan parameter yang diperlukan, Anda dapat menghilangkan bagian `Parameters:` pada templat.
**penting**
Aplikasi yang berisi aplikasi bersarang yang dihosting di AWS Serverless Application Repository mewarisi batasan berbagi aplikasi bersarang.
Misalnya, aplikasi dibagikan secara publik, tetapi berisi aplikasi bersarang yang hanya dibagikan secara pribadi dengan AWS akun yang membuat aplikasi induk. Dalam hal ini, jika AWS akun Anda tidak memiliki izin untuk menerapkan aplikasi bersarang, Anda tidak dapat menerapkan aplikasi induk. Untuk informasi lebih lanjut tentang izin untuk men-deploy aplikasi, lihat [Izin Deployment Aplikasi](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) dan [Memublikasikan Aplikasi](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) di *Panduan Developer AWS Serverless Application Repository *.
## Mendefinisikan aplikasi nest dari sistem file lokal
Anda dapat menentukan aplikasi nest dengan menggunakan aplikasi yang disimpan di sistem file lokal Anda. Anda melakukan ini dengan menentukan path ke file AWS SAM template yang disimpan di sistem file lokal Anda.
Berikut ini adalah contoh bagian templat SAM untuk aplikasi lokal nest:
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location: ../my-other-app/template.yaml
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
Jika tidak ada pengaturan parameter, Anda dapat menghilangkan bagian `Parameters:` pada templat.
## Men-deploy aplikasi nest
Anda dapat menerapkan aplikasi bersarang Anda dengan menggunakan perintah. AWS SAMCLI `sam deploy` Untuk detail selengkapnya, lihat [Menyebarkan aplikasi dan sumber daya Anda dengan AWS SAM](serverless-deploying.md).
**catatan**
Saat Anda menyebarkan aplikasi yang berisi aplikasi bersarang, Anda harus mengakuinya berisi aplikasi bersarang. Anda melakukan ini dengan meneruskan `CAPABILITY_AUTO_EXPAND` ke [CreateCloudFormationChangeSet API](https://docs.aws.amazon.com/goto/WebAPI/serverlessrepo-2017-09-08/CreateCloudFormationChangeSet), atau menggunakan [https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html) AWS CLI perintah.
Untuk informasi selengkapnya tentang mengakui aplikasi nest, lihat [Mengakui IAM Role, Kebijakan Sumber Daya, dan Aplikasi Bersarang saat Men-deploy Aplikasi](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/acknowledging-application-capabilities.html) di *Panduan Developer AWS Serverless Application Repository *.
# Kelola acara berbasis waktu dengan EventBridge Scheduler di AWS SAM
Konten dalam topik ini memberikan detail tentang apa itu Amazon EventBridge Scheduler, dukungan apa yang AWS SAM ditawarkan, bagaimana Anda dapat membuat acara Scheduler, dan contoh yang dapat Anda referensikan saat membuat acara Scheduler.
## Apa itu Amazon EventBridge Scheduler?
Gunakan EventBridge Scheduler untuk menjadwalkan acara di AWS SAM template Anda. Amazon EventBridge Scheduler adalah layanan penjadwalan yang memungkinkan Anda membuat, memulai, dan mengelola puluhan juta acara dan tugas di semua layanan. AWS Layanan ini sangat berguna untuk acara terkait waktu. Anda dapat menggunakannya untuk menjadwalkan acara dan pemanggilan berbasis waktu berulang. Ini juga mendukung acara satu kali serta ekspresi rate dan chron dengan waktu mulai dan berakhir.
Untuk mempelajari selengkapnya tentang Amazon EventBridge Scheduler, lihat [Apa itu Amazon EventBridge Scheduler?](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html) di *Panduan Pengguna EventBridge Penjadwal*.
**Topics**
+ [
## Apa itu Amazon EventBridge Scheduler?
](#using-eventbridge-scheduler-intro)
+ [
## EventBridge Dukungan penjadwal di AWS SAM
](#using-eventbridge-scheduler-sam-support)
+ [
## Membuat acara EventBridge Scheduler di AWS SAM
](#using-eventbridge-scheduler-sam-create)
+ [
## Contoh
](#using-eventbridge-scheduler-examples)
+ [
## Pelajari selengkapnya
](#using-eventbridge-scheduler-learn)
## EventBridge Dukungan penjadwal di AWS SAM
Spesifikasi template AWS Serverless Application Model (AWS SAM) menyediakan sintaks sederhana dan singkat yang dapat Anda gunakan untuk menjadwalkan acara dengan EventBridge Scheduler untuk dan. AWS Lambda AWS Step Functions
## Membuat acara EventBridge Scheduler di AWS SAM
Tetapkan `ScheduleV2` properti sebagai jenis acara di AWS SAM template Anda untuk menentukan acara EventBridge Scheduler Anda. Properti ini mendukung `AWS::Serverless::Function` dan jenis `AWS::Serverless::StateMachine` sumber daya.
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2Function
Description: Test schedule event
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2StateMachine
Description: Test schedule event
```
EventBridge Penjadwalan acara Scheduler juga mendukung *antrian surat mati (DLQ) untuk acara yang* belum diproses. *Untuk informasi selengkapnya tentang antrian huruf mati, lihat [Mengonfigurasi antrian huruf mati untuk Penjadwal di Panduan](https://docs.aws.amazon.com/scheduler/latest/UserGuide/configuring-schedule-dlq.html) Pengguna Penjadwal. EventBridge EventBridge *
Ketika ARN DLQ ditentukan, AWS SAM mengonfigurasi izin untuk jadwal Scheduler untuk mengirim pesan ke DLQ. Ketika ARN DLQ tidak ditentukan, AWS SAM akan membuat sumber daya DLQ.
## Contoh
### Contoh dasar mendefinisikan acara EventBridge Scheduler dengan AWS SAM
```
Transform: AWS::Serverless-2016-10-31
Resources:
MyLambdaFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
MySFNFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
StateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Type: STANDARD
Definition:
StartAt: MyLambdaState
States:
MyLambdaState:
Type: Task
Resource: !GetAtt MySFNFunction.Arn
End: true
Policies:
- LambdaInvokePolicy:
FunctionName: !Ref MySFNFunction
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
```
## Pelajari selengkapnya
Untuk mempelajari lebih lanjut tentang mendefinisikan properti `ScheduleV2` EventBridge Scheduler, lihat:
+ [ScheduleV2](sam-property-function-schedulev2.md)untuk`AWS::Serverless::Function`.
+ [ScheduleV2](sam-property-statemachine-statemachineschedulev2.md)untuk`AWS::Serverless::StateMachine`.
# Mengatur sumber daya dengan AWS SAM AWS Step Functions
Anda dapat menggunakan [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/)untuk mengatur AWS Lambda fungsi dan AWS sumber daya lainnya untuk membentuk alur kerja yang kompleks dan kuat. Step Functions untuk memberi tahu aplikasi Anda kapan dan dalam kondisi apa AWS sumber daya Anda, seperti AWS Lambda fungsi, digunakan. Ini menyederhanakan proses pembentukan alur kerja yang kompleks dan kuat. Dengan menggunakan[AWS::Serverless::StateMachine](sam-resource-statemachine.md), Anda menentukan langkah-langkah individual dalam alur kerja Anda, mengaitkan sumber daya di setiap langkah, dan kemudian mengurutkan langkah-langkah ini bersama-sama. Anda juga menambahkan transisi dan kondisi di mana mereka dibutuhkan. Ini menyederhanakan proses pembuatan alur kerja yang kompleks dan kuat.
**catatan**
Untuk mengelola AWS SAM template yang berisi mesin status Step Functions, Anda harus menggunakan versi 0.52.0 atau yang lebih baru. AWS SAMCLI Untuk memeriksa versi yang Anda miliki, jalankan perintah `sam --version`.
Step Functions didasarkan pada konsep [tugas](https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-task-state.html) dan [mesin status](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-states.html). Anda menentukan mesin status yang menggunakan [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) berbasis JSON. [Konsol Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) menampilkan tampilan grafis dari struktur mesin status sehingga Anda dapat secara visual memeriksa logika mesin status Anda dan memantau eksekusi.
Dengan dukungan Step Functions in AWS Serverless Application Model (AWS SAM), Anda dapat melakukan hal berikut:
+ Tentukan mesin status, baik secara langsung dalam AWS SAM template atau dalam file terpisah
+ Buat peran eksekusi mesin status melalui templat AWS SAM kebijakan, kebijakan sebaris, atau kebijakan terkelola
+ Memicu eksekusi mesin status dengan API Gateway atau EventBridge peristiwa Amazon, sesuai jadwal dalam AWS SAM templat, atau dengan menelepon langsung APIs
+ Gunakan [Templat Kebijakan AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html) yang tersedia untuk pola pengembangan Step Functions yang umum.
## Contoh
Contoh cuplikan berikut dari file AWS SAM template mendefinisikan mesin status Step Functions dalam file definisi. Perhatikan bahwa file `my_state_machine.asl.json` harus ditulis dalam [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html).
```
AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: Sample SAM template with Step Functions State Machine
Resources:
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
DefinitionUri: statemachine/my_state_machine.asl.json
...
```
Untuk mengunduh contoh AWS SAM aplikasi yang menyertakan mesin status Step Functions, lihat [Membuat Mesin Status Step Functions Menggunakan AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html) dalam *Panduan AWS Step Functions Pengembang*.
## Informasi selengkapnya
Untuk mempelajari lebih lanjut tentang Step Functions dan menggunakannya AWS SAM, lihat berikut ini:
+ [Cara kerja AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/how-step-functions-works.html)
+ [AWS Step Functions dan AWS Serverless Application Model](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-sam-sfn.html)
+ [Tutorial: Membuat Mesin Status Step Functions Menggunakan AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html)
+ [AWS SAM Spesifikasi: AWS::Serverless::StateMachine](sam-resource-statemachine.md)
# Siapkan penandatanganan kode untuk AWS SAM aplikasi Anda
Untuk memastikan bahwa hanya kode tepercaya yang digunakan, Anda dapat menggunakan AWS SAM untuk mengaktifkan penandatanganan kode dengan aplikasi tanpa server Anda. Menandatangani kode membantu memastikan bahwa kode belum diubah sejak penandatanganan dan hanya paket kode yang ditandatangani dari penerbit tepercaya yang berjalan di fungsi Lambda Anda. Ini membantu membebaskan organisasi dari beban membangun komponen penjaga gerbang di jaringan pipa penyebaran mereka.
Untuk informasi selengkapnya tentang penandatanganan kode, lihat [Mengonfigurasi penandatanganan kode untuk fungsi Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html) di Panduan *AWS Lambda Pengembang*.
Sebelum dapat mengonfigurasi penandatanganan kode untuk aplikasi tanpa server, Anda harus membuat profil penandatanganan menggunakan AWS Signer. Anda menggunakan profil penandatanganan ini untuk tugas-tugas berikut:
1. **Membuat konfigurasi penandatanganan kode** – Menyatakan sumber daya [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html) untuk menentukan profil penandatanganan penerbit tepercaya dan untuk mengatur tindakan kebijakan untuk pemeriksaan validasi. Anda dapat mendeklarasikan objek ini dalam AWS SAM template yang sama dengan fungsi tanpa server Anda, dalam template yang berbeda, atau dalam AWS SAM template. CloudFormation Anda kemudian mengaktifkan penandatanganan kode untuk fungsi nirserver dengan menentukan properti [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn) fungsi tersebut dengan Amazon Resource Name (ARN) dari sumber daya [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html).
1. **Menandatangani kode Anda** – Gunakan perintah [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html) atau [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) dengan opsi `--signing-profiles`.
**catatan**
Agar kode Anda berhasil ditandatangani dengan perintah `sam package` atau `sam deploy`, versioning untuk bucket Amazon S3 yang Anda gunakan harus diaktifkan dengan perintah ini. Jika Anda menggunakan Bucket Amazon S3 yang AWS SAM dibuat untuk Anda, pembuatan versi diaktifkan secara otomatis. *Untuk informasi selengkapnya tentang pembuatan versi bucket Amazon S3 dan petunjuk untuk mengaktifkan pembuatan versi di bucket Amazon S3 yang Anda berikan, lihat [Menggunakan pembuatan versi di bucket Amazon S3 di Panduan Pengguna Layanan Penyimpanan Sederhana Amazon](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html).*
Saat Anda men-deploy aplikasi nirserver, Lambda melakukan pemeriksaan validasi pada semua fungsi yang penandatanganan kodenya telah Anda aktifkan. Lambda juga melakukan pemeriksaan validasi pada setiap lapisan yang fungsi lambda-nya bergantung pada lapisan tersebut. Untuk informasi selengkapnya tentang pemeriksaan validasi Lambda, lihat [Validasi tanda tangan](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html#config-codesigning-valid) di *Panduan Developer AWS Lambda *.
## Contoh
### Membuat profil penandatanganan
Untuk membuat profil penandatanganan, jalankan perintah berikut:
```
aws signer put-signing-profile --platform-id "AWSLambda-SHA384-ECDSA" --profile-name MySigningProfile
```
Jika perintah sebelumnya berhasil, Anda akan melihat ARN profil penandatanganan dikembalikan. Contoh:
```
{
"arn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile",
"profileVersion": "SAMPLEverx",
"profileVersionArn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile/SAMPLEverx"
}
```
Bidang `profileVersionArn` berisi ARN untuk digunakan saat Anda membuat konfigurasi penandatanganan kode.
### Membuat konfigurasi penandatanganan kode dan mengaktifkan penandatanganan kode untuk suatu fungsi
Contoh AWS SAM template berikut mendeklarasikan [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)sumber daya dan memungkinkan penandatanganan kode untuk fungsi Lambda. Dalam contoh ini, jika pemeriksaan tanda tangan gagal, akan ditemukan satu profil tepercaya, dan penolakan deployment.
```
Resources:
HelloWorld:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.7
CodeSigningConfigArn: !Ref MySignedFunctionCodeSigningConfig
MySignedFunctionCodeSigningConfig:
Type: AWS::Lambda::CodeSigningConfig
Properties:
Description: "Code Signing for MySignedLambdaFunction"
AllowedPublishers:
SigningProfileVersionArns:
- MySigningProfile-profileVersionArn
CodeSigningPolicies:
UntrustedArtifactOnDeployment: "Enforce"
```
### Menandatangani kode Anda
Anda dapat menandatangani kode saat mengemas atau men-deploy aplikasi Anda. Tentukan opsi `--signing-profiles` dengan perintah `sam package` atau `sam deploy`, seperti yang ditunjukkan pada contoh perintah berikut.
Menandatangani kode fungsi saat mengemas aplikasi Anda:
```
sam package --signing-profiles HelloWorld=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
Menandatangani kode fungsi dan lapisan tempat fungsi Anda bergantung, saat mengemas aplikasi Anda:
```
sam package --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
Menandatangani kode fungsi dan lapisan Anda, lalu melakukan deployment:
```
sam deploy --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --template-file packaged.yaml --stack-name --region us-east-1 --capabilities CAPABILITY_IAM
```
**catatan**
Agar berhasil menandatangani kode Anda dengan perintah `sam package` atau `sam deploy`, versioning untuk bucket Amazon S3 yang Anda gunakan harus diaktifkan dengan perintah ini. Jika Anda menggunakan Bucket Amazon S3 yang AWS SAM dibuat untuk Anda, pembuatan versi diaktifkan secara otomatis. *Untuk informasi selengkapnya tentang pembuatan versi bucket Amazon S3 dan petunjuk untuk mengaktifkan pembuatan versi di bucket Amazon S3 yang Anda berikan, lihat [Menggunakan pembuatan versi di bucket Amazon S3 di Panduan Pengguna Layanan Penyimpanan Sederhana Amazon](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html).*
## Menyediakan profil penandatanganan dengan `sam deploy --guided`
Saat Anda menjalankan `sam deploy --guided` perintah dengan aplikasi tanpa server yang dikonfigurasi dengan penandatanganan kode, AWS SAM meminta Anda untuk memberikan profil penandatanganan yang akan digunakan untuk penandatanganan kode. Untuk informasi selengkapnya tentang `sam deploy --guided` prompt, lihat [sam deploy](sam-cli-command-reference-sam-deploy.md) di referensi AWS SAMCLI perintah.
# Validasi file AWS SAM template
Validasi templat Anda dengan `sam validate`. Saat ini, perintah ini memvalidasi bahwa templat yang disediakan adalah JSON / YAML yang valid. Seperti kebanyakan AWS SAMCLI perintah, ia mencari `template.[yaml|yml]` file di direktori kerja Anda saat ini secara default. Anda dapat menentukan template yang berbeda file/location dengan `--template` opsi `-t` or.
Contoh:
```
$ sam validate
/template.yaml is a valid SAM Template
```
**catatan**
`sam validate`Perintah membutuhkan AWS kredensional untuk dikonfigurasi. Lihat informasi yang lebih lengkap di [Mengkonfigurasi AWS SAMCLI](using-sam-cli-configure.md).
# 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
```