Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Kait SnapStart runtime Lambda untuk Java
<a name="snapstart-runtime-hooks-java"></a>

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 <R extends Resource>`— 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
<a name="runtime-hooks-registration-java"></a>

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
<a name="runtime-hooks-java-update-build"></a>

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
<a name="runtime-hooks-java-update-handler"></a>

*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<? extends Resource> context)
        throws Exception {
      System.out.println("Before checkpoint");
    }
    @Override
    public void afterRestore(org.crac.Context<? extends Resource> 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<? extends Resource> context) throws Exception {
    // ...
   }
   
   @Override
   public void beforeCheckpoint(Context<? extends Resource> 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 );
```