Ver3.0 ☁️ 자바 클라우드와 AWS SDK로 시작하는 클라우드 네이티브 개발

☁️ 자바 클라우드와 AWS SDK로 시작하는 클라우드 네이티브 개발
안녕! 👋 오늘은 자바 개발자라면 꼭 알아야 할 클라우드 네이티브 개발에 대해 이야기해볼게. 요즘 IT 업계에서 클라우드는 선택이 아니라 필수가 됐잖아? 특히 AWS(Amazon Web Services)는 전 세계 클라우드 시장의 약 32%를 차지하는 압도적인 1위 플랫폼이야. 그리고 우리가 사랑하는 자바와 AWS SDK를 결합하면 정말 강력한 클라우드 애플리케이션을 만들 수 있어!
이 글에서는 클라우드 네이티브가 뭔지부터 시작해서, AWS SDK for Java를 실제로 어떻게 활용하는지까지 차근차근 알아볼 거야. 코드 예제도 많이 준비했으니까 편하게 따라와 줘! 😊
🌥️ 클라우드 네이티브, 도대체 뭘까?
먼저 클라우드 네이티브(Cloud Native)라는 용어부터 정리하고 가자. 많은 사람들이 "클라우드에서 실행되는 애플리케이션"이라고 생각하는데, 사실 그것보다 훨씬 더 깊은 의미가 있어.
CNCF(Cloud Native Computing Foundation)에서는 클라우드 네이티브 기술을 다음과 같이 정의하고 있어:
1. 컨테이너화 (Containerization) 🐳
애플리케이션을 컨테이너로 패키징해서 어디서든 동일하게 실행될 수 있도록 해. Docker가 대표적이지!
2. 동적 오케스트레이션 (Dynamic Orchestration) ⚙️
Kubernetes 같은 도구로 컨테이너들을 자동으로 관리하고 스케일링해.
3. 마이크로서비스 아키텍처 (Microservices) 🧩
큰 애플리케이션을 작은 독립적인 서비스들로 나눠서 개발하고 배포해.
4. 선언적 API (Declarative APIs) 📝
"어떻게"가 아니라 "무엇을"에 집중하는 방식으로 인프라를 관리해.
클라우드 네이티브 애플리케이션은 전통적인 모놀리식 애플리케이션과는 완전히 다른 접근 방식을 취해. 예를 들어, 전통적인 방식에서는 서버 한 대에 모든 기능을 넣고 수직 확장(Scale-up)을 했다면, 클라우드 네이티브에서는 기능을 분리하고 수평 확장(Scale-out)을 통해 유연하게 대응하지.
☕ 자바와 클라우드의 환상적인 조합
자바는 1995년에 탄생한 이후로 지금까지 엔터프라이즈 애플리케이션 개발의 표준으로 자리잡고 있어. "Write Once, Run Anywhere"라는 철학은 클라우드 환경과도 완벽하게 맞아떨어지지! 🎯
2. 성숙한 생태계: Spring Boot, Quarkus, Micronaut 등 클라우드 네이티브 프레임워크가 풍부해.
3. 강력한 성능: JIT 컴파일러와 최적화된 가비지 컬렉션으로 높은 성능을 제공해.
4. 엔터프라이즈 지원: 대규모 시스템에서 검증된 안정성과 보안성을 갖추고 있어.
특히 최근에는 GraalVM 네이티브 이미지를 통해 자바의 전통적인 단점이었던 느린 시작 시간과 높은 메모리 사용량 문제도 많이 개선됐어. Quarkus나 Micronaut 같은 프레임워크를 사용하면 밀리초 단위로 애플리케이션을 시작할 수 있고, 메모리도 수십 MB만 사용하지!
• 시작 시간: 5-10초
• 메모리: 200-500MB
• 최적화: JIT 컴파일
• 배포: JAR/WAR
• 시작 시간: 0.01-0.1초
• 메모리: 20-100MB
• 최적화: AOT 컴파일
• 배포: 컨테이너 이미지
🌟 AWS SDK for Java 완벽 가이드
이제 본격적으로 AWS SDK for Java에 대해 알아보자! AWS SDK는 자바 애플리케이션에서 AWS 서비스를 쉽게 사용할 수 있도록 해주는 라이브러리야. 현재 버전 2(AWS SDK for Java 2.x)가 최신이고, 비동기 처리와 성능이 크게 개선됐어. 🚀
• 비동기 클라이언트 지원
CompletableFuture 기반의 완전한 비동기 API를 제공해서 높은 처리량을 달성할 수 있어.
• 향상된 성능
HTTP/2 지원, 커넥션 풀링 최적화, 메모리 사용량 감소 등으로 성능이 대폭 개선됐어.
• 모듈화된 구조
필요한 서비스만 의존성에 추가할 수 있어서 애플리케이션 크기를 줄일 수 있지.
• 스트림 기반 API
대용량 데이터를 효율적으로 처리할 수 있는 스트림 API를 제공해.
🔧 AWS SDK 설정하기
먼저 프로젝트에 AWS SDK를 추가해야 해. Maven을 사용한다면 pom.xml에 다음과 같이 추가하면 돼:
<dependencyManagement>
<dependencies>
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>bom</artifactId>
<version>2.20.26</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!-- S3 서비스 -->
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>s3</artifactId>
</dependency>
<!-- DynamoDB 서비스 -->
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>dynamodb</artifactId>
</dependency>
<!-- Lambda 서비스 -->
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>lambda</artifactId>
</dependency>
</dependencies>
Gradle을 사용한다면 build.gradle에 이렇게 추가해:
dependencies {
implementation platform('software.amazon.awssdk:bom:2.20.26')
implementation 'software.amazon.awssdk:s3'
implementation 'software.amazon.awssdk:dynamodb'
implementation 'software.amazon.awssdk:lambda'
}
🔐 인증 설정하기
AWS SDK를 사용하려면 먼저 인증 정보를 설정해야 해. AWS는 여러 가지 인증 방법을 제공하는데, 가장 일반적인 방법들을 알아보자:
가장 간단한 방법이야. 환경 변수에 AWS 자격 증명을 설정하면 SDK가 자동으로 읽어와.
export AWS_ACCESS_KEY_ID=your_access_key
export AWS_SECRET_ACCESS_KEY=your_secret_key
export AWS_DEFAULT_REGION=ap-northeast-2
~/.aws/credentials 파일에 자격 증명을 저장하는 방법이야. 여러 프로필을 관리할 수 있어서 편리해.
[default]
aws_access_key_id = your_access_key
aws_secret_access_key = your_secret_key
[production]
aws_access_key_id = prod_access_key
aws_secret_access_key = prod_secret_key
EC2, ECS, Lambda 등 AWS 서비스에서 실행될 때는 IAM Role을 사용하는 게 가장 안전하고 편리해. 자격 증명을 코드에 하드코딩할 필요가 없거든!
// IAM Role을 사용하면 별도 설정 없이 자동으로 인증됨
S3Client s3Client = S3Client.builder()
.region(Region.AP_NORTHEAST_2)
.build();
자바 코드에서 특정 프로필을 사용하고 싶다면 이렇게 하면 돼:
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
public class AwsClientExample {
public static void main(String[] args) {
// 특정 프로필 사용
S3Client s3Client = S3Client.builder()
.region(Region.AP_NORTHEAST_2)
.credentialsProvider(
ProfileCredentialsProvider.create("production")
)
.build();
// 사용 후 반드시 닫아주기
s3Client.close();
}
}
📦 Amazon S3와 자바로 파일 다루기
Amazon S3(Simple Storage Service)는 AWS의 대표적인 객체 스토리지 서비스야. 무제한 용량에 99.999999999%(11 nines)의 내구성을 자랑하지! 이미지, 동영상, 백업 파일 등 모든 종류의 데이터를 저장할 수 있어. 🗄️
🎯 S3 기본 작업 - 버킷과 객체
S3에서는 데이터를 "객체(Object)"라고 부르고, 객체들을 담는 컨테이너를 "버킷(Bucket)"이라고 해. 버킷 이름은 전 세계적으로 고유해야 하니까 주의해야 해!
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.*;
import java.io.File;
import java.nio.file.Paths;
public class S3Example {
private final S3Client s3Client;
private final String bucketName = "my-awesome-bucket-2024";
public S3Example() {
this.s3Client = S3Client.builder()
.region(Region.AP_NORTHEAST_2)
.build();
}
// 버킷 생성
public void createBucket() {
try {
CreateBucketRequest createBucketRequest = CreateBucketRequest.builder()
.bucket(bucketName)
.createBucketConfiguration(
CreateBucketConfiguration.builder()
.locationConstraint(BucketLocationConstraint.AP_NORTHEAST_2)
.build()
)
.build();
s3Client.createBucket(createBucketRequest);
System.out.println("버킷 생성 완료: " + bucketName);
} catch (S3Exception e) {
System.err.println("버킷 생성 실패: " + e.awsErrorDetails().errorMessage());
}
}
// 파일 업로드
public void uploadFile(String filePath, String keyName) {
try {
PutObjectRequest putObjectRequest = PutObjectRequest.builder()
.bucket(bucketName)
.key(keyName)
.contentType("image/jpeg") // 파일 타입에 맞게 설정
.build();
s3Client.putObject(putObjectRequest,
RequestBody.fromFile(new File(filePath)));
System.out.println("파일 업로드 완료: " + keyName);
} catch (S3Exception e) {
System.err.println("업로드 실패: " + e.awsErrorDetails().errorMessage());
}
}
// 파일 다운로드
public void downloadFile(String keyName, String downloadPath) {
try {
GetObjectRequest getObjectRequest = GetObjectRequest.builder()
.bucket(bucketName)
.key(keyName)
.build();
s3Client.getObject(getObjectRequest,
Paths.get(downloadPath));
System.out.println("파일 다운로드 완료: " + downloadPath);
} catch (S3Exception e) {
System.err.println("다운로드 실패: " + e.awsErrorDetails().errorMessage());
}
}
// 파일 목록 조회
public void listObjects() {
try {
ListObjectsV2Request listRequest = ListObjectsV2Request.builder()
.bucket(bucketName)
.maxKeys(10)
.build();
ListObjectsV2Response listResponse = s3Client.listObjectsV2(listRequest);
System.out.println("버킷 내 객체 목록:");
for (S3Object object : listResponse.contents()) {
System.out.println(" - " + object.key() +
" (크기: " + object.size() + " bytes)");
}
} catch (S3Exception e) {
System.err.println("목록 조회 실패: " + e.awsErrorDetails().errorMessage());
}
}
// 파일 삭제
public void deleteFile(String keyName) {
try {
DeleteObjectRequest deleteRequest = DeleteObjectRequest.builder()
.bucket(bucketName)
.key(keyName)
.build();
s3Client.deleteObject(deleteRequest);
System.out.println("파일 삭제 완료: " + keyName);
} catch (S3Exception e) {
System.err.println("삭제 실패: " + e.awsErrorDetails().errorMessage());
}
}
// 리소스 정리
public void close() {
s3Client.close();
}
}
⚡ 비동기 S3 작업으로 성능 향상
대용량 파일을 다루거나 여러 파일을 동시에 처리할 때는 비동기 클라이언트를 사용하면 훨씬 효율적이야. AWS SDK 2.x는 CompletableFuture를 사용한 완전한 비동기 API를 제공해!
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import java.nio.file.Paths;
import java.util.concurrent.CompletableFuture;
public class S3AsyncExample {
private final S3AsyncClient s3AsyncClient;
public S3AsyncExample() {
this.s3AsyncClient = S3AsyncClient.builder()
.region(Region.AP_NORTHEAST_2)
.build();
}
// 비동기 파일 업로드
public CompletableFuture<Void> uploadFileAsync(
String bucketName, String keyName, String filePath) {
PutObjectRequest putRequest = PutObjectRequest.builder()
.bucket(bucketName)
.key(keyName)
.build();
return s3AsyncClient.putObject(putRequest,
AsyncRequestBody.fromFile(Paths.get(filePath)))
.thenAccept(response -> {
System.out.println("비동기 업로드 완료: " + keyName);
})
.exceptionally(throwable -> {
System.err.println("업로드 실패: " + throwable.getMessage());
return null;
});
}
// 여러 파일 동시 업로드
public void uploadMultipleFiles(String bucketName, String... filePaths) {
CompletableFuture<?>[] futures = new CompletableFuture[filePaths.length];
for (int i = 0; i < filePaths.length; i++) {
String filePath = filePaths[i];
String keyName = Paths.get(filePath).getFileName().toString();
futures[i] = uploadFileAsync(bucketName, keyName, filePath);
}
// 모든 업로드가 완료될 때까지 대기
CompletableFuture.allOf(futures).join();
System.out.println("모든 파일 업로드 완료!");
}
public void close() {
s3AsyncClient.close();
}
}
🔒 S3 보안 설정
S3에 저장된 데이터의 보안은 매우 중요해. 기본적으로 S3 버킷은 비공개로 설정되지만, 추가적인 보안 조치를 취할 수 있어:
import software.amazon.awssdk.services.s3.model.*;
public class S3SecurityExample {
// 서버 측 암호화 설정
public void uploadWithEncryption(S3Client s3Client,
String bucketName, String keyName, String filePath) {
PutObjectRequest putRequest = PutObjectRequest.builder()
.bucket(bucketName)
.key(keyName)
.serverSideEncryption(ServerSideEncryption.AES256) // AES-256 암호화
.build();
s3Client.putObject(putRequest,
RequestBody.fromFile(new File(filePath)));
}
// 버킷 정책 설정 (특정 IP만 접근 허용)
public void setBucketPolicy(S3Client s3Client, String bucketName) {
String policyText = """
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "IPAllow",
"Effect": "Allow",
"Principal": "*",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::%s/*",
"Condition": {
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}
}]
}
""".formatted(bucketName);
PutBucketPolicyRequest policyRequest = PutBucketPolicyRequest.builder()
.bucket(bucketName)
.policy(policyText)
.build();
s3Client.putBucketPolicy(policyRequest);
}
// 객체 ACL 설정
public void setObjectAcl(S3Client s3Client,
String bucketName, String keyName) {
PutObjectAclRequest aclRequest = PutObjectAclRequest.builder()
.bucket(bucketName)
.key(keyName)
.acl(ObjectCannedACL.PRIVATE) // 비공개 설정
.build();
s3Client.putObjectAcl(aclRequest);
}
}
💾 DynamoDB로 NoSQL 데이터베이스 다루기
Amazon DynamoDB는 완전 관리형 NoSQL 데이터베이스 서비스야. 밀리초 단위의 빠른 응답 속도와 무제한 확장성을 제공하지! 특히 클라우드 네이티브 애플리케이션에서 많이 사용돼. 🚀
• 항목(Item): 테이블의 각 레코드. JSON 형식과 비슷해.
• 속성(Attribute): 항목의 각 필드.
• 파티션 키(Partition Key): 필수 기본 키. 데이터 분산의 기준이 돼.
• 정렬 키(Sort Key): 선택적 키. 파티션 내에서 정렬에 사용돼.
📝 DynamoDB 테이블 생성 및 기본 작업
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.*;
import java.util.HashMap;
import java.util.Map;
public class DynamoDBExample {
private final DynamoDbClient dynamoDbClient;
private final String tableName = "Users";
public DynamoDBExample() {
this.dynamoDbClient = DynamoDbClient.builder()
.region(Region.AP_NORTHEAST_2)
.build();
}
// 테이블 생성
public void createTable() {
try {
CreateTableRequest request = CreateTableRequest.builder()
.tableName(tableName)
.keySchema(
KeySchemaElement.builder()
.attributeName("userId")
.keyType(KeyType.HASH) // 파티션 키
.build(),
KeySchemaElement.builder()
.attributeName("timestamp")
.keyType(KeyType.RANGE) // 정렬 키
.build()
)
.attributeDefinitions(
AttributeDefinition.builder()
.attributeName("userId")
.attributeType(ScalarAttributeType.S) // String
.build(),
AttributeDefinition.builder()
.attributeName("timestamp")
.attributeType(ScalarAttributeType.N) // Number
.build()
)
.billingMode(BillingMode.PAY_PER_REQUEST) // 온디맨드 요금제
.build();
dynamoDbClient.createTable(request);
System.out.println("테이블 생성 완료: " + tableName);
} catch (DynamoDbException e) {
System.err.println("테이블 생성 실패: " + e.getMessage());
}
}
// 항목 추가
public void putItem(String userId, String name, String email) {
try {
Map<String, AttributeValue> item = new HashMap<>();
item.put("userId", AttributeValue.builder().s(userId).build());
item.put("timestamp", AttributeValue.builder()
.n(String.valueOf(System.currentTimeMillis())).build());
item.put("name", AttributeValue.builder().s(name).build());
item.put("email", AttributeValue.builder().s(email).build());
PutItemRequest request = PutItemRequest.builder()
.tableName(tableName)
.item(item)
.build();
dynamoDbClient.putItem(request);
System.out.println("항목 추가 완료: " + userId);
} catch (DynamoDbException e) {
System.err.println("항목 추가 실패: " + e.getMessage());
}
}
// 항목 조회
public void getItem(String userId, long timestamp) {
try {
Map<String, AttributeValue> key = new HashMap<>();
key.put("userId", AttributeValue.builder().s(userId).build());
key.put("timestamp", AttributeValue.builder()
.n(String.valueOf(timestamp)).build());
GetItemRequest request = GetItemRequest.builder()
.tableName(tableName)
.key(key)
.build();
GetItemResponse response = dynamoDbClient.getItem(request);
if (response.hasItem()) {
Map<String, AttributeValue> item = response.item();
System.out.println("조회 결과:");
System.out.println(" userId: " + item.get("userId").s());
System.out.println(" name: " + item.get("name").s());
System.out.println(" email: " + item.get("email").s());
} else {
System.out.println("항목을 찾을 수 없습니다.");
}
} catch (DynamoDbException e) {
System.err.println("조회 실패: " + e.getMessage());
}
}
// 항목 업데이트
public void updateItem(String userId, long timestamp, String newEmail) {
try {
Map<String, AttributeValue> key = new HashMap<>();
key.put("userId", AttributeValue.builder().s(userId).build());
key.put("timestamp", AttributeValue.builder()
.n(String.valueOf(timestamp)).build());
Map<String, AttributeValueUpdate> updates = new HashMap<>();
updates.put("email", AttributeValueUpdate.builder()
.value(AttributeValue.builder().s(newEmail).build())
.action(AttributeAction.PUT)
.build());
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.attributeUpdates(updates)
.build();
dynamoDbClient.updateItem(request);
System.out.println("항목 업데이트 완료");
} catch (DynamoDbException e) {
System.err.println("업데이트 실패: " + e.getMessage());
}
}
// 항목 삭제
public void deleteItem(String userId, long timestamp) {
try {
Map<String, AttributeValue> key = new HashMap<>();
key.put("userId", AttributeValue.builder().s(userId).build());
key.put("timestamp", AttributeValue.builder()
.n(String.valueOf(timestamp)).build());
DeleteItemRequest request = DeleteItemRequest.builder()
.tableName(tableName)
.key(key)
.build();
dynamoDbClient.deleteItem(request);
System.out.println("항목 삭제 완료");
} catch (DynamoDbException e) {
System.err.println("삭제 실패: " + e.getMessage());
}
}
public void close() {
dynamoDbClient.close();
}
}
🔍 DynamoDB 쿼리와 스캔
DynamoDB에서 데이터를 검색하는 방법은 크게 두 가지야. Query는 파티션 키를 기반으로 효율적으로 검색하고, Scan은 전체 테이블을 스캔해. 당연히 Query가 훨씬 빠르고 비용도 적게 들지!
import software.amazon.awssdk.services.dynamodb.model.*;
import java.util.HashMap;
import java.util.Map;
public class DynamoDBQueryExample {
private final DynamoDbClient dynamoDbClient;
// Query: 특정 사용자의 모든 활동 조회
public void queryUserActivities(String userId) {
try {
Map<String, AttributeValue> expressionValues = new HashMap<>();
expressionValues.put(":userId",
AttributeValue.builder().s(userId).build());
QueryRequest queryRequest = QueryRequest.builder()
.tableName("Users")
.keyConditionExpression("userId = :userId")
.expressionAttributeValues(expressionValues)
.build();
QueryResponse response = dynamoDbClient.query(queryRequest);
System.out.println("조회된 항목 수: " + response.count());
for (Map<String, AttributeValue> item : response.items()) {
System.out.println(" - " + item.get("name").s() +
" (" + item.get("timestamp").n() + ")");
}
} catch (DynamoDbException e) {
System.err.println("쿼리 실패: " + e.getMessage());
}
}
// Query: 특정 기간의 활동 조회
public void queryByTimeRange(String userId, long startTime, long endTime) {
try {
Map<String, AttributeValue> expressionValues = new HashMap<>();
expressionValues.put(":userId",
AttributeValue.builder().s(userId).build());
expressionValues.put(":startTime",
AttributeValue.builder().n(String.valueOf(startTime)).build());
expressionValues.put(":endTime",
AttributeValue.builder().n(String.valueOf(endTime)).build());
QueryRequest queryRequest = QueryRequest.builder()
.tableName("Users")
.keyConditionExpression(
"userId = :userId AND timestamp BETWEEN :startTime AND :endTime"
)
.expressionAttributeValues(expressionValues)
.build();
QueryResponse response = dynamoDbClient.query(queryRequest);
System.out.println("기간 내 활동: " + response.count() + "건");
} catch (DynamoDbException e) {
System.err.println("쿼리 실패: " + e.getMessage());
}
}
// Scan: 특정 조건의 모든 항목 검색 (비효율적, 주의!)
public void scanByEmail(String emailDomain) {
try {
Map<String, AttributeValue> expressionValues = new HashMap<>();
expressionValues.put(":domain",
AttributeValue.builder().s(emailDomain).build());
ScanRequest scanRequest = ScanRequest.builder()
.tableName("Users")
.filterExpression("contains(email, :domain)")
.expressionAttributeValues(expressionValues)
.build();
ScanResponse response = dynamoDbClient.scan(scanRequest);
System.out.println("스캔 결과: " + response.count() + "건");
System.out.println("스캔한 항목 수: " + response.scannedCount() + "건");
} catch (DynamoDbException e) {
System.err.println("스캔 실패: " + e.getMessage());
}
}
}
🎨 DynamoDB Enhanced Client 사용하기
AWS SDK 2.x는 DynamoDB Enhanced Client라는 고수준 API를 제공해. 이걸 사용하면 자바 객체를 직접 DynamoDB에 매핑할 수 있어서 훨씬 편리하지!
import software.amazon.awssdk.enhanced.dynamodb.*;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.*;
import java.time.Instant;
// DynamoDB 테이블에 매핑될 엔티티 클래스
@DynamoDbBean
public class User {
private String userId;
private Long timestamp;
private String name;
private String email;
private String status;
@DynamoDbPartitionKey
@DynamoDbAttribute("userId")
public String getUserId() { return userId; }
public void setUserId(String userId) { this.userId = userId; }
@DynamoDbSortKey
@DynamoDbAttribute("timestamp")
public Long getTimestamp() { return timestamp; }
public void setTimestamp(Long timestamp) { this.timestamp = timestamp; }
@DynamoDbAttribute("name")
public String getName() { return name; }
public void setName(String name) { this.name = name; }
@DynamoDbAttribute("email")
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
@DynamoDbAttribute("status")
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
}
// Enhanced Client 사용 예제
public class DynamoDBEnhancedExample {
private final DynamoDbEnhancedClient enhancedClient;
private final DynamoDbTable<User> userTable;
public DynamoDBEnhancedExample(DynamoDbClient dynamoDbClient) {
this.enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(dynamoDbClient)
.build();
this.userTable = enhancedClient.table("Users",
TableSchema.fromBean(User.class));
}
// 항목 저장 (훨씬 간단!)
public void saveUser(User user) {
userTable.putItem(user);
System.out.println("사용자 저장 완료: " + user.getUserId());
}
// 항목 조회
public User getUser(String userId, Long timestamp) {
Key key = Key.builder()
.partitionValue(userId)
.sortValue(timestamp)
.build();
return userTable.getItem(key);
}
// 항목 업데이트
public void updateUser(User user) {
userTable.updateItem(user);
System.out.println("사용자 업데이트 완료");
}
// 항목 삭제
public void deleteUser(String userId, Long timestamp) {
Key key = Key.builder()
.partitionValue(userId)
.sortValue(timestamp)
.build();
userTable.deleteItem(key);
System.out.println("사용자 삭제 완료");
}
// 쿼리 (타입 안전!)
public void queryUsers(String userId) {
QueryConditional queryConditional = QueryConditional
.keyEqualTo(Key.builder().partitionValue(userId).build());
PageIterable<User> results = userTable.query(queryConditional);
results.items().forEach(user -> {
System.out.println("User: " + user.getName() +
" (" + user.getEmail() + ")");
});
}
}
⚡ AWS Lambda로 서버리스 함수 만들기
AWS Lambda는 서버를 관리할 필요 없이 코드를 실행할 수 있는 서버리스 컴퓨팅 서비스야. 사용한 만큼만 비용을 지불하고, 자동으로 스케일링되니까 정말 편리하지! 🎯
🔨 Lambda 함수 작성하기
Lambda 함수를 자바로 작성하려면 먼저 핸들러 인터페이스를 구현해야 해. AWS는 여러 가지 핸들러 타입을 제공하는데, 가장 일반적인 방법을 알아보자:
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 com.google.gson.Gson;
import java.util.HashMap;
import java.util.Map;
// API Gateway와 연동되는 Lambda 함수
public class HelloWorldHandler implements
RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
private final Gson gson = new Gson();
@Override
public APIGatewayProxyResponseEvent handleRequest(
APIGatewayProxyRequestEvent request, Context context) {
// 로깅
context.getLogger().log("Lambda 함수 실행 시작");
context.getLogger().log("Request ID: " + context.getRequestId());
// 요청 파라미터 추출
Map<String, String> queryParams = request.getQueryStringParameters();
String name = queryParams != null ? queryParams.get("name") : "World";
// 응답 데이터 생성
Map<String, String> responseBody = new HashMap<>();
responseBody.put("message", "Hello, " + name + "!");
responseBody.put("timestamp", String.valueOf(System.currentTimeMillis()));
// API Gateway 응답 생성
APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();
response.setStatusCode(200);
response.setBody(gson.toJson(responseBody));
Map<String, String> headers = new HashMap<>();
headers.put("Content-Type", "application/json");
headers.put("Access-Control-Allow-Origin", "*");
response.setHeaders(headers);
return response;
}
}
Maven pom.xml에 필요한 의존성을 추가해야 해:
<dependencies>
<!-- Lambda Core -->
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-lambda-java-core</artifactId>
<version>1.2.2</version>
</dependency>
<!-- Lambda Events -->
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-lambda-java-events</artifactId>
<version>3.11.1</version>
</dependency>
<!-- JSON 처리 -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.10.1</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.4.1</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
🎯 실전 Lambda 함수 예제
이제 좀 더 실용적인 예제를 만들어보자. S3에 이미지가 업로드되면 자동으로 썸네일을 생성하는 Lambda 함수야:
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;
import com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.*;
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
public class ThumbnailGenerator implements RequestHandler<S3Event, String> {
private final S3Client s3Client = S3Client.create();
private static final int THUMBNAIL_WIDTH = 200;
private static final int THUMBNAIL_HEIGHT = 200;
@Override
public String handleRequest(S3Event s3Event, Context context) {
try {
// S3 이벤트에서 버킷과 키 정보 추출
S3EventNotification.S3EventNotificationRecord record =
s3Event.getRecords().get(0);
String bucketName = record.getS3().getBucket().getName();
String objectKey = record.getS3().getObject().getKey();
context.getLogger().log("처리 중: " + bucketName + "/" + objectKey);
// 원본 이미지 다운로드
GetObjectRequest getRequest = GetObjectRequest.builder()
.bucket(bucketName)
.key(objectKey)
.build();
InputStream imageStream = s3Client.getObject(getRequest);
BufferedImage originalImage = ImageIO.read(imageStream);
// 썸네일 생성
BufferedImage thumbnail = createThumbnail(originalImage);
// 썸네일을 바이트 배열로 변환
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ImageIO.write(thumbnail, "jpg", outputStream);
byte[] thumbnailBytes = outputStream.toByteArray();
// 썸네일을 S3에 업로드
String thumbnailKey = "thumbnails/" + objectKey;
PutObjectRequest putRequest = PutObjectRequest.builder()
.bucket(bucketName)
.key(thumbnailKey)
.contentType("image/jpeg")
.build();
s3Client.putObject(putRequest,
RequestBody.fromBytes(thumbnailBytes));
context.getLogger().log("썸네일 생성 완료: " + thumbnailKey);
return "Success: " + thumbnailKey;
} catch (Exception e) {
context.getLogger().log("오류 발생: " + e.getMessage());
throw new RuntimeException(e);
}
}
private BufferedImage createThumbnail(BufferedImage original) {
BufferedImage thumbnail = new BufferedImage(
THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT, BufferedImage.TYPE_INT_RGB);
Graphics2D graphics = thumbnail.createGraphics();
graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR);
graphics.drawImage(original, 0, 0,
THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT, null);
graphics.dispose();
return thumbnail;
}
}
⚙️ Lambda 함수 배포 및 설정
Lambda 함수를 배포하려면 먼저 JAR 파일을 빌드해야 해:
# Maven으로 빌드
mvn clean package
# 생성된 JAR 파일 확인
ls -lh target/*.jar
AWS CLI를 사용해서 Lambda 함수를 생성하고 배포할 수 있어:
# Lambda 함수 생성
aws lambda create-function \
--function-name thumbnail-generator \
--runtime java11 \
--role arn:aws:iam::123456789012:role/lambda-execution-role \
--handler com.example.ThumbnailGenerator::handleRequest \
--zip-file fileb://target/thumbnail-generator-1.0.jar \
--timeout 60 \
--memory-size 512
# S3 트리거 추가
aws lambda add-permission \
--function-name thumbnail-generator \
--statement-id s3-trigger \
--action lambda:InvokeFunction \
--principal s3.amazonaws.com \
--source-arn arn:aws:s3:::my-image-bucket
# S3 버킷에 이벤트 알림 설정
aws s3api put-bucket-notification-configuration \
--bucket my-image-bucket \
--notification-configuration file://notification.json
• 메모리 최적화: 메모리를 늘리면 CPU 성능도 함께 증가해. 적절한 밸런스를 찾는 게 중요해.
• 레이어 활용: 공통 라이브러리는 Lambda Layer로 분리하면 배포 크기를 줄일 수 있어.
• 환경 변수: 설정값은 환경 변수로 관리하면 코드 수정 없이 변경할 수 있어.
🌐 Spring Boot와 AWS SDK 통합하기
Spring Boot는 자바 생태계에서 가장 인기 있는 프레임워크야. AWS SDK와 Spring Boot를 함께 사용하면 엔터프라이즈급 클라우드 애플리케이션을 빠르게 개발할 수 있지! 🚀
📦 Spring Cloud AWS 설정
Spring Cloud AWS는 Spring Boot 애플리케이션에서 AWS 서비스를 쉽게 사용할 수 있도록 도와주는 프로젝트야. 먼저 의존성을 추가하자:
<dependencies>
<!-- Spring Boot Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- AWS SDK BOM -->
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>bom</artifactId>
<version>2.20.26</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- AWS SDK Services -->
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>s3</artifactId>
</dependency>
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>dynamodb-enhanced</artifactId>
</dependency>
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>sqs</artifactId>
</dependency>
</dependencies>
⚙️ AWS 클라이언트 Bean 설정
Spring의 의존성 주입을 활용해서 AWS 클라이언트를 Bean으로 등록하자:
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.services.sqs.SqsClient;
@Configuration
public class AwsConfig {
private static final Region REGION = Region.AP_NORTHEAST_2;
@Bean
public S3Client s3Client() {
return S3Client.builder()
.region(REGION)
.build();
}
@Bean
public DynamoDbClient dynamoDbClient() {
return DynamoDbClient.builder()
.region(REGION)
.build();
}
@Bean
public DynamoDbEnhancedClient dynamoDbEnhancedClient(
DynamoDbClient dynamoDbClient) {
return DynamoDbEnhancedClient.builder()
.dynamoDbClient(dynamoDbClient)
.build();
}
@Bean
public SqsClient sqsClient() {
return SqsClient.builder()
.region(REGION)
.build();
}
}
🎯 실전 Spring Boot + AWS 예제
이제 실제로 사용할 수 있는 파일 업로드 서비스를 만들어보자:
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.*;
import java.io.IOException;
import java.util.UUID;
@Service
public class FileUploadService {
private final S3Client s3Client;
@Value("${aws.s3.bucket-name}")
private String bucketName;
public FileUploadService(S3Client s3Client) {
this.s3Client = s3Client;
}
public String uploadFile(MultipartFile file) throws IOException {
// 고유한 파일명 생성
String fileName = UUID.randomUUID() + "_" + file.getOriginalFilename();
// S3에 업로드
PutObjectRequest putRequest = PutObjectRequest.builder()
.bucket(bucketName)
.key(fileName)
.contentType(file.getContentType())
.contentLength(file.getSize())
.build();
s3Client.putObject(putRequest,
RequestBody.fromInputStream(file.getInputStream(), file.getSize()));
// 파일 URL 반환
return getFileUrl(fileName);
}
public String getFileUrl(String fileName) {
return String.format("https://%s.s3.%s.amazonaws.com/%s",
bucketName,
s3Client.serviceClientConfiguration().region().id(),
fileName);
}
public void deleteFile(String fileName) {
DeleteObjectRequest deleteRequest = DeleteObjectRequest.builder()
.bucket(bucketName)
.key(fileName)
.build();
s3Client.deleteObject(deleteRequest);
}
public byte[] downloadFile(String fileName) throws IOException {
GetObjectRequest getRequest = GetObjectRequest.builder()
.bucket(bucketName)
.key(fileName)
.build();
return s3Client.getObjectAsBytes(getRequest).asByteArray();
}
}
컨트롤러도 만들어보자:
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
@RestController
@RequestMapping("/api/files")
public class FileController {
private final FileUploadService fileUploadService;
public FileController(FileUploadService fileUploadService) {
this.fileUploadService = fileUploadService;
}
@PostMapping("/upload")
public ResponseEntity<Map<String, String>> uploadFile(
@RequestParam("file") MultipartFile file) {
try {
if (file.isEmpty()) {
return ResponseEntity.badRequest()
.body(Map.of("error", "파일이 비어있습니다."));
}
String fileUrl = fileUploadService.uploadFile(file);
Map<String, String> response = new HashMap<>();
response.put("message", "파일 업로드 성공");
response.put("fileUrl", fileUrl);
response.put("fileName", file.getOriginalFilename());
return ResponseEntity.ok(response);
} catch (IOException e) {
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(Map.of("error", "파일 업로드 실패: " + e.getMessage()));
}
}
@DeleteMapping("/{fileName}")
public ResponseEntity<Map<String, String>> deleteFile(
@PathVariable String fileName) {
try {
fileUploadService.deleteFile(fileName);
return ResponseEntity.ok(Map.of("message", "파일 삭제 완료"));
} catch (Exception e) {
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(Map.of("error", "파일 삭제 실패: " + e.getMessage()));
}
}
@GetMapping("/download/{fileName}")
public ResponseEntity<byte[]> downloadFile(@PathVariable String fileName) {
try {
byte[] fileData = fileUploadService.downloadFile(fileName);
return ResponseEntity.ok()
.header("Content-Disposition",
"attachment; filename=\"" + fileName + "\"")
.body(fileData);
} catch (IOException e) {
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(null);
}
}
}
application.yml 설정 파일도 추가하자:
spring:
application:
name: cloud-native-app
servlet:
multipart:
max-file-size: 10MB
max-request-size: 10MB
aws:
s3:
bucket-name: my-application-bucket
region: ap-northeast-2
server:
port: 8080
logging:
level:
software.amazon.awssdk: DEBUG
📨 Amazon SQS로 메시지 큐 구현하기
Amazon SQS(Simple Queue Service)는 완전 관리형 메시지 큐 서비스야. 마이크로서비스 간 비동기 통신이나 작업 큐를 구현할 때 정말 유용하지! 📬
• 무제한 처리량
• 최소 1회 전달 보장
• 메시지 순서가 보장되지 않을 수 있음
• 대부분의 경우에 적합
2. FIFO Queue (선입선출 큐)
• 초당 최대 3,000개 메시지 처리
• 정확히 1회 전달 보장
• 메시지 순서 엄격히 보장
• 순서가 중요한 경우에 사용
💬 SQS 메시지 송수신 구현
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import org.springframework.stereotype.Service;
import com.google.gson.Gson;
import java.util.List;
import java.util.Map;
@Service
public class MessageQueueService {
private final SqsClient sqsClient;
private final Gson gson = new Gson();
private final String queueUrl;
public MessageQueueService(SqsClient sqsClient) {
this.sqsClient = sqsClient;
this.queueUrl = getQueueUrl("my-application-queue");
}
// 큐 URL 가져오기
private String getQueueUrl(String queueName) {
GetQueueUrlRequest request = GetQueueUrlRequest.builder()
.queueName(queueName)
.build();
return sqsClient.getQueueUrl(request).queueUrl();
}
// 메시지 전송
public void sendMessage(String messageBody) {
SendMessageRequest sendRequest = SendMessageRequest.builder()
.queueUrl(queueUrl)
.messageBody(messageBody)
.build();
SendMessageResponse response = sqsClient.sendMessage(sendRequest);
System.out.println("메시지 전송 완료. ID: " + response.messageId());
}
// 객체를 JSON으로 변환해서 전송
public <T> void sendObject(T object) {
String jsonMessage = gson.toJson(object);
sendMessage(jsonMessage);
}
// 메시지 수신
public List<Message> receiveMessages(int maxMessages) {
ReceiveMessageRequest receiveRequest = ReceiveMessageRequest.builder()
.queueUrl(queueUrl)
.maxNumberOfMessages(maxMessages)
.waitTimeSeconds(10) // Long polling
.build();
ReceiveMessageResponse response = sqsClient.receiveMessage(receiveRequest);
return response.messages();
}
// 메시지 처리 후 삭제
public void deleteMessage(String receiptHandle) {
DeleteMessageRequest deleteRequest = DeleteMessageRequest.builder()
.queueUrl(queueUrl)
.receiptHandle(receiptHandle)
.build();
sqsClient.deleteMessage(deleteRequest);
System.out.println("메시지 삭제 완료");
}
// 메시지 처리 시간 연장
public void changeMessageVisibility(String receiptHandle, int timeoutSeconds) {
ChangeMessageVisibilityRequest request =
ChangeMessageVisibilityRequest.builder()
.queueUrl(queueUrl)
.receiptHandle(receiptHandle)
.visibilityTimeout(timeoutSeconds)
.build();
sqsClient.changeMessageVisibility(request);
}
}
🔄 메시지 처리 워커 구현
백그라운드에서 계속 메시지를 처리하는 워커를 만들어보자:
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import software.amazon.awssdk.services.sqs.model.Message;
import java.util.List;
@Component
public class MessageWorker {
private final MessageQueueService queueService;
public MessageWorker(MessageQueueService queueService) {
this.queueService = queueService;
}
// 5초마다 메시지 확인
@Scheduled(fixedDelay = 5000)
public void processMessages() {
List<Message> messages = queueService.receiveMessages(10);
for (Message message : messages) {
try {
// 메시지 처리
processMessage(message);
// 처리 완료 후 삭제
queueService.deleteMessage(message.receiptHandle());
} catch (Exception e) {
System.err.println("메시지 처리 실패: " + e.getMessage());
// 처리 실패 시 가시성 타임아웃 연장
queueService.changeMessageVisibility(
message.receiptHandle(), 60);
}
}
}
private void processMessage(Message message) {
System.out.println("메시지 처리 중: " + message.body());
// 실제 비즈니스 로직 구현
// 예: 이메일 발송, 이미지 처리, 데이터 변환 등
// 시뮬레이션을 위한 대기
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println("메시지 처리 완료");
}
}
• 배치 처리: 여러 메시지를 한 번에 처리하면 효율적이야.
• Dead Letter Queue: 처리 실패한 메시지를 별도 큐로 보내서 나중에 분석할 수 있어.
• 멱등성 보장: 같은 메시지가 여러 번 처리되어도 문제없도록 설계해야 해.
🔐 AWS Secrets Manager로 보안 관리하기
애플리케이션에서 데이터베이스 비밀번호, API 키 같은 민감한 정보를 안전하게 관리하는 건 정말 중요해. AWS Secrets Manager를 사용하면 이런 정보들을 암호화해서 저장하고 자동으로 로테이션할 수 있어! 🔒
import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;
import software.amazon.awssdk.services.secretsmanager.model.*;
import com.google.gson.Gson;
import org.springframework.stereotype.Service;
import java.util.Map;
@Service
public class SecretsService {
private final SecretsManagerClient secretsClient;
private final Gson gson = new Gson();
public SecretsService() {
this.secretsClient = SecretsManagerClient.builder()
.region(Region.AP_NORTHEAST_2)
.build();
}
// 시크릿 생성
public void createSecret(String secretName, Map<String, String> secretData) {
String secretString = gson.toJson(secretData);
CreateSecretRequest createRequest = CreateSecretRequest.builder()
.name(secretName)
.description("Application secrets")
.secretString(secretString)
.build();
secretsClient.createSecret(createRequest);
System.out.println("시크릿 생성 완료: " + secretName);
}
// 시크릿 조회
public String getSecret(String secretName) {
GetSecretValueRequest getRequest = GetSecretValueRequest.builder()
.secretId(secretName)
.build();
GetSecretValueResponse response = secretsClient.getSecretValue(getRequest);
return response.secretString();
}
// JSON 시크릿을 Map으로 파싱
public Map<String, String> getSecretAsMap(String secretName) {
String secretString = getSecret(secretName);
return gson.fromJson(secretString, Map.class);
}
// 특정 키의 값만 가져오기
public String getSecretValue(String secretName, String key) {
Map<String, String> secrets = getSecretAsMap(secretName);
return secrets.get(key);
}
// 시크릿 업데이트
public void updateSecret(String secretName, Map<String, String> newSecretData) {
String secretString = gson.toJson(newSecretData);
UpdateSecretRequest updateRequest = UpdateSecretRequest.builder()
.secretId(secretName)
.secretString(secretString)
.build();
secretsClient.updateSecret(updateRequest);
System.out.println("시크릿 업데이트 완료: " + secretName);
}
}
Spring Boot 애플리케이션 시작 시 Secrets Manager에서 설정을 로드하는 방법:
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import javax.annotation.PostConstruct;
import java.util.Map;
@SpringBootApplication
public class CloudNativeApplication {
private final SecretsService secretsService;
public CloudNativeApplication(SecretsService secretsService) {
this.secretsService = secretsService;
}
public static void main(String[] args) {
SpringApplication.run(CloudNativeApplication.class, args);
}
@PostConstruct
public void loadSecrets() {
// 애플리케이션 시작 시 시크릿 로드
Map<String, String> secrets =
secretsService.getSecretAsMap("my-app/database");
// 시스템 프로퍼티로 설정
System.setProperty("db.username", secrets.get("username"));
System.setProperty("db.password", secrets.get("password"));
System.setProperty("db.host", secrets.get("host"));
System.out.println("시크릿 로드 완료");
}
}
📊 CloudWatch로 모니터링 및 로깅
프로덕션 환경에서는 애플리케이션의 상태를 실시간으로 모니터링하는 게 필수야. AWS CloudWatch를 사용하면 로그 수집, 메트릭 추적, 알람 설정 등을 할 수 있어! 📈
📝 CloudWatch Logs 통합
import software.amazon.awssdk.services.cloudwatchlogs.CloudWatchLogsClient;
import software.amazon.awssdk.services.cloudwatchlogs.model.*;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
@Service
public class CloudWatchLoggingService {
private final CloudWatchLogsClient logsClient;
private final String logGroupName = "/aws/application/my-app";
private final String logStreamName;
public CloudWatchLoggingService() {
this.logsClient = CloudWatchLogsClient.builder()
.region(Region.AP_NORTHEAST_2)
.build();
this.logStreamName = "instance-" + System.currentTimeMillis();
initializeLogStream();
}
private void initializeLogStream() {
try {
// 로그 그룹 생성 (이미 존재하면 무시)
CreateLogGroupRequest groupRequest = CreateLogGroupRequest.builder()
.logGroupName(logGroupName)
.build();
logsClient.createLogGroup(groupRequest);
} catch (ResourceAlreadyExistsException e) {
// 이미 존재하는 경우 무시
}
// 로그 스트림 생성
CreateLogStreamRequest streamRequest = CreateLogStreamRequest.builder()
.logGroupName(logGroupName)
.logStreamName(logStreamName)
.build();
logsClient.createLogStream(streamRequest);
}
public void logMessage(String message) {
InputLogEvent logEvent = InputLogEvent.builder()
.message(message)
.timestamp(System.currentTimeMillis())
.build();
PutLogEventsRequest request = PutLogEventsRequest.builder()
.logGroupName(logGroupName)
.logStreamName(logStreamName)
.logEvents(logEvent)
.build();
logsClient.putLogEvents(request);
}
public void logError(String message, Exception e) {
String errorMessage = String.format("[ERROR] %s - %s: %s",
message, e.getClass().getSimpleName(), e.getMessage());
logMessage(errorMessage);
}
}
📈 커스텀 메트릭 전송
import software.amazon.awssdk.services.cloudwatch.CloudWatchClient;
import software.amazon.awssdk.services.cloudwatch.model.*;
import org.springframework.stereotype.Service;
import java.time.Instant;
@Service
public class MetricsService {
private final CloudWatchClient cloudWatchClient;
private final String namespace = "MyApplication";
public MetricsService() {
this.cloudWatchClient = CloudWatchClient.builder()
.region(Region.AP_NORTHEAST_2)
.build();
}
// 단일 메트릭 전송
public void putMetric(String metricName, double value, StandardUnit unit) {
MetricDatum datum = MetricDatum.builder()
.metricName(metricName)
.value(value)
.unit(unit)
.timestamp(Instant.now())
.build();
PutMetricDataRequest request = PutMetricDataRequest.builder()
.namespace(namespace)
.metricData(datum)
.build();
cloudWatchClient.putMetricData(request);
}
// 차원(Dimension)이 있는 메트릭
public void putMetricWithDimension(String metricName, double value,
String dimensionName, String dimensionValue) {
Dimension dimension = Dimension.builder()
.name(dimensionName)
.value(dimensionValue)
.build();
MetricDatum datum = MetricDatum.builder()
.metricName(metricName)
.value(value)
.unit(StandardUnit.COUNT)
.timestamp(Instant.now())
.dimensions(dimension)
.build();
PutMetricDataRequest request = PutMetricDataRequest.builder()
.namespace(namespace)
.metricData(datum)
.build();
cloudWatchClient.putMetricData(request);
}
// 응용: API 호출 횟수 추적
public void trackApiCall(String endpoint, boolean success) {
putMetricWithDimension(
"ApiCalls",
1.0,
"Endpoint",
endpoint
);
if (!success) {
putMetricWithDimension(
"ApiErrors",
1.0,
"Endpoint",
endpoint
);
}
}
// 응용: 처리 시간 추적
public void trackProcessingTime(String operation, long milliseconds) {
putMetricWithDimension(
"ProcessingTime",
milliseconds,
"Operation",
operation
);
}
}
🎓 클라우드 네이티브 개발 Best Practices
지금까지 배운 내용들을 실전에서 잘 활용하려면 몇 가지 중요한 원칙들을 알아야 해. 이제 클라우드 네이티브 개발의 베스트 프랙티스를 정리해보자! ✨
• 코드베이스: 버전 관리되는 하나의 코드베이스, 여러 배포
• 의존성: 명시적으로 선언하고 분리
• 설정: 환경 변수에 저장
• 백엔드 서비스: 연결된 리소스로 취급
• 빌드, 릴리스, 실행: 엄격하게 분리
• 프로세스: 무상태(stateless)로 실행
• 포트 바인딩: 포트를 통해 서비스 노출
• 동시성: 프로세스 모델로 확장
• 폐기 가능: 빠른 시작과 우아한 종료
• 개발/프로덕션 일치: 환경을 최대한 비슷하게
• 로그: 이벤트 스트림으로 취급
• 관리 프로세스: 일회성 작업을 실행
• 단일 책임: 각 서비스는 하나의 비즈니스 기능에 집중
• 느슨한 결합: 서비스 간 의존성 최소화
• 독립적 배포: 다른 서비스에 영향 없이 배포 가능
• 데이터 독립성: 각 서비스가 자체 데이터베이스 소유
• API 우선: 명확한 API 계약 정의
• 최소 권한 원칙: IAM 역할에 필요한 최소한의 권한만 부여
• 암호화: 전송 중(TLS)과 저장 시(at-rest) 모두 암호화
• 시크릿 관리: 코드에 하드코딩 금지, Secrets Manager 사용
• 네트워크 격리: VPC, 보안 그룹, NACL 활용
• 감사 로깅: CloudTrail로 모든 API 호출 기록
• 캐싱 전략: ElastiCache(Redis/Memcached) 활용
• CDN 사용: CloudFront로 정적 콘텐츠 배포
• 비동기 처리: SQS, SNS로 작업 분산
• 연결 풀링: 데이터베이스 연결 재사용
• 압축: 데이터 전송 시 gzip 압축 사용
• 리소스 태깅: 모든 리소스에 태그 붙여서 비용 추적
• 자동 스케일링: 수요에 따라 리소스 조정
• Reserved Instances: 장기 사용 시 예약 인스턴스 구매
• S3 스토리지 클래스: 접근 빈도에 따라 적절한 클래스 선택
• Lambda 메모리 최적화: 적절한 메모리 크기 설정
🔄 CI/CD 파이프라인 구축
클라우드 네이티브 개발에서 CI/CD는 필수야. AWS CodePipeline, CodeBuild, CodeDeploy를 활용한 예제를 보자:
# buildspec.yml - CodeBuild 설정
version: 0.2
phases:
pre_build:
commands:
- echo Logging in to Amazon ECR...
- aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com
- REPOSITORY_URI=$AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/my-app
- COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
- IMAGE_TAG=${COMMIT_HASH:=latest}
build:
commands:
- echo Build started on `date`
- echo Building the Docker image...
- mvn clean package
- docker build -t $REPOSITORY_URI:latest .
- docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
post_build:
commands:
- echo Build completed on `date`
- echo Pushing the Docker images...
- docker push $REPOSITORY_URI:latest
- docker push $REPOSITORY_URI:$IMAGE_TAG
- echo Writing image definitions file...
- printf '[{"name":"my-app","imageUri":"%s"}]' $REPOSITORY_URI:$IMAGE_TAG > imagedefinitions.json
artifacts:
files:
- imagedefinitions.json
# Dockerfile - 멀티 스테이지 빌드
FROM maven:3.8-openjdk-17 AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests
FROM openjdk:17-jdk-slim
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
# 비root 사용자로 실행 (보안)
RUN useradd -m appuser
USER appuser
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]
🚀 실전 프로젝트: 풀스택 클라우드 네이티브 애플리케이션
이제 지금까지 배운 모든 내용을 종합해서 실제 동작하는 애플리케이션을 만들어보자! 간단한 이미지 공유 서비스를 구축할 거야. 📸
🏗️ 아키텍처 설계
• Backend API: Spring Boot (ECS Fargate에서 실행)
• 이미지 저장: S3
• 메타데이터: DynamoDB
• 이미지 처리: Lambda (썸네일 생성)
• 메시지 큐: SQS
• 인증: Cognito
• 모니터링: CloudWatch
💻 핵심 코드 구현
이미지 업로드 및 메타데이터 저장 서비스:
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.*;
import software.amazon.awssdk.enhanced.dynamodb.*;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.*;
import java.time.Instant;
import java.util.UUID;
// DynamoDB 엔티티
@DynamoDbBean
class ImageMetadata {
private String imageId;
private String userId;
private String originalUrl;
private String thumbnailUrl;
private Long uploadTime;
private String description;
private Long fileSize;
@DynamoDbPartitionKey
public String getImageId() { return imageId; }
public void setImageId(String imageId) { this.imageId = imageId; }
@DynamoDbSortKey
public String getUserId() { return userId; }
public void setUserId(String userId) { this.userId = userId; }
// 나머지 getter/setter...
public String getOriginalUrl() { return originalUrl; }
public void setOriginalUrl(String originalUrl) { this.originalUrl = originalUrl; }
public String getThumbnailUrl() { return thumbnailUrl; }
public void setThumbnailUrl(String thumbnailUrl) { this.thumbnailUrl = thumbnailUrl; }
public Long getUploadTime() { return uploadTime; }
public void setUploadTime(Long uploadTime) { this.uploadTime = uploadTime; }
public String getDescription() { return description; }
public void setDescription(String description) { this.description = description; }
public Long getFileSize() { return fileSize; }
public void setFileSize(Long fileSize) { this.fileSize = fileSize; }
}
@Service
public class ImageService {
private final S3Client s3Client;
private final DynamoDbTable<ImageMetadata> imageTable;
private final String bucketName = "my-image-sharing-app";
public ImageService(S3Client s3Client,
DynamoDbEnhancedClient enhancedClient) {
this.s3Client = s3Client;
this.imageTable = enhancedClient.table("Images",
TableSchema.fromBean(ImageMetadata.class));
}
public ImageMetadata uploadImage(MultipartFile file,
String userId, String description) throws Exception {
// 고유 ID 생성
String imageId = UUID.randomUUID().toString();
String fileName = imageId + "_" + file.getOriginalFilename();
// S3에 업로드
PutObjectRequest putRequest = PutObjectRequest.builder()
.bucket(bucketName)
.key("originals/" + fileName)
.contentType(file.getContentType())
.metadata(Map.of(
"userId", userId,
"imageId", imageId
))
.build();
s3Client.putObject(putRequest,
RequestBody.fromInputStream(file.getInputStream(), file.getSize()));
// URL 생성
String imageUrl = String.format(
"https://%s.s3.amazonaws.com/originals/%s",
bucketName, fileName);
// 메타데이터 저장
ImageMetadata metadata = new ImageMetadata();
metadata.setImageId(imageId);
metadata.setUserId(userId);
metadata.setOriginalUrl(imageUrl);
metadata.setUploadTime(Instant.now().toEpochMilli());
metadata.setDescription(description);
metadata.setFileSize(file.getSize());
imageTable.putItem(metadata);
return metadata;
}
public List<ImageMetadata> getUserImages(String userId) {
QueryConditional queryConditional = QueryConditional
.sortBeginsWith(Key.builder()
.partitionValue(userId)
.build());
return imageTable.query(queryConditional)
.items()
.stream()
.collect(Collectors.toList());
}
public void deleteImage(String imageId, String userId) {
// 메타데이터 조회
Key key = Key.builder()
.partitionValue(imageId)
.sortValue(userId)
.build();
ImageMetadata metadata = imageTable.getItem(key);
if (metadata != null) {
// S3에서 삭제
String fileName = metadata.getOriginalUrl()
.substring(metadata.getOriginalUrl().lastIndexOf("/") + 1);
DeleteObjectRequest deleteRequest = DeleteObjectRequest.builder()
.bucket(bucketName)
.key("originals/" + fileName)
.build();
s3Client.deleteObject(deleteRequest);
// 썸네일도 삭제
if (metadata.getThumbnailUrl() != null) {
String thumbFileName = metadata.getThumbnailUrl()
.substring(metadata.getThumbnailUrl().lastIndexOf("/") + 1);
DeleteObjectRequest thumbDeleteRequest = DeleteObjectRequest.builder()
.bucket(bucketName)
.key("thumbnails/" + thumbFileName)
.build();
s3Client.deleteObject(thumbDeleteRequest);
}
// DynamoDB에서 삭제
imageTable.deleteItem(key);
}
}
}
REST API 컨트롤러:
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
@RestController
@RequestMapping("/api/images")
@CrossOrigin(origins = "*")
public class ImageController {
private final ImageService imageService;
public ImageController(ImageService imageService) {
this.imageService = imageService;
}
@PostMapping("/upload")
public ResponseEntity<ImageMetadata> uploadImage(
@RequestParam("file") MultipartFile file,
@RequestParam("userId") String userId,
@RequestParam(value = "description", required = false) String description) {
try {
if (file.isEmpty()) {
return ResponseEntity.badRequest().build();
}
// 파일 크기 제한 (10MB)
if (file.getSize() > 10 * 1024 * 1024) {
return ResponseEntity.status(413).build();
}
// 이미지 파일 타입 검증
String contentType = file.getContentType();
if (contentType == null || !contentType.startsWith("image/")) {
return ResponseEntity.badRequest().build();
}
ImageMetadata metadata = imageService.uploadImage(
file, userId, description);
return ResponseEntity.ok(metadata);
} catch (Exception e) {
return ResponseEntity.internalServerError().build();
}
}
@GetMapping("/user/{userId}")
public ResponseEntity<List<ImageMetadata>> getUserImages(
@PathVariable String userId) {
try {
List<ImageMetadata> images = imageService.getUserImages(userId);
return ResponseEntity.ok(images);
} catch (Exception e) {
return ResponseEntity.internalServerError().build();
}
}
@DeleteMapping("/{imageId}")
public ResponseEntity<Void> deleteImage(
@PathVariable String imageId,
@RequestParam String userId) {
try {
imageService.deleteImage(imageId, userId);
return ResponseEntity.noContent().build();
} catch (Exception e) {
return ResponseEntity.internalServerError().build();
}
}
}
🎯 재능넷에서 클라우드 개발 전문가 되기
자, 여기까지 자바와 AWS SDK를 활용한 클라우드 네이티브 개발에 대해 알아봤어! 정말 많은 내용을 다뤘지? 😊
클라우드 네이티브 개발은 단순히 기술을 배우는 것을 넘어서, 새로운 사고방식을 익히는 과정이야. 전통적인 온프레미스 환경에서는 서버 한 대를 최대한 효율적으로 사용하는 게 중요했다면, 클라우드에서는 필요할 때 리소스를 늘리고 줄이는 탄력성이 핵심이지.
1단계: 기초 다지기
• 자바 기본기 탄탄히 하기
• Spring Boot 마스터하기
• AWS 핵심 서비스 이해하기 (EC2, S3, RDS)
2단계: 클라우드 네이티브 기술
• Docker 컨테이너화
• Kubernetes 오케스트레이션
• 마이크로서비스 아키텍처 설계
3단계: 고급 AWS 서비스
• Lambda 서버리스
• DynamoDB NoSQL
• SQS/SNS 메시징
• API Gateway
4단계: DevOps & 자동화
• CI/CD 파이프라인 구축
• Infrastructure as Code (Terraform, CloudFormation)
• 모니터링 및 로깅
• 보안 베스트 프랙티스
재능넷(https://www.jaenung.net)에서는 이런 클라우드 개발 기술을 배우고 싶은 사람들과 가르치고 싶은 전문가들이 만날 수 있어. 만약 여러분이 이 글을 통해 클라우드 개발에 관심이 생겼다면, 재능넷에서 멘토를 찾아보는 것도 좋은 방법이야. 반대로 여러분이 이미 클라우드 전문가라면, 재능넷에서 여러분의 지식을 나누고 수익도 창출할 수 있지!
📚 추가 학습 리소스
• AWS SDK for Java 문서
• Spring Cloud AWS
• AWS 아키텍처 센터
• Java 공식 문서
• AWS Certified Developer
• Spring Boot 마스터클래스
• Kubernetes 완벽 가이드
• 클라우드 아키텍처 패턴
• AWS Free Tier
• AWS Workshops
• GitHub 오픈소스
• 재능넷 프로젝트
🚀 마치며
클라우드 네이티브 개발은 계속 진화하고 있어. 새로운 서비스와 기술이 끊임없이 나오고 있지만, 이 글에서 다룬 핵심 개념들은 변하지 않아. S3로 파일을 저장하고, DynamoDB로 데이터를 관리하고, Lambda로 서버리스 함수를 실행하는 이런 기본적인 패턴들은 앞으로도 계속 사용될 거야.
가장 중요한 건 직접 해보는 것이야! AWS Free Tier를 활용하면 대부분의 서비스를 무료로 체험할 수 있으니까, 이 글의 예제 코드들을 직접 실행해보면서 감을 익혀봐. 처음에는 어려울 수 있지만, 하나씩 따라하다 보면 어느새 클라우드 네이티브 애플리케이션을 자유자재로 만들 수 있게 될 거야! 💪
혹시 막히는 부분이 있거나 더 깊이 배우고 싶다면, 재능넷의 '지식인의 숲'에서 다른 개발자들의 경험담도 찾아보고, 필요하다면 전문가의 도움을 받는 것도 좋은 방법이야. 클라우드 개발은 혼자 하는 것보다 함께 배우고 성장할 때 훨씬 더 재미있거든! 🌟
자, 이제 여러분의 첫 클라우드 네이티브 애플리케이션을 만들어볼 시간이야. 화이팅! 🚀
🎉 축하합니다!
자바 클라우드와 AWS SDK를 활용한 클라우드 네이티브 개발의 세계를 탐험했습니다.
이제 여러분도 현대적인 클라우드 애플리케이션을 만들 수 있는 개발자입니다!
계속 학습하고 실습하면서 더 멋진 서비스를 만들어보세요! ☁️✨
관련 키워드
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.