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

Kurangi waktu startup SDK untuk AWS Lambda

Salah satu tujuannya AWS SDK for Java 2.x adalah untuk mengurangi latensi startup untuk AWS Lambda fungsi. SDK berisi perubahan yang mengurangi waktu startup, yang dibahas di akhir topik ini.

Pertama, topik ini berfokus pada perubahan yang dapat Anda lakukan untuk mengurangi waktu mulai dingin. Ini termasuk membuat perubahan dalam struktur kode Anda dan dalam konfigurasi klien layanan.

Gunakan sebuah AWS CRT-based Klien HTTP

Untuk bekerja dengan AWS Lambda, kami merekomendasikan AwsCrtHttpClient untuk skenario sinkron dan skenario asinkron. AwsCrtAsyncHttpClient

Top Konfigurasikan AWS klien HTTP berbasis CRT ik dalam panduan ini menjelaskan manfaat menggunakan klien HTTP, cara menambahkan ketergantungan, dan cara mengonfigurasi penggunaannya oleh klien layanan.

Hapus dependensi klien HTTP yang tidak digunakan

Seiring dengan penggunaan AWS CRT-based klien secara eksplisit, Anda dapat menghapus klien HTTP lain yang dibawa SDK secara default. Waktu startup Lambda berkurang ketika lebih sedikit pustaka yang perlu dimuat, jadi Anda harus menghapus artefak yang tidak digunakan yang perlu dimuat oleh JVM.

Cuplikan berikut dari pom.xml file Maven menunjukkan pengecualian klien Apache-based HTTP dan klien Netty-based HTTP. (Klien ini tidak diperlukan saat Anda menggunakan AWS CRT-based klien.) Contoh ini mengecualikan artefak klien HTTP dari ketergantungan klien S3 dan menambahkan aws-crt-client artefak untuk memungkinkan akses ke klien AWS CRT-based HTTP.

<project>
    <properties>
        <aws.java.sdk.version>2.27.21</aws.java.sdk.version>
    <properties>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>${aws.java.sdk.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>aws-crt-client</artifactId>
        </dependency>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>netty-nio-client</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>apache-client</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
</project>

Konfigurasikan klien layanan untuk pencarian pintasan

Cuplikan kode berikut menunjukkan klien layanan S3 yang dikonfigurasi dengan tepat untuk digunakan di lingkungan Lambda.

S3Client s3Client = S3Client.builder()
    .region(Region.of(System.getenv(SdkSystemSetting.AWS_REGION.environmentVariable())))
    .credentialsProvider(EnvironmentVariableCredentialsProvider.create())
    .httpClient(AwsCrtHttpClient.builder().build())
    .build();

Inisialisasi klien SDK di luar pengendali fungsi Lambda

Sebaiknya inisialisasi klien SDK di luar metode handler Lambda. Dengan cara ini, jika konteks eksekusi digunakan kembali, inisialisasi klien layanan dapat dilewati. Dengan menggunakan kembali instance klien dan koneksinya, pemanggilan berikutnya dari metode handler terjadi lebih cepat.

Dalam contoh berikut, S3Client instance diinisialisasi dalam konstruktor menggunakan metode pabrik statis. Jika wadah yang dikelola oleh lingkungan Lambda digunakan kembali, S3Client instance yang diinisialisasi digunakan kembali.

public class App implements RequestHandler<Object, Object> {
    private final S3Client s3Client;

    public App() {
        s3Client = DependencyFactory.s3Client();
    }

    @Override
    public Object handle Request(final Object input, final Context context) {
         ListBucketResponse response = s3Client.listBuckets();
         // Process the response.
    }
}

Minimalkan injeksi ketergantungan

Kerangka kerja injeksi ketergantungan (DI) mungkin membutuhkan waktu tambahan untuk menyelesaikan proses penyiapan. Mereka mungkin juga memerlukan dependensi tambahan, yang membutuhkan waktu untuk memuat.

Jika kerangka kerja DI diperlukan, kami sarankan menggunakan kerangka kerja DI ringan seperti Dagger.

Gunakan penargetan Archetype Maven AWS Lambda

Tim AWS Java SDK telah mengembangkan template Maven Archetype untuk mem-bootstrap proyek Lambda dengan waktu startup minimal. Anda dapat membangun proyek Maven dari arketipe dan mengetahui bahwa dependensi dikonfigurasi sesuai untuk lingkungan Lambda.

Untuk mempelajari lebih lanjut tentang arketipe dan bekerja melalui contoh penerapan, lihat posting blog ini.

Pertimbangkan Lambda SnapStart untuk Java

Jika persyaratan runtime Anda kompatibel, AWS menawarkan Lambda SnapStart untuk Java. Lambda SnapStart adalah solusi berbasis infrastruktur yang meningkatkan kinerja startup untuk fungsi Java. Ketika Anda menerbitkan versi baru dari suatu fungsi, Lambda meng SnapStart inisialisasi dan mengambil snapshot yang tidak dapat diubah dan terenkripsi dari memori dan status disk. SnapStart kemudian menyimpan snapshot untuk digunakan kembali.

Untuk mendapatkan manfaat startup penuh SnapStart, gunakan SdkWarmUp API untuk menghangatkan semua klien SDK Anda sebelum Lambda mengambil snapshot. Snapshot kemudian menangkap klien yang dihangatkan, sehingga setiap fungsi yang dipulihkan dimulai dengan mereka siap. Untuk informasi selengkapnya, lihat Pertimbangkan untuk menghangatkan klien SDK dengan SdkWarmUp.

Pertimbangkan untuk menghangatkan klien SDK dengan SdkWarmUp

SdkWarmUpAPI di dalam AWS SDK for Java 2.x menghangatkan klien SDK Anda selama inisialisasi aplikasi. Hasilnya, panggilan API layanan pertama Anda lebih cepat. Pemanasan membangun klien dan memanggil operasi untuk menjalankan jalur permintaan SDK. Ini terjadi sebelum aplikasi Anda menangani lalu lintas nyata. Dengan satu panggilan, Anda dapat menghangatkan semua klien SDK di classpath Anda, atau hanya klien tertentu yang digunakan aplikasi Anda.

Anda dapat menggunakan SdkWarmUp API dengan fitur Lambda yang mengurangi cold start, seperti Lambda SnapStart dan konkurensi yang disediakan. Untuk informasi selengkapnya tentang mengkonfigurasi dan menggunakanSdkWarmUp, lihatLakukan pemanasan klien SDK di AWS SDK for Java 2.x.

Versi 2.x perubahan yang memengaruhi waktu startup

Selain perubahan yang Anda buat pada kode Anda, versi 2.x SDK untuk Java menyertakan tiga perubahan utama yang mengurangi waktu startup:

Sumber daya tambahan

Panduan Peng AWS Lambda embang berisi bagian tentang praktik terbaik untuk mengembangkan fungsi Lambda yang tidak spesifik Java.

Untuk contoh membangun aplikasi cloud-native di Java yang menggunakan AWS Lambda, lihat konten lokak arya ini. Diskusi lokakarya optimalisasi kinerja dan praktik terbaik lainnya.

Anda dapat mempertimbangkan untuk menggunakan gambar statis yang dikompilasi sebelumnya untuk mengurangi latensi startup. Misalnya, Anda dapat menggunakan SDK untuk Java 2.x dan Maven untuk membangun image asli GraalVM.