Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Membangun fungsi Lambda dengan Java
com.amazonaws
aws-lambda-java-core
1.2.2
com.amazonaws
aws-lambda-java-events
3.11.1
com.amazonaws
aws-lambda-java-log4j2
1.5.1
```
------
**penting**
Jangan gunakan komponen pribadi dari JDK API, seperti bidang pribadi, metode, atau kelas. Komponen API non-publik dapat berubah atau dihapus dalam pembaruan apa pun, menyebabkan aplikasi Anda rusak.
**Untuk membuat fungsi Java**
1. Buka [Konsol Lambda](https://console.aws.amazon.com/lambda).
1. Pilih **Buat fungsi**.
1. Konfigurasikan pengaturan berikut:
+ **Nama fungsi**: Masukkan nama untuk fungsi tersebut.
+ **Runtime**: Pilih **Java 25**.
1. Pilih **Buat fungsi**.
Konsol membuat fungsi Lambda dengan kelas handler bernama `Hello`. Karena Java adalah bahasa kompilasi, Anda tidak dapat melihat atau mengedit kode sumber di konsol Lambda, tetapi Anda dapat memodifikasi konfigurasinya, memanggilnya, dan mengonfigurasi pemicu.
**catatan**
Untuk memulai pengembangan aplikasi di lingkungan lokal Anda, gunakan salah satu [contoh aplikasi](java-samples.md) yang tersedia di GitHub repositori panduan ini.
Kelas `Hello` memiliki fungsi bernama `handleRequest` yang mengambil objek peristiwa dan objek konteks. Ini adalah [fungsi handler](java-handler.md) yang dipanggil Lambda saat fungsi tersebut dipanggil. Runtime fungsi Java mendapatkan peristiwa invokasi dari Lambda dan menyampaikannya ke handler. Dalam konfigurasi fungsi, nilai handler adalah `example.Hello::handleRequest`.
Untuk memperbarui kode fungsi, Anda membuat paket deployment, yang merupakan arsip file .zip yang berisi kode fungsi Anda. Seiring kemajuan pengembangan fungsi, Anda perlu menyimpan kode fungsi Anda dalam kontrol sumber, menambahkan pustaka, dan mengotomatiskan deployment. Mulai dengan [membuat paket deployment](java-package.md) dan memperbarui kode Anda di baris perintah.
Runtime fungsi melewati objek konteks ke handler, selain peristiwa invokasi. [Objek konteks](java-context.md) berisi informasi tambahan tentang lingkungan invokasi, fungsi, dan eksekusi. Informasi selengkapnya tersedia dari variabel lingkungan.
Fungsi Lambda Anda dilengkapi dengan grup CloudWatch log Log. Runtime fungsi mengirimkan detail tentang setiap invokasi ke CloudWatch Logs. Detail tersebut menyampaikan [log yang dihasilkan fungsi Anda](java-logging.md) selama invokasi. Jika fungsi mengembalikan kesalahan, Lambda memformat kesalahan dan mengembalikannya ke pemanggil.
**Topics**
+ [Tentukan penangan fungsi Lambda di Java](java-handler.md)
+ [Deploy fungsi Java Lambda dengan arsip file .zip atau JAR](java-package.md)
+ [Deploy fungsi Java Lambda dengan gambar kontainer](java-image.md)
+ [Bekerja dengan lapisan untuk fungsi Java Lambda](java-layers.md)
+ [Kustomisasi serialisasi untuk fungsi Lambda Java](java-custom-serialization.md)
+ [Kustomisasi perilaku startup runtime Java untuk fungsi Lambda](java-customization.md)
+ [Menggunakan objek konteks Lambda untuk mengambil informasi fungsi Java](java-context.md)
+ [Log dan pantau fungsi Java Lambda](java-logging.md)
+ [Menginstrumentasi kode Java di AWS Lambda](java-tracing.md)
+ [Contoh aplikasi Java untuk AWS Lambda](java-samples.md)
# Tentukan penangan fungsi Lambda di Java
└ 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 ini`OrderHandler.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
{
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.java`File 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 adalah`src/main/java/example`.
+ `import`pernyataan: 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](#java-handler-signatures).
+ `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](lambda-runtime-environment.md#runtimes-lifecycle-ib).
+ `public record Order ...`: Tentukan bentuk peristiwa input yang diharapkan dalam [catatan](https://openjdk.org/jeps/395) 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
4.0.0
com.example
example-java
jar
1.0-SNAPSHOT
example-java-function
UTF-8
21
21
com.amazonaws
aws-lambda-java-core
1.2.3
software.amazon.awssdk
s3
2.28.29
org.slf4j
slf4j-nop
2.0.16
maven-surefire-plugin
3.5.2
org.apache.maven.plugins
maven-shade-plugin
3.4.1
false
*:*
META-INF/*
META-INF/versions/**
package
shade
org.apache.maven.plugins
maven-compiler-plugin
3.13.0
21
```
------
Agar fungsi ini berfungsi dengan baik, [peran pelaksanaannya](lambda-intro-execution-role.md) 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](lambda-runtime-environment.md#cold-start-latency). Pemanggilan selanjutnya harus berjalan lebih cepat karena penggunaan kembali lingkungan eksekusi.
## Definisi kelas yang valid untuk penangan Java
`. Tipe input adalah `Order` catatan yang kita definisikan di dalam kelas, dan tipe outputnya adalah`String`.
```
public class OrderHandler implements RequestHandler {
...
}
```
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](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-basic/src/main/java/example/HandlerStream.java).
Jika Anda bekerja hanya dengan tipe dasar dan generik (yaitu`String`,, `Integer``List`, atau`Map`) dalam fungsi Java Anda, Anda tidak perlu mengimplementasikan antarmuka. Misalnya, jika fungsi Anda mengambil `Map` input dan mengembalikan a`String`, definisi kelas dan tanda tangan handler Anda mungkin terlihat seperti berikut:
```
public class ExampleHandler {
public String handleRequest(Map input, Context context) {
...
}
}
```
Selain itu, ketika Anda tidak menerapkan antarmuka, objek [konteks](java-context.md) adalah opsional. Misalnya, definisi kelas dan tanda tangan handler Anda mungkin terlihat seperti berikut:
```
public class NoContextHandler {
public String handleRequest(Map input) {
...
}
}
```
## Konvensi penamaan handler
*. **- 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:
+ **. **:: ** — Misalnya,`example.Handler::mainHandler`.
## Mendefinisikan dan mengakses objek peristiwa masukan
`, `List`, `List`, 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-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events)perpustakaan. Misalnya, jika fungsi Lambda Anda dipanggil oleh Amazon Simple Queue Service (SQS), gunakan objek sebagai input. `SQSEvent`
## Mengakses dan menggunakan objek konteks Lambda
` bagian Anda: `pom.xml`
```
software.amazon.awssdk
s3
2.28.29
```
**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
com.amazonaws
aws-lambda-java-core
1.2.2
com.amazonaws
aws-lambda-java-events
3.11.1
com.amazonaws
aws-lambda-java-log4j2
1.5.1
```
------
Untuk membuat paket deployment, kompilasikan kode fungsi dan dependensi Anda menjadi file .zip atau Java Archive (JAR). Untuk Gradle, [gunakan tipe build `Zip`](#java-package-gradle). Untuk Apache Maven, [gunakan plugin Maven Shade](#java-package-maven). Untuk mengunggah paket penerapan Anda, gunakan konsol Lambda, API Lambda, atau (). AWS Serverless Application Model AWS SAM
**catatan**
Agar ukuran paket deployment Anda tetap kecil, kemas dependensi fungsi Anda dalam lapisan. Lapisan memungkinkan Anda mengelola dependensi secara mandiri, dapat digunakan oleh beberapa fungsi, dan dapat dibagikan ke akun lain. Untuk informasi selengkapnya, lihat [Mengelola dependensi Lambda dengan lapisan](chapter-layers.md).
## Membangun paket deployment dengan Gradle
org.apache.maven.plugins
maven-shade-plugin
3.2.2
false
package
shade
```
Untuk membuat paket deployment, gunakan perintah `mvn package`.
```
[INFO] Scanning for projects...
[INFO] -----------------------< com.example:java-maven >-----------------------
[INFO] Building java-maven-function 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
...
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ java-maven ---
[INFO] Building jar: target/java-maven-1.0-SNAPSHOT.jar
[INFO]
[INFO] --- maven-shade-plugin:3.2.2:shade (default) @ java-maven ---
[INFO] Including com.amazonaws:aws-lambda-java-core:jar:1.2.2 in the shaded jar.
[INFO] Including com.amazonaws:aws-lambda-java-events:jar:3.11.1 in the shaded jar.
[INFO] Including joda-time:joda-time:jar:2.6 in the shaded jar.
[INFO] Including com.google.code.gson:gson:jar:2.8.6 in the shaded jar.
[INFO] Replacing original artifact with shaded artifact.
[INFO] Replacing target/java-maven-1.0-SNAPSHOT.jar with target/java-maven-1.0-SNAPSHOT-shaded.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 8.321 s
[INFO] Finished at: 2020-03-03T09:07:19Z
[INFO] ------------------------------------------------------------------------
```
Perintah ini menghasilkan file JAR dalam direktori `target`.
**catatan**
Jika Anda bekerja dengan JAR [multi-rilis (MRJAR)](https://openjdk.org/jeps/238), Anda harus menyertakan MRJAR (yaitu JAR berbayang yang dihasilkan oleh plugin Maven Shade) di `lib` direktori dan zip sebelum mengunggah paket penerapan Anda ke Lambda. Jika tidak, Lambda mungkin tidak membongkar file JAR Anda dengan benar, menyebabkan `MANIFEST.MF` file Anda diabaikan.
Jika Anda menggunakan pustaka appender (`aws-lambda-java-log4j2`), Anda juga harus mengonfigurasi trafo untuk plugin Maven Shade. Pustaka trafo menggabungkan versi file cache yang muncul di pustaka appender dan Log4j.
**Example pom.xml – Konfigurasi plugin dengan appender Log4j 2**
```
org.apache.maven.plugins
maven-shade-plugin
3.2.2
false
package
shade
com.github.edwgiz
maven-shade-plugin.log4j2-cachefile-transformer
2.13.0
```
## Mengunggah paket penerapan dengan konsol Lambda
{
public String handleRequest(Object input, Context context) {
return "Hello world!";
}
}
```
1. Buka file `build.gradle`. Jika Anda menggunakan kode fungsi sampel dari langkah sebelumnya, ganti isinya `build.gradle` dengan yang berikut ini. Jika Anda menggunakan kode fungsi Anda sendiri, ubah `build.gradle` file Anda sesuai kebutuhan.
**Example build.gradle (Groovy DSL)**
```
plugins {
id 'java'
}
group 'com.example'
version '1.0-SNAPSHOT'
sourceCompatibility = 1.8
repositories {
mavenCentral()
}
dependencies {
implementation 'com.amazonaws:aws-lambda-java-core:1.2.1'
}
jar {
manifest {
attributes 'Main-Class': 'com.example.App'
}
}
```
1. `gradle init`Perintah dari langkah 2 juga menghasilkan kasus uji dummy di `app/test` direktori. Untuk keperluan tutorial ini, lewati tes yang sedang berjalan dengan menghapus `/test` direktori.
1. Bangun proyek.
```
gradle build
```
1. Di direktori root proyek (`/example`), buat Dockerfile dengan konfigurasi berikut:
+ Mengatur `FROM` properti ke [URI dari gambar dasar](https://gallery.ecr.aws/lambda/java).
+ Gunakan perintah COPY untuk menyalin kode fungsi dan dependensi runtime ke`{LAMBDA_TASK_ROOT}`, variabel lingkungan yang ditentukan [Lambda](configuration-envvars.md#configuration-envvars-runtime).
+ Atur `CMD` argumen ke penangan fungsi Lambda.
Perhatikan bahwa contoh Dockerfile tidak menyertakan instruksi [USER](https://docs.docker.com/reference/dockerfile/#user). Saat Anda menyebarkan gambar kontainer ke Lambda, Lambda secara otomatis mendefinisikan pengguna Linux default dengan izin yang paling tidak memiliki hak istimewa. Ini berbeda dari perilaku Docker standar yang default ke `root` pengguna ketika tidak ada `USER` instruksi yang diberikan.
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/java:21
# Copy function code and runtime dependencies from Gradle layout
COPY app/build/classes/java/main ${LAMBDA_TASK_ROOT}
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "com.example.App::handleRequest" ]
```
1. Buat image Docker dengan perintah [docker](https://docs.docker.com/engine/reference/commandline/build/) build. Contoh berikut menamai gambar `docker-image` dan memberinya `test` [tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Untuk membuat gambar Anda kompatibel dengan Lambda, Anda harus menggunakan opsi. `--provenance=false`
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**catatan**
Perintah menentukan `--platform linux/amd64` opsi untuk memastikan bahwa container Anda kompatibel dengan lingkungan eksekusi Lambda terlepas dari arsitektur mesin build Anda. Jika Anda berniat untuk membuat fungsi Lambda menggunakan arsitektur set ARM64 instruksi, pastikan untuk mengubah perintah untuk menggunakan `--platform linux/arm64` opsi sebagai gantinya.
------
### (Opsional) Uji gambar secara lokal
` dengan `repositoryUri` yang Anda salin. Pastikan untuk menyertakan `:latest` di akhir URI.
```
docker tag docker-image:test :latest
```
Contoh:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Jalankan perintah [docker push](https://docs.docker.com/engine/reference/commandline/push/) untuk menyebarkan gambar lokal Anda ke repositori Amazon ECR. Pastikan untuk menyertakan `:latest` di akhir URI repositori.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Buat peran eksekusi](lambda-intro-execution-role.md#permissions-executionrole-api) untuk fungsi tersebut, jika Anda belum memilikinya. Anda memerlukan Nama Sumber Daya Amazon (ARN) dari peran tersebut di langkah berikutnya.
1. Buat fungsi Lambda. Untuk`ImageUri`, tentukan URI repositori dari sebelumnya. Pastikan untuk menyertakan `:latest` di akhir URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**catatan**
Anda dapat membuat fungsi menggunakan gambar di AWS akun yang berbeda, selama gambar berada di Wilayah yang sama dengan fungsi Lambda. Untuk informasi selengkapnya, lihat [Izin lintas akun Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Memanggil fungsi.
```
aws lambda invoke --function-name hello-world response.json
```
Anda akan melihat tanggapan seperti ini:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Untuk melihat output dari fungsi, periksa `response.json` file.
Untuk memperbarui kode fungsi, Anda harus membangun gambar lagi, mengunggah gambar baru ke repositori Amazon ECR, dan kemudian menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah untuk menyebarkan gambar ke fungsi Lambda.
Lambda menyelesaikan tag gambar ke intisari gambar tertentu. Ini berarti bahwa jika Anda mengarahkan tag gambar yang digunakan untuk menyebarkan fungsi ke gambar baru di Amazon ECR, Lambda tidak secara otomatis memperbarui fungsi untuk menggunakan gambar baru.
Untuk menyebarkan gambar baru ke fungsi Lambda yang sama, Anda harus menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah, meskipun tag gambar di Amazon ECR tetap sama. Dalam contoh berikut, `--publish` opsi membuat versi baru dari fungsi menggunakan gambar kontainer yang diperbarui.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Menggunakan gambar dasar alternatif dengan klien antarmuka runtime
com.amazonaws
aws-lambda-java-runtime-interface-client
2.3.2
```
Untuk detail paket, lihat [AWS Lambda Java Runtime Interface Client](https://mvnrepository.com/artifact/com.amazonaws/aws-lambda-java-runtime-interface-client) di Maven Central Repository. Anda juga dapat meninjau kode sumber klien antarmuka runtime di repositori [AWS Lambda Java Support Libraries](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-runtime-interface-client) GitHub .
Contoh berikut menunjukkan cara membangun image container untuk Java menggunakan image [Amazon Corretto](https://gallery.ecr.aws/amazoncorretto/amazoncorretto). Amazon Corretto adalah distribusi tanpa biaya, multiplatform, siap produksi dari Open Java Development Kit (OpenJDK). Proyek Maven menyertakan klien antarmuka runtime sebagai dependensi.
### Prasyarat
4.0.0
example
hello-lambda
jar
1.0-SNAPSHOT
hello-lambda
http://maven.apache.org
1.8
1.8
com.amazonaws
aws-lambda-java-runtime-interface-client
2.3.2
org.apache.maven.plugins
maven-dependency-plugin
3.1.2
copy-dependencies
package
copy-dependencies
```
1. Buka `myapp/src/main/java/com/example/myapp` direktori, dan temukan `App.java` filenya. Ini adalah kode untuk fungsi Lambda. Ganti kode dengan yang berikut ini.
**Example fungsi handler**
```
package example;
public class App {
public static String sayHello() {
return "Hello world!";
}
}
```
1. `mvn -B archetype:generate`Perintah dari langkah 1 juga menghasilkan kasus uji dummy di `src/test` direktori. Untuk keperluan tutorial ini, lewati tes yang sedang berjalan dengan menghapus seluruh `/test` direktori yang dihasilkan ini.
1. Arahkan kembali ke direktori root proyek, lalu buat Dockerfile baru. Contoh berikut Dockerfile menggunakan gambar Amazon [Corretto](https://gallery.ecr.aws/amazoncorretto/amazoncorretto). Amazon Corretto adalah distribusi OpenJDK tanpa biaya, multiplatform, dan siap produksi.
+ Atur properti `FROM` untuk URI dari gambar dasar.
+ Atur `ENTRYPOINT` ke modul yang Anda inginkan untuk menjalankan wadah Docker saat dimulai. Dalam hal ini, modul adalah klien antarmuka runtime.
+ Atur `CMD` argumen ke penangan fungsi Lambda.
Perhatikan bahwa contoh Dockerfile tidak menyertakan instruksi [USER](https://docs.docker.com/reference/dockerfile/#user). Saat Anda menyebarkan gambar kontainer ke Lambda, Lambda secara otomatis mendefinisikan pengguna Linux default dengan izin yang paling tidak memiliki hak istimewa. Ini berbeda dari perilaku Docker standar yang default ke `root` pengguna ketika tidak ada `USER` instruksi yang diberikan.
**Example Dockerfile**
```
FROM public.ecr.aws/amazoncorretto/amazoncorretto:21 as base
# Configure the build environment
FROM base as build
RUN yum install -y maven
WORKDIR /src
# Cache and copy dependencies
ADD pom.xml .
RUN mvn dependency:go-offline dependency:copy-dependencies
# Compile the function
ADD . .
RUN mvn package
# Copy the function artifact and dependencies onto a clean base
FROM base
WORKDIR /function
COPY --from=build /src/target/dependency/*.jar ./
COPY --from=build /src/target/*.jar ./
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "/usr/bin/java", "-cp", "./*", "com.amazonaws.services.lambda.runtime.api.client.AWSLambda" ]
# Pass the name of the function handler as an argument to the runtime
CMD [ "example.App::sayHello" ]
```
1. Buat image Docker dengan perintah [docker](https://docs.docker.com/engine/reference/commandline/build/) build. Contoh berikut menamai gambar `docker-image` dan memberinya `test` [tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Untuk membuat gambar Anda kompatibel dengan Lambda, Anda harus menggunakan opsi. `--provenance=false`
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**catatan**
Perintah menentukan `--platform linux/amd64` opsi untuk memastikan bahwa container Anda kompatibel dengan lingkungan eksekusi Lambda terlepas dari arsitektur mesin build Anda. Jika Anda berniat untuk membuat fungsi Lambda menggunakan arsitektur set ARM64 instruksi, pastikan untuk mengubah perintah untuk menggunakan `--platform linux/arm64` opsi sebagai gantinya.
### (Opsional) Uji gambar secara lokal
` dengan `repositoryUri` yang Anda salin. Pastikan untuk menyertakan `:latest` di akhir URI.
```
docker tag docker-image:test :latest
```
Contoh:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Jalankan perintah [docker push](https://docs.docker.com/engine/reference/commandline/push/) untuk menyebarkan gambar lokal Anda ke repositori Amazon ECR. Pastikan untuk menyertakan `:latest` di akhir URI repositori.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Buat peran eksekusi](lambda-intro-execution-role.md#permissions-executionrole-api) untuk fungsi tersebut, jika Anda belum memilikinya. Anda memerlukan Nama Sumber Daya Amazon (ARN) dari peran tersebut di langkah berikutnya.
1. Buat fungsi Lambda. Untuk`ImageUri`, tentukan URI repositori dari sebelumnya. Pastikan untuk menyertakan `:latest` di akhir URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**catatan**
Anda dapat membuat fungsi menggunakan gambar di AWS akun yang berbeda, selama gambar berada di Wilayah yang sama dengan fungsi Lambda. Untuk informasi selengkapnya, lihat [Izin lintas akun Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Memanggil fungsi.
```
aws lambda invoke --function-name hello-world response.json
```
Anda akan melihat tanggapan seperti ini:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Untuk melihat output dari fungsi, periksa `response.json` file.
Untuk memperbarui kode fungsi, Anda harus membangun gambar lagi, mengunggah gambar baru ke repositori Amazon ECR, dan kemudian menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah untuk menyebarkan gambar ke fungsi Lambda.
Lambda menyelesaikan tag gambar ke intisari gambar tertentu. Ini berarti bahwa jika Anda mengarahkan tag gambar yang digunakan untuk menyebarkan fungsi ke gambar baru di Amazon ECR, Lambda tidak secara otomatis memperbarui fungsi untuk menggunakan gambar baru.
Untuk menyebarkan gambar baru ke fungsi Lambda yang sama, Anda harus menggunakan [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)perintah, meskipun tag gambar di Amazon ECR tetap sama. Dalam contoh berikut, `--publish` opsi membuat versi baru dari fungsi menggunakan gambar kontainer yang diperbarui.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
# Bekerja dengan lapisan untuk fungsi Java Lambda
`Bagian ini menggunakan [maven-dependency-plugin](https://mvnrepository.com/artifact/org.apache.maven.plugins/maven-dependency-plugin)untuk membuat file JAR terpisah untuk setiap dependensi alih-alih menggabungkannya ke dalam satu uber-jar. Jika Anda ingin membuat uber-jar, gunakan. [maven-shade-plugin](https://maven.apache.org/plugins/maven-shade-plugin/)
**Example pom.xml**
```
com.fasterxml.jackson.core
jackson-databind
2.17.0
org.apache.maven.plugins
maven-compiler-plugin
3.13.0
21
21
21
org.apache.maven.plugins
maven-dependency-plugin
3.6.1
copy-dependencies
package
copy-dependencies
${project.build.directory}/lib
```
1. Bangun proyek. Perintah ini menciptakan semua file JAR ketergantungan dalam `target/lib/` direktori.
```
mvn clean package
```
1. Buat struktur direktori yang diperlukan untuk layer Anda:
```
mkdir -p java/lib
```
1. Salin file JAR ketergantungan ke `java/lib` direktori:
```
cp target/lib/*.jar java/lib/
```
1. Zip konten lapisan:
------
#### [ Linux/macOS ]
```
zip -r layer.zip java/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\java -DestinationPath .\layer.zip
```
------
Struktur direktori file.zip Anda akan terlihat seperti ini:
```
java/
└── lib/
├── jackson-databind-2.17.0.jar
├── jackson-core-2.17.0.jar
└── jackson-annotations-2.17.0.jar
```
**catatan**
Pastikan file.zip Anda menyertakan `java` direktori di tingkat root dengan `lib` di dalamnya. Struktur ini memastikan bahwa Lambda dapat menemukan dan mengimpor pustaka Anda. Setiap dependensi disimpan sebagai file JAR terpisah daripada dibundel ke dalam uber-jar.
## Buat layer di Lambda
, Void>{
@Override
public Void handleRequest(Map event, Context context)
{
LambdaLogger logger = context.getLogger();
logger.log("EVENT TYPE: " + event.getClass());
return null;
}
}
```
Fungsi mencatat jenis kelas dari acara yang masuk sebelum kembali`null`.
**Example output log**
```
EVENT TYPE: class java.util.LinkedHashMap
```
Antarmuka untuk objek konteks tersedia di [aws-lambda-java-core](https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-core)perpustakaan. Anda dapat menerapkan antarmuka ini untuk membuat kelas konteks untuk pengujian. Contoh berikut menunjukkan kelas konteks yang mengembalikan nilai tiruan untuk sebagian besar properti dan logger uji kerja.
**Example [src/test/java/example/TestContext.jawa](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-basic/src/test/java/example/TestContext.java)**
```
package example;
import [com.amazonaws.services.lambda.runtime.Context](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/Context.java);
import [com.amazonaws.services.lambda.runtime.CognitoIdentity](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/CognitoIdentity.java);
import [com.amazonaws.services.lambda.runtime.ClientContext](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/ClientContext.java);
import [com.amazonaws.services.lambda.runtime.LambdaLogger](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/LambdaLogger.java);
public class TestContext implements Context{
public TestContext() {}
public String getAwsRequestId(){
return new String("495b12a8-xmpl-4eca-8168-160484189f99");
}
public String getLogGroupName(){
return new String("/aws/lambda/my-function");
}
public String getLogStreamName(){
return new String("2020/02/26/[$LATEST]704f8dxmpla04097b9134246b8438f1a");
}
public String getFunctionName(){
return new String("my-function");
}
public String getFunctionVersion(){
return new String("$LATEST");
}
public String getInvokedFunctionArn(){
return new String("arn:aws:lambda:us-east-2:123456789012:function:my-function");
}
public CognitoIdentity getIdentity(){
return null;
}
public ClientContext getClientContext(){
return null;
}
public int getRemainingTimeInMillis(){
return 300000;
}
public int getMemoryLimitInMB(){
return 512;
}
public LambdaLogger getLogger(){
return new TestLogger();
}
}
```
Untuk informasi lebih lanjut tentang log, lihat [Log dan pantau fungsi Java Lambda](java-logging.md).
## Konteks dalam aplikasi sampel
{
Gson gson = new GsonBuilder().setPrettyPrinting().create();
@Override
public String handleRequest(Object event, Context context)
{
LambdaLogger logger = context.getLogger();
String response = new String("SUCCESS");
// log execution details
logger.log("ENVIRONMENT VARIABLES: " + gson.toJson(System.getenv()));
logger.log("CONTEXT: " + gson.toJson(context));
// process event
logger.log("EVENT: " + gson.toJson(event));
return response;
}
}
```
**Example format log**
```
START RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Version: $LATEST
ENVIRONMENT VARIABLES:
{
"_HANDLER": "example.Handler",
"AWS_EXECUTION_ENV": "AWS_Lambda_java8",
"AWS_LAMBDA_FUNCTION_MEMORY_SIZE": "512",
...
}
CONTEXT:
{
"memoryLimit": 512,
"awsRequestId": "6bc28136-xmpl-4365-b021-0ce6b2e64ab0",
"functionName": "java-console",
...
}
EVENT:
{
"records": [
{
"messageId": "19dd0b57-xmpl-4ac1-bd88-01bbb068cb78",
"receiptHandle": "MessageReceiptHandle",
"body": "Hello from SQS!",
...
}
]
}
END RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0
REPORT RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Duration: 198.50 ms Billed Duration: 724 ms Memory Size: 512 MB Max Memory Used: 90 MB Init Duration: 524.75 ms
```
Runtime Java mencatat baris `START`, `END`, dan `REPORT` untuk setiap invokasi. Baris laporan memberikan detail berikut:
**Laporkan bidang data baris**
+ **RequestId** – ID permintaan unik untuk invokasi.
+ **Durasi** – Jumlah waktu yang digunakan oleh metode handler fungsi Anda gunakan untuk memproses peristiwa.
+ **Durasi yang Ditagih** – Jumlah waktu yang ditagihkan untuk invokasi.
+ **Ukuran Memori** – Jumlah memori yang dialokasikan untuk fungsi.
+ **Memori Maks yang Digunakan** – Jumlah memori yang digunakan oleh fungsi. Saat pemanggilan berbagi lingkungan eksekusi, Lambda melaporkan memori maksimum yang digunakan di semua pemanggilan. Perilaku ini dapat menghasilkan nilai yang dilaporkan lebih tinggi dari yang diharapkan.
+ **Durasi Init** – Untuk permintaan pertama yang dilayani, lama waktu yang diperlukan runtime untuk memuat fungsi dan menjalankan kode di luar metode handler.
+ **XRAY TraceId** — Untuk permintaan yang dilacak, ID [AWS X-Ray jejak](services-xray.md).
+ **SegmentId** – Untuk permintaan yang dilacak, ID segmen X-Ray.
+ **Diambil Sampel** – Untuk permintaan yang dilacak, hasil pengambilan sampel.
## Menggunakan kontrol logging lanjutan Lambda dengan Java
%d{yyyy-MM-dd HH:mm:ss} %X{AWSRequestId} %-5p %c{1} - %m%n
```
Anda dapat memutuskan bagaimana log Log4j2 Anda dikonfigurasi untuk teks biasa atau output JSON dengan menentukan tata letak di bawah tag dan. `` ``
Dalam contoh ini, dalam mode teks, setiap baris ditambahkan dengan tanggal, waktu, ID permintaan, tingkat log, dan nama kelas. Dalam mode JSON, `` digunakan dengan konfigurasi yang dikirimkan bersama dengan `aws-lambda-java-log4j2` perpustakaan.
SLF4J adalah perpustakaan fasad untuk login dalam kode Java. Dalam kode fungsi Anda, Anda menggunakan pabrik SLF4 J logger untuk mengambil logger dengan metode untuk tingkat log seperti dan. `info()` `warn()` Dalam konfigurasi build, Anda menyertakan library logging dan adaptor SLF4 J di classpath. Dengan mengubah pustaka dalam konfigurasi build, Anda dapat mengubah jenis logger tanpa mengubah kode fungsi. SLF4J diperlukan untuk menangkap log dari SDK for Java.
Dalam contoh kode berikut, kelas handler menggunakan SLF4 J untuk mengambil logger.
**Example [src/main/java/example/HandlerS3.java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-events/src/main/java/example/HandlerS3.java) - Logging dengan SLF4 J**
```
package example;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;
import static org.apache.logging.log4j.CloseableThreadContext.put;
public class HandlerS3 implements RequestHandler{
private static final Logger logger = LoggerFactory.getLogger(HandlerS3.class);
@Override
public String handleRequest(S3Event event, Context context) {
for(var record : event.getRecords()) {
try (var loggingCtx = put("awsRegion", record.getAwsRegion())) {
loggingCtx.put("eventName", record.getEventName());
loggingCtx.put("bucket", record.getS3().getBucket().getName());
loggingCtx.put("key", record.getS3().getObject().getKey());
logger.info("Handling s3 event");
}
}
return "Ok";
}
}
```
Kode ini menghasilkan output log seperti berikut:
**Example format log**
```
{
"timestamp": "2023-11-15T16:56:00.815Z",
"level": "INFO",
"message": "Handling s3 event",
"logger": "example.HandlerS3",
"AWSRequestId": "0bced576-3936-4e5a-9dcd-db9477b77f97",
"awsRegion": "eu-south-1",
"bucket": "java-logging-test-input-bucket",
"eventName": "ObjectCreated:Put",
"key": "test-folder/"
}
```
Konfigurasi build mengambil dependensi runtime pada appender Lambda dan adaptor SLF4 J, dan dependensi implementasi pada Log4j2.
**Example build.gradle – dependensi pencatatan**
```
dependencies {
...
'com.amazonaws:aws-lambda-java-log4j2:[1.6.0,)',
'com.amazonaws:aws-lambda-java-events:[3.11.3,)',
'org.apache.logging.log4j:log4j-layout-template-json:[2.17.1,)',
'org.apache.logging.log4j:log4j-slf4j2-impl:[2.19.0,)',
...
}
```
Saat Anda menjalankan kode Anda secara lokal untuk pengujian, objek konteks dengan logger Lambda tidak tersedia, dan tidak ada ID permintaan untuk appender Lambda untuk digunakan. Misalnya konfigurasi uji, lihat aplikasi sampel di bagian berikutnya.
## Menggunakan alat logging dan pustaka lainnya
```
Jika berhasil, Anda akan melihat tanggapan ini:
```
{"message":"hello world"}
```
1. Untuk mendapatkan log untuk fungsi tersebut, jalankan [log sam](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Untuk informasi selengkapnya, lihat [Bekerja dengan log](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) di *Panduan AWS Serverless Application Model Pengembang*.
```
sam logs --stack-name sam-app
```
Output log terlihat seperti ini:
```
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.095000 INIT_START Runtime Version: java:11.v15 Runtime Version ARN: arn:aws:lambda:eu-central-1::runtime:0a25e3e7a1cc9ce404bc435eeb2ad358d8fa64338e618d0c224fe509403583ca
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.114000 Picked up JAVA_TOOL_OPTIONS: -XX:+TieredCompilation -XX:TieredStopAtLevel=1
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.793000 Transforming org/apache/logging/log4j/core/lookup/JndiLookup (lambdainternal.CustomerClassLoader@1a6c5a9e)
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:35.252000 START RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765 Version: $LATEST
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.531000 {
"_aws": {
"Timestamp": 1675416276051,
"CloudWatchMetrics": [
{
"Namespace": "sam-app-powerools-java",
"Metrics": [
{
"Name": "ColdStart",
"Unit": "Count"
}
],
"Dimensions": [
[
"Service",
"FunctionName"
]
]
}
]
},
"function_request_id": "7fcf1548-d2d4-41cd-a9a8-6ae47c51f765",
"traceId": "Root=1-63dcd2d1-25f90b9d1c753a783547f4dd;Parent=e29684c1be352ce4;Sampled=1",
"FunctionName": "sam-app-HelloWorldFunction-y9Iu1FLJJBGD",
"functionVersion": "$LATEST",
"ColdStart": 1.0,
"Service": "service_undefined",
"logStreamId": "2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81",
"executionEnvironment": "AWS_Lambda_java11"
}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.974000 Feb 03, 2023 9:24:36 AM com.amazonaws.xray.AWSXRayRecorder
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.993000 Feb 03, 2023 9:24:36 AM com.amazonaws.xray.config.DaemonConfiguration
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.993000 INFO: Environment variable AWS_XRAY_DAEMON_ADDRESS is set. Emitting to daemon on address XXXX.XXXX.XXXX.XXXX:2000.
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:37.331000 09:24:37.294 [main] INFO helloworld.App - {"version":null,"resource":"/hello","path":"/hello/","httpMethod":"GET","headers":{"Accept":"*/*","CloudFront-Forwarded-Proto":"https","CloudFront-Is-Desktop-Viewer":"true","CloudFront-Is-Mobile-Viewer":"false","CloudFront-Is-SmartTV-Viewer":"false","CloudFront-Is-Tablet-Viewer":"false","CloudFront-Viewer-ASN":"16509","CloudFront-Viewer-Country":"IE","Host":"XXXX.execute-api.eu-central-1.amazonaws.com","User-Agent":"curl/7.86.0","Via":"2.0 f0300a9921a99446a44423d996042050.cloudfront.net (CloudFront)","X-Amz-Cf-Id":"t9W5ByT11HaY33NM8YioKECn_4eMpNsOMPfEVRczD7T1RdhbtiwV1Q==","X-Amzn-Trace-Id":"Root=1-63dcd2d1-25f90b9d1c753a783547f4dd","X-Forwarded-For":"XX.XXX.XXX.XX, XX.XXX.XXX.XX","X-Forwarded-Port":"443","X-Forwarded-Proto":"https"},"multiValueHeaders":{"Accept":["*/*"],"CloudFront-Forwarded-Proto":["https"],"CloudFront-Is-Desktop-Viewer":["true"],"CloudFront-Is-Mobile-Viewer":["false"],"CloudFront-Is-SmartTV-Viewer":["false"],"CloudFront-Is-Tablet-Viewer":["false"],"CloudFront-Viewer-ASN":["16509"],"CloudFront-Viewer-Country":["IE"],"Host":["XXXX.execute-api.eu-central-1.amazonaws.com"],"User-Agent":["curl/7.86.0"],"Via":["2.0 f0300a9921a99446a44423d996042050.cloudfront.net (CloudFront)"],"X-Amz-Cf-Id":["t9W5ByT11HaY33NM8YioKECn_4eMpNsOMPfEVRczD7T1RdhbtiwV1Q=="],"X-Amzn-Trace-Id":["Root=1-63dcd2d1-25f90b9d1c753a783547f4dd"],"X-Forwarded-For":["XXX, XXX"],"X-Forwarded-Port":["443"],"X-Forwarded-Proto":["https"]},"queryStringParameters":null,"multiValueQueryStringParameters":null,"pathParameters":null,"stageVariables":null,"requestContext":{"accountId":"XXX","stage":"Prod","resourceId":"at73a1","requestId":"ba09ecd2-acf3-40f6-89af-fad32df67597","operationName":null,"identity":{"cognitoIdentityPoolId":null,"accountId":null,"cognitoIdentityId":null,"caller":null,"apiKey":null,"principalOrgId":null,"sourceIp":"54.240.197.236","cognitoAuthenticationType":null,"cognitoAuthenticationProvider":null,"userArn":null,"userAgent":"curl/7.86.0","user":null,"accessKey":null},"resourcePath":"/hello","httpMethod":"GET","apiId":"XXX","path":"/Prod/hello/","authorizer":null},"body":null,"isBase64Encoded":false}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:37.351000 09:24:37.351 [main] INFO helloworld.App - Retrieving https://checkip.amazonaws.com
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.313000 {
"function_request_id": "7fcf1548-d2d4-41cd-a9a8-6ae47c51f765",
"traceId": "Root=1-63dcd2d1-25f90b9d1c753a783547f4dd;Parent=e29684c1be352ce4;Sampled=1",
"xray_trace_id": "1-63dcd2d1-25f90b9d1c753a783547f4dd",
"functionVersion": "$LATEST",
"Service": "service_undefined",
"logStreamId": "2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81",
"executionEnvironment": "AWS_Lambda_java11"
}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.371000 END RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.371000 REPORT RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765 Duration: 4118.98 ms Billed Duration: 5275 ms Memory Size: 512 MB Max Memory Used: 152 MB Init Duration: 1155.47 ms
XRAY TraceId: 1-63dcd2d1-25f90b9d1c753a783547f4dd SegmentId: 3a028fee19b895cb Sampled: true
```
1. Ini adalah titik akhir API publik yang dapat diakses melalui internet. Kami menyarankan Anda menghapus titik akhir setelah pengujian.
```
sam delete
```
### Mengelola retensi log
```
Jika berhasil, Anda akan melihat tanggapan ini:
```
{"message":"hello world"}
```
1. Untuk mendapatkan jejak untuk fungsi tersebut, jalankan [jejak sam](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html).
```
sam traces
```
Output jejak terlihat seperti ini:
```
New XRay Service Graph
Start time: 2025-02-03 14:31:48+01:00
End time: 2025-02-03 14:31:48+01:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-y9Iu1FLJJBGD - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 5.587
Reference Id: 1 - client - sam-app-HelloWorldFunction-y9Iu1FLJJBGD - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 3] at (2025-02-03T14:31:48.500000) with id (1-63dd0cc4-3c869dec72a586875da39777) and duration (5.603s)
- 5.587s - sam-app-HelloWorldFunction-y9Iu1FLJJBGD [HTTP: 200]
- 4.053s - sam-app-HelloWorldFunction-y9Iu1FLJJBGD
- 1.181s - Initialization
- 4.037s - Invocation
- 1.981s - ## handleRequest
- 1.840s - ## getPageContents
- 0.000s - Overhead
```
1. Ini adalah titik akhir API publik yang dapat diakses melalui internet. Kami menyarankan Anda menghapus titik akhir setelah pengujian.
```
sam delete
```
## Menggunakan Powertools untuk AWS Lambda (Java) dan AWS CDK untuk melacak
4.0.0
helloworld
Function
jar
1.0-SNAPSHOT
Function
http://maven.apache.org
11
11
2.17.2
junit
junit
3.8.1
test
software.amazon.lambda
powertools-tracing
1.3.0
software.amazon.lambda
powertools-metrics
1.3.0
software.amazon.lambda
powertools-logging
1.3.0
com.amazonaws
aws-lambda-java-core
1.2.2
com.amazonaws
aws-lambda-java-events
3.11.1
org.codehaus.mojo
aspectj-maven-plugin
1.14.0
${maven.compiler.source}
${maven.compiler.target}
${maven.compiler.target}
software.amazon.lambda
powertools-tracing
software.amazon.lambda
powertools-metrics
software.amazon.lambda
powertools-logging
compile
org.apache.maven.plugins
maven-shade-plugin
3.4.1
package
shade
false
function
com.github.edwgiz
maven-shade-plugin.log4j2-cachefile-transformer
2.15
```
1. Buat `hello-world\app\src\main\resource` direktori dan buat `log4j.xml` untuk konfigurasi log.
```
mkdir -p src/main/resource
cd src/main/resource
touch log4j.xml
```
1. Buka `log4j.xml` dan tambahkan kode berikut.
```
```
1. Buka `App.java` dari `hello-world\app\Function\src\main\java\helloworld` direktori dan ganti kode yang ada dengan kode berikut. Ini adalah kode untuk fungsi Lambda.
```
package helloworld;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import software.amazon.lambda.powertools.logging.Logging;
import software.amazon.lambda.powertools.metrics.Metrics;
import software.amazon.lambda.powertools.tracing.CaptureMode;
import software.amazon.lambda.powertools.tracing.Tracing;
import static software.amazon.lambda.powertools.tracing.CaptureMode.*;
/**
* Handler for requests to Lambda function.
*/
public class App implements RequestHandler {
Logger log = LogManager.getLogger(App.class);
@Logging(logEvent = true)
@Tracing(captureMode = DISABLED)
@Metrics(captureColdStart = true)
public APIGatewayProxyResponseEvent handleRequest(final APIGatewayProxyRequestEvent input, final Context context) {
Map headers = new HashMap<>();
headers.put("Content-Type", "application/json");
headers.put("X-Custom-Header", "application/json");
APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent()
.withHeaders(headers);
try {
final String pageContents = this.getPageContents("https://checkip.amazonaws.com");
String output = String.format("{ \"message\": \"hello world\", \"location\": \"%s\" }", pageContents);
return response
.withStatusCode(200)
.withBody(output);
} catch (IOException e) {
return response
.withBody("{}")
.withStatusCode(500);
}
}
@Tracing(namespace = "getPageContents")
private String getPageContents(String address) throws IOException {
log.info("Retrieving {}", address);
URL url = new URL(address);
try (BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()))) {
return br.lines().collect(Collectors.joining(System.lineSeparator()));
}
}
}
```
1. Buka `HelloWorldStack.java` dari `hello-world\src\main\java\com\myorg` direktori dan ganti kode yang ada dengan kode berikut. Kode ini menggunakan [Lambda Constructor](https://docs.aws.amazon.com/cdk/api/v1/java/aws_cdk.aws_lambda.html) dan [ApiGatewayv2 Constructor](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigatewayv2-readme.html) untuk membuat REST API dan fungsi Lambda.
```
package com.myorg;
import software.amazon.awscdk.*;
import software.amazon.awscdk.services.apigatewayv2.alpha.*;
import software.amazon.awscdk.services.apigatewayv2.integrations.alpha.HttpLambdaIntegration;
import software.amazon.awscdk.services.apigatewayv2.integrations.alpha.HttpLambdaIntegrationProps;
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.FunctionProps;
import software.amazon.awscdk.services.lambda.Runtime;
import software.amazon.awscdk.services.lambda.Tracing;
import software.amazon.awscdk.services.logs.RetentionDays;
import software.amazon.awscdk.services.s3.assets.AssetOptions;
import software.constructs.Construct;
import java.util.Arrays;
import java.util.List;
import static java.util.Collections.singletonList;
import static software.amazon.awscdk.BundlingOutput.ARCHIVED;
public class HelloWorldStack extends Stack {
public HelloWorldStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloWorldStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
List functionPackagingInstructions = Arrays.asList(
"/bin/sh",
"-c",
"cd Function " +
"&& mvn clean install " +
"&& cp /asset-input/Function/target/function.jar /asset-output/"
);
BundlingOptions.Builder builderOptions = BundlingOptions.builder()
.command(functionPackagingInstructions)
.image(Runtime.JAVA_11.getBundlingImage())
.volumes(singletonList(
// Mount local .m2 repo to avoid download all the dependencies again inside the container
DockerVolume.builder()
.hostPath(System.getProperty("user.home") + "/.m2/")
.containerPath("/root/.m2/")
.build()
))
.user("root")
.outputType(ARCHIVED);
Function function = new Function(this, "Function", FunctionProps.builder()
.runtime(Runtime.JAVA_11)
.code(Code.fromAsset("app", AssetOptions.builder()
.bundling(builderOptions
.command(functionPackagingInstructions)
.build())
.build()))
.handler("helloworld.App::handleRequest")
.memorySize(1024)
.tracing(Tracing.ACTIVE)
.timeout(Duration.seconds(10))
.logRetention(RetentionDays.ONE_WEEK)
.build());
HttpApi httpApi = new HttpApi(this, "sample-api", HttpApiProps.builder()
.apiName("sample-api")
.build());
httpApi.addRoutes(AddRoutesOptions.builder()
.path("/")
.methods(singletonList(HttpMethod.GET))
.integration(new HttpLambdaIntegration("function", function, HttpLambdaIntegrationProps.builder()
.payloadFormatVersion(PayloadFormatVersion.VERSION_2_0)
.build()))
.build());
new CfnOutput(this, "HttpApi", CfnOutputProps.builder()
.description("Url for Http Api")
.value(httpApi.getApiEndpoint())
.build());
}
}
```
1. Buka `pom.xml` dari `hello-world` direktori dan ganti kode yang ada dengan kode berikut.
```
4.0.0
com.myorg
hello-world
0.1
UTF-8
2.70.0
[10.0.0,11.0.0)
5.7.1
org.apache.maven.plugins
maven-compiler-plugin
3.8.1
1.8
1.8
org.codehaus.mojo
exec-maven-plugin
3.0.0
com.myorg.HelloWorldApp
software.amazon.awscdk
aws-cdk-lib
${cdk.version}
software.constructs
constructs
${constructs.version}
org.junit.jupiter
junit-jupiter
${junit.version}
test
software.amazon.awscdk
apigatewayv2-alpha
${cdk.version}-alpha.0
software.amazon.awscdk
apigatewayv2-integrations-alpha
${cdk.version}-alpha.0
```
1. Pastikan Anda berada di `hello-world` direktori dan menyebarkan aplikasi Anda.
```
cdk deploy
```
1. Dapatkan URL aplikasi yang digunakan:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`HttpApi`].OutputValue' --output text
```
1. Memanggil titik akhir API:
```
curl -X GET
```
Jika berhasil, Anda akan melihat tanggapan ini:
```
{"message":"hello world"}
```
1. Untuk mendapatkan jejak untuk fungsi tersebut, jalankan [jejak sam](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html).
```
sam traces
```
Output jejak terlihat seperti ini:
```
New XRay Service Graph
Start time: 2025-02-03 14:59:50+00:00
End time: 2025-02-03 14:59:50+00:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.924
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.016
Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 1] at (2025-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
- 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
- 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
- 0.739s - Initialization
- 0.016s - Invocation
- 0.013s - ## lambda_handler
- 0.000s - ## app.hello
- 0.000s - Overhead
```
1. Ini adalah titik akhir API publik yang dapat diakses melalui internet. Kami menyarankan Anda menghapus titik akhir setelah pengujian.
```
cdk destroy
```
## Menggunakan ADOT untuk instrumen fungsi Java Anda