Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Maksimalkan kinerja Lambda SnapStart
**Topics**
+ [Penyempurnaan performa](#snapstart-tuning)
+ [Praktik terbaik jaringan](#snapstart-networking)
## Penyempurnaan performa
Untuk memaksimalkan manfaat SnapStart, pertimbangkan rekomendasi pengoptimalan kode berikut untuk runtime Anda.
**catatan**
SnapStart bekerja paling baik saat digunakan dengan pemanggilan fungsi dalam skala besar. Fungsi yang jarang dipanggil mungkin tidak mengalami peningkatan kinerja yang sama.
### Java
Untuk memaksimalkan manfaat SnapStart, kami menyarankan Anda memuat dependensi terlebih dahulu dan menginisialisasi sumber daya yang berkontribusi pada latensi startup dalam kode inisialisasi Anda, bukan di penangan fungsi. Ini memindahkan latensi yang terkait dengan pemuatan kelas berat keluar dari jalur pemanggilan, mengoptimalkan kinerja startup dengan. SnapStart
Jika Anda tidak dapat memuat dependensi atau sumber daya selama inisialisasi, sebaiknya Anda memuatnya terlebih dahulu dengan pemanggilan dummy. Untuk melakukan ini, perbarui kode fungsi handler, seperti yang ditunjukkan pada contoh berikut dari [fungsi pet store](https://github.com/awslabs/aws-serverless-java-container/tree/main/samples/spring/pet-store) pada GitHub repositori AWS Labs.
```
private static SpringLambdaContainerHandler handler;
static {
try {
handler = SpringLambdaContainerHandler.getAwsProxyHandler(PetStoreSpringAppConfig.class);
// Use the onStartup method of the handler to register the custom filter
handler.onStartup(servletContext -> {
FilterRegistration.Dynamic registration = servletContext.addFilter("CognitoIdentityFilter", CognitoIdentityFilter.class);
registration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), false, "/*");
});
// Send a fake Amazon API Gateway request to the handler to load classes ahead of time
ApiGatewayRequestIdentity identity = new ApiGatewayRequestIdentity();
identity.setApiKey("foo");
identity.setAccountId("foo");
identity.setAccessKey("foo");
AwsProxyRequestContext reqCtx = new AwsProxyRequestContext();
reqCtx.setPath("/pets");
reqCtx.setStage("default");
reqCtx.setAuthorizer(null);
reqCtx.setIdentity(identity);
AwsProxyRequest req = new AwsProxyRequest();
req.setHttpMethod("GET");
req.setPath("/pets");
req.setBody("");
req.setRequestContext(reqCtx);
Context ctx = new TestContext();
handler.proxy(req, ctx);
} catch (ContainerInitializationException e) {
// if we fail here. We re-throw the exception to force another cold start
e.printStackTrace();
throw new RuntimeException("Could not initialize Spring framework", e);
}
}
```
### Python
Untuk memaksimalkan manfaat SnapStart, fokuslah pada organisasi kode yang efisien dan manajemen sumber daya dalam fungsi Python Anda. [Sebagai pedoman umum, lakukan tugas komputasi berat selama fase inisialisasi.](lambda-runtime-environment.md#runtimes-lifecycle-ib) Pendekatan ini memindahkan operasi yang memakan waktu keluar dari jalur pemanggilan, meningkatkan kinerja fungsi secara keseluruhan. Untuk menerapkan strategi ini secara efektif, kami merekomendasikan praktik terbaik berikut:
+ Impor dependensi di luar fungsi handler.
+ Buat `boto3` instance di luar handler.
+ Inisialisasi sumber daya statis atau konfigurasi sebelum handler dipanggil.
+ Pertimbangkan untuk menggunakan [hook runtime](snapstart-runtime-hooks-python.md) sebelum snapshot untuk tugas intensif sumber daya seperti mengunduh file eksternal, kerangka kerja pra-pemuatan seperti Django, atau memuat model pembelajaran mesin.
**Example — Optimalkan fungsi Python untuk SnapStart**
```
# Import all dependencies outside of Lambda handler
from snapshot_restore_py import register_before_snapshot
import boto3
import pandas
import pydantic
# Create S3 and SSM clients outside of Lambda handler
s3_client = boto3.client("s3")
# Register the function to be called before snapshot
@register_before_snapshot
def download_llm_models():
# Download an object from S3 and save to tmp
# This files will persist in this snapshot
with open('/tmp/FILE_NAME', 'wb') as f:
s3_client.download_fileobj('amzn-s3-demo-bucket', 'OBJECT_NAME', f)
...
def lambda_handler(event, context):
...
```
### .NET
[Untuk mengurangi kompilasi just-in-time (JIT) dan waktu pemuatan perakitan, pertimbangkan untuk menjalankan function handler Anda dari hook runtime. `RegisterBeforeCheckpoint`](snapstart-runtime-hooks-dotnet.md) Karena cara kerja kompilasi berjenjang .NET, Anda akan mendapatkan hasil yang optimal dengan memanggil handler beberapa kali, seperti yang ditunjukkan pada contoh berikut.
**penting**
Pastikan bahwa pemanggilan fungsi dummy Anda tidak menghasilkan efek samping yang tidak diinginkan, seperti memulai transaksi bisnis.
**Example**
```
public class Function
{
public Function()
{
Amazon.Lambda.Core.SnapshotRestore.RegisterBeforeSnapshot(FunctionWarmup);
}
// Warmup method that calls the function handler before snapshot to warm up the .NET code and runtime.
// This speeds up future cold starts after restoring from a snapshot.
private async ValueTask FunctionWarmup()
{
var request = new APIGatewayProxyRequest
{
Path = "/heathcheck",
HttpMethod = "GET"
};
for (var i = 0; i < 10; i++)
{
await FunctionHandler(request, null);
}
}
public async Task FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
//
// Process HTTP request
//
var response = new APIGatewayProxyResponse
{
StatusCode = 200
};
return await Task.FromResult(response);
}
}
```
## Praktik terbaik jaringan
Status koneksi yang ditetapkan fungsi Anda selama fase inisialisasi tidak dijamin saat Lambda melanjutkan fungsi Anda dari snapshot. Dalam kebanyakan kasus, koneksi jaringan yang dibuat AWS SDK secara otomatis dilanjutkan. Untuk koneksi lain, kami merekomendasikan praktik terbaik berikut.
**Membangun kembali koneksi jaringan**
Selalu buat kembali koneksi jaringan Anda saat fungsi Anda dilanjutkan dari snapshot. Kami menyarankan Anda membangun kembali koneksi jaringan di function handler. Atau, Anda dapat menggunakan hook [runtime](snapstart-runtime-hooks.md) setelah pemulihan.
**Jangan gunakan nama host sebagai pengenal lingkungan eksekusi yang unik**
Kami merekomendasikan untuk tidak menggunakan `hostname` untuk mengidentifikasi lingkungan eksekusi Anda sebagai node atau wadah unik dalam aplikasi Anda. Dengan SnapStart, satu snapshot digunakan sebagai status awal untuk beberapa lingkungan eksekusi. Semua lingkungan eksekusi mengembalikan `hostname` nilai yang sama untuk `InetAddress.getLocalHost()` (Java), `socket.gethostname()` (Python), dan `Dns.GetHostName()` (.NET). Untuk aplikasi yang memerlukan identitas atau `hostname` nilai lingkungan eksekusi yang unik, kami sarankan Anda membuat ID unik di pengendali fungsi. Atau, gunakan [hook runtime](snapstart-runtime-hooks.md) setelah pemulihan untuk menghasilkan ID unik, lalu gunakan ID unik sebagai pengenal untuk lingkungan eksekusi.
**Hindari mengikat koneksi ke port sumber tetap**
Kami menyarankan Anda menghindari pengikatan koneksi jaringan ke port sumber tetap. Koneksi dibuat kembali ketika fungsi dilanjutkan dari snapshot, dan koneksi jaringan yang terikat ke port sumber tetap mungkin gagal.
**Hindari menggunakan cache DNS Java**
Fungsi Lambda sudah menyimpan respons DNS cache. Jika Anda menggunakan cache DNS lain SnapStart, Anda mungkin mengalami batas waktu koneksi saat fungsi dilanjutkan dari snapshot.
`java.util.logging.Logger`Kelas secara tidak langsung dapat mengaktifkan cache DNS JVM. Untuk mengganti pengaturan default, setel [networkaddress.cache.ttl](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/net/InetAddress.html#inetaddress-caching-heading) 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);
}
```
Untuk mencegah `UnknownHostException` kegagalan dalam runtime Java 11, kami sarankan pengaturan `networkaddress.cache.negative.ttl` ke 0. Di Java 17 dan runtime yang lebih baru, langkah ini tidak diperlukan. Anda dapat mengatur properti ini untuk fungsi Lambda dengan variabel `AWS_LAMBDA_JAVA_NETWORKADDRESS_CACHE_NEGATIVE_TTL=0` lingkungan.
Menonaktifkan cache DNS JVM tidak menonaktifkan cache DNS terkelola Lambda.