Prasyarat Kompatibilitas lapisan Node.js dengan lingkungan runtime Lambda Jalur lapisan untuk runtime Node.js Mengemas konten lapisan Membuat layer Menambahkan layer ke fungsi Anda

Bekerja dengan lapisan untuk fungsi Lambda Node.js

Lapisan Lambda adalah arsip file.zip yang berisi kode atau data tambahan. Lapisan biasanya berisi dependensi pustaka, runtime kustom, atau file konfigurasi. Membuat layer melibatkan tiga langkah umum:

Package konten layer Anda. Ini berarti membuat arsip file.zip yang berisi dependensi yang ingin Anda gunakan dalam fungsi Anda.
Buat layer di Lambda.
Tambahkan layer ke fungsi Anda.

Topik ini berisi langkah-langkah dan panduan tentang cara mengemas dan membuat lapisan Lambda Node.js dengan dependensi pustaka eksternal dengan benar.

Topik

Prasyarat
Kompatibilitas lapisan Node.js dengan lingkungan runtime Lambda
Jalur lapisan untuk runtime Node.js
Mengemas konten lapisan
Membuat layer
Menambahkan layer ke fungsi Anda

Prasyarat

Untuk mengikuti langkah-langkah di bagian ini, Anda harus memiliki yang berikut:

Node.js 20 dan manajer paket npm. Untuk informasi selengkapnya tentang menginstal Node.js, lihat Menginstal Node.js melalui pengelola paket di dokumentasi Node.js.
AWS Command Line Interface (AWS CLI) versi 2

Sepanjang topik ini, kami mereferensikan aplikasi sampel layer-nodejs di repositori. aws-lambda-developer-guide GitHub Aplikasi ini berisi skrip yang mengunduh ketergantungan dan mengemasnya ke dalam lapisan. Aplikasi ini juga berisi fungsi terkait yang menggunakan ketergantungan dari lapisan. Setelah membuat layer, Anda dapat menerapkan dan memanggil fungsi yang sesuai untuk memverifikasi bahwa semuanya berfungsi. Contoh aplikasi ini menggunakan runtime Node.js 20. Jika Anda menambahkan dependensi tambahan ke lapisan Anda, mereka harus kompatibel dengan Node.js 20.

Aplikasi layer-nodejs sampel akan mengemas pustaka lodash ke dalam lapisan Lambda. layerDirektori berisi skrip untuk menghasilkan lapisan. functionDirektori berisi fungsi sampel untuk menguji apakah lapisan berfungsi. Dokumen ini berjalan melalui cara membuat, mengemas, menyebarkan, dan menguji lapisan ini.

Kompatibilitas lapisan Node.js dengan lingkungan runtime Lambda

Saat Anda mengemas kode dalam lapisan Node.js, Anda menentukan lingkungan runtime Lambda yang kompatibel dengan kode tersebut. Untuk menilai kompatibilitas kode dengan runtime, pertimbangkan versi Node.js, sistem operasi apa, dan arsitektur set instruksi apa yang dirancang untuk kode tersebut.

Runtime Lambda Node.js menentukan versi Node.js dan sistem operasi mereka. Dalam dokumen ini, Anda akan menggunakan runtime Node.js 20, yang didasarkan pada AL2 023. Untuk informasi selengkapnya tentang versi runtime, lihatWaktu aktif yang didukung. Saat Anda membuat fungsi Lambda, Anda menentukan arsitektur set instruksi. Dalam dokumen ini, Anda akan menggunakan arm64 arsitektur. Untuk informasi lebih lanjut tentang arsitektur di Lambda, lihat. Memilih dan mengonfigurasi arsitektur set instruksi untuk fungsi Lambda Anda

Bila Anda menggunakan kode yang disediakan dalam sebuah paket, setiap pengelola paket secara independen mendefinisikan kompatibilitasnya. Sebagian besar pengembangan Node.js dirancang untuk bekerja secara independen dari sistem operasi dan arsitektur set instruksi. Selain itu, melanggar ketidakcocokan dengan versi Node.js baru tidak begitu umum. Berharap untuk menghabiskan lebih banyak waktu Anda menilai kompatibilitas antar paket daripada menilai kompatibilitas paket dengan versi Node.js, sistem operasi, atau arsitektur set instruksi.

Terkadang paket Node.js menyertakan kode yang dikompilasi, yang mengharuskan Anda mempertimbangkan kompatibilitas arsitektur sistem operasi dan set instruksi. Jika Anda perlu menilai kompatibilitas kode untuk paket Anda, Anda perlu memeriksa paket dan dokumentasinya. Paket di NPM dapat menentukan kompatibilitasnya melaluiengines,os, dan cpu bidang file package.json manifes mereka. Untuk informasi selengkapnya tentang package.json file, lihat package.json di dokumentasi. NPM

Jalur lapisan untuk runtime Node.js

Saat Anda menambahkan layer ke fungsi, Lambda memuat konten layer ke dalam lingkungan eksekusi. Jika layer Anda mengemas dependensi di jalur folder tertentu, lingkungan eksekusi Node.js akan mengenali modul, dan Anda dapat mereferensikan modul dari kode fungsi Anda.

Untuk memastikan bahwa modul Anda diambil, paketkan ke dalam file layer .zip Anda di salah satu jalur folder berikut. File-file ini disimpan di/opt, dan jalur folder dimuat ke dalam variabel PATH lingkungan.

nodejs/node_modules
nodejs/nodeX/node_modules

Misalnya, file layer zip yang dihasilkan yang Anda buat dalam tutorial ini memiliki struktur direktori berikut:


layer_content.zip
└ nodejs
    └ node20
        └ node_modules
            └ lodash
            └ <other potential dependencies>
            └ ...

Anda akan menempatkan lodashperpustakaan di nodejs/node20/node_modules direktori. Ini memastikan bahwa Lambda dapat menemukan pustaka selama pemanggilan fungsi.

Mengemas konten lapisan

Dalam contoh ini, Anda mengemas lodash pustaka dalam file layer .zip. Selesaikan langkah-langkah berikut untuk menginstal dan mengemas konten lapisan.

Untuk menginstal dan mengemas konten lapisan Anda

Kloning repositori aws-lambda-developer-guide dari GitHub, yang berisi kode sampel yang Anda butuhkan di direktori. sample-apps/layer-nodejs
```
git clone https://github.com/awsdocs/aws-lambda-developer-guide.git
```
Arahkan ke layer direktori aplikasi layer-nodejs sampel. Direktori ini berisi skrip yang Anda gunakan untuk membuat dan mengemas lapisan dengan benar.
```
cd aws-lambda-developer-guide/sample-apps/layer-nodejs/layer
```
Pastikan daftar package.json filelodash. File ini mendefinisikan dependensi yang ingin Anda sertakan dalam layer. Anda dapat memperbarui file ini untuk menyertakan dependensi apa pun yang Anda inginkan di lapisan Anda.

catatan
Yang package.json digunakan dalam langkah ini tidak disimpan atau digunakan dengan dependensi Anda setelah diunggah ke lapisan Lambda. Ini hanya digunakan dalam proses pengemasan lapisan, dan tidak menentukan perintah run dan kompatibilitas seperti file dalam aplikasi Node.js atau paket yang diterbitkan.
Pastikan Anda memiliki izin shell untuk menjalankan skrip di layer direktori.
```
chmod 744 1-install.sh && chmod 744 2-package.sh
```
Jalankan skrip 1-install.sh menggunakan perintah berikut:
```
./1-install.sh
```
Skrip ini berjalannpm install, yang membaca Anda package.json dan mengunduh dependensi yang ditentukan di dalamnya.
contoh 1-install.sh
```
npm install .
```
Jalankan skrip 2-package.sh menggunakan perintah berikut:
```
./2-package.sh
```
Script ini menyalin isi dari node_modules direktori ke direktori baru bernamanodejs/node20. Kemudian zip isi nodejs direktori ke dalam file bernamalayer_content.zip. Ini adalah file.zip untuk layer Anda. Anda dapat membuka zip file dan memverifikasi bahwa itu berisi struktur file yang benar, seperti yang ditunjukkan pada Jalur lapisan untuk runtime Node.js bagian.
contoh 2-package.sh
```
mkdir -p nodejs/node20
cp -r node_modules nodejs/node20/
zip -r layer_content.zip nodejs
```

Membuat layer

Ambil layer_content.zip file yang Anda buat di bagian sebelumnya dan unggah sebagai lapisan Lambda. Anda dapat mengunggah layer menggunakan AWS Management Console atau Lambda API melalui AWS Command Line Interface ()AWS CLI. Saat Anda mengunggah file layer .zip Anda, dalam PublishLayerVersion AWS CLI perintah berikut, tentukan nodejs20.x sebagai runtime yang kompatibel dan arm64 sebagai arsitektur yang kompatibel.


aws lambda publish-layer-version --layer-name node-lodash-layer \
    --zip-file fileb://layer_content.zip \
    --compatible-runtimes nodejs20.x \
    --compatible-architectures "arm64"

Dari tanggapan, perhatikanLayerVersionArn, yang terlihat sepertiarn:aws:lambda:us-east-1:123456789012:layer:node-lodash-layer:1. Anda akan memerlukan Amazon Resource Name (ARN) ini di langkah berikutnya dari tutorial ini, ketika Anda menambahkan layer ke fungsi Anda.

Menambahkan layer ke fungsi Anda

Menyebarkan contoh fungsi Lambda yang menggunakan lodash pustaka dalam kode fungsinya, lalu lampirkan layer yang Anda buat. Untuk menerapkan fungsi, Anda memerlukan peran eksekusi. Untuk informasi selengkapnya, lihat Mendefinisikan izin fungsi Lambda dengan peran eksekusi. Jika Anda tidak memiliki peran eksekusi yang ada, ikuti langkah-langkah di bagian yang dapat dilipat. Jika tidak, lewati ke bagian berikutnya untuk menyebarkan fungsi.

Untuk membuat peran eksekusi

Buka halaman peran di IAM konsol.
Pilih Buat peran.
Buat peran dengan properti berikut.
- Entitas tepercaya – Lambda.
- Izin — AWSLambdaBasicExecutionRole.
- Nama peran – lambda-role.
AWSLambdaBasicExecutionRoleKebijakan ini memiliki izin yang diperlukan fungsi untuk menulis log ke CloudWatch Log.

Kode fungsi sampel menggunakan _.findLastIndex metode lodash untuk membaca melalui array objek. Ini membandingkan objek dengan kriteria untuk menemukan indeks kecocokan. Kemudian, ia mengembalikan indeks dan nilai objek dalam respons Lambda.


import _ from "lodash"

export const handler = async (event) => {

  var users = [
  { 'user': 'Carlos',  'active': true },
  { 'user': 'Gil-dong',    'active': false },
  { 'user': 'Pat', 'active': false }
  ];

  let out = _.findLastIndex(users, function(o) { return o.user == 'Pat'; });
  const response = {
    statusCode: 200,
    body: JSON.stringify(out + ", " + users[out].user),
  };
  return response;
};

Untuk menyebarkan fungsi Lambda

Buka direktori function/ tersebut. Jika saat ini Anda berada di layer/ direktori, jalankan perintah berikut:
```
cd ../function
```
Buat paket penyebaran file.zip menggunakan perintah berikut:
```
zip my_deployment_package.zip index.mjs
```

Menyebarkan fungsi. Dalam AWS CLI perintah berikut, ganti --role parameter dengan peran eksekusi AndaARN:


aws lambda create-function --function-name nodejs_function_with_layer \
    --runtime nodejs20.x \
    --architectures "arm64" \
    --handler index.handler \
    --role arn:aws:iam::123456789012:role/lambda-role \
    --zip-file fileb://my_deployment_package.zip

Pasang layer ke fungsi Anda. Dalam AWS CLI perintah berikut, ganti --layers parameter dengan versi layer ARN yang Anda catat sebelumnya:


aws lambda update-function-configuration --function-name nodejs_function_with_layer \
    --cli-binary-format raw-in-base64-out \
    --layers "arn:aws:lambda:us-east-1:123456789012:layer:nodejs-lodash-layer:1"

Panggil fungsi Anda untuk memverifikasi itu berfungsi menggunakan AWS CLI perintah berikut:


aws lambda invoke --function-name nodejs_function_with_layer \
    --cli-binary-format raw-in-base64-out \
    --payload '{}' response.json

Anda akan melihat output seperti ini:


{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}

response.jsonFile output berisi rincian tentang respon.

Sekarang Anda dapat menghapus sumber daya yang Anda buat untuk tutorial ini, kecuali Anda ingin mempertahankannya. Dengan menghapus AWS sumber daya yang tidak lagi Anda gunakan, Anda mencegah tagihan yang tidak perlu ke Anda Akun AWS.

Untuk menghapus layer Lambda

Buka halaman Fungsi di konsol Lambda.
Pilih layer yang Anda buat.
Pilih Hapus, lalu pilih Hapus lagi.

Untuk menghapus fungsi Lambda

Buka halaman Fungsi di konsol Lambda.
Pilih fungsi yang Anda buat.
Pilih Tindakan, Hapus.
Ketik delete kolom input teks dan pilih Hapus.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Deploy gambar kontainer

Konteks