Dasar-dasar penangan TypeScript Menggunakan async/await Menggunakan callback Menggunakan tipe untuk objek acara Praktik terbaik kode untuk fungsi Lambda TypeScript

Tentukan penangan fungsi Lambda di TypeScript

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.

Topik

Dasar-dasar penangan TypeScript
Menggunakan async/await
Menggunakan callback
Menggunakan tipe untuk objek acara
Praktik terbaik kode untuk fungsi Lambda TypeScript

Dasar-dasar penangan TypeScript

contoh TypeScript pawang

Fungsi contoh ini mencatat isi objek acara dan mengembalikan lokasi log. Perhatikan hal berikut:

Sebelum menggunakan kode ini dalam fungsi Lambda, Anda harus menambahkan paket @types /aws-lambda sebagai dependensi pengembangan. Paket ini berisi definisi tipe untuk Lambda. Ketika @types/aws-lambda diinstal, import pernyataan (import ... from 'aws-lambda') mengimpor definisi tipe. Itu tidak mengimpor aws-lambda NPM paket, yang merupakan alat pihak ketiga yang tidak terkait. Untuk informasi selengkapnya, lihat aws-lambda di repositori. DefinitelyTyped GitHub
Handler dalam contoh ini adalah modul ES dan harus ditunjuk seperti itu di package.json file Anda atau dengan menggunakan ekstensi .mjs file. Untuk informasi lebih lanjut, lihatMenunjuk penangan fungsi sebagai modul ES.


import { Handler } from 'aws-lambda';

export const handler: Handler = async (event, context) => {
    console.log('EVENT: \n' + JSON.stringify(event, null, 2));
    return context.logStreamName;
};

Runtime meneruskan argumen ke metode handler. Argumen pertama adalah objek event, yang berisi informasi dari invoker. Invoker meneruskan informasi ini sebagai string yang JSON diformat -saat memanggil Invoke, dan runtime mengubahnya menjadi objek. Ketika AWS layanan memanggil fungsi Anda, struktur acara bervariasi menurut layanan. Dengan TypeScript, kami sarankan menggunakan anotasi tipe untuk objek acara. Untuk informasi selengkapnya, lihat Menggunakan tipe untuk objek acara.

Argumen kedua adalah objek konteks, yang berisi informasi tentang lingkungan invokasi, fungsi, dan eksekusi. Pada contoh sebelumnya, fungsi mendapatkan nama alur log dari objek konteks dan mengembalikannya ke invoker.

Anda juga dapat menggunakan argumen callback, yang merupakan fungsi yang dapat Anda panggil di penangan non-async untuk mengirim respons. Kami menyarankan Anda menggunakan async/await alih-alih callback. Async/await memberikan peningkatan keterbacaan, penanganan kesalahan, dan efisiensi. Untuk informasi selengkapnya tentang perbedaan antara async/await dan callback, lihat. Menggunakan callback

Menggunakan async/await

Jika kode Anda melakukan tugas asinkron, gunakan pola async/await untuk memastikan bahwa handler selesai berjalan. Async/await adalah cara ringkas dan mudah dibaca untuk menulis kode asinkron di Node.js, tanpa perlu panggilan balik bersarang atau janji rantai. Dengan async/await, Anda dapat menulis kode yang berbunyi seperti kode sinkron, sambil tetap asinkron dan tidak memblokir.

asyncKata kunci menandai fungsi sebagai asinkron, dan await kata kunci menjeda eksekusi fungsi sampai a diselesaikan. Promise

contoh TypeScript fungsi — asinkron

Contoh ini menggunakanfetch, yang tersedia di nodejs18.x runtime. Perhatikan hal berikut:

Sebelum menggunakan kode ini dalam fungsi Lambda, Anda harus menambahkan paket @types /aws-lambda sebagai dependensi pengembangan. Paket ini berisi definisi tipe untuk Lambda. Ketika @types/aws-lambda diinstal, import pernyataan (import ... from 'aws-lambda') mengimpor definisi tipe. Itu tidak mengimpor aws-lambda NPM paket, yang merupakan alat pihak ketiga yang tidak terkait. Untuk informasi selengkapnya, lihat aws-lambda di repositori. DefinitelyTyped GitHub
Handler dalam contoh ini adalah modul ES dan harus ditunjuk seperti itu di package.json file Anda atau dengan menggunakan ekstensi .mjs file. Untuk informasi lebih lanjut, lihatMenunjuk penangan fungsi sebagai modul ES.


import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
const url = 'https://aws.amazon.com/';
export const lambdaHandler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
    try {
        // fetch is available with Node.js 18
        const res = await fetch(url);
        return {
            statusCode: res.status,
            body: JSON.stringify({
                message: await res.text(),
            }),
        };
    } catch (err) {
        console.log(err);
        return {
            statusCode: 500,
            body: JSON.stringify({
                message: 'some error happened',
            }),
        };
    }
};

Menggunakan callback

Kami menyarankan Anda menggunakan async/await untuk mendeklarasikan fungsi handler alih-alih menggunakan callback. Async/await adalah pilihan yang lebih baik karena beberapa alasan:

Keterbacaan: Kode async/await lebih mudah dibaca dan dipahami daripada kode panggilan balik, yang dapat dengan cepat menjadi sulit untuk diikuti dan menghasilkan neraka panggilan balik.
Debugging dan penanganan kesalahan: Debugging kode berbasis callback bisa jadi sulit. Tumpukan panggilan bisa menjadi sulit untuk diikuti dan kesalahan dapat dengan mudah ditelan. Dengan async/await, Anda dapat menggunakan blok coba/tangkap untuk menangani kesalahan.
Efisiensi: Callback sering memerlukan peralihan di antara bagian-bagian kode yang berbeda. Async/await dapat mengurangi jumlah sakelar konteks, menghasilkan kode yang lebih efisien.

Saat Anda menggunakan callback di handler Anda, fungsi terus dijalankan hingga loop peristiwa kosong atau fungsi habis waktu. Respons tidak dikirimkan ke invoker hingga semua tugas loop peristiwa selesai. Jika waktu fungsi habis, kesalahan akan dikembalikan. Anda dapat mengonfigurasi runtime untuk mengirim respons segera dengan menyetel konteks. callbackWaitsForEmptyEventLoopuntuk palsu.

Fungsi panggilan balik memiliki dua argumen: Error dan respons. Objek respons harus kompatibel dengan JSON.stringify.

contoh TypeScript fungsi dengan callback

Fungsi sampel ini menerima peristiwa dari Amazon API Gateway, mencatat peristiwa dan objek konteks, lalu mengembalikan respons ke API Gateway. Perhatikan hal berikut:

Sebelum menggunakan kode ini dalam fungsi Lambda, Anda harus menambahkan paket @types /aws-lambda sebagai dependensi pengembangan. Paket ini berisi definisi tipe untuk Lambda. Ketika @types/aws-lambda diinstal, import pernyataan (import ... from 'aws-lambda') mengimpor definisi tipe. Itu tidak mengimpor aws-lambda NPM paket, yang merupakan alat pihak ketiga yang tidak terkait. Untuk informasi selengkapnya, lihat aws-lambda di repositori. DefinitelyTyped GitHub
Handler dalam contoh ini adalah modul ES dan harus ditunjuk seperti itu di package.json file Anda atau dengan menggunakan ekstensi .mjs file. Untuk informasi lebih lanjut, lihatMenunjuk penangan fungsi sebagai modul ES.


import { Context, APIGatewayProxyCallback, APIGatewayEvent } from 'aws-lambda';

export const lambdaHandler = (event: APIGatewayEvent, context: Context, callback: APIGatewayProxyCallback): void => {
    console.log(`Event: ${JSON.stringify(event, null, 2)}`);
    console.log(`Context: ${JSON.stringify(context, null, 2)}`);
    callback(null, {
        statusCode: 200,
        body: JSON.stringify({
            message: 'hello world',
        }),
    });
};

Menggunakan tipe untuk objek acara

Kami menyarankan agar Anda tidak menggunakan tipe apa pun untuk argumen handler dan tipe pengembalian karena Anda kehilangan kemampuan untuk memeriksa tipe. Sebagai gantinya, buat acara menggunakan AWS Serverless Application Model CLI perintah sam local generate-event, atau gunakan definisi sumber terbuka dari paket @types /aws-lambda.

Menghasilkan acara menggunakan perintah sam local generate-event

Buat acara proxy Amazon Simple Storage Service (Amazon S3).
```
sam local generate-event s3 put >> S3PutEvent.json
```
Gunakan utilitas quicktype untuk menghasilkan definisi tipe dari file S3 PutEvent .json.
```
npm install -g quicktype
quicktype S3PutEvent.json -o S3PutEvent.ts
```

Gunakan jenis yang dihasilkan dalam kode Anda.


import { S3PutEvent } from './S3PutEvent';

export const lambdaHandler = async (event: S3PutEvent): Promise<void> => {
  event.Records.map((record) => console.log(record.s3.object.key));
};

Membuat acara menggunakan definisi sumber terbuka dari paket @types /aws-lambda

Tambahkan paket @types /aws-lambda sebagai dependensi pengembangan.
```
npm install -D @types/aws-lambda
```

Gunakan jenis dalam kode Anda.


import { S3Event } from "aws-lambda";

export const lambdaHandler = async (event: S3Event): Promise<void> => {
  event.Records.map((record) => console.log(record.s3.object.key));
};

Praktik terbaik kode untuk fungsi Lambda TypeScript

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. Dalam Node.js, ini mungkin terlihat seperti:


exports.myHandler = function(event, context, callback) {
	var foo = event.foo;
	var bar = event.bar;
	var result = MyLambdaFunction (foo, bar);

	callback(null, result);
}

function MyLambdaFunction (foo, bar) {
	// MyLambdaFunction logic here
}

Kontrol dependensi dalam paket penerapan fungsi Anda. Lingkungan AWS Lambda eksekusi berisi sejumlah pustaka. Untuk runtime Node.js dan Python, ini termasuk file. AWS SDKs 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.
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.

Manfaatkan penggunaan kembali lingkungan eksekusi untuk meningkatkan kinerja fungsi Anda. Inisialisasi SDK klien dan koneksi database di luar fungsi handler, dan cache 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.
Gunakan variabel lingkungan 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 APIPembaruan 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 APIreferensi 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? .

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

Membangun dengan TypeScript

Deploy arsip file .zip