Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menerapkan kode sebelum atau sesudah snapshot fungsi Lambda
Anda dapat menggunakan kait runtime untuk mengimplementasikan kode sebelum Lambda membuat snapshot atau setelah Lambda melanjutkan fungsi dari snapshot. Runtime hook berguna untuk berbagai tujuan, seperti:
+ **Pembersihan dan inisialisasi:** Sebelum snapshot dibuat, Anda dapat menggunakan hook runtime untuk melakukan pembersihan atau operasi rilis sumber daya. Setelah snapshot dipulihkan, Anda dapat menggunakan hook runtime untuk menginisialisasi ulang sumber daya atau status apa pun yang tidak ditangkap dalam snapshot.
+ **Konfigurasi dinamis:** Anda dapat menggunakan kait runtime untuk memperbarui konfigurasi atau metadata lain secara dinamis sebelum snapshot dibuat atau setelah dipulihkan. Ini dapat berguna jika fungsi Anda perlu beradaptasi dengan perubahan di lingkungan runtime.
+ **Integrasi eksternal:** Anda dapat menggunakan kait runtime untuk berintegrasi dengan layanan atau sistem eksternal, seperti mengirim pemberitahuan atau memperbarui status eksternal, sebagai bagian dari proses pemeriksaan dan pemulihan.
+ **Penyetelan kinerja:** Anda dapat menggunakan kait runtime untuk menyempurnakan urutan startup fungsi Anda, seperti dengan preloading dependensi. Untuk informasi selengkapnya, lihat [Penyempurnaan performa](snapstart-best-practices.md#snapstart-tuning).
Halaman-halaman berikut menjelaskan cara menerapkan kait runtime untuk runtime pilihan Anda.
**Topics**
+ [Java](snapstart-runtime-hooks-java.md)
+ [Python](snapstart-runtime-hooks-python.md)
+ [.NET](snapstart-runtime-hooks-dotnet.md)
# Kait SnapStart runtime Lambda untuk Java
Anda dapat menggunakan kait runtime untuk mengimplementasikan kode sebelum Lambda membuat snapshot atau setelah Lambda melanjutkan fungsi dari snapshot. Runtime hook tersedia sebagai bagian dari proyek Coordinated Restore at Checkpoint (C) open-source. CRa CRaC sedang dalam pengembangan untuk [Open Java Development Kit (OpenJDK](https://wiki.openjdk.org/display/crac)). Untuk contoh cara menggunakan CRa C dengan aplikasi referensi, lihat repositori [CRaC](https://github.com/CRaC/docs/blob/master/STEP-BY-STEP.md) di. GitHub CRaC menggunakan tiga elemen utama:
+ `Resource`Antarmuka dengan dua metode, `beforeCheckpoint()` dan`afterRestore()`. Gunakan metode ini untuk mengimplementasikan kode yang ingin Anda jalankan sebelum snapshot dan setelah pemulihan.
+ `Context `— Untuk menerima pemberitahuan untuk pos pemeriksaan dan pemulihan, a `Resource` harus terdaftar dengan a. `Context`
+ `Core`— Layanan koordinasi, yang menyediakan global default `Context` melalui metode statis`Core.getGlobalContext()`.
Untuk informasi selengkapnya tentang `Context` dan`Resource`, lihat [Package org.crac di dokumentasi C](https://javadoc.io/doc/io.github.crac/org-crac/latest/index.html). CRa
Gunakan langkah-langkah berikut untuk mengimplementasikan kait runtime dengan paket [org.crac](https://github.com/CRaC/org.crac). Runtime Lambda berisi implementasi konteks CRa C yang disesuaikan yang memanggil kait runtime Anda sebelum checkpointing dan setelah memulihkan.
## Registrasi dan eksekusi runtime hook
Urutan Lambda mengeksekusi kait runtime Anda ditentukan oleh urutan pendaftaran. Pesanan pendaftaran mengikuti urutan impor, definisi, atau eksekusi dalam kode Anda.
+ `beforeCheckpoint()`: Dieksekusi dalam urutan terbalik pendaftaran
+ `afterRestore()`: Dieksekusi dalam urutan pendaftaran
Pastikan bahwa semua kait terdaftar diimpor dengan benar dan disertakan dalam kode fungsi Anda. Jika Anda mendaftarkan kait runtime dalam file atau modul terpisah, Anda harus memastikan bahwa modul diimpor, baik secara langsung atau sebagai bagian dari paket yang lebih besar, dalam file handler fungsi Anda. Jika file atau modul tidak diimpor dalam penangan fungsi, Lambda mengabaikan kait runtime.
**catatan**
Saat Lambda membuat snapshot, kode inisialisasi Anda dapat berjalan hingga 15 menit. Batas waktu adalah 130 detik atau batas [waktu fungsi yang dikonfigurasi](configuration-timeout.md) (maksimum 900 detik), mana yang lebih tinggi. Kait `beforeCheckpoint()` runtime Anda dihitung terhadap batas waktu kode inisialisasi. Saat Lambda mengembalikan snapshot, runtime harus dimuat dan kait runtime harus selesai dalam batas `afterRestore()` waktu tunggu (10 detik). Jika tidak, Anda akan mendapatkan SnapStartTimeoutException.
## Langkah 1: Perbarui konfigurasi build
Tambahkan `org.crac` dependensi ke konfigurasi build. Contoh berikut menggunakan Gradle. Untuk contoh untuk sistem build lainnya, lihat dokumentasi [Apache Maven](https://search.maven.org/artifact/io.github.crac/org-crac/0.1.3/jar).
```
dependencies {
compile group: 'com.amazonaws', name: 'aws-lambda-java-core', version: '1.2.1'
# All other project dependecies go here:
# ...
# Then, add the org.crac dependency:
implementation group: 'org.crac', name: 'crac', version: '1.4.0'
}
```
## Langkah 2: Perbarui penangan Lambda
*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.
Untuk informasi selengkapnya, lihat [Tentukan penangan fungsi Lambda di Java](java-handler.md).
Contoh handler berikut menunjukkan cara menjalankan kode sebelum checkpointing (`beforeCheckpoint()`) dan setelah restoring (). `afterRestore()` Handler ini juga mendaftarkan `Resource` ke global yang dikelola runtime. `Context`
**catatan**
Saat Lambda membuat snapshot, kode inisialisasi Anda dapat berjalan hingga 15 menit. Batas waktu adalah 130 detik atau batas [waktu fungsi yang dikonfigurasi](configuration-timeout.md) (maksimum 900 detik), mana yang lebih tinggi. Kait `beforeCheckpoint()` runtime Anda dihitung terhadap batas waktu kode inisialisasi. Saat Lambda mengembalikan snapshot, runtime (JVM) harus dimuat dan kait `afterRestore()` runtime harus selesai dalam batas waktu tunggu (10 detik). Jika tidak, Anda akan mendapatkan SnapStartTimeoutException.
```
...
import org.crac.Resource;
import org.crac.Core;
...
public class CRaCDemo implements RequestStreamHandler, Resource {
public CRaCDemo() {
Core.getGlobalContext().register(this);
}
public String handleRequest(String name, Context context) throws IOException {
System.out.println("Handler execution");
return "Hello " + name;
}
@Override
public void beforeCheckpoint(org.crac.Context context)
throws Exception {
System.out.println("Before checkpoint");
}
@Override
public void afterRestore(org.crac.Context context)
throws Exception {
System.out.println("After restore");
```
`Context`hanya mempertahankan a [https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/ref/WeakReference.html](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/ref/WeakReference.html)ke objek yang terdaftar. Jika sampah [https://javadoc.io/static/io.github.crac/org-crac/0.1.3/org/crac/Resource.html](https://javadoc.io/static/io.github.crac/org-crac/0.1.3/org/crac/Resource.html)dikumpulkan, kait runtime tidak berjalan. Kode Anda harus mempertahankan referensi yang kuat `Resource` untuk menjamin bahwa hook runtime berjalan.
Berikut adalah dua contoh pola yang harus dihindari:
**Example — Objek tanpa referensi yang kuat**
```
Core.getGlobalContext().register( new MyResource() );
```
**Example — Objek kelas anonim**
```
Core.getGlobalContext().register( new Resource() {
@Override
public void afterRestore(Context context) throws Exception {
// ...
}
@Override
public void beforeCheckpoint(Context context) throws Exception {
// ...
}
} );
```
Sebaliknya, pertahankan referensi yang kuat. Dalam contoh berikut, sumber daya terdaftar bukan sampah yang dikumpulkan dan kait runtime berjalan secara konsisten.
**Example — Objek dengan referensi yang kuat**
```
Resource myResource = new MyResource(); // This reference must be maintained to prevent the registered resource from being garbage collected
Core.getGlobalContext().register( myResource );
```
# Kait SnapStart runtime Lambda untuk Python
Anda dapat menggunakan kait runtime untuk mengimplementasikan kode sebelum Lambda membuat snapshot atau setelah Lambda melanjutkan fungsi dari snapshot. Kait runtime Python tersedia sebagai bagian dari [pustaka Snapshot Restore for Python open-source, yang disertakan dalam runtime terkelola Python](https://pypi.org/project/snapshot-restore-py/). Pustaka ini menyediakan dua dekorator yang dapat Anda gunakan untuk menentukan kait runtime Anda:
+ `@register_before_snapshot`: Untuk fungsi yang ingin Anda jalankan sebelum Lambda membuat snapshot.
+ `@register_after_restore`: Untuk fungsi yang ingin Anda jalankan saat Lambda melanjutkan fungsi dari snapshot.
Atau, Anda dapat menggunakan metode berikut untuk mendaftarkan callable untuk kait runtime:
+ `register_before_snapshot(func, *args, **kwargs)`
+ `register_after_restore(func, *args, **kwargs)`
## Registrasi dan eksekusi runtime hook
Urutan Lambda mengeksekusi kait runtime Anda ditentukan oleh urutan pendaftaran:
+ Sebelum snapshot: Dieksekusi dalam urutan terbalik pendaftaran
+ Setelah snapshot: Dieksekusi dalam urutan pendaftaran
Urutan pendaftaran kait runtime tergantung pada bagaimana Anda mendefinisikan kait. Saat menggunakan dekorator (`@register_before_snapshot`dan`@register_after_restore`), urutan pendaftaran mengikuti urutan impor, definisi, atau eksekusi dalam kode Anda. Jika Anda memerlukan kontrol lebih besar atas pesanan pendaftaran, gunakan `register_after_restore()` metode `register_before_snapshot()` dan bukan dekorator.
Pastikan bahwa semua kait terdaftar diimpor dengan benar dan disertakan dalam kode fungsi Anda. Jika Anda mendaftarkan kait runtime dalam file atau modul terpisah, Anda harus memastikan bahwa modul diimpor, baik secara langsung atau sebagai bagian dari paket yang lebih besar, dalam file handler fungsi Anda. Jika file atau modul tidak diimpor dalam penangan fungsi, Lambda mengabaikan kait runtime.
**catatan**
Saat Lambda membuat snapshot, kode inisialisasi Anda dapat berjalan hingga 15 menit. Batas waktu adalah 130 detik atau batas [waktu fungsi yang dikonfigurasi](configuration-timeout.md) (maksimum 900 detik), mana yang lebih tinggi. Kait `@register_before_snapshot` runtime Anda dihitung terhadap batas waktu kode inisialisasi. Saat Lambda mengembalikan snapshot, runtime harus dimuat dan kait runtime harus selesai dalam batas `@register_after_restore` waktu tunggu (10 detik). Jika tidak, Anda akan mendapatkan SnapStartTimeoutException.
## Contoh
Contoh handler berikut menunjukkan cara menjalankan kode sebelum checkpointing (`@register_before_snapshot`) dan setelah restoring (). `@register_after_restore`
```
from snapshot_restore_py import register_before_snapshot, register_after_restore
def lambda_handler(event, context):
# Handler code
@register_before_snapshot
def before_checkpoint():
# Logic to be executed before taking snapshots
@register_after_restore
def after_restore():
# Logic to be executed after restore
```
Untuk contoh lainnya, lihat [Pemulihan Snapshot untuk Python](https://github.com/aws/snapshot-restore-py/tree/main/examples) di AWS GitHub repositori.
# Kait SnapStart runtime Lambda untuk .NET
Anda dapat menggunakan kait runtime untuk mengimplementasikan kode sebelum Lambda membuat snapshot atau setelah Lambda melanjutkan fungsi dari snapshot. .NET runtime hooks tersedia sebagai bagian dari paket [Amazon.Lambda.Core](https://www.nuget.org/packages/Amazon.Lambda.Core) (versi 2.5.0 atau yang lebih baru). Pustaka ini menyediakan dua metode yang dapat Anda gunakan untuk menentukan kait runtime Anda:
+ `RegisterBeforeSnapshot()`: Kode untuk dijalankan sebelum pembuatan snapshot
+ `RegisterAfterSnapshot()`: Kode untuk dijalankan setelah melanjutkan fungsi dari snapshot
**catatan**
Jika Anda menggunakan [kerangka kerja Anotasi Lambda untuk.NET, tingkatkan ke [Amazon.Lambda.Annotations](https://www.nuget.org/packages/Amazon.Lambda.Annotations)](csharp-handler.md#csharp-handler-annotations) versi 1.6.0 atau yang lebih baru untuk memastikan kompatibilitas dengan. SnapStart
## Registrasi dan eksekusi runtime hook
Daftarkan kait Anda dalam kode inisialisasi Anda. Pertimbangkan panduan berikut berdasarkan model [eksekusi](csharp-handler.md#csharp-handler-setup) fungsi Lambda Anda:
+ Untuk [pendekatan perakitan yang dapat dieksekusi](csharp-handler.md#csharp-executable-assembly-handlers), daftarkan kait Anda sebelum Anda memulai bootstrap Lambda dengan. `RunAsync`
+ Untuk [pendekatan perpustakaan kelas](csharp-handler.md#csharp-class-library-handlers), daftarkan kait Anda di konstruktor kelas handler.
+ Untuk [aplikasi ASP.NET Core](csharp-package-asp.md), daftarkan kait Anda sebelum memanggil metode. `WebApplications.Run`
Untuk mendaftarkan kait runtime SnapStart di .NET, gunakan metode berikut:
```
Amazon.Lambda.Core.SnapshotRestore.RegisterBeforeSnapshot(BeforeCheckpoint);
Amazon.Lambda.Core.SnapshotRestore.RegisterAfterRestore(AfterCheckpoint);
```
Ketika beberapa jenis hook terdaftar, urutan Lambda mengeksekusi kait runtime Anda ditentukan oleh urutan pendaftaran:
+ `RegisterBeforeSnapshot()`: Dieksekusi dalam urutan terbalik pendaftaran
+ `RegisterAfterSnapshot()`: Dieksekusi dalam urutan pendaftaran
**catatan**
Saat Lambda membuat snapshot, kode inisialisasi Anda dapat berjalan hingga 15 menit. Batas waktu adalah 130 detik atau batas [waktu fungsi yang dikonfigurasi](configuration-timeout.md) (maksimum 900 detik), mana yang lebih tinggi. Kait `RegisterBeforeSnapshot()` runtime Anda dihitung terhadap batas waktu kode inisialisasi. Saat Lambda mengembalikan snapshot, runtime harus dimuat dan kait runtime harus selesai dalam batas `RegisterAfterSnapshot()` waktu tunggu (10 detik). Jika tidak, Anda akan mendapatkan SnapStartTimeoutException.
## Contoh
Contoh fungsi berikut menunjukkan bagaimana menjalankan kode sebelum checkpointing (`RegisterBeforeSnapshot`) dan setelah restoring (). `RegisterAfterRestore`
```
public class SampleClass
{
public SampleClass()
{
Amazon.Lambda.Core.SnapshotRestore.RegisterBeforeSnapshot(BeforeCheckpoint);
Amazon.Lambda.Core.SnapshotRestore.RegisterAfterRestore(AfterCheckpoint);
}
private ValueTask BeforeCheckpoint()
{
// Add logic to be executed before taking the snapshot
return ValueTask.CompletedTask;
}
private ValueTask AfterCheckpoint()
{
// Add logic to be executed after restoring the snapshot
return ValueTask.CompletedTask;
}
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
// Add business logic
return new APIGatewayProxyResponse
{
StatusCode = 200
};
}
}
```