AWS S3 생성
AWS S3 서비스 소개
AWS S3는 인터넷 스토리지 서비스로, S3는 Simple, Storage, Service의 약자이다. 파일 저장 서비스로 데이터를 객체 형태로 저장하는 역할을 수행한다. 주로 이미지, 영상 파일을 저장하기 위해 사용된다. 해당 서비스를 이용하면 다음과 같은 이점을 얻을 수 있다.
- 높은 내구성과 보안성
SSL을 통해 데이터를 전송 및 암호화하므로 해킹의 위험으로부터 안전하다. - 저렴한 비용
EC2에 이미지, 영상을 저장할 때보다 더 저렴한 비용으로 사용 가능하다. - 빠른 처리속도
파일 저장에 최적화되어 있어 업로드/다운로드 속도가 빠르다.
배경지식
객체
S3에 데이터가 저장되는 기본 단위로 파일과 메타데이터로 이뤄진다. 객체 하나의 크기는 1Byte부터 5TB까지 허용되며, 메타데이터는 MIME 형식으로 파일 확장자를 통해 자동으로 설정된다.(임의 지정 가능)
버킷
S3에서 생성할 수 있는 최상위 디렉터리의 개념으로 이름은 S3 리전 중에서 유일해야 한다. 계정별로 100개까지 생성 가능하며, 버킷에 저장할 수 있는 객체 수와 용량에는 제한이 없다.
표준 스토리지
S3 서비스 수준 계약으로 객체에 대해 높은 내구성과 가용성을 제공한다. 하지만 높은 내구성을 보장하는 만큼 비용이 높아 유실되면 안되는 원본 데이터, 민감정보, 개인정보 등의 데이터를 저장하는 것이 적합하다.
참고 : 객체의 내구성과 가용성
내구성(Durability)란 시스템이 발생한 데이터를 영구적으로 저장하고 보존하는 능력을 의미한다. 데이터가 시스템에 기록되면, 시스템 장애나 전원 이상과 같은 상황에서도 데이터는 보존되어야 한다. 내구성은 데이터의 지속성을 보장하는 척도이다.
가용성(Availability)은 시스템이 사용자에게 지속적으로 서비스를 제공하고 사용 가능한 상태를 유지하는 능력을 의미한다. 시스템은 장애, 네트워크 문제, 예기치 못한 상황 등에도 계속해서 사용자 요청에 응답할 수 있어야 한다. 가용성은 시스템의 신뢰성과 지속 운영을 보장하는 척도이다.
RRS(Reduced Redundancy Storage)
표준 스토리지보다 저렴한 비용으로 데이터를 저장할 수 있는 형태의 저장 방식이다. 일반 S3 객체에 비해 데이터 손실 확률이 높다.
S3 생성
AWS S3 서비스에 접속한 후 버킷 만들기 버튼을 클릭한다. 버킷 이름의 경우 대문자를 사용할 수 없으며 설정 리전에서 유일해야 한다.
외부에 S3를 공개하기 위해서 아래와 같이 설정해주자.
버킷 버전 관리는 비활성화 설정해야 과금이 되지 않는다. 활성화할 경우 파일을 버전별로 관리해주기 때문에 삭제 파일에 대한 복원 기능을 제공해준다. 고급 설정은 그대로 두고 생성을 완료한다.
Public Access 설정(퍼블릭 정책 활성화)
생성된 버킷을 클릭하여 권한 → 버킷 정책 → 편집 → 정책 생성기로 들어간다.
아래와 같이 설정해준다.
- Select Type of Policy: S3 Bucket Policy
- Effect: Allow (접근하는 모든 사람을 허용)
- Principal: * (모두에게 접근 권한 부여)
- Actions: GetObject, PutObject, DeleteObject (파일 조회, 업로드, 삭제)
- ARN: arn:aws:s3:::내 버킷 이름
Add Statement를 누르고 Generate Policy를 클릭하면 나오는 내용을 복사해주자.
해당 내용을 버킷 정책에 붙여넣으면, 접근 경로를 지정해주지 않아 에러가 발생한다. 해결법은 Resource 속성 값의 맨 뒤에 /* 을 달아주면 된다. 만약, 특정 폴더에만 접근 가능하게 하고 싶다면 특정 이름을 지정해주면 된다.
AWS S3와 스프링부트 연동
SpringBoot 환경 설정
spring-cloud-starter-aws 라이브러리를 의존성 추가하고 refresh 해주자.
implementation 'io.awspring.cloud:spring-cloud-starter-aws:2.4.4'implementation 'org.springframework.cloud:spring-cloud-starter-aws' 는 2021년 이후 업데이트가 안 되고 있어 위 경로로 의존성을 추가해주는 것이 좋다고 한다.
application.yml 파일에 다음 설정도 추가해주어야 한다.
spring:
servlet:
multipart:
max-request-size: 30MB
max-file-size: 30MB
cloud:
aws:
s3:
bucket: umcbucketchrome
region:
static: ap-northeast-2
stack:
auto: falseAcess Key, Secret Key 발급
S3를 스프링 부트에서 사용하려면 액세스 키와 비밀 키를 이용하여 인증해야 한다. 이런 액세스 키와 비밀 키는 AWS IAM을 통해 발급받을 수 있다.
IAM 서비스의 사용자 → 사용자 추가로 접속한다.
권한 설정에서는 선택 사항은 그대로 둔 채 아래와 같이 설정한다.
만든 IAM 사용자 메뉴로 들어가 액세스 키 만들기를 클릭한다.
설명 태그는 선택 사항이니 넘어간다. 생성된 액세스 키, 비밀 키를 복사해둔다.
당연한 얘기지만 이런 키들은 외부에 노출되어선 안 된다.
SpringBoot S3 관련 추가 설정
application.yml
spring:
datasource:
url: ${DB_URL}
username: ${DB_USERNAME}
password: ${DB_PW}
driver-class-name: com.mysql.cj.jdbc.Driver
jpa:
properties:
hibernate:
dialect: org.hibernate.dialect.MySQLDialect
hbm2ddl:
auto: create
show-sql: true
servlet:
multipart:
max-request-size: 30MB
max-file-size: 30MB
cloud:
aws:
credentials:
access-key: ${S3_ACCESS_KEY}
secret-key: ${S3_SECRET_KEY}
s3:
bucket: spring-all-in-one-bucket
region:
static: ap-northeast-2
stack:
auto: falseS3Config
package com.example.springallinoneproject.config;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class S3Config {
@Value("${S3_ACCESS_KEY}")
private String accessKey;
@Value("${S3_SECRET_KEY}")
private String secretKey;
@Value("${cloud.aws.region.static}")
private String region;
@Bean
public AmazonS3 amazonS3Client() {
BasicAWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
return AmazonS3ClientBuilder
.standard()
.withCredentials(new AWSStaticCredentialsProvider(credentials))
.withRegion(region)
.build();
}
}AmazonS3AmazonS3가 인터페이스이고,AmazonS3Client가 구체클래스이다.AmazonS3Client는 AWS S3 서비스와 상호 작용하기 위한 클라이언트 클래스이다.
AWSCredentials객체- AWS 자격 증명(AWS Credentials)을 나타내는 객체이다.
- accessKey, secretKey, region 필드로부터 값을 가져와서
AWSCredentials객체를 생성하고 있다. BasicAWSCredentials는AWSCredentials인터페이스의 구체클래스로, 다형성을 활용해 객체를 생성하고 있다.
AmazonS3ClientBuilder- AWS S3 서비스에 대한 클라이언트를 구성하고 빌드하기 위한 빌더 클래스이다.
- standard() 메서드를 호출하여 기본 빌더를 생성한 뒤, 자격 증명 객체와 region을 지정한다.
- build() 메서드를 호출하여 AmazonS3 객체를 생성하여 반환한다.
AWS S3에 파일 업로드 및 삭제
버킷 설정
앞서 생성한 버킷 메뉴로 들어가 권한 탭을 누르고 내리다 보면 객체 소유권이 보인다. 편집을 통해 아래와 같이 설정을 변경한다.
ACL을 활성화하여 AWS S3 버킷 객체에 대한 접근 권한을 제어할 수 있다. S3 버킷은 기본적으로 개인 또는 팀의 액세스만 허용하도록 구성되어 있다. 따라서 ACL을 활성화하면, 적절한 액세스 제어를 위해 권한을 설정해야 한다. 이 권한은 앞서 설정해주었다.
SpringBoot를 통해 S3에 이미지를 업로드하는 기능을 개발해보기 위해 유저-유저이미지라는 상황을 가정하였다. S3 연동에 초점을 두고 있기에 세세한 로직 설명은 생략하였다.
User
package com.example.springallinoneproject.user.entity;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import java.util.ArrayList;
import java.util.List;
import lombok.AccessLevel;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Table(name = "users")
@Getter
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String email;
private String username;
private String password;
@Enumerated(value = EnumType.STRING)
private SocialType socialType;
@OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
private List<UserImage> userImages;
@Builder
public User(String email, String username, String password, SocialType socialType) {
this.email = email;
this.username = username;
this.password = password;
this.socialType = socialType;
userImages = new ArrayList<>();
}
public void addUserImage(UserImage userImage) {
userImages.add(userImage);
userImage.updateUser(this);
}
public boolean deleteUserImage(String deleteImageFilename) {
return userImages.removeIf(userImage ->
userImage.getFilename().equals(deleteImageFilename));
}
}UserImage
package com.example.springallinoneproject.user.entity;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import lombok.AccessLevel;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
public class UserImage {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String imageUrl;
private String filename;
@ManyToOne
@JoinColumn(name = "user_id")
private User user;
@Builder
public UserImage(String imageUrl, String filename) {
this.imageUrl = imageUrl;
this.filename = filename;
}
public void updateUser(User user) {
this.user = user;
}
}S3Service
package com.example.springallinoneproject.util;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.model.CannedAccessControlList;
import com.amazonaws.services.s3.model.DeleteObjectRequest;
import com.amazonaws.services.s3.model.ObjectMetadata;
import com.amazonaws.services.s3.model.PutObjectRequest;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.UUID;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
@Service
@RequiredArgsConstructor
public class S3Service {
private final AmazonS3 s3Client;
@Value("${cloud.aws.s3.bucket}")
private String bucket;
@Value("${cloud.aws.region.static}")
private String region;
private String createFilename(String filename) {
return UUID.randomUUID().toString().concat(getFileExtension(filename));
}
private String getFileExtension(String filename) {
try {
return filename.substring(filename.lastIndexOf("."));
} catch (StringIndexOutOfBoundsException e) {
throw new IllegalStateException("잘못된 형식의 파일(" + filename + ") 입니다.");
}
}
public GetS3Res uploadSingleFile(MultipartFile multipartFile) {
String filename = createFilename(multipartFile.getOriginalFilename());
ObjectMetadata objectMetadata = new ObjectMetadata();
objectMetadata.setContentLength(multipartFile.getSize());
objectMetadata.setContentType(multipartFile.getContentType());
try (InputStream inputStream = multipartFile.getInputStream()) {
s3Client.putObject(new PutObjectRequest(bucket, filename, inputStream, objectMetadata)
.withCannedAcl(CannedAccessControlList.PublicRead));
} catch (IOException e) {
throw new IllegalStateException("파일 업로드 실패");
}
return new GetS3Res(s3Client.getUrl(bucket, filename).toString(), filename);
}
public List<GetS3Res> uploadFiles(List<MultipartFile> multipartFiles) {
return multipartFiles.stream()
.map(this::uploadSingleFile)
.toList();
}
public void deleteFile(String filename) {
s3Client.deleteObject(new DeleteObjectRequest(bucket, filename));
}
}- 로직에서
filename을 파일을 고유하게 식별하기 위한 키로 사용하고 있기 때문에 파일을 업로드할 때createFilename로직에서 UUID를 활용하여getFileExtension을 통해 분리한 확장자에 합쳐 파일 이름을 형성해주고 있다. - 완전히 동일한 파일을 업로드하더라도
filename은 고유하게 설정된다.
MultiPartFile
- 스프링에서 파일 업로드를 다루기 위해 제공하는 인터페이스이다.
- 업로드된 파일의 메타데이터, 파일 데이터를 제공하며 파일 원본 이름, 크기, MIME 유형 등 정보를 얻을 수 있다.
MIME(Multipurpose Mail Extensions)는 인터넷에서 다양한 종류의 데이터를 식별하는 데 사용되는 표준으로, 데이터의 형식이나 유형을 나타내기 위해 사용된다. 주로 파일의 확장자에 기반하여 식별한다. 데이터의 특성과 형식을 나타내는 문자열로 구성되며 주 타입과 서브타입으로 구분된다. “text/plain”은 일반 텍스트 데이터를 나타낸다.
UserCommandService
package com.example.springallinoneproject.user.service;
import static com.example.springallinoneproject.user.dto.UserImageResponse.UserImageUploadResponse;
import com.example.springallinoneproject.converter.UserConverter;
import com.example.springallinoneproject.user.dto.UserResponse.UserImagesUploadResponse;
import com.example.springallinoneproject.user.entity.User;
import com.example.springallinoneproject.user.entity.UserImage;
import com.example.springallinoneproject.user.repository.UserImageRepository;
import com.example.springallinoneproject.user.repository.UserRepository;
import com.example.springallinoneproject.util.GetS3Res;
import com.example.springallinoneproject.util.S3Service;
import java.util.List;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
@Service
@RequiredArgsConstructor
@Transactional
@Slf4j
public class UserCommandService {
private final UserRepository userRepository;
private final UserImageRepository userImageRepository;
private final S3Service s3Service;
public UserImageUploadResponse uploadUserImage(Long userId, MultipartFile uploadImage){
User user = findById(userId);
GetS3Res getS3Res = s3Service.uploadSingleFile(uploadImage);
UserImage userImage = UserImage.builder()
.imageUrl(getS3Res.getImageUrl())
.filename(getS3Res.getFilename())
.build();
user.addUserImage(userImage);
saveUserImage(userImage);
return UserImageUploadResponse.builder()
.userId(userId)
.userImageId(userImage.getId())
.imageFilename(userImage.getFilename())
.imageUrl(userImage.getImageUrl())
.build();
}
public UserImagesUploadResponse uploadUserImages(Long userId, List<MultipartFile> uploadImages){
User user = findById(userId);
List<GetS3Res> getS3ResList = s3Service.uploadFiles(uploadImages);
List<UserImage> userImages = getS3ResList.stream()
.map(getS3Res -> new UserImage(getS3Res.getImageUrl(), getS3Res.getFilename()))
.toList();
userImages.forEach(user::addUserImage);
userImages.forEach(this::saveUserImage);
return UserConverter.toUserImagesResponse(userId, userImages);
}
public void deleteUserImage(Long userId, String deleteImageFilename){
User user = findById(userId);
if(!user.deleteUserImage(deleteImageFilename))
throw new IllegalStateException("해당 파일이 존재하지 않습니다");
s3Service.deleteFile(deleteImageFilename);
}
private UserImage saveUserImage(UserImage userImage){
return userImageRepository.save(userImage);
}
private User findById(Long id){
return userRepository.findById(id)
.orElseThrow(()->new IllegalStateException("해당 사용자가 존재하지 않음"));
}
}유저 이미지 업로드와 삭제 로직 모두 S3Service 를 통해 먼저 S3에 업로드/삭제 작업이 이루어진 뒤 DB에 적용되는 흐름으로 구성되어 있다.
UserController - 전체 코드
package com.example.springallinoneproject.user.controller;
import com.example.springallinoneproject.user.dto.UserImageRequest.DeleteUserImageRequest;
import com.example.springallinoneproject.user.dto.UserImageResponse.UserImageUploadResponse;
import com.example.springallinoneproject.user.dto.UserResponse.UserImagesUploadResponse;
import com.example.springallinoneproject.user.service.UserCommandService;
import java.util.List;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
@RestController
@RequiredArgsConstructor
@RequestMapping("/user")
public class UserController {
private final UserCommandService userCommandService;
@PostMapping("/{userId}/single-image")
public ResponseEntity<UserImageUploadResponse>
uploadSingleUserImage(@PathVariable Long userId,
@RequestPart(value = "image") MultipartFile uploadImage) {
UserImageUploadResponse response = userCommandService
.uploadUserImage(userId, uploadImage);
return ResponseEntity.ok(response);
}
@PostMapping("/{userId}/images")
public ResponseEntity<UserImagesUploadResponse>
uploadUserImaeges(@PathVariable Long userId,
@RequestPart(value = "images") List<MultipartFile> uploadImages) {
UserImagesUploadResponse response = userCommandService.uploadUserImages(userId, uploadImages);
return ResponseEntity.ok(response);
}
@DeleteMapping("/{userId}/image")
public ResponseEntity<Object> deleteUserImage(@PathVariable Long userId,
@RequestBody DeleteUserImageRequest request) {
userCommandService.deleteUserImage(userId, request.getDeleteImageFilename());
return ResponseEntity.accepted().build();
}
}@RequestPart
- HTTP 요청의 일부를 처리하기 위해 사용되는 어노테이션이다.
@RequestParam과 비슷한 역할을 수행하지만@RequestParam은 주로 쿼리 스트링 형식의 요청 파라미터를 처리하는 데 사용하고,@RequestPart는multipart/form-data형식의 요청 데이터를 처리하는 데 사용된다.- 파일 업로드와 관련된 작업을 수행하는데 주로 사용된다.
value속성을 통해 파라미터에 매핑할 값을 지정할 수 있다.
참고
먹고 살려고 개발 시작했지만, 이왕 하는 거 잘하고 싶다.