Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Membangun fungsi Lambda dengan Ruby
Anda dapat menjalankan kode Ruby di AWS Lambda. Lambda menyediakan [runtime](lambda-runtimes.md) untuk Ruby yang menjalankan kode Anda untuk memproses peristiwa. Kode Anda berjalan di lingkungan yang menyertakan AWS SDK untuk Ruby, dengan kredensi dari peran AWS Identity and Access Management (IAM) yang Anda kelola. Untuk mempelajari lebih lanjut tentang versi SDK yang disertakan dengan runtime Ruby, lihat. [Versi SDK yang disertakan Runtime](#ruby-sdk-included)
Lambda mendukung runtime Ruby berikut.
| Nama | Pengidentifikasi | Sistem operasi | Tanggal pengusangan | Buat fungsi blok | Pembaruan fungsi blok |
| --- | --- | --- | --- | --- | --- |
| Ruby 3.4 | `ruby3.4` | Amazon Linux 2023 | 31 Mar 2028 | 30 Apr 2028 | 31 Mei 2028 |
| Ruby 3.3 | `ruby3.3` | Amazon Linux 2023 | 31 Mar 2027 | 30 Apr 2027 | 31 Mei 2027 |
| Ruby 3.2 | `ruby3.2` | Amazon Linux 2 | 31 Mar 2026 | Agustus 31, 2026 | Sep 30, 2026 |
**Untuk membuat fungsi Ruby**
1. Buka [Konsol Lambda](https://console.aws.amazon.com/lambda).
1. Pilih **Buat fungsi**.
1. Konfigurasikan pengaturan berikut:
+ **Nama fungsi**: Masukkan nama untuk fungsi tersebut.
+ **Runtime**: Pilih **Ruby 3.4**.
1. Pilih **Buat fungsi**.
Konsol membuat fungsi Lambda dengan satu file sumber bernama `lambda_function.rb`. Anda dapat mengedit file ini dan menambahkan lebih banyak file di editor kode bawaan. Di bagian **DEPLOY**, pilih **Deploy** untuk memperbarui kode fungsi Anda. Kemudian, untuk menjalankan kode Anda, pilih **Create test event** di bagian **TEST EVENTS**.
File `lambda_function.rb` mengekspor fungsi bernama `lambda_handler` yang menerima objek peristiwa dan objek konteks. Ini adalah [fungsi handler](ruby-handler.md) yang dipanggil Lambda saat fungsi tersebut dipanggil. Fungsi waktu habis Ruby mendapatkan peristiwa invokasi dari Lambda dan meneruskannya ke handler. Dalam konfigurasi fungsi, nilai handler adalah `lambda_function.lambda_handler`.
Saat Anda menyimpan kode fungsi, konsol Lambda membuat paket penyebaran arsip file.zip. Saat Anda mengembangkan kode fungsi di luar konsol (menggunakan IDE), Anda perlu [membuat paket penerapan](ruby-package.md) untuk mengunggah kode Anda ke fungsi Lambda.
Runtime fungsi meneruskan objek konteks ke handler, selain peristiwa invokasi. [Objek konteks](ruby-context.md) berisi informasi tambahan tentang lingkungan invokasi, fungsi, dan eksekusi. Informasi selengkapnya tersedia dari variabel lingkungan.
Fungsi Lambda Anda dilengkapi dengan grup CloudWatch log Log. Runtime fungsi mengirimkan detail tentang setiap invokasi ke CloudWatch Logs. Detail tersebut menyampaikan [log yang dihasilkan fungsi Anda](ruby-logging.md) selama invokasi. Jika fungsi mengembalikan kesalahan, Lambda memformat kesalahan dan mengembalikannya ke pemanggil.
**Topics**
+ [
## Versi SDK yang disertakan Runtime
](#ruby-sdk-included)
+ [
## Mengaktifkan Ruby JIT (YJIT) Lainnya
](#ruby-yjit)
+ [
# Tentukan penangan fungsi Lambda di Ruby
](ruby-handler.md)
+ [
# Deploy fungsi Lambda Ruby dengan arsip file .zip
](ruby-package.md)
+ [
# Deploy fungsi Ruby Lambda dengan gambar kontainer
](ruby-image.md)
+ [
# Bekerja dengan lapisan untuk fungsi Ruby Lambda
](ruby-layers.md)
+ [
# Menggunakan objek konteks Lambda untuk mengambil informasi fungsi Ruby
](ruby-context.md)
+ [
# Log dan pantau fungsi Ruby Lambda
](ruby-logging.md)
+ [
# Menginstrumentasi kode Ruby di AWS Lambda
](ruby-tracing.md)
## Versi SDK yang disertakan Runtime
Versi AWS SDK yang disertakan dalam runtime Ruby bergantung pada versi runtime dan versi Anda. Wilayah AWS AWS SDK for Ruby dirancang untuk modular dan dipisahkan oleh. Layanan AWS Untuk menemukan nomor versi permata layanan tertentu yang disertakan dalam runtime yang Anda gunakan, buat fungsi Lambda dengan kode dalam format berikut. Ganti `aws-sdk-s3` dan `Aws::S3` dengan nama permata layanan yang digunakan kode Anda.
```
require 'aws-sdk-s3'
def lambda_handler(event:, context:)
puts "Service gem version: #{Aws::S3::GEM_VERSION}"
puts "Core version: #{Aws::CORE_GEM_VERSION}"
end
```
## Mengaktifkan Ruby JIT (YJIT) Lainnya
Runtime Ruby mendukung [YJIT, kompiler Ruby JIT](https://docs.ruby-lang.org/en/master/jit/yjit_md.html) yang ringan dan minimalis. YJIT memberikan kinerja yang jauh lebih tinggi, tetapi juga menggunakan lebih banyak memori daripada penerjemah Ruby. YJIT direkomendasikan untuk beban kerja Ruby on Rails.
YJIT tidak diaktifkan secara default. Untuk mengaktifkan YJIT untuk fungsi Ruby, atur variabel `RUBY_YJIT_ENABLE` lingkungan ke. `1` Untuk mengonfirmasi bahwa YJIT diaktifkan, cetak hasil metode. `RubyVM::YJIT.enabled?`
**Example — Konfirmasikan bahwa YJIT diaktifkan**
```
puts(RubyVM::YJIT.enabled?())
# => true
```
# Tentukan penangan fungsi Lambda di Ruby
*Handler* fungsi Lambda Anda adalah metode dalam kode fungsi Anda yang memproses peristiwa. Saat fungsi Anda diaktifkan, Lambda menjalankan metode handler. Fungsi Anda berjalan sampai handler mengembalikan respons, keluar, atau waktu habis.
**Topics**
+ [
## Dasar-dasar penangan Ruby
](#ruby-handler-basics)
+ [
## Praktik terbaik kode untuk fungsi Ruby Lambda
](#ruby-best-practices)
## Dasar-dasar penangan Ruby
Dalam contoh berikut, file `function.rb` menentukan metode handler bernama `handler`. Fungsi handler mengambil dua objek sebagai input dan mengembalikan dokumen JSON.
**Example function.rb**
```
require 'json'
def handler(event:, context:)
{ event: JSON.generate(event), context: JSON.generate(context.inspect) }
end
```
Dalam konfigurasi fungsi Anda, pengaturan `handler` memberi tahu Lambda tempat untuk menemukan penangan. Untuk contoh sebelumnya, nilai yang benar untuk pengaturan ini adalah **function.handler**. Ini mencakup dua nama yang dipisahkan oleh titik: nama file dan metode handler.
Anda juga dapat menentukan metode penangan dalam kelas. Contoh berikut mendefinisikan metode penangan bernama `process` pada kelas bernama `Handler` dalam modul bernama `LambdaFunctions`.
**Example source.rb**
```
module LambdaFunctions
class Handler
def self.process(event:,context:)
"Hello!"
end
end
end
```
Dalam hal ini, pengaturan penangan adalah **source.LambdaFunctions::Handler.process**.
Dua objek yang diterima handler adalah kejadian dan konteks invokasi. Kejadian tersebut adalah objek Ruby yang berisi muatan yang disediakan oleh pelaku invokasi. Jika muatannya adalah dokumen JSON, objek kejadiannya adalah hash Ruby. Jika tidak, objek kejadiannya adalah string. [Objek konteks](ruby-context.md) memiliki metode dan properti yang menyediakan informasi tentang invokasi, fungsi, dan lingkungan eksekusi.
Penangan fungsi dijalankan setiap kali fungsi Lambda Anda diinvokasi. Kode statis di luar penangan dijalankan satu kali per instans fungsi. Jika penangan menggunakan sumber daya, seperti klien SDK dan koneksi database, Anda dapat membuatnya di luar metode penangan untuk menggunakannya kembali untuk beberapa invokasi.
Setiap instans fungsi Anda dapat memproses beberapa kejadian invokasi, tetapi hanya memproses satu kejadian dalam satu waktu. Jumlah instans yang memproses kejadian pada waktu tertentu adalah *konkurensi* fungsi Anda. Untuk informasi lebih lanjut tentang lingkungan eksekusi Lambda, lihat [Memahami siklus hidup lingkungan pelaksanaan Lambda](lambda-runtime-environment.md).
## Praktik terbaik kode untuk fungsi Ruby Lambda
Patuhi pedoman dalam daftar berikut untuk menggunakan praktik pengkodean terbaik saat membangun fungsi Lambda Anda:
+ **Pisahkan handler Lambda dari logika inti Anda.** Ini memungkinkan Anda untuk membuat fungsi yang lebih dapat teruji. Misalnya, di Ruby, ini mungkin terlihat seperti:
```
def lambda_handler(event:, context:)
foo = event['foo']
bar = event['bar']
result = my_lambda_function(foo:, bar:)
end
def my_lambda_function(foo:, bar:)
// MyLambdaFunction logic here
end
```
+ **Kontrol dependensi dalam paket penerapan fungsi Anda.** Lingkungan AWS Lambda eksekusi berisi sejumlah pustaka. Untuk runtime Ruby, ini termasuk SDK AWS . Untuk mengaktifkan serangkaian fitur dan pembaruan keamanan terbaru, Lambda akan memperbarui pustaka ini secara berkala. Pembaruan ini dapat memberikan perubahan kecil pada perilaku fungsi Lambda Anda. Untuk memiliki kendali penuh atas dependensi yang digunakan fungsi Anda, kemas semua dependensi Anda dengan paket deployment Anda.
+ **Minimalkan kompleksitas dependensi Anda.** Utamakan memilih kerangka kerja lebih sederhana yang cepat dimuat dalam memulai [lingkungan eksekusi](lambda-runtime-environment.md).
+ **Minimalkan ukuran paket penerapan Anda sesuai kebutuhan runtime-nya.** Ini akan mengurangi jumlah waktu yang dibutuhkan untuk mengunduh dan membongkar paket deployment Anda sebelum invokasi. Untuk fungsi yang ditulis di Ruby, hindari mengunggah seluruh pustaka AWS SDK sebagai bagian dari paket penerapan Anda. Sebagai gantinya, secara selektif bergantung pada permata yang mengambil komponen SDK yang Anda butuhkan (misalnya permata DynamoDB atau Amazon S3 SDK).
**Manfaatkan penggunaan kembali lingkungan eksekusi untuk meningkatkan kinerja fungsi Anda.** Inisialisasi klien SDK dan koneksi basis data di luar fungsi handler, dan lakukan caching aset statis secara lokal di direktori `/tmp`. Invokasi selanjutnya yang diproses oleh instans yang sama dari fungsi Anda dapat menggunakan kembali sumber daya ini. Ini menghemat biaya dengan mengurangi waktu pengoperasian fungsi.
Untuk menghindari potensi kebocoran data di seluruh invokasi, jangan menggunakan lingkungan eksekusi untuk menyimpan data pengguna, peristiwa, atau informasi lainnya implikasi keamanan. Jika fungsi Anda bergantung pada status yang dapat disenyapkan yang tidak dapat disimpan dalam memori di dalam handler, pertimbangkan untuk membuat fungsi terpisah atau versi terpisah dari fungsi untuk setiap pengguna.
**Gunakan arahan keep-alive untuk mempertahankan koneksi yang persisten.** Lambda membersihkan koneksi idle dari waktu ke waktu. Mencoba menggunakan ulang koneksi idle saat mengidentifikasi suatu fungsi akan menyebabkan kesalahan koneksi. Untuk mempertahankan koneksi yang persisten, gunakan arahan tetap aktif yang berkaitan dengan runtime Anda. Sebagai contoh, lihat [Menggunakan Kembali Koneksi dengan Keep-Alive di Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).
**Gunakan [variabel lingkungan](configuration-envvars.md) untuk meneruskan parameter operasional ke fungsi Anda.** Misalnya, jika Anda ingin menulis ke bucket Amazon S3 alih-alih melakukan hard-coding nama bucket yang Anda tulis, konfigurasikan nama bucket sebagai variabel lingkungan.
**Hindari menggunakan pemanggilan rekursif** dalam fungsi Lambda Anda, di mana fungsi memanggil dirinya sendiri atau memulai proses yang dapat memanggil fungsi lagi. Hal ini dapat menyebabkan volume invokasi fungsi yang tidak diinginkan dan peningkatan biaya. Jika Anda melihat volume pemanggilan yang tidak diinginkan, setel konkurensi fungsi cadangan untuk `0` segera membatasi semua pemanggilan ke fungsi, saat Anda memperbarui kode.
**Jangan gunakan non-dokumen, non-publik APIs** dalam kode fungsi Lambda Anda. Untuk runtime AWS Lambda terkelola, Lambda secara berkala menerapkan pembaruan keamanan dan fungsional ke internal Lambda. APIs Pembaruan API internal ini mungkin tidak kompatibel ke belakang, yang menyebabkan konsekuensi yang tidak diinginkan seperti kegagalan pemanggilan jika fungsi Anda memiliki ketergantungan pada non-publik ini. APIs Lihat [referensi API](https://docs.aws.amazon.com/lambda/latest/api/welcome.html) untuk daftar yang tersedia APIs untuk umum.
**Tulis kode idempoten.** Menulis kode idempoten untuk fungsi Anda memastikan bahwa peristiwa duplikat ditangani dengan cara yang sama. Kode Anda harus memvalidasi peristiwa dengan benar dan menangani peristiwa duplikat dengan anggun. Untuk informasi selengkapnya, lihat [Bagaimana cara membuat fungsi Lambda saya idempoten?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/) .
# Deploy fungsi Lambda Ruby dengan arsip file .zip
Kode AWS Lambda fungsi Anda terdiri dari file.rb yang berisi kode handler fungsi Anda, bersama dengan dependensi tambahan (permata) yang bergantung pada kode Anda. *Untuk menyebarkan kode fungsi ini ke Lambda, Anda menggunakan paket penerapan.* Paket ini dapat berupa arsip file.zip atau gambar kontainer. Untuk informasi selengkapnya tentang penggunaan gambar kontainer dengan Ruby, lihat [Menerapkan fungsi Ruby Lambda](https://docs.aws.amazon.com/lambda/latest/dg/ruby-image.html) dengan gambar kontainer.
[Untuk membuat paket penyebaran Anda sebagai arsip file.zip, Anda dapat menggunakan utilitas arsip file.zip bawaan alat baris perintah Anda, atau utilitas file.zip lainnya seperti 7zip.](https://www.7-zip.org/download.html) Contoh yang ditampilkan di bagian berikut mengasumsikan Anda menggunakan `zip` alat baris perintah di lingkungan Linux atau macOS. Untuk menggunakan perintah yang sama di Windows, Anda dapat [menginstal Windows Subsystem untuk Linux untuk](https://docs.microsoft.com/en-us/windows/wsl/install-win10) mendapatkan versi Windows terintegrasi dari Ubuntu dan Bash.
Perhatikan bahwa Lambda menggunakan izin file POSIX, jadi Anda mungkin perlu [mengatur izin untuk folder paket penyebaran](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/) sebelum membuat arsip file.zip.
Perintah contoh di bagian berikut menggunakan utilitas [Bundler](https://bundler.io/) untuk menambahkan dependensi ke paket penyebaran Anda. Untuk menginstal bundler, jalankan perintah berikut.
```
gem install bundler
```
**Topics**
+ [
## Dependensi di Ruby
](#ruby-package-runtime-dependencies)
+ [
## Membuat paket penerapan.zip tanpa dependensi
](#ruby-package-codeonly)
+ [
## Membuat paket penerapan.zip dengan dependensi
](#ruby-package-dependencies)
+ [
## Membuat layer Ruby untuk dependensi Anda
](#ruby-package-dependencies-layers)
+ [
## Membuat paket penerapan.zip dengan pustaka asli
](#ruby-package-native)
+ [
## Membuat dan memperbarui fungsi Ruby Lambda menggunakan file.zip
](#ruby-package-create-functions)
## Dependensi di Ruby
Untuk fungsi Lambda yang menggunakan runtime Ruby, dependensi dapat berupa permata Ruby apa pun. Ketika Anda menerapkan fungsi Anda menggunakan arsip.zip, Anda dapat menambahkan dependensi ini ke file.zip Anda dengan kode fungsi Anda atau menggunakan lapisan Lambda. Lapisan adalah file.zip terpisah yang dapat berisi kode tambahan dan konten lainnya. Untuk mempelajari lebih lanjut tentang menggunakan layer Lambda, lihat. [Mengelola dependensi Lambda dengan lapisan](chapter-layers.md)
Runtime Ruby termasuk. AWS SDK untuk Ruby Jika fungsi Anda menggunakan SDK, Anda tidak perlu menggabungkannya dengan kode Anda. Namun, untuk mempertahankan kontrol penuh atas dependensi Anda, atau menggunakan versi SDK tertentu, Anda dapat menambahkannya ke paket penerapan fungsi Anda. Anda dapat menyertakan SDK dalam file.zip Anda, atau menambahkannya menggunakan lapisan Lambda. Dependensi di file.zip Anda atau di lapisan Lambda lebih diutamakan daripada versi yang disertakan dalam runtime. Untuk mengetahui versi SDK for Ruby mana yang disertakan dalam versi runtime Anda, lihat. [Versi SDK yang disertakan Runtime](lambda-ruby.md#ruby-sdk-included)
Di bawah [model tanggung jawab AWS bersama](lambda-runtimes.md#runtimes-shared-responsibility), Anda bertanggung jawab atas pengelolaan dependensi apa pun dalam paket penerapan fungsi Anda. Ini termasuk menerapkan pembaruan dan patch keamanan. Untuk memperbarui dependensi dalam paket penerapan fungsi Anda, pertama buat file.zip baru dan kemudian unggah ke Lambda. Lihat [Membuat paket penerapan.zip dengan dependensi](#ruby-package-dependencies) dan [Membuat dan memperbarui fungsi Ruby Lambda menggunakan file.zip](#ruby-package-create-functions) untuk informasi lebih lanjut.
## Membuat paket penerapan.zip tanpa dependensi
Jika kode fungsi Anda tidak memiliki dependensi, file.zip Anda hanya berisi file.rb dengan kode handler fungsi Anda. Gunakan utilitas zip pilihan Anda untuk membuat file.zip dengan file.rb Anda di root. Jika file.rb tidak berada di root file.zip Anda, Lambda tidak akan dapat menjalankan kode Anda.
Untuk mempelajari cara menerapkan file.zip Anda untuk membuat fungsi Lambda baru atau memperbarui yang sudah ada, lihat. [Membuat dan memperbarui fungsi Ruby Lambda menggunakan file.zip](#ruby-package-create-functions)
## Membuat paket penerapan.zip dengan dependensi
[Jika kode fungsi Anda bergantung pada permata Ruby tambahan, Anda dapat menambahkan dependensi ini ke file.zip Anda dengan kode fungsi Anda atau menggunakan lapisan Lambda.](chapter-layers.md) Petunjuk di bagian ini menunjukkan cara memasukkan dependensi dalam paket penerapan.zip Anda. Untuk petunjuk tentang cara memasukkan dependensi Anda dalam lapisan, lihat. [Membuat layer Ruby untuk dependensi Anda](#ruby-package-dependencies-layers)
Misalkan kode fungsi Anda disimpan dalam file bernama `lambda_function.rb` di direktori proyek Anda. Contoh perintah CLI berikut membuat file.zip bernama `my_deployment_package.zip` berisi kode fungsi Anda dan dependensinya.
**Untuk membuat paket deployment**
1. Di direktori proyek Anda, buat a `Gemfile` untuk menentukan dependensi Anda di.
```
bundle init
```
1. Menggunakan editor teks pilihan Anda, edit `Gemfile` untuk menentukan dependensi fungsi Anda. Misalnya, untuk menggunakan TZInfo permata, edit Anda `Gemfile` agar terlihat seperti berikut ini.
```
source "https://rubygems.org"
gem "tzinfo"
```
1. Jalankan perintah berikut untuk menginstal permata yang ditentukan `Gemfile` dalam direktori proyek Anda. Perintah ini ditetapkan `vendor/bundle` sebagai jalur default untuk instalasi permata.
```
bundle config set --local path 'vendor/bundle' && bundle install
```
Anda akan melihat output seperti yang berikut ini.
```
Fetching gem metadata from https://rubygems.org/...........
Resolving dependencies...
Using bundler 2.4.13
Fetching tzinfo 2.0.6
Installing tzinfo 2.0.6
...
```
**catatan**
Untuk menginstal permata secara global lagi nanti, jalankan perintah berikut.
```
bundle config set --local system 'true'
```
1. Buat arsip file.zip yang berisi `lambda_function.rb` file dengan kode handler fungsi Anda dan dependensi yang Anda instal pada langkah sebelumnya.
```
zip -r my_deployment_package.zip lambda_function.rb vendor
```
Anda akan melihat output seperti yang berikut ini.
```
adding: lambda_function.rb (deflated 37%)
adding: vendor/ (stored 0%)
adding: vendor/bundle/ (stored 0%)
adding: vendor/bundle/ruby/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/build_info/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/cache/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/cache/aws-eventstream-1.0.1.gem (deflated 36%)
...
```
## Membuat layer Ruby untuk dependensi Anda
Untuk mempelajari cara mengemas dependensi Ruby Anda ke dalam lapisan Lambda, lihat. [Bekerja dengan lapisan untuk fungsi Ruby Lambda](ruby-layers.md)
## Membuat paket penerapan.zip dengan pustaka asli
Banyak permata Ruby umum seperti`nokogiri`,`nio4r`, dan `mysql` berisi ekstensi asli yang ditulis dalam C. Ketika Anda menambahkan pustaka yang berisi kode C ke paket penyebaran Anda, Anda harus membangun paket Anda dengan benar untuk memastikan bahwa itu kompatibel dengan lingkungan eksekusi Lambda.
Untuk aplikasi produksi, kami sarankan untuk membangun dan menerapkan kode Anda menggunakan AWS Serverless Application Model (AWS SAM). AWS SAM Gunakan `sam build --use-container` opsi untuk membangun fungsi Anda di dalam wadah Docker seperti Lambda. Untuk mempelajari lebih lanjut AWS SAM cara menggunakan kode fungsi, lihat [Membangun aplikasi](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-using-build.html) di *Panduan AWS SAM Pengembang*.
Untuk membuat paket penerapan.zip yang berisi permata dengan ekstensi asli tanpa menggunakan AWS SAM, Anda dapat menggunakan container untuk menggabungkan dependensi Anda di lingkungan yang sama dengan lingkungan runtime Lambda Ruby. Untuk menyelesaikan langkah-langkah ini, Anda harus menginstal Docker di mesin build Anda. Untuk mempelajari lebih lanjut tentang menginstal Docker, lihat [Menginstal Docker Engine](https://docs.docker.com/engine/install/).
**Untuk membuat paket penyebaran.zip dalam wadah Docker**
1. Buat folder di mesin build lokal Anda untuk menyimpan wadah Anda. Di dalam folder itu, buat file bernama `dockerfile` dan tempel kode berikut ke dalamnya.
```
FROM public.ecr.aws/sam/build-ruby3.2:latest-x86_64
RUN gem update bundler
CMD "/bin/bash"
```
1. Di dalam folder yang Anda `dockerfile` buat, jalankan perintah berikut untuk membuat wadah Docker.
```
docker build -t awsruby32 .
```
1. Arahkan ke direktori proyek yang berisi `.rb` file dengan kode handler fungsi Anda dan `Gemfile` menentukan dependensi fungsi Anda. Dari dalam direktori itu, jalankan perintah berikut untuk memulai wadah Lambda Ruby.
------
#### [ Linux/MacOS ]
```
docker run --rm -it -v $PWD:/var/task -w /var/task awsruby32
```
**catatan**
Di macOS, Anda mungkin melihat peringatan yang memberi tahu Anda bahwa platform gambar yang diminta tidak cocok dengan platform host yang terdeteksi. Abaikan peringatan ini.
------
#### [ Windows PowerShell ]
```
docker run --rm -it -v ${pwd}:var/task -w /var/task awsruby32
```
------
Saat wadah Anda dimulai, Anda akan melihat prompt bash.
```
bash-4.2#
```
1. Konfigurasikan utilitas bundel untuk menginstal permata yang ditentukan `Gemfile` dalam `vendor/bundle` direktori lokal Anda dan instal dependensi Anda.
```
bash-4.2# bundle config set --local path 'vendor/bundle' && bundle install
```
1. Buat paket deployment .zip dengan kode fungsi Anda dan dependensinya. Dalam contoh ini, file yang berisi kode handler fungsi Anda diberi nama`lambda_function.rb`.
```
bash-4.2# zip -r my_deployment_package.zip lambda_function.rb vendor
```
1. Keluar dari wadah dan kembali ke direktori proyek lokal Anda.
```
bash-4.2# exit
```
Anda sekarang dapat menggunakan paket penyebaran file.zip untuk membuat atau memperbarui fungsi Lambda Anda. Lihat [Membuat dan memperbarui fungsi Ruby Lambda menggunakan file.zip](#ruby-package-create-functions)
## Membuat dan memperbarui fungsi Ruby Lambda menggunakan file.zip
Setelah Anda membuat paket.zip deployment, Anda dapat menggunakannya untuk membuat fungsi Lambda baru atau memperbarui yang sudah ada. Anda dapat menerapkan paket.zip Anda menggunakan konsol Lambda, API, AWS Command Line Interface dan Lambda. Anda juga dapat membuat dan memperbarui fungsi Lambda menggunakan AWS Serverless Application Model (AWS SAM) dan. CloudFormation
Ukuran maksimum untuk paket.zip deployment untuk Lambda adalah 250 MB (unzip). Perhatikan bahwa batas ini berlaku untuk ukuran gabungan semua file yang Anda unggah, termasuk lapisan Lambda apa pun.
Runtime Lambda membutuhkan izin untuk membaca file dalam paket deployment Anda. Dalam notasi oktal izin Linux, Lambda membutuhkan 644 izin untuk file yang tidak dapat dieksekusi (rw-r - r--) dan 755 izin () untuk direktori dan file yang dapat dieksekusi. rwxr-xr-x
Di Linux dan macOS, gunakan `chmod` perintah untuk mengubah izin file pada file dan direktori dalam paket penyebaran Anda. Misalnya, untuk memberikan file yang tidak dapat dieksekusi izin yang benar, jalankan perintah berikut.
```
chmod 644
```
Untuk mengubah izin file di Windows, lihat [Mengatur, Melihat, Mengubah, atau Menghapus Izin pada Objek](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) dalam dokumentasi Microsoft Windows.
**catatan**
Jika Anda tidak memberikan Lambda izin yang diperlukan untuk mengakses direktori dalam paket penerapan Anda, Lambda menetapkan izin untuk direktori tersebut ke 755 (). rwxr-xr-x
### Membuat dan memperbarui fungsi dengan file.zip menggunakan konsol
Untuk membuat fungsi baru, Anda harus terlebih dahulu membuat fungsi di konsol, lalu mengunggah arsip.zip Anda. Untuk memperbarui fungsi yang ada, buka halaman untuk fungsi Anda, lalu ikuti prosedur yang sama untuk menambahkan file.zip Anda yang diperbarui.
Jika file.zip Anda kurang dari 50MB, Anda dapat membuat atau memperbarui fungsi dengan mengunggah file langsung dari mesin lokal Anda. Untuk file.zip yang lebih besar dari 50MB, Anda harus mengunggah paket Anda ke bucket Amazon S3 terlebih dahulu. Untuk petunjuk tentang cara mengunggah file ke bucket Amazon S3 menggunakan Konsol Manajemen AWS, lihat [Memulai Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). Untuk mengunggah file menggunakan AWS CLI, lihat [Memindahkan objek](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) di *Panduan AWS CLI Pengguna*.
**catatan**
Anda tidak dapat mengubah [jenis paket penerapan](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip atau image kontainer) untuk fungsi yang ada. Misalnya, Anda tidak dapat mengonversi fungsi gambar kontainer untuk menggunakan arsip file.zip. Anda harus membuat fungsi baru.
**Untuk membuat fungsi baru (konsol)**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) konsol Lambda dan pilih **Buat** Fungsi.
1. Pilih **Tulis dari awal**.
1. Di bagian **Informasi dasar**, lakukan hal berikut:
1. Untuk **nama Fungsi**, masukkan nama untuk fungsi Anda.
1. Untuk **Runtime**, pilih runtime yang ingin Anda gunakan.
1. (Opsional) Untuk **Arsitektur**, pilih arsitektur set instruksi untuk fungsi Anda. Arsitektur defaultnya adalah x86\$164. Pastikan bahwa paket deployment .zip untuk fungsi Anda kompatibel dengan arsitektur set instruksi yang Anda pilih.
1. (Opsional) Di bagian **Izin**, luaskan **Ubah peran eksekusi default**. Anda dapat membuat **peran Eksekusi** baru atau menggunakan yang sudah ada.
1. Pilih **Buat fungsi**. Lambda menciptakan fungsi dasar 'Hello world' menggunakan runtime yang Anda pilih.
**Untuk mengunggah arsip.zip dari mesin lokal Anda (konsol)**
1. Di [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) konsol Lambda, pilih fungsi yang ingin Anda unggah file.zip.
1. Pilih tab **Kode**.
1. Di panel **Sumber kode**, pilih **Unggah dari**.
1. Pilih **file.zip**.
1. Untuk mengunggah file.zip, lakukan hal berikut:
1. Pilih **Unggah**, lalu pilih file.zip Anda di pemilih file.
1. Pilih **Buka**.
1. Pilih **Simpan**.
**Untuk mengunggah arsip.zip dari bucket Amazon S3 (konsol)**
1. Di [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) konsol Lambda, pilih fungsi yang ingin Anda unggah file.zip baru.
1. Pilih tab **Kode**.
1. Di panel **Sumber kode**, pilih **Unggah dari**.
1. Pilih **lokasi Amazon S3**.
1. **Rekatkan URL tautan Amazon S3 dari file.zip Anda dan pilih Simpan.**
### Memperbarui fungsi file.zip menggunakan editor kode konsol
Untuk beberapa fungsi dengan paket penyebaran.zip, Anda dapat menggunakan editor kode bawaan konsol Lambda untuk memperbarui kode fungsi Anda secara langsung. Untuk menggunakan fitur ini, fungsi Anda harus memenuhi kriteria berikut:
+ Fungsi Anda harus menggunakan salah satu runtime bahasa yang ditafsirkan (Python, Node.js, atau Ruby)
+ Paket penerapan fungsi Anda harus lebih kecil dari 50 MB (unzip).
Kode fungsi untuk fungsi dengan paket penerapan gambar kontainer tidak dapat diedit langsung di konsol.
**Untuk memperbarui kode fungsi menggunakan editor kode konsol**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) konsol Lambda dan pilih fungsi Anda.
1. Pilih tab **Kode**.
1. Di panel **Sumber kode**, pilih file kode sumber Anda dan edit di editor kode terintegrasi.
1. Di bagian **DEPLOY**, pilih **Deploy** untuk memperbarui kode fungsi Anda:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
### Membuat dan memperbarui fungsi dengan file.zip menggunakan AWS CLI
Anda dapat menggunakan [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)untuk membuat fungsi baru atau memperbarui yang sudah ada menggunakan file.zip. Gunakan [create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) dan [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html)perintah untuk menyebarkan paket.zip Anda. Jika file.zip Anda lebih kecil dari 50MB, Anda dapat mengunggah paket.zip dari lokasi file di mesin build lokal Anda. Untuk file yang lebih besar, Anda harus mengunggah paket.zip Anda dari bucket Amazon S3. Untuk petunjuk tentang cara mengunggah file ke bucket Amazon S3 menggunakan AWS CLI, lihat [Memindahkan objek](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) di *AWS CLI Panduan Pengguna*.
**catatan**
Jika Anda mengunggah file.zip dari bucket Amazon S3 menggunakan AWS CLI bucket, bucket harus berada di lokasi Wilayah AWS yang sama dengan fungsi Anda.
Untuk membuat fungsi baru menggunakan file.zip dengan AWS CLI, Anda harus menentukan yang berikut:
+ Nama fungsi Anda (`--function-name`)
+ Runtime () `--runtime` fungsi Anda
+ Nama Sumber Daya Amazon (ARN) dari [peran eksekusi](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) fungsi Anda () `--role`
+ Nama metode handler dalam kode fungsi Anda () `--handler`
Anda juga harus menentukan lokasi file.zip Anda. Jika file.zip Anda terletak di folder di mesin build lokal Anda, gunakan `--zip-file` opsi untuk menentukan jalur file, seperti yang ditunjukkan pada perintah contoh berikut.
```
aws lambda create-function --function-name myFunction \
--runtime ruby3.2 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```
Untuk menentukan lokasi file.zip di bucket Amazon S3, gunakan opsi seperti `--code` yang ditunjukkan pada perintah contoh berikut. Anda hanya perlu menggunakan `S3ObjectVersion` parameter untuk objek berversi.
```
aws lambda create-function --function-name myFunction \
--runtime ruby3.2 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```
Untuk memperbarui fungsi yang ada menggunakan CLI, Anda menentukan nama fungsi Anda menggunakan parameter. `--function-name` Anda juga harus menentukan lokasi file.zip yang ingin Anda gunakan untuk memperbarui kode fungsi Anda. Jika file.zip Anda terletak di folder di mesin build lokal Anda, gunakan `--zip-file` opsi untuk menentukan jalur file, seperti yang ditunjukkan pada perintah contoh berikut.
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Untuk menentukan lokasi file.zip di bucket Amazon S3, gunakan opsi `--s3-key` dan seperti `--s3-bucket` yang ditunjukkan pada perintah contoh berikut. Anda hanya perlu menggunakan `--s3-object-version` parameter untuk objek berversi.
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Membuat dan memperbarui fungsi dengan file.zip menggunakan API Lambda
Untuk membuat dan memperbarui fungsi menggunakan arsip file.zip, gunakan operasi API berikut:
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
### Membuat dan memperbarui fungsi dengan file.zip menggunakan AWS SAM
The AWS Serverless Application Model (AWS SAM) adalah toolkit yang membantu merampingkan proses membangun dan menjalankan aplikasi tanpa server. AWS Anda menentukan sumber daya untuk aplikasi Anda dalam template YAMB atau JSON dan menggunakan antarmuka baris AWS SAM perintah (AWS SAM CLI) untuk membangun, mengemas, dan menyebarkan aplikasi Anda. Saat Anda membuat fungsi Lambda dari AWS SAM template, AWS SAM secara otomatis membuat paket penerapan .zip atau gambar kontainer dengan kode fungsi Anda dan dependensi apa pun yang Anda tentukan. Untuk mempelajari lebih lanjut cara menggunakan AWS SAM untuk membangun dan menerapkan fungsi Lambda, [lihat Memulai](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) di Panduan AWS SAM*AWS Serverless Application Model Pengembang*.
Anda juga dapat menggunakan AWS SAM untuk membuat fungsi Lambda menggunakan arsip file.zip yang ada. Untuk membuat fungsi Lambda menggunakan AWS SAM, Anda dapat menyimpan file.zip di bucket Amazon S3 atau di folder lokal di mesin build Anda. Untuk petunjuk tentang cara mengunggah file ke bucket Amazon S3 menggunakan AWS CLI, lihat [Memindahkan objek](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) di *AWS CLI Panduan Pengguna*.
Dalam AWS SAM template Anda, `AWS::Serverless::Function` sumber daya menentukan fungsi Lambda Anda. Dalam sumber daya ini, atur properti berikut untuk membuat fungsi menggunakan arsip file.zip:
+ `PackageType`- diatur ke `Zip`
+ `CodeUri`- diatur ke kode fungsi Amazon S3 URI, jalur ke folder lokal, atau objek [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html)
+ `Runtime`- Setel ke runtime yang Anda pilih
Dengan AWS SAM, jika file.zip Anda lebih besar dari 50MB, Anda tidak perlu mengunggahnya ke bucket Amazon S3 terlebih dahulu. AWS SAM dapat mengunggah paket.zip hingga ukuran maksimum yang diizinkan 250MB (unzip) dari lokasi di mesin build lokal Anda.
Untuk mempelajari selengkapnya tentang penerapan fungsi menggunakan file.zip AWS SAM, lihat [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)di Panduan *AWS SAM Pengembang*.
### Membuat dan memperbarui fungsi dengan file.zip menggunakan CloudFormation
Anda dapat menggunakan CloudFormation untuk membuat fungsi Lambda menggunakan arsip file.zip. Untuk membuat fungsi Lambda dari file.zip, Anda harus terlebih dahulu mengunggah file Anda ke bucket Amazon S3. Untuk petunjuk tentang cara mengunggah file ke bucket Amazon S3 menggunakan AWS CLI, lihat [Memindahkan objek](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) di *AWS CLI Panduan Pengguna*.
Dalam CloudFormation template Anda, `AWS::Lambda::Function` sumber daya menentukan fungsi Lambda Anda. Dalam sumber daya ini, atur properti berikut untuk membuat fungsi menggunakan arsip file.zip:
+ `PackageType`- Setel ke `Zip`
+ `Code`- Masukkan nama bucket Amazon S3 dan nama file.zip di dan bidang `S3Bucket` `S3Key`
+ `Runtime`- Setel ke runtime yang Anda pilih
File.zip yang CloudFormation menghasilkan tidak boleh melebihi 4MB. Untuk mempelajari selengkapnya tentang penerapan fungsi menggunakan file.zip CloudFormation, lihat [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)di *CloudFormation Panduan Pengguna*.
# Deploy fungsi Ruby Lambda dengan gambar kontainer
Ada tiga cara untuk membangun gambar kontainer untuk fungsi Ruby Lambda:
+ [Menggunakan gambar AWS dasar untuk Ruby](#ruby-image-instructions)
[Gambar AWS dasar](images-create.md#runtimes-images-lp) dimuat sebelumnya dengan runtime bahasa, klien antarmuka runtime untuk mengelola interaksi antara Lambda dan kode fungsi Anda, dan emulator antarmuka runtime untuk pengujian lokal.
+ [Menggunakan gambar AWS dasar khusus OS](images-create.md#runtimes-images-provided)
[AWS Gambar dasar khusus OS](https://gallery.ecr.aws/lambda/provided) berisi distribusi Amazon Linux dan emulator antarmuka [runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Gambar-gambar ini biasanya digunakan untuk membuat gambar kontainer untuk bahasa yang dikompilasi, seperti [Go](go-image.md#go-image-provided) dan [Rust](lambda-rust.md), dan untuk versi bahasa atau bahasa yang Lambda tidak menyediakan gambar dasar, seperti Node.js 19. Anda juga dapat menggunakan gambar dasar khusus OS untuk mengimplementasikan runtime [kustom](runtimes-custom.md). Untuk membuat gambar kompatibel dengan Lambda, Anda harus menyertakan [klien antarmuka runtime untuk Ruby](#ruby-image-clients) dalam gambar.
+ [Menggunakan gambar AWS non-dasar](#ruby-image-clients)
Anda dapat menggunakan gambar dasar alternatif dari registri kontainer lain, seperti Alpine Linux atau Debian. Anda juga dapat menggunakan gambar kustom yang dibuat oleh organisasi Anda. Untuk membuat gambar kompatibel dengan Lambda, Anda harus menyertakan [klien antarmuka runtime untuk Ruby](#ruby-image-clients) dalam gambar.
**Tip**
Untuk mengurangi waktu yang dibutuhkan agar fungsi kontainer Lambda menjadi aktif, lihat [Menggunakan build multi-tahap](https://docs.docker.com/build/building/multi-stage/) dalam dokumentasi Docker. Untuk membuat gambar kontainer yang efisien, ikuti [Praktik terbaik untuk menulis Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Halaman ini menjelaskan cara membuat, menguji, dan menyebarkan gambar kontainer untuk Lambda.
**Topics**
+ [
## AWS gambar dasar untuk Ruby
](#ruby-image-base)
+ [
## Menggunakan gambar AWS dasar untuk Ruby
](#ruby-image-instructions)
+ [
## Menggunakan gambar dasar alternatif dengan klien antarmuka runtime
](#ruby-image-clients)
## AWS gambar dasar untuk Ruby
AWS menyediakan gambar dasar berikut untuk Ruby:
| Tanda | Waktu berjalan | Sistem operasi | Dockerfile | penghentian |
| --- | --- | --- | --- | --- |
| 3.4 | Ruby 3.4 | Amazon Linux 2023 | [Dockerfile untuk Ruby 3.4 di GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.4/Dockerfile.ruby3.4) | 31 Mar 2028 |
| 3.3 | Ruby 3.3 | Amazon Linux 2023 | [Dockerfile untuk Ruby 3.3 di GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.3/Dockerfile.ruby3.3) | 31 Mar 2027 |
| 3.2 | Ruby 3.2 | Amazon Linux 2 | [Dockerfile untuk Ruby 3.2 di GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.2/Dockerfile.ruby3.2) | 31 Mar 2026 |
[Repositori Amazon ECR: gallery.ecr. aws/lambda/ruby](https://gallery.ecr.aws/lambda/ruby)
## Menggunakan gambar AWS dasar untuk Ruby
### Prasyarat
Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki hal-hal berikut:
+ [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versi minimum 25.0.0)
+ Plugin [buildx Docker](https://github.com/docker/buildx/blob/master/README.md).
+ Ruby
### Membuat gambar dari gambar dasar
**Untuk membuat gambar kontainer untuk Ruby**
1. Buat direktori untuk proyek, dan kemudian beralih ke direktori itu.
```
mkdir example
cd example
```
1. Buat file baru bernama`Gemfile`. Di sinilah Anda mencantumkan RubyGems paket yang diperlukan aplikasi Anda. AWS SDK untuk Ruby Tersedia dari RubyGems. Anda harus memilih permata AWS layanan tertentu untuk dipasang. Misalnya, untuk menggunakan [permata Ruby untuk Lambda](https://rubygems.org/gems/aws-sdk-lambda/), Gemfile Anda akan terlihat seperti ini:
```
source 'https://rubygems.org'
gem 'aws-sdk-lambda'
```
Atau, permata [aws-sdk](https://rubygems.org/gems/aws-sdk/) berisi setiap permata layanan yang tersedia. AWS Permata ini sangat besar. Kami menyarankan Anda menggunakannya hanya jika Anda bergantung pada banyak AWS layanan.
1. [Instal dependensi yang ditentukan dalam Gemfile menggunakan bundle install.](https://bundler.io/v2.4/man/bundle-install.1.html)
```
bundle install
```
1. Buat file baru bernama`lambda_function.rb`. Anda dapat menambahkan kode fungsi contoh berikut ke file untuk pengujian, atau menggunakan kode Anda sendiri.
**Example Fungsi Ruby**
```
module LambdaFunction
class Handler
def self.process(event:,context:)
"Hello from Lambda!"
end
end
end
```
1. Buat Dockerfile baru. Berikut ini adalah contoh Dockerfile yang menggunakan gambar [AWS dasar](images-create.md#runtimes-images-lp). Dockerfiles ini menggunakan konfigurasi berikut:
+ Atur properti `FROM` untuk URI dari gambar dasar.
+ Gunakan perintah COPY untuk menyalin kode fungsi dan dependensi runtime ke`{LAMBDA_TASK_ROOT}`, variabel lingkungan yang ditentukan [Lambda](configuration-envvars.md#configuration-envvars-runtime).
+ Atur `CMD` argumen ke penangan fungsi Lambda.
Perhatikan bahwa contoh Dockerfile tidak menyertakan instruksi [USER](https://docs.docker.com/reference/dockerfile/#user). Saat Anda menyebarkan gambar kontainer ke Lambda, Lambda secara otomatis mendefinisikan pengguna Linux default dengan izin yang paling tidak memiliki hak istimewa. Ini berbeda dari perilaku Docker standar yang default ke `root` pengguna ketika tidak ada `USER` instruksi yang diberikan.
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/ruby:3.4
# Copy Gemfile and Gemfile.lock
COPY Gemfile Gemfile.lock ${LAMBDA_TASK_ROOT}/
# Install Bundler and the specified gems
RUN gem install bundler:2.4.20 && \
bundle config set --local path 'vendor/bundle' && \
bundle install
# Copy function code
COPY lambda_function.rb ${LAMBDA_TASK_ROOT}/
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.LambdaFunction::Handler.process" ]
```
1. Buat image Docker dengan perintah [docker](https://docs.docker.com/engine/reference/commandline/build/) build. Contoh berikut menamai gambar `docker-image` dan memberinya `test` [tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Untuk membuat gambar Anda kompatibel dengan Lambda, Anda harus menggunakan opsi. `--provenance=false`
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**catatan**
Perintah menentukan `--platform linux/amd64` opsi untuk memastikan bahwa container Anda kompatibel dengan lingkungan eksekusi Lambda terlepas dari arsitektur mesin build Anda. Jika Anda berniat untuk membuat fungsi Lambda menggunakan arsitektur set ARM64 instruksi, pastikan untuk mengubah perintah untuk menggunakan `--platform linux/arm64` opsi sebagai gantinya.
### (Opsional) Uji gambar secara lokal
1. Mulai gambar Docker dengan perintah **docker run**. Dalam contoh ini, `docker-image` adalah nama gambar dan `test` tag.
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
Perintah ini menjalankan gambar sebagai wadah dan membuat titik akhir lokal di`localhost:9000/2015-03-31/functions/function/invocations`.
**catatan**
Jika Anda membuat image Docker untuk arsitektur set ARM64 instruksi, pastikan untuk menggunakan `--platform linux/arm64` opsi alih-alih. `--platform linux/amd64`
1. Dari jendela terminal baru, posting acara ke titik akhir lokal.
------
#### [ Linux/macOS ]
Di Linux dan macOS, jalankan perintah berikut: `curl`
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Perintah ini memanggil fungsi dengan peristiwa kosong dan mengembalikan respons. Jika Anda menggunakan kode fungsi Anda sendiri daripada kode fungsi sampel, Anda mungkin ingin memanggil fungsi dengan payload JSON. Contoh:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
Dalam PowerShell, jalankan `Invoke-WebRequest` perintah berikut:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Perintah ini memanggil fungsi dengan peristiwa kosong dan mengembalikan respons. Jika Anda menggunakan kode fungsi Anda sendiri daripada kode fungsi sampel, Anda mungkin ingin memanggil fungsi dengan payload JSON. Contoh:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Dapatkan ID kontainer.
```
docker ps
```
1. Gunakan perintah [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) untuk menghentikan kontainer. Dalam perintah ini, ganti `3766c4ab331c` dengan ID kontainer dari langkah sebelumnya.
```
docker kill 3766c4ab331c
```
### Menyebarkan gambar
**Untuk mengunggah gambar ke Amazon ECR dan membuat fungsi Lambda**
1. Jalankan [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)perintah untuk mengautentikasi CLI Docker ke registri Amazon ECR Anda.
+ Tetapkan `--region` nilai ke Wilayah AWS tempat Anda ingin membuat repositori Amazon ECR.
+ Ganti `111122223333` dengan Akun AWS ID Anda.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. [Buat repositori di Amazon ECR menggunakan perintah create-repository.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html)
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**catatan**
Repositori Amazon ECR harus sama Wilayah AWS dengan fungsi Lambda.
Jika berhasil, Anda melihat respons seperti ini:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Salin `repositoryUri` dari output pada langkah sebelumnya.
1. Jalankan perintah [tag docker](https://docs.docker.com/engine/reference/commandline/tag/) untuk menandai gambar lokal Anda ke repositori Amazon ECR Anda sebagai versi terbaru. Dalam perintah ini:
+ `docker-image:test`adalah nama dan [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) gambar Docker Anda. Ini adalah nama gambar dan tag yang Anda tentukan dalam `docker build` perintah.
+ Ganti `` dengan `repositoryUri` yang Anda salin. Pastikan untuk menyertakan `:latest` di akhir URI.
```
docker tag docker-image:test :latest
```
Contoh:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Jalankan perintah [docker push](https://docs.docker.com/engine/reference/commandline/push/) untuk menyebarkan gambar lokal Anda ke repositori Amazon ECR. Pastikan untuk menyertakan `:latest` di akhir URI repositori.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Buat peran eksekusi](lambda-intro-execution-role.md#permissions-executionrole-api) untuk fungsi tersebut, jika Anda belum memilikinya. Anda memerlukan Nama Sumber Daya Amazon (ARN) dari peran tersebut di langkah berikutnya.
1. Buat fungsi Lambda. Untuk`ImageUri`, tentukan URI repositori dari sebelumnya. Pastikan untuk menyertakan `:latest` di akhir URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**catatan**
Anda dapat membuat fungsi menggunakan gambar di AWS akun yang berbeda, selama gambar berada di Wilayah yang sama dengan fungsi Lambda. Untuk informasi selengkapnya, lihat [Izin lintas akun Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Memanggil fungsi.
```
aws lambda invoke --function-name hello-world response.json
```
Anda akan melihat tanggapan seperti ini:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Untuk melihat output dari fungsi, periksa `response.json` file.
Untuk memperbarui kode fungsi, Anda harus membangun gambar lagi, mengunggah gambar baru ke repositori Amazon ECR, dan kemudian menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah untuk menyebarkan gambar ke fungsi Lambda.
Lambda menyelesaikan tag gambar ke intisari gambar tertentu. Ini berarti bahwa jika Anda mengarahkan tag gambar yang digunakan untuk menyebarkan fungsi ke gambar baru di Amazon ECR, Lambda tidak secara otomatis memperbarui fungsi untuk menggunakan gambar baru.
Untuk menyebarkan gambar baru ke fungsi Lambda yang sama, Anda harus menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah, meskipun tag gambar di Amazon ECR tetap sama. Dalam contoh berikut, `--publish` opsi membuat versi baru dari fungsi menggunakan gambar kontainer yang diperbarui.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Menggunakan gambar dasar alternatif dengan klien antarmuka runtime
Jika Anda menggunakan gambar [dasar khusus OS atau gambar dasar](images-create.md#runtimes-images-provided) alternatif, Anda harus menyertakan klien antarmuka runtime dalam gambar Anda. Klien antarmuka runtime memperluas[API runtime](runtimes-api.md), yang mengelola interaksi antara Lambda dan kode fungsi Anda.
Instal [klien antarmuka runtime Lambda untuk Ruby](https://rubygems.org/gems/aws_lambda_ric) menggunakan pengelola paket.org: RubyGems
```
gem install aws_lambda_ric
```
Anda juga dapat mengunduh [klien antarmuka runtime Ruby](https://github.com/aws/aws-lambda-ruby-runtime-interface-client) dari. GitHub
Contoh berikut menunjukkan bagaimana membangun image container untuk Ruby menggunakan gambar AWS non-dasar. Contoh Dockerfile menggunakan gambar dasar Ruby resmi. Dockerfile menyertakan klien antarmuka runtime.
### Prasyarat
Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki hal-hal berikut:
+ [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versi minimum 25.0.0)
+ Plugin [buildx Docker](https://github.com/docker/buildx/blob/master/README.md).
+ Ruby
### Membuat gambar dari gambar dasar alternatif
**Untuk membuat gambar kontainer untuk Ruby menggunakan gambar dasar alternatif**
1. Buat direktori untuk proyek, dan kemudian beralih ke direktori itu.
```
mkdir example
cd example
```
1. Buat file baru bernama`Gemfile`. Di sinilah Anda mencantumkan RubyGems paket yang diperlukan aplikasi Anda. AWS SDK untuk Ruby Tersedia dari RubyGems. Anda harus memilih permata AWS layanan tertentu untuk dipasang. Misalnya, untuk menggunakan [permata Ruby untuk Lambda](https://rubygems.org/gems/aws-sdk-lambda/), Gemfile Anda akan terlihat seperti ini:
```
source 'https://rubygems.org'
gem 'aws-sdk-lambda'
```
Atau, permata [aws-sdk](https://rubygems.org/gems/aws-sdk/) berisi setiap permata layanan yang tersedia. AWS Permata ini sangat besar. Kami menyarankan Anda menggunakannya hanya jika Anda bergantung pada banyak AWS layanan.
1. [Instal dependensi yang ditentukan dalam Gemfile menggunakan bundle install.](https://bundler.io/v2.4/man/bundle-install.1.html)
```
bundle install
```
1. Buat file baru bernama`lambda_function.rb`. Anda dapat menambahkan kode fungsi contoh berikut ke file untuk pengujian, atau menggunakan kode Anda sendiri.
**Example Fungsi Ruby**
```
module LambdaFunction
class Handler
def self.process(event:,context:)
"Hello from Lambda!"
end
end
end
```
1. Buat Dockerfile baru. [Dockerfile berikut menggunakan gambar dasar Ruby alih-alih gambar dasar.AWS](images-create.md#runtimes-images-lp) Dockerfile menyertakan [klien antarmuka runtime untuk Ruby](https://github.com/aws/aws-lambda-ruby-runtime-interface-client), yang membuat gambar kompatibel dengan Lambda. Atau, Anda dapat menambahkan klien antarmuka runtime ke Gemfile aplikasi Anda.
+ Atur `FROM` properti ke gambar dasar Ruby.
+ Buat direktori untuk kode fungsi dan variabel lingkungan yang menunjuk ke direktori itu. Dalam contoh ini, direktorinya adalah`/var/task`, yang mencerminkan lingkungan eksekusi Lambda. Namun, Anda dapat memilih direktori apa pun untuk kode fungsi karena Dockerfile tidak menggunakan gambar AWS dasar.
+ Atur `ENTRYPOINT` ke modul yang Anda inginkan untuk menjalankan wadah Docker saat dimulai. Dalam hal ini, modul adalah klien antarmuka runtime.
+ Atur `CMD` argumen ke penangan fungsi Lambda.
Perhatikan bahwa contoh Dockerfile tidak menyertakan instruksi [USER](https://docs.docker.com/reference/dockerfile/#user). Saat Anda menyebarkan gambar kontainer ke Lambda, Lambda secara otomatis mendefinisikan pengguna Linux default dengan izin yang paling tidak memiliki hak istimewa. Ini berbeda dari perilaku Docker standar yang default ke `root` pengguna ketika tidak ada `USER` instruksi yang diberikan.
**Example Dockerfile**
```
FROM ruby:2.7
# Install the runtime interface client for Ruby
RUN gem install aws_lambda_ric
# Add the runtime interface client to the PATH
ENV PATH="/usr/local/bundle/bin:${PATH}"
# Create a directory for the Lambda function
ENV LAMBDA_TASK_ROOT=/var/task
RUN mkdir -p ${LAMBDA_TASK_ROOT}
WORKDIR ${LAMBDA_TASK_ROOT}
# Copy Gemfile and Gemfile.lock
COPY Gemfile Gemfile.lock ${LAMBDA_TASK_ROOT}/
# Install Bundler and the specified gems
RUN gem install bundler:2.4.20 && \
bundle config set --local path 'vendor/bundle' && \
bundle install
# Copy function code
COPY lambda_function.rb ${LAMBDA_TASK_ROOT}/
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "aws_lambda_ric" ]
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.LambdaFunction::Handler.process" ]
```
1. Buat image Docker dengan perintah [docker](https://docs.docker.com/engine/reference/commandline/build/) build. Contoh berikut menamai gambar `docker-image` dan memberinya `test` [tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Untuk membuat gambar Anda kompatibel dengan Lambda, Anda harus menggunakan opsi. `--provenance=false`
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**catatan**
Perintah menentukan `--platform linux/amd64` opsi untuk memastikan bahwa container Anda kompatibel dengan lingkungan eksekusi Lambda terlepas dari arsitektur mesin build Anda. Jika Anda berniat untuk membuat fungsi Lambda menggunakan arsitektur set ARM64 instruksi, pastikan untuk mengubah perintah untuk menggunakan `--platform linux/arm64` opsi sebagai gantinya.
### (Opsional) Uji gambar secara lokal
Gunakan [emulator antarmuka runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/) untuk menguji gambar secara lokal. Anda dapat [membangun emulator ke dalam gambar Anda](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) atau menggunakan prosedur berikut untuk menginstalnya di mesin lokal Anda.
**Untuk menginstal dan menjalankan emulator antarmuka runtime di mesin lokal Anda**
1. Dari direktori proyek Anda, jalankan perintah berikut untuk mengunduh emulator antarmuka runtime (arsitektur x86-64) dari GitHub dan menginstalnya di mesin lokal Anda.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Untuk menginstal emulator arm64, ganti URL GitHub repositori di perintah sebelumnya dengan yang berikut:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Untuk menginstal emulator arm64, ganti `$downloadLink` dengan yang berikut ini:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Mulai gambar Docker dengan perintah **docker run**. Perhatikan hal-hal berikut:
+ `docker-image`adalah nama gambar dan `test` tag.
+ `aws_lambda_ric lambda_function.LambdaFunction::Handler.process`adalah `ENTRYPOINT` diikuti oleh `CMD` dari Dockerfile Anda.
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
docker-image:test \
aws_lambda_ric lambda_function.LambdaFunction::Handler.process
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
aws_lambda_ric lambda_function.LambdaFunction::Handler.process
```
------
Perintah ini menjalankan gambar sebagai wadah dan membuat titik akhir lokal di`localhost:9000/2015-03-31/functions/function/invocations`.
**catatan**
Jika Anda membuat image Docker untuk arsitektur set ARM64 instruksi, pastikan untuk menggunakan `--platform linux/arm64` opsi alih-alih. `--platform linux/amd64`
1. Posting acara ke titik akhir lokal.
------
#### [ Linux/macOS ]
Di Linux dan macOS, jalankan perintah berikut: `curl`
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Perintah ini memanggil fungsi dengan peristiwa kosong dan mengembalikan respons. Jika Anda menggunakan kode fungsi Anda sendiri daripada kode fungsi sampel, Anda mungkin ingin memanggil fungsi dengan payload JSON. Contoh:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
Dalam PowerShell, jalankan `Invoke-WebRequest` perintah berikut:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Perintah ini memanggil fungsi dengan peristiwa kosong dan mengembalikan respons. Jika Anda menggunakan kode fungsi Anda sendiri daripada kode fungsi sampel, Anda mungkin ingin memanggil fungsi dengan payload JSON. Contoh:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Dapatkan ID kontainer.
```
docker ps
```
1. Gunakan perintah [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) untuk menghentikan kontainer. Dalam perintah ini, ganti `3766c4ab331c` dengan ID kontainer dari langkah sebelumnya.
```
docker kill 3766c4ab331c
```
### Menyebarkan gambar
**Untuk mengunggah gambar ke Amazon ECR dan membuat fungsi Lambda**
1. Jalankan [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)perintah untuk mengautentikasi CLI Docker ke registri Amazon ECR Anda.
+ Tetapkan `--region` nilai ke Wilayah AWS tempat Anda ingin membuat repositori Amazon ECR.
+ Ganti `111122223333` dengan Akun AWS ID Anda.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. [Buat repositori di Amazon ECR menggunakan perintah create-repository.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html)
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**catatan**
Repositori Amazon ECR harus sama Wilayah AWS dengan fungsi Lambda.
Jika berhasil, Anda melihat respons seperti ini:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Salin `repositoryUri` dari output pada langkah sebelumnya.
1. Jalankan perintah [tag docker](https://docs.docker.com/engine/reference/commandline/tag/) untuk menandai gambar lokal Anda ke repositori Amazon ECR Anda sebagai versi terbaru. Dalam perintah ini:
+ `docker-image:test`adalah nama dan [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) gambar Docker Anda. Ini adalah nama gambar dan tag yang Anda tentukan dalam `docker build` perintah.
+ Ganti `` dengan `repositoryUri` yang Anda salin. Pastikan untuk menyertakan `:latest` di akhir URI.
```
docker tag docker-image:test :latest
```
Contoh:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Jalankan perintah [docker push](https://docs.docker.com/engine/reference/commandline/push/) untuk menyebarkan gambar lokal Anda ke repositori Amazon ECR. Pastikan untuk menyertakan `:latest` di akhir URI repositori.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Buat peran eksekusi](lambda-intro-execution-role.md#permissions-executionrole-api) untuk fungsi tersebut, jika Anda belum memilikinya. Anda memerlukan Nama Sumber Daya Amazon (ARN) dari peran tersebut di langkah berikutnya.
1. Buat fungsi Lambda. Untuk`ImageUri`, tentukan URI repositori dari sebelumnya. Pastikan untuk menyertakan `:latest` di akhir URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**catatan**
Anda dapat membuat fungsi menggunakan gambar di AWS akun yang berbeda, selama gambar berada di Wilayah yang sama dengan fungsi Lambda. Untuk informasi selengkapnya, lihat [Izin lintas akun Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Memanggil fungsi.
```
aws lambda invoke --function-name hello-world response.json
```
Anda akan melihat tanggapan seperti ini:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Untuk melihat output dari fungsi, periksa `response.json` file.
Untuk memperbarui kode fungsi, Anda harus membangun gambar lagi, mengunggah gambar baru ke repositori Amazon ECR, dan kemudian menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah untuk menyebarkan gambar ke fungsi Lambda.
Lambda menyelesaikan tag gambar ke intisari gambar tertentu. Ini berarti bahwa jika Anda mengarahkan tag gambar yang digunakan untuk menyebarkan fungsi ke gambar baru di Amazon ECR, Lambda tidak secara otomatis memperbarui fungsi untuk menggunakan gambar baru.
Untuk menyebarkan gambar baru ke fungsi Lambda yang sama, Anda harus menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah, meskipun tag gambar di Amazon ECR tetap sama. Dalam contoh berikut, `--publish` opsi membuat versi baru dari fungsi menggunakan gambar kontainer yang diperbarui.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
# Bekerja dengan lapisan untuk fungsi Ruby Lambda
Gunakan [lapisan Lambda](chapter-layers.md) untuk mengemas kode dan dependensi yang ingin Anda gunakan kembali di beberapa fungsi. Lapisan biasanya berisi dependensi pustaka, [runtime kustom](runtimes-custom.md), atau file konfigurasi. Membuat layer melibatkan tiga langkah umum:
1. Package konten layer Anda. Ini berarti membuat arsip file.zip yang berisi dependensi yang ingin Anda gunakan dalam fungsi Anda.
1. Buat layer di Lambda.
1. Tambahkan layer ke fungsi Anda.
**Topics**
+ [
## Package konten layer Anda
](#ruby-layers-package)
+ [
## Buat layer di Lambda
](#publishing-layer)
+ [
## Menggunakan permata dari lapisan dalam suatu fungsi
](#ruby-layers-bundler-limitations)
+ [
## Tambahkan layer ke fungsi Anda
](#ruby-layer-adding)
+ [
## Contoh aplikasi
](#ruby-layer-sample-app)
## Package konten layer Anda
Untuk membuat layer, bundel paket Anda ke dalam arsip file.zip yang memenuhi persyaratan berikut:
+ Buat layer menggunakan versi Ruby yang sama yang Anda rencanakan untuk digunakan untuk fungsi Lambda. Misalnya, jika Anda membuat layer untuk Ruby 3.4, gunakan runtime Ruby 3.4 untuk fungsi Anda.
+ File.zip layer Anda harus menggunakan salah satu struktur direktori ini:
+ `ruby/gems/x.x.x`(di *x.x.x* mana versi Ruby Anda, misalnya`3.4.0`)
+ `ruby/lib`
Untuk informasi selengkapnya, lihat [Jalur lapisan untuk setiap runtime Lambda](packaging-layers.md#packaging-layers-paths).
+ Paket di lapisan Anda harus kompatibel dengan Linux. Fungsi Lambda berjalan di Amazon Linux.
Anda dapat membuat layer yang berisi permata Ruby pihak ketiga atau modul dan kelas Ruby Anda sendiri. Banyak permata Ruby populer berisi ekstensi asli (kode C) yang harus dikompilasi untuk lingkungan Linux Lambda.
### Permata Ruby murni
Permata Ruby murni hanya berisi kode Ruby dan tidak memerlukan kompilasi. Permata ini lebih mudah untuk dikemas dan bekerja di berbagai platform.
**Untuk membuat layer menggunakan permata Ruby murni**
1. Buat a `Gemfile` untuk menentukan permata Ruby murni yang ingin Anda sertakan dalam layer Anda:
**Example Gemfile**
```
source 'https://rubygems.org'
gem 'tzinfo'
```
1. Instal permata ke `vendor/bundle` direktori menggunakan Bundler:
```
bundle config set --local path vendor/bundle
bundle install
```
1. Salin permata yang diinstal ke struktur direktori yang dibutuhkan `ruby/gems/3.4.0` Lambda):
```
mkdir -p ruby/gems/3.4.0
cp -r vendor/bundle/ruby/3.4.0*/* ruby/gems/3.4.0/
```
1. Zip konten lapisan:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
Struktur direktori file.zip Anda akan terlihat seperti ini:
```
ruby/
└── gems/
└── 3.4.0/
├── gems/
│ ├── concurrent-ruby-1.3.5/
│ └── tzinfo-2.0.6/
├── specifications/
├── cache/
├── build_info/
└── (other bundler directories)
```
**catatan**
Anda harus meminta setiap permata satu per satu dalam kode fungsi Anda. Anda tidak dapat menggunakan `bundler/setup` atau`Bundler.require`. Untuk informasi selengkapnya, lihat [Menggunakan permata dari lapisan dalam suatu fungsi](#ruby-layers-bundler-limitations).
### Permata dengan ekstensi asli
Banyak permata Ruby populer berisi ekstensi asli (kode C) yang harus dikompilasi untuk platform target. [https://rubygems.org/gems/sqlite3/](https://rubygems.org/gems/sqlite3/) Permata ini harus dibangun di lingkungan Linux yang kompatibel dengan runtime Lambda.
**Untuk membuat layer menggunakan permata dengan ekstensi asli**
1. Buat a`Gemfile`.
**Example Gemfile**
```
source 'https://rubygems.org'
gem 'nokogiri'
gem 'httparty'
```
1. Gunakan Docker untuk membangun permata di lingkungan Linux yang kompatibel dengan Lambda. Tentukan [gambar AWS dasar](ruby-image.md#ruby-image-base) di Dockerfile Anda:
**Example Dockerfile untuk Ruby 3.4**
```
FROM public.ecr.aws/lambda/ruby:3.4
# Copy Gemfile
COPY Gemfile ./
# Install system dependencies for native extensions
RUN dnf update -y && \
dnf install -y gcc gcc-c++ make
# Configure bundler and install gems
RUN bundle config set --local path vendor/bundle && \
bundle install
# Create the layer structure
RUN mkdir -p ruby/gems/3.4.0 && \
cp -r vendor/bundle/ruby/3.4.0*/* ruby/gems/3.4.0/
# Create the layer zip file
RUN zip -r layer.zip ruby/
```
1. Bangun gambar dan ekstrak layer:
```
docker build -t ruby-layer-builder .
docker run --rm -v $(pwd):/output --entrypoint cp ruby-layer-builder layer.zip /output/
```
Ini membangun permata di lingkungan Linux yang benar dan menyalin `layer.zip` file ke direktori lokal Anda. Struktur direktori file.zip Anda akan terlihat seperti ini:
```
ruby/
└── gems/
└── 3.4.0/
├── gems/
│ ├── bigdecimal-3.2.2/
│ ├── csv-3.3.5/
│ ├── httparty-0.23.1/
│ ├── mini_mime-1.1.5/
│ ├── multi_xml-0.7.2/
│ ├── nokogiri-1.18.8-x86_64-linux-gnu/
│ └── racc-1.8.1/
├── build_info/
├── cache/
├── specifications/
└── (other bundler directories)
```
**catatan**
Anda harus meminta setiap permata satu per satu dalam kode fungsi Anda. Anda tidak dapat menggunakan `bundler/setup` atau`Bundler.require`. Untuk informasi selengkapnya, lihat [Menggunakan permata dari lapisan dalam suatu fungsi](#ruby-layers-bundler-limitations).
### Modul Ruby kustom
**Untuk membuat layer menggunakan kode Anda sendiri**
1. Buat struktur direktori yang diperlukan untuk layer Anda:
```
mkdir -p ruby/lib
```
1. Buat modul Ruby Anda di `ruby/lib` direktori. Modul contoh berikut memvalidasi pesanan dengan mengonfirmasi bahwa mereka berisi informasi yang diperlukan.
**Example ruby/lib/order\$1validator.rb**
```
require 'json'
module OrderValidator
class ValidationError < StandardError; end
def self.validate_order(order_data)
# Validates an order and returns formatted data
required_fields = %w[product_id quantity]
# Check required fields
missing_fields = required_fields.reject { |field| order_data.key?(field) }
unless missing_fields.empty?
raise ValidationError, "Missing required fields: #{missing_fields.join(', ')}"
end
# Validate quantity
quantity = order_data['quantity']
unless quantity.is_a?(Integer) && quantity > 0
raise ValidationError, 'Quantity must be a positive integer'
end
# Format and return the validated data
{
'product_id' => order_data['product_id'].to_s,
'quantity' => quantity,
'shipping_priority' => order_data.fetch('priority', 'standard')
}
end
def self.format_response(status_code, body)
# Formats the API response
{
statusCode: status_code,
body: JSON.generate(body)
}
end
end
```
1. Zip konten lapisan:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
Struktur direktori file.zip Anda akan terlihat seperti ini:
```
ruby/
└── lib/
└── order_validator.rb
```
1. Dalam fungsi Anda, membutuhkan dan menggunakan modul. Anda harus meminta setiap permata satu per satu dalam kode fungsi Anda. Anda tidak dapat menggunakan `bundler/setup` atau`Bundler.require`. Untuk informasi selengkapnya, lihat [Menggunakan permata dari lapisan dalam suatu fungsi](#ruby-layers-bundler-limitations). Contoh:
```
require 'json'
require 'order_validator'
def lambda_handler(event:, context:)
begin
# Parse the order data from the event body
order_data = JSON.parse(event['body'] || '{}')
# Validate and format the order
validated_order = OrderValidator.validate_order(order_data)
OrderValidator.format_response(200, {
message: 'Order validated successfully',
order: validated_order
})
rescue OrderValidator::ValidationError => e
OrderValidator.format_response(400, {
error: e.message
})
rescue => e
OrderValidator.format_response(500, {
error: 'Internal server error'
})
end
end
```
Anda dapat menggunakan [peristiwa pengujian](testing-functions.md#invoke-with-event) berikut untuk menjalankan fungsi:
```
{
"body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
}
```
Tanggapan yang diharapkan:
```
{
"statusCode": 200,
"body": "{\"message\":\"Order validated successfully\",\"order\":{\"product_id\":\"ABC123\",\"quantity\":2,\"shipping_priority\":\"express\"}}"
}
```
## Buat layer di Lambda
Anda dapat mempublikasikan layer Anda menggunakan konsol AWS CLI atau Lambda.
------
#### [ AWS CLI ]
Jalankan [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) AWS CLI perintah untuk membuat layer Lambda:
```
aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes ruby3.4
```
Parameter [runtime yang kompatibel](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) adalah opsional. Saat ditentukan, Lambda menggunakan parameter ini untuk memfilter lapisan di konsol Lambda.
------
#### [ Console ]
**Untuk membuat lapisan (konsol)**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/layers) di konsol Lambda.
1. Pilih **Buat lapisan**.
1. Pilih **Unggah file.zip**, lalu unggah arsip.zip yang Anda buat sebelumnya.
1. (Opsional) Untuk **runtime yang kompatibel**, pilih runtime Ruby yang sesuai dengan versi Ruby yang Anda gunakan untuk membangun layer Anda.
1. Pilih **Buat**.
------
## Menggunakan permata dari lapisan dalam suatu fungsi
Dalam kode fungsi Anda, Anda harus secara eksplisit meminta setiap permata yang ingin Anda gunakan. Perintah bundler seperti `bundler/setup` dan `Bundler.require` tidak didukung. Berikut cara menggunakan permata dengan benar dari lapisan dalam fungsi Lambda:
```
# Correct: Use explicit requires for each gem
require 'nokogiri'
require 'httparty'
def lambda_handler(event:, context:)
# Use the gems directly
doc = Nokogiri::HTML(event['html'])
response = HTTParty.get(event['url'])
# ... rest of your function
end
# Incorrect: These Bundler commands will not work
# require 'bundler/setup'
# Bundler.require
```
## Tambahkan layer ke fungsi Anda
------
#### [ AWS CLI ]
Untuk melampirkan layer ke fungsi Anda, jalankan [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) AWS CLI perintah. Untuk `--layers` parameter, gunakan lapisan ARN. ARN harus menentukan versi (misalnya,`arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`). Untuk informasi selengkapnya, lihat [Versi lapisan dan lapisan](chapter-layers.md#lambda-layer-versions).
```
aws lambda update-function-configuration --function-name my-function --cli-binary-format raw-in-base64-out --layers "arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1"
```
**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*.
------
#### [ Console ]
**Untuk menambahkan lapisan ke fungsi**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih fungsinya.
1. Gulir ke bawah ke bagian **Layers**, lalu pilih **Add a layer**.
1. Di bawah **Pilih layer**, pilih **Custom layers**, dan kemudian pilih layer Anda.
**catatan**
Jika Anda tidak menambahkan [runtime yang kompatibel](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) saat membuat layer, layer Anda tidak akan tercantum di sini. Anda dapat menentukan lapisan ARN sebagai gantinya.
1. Pilih **Tambahkan**.
------
## Contoh aplikasi
Untuk contoh lebih lanjut tentang cara menggunakan layer Lambda, lihat contoh aplikasi [layer-ruby](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-ruby) di repositori Panduan Pengembang. AWS Lambda GitHub Aplikasi ini mencakup lapisan yang berisi pustaka [tzinfo](https://rubygems.org/gems/tzinfo). Setelah membuat layer, Anda dapat menerapkan dan memanggil fungsi yang sesuai untuk mengonfirmasi bahwa lapisan berfungsi seperti yang diharapkan.
# Menggunakan objek konteks Lambda untuk mengambil informasi fungsi Ruby
Saat Lambda menjalankan fungsi Anda, ia meneruskan objek konteks ke [handler](ruby-handler.md). Objek ini menyediakan metode dan properti yang memberikan informasi tentang lingkungan invokasi, fungsi, dan eksekusi.
**Metode konteks**
+ `get_remaining_time_in_millis` – Mengembalikan jumlah milidetik yang tersisa sebelum waktu eksekusi habis.
**Properti konteks**
+ `function_name` – Nama fungsi Lambda.
+ `function_version` – [Versi](configuration-versions.md) fungsi.
+ `invoked_function_arn` – Amazon Resource Name (ARN) yang digunakan untuk memicu fungsi. Menunjukkan jika pemicu menyebutkan nomor versi atau alias.
+ `memory_limit_in_mb` – Jumlah memori yang dialokasikan untuk fungsi tersebut.
+ `aws_request_id` – Pengidentifikasi permintaan invokasi.
+ `log_group_name` – Grup log untuk fungsi.
+ `log_stream_name` – Aliran log untuk instans fungsi.
+ `deadline_ms`– Tanggal saat eksekusi berakhir, dalam milidetik waktu Unix.
+ `identity` – (aplikasi seluler) Informasi tentang identitas Amazon Cognito yang mengesahkan permintaan.
+ `client_context`– (aplikasi seluler) Konteks klien yang disediakan untuk Lambda oleh aplikasi klien.
# Log dan pantau fungsi Ruby Lambda
AWS Lambda secara otomatis memonitor fungsi Lambda atas nama Anda dan mengirim log ke Amazon. CloudWatch Fungsi Lambda Anda dilengkapi dengan grup CloudWatch log Log dan aliran log untuk setiap instance fungsi Anda. Lingkungan runtime Lambda mengirimkan detail tentang setiap invokasi ke pengaliran log, dan menyampaikan log serta output lain dari kode fungsi Anda. Untuk informasi selengkapnya, lihat [Mengirim log fungsi Lambda ke Log CloudWatch](monitoring-cloudwatchlogs.md).
Halaman ini menjelaskan cara menghasilkan keluaran log dari kode fungsi Lambda Anda, dan mengakses log menggunakan AWS Command Line Interface, konsol Lambda, atau konsol. CloudWatch
**Topics**
+ [
## Membuat fungsi yang mengembalikan log
](#ruby-logging-output)
+ [
## Melihat log di konsol Lambda
](#ruby-logging-console)
+ [
## Melihat log di CloudWatch konsol
](#ruby-logging-cwconsole)
+ [
## Melihat log menggunakan AWS Command Line Interface (AWS CLI)
](#ruby-logging-cli)
+ [
## Menghapus log
](#ruby-logging-delete)
+ [
## Bekerja dengan pustaka logger Ruby
](#ruby-logging-lib)
## Membuat fungsi yang mengembalikan log
Untuk menghasilkan log dari kode fungsi, Anda dapat menggunakan pernyataan `puts`, atau pustaka pencatatan apa pun yang menulis ke `stdout` atau `stderr`. Contoh berikut mencatat nilai variabel lingkungan dan objek peristiwa.
**Example lambda\$1function.rb**
```
# lambda_function.rb
def handler(event:, context:)
puts "## ENVIRONMENT VARIABLES"
puts ENV.to_a
puts "## EVENT"
puts event.to_a
end
```
**Example format log**
```
START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled: true
```
Waktu pengoperasian Ruby melakukan log baris `START`, `END`, dan `REPORT` untuk setiap invokasi. Baris laporan memberikan perincian berikut.
**Laporkan bidang data baris**
+ **RequestId** – ID permintaan unik untuk invokasi.
+ **Durasi** – Jumlah waktu yang digunakan oleh metode handler fungsi Anda gunakan untuk memproses peristiwa.
+ **Durasi yang Ditagih** – Jumlah waktu yang ditagihkan untuk invokasi.
+ **Ukuran Memori** – Jumlah memori yang dialokasikan untuk fungsi.
+ **Memori Maks yang Digunakan** – Jumlah memori yang digunakan oleh fungsi. Saat pemanggilan berbagi lingkungan eksekusi, Lambda melaporkan memori maksimum yang digunakan di semua pemanggilan. Perilaku ini dapat menghasilkan nilai yang dilaporkan lebih tinggi dari yang diharapkan.
+ **Durasi Init** – Untuk permintaan pertama yang dilayani, lama waktu yang diperlukan runtime untuk memuat fungsi dan menjalankan kode di luar metode handler.
+ **XRAY TraceId** — Untuk permintaan yang dilacak, ID [AWS X-Ray jejak](services-xray.md).
+ **SegmentId** – Untuk permintaan yang dilacak, ID segmen X-Ray.
+ **Diambil Sampel** – Untuk permintaan yang dilacak, hasil pengambilan sampel.
Untuk log yang lebih rinci, gunakan file[Bekerja dengan pustaka logger Ruby](#ruby-logging-lib).
## Melihat log di konsol Lambda
Anda dapat menggunakan konsol Lambda untuk melihat output log setelah Anda memanggil fungsi Lambda.
Jika kode Anda dapat diuji dari editor **Kode** tertanam, Anda akan menemukan log dalam **hasil eksekusi**. Saat Anda menggunakan fitur pengujian konsol untuk menjalankan fungsi, Anda akan menemukan **Keluaran Log** di bagian **Detail**.
## Melihat log di CloudWatch konsol
Anda dapat menggunakan CloudWatch konsol Amazon untuk melihat log untuk semua pemanggilan fungsi Lambda.
**Untuk melihat log di CloudWatch konsol**
1. Buka [halaman Grup log](https://console.aws.amazon.com/cloudwatch/home?#logs:) di CloudWatch konsol.
1. Pilih grup log untuk fungsi Anda (**/aws/lambda/ *your-function-name***).
1. Pilih pengaliran log.
Setiap aliran log sesuai dengan [instans fungsi Anda](lambda-runtime-environment.md). Aliran log muncul saat Anda memperbarui fungsi Lambda, dan saat instance tambahan dibuat untuk menangani pemanggilan bersamaan. Untuk menemukan log untuk pemanggilan tertentu, sebaiknya instrumentasi fungsi Anda dengan. AWS X-Ray X-Ray mencatat detail tentang permintaan dan pengaliran log di jejak.
## Melihat log menggunakan AWS Command Line Interface (AWS CLI)
AWS CLI Ini adalah alat sumber terbuka yang memungkinkan Anda berinteraksi dengan AWS layanan menggunakan perintah di shell baris perintah Anda. Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Anda dapat menggunakan [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) untuk mengambil log untuk invokasi menggunakan opsi perintah `--log-type`. Respons berisi bidang `LogResult` yang memuat hingga 4 KB log berkode base64 dari invokasi.
**Example mengambil ID log**
Contoh berikut menunjukkan cara mengambil *ID log* dari `LogResult` untuk fungsi bernama `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail
```
Anda akan melihat output berikut:
```
{
"StatusCode": 200,
"LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}
```
**Example mendekode log**
Pada prompt perintah yang sama, gunakan utilitas `base64` untuk mendekodekan log. Contoh berikut menunjukkan cara mengambil log berkode base64 untuk `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
**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 output berikut:
```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed Duration: 80 ms Memory Size: 128 MB Max Memory Used: 73 MB
```
Utilitas `base64` tersedia di Linux, macOS, dan [Ubuntu pada Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Pengguna macOS mungkin harus menggunakan `base64 -D`.
**Example Skrip get-logs.sh**
Pada prompt perintah yang sama, gunakan script berikut untuk mengunduh lima peristiwa log terakhir. Skrip menggunakan `sed` untuk menghapus kutipan dari file output, dan akan tidur selama 15 detik untuk memberikan waktu agar log tersedia. Output mencakup respons dari Lambda dan output dari perintah `get-log-events`.
Salin konten dari contoh kode berikut dan simpan dalam direktori proyek Lambda Anda sebagai `get-logs.sh`.
**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*.
```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```
**Example macOS dan Linux (khusus)**
Pada prompt perintah yang sama, pengguna macOS dan Linux mungkin perlu menjalankan perintah berikut untuk memastikan skrip dapat dijalankan.
```
chmod -R 755 get-logs.sh
```
**Example mengambil lima log acara terakhir**
Pada prompt perintah yang sama, gunakan skrip berikut untuk mendapatkan lima log acara terakhir.
```
./get-logs.sh
```
Anda akan melihat output berikut:
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```
## Menghapus log
Grup log tidak terhapus secara otomatis ketika Anda menghapus suatu fungsi. Untuk menghindari penyimpanan log secara tidak terbatas, hapus kelompok log, atau [lakukan konfigurasi periode penyimpanan](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention), yang setelahnya log akan dihapus secara otomatis.
## Bekerja dengan pustaka logger Ruby
[Pustaka logger](https://ruby-doc.org/stdlib-2.7.0/libdoc/logger/rdoc/index.html) Ruby mengembalikan log yang disederhanakan yang mudah dibaca. Gunakan utilitas logger untuk menampilkan informasi rinci, pesan, dan kode kesalahan yang terkait dengan fungsi Anda.
```
# lambda_function.rb
require 'logger'
def handler(event:, context:)
logger = Logger.new($stdout)
logger.info('## ENVIRONMENT VARIABLES')
logger.info(ENV.to_a)
logger.info('## EVENT')
logger.info(event)
event.to_a
end
```
Output dari `logger` mencakup tingkat log, stempel waktu, dan ID permintaan.
```
START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST
[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT VARIABLES
[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key': 'value'}
END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125
REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled: true
```
# Menginstrumentasi kode Ruby di AWS Lambda
Lambda terintegrasi dengan AWS X-Ray untuk memungkinkan Anda melacak, men-debug, dan mengoptimalkan aplikasi Lambda. Anda dapat menggunakan X-Ray untuk melacak permintaan karena ia melintasi sumber daya di aplikasi Anda, dari API frontend hingga penyimpanan dan database di backend. Hanya dengan menambahkan library X-Ray SDK ke konfigurasi build, Anda dapat merekam error dan latensi untuk panggilan apa pun yang dilakukan fungsi Anda ke layanan. AWS
Setelah mengonfigurasi penelusuran aktif, Anda dapat mengamati permintaan tertentu melalui aplikasi Anda. [Grafik layanan X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) menunjukkan informasi tentang aplikasi Anda dan semua komponennya. Contoh berikut menunjukkan aplikasi dengan dua fungsi. Fungsi utama memproses kejadian dan terkadang mengembalikan kesalahan. Fungsi kedua di bagian atas memproses kesalahan yang muncul di grup log pertama dan menggunakan AWS SDK untuk memanggil X-Ray, Amazon Simple Storage Service (Amazon S3), dan Amazon Logs. CloudWatch
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
Untuk mengaktifkan penelusuran aktif pada fungsi Lambda Anda dengan konsol, ikuti langkah-langkah berikut:
**Untuk mengaktifkan penelusuran aktif**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih fungsi.
1. Pilih **Konfigurasi** dan kemudian pilih **Alat Pemantauan dan operasi**.
1. Di bawah **Alat pemantauan tambahan**, pilih **Edit**.
1. Di bawah **Sinyal CloudWatch Aplikasi dan AWS X-Ray**, pilih **Aktifkan** untuk **jejak layanan Lambda**.
1. Pilih **Simpan**.
**Harga**
Anda dapat menggunakan penelusuran X-Ray secara gratis setiap bulan hingga batas tertentu sebagai bagian dari Tingkat AWS Gratis. Di luar ambang batas itu, X-Ray mengenakan biaya untuk penyimpanan dan pengambilan jejak. Untuk informasi selengkapnya, lihat [harga AWS X-Ray](https://aws.amazon.com/xray/pricing/).
Fungsi Anda memerlukan izin untuk mengunggah data jejak ke X-Ray. [Saat Anda mengaktifkan penelusuran di konsol Lambda, Lambda menambahkan izin yang diperlukan ke peran eksekusi fungsi Anda.](lambda-intro-execution-role.md) Atau, tambahkan kebijakan [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess) ke peran eksekusi.
X-Ray tidak melacak semua permintaan ke aplikasi Anda. X-Ray menerapkan algoritma pengambilan sampel untuk memastikan bahwa penelusuran efisien, sambil tetap memberikan sampel yang representatif dari semua permintaan. Tingkat pengambilan sampel adalah 1 permintaan per detik dan 5 persen dari permintaan tambahan. Anda tidak dapat mengonfigurasi laju pengambilan sampel X-Ray untuk fungsi Anda.
Di X-Ray, *jejak* merekam informasi tentang permintaan yang diproses oleh satu atau beberapa *layanan*. Lambda mencatat 2 segmen per jejak, yang menciptakan dua node pada grafik layanan. Gambar berikut menyoroti dua node ini:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/xray-servicemap-function.png)
Node pertama di sebelah kiri mewakili layanan Lambda, yang menerima permintaan pemanggilan. Node kedua mewakili fungsi Lambda spesifik Anda. Contoh berikut menunjukkan jejak dengan dua segmen ini. Keduanya bernama **fungsi saya**, tetapi yang satu memiliki asal `AWS::Lambda` dan yang lainnya memiliki asal usul. `AWS::Lambda::Function` Jika `AWS::Lambda` segmen menunjukkan kesalahan, layanan Lambda mengalami masalah. Jika `AWS::Lambda::Function` segmen menunjukkan kesalahan, fungsi Anda mengalami masalah.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
Contoh ini memperluas `AWS::Lambda::Function` segmen untuk menunjukkan tiga subsegmennya.
**catatan**
AWS saat ini menerapkan perubahan pada layanan Lambda. Karena perubahan ini, Anda mungkin melihat perbedaan kecil antara struktur dan konten pesan log sistem dan segmen pelacakan yang dipancarkan oleh fungsi Lambda yang berbeda di Anda. Akun AWS
Contoh jejak yang ditunjukkan di sini menggambarkan segmen fungsi gaya lama. Perbedaan antara segmen gaya lama dan baru dijelaskan dalam paragraf berikut.
Perubahan ini akan diterapkan selama beberapa minggu mendatang, dan semua fungsi di semua Wilayah AWS kecuali China GovCloud dan wilayah akan bertransisi untuk menggunakan pesan log format baru dan segmen pelacakan.
Segmen fungsi gaya lama berisi subsegmen berikut:
+ **Inisialisasi** – Mewakili waktu yang dihabiskan untuk memuat fungsi dan menjalankan [kode inisialisasi](foundation-progmodel.md). Subsegmen ini hanya muncul untuk peristiwa pertama yang diproses oleh setiap instance fungsi Anda.
+ **Doa** - Merupakan waktu yang dihabiskan untuk menjalankan kode handler Anda.
+ **Overhead** - Merupakan waktu yang dihabiskan runtime Lambda untuk mempersiapkan diri untuk menangani acara berikutnya.
Segmen fungsi gaya baru tidak berisi subsegmen. `Invocation` Sebagai gantinya, subsegmen pelanggan dilampirkan langsung ke segmen fungsi. Untuk informasi lebih lanjut tentang struktur segmen fungsi gaya lama dan baru, lihat. [Memahami jejak X-Ray](services-xray.md#services-xray-traces)
Anda dapat melakukan instrumentasi kode penangan untuk merekam metadata dan melacak panggilan downstream. Untuk merekam detail tentang panggilan yang dibuat penangan ke sumber daya dan layanan lain, gunakan X-Ray SDK for Ruby. Untuk mendapatkan SDK, tambahkan paket `aws-xray-sdk` ke dependensi aplikasi Anda.
**Example [kosong- ruby/function/Gemfile](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/function/Gemfile)**
```
# Gemfile
source 'https://rubygems.org'
gem 'aws-xray-sdk', '0.11.4'
gem 'aws-sdk-lambda', '1.39.0'
gem 'test-unit', '3.3.5'
```
Untuk instrumen klien AWS SDK, memerlukan `aws-xray-sdk/lambda` modul setelah membuat klien dalam kode inisialisasi.
**Example [blank- ruby/function/lambda \$1function.rb](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/function/lambda_function.rb) - Menelusuri klien SDK AWS**
```
# lambda_function.rb
require 'logger'
require 'json'
require 'aws-sdk-lambda'
$client = Aws::Lambda::Client.new()
$client.get_account_settings()
require 'aws-xray-sdk/lambda'
def lambda_handler(event:, context:)
logger = Logger.new($stdout)
...
```
Di X-Ray, *jejak* merekam informasi tentang permintaan yang diproses oleh satu atau beberapa *layanan*. Lambda mencatat 2 segmen per jejak, yang menciptakan dua node pada grafik layanan. Gambar berikut menyoroti dua node ini:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/xray-servicemap-function.png)
Node pertama di sebelah kiri mewakili layanan Lambda, yang menerima permintaan pemanggilan. Node kedua mewakili fungsi Lambda spesifik Anda. Contoh berikut menunjukkan jejak dengan dua segmen ini. Keduanya bernama **fungsi saya**, tetapi yang satu memiliki asal `AWS::Lambda` dan yang lainnya memiliki asal usul. `AWS::Lambda::Function` Jika `AWS::Lambda` segmen menunjukkan kesalahan, layanan Lambda mengalami masalah. Jika `AWS::Lambda::Function` segmen menunjukkan kesalahan, fungsi Anda mengalami masalah.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
Contoh ini memperluas `AWS::Lambda::Function` segmen untuk menunjukkan tiga subsegmennya.
**catatan**
AWS saat ini menerapkan perubahan pada layanan Lambda. Karena perubahan ini, Anda mungkin melihat perbedaan kecil antara struktur dan konten pesan log sistem dan segmen pelacakan yang dipancarkan oleh fungsi Lambda yang berbeda di Anda. Akun AWS
Contoh jejak yang ditunjukkan di sini menggambarkan segmen fungsi gaya lama. Perbedaan antara segmen gaya lama dan baru dijelaskan dalam paragraf berikut.
Perubahan ini akan diterapkan selama beberapa minggu mendatang, dan semua fungsi di semua Wilayah AWS kecuali China GovCloud dan wilayah akan bertransisi untuk menggunakan pesan log format baru dan segmen pelacakan.
Segmen fungsi gaya lama berisi subsegmen berikut:
+ **Inisialisasi** – Mewakili waktu yang dihabiskan untuk memuat fungsi dan menjalankan [kode inisialisasi](foundation-progmodel.md). Subsegmen ini hanya muncul untuk peristiwa pertama yang diproses oleh setiap instance fungsi Anda.
+ **Doa** - Merupakan waktu yang dihabiskan untuk menjalankan kode handler Anda.
+ **Overhead** - Merupakan waktu yang dihabiskan runtime Lambda untuk mempersiapkan diri untuk menangani acara berikutnya.
Segmen fungsi gaya baru tidak berisi subsegmen. `Invocation` Sebagai gantinya, subsegmen pelanggan dilampirkan langsung ke segmen fungsi. Untuk informasi lebih lanjut tentang struktur segmen fungsi gaya lama dan baru, lihat. [Memahami jejak X-Ray](services-xray.md#services-xray-traces)
Anda juga dapat melakukan instrumentasi klien HTTP, merekam kueri SQL, dan membuat subsegmen khusus dengan anotasi dan metadata. Untuk informasi selengkapnya, lihat [X-Ray SDK for](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-ruby.html) Ruby AWS X-Ray di Panduan Pengembang.
**Topics**
+ [
## Mengaktifkan pelacakan aktif dengan API Lambda
](#ruby-tracing-api)
+ [
## Mengaktifkan penelusuran aktif dengan CloudFormation
](#ruby-tracing-cloudformation)
+ [
## Menyimpan dependensi runtime dalam satu lapisan
](#ruby-tracing-layers)
## Mengaktifkan pelacakan aktif dengan API Lambda
Untuk mengelola konfigurasi penelusuran dengan AWS CLI atau AWS SDK, gunakan operasi API berikut:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
Contoh AWS CLI perintah berikut memungkinkan penelusuran aktif pada fungsi bernama **my-function**.
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
Mode penelusuran adalah bagian dari konfigurasi khusus versi saat Anda memublikasikan versi fungsi Anda. Anda tidak dapat mengubah mode pelacakan pada versi yang telah diterbitkan.
## Mengaktifkan penelusuran aktif dengan CloudFormation
Untuk mengaktifkan penelusuran pada `AWS::Lambda::Function` sumber daya dalam CloudFormation templat, gunakan `TracingConfig` properti.
**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) – Konfigurasi pelacakan**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
Untuk sumber `AWS::Serverless::Function` daya AWS Serverless Application Model (AWS SAM), gunakan `Tracing` properti.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) – Konfigurasi pelacakan**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## Menyimpan dependensi runtime dalam satu lapisan
Jika Anda menggunakan X-Ray SDK untuk menginstruksikan klien AWS SDK kode fungsi Anda, paket penerapan Anda bisa menjadi cukup besar. [Untuk menghindari mengunggah dependensi runtime setiap kali Anda memperbarui kode fungsi, paketkan X-Ray SDK di lapisan Lambda.](chapter-layers.md)
Contoh berikut menunjukkan sumber daya `AWS::Serverless::LayerVersion` yang menyimpan X-Ray SDK for Ruby.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/template.yml) – Lapisan dependensi**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
CodeUri: function/.
Tracing: Active
Layers:
- !Ref libs
...
libs:
Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
Properties:
LayerName: blank-ruby-lib
Description: Dependencies for the blank-ruby sample app.
ContentUri: lib/.
CompatibleRuntimes:
- ruby2.5
```
Dengan konfigurasi ini, Anda memperbarui lapisan pustaka hanya jika Anda mengubah dependensi runtime Anda. Karena paket penerapan fungsi hanya berisi kode Anda, ini dapat membantu mengurangi waktu upload.
Membuat lapisan untuk dependensi memerlukan perubahan build untuk membuat arsip lapisan sebelum deployment. Untuk contoh pekerjaan, lihat aplikasi sampel [blank-ruby](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby).