Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Kapan menggunakan runtime khusus OS Lambda
Lambda menyediakan [runtime terkelola](lambda-runtimes.md) untuk Java, Python, Node.js, .NET, dan Ruby. Untuk membuat fungsi Lambda dalam bahasa pemrograman yang tidak tersedia sebagai runtime terkelola, gunakan runtime khusus OS (keluarga runtime). `provided` Ada tiga kasus penggunaan utama untuk runtime khusus OS:
+ **Kompilasi asli ahead-of-time (AOT)**: Bahasa seperti Go, Rust, Swift, dan C\$1\$1 dikompilasi secara native ke biner yang dapat dieksekusi, yang tidak memerlukan runtime bahasa khusus. Bahasa-bahasa ini hanya membutuhkan lingkungan OS di mana biner yang dikompilasi dapat berjalan. Anda juga dapat menggunakan runtime khusus OS Lambda untuk menyebarkan binari yang dikompilasi dengan.NET Native AOT dan Java GraalVM Native Image.
Anda harus menyertakan klien antarmuka runtime dalam biner Anda. Klien antarmuka runtime memanggil [Menggunakan API runtime Lambda untuk runtime kustom](runtimes-api.md) untuk mengambil pemanggilan fungsi dan kemudian memanggil penangan fungsi Anda. [Lambda menyediakan klien antarmuka runtime untuk [Rust](lambda-rust.md), [Go](golang-package.md#golang-package-mac-linux), [.NET Native AOT](dotnet-native-aot.md), [Swift](https://github.com/awslabs/swift-aws-lambda-runtime) (eksperimental), dan C \$1\$1 (eksperimental).](https://github.com/awslabs/aws-lambda-cpp)
Anda harus mengkompilasi biner Anda untuk lingkungan Linux dan untuk arsitektur set instruksi yang sama yang Anda rencanakan untuk digunakan untuk fungsi (x86\$164 atau arm64).
+ **Runtime pihak ketiga**: Anda dapat menjalankan fungsi Lambda off-the-shelf menggunakan runtime [seperti](https://bref.sh/docs/news/01-bref-1.0.html#amazon-linux-2) Bref untuk PHP.
+ **Runtime kustom**: Anda dapat membuat runtime sendiri untuk versi bahasa atau bahasa yang Lambda tidak menyediakan runtime terkelola, seperti Node.js 19. Untuk informasi selengkapnya, lihat [Membangun runtime khusus untuk AWS Lambda](runtimes-custom.md). Ini adalah kasus penggunaan yang paling tidak umum untuk runtime khusus OS.
Lambda mendukung runtime khusus OS berikut:
| Nama | Pengidentifikasi | Sistem operasi | Tanggal pengusangan | Buat fungsi blok | Pembaruan fungsi blok |
| --- | --- | --- | --- | --- | --- |
| Runtime Khusus OS | `provided.al2023` | Amazon Linux 2023 | 30 Jun 2029 | Jul 31, 2029 | Agustus 31, 2029 |
| Runtime Khusus OS | `provided.al2` | Amazon Linux 2 | Juli 31, 2026 | Agustus 31, 2026 | Sep 30, 2026 |
Runtime Amazon Linux 2023 (`provided.al2023`) memberikan beberapa keunggulan dibandingkan Amazon Linux 2, termasuk jejak penyebaran yang lebih kecil dan versi pustaka yang diperbarui seperti. `glibc`
`provided.al2023`Runtime digunakan `dnf` sebagai manajer paket, bukan`yum`, yang merupakan manajer paket default di Amazon Linux 2. Untuk informasi selengkapnya tentang perbedaan antara `provided.al2023` dan`provided.al2`, lihat [Memperkenalkan runtime Amazon Linux 2023 untuk AWS Lambda di Blog](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) AWS Komputasi.
# Membangun runtime khusus untuk AWS Lambda
Anda dapat menerapkan AWS Lambda runtime dalam bahasa pemrograman apa pun. Runtime adalah program yang menjalankan metode handler fungsi Lambda saat fungsi tersebut dipanggil. [Anda dapat menyertakan runtime dalam paket penerapan fungsi Anda atau mendistribusikannya dalam lapisan.](chapter-layers.md) Saat Anda membuat fungsi Lambda, pilih runtime khusus [OS (keluarga runtime](runtimes-provided.md)). `provided`
**catatan**
Membuat runtime khusus adalah kasus penggunaan lanjutan. Jika Anda mencari informasi tentang kompilasi ke biner asli atau menggunakan off-the-shelf runtime pihak ketiga, lihat. [Kapan menggunakan runtime khusus OS Lambda](runtimes-provided.md)
Untuk panduan proses penerapan runtime kustom, lihat. [Tutorial: Membangun runtime khusus](runtimes-walkthrough.md)
**Topics**
+ [Persyaratan](#runtimes-custom-build)
+ [Menerapkan streaming respons dalam runtime khusus](#runtimes-custom-response-streaming)
+ [Membangun runtime kustom untuk Instans Terkelola Lambda](#runtimes-custom-managed-instances)
## Persyaratan
Runtime khusus harus menyelesaikan tugas inisialisasi dan pemrosesan tertentu. Runtime menjalankan kode penyiapan fungsi, membaca nama handler dari variabel lingkungan, dan membaca peristiwa pemanggilan dari API runtime Lambda. Runtime meneruskan data event ke handler fungsi, dan memposting respons dari handler kembali ke Lambda.
### Tugas inisialisasi
Tugas inisialisasi dijalankan sekali [per instans fungsi](lambda-runtime-environment.md) untuk menyiapkan lingkungan untuk menangani invokasi.
+ **Ambil pengaturan** – Baca variabel lingkungan untuk mendapatkan detail tentang fungsi dan lingkungan.
+ `_HANDLER` – Lokasi ke handler, dari konfigurasi fungsi. Format standar adalah `file.method`, dengan `file` adalah nama file tanpa ekstensi, dan `method` merupakan nama metode atau fungsi yang ditentukan dalam file.
+ `LAMBDA_TASK_ROOT` – Direktori yang berisi kode fungsi.
+ `AWS_LAMBDA_RUNTIME_API` – Host dan port API runtime.
Untuk daftar lengkap variabel yang tersedia, lihat[Variabel lingkungan runtime yang ditetapkan](configuration-envvars.md#configuration-envvars-runtime).
+ **Inisialisasi fungsi** – Muat file handler dan jalankan kode global atau statis yang ada di dalamnya. Fungsi harus membuat sumber daya statis seperti klien SDK dan koneksi database satu kali, dan menggunakannya kembali untuk beberapa invokasi.
+ **Mengatasi kesalahan** – Jika terjadi kesalahan, hubungi [kesalahan inisialisasi](runtimes-api.md#runtimes-api-initerror) API dan segera keluar.
Inisialisasi diperhitungkan dalam waktu dan batas waktu eksekusi yang ditagih. Saat eksekusi memicu inisialisasi instans baru dari fungsi, Anda dapat melihat waktu inisialisasi dalam log dan [jejak AWS X-Ray](services-xray.md).
**Example log**
```
REPORT RequestId: f8ac1208... Init Duration: 48.26 ms Duration: 237.17 ms Billed Duration: 300 ms Memory Size: 128 MB Max Memory Used: 26 MB
```
### Memproses tugas
Saat belajar, runtime menggunakan [antarmuka runtime Lambda](runtimes-api.md) untuk mengelola event masuk dan melaporkan kesalahan. Setelah menyelesaikan tugas inisialisasi, runtime memproses event masuk secara berulang. Dalam kode runtime Anda, lakukan langkah berikut secara berurutan.
+ **Dapatkan event** – Hubungi [API invokasi beikutnya](runtimes-api.md#runtimes-api-next) untuk mendapatkan event berikutnya. Badan respons berisi data event. Header respons berisi ID permintaan dan informasi lainnya.
+ **Sebakan header pelacakan** – Dapatkan header pelacakan X-Ray dari header `Lambda-Runtime-Trace-Id` di respons API. Tetapkan variabel lingkungan `_X_AMZN_TRACE_ID` secara lokal dengan nilai yang sama. X-Ray SDK menggunakan nilai ini untuk menghubungkan data pelacakan di antara layanan.
+ **Buat objek konteks** – Buat objek dengan informasi konteks dari variabel lingkungan dan header dalam respons API.
+ **Memanggil handler fungsi** – Berikan event dan objek konteks ke handler.
+ **Menangani respons** – Hubungi [respons pemanggil](runtimes-api.md#runtimes-api-response) API untuk memposting respons dari penanggung jawab.
+ **Mengatasi kesalahan** – Jika terjadi kesalahan, hubungi [kesalahan invokasi](runtimes-api.md#runtimes-api-invokeerror) API.
+ **Pembersihan** – Lepaskan sumber daya yang tidak digunakan, kirim data ke layanan lain, atau lakukan tugas tambahan sebelum melanjutkan ke event berikutnya.
### Entrypoint
Titik entri runtime kustom adalah file eksekusi bernama `bootstrap`. File bootstrap dapat menjadi runtime, atau dapat memanggil file lain yang membuat runtime. Jika root paket penyebaran Anda tidak berisi file bernama`bootstrap`, Lambda mencari file di lapisan fungsi. Jika `bootstrap` file tidak ada atau tidak dapat dieksekusi, fungsi Anda mengembalikan `Runtime.InvalidEntrypoint` kesalahan saat pemanggilan.
Berikut adalah contoh `bootstrap` file yang menggunakan versi bundel Node.js untuk menjalankan JavaScript runtime dalam file terpisah bernama. `runtime.js`
**Example bootstrap**
```
#!/bin/sh
cd $LAMBDA_TASK_ROOT
./node-v11.1.0-linux-x64/bin/node runtime.js
```
## Menerapkan streaming respons dalam runtime khusus
Untuk [fungsi streaming respons](configuration-response-streaming.md), titik akhir `response` dan `error` titik akhir memiliki perilaku yang sedikit dimodifikasi yang memungkinkan runtime mengalirkan sebagian respons ke klien dan mengembalikan muatan dalam potongan. Untuk informasi selengkapnya tentang perilaku tertentu, lihat berikut ini:
+ `/runtime/invocation/AwsRequestId/response`— Menyebarkan `Content-Type` header dari runtime untuk dikirim ke klien. Lambda mengembalikan payload respons dalam potongan melalui HTTP/1.1 chunked transfer encoding. Untuk melakukan streaming respons ke Lambda, runtime harus:
+ Atur header `Lambda-Runtime-Function-Response-Mode` HTTP ke`streaming`.
+ Atur header `Transfer-Encoding` ke `chunked`.
+ Tulis respons yang sesuai dengan spesifikasi pengkodean transfer chunked HTTP/1.1.
+ Tutup koneksi yang mendasarinya setelah berhasil menulis respons.
+ `/runtime/invocation/AwsRequestId/error`— Runtime dapat menggunakan titik akhir ini untuk melaporkan kesalahan fungsi atau runtime ke Lambda, yang juga menerima header. `Transfer-Encoding` Titik akhir ini hanya dapat dipanggil sebelum runtime mulai mengirimkan respons pemanggilan.
+ Laporkan kesalahan midstream menggunakan trailer kesalahan di `/runtime/invocation/AwsRequestId/response` — Untuk melaporkan kesalahan yang terjadi setelah runtime mulai menulis respons pemanggilan, runtime dapat secara opsional melampirkan header trailing HTTP bernama dan. `Lambda-Runtime-Function-Error-Type` `Lambda-Runtime-Function-Error-Body` Lambda memperlakukan ini sebagai respons yang berhasil dan meneruskan metadata kesalahan yang disediakan runtime kepada klien.
**catatan**
Untuk melampirkan header tambahan, runtime harus menetapkan nilai `Trailer` header di awal permintaan HTTP. Ini adalah persyaratan spesifikasi pengkodean transfer chunked HTTP/1.1.
+ `Lambda-Runtime-Function-Error-Type`— Jenis kesalahan yang ditemui runtime. Header ini terdiri dari nilai string. Lambda menerima string apa pun, tetapi kami merekomendasikan format. ** Misalnya, `Runtime.APIKeyNotFound`.
+ `Lambda-Runtime-Function-Error-Body`— Informasi yang dikodekan Base64 tentang kesalahan.
## Membangun runtime kustom untuk Instans Terkelola Lambda
Instans Terkelola Lambda menggunakan API runtime yang sama dengan fungsi Lambda (default). Namun, ada perbedaan utama dalam cara runtime kustom harus diimplementasikan untuk mendukung model eksekusi bersamaan dari Instans Terkelola.
### Penanganan permintaan bersamaan
Perbedaan utama saat membuat runtime kustom untuk Instans Terkelola adalah dukungan untuk pemanggilan bersamaan. Tidak seperti fungsi Lambda (default) di mana runtime memproses satu pemanggilan pada satu waktu, Instans Terkelola dapat memproses beberapa pemanggilan secara bersamaan dalam satu lingkungan eksekusi.
Runtime kustom Anda harus:
+ **Mendukung `/next` permintaan bersamaan** - Runtime dapat membuat beberapa panggilan simultan ke API [pemanggilan berikutnya](runtimes-api.md#runtimes-api-next), hingga batas yang ditentukan oleh variabel lingkungan. `AWS_LAMBDA_MAX_CONCURRENCY`
+ **Menangani `/response` permintaan bersamaan** - Beberapa pemanggilan dapat memanggil API respons [pemanggilan](runtimes-api.md#runtimes-api-response) secara bersamaan.
+ **Menerapkan penanganan permintaan aman utas** - Pastikan pemanggilan bersamaan tidak saling mengganggu dengan mengelola sumber daya dan status bersama dengan benar.
+ **Gunakan permintaan unik IDs** — Lacak setiap pemanggilan secara terpisah menggunakan `Lambda-Runtime-Aws-Request-Id` header untuk mencocokkan respons dengan permintaan yang sesuai.
### Pola implementasi
Pola implementasi khas untuk runtime Instans Terkelola melibatkan pembuatan thread atau proses pekerja untuk menangani pemanggilan bersamaan:
1. **Baca batas konkurensi** — Pada inisialisasi, baca variabel `AWS_LAMBDA_MAX_CONCURRENCY` lingkungan untuk menentukan berapa banyak pemanggilan bersamaan yang akan didukung.
1. **Buat kumpulan pekerja** — Inisialisasi kumpulan pekerja (utas, proses, atau tugas asinkron) sama dengan batas konkurensi.
1. **Loop pemrosesan pekerja** - Setiap pekerja secara independen:
+ Panggilan `/runtime/invocation/next` untuk mendapatkan acara pemanggilan
+ Memanggil fungsi handler dengan data peristiwa
+ Memposting tanggapan terhadap `/runtime/invocation/AwsRequestId/response`
+ Mengulangi loop
### Pertimbangan tambahan
+ **Format logging** - Instans Terkelola hanya mendukung format log JSON. Pastikan runtime Anda menghormati variabel `AWS_LAMBDA_LOG_FORMAT` lingkungan dan hanya menggunakan format JSON. Untuk informasi selengkapnya, lihat [Mengkonfigurasi JSON dan format log teks biasa](monitoring-cloudwatchlogs-logformat.md).
+ **Sumber daya bersama** — Berhati-hatilah saat menggunakan sumber daya bersama seperti `/tmp` direktori dengan pemanggilan bersamaan. Menerapkan mekanisme penguncian yang tepat untuk mencegah kondisi balapan.
Untuk informasi selengkapnya tentang lingkungan eksekusi Instans Terkelola Lambda, lihat. [Memahami lingkungan eksekusi Instans Terkelola Lambda](lambda-managed-instances-execution-environment.md)
# Tutorial: Membangun runtime khusus
Dalam tutorial ini, Anda membuat fungsi Lambda dengan waktu pengoperasian kustom. Anda memulai dengan memasukkan waktu pengoperasian dalam paket deployment fungsi. Kemudian Anda memigrasikannya ke lapisan yang Anda kelola secara terpisah dari fungsi. Terakhir, Anda membagikan lapisan waktu pengoperasian kepada dunia dengan memperbarui kebijakan izin berbasis sumber daya.
## Prasyarat
Tutorial ini mengasumsikan bahwa Anda memiliki pengetahuan tentang operasi Lambda dan konsol Lambda dasar. Jika belum, ikuti petunjuk di [Membuat fungsi Lambda dengan konsol](getting-started.md#getting-started-create-function) untuk membuat fungsi Lambda pertama Anda.
Untuk menyelesaikan langkah-langkah berikut, Anda memerlukan [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). Perintah dan output yang diharapkan dicantumkan dalam blok terpisah:
```
aws --version
```
Anda akan melihat output berikut:
```
aws-cli/2.13.27 Python/3.11.6 Linux/4.14.328-248.540.amzn2.x86_64 exe/x86_64.amzn.2
```
Untuk perintah panjang, karakter escape (`\`) digunakan untuk memisahkan perintah menjadi beberapa baris.
Di Linux dan macOS, gunakan shell dan manajer paket pilihan Anda.
**catatan**
Di Windows, beberapa perintah Bash CLI yang biasa Anda gunakan dengan Lambda (`zip`seperti) tidak didukung oleh terminal bawaan sistem operasi. Untuk mendapatkan versi terintegrasi Windows dari Ubuntu dan Bash, [instal Windows Subsystem untuk](https://docs.microsoft.com/en-us/windows/wsl/install-win10) Linux. Contoh perintah CLI dalam panduan ini menggunakan pemformatan Linux. Perintah yang menyertakan dokumen JSON sebaris harus diformat ulang jika Anda menggunakan CLI Windows.
Anda memerlukan IAM role untuk membuat fungsi Lambda. Peran memerlukan izin untuk mengirim CloudWatch log ke Log dan mengakses Layanan AWS yang digunakan fungsi Anda. Jika Anda tidak memiliki peran untuk pengembangan fungsi, buatlah sekarang juga.
**Untuk membuat peran eksekusi**
1. Buka [halaman peran](https://console.aws.amazon.com/iam/home#/roles) di konsol IAM.
1. Pilih **Buat peran**.
1. Buat peran dengan properti berikut.
+ **Entitas tepercaya** – **Lambda**.
+ **Izin** – **AWSLambdaBasicExecutionRole**.
+ **Nama peran** – **lambda-role**.
**AWSLambdaBasicExecutionRole**Kebijakan ini memiliki izin yang diperlukan fungsi untuk menulis log ke CloudWatch Log.
## Buat fungsi
Buat fungsi Lambda dengan waktu pengoperasian kustom. Contoh ini mencakup dua file: file runtime `bootstrap` dan function handler. Keduanya diterapkan di Bash.
1. Buat direktori untuk proyek, dan kemudian beralih ke direktori itu.
```
mkdir runtime-tutorial
cd runtime-tutorial
```
1. Buat file baru bernama`bootstrap`. Ini adalah runtime khusus.
**Example bootstrap**
```
#!/bin/sh
set -euo pipefail
# Initialization - load function handler
source $LAMBDA_TASK_ROOT/"$(echo $_HANDLER | cut -d. -f1).sh"
# Processing
while true
do
HEADERS="$(mktemp)"
# Get an event. The HTTP request will block until one is received
EVENT_DATA=$(curl -sS -LD "$HEADERS" "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/next")
# Extract request ID by scraping response headers received above
REQUEST_ID=$(grep -Fi Lambda-Runtime-Aws-Request-Id "$HEADERS" | tr -d '[:space:]' | cut -d: -f2)
# Run the handler function from the script
RESPONSE=$($(echo "$_HANDLER" | cut -d. -f2) "$EVENT_DATA")
# Send the response
curl "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/$REQUEST_ID/response" -d "$RESPONSE"
done
```
Waktu pengoperasian memuat skrip fungsi dari paket deployment. Runtime menggunakan dua variabel untuk menemukan skrip.`LAMBDA_TASK_ROOT` memberi tahu tempat paket diekstrak, dan `_HANDLER` mencakup nama skrip.
Setelah runtime memuat skrip fungsi, ia menggunakan API runtime untuk mengambil peristiwa pemanggilan dari Lambda, meneruskan acara ke handler, dan memposting respons kembali ke Lambda. Untuk mendapatkan ID permintaan, waktu pengoperasian menyimpan header dari respons API ke file sementara, dan membaca header `Lambda-Runtime-Aws-Request-Id` dari file.
**catatan**
Waktu pengoperasian memiliki tanggung jawab tambahan, termasuk penanganan kesalahan, dan memberikan informasi konteks kepada penangan. Untuk detailnya, lihat [Persyaratan](runtimes-custom.md#runtimes-custom-build).
1. Buat skrip untuk fungsi tersebut. Contoh skrip berikut mendefinisikan fungsi handler yang mengambil data peristiwa, log ke`stderr`, dan mengembalikannya.
**Example function.sh**
```
function handler () {
EVENT_DATA=$1
echo "$EVENT_DATA" 1>&2;
RESPONSE="Echoing request: '$EVENT_DATA'"
echo $RESPONSE
}
```
`runtime-tutorial`Direktori sekarang akan terlihat seperti ini:
```
runtime-tutorial
├ bootstrap
└ function.sh
```
1. Buat file dapat dijalankan dan tambahkan ke arsip file .zip. Ini adalah paket penyebaran.
```
chmod 755 function.sh bootstrap
zip function.zip function.sh bootstrap
```
1. Buat fungsi bernama `bash-runtime`. [Untuk`--role`, masukkan ARN peran eksekusi Lambda Anda.](lambda-intro-execution-role.md)
```
aws lambda create-function --function-name bash-runtime \
--zip-file fileb://function.zip --handler function.handler --runtime provided.al2023 \
--role arn:aws:iam::123456789012:role/lambda-role
```
1. Memanggil fungsi.
```
aws lambda invoke --function-name bash-runtime --payload '{"text":"Hello"}' response.txt --cli-binary-format raw-in-base64-out
```
**cli-binary-format**Opsi ini diperlukan jika Anda menggunakan AWS CLI versi 2. Untuk menjadikan ini pengaturan default, jalankan`aws configure set cli-binary-format raw-in-base64-out`. Untuk informasi selengkapnya, lihat [opsi baris perintah global yang AWS CLI didukung](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) di *Panduan AWS Command Line Interface Pengguna untuk Versi 2*.
Anda akan melihat tanggapan seperti ini:
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
```
1. Verifikasi responsnya.
```
cat response.txt
```
Anda akan melihat tanggapan seperti ini:
```
Echoing request: '{"text":"Hello"}'
```
## Buat lapisan
Untuk memisahkan kode waktu pengoperasian dari kode fungsi, buat lapisan yang hanya berisi waktu pengoperasian. Lapisan memungkinkan Anda mengembangkan dependensi fungsi secara independen, dan dapat mengurangi penggunaan penyimpanan ketika Anda menggunakan lapisan yang sama dengan beberapa fungsi. Untuk informasi selengkapnya, lihat [Mengelola dependensi Lambda dengan lapisan](chapter-layers.md).
1. Buat file.zip yang berisi `bootstrap` file.
```
zip runtime.zip bootstrap
```
1. Buat lapisan dengan perintah [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html?highlight=nodejs16%20x).
```
aws lambda publish-layer-version --layer-name bash-runtime --zip-file fileb://runtime.zip
```
Ini menciptakan versi pertama lapisan.
## Perbarui fungsi
Untuk menggunakan layer runtime dalam fungsi, konfigurasikan fungsi untuk menggunakan layer, dan hapus kode runtime dari fungsi.
1. Perbarui konfigurasi fungsi untuk menarik lapisan.
```
aws lambda update-function-configuration --function-name bash-runtime \
--layers arn:aws:lambda:us-east-1:123456789012:layer:bash-runtime:1
```
Ini menambahkan waktu pengoperasian ke fungsi di direktori `/opt`. Untuk memastikan bahwa Lambda menggunakan runtime di layer, Anda harus menghapus `boostrap` dari paket penerapan fungsi, seperti yang ditunjukkan dalam dua langkah berikutnya.
1. Buat file.zip yang berisi kode fungsi.
```
zip function-only.zip function.sh
```
1. Perbarui kode fungsi untuk hanya memasukkan skrip penangan.
```
aws lambda update-function-code --function-name bash-runtime --zip-file fileb://function-only.zip
```
1. Panggil fungsi untuk mengonfirmasi bahwa ia berfungsi dengan layer runtime.
```
aws lambda invoke --function-name bash-runtime --payload '{"text":"Hello"}' response.txt --cli-binary-format raw-in-base64-out
```
**cli-binary-format**Opsi ini diperlukan jika Anda menggunakan AWS CLI versi 2. Untuk menjadikan ini pengaturan default, jalankan`aws configure set cli-binary-format raw-in-base64-out`. Untuk informasi selengkapnya, lihat [opsi baris perintah global yang AWS CLI didukung](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) di *Panduan AWS Command Line Interface Pengguna untuk Versi 2*.
Anda akan melihat tanggapan seperti ini:
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
```
1. Verifikasi responsnya.
```
cat response.txt
```
Anda akan melihat tanggapan seperti ini:
```
Echoing request: '{"text":"Hello"}'
```
## Perbarui waktu pengoperasian
1. Untuk mencatat log informasi tentang lingkungan eksekusi, perbarui skrip waktu pengoperasian ke variabel lingkungan output.
**Example bootstrap**
```
#!/bin/sh
set -euo pipefail
# Configure runtime to output environment variables
echo "## Environment variables:"
env
# Load function handler
source $LAMBDA_TASK_ROOT/"$(echo $_HANDLER | cut -d. -f1).sh"
# Processing
while true
do
HEADERS="$(mktemp)"
# Get an event. The HTTP request will block until one is received
EVENT_DATA=$(curl -sS -LD "$HEADERS" "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/next")
# Extract request ID by scraping response headers received above
REQUEST_ID=$(grep -Fi Lambda-Runtime-Aws-Request-Id "$HEADERS" | tr -d '[:space:]' | cut -d: -f2)
# Run the handler function from the script
RESPONSE=$($(echo "$_HANDLER" | cut -d. -f2) "$EVENT_DATA")
# Send the response
curl "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/$REQUEST_ID/response" -d "$RESPONSE"
done
```
1. Buat file.zip yang berisi versi baru `bootstrap` file.
```
zip runtime.zip bootstrap
```
1. Buat versi baru dari `bash-runtime` layer.
```
aws lambda publish-layer-version --layer-name bash-runtime --zip-file fileb://runtime.zip
```
1. Konfigurasikan fungsi untuk menggunakan versi baru lapisan.
```
aws lambda update-function-configuration --function-name bash-runtime \
--layers arn:aws:lambda:us-east-1:123456789012:layer:bash-runtime:2
```
## Bagikan lapisan
[Untuk berbagi layer dengan yang lain Akun AWS, tambahkan pernyataan izin lintas akun ke kebijakan berbasis sumber daya lapisan.](access-control-resource-based.md) Jalankan [add-layer-version-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-layer-version-permission.html)perintah dan tentukan ID akun sebagai`principal`. Dalam setiap pernyataan, Anda dapat memberikan izin ke satu akun, semua akun, atau organisasi di [AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_introduction.html).
Contoh berikut memberikan akun 111122223333 akses ke versi 2 lapisan. `bash-runtime`
```
aws lambda add-layer-version-permission \
--layer-name bash-runtime \
--version-number 2 \
--statement-id xaccount \
--action lambda:GetLayerVersion \
--principal 111122223333 \
--output text
```
Anda akan melihat output yang serupa dengan yang berikut:
```
{"Sid":"xaccount","Effect":"Allow","Principal":{"AWS":"arn:aws:iam::111122223333:root"},"Action":"lambda:GetLayerVersion","Resource":"arn:aws:lambda:us-east-1:123456789012:layer:bash-runtime:2"}
```
Izin hanya berlaku untuk satu versi lapisan. Ulangi proses ini tiap kali Anda membuat versi lapisan baru.
## Bersihkan
Hapus setiap versi lapisan.
```
aws lambda delete-layer-version --layer-name bash-runtime --version-number 1
aws lambda delete-layer-version --layer-name bash-runtime --version-number 2
```
Karena fungsi memiliki referensi ke lapisan versi 2, ia masih ada di Lambda. Fungsi terus bekerja, tetapi fungsi tidak dapat lagi dikonfigurasi untuk menggunakan versi yang dihapus. Jika Anda memodifikasi daftar lapisan pada fungsi, Anda harus menentukan versi baru atau menghilangkan lapisan yang dihapus.
Hapus fungsi dengan perintah [hapus-fungsi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-function.html).
```
aws lambda delete-function --function-name bash-runtime
```