Tentukan penangan fungsi Lambda di Java

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.

Halaman ini menjelaskan cara bekerja dengan penangan fungsi Lambda di Java, termasuk opsi untuk penyiapan proyek, konvensi penamaan, dan praktik terbaik. Halaman ini juga menyertakan contoh fungsi Java Lambda yang mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini di bucket Amazon Simple Storage Service (S3). Untuk informasi tentang cara menerapkan fungsi Anda setelah menulisnya, lihat Deploy fungsi Java Lambda dengan arsip file .zip atau JAR atauDeploy fungsi Java Lambda dengan gambar kontainer.

Menyiapkan proyek handler Java Anda

Saat bekerja dengan fungsi Lambda di Java, prosesnya melibatkan penulisan kode Anda, mengompilasinya, dan menyebarkan artefak yang dikompilasi ke Lambda. Anda dapat menginisialisasi proyek Java Lambda dengan berbagai cara. Misalnya, Anda dapat menggunakan alat seperti Maven Archetype untuk fungsi Lambda, perintah AWS SAM CLI sam init, atau bahkan pengaturan proyek Java standar di IDE pilihan Anda, seperti IntelliJ IDEA atau Visual Studio Code. Atau, Anda dapat membuat struktur file yang diperlukan secara manual.

Proyek fungsi Java Lambda yang khas mengikuti struktur umum ini:

/project-root
    └ src
        └ main
            └ java
                └ example
                    └ OrderHandler.java (contains main handler)
                    └ <other_supporting_classes>
     └ build.gradle OR pom.xml

Anda dapat menggunakan Maven atau Gradle untuk membangun proyek dan mengelola dependensi.

Logika handler utama untuk fungsi Anda berada di file Java di bawah direktori. src/main/java/example Dalam contoh di halaman ini, kami memberi nama file iniOrderHandler.java. Terlepas dari file ini, Anda dapat menyertakan kelas Java tambahan sesuai kebutuhan. Saat menerapkan fungsi Anda ke Lambda, pastikan Anda menentukan kelas Java yang berisi metode pengendali utama yang harus dipanggil Lambda selama pemanggilan.

Contoh kode fungsi Java Lambda

Contoh berikut kode fungsi Java 21 Lambda mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini di bucket Amazon S3.

contoh OrderHandler.javaFungsi Lambda

package example;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.S3Exception;

import java.nio.charset.StandardCharsets;

/**
 * Lambda handler for processing orders and storing receipts in S3.
 */
public class OrderHandler implements RequestHandler<OrderHandler.Order, String> {

    private static final S3Client S3_CLIENT = S3Client.builder().build();

    /**
     * Record to model the input event.
     */
    public record Order(String orderId, double amount, String item) {}

    @Override
    public String handleRequest(Order event, Context context) {
        try {
            // Access environment variables
            String bucketName = System.getenv("RECEIPT_BUCKET");
            if (bucketName == null || bucketName.isEmpty()) {
                throw new IllegalArgumentException("RECEIPT_BUCKET environment variable is not set");
            }

            // Create the receipt content and key destination
            String receiptContent = String.format("OrderID: %s\nAmount: $%.2f\nItem: %s",
                    event.orderId(), event.amount(), event.item());
            String key = "receipts/" + event.orderId() + ".txt";

            // Upload the receipt to S3
            uploadReceiptToS3(bucketName, key, receiptContent);

            context.getLogger().log("Successfully processed order " + event.orderId() +
                    " and stored receipt in S3 bucket " + bucketName);
            return "Success";

        } catch (Exception e) {
            context.getLogger().log("Failed to process order: " + e.getMessage());
            throw new RuntimeException(e);
        }
    }

    private void uploadReceiptToS3(String bucketName, String key, String receiptContent) {
        try {
            PutObjectRequest putObjectRequest = PutObjectRequest.builder()
                    .bucket(bucketName)
                    .key(key)
                    .build();

            // Convert the receipt content to bytes and upload to S3
            S3_CLIENT.putObject(putObjectRequest, RequestBody.fromBytes(receiptContent.getBytes(StandardCharsets.UTF_8)));
        } catch (S3Exception e) {
            throw new RuntimeException("Failed to upload receipt to S3: " + e.awsErrorDetails().errorMessage(), e);
        }
    }
}

OrderHandler.javaFile ini berisi bagian kode berikut:

• package example: Di Java, ini bisa apa saja, tetapi harus sesuai dengan struktur direktori proyek Anda. Di sini, kita gunakan package example karena struktur direktori adalahsrc/main/java/example.

• importpernyataan: Gunakan ini untuk mengimpor kelas Java yang diperlukan oleh fungsi Lambda Anda.

• public class OrderHandler ...: Ini mendefinisikan kelas Java Anda, dan harus menjadi definisi kelas yang valid.

• private static final S3Client S3_CLIENT ...: Ini menginisialisasi klien S3 di luar salah satu metode kelas. Hal ini menyebabkan Lambda menjalankan kode ini selama fase inisialisasi.

• public record Order ...: Tentukan bentuk peristiwa input yang diharapkan dalam catatan Java kustom ini.

• public String handleRequest(Order event, Context context): Ini adalah metode handler utama, yang berisi logika aplikasi utama Anda.

• private void uploadReceiptToS3(...) {}: Ini adalah metode helper yang direferensikan oleh metode handleRequest handler utama.

Contoh build.gradle dan file pom.xml

Berikut build.gradle atau pom.xml file menyertai fungsi ini.

build.gradle

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.amazonaws:aws-lambda-java-core:1.2.3'
    implementation 'software.amazon.awssdk:s3:2.28.29'
    implementation 'org.slf4j:slf4j-nop:2.0.16'
}

task buildZip(type: Zip) {
    from compileJava
    from processResources
    into('lib') {
        from configurations.runtimeClasspath
    }
}

java {
    sourceCompatibility = JavaVersion.VERSION_21
    targetCompatibility = JavaVersion.VERSION_21
}

build.dependsOn buildZip

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>example-java</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>example-java-function</name>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-lambda-java-core</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>
            <version>2.28.29</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>2.0.16</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.5.2</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.4.1</version>
                <configuration>
                    <createDependencyReducedPom>false</createDependencyReducedPom>
                    <filters>
                        <filter>
                            <artifact>*:*</artifact>
                            <excludes>
                                <exclude>META-INF/*</exclude>
                                <exclude>META-INF/versions/**</exclude>
                            </excludes>
                        </filter>
                    </filters>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.13.0</version>
                <configuration>
                    <release>21</release>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Contoh build.gradle dan file pom.xml

Berikut build.gradle atau pom.xml file menyertai fungsi ini.

build.gradle

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.amazonaws:aws-lambda-java-core:1.2.3'
    implementation 'software.amazon.awssdk:s3:2.28.29'
    implementation 'org.slf4j:slf4j-nop:2.0.16'
}

task buildZip(type: Zip) {
    from compileJava
    from processResources
    into('lib') {
        from configurations.runtimeClasspath
    }
}

java {
    sourceCompatibility = JavaVersion.VERSION_21
    targetCompatibility = JavaVersion.VERSION_21
}

build.dependsOn buildZip

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>example-java</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>example-java-function</name>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-lambda-java-core</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>
            <version>2.28.29</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>2.0.16</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.5.2</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.4.1</version>
                <configuration>
                    <createDependencyReducedPom>false</createDependencyReducedPom>
                    <filters>
                        <filter>
                            <artifact>*:*</artifact>
                            <excludes>
                                <exclude>META-INF/*</exclude>
                                <exclude>META-INF/versions/**</exclude>
                            </excludes>
                        </filter>
                    </filters>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.13.0</version>
                <configuration>
                    <release>21</release>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Agar fungsi ini berfungsi dengan baik, peran pelaksanaannya harus memungkinkan s3:PutObject tindakan. Juga, pastikan bahwa Anda mendefinisikan variabel RECEIPT_BUCKET lingkungan. Setelah pemanggilan berhasil, bucket Amazon S3 harus berisi file tanda terima.

catatan

Fungsi ini mungkin memerlukan pengaturan konfigurasi tambahan agar berhasil berjalan tanpa waktu habis. Kami merekomendasikan untuk mengonfigurasi memori 256 MB, dan batas waktu 10 detik. Doa pertama mungkin membutuhkan waktu ekstra karena awal yang dingin. Pemanggilan selanjutnya harus berjalan lebih cepat karena penggunaan kembali lingkungan eksekusi.

Definisi kelas yang valid untuk penangan Java

Untuk menentukan kelas Anda, aws-lambda-java-coreperpustakaan mendefinisikan dua antarmuka untuk metode handler. Gunakan antarmuka yang disediakan untuk menyederhanakan konfigurasi handler dan memvalidasi tanda tangan metode pada waktu kompilasi.

• com.amazonaws.services.lambda.runtime. RequestHandler

• com.amazonaws.services.lambda.runtime. RequestStreamHandler

Antarmuka RequestHandler adalah jenis generik yang mengambil dua parameter: jenis input dan jenis output. Kedua jenis tersebut harus berupa objek. Dalam contoh ini, OrderHandler kelas kami mengimplementasikanRequestHandler<OrderHandler.Order, String>. Tipe input adalah Order catatan yang kita definisikan di dalam kelas, dan tipe outputnya adalahString.

public class OrderHandler implements RequestHandler<OrderHandler.Order, String> {
    ...
}

Saat Anda menggunakan antarmuka ini, runtime Java mendeserialisasi acara ke dalam objek dengan tipe input, dan membuat serial output ke dalam teks. Gunakan antarmuka ini saat serialisasi bawaan bekerja dengan tipe input dan output Anda.

Untuk menggunakan serialisasi Anda sendiri, Anda dapat mengimplementasikan RequestStreamHandler antarmuka. Dengan antarmuka ini, Lambda melewatkan aliran input dan aliran output ke handler Anda. Handler membaca byte dari aliran input, menuliskan aliran output, dan mengembalikan pembatalan. Untuk contoh ini menggunakan runtime Java 21, lihat HandlerStream.java.

Jika Anda bekerja hanya dengan tipe dasar dan generik (yaituString,, Integer=List, atauMap) dalam fungsi Java Anda, Anda tidak perlu mengimplementasikan antarmuka. Misalnya, jika fungsi Anda mengambil Map<String, String> input dan mengembalikan aString, definisi kelas dan tanda tangan handler Anda mungkin terlihat seperti berikut:

public class ExampleHandler {
    public String handleRequest(Map<String, String> input, Context context) {
        ...
    }
}

Selain itu, ketika Anda tidak mengimplementasikan antarmuka, objek konteks adalah opsional. Misalnya, definisi kelas dan tanda tangan handler Anda mungkin terlihat seperti berikut:

public class NoContextHandler {
   public String handleRequest(Map<String, String> input) {
        ...
   }
}

Konvensi penamaan handler

Untuk fungsi Lambda di Java, jika Anda menerapkan salah satu RequestHandler atau RequestStreamHandler antarmuka, metode handler utama Anda harus diberi nama. handleRequest Juga, sertakan @Override tag di atas handleRequest metode Anda. Saat Anda menerapkan fungsi ke Lambda, tentukan pengendali utama dalam konfigurasi fungsi Anda dalam format berikut:

• <package>. <Class>- Sebagai contoh,example.OrderHandler.

Untuk fungsi Lambda di Java yang tidak mengimplementasikan RequestStreamHandler antarmuka RequestHandler atau, Anda dapat menggunakan nama apa pun untuk handler. Saat Anda menerapkan fungsi ke Lambda, tentukan pengendali utama dalam konfigurasi fungsi Anda dalam format berikut:

• <package>. <Class>:: <handler_method_name> — Misalnya,example.Handler::mainHandler.

Mendefinisikan dan mengakses objek peristiwa masukan

JSON adalah format input yang paling umum dan standar untuk fungsi Lambda. Dalam contoh ini, fungsi mengharapkan input yang mirip dengan yang berikut:

{
    "orderId": "12345",
    "amount": 199.99,
    "item": "Wireless Headphones"
}

Saat bekerja dengan fungsi Lambda di Java 17 atau yang lebih baru, Anda dapat menentukan bentuk peristiwa input yang diharapkan sebagai catatan Java. Dalam contoh ini, kita mendefinisikan catatan dalam OrderHandler kelas untuk mewakili Order objek:

public record Order(String orderId, double amount, String item) {}

Catatan ini cocok dengan bentuk input yang diharapkan. Setelah Anda menentukan catatan Anda, Anda dapat menulis tanda tangan handler yang mengambil input JSON yang sesuai dengan definisi rekaman. Runtime Java secara otomatis deserialisasi JSON ini menjadi objek Java. Anda kemudian dapat mengakses bidang objek. Misalnya, event.orderId mengambil nilai dari orderId dari input asli.

catatan

Catatan Java adalah fitur runtime Java 17 dan yang lebih baru saja. Di semua runtime Java, Anda dapat menggunakan kelas untuk mewakili data peristiwa. Dalam kasus seperti itu, Anda dapat menggunakan perpustakaan seperti jackson untuk deserialisasi input JSON.

Jenis acara masukan lainnya

Ada banyak kemungkinan peristiwa input untuk fungsi Lambda di Java:

• Integer, Long, Double, dll. — Peristiwa tersebut merupakan nomor tanpa format tambahan—misalnya, 3.5. Runtime Java mengubah nilai menjadi objek dari tipe yang ditentukan.

• String – Peristiwa tersebut merupakan string JSON, termasuk kutipan—misalnya,“My string”. Runtime mengubah nilai menjadi String objek tanpa tanda kutip.

• List<Integer>, List<String>, List<Object>, dll. – Peristiwa tersebut merupakan larik JSON. Runtime mendeserialisasikannya menjadi objek dengan jenis atau antarmuka yang ditentukan.

• InputStream – Peristiwa adalah segala jenis JSON. Runtime menyampaikan aliran byte dokumen ke handler tanpa modifikasi. Anda mendeserialisasi input dan menuliskan output ke aliran output.

• Jenis pustaka — Untuk acara yang dikirim oleh AWS layanan lain, gunakan tipe di aws-lambda-java-eventsperpustakaan. Misalnya, jika fungsi Lambda Anda dipanggil oleh Amazon Simple Queue Service (SQS), gunakan objek sebagai input. SQSEvent

Mengakses dan menggunakan objek konteks Lambda

Objek konteks Lambda berisi informasi tentang lingkungan pemanggilan, fungsi, dan eksekusi. Dalam contoh ini, objek konteks bertipecom.amazonaws.services.lambda.runtime.Context, dan merupakan argumen kedua dari fungsi pengendali utama.

public String handleRequest(Order event, Context context) {
    ...
}

Jika kelas Anda mengimplementasikan RequestStreamHandlerantarmuka RequestHandleratau, objek konteks adalah argumen yang diperlukan. Jika tidak, objek konteks adalah opsional. Untuk informasi selengkapnya tentang tanda tangan handler yang diterima valid, lihat. Definisi kelas yang valid untuk penangan Java

Jika Anda melakukan panggilan ke layanan lain menggunakan AWS SDK, objek konteks diperlukan di beberapa area utama. Misalnya, untuk menghasilkan log fungsi untuk Amazon CloudWatch, Anda dapat menggunakan context.getLogger() metode untuk mendapatkan LambdaLogger objek untuk logging. Dalam contoh ini, kita dapat menggunakan logger untuk mencatat pesan kesalahan jika pemrosesan gagal karena alasan apa pun:

context.getLogger().log("Failed to process order: " + e.getMessage());

Di luar logging, Anda juga dapat menggunakan objek konteks untuk pemantauan fungsi. Untuk informasi lebih lanjut tentang objek konteks, lihatMenggunakan objek konteks Lambda untuk mengambil informasi fungsi Java.

Menggunakan AWS SDK for Java v2 di handler Anda

Seringkali, Anda akan menggunakan fungsi Lambda untuk berinteraksi dengan atau membuat pembaruan ke sumber daya lain AWS . Cara termudah untuk berinteraksi dengan sumber daya ini adalah dengan menggunakan AWS SDK for Java v2.

catatan

AWS SDK for Java (v1) berada dalam mode pemeliharaan, dan akan end-of-support mencapai pada 31 Desember 2025. Kami menyarankan Anda hanya menggunakan AWS SDK for Java v2 ke depan.

Untuk menambahkan dependensi SDK ke fungsi Anda, tambahkan dependensi SDK di Gradle atau build.gradle pom.xml file untuk Maven. Kami sarankan hanya menambahkan pustaka yang Anda butuhkan untuk fungsi Anda. Dalam contoh kode sebelumnya, kita menggunakan software.amazon.awssdk.services.s3 perpustakaan. Di Gradle, Anda dapat menambahkan dependensi ini dengan menambahkan baris berikut di bagian dependensi: build.gradle

implementation 'software.amazon.awssdk:s3:2.28.29'

Di Maven, tambahkan baris berikut di <dependencies> bagian Anda: pom.xml

    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>s3</artifactId>
        <version>2.28.29</version>
    </dependency>

catatan

Ini mungkin bukan versi SDK terbaru. Pilih versi SDK yang sesuai untuk aplikasi Anda.

Kemudian, impor dependensi langsung di kelas Java Anda:

import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.S3Exception;

Kode contoh kemudian menginisialisasi klien Amazon S3 sebagai berikut:

private static final S3Client S3_CLIENT = S3Client.builder().build();

Dalam contoh ini, kami menginisialisasi klien Amazon S3 kami di luar fungsi pengendali utama untuk menghindari keharusan menginisialisasi setiap kali kami menjalankan fungsi kami. Setelah menginisialisasi klien SDK, Anda dapat menggunakannya untuk berinteraksi dengan layanan lain AWS . Kode contoh memanggil Amazon S3 PutObject API sebagai berikut:

PutObjectRequest putObjectRequest = PutObjectRequest.builder()
    .bucket(bucketName)
    .key(key)
    .build();

// Convert the receipt content to bytes and upload to S3
S3_CLIENT.putObject(putObjectRequest, RequestBody.fromBytes(receiptContent.getBytes(StandardCharsets.UTF_8)));

Mengakses variabel lingkungan

Dalam kode handler Anda, Anda dapat mereferensikan variabel lingkungan apa pun dengan menggunakan System.getenv() metode ini. Dalam contoh ini, kami mereferensikan variabel RECEIPT_BUCKET lingkungan yang ditentukan menggunakan baris kode berikut:

String bucketName = System.getenv("RECEIPT_BUCKET");
if (bucketName == null || bucketName.isEmpty()) {
    throw new IllegalArgumentException("RECEIPT_BUCKET environment variable is not set");
}

Menggunakan status global

Lambda menjalankan kode statis Anda dan konstruktor kelas selama fase inisialisasi sebelum menjalankan fungsi Anda untuk pertama kalinya. Sumber daya yang dibuat selama inisialisasi tetap berada di memori di antara pemanggilan, sehingga Anda dapat menghindari keharusan membuatnya setiap kali Anda menjalankan fungsi Anda.

Dalam kode contoh, kode inisialisasi klien S3 berada di luar metode handler utama. Runtime menginisialisasi klien sebelum fungsi menangani peristiwa pertamanya, yang dapat menyebabkan waktu pemrosesan lebih lama. Peristiwa selanjutnya jauh lebih cepat karena Lambda tidak perlu menginisialisasi klien lagi.

Praktik terbaik kode untuk fungsi Java 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.

• Kontrol dependensi dalam paket penerapan fungsi Anda. Lingkungan AWS Lambda eksekusi berisi sejumlah pustaka. 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. Misalnya, utamakan kerangka kerja injeksi dependensi Java (IoC) yang lebih sederhana seperti Dagger atau Guice, daripada yang lebih kompleks seperti Spring Framework.

• 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 Java, hindari mengunggah seluruh pustaka AWS SDK sebagai bagian dari paket penerapan Anda. Sebaliknya, bergantunglah secara selektif pada modul yang mengambil komponen SDK yang Anda perlukan (mis., DynamoDB, modul SDK Amazon S3, dan pustaka inti Lambda).

• 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.

• 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 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 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? .

• Hindari menggunakan cache DNS Java. Fungsi Lambda sudah menyimpan respons DNS cache. Jika Anda menggunakan cache DNS lain, Anda mungkin mengalami batas waktu koneksi.

  java.util.logging.LoggerKelas secara tidak langsung dapat mengaktifkan cache DNS JVM. Untuk mengganti pengaturan default, setel networkaddress.cache.ttl ke 0 sebelum menginisialisasi. logger Contoh:

  public class MyHandler {
    // first set TTL property
    static{
     java.security.Security.setProperty("networkaddress.cache.ttl" , "0");
    }
   // then instantiate logger
    var logger = org.apache.logging.log4j.LogManager.getLogger(MyHandler.class);
  }

• Kurangi waktu yang dibutuhkan Lambda untuk membuka paket deployment yang ditulis di Java dengan meletakkan file .jar dependensi Anda dalam direktori/lib terpisah. Ini lebih cepat daripada memasukkan semua kode fungsi Anda dalam satu wadah yang berisi sejumlah besar file .class. Lihat Deploy fungsi Java Lambda dengan arsip file .zip atau JAR untuk instruksi.