# Java를 사용하여 Lambda 함수 빌드
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
```
------
**중요**
프라이빗 필드, 메서드 또는 클래스와 같은 JDK API의 프라이빗 구성 요소를 사용하지 않습니다. 퍼블릭 API가 아닌 API 구성 요소는 변경되거나 업데이트 시 제거될 수 있으며, 이로 인해 애플리케이션이 중단될 수 있습니다.
**Java 함수를 만들려면**
1. [Lambda 콘솔](https://console.aws.amazon.com/lambda)을 엽니다.
1. **함수 생성**을 선택합니다.
1. 다음 설정을 구성합니다:
+ **함수 이름**: 함수의 이름을 입력합니다.
+ **런타임**: **Java 25**을 선택합니다.
1. **함수 생성**을 선택합니다.
콘솔은 `Hello`라는 핸들러 클래스를 사용하여 Lambda 함수를 만듭니다. Java는 컴파일된 언어이므로 Lambda 콘솔에서 소스 코드를 보거나 편집할 수 없지만 구성을 수정하고 간접 호출하고 트리거를 구성할 수 있습니다.
**참고**
로컬 환경에서 애플리케이션 개발을 시작하려면 이 가이드의 GitHub 리포지토리에서 사용할 수 있는 [샘플 애플리케이션](java-samples.md) 중 하나를 배포하세요.
`Hello` 클래스에는 이벤트 객체와 컨텍스트 객체를 취하는 `handleRequest`라는 이름의 함수가 있습니다. 이는 함수가 간접 호출될 때 Lambda가 간접 호출하는 [핸들러 함수](java-handler.md)입니다. Java 함수 런타임은 Lambda에서 호출 이벤트를 가져와 핸들러로 전달합니다. 함수 구성에서 핸들러 값은 `example.Hello::handleRequest`입니다.
함수의 코드를 업데이트하려면 함수 코드가 포함된 .zip 파일 아카이브인 배포 패키지를 작성합니다. 함수 개발이 진행되면 소스 제어에 함수 코드를 저장하고 라이브러리를 추가하며 배포를 자동화할 필요가 있습니다. 먼저 [배포 패키지를 생성](java-package.md)하고 명령줄에서 코드를 업데이트하세요.
함수 런타임은 호출 이벤트 외에도 컨텍스트 객체를 핸들러에 전달합니다. [컨텍스트 객체](java-context.md)에는 호출, 함수 및 실행 환경에 관한 추가 정보가 포함되어 있습니다. 자세한 내용은 환경 변수에서 확인할 수 있습니다.
Lambda 함수는 CloudWatch Logs 로그 그룹을 함께 제공됩니다. 함수 런타임은 각 호출에 대한 세부 정보를 CloudWatch Logs에 보냅니다. 호출 중 [함수가 출력하는 로그](java-logging.md)를 전달합니다. 함수가 오류를 반환하면 Lambda은 오류에 서식을 지정한 후 이를 간접 호출자에게 반환합니다.
**Topics**
+ [Java에서 Lambda 함수 핸들러 정의](java-handler.md)
+ [.zip 또는 JAR 파일 아카이브를 사용하여 Java Lambda 함수 배포](java-package.md)
+ [컨테이너 이미지로 Java Lambda 함수 배포](java-image.md)
+ [Java Lambda 함수를 위한 계층 작업](java-layers.md)
+ [Lambda Java 함수의 직렬화 사용자 지정](java-custom-serialization.md)
+ [Lambda 함수의 Java 런타임 시작 동작에 대한 사용자 지정](java-customization.md)
+ [Lambda 컨텍스트 객체를 사용하여 Java 함수 정보 검색](java-context.md)
+ [Java Lambda 함수 로깅 및 모니터링](java-logging.md)
+ [AWS Lambda에서 Java 코드 계측](java-tracing.md)
+ [AWS Lambda용 Java 샘플 애플리케이션](java-samples.md)
# Java에서 Lambda 함수 핸들러 정의
└ build.gradle OR pom.xml
```
Maven 또는 Gradle을 사용하여 프로젝트를 빌드하고 종속성을 관리할 수 있습니다.
함수의 기본 핸들러 로직은 `src/main/java/example` 디렉터리 아래의 Java 파일에 있습니다. 이 페이지의 예제에서는 이 파일의 이름을 `OrderHandler.java`로 지정합니다. 이 파일 외에도 필요에 따라 추가 Java 클래스를 포함할 수 있습니다. 함수를 Lambda에 배포할 경우, 간접 호출 중에 Lambda가 간접적으로 호출해야 하는 기본 핸들러 메서드가 포함된 Java 클래스를 지정해야 합니다.
## 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` 파일은 다음 코드 섹션을 포함하고 있습니다.
+ `package example`: Java에서는 무엇이든 가능하지만 프로젝트의 디렉터리 구조와 일치해야 합니다. 여기서는 디렉터리 구조가 `src/main/java/example`이기 때문에 `package example`을 사용합니다.
+ `import` 문: Lambda 함수에 필요한 Java 클래스를 가져오는 데 사용합니다.
+ `public class OrderHandler ...`: Java 클래스를 정의하며 [유효한 클래스 정의](#java-handler-signatures)여야 합니다.
+ `private static final S3Client S3_CLIENT ...`: 클래스의 메서드 외부에서 S3 클라이언트를 초기화합니다. 이렇게 하면 [초기화 단계](lambda-runtime-environment.md#runtimes-lifecycle-ib)에서 Lambda가 이 코드를 실행합니다.
+ `public record Order ...`: 이 사용자 지정 Java [레코드](https://openjdk.org/jeps/395)에서 예상 입력 이벤트의 형태를 정의합니다.
+ `public String handleRequest(Order event, Context context)`: 기본 애플리케이션 논리를 포함한 **기본 핸들러 메서드**입니다.
+ `private void uploadReceiptToS3(...) {}`: 기본 `handleRequest` 핸들러 메서드에서 참조하는 도우미 메서드입니다.
### 샘플 build.gradle 및 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
```
------
이 함수가 제대로 작동하려면 [실행 역할](lambda-intro-execution-role.md)이 `s3:PutObject` 작업을 허용해야 합니다. 또한 `RECEIPT_BUCKET` 환경 변수를 정의해야 합니다. 성공적으로 간접 호출되면 Amazon S3 버킷은 영수증 파일을 포함합니다.
**참고**
이 함수를 제한 시간 없이 성공적으로 실행하려면 추가 구성 설정이 필요할 수 있습니다. 메모리는 256MB, 제한 시간은 10초로 구성하는 것이 좋습니다. [콜드 스타트](lambda-runtime-environment.md#cold-start-latency)로 인해 첫 번째 간접 호출 시 추가 시간이 걸릴 수 있습니다. 후속 간접 호출은 실행 환경의 재사용으로 인해 훨씬 더 빠르게 실행됩니다.
## Java 핸들러에 유효한 클래스 정의
`을 구현합니다. 입력 유형은 클래스 내에서 정의하는 `Order` 레코드이고, 출력 유형은 `String`입니다.
```
public class OrderHandler implements RequestHandler {
...
}
```
이 인터페이스를 사용하면 Java 런타임에서 이벤트를 입력 유형의 객체로 역직렬화하고 출력을 텍스트로 직렬화합니다. 해당 입력 및 출력 유형에 대해 기본 제공 직렬화가 작동하는 경우 이 인터페이스를 사용하세요.
고유한 직렬화를 사용하려면 `RequestStreamHandler` 인터페이스를 구현할 수 있습니다. 이 인터페이스를 사용하면 Lambda에서 핸들러에 입력 스트림과 출력 스트림을 전달합니다. 핸들러는 입력 스트림에서 바이트를 읽어 출력 스트림에 쓰고 void를 반환합니다. Java 21 런타임을 사용하는 예제는 [HandlerStream.java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-basic/src/main/java/example/HandlerStream.java)를 참조하세요.
Java 함수에서 기본 및 일반 유형(예: `String`, `Integer`, `List`, `Map`)으로만 작업하는 경우 인터페이스를 구현할 필요가 없습니다. 예를 들어 함수가 `Map` 입력을 가져와 `String`을 반환할 경우 클래스 정의 및 핸들러 서명은 다음과 같을 수 있습니다.
```
public class ExampleHandler {
public String handleRequest(Map input, Context context) {
...
}
}
```
또한 인터페이스를 구현하지 않을 경우 [컨텍스트](java-context.md) 객체는 선택 사항입니다. 예를 들어 클래스 정의 및 핸들러 서명은 다음과 같을 수 있습니다.
```
public class NoContextHandler {
public String handleRequest(Map input) {
...
}
}
```
## 핸들러 이름 지정 규칙
*.** – 예: `example.OrderHandler`.
`RequestHandler` 또는 `RequestStreamHandler` 인터페이스를 구현하지 않는 Java 내 Lambda 함수의 경우 핸들러의 이름을 사용할 수 있습니다. 함수를 Lambda에 배포할 경우 함수 구성에서 기본 핸들러를 다음 형식으로 지정합니다.
+ **.**::** – 예: `example.Handler::mainHandler`.
## 입력 이벤트 객체 정의 및 액세스
` `List`,`List` ,등. - 이벤트가 JSON 배열입니다. 런타임에서 이벤트를 지정된 유형 또는 인터페이스의 객체로 역직렬화합니다.
+ `InputStream` – 이벤트가 임의의 JSON 유형입니다. 런타임에서 문서의 바이트 스트림을 수정하지 않고 핸들러에 전달합니다. 사용자가 입력을 역직렬화하고 출력 스트림에 출력을 써야 합니다.
+ 라이브러리 유형 – 다른 AWS 서비스에서 전송하는 이벤트의 경우 [aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events) 라이브러리에 있는 유형을 사용합니다. 예를 들어 Amazon Simple Queue Service(SQS)에서 Lambda 함수를 호출하는 경우 `SQSEvent` 객체를 입력으로 사용합니다.
## Lambda 컨텍스트 객체 액세스 및 사용
` 섹션에 다음 줄을 추가합니다.
```
software.amazon.awssdk
s3
2.28.29
```
**참고**
이는 SDK의 최신 버전이 아닐 수 있습니다. 애플리케이션에 적합한 SDK 버전을 선택합니다.
그런 다음, Java 클래스에서 직접 종속성을 가져옵니다.
```
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.S3Exception;
```
이렇게 하면 예제 코드가 다음과 같이 Amazon S3 클라이언트를 초기화합니다.
```
private static final S3Client S3_CLIENT = S3Client.builder().build();
```
이 예제에서는 함수를 간접적으로 호출할 때마다 초기화할 필요가 없도록 기본 핸들러 함수에서 Amazon S3 클라이언트를 초기화했습니다. SDK 클라이언트를 초기화한 후에는 이를 사용하여 다른 AWS 서비스와 상호 작용할 수 있습니다. 예제 코드는 다음과 같이 Amazon S3 `PutObject` API를 직접적으로 호출합니다.
```
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)));
```
## 환경 변수에 액세스
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
```
------
배포 패키지를 만들려면 함수 코드와 종속 항목을 단일 .zip 파일 또는 Java 아카이브(JAR) 파일로 컴파일합니다. Gradle의 경우 [`Zip` 빌드 유형을 사용](#java-package-gradle)합니다. Apache Maven의 경우 [Maven Shade 플러그인을 사용](#java-package-maven)합니다. 배포 패키지를 업로드하려면 Lambda 콘솔, Lambda API 또는 AWS Serverless Application Model(AWS SAM)을 사용합니다.
**참고**
배포 패키지 크기를 작게 유지하려면 함수의 계층별 종속성을 패키징하세요. 계층을 사용하면 독립적으로 종속성을 관리하고, 여러 함수에서 사용할 수 있으며 다른 계정과 공유할 수 있습니다. 자세한 내용은 [계층으로 Lambda 종속성 관리](chapter-layers.md) 섹션을 참조하세요.
## Gradle을 사용하여 배포 패키지 빌드
org.apache.maven.plugins
maven-shade-plugin
3.2.2
false
package
shade
```
배포 패키지를 빌드하려면 `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] ------------------------------------------------------------------------
```
이 명령은 `target` 디렉터리에 JAR 파일을 생성합니다.
**참고**
[다중 릴리스 JAR(MRJAR)](https://openjdk.org/jeps/238)로 작업하는 경우 배포 패키지를 Lambda에 업로드하기 전에 `lib` 디렉터리에 MRJAR(즉, Maven Shade 플러그인에서 생성된 음영 처리된 JAR)을 포함하고 압축해야 합니다. 그렇지 않으면 Lambda가 JAR 파일의 압축을 제대로 풀지 못해 `MANIFEST.MF` 파일이 무시될 수 있습니다.
appender 라이브러리(`aws-lambda-java-log4j2`)를 사용하는 경우 Maven Shade 플러그인에 대한 변환기도 구성해야 합니다. 변환기 라이브러리는 appender 라이브러리와 Log4j에 모두 나타나는 캐시 파일 버전을 결합합니다.
**Example pom.xml – Log4j 2 appender를 사용하여 플러그인 구성**
```
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
```
## Lambda 콘솔을 사용하여 배포 패키지 업로드
{
public String handleRequest(Object input, Context context) {
return "Hello world!";
}
}
```
1. `build.gradle` 파일을 엽니다. 이전 단계의 샘플 함수 코드를 사용하는 경우 `build.gradle`의 내용을 다음으로 바꿉니다. 자체 함수 코드를 사용하는 경우 필요에 따라 `build.gradle` 파일을 수정합니다.
**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. 2단계의 `gradle init` 명령은 `app/test` 디렉터리에 더미 테스트 사례도 생성했습니다. 이 자습서에서는 `/test` 디렉터리를 삭제하여 테스트 실행을 건너뜁니다.
1. 프로젝트를 빌드합니다.
```
gradle build
```
1. 프로젝트의 루트 디렉터리(`/example`)에서 다음 구성으로 Dockerfile을 생성합니다.
+ `FROM` 속성을 [기본 이미지의 URI](https://gallery.ecr.aws/lambda/java)로 설정합니다.
+ COPY 명령을 사용하여 함수 코드와 런타임 종속성을 [Lambda 정의 환경 변수](configuration-envvars.md#configuration-envvars-runtime)인 `{LAMBDA_TASK_ROOT}`에 복사합니다.
+ `CMD` 인수를 Lambda 함수 핸들러로 설정합니다.
참고로 Dockerfile 예제에는 [USER 지침](https://docs.docker.com/reference/dockerfile/#user)이 포함되어 있지 않습니다. Lambda에 컨테이너 이미지를 배포할 때 Lambda는 권한이 최소 권한인 기본 Linux 사용자를 자동으로 정의합니다. 이는 `USER` 지침이 제공되지 않을 때 `root` 사용자에게 기본 설정이 적용되는 표준 Docker 동작과는 다릅니다.
**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. [docker build](https://docs.docker.com/engine/reference/commandline/build/) 명령으로 도커 이미지를 빌드합니다. 다음 예제에서는 이미지 이름을 `docker-image`로 지정하고 `test` [태그](https://docs.docker.com/engine/reference/commandline/build/#tag)를 지정합니다. 이미지를 Lambda와 호환되게 만들려면 `--provenance=false` 옵션을 사용해야 합니다.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**참고**
이 명령은 빌드 머신의 아키텍처에 관계없이 컨테이너가 Lambda 실행 환경과 호환되는지 확인하기 위해 `--platform linux/amd64` 옵션을 지정합니다. ARM64 명령 세트 아키텍처를 사용하여 Lambda 함수를 생성하려는 경우 `--platform linux/arm64` 옵션을 대신 사용하도록 명령을 변경해야 합니다.
------
### (선택 사항) 로컬에서 이미지 테스트
`를 복사한 `repositoryUri`로 바꿉니다. URI 끝에 `:latest`를 포함해야 합니다.
```
docker tag docker-image:test :latest
```
예제:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [docker push](https://docs.docker.com/engine/reference/commandline/push/) 명령을 실행하여 Amazon ECR 리포지토리에 로컬 이미지를 배포합니다. 리포지토리 URI 끝에 `:latest`를 포함해야 합니다.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. 함수에 대한 실행 역할이 아직 없는 경우 하나 [생성](lambda-intro-execution-role.md#permissions-executionrole-api)합니다. 다음 단계에서는 역할의 Amazon 리소스 이름(ARN)이 필요합니다.
1. Lambda 함수를 생성합니다. `ImageUri`의 경우 이전의 리포지토리 URI를 지정합니다. URI 끝에 `:latest`를 포함해야 합니다.
```
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
```
**참고**
이미지가 Lambda 함수와 동일한 리전에 있는 한 다른 AWS 계정의 이미지를 사용하여 함수를 생성할 수 있습니다. 자세한 내용은 [Amazon ECR 교차 계정 권한](images-create.md#configuration-images-xaccount-permissions) 섹션을 참조하세요.
1. 함수를 간접 호출합니다.
```
aws lambda invoke --function-name hello-world response.json
```
다음과 같은 응답이 표시되어야 합니다.
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. 함수의 출력을 보려면 `response.json` 파일을 확인합니다.
함수 코드를 업데이트하려면 이미지를 다시 빌드하고 Amazon ECR 리포지토리에 새 이미지를 업로드한 다음 [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) 명령을 사용하여 이미지를 Lambda 함수에 배포해야 합니다.
Lambda는 이미지 태그를 특정 이미지 다이제스트로 확인합니다. 즉, 함수를 배포하는 데 사용된 이미지 태그가 Amazon ECR의 새 이미지로 가리키는 경우 Lambda는 새 이미지를 사용하도록 함수를 자동으로 업데이트하지 않습니다.
새 이미지를 동일한 Lambda 함수에 배포하려면 Amazon ECR의 이미지 태그가 동일하게 유지되더라도 [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) 명령을 사용해야 합니다. 다음 예제에서 `--publish` 옵션은 업데이트된 컨테이너 이미지를 사용하여 새 버전의 함수를 생성합니다.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## 런타임 인터페이스 클라이언트에서 대체 기본 이미지 사용
com.amazonaws
aws-lambda-java-runtime-interface-client
2.3.2
```
패키지에 대한 자세한 내용은 Maven Central Repository의 [AWS Lambda Java 런타임 인터페이스 클라이언트](https://mvnrepository.com/artifact/com.amazonaws/aws-lambda-java-runtime-interface-client)를 참조하세요. [AWS Lambda Java 지원 라이브러리](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-runtime-interface-client) GitHub 리포지토리에서 런타임 인터페이스 클라이언트 소스 코드를 검토할 수도 있습니다.
다음 예제에서는 [Amazon Corretto 이미지](https://gallery.ecr.aws/amazoncorretto/amazoncorretto)를 사용하여 Java용 컨테이너 이미지를 빌드하는 방법을 보여줍니다. Amazon Corretto는 무료로 사용할 수 있는 Open Java Development Kit(OpenJDK)의 프로덕션용 멀티플랫폼 배포판입니다. Maven 프로젝트에는 런타임 인터페이스 클라이언트가 종속 항목으로 포함되어 있습니다.
### 사전 조건
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. `myapp/src/main/java/com/example/myapp` 디렉터리를 열고 `App.java` 파일을 찾습니다. Lambda 함수에 대한 코드입니다. 코드를 다음으로 바꿉니다.
**Example 함수 핸들러**
```
package example;
public class App {
public static String sayHello() {
return "Hello world!";
}
}
```
1. 1단계의 `mvn -B archetype:generate` 명령은 `src/test` 디렉터리에 더미 테스트 케이스도 생성했습니다. 본 자습서의 목적에 맞게 생성된 전체 `/test` 디렉터리를 삭제하여 실행 중인 테스트를 건너뛰는 것입니다.
1. 프로젝트의 루트 디렉터리로 다시 이동하고 새 Dockerfile을 생성합니다. 다음 예제 Dockerfile에서는 [Amazon Corretto 이미지](https://gallery.ecr.aws/amazoncorretto/amazoncorretto)를 사용합니다. Amazon Corretto는 OpenJDK의 프로덕션용 무료 멀티플랫폼 배포판입니다.
+ `FROM` 속성을 기본 이미지의 URI로 설정합니다.
+ Docker 컨테이너가 시작될 때 실행할 모듈로 `ENTRYPOINT`를 설정합니다. 이 경우 모듈은 런타임 인터페이스 클라이언트입니다.
+ `CMD` 인수를 Lambda 함수 핸들러로 설정합니다.
참고로 Dockerfile 예제에는 [USER 지침](https://docs.docker.com/reference/dockerfile/#user)이 포함되어 있지 않습니다. Lambda에 컨테이너 이미지를 배포할 때 Lambda는 권한이 최소 권한인 기본 Linux 사용자를 자동으로 정의합니다. 이는 `USER` 지침이 제공되지 않을 때 `root` 사용자에게 기본 설정이 적용되는 표준 Docker 동작과는 다릅니다.
**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. [docker build](https://docs.docker.com/engine/reference/commandline/build/) 명령으로 도커 이미지를 빌드합니다. 다음 예제에서는 이미지 이름을 `docker-image`로 지정하고 `test` [태그](https://docs.docker.com/engine/reference/commandline/build/#tag)를 지정합니다. 이미지를 Lambda와 호환되게 만들려면 `--provenance=false` 옵션을 사용해야 합니다.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**참고**
이 명령은 빌드 머신의 아키텍처에 관계없이 컨테이너가 Lambda 실행 환경과 호환되는지 확인하기 위해 `--platform linux/amd64` 옵션을 지정합니다. ARM64 명령 세트 아키텍처를 사용하여 Lambda 함수를 생성하려는 경우 `--platform linux/arm64` 옵션을 대신 사용하도록 명령을 변경해야 합니다.
### (선택 사항) 로컬에서 이미지 테스트
`를 복사한 `repositoryUri`로 바꿉니다. URI 끝에 `:latest`를 포함해야 합니다.
```
docker tag docker-image:test :latest
```
예제:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [docker push](https://docs.docker.com/engine/reference/commandline/push/) 명령을 실행하여 Amazon ECR 리포지토리에 로컬 이미지를 배포합니다. 리포지토리 URI 끝에 `:latest`를 포함해야 합니다.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. 함수에 대한 실행 역할이 아직 없는 경우 하나 [생성](lambda-intro-execution-role.md#permissions-executionrole-api)합니다. 다음 단계에서는 역할의 Amazon 리소스 이름(ARN)이 필요합니다.
1. Lambda 함수를 생성합니다. `ImageUri`의 경우 이전의 리포지토리 URI를 지정합니다. URI 끝에 `:latest`를 포함해야 합니다.
```
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
```
**참고**
이미지가 Lambda 함수와 동일한 리전에 있는 한 다른 AWS 계정의 이미지를 사용하여 함수를 생성할 수 있습니다. 자세한 내용은 [Amazon ECR 교차 계정 권한](images-create.md#configuration-images-xaccount-permissions) 섹션을 참조하세요.
1. 함수를 간접 호출합니다.
```
aws lambda invoke --function-name hello-world response.json
```
다음과 같은 응답이 표시되어야 합니다.
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. 함수의 출력을 보려면 `response.json` 파일을 확인합니다.
함수 코드를 업데이트하려면 이미지를 다시 빌드하고 Amazon ECR 리포지토리에 새 이미지를 업로드한 다음 [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) 명령을 사용하여 이미지를 Lambda 함수에 배포해야 합니다.
Lambda는 이미지 태그를 특정 이미지 다이제스트로 확인합니다. 즉, 함수를 배포하는 데 사용된 이미지 태그가 Amazon ECR의 새 이미지로 가리키는 경우 Lambda는 새 이미지를 사용하도록 함수를 자동으로 업데이트하지 않습니다.
새 이미지를 동일한 Lambda 함수에 배포하려면 Amazon ECR의 이미지 태그가 동일하게 유지되더라도 [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) 명령을 사용해야 합니다. 다음 예제에서 `--publish` 옵션은 업데이트된 컨테이너 이미지를 사용하여 새 버전의 함수를 생성합니다.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
# Java Lambda 함수를 위한 계층 작업
` 섹션에서는 종속성을 단일 uber-jar로 번들링하는 대신 [maven-dependency-plugin](https://mvnrepository.com/artifact/org.apache.maven.plugins/maven-dependency-plugin)을 사용하여 각 종속성에 대해 별도의 JAR 파일을 생성합니다. uber-jar를 생성하려면 [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. 프로젝트를 빌드합니다. 이 명령은 `target/lib/` 디렉터리에 모든 종속성 JAR 파일을 생성합니다.
```
mvn clean package
```
1. 계층에 필요한 디렉터리 구조를 생성합니다.
```
mkdir -p java/lib
```
1. `java/lib` 디렉터리에 종속성 JAR 파일을 복사합니다.
```
cp target/lib/*.jar java/lib/
```
1. 계층 콘텐츠를 .zip 파일로 압축합니다.
------
#### [ Linux/macOS ]
```
zip -r layer.zip java/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\java -DestinationPath .\layer.zip
```
------
.zip 파일의 디렉터리 구조는 다음과 같아야 합니다.
```
java/
└── lib/
├── jackson-databind-2.17.0.jar
├── jackson-core-2.17.0.jar
└── jackson-annotations-2.17.0.jar
```
**참고**
파일의 루트 수준에 `java` 디렉터리가 포함되어 있고 그 안에 `lib`가 있는지 확인하세요. 이 구조는 Lambda가 라이브러리를 찾아서 가져올 수 있도록 합니다. 각 종속성은 uber-jar로 번들링되지 않고 별도의 JAR 파일로 유지됩니다.
## Lambda에서 계층 생성
, Void>{
@Override
public Void handleRequest(Map event, Context context)
{
LambdaLogger logger = context.getLogger();
logger.log("EVENT TYPE: " + event.getClass());
return null;
}
}
```
이 함수는 `null`을 반환하기 전에 수신 이벤트의 클래스 유형을 기록합니다.
**Example 로그 출력**
```
EVENT TYPE: class java.util.LinkedHashMap
```
컨텍스트 객체에 대한 인터페이스는 [aws-lambda-java-core](https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-core) 라이브러리에서 사용할 수 있습니다. 이 인터페이스를 구현하여 테스트용 컨텍스트 클래스를 만들 수 있습니다. 다음 예제에서는 대부분의 속성 및 작업 테스트 로거에 대해 더미 값을 반환하는 컨텍스트 클래스를 보여 줍니다.
**Example [src/test/java/example/TestContext.java](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();
}
}
```
로깅에 대한 자세한 내용은 [Java Lambda 함수 로깅 및 모니터링](java-logging.md) 단원을 참조하세요.
## 샘플 애플리케이션의 컨텍스트
{
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 로그 형식**
```
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
```
Java 런타임은 각 호출에 대해 `START`, `END` 및 `REPORT` 줄을 로깅합니다. 보고서 행은 다음과 같은 세부 정보를 제공합니다.
**REPORT 행 데이터 필드**
+ **RequestId** – 호출의 고유한 요청 ID입니다.
+ **지속시간** – 함수의 핸들러 메서드가 이벤트를 처리하는 데 걸린 시간입니다.
+ **청구 기간** – 호출에 대해 청구된 시간입니다.
+ **메모리 크기** - 함수에 할당된 메모리 양입니다.
+ **사용된 최대 메모리** – 함수에서 사용한 메모리 양입니다. 간접 호출이 실행 환경을 공유하는 경우 Lambda는 모든 간접 호출에서 사용된 최대 메모리를 보고합니다. 이 동작으로 인해 보고된 값이 예상보다 높을 수 있습니다.
+ **초기화 기간** – 제공된 첫 번째 요청의 경우 런타임이 핸들러 메서드 외부에서 함수를 로드하고 코드를 실행하는 데 걸린 시간입니다.
+ **XRAY TraceId** – 추적된 요청의 경우 [AWS X-Ray 추적 ID](services-xray.md)입니다.
+ **SegmentId** - 추적된 요청의 경우 X-Ray 세그먼트 ID입니다.
+ **샘플링 완료(Sampled)** – 추적된 요청의 경우 샘플링 결과입니다.
## Java에서 Lambda 고급 로깅 제어 사용
%d{yyyy-MM-dd HH:mm:ss} %X{AWSRequestId} %-5p %c{1} - %m%n
```
`` 및 `` 태그 아래에 레이아웃을 지정하여 Log4j2 로그가 일반 텍스트 또는 JSON 출력으로 구성되는 방법을 결정할 수 있습니다.
이 예제에서는 텍스트 모드에서 각 행 앞에 날짜, 시간, 요청 ID, 로그 수준 및 클래스 이름이 추가됩니다. JSON 모드에서는 ``은 `aws-lambda-java-log4j2` 라이브러리와 함께 제공되는 구성과 함께 사용됩니다.
SLF4J는 Java 코드에 로깅하기 위한 facade 라이브러리입니다. 함수 코드에서 SLF4J 로거 팩토리를 사용하여 `info()` 및 `warn()`과 같은 로그 수준에 대한 메서드로 로거를 가져옵니다. 빌드 구성에서 로깅 라이브러리와 SLF4J 어댑터를 클래스 경로에 포함합니다. 빌드 구성에서 라이브러리를 변경하면 함수 코드를 변경하지 않고 로거 유형을 변경할 수 있습니다. SLF4J는 SDK for Java에서 로그를 캡처하는 데 필요합니다.
다음 예제 코드에서 핸들러 클래스는 SLF4J를 사용하여 로거를 검색합니다.
**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) – SLF4J를 사용한 로깅**
```
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";
}
}
```
이 코드는 다음과 같은 로그 출력을 생성합니다.
**Example 로그 형식**
```
{
"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/"
}
```
빌드 구성은 Lambda appender 및 SLF4J 어댑터에 대한 런타임 종속성을 사용하고 Log4j2에 대한 구현 종속성을 사용합니다.
**Example build.gradle – 종속성 로깅**
```
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,)',
...
}
```
테스트를 위해 로컬에서 코드를 실행하면 Lambda 로거가 있는 컨텍스트 객체를 사용할 수 없으며 Lambda appender가 사용할 요청 ID가 없습니다. 테스트 구성에 대한 예는 다음 단원의 샘플 애플리케이션을 참조하세요.
## 기타 로깅 도구 및 라이브러리 사용
```
성공하면 다음과 같은 결과가 응답됩니다.
```
{"message":"hello world"}
```
1. 함수에 대한 로그를 가져오려면 [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html)를 실행합니다. 자세한 내용은 *AWS Serverless Application Model 개발자 안내서*에서 [로그 관련 작업](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html)을 참조하세요.
```
sam logs --stack-name sam-app
```
출력은 다음과 같습니다.
```
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. 이는 인터넷을 통해 액세스할 수 있는 퍼블릭 API 엔드포인트입니다. 테스트 후에는 엔드포인트를 삭제하는 것이 좋습니다.
```
sam delete
```
### 로그 보존 관리
```
성공하면 다음과 같은 결과가 응답됩니다.
```
{"message":"hello world"}
```
1. 함수에 대한 트레이스를 가져오려면 [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html)를 실행합니다.
```
sam traces
```
추적 출력은 다음과 같습니다.
```
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. 이는 인터넷을 통해 액세스할 수 있는 퍼블릭 API 엔드포인트입니다. 테스트 후에는 엔드포인트를 삭제하는 것이 좋습니다.
```
sam delete
```
## 추적에 Powertools for AWS Lambda(Java) 및 AWS CDK 사용
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. `hello-world\app\src\main\resource` 디렉터리를 생성하고 로그 구성에 대한 `log4j.xml`을 생성합니다.
```
mkdir -p src/main/resource
cd src/main/resource
touch log4j.xml
```
1. `log4j.xml`을 열고 다음 코드를 추가합니다.
```
```
1. `hello-world\app\Function\src\main\java\helloworld` 디렉터리에서 `App.java`를 열고 기존 코드를 다음 코드로 바꿉니다. 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. `hello-world\src\main\java\com\myorg` 디렉터리에서 `HelloWorldStack.java`를 열고 기존 코드를 다음 코드로 바꿉니다. 이 코드는 [Lambda Constructor](https://docs.aws.amazon.com/cdk/api/v1/java/aws_cdk.aws_lambda.html)와 [ApiGatewayv2 Constructor](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigatewayv2-readme.html)를 사용하여 REST API와 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. `hello-world` 디렉터리에서 `pom.xml`를 열고 기존 코드를 다음 코드로 바꿉니다.
```
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. `hello-world` 디렉터리에 있는지 확인하고 애플리케이션을 배포합니다.
```
cdk deploy
```
1. 배포된 애플리케이션의 URL을 가져옵니다.
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`HttpApi`].OutputValue' --output text
```
1. API 엔드포인트 간접 호출:
```
curl -X GET
```
성공하면 다음과 같은 결과가 응답됩니다.
```
{"message":"hello world"}
```
1. 함수에 대한 트레이스를 가져오려면 [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html)를 실행합니다.
```
sam traces
```
추적 출력은 다음과 같습니다.
```
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. 이는 인터넷을 통해 액세스할 수 있는 퍼블릭 API 엔드포인트입니다. 테스트 후에는 엔드포인트를 삭제하는 것이 좋습니다.
```
cdk destroy
```
## ADOT를 사용하여 Java 함수 계측