Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Deploy fungsi Java Lambda dengan gambar kontainer
Ada tiga cara untuk membangun image container untuk fungsi Java Lambda:
+ [Menggunakan gambar AWS dasar untuk Java](#java-image-instructions)
[Gambar AWS dasar](images-create.md#runtimes-images-lp) dimuat sebelumnya dengan runtime bahasa, klien antarmuka runtime untuk mengelola interaksi antara Lambda dan kode fungsi Anda, dan emulator antarmuka runtime untuk pengujian lokal.
+ [Menggunakan gambar AWS dasar khusus OS](images-create.md#runtimes-images-provided)
[AWS Gambar dasar khusus OS](https://gallery.ecr.aws/lambda/provided) berisi distribusi Amazon Linux dan emulator antarmuka [runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Gambar-gambar ini biasanya digunakan untuk membuat gambar kontainer untuk bahasa yang dikompilasi, seperti [Go](go-image.md#go-image-provided) dan [Rust](lambda-rust.md), dan untuk versi bahasa atau bahasa yang Lambda tidak menyediakan gambar dasar, seperti Node.js 19. Anda juga dapat menggunakan gambar dasar khusus OS untuk mengimplementasikan runtime [kustom](runtimes-custom.md). Untuk membuat gambar kompatibel dengan Lambda, Anda harus menyertakan [klien antarmuka runtime untuk Java](#java-image-clients) dalam gambar.
+ [Menggunakan gambar AWS non-dasar](#java-image-clients)
Anda dapat menggunakan gambar dasar alternatif dari registri kontainer lain, seperti Alpine Linux atau Debian. Anda juga dapat menggunakan gambar kustom yang dibuat oleh organisasi Anda. Untuk membuat gambar kompatibel dengan Lambda, Anda harus menyertakan [klien antarmuka runtime untuk Java](#java-image-clients) dalam gambar.
**Tip**
Untuk mengurangi waktu yang dibutuhkan agar fungsi kontainer Lambda menjadi aktif, lihat [Menggunakan build multi-tahap](https://docs.docker.com/build/building/multi-stage/) dalam dokumentasi Docker. Untuk membuat gambar kontainer yang efisien, ikuti [Praktik terbaik untuk menulis Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Halaman ini menjelaskan cara membuat, menguji, dan menyebarkan gambar kontainer untuk Lambda.
**Topics**
+ [AWS gambar dasar untuk Java](#java-image-base)
+ [Menggunakan gambar AWS dasar untuk Java](#java-image-instructions)
+ [Menggunakan gambar dasar alternatif dengan klien antarmuka runtime](#java-image-clients)
## AWS gambar dasar untuk Java
AWS menyediakan gambar dasar berikut untuk Java:
| Tanda | Waktu berjalan | Sistem operasi | Dockerfile | penghentian |
| --- | --- | --- | --- | --- |
| 25 | Jawa 25 | Amazon Linux 2023 | [Dockerfile untuk Java 25 di GitHub](https://github.com/aws/aws-lambda-base-images/blob/java25/Dockerfile.java25) | 30 Jun 2029 |
| 21 | Jawa 21 | Amazon Linux 2023 | [Dockerfile untuk Java 21 di GitHub](https://github.com/aws/aws-lambda-base-images/blob/java21/Dockerfile.java21) | 30 Jun 2029 |
| 17 | Jawa 17 | Amazon Linux 2 | [Dockerfile untuk Java 17 di GitHub](https://github.com/aws/aws-lambda-base-images/blob/java17/Dockerfile.java17) | 30 Jun 2027 |
| 11 | Java 11 | Amazon Linux 2 | [Dockerfile untuk Java 11 di GitHub](https://github.com/aws/aws-lambda-base-images/blob/java11/Dockerfile.java11) | 30 Jun 2027 |
| 8.al2 | Java 8 | Amazon Linux 2 | [Dockerfile untuk Java 8 di GitHub](https://github.com/aws/aws-lambda-base-images/blob/java8.al2/Dockerfile.java8.al2) | 30 Jun 2027 |
[Repositori Amazon ECR: gallery.ecr. aws/lambda/java](https://gallery.ecr.aws/lambda/java)
Gambar dasar Java 21 dan yang lebih baru didasarkan pada [gambar kontainer minimal Amazon Linux 2023](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html). Gambar dasar sebelumnya menggunakan Amazon Linux 2. AL2023 memberikan beberapa keunggulan dibandingkan Amazon Linux 2, termasuk jejak penyebaran yang lebih kecil dan versi pustaka yang diperbarui seperti. `glibc`
AL2023gambar berbasis menggunakan `microdnf` (symlinked as`dnf`) sebagai manajer paket alih-alih`yum`, yang merupakan manajer paket default di Amazon Linux 2. `microdnf`adalah implementasi mandiri dari. `dnf` Untuk daftar paket yang disertakan dalam gambar AL2023 berbasis, lihat kolom **Penampung Minimal** di [Membandingkan paket yang diinstal di Amazon Linux 2023 Container Images](https://docs.aws.amazon.com/linux/al2023/ug/al2023-container-image-types.html). Untuk informasi selengkapnya tentang perbedaan antara AL2023 dan Amazon Linux 2, lihat [Memperkenalkan runtime Amazon Linux 2023 untuk AWS Lambda di Blog](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) AWS Komputasi.
**catatan**
Untuk menjalankan image AL2023 berbasis lokal, termasuk with AWS Serverless Application Model (AWS SAM), Anda harus menggunakan Docker versi 20.10.10 atau yang lebih baru.
## Menggunakan gambar AWS dasar untuk Java
### Prasyarat
Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki hal-hal berikut:
+ Java (misalnya, [Amazon Corretto](https://aws.amazon.com/corretto))
+ [Apache Maven](https://maven.apache.org/) [atau Gradle](https://gradle.org/install/)
+ [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versi minimum 25.0.0)
+ Plugin [buildx Docker](https://github.com/docker/buildx/blob/master/README.md).
### Membuat gambar dari gambar dasar
------
#### [ Maven ]
1. Jalankan perintah berikut untuk membuat proyek Maven menggunakan [pola dasar](https://github.com/aws/aws-sdk-java-v2/tree/master/archetypes/archetype-lambda) untuk Lambda. Parameter-parameter berikut diperlukan:
+ **Layanan** — Layanan AWS Klien untuk digunakan dalam fungsi Lambda. Untuk daftar sumber yang tersedia, lihat [aws-sdk-java-v2/layanan](https://github.com/aws/aws-sdk-java-v2/tree/master/services) di GitHub.
+ **wilayah** — Wilayah AWS Tempat Anda ingin membuat fungsi Lambda.
+ **GroupId** — Namespace paket lengkap aplikasi Anda.
+ **ArtifactID** — Nama proyek Anda. Ini menjadi nama direktori untuk proyek Anda.
Di Linux dan macOS, jalankan perintah ini:
```
mvn -B archetype:generate \
-DarchetypeGroupId=software.amazon.awssdk \
-DarchetypeArtifactId=archetype-lambda -Dservice=s3 -Dregion=US_WEST_2 \
-DgroupId=com.example.myapp \
-DartifactId=myapp
```
Di PowerShell, jalankan perintah ini:
```
mvn -B archetype:generate `
"-DarchetypeGroupId=software.amazon.awssdk" `
"-DarchetypeArtifactId=archetype-lambda" "-Dservice=s3" "-Dregion=US_WEST_2" `
"-DgroupId=com.example.myapp" `
"-DartifactId=myapp"
```
Pola dasar Maven untuk Lambda telah dikonfigurasi sebelumnya untuk dikompilasi dengan Java SE 8 dan menyertakan ketergantungan pada file. AWS SDK untuk Java Jika Anda membuat proyek Anda dengan pola dasar yang berbeda atau dengan menggunakan metode lain, Anda harus [mengkonfigurasi compiler Java untuk Maven](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#configure-maven-compiler) dan [mendeklarasikan](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#configure-maven-compiler) SDK sebagai dependensi.
1. Buka `myapp/src/main/java/com/example/myapp` direktori, dan temukan `App.java` filenya. Ini adalah kode untuk fungsi Lambda. Anda dapat menggunakan kode sampel yang disediakan untuk pengujian, atau menggantinya dengan kode Anda sendiri.
1. Arahkan kembali ke direktori root proyek, lalu buat Dockerfile baru dengan konfigurasi berikut:
+ Mengatur `FROM` properti ke [URI dari gambar dasar](https://gallery.ecr.aws/lambda/java).
+ 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 Maven layout
COPY target/classes ${LAMBDA_TASK_ROOT}
COPY target/dependency/* ${LAMBDA_TASK_ROOT}/lib/
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "com.example.myapp.App::handleRequest" ]
```
1. Kompilasi proyek dan kumpulkan dependensi runtime.
```
mvn compile dependency:copy-dependencies -DincludeScope=runtime
```
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.
------
#### [ Gradle ]
1. Buat direktori untuk proyek, dan kemudian beralih ke direktori itu.
```
mkdir example
cd example
```
1. Jalankan perintah berikut agar Gradle membuat proyek aplikasi Java baru di direktori `example` di lingkungan Anda. Untuk **Pilih skrip build DSL**, pilih **2: Groovy**.
```
gradle init --type java-application
```
1. Buka `/example/app/src/main/java/example` direktori, dan temukan `App.java` filenya. Ini adalah kode untuk fungsi Lambda. Anda dapat menggunakan kode contoh berikut untuk pengujian, atau menggantinya dengan kode Anda sendiri.
**Example App.java**
```
package com.example;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class App implements RequestHandler {
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
1. Mulai gambar Docker dengan perintah **docker run**. Dalam contoh ini, `docker-image` adalah nama gambar dan `test` tag.
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
Perintah ini menjalankan gambar sebagai wadah dan membuat titik akhir lokal di`localhost:9000/2015-03-31/functions/function/invocations`.
**catatan**
Jika Anda membuat image Docker untuk arsitektur set ARM64 instruksi, pastikan untuk menggunakan `--platform linux/arm64` opsi alih-alih. `--platform linux/amd64`
1. Dari jendela terminal baru, posting acara ke titik akhir lokal.
------
#### [ Linux/macOS ]
Di Linux dan macOS, jalankan perintah berikut: `curl`
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Perintah ini memanggil fungsi dengan peristiwa kosong dan mengembalikan respons. Jika Anda menggunakan kode fungsi Anda sendiri daripada kode fungsi sampel, Anda mungkin ingin memanggil fungsi dengan payload JSON. Contoh:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
Dalam PowerShell, jalankan `Invoke-WebRequest` perintah berikut:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Perintah ini memanggil fungsi dengan peristiwa kosong dan mengembalikan respons. Jika Anda menggunakan kode fungsi Anda sendiri daripada kode fungsi sampel, Anda mungkin ingin memanggil fungsi dengan payload JSON. Contoh:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Dapatkan ID kontainer.
```
docker ps
```
1. Gunakan perintah [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) untuk menghentikan wadah. Dalam perintah ini, ganti `3766c4ab331c` dengan ID kontainer dari langkah sebelumnya.
```
docker kill 3766c4ab331c
```
### Menyebarkan gambar
**Untuk mengunggah gambar ke Amazon ECR dan membuat fungsi Lambda**
1. Jalankan [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)perintah untuk mengautentikasi CLI Docker ke registri Amazon ECR Anda.
+ Tetapkan `--region` nilai ke Wilayah AWS tempat Anda ingin membuat repositori Amazon ECR.
+ Ganti `111122223333` dengan Akun AWS ID Anda.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. [Buat repositori di Amazon ECR menggunakan perintah create-repository.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html)
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**catatan**
Repositori Amazon ECR harus sama Wilayah AWS dengan fungsi Lambda.
Jika berhasil, Anda melihat respons seperti ini:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Salin `repositoryUri` dari output pada langkah sebelumnya.
1. Jalankan perintah [tag docker](https://docs.docker.com/engine/reference/commandline/tag/) untuk menandai gambar lokal Anda ke repositori Amazon ECR Anda sebagai versi terbaru. Dalam perintah ini:
+ `docker-image:test`adalah nama dan [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) gambar Docker Anda. Ini adalah nama gambar dan tag yang Anda tentukan dalam `docker build` perintah.
+ Ganti `` 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
Jika Anda menggunakan gambar [dasar khusus OS atau gambar dasar](images-create.md#runtimes-images-provided) alternatif, Anda harus menyertakan klien antarmuka runtime dalam gambar Anda. Klien antarmuka runtime memperluas[API runtime](runtimes-api.md), yang mengelola interaksi antara Lambda dan kode fungsi Anda.
Instal klien antarmuka runtime untuk Java di Dockerfile Anda, atau sebagai ketergantungan dalam proyek Anda. Misalnya, untuk menginstal klien antarmuka runtime menggunakan manajer paket Maven, tambahkan yang berikut ini ke file Anda: `pom.xml`
```
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
Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki hal-hal berikut:
+ Java (misalnya, [Amazon Corretto](https://aws.amazon.com/corretto))
+ [Apache Maven](https://maven.apache.org/)
+ [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versi minimum 25.0.0)
+ Plugin [buildx Docker](https://github.com/docker/buildx/blob/master/README.md).
### Membuat gambar dari gambar dasar alternatif
1. Buat proyek Maven. Parameter-parameter berikut diperlukan:
+ **GroupId** — Namespace paket lengkap aplikasi Anda.
+ **ArtifactID** — Nama proyek Anda. Ini menjadi nama direktori untuk proyek Anda.
------
#### [ Linux/macOS ]
```
mvn -B archetype:generate \
-DarchetypeArtifactId=maven-archetype-quickstart \
-DgroupId=example \
-DartifactId=myapp \
-DinteractiveMode=false
```
------
#### [ PowerShell ]
```
mvn -B archetype:generate `
-DarchetypeArtifactId=maven-archetype-quickstart `
-DgroupId=example `
-DartifactId=myapp `
-DinteractiveMode=false
```
------
1. Buka direktori proyek.
```
cd myapp
```
1. Buka `pom.xml` file dan ganti isinya dengan yang berikut ini. File ini menyertakan [aws-lambda-java-runtime-interface-client](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-runtime-interface-client) sebagai dependensi. Atau, Anda dapat menginstal klien antarmuka runtime di Dockerfile. Namun, pendekatan paling sederhana adalah memasukkan perpustakaan sebagai ketergantungan.
```
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
Gunakan [emulator antarmuka runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/) untuk menguji gambar secara lokal. Anda dapat [membangun emulator ke dalam gambar Anda](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) atau menggunakan prosedur berikut untuk menginstalnya di mesin lokal Anda.
**Untuk menginstal dan menjalankan emulator antarmuka runtime di mesin lokal Anda**
1. Dari direktori proyek Anda, jalankan perintah berikut untuk mengunduh emulator antarmuka runtime (arsitektur x86-64) dari GitHub dan menginstalnya di mesin lokal Anda.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Untuk menginstal emulator arm64, ganti URL GitHub repositori di perintah sebelumnya dengan yang berikut:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Untuk menginstal emulator arm64, ganti `$downloadLink` dengan yang berikut ini:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Mulai gambar Docker dengan perintah **docker run**. Perhatikan hal-hal berikut:
+ `docker-image`adalah nama gambar dan `test` tag.
+ `/usr/bin/java -cp './*' com.amazonaws.services.lambda.runtime.api.client.AWSLambda example.App::sayHello`adalah `ENTRYPOINT` diikuti oleh `CMD` dari Dockerfile Anda.
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
docker-image:test \
/usr/bin/java -cp './*' com.amazonaws.services.lambda.runtime.api.client.AWSLambda example.App::sayHello
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
/usr/bin/java -cp './*' com.amazonaws.services.lambda.runtime.api.client.AWSLambda example.App::sayHello
```
------
Perintah ini menjalankan gambar sebagai wadah dan membuat titik akhir lokal di`localhost:9000/2015-03-31/functions/function/invocations`.
**catatan**
Jika Anda membuat image Docker untuk arsitektur set ARM64 instruksi, pastikan untuk menggunakan `--platform linux/arm64` opsi alih-alih. `--platform linux/amd64`
1. Posting acara ke titik akhir lokal.
------
#### [ Linux/macOS ]
Di Linux dan macOS, jalankan perintah berikut: `curl`
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Perintah ini memanggil fungsi dengan peristiwa kosong dan mengembalikan respons. Jika Anda menggunakan kode fungsi Anda sendiri daripada kode fungsi sampel, Anda mungkin ingin memanggil fungsi dengan payload JSON. Contoh:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
Dalam PowerShell, jalankan `Invoke-WebRequest` perintah berikut:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Perintah ini memanggil fungsi dengan peristiwa kosong dan mengembalikan respons. Jika Anda menggunakan kode fungsi Anda sendiri daripada kode fungsi sampel, Anda mungkin ingin memanggil fungsi dengan payload JSON. Contoh:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Dapatkan ID kontainer.
```
docker ps
```
1. Gunakan perintah [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) untuk menghentikan wadah. Dalam perintah ini, ganti `3766c4ab331c` dengan ID kontainer dari langkah sebelumnya.
```
docker kill 3766c4ab331c
```
### Menyebarkan gambar
**Untuk mengunggah gambar ke Amazon ECR dan membuat fungsi Lambda**
1. Jalankan [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)perintah untuk mengautentikasi CLI Docker ke registri Amazon ECR Anda.
+ Tetapkan `--region` nilai ke Wilayah AWS tempat Anda ingin membuat repositori Amazon ECR.
+ Ganti `111122223333` dengan Akun AWS ID Anda.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. [Buat repositori di Amazon ECR menggunakan perintah create-repository.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html)
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**catatan**
Repositori Amazon ECR harus sama Wilayah AWS dengan fungsi Lambda.
Jika berhasil, Anda melihat respons seperti ini:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Salin `repositoryUri` dari output pada langkah sebelumnya.
1. Jalankan perintah [tag docker](https://docs.docker.com/engine/reference/commandline/tag/) untuk menandai gambar lokal Anda ke repositori Amazon ECR Anda sebagai versi terbaru. Dalam perintah ini:
+ `docker-image:test`adalah nama dan [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) gambar Docker Anda. Ini adalah nama gambar dan tag yang Anda tentukan dalam `docker build` perintah.
+ Ganti `` 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
```