갱미니의 코딩일지

[Spring] x-www-form-urlencoded 요청 JSON 으로 변환하여 받기

gengminy — Mon, 1 Apr 2024 15:48:55 +0900

들어가며

스프링을 사용한 프로젝트에서 NHN KCP 결제 시스템을 연동하는 요구사항이 있었다.

우리 서버에서는 객체 필드명에 카멜 케이스를 사용하는데, 결제 서버에서는 스네이크 케이스로 보내주는 상황.

이를 @JsonProperty 로 매핑시키려고 했으나
해당 결제 서버에서 보내는 콜백 요청은 x-www-form-urlencded 를 사용 중이었다

따라서 Jackson 이 아닌 다른 컨버터가 사용되어 @JsonProperty 가 먹히지 않았다.

이를 커스텀 컨버터를 등록하여 JSON 으로 매핑시키도록 하여 해결해보자.

인코딩

application/x-www-form-urlencoded

HTML 의 form 태그에서 서버에 전송할 때 주로 사용되는 방식이다.

말 그대로 데이터를 서버에 전송하기 전에 URL 인코딩하여 전송한다.

공백은 '+', 특수문자는 '%x' 형태로 치환되고 키 값 쌍이 '&' 으로 구분되는 형태이다.

(name=John Doe, age=23)

=> name=John+Doe&age=23

application/json

JSON 형식으로 된 데이터를 전송하는 방법이다.

프론트엔드와 백엔드를 나누어 API 로 통신할 때 가장 익숙한 형태일 것이다.

{
    "name": "John Doe",
    "age": 23
}

Spring 의 요청 파싱 방법

Spring 은 여러 요청 방법을 Java 코드로 올바르게 파싱할 수 있도록 표준적인 컨버터를 제공한다.

public interface HttpMessageConverter<T> {
    boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);

    boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);

    List<MediaType> getSupportedMediaTypes();

    default List<MediaType> getSupportedMediaTypes(Class<?> clazz) {
        return !this.canRead(clazz, (MediaType)null) && !this.canWrite(clazz, (MediaType)null) ? Collections.emptyList() : this.getSupportedMediaTypes();
    }

    T read(Class<? extends T> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException;

    void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException;
}

Spring MVC 는 HttpMessageConverter 인터페이스를 제공한다.

canRead, canWrite 메서드를 통해 해당 객체에 적용 가능한지 여부를 파악하는데
여기에서 HTTP Header 의 Content-Type, Accept 를 기반으로 적절한 구현체를 선택하게 된다.

또한 인터페이스이기 때문에 WebMvcConfigurer 를 구현하여 얼마든지 확장 가능하다.

public class FormHttpMessageConverter implements HttpMessageConverter<MultiValueMap<String, ?>> {
    ...
    
    public FormHttpMessageConverter() {
        this.charset = DEFAULT_CHARSET;
        this.supportedMediaTypes.add(MediaType.APPLICATION_FORM_URLENCODED);
        this.supportedMediaTypes.add(MediaType.MULTIPART_FORM_DATA);
        this.supportedMediaTypes.add(MediaType.MULTIPART_MIXED);
        this.supportedMediaTypes.add(MediaType.MULTIPART_RELATED);
        this.partConverters.add(new ByteArrayHttpMessageConverter());
        this.partConverters.add(new StringHttpMessageConverter());
        this.partConverters.add(new ResourceHttpMessageConverter());
        this.applyDefaultCharset();
    }
    
    public MultiValueMap<String, String> read(@Nullable Class<? extends MultiValueMap<String, ?>> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
        MediaType contentType = inputMessage.getHeaders().getContentType();
        Charset charset = contentType != null && contentType.getCharset() != null ? contentType.getCharset() : this.charset;
        String body = StreamUtils.copyToString(inputMessage.getBody(), charset);
        String[] pairs = StringUtils.tokenizeToStringArray(body, "&");
        MultiValueMap<String, String> result = new LinkedMultiValueMap(pairs.length);
        
        ...

        return result;
    }
    
    ...
}

application/x-www-form-urlencoded 요청은 FormHttpMessageConverter 를 사용하여 파싱된다.

HTTP 요청의 데이터는 MultiValueMap 형태로 반환된다.

Jackson 관련 코드를 전혀 사용하지 않기 때문에 @JsonProperty 가 동작하지 않았던 것이다.

public class MappingJackson2HttpMessageConverter extends AbstractJackson2HttpMessageConverter {
    ...
    
    public MappingJackson2HttpMessageConverter(ObjectMapper objectMapper) {
        super(objectMapper, new MediaType[]{MediaType.APPLICATION_JSON, new MediaType("application", "*+json")});
    }
}

public abstract class AbstractJackson2HttpMessageConverter extends AbstractGenericHttpMessageConverter<Object> {
   ...

    protected AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper, MediaType supportedMediaType) {
        this(objectMapper);
        this.setSupportedMediaTypes(Collections.singletonList(supportedMediaType));
    }
    
    public Object read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
        JavaType javaType = this.getJavaType(type, contextClass);
        return this.readJavaType(javaType, inputMessage);
    }
    
    private Object readJavaType(JavaType javaType, HttpInputMessage inputMessage) throws IOException {
        MediaType contentType = inputMessage.getHeaders().getContentType();
        Charset charset = this.getCharset(contentType);
        ObjectMapper objectMapper = this.selectObjectMapper(javaType.getRawClass(), contentType);
        
        ...
    }
}

application/json 은 MappingJackson2HttpMessageConverter 을 통해 처리된다.

내부적으로 ObjectMapper 를 사용하기 때문에 Jackson 관련 어노테이션을 모두 사용할 수 있다.

결론적으로 form 요청에 Jackson 관련 어노테이션을 사용하려면 Jackson Converter 를 사용하도록 해야 한다.

Custom FormHttpMessageConverter

이제 스프링의 Http 요청 파싱 방법을 알았으니 이를 응용하여 커스텀 컨버터를 구현해보자.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface JsonFormData {}

우선 모든 form 요청에 대해 적용하는 것이 아닌 특정 요청에 대해서만 적용할 것이기 때문에
이를 지정하기 위한 커스텀 어노테이션을 구현한다.

@SuppressWarnings("all")
public class JsonFormUrlEncodedConverter<T> extends AbstractHttpMessageConverter<T> {

    /** JSON 매핑 안된 속성 오류 무시 */
    private static final ObjectMapper objectMapper =
            new ObjectMapper().configure(FAIL_ON_UNKNOWN_PROPERTIES, false);

    private static final FormHttpMessageConverter converter = new FormHttpMessageConverter();

    @Override
    protected boolean supports(Class<?> clazz) {
        return clazz.isAnnotationPresent(JsonFormData.class);
    }

    @Override
    protected T readInternal(Class<? extends T> clazz, HttpInputMessage inputMessage)
            throws IOException, HttpMessageNotReadableException {
        Map<String, String> vals = converter.read(null, inputMessage).toSingleValueMap();

        return objectMapper.convertValue(vals, clazz);
    }

    @Override
    protected void writeInternal(T clazz, HttpOutputMessage outputMessage)
            throws HttpMessageNotWritableException {}
}

이제 이를 사용하는 커스텀 컨버터를 구현한다.

AbstractHttpMessageConverter 를 상속하고 FormHttpMessageConverter 를 내부적으로 주입한다.

supports 메소드를 통해 convert 대상을 JsonFormData 를 메타 어노테이션으로 가지고 있는 클래스로 한정한다.

그리고 Map 으로 변환된 폼 요청 데이터를 objectMapper 를 통해 json 으로 변환하면 된다.

@Configuration
public class JsonFormUrlEncodedConverterConfiguration implements WebMvcConfigurer {
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        JsonFormUrlEncodedConverter<?> converter = new JsonFormUrlEncodedConverter<>();
        MediaType mediaType = new MediaType(APPLICATION_FORM_URLENCODED, UTF_8);
        converter.setSupportedMediaTypes(List.of(mediaType));
        converters.add(converter);
    }
}

마지막으로 Spring MVC 에 해당 컨버터를 등록해주면 끝이다.

WebMvcConfigurer 구현체를 만들어 MessageConverter 를 등록한다.

@Getter
@NoArgsConstructor
@JsonFormData
public class UserRequest {
    @JsonProperty("user_name")
    @NotNull
    private String userName;

    @JsonProperty("user_phone")
    private String userPhone;
}

@JsonFormData 를 적용하고자 하는 클래스의 메타 어노테이션으로 지정해준다.

@RestController
@RequestMapping("/user")
public class UserController {
    @PostMapping(value = "/callback", consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE)
    public ResponseEntity<?> callback(@Valid @RequestBody UserRequest userRequest) {
        return ResponseEntity.ok(UserResponse.builder()
                .userName(userRequest.getUserName())
                .userPhone(userRequest.getUserPhone())
                .build());
    }
}

컨트롤러 단에서는 consumes 와 @RequestBody 를 지정해준다.

이런 식으로 구현할 경우 java validation 의 @Valid 동작도 올바르게 수행되어 요청 검증이 쉬워진다.

application/x-www-form-urlencoded + @RequestBody 를 사용했음에도 요청이 올바르게 파싱된 모습

Validation 의 @NotNull 도 올바르게 동작한다.

마치며

코드 컨벤션이 다른 외부 API 를 연동하며 내부적인 컨벤션을 지키기 위해 고민했다.

그 과정에서 Spring 이 HttpMessageConverter 를 사용하고 확장하는 방식에 대해 알 수 있었다.

이를 응용하면 더 다양한 상황에서의 요청 필드 처리가 가능할 것 같다.

끝

[Spring] Jackson Module 을 이용한 Jackson 확장

gengminy — Mon, 25 Mar 2024 22:19:42 +0900

Custom Serializer / Deserializer 를 만들어 Jackson Module 에 등록하고,
이를 통해 Jackson 을 확장하여 기본 JSON 처리 방식을 변경하는 방법에 대한 글입니다.

들어가며

Java Spring 서버를 개발하다보면 Jackson 이라는 라이브러리를 많이 들어봤을 것이다.

Jackson 은 Java 진영에서 JSON 처리를 담당하는 라이브러리이다.
Java 객체를 JSON 으로 직렬화, 혹은 반대로 역직렬화할 수 있는 데이터 바인딩 기능을 제공한다.

현재 REST API 처리 방식에 JSON 요청, 응답을 가장 많이 사용하기 때문에 중요한 라이브러리라 할 수 있다.
그래서인지 현재 스프링 프레임워크에도 Jackson 이 기본적으로 탑재되어 있기도 하다.

Jackson Module

Jackson Module 은 Jackson 의 확장을 위한 추상 클래스로
커스텀 직렬화, 역직렬화, 타입 변환기를 Jackson 에 등록하여 확장할 수 있도록 한다.

public abstract class Module implements Versioned {
	
    ...
    
    public abstract void setupModule(SetupContext var1);

    
    public interface SetupContext {
        void addDeserializers(Deserializers var1);

        void addKeyDeserializers(KeyDeserializers var1);

        void addSerializers(Serializers var1);
    
        void addKeySerializers(Serializers var1);
        
        void setNamingStrategy(PropertyNamingStrategy var1);
        
        ...
    }
}

Jackson 은 이전 버전의 Java 에서 구현되었기 때문에
Java 8 에서 도입된 java.time 패키지를 자동으로 처리하지 못한다.

이를 해결하기 위한 jackson-datatype-jsr310 모듈의 JavaTimeModule 도 Jackson Module 이다.

또한 Kotlin 에서 자주 사용하는 jackson-module-kotlin 도
자주 사용되는 Jackson Module 중 하나이다.

이처럼 Module 을 구현하고 ObjectMapper 에 등록하면 사용할 수 있는데

Jackson 2.10 이상에서는 Jackson Module 을 Bean 으로 등록하기만 하면
ObjectMapper 에서 ServiceLoader 를 사용하여 classpath 상 모든 Module 구현체를 자동으로 탐색하고 등록한다.

이후 ObjectMapper 는 JSON 을 바인딩하는 과정에서
Context 에 등록된 Module 을 탐색하고 적절한 모듈을 찾아 바인딩하는데 사용하게 된다.

public JsonDeserializer<?> createEnumDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) throws JsonMappingException {
    DeserializationConfig config = ctxt.getConfig();
    Class<?> enumClass = type.getRawClass();
    JsonDeserializer<?> deser = this._findCustomEnumDeserializer(enumClass, config, beanDesc);
    if (deser == null) {
        if (enumClass == Enum.class) {
            return AbstractDeserializer.constructForNonPOJO(beanDesc);
        }

        ...
    }

    ...

    return (JsonDeserializer)deser;
}

protected JsonDeserializer<?> _findCustomEnumDeserializer(Class<?> type, DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException {
    Iterator var4 = this._factoryConfig.deserializers().iterator();

    JsonDeserializer deser;
    do {
        if (!var4.hasNext()) {
            return null;
        }

        Deserializers d = (Deserializers)var4.next();
        deser = d.findEnumDeserializer(type, config, beanDesc);
    } while(deser == null);

    return deser;
}

위 코드는 BasicDeserializerFactory.class 의 내부 구현 중 EnumDeserializer 에 대한 코드 일부이다.

사용자 정의 모듈을 최우선으로 선택하며 없을 경우 기본 Enum 처리 모듈을 사용하는 것을 알 수 있다.

public <T> MappingIterator<T> readValues(JsonParser p, JavaType valueType) throws IOException {
    this._assertNotNull("p", p);
    DeserializationConfig config = this.getDeserializationConfig();
    DeserializationContext ctxt = this.createDeserializationContext(p, config);
    JsonDeserializer<?> deser = this._findRootDeserializer(ctxt, valueType);
    return new MappingIterator(valueType, p, ctxt, deser, false, (Object)null);
}

ObjectMapper 는 Context 를 가져와 현재 존재하는 Module 을 탐색하고
가장 적절한 모듈을 가져와 JSON 매핑을 처리하게 된다.

이 중 눈여겨봐야 할 점은 Deserializers 클래스이다.

public interface Deserializers {
    JsonDeserializer<?> findEnumDeserializer(Class<?> var1, DeserializationConfig var2, BeanDescription var3) throws JsonMappingException;
    
    ...
    
    public abstract static class Base implements Deserializers {
        public Base() {
        }

        public JsonDeserializer<?> findEnumDeserializer(Class<?> type, DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException {
            return null;
        }
    }
}

Deserializers.class 는 JsonDeserializer 를 리턴하여
해당 클래스 타입에 맞는 Deserializaer 를 반환하거나
null 을 리턴하여 처리를 해당 처리기가 아닌 다른 Deserializer 에게 넘길 수 있다.

또한 내부 추상 메서드인 Base.class 를 구현하도록 강력하게 권장하고 있는데
나머지 타입에 대해 기본 처리기 구현체가 이미 만들어져 있기 때문이다.

즉 Deserializers.Base 를 구현하는 것을 통해
커스텀 Deserializer 를 구현하여 Jackson Module 로 등록할 수 있다.

이제 이를 구현해서 실제 Module 로 등록해보자.

Deserializer 등록

public class EnumDeserializer extends StdDeserializer<Enum> implements ContextualDeserializer {

    public EnumDeserializer() {
        this(null);
    }

    protected EnumDeserializer(Class<?> vc) {
        super(vc);
    }

    @SuppressWarnings("unchecked")
    @Override
    public Enum deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
        JsonNode jsonNode = jp.getCodec().readTree(jp);
        String text = jsonNode.asText();
        Class<? extends Enum> enumType = (Class<? extends Enum>) this._valueClass;
        return Arrays.stream(enumType.getEnumConstants()).filter(e -> {
            return e.name().equals(text);
        }).findAny().map(it -> Enum.valueOf(enumType, it.name())).orElse(null);
    }

    @Override
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
        return new EnumDeserializer(property.getType().getRawClass());
    }
}

다음과 같이 Custom Enum Deserializer 를 구현했다.

이 역직렬화기는 기대했던 Enum 타입 내부에 존재하는 값이 아닐 경우
JsonParseError 를 던지지 않고 null 값을 리턴하도록 한다.

Request Body 의 Enum 오류 처리를 위한 역직렬화기이고 프로젝트의 전역 에러 핸들링 설정으로 인해 사용하게 되었다.

자세한 것은 아래 링크에 포함된 3개의 게시글을 참조하면 좋을 것 같다.

https://gengminy.tistory.com/49

[Spring] 스프링 Custom Enum Deserializer 구현으로 JSON Enum null 로 파싱하기

https://gengminy.tistory.com/48 [Spring] 스프링 Enum Validator Reflection 으로 개선 및 구현하기 https://gengminy.tistory.com/47 [Spring] 스프링에서 Enum 클래스 Validation 추가하기 (Enum JSON parse error 해결) 스프링에서 일

gengminy.tistory.com

이제 이 Deserializer 를 Module 안에 포함시킨다.

@Configuration
public class JacksonConfig {
    @Bean
    public Module customEnumModule() {
        return new Module() {
            @Override
            public String getModuleName() {
                return "customEnumModule";
            }

            @Override
            public Version version() {
                return Version.unknownVersion();
            }

            @Override
            public void setupModule(SetupContext context) {
                context.addDeserializers(new Deserializers.Base() {
                    final Map<ClassKey, JsonDeserializer<?>> cache = new ConcurrentHashMap<>();

                    @Override
                    public JsonDeserializer<?> findEnumDeserializer(Class<?> type, DeserializationConfig config, BeanDescription beanDesc) {
                        if (Enum.class.isAssignableFrom(type)) {
                            JsonDeserializer<?> enumDeserializer = new EnumDeserializer(type);
                            addDeserializer(type, enumDeserializer);
                            return enumDeserializer;
                        }
                        return null;
                    }

                    @Override
                    public boolean hasDeserializerFor(DeserializationConfig config, Class<?> valueType) {
                        return cache.containsKey(new ClassKey(valueType));
                    }

                    public void addDeserializer(Class<?> forClass, JsonDeserializer<?> deserializer) {
                        ClassKey key = new ClassKey(forClass);
                        cache.put(key, deserializer);
                    }
                });
            }
        };
    }
}

Module 을 생성하고 필요한 추상 메서드를 구현한다.
이후 SetupContext 에서 Deserializers.Base() 를 인스턴스화 한다.

내부에는 findEnumDeserializer 를 오버라이딩하여 원하는 타입에 대해 Custom Deserializer 를 반환하도록 한다.

이 과정에서 Deserialzer 는 Lazy 하게 생성된다.

캐시를 두어 매번 역직렬화기를 생성하지 않고 이미 존재하는 Deserializer 를 가져와 처리하도록 할 수도 있다.

마치며

Jackson Module 을 알아보며 Custom Deserializer 를 Jackson Module 을 통해 등록하는 방식이
Jackson 이 의도하는 확장 방식에 가깝다고 확실히 느꼈다.

매번 @JsonCreator, @JsonDeserialize 등의 어노테이션을 사용하는 것 보다는
이처럼 전역적인 모듈 설정을 등록하는 것으로 중복을 없애고 깔끔하게 POJO 를 구성할 수 있을 것이다.

끝

[Spring] Swagger 공통 응답 예시 커스터마이징

gengminy — Sun, 17 Mar 2024 18:46:49 +0900

SuccessResponse 를 @RestControllerAdvice 를 이용해 전역 처리 중이며
Swagger Example 커스터마이징을 하고 싶은 경우
이 글을 읽어주시면 도움이 될 것 입니다.

들어가며

Swagger 를 사용중이며, @RestControllerAdvice 를 사용해 전역 응답을 설정중인 경우
Swagger 응답 예시에서 wrapping 시켜주는 객체가 나타나지 않는다.

최근에는 springfox 공식 업데이트가 멈췄고 springdocs 를 많이 사용중이다.
springfox 같은 경우 기본 설정으로 제네릭 클래스를 응답으로 선택할 수 있는데
springdocs 에서는 이를 지원해주지 않아 다른 방법을 사용해야 한다.

SuccessResponseAdvice 예시

@Getter
@NoArgsConstructor
public class SuccessResponse<T> {

    private final boolean success = true;
    private final LocalDateTime timeStamp = LocalDateTime.now();
    private int status;
    private T data;

    public SuccessResponse(T data) {
        this.status = 200;
        this.data = data;
    }

    public SuccessResponse(T data, int status) {
        this.status = status;
        this.data = data;
    }
}

@RestControllerAdvice(basePackages = "kr.co.swagger")
public class SuccessResponseAdvice implements ResponseBodyAdvice<Object> {
    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(
            Object body,
            MethodParameter returnType,
            MediaType selectedContentType,
            Class<? extends HttpMessageConverter<?>> selectedConverterType,
            ServerHttpRequest request,
            ServerHttpResponse response) {
        final HttpServletResponse servletResponse =
                ((ServletServerHttpResponse) response).getServletResponse();

        int status = servletResponse.getStatus();
        final HttpStatus resolve = HttpStatus.resolve(status);

        if (resolve == null) {
            return body;
        }

        if (resolve.is2xxSuccessful()) {
            return new SuccessResponse<>(body, status);
        }

        return body;
    }
}

예시 응답

실제 응답

이럴 경우 swagger 상에서 설정을 바꿔줘서 기본 예시를 wrapping 할 수 있다.

Swagger 동작 원리

{host}/v3/api-docs 로 접속할 경우 아래와 같이 swagger-ui 로 변환되기 이전의 JSON 데이터가 노출된다.
이를 바탕으로 스웨거는 화면에 API 문서를 띄우게 된다.

즉 이 JSON 데이터를 설정해준다면 스웨거가 그리는 화면을 수정할 수 있다는 것이다.

Swagger Customizer

스웨거에서는 customizer 라는 함수형 인터페이스를 제공하는데
이를 빈으로 등록하게 될 경우 커스터마이징을 할 수 있다

이 중에서 컨트롤러 메소드를 처리하는 OperationCustomizer 를 사용할 것이다.

@FunctionalInterface
public interface OperationCustomizer {
    Operation customize(Operation operation, HandlerMethod handlerMethod);
}

공통 응답 랩핑 처리

@Configuration
public class SwaggerConfig {
    ...

    @Bean
    public OperationCustomizer operationCustomizer() {
        return (operation, handlerMethod) -> {
            this.addResponseBodyWrapperSchemaExample(operation);
            return operation;
        };
    }

    private void addResponseBodyWrapperSchemaExample(Operation operation) {
        final Content content = operation.getResponses().get("200").getContent();
        if (content != null) {
            content.forEach((mediaTypeKey, mediaType) -> {
                Schema<?> originalSchema = mediaType.getSchema();
                Schema<?> wrappedSchema = wrapSchema(originalSchema);
                mediaType.setSchema(wrappedSchema);
            });
        }
    }

    private Schema<?> wrapSchema(Schema<?> originalSchema) {
        final Schema<?> wrapperSchema = new Schema<>();

        wrapperSchema.addProperty("success", new Schema<>().type("boolean").example(true));
        wrapperSchema.addProperty("timeStamp", new Schema<>().type("string").format("date-time").example(
                LocalDateTime.now().toString()));
        wrapperSchema.addProperty("status", new Schema<>().type("integer").example(200));
        wrapperSchema.addProperty("data", originalSchema);

        return wrapperSchema;
    }
}

operation 의 getResponses() 를 통해 예시 응답 리스트를 꺼내고 그 중에서 200 성공 응답에 대해 가져온다.
JSON 에서 각 컨트롤러 메소드의 예시는 응답 코드 쌍으로 그룹핑된다.

그 후 내부에서는 각 mediaType 별로 그룹핑되어 있는데, 이 중에서 Schema 를 꺼내면 원본 예시가 나오게 된다.
이를 새로운 응답으로 랩핑해주면 원하는 결과가 나올 것이다.

기존 JSON

...        
        "/user": {
            "get": {
                "tags": [
                    "사용자 API"
                ],
                "summary": "사용자 정보 조회",
                "description": "사용자 정보를 조회합니다.",
                "operationId": "getUser",
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json;charset=UTF-8": {
                                "schema": {
                                    "$ref": "#/components/schemas/UserResponse"
                                }
                            }
                        }
                    }
                }
            }
        }
...

새로운 JSON

...
			"/user": {
            "get": {
                "tags": [
                    "사용자 API"
                ],
                "summary": "사용자 정보 조회",
                "description": "사용자 정보를 조회합니다.",
                "operationId": "getUser",
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json;charset=UTF-8": {
                                "schema": {
                                    "properties": {
                                        "success": {
                                            "type": "boolean",
                                            "example": true
                                        },
                                        "timeStamp": {
                                            "type": "string",
                                            "format": "date-time",
                                            "example": "2024-03-17T18:30:50.334396"
                                        },
                                        "status": {
                                            "type": "integer",
                                            "example": 200
                                        },
                                        "data": {
                                            "$ref": "#/components/schemas/UserResponse"
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
...

결과

각 스키마에 property 가 지정되며 응답이 성공적으로 wrapping 되었다.
다만 각 필드를 삽입하는 과정에서 텍스트를 하드코딩하게 되는 문제가 있는데 리플렉션으로 해결해보았다.

@Configuration
public class SwaggerConfig {
    ...
    
    @Bean
    public OperationCustomizer operationCustomizer() {
        return (operation, handlerMethod) -> {
            this.addResponseBodyWrapperSchemaExample(operation, SuccessResponse.class, "data");
            return operation;
        };
    }
    
    private void addResponseBodyWrapperSchemaExample(Operation operation, Class<?> type, String wrapFieldName) {
        final Content content = operation.getResponses().get("200").getContent();
        if (content != null) {
            content.keySet()
                    .forEach(mediaTypeKey -> {
                        final MediaType mediaType = content.get(mediaTypeKey);
                        mediaType.schema(wrapSchema(mediaType.getSchema(), type, wrapFieldName));
                    });
        }
    }
    
    @SneakyThrows
    private <T> Schema<T> wrapSchema(Schema<?> originalSchema, Class<T> type, String wrapFieldName) {
        final Schema<T> wrapperSchema = new Schema<>();
        final T instance = type.getDeclaredConstructor().newInstance();
        
        for (Field field : type.getDeclaredFields()) {
            field.setAccessible(true);
            wrapperSchema.addProperty(field.getName(), new Schema<>().example(field.get(instance)));
            field.setAccessible(false);
        }
        wrapperSchema.addProperty(wrapFieldName, originalSchema);
        return wrapperSchema;
    }
}

이렇게 되면 SuccessResponse 필드 코드가 바뀌었을 때에도 조치가 가능하다.
이 부분은 최초 Swagger 로딩시에만 리플렉션이 동작하고 이후에는 캐싱되기 때문에 어느정도 감수할만 하다고 생각해서 적용해보았다.

스웨거 커스터마이징에 익숙해진다면 더 좋은 방법이 있을 수도 있을 것 같다.

마치며

스웨거 응답을 커스터마이징하여 API 문서의 공통 응답을 변경하는 방법을 알아보았다.
이외에도 예외 처리에 대한 문서 자동화, 복잡한 처리 등이 가능하니 잘 찾아본다면 더 깔끔하고 정확한 스웨거 문서를 작성할 수 있겠다.

[Spring] spring-data-envers 를 이용한 엔티티 변경 이력 관리

gengminy — Sun, 10 Mar 2024 20:16:14 +0900

들어가며

시스템 운영 단계에서 중요 데이터의 변경 이력을 저장하고 관리해야 하는 경우가 있다.

보통 history 테이블을 따로 만들어 이것들을 관리하곤 하는데

JPA 를 사용중이라면 spring-data-envers 를 통해 이를 편리하게 설정하고 관리할 수 있다.

spring-data-envers 는 hibernate-envers 의 wrapping 프로젝트로

envers 를 편리하게 사용할 수 있는 기능(RevisionRepository, 메타데이터 조회)을 제공한다.

1. Dependency (gradle)

implementation("org.springframework.data:spring-data-envers")

2. Auditing 활성화

감사를 진행할 엔티티에 @Audited 를 추가한다

@Getter
@Entity
@Audited
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private String email;
}

전체 테이블에 대해서 이력을 남기고 싶다면 클래스에 @Audited 를 붙이고,

정해진 필드만 관리하고 싶다면 각 필드에 대해 @Audited 어노테이션을 붙이면 된다.

또 전체 필드 중 제외하고 싶은 필드가 있다면 @NotAudited 를 붙이면 감사 대상에서 제외된다.

@Audited
private String name;

@NotAudited
private String email;

이력 조회 대상에 대해 변경되었는지 여부를 flag 를 통해 관리할 수도 있다.

이 flag 를 조회해서 해당 버전에서 어떤 엔티티가 바뀌었는지 boolean 값으로 관리할 수 있다.

@Audited(withModifiedFlag = true, modifiedColumnName = "nameChanged")
private String name;

연관관계 대상 테이블에 대한 이력 관리 전략을 바꿀 수도 있다.

원래는 연관관계 테이블도 반드시 @Audited 를 통해 이력 관리 대상으로 추가해야 한다.

이를 @NotAudited 로 아예 제외시키거나

targetAuditMode 를 NOT_AUDITED 로 설정하여 fk 값만 저장하도록 할 수도 있다.

// FK 만 이력 조회 대상으로 한다
@Audited(targetAuditMode = RelationTargetAuditMode.NOT_AUDITED)
@ManyToOne(fetch=FetchType.LAZY)
private Department department;

// 이력 관리 대상에서 제외한다
@NotAudited
private Department department;

3. RevInfo 테이블

hibernate.ddl-auto 옵션이 create 또는 update 일 때

envers 는 자동으로 REVINFO 테이블과 ***_AUD 테이블을 생성한다

create table REVINFO (
    REV integer not null auto_increment, 
    REVTSTMP bigint, 
    primary key (REV)
) engine=InnoDB

create table User_AUD (
    REV integer not null, 
    REVTYPE tinyint, 
    nameChanged bit, 
    id bigint not null, 
    name varchar(255), 
    primary key (REV, id)
) engine=InnoDB

alter table User_AUD 
    add constraint FKilft2rdosb65jocpcoan7xnjq 
        foreign key (REV) references REVINFO (REV)

REVINFO 는 envers 의 버전 관리 정보로 버전 번호인 REV, 그리고 수정 시간을 REVSTMP 으로 기록한다.

이력 관리에 대한 테이블은 ****_AUD 로 생성되는데

REVINFO 에 대한 FK 로 REV 를 가지고 있으며 원래 엔티티의 PK 와 복합키 쌍으로 관리된다.

REVTYPE 은 수정 타입으로 다음과 같이 관리된다.

public enum RevisionType {
    ADD((byte)0), // 추가
    MOD((byte)1), // 수정
    DEL((byte)2); // 삭제

    ...
}

만약 네이밍 방식을 바꾸고 싶거나 REVINFO 엔티티를 변경하고 싶다면 커스텀이 가능하다.

envers 를 사용한다면 REVINFO 엔티티의 커스텀은 거의 필수적인데

자세히 보면 REVINFO 엔티티의 PK 인 REV 의 타입은 Integer 이기 때문이다.

이력 조회에 경우 실제 운영단계에서는 잦은 추가가 발생하기 때문에 금방 INT_MAX 에 도달하게 되고,

더이상 이력을 생성할 수 없는 이슈가 발생할 수 있다.

@Getter
@Entity
@RevisionEntity
@Table(name = "RevisionHistory")
public class CustomRevisionEntity {
    @Id
    @Column
    @RevisionNumber
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long revisionId;

    @Column @RevisionTimestamp
    private Long updatedAt;

    public LocalDateTime getUpdatedAt() {
        return LocalDateTime.ofInstant(Instant.ofEpochMilli(updatedAt), ZoneId.systemDefault());
    }
}

REVINFO 를 @RevisionEntity 를 통해 재정의할 수 있다.

REV 는 @RevisionNumber , REVTSTMP 는 @RevisionTimestamp 로 재정의한다.

# custom revision entity 로 변경된 쿼리

create table RevisionHistory (
    revisionId bigint not null auto_increment, 
    updatedAt bigint, primary key (revisionId)
) engine=InnoDB

create table User_AUD (
    REVTYPE tinyint, 
    REV bigint not null, 
    id bigint not null, 
    email varchar(255), 
    name varchar(255), 
primary key (REV, id)) engine=InnoDB

alter table User_AUD 
    add constraint FK7gw0sgfolgrr3a6xju5tvqxxp 
        foreign key (REV) references RevisionHistory (revisionId)

다만 생성 쿼리를 보면 알 수 있다시피 User_AUD 쪽의 정보는 변경되지 않았는데

이는 application.yml 의 추가 설정을 통해 변경할 수 있다.

spring:
    jpa:
    properties:
      org.hibernate.envers:
        audit_table_suffix: History # 이력 테이블 이름의 _AUD 를 History 로 변경
        revision_field_name: revisionId # 이력 테이블 REV 컬럼명
        revision_type_field_name: revisionType # 이력 테이블 REVTYPE 컬럼명
        store_data_at_delete: true # 삭제시 저장 여부, 기본은 false 이다

revision_field_name 을 변경하면 REV ⇒ 해당 이름의 컬럼명으로 변경된다

여러 유용한 추가 설정이 있는데 검색 또는 envers 패키지를 찾아보면 좋을 듯 싶다.

https://docs.jboss.org/hibernate/envers/3.6/reference/en-US/html/configuration.html

Chapter 3. Configuration

Important The following configuration options have been added recently and should be regarded as experimental: org.hibernate.envers.audit_strategy org.hibernate.envers.audit_strategy_validity_end_rev_field_name org.hibernate.envers.audit_strategy_validity_

docs.jboss.org

# yml 설정으로 변경된 쿼리

create table RevisionHistory (
    revisionId bigint not null auto_increment, 
    updatedAt bigint, primary key (revisionId)
) engine=InnoDB

create table UserHistory (
    revisionType tinyint, 
    id bigint not null, 
    revisionId bigint not null, 
    email varchar(255), 
    name varchar(255), 
    primary key (id, revisionId)
) engine=InnoDB

alter table UserHistory 
    add constraint FKtqxax72rt5cgosfu35jtcghu7 
        foreign key (revisionId) references RevisionHistory (revisionId)

이제 컬럼명이 이쁘게 수정되었다.

여기서 마지막으로 소개할 기능은 RevisionListener 이다.

REVINFO 생성 단계에서 추가적인 정보를 부여하고 싶을 때 사용하는 기능이다.

예를 들면 중요한 데이터라 누가 해당 버전에서 데이터를 수정했는지 관리할 필요가 있다 하자.

수정한 사람을 기록하기 위해 RevisionListener 와 interceptor 를 적절하게 활용할 수 있다.

public class CustomRevisionEntityListener implements RevisionListener {
    @Override
    public void newRevision(Object o) {
        final Admin currentAdmin = AuditThreadContext.getCurrentAdmin();
        CustomRevisionEntity customRevisionEntity = (CustomRevisionEntity) o;
        if (currentAdmin != null) {
            customRevisionEntity.setAdminId(currentAdmin.getAdminId());
        }
    }
}

인터셉터에서 AuditThreadContext 라는 임의의 ThreadLocal 에 어드민 정보를 저장하고,

Revision 엔티티를 생성할 때 이를 꺼내와서 저장하는 방식으로 수정한 어드민 정보를 관리한다.

이를 통해 데이터를 수정한 사람이 누구인지 History 생성 단계에서 지정해줄 수 있다.

@Getter
@Entity
@Table(name = "RevisionHistory")
@RevisionEntity(CustomRevisionEntityListener.class)
public class CustomRevisionEntity {
    @Id
    @Column
    @RevisionNumber
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long revisionId;

    @Column @RevisionTimestamp
    private Long updatedAt;

    @Column private Long adminId;

    public void setAdminId(Long adminId) {
        this.adminId = adminId;
    }

    public LocalDateTime getUpdatedAt() {
        return LocalDateTime.ofInstant(Instant.ofEpochMilli(updatedAt), ZoneId.systemDefault());
    }
}

@RevisionEntity 에 새로운 컬럼을 지정한 후, 리스너 클래스를 등록하는 방식으로 사용한다.

4. RevisionRepository

@NoRepositoryBean
public interface RevisionRepository<T, ID, N extends Number & Comparable<N>> extends Repository<T, ID> {
    Optional<Revision<N, T>> findLastChangeRevision(ID id);

    Revisions<N, T> findRevisions(ID id);

    Page<Revision<N, T>> findRevisions(ID id, Pageable pageable);

    Optional<Revision<N, T>> findRevision(ID id, N revisionNumber);
}

spring-data-envers 는 기본적인 RevisionRepository 인터페이스를 제공하며 이를 상속받아 사용할 수 있다.

타입 인자는 <엔티티 클래스, 엔티티 ID 타입, REV 타입> 이다.

public interface UserRepository
    extends CrudRepository<User, Long>, RevisionRepository<User, Long, Long> {}

최신 버전 단건 조회

public User findLatestUserRevisionById(Long id) {
    Revision<Long, User> latestRevision 
        = userRepository.findRevisions(id).getLatestRevision();

    User user = latestRevision.getEntity(); // 감사 엔티티
    Optional<Long> revisionNumber = latestRevision.getRevisionNumber(); // 버전번호
    Optional<Instant> revisionInstant = latestRevision.getRevisionInstant(); // 수정일시

    return user;
}

Jpa Pageable 을 이용한 페이징 조회

public Page<User> findUserRevisionPage(Long id, Pageable pageable) {
    Page<Revision<Long, User>> revisionPage = userRepository.findRevisions(id, pageable);

    return revisionPage.map(Revision::getEntity);
}

5. 동적 쿼리

RevisionRepository 로 해결할 수 없는 복잡한 동적 쿼리는 AuditReader 를 사용하여 구현할 수 있다.

@Configuration
@RequiredArgsConstructor
public class AuditReaderConfig {
    private final EntityManagerFactory entityManagerFactory;

    @Bean
    public AuditReader auditReader() {
        return AuditReaderFactory.get(entityManagerFactory.createEntityManager());
    }
}

public interface UserHistoryRepositoryCustom {
    Optional<User> findLatestById(Long userId);
}

@RequiredArgsConstructor
public class UserHistoryRepositoryCustomImpl implements UserHistoryRepositoryCustom {
    private final AuditReader auditReader;

    public Optional<User> findLatestById(Long userId) {
        List<?> results =
                    auditReader
                            .createQuery()
                            .forRevisionsOfEntity(User.class, true, true)
                            .add(AuditEntity.id().eq(userId))
                            .addOrder(AuditEntity.revisionNumber().desc())
                            .setMaxResults(1)
                            .getResultList();
        return (results.isEmpty()) ? Optional.empty() : Optional.of((User) results.get(0));
    }
}

AuditReader 의 forRevisionsOfEntity 의 파라미터에 따라 여러 옵션이 오버로딩 되어있는데 필요에 따라 사용할 수 있다.

위의 예시에서는 추가적인 Revision 메타데이터 없이 유저 엔티티만 가져오는 옵션을 주었다.

where 절 조건은 .add() 체이닝으로 추가할 수 있고

and 는 AuditConjunction or 은 AuditDisjunction 이라는 타입을 제공해서 추가할 수 있다.

private AuditConjunction allMatch(AuditCriterion... criterion) {
    final AuditConjunction auditConjunction = new AuditConjunction();
    Arrays.stream(criterion).forEach(auditConjunction::add);
    return auditConjunction;
}

private AuditDisjunction anyMatch(AuditCriterion... criterion) {
    final AuditDisjunction auditDisjunction = new AuditDisjunction();
    Arrays.stream(criterion).forEach(auditDisjunction::add);
    return auditDisjunction;
}

AuditReader 를 사용해서 1개 결과를 조회할 때 List 로 먼저 가져온 후에 처리하는 것이 좋다

getSingleResult() 는 결과가 없을 경우 NoResultException 이 발생하기 때문이다.

패치된 결과는 Object[] 형태인데 프로젝션 갯수가 늘어날 때 마다 원소의 개수가 증가한다.

프로젝트에서는 이를 정해진 타입으로 관리하고 싶어 추가 필드를 만들어서 관리 중이다.

현재 프로젝트에서는 @Audited 에 수정 플래그를 사용 중인데

수정 플래그도 같이 가져오려면 forRevisionsOfEntityWithChanges 을 사용하면 된다.

이를 Object[] 의 3번 인덱스 원소로 수정된 엔티티 컬럼명을 Set 으로 제공한다.

(modifiedFlag 모드를 사용하고 있지 않다면 오류가 발생한다)

@Getter
@AllArgsConstructor
public class AuditReaderResult<T> {
    private final T entity;
    private final CustomRevisionEntity revisionEntity;
    private final RevisionType revisionType;
    private final Set<String> revisionFields;

    @SuppressWarnings("unchecked")
    public static <T> AuditReaderResult<T> from(Object[] result) {
        return new AuditReaderResult<>(
                (T) result[0],
                (CustomRevisionEntity) result[1],
                (RevisionType) result[2],
                (Set<String>) result[3]);
    }
}

@RequiredArgsConstructor
public class UserHistoryRepositoryCustomImpl implements UserHistoryRepositoryCustom {
    private final AuditReader auditReader;

    public Optional<User> findLatestById(Long userId) {
        final AuditCriterion predicate = this.allMatch(userIdEq(userId));
        final Optional<AuditReaderResult<User>> user = this.queryOne(predicate);

        return user.map(AuditReaderResult::getEntity);
    }

    private AuditCriterion userIdEq(Long userId) {
        return AuditEntity.property("id").eq(userId);
    }

    private <T> Optional<AuditReaderResult<T>> queryOne(AuditCriterion... auditCriterion) {
        List<?> results;
        synchronized (this) {
            results =
                    auditReader
                            .createQuery()
                            .forRevisionsOfEntityWithChanges(User.class, true)
                            .add(this.allMatch(auditCriterion))
                            .addOrder(AuditEntity.revisionNumber().desc())
                            .setMaxResults(1)
                            .getResultList();
        }
        final List<AuditReaderResult<T>> histories = auditReaderResultOf(results);
        return (histories.isEmpty()) ? Optional.empty() : Optional.of(histories.get(0));
    }

    private <T> List<AuditReaderResult<T>> auditReaderResultOf(List<?> results) {
        return results.stream()
                .map(Object[].class::cast)
                .map(AuditReaderResult::<T>from)
                .collect(Collectors.toList());
    }

    private AuditConjunction allMatch(AuditCriterion... criterion) {
        final AuditConjunction auditConjunction = new AuditConjunction();
        Arrays.stream(criterion).forEach(auditConjunction::add);
        return auditConjunction;
    }
}

Pageable 을 이용한 페이지네이션도 setFirstResult() 와 setMaxResults() 를 적절하게 섞어 구현할 수 있을 것이다.

@SuppressWarnings("unchecked")
private <T> Page<AuditReaderResult<T>> queryAll(
        Pageable pageable, AuditCriterion... auditCriterion) {
    final List<Long> coveringIndexes = (List<Long>)
            auditReader
                    .createQuery()
                    .forRevisionsOfEntity(User.class, false, true)
                    .add(this.allMatch(auditCriterion))
                    .addProjection(AuditEntity.revisionNumber())
                    .getResultList();

    final List<?> results =
                auditReader
                        .createQuery()
                        .forRevisionsOfEntityWithChanges(User.class, true)
                        .add(revisionIdIn(coveringIndexes))
                        .addOrder(AuditEntity.revisionNumber().desc())
                        .setFirstResult((int) pageable.getOffset())
                        .setMaxResults(pageable.getPageSize())
                        .getResultList();
    final List<AuditReaderResult<T>> histories = auditReaderResultOf(results);
    return PageableExecutionUtils.getPage(histories, pageable, coveringIndexes::size);
}

private AuditCriterion revisionIdIn(List<Long> ids) {
    return AuditEntity.revisionNumber().in(ids);
}

마치며

지금까지 spring-data-envers 를 이용해서 이력 조회를 간편하게 설정하는 방법을 알아보았다.

envers 를 이용하면 History 테이블을 직접 구현하지 않고도 이력 관리가 가능하기 때문에

운영 단계에서 생산성을 높일 수 있을 것이다.

또 생각보다 hibernate 에 많은 기능이 구현되어있고 지원해주니 잘 찾아보면 수고를 덜 수 있을 것 같다.

[Spring] Redisson 분산락 AOP로 동시성 문제 해결하기 (트랜잭션 전파속성 NEVER 사용)

gengminy — Thu, 6 Jul 2023 16:01:44 +0900

들어가며

동시성 문제는 백엔드 개발자들이라면 반드시 한 번쯤은 겪어보는 문제이다.

서버 단에서 동시성의 가장 흔한 예로는

선착순, 이벤트 등의 상황에서 다수의 트래픽이 동시에 몰리는 상황
확인 버튼을 실수로 두 번 클릭을 해(따닥) 서버에 동시에 동일한 요청이 두 번 전송된 상황
어떤 사용자가 추천과 비추천, 취소를 순식간에 계속 눌렀는데
서버에 마침 부하가 걸려 이 요청들이 동시에 들어온 상황

이런 예시들을 생각해볼 수 있다.

자바는 기본적으로 멀티 쓰레드 환경에서 실행되기 때문에

이러한 경쟁상태(Race Condition)에 대해 처리를 해줄 필요가 있다.

결론부터 말하자면 Redis 의 구현체 중 하나인 Redisson Client 를 활용하여 이 문제를 해결했다.

이번 포스팅에서는 그 과정에 대해 서술해보려고 한다.

❓ 그거 프론트에서 더블 클릭 막으면 되는 거 아닌가?

프론트에서 동시에 여러 번 클릭하는 상황을 막는 기법들이 존재한다.

디바운스나 쓰로틀링 같은 기법으로

클라이언트로부터 일정 주기안에 들어오는 동시 요청 중 단 하나만 수행하도록 할 수 있다.

그런데 이 방식은 허점이 존재한다.

만약 클라이언트가 여러 개의 브라우저로 동시 요청을 보내면?

하나의 자원에 대해 여러 클라이언트가 동시에 처리 요청을 보내면?

프론트에서의 처리는 보조적인 수단일 뿐, 근본적인 동시성 문제를 해결할 수 없다.

Java Synchronized

자바 진영에서는 기본적으로 synchronized 키워드를 통해 상호 배제(Mutual Exclusion) 기능을 제공한다.

단 하나의 인스턴스, 즉 싱글 프로세스로 동작하는 서버는

Synchronized 를 통한 멀티 쓰레드의 동시성 제어가 가능할 것으로 예상된다.

@Service
class ReviewService {

    @Transactional
    @Synchronized
    fun update(productId: Long) {
        // do something
    }
}

그러나 Synchronized 키워드는 몇 가지 문제가 있다.

1. Synchronized 키워드는 @Transactional 에서 처리되지 않는다.

스프링 AOP는 @Transactional 이 붙은 메소드를

트랜잭션의 시작, 커밋, 종료를 담당하는 프록시 객체로 감싸 처리해준다.

그러나 이 부분은 Synchronized 메소드에 포함되어 있지 않다.

즉, 트랜잭션의 커밋을 처리하고 DB에 반영되기 직전,

다른 스레드가 이 구역에 진입해 반영되지 않은 값을 읽어도 오류가 발생하지 않는다.

2. 멀티 프로세스 환경에서는 동작하지 않는다.

Synchronized 는 싱글 프로세스 내부의 멀티 쓰레드를 제어할 수 있다.

하지만 멀티 프로세스 환경에서는 다른 프로세스 내부의 쓰레드를 제어할 수 없기 때문에

서버가 확장된다면 동시성 제어가 불가능하다.

MySQL을 이용한 분산락

현재 이 분산락을 적용하려는 서버도 MySQL 을 사용하고 있기 때문에

MySQL 에 내장되어 있는 Lock 을 고려할 수도 있었다.

MySQL 의 Lock은 Lock Table 을 생성하여 별도 관리하는데

락에 대한 상태와 소유자 정보를 쿼리를 통해 관리한다.

추가적인 인프라에 대한 구현 및 유지보수 비용은 줄일 수 있으나

별도의 커넥션 풀을 관리해야 하고, DB에 락과 관련된 부하를 일으켜 속도가 저하될 수 있으며 dead lock 의 가능성도 있다.

이미 우리 서버는 Redis 를 사용하고 있는 상황이기 때문에

MySQL을 이용한 Lock은 사용하지 않았다.

우형에서는 MySQL을 이용한 분산락을 구현한 글을 적어두었다.

https://techblog.woowahan.com/2631/

MySQL을 이용한 분산락으로 여러 서버에 걸친 동시성 관리 | 우아한형제들 기술블로그

{{item.name}} 안녕하세요. 비즈인프라개발팀 권순규입니다. 현재 광고시스템에서 사용하고 있는 MySQL을 이용한 분산락에 대해 설명드리고자 합니다. 분산락을 적용하게된 원인 현재 테이블은 아래

techblog.woowahan.com

Redis를 이용한 분산락

Zookeeper 를 통한 예제도 있지만 오버 테크놀로지라 생각했고,

또한 현재 서버에서 토큰 및 캐싱 관리에 Redis 를 사용중이기 때문에 이를 채택했다.

Redis는 싱글 쓰레드 특성을 지녀 한 번에 하나의 명령을 처리하기 때문에 분산락 구현에 많이 사용된다.

Redis Client 중 기본 설정인 Lettuce 와 다른 클라이언트인 Redisson 중 하나를 선택해야 했다.

1. Lettuce

@Component
class RedisLockRepository(private val redisTemplate: RedisTemplate<String, String>) {

    fun lock(key: Long): Boolean {
        return redisTemplate.opsForValue()
            .setIfAbsent(key.toString(), "lock", Duration.ofMillis(3000))
    }

    fun unlock(key: Long): Boolean {
        return redisTemplate.delete(key.toString())
    }
}

Lettuce 는 setnx, setex 같은 명령어를 통해 분산락을 구현해야 한다.

다만, 이 명령어들은 Spin Lock 방식으로 동작하기 때문에 Redis 에 엄청난 부하를 준다.

말 그대로 단순하게 무한 while 루프를 통해 대기하는 방식이다.

또한 락의 타임아웃이 없어 불행하게도 특정 프로세스에서 락을 획득한 후 종료되면?

영원히 락을 획득하지 못하고 무한대기를 하게 될 것이다.

2. Redisson

@Service
class ReviewService(private val redissonClient: RedissonClient) {

    @Transactional
    fun update(productId: Long) {
        val lock = redissonClient.getLock("key")

        try {
            val available = lock.tryLock(2, 3, TimeUnit.SECONDS)
            if (!available) {
                throw RuntimeExcetpion("Lock Not Avaliable")
            }

            // do something

        } finally {
            lock.unlock()
        }
    }
}

Redisson 을 이용한 lock 예시

현재 우리 서버에서 사용 중인 클라이언트이다.

Pub/Sub 방식으로 동작하며 락이 해제되면 해당 락을 Subscribe 중인 클라이언트들이 신호를 받고 락에 진입한다.

Redisson 은 Lock에 타임아웃을 명시해야 하며, 덕분에 무한 루프에 빠지지 않을 수 있다.

특히 마켓컬리 팀에서 작성한 분산락 방식이 최상단에 뜨는데

검색하면 나오는 대부분의 결과도 Redisson 으로 비슷하게 구현되어 있다.

https://helloworld.kurly.com/blog/distributed-redisson-lock/

풀필먼트 입고 서비스팀에서 분산락을 사용하는 방법 - Spring Redisson

어노테이션 기반으로 분산락을 사용하는 방법에 대해 소개합니다.

helloworld.kurly.com

Redisson Lock AOP 구현

이렇게 Redisson Lock 을 매번 필요한 비즈니스 로직마다 사용하면 비즈니스 로직이 오염된다.

그래서 스프링의 AOP를 이용하여 분리시키고자 한다.

검색하면 나오는 대부분의 예제는 AOP에 너무 많은 처리 로직이 몰려있어

이를 LockManager를 통해 분리시켰다.

DistributedLock

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.FUNCTION)
annotation class DistributedLock(
    val type: DistributedLockType,
    val keys: Array<String>,
)

DistributedLock 을 정의하는 어노테이션

lock name 을 enum 으로 관리하고 key 값을 배열로 받아와 복합키에 대한 락을 대응했다.

우리 프로젝트에서는 DDD 를 사용하고 있기 때문에 Object Key 에 대해서는 고려하지 않았다.

이 key 값에는 분산락의 키로 사용하는 각 엔티티 id가 메소드의 인자로 들어온다.

DistributedLockAop

@Aspect
@Component
class DistributedLockAop(
        private val lockManager: LockManager,
) {
    @Around("@annotation(distributedLock)")
    fun lock(joinPoint: ProceedingJoinPoint, distributedLock: DistributedLock): Any? {
        val dynamicKey = createDynamicKey(joinPoint, distributedLock.keys)
        val lockName = "${distributedLock.type.lockName}:$dynamicKey"
        return lockManager.lock(lockName) { joinPoint.proceed() }
    }

    private fun createDynamicKey(joinPoint: ProceedingJoinPoint, keys: Array<String>): String {
        val methodSignature = joinPoint.signature as MethodSignature
        val methodParameterNames = methodSignature.parameterNames
        val methodArgs = joinPoint.args

        val dynamicKey = keys.joinToString(separator = ":") { key ->
            val indexOfKey = methodParameterNames.indexOf(key)
            methodArgs.getOrNull(indexOfKey)?.toString() ?: throw InvalidLockException("Invalid Lock Key")
        }
        return dynamicKey
    }
}

Redis Client 가 바뀌거나 Lock 을 처리하는 방법 자체가 바뀔 상황을 대비하여

LockManager 를 별도 인터페이스로 정의하여 빼주었다.

또한 AOP 에서 Lock 을 처리하지 않고 LockManager 에 위임했다.

그래서 각 key 를 메소드 파라미터에서 찾아와 콜론으로 분리하여 키를 설정했다.

추후 확장한다면 Object 에 대해서도 리플렉션으로 가져와 key 값으로 적절하게 처리할 수 있게 하면 된다.

@DistributedLock 과 관련된 오류는 InvalidLockException 이라는 커스텀 예외를 만들어 던졌다.

LockManager

@Component
interface LockManager {
    fun lock(lockName: String, operation: () -> Any?): Any?
}

락을 담당하는 인터페이스이다.

동작하려는 함수 하나와 락 이름을 지정한다.

RedissonLockManager

@Component
class RedissonLockManager(
    private val redissonClient: RedissonClient,
    private val aopForNewTransaction: AopForNewTransaction
): LockManager {

    override fun lock(operation: () -> Any?, lockName: String): Any? {
        val rLock = redissonClient.getLock(lockName)

        try {
            val available = rLock.tryLock(waitTime, leaseTime, timeUnit)
            if (!available) {
                throw InvalidLockException("Redisson Lock Not Available")
            }
            return aopForNewTransaction.callNewTransaction { operation() }
        } finally {
            rLock.unlock()
        }
    }

    companion object {
        private const val waitTime = 5L
        private const val leaseTime = 3L
        private val timeUnit = TimeUnit.SECONDS
    }
}

Redisson 을 이용한 분산락을 처리하는 LockManager의 구현체이다.

락으로 자원을 잠그고 로직을 처리한다.

waitTime 과 leaseTime 등의 각 속성은

각 LockManager 구현체마다 동일하고 바꿀 일이 거의 없을 것이라 예상하고

상수를 통해 전체적으로 관리한다.

AopForNewTransaction

@Component
class AopForNewTransaction {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    fun callNewTransaction(operation: () -> Any?): Any? {
        return operation()
    }
}

주목할 점은 이 부분이다.

락으로 자원을 잠그고, 해제하는 그 사이에

트랜잭션 전파속성을 통해 완전히 새로운 트랜잭션을 열고 로직을 처리하는 것이다.

즉 트랜잭션이 락 내부에 있기 때문에 트랜잭션이 완전히 커밋된 후에야 락이 해제된다.

왜 이렇게 구현해야 할까?

REQUIRES_NEW 를 사용하지 않은 경우 트랜잭션 플로우

만약 락이 트랜잭션의 내부에 있다면

락이 해제되고 커밋되는 그 사이에 다른 트랜잭션이 끼어들 여지가 생긴다.

이렇게 되면 동시성 문제가 똑같이 발생한다.

REQUIRES_NEW 를 사용한 경우 트랜잭션 플로우

트랜잭션을 락의 내부에서 새로 열어주면

다른 트랜잭션이 커밋 이전에 끼어들 여지가 없어져 데이터의 정합성이 보장된다.

이 방식은 올바른 방법이긴 하지만 단점도 있다.

트랜잭션 전파속성 REQUIRES_NEW 의 단점

// (1)
@Transactional
@DistributedLock(DistributedLockType.LIKE, ["productId", "memberId"])
fun like(productId: Long): ProductLikeVO {
    // do something
}

// (2)
@DistributedLock(DistributedLockType.LIKE, ["productId", "memberId"])
fun like(productId: Long): ProductLikeVO {
    // do something
}

만약 어떠한 메소드에 @Transactional 과 @DistributedLock 을 모두 사용했다고 하자.

@Transactional 의 우선순위가 기본적으로 높기 때문에

하나의 트랜잭션 내부에서 다시 @DistributedLock 의 새로운 트랜잭션 호출 로직(REQUIRES_NEW)이 동작한다.

그러면 총 두 개의 트랜잭션이 하나의 메소드에서 호출된다.

여기서 @DistributedLock 관련 트랜잭션인 Transaction 2는 커밋이 되었는데

이 메소드를 호출한 Transaction 1 은 오류가 발생했다고 하자.

그러면 Transaction 1에서 @Transactional 을 사용했기 때문에

두 트랜잭션이 모두 롤백 되기를 기대했지만

하나의 트랜잭션은 커밋되고 하나의 트랜잭션은 커밋이 된 상황이다.

두 트랜잭션은 독립적이기 때문이다.

이를 방지하려면 (2)번처럼 @DistributedLock 하나의 어노테이션만 사용해야 하는데

그러면 이 메소드가 트랜잭션을 포함하는지 안하는지, 코드의 동작 결과를 한눈에 예상하기 어려워질 것이다.

그래서 이를 해결하기 위해 전파속성을 바꿔서 처리하고자 했다.

Propagation 속성 변경을 통한 aspect 개선

앞서 구현한 분산락 코드를 개선하고자 하는 이유는

어떠한 메소드에 @Transactional 과 @DistributedLock 을 모두 사용하여

코드의 동작 결과를 예상하기 쉽게 하여 가독성을 높이기 위함이다.

문제 상황은 @DistributedLock 이 다른 트랜잭션에서 호출될 때 발생했다.

그러면 다른 트랜잭션에서 절대 호출할 수 없도록 하면 해결되지 않을까?

트랜잭션 전파속성 NEVER

트랜잭션 전파속성 중 NEVER 은

트랜잭션을 사용하지 않음과 동시에 선행 트랜잭션이 존재하면 오류를 발생시키는 옵션이다.

즉 선행 트랜잭션이 존재하는지 검사하기 위해 사용하는 옵션이다.

이를 이용하면 아까와 같은 상황에서 오류를 발생시켜

다른 메소드에서 분산락 메소드를 호출하지 않도록 할 수 있다.

RedissonLockManager

@Component
class RedissonLockManager(
    private val redissonClient: RedissonClient,
): LockManager {
    // 트랜잭션이 모두 Lock 내부에서 실행됨을 보장한다
    @Transactional(propagation = Propagation.NEVER)
    override fun lock(lockName: String, operation: () -> Any?): Any? {
        val rLock = redissonClient.getLock(lockName)

        try {
            val available = rLock.tryLock(waitTime, leaseTime, timeUnit)
            if (!available) {
                throw InvalidLockException("Redisson Lock Not Available")
            }
            return operation()
        } finally {
            rLock.unlock()
        }
    }

    companion object {
        private const val waitTime = 5L
        private const val leaseTime = 3L
        private val timeUnit = TimeUnit.SECONDS
    }
}

AopForNewTransaction 을 없애고 Lock 에 대한 연산만 남겨두었다.

다만 이렇게 될 경우 @Transaction 의 기본 우선순위가 높기 때문에

@Transaction 과 @DistributedLock 가 메소드에 동시에 붙게 되면

@Transaction 내부에서 @DistributedLock 이 호출되고,

Propagation=NEVER 옵션에서 제약에 걸려 오류가 발생한다.

그렇기 때문에 @DistributedLock 의 우선순위를 높혀

@Transactional 보다 먼저 처리될 수 있도록 해야 한다.

DistributedLockAop

@Aspect
@Component
@Order(Ordered.HIGHEST_PRECEDENCE + 1)
class DistributedLockAop(
        private val lockManager: LockManager,
) {
    ...
}

스프링에서는 @Order 라는 어노테이션을 통해 어노테이션의 적용 우선순위를 설정할 수 있다.

우선순위는 INT_MIN 부터 INT_MAX 까지 설정할 수 있다.

Ordered.HIGHEST_PRECEDENCE 라는 상수는 INT_MIN 으로 설정되어 있는데

이것을 사용해 @DistributedLock 의 적용 우선순위를 @Transactional 보다 높혔다.

이제 @Transactional 은 락이 설정된 이후에 호출되기 때문에

메소드 선언에서 같이 사용할 수 있다.

또한 외부 메소드에서 @DistributedLock 을 호출할 수 없기 때문에

예시처럼 예상치 못한 롤백 같은 상황이 생기지 않는다.

마치며

분산락을 구현하는 방식은 생각보다 다양하다.

각 방법을 상황에 맞게 사용한다면 효과적으로 동시성 이슈를 대응할 수 있을 것이라 생각한다.

읽어주셔서 감사합니다.

[YAPP] IT 연합동아리 YAPP 22기 백엔드 서류 / 면접 합격 후기

gengminy — Tue, 25 Apr 2023 13:01:11 +0900

✨ YAPP

연합 개발 동아리들 중 하나로, 기업형 IT 연합동아리라고 소개하고 있네요!

대학생과 현업자가 모두 참여할 수 있는 것이 특징 중 하나입니다.

PM(기획자), 디자이너, 프론트엔드, 백엔드 네 개의 파트로 나누어 모집하고 있습니다.

YAPP은 22기 기준 매주 토요일 정기 세션을 진행하고 기수 당 3회의 해커톤이 열립니다.

또한 스터디를 열거나 참여할 수도 있습니다.

YAPP 에는 실력자 분들도 많고 네트워킹도 활발하다고 알고 있어서 지원할까 고민 중이었는데

결정적으로 지인이 YAPP 한 번 지원해보는 게 어떻냐고 꼬셔서

부랴부랴 포폴 정리하고 서류 준비해서 지원했네요

https://www.yapp.co.kr/

YAPP

작은 아이디어로 세상을 크게 변화시키는 IT동아리, YAPP

www.yapp.co.kr

서류 문항

구글 폼을 사용하는 대부분의 다른 동아리들과는 다르게

'그리팅'이라는 채용 사이트를 별도로 사용해서 지원서를 받는 점이 신기했습니다.

백엔드 서류 문항은 다음과 같았습니다.

YAPP에 지원하게 된 동기를 포함하여 자유롭게 자기소개를 해주세요. (최대 500자)
프로젝트를 진행할 때 어떤 방식으로 팀원과 소통하는지 경험을 바탕으로 작성해 주세요. (최대 500자)
개발 경력 혹은 경험을 알려주세요. 프로젝트 이름, 기간, 본인의 역할, 성과를 포함하여 작성해 주세요. (최대 5000자, 개괄식)
위 프로젝트 중 기억에 남는 것을 하나 선정해 기술적인 어려움을 겪었던 부분과 어떠한 과정으로 해당 문제를 해결했는지 작성해 주세요. (최대 700자)

평가하시는 분은 많고 많은 자소서를 하나하나 읽어야하기 때문에....

아무래도 읽는 사람의 이목을 끌도록 적는게 좋습니다.

(그렇다고 절대 거짓말을 적으면 안됩니다... 어차피 면접 때 다 들통나요. 깔끔하고 보기 좋게 적으라는 의미!)

그래서 답변을 두괄식으로 작성하고 가독성 좋게 하려고 노력했습니다.

1번 같은 경우는 사람마다 다를테니 넘어가고

2번과 4번은 최근에 프로젝트에서 경험한 것들을 포트폴리오와 블로그 기반으로 녹여내려고 했습니다.

3번은 여태 했던 프로젝트들에서 어떤 기능을 담당하고 구현했는지, 이것으로 어떤 성장을 이루어냈는지 적었습니다.

서류 같은 경우는 여러 개발 동아리들 많이 써보기도 했고,

포트폴리오도 정리 많이 해놔서 자신이 있었는데 다행스럽게도 합격 했네요!

⚡️ 면접

면접 같은 경우 서류 결과 발표 주 토요일에 진행했습니다.

서류 합격 메일에 포함된 링크로 면접 시간을 선택할 수 있는데 선착순입니다.

저는 요상하게도 면접 날 아침에 네이버 코테, 오후에 중간고사가 겹쳐서

호다닥 들어가서 오후 5시 반으로 정했습니다.

당일 날 준비할 시간이 모자라서 서류 합격 날 부터 맨날 면접 준비했던 거 같아요ㅜ ㅜ

넥스터즈와 디프만도 서류는 합격했으나 면접 때 기술 질문에 탈탈 털리고 광탈해버렸는데,

이번에는 진짜 붙고 싶어서 며칠 동안 하루 종일 CS 질문과 프로젝트 관련 예상 질문 쫙 뽑아서 대비했습니다...!

면접은 2:2 로 진행했고 같이 본 분은 현업자셨습니다.

질문은 기억 나는 거 몇 가지만 간단하게 적을게요.

1분 자기소개 및 지원동기
본인이 생각하는 본인의 개발자로서의 강점과 단점
가장 인상 깊었던 프로젝트 설명
코드 리뷰에 대해 어떻게 생각하는지? 해보았다면 어떤 식으로 했고, 어떤 점을 중점적으로 보는지
다른 대외활동 참여하는 게 있는지? 만약 있다면 얍 활동을 어떤 식으로 진행할 건지
얍 활동으로 얻어가고 싶은 것이 있는지?
얍에서는 네이티브 앱과 웹 앱 중 어떤 환경에서 개발해보고 싶은지

면접은 총 45분 정도 소요되었습니다.

특이한 점은 제 면접 방에서는 기술 질문 없이 모두 인성 질문만 여쭤보셨습니다.

그리고 활동하면서 어떤 플랫폼에서(웹 또는 앱) 개발을 해보고 싶은지 팀 빌딩 관련된 질문을 주셨습니다.

보통 이러면 확실한 합격 또는 불합격 시그널이라고 생각하는데...

모든 질문을 깔끔하게 잘 답변했다고 생각해서 자신은 있었으나

같이 면접 본 다른 친구는 자바 관련 기술 질문 받았다고 해서 오히려 불안해졌습니다 하하...

(근데 오히려 열심히 준비했는데 기술 질문 안받으니까 조금 서운한 감이 들기도 했네요..? )

결과

CMC 이후로 오랜만에 받아보는 합격 메일

결과적으로는 합격했습니다!

다행스럽게도 포폴 적은 것과 답변 내용을 좋게 봐주신 거 같아요.

최종 경쟁률도 함께 발표되었는데 백엔드 경쟁률이 18.5 : 1 이더라구요....????

기분이 좋으면서도 뭔가 많은 것을 느끼게 해주는 숫자네요

장난 아닌 경쟁률 디자이너는 25.3 : 1 이라는데..... 후달달

확실히 실력자 분들이 모인다는 느낌을 받은게

네이버, 라인, 카카오페이, 쿠팡 등등.... 현업자 분들 장난 아니더라구요...!!!

벌써 네트워킹 할 생각에 설레네요

뒤쳐지지 않게 열심히 따라가면서 활동해보겠습니다!

[Spring] 스프링 소셜 로그인 OIDC 방식으로 구현하기 (OAuth with OpenID Connect)

gengminy — Sat, 25 Mar 2023 22:21:28 +0900

OpenID Connect (OIDC) Flow Chart

OpenID Connect (OIDC) 는 무엇인가?

OAuth 2.0 프로토콜을 기반으로 한 사용자 인증 프로토콜

accessToken 이외에도 id_token을 사용하여 토큰으로 사용자가 누구인지 확인할 수도 있다.

OIDC는 표준 프로토콜(스펙)이기 때문에 다른 OAuth 공급자와 호환된다.

보통 소셜 로그인 요청 시 scope 에 `open id` 를 추가해주면

엑세스 토큰과 리프레시 토큰 이외에 id token 을 추가로 응답해준다.

공개 키 가져오기

각 OAuth Provider 들은 공개키 목록의 JSON 파일을 제공한다.

구글, 카카오, 애플의 공개키 목록 url 은 다음과 같다.

Google

https://www.googleapis.com/oauth2/v3/certs

Kakao

https://kauth.kakao.com/.well-known/jwks.json

Apple

https://appleid.apple.com/auth/keys

아래는 애플의 공개키를 가져오는 FeignClient 예시이다

AppleOIDCClient

@FeignClient(
        name = "AppleOIDCClient",
        url = "https://appleid.apple.com",
        configuration = AppleOAuthConfig.class)
public interface AppleOIDCClient {
    @GetMapping("/auth/keys")
    OIDCPublicKeysResponse getAppleOIDCOpenKeys();
}

애플의 OIDC 정보들을 가져오는 Feign Client

해당 url 로 들어가면 Apple 이 제공하는 공개키 리스트가 있다.

다음과 같은 DTO에 저장시켰다.

@Getter
@NoArgsConstructor
public class OIDCPublicKeysResponse {
    List<OIDCPublicKeyDto> keys;
}

@Getter
@NoArgsConstructor
public class OIDCPublicKeyDto {
    private String kid;
    private String alg;
    private String use;
    private String n;
    private String e;
}

id_token 검증하기

OIDC 방식 로그인에서는

이를 decode 했을 때 나오는 정보들을 검증할 필요가 있다.

아래 글을 많이 참고했다.

>> [스프링] spring oauth Open ID Connect with kakao

OIDC 는 앞서 말했다시피 SPEC 이기 때문에

한 번 구현해두면 OAuth Provider 별로 동일하게 사용 가능하다!

JwtOIDCProvider

private String getUnsignedToken(String token) {
    String[] splitToken = token.split("\\.");
    if (splitToken.length != 3) throw new BaseException(INVALID_TOKEN);
    return splitToken[0] + "." + splitToken[1] + ".";
}

Header, Payload, Signature 를 분리하고 검증한다.

이후 Header 와 Payload 값만 가져옴

private Jwt<Header, Claims> getUnsignedTokenClaims(String token, String iss, String aud) {
    try {
        return Jwts.parserBuilder()
                .requireAudience(aud)
                .requireIssuer(iss)
                .build()
                .parseClaimsJwt(getUnsignedToken(token));
    } catch (ExpiredJwtException e) {
        throw new BaseException(ACCESS_TOKEN_EXPIRED);
    } catch (Exception e) {
        log.error(e.toString());
        throw new BaseException(INVALID_TOKEN);
    }
}

이후 iss와 aud 및 토큰 만료를 검증한다.

public String getKidFromUnsignedTokenHeader(String token, String iss, String aud) {
    return (String) getUnsignedTokenClaims(token, iss, aud).getHeader().get("kid");
}

이번엔 공개키 목록에서 사용할 kid 를 알아내기 위해

헤더에서 key id 를 가져온다.

이후 OAuthOIDCHelper 에서 이 메소드를 사용할 것이다

public OIDCDecodePayload getOIDCTokenBody(String token, String modulus, String exponent) {
    Claims body = getOIDCTokenJws(token, modulus, exponent).getBody();
    return new OIDCDecodePayload(
            body.getIssuer(),
            body.getAudience(),
            body.getSubject(),
            body.get("email", String.class));
}

public Jws<Claims> getOIDCTokenJws(String token, String modulus, String exponent) {
    try {
        return Jwts.parserBuilder()
                .setSigningKey(getRSAPublicKey(modulus, exponent))
                .build()
                .parseClaimsJws(token);
    } catch (ExpiredJwtException e) {
        throw new BaseException(ACCESS_TOKEN_EXPIRED);
    } catch (Exception e) {
        log.error(e.toString());
        throw new BaseException(INVALID_TOKEN);
    }
}

private Key getRSAPublicKey(String modulus, String exponent)
        throws NoSuchAlgorithmException, InvalidKeySpecException {
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    byte[] decodeN = Base64.getUrlDecoder().decode(modulus);
    byte[] decodeE = Base64.getUrlDecoder().decode(exponent);
    BigInteger n = new BigInteger(1, decodeN);
    BigInteger e = new BigInteger(1, decodeE);

    RSAPublicKeySpec keySpec = new RSAPublicKeySpec(n, e);
    return keyFactory.generatePublic(keySpec);
}

이번엔 암호화 과정이다

kid 로 가져온 공개키에서 n 과 e 를 조합하여 직접 공개키를 새로 만든다.

n과 e는 base64 로 인코딩된 값이 넘어오기 때문에 디코딩이 필요하다.

또한 n과 e는 값이 큰 수이기 때문에 BigInteger 를 사용한다.

이러한 과정으로 새로 만든 공개키로 서명하여 id token 의 body 를 검증할 수 있다.

OAuthOIDCHelper

@Service
@RequiredArgsConstructor
public class OAuthOIDCHelper {
    private final JwtOIDCProvider jwtOIDCProvider;

    public OIDCDecodePayload getPayloadFromIdToken(
            String token, String iss, String aud, OIDCPublicKeysResponse oidcPublicKeysResponse) {
        String kid = getKidFromUnsignedIdToken(token, iss, aud);

        OIDCPublicKeyDto oidcPublicKeyDto =
                oidcPublicKeysResponse.getKeys().stream()
                        .filter(o -> o.getKid().equals(kid))
                        .findFirst()
                        .orElseThrow(() -> new BaseException(INVALID_TOKEN));

        return jwtOIDCProvider.getOIDCTokenBody(
                token, oidcPublicKeyDto.getN(), oidcPublicKeyDto.getE());
    }

    private String getKidFromUnsignedIdToken(String token, String iss, String aud) {
        return jwtOIDCProvider.getKidFromUnsignedTokenHeader(token, iss, aud);
    }
}

앞서 구현한 로직으로

헤더에서 kid 를 뽑아 공개키 리스트 중에서 선택한다.

이후 n 과 e 정보를 가지고 공개키를 구하고

oauth 에 인증된 사용자인지 토큰을 검증한다.

OIDCDecodePayload

@Getter
@AllArgsConstructor
public class OIDCDecodePayload {
    private String iss;
    private String aud;
    private String sub;
    private String email;
}

id token 를 decode 했을 때 나오는 필드들

이로써 id token 을 검증하고 body 정보를 가져올 수 있다!

[Spring] 스프링 애플 로그인 구현하기 (Sign in with Apple OIDC)

gengminy — Sat, 25 Mar 2023 21:58:55 +0900

이 단순한 흑백 버튼 하나에 개발자의 무한한 피와 땀이.... 사과놈들

악명이 높기로 소문난 애플 로그인 구현하기

공식 Docs 도 너무 불친절하고 자료도 별로 없어서 애먹었지만

무한한 삽질을 통해 입맛에 맞게 완성시켜 보았다.

엑세스 토큰이 아닌,

OIDC(Open ID Connect)의 id_token 방식을 사용하여 구현했다.

id_token 방식의 경우 이슈어와 앱키 등의 정보가 들어있어

검증 및 로그인 세션을 유지할 수 있게 도와준다.

특히 이는 회원 가입시

OAuth 에서 제공하지 않는 정보의 추가 기입이 필요할 때 유용하게 사용할 수 있다.

Dependency

implementation 'com.nimbusds:nimbus-jose-jwt:3.10'

client secret 을 생성하기 위한 jwt 관련 라이브러리

Apple Developers 설정

애플 로그인은 준비해야 할 것들이 조금 많다....

13만원인가 하는 Apple Developer 서비스를 매년 결제해야 하고

private key 를 발급받은 후 저장한 .p8 파일을 이용하여 시크릿 키를 생성해줘야 하고

또 이것 저것 등록을 해야한다.

근데 이게 IOS 앱 등록 시

타 소셜 로그인을 사용하면 반드시 애플 로그인을 등록해야 해서

거의 반 강제로 구현해야 한다 하하

~~아니면 리젝 먹인다.~~

아래 링크를 참고하여 설정하였다.

>> 스프링 프로젝트에 애플 로그인 API 연동을 위한 Apple Developer 설정

애플 로그인 링크

Query Param 은 다음과 같다

client_id : Services Id -> identifier 값
redirect_uri : Return URLs 값, 로그인 직후 리다이렉션 되는 링크
scope : 전달받을 정보 (name, email, openid)
response_type : code 로 하면 인가 코드 반환 (고정)
response_mode : (공백) -> GET, form_post -> 리다이렉션 링크에 POST 요청을 날림
state : csrf 공격 방지 위한 검증 값
nonce : 랜덤 값, oauth 인증 토큰 무결성 보호를 위한 것

로그인 요청 시 주의할 점

최초 로그인 요청 링크에서 주의할 점이 몇 가지 있는데

response_mode 가 form_post 일 때만 scope 를 사용할 수 있다.
scope 의 name 은 최초 가입시에만 제공되는 필드이다 (이후 요청 시 값이 안나옴)
redirect_uri 에는 localhost 를 사용할 수 없다. 정책적으로 막혀있다.
ngrok 같은 포워딩 툴로 우회해야 로컬에서 테스트 가능!

위 내용 때문에 삽질하는 경우가 많으니 주의!

결론적으로 나는 로그인 링크를 다음과 같이 구성하였다.

https://appleid.apple.com/auth/authorize?client_id=%s&redirect_uri=%s&response_type=code

토큰 요청 Feign Client

Feign Client 를 사용중이며 관련 설정은 다음 게시글을 참고하면 되겠다.

[Spring] 스프링 Feign Client 적용하기 (Spring Cloud OpenFeign)

Feign Client 란? 본래 Netflix (그 넷플릭스 맞음) 에서 오픈 소스 일부로 개발되어 사용중인 경량 REST 클라이언트 현재는 Spring Cloud 프레임워크의 일부가 되었다. 인터페이스로 정의된 API를 기반

gengminy.tistory.com

AppleOAuthClient

@FeignClient(
        name = "AppleOAuthClient",
        url = "https://appleid.apple.com",
        configuration = AppleOAuthConfig.class)
public interface AppleOAuthClient {

    @PostMapping("/auth/token?grant_type=authorization_code")
    AppleTokenResponse appleAuth(
            @RequestParam("client_id") String clientId,
            @RequestParam("redirect_uri") String redirectUri,
            @RequestParam("code") String code,
            @RequestParam("client_secret") String clientSecret);
}

애플 로그인을 통해 받은 인가 코드를 받아 처리하는 url

여기서 중요한 점은 client_secret 파라미터 인데

p8 파일을 가지고 jwt 인코딩을 해줘서 여기에 집어넣어야 한다.

이 설정을 제대로 해주지 않을 경우

무한 invalid_client 오류에 빠지게 될 것이다......

AppleOAuthHelper

@Component
@RequiredArgsConstructor
public class AppleOAuthHelper {
    private final AppleOAuthProperties appleOAuthProperties;
    private final AppleOAuthClient appleOAuthClient;
    private final AppleOIDCClient appleOIDCClient;
    private final OAuthOIDCHelper oAuthOIDCHelper;
    
    //...(생락)
    
    public AppleTokenResponse getOAuthToken(String code, String referer) {
        return appleOAuthClient.appleAuth(
                appleOAuthProperties.getClientId(),
                referer + "callback/apple",
                code,
                getClientSecret());
    }
    
    private String getClientSecret() {
        return AppleLoginUtil.createClientSecret(
                appleOAuthProperties.getTeamId(),
                appleOAuthProperties.getClientId(),
                appleOAuthProperties.getKeyId(),
                appleOAuthProperties.getKeyPath(),
                appleOAuthProperties.getBaseUrl());
    }
}

그래서 이 Feign Client 를 호출하기 전에

client secret 을 만드는 로직이 필요하다.

Client Secret

client secret 을 만드는 방법은 다음 게시글을 기본적으로 참고하였으나

ECPrivateKeyImpl 과 :classpath 읽어오는데 문제가 있어 일부 변형시켰다.

>> 스프링 프로젝트에 애플 로그인 API 연동하기

AppleLoginUtil

public class AppleLoginUtil {
    /**
     * client_secret 생성 Apple Document URL ‣
     * https://developer.apple.com/documentation/sign_in_with_apple/generate_and_validate_tokens
     *
     * @return client_secret(jwt)
     */
    public static String createClientSecret(
            String teamId, String clientId, String keyId, String keyPath, String authUrl) {

        JWSHeader header = new JWSHeader.Builder(JWSAlgorithm.ES256).keyID(keyId).build();
        JWTClaimsSet claimsSet = new JWTClaimsSet();
        Date now = new Date();

        claimsSet.setIssuer(teamId);
        claimsSet.setIssueTime(now);
        claimsSet.setExpirationTime(new Date(now.getTime() + 3600000));
        claimsSet.setAudience(authUrl);
        claimsSet.setSubject(clientId);

        SignedJWT jwt = new SignedJWT(header, claimsSet);

        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(readPrivateKey(keyPath));
        try {
            KeyFactory kf = KeyFactory.getInstance("EC");
            ECPrivateKey ecPrivateKey = (ECPrivateKey) kf.generatePrivate(spec);
            JWSSigner jwsSigner = new ECDSASigner(ecPrivateKey.getS());
            jwt.sign(jwsSigner);
        } catch (InvalidKeyException | JOSEException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
            throw new RuntimeException(e);
        }

        return jwt.serialize();
    }

    /**
     * 파일에서 private key 획득
     *
     * @return Private Key
     */
    private static byte[] readPrivateKey(String keyPath) {

        Resource resource = new ClassPathResource(keyPath);
        byte[] content = null;

        try (InputStream keyInputStream = resource.getInputStream();
                InputStreamReader keyReader = new InputStreamReader(keyInputStream);
                PemReader pemReader = new PemReader(keyReader)) {
            PemObject pemObject = pemReader.readPemObject();
            content = pemObject.getContent();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return content;
    }
}

Apple Developer 설정할 때 받아왔던 정보를 모두 기억해야 하는 이유이다.

teamId, clientId, keyId 를 모두 요구한다.

여기서 keyPath 는 .p8 파일이 들어있는 폴더이다.

예를 들어 다음과 같이 resources 디렉토리에 p8 파일을 넣어두었다면,

keyPath 에 대한 설정 디렉토리는 다음과 같아진다.

APPLE_KEY_PATH=static/apple/AuthKey_{keyId}.p8

또한 ECPrivateKeyImpl 같은 경우 java.security 에 기본 포함된 것으로 아는데

문제가 있어 비슷한 다른 라이브러리를 차용했다.

PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(readPrivateKey(keyPath));
try {
    KeyFactory kf = KeyFactory.getInstance("EC");
    ECPrivateKey ecPrivateKey = (ECPrivateKey) kf.generatePrivate(spec);
    JWSSigner jwsSigner = new ECDSASigner(ecPrivateKey.getS());
    jwt.sign(jwsSigner);
} catch (InvalidKeyException | JOSEException e) {
    e.printStackTrace();
} catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
    throw new RuntimeException(e);
}

그리고 빌드된 jar 파일 내부에서 :classpath 를 제대로 찾지 못해서

FileNotFoundException 이 터지는 문제가 있었다.

getFile 같은 경우

Resource 객체의 참조 리소스가 classpath 에 있는 경우 오류가 발생한다.

반면 getInputStream 은

Resource 객체의 모든 리소스 내용을 바이트 단위로 읽을 수 있고

FileNotFoundException 이 터지지 않는다.

private static byte[] readPrivateKey(String keyPath) {

    Resource resource = new ClassPathResource(keyPath);
    byte[] content = null;

    try (InputStream keyInputStream = resource.getInputStream();
            InputStreamReader keyReader = new InputStreamReader(keyInputStream);
            PemReader pemReader = new PemReader(keyReader)) {
        PemObject pemObject = pemReader.readPemObject();
        content = pemObject.getContent();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return content;
}

이러한 과정으로 jwt 로 감싸주면 client secret 이 생성된다.

애플 로그인을 처음 구현한다면

다른 OAuth 에 비해 상당히 난해한 부분이 바로 여기이다.

{
  "access_token":"a08c1600e80f84d4484...",
  "expires_in":3600,
  "id_token":"eyJraWQiOiJlWGF1bm...",
  "refresh_token":"r8e88bc9f62bc49...",
  "token_type":"Bearer"
}

응답값으로 다음과 같이 전달되고

AppleTokenResponse

@Getter
@NoArgsConstructor
@JsonNaming(SnakeCaseStrategy.class)
public class AppleTokenResponse {
    private String accessToken;
    private String refreshToken;
    private String idToken;
}

다음 DTO 에 저장하여 사용한다.

이제 idToken 을 다음 요청에 사용하면 된다.

id_token 검증하기

메소드와 DTO 등 자세한 것은

내용이 길어져서 게시글을 분리시켰다

[Spring] 스프링 소셜 로그인에 OIDC 사용하기 (OAuth with OpenID Connect)

OpenID Connect (OIDC) 는 무엇인가? OAuth 2.0 프로토콜을 기반으로 한 사용자 인증 프로토콜 accessToken 이외에도 id_token을 사용하여 토큰으로 사용자가 누구인지 확인할 수도 있다. OIDC는 표준 프로토

gengminy.tistory.com

id_token 으로 회원가입하기

AppleController

@PostMapping("/register")
public TokenResponse appleOAuthRegistration(
        @RequestParam("id_token") String token,
        @Valid @RequestBody UserRegistrationRequest userRegistrationRequest) {
    return appleService.registerUserByOCIDToken(token, userRegistrationRequest);
}

발급받은 id token 을 통해 회원가입을 진행해보자.

AppleService

public TokenAndUserResponse registerUserByOCIDToken(
			String idToken, UserRegistrationRequest userRegistrationRequest) {
    final OAuthInfo oAuthInfo = this.getOAuthInfoByIdToken(idToken);
    final UserProfileDto userProfileDto = userRegistrationRequest.toProfile();

    final User user = userService.register(userProfileDto, oAuthInfo);
    return tokenGenerateHelper.generate(user);
}

Apple OAuth 에서는 유저 정보에 대한 스코프가 현저하게 적기 때문에 (이름, 이메일로 끝)

유저 회원가입 정보를 반드시 추가로 받아야 한다.

이를 받아서 회원가입을 진행하고 토큰을 발급해주는 로직이다.

이 글은 Apple OAuth 에 대한 글이기 때문에 자세한 로직은 생략.

public OAuthInfo getOAuthInfoByIdToken(String idToken) {
    OIDCDecodePayload oidcDecodePayload = getOIDCDecodePayload(idToken);
    return OAuthInfo.builder().provider(Provider.APPLE).oid(oidcDecodePayload.getSub()).build();
}

public OIDCDecodePayload getOIDCDecodePayload(String token) {
    OIDCPublicKeysResponse oidcPublicKeysResponse = appleOIDCClient.getAppleOIDCOpenKeys();
    return oAuthOIDCHelper.getPayloadFromIdToken(
            token,
            appleOAuthProperties.getBaseUrl(),
            appleOAuthProperties.getClientId(),
            oidcPublicKeysResponse);
}

id token 을 decode 하여 정보를 가져오는 로직

앞서 구현한 id token 검증 로직으로 검증해주면 decode 가 완료된다.

OAuthInfo / Provider

@Getter
@AllArgsConstructor
@Builder
public class OAuthInfo {
    private Provider provider;
    private String oid;

    public static OAuthInfo from(OAuthUserInfoDto oAuthUserInfoDto) {
        return new OAuthInfo(oAuthUserInfoDto.getOAuthProvider(), oAuthUserInfoDto.getOauthId());
    }
}

@Getter
@AllArgsConstructor
public enum Provider {
    GOOGLE("GOOGLE"),
    KAKAO("KAKAO"),
    APPLE("APPLE");

    private String value;
}

OAuth provider 와 유저 고유 아이디인 oid 값을 담는 객체

TokenGenerationHelper

@Service
@RequiredArgsConstructor
public class TokenGenerationHelper {

    private final JwtTokenProvider jwtTokenProvider;
    private final UserService userService;

    @Transactional
    public TokenAndUserResponse generate(User user) {
        final String newAccessToken =
                jwtTokenProvider.generateAccessToken(user.getId(), user.getRole().getValue());
        final String newRefreshToken = jwtTokenProvider.generateRefreshToken(user.getId());

        user.setRefreshToken(newRefreshToken);
        userService.upsert(user);

        return TokenAndUserResponse.builder()
                .accessToken(newAccessToken)
                .accessTokenAge(jwtTokenProvider.getAccessTokenTTLSecond())
                .refreshTokenAge(jwtTokenProvider.getRefreshTokenTTLSecond())
                .refreshToken(newRefreshToken)
                .build();
    }
}

최종적으로 엑세스 토큰과 리프레시 토큰까지 발급해주면 완료

id_token 으로 로그인 하기

AppleController

@PostMapping("/login")
public TokenResponse appleOAuthUserLogin(@RequestParam("id_token") String token) {
    return appleService.login(token);
}

이번엔 id token 으로 우리 서버 로그인을 해보자

발급받은 id token 을 가져온다.

AppleService

public TokenResponse login(String idToken) {
    OAuthInfo oAuthInfo = this.getOAuthInfoByIdToken(idToken);
    User user = userService.login(oAuthInfo);
    return tokenGenerationHelper.generate(user);
}

oAuthInfo 를 가지고 유저 정보를 찾음

UserService

@Transactional
public User login(OAuthInfo oAuthInfo) {
    User user = userAdaptor.queryByOAuthInfo(oAuthInfo);
    user.login();
    return user;
}

//User
public void login() {
    if (!this.state.equals(ACTIVE)) throw new BaseException(INACTIVE_USER);
}

이후 유저 검증을 해주면 로그인 로직 끝

OIDC 방식과 Apple login 모두를 적용하는게 상당히 난이도 있지만

서버 관련 지식이 더욱 상승하는 것 같다.

다른 OAuth 로그인 대응 시에도 동일하게 사용 가능하니까

한번 적용하면 편리하다.

필자는 실제론 이런 식으로 Provider 별로 Switch 하여 대응 중이다.

private OAuthInfo getOAuthInfoByProviderAndIdToken(Provider provider, String idToken) {
    switch (provider) {
        case GOOGLE:
            return googleOAuthHelper.getOAuthInfoByIdToken(idToken);
        case KAKAO:
            return kakaoOAuthHelper.getOAuthInfoByIdToken(idToken);
        case APPLE:
            return appleOAuthHelper.getOAuthInfoByIdToken(idToken);
        default:
            throw new BaseException(INVALID_OAUTH_PROVIDER);
    }
}

[Spring] 스프링 Feign Client 적용하기 (Spring Cloud OpenFeign)

gengminy — Sat, 25 Mar 2023 20:07:58 +0900

Feign Client 란?

본래 Netflix (그 넷플릭스 맞음) 에서

오픈 소스 일부로 개발되어 사용중인 경량 REST 클라이언트

현재는 Spring Cloud 프레임워크의 일부가 되었다.

인터페이스로 정의된 API를 기반으로 RESTful 서비스를 호출한다.

이를 통해 코드 가독성과 유지 보수성이 늘어남을 기대할 수 있다.

Dependency

implementation group: 'org.springframework.cloud', name: 'spring-cloud-starter-openfeign', version: '3.1.1'
implementation 'io.github.openfeign:feign-jackson:12.1'

@EnableFeignClient

Feign 을 사용하기 위한 어노테이션

class 를 가져오는 방식과 basePackage 를 기반으로 scan 하는 방식이 있다.

FeignCommonConfig

@Configuration
@EnableFeignClients(basePackageClasses = BaseFeignClientPackage.class)
public class FeignCommonConfig {}

이 프로젝트에서는 basePackage 를 스캔하는 방식을 사용했다.

BaseFeignClientPackage

public interface BaseFeignClientPackage {}

Feign Client 들이 있는 패키지에 이 인터페이스 파일을 넣어주면

해당 패키지 하위의 모든 FeignClient 들을 스캔해준다.

@FeignClient

Feign 에서 본격적으로 외부 서버와 통신하게 해주는 Client

인터페이스 기반으로 구현되기 때문에 가독성이 훨씬 높다.

RestTemplete 예시

public CommonResponse addUser() {
  RestTemplate restTemplate = new RestTemplate();

  HttpHeaders headers = new HttpHeaders();
  headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

  MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
  map.add("userId", "lim");
  map.add("userName", "sua");
  map.add("age", "21");
  
  HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<>(map, headers);
  ResponseEntity<CommonResponse> response = 
    restTemplate.postForEntity(USER_URL + "/form", request, CommonResponse.class);

  return response.getBody();
}

만약 RestTemplete 이나 Webclient 로 구현되었으면

위처럼 서비스 레이어에서 http 요청이 수행됐을 거다

AppleOAuthClient

@FeignClient(
        name = "AppleOAuthClient",
        url = "https://appleid.apple.com",
        configuration = AppleOAuthConfig.class)
public interface AppleOAuthClient {

    @PostMapping("/auth/token?grant_type=authorization_code")
    AppleTokenResponse appleAuth(
            @RequestParam("client_id") String clientId,
            @RequestParam("redirect_uri") String redirectUri,
            @RequestParam("code") String code,
            @RequestParam("client_secret") String clientSecret);
}

애플 oauth 서버에서 받은 인가 코드를 넘겨서 인증하는 Client 예시

반면 Feign Client 같은 경우는

마치 컨트롤러에서 수행되는 것 처럼 인터페이스가 구성되어 있어

관심도 분리 측면에서 훨씬 좋은 것 같다.

의견 차이가 있을 수 있겠지만 Feign Client 가 가독성이 더 높아 보인다.

추가 설정

설정 파일을 통해 Feign Client 에 대한 추가 설정을 해줄 수 있다.

AppleOAuthConfig

@Import(AppleOAuthErrorDecoder.class)
public class AppleOAuthConfig {

    @Bean
    @ConditionalOnMissingBean(value = ErrorDecoder.class)
    public AppleOAuthErrorDecoder commonFeignErrorDecoder() {
        return new AppleOAuthErrorDecoder();
    }

    @Bean
    Encoder formEncoder() {
        return new feign.form.FormEncoder();
    }
}

@ConditionalOnMissingBean 어노테이션은

기존 ErrorDecoder 가 존재하면 무시,

존재하지 않을 경우 AppleOAuthErrorDecoder 를 등록하도록 한다.

FeignClient 같은 경우 200 이외 값에 대해서 에러를 처리 해주는데

이 설정을 통해 에러 디코더에 대한 커스터마이징을 도와준다.

Encoder 는 객체를 Key - Value 의 폼 데이터로 변환시켜준다.

이를 통해 Java 객체를 HTTP POST 요청에 대한 폼 데이터로 보낼 수 있도록 한다.

Content-Type 헤더는 application/x-www-form-urlencoded 로 설정된다.

AppleOAuthDecoder

public class AppleOAuthErrorDecoder implements ErrorDecoder {
    @Override
    @SneakyThrows
    public Exception decode(String methodKey, Response response) {
        InputStream inputStream = response.body().asInputStream();
        byte[] byteArray = IOUtils.toByteArray(inputStream);
        String responseBody = new String(byteArray);
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode jsonNode = objectMapper.readTree(responseBody);

        String error = jsonNode.get("error") == null ? null : jsonNode.get("error").asText();
        String errorDescription =
                jsonNode.get("error_description") == null
                        ? null
                        : jsonNode.get("error_description").asText();

        System.out.println(jsonNode);
        throw new BaseDynamicException(response.status(), error, errorDescription);
    }
}

ErrorDecoder 를 implements 한다.

이를 통해 에러 코드에 대한 처리를 커스터마이징 할 수 있다.

OAuth 인증을 예시로 들면

구글, 카카오, 네이버, 애플 등등 모두 에러 처리에 대한 응답이 다르다.

그렇기 때문에 각 서비스 별 에러 처리에 대해 커스터마이징 해주어 처리할 필요가 있었다.

KauthErrorDecoder

public class KauthErrorDecoder implements ErrorDecoder {
    @Override
    public Exception decode(String methodKey, Response response) {
        KakaoKauthErrorResponse body = KakaoKauthErrorResponse.from(response);

        try {
            KakaoKauthErrorCode kakaoKauthErrorCode =
                    KakaoKauthErrorCode.valueOf(body.getErrorCode());
            throw kakaoKauthErrorCode.getException();
        } catch (IllegalArgumentException e) {
            KakaoKauthErrorCode koeInvalidRequest = KakaoKauthErrorCode.KOE_INVALID_REQUEST;
            throw koeInvalidRequest.getException();
        }
    }
}

예시로 카카오 oauth 같은 경우에는

KOE303 과 같이 카카오 자체 에러코드를 제공해준다.

이를 커스터마이징하여 에러 메세지를 자체적으로 내 서버에 띄우도록 할 수 있다.

그렇다면 FeignClient 호출은?

public AppleTokenResponse getOAuthTokenTest(String code) {
    return appleOAuthClient.appleAuth(
            appleOAuthProperties.getClientId(),
            appleOAuthProperties.getRedirectUrl(),
            code,
            getClientSecret());
}

마치 메소드를 호출하는 것 처럼

서비스 레이어에서 파라미터를 넣어줌으로써 호출할 수 있다.

로직 분리에 정말 탁월하고 편리하다.

처음 설정하는 부분이 어려울 수도 있는데

적응하면 이 만큼 가독성 높고 편리한 것도 없다.

특히 외부 서버의 API 를 호출하는 코드가 많다면

Feign Client 의 도입을 적극적으로 고려해봐도 좋을 것 같다!

[DuDoong] 두둥 프로젝트 관련 글 정리

gengminy — Wed, 15 Mar 2023 23:42:11 +0900

사용 언어 / 프레임워크

Java + Spring Boot
MySQL
Redis
Docker
JUnit5
Spring Batch
Spring Cloud Feign

✨ 웹 사이트 주소

https://dudoong.com/

두둥!

모두를 위한 새로운 공연 라이프

dudoong.com

[Spring] 스프링 500 에러 발생 시 Slack 알림 전송하기 (슬랙 봇)

gengminy — Wed, 15 Mar 2023 23:21:08 +0900

500 에러 발생시 메세지를 보내주는 슬랙 봇 2

지난 글에 이은,

본격적으로 500 내부 서버 에러 발생 시

슬랙으로 알림을 전송해주는 봇을 만들어보는 글이다.

Slack API 를 활용하여 이러한 알림 서비스를 구현할 수 있다.

⚙️ Dependency

implementation 'com.slack.api:slack-api-client:1.27.2'

다음과 같은 의존성을 build.gradle 에 추가해준다.

Slack API 사용하기 위한 설정

SlackApiConfig

@Configuration
public class SlackApiConfig {

    @Value("${slack.webhook.token}")
    private String token;

    @Bean
    public MethodsClient getClient() {
        Slack slackClient = Slack.getInstance();
        return slackClient.methods(token);
    }
}

우선 지속적으로 알림을 보내는 봇으로 만들고자 슬랙 봇을 추가했다.

슬랙 봇을 사용할 때는 슬랙 관련 설정이 필요하다.

MethodClient 빈에 슬랙 웹훅 토큰을 등록하는 과정이 필요한데,

슬랙 웹훅 토큰(OAuth Token)은 xoxb- 로 시작하는 문자열이다.

자세한 발급 과정은 추가 게시글에 올려두었다.

https://gengminy.tistory.com/52

[Slack] 슬랙 봇 설정 및 슬랙 OAuth Token 발급받기

스프링에서 Slack API 를 사용하기 위해서는 슬랙 웹훅 토큰이 필요하다. 따라서 슬랙 토큰을 발급받고 슬랙 봇을 등록하는 과정을 알아보자. 1. 워크스페이스 및 슬랙 APP 생성 https://api.slack.com/apps

gengminy.tistory.com

슬랙 알림 구현하기

SlackHelper

@Component
@RequiredArgsConstructor
@Slf4j
public class SlackHelper {
    private final SpringEnvironmentHelper springEnvironmentHelper;

    private final MethodsClient methodsClient;

    public void sendNotification(String CHANNEL_ID, List<LayoutBlock> layoutBlocks) {
        if (!springEnvironmentHelper.isProdAndStagingProfile()) {
            return;
        }
        ChatPostMessageRequest chatPostMessageRequest =
                ChatPostMessageRequest.builder()
                        .channel(CHANNEL_ID)
                        .text("")
                        .blocks(layoutBlocks)
                        .build();
        try {
            methodsClient.chatPostMessage(chatPostMessageRequest);
        } catch (SlackApiException | IOException slackApiException) {
            log.error(slackApiException.toString());
        }
    }
}

SpringEnvironmentHelper 는 현재 프로파일을 가져오도록 만든

커스텀 유틸 클래스이다.

Prod 환경일 때만 Slack 알림을 보여주기 위해 도입했다.

이 클래스에서는 실제 Slack API 를 호출하여 알림을 전송한다.

ChatPostMessageRequest 인스턴스를 생성하여

methodsClient.chatPostMessage 의 인자로 넣고 호출하면

슬랙 메세지가 전송된다.

SlackErrorNotificationProvider

@Component
@RequiredArgsConstructor
@Slf4j
public class SlackErrorNotificationProvider {

    private final SlackHelper slackHelper;

    private final int MAX_LEN = 500;

    @Value("${slack.webhook.id}")
    private String CHANNEL_ID;

    public String getErrorStack(Throwable throwable) {
        String exceptionAsString = Arrays.toString(throwable.getStackTrace());
        int cutLength = Math.min(exceptionAsString.length(), MAX_LEN);
        return exceptionAsString.substring(0, cutLength);
    }

    @Async
    public void sendNotification(List<LayoutBlock> layoutBlocks) {
        slackHelper.sendNotification(CHANNEL_ID, layoutBlocks);
    }
}

워크스페이스의 채널 ID를 설정하고 전송 메소드를 호출하는 클래스

getErrorStack 는 해당 에러의 StackTrace 를 꺼내어

최대 길이를 제한해주는 유틸 메소드이다.

SlackInternalErrorSender

@Component
@RequiredArgsConstructor
@Slf4j
public class SlackInternalErrorSender {
    private final ObjectMapper objectMapper;

    private final SlackErrorNotificationProvider slackProvider;

    public void execute(ContentCachingRequestWrapper cachingRequest, Exception e, Long userId)
            throws IOException {
        final String url = cachingRequest.getRequestURL().toString();
        final String method = cachingRequest.getMethod();
        final String body =
                objectMapper.readTree(cachingRequest.getContentAsByteArray()).toString();

        final String errorMessage = e.getMessage();
        String errorStack = slackProvider.getErrorStack(e);
        final String errorUserIP = cachingRequest.getRemoteAddr();

        List<LayoutBlock> layoutBlocks = new ArrayList<>();
        layoutBlocks.add(
                Blocks.header(
                        headerBlockBuilder ->
                                headerBlockBuilder.text(plainText("Error Detection"))));
        layoutBlocks.add(divider());

        MarkdownTextObject errorUserIdMarkdown =
                MarkdownTextObject.builder().text("* User Id :*\n" + userId).build();
        MarkdownTextObject errorUserIpMarkdown =
                MarkdownTextObject.builder().text("* User IP :*\n" + errorUserIP).build();
        layoutBlocks.add(
                section(
                        section ->
                                section.fields(List.of(errorUserIdMarkdown, errorUserIpMarkdown))));

        MarkdownTextObject methodMarkdown =
                MarkdownTextObject.builder()
                        .text("* Request Addr :*\n" + method + " : " + url)
                        .build();
        MarkdownTextObject bodyMarkdown =
                MarkdownTextObject.builder().text("* Request Body :*\n" + body).build();
        List<TextObject> fields = List.of(methodMarkdown, bodyMarkdown);
        layoutBlocks.add(section(section -> section.fields(fields)));

        layoutBlocks.add(divider());

        MarkdownTextObject errorNameMarkdown =
                MarkdownTextObject.builder().text("* Message :*\n" + errorMessage).build();
        MarkdownTextObject errorStackMarkdown =
                MarkdownTextObject.builder().text("* Stack Trace :*\n" + errorStack).build();
        layoutBlocks.add(
                section(section -> section.fields(List.of(errorNameMarkdown, errorStackMarkdown))));

        slackProvider.sendNotification(layoutBlocks);
    }
}

본격적으로 내부 에러를 처리하기 위한 클래스이다.

슬랙 메세지에는 마크다운 언어를 지원하기 때문에

커스텀하여 메세지 형식을 바꿔서 예쁘게 보여줄 수 있다.

마크다운 오브젝트는 Slack API 패키지에 포함되어 있어 즉시 사용 가능하다.

여기서 주목해야 할 점은 ContentCachingRequestWrapper 인데 후술하겠다.

GlobalExceptionHandler

@RestControllerAdvice
@Slf4j
@RequiredArgsConstructor
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
    private final SlackInternalErrorSender slackInternalErrorSender;
    
    //...(생략)
    
    @ExceptionHandler(Exception.class)
    protected ResponseEntity<ErrorResponse> handleException(Exception e, HttpServletRequest request)
            throws IOException {
        final ContentCachingRequestWrapper cachingRequest = (ContentCachingRequestWrapper) request;
        final Long userId = SecurityUtils.getCurrentUserId();
        String url =
                UriComponentsBuilder.fromHttpRequest(new ServletServerHttpRequest(request))
                        .build()
                        .toUriString();

        log.error("INTERNAL_SERVER_ERROR", e);
        GlobalErrorCode internalServerError = GlobalErrorCode.INTERNAL_SERVER_ERROR;
        ErrorResponse errorResponse =
                new ErrorResponse(
                        internalServerError.getStatus(),
                        internalServerError.getCode(),
                        internalServerError.getReason(),
                        url);

        slackInternalErrorSender.execute(cachingRequest, e, userId);
        return ResponseEntity.status(HttpStatus.valueOf(internalServerError.getStatus()))
                .body(errorResponse);
    }
}

최종 목표인 내부 서버 에러에 대해 처리하는

GlobalExceptionHandler 이다.

앞서 비즈니스 익셉션 등의 처리에 걸러지지 못하고 남은 애들은 이곳으로 온다.

여기서 HttpServletRequest 를 즉시 사용하지 않고

ContentCachingRequestWrapper 로 감싸주는 형태를 사용하게 된다.

httpServletRequest의 내용을 가져오기 위해 getInputStream() 을 사용해야하는데,

한번 사용하게 될 경우 내용이 사라지게 된다.

그래서 java.lang.IllegalStateException: getReader() has already been called for this request 에러가 발생한다.

그렇기 때문에 ContentCachingRequestWrapper 로 감싸주어 전달하는 것이다.

이렇게 되면 원하는 처리가 이루어지게 된다.

[Slack] 슬랙 봇 설정 및 슬랙 OAuth Token 발급받기

gengminy — Wed, 15 Mar 2023 23:01:20 +0900

스프링에서 Slack API 를 사용하기 위해서는

슬랙 웹훅 토큰이 필요하다.

따라서 슬랙 토큰을 발급받고 슬랙 봇을 등록하는 과정을 알아보자.

1. 워크스페이스 및 슬랙 APP 생성

https://api.slack.com/apps

Slack API: Applications | Slack

Your Apps Don't see an app you're looking for? Sign in to another workspace.

api.slack.com

해당 작업 이전에 Slack 워크스페이스를 생성해두어야 합니다.

이후 슬랙 APP 을 생성하기 위해 Slack API 사이트에 접속합니다.

오른쪽 상단 Create New App

App 이름 지어주고 이 앱을 등록할 워크스페이스를 지정합니다.

이후 Create App 버튼 클릭

2. Bot 유저 추가

앱 생성 후 Bots 를 선택해줍니다.

3. Scopes 지정

OAuth & Permissions 탭에서 Scopes 를 찾습니다.

이 앱에 원하는 권한을 지정합니다.

메세지 전송 권한을 위해 chat:write 는 필수겠죠?

4. OAuth Token 발급

이제 Install to Workspace 버튼을 통해 워크스페이스에 설치.

드디어 원하는 OAuth Token 을 획득했습니다.

Slack API 토큰은 xoxb- 로 시작하는 문자열입니다.

5. 워크스페이스에 봇 유저 추가

워크스페이스로 돌아와서 원하는 채널 오른쪽 클릭 후 "앱 추가"

통합 -> 앱 추가

이제 방금 전 등록했던 슬랙 앱이 보일 겁니다.

추가 해줍니다.

해당 채널에 이렇게 뜬다면 성공입니다.

이제 발급받은 봇 유저 토큰으로 Slack API 를 사용하시면 됩니다.

[Spring] 스프링 Slack 메세지 전송하기 (Incoming WebHooks 활용하여 슬랙봇 만들기)

gengminy — Fri, 3 Mar 2023 14:35:24 +0900

500 에러 발생 시 메세지 보내주는 슬랙봇

개발 중 로컬 서버에서 발생한 에러는 바로 탐지가 가능하지만,

배포 서버에서 실행 중일 때 발생한 에러는 바로 탐지가 어렵다.

그래서 에러 발생 시 메세지를 띄워주면 좋겠다고

누구나 한 번 쯤은 생각해보았을 것이다.

Slack API 를 활용하여 알림을 보낸다면

이러한 알림 서비스를 구현하고 활용할 수 있다.

다만 이 파트에서는 에러 자동 탐지 알림 대신

사용자 편의를 의한 단순 메세지 발송에 대해서만 적었다.

500 서버 에러 탐지 알림은 아래 다른 게시글에 올려두었다.

https://gengminy.tistory.com/53

[Spring] 스프링 500 에러 발생 시 Slack 알림 전송하기 (슬랙 봇)

지난 글에 이은, 본격적으로 500 내부 서버 에러 발생 시 슬랙으로 알림을 전송해주는 봇을 만들어보는 글이다. Slack API 를 활용하여 이러한 알림 서비스를 구현할 수 있다. ⚙️ Dependency implementati

gengminy.tistory.com

⚙️ Dependency

implementation 'com.slack.api:slack-api-client:1.27.2'
implementation group: 'org.apache.commons', name: 'commons-lang3', version: '3.12.0'

Slack API 사용을 위한 slack api client 추가
StringUtils 를 사용하기 위한 apache 모듈 추가 (이건 반드시 필요한 것은 아님)

Incoming Webhooks URL 발급받기

토큰을 가져와 Slack API Bean 을 만들어 등록 및 사용하는 방식도 있지만,

이 글에서는 Incoming Webhooks 라는 서드파티 앱을 추가한 후

전용 URL 을 발급받아 메세지를 전송하는 방식을 택했다.

Incoming Webhooks URL 발급받는 방법

1. 채널 세부정보 보기

Slack 워크스페이스 생성 -> 채널 오른쪽 클릭 -> 채널 세부정보 보기

2. 앱 추가 들어가기

통합 -> 앱 -> 앱 추가

3. Incoming Webhooks 앱 추가

Incoming WebHooks 검색 -> 앱 디렉터리에서 -> 설치

Slack에 추가 클릭

메세지를 받기 원하는 채널 선택 -> 수신 웹후크 통합 앱 추가 클릭

다음과 같이 웹후크 URL 이 발급된다!

이것을 슬랙 URL 로 등록하고, 메세지를 보내면 된다.

Incoming Webhooks URL 작동 테스트 하기

웹훅 URL 발급받은 창에서 아래로 내리면

다음과 같이 예시 요청을 보낼 수 있도록 샘플 코드가 주어진다.

curl -X POST --data-urlencode "payload={\"channel\": \"#webhook\", \"username\": \"webhookbot\", \"text\": \"이 항목은 #개의 webhook에 포스트되며 webhookbot이라는 봇에서 제공됩니다.\", \"icon_emoji\": \":ghost:\"}" https://hooks.slack.com/services/{고유 문자열}

위에 있는 요청을 보냈을 때 응답으로 ok 가 온다면

송수신이 정상적으로 이루어짐을 확인할 수 있다.

슬랙 채널에서도 알림이 성공적으로 오는 모습

Slack URL 등록 비즈니스 로직

이제 채널 URL 발급받는 방법을 알았으니

채널을 등록하고 메세지를 보내보도록 하자.

HostController

@RestController
@RequestMapping("/v1/hosts")
@RequiredArgsConstructor
public class HostController {    
    private final UpdateHostSlackUrlUseCase updateHostSlackUrlUseCase;
    
    //... 생략

    @PatchMapping("/{hostId}/slack")
    public HostDetailResponse patchHostSlackUrlById(
            @PathVariable Long hostId,
            @RequestBody @Valid UpdateHostSlackRequest updateHostSlackRequest) {
        return updateHostSlackUrlUseCase.execute(hostId, updateHostSlackRequest);
    }
}

특정 호스트의 아이디를 통해 호스트를 가져온다

UpdateHostSlackRequest

@Getter
@NoArgsConstructor
@AllArgsConstructor
public class UpdateHostSlackRequest {
    @NotBlank(message = "올바른 슬랙 URL 을 입력해주세요")
    @URL(message = "올바른 슬랙 URL 을 입력해주세요")
    private String slackUrl;
}

호스트 슬랙 업데이트를 위한 요청 DTO

단순하게 String 만 하나 가져오고

DTO 내부에서 Validation 한다.

UpdateHostSlackUrlUseCase

@UseCase
@RequiredArgsConstructor
public class UpdateHostSlackUrlUseCase {
    private final HostService hostService;
    private final HostAdaptor hostAdaptor;
    private final HostMapper hostMapper;

    private final SlackMessageProvider slackMessageProvider;

    @Transactional
    @HostRolesAllowed(role = MANAGER, findHostFrom = HOST_ID)
    public HostDetailResponse execute(Long hostId, UpdateHostSlackRequest updateHostSlackRequest) {
        final Host host = hostAdaptor.findById(hostId);
        final String slackUrl = updateHostSlackRequest.getSlackUrl();
        hostService.validateDuplicatedSlackUrl(host, slackUrl);

        try {
            slackMessageProvider.register(slackUrl);
            return hostMapper.toHostDetailResponse(hostService.updateHostSlackUrl(host, slackUrl));
        } catch (UnknownHostException e) {
            throw InvalidSlackUrlException.EXCEPTION;
        }
    }
}

두둥 프로젝트에서는 Service 끼리의 참조에서 생기는

순환 참조와 복잡도 증가 등을 막기 위해

UseCase 라는 레이어를 하나 더 도입했다.

즉 UseCase 에서 종합적인 비즈니스 로직이 실행된다.

SlackUrl 의 중복 주입을 검증하고

레포지토리에서 Host 를 가져와 주입하는 로직이다.

try catch 로 감싼 이유는

이후 내부에서 반환되는 UnknownHostException 을 깔끔하게 처리하기 위함이다.

반환값은 Setter 호출 및 Response DTO 생성이니

무시해도 된다.

SlackMessageProvider

@Service
@RequiredArgsConstructor
@Slf4j
public class SlackMessageProvider {

    @Value("${slack.webhook.username}")
    private String username;

    @Value("${slack.webhook.icon-url}")
    private String iconUrl;

    /** 이벤트 핸들러 자체에서 비동기로 실행하기 때문에 @Async 어노테이션 지움 */
    public void sendMessage(String url, String text) {
        // 슬랙 url 이 null 일경우 안보냄.
        if (Objects.isNull(url)) return;
        try {
            doSend(url, text);
        } catch (Exception ignored) {
        }
    }

    /** 호스트가 존재하는 지 확인하기 위해 동기로 처리 */
    public void register(String url) throws UnknownHostException {
        final String text = "두둥 슬랙 알림이 성공적으로 등록되었습니다!";
        doSend(url, text);
    }

    private void doSend(String url, String text) throws UnknownHostException {
        final Slack slack = Slack.getInstance();
        final Payload payload =
                Payload.builder().text(text).username(username).iconUrl(iconUrl).build();
        try {
            String responseBody = slack.send(url, payload).getBody();
            if (!StringUtils.equals(responseBody, "ok")) {
                throw new UnknownHostException("올바른 슬랙 URL이 아닙니다.");
            }
        } catch (UnknownHostException error) {
            // 호스트가 존재하지 않을 경우 abort
            throw error;
        } catch (IOException e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }
}

이제 슬랙 API 를 본격적으로 사용하는 부분이다.

doSend 라는 private method 에서는

해당 URL 에 텍스트를 보내는 로직을 수행한다.

아까 전에 해당 URL 에 Payload 를 담아 post 요청을 보내면

응답 값으로 ok 가 반환되는 것을 확인했다.

요청에 실패하면 슬랙 API 자체에서 UnknownErrorException 가 던져지는데,

이를 응용하여 "ok" 가 반환되면 통과시키고

그렇지 않으면 UnknownErrorException 을 임의로 던져주도록 변형했다.

IOException 은 슬랙 메세지 전송 실패에 대해 처리하기 위해 추가했다.

Slack 인스턴스를 가져와서 Payload 에 원하는 값을 넣고

slack.send() 메소드를 호출하면 메세지 전송이 된다.

다른 슬랙 알림 같은 경우는 @Async 를 통해 비동기로 처리했으나,

등록 로직 같은 경우는 응답이 제대로 오는지 안오는지 먼저 확인해야 하기 때문에

동기로 처리하였다.

이상한 url 을 입력하여 메세지 전송에 실패했을 때 오류

슬랙 url 등록 성공 시 메세지

Slack 비동기 메세지 전송 비즈니스 로직

이벤트를 간편하게 구현하기 위해 커스텀 객체들이 많으니 감안하고 봐주시길

이벤트 발행과 처리에 대해서 이 글에서 상세하게 다루지는 않겠다.

Host

@Getter
public class Host extends BaseTimeEntity {
	
    //...생략
    
    public void setSlackUrl(String slackUrl) {
        if (StringUtils.equals(this.slackUrl, slackUrl)) {
            throw DuplicateSlackUrlException.EXCEPTION;
        }
        Events.raise(HostRegisterSlackEvent.of(this));
        this.slackUrl = slackUrl;
    }
    
	//...생략
}

Events 오브젝트는 ApplicationEventPublisher 를 감싸서 임의로 구현한 것이다.

publishEvent 의 의미라고 생각하면 되겠다.

Host 내부에서 setter 를 호출할 때 호스트 등록 이벤트를 발생시켰다.

HostRegisterSlackEvent

@Getter
@Builder
@ToString
public class HostRegisterSlackEvent extends DomainEvent {
    private final Long hostId;
    private final String hostName;

    public static HostRegisterSlackEvent of(Host host) {
        return HostRegisterSlackEvent.builder()
                .hostId(host.getId())
                .hostName(host.toHostProfileVo().getName())
                .build();
    }
}

Events 에서 DomainEvent 라는 객체로 통합 처리하기 위해 이를 상속받는다.

발행시킬 이벤트는 POJO 로 구성한다.

DomainEvent

@Getter
public class DomainEvent {
    private final LocalDateTime publishAt;

    public DomainEvent() {
        this.publishAt = LocalDateTime.now();
    }
}

DomainEvent 객체는 그냥 이렇게 생겼다.

HostRegisterSlackEventHandler

@Component
@RequiredArgsConstructor
@Slf4j
public class HostRegisterSlackEventHandler {
    private final HostAdaptor hostAdaptor;
    private final SlackMessageProvider slackMessageProvider;

    @Async
    @TransactionalEventListener(
            classes = HostRegisterSlackEvent.class,
            phase = TransactionPhase.AFTER_COMMIT)
    public void handle(HostRegisterSlackEvent hostRegisterSlackEvent) {
        final Host host = hostAdaptor.findById(hostRegisterSlackEvent.getHostId());
        final String message = HostSlackAlarm.slackRegistrationOf(host);

        slackMessageProvider.sendMessage(host.getSlackUrl(), message);
    }
}

발행시킨 이벤트를 리스닝하고 처리해주는 핸들러를 구현한다.

@Async 를 통해 비동기로 처리하며,

@TransactionalEventListener 의 phase 를 AFTER_COMMIT 으로 설정해

트랜잭션이 종료되어 성공적으로 Host 엔티티에 값이 들어간 이후에

이 이벤트가 실행되도록 했다.

슬랙 url 등록 성공 시 메세지

그래서 아래의 메세지가 성공적으로 나오게 된다.

이를 활용하여 각종 호스트 유저 가입, 티켓 판매 알림 등등

알림을 구현하여 유저에게 편의성을 제공하였다.

[Spring] 스프링 날짜 타입 JSON 변환 및 포맷팅하기 - @JsonFormat, @JacksonAnnotationsInside

gengminy — Mon, 27 Feb 2023 00:46:03 +0900

개발을 하다보면

좋든 싫든 항상 날짜에 대한 포맷팅을 마주하게 된다.

이 글에서는 그 과정에서 공부했던,

@JsonFormat 을 활용하여 LocalDateTime 등 날짜에 대한 JSON 직렬화하기와

또 날짜 포맷팅, Jackson 을 활용한 커스텀 어노테이션까지 적어보았다.

LocalDateTime 형식

{
  "name": "hello",
  "startAt": "2023-02-26T15:12:17.536Z",
  "endAt": "2023-02-26T15:12:17.536Z"
}

LocalDateTime 같은 경우에는

기본적으로 중간에 알파벳 등이 섞여있어

응답 시 같이 내보내게 된다.

{
    "name": "hello",
    "startAt": "2023.03.20 12:00",
    "endAt": "2023.03.20 13:30"
}

응답값에 포맷팅을 걸어서

이런 식으로 요청 및 응답하게 할 순 없을까?

@JsonFormat

Jackson 에서 제공하는 @JsonFormat 을 사용하면

Request 나 Response 필드의 날짜 형식을 JSON 으로 변환시킬 수 있다.

MyRequest

@Getter
@RequiredArgsConstructor
public class MyRequest {
    private String name;
    
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy.MM.dd HH:mm", timezone = "Asia/Seoul")
    private LocalDateTime startAt;
}

@JsonFormat 의 pattern 필드에 내가 원하는 날짜 형식을 입력하면 된다.

{
  "name": "HI",
  "startAt": "2023.03.20 12:00"
}

Request DTO 필드에 @JsonFormat 을 쓸 경우

내가 원하는 형식에 맞게 필드를 사용할 수 있다!

이런 식으로 하게 되면 Controller 에서 String 형식으로 가져오거나 해서

번거롭게 변환하지 않아도 되는 큰 장점이 있다

BasicResponse

@Getter
@Builder
public class BasicResponse {
    private String name;
    
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy.MM.dd HH:mm", timezone = "Asia/Seoul")
    private LocalDateTime startAt;
    
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy.MM.dd HH:mm", timezone = "Asia/Seoul")
    private LocalDateTime endAt;
}

Response DTO 도 마찬가지이다.

자동으로 해당 패턴에 맞는 형식으로 직렬화된다.

@DateTimeFormat

스프링에서 지원하는 어노테이션인 @DateTimeFormat 도 있지만,

기본적으로 Spring 의 기본 JSON 컨버터는 Jackson 이기 때문에 우선순위에서 밀린다.

하지만 @DateTimeFormat 을 사용해야 하는 곳이 있는데

JSON 직렬화를 하지 않는 Request Parameter 나 ModelAttribute 등에서는

이 어노테이션을 사용하면 된다.

JSON 은 @JsonFormat 을 사용하자!

커스텀 어노테이션 @DateFormat

프로젝트 내에서 날짜 형식을 통일하기 위해

모든 필드에 이와 같이 붙여줘야 하는데,

일단 코드 길이가 길며

파라미터가 3개라 오탈자 등의 가능성도 있었다.

때문에 이를 단순화하고 싶었다.

DateFormat

@JacksonAnnotationsInside
@Retention(RetentionPolicy.RUNTIME)
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy.MM.dd HH:mm", timezone = "Asia/Seoul")
public @interface DateFormat {}

커스텀 어노테이션인 @DateFormat 이다.

사용 목적은 @JsonFormat 을 전부 통일시키고

재사용성을 높이기 위해서이다.

중요한 점은 @JacksonAnnotationsInside 를 반드시 붙여줘야 하는데,

이 어노테이션이 Jackson 관련 어노테이션을 상속하여 사용하겠다는 의미이다.

이것을 붙이지 않는다면 인터페이스 자체에 어노테이션이 적용되어 원치 않는 결과가 발생한다.

이렇게 사용하게 되면 굉장히 단순해지고

가독성이 올라가게 된다!

다만 커스텀 어노테이션을 남발하거나 이름을 명확하게 짓지 않으면

팀원들이 혼동할 수 있고, 오히려 생산성이 저해되기 때문에

적절하게 잘 만들어 팀원들과 소통할 필요가 있겠다.

[Spring] 스프링 Custom Enum Deserializer 구현으로 JSON Enum null 로 파싱하기

gengminy — Tue, 21 Feb 2023 16:57:31 +0900

https://gengminy.tistory.com/48

[Spring] 스프링 Enum Validator Reflection 으로 개선 및 구현하기

https://gengminy.tistory.com/47 [Spring] 스프링에서 Enum 클래스 Validation 추가하기 (Enum JSON parse error 해결) 스프링에서 일반적으로 RequestBody 의 값을 Validation 하는 방법 스프링 MVC 에서 @Valid 어노테이션을

gengminy.tistory.com

앞서 스프링에서 Custom Enum Constraint Validator 를 Reflection 으로까지 구현했다.

하지만 딱 한 가지가 남았는데....

보기 싫었던 다음과 같은 반복적인 코드가 있다.

// Enum Validation 을 위한 코드, enum 에 속하지 않으면 null 리턴
@JsonCreator
public static EventStatus fromEventStatus(String val) {
    return Arrays.stream(values())
            .filter(type -> type.getName().equals(val))
            .findAny()
            .orElse(null);
}

Request 에서 제공한 Enum 필드에 대해 역직렬화 해주는 @JsonCreator

@JsonCreator 를 구현하지 않는다면

null 값을 대입하는 대신 JSON Parse Error 를 발생시킨다.

그래서 Enum Validation 을 위해선

Enum 에 속하지 않는 Constant 에 대해서 null 을 반환하도록 할 필요가 있다.

하지만 Enum 마다 반복적으로 구현해야 해서 이를 줄이고 싶었다.

여러 가지 방법을 시도하고 실패를 반복하며....

결국 구글링으로 방법을 찾았다!

원하고자 하는 목표

@Getter
@AllArgsConstructor
@EnumClass
public enum EventStatus {
    PREPARING("PREPARING", "준비중"),
    OPEN("OPEN", "진행중"),
    CALCULATING("CALCULATING", "정산중"),
    CLOSED("CLOSED", "지난공연"),
    DELETED("DELETED", "삭제된공연");

    private final String name;
    @JsonValue private final String value;
}

위 처럼 @EnumClass 라는 커스텀 어노테이션 하나로

@JsonCreator 에서 실행하는 로직을 축약하고 싶었다.

EnumClass

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonDeserialize(using = CustomEnumDeserializer.class)
public @interface EnumClass {}

커스텀 어노테이션 @EnumClass 를 정의한다.

@JsonDeserialize 라는 어노테이션을 통해 사용하고 싶은 Deserializer 를 지정할 수 있다.

이런 식으로 Jackson 관련 어노테이션을 상속시킬 때는

반드시 @JacksonAnnotationsInside 를 붙여야한다.

그렇지 않으면 이 어노테이션 자체에 Jackson 관련 코드가 적용되어서

원하지 않는 방향으로 실행이 된다.

CustomEnumDeserializer

public class CustomEnumDeserializer extends StdDeserializer<Enum<?>>
        implements ContextualDeserializer {

    public CustomEnumDeserializer() {
        this(null);
    }

    protected CustomEnumDeserializer(Class<?> vc) {
        super(vc);
    }

    @SuppressWarnings("unchecked")
    @Override
    public Enum<?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
        JsonNode jsonNode = jp.getCodec().readTree(jp);
        JsonNode nameNode = jsonNode.get("name");
        if (nameNode == null) return null;
        String text = jsonNode.asText();
        Class<? extends Enum> enumType = (Class<? extends Enum>) this._valueClass;
        return Arrays.stream(enumType.getEnumConstants())
                .filter(constant -> constant.name().equals(text))
                .findAny()
                .orElse(null);
    }

    @Override
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property)
            throws JsonMappingException {
        return new CustomEnumDeserializer(property.getType().getRawClass());
    }
}

모든 Enum 인스턴스에 대해 적용하기 위해 제네릭으로 Enum<?> 을 적용한다.

또 주목할만한 점은 ContextualDeserializer 를 implementation 하는 점인데

현재 Context 의 Target 클래스 타입을 통해 Deserializer 를 재정의할 필요가 있기 때문이다.

그렇지 않다면 현재 타입을 알 수 없어 this._valueClass 호출 시 NPE 가 발생한다.

Enum 타입이 고정되어 있다면 직접 Status.class 같이 생성자에 넣어주면 되지만,

현재 모든 추상 클래스 타입에 대해 적용해야하기 때문에 이 과정이 반드시 필요하다.

deserialize 구현부에서는 jsonNode 의 "name" 을 가져와

Enum Constant 의 name 으로 비교를 수행한다.

nameNode 로 굳이 한 번 더 나누어준 이유는

asText() 메소드가 null 에 대해 수행할 수 있는 가능성이 있기 때문

아주 깔끔해졌다

없는 Enum Constant 에 대해 정상적으로 null 을 반환하고 Validation 해준다.

이로써 Enum 관련 코드가 아주 깔끔해졌다!

레퍼런스

https://d2.naver.com/helloworld/0473330

위의 글이 많은 도움이 되었다.

구현 과정 관련 게시글

[Spring] 스프링 Enum Validator Reflection 으로 개선 및 구현하기

gengminy — Tue, 21 Feb 2023 14:05:51 +0900

https://gengminy.tistory.com/47

[Spring] 스프링에서 Enum 클래스 Validation 추가하기 (Enum JSON parse error 해결)

스프링에서 일반적으로 RequestBody 의 값을 Validation 하는 방법 스프링 MVC 에서 @Valid 어노테이션을 명시해주면 컨트롤러에서 해당 값에 대해 미리 Validation 해줘서 값이 들어오게 된다. JAVAX 에서 @Not

gengminy.tistory.com

앞서 작성한 스프링에서 Custom Enum Constraint Validator 구현하기

이 글에서 @Enum 이라는 커스텀 어노테이션을 만들었고

Request 필드에서 적용해보았다.

@Schema(defaultValue = "OPEN", description = "오픈 상태")
@Enum(target = EventStatus.class, message = "올바른 값을 입력해주세요.")
private EventStatus status;

하지만 이런식으로 작성하게 되면

매번 검증하고자 하는 Enum 클래스를 위처럼 명시해줘야 한다.

이게 보기 싫기 때문에 Reflection 을 통해 동적으로 Enum 클래스의 value 를 가져와 검증하려고 했다.

리플렉션(Reflection) : 실행 중인 프로그램의 클래스, 메서드, 필드 등의 정보를 동적으로 조사하고 사용하는 기능
클래스의 이름을 문자열로 받아와 그 클래스를 동적으로 로딩하거나, 인스턴스의 메소드나 필드를 호출하거나, 어떤 클래스가 어떤 인터페이스를 구현하고 있는지, 어떤 클래스가 어떤 클래스를 상속받았는지 등의 정보를 런타임에 조사할 수 있다.

원하고자 하는 목표

@Schema(defaultValue = "OPEN", description = "오픈 상태")
@Enum(message = "올바른 값을 입력해주세요.")
private EventStatus status;

위 처럼 @Enum 사용 시 조사할 Enum 클래스를 생략하고 싶다.

Enum

@Constraint(validatedBy = {EnumValidator.class})
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface Enum {
    String message() default "Invalid Enum Value.";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

target 필드를 제외하여 재정의한다.

EnumValidator

public class EnumValidator implements ConstraintValidator<Enum, java.lang.Enum> {
    @Override
    public boolean isValid(java.lang.Enum value, ConstraintValidatorContext context) {
        if (value == null) {
            return false; //null 값 허용 여부
        }

        Class<?> reflectionEnumClass = value.getDeclaringClass();
        return Arrays.asList(reflectionEnumClass.getEnumConstants()).contains(value);
    }
}

여러 가지 방법을 찾아보았는데 위의 방법이 가장 효과적인 것 같아서 채용했다

우선 해당 Enum 값이 null 일 경우를 검사한다.

여기서는 null 에 해당하는 값은 검증에 실패하도록 정책을 설정했다.

이후 이 Enum 값이 null 이 아님이 보장되었기 때문에

value.getDeclaringClass 를 통해 이 value 가 속한 Enum 클래스 정보를 가져온다.

이제 Enum Class 를 알아냈으니 이 Enum 에 속해있는 Constant 들을 가져와 비교하면 된다.

비교는 Collection 의 contains 메소드를 이용하여 축약시켰다.

이제 target 을 지정하지 않아도

동적으로 Enum Class 정보를 가져와 Validation 할 수 있게 되었다!

올바르게 검증해주는 모습

구현 과정 관련 게시글

Custom Enum Validator 구현하기

https://gengminy.tistory.com/47

Reflection 을 이용하여 Enum Validator 개선하기

https://gengminy.tistory.com/48

Custom Enum Deserializer 구현하여 Enum 에 없는 값 null 로 파싱하기

https://gengminy.tistory.com/49

[Spring] 스프링에서 Enum 클래스 Validation 구현하기 (Enum JSON parse error 해결)

gengminy — Tue, 21 Feb 2023 13:37:08 +0900

스프링에서 일반적으로 RequestBody 의 값을 Validation 하는 방법

스프링 MVC 에서 @Valid 어노테이션을 명시해주면

컨트롤러에서 해당 값에 대해 미리 Validation 해줘서 값이 들어오게 된다.

JAVAX 에서 @NotBlank, @NotNull, @Positive 등등

원시 타입에 대해서는 여러 가지 기본 검증을 지원한다.

하지만 Enum 클래스에 대한 Validation 은 기본으로 지원하지 않는다.

그러면 어떤 식으로 처리해야 할까?

Enum Validation 처리를 하지 않았을 경우

Enum 필드에 대해 Validation 처리하지 않는다면

Enum 클래스에 속하지 않은 값이 Request 필드에 포함되면

JSON 값을 Enum 으로 올바르게 파싱하지 못하여

위 처럼 JSON parse error 가 응답으로 오게 된다.

하지만 백엔드의 입장에서도 그렇고 500 에러와 더불어 이런 에러는 상당히 보기가 싫다

그러니까 이러한 예외 처리를 더불어

에러 메세지까지 보내주는게 정신건강에 좋을 거 같지 않은가?

Enum Validation 적용 과정

EventStatus

@Getter
@AllArgsConstructor
public enum EventStatus {
    // 준비중
    PREPARING("PREPARING", "준비중"),
    // 진행중
    OPEN("OPEN", "진행중"),
    // 정산중
    CALCULATING("CALCULATING", "정산중"),
    // 지난 공연
    CLOSED("CLOSED", "지난공연"),
    // 삭제된 공연
    DELETED("DELETED", "삭제된공연");

    private final String name;
    @JsonValue private final String value;

    // Enum Validation 을 위한 코드, enum 에 속하지 않으면 null 리턴
    @JsonCreator
    public static EventStatus fromEventStatus(String val) {
        return Arrays.stream(values())
                .filter(type -> type.getName().equals(val))
                .findAny()
                .orElse(null);
    }
}

Validation 을 사용하고 싶은 Enum Class 에

다음과 같이 @JsonCreator 어노테이션을 명시한 정적 메소드를 추가하자

@JsonCreator 는 페이로드에서 JSON -> Enum 필드로 파싱하는 방법을 직접 명시해주게 된다.

fromEventStatus 메소드에서는 Enum Class 에 속하지 않는 값이 들어올 때 null 을 리턴하게 되서

JSON parsing error 가 발생하지 않도록 해줬다.

이렇게만 해도 JSON parsing error 는 응답으로 오지 않지만

잘못된 Enum 값에 대한 예외 처리도 해주고 싶다.

Enum

@Constraint(validatedBy = {EnumValidator.class})
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface Enum {
    String message() default "Invalid Enum Value.";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
    
    Class<? extends java.lang.Enum<?>> target();
}

커스텀 어노테이션 인터페이스를 작성해준다

@Constraint 는 Validation 하려는 메소드가 정의된 클래스
@Target 은 이 어노테이션이 붙을 수 있는 범위
@Retention 은 이 어노테이션의 생명주기를 지정해준다

또한 Custom Constraint Annotation 을 지정할 때는 다음 3개를 꼭 정의해야 한다

message 는 예외 발생 시 응답 메세지 지정
group 은 Validation 그룹 지정
payload 는 추가 정보를 위해 지정할 수 있으며 주로 심각도를 나타내는 필드

마지막으로 target 은 이 Validator 가 적용해줄 범위를 지정한다

Class<? extends Enum> 은 java.lang.Enum 클래스를 상속받는 모든 인자라는 뜻을 제네릭으로 표현한 것이다

즉, 이 인자에는 Enum 클래스만 올 수 있다는 뜻이 된다

target 필드는 Request 에 무조건 Enum 타입만 넣는다고 가정하면 없어도 되지만,
다른 타입의 값을 Request 로 받아 Enum 으로 넣어주고 싶은 상황이 생길 수도 있으니
범용성을 위해 추가하였다.

EnumValidator

public class EnumValidator implements ConstraintValidator<Enum, java.lang.Enum> {
    private Enum annotation;

    @Override
    public void initialize(Enum constraintAnnotation) {
        this.annotation = constraintAnnotation;
    }

    @Override
    public boolean isValid(java.lang.Enum value, ConstraintValidatorContext context) {
        Object[] enumValues = this.annotation.target().getEnumConstants();
        if (enumValues != null) {
            for (Object enumValue : enumValues) {
                if (value.equals(enumValue.toString())) {
                    return true;
                }
            }
        }
        return false;
    }
}

EnumValidator 에서는 Enum 의 value 값들을 가져오기 위해 멤버 변수로 지정하고

initailize 메소드를 오버라이딩 하여 이 값을 할당한다.

이후 isValid 메소드를 오버라이딩 하여 검증 로직을 실행한다.

target 클래스에서 Enum 값들을 가져와 검증하려는 value 와 비교하게 된다.

무조건 Enum 값이 들어온다고 가정하고 작성하면 아래와 같이 줄일 수 있다.

public class EnumValidator implements ConstraintValidator<Enum, java.lang.Enum> {
    @Override
    public boolean isValid(java.lang.Enum value, ConstraintValidatorContext context) {
        return value != null;
    }
}

@JsonCreator 에서 해당 Enum 클래스에 없는 값이 들어오면

NULL 로 파싱해주기 때문에 이 로직을 적용할 수 있다

UpdateEventStatusRequest

@Getter
@RequiredArgsConstructor
public class UpdateEventStatusRequest {
    @Schema(defaultValue = "OPEN", description = "오픈 상태")
    @Enum(target = EventStatus.class, message = "올바른 값을 입력해주세요.")
    private EventStatus status;
}

이제 Request 에서 원하는 Enum 필드에 적용해보자.

target 에는 내가 검증하고자 하는 Enum 클래스를 지정하면 된다.

처음에는 이런 식으로 예외처리가 안되어서 에러 메세지가 그대로 노출이 될텐데

@RestControllerAdvice 에서 MethodArgumentNotValidException 핸들링을 해줘

적절하게 에러 메세지를 가공하면

이런 식으로 각 필드별로 메세지를 깔끔하게 정리할 수 있다

구현 과정 관련 게시글

Custom Enum Validator 구현하기

https://gengminy.tistory.com/47

Reflection 을 이용하여 Enum Validator 개선하기

https://gengminy.tistory.com/48

Custom Enum Deserializer 구현하여 Enum 에 없는 값 null 로 파싱하기

https://gengminy.tistory.com/49

[Spring] RefreshToken + Redis 사용해서 자동 로그인 + 로그아웃 구현하기

gengminy — Mon, 14 Nov 2022 20:41:51 +0900

현재 진행중인 프로젝트 내친소 캐릭터입니다 귀엽죠

모바일 어플리케이션 또는 일부 웹 앱을 사용하다 보면 보통 자동 로그인 체크 옵션이 있다.

또는 이런 옵션이 없어도 앱을 키면 이미 로그인 되어있는 경우가 많다.

카카오톡, 토스 등등

과연 어떻게 구현하는 것일까?

세션 방식과 토큰 방식에서 물론 차이가 있지만

내가 선호하는 방법인 토큰 방식으로 구현을 해보았다.

이 포스팅은 Spring Security, JWT, Redis 관련 세팅이

이미 되어있다고 가정하고 코드를 작성했습니다.

자동 로그인 인증 과정

1) 유저가 성공적으로 로그인 했을 경우 리프레시 토큰과 엑세스 토큰을 응답받는다.

2) 유저는 이를 보관하고 사용하다가, 엑세스 토큰이 만료되는 시점이 올 것이다.

3) 유저의 서버 API 요청시 401 응답을 받으면 reissue 요청을 시도해야 한다

4) 로그인 시 응답받았던 리프레시 토큰과 만료된 엑세스 토큰을 통해 재발급 요청을 서버에 보낸다.

5) 유효한 토큰일 경우 새로운 엑세스 토큰과 새로운 리프레시 토큰을 응답받는다.

구현

JwtTokenProvider

@Slf4j
@Component
@RequiredArgsConstructor
public class JwtTokenProvider {
	private static final long JWT_EXPIRATION_MS = 1000L * 60 * 40; //40분
	private static final long REFRESH_TOKEN_EXPIRATION_MS = 1000L * 60 * 60 * 24 * 7; //7일


	... 생략


    public String generateRefreshToken(JwtDTO jwtDTO) {
        final String encodedKey = Base64.getEncoder().encodeToString(JWT_SECRET.getBytes());
        final Date now = new Date();
        final Date refreshTokenExpiresIn = new Date(now.getTime() + REFRESH_TOKEN_EXPIRATION_MS);

        final String refreshToken = Jwts.builder()
                .setHeaderParam(Header.TYPE, Header.JWT_TYPE)
                .setIssuer("naechinso")
                .setExpiration(refreshTokenExpiresIn)
                .signWith(SignatureAlgorithm.HS512, encodedKey)
                .compact();

        //redis에 해당 phone number 의 리프레시 토큰 등록
        redisService.setValues(
                jwtDTO.getPhoneNumber(),
                refreshToken,
                Duration.ofMillis(REFRESH_TOKEN_EXPIRATION_MS)
        );

        return refreshToken;
    }
}

우선 TokenProvider에서 레지스터 토큰을 만드는 로직이다.

엑세스 토큰의(JWT) 만료 시간은 40분,

리프레시 토큰의 만료 시간은 7일로 잡아놨다.

만약 유저가 서비스를 사용 중인데,

그 순간 엑세스 토큰이 만료되면

더 이상 서비스를 이용하지 못하고 강제 로그아웃 될 것이다.

그렇기 때문에 더욱 토큰 자동 재발급 + 자동 로그인 기능이 필요했다

리프레시 토큰은 이럴 때 필요하다.

리프레시 토큰은 브라우저의 쿠키나 LocalStorage 에 저장하기도 하고

유저 DB에 저장하기도 하고 여러 가지 방법이 있다.

나는 유저가 로그인하여 토큰을 발급 받을 때

리프레시 토큰도 같이 Redis 에 저장하는 방법을 사용했다.

이후 유저의 ID를 통해 해당 리프레시 토큰에 접근할 수 있다.

MemberController

@Slf4j
@RestController
@RequestMapping("/member")
@RequiredArgsConstructor
public class MemberController {    
    private final MemberService memberService;
    private final JwtTokenProvider jwtTokenService;

    @PostMapping("/reissue")
    @ApiOperation(value = "리프레시 토큰을 통해 새로운 토큰을 발급받는다 (RefreshToken)")
    public CommonApiResponse<MemberReissueResponseDTO> reissue(
            @RequestHeader("Authorization") String accessToken,
            @RequestHeader("Refresh") String refreshToken
    ) {
        return CommonApiResponse.of(memberService.reissue(accessToken, refreshToken));
    }
    
    ... 생략
}

컨트롤러에는 reissue 라는 API를 생성했다.

유저가 현재 유효한 로그인 상태를 가지고 있을 경우

accessToken 과 refreshToken 을 모두 가지고 있을 것이다.

임의의 "Refresh" 라는 헤더를 통해 리프레시 토큰 값을 가져오도록 프론트와 말했다.

또 "Authorization" 헤더에는 원래의 엑세스 토큰 값이 들어있을 것이다.

MemberService

@Service
@RequiredArgsConstructor
@Transactional
public class MemberService {
    private final JwtTokenProvider jwtTokenProvider;
    private final MemberRepository memberRepository;
    
    
    (...생략)
    
    
    public MemberReissueResponseDTO reissue(String accessToken, String refreshToken) {
        String phone;

        if (!jwtTokenProvider.validateTokenExceptExpiration(accessToken)){
            throw new BadRequestException(ErrorCode.INVALID_ACCESS_TOKEN);
        }

        try {
            phone = jwtTokenProvider.parseClaims(accessToken).getSubject();
        } catch (Exception e) {
            throw new BadRequestException(ErrorCode.INVALID_REFRESH_TOKEN);
        }

        Member authMember = findByPhone(phone);

   		(...생략)


        jwtTokenProvider.validateRefreshToken(phone, refreshToken);

        TokenResponseDTO tokenResponseDTO = jwtTokenProvider.generateToken(new JwtDTO(phone, authMember.getRole().toString()));

        return MemberReissueResponseDTO.builder()
                .accessToken(tokenResponseDTO.getAccessToken())
                .refreshToken(tokenResponseDTO.getRefreshToken())
                (...생략)
                .build();
    }
}

비즈니스 로직 처리 부분이다.

처음에 jwtTokenProvider 에서 다시 토큰 검증이 발생하는데

토큰의 유효성 중 만료 시간만 검증하는 validateTokenExceptExpiration 메소드를 만들었다.

//jwtTokenProvider
...
	/**
     * 토큰 예외 중 만료 상황만 검증 함수
     * @param token 검사하려는 JWT 토큰
     * @returns boolean
     * */
    public boolean validateTokenExceptExpiration(String token) {
        final String encodedKey = Base64.getEncoder().encodeToString(JWT_SECRET.getBytes());
        try {
            Jwts.parser().setSigningKey(encodedKey).parseClaimsJws(token);
            return true;
        } catch(ExpiredJwtException e) {
            return true;
        } catch (Exception e) {
            return false;
        }
    }
   
...

이 부분인데,

토큰이 정상이거나 토큰 만료 시 던져주는 ExpiredJwtException 만 catch 해서 true 로 처리해준다.

이렇게 하면 비 정상적인 토큰을 걸러낼 수 있다.

이후 parseClaims 를 호출하면 엑세스 토큰으로 부터

유저의 ID (이 프로젝트에서는 phone) 를 뽑아낼 수 있다.

 //JwtTokenProvider
 ...
 	/** Redis Memory 의 RefreshToken 과
     * User 의 RefreshToken 이 일치하는지 확인
     * @param phone 검증하려는 유저 휴대전화
     * @param refreshToken 검증하려는 리프레시 토큰
     */
    public void validateRefreshToken(String phone, String refreshToken) {
        String redisRefreshToken = redisService.getValues(phone);
        if (!refreshToken.equals(redisRefreshToken)) {
            throw new BadRequestException(ErrorCode.EXPIRED_REFRESH_TOKEN);
        }
    }
...

이번에는 리프레시 토큰 검증이다.

리프레시 토큰을 생성할 때 <Key, Value> 값으로

<Phone, RefreshToken> 쌍을 Redis 에 삽입했다.

추출할 때는 phone 을 참조하여 RefreshToken 값을 가져올 수 있다.

유저가 요청한 리프레시 토큰과 Redis 의 값을 비교해서 일치하면 검증 성공

검증이 완료되었을 경우 토큰을 재생성해서 응답한다.

MemberReissueResponseDTO

/**
 * 토큰 재발급을 담당하는 응답 DTO
 * */
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Builder
@ToString
@JsonInclude(JsonInclude.Include.NON_NULL) //NULL 필드 가림
public class MemberReissueResponseDTO {
    private String accessToken;
    private String refreshToken;
    
    (생략)
}

응답 DTO는 별 거 없이 accessToken 과 refreshToken 필드만 가진다.

@RequestHeader 사용했기 때문에 스웨거에서 테스트도 가능하다.

로그아웃은?

자동 로그인까지 만든 건 좋다.

그렇다면 로그아웃은 어떻게 해야 할까?

유저가 분명 로그아웃 요청을 했는데

앱을 다시 키니 로그인이 되어있는 불상사가 있으면 안된다.

//MemberService
	(...생략)
    
    /**
     * 로그아웃 -> Register Token 삭제
     * */
    public MemberLoginResponseDTO logout(Member authMember) {
        Member member = findByMember(authMember);

        //redis 에서 registerToken 삭제
        jwtTokenProvider.deleteRegisterToken(member.getPhone());
        
        return new MemberLoginResponseDTO("");
    }

로그아웃은 딱히 별 거 없다.

자동 로그인 시 유저의 리프레시 토큰을

Redis 에 저장되어 있는 리프레시 토큰과 비교한다고 했다.

그러면 Redis 에 저장된 리프레시 토큰을 없애주면 될 것이다.

이러면 토큰 재발급 요청을 보내더라도 성공하지 못할 것이다.

//JwtTokenProvider

	(...생략)

    /** Redis 에서 RegistrerToken 을 제거
     * @param phone 로그아웃 요청 유저
     * @return true if redis 서버에 토큰이 있었을 경우
     * false if 토큰이 없었을 경우
     */
    public boolean deleteRegisterToken(String phone) {
        try {
            if (redisService.hasKey(phone)) {
                redisService.deleteValues(phone);
                return true;
            }
        } catch (Exception e) {
            log.error("Redis 로그아웃 요청을 실패했습니다");
        }
        return false;
    }

Redis 에서 유저 키 값을 참고해 삭제한다.

[Spring] 스프링 스케쥴러 사용해서 일정 주기로 메소드 실행하기 (Scheduler)

gengminy — Sat, 5 Nov 2022 21:30:43 +0900

프로젝트 개발 중

엔티티를 생성한지 3일 이후에

자동으로 해당 엔티티 필드를 갱신해 만료 상태로 만드는 로직이 필요했다

PostgreSQL 에서는 내장 스케쥴러가 없다는 말도 있고

스케쥴러 사용하는 법이 까다로워서

로깅도 같이 하기 위해 그냥 스프링 내장 스케쥴러를 사용하기로 했다

⚙️ Dependency

@Scheduler 는 Spring Boot Starter 에서 기본으로 제공하는 어노테이션이다

전역 설정

MyApplication

@EnableScheduling //scheduler 사용
@EnableJpaAuditing //jpa entity 자동 감시
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

내 Application 의 main 메소드가 들어있는 클래스에

@EnableScheduling 어노테이션을 추가해준다

사용법

스케쥴링을 원하는 메소드에 @Scheduled 어노테이션을 추가한다

단, 스케쥴링이 가능한 메소드는 다음과 같은 조건이 있다

반환형이 void 이어야함
매개변수가 없는 메소드

fixedDelay

해당 메소드가 끝나는 시점을 기준으로 ms 단위로 실행

@Scheduled(fixedDelay = 1000)
protected void scheduleTask() {
	...
}

-> 1초마다 실행하는 스케쥴링 메소드

fixedRate

해당 메소드가 시작하는 시점을 기준으로 ms 단위로 실행

병렬로 실행을 원한다면 @Async 어노테이션 가능

@Async
@Scheduled(fixedRate = 1000)
protected void scheduleTask() {
	...
}

cron

작업을 예약하여 실행

이번 프로젝트에서 사용할 정책이다

cron 표현식은 다음 사이트에서 도움을 받을 수 있다

단 스프링 스케쥴러에서는 6자리 표기식을 사용하기 때문에

7번째 글자를 지우고 맞는지 확인해보아야 함

http://www.cronmaker.com/?0

CronMaker

www.cronmaker.com

이런식로 원하는 정보를 기입하면 Cron 표현식을 만들어준다

내가 적은 Cron 표현식에 따른 다음 스케쥴링도 알려주기 때문에

원하는대로 다음 스케쥴이 동작하는지도 알 수 있다

@Scheduled(cron = "0 0 0 * * ?") //daily at 00:00
protected void scheduleTask() {
    ...
}

-> 위 식은 매일 00시 자정마다 아래 메소드를 실행하는 어노테이션이다

구현

결국 내가 원하는 것은

매일 00시 자정마다 생성한지 3일이 지난 카드를 가져와서

자동으로 만료시키는 것이다

여기에 로그를 출력하도록 하여

몇 개의 엔티티가 영향을 받았는지도 표시했다

/**
 * 매일 00시00분 마다 기간이 지난 카드 자동 만료
 */
@Scheduled(cron = "0 0 0 * * ?") //daily at 00:00
protected void scheduleTask() {
    //현재 시간으로 부터 3일 전의 00시 00분 이전 시각
    LocalDateTime compareDateTime = LocalDateTime.of(LocalDate.now().minusDays(EXPIRY_DATE_DAY), LocalTime.of(0,0,0));
    //그 이전의 카드는 만료되었으므로 모두 가져옴
    List<Match> matchList = matchRepository.findAllByIsExpiredFalseAndCreatedAtBefore(compareDateTime);
    //만료
    matchList.forEach(Match::expire);
    log.info("Scheduling System Automatically Expire Matches :: Affected Matches Count - {}", matchList.size());
    matchRepository.saveAll(matchList);
}

생성 시간의 비교는 JpaRepository 의 표기 방법 중 CreatedAtBefore 을 통해 비교했다

만료는 boolean 형의 isExpired 필드를 가져와서 비교했다

만약 만료된 리스트를 가져왔을 경우

expire 메소드를 통해 isExpired 를 true 로 변경했다

다른 비즈니스 로직에서는 isExpired 값을 비교하여 수행하도록 바꿨다

[Spring/Nginx] MultipartFile 최대 용량 설정하기 (MaxUploadSizeExceededException / Request Entity Too Large)

gengminy — Tue, 1 Nov 2022 13:28:35 +0900

❌ 에러 상황

org.springframework.web.multipart.MaxUploadSizeExceededException:
Maximum upload size exceeded;
nested exception is java.lang.IllegalStateException:
org.apache.tomcat.util.http.fileupload.impl.FileSizeLimitExceededException:
The field multipartFiles exceeds its maximum permitted size of 1048576 bytes.

AWS S3 파일 업로드 중 발생한 문제

MaxUploadSizeExceededException

AWS S3 와 연동해서 파일을 업로드 할 때

http 413 이 뜨면서 허용된 파일 용량을 초과했다고 하는 에러이다

스프링의 내장 톰캣 서버에서 초기 설정 값은

1048576 bytes => 1MB 이다

Trouble Shooting 1

Spring Boot 설정 파일에서 최대 허용 용량을 설정해주면 된다

application.yml

spring:
  servlet:
    multipart:
      #file upload size
      max-file-size: 3MB

spring.servlet.multipart.max-file-size: {원하는 크기} 로 설정해준다

우리 서버에서는 3MB 를 최대 크기로 하도록 설정했다

GlobalExceptionHandler.java

    /**
     * 업로드 최대 용량을 초과했을 경우
     */
    @ExceptionHandler({MaxUploadSizeExceededException.class})
    protected ResponseEntity<ErrorResponse> handleMultipartException(MaxUploadSizeExceededException e) {
        log.error("handleMaxUploadSizeExceededException", e);
        final ErrorResponse response = ErrorResponse.of(ErrorCode.MAX_FILE_SIZE_EXCEEDED);
        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
    }

보너스로 글로벌 에러 핸들러에서

관련 예외를 처리해주는 코드도 작성했다

이제 413 에러가 아닌 400 에러로 처리된다

❌ 또 다른 에러

이번에는 json 예외 메세지가 아니라 html 응답이 뜨면서

여전히 http 413 에러가 발생한다

이는 우리 서버에서 사용하고 있는 Nginx 에서

또한 최대 body size 를 제한하고 있기 때문이다

그렇기 때문에 Nginx 설정 파일도 바꿔줘야 한다

Trouble Shooting 2

nginx.conf

http {
  include       /etc/nginx/mime.types;
  default_type  application/octet-stream;

  client_max_body_size  4M;
  ...

Nginx 설정 파일에서

client_max_body_size {원하는 크기};

설정해주면 된다

spring 내장 tomcat 에서 3MB 를 최대로 하기로 했으니까

Nginx 에서는 넉넉하게 4MB 로 설정해주었다

역시 Nginx 에서도 초기 값은 1MB 이다

너무 큰 값을 주면 공격 위험이 있을 거 같아서

용량을 많이는 안주었다

이제 응답이 잘 된다

로컬이랑 AWS 개발 서버에서 모두 동작하는 것을 확인했따

[Spring] JPA + Lombok 사용할 때 @OneToOne 에서 발생하는 StackOverflowError 해결

gengminy — Sat, 24 Sep 2022 17:56:09 +0900

JPA 와 Lombok 을 같이 사용중이라면 발생할 수 있는 에러

❌ 원인

@OneToOne 또는 @OneToMany 를 통해 연관관계를 정의했고

이후 데이터를 꺼내올 때 hashCode 또는 toString 을 호출하면서

무한 순환 참조에 의해 스택 오버플로우가 발생하는 에러이다

java.lang.StackOverflowError: null
	at com.tikitaka.naechinso.domain.member.entity.Member.toString(Member.java:21) ~[main/:na]
	at java.base/java.lang.StringConcatHelper.stringOf(StringConcatHelper.java:453) ~[na:na]
	at com.tikitaka.naechinso.domain.member.entity.MemberDetail.toString(MemberDetail.java:18) ~[main/:na]
	at java.base/java.lang.StringConcatHelper.stringOf(StringConcatHelper.java:453) ~[na:na]
	at com.tikitaka.naechinso.domain.member.entity.Member.toString(Member.java:21) ~[main/:na]
	at java.base/java.lang.StringConcatHelper.stringOf(StringConcatHelper.java:453) ~[na:na]
    ...

또는

Caused by: java.lang.StackOverflowError: null
	at com.tikitaka.naechinso.domain.member.entity.Member.hashCode(Member.java:22) ~[main/:na]
	at com.tikitaka.naechinso.domain.member.entity.MemberDetail.hashCode(MemberDetail.java:19) ~[main/:na]
	at com.tikitaka.naechinso.domain.member.entity.Member.hashCode(Member.java:22) ~[main/:na]
	at com.tikitaka.naechinso.domain.member.entity.MemberDetail.hashCode(MemberDetail.java:19) ~[main/:na]
	at com.tikitaka.naechinso.domain.member.entity.Member.hashCode(Member.java:22) ~[main/:na]

Lombok 어노테이션

@EqualsAndHashCode 는 equals 와 hashCode 를 자동 생성해준다

eqauls : 두 객체의 내용이 같은지 비교 (동일성)
hashCode : 두 객체가 같은 객체인지 존재를 비교 (동등성)

@ToString 은 toString 을 자동 생성하여 멤버 데이터를 문자열로 만들어준다

@Data는

@Getter @Setter @RequiredArgsConstructor @ToString @EqualsAndHashCode

를 한번에 정의해준다

엔티티 정의

Member.java

@Entity
@Table(name = "member")
@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ToString
@EqualsAndHashCode
public class Member extends BaseEntity {

    @Id
    @Column(name = "mem_id")
    @GeneratedValue
    private Long id;

    @OneToOne(mappedBy = "member")
    @JoinColumn(name = "mem_detail")
    private MemberDetail detail;
    
}

MemberDetail.java

@Entity
@Table(name = "member_detail")
@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ToString
@EqualsAndHashCode
public class MemberDetail extends BaseEntity {

    @Id
    @Column(name = "mem_id")
    private Long id;

    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @MapsId
    @JoinColumn(name = "mem_id")
    private Member member;
    
}

Member 와 멤버의 디테일을 저장하는 MemberDetail 을

1대1 연관관계를 맺었다

MemberRepository.findAll 을 통해 Member 정보를 가져올 때

hashCode 를 무한으로 호출하면서 순환 참조에 빠졌다

해결 방안

MemberDetail.java

@Entity
@Table(name = "member_detail")
@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ToString(exclude = {"member"})
@EqualsAndHashCode(exclude = {"member"})
public class MemberDetail extends BaseEntity {

    @Id
    @Column(name = "mem_id")
    private Long id;

    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @MapsId
    @JoinColumn(name = "mem_id")
    private Member member;
    
}

자식 엔티티에다가

@ToString 과 @EqualsAndHashCode 의 옵션 중에 exclude를 추가해주면 된다

exclude = { "원하는 필드명" } 을 추가하고

원하는 필드명에 연관관계를 맺은 엔티티를 적어준다

이렇게 되면 ToString 과 EqualsAndHashCode 를 생성할 때

해당 필드를 제외시키게 되고 무한 순환 참조에 빠지지 않게 된다

해결 완료!!

[AWS] Elastic Beanstalk + Github Actions 사용해서 Spring boot CI/CD 파이프라인 구축하기

gengminy — Wed, 21 Sep 2022 23:34:01 +0900

동아리 스터디의 일환으로 시작된

Beanstalk 으로 CI/CD 파이프라인 구축하기

처음 써보는거라 확실히 어렵지만

EC2 생성하고 RDS 생성하고 https 설정해주고... 하던 시절과 비교하면

확실히 배포 속도가 엄청 빠르긴 하다

물론 그 과정에서 삽질을 엄청나게 하긴 했지만...

하지만 결론적으로는 빌드 시간이 많이 오래 걸리기도 하고

배포서버와 개발서버 그리고 혹시 모르지만 웹까지

하나의 EC2 환경에서 배포하고 싶어서

JAR 환경에서 Docker 환경으로 이동할 것이다

JAR 이나 WAR 로 배포하는 것은 물론 좋지만

여러 EC2 인스턴스를 사용하기엔 돈이 모자란 ^^.... 가난한 대학생에겐

하나의 EC2에서 멀티 컨테이너로 돌리는게 더 나을 것이라는 판단이다

그래도 공부한게 아까우니까 까먹기 전에 과정을 올려본다

Elastic Beanstalk 환경 생성

Elastic Beanstalk 은 EC2 를 한번 더 추상화 한 개념이다

하나의 환경 내에 여러 EC2 인스턴스를 두고 Auto Scaling 으로 관리도 할 수 있다

S3나 RDS, ELB 등 여러 요소를 하나의 환경에서 관리할 수 있다

환경 -> 새 환경 생성 -> 웹 서버 환경 선택하고 다음으로

어플리케이션 이름 지어주면

환경 이름은 첫 문자를 대문자로 바꾼 것에 -env 가 붙어서 자동으로 만들어진다

물론 바꿀 수도 있다

아래 도메인은 기본 도메인이 생성되는데

나중에 구매해서 연결할 도메인이랑 별개이니까 놔둬도 상관 없다

관리형 플랫폼 -> Java -> 자바 버전 선택 -> 플랫폼 버전 선택

환경에서 사용할 플랫폼을 지정해준다

JAR 파일을 그대로 사용하려면 Java 플랫폼을 선택해주면 된다

Docker, Go, Node.js, Python 등등 웹서버로 많이 활용하는 플랫폼도 당연히 있다

Java 는 8, 11, 17이 지원되는데

보통 8이나 11버전을 많이 사용하더라

나는 간지나게 새삥 17을 선택했다

그 다음 중요한 추가 옵션 구성으로 들어가준다

새 인스턴스를 생성하고 삭제하는 것을 통해 CI 환경을 만들기 때문에

단일 인스턴스 대신 사용자 지정 구성을 선택

그리고 EC2 프리티어 기준이

한달 EC2의 총합 사용 시간이 750시간을 안넘기면 되기 때문에

여러 EC2 인스턴스가 존재하는 것은 사실 상관이 없다

어차피 배포가 끝나면 바로 삭제되기 때문

그리고 EC2 보안 그룹을 설정해야 하는데

환경 구성 메뉴에서는 설정을 할 수가 없다

그러니까 EC2 서비스 -> 보안 그룹으로 가서 설정해야한다

새 탭 열어서 HTTP, HTTPS 포트 여는 등 설정을 끝내고 다시 오자

용량 설정에서는 Auto Scaling 을 중요하게 보면 된다

왜냐면 돈과 직결되는 부분이기 때문

최소 최대 인스턴스를 모두 1로 설정해주면

Auto Scaling 이 동작하지 않아서

새 EC2 인스턴스가 생기지 않기 때문에 과금 우려가 없어진다

인스턴스 유형에서 t2.small 기본 선택이 되어있을텐데

프리티어인 t2.micro 만 빼고 없애버린다

우리는 가난한 대학생이니까...

HTTPS 설정이 필요하다면 리스너 -> 리스너 추가에서

HTTPS 와 SSL 인증서를 달아주면 된다

인증서가 없다면 Route 53 서비스를 이용하는 조건으로

무료 인증서를 발급받을 수 있다

(무료라면서 Route 53 에 도메인 하나 연결 당 매달 500원 정도 나온다)

다음으로 중요한 롤링 업데이트와 배포 설정

배포 방식을 추가 배치를 사용한 롤링으로 바꿔준다

배포할 때마다 새 EC2 인스턴스를 생성한 후 배포 작업을 진행하며

배포 작업이 끝나면 로드밸런서가 새 EC2 인스턴스를 가리키게 하여

CI 환경을 구성하는 것이다

이후 구 버전 EC2 인스턴스를 삭제하여 배포 작업을 끝낸다

그 다음 중요한 보안 수정

서비스 역할과 IAM 인스턴스 프로파일은 IAM 서비스에서 정의하고

EC2 키 페어는 EC2 서비스로 들어가서 만들어야 한다

이미 있다면 선택 후 저장

없다면 IAM 서비스로 진입

IAM -> 엑세스 관리 -> 역할 -> 역할 만들기 메뉴로 진입해서

위와 같은 권한을 주었다

AdministratorAccess 만 추가했을 때는

권한이 없다면서 안되어서 몇 개 더 넣었더니 되더라

그 다음은 사용자 추가

엑세스 키를 선택하고 이름 지정

나는 이 2가지의 권한을 주었다

다 만들면 이렇게 엑세스 키 ID 와 비밀 엑세스 키가 제공되는데

이 다음에는 더 이상 값을 보여주지 않기 때문에 이를 메모해두자

Github Actions 정의할 때 필요하다

여기까지 하고 환경 생성

문제가 없다면 이런식으로 상태에 파란 불이 들어와야 한다

보통 처음에 안되는건 업로드한 서버 파일 문제 또는 권한 문제

Beanstalk 배포 세팅

Beanstalk 배포 설정을 위해서 내 프로젝트에 파일을 추가해야 한다

.ebextensions/00-makeFile.config

files:
    "/sbin/appstart" :
        mode: "000755"
        owner: webapp
        group: webapp
        content: |
            #!/usr/bin/env bash
            JAR_PATH=/var/app/current/application.jar

            # run app
            killall java
            java -Dfile.encoding=UTF-8 -Dspring.profiles.active=$SPRING_PROFILE -jar $JAR_PATH

Beanstalk 내부에서 배포 작업 중 실행할 명령어를 정의했다

현재 실행중인 자바를 종료하고 배포시키는 명령어이다

SPRING_PROFILE 이라는 환경 변수는 Beanstalk 의 소프트웨이 -> 환경 속성에 정의했다

./Procfile

web: appstart

아까 .ebextensions 에서 정의한 명령어를 배포 작업이 종료되면 즉시 실행한다

.platform/nginx/nginx.conf

user                    nginx;
error_log               /var/log/nginx/error.log warn;
pid                     /var/run/nginx.pid;
worker_processes        auto;
worker_rlimit_nofile    33282;

events {
    use epoll;
    worker_connections  1024;
    multi_accept on;
}

http {
  include       /etc/nginx/mime.types;
  default_type  application/octet-stream;

  log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';

  include       conf.d/*.conf;

  map $http_upgrade $connection_upgrade {
      default     "upgrade";
  }

  upstream springboot {
    server localhost:8080;
    keepalive 1024;
  }

  server {
      listen        80 default_server;
      listen        [::]:80 default_server;

      location / {
          proxy_pass          http://springboot;
          proxy_http_version  1.1;
          proxy_set_header    Connection          $connection_upgrade;
          proxy_set_header    Upgrade             $http_upgrade;

          proxy_set_header    Host                $host;
          proxy_set_header    X-Real-IP           $remote_addr;
          proxy_set_header    X-Forwarded-For     $proxy_add_x_forwarded_for;
      }

      access_log    /var/log/nginx/access.log main;

      client_header_timeout 60;
      client_body_timeout   60;
      keepalive_timeout     60;
      gzip                  off;
      gzip_comp_level       4;

      # Include the Elastic Beanstalk generated locations
      include conf.d/elasticbeanstalk/healthd.conf;
  }
}

Nginx 설정 정의 파일

Elastic Beanstalk은 기본적으로 Nginx 를 통해 호스팅 해주는데

Nginx 의 특장점중 하나인 리버스 프록시를 통해

80번 포트 -> 8080 포트로 전달해주는 설정이다

Beanstalk 에 내장된 Nginx 는

기본 설정으로 localhost:5000 포트로 전달해주기 때문에

재정의를 통해 8080 포트로 전달해주도록 하는 것이다

Github Actions 정의

.github/workflows/deploy.yml

name: beanstalk-springboot-deploy

on:
  push:
    branches:
      - main
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v3

      #JDK Setting
      - name: Set up JDK 11
        uses: actions/setup-java@v3
        with:
          java-version: '11'
          distribution: 'temurin'

      #Create dotenv file
      - name: Make env properties
        run: |
          touch ./src/main/resources/application-dev.yml
          touch ./src/main/resources/application-prod.yml
          echo "$ENV_PROPERTIES_DEV" > ./src/main/resources/application-dev.yml
          echo "$ENV_PROPERTIES_PROD" > ./src/main/resources/application-prod.yml
        env:
          ENV_PROPERTIES_DEV: ${{ secrets.ENV_PROPERTIES_DEV }}
          ENV_PROPERTIES_PROD: ${{ secrets.ENV_PROPERTIES_PROD }}

      #Grant gradlew Permission
      - name: Grant execute permission for gradlew
        run: chmod +x ./gradlew
        shell: bash

      - name: Build with Gradle
        run: ./gradlew clean build
        shell: bash

      - name: Get current time
        uses: 1466587594/get-current-time@v2
        id: current-time
        with:
          format: YYYY-MM-DDTHH-mm-ss
          utcOffset: "+09:00"

      - name: Show Current Time
        run: echo "CurrentTime=$"
        shell: bash

      - name: Generate deployment package
        run: |
          mkdir -p deploy
          cp build/libs/*.jar deploy/application.jar
          cp Procfile deploy/Procfile
          cp -r .ebextensions deploy/.ebextensions
          cp -r .platform deploy/.platform
          cd deploy && zip -r deploy.zip .

      - name: Beanstalk Deploy
        uses: einaregilsson/beanstalk-deploy@v20
        with:
          aws_access_key: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws_secret_key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          application_name: naechinso
          environment_name: Naechinso-env-1
          version_label: github-action-${{ steps.current-time.outputs.formattedTime }}
          region: ap-northeast-2
          deployment_package: deploy/deploy.zip

github actions 는 반드시 루트 폴더의 .github/workflows 내부에 정의해야 한다

나는 민감한 변수들을 application.yml 을 나누어 관리하기 때문에

빌드 과정에서 가상 환경에 생성하는 방식으로 만들었다

마지막 application_name 과 environment_name 은

아까 beanstalk 에서 구성한 어플리케이션 이름과 환경 이름을 넣어주면 된다

secrets 변수들은 내 레포지토리 -> setting -> secrets -> actions 에서 관리한다

여기에 아까 만든 IAM 프로파일 값을 넣어주고 사용한다

설정에 따라 main 브랜치에 푸시를 하면 액션 실행

배포가 진행된다

✨ Log 보는 법

Elastic Beanstalk 이 이렇게 설정하는 것이 간단하지만

답답한 것중 하나가 로그를 직접 보지 못한다는 것...

로그는 환경 -> 로그에서 로그 요청을 한 후에 다운받아서 볼 수 있다

다만 이것도 배포 과정 중에 실시간으로 볼 수 없고

기다렸다가 아니면 중지해야지만 볼 수 있다

이래서 나는 너무 추상화 된 것을 안좋아한다...

이제 Docker 로 새 환경 구성하러 가야겠다

[Spring] 문자 인증 구현하기 (Redis + 네이버 클라우드 플랫폼 SMS API)

gengminy — Sun, 11 Sep 2022 14:15:57 +0900

지금 하는 중인 프로젝트가 원래는 아이디 + 비밀번호 기반 로그인이여서

메일 기반 인증과 OAuth 를 준비중이었는데

다시 문자 인증 기반 로그인으로 기획이 변경되었다

문자 인증 같은 경우는 예전 프로젝트에서

네이버 SMS API를 통해 구현해 본 적이 있어서 그다지 어렵지는 않지만

마침 만드는 김에 복습하는 차원으로 구현하고 나서 글을 적어보기로 했다

⚙️ Dependency

//webflux
implementation 'org.springframework.boot:spring-boot-starter-webflux'
//redis
implementation 'org.springframework.boot:spring-boot-starter-data-redis'

서버 상에서 http 요청을 보내고 응답받기 위한 WebClient를 사용하기 위해 webflux를 추가,

휴대폰 번호와 인증번호를 만료기간을 두고 관리하기 위한 인메모리 DB인 Redis 를 추가해준다

네이버 클라우드 플랫폼 SMS API 가입

https://www.ncloud.com/

NAVER CLOUD PLATFORM

cloud computing services for corporations, IaaS, PaaS, SaaS, with Global region and Security Technology Certification

www.ncloud.com

가입 절차를 진행하고 본인 인증 후 콘솔로 진입하면 된다

먼저 우리가 사용할 서비스는 SMS API 서비스이고

이름은 SENS(Simple & Easy Notification Service) 이다

문자 메세지 전송 및 푸시 알림을 보낼 수 있다

https://www.ncloud.com/product/applicationService/sens

NAVER CLOUD PLATFORM

cloud computing services for corporations, IaaS, PaaS, SaaS, with Global region and Security Technology Certification

www.ncloud.com

문자 인증에는 당연히 80자 이하의 SMS 를 사용할 것이고

50건 이하까지는 무료이다

테스트로 몇 번씩 보내보면서 진행하기에 딱이다

그리고 신규 가입 후 결제 수단 등록하면 크레딧도 주고

몇몇 제휴된 대학에서는 크레딧을 뿌리기도 하니 확인해볼 것

우리 학교는 없다 하...

콘솔 진입후

대시보드 -> 서비스 -> 검색어로 Simple & Easy Notification Service 진입

프로젝트 생성하기

옆에 OPEN API 가이드는 이따가 봐야하는데

문자 메세지를 어떻게 전송하고 응답 받는지 전부 다 적혀있다

개발자는 공식 Docs 도 잘 봐야한다

문자 인증이니 당연히 SMS 체크 후 이름과 설명 대충 만들어주기

이후 왼쪽 대시보드에서 Projects 선택 후에

방금 만든 프로젝트 행에서 오른쪽 서비스 ID의 열쇠모양 클릭

ncp: 로 시작하는 API Service ID Key 가 나오는데

꼭 써먹어야 하니 이를 기억해두자

이번엔 Simple & Easy Notification Service -> Solutions -> SMS -> Calling Number 들어와서 발신번호 등록해주기

개인 회원은 개인 명의의 휴대폰밖에 등록 못하니 주의

다른 번호 등록하거나 사업자 같은 경우 따로 서류를 준비해서 여차저차 하면 된다고 설명되어 있다

이번엔 다시 콘솔에서 나와서

네이버 클라우드 플랫폼 -> 마이페이지 -> 계정 관리 -> 인증키 관리로 들어옴

이번엔 API 인증키 관리에서

Access Key 와 Secret Key 를 잘 기억해두자

이제 대충 준비는 끝났따

.env

NAVER_SMS_ID={네이버sms 서비스ID}
NAVER_SMS_PHONE_NUMBER={발신전화번호}
NAVER_ACCESS_KEY={네이버API 엑세스키}
NAVER_SECRET_KEY={네이버API 비밀키}

dotenv 나 application.properties 파일등에 비밀스럽게 잘 두면 된다

특히 git 에 이 정보가 올라가면 큰일나니 주의

요즘엔 워낙 서비스가 잘 되어있어서

git 같은데 올라가는 거 감지되면 서비스를 강제 종료시켜버리던가 그러지만

애초에 올리지 않으면 해결될 일이니

문자 인증 절차

https://api.ncloud-docs.com/docs/ko/ai-application-service-sens-smsv2

SMS API

api.ncloud-docs.com

물론 공식 레퍼런스에 너무나도 잘 설명되어 있다

하나하나 차근차근 따라가보자

API Header 정의

네이버 클라우드 API 를 사용하기 위해서는 위 3개의 헤더를 끼워서 요청을 보내야한다

1. 밀리초 단위의 타임스탬프

2. 아까 받은 계정 Access Key

3. 1번과 2번을 암호화 알고리즘으로 서명한 것

1번과 2번은 여차저차 하면 되지만

3번은 조금 헷갈릴 수 있다

서명

https://api.ncloud-docs.com/docs/common-ncpapi

Ncloud API

api.ncloud-docs.com

서명 생성 예제가 모두 나와있으니 보면 된다

SmsCertificationServiceImpl.java

@Slf4j
@Service
@RequiredArgsConstructor
public class SmsCertificationServiceImpl implements SmsCertificationService {

    private final WebClient webClient;
    private final RedisService redisService;

    private final String VERIFICATION_PREFIX = "sms:";
    private final int VERIFICATION_TIME_LIMIT = 3 * 60;

    @Value("${SPRING_PROFILE}")
    private String springProfile;
    @Value("${NAVER_ACCESS_KEY}")
    private String accessKey;
    @Value("${NAVER_SECRET_KEY}")
    private String secretKey;
    @Value("${NAVER_SMS_ID}")
    private String serviceId;
    @Value("${NAVER_SMS_PHONE_NUMBER}")
    private String senderNumber;

	/**
     * sms 전송을 위한 서명을 추가한다
     * @param currentTime 현재 시간
     * @return 서명
     */
    @Override
    public String makeSignature(Long currentTime) {
        String space = " ";
        String newLine = "\n";
        String method = "POST";
        String url = "/sms/v2/services/" + this.serviceId + "/messages";
        String timestamp = currentTime.toString();
        String accessKey = this.accessKey;
        String secretKey = this.secretKey;

        try {

            String message = method +
                    space +
                    url +
                    newLine +
                    timestamp +
                    newLine +
                    accessKey;

            SecretKeySpec signingKey = new SecretKeySpec(secretKey.getBytes("UTF-8"), "HmacSHA256");
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(signingKey);

            byte[] rawHmac = mac.doFinal(message.getBytes("UTF-8"));
            String encodeBase64String = Base64.encodeBase64String(rawHmac);

            return encodeBase64String;
        } catch (Exception e) {
            throw new BadRequestException(ErrorCode._BAD_REQUEST, e.getMessage());
        }
    }
    ...
    ...
}

예제와 비슷하지만 매개변수로 Long 형의 현재 시간을 받아온다

DTO 정의

NaverSmsMessageDTO.java

@AllArgsConstructor
@NoArgsConstructor
@Getter
@Builder
@ToString
public class NaverSmsMessageDTO {
    String to;
    String content;
}

NaverSmsRequestDTO.java

@AllArgsConstructor
@NoArgsConstructor
@Getter
@Builder
@ToString
public class NaverSmsRequestDTO {
    String type;
    String contentType;
    String countryCode;
    String from;
    String content;
    List<NaverSmsMessageDTO> messages;
}

NaverSmsResponseDTO.java

@AllArgsConstructor
@NoArgsConstructor
@Getter
@Builder
@ToString
public class NaverSmsResponseDTO {
    String requestId;
    LocalDateTime requestTime;
    String statusCode;
    String statusName;
}

꼭 정의해야하는 DTO는 위의 세 가지로

네이버 SMS API의 메세지 응답, 처리에 필요하다

이름 마음대로 바꿨다가 DTO <-> JSON 매칭이 안돼서 삽질좀 했다

왠만하면 그대로 사용하는 게 좋다

request body 의 각 필드는 optional 이라서 필요한 것만 추가해주면 된다

인증번호 전송

SmsCertificationServiceImpl.java

    ...
    ...
    /**
     * 인증번호가 담긴 메세지를 전송한다
     * @param to 수신자
     * @return 네이버 api 서버 메세지 응답
     */
    @Override
    public String sendVerificationMessage(String to) {
        final String smsURL = "https://sens.apigw.ntruss.com/sms/v2/services/"+ serviceId +"/messages";
        final Long time = System.currentTimeMillis();
        //랜덤 6자리 인증번호
        final String verificationCode = generateVerificationCode();
        //3분 제한시간
        final Duration verificationTimeLimit = Duration.ofSeconds(VERIFICATION_TIME_LIMIT);

        //[local, dev] 배포 환경이 아닐때는 fake service 를 제공합니다
        if (!springProfile.equals("prod")) {
            log.info("스프링 프로파일(" + springProfile + ") 따라 fake 서비스를 제공합니다");
            String message = generateMessageWithCode(verificationCode);
            log.info(message);
            redisService.setValues(VERIFICATION_PREFIX + to, verificationCode, verificationTimeLimit);
            return message;
        }

        //[prod] 실 배포 환경에서는 문자를 전송합니다
        try {
            //네이버 sms 메세지 dto
            final NaverSmsMessageDTO naverSmsMessageDTO = new NaverSmsMessageDTO(to, generateMessageWithCode(verificationCode));
            List<NaverSmsMessageDTO> messages = new ArrayList<>();
            messages.add(naverSmsMessageDTO);
            final NaverSmsRequestDTO naverSmsRequestDTO = NaverSmsRequestDTO.builder()
                    .type("SMS")
                    .contentType("COMM")
                    .countryCode("82")
                    .from(senderNumber)
                    .content(naverSmsMessageDTO.getContent())
                    .messages(messages)
                    .build();
            final String body = new ObjectMapper().writeValueAsString(naverSmsRequestDTO);

//            final ResponseMessageDTO responseMessageDTO =
            webClient.post().uri(smsURL)
                    .contentType(MediaType.APPLICATION_JSON)
                    .header("x-ncp-apigw-timestamp", time.toString())
                    .header("x-ncp-iam-access-key", accessKey)
                    .header("x-ncp-apigw-signature-v2", makeSignature(time))
                    .accept(MediaType.APPLICATION_JSON)
                    .body(BodyInserters.fromValue(body))
                    .retrieve()
                    .bodyToMono(NaverSmsResponseDTO.class).block();

            //redis 에 3분 제한의 인증번호 토큰 저장
            redisService.setValues(VERIFICATION_PREFIX + to, verificationCode, verificationTimeLimit);

            return "메세지 전송 성공";
//            return responseMessageDTO;
        } catch (Exception e) {
            e.printStackTrace();
            throw new BadRequestException(ErrorCode._BAD_REQUEST, "메세지 발송에 실패하였습니다");
        }
    }
    
        /**
     * 랜덤 인증번호를 생성한다
     * @return 인증번호 6자리
     */
    private String generateVerificationCode() {
        Random random = new Random();
        int verificationCode = random.nextInt(888888) + 111111;
        return Integer.toString(verificationCode);
    }

    /**
     * 인증번호가 포함된 메세지를 생성한다
     * @param code 인증번호 6자리
     * @return 인증번호 6자리가 포함된 메세지
     */
    private String generateMessageWithCode(String code) {
        final String provider = "내친소";
        return "[" + provider + "] 인증번호 [" + code + "] 를 입력해주세요 :)";
    }
    
    ...

인증번호 전송은 fake 와 real 서비스로 나누었다

스프링 프로파일을 local / dev / prod 총 3가지로 나누었는데

각 로컬, 개발서버, 배포서버에서 활용할 예정이다

프로파일이 prod가 아닐 경우에는 문자를 전송하지 않고

response 로 바로 인증번호를 반환시켜버렸다

프로파일이 prod 이면은 실제 문자를 전송시키는데

Webflux 의 WebClient를 사용해서 네이버 SMS API 서버와 통신했다

인증번호가 생성되고 문자를 보내면

3분 기한을 두고 Redis 에 {Key: Value} 형태로 저장해둔다

Key는 사용자의 번호로 두었고 인증 과정에서 뽑아올 때 번호를 통해 처리한다

Redis 설정

RedisConfig.java

@Configuration
public class RedisConfig {
    @Value("${REDIS_HOST}")
    private String host;

    @Value("${REDIS_PORT}")
    private int port;

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory(host, port);
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate() {
        // redisTemplate를 받아와서 set, get, delete를 사용
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        /**
         * setKeySerializer, setValueSerializer 설정
         * redis-cli을 통해 직접 데이터를 조회 시 알아볼 수 없는 형태로 출력되는 것을 방지
         */
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(redisConnectionFactory());

        return redisTemplate;
    }
}

레디스 설정 파일이다

레디스 서버는 도커 컴포즈를 통해 로컬에서 관리중이다

RedisServiceImpl.java

@Slf4j
@Service
@RequiredArgsConstructor
public class RedisServiceImpl implements RedisService {
    private final RedisTemplate<String, String> redisTemplate;

    @Override
    public void setValues(String key, String data) {
        ValueOperations<String, String> values = redisTemplate.opsForValue();
        values.set(key, data);
    }

    @Override
    public void setValues(String key, String data, Duration duration) {
        ValueOperations<String, String> values = redisTemplate.opsForValue();
        values.set(key, data, duration);
    }

    @Override
    public String getValues(String key) {
        ValueOperations<String, String> values = redisTemplate.opsForValue();
        return values.get(key);
    }

    @Override
    public void deleteValues(String key) {
        redisTemplate.delete(key);
    }

    @Override
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
}

레디스 서비스

키 저장, 삭제, 뽑아오기 등을 담당하고 있다

인증번호 검증

SmsCertificationServiceImpl.java

...
...
	@Override
    public String verifyCode(SmsCertificationRequestDTO smsCertificationRequestDto) {
        String phoneNumber = smsCertificationRequestDto.getPhoneNumber();
        String code = smsCertificationRequestDto.getCode();
        String key = VERIFICATION_PREFIX + phoneNumber;

        //redis 에 해당 번호의 키가 없는 경우는 인증번호(3분) 만료로 처리
        if (!redisService.hasKey(key)) {
            throw new UnauthorizedException(ErrorCode.EXPIRED_VERIFICATION_CODE);
        }

        //redis 에 해당 번호의 키와 인증번호가 일치하지 않는 경우
        if (!redisService.getValues(key).equals(code)) {
            throw new UnauthorizedException(ErrorCode.MISMATCH_VERIFICATION_CODE);
        }

        //필터를 모두 통과, 인증이 완료되었으니 redis 에서 전화번호 삭제
        redisService.deleteValues(key);
        return "인증에 성공하였습니다";
    }
...
...

만약 사용자의 번호로 된 Key값이 없으면 만료된 것으로 처리

있지만 인증번호가 다를 경우 인증 실패로 처리했다

모든 필터를 통과하면 Redis 상에서 번호로 된 키 값을 제거(만료)시키고

인증 성공 처리를 한다

리턴 값을 String 메세지 형태로 주었는데

인증에 성공할 경우를 제외하면 모두 4xx 에러로 리턴되기 때문이다

컨트롤러 구성

SmsCertificationController.java

@Slf4j
@RestController
@RequestMapping("/sms")
@RequiredArgsConstructor
public class SmsCertificationController {
    private final SmsCertificationService smsCertificationService;

    @PostMapping("/send")
    public CommonApiResponse<String> sendMessageWithVerificationCode(@RequestBody @Valid SmsVerificationCodeRequestDTO dto) {
        String result = smsCertificationService.sendVerificationMessage(dto.getPhoneNumber());
        return CommonApiResponse.of(result);
    }

    @PostMapping("/verify")
    public CommonApiResponse<String> verifyCode(@RequestBody @Valid SmsCertificationRequestDTO dto) {
        String result = smsCertificationService.verifyCode(dto);
        return CommonApiResponse.of(result);
    }
}

인증번호 전송과 검증 처리 관련 url 을 추가했다

SmsVerificationCodeRequestDTO.java

@AllArgsConstructor
@NoArgsConstructor
@Getter
@Builder
@ToString
public class SmsVerificationCodeRequestDTO {
    @NotBlank(message = "전화번호를 입력해주세요")
    @Pattern(regexp = "[0-9]{10,11}", message = "하이픈 없는 10~11자리 숫자를 입력해주세요")
    String phoneNumber;
}

인증번호 전송 요청 DTO

Spring Validation 을 통해 인자를 검증한다

01000000000 형태의 붙어있는 번호를 받을 것이기 때문에

정규식으로 숫자만 있는 문자열이 오도록 했다

SmsCertificationRequestDTO.java

@AllArgsConstructor
@NoArgsConstructor
@Getter
@Builder
@ToString
public class SmsCertificationRequestDTO {
    @NotBlank(message = "전화번호를 입력해주세요")
    @Pattern(regexp = "[0-9]{10,11}", message = "하이픈 없는 10~11자리 숫자를 입력해주세요")
    String phoneNumber;

    @NotBlank(message = "인증번호를 입력해주세요")
    @Pattern(regexp = "[0-9]{6}", message = "인증번호 6자리를 입력해주세요")
    String code;
}

인증번호 검증 요청 DTO

마찬가지로 휴대폰번호와 인증번호를 검증했다

Validation 을 통과하지 못하면 MethodArgumentNotValidException 을 내뿜어서

글로벌 익셉션 핸들러 정의한 곳에서 걸리게 된다

문자인증 테스트

프로파일이 local 일 경우 이렇게 데이터로 바로 넘어온다

인자가 유효하지 않으면 유효하지 않은 해당 필드가 반환되도록 했다

똑바로 입력하면 성공

이후 똑같은 인증번호로 인증 요청을 하게 되면

Redis 상에서 삭제했기 때문에 만료되었다고 뜬다

이번엔 스프링 프로파일 변경 후 시도

이번엔 인증번호가 아니라 메세지 전송 성공이라는 메세지가 응답된다

문자가 잘 오는 모습

첫 프로젝트에서 담당했던게 Node.js + 문자인증이었는데

다시 해보니까 그다지 어렵지는 않은 거 같다

그 때는 이렇게 어려운게 없었는데

이제 메세지 큐 이용해서 비동기로 메세지 보내는 거까지 구현을 해보아야 겠다

아무튼 문자인증 구현 끗

[Spring] 스프링 시큐리티 + JWT로 카카오 로그인 구현하기, 프론트엔드와 연결

gengminy — Sun, 4 Sep 2022 18:51:14 +0900

지난 번에 DefaultOAuth2Service 를 상속하여

스프링 시큐리티에 등록하는 방식으로 카카오 로그인을 구현해보았다

하지만 이런 식으로 하게 되면

스프링 내장 함수을 이용하면서 편리하게 구현을 할 수는 있지만

구조가 너무 추상적이고 컨트롤러에서 통제하기가 어려웠다

그래서 이번에는 OAuth 인증 과정의 본질을 뜯어보면서 하나하나 구현해보았다

이전 글 (DefaultOAuth2Service 이용)

https://gengminy.tistory.com/39

[Spring] OAuth2Service + 스프링 시큐리티 + JWT로 카카오 로그인 구현하기

OAuth "OpenID Authorization"의 약자 비밀번호를 제공하지 않으면서 웹사이트나 어플리케이션 접근 권한을 부여할 수 있는 로그인 방식 기존 아이디와 비밀번호를 통한 로그인 방식은 보안상 취약

gengminy.tistory.com

Kakao Developers 설정

https://developers.kakao.com/

Kakao Developers

카카오 API를 활용하여 다양한 어플리케이션을 개발해보세요. 카카오 로그인, 메시지 보내기, 친구 API, 인공지능 API 등을 제공합니다.

developers.kakao.com

시작하기

어플리케이션 추가하기 누르고 앱 이름과 사업자명 입력

이후 만든 어플리케이션 클릭해서 이동

REST API 키 나중에 사용해야 하니까 이 페이지 기억해두기

좌측 메뉴 카카오 로그인 -> 활성화 설정 상태 ON 으로 변경

이후 아래 Redirect URI 설정으로 진입

일단 로컬 환경에서 테스트를 진행해야 하기 때문에 로컬호스트로 설정
리액트에서 localhost:3000 사용하니까 그 쪽으로 등록해준다

이전 글에서는 localhost:8000 사용해서 서버 포트로 들어갔는데

이번에는 리액트랑도 완벽하게 연결하기 위해 바꾸었다

로그인 시도할 때 이 URI 를 통해 인가 코드가 반환이 된다

이 URI 은 클라이언트 쪽에서 사용해야 하니까 잘 기억해두기

카카오 로그인 -> 동의항목 에서

OAuth 를 통한 회원가입 진행 시 받아올 정보를 설정

인증 구조

이미지 출처 : https://developers.kakao.com/docs/latest/ko/kakaologin/rest-api

클라이언트 <-> 백엔드 서버 <-> 카카오 api 서버가

수 차례 통신하면서 로그인 과정을 진행하게 된다

본질은 같아서 하나만 구현해보면 나머지는 쉽게 할 수 있을 거 같다

프론트엔드 (React)

KakaoLogin.js

const KakaoLogin = () => {
  const location = useLocation();
  const param = useParams();

  const KAKAO_BASEURL = process.env.REACT_APP_KAKAO_BASEURL;
  const KAKAO_RESTAPI_KEY = process.env.REACT_APP_KAKAO_RESTAPI_KEY;
  const KAKAO_REDIRECT_URI = process.env.REACT_APP_KAKAO_REDIRECT_URI;

  const loginUri =
    'https://kauth.kakao.com/oauth/authorize?response_type=code&client_id=' +
    KAKAO_RESTAPI_KEY +
    '&redirect_uri=' +
    KAKAO_BASEURL +
    KAKAO_REDIRECT_URI;

  return (
    <>
      <NavBar />
      <h1>카카오 로그인</h1>
      <a href={loginUri}>카카오 로그인</a>
    </>
  );
};

export default KakaoLogin;

아까 카카오 디벨로퍼에서 설정했던 정보를

dotenv 파일에 다 담아두고 사용 중이다

이 정보를 이용해서 카카오 로그인 요청 시 해당 url로 넘어가게 하면 된다

해당 url 로 넘어가면 유저에게 카카오 계정 로그인을 요청하고

카카오 계정 로그인이 완료되면 다음 스텝으로 넘어간다

KakaoProcess.js

const KakaoProcess = () => {
  const params = new URL(document.location).searchParams;
  const code = params.get('code'); //쿼리파라미터 code 가져오기
  const setAccessToken = useCookies(['accessToken'])[1];

  useEffect(() => {
    async function dispatchLogin() {
      try {
        AuthApi.requestKakaoLogin(code).then(res => {
          if (res.status === 200) {
            const date = new Date();
            const { accessToken } = res.data.data;
            setAccessToken('accessToken', accessToken, {
              expires: new Date(date.setDate(date.getDate() + 3)),
              path: '/',
              secure: true,
            });
            console.log(res.data.data);
          }
        });
      } catch (error) {
        console.error(error);
      }
    }
    dispatchLogin();
  }, []);

  return (
    <>
      <NavBar />
      <h1>로그인 처리중입니다</h1>
    </>
  );
};

export default KakaoProcess;

카카오 계정 로그인이 완료되면 query parameter 로

해당 유저의 계정 코드가 같이 넘어오는데

이를 캐치해서 백엔드 서버에 axios post 하는 방식으로 진행했다

아까 설정한 redirect url + code 가 넘어온다

AuthApi.js

const AuthApi = {
  ...
  ...
  requestKakaoLogin: async body => {
    const data = await axios.post(
      'http://localhost:8000/auth/login/kakao',
      body,
      { headers: { 'Content-Type': 'application/json' } }
    );
    return data;
  },
};

export default AuthApi;

일단 테스트 중이니 localhost:8000으로 날리는 방식

서버에서는 /auth/login/kakao 를 컨트롤러에서 받아서 처리한다

간혹 content-type 이 urlencoded 방식이라고 안되는 경우가 있는데

헤더에 application/json 방식을 정의해주면 해결된다

이제 백엔드 서버 로직을 보자

백엔드 (Spring)

KakaoController.java

@Slf4j
@Controller
@RequestMapping("/auth/login")
@RequiredArgsConstructor
public class KakaoController {

    private final KakaoService kakaoService;
    private final AuthService authService;
    private final UserRepository userRepository;
    private final JwtTokenProvider jwtTokenProvider;

    @ApiOperation(value = "카카오 코드를 포함한 로그인 요청")
    @PostMapping(value = "/kakao", produces = "application/json; charset=utf-8")
    @ResponseBody
    public CommonApiResponse<TokenResponseDto> postKakaoLoginWithCode(
            @RequestBody KakaoRequest kakaoRequest,
            HttpServletResponse response
    ) {
        KakaoTokenDto kakaoTokenDto = kakaoService.getKakaoAccessToken(kakaoRequest.getCode());
        KakaoUserDto kakaoUserDto = kakaoService.getKakaoUser(kakaoTokenDto.getAccessToken());
        TokenResponseDto tokenResponseDto = authService.loginKakao(kakaoUserDto);
        return CommonApiResponse.of(tokenResponseDto);
    }
}

처리하는 엔드포인트는 /auth/login/kakao

KakaoRequest 라는 Dto를 받아서 처리한다

별건 없고 String code 를 가지고 있는 Dto 이다

나머지 로직은 서비스 단에서 구현했다

반환값은 JWT 관련 Dto 인데

엑세스 토큰과 리프레시 토큰을 반환한다

KakaoRequest.java

@Getter
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class KakaoRequest {
    private String code;
}

입력받는 dto 정의

프론트의 유저 code 를 가지고 있다

KakaoService.java

@Service
@RequiredArgsConstructor
@Transactional(readOnly = false)
@Slf4j
public class KakaoService {

    private final WebClient webClient;
    private final UserRepository userRepository;

    @Value("${KAKAO_BASEURL}")
    private String KAKAO_BASEURL;
    @Value("${KAKAO_RESTAPI_KEY}")
    private String KAKAO_RESTPAPI_KEY;
    @Value("${KAKAO_REDIRECT_URI}")
    private String KAKAO_REDIRECT_URL;

    public KakaoTokenDto getKakaoAccessToken(String code) {
        String getTokenURL =
                "https://kauth.kakao.com/oauth/token?grant_type=authorization_code&client_id="
                        + KAKAO_RESTPAPI_KEY + "&redirect_uri=" + KAKAO_BASEURL + KAKAO_REDIRECT_URL + "&code="
                        + code;

        try {
            KakaoTokenDto kakaoTokenDto =
                    webClient.post()
                            .uri(getTokenURL)
                            .retrieve()
                            .bodyToMono(KakaoTokenDto.class).block();
            return kakaoTokenDto;
        } catch (Exception e) {
            e.printStackTrace();
            throw new BadRequestException(ErrorCode.KAKAO_BAD_REQUEST);
        }
    }

    public KakaoUserDto getKakaoUser(String kakaoAccessToken) {
        String getUserURL = "https://kapi.kakao.com/v2/user/me";

        try {
            KakaoUserDto kakaoUserDto =
                    webClient.post()
                            .uri(getUserURL)
                            .header("Authorization", "Bearer " + kakaoAccessToken)
                            .retrieve()
                            .bodyToMono(KakaoUserDto.class)
                            .block();
            
            return kakaoUserDto;
        } catch (Exception e) {
            e.printStackTrace();
            throw new BadRequestException(ErrorCode.KAKAO_BAD_REQUEST);
        }
    }
}

getKakaoAccessToken 에서는

카카오 유저 코드를 이용해 카카오 계정 관련 권한이 담긴 엑세스 토큰을 가져온다

처음할 때 혼동이 있을 수 있는데

이 엑세스 토큰은 카카오 api 서버에서 카카오 계정 관련 서비스를 이용하기 위함이지

우리가 만드는 서비스 관련 엑세스 토큰이 아니다

여기서는 서버에서도 프론트의 axios 와 같이

서버에서 카카오 api 서버와 통신하는 웹 클라이언트가 필요하다

이 때 사용하는게 RestTemplete 과 WebClient 인데

RestTemplete 은 지원이 끊기니 사용하지 않는게 좋다고 들어서

Webflux의 WebClient 를 사용했다

WebClientConfig.java

@Configuration
public class WebClientConfig {

    @Bean
    public WebClient webClient() {
        HttpClient httpClient = HttpClient.create()
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
                .responseTimeout(Duration.ofMillis(5000))
                .doOnConnected(connection -> {
                    connection.addHandlerLast(new ReadTimeoutHandler(5000, TimeUnit.MILLISECONDS))
                            .addHandlerLast(new WriteTimeoutHandler(5000, TimeUnit.MILLISECONDS));
                });

        WebClient webClient = WebClient.builder()
                .defaultHeader(HttpHeaders.CONTENT_TYPE, String.valueOf(MediaType.APPLICATION_JSON))
                .clientConnector(new ReactorClientHttpConnector(httpClient))
                .build();

        httpClient.warmup().block();

        return webClient;
    }
}

웹 클라이언트를 싱글톤 빈으로 사용하기 위한 설정 파일이다

여러가지 WebClient 생성 관련 설정을 해줄 수 있다

의존성은 다음을 build.gradle 에 추가해주면 된다

implementation 'org.springframework.boot:spring-boot-starter-webflux'

처음에 얻는 엑세스 토큰으로

다시 카카오 api 서버에 해당 유저를 가져오는 요청을 보낼 수 있다

이를 kakaoUserDto 에 저장했다

KakaoUserDto.java

@Getter
@ToString
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
public class KakaoUserDto {

    @JsonProperty("id")
    private String authenticationCode;

    @JsonProperty("connected_at")
    private Timestamp connectedAt;

    @JsonProperty("kakao_account")
    private KakaoAccount kakaoAccount;

    @JsonProperty("properties")
    private Properties properties;

    @Getter
    @ToString
    public static class KakaoAccount {
        private String email;
    }

    @Getter
    @ToString
    public static class Properties {
        private String nickname;
    }
}

카카오 계정 로그인한 유저가 정보 제공에 동의했다면

그 정보들이 다 넘어와 각 필드에 저장된다

AuthService.java

...
...
  @Override
    @Transactional
    public TokenResponseDto loginKakao(KakaoUserDto kakaoUserDto) {
        String provider = "kakao";

        log.info("로그인 시도");

        Optional<User> user = userRepository.findByEmailAndProvider(
                kakaoUserDto.getKakaoAccount().getEmail(),
                provider
        );

        if (user.isPresent()) {
            log.info("가입된 회원");
            /* 이미 가입된 회원 */
            TokenResponseDto tokenResponseDto = jwtTokenProvider.generateSocialToken(user.get());
            return tokenResponseDto;
        } else {
            /* 새로 가입할 회원 */

            String email = kakaoUserDto.getKakaoAccount().getEmail();
            String name = kakaoUserDto.getProperties().getNickname();

            User newUser = User.builder()
                    .email(email)
                    .name(name)
                    .role(UserRole.ROLE_USER)
                    .provider(provider)
                    .authenticationCode(kakaoUserDto.getAuthenticationCode())
                    .build();
            userRepository.save(newUser);

            log.info("새로운 회원");
            

            TokenResponseDto tokenResponseDto = jwtTokenProvider.generateSocialToken(newUser);
            return tokenResponseDto;
        }
    }
...
...

이제 이전에 만든 로그인 관련 서비스인 AuthService 에 일부 로직을 추가해준다

KakaoUserDto 를 받아서 해당 유저의 소셜 로그인을 처리한다

만약 DB 상 유저가 있다면 로그인을 시키고

그렇지 않다면 회원가입 시킨다

이후 해당 유저의 정보가 담긴 JWT를 생성해서 리턴해주면 된다

이제 프론트에서 요청을 보내면

이런식으로 엑세스 토큰과 리프레시 토큰이 잘 넘어오게 된다

이를 리다이렉션 시켜서 다시 서비스를 시작하면 된다

OAuth 구조 이해하기가 힘들어서 일단 구현하면서 부딪혀봤는데 꽤 어려웠다

아무래도 너무 추상화된 코드 보다는 이런식으로 하나하나 뜯어서 하는게 성에 차는 거 같다

이제 다른 소셜 로그인도 구현해 봐야지

[Spring] OAuth2Service + 스프링 시큐리티 + JWT로 카카오 로그인 구현하기

gengminy — Sat, 27 Aug 2022 00:53:23 +0900

OAuth

"OpenID Authorization"의 약자

비밀번호를 제공하지 않으면서 웹사이트나 어플리케이션 접근 권한을 부여할 수 있는 로그인 방식

기존 아이디와 비밀번호를 통한 로그인 방식은 보안상 취약한 점이 아주 많다

그러나 OAuth 를 사용하면 특정 접근 권한만 부여할 수도 있고

강력한 보안을 제공하는 대기업에 사용자 인증과 인가를 위임하는 방식으로 안전하게 로그인할 수 있다

Dependency

implementation group: 'org.springframework.security', name: 'spring-security-oauth2-client', version: '5.6.3'

build.gradle 에 OAuth 관련 의존성을 추가해준다

Kakao Developers 설정

https://developers.kakao.com/

Kakao Developers

카카오 API를 활용하여 다양한 어플리케이션을 개발해보세요. 카카오 로그인, 메시지 보내기, 친구 API, 인공지능 API 등을 제공합니다.

developers.kakao.com

시작하기

어플리케이션 추가하기 누르고 앱 이름과 사업자명 입력

이후 만든 어플리케이션 클릭해서 이동

REST API 키 나중에 사용해야 하니까 이 페이지 기억해두기

좌측 메뉴 카카오 로그인 -> 활성화 설정 상태 ON 으로 변경

이후 아래 Redirect URI 설정으로 진입

일단 로컬 환경에서 테스트를 진행해야 하기 때문에 로컬호스트로 설정

로그인 시도할 때 이 URI 를 통해 인가 코드가 반환이 된다

이 URI 은 클라이언트 쪽에서 사용해야 하니까 잘 기억해두기

카카오 로그인 -> 동의항목 에서

OAuth 를 통한 회원가입 진행 시 받아올 정보를 설정

application.yml 설정

application.yml

...
...
  security:
    oauth2:
      client:
        registration:
          kakao:
            client-id: ${KAKAO_RESTAPI_KEY}
            redirect-uri: ${KAKAO_REDIRECT_URI}
            authorization-grant-type: authorization_code
            client-authentication-method: POST
            client-name: Kakao
            scope:
              - profile_nickname
              - account_email
        provider:
          kakao:
            authorization-uri: https://kauth.kakao.com/oauth/authorize
            token-uri: https://kauth.kakao.com/oauth/token
            user-info-uri: https://kapi.kakao.com/v2/user/me
            user-name-attribute: id
...
...

설정 파일에서 security 부분을 추가해준다

아까 받은 rest api key 와 redirect uri 를 넣어주면 된다

OAuth2 구현

CustomOAuth2Service

@Slf4j
@RequiredArgsConstructor
@Service
public class CustomOAuth2Service extends DefaultOAuth2UserService {

    private final UserRepository userRepository;

    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        OAuth2User oAuth2User = super.loadUser(userRequest);

        //provider 정보 (kakao, google, naver...)
        String registrationId = userRequest.getClientRegistration().getRegistrationId();
        String userNameAttributeName = userRequest.getClientRegistration()
                .getProviderDetails().getUserInfoEndpoint().getUserNameAttributeName();
        log.info("registrationId = {}", registrationId);
        log.info("userNameAttributeName = {}", userNameAttributeName);

        //provider 정보 기반 객체 생성
        OAuth2Attribute oAuth2Attribute =
                OAuth2Attribute.of(registrationId, userNameAttributeName, oAuth2User.getAttributes());

        final String email = oAuth2Attribute.getEmail();
        final String name = oAuth2Attribute.getName();
        final String provider = oAuth2Attribute.getProvider();

        if (userRepository.existsByEmail(email)) {
            log.info("가입된 회원입니다");
        } else {
            User user = User.builder()
                    .email(email)
                    .name(name)
                    .provider(provider)
                    .role(UserRole.ROLE_USER)
                    .build();

            userRepository.save(user);

            log.info("회원가입");
        }

        var memberAttribute = oAuth2Attribute.convertToMap();

        return new DefaultOAuth2User(
                Collections.singleton(new SimpleGrantedAuthority("ROLE_USER")),
                memberAttribute, "email");
    }
}

DefaultOAuth2UserService 를 구현한 클래스이다

이 클래스는 사용자 정보 기반으로 여러 기능을 지원해준다

OAuth2UserRequest 는 서드파티 서버로부터 사용자 정보를 받아올 수 있다

이 정보를 통해 가입된 회원인지 아닌지 파악하고 결과를 반환해주면 된다

결과로는 UserPrincipal 을 반환하는데 세션 방식에서는 이 결과가 저장이 되지만

우리는 JWT 방식을 사용하기 때문에 무시된다

OAuth2Attribute

@ToString
@Builder(access = AccessLevel.PRIVATE)
@Getter
public class OAuth2Attribute {
    private Map<String, Object> attributes;
    private String attributeKey;
    private String email;
    private String name;
    private String provider;

    static OAuth2Attribute of(String provider, String attributeKey,
                              Map<String, Object> attributes) {
        switch (provider) {
            case "google":
                return ofGoogle(attributeKey, attributes);
            case "kakao":
                return ofKakao("email", attributes);
            case "naver":
                return ofNaver("id", attributes);
            default:
                throw new RuntimeException();
        }
    }

    private static OAuth2Attribute ofGoogle(String attributeKey,
                                            Map<String, Object> attributes) {
        return OAuth2Attribute.builder()
                .name((String) attributes.get("name"))
                .email((String) attributes.get("email"))
                .provider("google")
                .attributes(attributes)
                .attributeKey(attributeKey)
                .build();
    }

    private static OAuth2Attribute ofKakao(String attributeKey,
                                           Map<String, Object> attributes) {
        Map<String, Object> kakaoAccount = (Map<String, Object>) attributes.get("kakao_account");
        Map<String, Object> kakaoProfile = (Map<String, Object>) kakaoAccount.get("profile");

        return OAuth2Attribute.builder()
                .name((String) kakaoProfile.get("nickname"))
                .email((String) kakaoAccount.get("email"))
                .provider("kakao")
                .attributes(kakaoAccount)
                .attributeKey(attributeKey)
                .build();
    }

    private static OAuth2Attribute ofNaver(String attributeKey,
                                           Map<String, Object> attributes) {
        Map<String, Object> response = (Map<String, Object>) attributes.get("response");

        return OAuth2Attribute.builder()
                .name((String) response.get("name"))
                .email((String) response.get("email"))
                .provider("naver")
//                .picture((String) response.get("profile_image"))
                .attributes(response)
                .attributeKey(attributeKey)
                .build();
    }

    Map<String, Object> convertToMap() {
        Map<String, Object> map = new HashMap<>();
        map.put("id", attributeKey);
        map.put("key", attributeKey);
        map.put("email", email);
        map.put("name", name);
        map.put("provider", provider);

        return map;
    }
}

OAuth 를 지원하는 플랫폼 마다 이름들이 조금씩 달라져서

통합하여 관리하기 위한 클래스이다

provider에 따라서 자동으로 이름을 변환시켜서 값을 대입해준다

카카오 뿐 아니라 다른 플랫폼으로도 확장하기 위하여 도입시켰다

OAuth2AuthenticationSuccessHandler

package Backend.HIFI.auth.oauth;

import Backend.HIFI.auth.dto.TokenResponseDto;
import Backend.HIFI.auth.jwt.JwtTokenProvider;
import Backend.HIFI.auth.security.UserAuthentication;
import Backend.HIFI.user.User;
import Backend.HIFI.user.UserRepository;
import Backend.HIFI.user.UserRole;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.oauth2.client.authentication.OAuth2LoginAuthenticationToken;
import org.springframework.security.oauth2.core.user.OAuth2User;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;
import org.springframework.stereotype.Component;
import org.springframework.web.util.UriComponentsBuilder;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.stream.Collectors;

@Slf4j
@Component
@RequiredArgsConstructor
public class OAuth2AuthenticationSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {

    private final JwtTokenProvider jwtTokenProvider;
    private final UserRepository userRepository;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
                                        Authentication authentication) throws IOException {
        //로그인 성공한 사용자
        OAuth2User oAuth2User = (OAuth2User) authentication.getPrincipal();

        final String email = oAuth2User.getName();
        final String provider = oAuth2User.getAttribute("provider");
        final String name = oAuth2User.getAttribute("name");
        final String authorities = oAuth2User.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.joining(","));

        TokenResponseDto tokenResponseDto = jwtTokenProvider.generateOAuth2Token(oAuth2User);
        log.info("토큰 발행");

        String targetUrl = UriComponentsBuilder.fromUriString("/oauth2/redirect")
                        .queryParam("token", tokenResponseDto.getAccessToken())
                                .build().toUriString();
        getRedirectStrategy().sendRedirect(request, response, targetUrl);
    }
}

CustomOAuth2Service 이후로 실행되는 핸들러 메서드

여기서 엑세스 토큰을 만들어서 이것을 쿼리 파라미터로 리디렉션하여 프론트에 넘겨주게 된다

프론트에서는 이 값을 저장하면 된다

리프레시 토큰을 Redis 에 저장하는 로직은 아직 추가 안했는데

더 공부하면서 추가할 것이다

http://localhost:8000/oauth2/redirect?token={accessToken}

SecurityConfiguration

public class SecurityConfiguration {
    ...
    ...
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                ...
                ...
                .oauth2Login()
                .defaultSuccessUrl("/login-success")
                .successHandler(oAuth2AuthenticationSuccessHandler)
                .userInfoEndpoint()
                .userService(customOAuth2Service);

                http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
                return http.build();
    }
    ...
    ...
}

마지막으로 스프링 시큐리티 필터 체인에 등록시켜주면 끝난다

defaultSuccessUrl - 로그인 성공 시 이동할 url
successHanlder - 인증 절차에 따라서 사용자가 정의한 로직을 실행시킴
userInfoEndpoint - OAuth 로그인 성공 이후 행동 정의
userService - customOAuth2Service 에서 후처리 하겠다고 선언

http://localhost:{서버포트}/oauth2/authorization/kakao 로 접속하면 카카오 로그인 화면이 뜬다

절차를 동의하고 실행하면 리디렉션이 된다

Reference

[Gosrock] 고스락 티켓 2.0 프로젝트 관련 글 정리

gengminy — Wed, 17 Aug 2022 14:38:20 +0900

사용 언어 / 프레임워크

Nodejs + Nestjs
PostgreSQL
Socket.io
Redis
Docker

✨ 웹 사이트 주소

https://gosrock.band/

고스락 티켓

22번째 정기공연 [We are GOSROCK, Invites you]

gosrock.band

[Gosrock/Nestjs] PageDto를 이용한 페이지네이션 구현하기 (Paging)

gengminy — Wed, 17 Aug 2022 14:16:52 +0900

고스락 티켓 예매 페이지 22th 프로젝트의 일부인

페이지네이션 / 페이징 구현에 대한 글입니다

어드민 페이지에서 내가 구현한 티켓 서비스의 티켓을

특정 조건에 맞게 N개 가져올 필요가 있었다

그래서 페이지네이션을 제네릭을 이용하여 구현하게 되었다

언제 들었는지 기억은 안나지만 이런 말이 문득 생각난다

개발자가 힘들수록 사용자는 편리해진다

페이지네이션도 그렇다

서버 개발자는 페이징 구현이 귀찮고 짜증나지만

그것을 사용하는 프론트 개발자는 편할지어니,,,,,,

PageOptionsDto 구현

enum.ts

enum PageOrder {
  ASC = 'ASC',
  DESC = 'DESC'
}

오름차순 / 내림차순 옵션을 위한 Enum 이다

page-options.dto.ts

export class PageOptionsDto {
  @ApiPropertyOptional({ enum: PageOrder, default: PageOrder.ASC })
  @IsEnum(PageOrder)
  @IsOptional()
  @Expose()
  readonly order: PageOrder = PageOrder.ASC;

  @ApiPropertyOptional({
    minimum: 1,
    default: 1
  })
  @Type(() => Number)
  @IsInt()
  @Min(1)
  @Expose()
  readonly page: number = 1;

  @ApiPropertyOptional({
    minimum: 1,
    maximum: 50,
    default: 10
  })
  @Type(() => Number)
  @IsInt()
  @Min(1)
  @Max(50)
  @Expose()
  readonly take: number = 10;

  get skip(): number {
    return (this.page - 1) * this.take;
  }
}

page-options.dto 는 Request, page.dto 는 Response 용이다

우선 Request 를 먼저 보내는게 순서니까 옵션부터 알아보자

페이지 옵션에는 order, page, take, skip 이 네 가지 옵션이 들어간다

order : 오름차순 / 내림차순 정렬
page : 현재 가져올 페이지 번호
take : 한 페이지 당 몇 개의 원소를 가져올지
skip : 탐색을 시작하는 원소의 위치 ({현재 페이지 -1} * 가져오는 원소 개수)

그리고 각 멤버에 대해 validation 을 해주면 끝이다

여기서는 integer 조건과 최소, 최대, 기본값을 지정해주었다

skip은 해당 멤버를 불러올 때마다 값이 달라지기 때문에

get 으로 따로 처리했다

TicketFindDto 구현

enum.ts

enum PerformanceDate {
  YB = 'YB',
  OB = 'OB'
}

enum TicketStatus {
  DONE = '입장완료',
  ENTERWAIT = '입금확인',
  ORDERWAIT = '확인대기',
  EXPIRE = '기한만료'
}

티켓 상태에 대한 enum 이다

ticket-find.dto.ts

export class TicketFindDto {
  @ApiProperty({
    description: '티켓 상태',
    enum: TicketStatus,
    required: false
  })
  @IsEnum(TicketStatus)
  @IsOptional()
  @Expose()
  readonly status: TicketStatus;

  @ApiProperty({
    description: '공연 날짜',
    enum: PerformanceDate,
    required: false
  })
  @IsEnum(PerformanceDate)
  @IsOptional()
  @Expose()
  readonly date: PerformanceDate;
}

스웨거를 위해서 DTO 를 추가로 구현했다

여기서는 티켓의 상태와 공연 날짜를 추가로 조건으로 받았다

이것도 어드민 페이지에서 편하게 쓰기 위해 검색 조건에 추가한 것이다

또한 이 조건들이 붙지 않았을 때는

해당 조건에서 값에 상관없이 모든 결과를 불러올 수 있도록 하는게 의도인데

스웨거에서도 사용하기 쉽도록 required: false 옵션을 붙여주었다

Ticket 모듈에 적용

tickets.controller.ts

  @ApiOperation({
    summary: '[어드민]해당 조건의 티켓을 모두 불러온다'
  })
  @Get('/find')
  @Roles(Role.Admin)
  getTicketsWith(
    @Query() ticketFindDto: TicketFindDto,
    @Query() pageOptionsDto: PageOptionsDto
  ) {
    return this.ticketService.findAllWith(ticketFindDto, pageOptionsDto);
  }

일단 다음 페이지로 가기, 또는 뒤로가기나 앞으로 가기를 했을 때에도

이전 검색 결과를 유지하기 위해서 GET 메소드를 사용했고

검색 조건은 쿼리 파라미터로 넘겨주었다

아까 만든 TicketFindDto와 PageOptionsDto 를 레포지토리까지 넘겨주면 된다

tickets.repository.ts

  /**
   * 해당 ticketStatus를 참조하여 해당하는 Ticket 엔티티를 가지고 온다 (관리자용)
   * @param ticketStatus TicketStatus Enum
   * @param pageOptionsDto 페이지네이션 메타 정보
   */
  async findAllWith(
    ticketFindDto: TicketFindDto,
    pageOptionsDto: PageOptionsDto
  ): Promise<PageDto<Ticket>> {
    const { status, date } = ticketFindDto;
    const queryBuilder = this.ticketRepository.createQueryBuilder('ticket');

    //조건부 검색
    if (status) {
      queryBuilder.andWhere({ status });
    }
    if (date) {
      queryBuilder.andWhere({ date });
    }

    queryBuilder
      .orderBy('ticket.id', pageOptionsDto.order)
      .leftJoinAndSelect('ticket.user', 'user')
      .leftJoinAndSelect('ticket.admin', 'admin')
      .skip(pageOptionsDto.skip)
      .take(pageOptionsDto.take);

    const itemCount = await queryBuilder.getCount();
    const { entities } = await queryBuilder.getRawAndEntities();

    const pageMetaDto = new PageMetaDto({ pageOptionsDto, itemCount });

    //console.log(1);
    return new PageDto(entities, pageMetaDto);
  }

TicketFindDto 의 멤버를 찾아서

값이 있을 때만 queryBuilder 의 where 절에 추가시켜준다

쿼리를 날릴 때도 order, skip, take 조건이 있기 때문에

이를 pageOptionsDto 에서 찾아서 넣어준다

이후 결과에서 전체 검색 결과의 개수와 엔티티를 가져오는데

보통은 쿼리 빌더에서 getMany 나 getOne으로 가져오는 것과 달리

getRawAndEntities 를 통해 원시 데이터(raw data)를 추출해낸다

이건 내가 pageDto 구현부에서 데이터를 제네릭으로 구현했기 때문이다

그냥 getMany 로 들고 오면 값이 안들어 가는걸 확인할 수 있다

제네릭으로 구현했기 때문에 Ticket 엔티티에 제대로 매칭이 안된다

그래서 raw data를 뽑아내서 직접 넣어주면 된다

이제 내가 사용한 페이징 옵션과 결과 개수를 메타 정보로 만든 후에

결과인 PageDto에 넣어주면 된다

PageDto, PageMetaDto 구현

page-meta-dto.interface.ts

import { PageOptionsDto } from './page-options.dto';

export interface PageMetaDtoParameters {
  pageOptionsDto: PageOptionsDto;
  itemCount: number;
}

PageOptionsDto 와 아이템 결과의 개수를 가지고 있는

타입스크립트 타입 적용을 위한 인터페이스

page-meta.dto.ts

export class PageMetaDto {
  @ApiProperty({ description: '페이지 정보입니다.' })
  @Expose()
  readonly page: number;

  @ApiProperty({ description: '몇개를 받아가는지 한페이지 당 원소갯수' })
  @Expose()
  readonly take: number;

  @ApiProperty({ description: '총 아이템 숫자 ( 검색 조건에 맞는 )' })
  @Expose()
  readonly itemCount: number;

  @ApiProperty({ description: '총 페이지 숫자 ( 검색 조건에 맞는 )' })
  @Expose()
  readonly pageCount: number;

  @ApiProperty({ description: '이전페이지가 있는지에 대한정보' })
  @Expose()
  readonly hasPreviousPage: boolean;

  @ApiProperty({ description: '다음페이지가 있는지에 대한 정보' })
  @Expose()
  readonly hasNextPage: boolean;

  constructor({ pageOptionsDto, itemCount }: PageMetaDtoParameters) {
    this.page = pageOptionsDto.page;
    this.take = pageOptionsDto.take;
    this.itemCount = itemCount;
    this.pageCount = Math.ceil(this.itemCount / this.take);
    this.hasPreviousPage = this.page > 1;
    this.hasNextPage = this.page < this.pageCount;
  }
}

호출할 때 사용한 PageOptionsDto 를 그대로 넣어주고

생성자에서 값을 변환해 넣어준다

각 멤버에 대한 설명은 주석을 참고

여기서 전체페이지, 이전 페이지가 있는지, 다음 페이지가 있는지 등등을 검사해서 저장한다

어드민 페이지에서 참고하기 정말 좋은 정보들이다

page.dto.ts

export class PageDto<T> {
  @IsArray()
  @ApiProperty({ type: 'generic', isArray: true })
  @Expose()
  readonly data: T[];

  @ApiProperty({ type: () => PageMetaDto })
  @Type(() => PageMetaDto)
  @Expose()
  readonly meta: PageMetaDto;

  constructor(data: T[], meta: PageMetaDto) {
    this.data = data;
    this.meta = meta;
  }
}

제네릭으로 구현해서 어떠한 타입이든 처리할 수 있도록 했다

아까 raw data 로 결과 엔티티를 넣어버린 이유도 제네릭 때문

이렇게 만들어두어서 다른 모듈에서도 호출할 수 있다

Order, User 에서도 이 dto 정보를 사용중이다 하 하

스웨거 정보

{
  "statusCode": "상태코드",
  "success": "성공여부",
  "data": {
    "data": [
      {
        "id": "티켓 고유 식별번호입니다.",
        "uuid": "티켓의 고유 아이디(uuid) 입니다.",
        "date": "공연일자 입니다. (YB/OB)",
        "status": "티켓의 상태입니다. (입장대기/입장완료)",
        "admin": {
          "id": "유저의 고유 아이디입니다.",
          "name": "유저의 입금자명입니다.",
          "phoneNumber": "유저의 휴대전화번호 입니다.",
          "role": "유저의 권한입니다."
        },
        "user": {
          "id": "유저의 고유 아이디입니다.",
          "name": "유저의 입금자명입니다.",
          "phoneNumber": "유저의 휴대전화번호 입니다.",
          "role": "유저의 권한입니다."
        },
        "createdAt": "티켓 생성 일자"
      }
    ],
    "meta": {
      "page": "페이지 정보입니다.",
      "take": "몇개를 받아가는지 한페이지 당 원소갯수",
      "itemCount": "총 아이템 숫자 ( 검색 조건에 맞는 )",
      "pageCount": "총 페이지 숫자 ( 검색 조건에 맞는 )",
      "hasPreviousPage": "이전페이지가 있는지에 대한정보",
      "hasNextPage": false
    }
  }
}

이렇게 데이터 필드에 결괏값 배열이 채워지고

메타 정보와 같이 나오게 된다

또 중요한게 결과가 없을 때에도 null 이 아닌 빈 배열을 주어야 한다

그래야 프론트에서도 처리하기가 더 수월하다

관리자 페이지에서 구현된 모습

생각보다 ORM 동작 원리에 대해 빠삭하게 알아야하고

쿼리 빌더로 쿼리 날리는 것까지 열심히 공부해야했던 구현이었다

그래도 막상 구현해보니 재미있었다

실력이 쑥쑥 늘어나는 느낌

[Gosrock/Nestjs] Guard 사용중인 Controller 내부 특정 메소드에 모든 접근 허가하기 (NoAuth)

gengminy — Wed, 17 Aug 2022 13:09:47 +0900

고스락 티켓 예매 페이지 22th 의 일부인

@NoAuth 데코레이터 구현에 관한 글입니다

우선 이 글은 Nestjs 에서

AuthGuard 등의 Custom Guard 구현에 대해 알고 있다고 가정하고 작성했습니다

Reference

Guards - https://jakekwak.gitbook.io/nestjs/overview/guards

문제 상황

우선 고스락 티켓 프로젝트에서는 AccessTokenGuard 라는 커스텀 가드를 구현했고

이는 Role 기반으로 엑세스 토큰에서 유저와 그 권한을 뽑아와서

해당 요청 메소드에 접근 권한이 있는지 확인하고 접근 인가 / 불가 처리를 하는 것이다

자세한 것은 고티켓 팀장님의 포스팅을 참고하십쇼

https://devnm.tistory.com/16?category=1258201

[고스락 티켓 2.0] nest js 유저 role 기반 api 인가

어노테이션과 메타데이터를 이용해서 , 유저가 Admin인지 일반 User인지에따른 api 인가를 설정해보도록 하자. 이글을 통해서 얻어갈 수 있는점 nestjs SetMetadata 를 통해서 어노테이션과, 메타데이

devnm.tistory.com

tickets.controller.ts

@ApiTags('tickets')
@ApiBearerAuth('accessToken')
@Controller('tickets')
@UseGuards(AccessTokenGuard)
export class TicketsController {
  constructor(private ticketService: TicketsService) {}
  ...
  ...
 }

내가 맡았던 구현 부분 중 티켓 컨트롤러의 예시

@UseGuards 데코레이터를 통해 구현해둔 AccessTokenGuard 를 사용하도록 처리했다

문제는 이렇게 할 경우 중간에 특정 메소드만 권한을 부여하기가 어렵다는 것이다

사실 어렵지는 않지만

전역 가드를 떼어낸 후에 요청에 권한이 필요한 각 메소드마다 다시 가드를 붙이는 식으로

코드 구조가 쓸데없이 난잡해지고 귀찮아진다

개발자가 제일 싫어하는 구조? 라고 해야되나

그래서 나온 해결 책은 구조는 그대로 두되

새로운 데코레이터를 만드는 것이다

@NoAuth

NoAuth.guard.ts

import { SetMetadata } from '@nestjs/common';

export const NoAuth = () => SetMetadata('no-auth', true);

데코레이터를 하나 만드는 방법은 어렵지 않다

인자로 받은 애들을 특정 이름의 메타데이터로 변환 시켜주면 된다

이제 특정 메소드에 @NoAuth() 를 붙여주게 되면

해당 메소드의 메타데이터로 'no-auth': true 라는 값이 추가된다

코드 수정

AccessToken.guard.ts

@Injectable()
export class AccessTokenGuard implements CanActivate {
  constructor(private authService: AuthService, private reflector: Reflector) {}

  canActivate(
    context: ExecutionContext
  ): boolean | Promise<boolean> | Observable<boolean> {
    //@NoAuth 사용시 해당 부분에서 AccessTokenGuard 사용 해제시킴
    const noAuth = this.reflector.get<boolean>('no-auth', context.getHandler());
    if (noAuth) {
      return true;
    }
    const request = context.switchToHttp().getRequest();
    return this.validateRequest(request, context);
  }

  private async validateRequest(request: Request, context: ExecutionContext) {
  ...
  ...
  ...
}

이제 프로젝트에서 사용중인 AuthGuard 라던지,,,

여기서는 AccessTokenGuard 같이 내가 사용중인 가드의 코드를 약간만 수정하면 된다

Nestjs 에서 커스텀 가드는 반드시 CanActivate 를 구현해야 한다

가드는 특정 요청을 가로챈 후에

CanActivate 의 값이 true 이면 요청을 승인하고 그렇지 않으면 거부한다

이제 ExecutionContext 에서 getHandler 로

AccessTokenGuard를 사용중인 컨트롤러에서 메소드의 참조값을 가져온다

이후 리플렉터로 여기서 우리가 구현했던 메타데이터인 'no-auth' 값을 뽑아온다

getHandler 로 가져온 메소드가 @NoAuth() 데코레이터를 사용중이라면

'no-auth': true 일 것이고 그렇지 않다면 undefined, 즉 false 이다

'no-auth': true 이면 가드를 즉시 통과시키고

그렇지 않다면 원래처럼 가드에서 인증을 처리하면 된다

NoAuth 적용

tickets.controller.ts

...
  @ApiOperation({
    summary: '[랜딩페이지] 티켓 개수를 반환한다'
  })
  @ApiResponse({
    status: 200,
    description: '요청 성공시',
    type: TicketCountDto
  })
  @NoAuth()
  @Get('/count')
  async getTicketCount() {
    const count = await this.ticketService.countTicket();
    return { count: count };
  }
...

@NoAuth() 를 필요로 하는 메소드에 적용시켰다

이 메소드는 GET /count 요청을 날렸을 때

DB 내부에 몇 장의 티켓이 있는지 반환해주는 메소드이다

랜딩페이지에서 티켓이 몇 개 주문됐는지 보여줄 필요가 있는데

로그인하지 않은 사용자도 이를 볼 수 있어야 하기 때문에 구현하게 되었다

바로 이 부분을 위해서...

구현은 알고보면 매우 간단하지만

Nestjs 의 가드와 데코레이터의 동작 원리를 이해하지 못했다면 상당히 복잡해 보일 것이다

아무쪼록 더 까먹기 전에

얼른 구현하면서 공부했던 것들을 정리해야겠다

사이트가 궁금하다면~~~

https://gosrock.band/

고스락 티켓

22번째 정기공연 [We are GOSROCK, Invites you]

gosrock.band

[Spring] Swagger 연동 시 Unable to infer base url 접속 에러 (ResponseBodyAdvice)

gengminy — Thu, 11 Aug 2022 21:25:27 +0900

Unable to infer base url. This is common when using dynamic servlet registration or when the API is behind an API Gateway. The base url is the root of where all the swagger resources are served. For e.g. if the api is available at http://example.org/api/v2/api-docs then the base url is http://example.org/api/.
Please enter the location manually:

스웨거 사용 중인 스프링 부트 서버에서

기능 업그레이드 중 갑작스럽게 나타난 에러

원래는 이런 메세지 안떴는데 갑자기 떴다

구글링해도 다 뻔한 소리들 뿐이라서 좀 헤맸는데

다행스럽게 원인을 찾아냈다

Project Dependency

...
	id 'org.springframework.boot' version '2.7.1'
...
...
	implementation 'io.springfox:springfox-boot-starter:3.0.0'
	implementation 'io.springfox:springfox-swagger-ui:3.0.0'
...

Spring Boot 2.7.1 그리고 Spring fox 3.0 사용 중이다

다운 그레이드를 하면 된다 안된다 말도 있는데 설정만 잘해주면 상관이 없다

설정 파일

SwaggerConfig.java

@Configuration
@EnableWebMvc
public class SwaggerConfig {

    private ApiInfo swaggerInfo() {
        return new ApiInfoBuilder()
                .title("HIFI Api Docs")
                .version("0.0.1")
                .description("HIFI Api 문서입니다")
                .build();
    }

    @Bean
    public Docket swaggerApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .securityContexts(Arrays.asList(securityContext()))
                .securitySchemes(Arrays.asList(apiKey()))
                .ignoredParameterTypes(AuthenticationPrincipal.class)
                .consumes(getConsumeContentTypes())
                .produces(getProduceContentTypes())
                .apiInfo(swaggerInfo()).select()
                .apis(RequestHandlerSelectors.basePackage("Backend.HIFI"))
                .paths(PathSelectors.any())
                .build();
    }

    private SecurityContext securityContext() {
        return SecurityContext.builder()
                .securityReferences(defaultAuth())
                .build();
    }
    private List<SecurityReference> defaultAuth() {
        AuthorizationScope authorizationScope = new AuthorizationScope(
                "global",
                "accessEverything"
        );
        AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
        authorizationScopes[0] = authorizationScope;
        return Arrays.asList(new SecurityReference("Authorization", authorizationScopes));
    }
    private ApiKey apiKey() {
        return new ApiKey("Authorization", "X-AUTH-TOKEN", "header");
    }
    private Set<String> getConsumeContentTypes() {
        Set<String> consumes = new HashSet<>();
        consumes.add("application/json;charset=UTF-8");
        consumes.add("application/x-www-form-urlencoded");
        return consumes;
    }

    private Set<String> getProduceContentTypes() {
        Set<String> produces = new HashSet<>();
        produces.add("application/json;charset=UTF-8");
        return produces;
    }
}

설정 파일도 이상이 없다

해결 방안 1 - 스프링 시큐리티 설정

SecurityConfiguration.java

@EnableWebSecurity
@RequiredArgsConstructor
@Configuration
public class SecurityConfiguration {
    private static final String[] SwaggerPatterns = {
            "/swagger-resources/**",
            "/swagger-ui.html",
            "/v2/api-docs",
            "/webjars/**"
    };
    
    ...
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                ...
                ...
                .antMatchers(SwaggerPatterns).permitAll()
                ...
                ...

                http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
                return http.build();
    }

만약 스프링 시큐리티를 사용 중이라면

스프링 시큐리티 설정 파일에서 Swagger 가 사용 중인 url에서

보안 설정을 끄는 방법이 해결 방안 중 하나이다

저 위에 있는 4가지 url 패턴을 스프링 시큐리티에서 허용해주면 된다

"/swagger-resources/**",
"/swagger-ui.html",
"/v2/api-docs",
"/webjars/**"

하지만 보안 설정을 해줬음에도 오류는 사라지지 않아서 다시 검색하다가

해결책을 발견했다

해결 방안 2 - @ControllerAdvice 설정

https://stackoverflow.com/questions/64473435/controlleradvice-does-not-allow-swagger-ui-to-be-displayed

@ControllerAdvice does not allow Swagger UI to be displayed

I just add a GlobalExceptionHandler with @ControllerAdvice and when i try to access Swagger UI at http://localhost:8080/swagger-ui/index.html?configUrl=/v3/api-docs/swagger-config#/ a get a message...

stackoverflow.com

ResponceAdvice.java

@RestControllerAdvice                                                                   
public class ResponseAdvice implements ResponseBodyAdvice<Object> {                     
                                                                                        
    @Override                                                                           
    public boolean supports(                                                            
            MethodParameter returnType,                                                 
            Class<? extends HttpMessageConverter<?>> converterType)                     
    {                                                                                   
        return true;                                                                    
    }                                                                                   
                                                                                        
    @Override                                                                           
    public Object beforeBodyWrite(                                                      
            Object body,                                                                
            MethodParameter returnType,                                                 
            MediaType selectedContentType,                                              
            Class<? extends HttpMessageConverter<?>> selectedConverterType,             
            ServerHttpRequest request, ServerHttpResponse response)                     
    {                                                                                   
        if (body instanceof ErrorResponse)                                              
            return ResponseUtil.onError((ErrorResponse) body);                          
        return ResponseUtil.onSuccess(body);                                            
    }                                                                                   
}

모든 문제는 바로 이 ResponseBodyAdvice의 구현체로

@RestControllerAdvice 를 추가해서 발생했다

글로벌 익셉션 핸들러와 글로벌 리스폰스 핸들러를 구현한 이후부터 이 문제가 발생해서

바로 띠용했다

이유는 스웨거 응답까지 이 글로벌 리스폰스 핸들러를 거쳐서 가기 때문에

충돌이 발생하는 것이다

편하려고 구현한 controller advice 에 뒷통수를 세게 맞았다

해결책 중 하나는 basePackage를 설정해서

컨트롤러 범위를 지정해주는 것이다

@RestControllerAdvice(basePackages = {"Backend.HIFI.controller"})
public class ResponseAdvice implements ResponseBodyAdvice<Object> {
	...
}

이렇게 스웨거 설정 파일이 없는 디렉토리만 지정해주면 잘 된다

하지만 나는 도메인 기반 디렉토리 구조를 사용 중이라

더 좋은 해결방안을 고민해봐야겠다

[Spring] 스프링 시큐리티로 CORS와 preflight 설정하기

gengminy — Thu, 11 Aug 2022 15:29:27 +0900

스프링 시큐리티로 CORS 설정 삽질해서 해결한 과정을 올려본다

사실 결론부터 말하자면 설정은 몇 줄 빼고 아주 잘 되어있었고

도커 이미지 태그가 달라져서 갱신이 안됐던거였다 ^^^^^;;;

로컬 환경에서는 너무나도 잘 되다가 EC2에 띄웠을 때만

자꾸 계속 preflight 과정에서 CORS 이슈가 생겨서 무한 삽질을 하고 있었다

그러다가 도커 컴포즈 파일을 봤는데

도커 이미지 태그가 바뀐 걸 보고 아,,, 한숨밖에 안나왔다

그 과정에서 CORS 관련 공부는 된 거 같아서 긍정적으로 생각할란다

문제 상황

주니어 개발자들을 벌벌 떨게 만드는 무시무시한 CORS 에러

Access to XMLHttpRequest at '{SERVER}' from origin '{ANOTHER ORIGIN}' has been blocked by CORS policy: Response to preflight request doesn't pass access control check: No 'Access-Control-Allow-Origin' header is present on the requested resource.

특히 Postman 으로 API 요청을 보냈을 때는 매우 잘되는데

막상 실제 리액트 앱을 만들어 요청했을 때 이 에러가 발생하는 경우가 있다

나도 그랬다

이것도 브라우저에서 보내는 Preflight 요청 때문이었다 (후술)

CORS ?

Cross Origin Resource Sharing 의 약자

하나의 도메인에서 다른 도메인의 리소스에 접근할 수 있게 해주는 보안 메커니즘

동일 출처 정책(SOP), 즉 프로토콜과 호스트명, 포트가 같은 출처의 리소스에만 접근할 수 있도록 제한하는 정책 때문에 등장했다.

서버 사이드 렌더링으로 자원을 뿌려줄 때는 신경쓸 일이 거의 없지만

요즘에는 API 서버와 클라이언트(리액트나 뷰)를 분리하기 때문에 자주 발생하는 에러이다,,,,

CORS 에러를 해결하기 위해서는

API 서버에서 클라이언트 URL에 대한 리소스 참고를 허용하도록

헤더에 "Access-Control-Allow-Origin" 값을 넣어 응답을 해줘야 한다.

하지만 이 헤더를 보내 해결할 수 없는 경우가 몇 가지 있는데,

GET, POST, HEAD 를 제외한 메소드를 사용
Accept, Accept-Language, Content-Language, Content-Type, DPR, Downlink,
Save-Data, Viewport-Width, Width 를 제외한 헤더를 사용
Content-Type 에서 application/x-www-form-urlencoded, mulitpart/form-data, text/plain 이외의 것을 사용

특히 2번과 3번에서 문제가 되는데

JWT 방식으로 로그인을 구현할 때 X-AUTH-TOKEN 또는 Authorization 헤더를 사용하고

Content-Type 으로 application/json 을 보내는 경우가 많기 때문이다

Preflight

"Access-Control-Allow-Origin" 헤더로 해결할 수 없는 경우

사이트가 안전한지 확인하기 위해 간을 보는데

예비 요청으로 OPTIONS 메서드를 먼저 보내서 판단한 후 본 요청을 보내게 된다

이것이 바로 preflight 요청이다

아까 만났던 에러는 바로 이 preflight 요청을 서버에서 처리하지 못해서

내 요청이 팅겨져 나간 것이다

그러니까 결론적으로는 서버에서 preflight 요청을 처리할 수 있도록

OPTIONS 메서드를 허용해주어야 한다.

스프링 시큐리티 설정

SecurityConfiguration.java

@EnableWebSecurity
@RequiredArgsConstructor
@Configuration
public class SecurityConfiguration {
    private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
    private final JwtAuthenticationFilter jwtAuthenticationFilter;
    private final JwtAccessDeniedHandler jwtAccessDeniedHandler;


    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .cors().configurationSource(corsConfigurationSource())
                .and()
                .csrf().disable()
                //예외처리 핸들러
                .exceptionHandling()
                .authenticationEntryPoint(jwtAuthenticationEntryPoint)
                .accessDeniedHandler(jwtAccessDeniedHandler)
                .and()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .httpBasic().disable()
                //권한이 필요한 요청에 대한 설정
                .authorizeRequests()
                .requestMatchers(CorsUtils::isPreFlightRequest).permitAll()
                .antMatchers("/admin/**").hasAuthority("ROLE_ADMIN")
                .antMatchers("/user/**").authenticated()
                .anyRequest().permitAll()
                .and()
                .headers().frameOptions().disable();

                http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
                return http.build();
    }

    /** cors 설정 bean */
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();

        configuration.addAllowedOriginPattern("*");
        configuration.addAllowedHeader("*");
        configuration.addAllowedMethod("*");
        configuration.addExposedHeader("x-auth-token");
        configuration.setAllowCredentials(true);
        configuration.setMaxAge(3600L);

        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

스프링 MVC 말고 스프링 시큐리티를 사용중이라면

CORS 관련 설정을 전역적으로 할 수 있다

간혹 Controller 단에서 @CrossOrigin 에노테이션 박아서 사용하는 코드를 많이 보는데

별로 좋은 방법은 아니라고 생각한다

여기서 핵심은 시큐리티 필터의 허용 Request 에 PreFlight 요청을 추가하는 것이다

...
.authorizeRequests()
.requestMatchers(CorsUtils::isPreFlightRequest).permitAll()
...

나는 CorsUtils 클래스에서 가져왔는데

HttpMethod.OPTIONS 로 빼서 가져와도 된다

이후 CorsConfigurationSource 빈에서 CORS 관련 설정을 해주면 끝이다

...
        configuration.addAllowedOriginPattern("*");
        configuration.addAllowedHeader("*");
        configuration.addAllowedMethod("*");
        configuration.addExposedHeader("x-auth-token");
        configuration.setAllowCredentials(true);
        configuration.setMaxAge(3600L);
...

스프링 최신 버전에서는

addAllowedOrigin 과 setAllowCredentials(true)를 같이 사용할 수 없다고 오류가 뜬다

에러 메세지 그대로 addAllowedOriginPattern 으로 수정해주면 된다

배포 이후 프론트단 리액트앱에서 axios 요청 날리니까 정상적으로 되는 모습

서버 도커 이미지 제대로 풀 해오니까 잘 되더라

이상 스프링 시큐리티 CORS 와 Preflight 관련한 삽질의 흔적이었습니다

[React] 로컬 환경에서 CORS 이슈 임시로 해결하기 + 스프링 CORS 설정

gengminy — Wed, 10 Aug 2022 19:38:40 +0900

백엔드와 프론트엔드를 동시에 만지는 중이라서

결국 손 놨던 리액트까지 다시 공부중이다

회원가입 + 로그인 로직을 건드리는 중인데

분명 백엔드 서버에서 CORS 설정을 해놨는데도 자꾸 팅기는 것이다

그래서 적어보는 프론트 단에서 CORS 이슈 해결하는 방법

✨ 개발 환경

Spring Boot
React

CORS ?

Cross Origin Resource Sharing 의 약자

하나의 도메인에서 다른 도메인의 리소스에 접근할 수 있게 해주는 보안 메커니즘

동일 출처 정책(SOP), 즉 프로토콜과 호스트명, 포트가 같은 출저의 리소스에만 접근할 수 있도록 제한하는 정책 때문에 등장했으며 현재는 다른 서버에서 제공하는 API를 사용하는 일이 많아 더욱 더 필요하게 되었다

웹 개발을 처음 시작하는, 특히 프론트에게 있어서 지옥을 보여주는 메세지

보통 백엔드 서버 쪽에서 먼저 이 CORS를 허용해둬야

axios나 ajax를 이용한 API 통신이 가능하다

스프링 부트 서버에서 CORS 설정

SecurityConfiguration.java

public class SecurityConfiguration {
    private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
    private final JwtAuthenticationFilter jwtAuthenticationFilter;
    private final JwtAccessDeniedHandler jwtAccessDeniedHandler;


    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .cors().and()
                ...
                ...
                return http.build();
    }

    /** cors 설정 configuration bean */
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();

        //모든 ip에 응답 허용
        configuration.addAllowedOriginPattern("*");
        configuration.addAllowedMethod("*");
        configuration.addAllowedHeader("*");
        //내 서버의 응답 json 을 javascript에서 처리할수 있게 하는것(axios 등)
        configuration.setAllowCredentials(true);
        configuration.setMaxAge(3600L);

        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

스프링 시큐리티를 사용한다면 해줘야하는 시큐리티 필터 설정

이곳에서 HttpSecurity의 CORS 사용 설정을 허용해준다

또 CorsConfigurationSource 빈을 하나 만들어 설정해준다

이 방법은 상당히 안좋은 방법이긴 하다

왜냐면 모든 Origin 에 대하여 리소스 공유를 허용한 것이기 때문이다

서버 개발 시 급하면 와일드카드로 전체 허용하는 경우가 많다

실제 배포시에는 ~~addAllowedOrigin~~ 에 내 프론트 서버 Origin 만 허용해주는 게 옳다

(스프링 업데이트 되면서 addAllowedOrigin 이랑 setAllowCredentials 를 같이 사용할 수 없다

addAllowedOriginPattern으로 사용하자)

그외 백엔드에서 설정하는 자세한 방법은 여기로

리액트에서 CORS 설정

하지만 나의 경우 이렇게 설정하더라도 CORS 이슈로 Axios 요청이 계속 거부되었다

이를 임시로 해결하는 방법이 있는데

package.json 에 프록시 설정을 해주는 것이다

package.json

{
  ...
  "proxy": "https://api.examplesite.net"
}

proxy를 추가해주고 http 통신을 할 사이트 도메인을 적어준다

api.js

import axios from 'axios';

const AuthApi = {
  requestJoin: async () => {
    const data = await axios.get('/join', {});

    console.log(data);
    return data;
  },
};

export default AuthApi;

콘솔 찍어보고 테스트를 해본다

CORS 이슈가 해결되었다

서버로부터 올바른 응답을 받았다

응답 헤더에 아까 스프링 서버에서 설정해둔 CORS 관련 설정도 같이 있다

끗

(수정) 위 방법은 로컬 개발환경에서만 가능하다

실제 AWS 서버 같은데에 올리면 다시 CORS 이슈가 발생한다

그리고 사실 CORS는 백엔드에서 수정해주는게 거의 맞다

[AWS/Docker/Nginx] 단일 서버에서 도메인별 서비스 제공하기

gengminy — Wed, 10 Aug 2022 16:17:00 +0900

처음엔 뭔 괴상한 기둥이 있길래 놀랐었다 AWS는 늘 이런 이미지를 쓴다

분명 세팅 잘 했는데도 서브도메인이 모두 같은 포트로 넘어가서

하루 종일 끙끙대다가 도움을 받아서 겨우 해결한 문제

사실 설정값 문제는 없었지만

docker-compose 로 이미지 빌드가 제대로 안되어서

이전 설정값으로 계속 사용중이었음 ^^;;;

아무튼 고쳤으니까 블로그 정리하는 김에 적어봅니다

작업 환경

AWS EC2 + ELB
Docker
Nginx
Spring boot
React

프로젝트 구조

도커 컴포즈 세팅

docker-compose.yml

version: "3.7"
services:

# redis 설정
  redis:
    image: "redis:alpine"
    network_mode: "host"

# 서버 설정
  backend:
    image: gengminy/hifi-dev:dev
    container_name: backend
    network_mode: "host"
    env_file:
      - .env

# 리액트 설정
  frontend:
    image: gengminy/hififront:main
    container_name: frontend
    network_mode: "host"

# nginx 설정
  nginx:
    depends_on:
      - backend
      - frontend
      - redis
    network_mode: "host"
    restart: always
    build:
      dockerfile: Dockerfile
      context: ./nginx

EC2 서버에 배포용으로 올라가있는 도커 컴포즈 파일

네트워크 모드를 기본 브릿지가 아닌 호스트 모드로 사용하여

EC2 인스턴스에서 localhost로도 각 컨테이너에 접근할 수 있다

각 컨테이너의 포트는 이미지를 만들었을 때 사용한 포트 설정을 따라간다

예를 들어 리액트 이미지를 만들때 포트가 3000번으로 세팅되어 있다면

EC2 인스턴스에서도 localhost:3000 으로 리액트 컨테이너에 접근할 수 있다

Nginx는 배포 레포지토리에 default.conf 파일과 도커파일을 내장시켜서

도커 컴포즈가 수행될 때 빌드되도록 했다

여담으로 이 Nginx 빌드하는 과정 때문에 장장 한나절을 삽질해버렸다

이런식으로 세팅했을 때, Nginx 설정 파일을 건드렸다면

docker-compose up --build 를 통해 이미지를 다시 생성해주자 ^^

Nginx 세팅

default.conf

server{
    listen 80;
    server_name hifihifi.site;
    location / {
        proxy_pass http://localhost:3000;
        proxy_redirect     off;
        proxy_set_header   Host $host;
        proxy_set_header   X-Real-IP $remote_addr;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

server{
    listen 80;
    server_name api.hifihifi.site;
    access_log  /var/log/nginx/access.log  backend;

    location / {
        proxy_pass http://localhost:8000;
        proxy_redirect     off;
        proxy_set_header   X-Real-IP $remote_addr;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

server{
    listen 80;
    server_name admin.hifihifi.site;
    location / {
        proxy_pass http://localhost:3100;
        proxy_redirect     off;
        proxy_set_header   Host $host;
        proxy_set_header   X-Real-IP $remote_addr;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

모든 요청은 EC2 인스턴스의 80번 포트로 들어오게 된다

443번 포트를 사용하는 HTTPS 요청도 ELB 앞단에서 80번 포트로 포워딩 해주었다

각 요청은 호스트 헤더에 포함된 도메인 이름을 통해

EC2의 각 서비스별 포트로 포워딩 시켜준다

이렇게 하면 장점이 인바운드 규칙에

3000, 8000, 3100번 포트와 같은 애들을 노출시키지 않아도 되어서

보안 설정에 유리한 점도 있고 무엇보다도 찝찝하지 않다

(인바운드는 서버에 들어오는 요청, 아웃바운드는 서버에서 나가는 응답)

이렇게 설정한 다음에 꼭 도커 빌드를 통해 이미지를 새로 만들어주자

까먹었다가 또 삽질하지 말구,,,

Route 53 세팅

이미 Route 53에 도메인 등록을 했다고 가정하고

생성했던 레코드에 들어가서 서브도메인 자리에 서브도메인 입력

서브 도메인을 등록해주면 하나의 도메인을 가지고

****.com

api.****.com

admin.****.com

이런 식으로 사용할 수 있다

만약 다른 사이트로 단순 라우팅을 해주는거라면

값에다가 해당 서비스의 CNAME 이나 IP 등을 입력

필자 같은 경우는 서버 설정에 로드 밸런서가 앞단에 있기 때문에

해당 로드 밸런서로 라우팅 해주면 된다

별칭 켜주고 로드 밸런서 등록

레코드 생성을 눌러서 등록 완료하고 몇 분 기다리면 라우팅이 된다

이렇게 하면 단일 EC2 서버에서 여러 서비스를 제공할 수 있으니

알아두면 많은 도움이 될 거 같다

[AWS] Elastic Load Balancer(ELB)로 https 설정하기

gengminy — Tue, 9 Aug 2022 21:55:50 +0900

웃고 있는게 조금이라도 실수하면 바로 과금을 때려버리겠다는 사악한 미소 같다

도메인 구매해서 백엔드 서버 연결 완료한 이후

프론트까지 같이 연결할 이유가 생겼다

서브도메인 설정해서 내부에서 서비스별 포트포워딩 해주려고 했는데

자꾸 잘 안되길래 https 설정이 안되어서 그런 거 같아

마침 설정하는 김에 블로그 정리까지 시작

HTTPS

HTTP Secure 의 약자로 HTTP 프로토콜을 암호화한 버전이다.

SSL이나 TLS를 이용해서 클라이언트와 서버 간의 모든 커뮤니케이션을 암호화하여

민감한 정보를 서로 안전하게 주고 받도록 해준다

그래서 가끔 HTTPS 지원 안하고 HTTP만 사용하는 웹사이트들은

보안오류 뜨면서 접근을 차단하는 경우가 꽤 있다

HTTPS 설정이 되어있다면 이렇게 URL 옆에 자물쇠가 뜬다 (크롬 기준)

✨ SSL 인증서 발급

보통 HTTPS를 사용하기 위해 SSL(Secure Socket Layer)을 발급 받는다

보통 공인 기업 CA(Certificate Authority)에서 발급해주며

대칭키와 공개키 방식을 동시에 사용한다

클라이언트와 서버는 SSL 핸드쉐이크를 통해 HTTPS 통신을 시작한다

이 SSL 인증서를 발급 받아야 HTTPS를 사용할 수 있는데

사설 기관은 유료인 곳이 많다

AWS 서비스를 사용할 경우 무료로 발급받을 수 있다

다만 이 인증서는 AWS 내에서만 사용가능하다

AWS Certificate Manager (ACM) 으로 이동

인증서 -> 요청

퍼블릭 인증서 요청 -> 다음

내가 등록해둔 도메인 입력

*.example.com 이런식으로 와일드카드를 매치하면

서브도메인까지 같이 등록해준다

검증 방법은 DNS 검증으로

사진은 이미 발급된 인증서이지만

발급 받은 인증서로 들어가면 검증 보류중이라고 뜰 것이다

도메인 -> Route 53에서 레코드 생성 선택

CNAME 을 Route 53에 등록해주면 바로 사용할 수 있다

ELB 생성 및 설정

EC2 Console -> 로드 밸런싱 -> 로드밸런서 -> 로드 밸런서 생성

Application Load Balancer 선택

로드 밸런서는 AWS 가입 후 1년 간 월 750시간 무료다

EC2 랑 기준은 똑같다

프리티어 기준 중 ELB

이름 예쁘게 지어주고

우리는 http로 들어오는 트래픽에 대해 처리를 해주어야 하니까 Internet-facing

가용 영역 서브넷을 두 개 이상 선택해서 활성화

보안 그룹 선택

로드밸런서 용으로 따로 파줘도 되고

원래 설정 있으면 그거 써도 된다

대신 새로 만들 경우 80번 포트와 443번 포트를 오픈해야한다

HTTP 와 HTTPS 를 로드밸런서에서 오픈

그리고 타겟 그룹을 지정해야 하는데

인스턴스로 쏴주는게 목적이니까 인스턴스 선택

이름 예쁘게 지어주고

HTTP로 포트 지정

즉 이 그룹에 속한 인스턴스의 80번 포트로 요청을 처리하겠다는 의미

해당 인스턴스 선택하고 포트를 지정

pending 시켜주고 Create target group 눌러주면 설정 끝

오른쪽에서 아까 만들어준 SSL 인증서를 선택할 수 있는데

그거 골라준다

Create Load balancer

다시 로드 밸런서 메뉴에서 리스너 탭 -> HTTP: 80의 규칙 보기 선택

HTTPS 포트인 443으로 리디렉션 시킴

리스너 규칙에서 포트포워딩, HTTP 고정 응답, 특정 IP만 허용 등등

많은 것을 처리할 수도 있다

이번엔 HTTP:443의 규칙으로 들어옴

아까 선택했던 대상 그룹으로 포워딩

Route 53 에서 로드밸런서 등록

이번엔 Route 53으로 이동한다

호스팅 영역

내가 만든 도메인을 선택 -> 레코드 편집

유형A -> 별칭 -> Application/Classic Load Balancer에 대한 별칭 -> 지역 -> 로드밸런서 선택

저장하면 설정이 끝난다

이제 내 인스턴스 IP로 오는 요청은

로드밸런서가 가로채서 처리해줄 것이다

[Github] Github Actions로 CI/CD 개발 주기 자동화하기 - 3 (AWS EC2 서버에서 배포)

gengminy — Mon, 8 Aug 2022 14:53:59 +0900

쉘 스크립트로 AWS까지 조종하는 깃헙 액션

2편에 이어서 3편도 계속

EC2 와 RDS 프리티어를 구매한 후 세팅까지 완료

자세한 세팅은 나중에 시간 나면 올려보도록 하겠읍니다...

작업 환경

Windows + MacOS
AWS EC2 + RDS
Spring Boot (Gradle)
PostgreSQL
Redis
Docker

실제 운영 서버에 배포하기

사실 실 배포는 아니지만 어쨌든 개발 서버와 운영 서버를 통합했기 때문에

운영 서버라고 하는게 맞겠지

Deploy 전용 레포지토리를 만들어주고

프록시를 위한 nginx와 쉘 스크립트를 셋팅해준다

deploy.sh

#!/bin/bash

# Installing docker engine if not exists
if ! type docker > /dev/null
then
  echo "docker does not exist"
  echo "Start installing docker"
  sudo apt-get update
  sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
  sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
  sudo apt update
  apt-cache policy docker-ce
  sudo apt install -y docker-ce
fi

# Installing docker-compose if not exists
if ! type docker-compose > /dev/null
then
  echo "docker-compose does not exist"a
  echo "Start installing docker-compose"
  sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
  sudo chmod +x /usr/local/bin/docker-compose
fi

이건 깃헙 액션에서 제일 처음 실행하는 쉘 스크립트이다

물론 액션에서 바로 명령어를 입력할 수도 있지만

지저분해지니까 따로 빼놓는 게 좋다

나는 도커 이미지를 사용하기 때문에

도커와 도커 컴포즈가 반드시 깔려 있어야한다

따라서 도커와 도커 컴포즈가 설치되어 있는지 확인하고

만약 없으면 다운받아 실행시킨다

도커를 사용하지 않는다면 자바나 파이썬, 노드, npm 등등

셋팅을 확인하는 응용이 가능하겠죠?

deploy.yml

name: Deploy to EC2
on:
  workflow_dispatch:
  push:
    branches:
      - main

jobs:
  build:
    name: Build
    runs-on: ubuntu-latest
    steps:
      - name: checkout
        uses: actions/checkout@master

      - name: create env file
        run: |
          touch .env
          echo "${{ secrets.ENV_VARS }}" >> .env
      - name: create remote directory
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.HOST }}
          username: ${{ secrets.USERNAME }}
          password: ${{ secrets.PASSWORD }}
          script: mkdir -p ~/srv/ubuntu

      - name: copy source via ssh key
        uses: burnett01/rsync-deployments@4.1
        with:
          switches: -avzr --delete
          remote_path: ~/srv/ubuntu/
          remote_host: ${{ secrets.HOST }}
          remote_user: ${{ secrets.USERNAME }}
          remote_key: ${{ secrets.KEY }}
          
      - name: executing remote ssh commands using password
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.HOST }}
          username: ${{ secrets.USERNAME }}
          key: ${{ secrets.KEY }}
          script: |
            sh ~/srv/ubuntu/deploy.sh
            echo "start docker-compose up: ubuntu"
            sudo docker-compose -f ~/srv/ubuntu/docker-compose.yml pull
            sudo docker-compose -f ~/srv/ubuntu/docker-compose.yml --env-file ~/srv/ubuntu/.env up -d

deploy/main 브랜치를 리스닝하는 액션

실 배포 환경을 위한 .env 파일을 만들어주고

리눅스에 원격 로그인 해서 쉘 명령어까지 입력한다

여기서는 secrets에 여러 환경 변수를 입력해두었는데

HOST : EC2 public IP
USERNAME : EC2 username (ubuntu를 사용하기 때문에 기본 ubuntu)
PASSWORD : EC2 password (기본 패스워드는 없어서 사용하고 싶다면
EC2 콘솔에서 password authentication 세팅해줘야함)
KEY : EC2 pem 키 (windows에서는 ppk로 변환되는데 이거는 잘 안먹으니까 조심)

중간에 rsync 를 사용하는게 있는데

이건 github action runner에 복사된 내 deploy 레포지토리의 소스를

remote, 즉 내 EC2 서버로 동기화하여 복사해주는 리눅스 명령어다

따라서 자동으로 내 레포지토리의 소스가 EC2 까지 복사된다

이후 EC2 서버에 복사된 deploy.sh 파일을 실행하고

도커 셋팅을 완료하면 도커 컴포즈로 서버 배포가 완료된다

docker-compose.yml

version: "3.7"
services:

# redis 설정
  redis:
    image: "redis:alpine"
    network_mode: "host"

# 서버 설정
  backend:
    image: gengminy/hifi-dev:dev
    container_name: backend
    network_mode: "host"
    env_file:
      - .env

# nginx 설정
  nginx:
    network_mode: "host"
    depends_on:
      - backend
    restart: always
    build:
      dockerfile: Dockerfile
      context: ./nginx

RDS 를 사용하기 때문에

인메모리 DB인 redis 를 제외한 DB관련 컨테이너는 띄우지 않는다

redis는 jwt 리프레시 토큰을 편하게 사용하기 위해 도입했다

nginx를 이용한 프록시 설정으로

80번 포트에서 서버 포트인 8000번 포트로 포워딩 시켰다

nginx는 도커 파일과 default.conf 파일을 따로 두어서 빌드시켰다

단일 서버를 띄우기 때문에 편하게 사용하고자

network_mode 를 host 로 두었다

기본 네트워크 모드는 bridge라서

컨테이너가 독립적으로 존재하는 네트워크를 구성하는데

host로 두게 되면 호스트의 네트워크를 각 컨테이너가 사용하게 된다

이렇게 쓰면 편한게 localhost로도 각 컨테이너에 접근이 가능하다

default.conf

server{
    listen 80;
    server_name {내 서버 도메인};
    access_log  /var/log/nginx/access.log  backend;

    location / {
        proxy_pass http://backend:8000;
        proxy_redirect     off;

        proxy_set_header   X-Real-IP $remote_addr;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

nginx에 대해서는 따로 설명을 붙이지 않겠다

80번 포트에서 들어온 요청을 서버 8000번 포트로 포워딩 한다

server_name 은 내가 구매해서 사용중인 도메인을 적어주면 된다

배포 확인

빌드에 성공한 모습

이후 EC2 서버에 접속해서

sudo docker-compose logs 찍으면 배포가 되었는지 확인할 수 있다

postman에서 리퀘스트 보내도 잘 오는 것을 확인

DB와 redis 관련 동작까지 잘 된다

이렇게 깃헙 액션을 통해 CI/CD 자동화를 해보았는데

처음에는 되게 막막하고 어렵다 생각했는데

자세하게 알아보니까 꽤 재밌었다

물론 하루종일 이거만 붙잡고 있어서 머리가 꽤 아팠는데

아마도 성장통이지 않을까

Series

[Github] Github Actions로 CI/CD 개발 주기 자동화하기 - 2 (스프링 Gradle 빌드 + 도커 푸시)

gengminy — Mon, 8 Aug 2022 14:19:18 +0900

쓰면 쓸수록 생각보다 재미있는 깃헙 액션

서버를 어떻게 효율적으로 띄울까 하다가 여러 방식을 찾아보았는데

개발 서버와 운영 서버를 방식이 가장 일반적이었다

하지만 돈없는 가난한 대학생은 여러 서버를 띄울 형편이 안되니...

로컬에서 테스트 코드까지 빡세게 돌린 것들만

하나의 운영 서버에 띄우기로 결심했다

고로 프론트엔드, 백엔드, 배포 레포지토리 3개로 나누었고

아키텍쳐는 다음과 같다

서비스 아키텍쳐

아직 프론트는 건들지 않아서 백엔드 서버와 배포 단계만 진행중이다

backend/main 브랜치에 push가 일어나면

깃헙 액션을 통해 스프링 도커 이미지를 빌드해 도커 허브에 push 한다

이후 deploy/main 브랜치에 push가 일어나거나, 직접 action 을 실행시키면

배포 쉘 스크립트 및 docker-compose를 통해 배포가 일어난다

그러니까 마지막에 결국 개발자의 승인이 필요한거니까

여기서는 Continuous Deployment 보다는 Continuous Delivery가 맞을 거 같다

AWS S3 나 Github Runner를 이용하면 승인없는 자동배포도 가능한데

이거랑 무중단 배포는 나중에 해봐야지

Github Actions 생성

docker-image-publish.yml

name: Push Image to DockerHub

on:
  push:
    branches: [main]
    # Publish semver tags as releases.
    tags: ['v*.*.*']

permissions:
  contents: read

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      #JDK Setting
      - uses: actions/checkout@v3
      - name: Set up JDK 11
        uses: actions/setup-java@v3
        with:
          java-version: '11'
          distribution: 'temurin'
          
      #Gradle Caching
      - name: Cache Gradle packages
        uses: actions/cache@v2
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: ${{ runner.os }}-gradle-
      
      #Grant gradlew Permission
      - name: Grant execute permission for gradlew
        run: chmod +x gradlew

      #Create dotenv file
      - name: Make env file
        run: |
          touch ./.env
          echo "$ENV_PROPERTIES_DEV" > ./.env
        env:
          ENV_PROPERTIES_DEV: ${{ secrets.ENV_PROPERTIES_DEV }}

      #Gradle Build
      - name: Build with Gradle
        run: ./gradlew build -x test

      #Image Tagging
      - name: Docker meta
        id: docker_meta
        uses: crazy-max/ghaction-docker-meta@v1
        with:
          images: ${{ secrets.DOCKER_REPOSITORY }}/hifi-dev
          tag-semver: |
            {{version}}
            {{major}}.{{minor}}
      #Docker Buildx Setup
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1

      #Login to DockerHub
      - name: Login to DockerHub
        uses: docker/login-action@v1
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      #Docker Build and Push
      - name: Docker build & push
        uses: docker/build-push-action@v2
        with:
          context: .
          file: ./Dockerfile
          platforms: linux/amd64
          push: true
          tags: ${{ steps.docker_meta.outputs.tags }}
          labels: ${{ steps.docker_meta.outputs.labels }}

전체 코드는 이렇다

실행 과정

JDK 11 버전으로 세팅을 시작한다
Gradle Caching 이라는 과정이 있는데 반드시 필요한 것은 아니지만
캐싱 사용 시 성능이 2~30퍼센트 정도 빨라진다
gradlew 빌더를 사용하기 위해 chmod 로 권한을 부여한다
환경변수 파일을 생성한다 secrets 는 레포지토리의 Settings 에서 설정 가능하다. 후술
gradlew 빌드를 진행한다
도커 이미지에 태그를 붙힌다
도커 빌더 셋업
도커 이미지 푸시를 위해 도커 허브에 로그인한다, 비밀번호로 토큰을 사용하는 것을 권장한다
도커 파일을 통해 도커 이미지 빌드를 하고 이것을 내 레포지토리에 푸시한다

Github Actions 실행 및 로그

내 레포지토리 -> Settings -> Security(Secrets) -> Actions 탭에서

깃헙 액션 용 환경 변수를 설정할 수 있다

한번 설정하면 다시 못 보니까 내용을 잘 기억하거나 업데이트를 통해 덮어쓰기 해주어야 한다

가져다 쓸 때는 깃헙 액션 yml 에서 ${{secrets.환경변수이름}} 으로 가져와 쓸 수 있다

특히 EC2 서버 접속을 위한 pem 키 같은 것들을 여기다가 잘 입력해주자

실수로 노출시키면 서버가 공격 당할 수도 있다

main 브랜치에서 변화를 감지하면

이렇게 Actions 탭에서 액션이 실행되는 것을 볼 수 있다

실제 배포 액션 성공한 모습

도커 허브에도 잘 올라간 모습

깃헙 액션이 실행 도중 실패하면 에러 메세지 뜨니까 그것으로 확인 잘 하면 고치기 쉽다

보통 컴파일 에러, Docker hub 로그인 에러, 환경 변수 설정 안해서 생기는 에러 등등

잘 확인해보자

Series

[Docker] docker compose로 다중 컨테이너 연결 시 Connection to localhost:5432 refused 에러

gengminy — Sun, 7 Aug 2022 20:54:02 +0900

도커 컴포즈로 Spring Boot + PostgreSQL 다중 컨테이너를 띄워서 연결하던 중 발견한 오류

일단 결론부터 말하자면 도커에 대한 이해가 얕아서 생긴 오류

알고보면 정말 별 것도 아닌 오류이지만

도커 초심자는 반드시 거쳐가는 오류가 아닐까 싶다..,,

장장 4시간의 삽질

작업 환경

Spring Boot (Gradle)
Redis
PostgreSQL
PgAdmin

원인 찾기

org.postgresql.uti.PSQLException: Conntection to localhost:5432 refused.

Spring에서 PostgreSQL 연결 시 호스트나 포트를 잘못 찾아서 연결할 수 없는 오류이다

말 그대로 db 주소를 잘못 입력했다는 거다

변경 전 파일

docker-compose.yml

version: '3.7'
services:
  app:
    build: .
    container_name: app
    hostname: backend
    env_file:
      - .env
    expose:
      - '8000'
    depends_on:
      - postgres
      - redis

  redis:
    image: redis:alpine
    ports:
      - '6379:6379'

  postgres:
    image: postgres:latest
    container_name: postgres
    restart: always
    ports:
      - '5432:5432'
    env_file:
      - .env
    networks:
      - postgres

  pgadmin:
    links:
      - postgres:postgres
    container_name: pgadmin
    image: dpage/pgadmin4
    ports:
      - '8080:80'
    env_file:
      - .env
    networks:
      - postgres

networks:
  postgres:
    driver: bridge

.env

PORT=8000
...
REDIS_HOST=localhost
REDIS_PORT=6379
POSTGRES_HOST=localhost
POSTGRES_PORT=5432
...

./src/main/resources/application.yml

spring:
  # .env import
  config:
    import: optional:file:.env[.properties]
  # Using POSTGRESQL
  datasource:
    url: jdbc:postgresql://${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
    username: ${POSTGRES_USER}
    password: ${POSTGRES_PASSWORD}
    driver-class-name: org.postgresql.Driver
    ...

장장 4시간을 헤메이다 결국 구글링으로 원인을 찾아냈다

https://www.linuxfixes.com/2021/12/solved-docker-is-server-running-on-host.html

[SOLVED] Docker: Is the server running on host "localhost" (::1) and accepting TCP/IP connections on port 5432?

Issue I am getting issues while setup and run the docker instance on my local system with ...

www.linuxfixes.com

문제는 바로 각 컨테이너가 독립된 상태로 존재하는데

app 이라는 스프링 서버 컨테이너에서 localhost:5432 를 조회하게 되면

자기 자신의 5432 포트를 조회하는 거니까 아무것도 없는 빈 곳을 조회하는 것이다

머리가 상당히 띵했다

그러니까 결국 localhost:5432 가 아니라 postgres:5432 로

postgres 서비스의 5432 포트를 조회해야 db에 접근할 수 있다는 것이다

코드 수정

변경 후 파일

docker-compose.yml

version: '3.7'
services:
  app:
    build: .
    container_name: app
    hostname: backend
    env_file:
      - .env
    expose:
      - '8000'
    depends_on:
      - postgres
      - redis
    networks:
      - postgres

  redis:
    image: redis:alpine
    ports:
      - '6379:6379'

  postgres:
    image: postgres:latest
    container_name: postgres
    restart: always
    ports:
      - '5432:5432'
    env_file:
      - .env
    networks:
      - postgres

  pgadmin:
    links:
      - postgres:postgres
    container_name: pgadmin
    image: dpage/pgadmin4
    ports:
      - '8080:80'
    env_file:
      - .env
    networks:
      - postgres

networks:
  postgres:
    driver: bridge

depends_on 으로 redis 와 postgres 가 먼저 켜진 후에 app을 실행한다

이후 같은 networks 로 묶어서 통신할 수 있도록 해준다

.env

PORT=8000
...
REDIS_HOST=redis
REDIS_PORT=6379
POSTGRES_HOST=postgres
POSTGRES_PORT=5432
...

이후 환경변수의 호스트 이름을

도커 컴포즈 파일에서 정의한 service 이름과 똑같이 매칭해주면 된다

스프링 설정 파일은 건들지 않아도 되었다

매우 잘된다 ^^

이상 도커 컴포즈 삽질의 흔적이었다

막상 삽질했더니 이렇게 하면 안될 거 같아서

postgres docker는 테스트 용으로만 두고 RDS 추가해서 그걸로 설정했다

[Github] Github Actions로 CI/CD 개발 주기 자동화하기 - 1 (깃헙 액션 사용법)

gengminy — Sun, 7 Aug 2022 15:29:01 +0900

CI/CD 툴 중 하나인 Github Actions 를 이용해보자

CI / CD ?

CI (Continuous Integration)

지속적인 통합
[코드작성 -> 테스트 -> 빌드 -> 배포 -> 버그수정] 이라는 일련의 사이클을 단축시키고 자동화시키는 방법

CD (Continuous Delivery 또는 Continuous Deployment)

지속적인 배포
어플리케이션에 적용한 변경 사항을 테스트를 거쳐 레포지토리에 업로드 되는 것
Continuous Delivery 는 마지막 단계인 개발환경에서 운영환경으로의 배포를 개발자가 수동으로 해줌
Continuous Deployment 는 이러한 수동 처리 없이 자동으로 운영환경 배포까지 자동으로 해줌

Github Actions 는 이러한 CI/CD를 가능하게 해주는 툴 중 하나이고

Jenkins, Travis CI, AWS Code Deploy 등등 다양한 툴이 있다

Github Actions 만들기

프로젝트 루트 폴더에서 ./.github/workflows/ 내부에 정의할 수 있다

깃헙 액션 템플릿을 사용할 수도 있는데

레포지토리의 Actions 탭에서 만들거나 깃허브 Marketplace 탭에서 커스텀 액션을 검색할 수도 있다

다양한 템플릿이 있다

템플릿은 이런식으로 기본 셋팅을 포함시켜준다

여기다가 깃헙 액션을 언제 실행할지, 무엇을 실행할지 등을 yml 파일로 정의한다

Github Actions 구조

Workflow > Job > Step > Action 순으로 정의한다

말 그대로 하나의 workflow 안에 여러 개의 job 을 정의할 수 있고

job 내부에도 여러 개의 step .... 이런식으로 세부화된다

찬찬히 뜯어보자

./.github/workflows/gradle-publish.yml

name: Gradle Package

on:
  release:
    types: [created]

jobs:
  build:
  ...

Workflow

하나 이상의 Job 으로 구성되고 이벤트 기반으로 동작하는 절차이다

name : workflow 이름을 정의한다
on : 어떠한 branch에 push 되었을때, 특정한 시간에만 등등.. workflow 가 실행되도록 하는 이벤트를 정의한다
jobs : 하나의 workflow 에서 수행시킬 job을 정의한다. 기본적으로 병렬로 실행된다.

Jobs

하나 이상의 step 으로 구성된 집합이다

하나의 job 은 독립된 runner, 즉 분리되어진 가상 환경에서 실행된다.

기본적으로 workflow는 여러 개의 job을 병렬로 실행시킨다

만약 순차적으로 실행하게 하고 싶다면 의존성을 명시해주어야 한다.

...
jobs:
  build:
    runs-on: ubuntu-latest
    
    strategy:
      matrix:
        os: [ubuntu-latest, windows-2016]
        node-version: [12.x, 14,x]
        
    steps:
      - uses: actions/checkout@v2
      - name: npm install and build webpack
        run: |
          npm install
          npm run build
      #아티팩트를 업로드함
      - uses: actions/upload-artifact@master
        with:
          name: webpack artifacts
          path: public/

  test:
    #의존성 명시, build가 실행된 이후 test가 실행됨
    needs: build
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    #아티팩트를 다운받음    
    - uses: actions/download-artifact@master
      with: 
        name: webpack artifacts
        path: public
    ...

build 이후에 여러 개의 test를 수행해야 한다면 위 코드처럼 분리시킬 수 있다

하지만 각 job은 독립된 runner에서 돌아간다고 했다

따라서 build 라는 job 에서 사용한 빌드된 코드를 test에서 사용할 수 없다 (독립된 공간이므로)

이런 식으로 의존성이 있는 job 은 빌드된 아티팩트를 업로드 하고,

다른 job 에서 내려받는 식으로 사용할 수도 있다

그리고 needs 를 사용하여 순서를 명시해주면 된다

build 또는 test : 하나의 job과 그 이름을 정의한다
runs-on : job이 수행될 os 등의 환경을 정의한다. 여기서는 ubuntu 최신 버전에서 동작하도록 했다
strategy : 매트리스 등을 정의하여 여러 환경에서 동시에 빌드하도록 할 수 있다.
needs : 해당 job 이 끝나면 이 job 을 수행하도록 정의한다
steps : 하나의 job 에서 수행할 step의 집합을 정의한다

Steps

Job 안에서 명령어를 실행시킨다.

action 또는 shell 명령어로 이루어진 집합이다

하나의 job은 같은 runner에서 실행되기 때문에 데이터를 공유할 수 있다

  test:
    ...
    steps:
    - uses: actions/checkout@v2
    - uses: actions/download-artifact@master
      with: 
        name: webpack artifacts
        path: public
    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v1
      with:
        node-version: ${{ matrix.node-version }}
    - name: npm install, and test
      run: |
        npm install
        npm test
      env:
        CI: true

uses : 오픈 소스 커뮤니티에 있는 다른 action를 가지고 와서 실행하는 것
actions/checkout@v2 는 내 레포지토리 환경을 runner 에 복사해서 실행하는 action이므로
내 레포지토리의 코드를 다루는 job 에서는 반드시 사용해야함
with : 각 actions에 의해 정의된 파라미터를 나열한다.
이 변수들은 앞에 INPUT_ 이라는 prefix 가 붙고
대문자로 바뀌어 각 action에 대한 환경변수로 선언된다. (node-version -> INPUT_NODE-VERSION)
env : 각 actions에 필요한 환경 변수를 정의한다.
name : 각 step 의 이름을 정의한다
run : runner에서 실행할 커맨드를 정의한다

Secrets 환경 변수 정의하기

Secret 을 이용해 환경 변수를 전달할 수도 있다

내 레포지토리 -> Settings -> Secrets -> Actions 에서

원하는 환경 변수를 정의

      ...
      - name: Login to DockerHub
        uses: docker/login-action@v1
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_TOKEN }}
      ...

깃헙 액션 yml 파일에서 secrets로 접근 가능하다

Reference

Github Actions Docs - 깃헙 액션 공식 Docs
Github Actions로 개발 주기 자동화 - 애저 듣고보는 잡학지식

GitHub Actions Documentation - GitHub Docs

Automate, customize, and execute your software development workflows right in your repository with GitHub Actions. You can discover, create, and share actions to perform any job you'd like, including CI/CD, and combine actions in a completely customized wo

docs.github.com

Series

[Docker] docker compose 사용해서 다중 컨테이너 띄우기

gengminy — Sun, 7 Aug 2022 00:33:33 +0900

왜 귀여운 고래 어디가고 징징이를 데려왔을까 싶었는데 다중 컨테이너 띄우는걸 잘 표현한 거 같다

Reference

도커, 컨테이너 빌드업! - 이현룡

docker compose 를 사용하는 이유

컨테이너가 늘어나면 늘어날 수록 docker run 으로 실행해야 할 명령어 수가 많아지며
특히 각각의 컨테이너에 설정할 플래그가 많아질수록 더욱 더 복잡해진다
이를 하나로 묶어서 한번에 서비스를 올리고 관리할 수 있도록 해주는 도구가 도커 컴포즈
각 컨테이너는 독립된 기능을 가지고 공통 네트워크로 구성되어 컨테이너 간 통신이 쉽다
다만 다양한 관리 기능은 없어 실제 운영 환경에서는 쿠버네티스를 사용하는 것이 더 좋다

docker compose 파일 작성

루트 폴더에 docker-compose.yml 또는 docker-compose.yaml 파일을 생성한다

도커 컴포즈 파일은 yml(야믈) 코드로 작성해야 한다

yml 파일은 반드시 두 칸의 들여쓰기를 통해 구분이 된다 tab은 안된다

아래는 현재 프로젝트에서 사용중인 개발용 도커 컴포즈 파일 예시이다

docker-compose.yml

version: '3.7'
services:
  redis:
    image: redis:alpine
    ports:
      - '6379:6379'

  postgres:
    image: postgres:latest
    container_name: postgres
    restart: always
    ports:
      - '5432:5432'
    env_file:
      - .env
    networks:
      - postgres

  pgadmin:
    links:
      - postgres:postgres
    container_name: pgadmin
    image: dpage/pgadmin4
    ports:
      - '8080:80'
    # volumes:
    #   - /data/pgadmin:/root/.pgadmin
    env_file:
      - .env
    networks:
      - postgres

networks:
  postgres:
    driver: bridge

version : 도커 컴포즈 버전을 명시한다, 버전에 따라 약간의 기능과 옵션의 차이가 있다
service : 실행시킬 서비스를 정의한다. 컨테이너와 동일하다고 생각하면 편하다
- image : 도커 허브의 공식 이미지를 사용할 경우 지정
- build : Dockerfile 의 경로를 지정한다. 도커 컴포즈 파일과 동일한 경로일 경우 점. 을 찍는다
  - context / dockerfile : 경로가 다를 경우 도커 파일 지정
- container_name : (생략가능) 컨테이너의 이름 지정
- ports : 호스트 포트와 서비스 내부 포트 지정
- expose : 서비스 포트만을 노출
- networks : 최상위 레벨의 networks에 정의된 네트워크 이름을 지정
- volumes : 호스트 디렉토리와 서비스 내부 디렉토리를 연결, 데이터 지속성 설정
- environment : 서비스 내부의 환경 변수 설정
- env_file : 환경변수 파일(.env)을 가져와 환경 변수 지정
- command : 서비스 구동 이후 실행할 명령어
- restart : 서비스 재시작 옵션 (always: 수동 종료 제외하고 항상 재시작, on-failure: 오류 시 재시작)
- depends_on : 서비스 간 종속성 지정, 이 옵션에 지정한 서비스가 먼저 시작됨
network : 해당 이름의 네트워크를 정의한다. 대역은 172.x.x.x 로 할당, 기본 드라이버는 bridge
volume : 최상위 레벨의 볼륨 지정

자주 사용하는 docker compose 명령어

docker-compose 또는 docker compose 를 통해 도커 컴포즈를 실행할 수 있다

docker-compose up : 도커 컴포즈 실행
docker-compose up -d : 백그라운드로 도커 컴포즈 실행
docker-compose down : 컨테이너 서비스, 볼륨, 네트워크를 모두 정지시킨 후 삭제
docker-compose down -v : 외부 볼륨까지 전체 삭제
docker-compose stop {service} : 특정 컨테이너만 중지
docker-compose start {service} : 특정 컨테이너만 시작
docker-compose logs : 어플리케이션 로그 출력
docker-compose logs -f : 실시간 로그 출력
docker-compose ps : 도커 컴포즈에 정의된 모든 서비스 컨테이너 조회
docker-compose config : yml 파일 설정 확인
docker-compose pause : 컨테이너 일시 정지
docker-compose unpause : 컨테이너 정지 해제

docker compose 실행

잘 시작된 모습

터미널이 멈추는 것을 원치 않으면 반드시 -d 플래그를 붙여서

데몬(백그라운드)으로 실행하자

Windows 나 macOS 환경이라면

꼭 Docker Desktop 실행 후에 도커 컴포즈 명령어 입력하시구요

끝

[Docker] Dockerfile 명령어로 스프링 프로젝트 도커 이미지 빌드 및 푸시

gengminy — Fri, 5 Aug 2022 17:32:08 +0900

우영우가 좋아할 만한 귀여운 도커 고래

프로젝트 진행하면서 배포를 직접할 일이 생겼다

보통 잘하는 팀장님이 배포 셋팅을 미리 해줘서 편하게 작업을 했었는데

막상 직접 하려니까 쉬우면 쉽고 어려우면 어려운 복잡한 일이었다

이 글은 도커와 AWS를 공부하면서 참고하기 위해 작성해보는

도커를 이용한 배포 과정, 그 중에서도 Dockerfile 에 대한 작성법이다

Reference

도커, 컨테이너 빌드 업! - 이현룡

Dockerfile

어떠한 컨테이너를 위해 필요한 모든 설정을 기록한 파일

도커 파일을 빌드하면 이미지가 자동으로 생성된다

도커 파일을 통해 특정 컨테이너를 빌드하고 배포하기 위한 과정들을 자동화 할 수 있게 된다

Dockerfile 작성 시 고려할 점

컨테이너 서비스의 장점인 경량 가상화 서비스를 지향하기 위해 최소한의 설정과 구성만을 사용
Dockerfile 명령어 수와 도커 이미지 레이어 수는 동일하다
레이어 수가 늘어나면 빌드 시간이 길어지고 파일 용량이 커지게 된다
따라서 Dockerfile 명령어를 최적화 할 필요가 있다
하나의 어플리케이션은 하나의 컨테이너에 담아 결합성을 낮춘다
Dockerfile은 명령어 단위로 캐싱이 일어난다
이것을 적극 활용하여 빌드 속도를 높힌다
Dockerfile은 이미지 빌드를 시작하면 현재 위치 포함 하위 디렉토리의 모든 것들을 빌드한다
따라서 별도의 작업 디렉토리를 두어 독립된 환경에서 꼭 필요한 파일만 빌드한다

Dockerfile 명령어 리스트

FROM : 생성하려는 이미지의 베이스 이미지 지정, 반드시 입력해야함
_{ex) FROM ubuntu:20.04}
MAINTAINER : 보통 이미지를 빌드한 작성자의 이름 또는 이메일을 입력
_{ex) MAINTAINER gengminy <gengminy@github.com>}
LABEL : 버전, 타이틀, 설명, 라이센스 등 메타 데이터를 입력, 여러 개 입력 가능
_{ex) LABEL description = 'my web service application'}
RUN : 컨테이너 내부에서 실행할 명령어를 지정, 여러 개 입력 가능
_{ex1 shell 방식) RUN apt update
ex2 exec 방식) RUN ["bin/bash", "-c", "apt -y install nginx git vim curl"]}
CMD : 컨테이너가 실행될 때 실행할 명령어, 하나만 입력 가능
_{ex1 shell 방식) CMD nginx -g deamon off
ex2 exec 방식) CMD ["python", "app.py"]}
ENTRYPOINT : CMD 와 마찬가지로 생성된 이미지가 컨테이너로 실행될 때 사용
_{ex) ENTRYPOINT ["npm", "start"]}
COPY : 호스트 환경의 파일이나 디렉토리를 이미지 내부로 복사할 때 사용
빌드 작업 디렉토리 외부 파일은 복사할 수 없다
_{ex) COPY index.html /usr/share/nginx/html}
ADD : 호스트 환경의 파일이나 디렉토리를 이미지 내부로 복사하거나
해당 URL에서 다운로드, 또는 압축파일을 풀어서 추가한다
_{ex1) ADD index.html /usr/share/nginx/html
ex2) ADD http://dockerhub.com/example.tar.gz /app
ex3) ADD web.tar.gz /var/www/html}
ENV : 이미지 내부에 환경 변수를 지정할 때 사용
_{ex) ENV JAVA_HOME /usr/lib/jvm/java-8-oracle}
EXPOSE : 호스트 네트워크를 통해 컨테이너로 들어오는 트래픽을 listening 하기 위한 포트와 프로토콜 지정
_{ex1) EXPOSE 80
ex2) EXPOSE 8000/tcp}
VOLUME : 호스트와 공유하기 위한 컨테이너 볼륨 지정
_{ex) VOLUME /etc/nginx}
USER : 컨테이너 사용자 변경, 기본은 root
_{ex) USER gengminy}
WORKDIR : 컨테이너에서 작업할 경로의 전환을 위한 명령어
_{ex) WORKDIR /app}
ARG : docker build 시점에서 인자 값을 전달하기 위한 명령어
_{ex) ARG db_name ---> docker bulid --build-arg db_name=my_sql_server}
ONBUILD : 현재 이미지가 다른 이미지의 기본 이미지(FROM)로 포함될 경우
다른 이미지가 빌드될 때 실행시킬 명령어 현재 이미지에서는 실행되지 않는다
_{ex) ONBUILD ADD source.tar.gz /usr/share/nginx}
STOPSIGNAL : docker stop 명령어 입력 시 컨테이너에 전달될 signal 지정
_{ex) STOPSIGNAL SIGKILL}
HEALTHCHECK : 컨테이너 프로세스 상태를 체크할 때 작성, 하나만 사용 가능
_{ex) HEALTHCHECK --interval={체크간격(초)} --timeout={타임아웃(초)} --retries={타임아웃회수}}
SHELL : Dockerfile 내부에서 사용할 기본 쉘을 지정
_{ex) SHELL ["bin/bash", "-c"]}

Dockerfile 직접 작성해보기 (Spring Boot Project)

Dockerfile

FROM openjdk:11
EXPOSE 8000
ARG JAR_FILE=build/libs/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

FROM openjdk:11

- 베이스 이미지를 openjdk:11로 지정

EXPOSE 8000

- 8000번 포트를 listening (스프링 프로젝트의 기본 포트는 8080)

ARG JAR_FILE=build/libs/*.jar

- 스프링 프로젝트를 빌드할 때 나오는 결과물을 JAR_FILE 로 지정

COPY ${JAR_FILE} app.jar

- 빌드된 파일을을 app.jar 로 복사

ENTRYPOINT ["java", "-jar", "/app.jar"]

- 생성된 이미지를 컨테이너로 실행하는 시점에 app.jar 실행, 즉 컨테이너 실행과 동시에 서버를 실행함

스프링 프로젝트 Gradle 빌드

./gradlew build -x test

-x test : 테스트 없이 빌드하겠다는 의미

빌드 성공 시 /build/libs 에 .jar 파일이 만들어진다

Dockerfile 빌드

docker  build  [플래그]  이미지명:[태그]  경로|URL|압축파일

[플래그]
-t : tag를 지정하는 옵션
-f : Dockerfile 이외의 다른 파일명을 지정하는 옵션
--platform : 애플 M1의 경우 플랫폼을 linux/amd64 로 지정해주어야 빌드가 됨
이미지명:[태그]
생성할 이미지 이름 및 태그를 지정, 태그는 보통 버전 관리용으로 지정
경로 | URL | 압축파일
디렉토리 경로나 Dokerfile 이 포함된 깃허브 url, 또는 압축파일을 지정한다

예시

docker build -t {username}/{imagename} .

반드시 마지막에 Dockerfile 의 경로를 표시해주어야 한다

여기서는 현재 디렉토리에 Dockerfile 이 있기 때문에 점을 찍는다

만약 Docker hub 에 이미지를 올릴 것이라면

반드시 {username} 에 본인의 유저 이름이 들어가야 한다

아니면 권한 거부가 일어날 것이다

혹시라도 docker deamon is not runnig 오류가 나온다면

docker desktop 을 실행하고 빌드하면 된다

빌드 실행

빌드 완료

Docker image push

빌드한 도커 이미지를 도커 허브에 푸시하는 과정이다

도커 허브 아이디가 없다면 만들어야 한다

https://hub.docker.com/

Docker Hub Container Image Library | App Containerization

We and third parties use cookies or similar technologies ("Cookies") as described below to collect and process personal data, such as your IP address or browser information. You can learn more about how this site uses Cookies by reading our privacy policy

hub.docker.com

docker login

docker login 명령어 실행 후

docker hub 에 로그인 한다

docker push {username}/{imagename}

푸시 완료

리모트 레포지토리에 성공적으로 올라간 모습

나중에 배포 서버에서 도커 허브에 접근하여

이 이미지를 내려받으면 손쉽게 배포 세팅을 끝마칠 수 있다

배포 서버에서 도커 이미지 실행만 하면 되니까 얼마나 편한가

나중에 Github Action 이랑 연동하면

깃헙에 푸시 하자마자 도커 이미지 빌드 및 푸시까지 자동으로 해줄 수 있다

따라하면서 해보니까 꽤 재밌다

끝

[Spring] 스프링 부트 프로젝트에서 dotenv 환경변수 파일 사용하기

gengminy — Wed, 3 Aug 2022 14:12:37 +0900

스프링 프레임워크를 사용하는 웹앱 프로젝트를 진행하면서

환경변수를 저장하기 위한 방법을 검색해보았다

그런데 보통 .env.properties 파일을 만들어서

그 안에 있는 값을 또 프로퍼티 빈을 만들어서 불러오더라

이렇게 하더라도 비밀키 값 같은 거는

.gitignore 에다가 등록을 하면 되지만

다른 언어를 사용하다가 온 입장에서는

굳이 이렇게 해야하나 싶어서 뭔가 답답하다고 해야하나

그래서 이 프로젝트에서는

.env 파일을 사용해서 환경변수를 불러오는 방법을 도입시켜보았다

/.env

PORT=8000
JWT_SECRET_KEY="MYSUPERSECRETJWTKEY"
...

우선 프로젝트 루트 디렉토리에 .env 파일을 만들었다

/.gitignore

...
.env*

git을 사용중이라면 반드시 이 설정 파일을 gitignore에 등록해서

git에 딸려서 리모트 레포지토리에 올라가지 않도록 하자

안그러면 비밀키가 전세계에 노출되는 대 참사가 일어난다 (찬진맨 선생님 죄송해요 ^^)

/src/main/resources/application.yml

server:
  port: ${PORT:8000}

spring:
  # .env import
  config:
    import: optional:file:.env[.properties]
  # Using POSTGRESQL
  datasource:
    url: jdbc:postgresql://${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
    username: ${POSTGRES_USER}
    password: ${POSTGRES_PASSWORD}
    driver-class-name: org.postgresql.Driver

  jpa:
    database: postgresql
    database-platform: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: create
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
        database-platform: org.hibernate.dialect.PostgreSQLDialect

  thymeleaf:
    cache: false
    prefix: classpath:/templates/
    suffix: .html

logging.level:
    org.hibernate.SQL: debug
    org.hibernate.type: trace

우리 프로젝트의 설정 파일이다 yml 형식을 사용중이다

중요한 부분은 저 spring:config:import: 에다 .env 파일을 import 해주어야 한다

  config:
    import: optional:file:.env[.properties]

.env를 .env.properties 로 해석하여 가져오겠다는 뜻이다

optional을 붙여서 .env 파일이 있을 때만 들고오며

없어도 컴파일 오류는 안난다

또한 동일 yml 파일에서 환경변수 값을 읽을 때는

${변수명} 으로 가져오면 된다

  datasource:
    url: jdbc:postgresql://${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
    username: ${POSTGRES_USER}
    password: ${POSTGRES_PASSWORD}
    driver-class-name: org.postgresql.Driver

기본값을 지정하고 싶다면

${변수명:기본값} 이런식으로 콜론을 붙여주면

해당 환경변수가 없을 때 자동으로 기본 값으로 들어가게 된다

server:
  port: ${PORT:8000}

.../JwtTokenProvider

@Slf4j
@Component
public class JwtTokenProvider {
    /** 토큰 비밀 키 */
    @Value("${JWT_SECRET_KEY}")
    private String JWT_SECRET;

	...

마찬가지로 클래스 내에서 읽을 때는 클래스의 제일 바깥 블록 안에다가

@Value 에노테이션을 사용해서 가져온다

아래에 해당 값을 주입시킬 변수도 써주면 된다

스프링 프레임워크 빈 팩토리의 것을 import 해주면 된다

끝

[Gosrock/Nestjs] Socket.io 사용하여 실시간 공연 입장 시스템 구현하기

gengminy — Sat, 30 Jul 2022 18:46:42 +0900

학교 컴공 밴드 동아리 고스락 여름방학 프로젝트인

고스락 티켓 예매 페이지 22th 의 일부인 socket 구현에 대한 글입니다

nestjs + socket.io 를 사용하여 구현하였습니다

Reference

nestjs + socket.io(EventsGateway) - https://www.youtube.com/watch?v=gkJ1N6PDCEc&t=690s

chat app with nestjs - https://www.youtube.com/watch?v=7xpLYk4q0Sg&t=722s

docs nest js (gateway) - https://docs.nestjs.com/websockets/gateways

socket.io 모듈 설치

npm i @nestjs/websockets @nestjs/platform-socket.io --save

gateway 생성

nest g ga socket

socket 모듈 아래에 게이트웨이를 생성한다

socket 모듈 구조

backend
...
└───socket
│   │   socket-admin.gateway.ts
│   │   socket-user.gateway.ts
│   │   socket.guard.ts
│   │   socket-module.ts
│   │   socket-service.ts
└───tickets
│   │   tickets-service.ts
│   │   ...
...

Gateway 구현

유저와 어드민 페이지의 분리를 위해

각 게이트웨이 파일을 네임스페이스 별로 나누었다

SocketUserGateway 와 SocketAdminGateway

콘솔에 찍어서 확인해본 결과 게이트웨이를 나누어 init 해줘도

싱글톤으로 동작하는 듯 보인다

즉 하나의 소켓 서버 아래에서 동작하는 것이다

socket-user.gateway.ts

// @UseGuards(SocketGuard)
@WebSocketGateway({
  cors: {
    origin: '*'
  },
  namespace: '/socket/user' //socket/admin or socket/user
})
export class SocketUserGateway
  implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect
{
  private readonly logger = new Logger(SocketUserGateway.name);
  constructor(
    @Inject(forwardRef(() => TicketsService))
    private ticketsService: TicketsService
  ) {}
  @WebSocketServer() public io: Namespace;

  //interface 구현부

  afterInit(server: Server) {
    this.logger.log('SocketUserGateway Init');
  }

  //티켓 uuid로 존재하는 티켓인지 검사 후 연결
  async handleConnection(@ConnectedSocket() client: Socket) {
    try {
      const ticketUuid =
        process.env.NODE_ENV == 'dev'
          ? client.handshake.headers.authorization
          : client.handshake.auth?.ticketUuid;

      if (!ticketUuid) {
        throw new UnauthorizedException('잘못된 헤더 요청');
      }

      const ticket = await this.ticketsService.findByUuidSocket(ticketUuid);
      if (!ticket) {
        throw new UnauthorizedException('없는 유저입니다.');
      }
      this.logger.log(`${client.id} connected`);

      //room: uuid로 강제 연결
      client.join(ticketUuid);
    } catch (e) {
      this.logger.error(
        `${client.id} 연결 강제 종료, status: ${e.status}, ${e.message}`
      );
      client.disconnect();
    }
  }

  handleDisconnect(@ConnectedSocket() client: Socket) {
    this.logger.log(`${client.id} disconnected`);
  }
}

클래스 정의 위에 @WebSocketGateway 데코레이터를 달아준다

여기에서 네임스페이스 이름과 cors 정책을 변경할 수 있다

네임스페이스는 룸의 상위 호환이다

하나의 네임스페이스에 여러 개의 룸을 만들수 있다

쉽게 말해서 네임스페이스는 채널, 룸은 채팅방이라고 생각하면 된다

게이트웨이는 interface 상속해서 세 가지 메서드를 구현해야 한다 구현하는 것이 반드시 좋다

afterInit, handleConnection, handleDisconnect

이건 socket.on 사용해서 connection, disconnection 구현했던 거와 같다

afterinit - 초기 생성 시 호출

handleConnection - 유저가 연결 시도할 때 호출

handleConnection - 유저가 연결 해제 시도할 때 호출

constructor 대신 @WebSocketServer() 로 의존성을 주입 받는다(DI)

DI 오브젝트에 Server와 Namespace 를 적을 수 있는데

나는 외부 네임스페이스를 가져오기 위해 Namespace 형태로 주입시켜주었다

왜인지는 모르겠지만 Server로 주입하면 server.of('admin') 형태로

외부 네임스페이스와 연결할 수가 없었다

of 메서드가 정의되지 않았다면서 말이다

@SubscribeMessage('') 를 통해 해당 룸에 대한 리스너를 달아줄 수 있다

node 같은데서 했던 sockett.on('message', () => {}) 이런 구문과 같음

매개변수로 @ConnectedSocket 은 현재 연결중인 소켓 정보를 가져올 수 있고

@MessageBody로 메세지 정보를 가져올 수 있음

구현해 보니까 이 프로젝트에서는 메세지 구독 까지는 사용하지 않을 거 같아서

없애버렸다

처음에 구조 이해가 힘들어서 그림판에 발로 그린 그림이다

결국 구현하고자 하는 것은 실시간 티켓 입장 확인 이벤트 처리를 소켓으로 하고자 하는 거였는데

1. 유저가 /tickets/{ticketUuid} 라는 url에 접근
티켓 uuid 가 담긴 QR 코드를 띄움과 동시에 socket 채널에 입장시켜야 한다

그래서 프론트 단에서 socket 요청을 날릴 때 header.authorization 에 담아서 보내도록 말해놨다

2. 여기서 티켓의 uuid 를 뽑아와 유효성 검사를 한다

유효성 검사를 마치면 uuid 룸에 강제로 join 시켜버렸다

그러면 해당 유저는 자신의 티켓 uuid 에 해당하는 소켓 메세지를 강제로 구독중인 것이다

socket-admin.gateway.ts

// @UseGuards(SocketGuard)
// @Roles(Role.Admin)
@WebSocketGateway({
  cors: {
    origin: '*'
  },
  namespace: '/socket/admin' //socket/admin or socket/user
})
export class SocketAdminGateway
  implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect
{
  private readonly logger = new Logger(SocketAdminGateway.name);
  constructor(private authService: AuthService) {}

  @WebSocketServer() public io: Namespace;

  //interface 구현부

  afterInit(server: Server) {
    // remove the namespace
    this.io.server._nsps.delete('/');
    this.logger.log('SocketAdminGateway Init');
  }

  //소켓 헤더에서 엑세스토큰 검사
  async handleConnection(@ConnectedSocket() client: Socket) {
    try {
      const accessToken =
        process.env.NODE_ENV == 'dev'
          ? client.handshake.headers.authorization
          : client.handshake.auth?.token;

      if (!accessToken) {
        throw new UnauthorizedException('잘못된 헤더 요청');
      }
      const payload = this.authService.verifyAccessJWT(accessToken);

      const user = await this.authService.findUserById(payload.id);
      if (!user) {
        throw new UnauthorizedException('없는 유저입니다.');
      }
      if (user.role !== Role.Admin) {
        throw new UnauthorizedException('권한이 없습니다');
      }
      this.logger.log(`${client.id} connected`);
    } catch (e) {
      this.logger.error(
        `${client.id} 연결 강제 종료, status: ${e.status}, ${e.message}`
      );
      client.disconnect();
    }
  }

  handleDisconnect(@ConnectedSocket() client: Socket) {
    this.logger.log(`${client.id} disconnected`);
  }
}

어드민은 엑세스 토큰을 헤더에서 가져와서 권한을 획득한다

3. 어드민은 티켓을 QR 리더로 찍었을때

/tickets/{ticketUuid}/enter 라는 url 로 이동하게되고

권한이 어드민일 경우에 이 티켓의 상태를 업데이트 시킨다

socket.service.ts

@Injectable()
export class SocketService {
  constructor(
    @Inject(forwardRef(() => SocketUserGateway))
    private userGateway: SocketUserGateway,
    @Inject(forwardRef(() => SocketAdminGateway))
    private adminGateway: SocketAdminGateway
  ) {}

  async emitToUser(ticketEntryResponseDto: TicketEntryResponseDto) {
    try {
      const { uuid } = ticketEntryResponseDto;
      this.userGateway.io.emit(uuid, ticketEntryResponseDto);
    } catch (error) {
      console.log(error);
      throw new GatewayTimeoutException('소켓 서버에 연결할 수 없습니다');
    }
  }

  async emitToAdmin(ticketEntryResponseDto: TicketEntryResponseDto) {
    try {
      this.adminGateway.io.emit('enter', ticketEntryResponseDto);
    } catch (error) {
      console.log(error);
      throw new GatewayTimeoutException('소켓 서버에 연결할 수 없습니다');
    }
  }

  //양쪽
  async emitToAll(ticketEntryResponseDto: TicketEntryResponseDto) {
    await this.emitToUser(ticketEntryResponseDto);
    await this.emitToAdmin(ticketEntryResponseDto);
  }
}

4. 해당 url 에 접근하면

유저의 ticketUuid 룸과 어드민의 enter 룸에 메세지를 보낸다

프론트 단에서 admin 은 enter 메세지를 구독중이니까

실시간 입장 확인은 admin 도 가능하다

tickets.service.ts

/**
   * 어드민이 티켓을 찍었을때 연결할 url에서 검증을 완료한 후 소켓 메세지 전송
   * @param uuid TicketValidationDto -> uuid
   * @param admin 현재 로그인 중인 어드민
   */
  async entryValidation(
    ticketEntryDateValidationDto: TicketEntryDateValidationDto,
    uuid: string,
    admin: User
  ): Promise<TicketEntryResponseDto> {
    this.logger.log('TicketEntryValidation');

    const queryRunner = this.dataSource.createQueryRunner();

    await queryRunner.connect();
    await queryRunner.startTransaction();

    const connectedRepository = getConnectedRepository(
      TicketRepository,
      queryRunner,
      Ticket
    );

    try {
      const { date } = ticketEntryDateValidationDto;
      const ticket = await connectedRepository.findByUuid(uuid);

      // 티켓 날짜 오류(공연 날짜가 일치하지 않음)
      if (ticket.date !== date) {
        const failureResponse = new TicketEntryResponseDto(
          ticket,
          admin.name,
          false,
          '[입장실패] 공연 날짜가 일치하지 않습니다'
        );
        this.socketService.emitToAll(failureResponse);
        throw new BadRequestException('공연 날짜가 일치하지 않습니다');
      }

      // 티켓 상태 오류('입장대기'가 아님)
      if (ticket.status !== TicketStatus.ENTERWAIT) {
        const failureResponse = new TicketEntryResponseDto(
          ticket,
          admin.name,
          false,
          '[입장실패] 이미 입장 완료된 티켓입니다'
        );
        this.socketService.emitToAll(failureResponse);
        throw new BadRequestException('이미 입장 완료된 티켓입니다');
      }

      //성공 시
      ticket.status = TicketStatus.DONE;
      ticket.admin = admin;

      await connectedRepository.saveTicket(ticket);

      await queryRunner.commitTransaction();

      const successResponse = new TicketEntryResponseDto(
        ticket,
        admin.name,
        true,
        `[입장성공] ${ticket.user?.name}님이 입장하셨습니다`
      );
      this.logger.log(`${ticket.user?.name}님이 입장하셨습니다`);
      this.socketService.emitToAll(successResponse);
      return successResponse;
    } catch (e) {
      await queryRunner.rollbackTransaction();
      this.logger.error(`티켓 상태 오류 - ${e.message}`);
      // 내부 예외 그대로 던짐
      throw e;
    } finally {
      await queryRunner.release();
    }
  }

/tickets/{ticektUuid}/enter 접근 시

TicketsController 에서 호출하는 비즈니스 로직

티켓 입장 상태와 티켓 건드린 어드민을 넣어줘야 해서 트랜잭션으로 처리햇다

모든 조건을 통과하면 socketService 의 emit 로직을 호출했다

socket.guard.ts

@Injectable()
export class SocketGuard implements CanActivate {
  private readonly logger = new Logger(SocketGuard.name);
  constructor(private authService: AuthService, private reflector: Reflector) {}

  canActivate(
    context: ExecutionContext
  ): boolean | Promise<boolean> | Observable<boolean> {
    const client: Socket = context.switchToWs().getClient<Socket>();
    return this.validateHeader(client, context);
  }

  public async validateHeader(client: Socket, context: ExecutionContext) {
    //가드에 걸리면 에러 리턴 + 소켓 강제 연결 종료
    try {
      const accessToken =
        process.env.NODE_ENV == 'dev'
          ? client.handshake.headers.authorization
          : client.handshake.auth?.accessToken;

      if (!accessToken) {
        throw new UnauthorizedException('잘못된 헤더 요청');
      }
      if (Array.isArray(accessToken)) {
        throw new UnauthorizedException('잘못된 헤더 요청');
      }
      const payload = this.authService.verifyAccessJWT(accessToken);

      const roles = this.reflector.getAllAndOverride<string[]>('roles', [
        context.getHandler(),
        context.getClass()
      ]);

      const user = await this.authService.findUserById(payload.id);
      if (!user) {
        throw new UnauthorizedException('없는 유저입니다.');
      }
      const newObj: any = client;
      newObj.user = user;
      context.switchToWs().getData().user = user;

      // 롤기반 체크
      if (!roles) {
        return true;
      }
      if (!roles.length) {
        return true;
      } else {
        if (roles.includes(user.role) === true) {
          return true;
        } else if (user.role === Role.Admin) {
          return true;
        } else {
          throw new UnauthorizedException('권한이 없습니다.');
        }
      }
    } catch (e) {
      this.logger.error(
        `${client.id} 연결 강제 종료, status: ${e.status}, ${e.message}`
      );
      client.disconnect();
      throw new WsException(e.message);
    }
  }
}

사용하지는 않지만 구현한 게 아까워서 올리는 소켓 가드

소켓 구현하면서 권한 관리에 많이 애먹었는데

그 중의 일부인 SocketGuard 이다

내가 하고 싶은 건 결국 소켓 요청을 보내는 것부터

권한이 없으면 막고 싶은건데 그게 힘들었다

Nestjs 공식 레퍼런스 페이지에서는

소켓에서도 Guard를 사용할 수 있다 해서 SocketGuard를 구현했다

문제는 이건 소켓의 이벤트, 예를 들면 @SubscribeMessage 같은 거만 막을 수 있다

소켓 커넥션 자체를 막을 수 있는게 아니였다

결국 구현해야 하는 건

handleConnection 에서 접근 자체를 막는 것으로 바뀌었다

✨ Postman 으로 소켓 연결 테스트

테스트는 postman 에 소켓 연결 테스트가 있길래 그것으로 했다

유저 테스트는 headers -> authorization 에 ticketUuid 를 끼우고

Listeners 에 해당 ticketUuid 를 끼우면 구독이 된다 (수동으로 해주어야됨)

어드민은 헤더에 엑세스 토큰을 끼우고 db에서 권한을 admin 으로 바꿔준 다음

listener에 enter 등록해주면 된다

이러고 tickets/{ticketUuid}/enter 에 접근해서 돌리면 테스트가 된다

권한이 없으면 이런식으로 튕궈버린다

소켓 둘다 연결시킨 다음에 swagger로 요청 테스트

입장 성공시 오는 메세지

어드민이랑 유저랑 동일함

상당히 구현하는데 머리 아팠지만

막상 만들고 나니까 소켓 공부도 많이 되었고 재밌었다

[Github] 이슈 템플릿, PR 템플릿 등록 (Issue Template, Pull Request Template)

gengminy — Mon, 25 Jul 2022 14:20:12 +0900

매번 개발 뛰어나게 잘하는 친구의 도움을 받아

체계적이게 깃허브를 사용하는 법을 배우는 중이다

사이드 프로젝트로 내가 조금? 주도적인 프로젝트를 하게 되었는데

이전에는 누가 편하게 쓰라고 만들어놨던 템플릿들을 쓰기만 했다면

이제는 그걸 내가 만들어야 했다

이번 글에서는 프로젝트 협업 과정에서 자주 사용하는

이슈 템플릿과 PR 템플릿을 만드는 과정을 써보았다

이슈 템플릿 생성하기

1. 해당 프로젝트 레포 -> Settings

2. 내리다 보면 Features -> Issue -> Set up templates

3. 템플릿 종류를 하나 선택한다

4. 그러면 템플릿이 하나 만들어지는데 Preview and edit 클릭

5. 연필 아이콘 클릭

6. 내용과 제목, 설명 등을 적어주면 된다 마크다운으로 작성

다 만들면 꼭 Close Preview 눌러주자 아니면 사라짐

7. 커밋 날리면 이렇게 레포 루트 폴더에 .github 하위에 템플릿들이 만들어짐

8. 이제 Issue 카테고리에 들어가서 이슈를 생성하면 이렇게 템플릿을 사용할 수 있다

아까 작성했던 것들이 잘 보이는 모습

컨벤션이 지켜지니 체계적으로 협업을 하기 쉬워진다

PR 템플릿 생성하기

1. 해당 프로젝트 레포 -> .github 폴더로 이동

나는 {root}/.github 에 PULL_REQUEST_TEMPLATE.md 파일을 생성해서

마크다운으로 양식을 작성해주었다

Pull Request 날리기 전에 양식으로 해당 글이 잘 나온다

생각보다 간단하게 템플릿을 작성해보았다

[NestJs] 따라하면서 배우는 NestJs - 9 (로그, 설정)

gengminy — Sat, 9 Jul 2022 14:19:46 +0900

✅ Logger 모듈 추가

./src/main.ts

import { Logger } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
    const logger = new Logger();
    const port = 3000;
    const app = await NestFactory.create(AppModule);
    await app.listen(port);
    logger.log(`Application running on port ${port}`);
}
bootstrap();

expressjs 에서는 Winston 모듈을 주로 사용한다고 한다

nestjs 에서는 내장 Logger 클래스가 존재한다

간단하게 서버 돌아가는 포트 번호 알려주는 로그 찍기

Log

Warning

Error

Debug

Verbose

이렇게 다섯 가지 레벨로 사용 가능하다

프로덕션 단계에서는 Log 와 Error 만 사용 가능

./src/boards/boards.controller.ts

export class BoardsController {
    private logger = new Logger('BoardsController');
    
    				...
                    
    @Get()
    getAllBoard(@GetUser() user: User): Promise<Board[]> {
        this.logger.verbose(`User ${user.username} trying to get all boards`);
        return this.boardsService.getAllBoards(user);
    }
}

Logger 생성자 인자로 string 전달해주면 그게 로그 찍을 때 정보로 나온다

./src/boards/boards.controller.ts

@Post()
@UsePipes(ValidationPipe)
createBoard(
    @Body() createBoardDto: CreateBoardDto,
    @GetUser() user: User,
): Promise<Board> {
    this.logger.verbose(
        `User ${
            user.username
        } creating a new board. Payload: ${JSON.stringify(createBoardDto)}`,
    );
    return this.boardsService.createBoard(createBoardDto, user);
}

✅ 설정 (Configuration)

npm i config --save

config 모듈을 추가한다

./config/default.yml

server:
  port: 3000

db:
  type: 'postgres'
  port: 5432
  database: 'board-app'
  
jwt:
  expiresIn: 3600

./config/development.yml

db:
  host: 'localhost'
  username: 'postgres'
  password: 'postgres'
  synchronize: true

jwt:
  secret: 'MySecretKey1234'

./config/development.yml

db:
  synchronize: false

예제에서는 야믈 파일로 생성해준다 json 형식도 가능하다

expressjs 할 때는 dotenv 를 썼었던 거 같은데 yml 파일 쓰는 건 첨이다

./src/main.ts

import { Logger } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as config from 'config';

async function bootstrap() {
    const logger = new Logger();

    const app = await NestFactory.create(AppModule);

    const serverConfig = config.get('server');
    const port = serverConfig.port;

    await app.listen(port);
    logger.log(`Application running on port ${port}`);
}
bootstrap();

config를 import 해서 사용 가능하다

./src/configs/typeorm.config.ts

import { TypeOrmModuleOptions } from '@nestjs/typeorm';
import * as config from 'config';

const dbConfig = config.get('db');

export const typeORMConfig: TypeOrmModuleOptions = {
    type: dbConfig.type,
    host: process.env.RDS_HOSTNAME || dbConfig.host,
    port: process.env.RDS_PORT || dbConfig.port,
    username: process.env.RDS_USERNAME || dbConfig.username,
    password: process.env.RDS_PASSWORD || dbConfig.password,
    database: process.env.RDS_DB_NAME || dbConfig.database,
    entities: [__dirname + '/../**/*.entity.{js,ts}'],
    synchronize: dbConfig.synchronize,
};

AWS 같은 클라우드에선 환경 변수 설정이 가능하기 때문에

process.env 에서 가져오거나 yml 파일에서 가져오도록 || 사용

일주일 정도 들어서 완강했다

이제 nestjs 활용한 프로젝트 곧 시작하니까 나머지도 잘 공부해야겠다

[NestJs] 따라하면서 배우는 NestJs - 8 (권한 부여, 유저와 게시글 관계 부여)

gengminy — Sat, 9 Jul 2022 13:43:45 +0900

✅ Boards 모듈에서 AuthGuard 사용하기

./src/boards/boards.module.ts

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from 'src/auth/auth.module';
import { BoardRepository } from './board.repository';
import { BoardsController } from './boards.controller';
import { BoardsService } from './boards.service';

@Module({
    imports: [
        ConfigModule.forRoot({ isGlobal: true }),
        TypeOrmModule.forFeature([BoardRepository]),
        AuthModule,
    ],
    controllers: [BoardsController],
    providers: [BoardsService],
})
export class BoardsModule {}

./src/boards/boards.controller.ts

@Controller('boards')
@UseGuards(AuthGuard())
export class BoardsController {
			...
}

컨트롤러 레벨에 UseGuards 추가

JWT 없이 GET 요청을 보내면 권한 없음 오류 발생

Signin 으로 얻은 JWT을 request 에 실어보내면 권한을 정상적으로 얻는다

권한 처리도 Guard 관련 코드 몇개만 뚝딱 했는데 되니까 상당히 편하다

✅ User와 Board 사이의 관계 정의

./src/auth/user.entity.ts

@Entity()
@Unique(['username'])
export class User extends BaseEntity {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    username: string;

    @Column()
    password: string;

    @OneToMany((type) => Board, (board) => board.user, { eager: true })
    boards: Board[];

    async validatePassword(password: string): Promise<boolean> {
        const isValid = await bcrypt.compare(password, this.password);
        return isValid;
    }
}

./src/boards/board.entity.ts

@Entity()
export class Board extends BaseEntity {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    title: string;

    @Column()
    description: string;

    @Column()
    status: BoardStatus;

    @ManyToOne((type) => User, (user) => user.boards, { eager: false })
    user: User;
}

관계 정의를 위해 각 엔티티 정의에 들어가서 관계를 지정해주면 된다

여기서는 User 가 Board 에 대해서 OneToMany 의 관계이고

반대로는 ManyToOne 의 관계이다

eager 옵션을 한쪽은 true, 한쪽은 false로 주었는데

강의에선 설명하지 않았지만 순환 참조 막을라고 넣은 것 같다

✅ 게시글 생성할 때 유저 정보 전달

./src/boards/boards.controller.ts

@Post()
@UsePipes(ValidationPipe)
createBoard(
    @Body() createBoardDto: CreateBoardDto,
    @GetUser() user: User,
): Promise<Board> {
    return this.boardsService.createBoard(createBoardDto, user);
}

./src/boards/boards.service.ts

createBoard(createBoardDto: CreateBoardDto, user: User): Promise<Board> {
    return this.boardRepository.createBoard(createBoardDto, user);
}

./src/boards/board.repository.ts

@EntityRepository(Board)
export class BoardRepository extends Repository<Board> {
    async createBoard(
        createBoardDto: CreateBoardDto,
        user: User,
    ): Promise<Board> {
        const { title, description } = createBoardDto;

        const board = this.create({
            title,
            description,
            status: BoardStatus.PUBLIC,
            user,
        });

        await this.save(board);
        return board;
    }
}

인자로 User 전달을 추가해준다

@GetUser 은 저번 시간에 만들었던 커스텀 데코레이터

req.user 를 즉시 가져오게 하는 데코레이터다

board 엔티티에 user 정보를 정의해놓았기 때문에 바로 인자 전달해서 생성하면 된다

이제 게시글 생성하면 유저 정보가 같이 전달된다

✅ 특정 유저의 게시글만 가져오기

./src/boards/boards.controller.ts

@Get()
getAllBoard(@GetUser() user: User): Promise<Board[]> {
    return this.boardsService.getAllBoards(user);
}

./src/boards/boards.service.ts

async getAllBoards(user: User): Promise<Board[]> {
    const query = this.boardRepository.createQueryBuilder('board');

    query.where('board.userId = :userId', { userId: user.id });

    const boards = await query.getMany();
    return boards;
}

이번 예제에서는 repository API 대신에 queryBuilder를 사용했다

복잡한 SQL 쿼리를 조작할 수 있도록 TypeORM 에서 제공해준다

getMany 는 해당하는 결과를 전부 가져오는 메소드다

✅ 자신이 생성한 게시글 지우기

./src/boards/boards.controller.ts

@Delete('/:id')
deleteBoard(
    @Param('id', ParseIntPipe) id: number,
    @GetUser() user: User,
): Promise<void> {
    return this.boardsService.deleteBoard(id, user);
}

./src/boards/boards.service.ts

async deleteBoard(id: number, user: User): Promise<void> {
    const result = await this.boardRepository.delete({ id, user });

    if (result.affected === 0) {
        throw new NotFoundException(`Can't find Board with id ${id}`);
    }
}

인자로 user 정보까지 전달해주면

권한이 있는 user만 그 게시글을 지울 수 있게 된다

[NestJs] 따라하면서 배우는 NestJs - 7 (JWT, passport 이용한 인증 구현)

gengminy — Fri, 8 Jul 2022 14:48:41 +0900

✅ JWT, passport 모듈 추가

npm i @nestjs/jwt @nestjs/passport passport passport-jwt --save

✔ @nestjs/jwt - nest에서 jwt를 사용하기 위한 모듈

✔ @nestjs/passport - nest에서 passport를 사용하기 위한 모듈

✔ passport - passport 모듈

✔ passport-jwt - passport와 jwt를 연동하기 위한 모듈

./src/auth/auth.module.ts

import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { UserRepository } from './user.repository';

@Module({
    imports: [
        PassportModule.register({ defaultStrategy: 'jwt' }),
        JwtModule.register({
            secret: 'MySecretKey1234',
            signOptions: {
                expiresIn: 3600,
            },
        }),
        TypeOrmModule.forFeature([UserRepository]),
    ],
    controllers: [AuthController],
    providers: [AuthService],
})
export class AuthModule {}

passport는 PassportModule.register로 등록

✔ defaultStrategy - 전략 지정, 여기서는 jwt를 이용한 로그인이니까 jwt로 지정

jwt는 JwtModule.register 로 등록하면 됨

✔ secret - secret key를 지정한다

✔ signOptions.expiresIn - 토큰 만료 기간을 지정, 3600은 한 시간

./src/auth/auth.service.ts

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { AuthCredentialDto } from './dto/auth-credential.dto';
import { UserRepository } from './user.repository';
import * as bcrypt from 'bcryptjs';
import { JwtService } from '@nestjs/jwt';

@Injectable()
export class AuthService {
    constructor(
        @InjectRepository(UserRepository)
        private userRepository: UserRepository,
        private jwtService: JwtService,
    ) {}

    async signUp(authCredentialDto: AuthCredentialDto): Promise<void> {
        return this.userRepository.createUser(authCredentialDto);
    }

    async signIn(
        authCredentialDto: AuthCredentialDto,
    ): Promise<{ accessToken: string }> {
        const { username, password } = authCredentialDto;
        const user = await this.userRepository.findOne({ username });

        if (user && (await bcrypt.compare(password, user.password))) {
            //유저 토큰 생성 (Secret + Payload 필요)
            const payload = { username };
            const accessToken = await this.jwtService.sign(payload);

            return { accessToken };
        } else {
            throw new UnauthorizedException('Login Failed');
        }
    }
}

JwtService에 대한 의존성 주입 이후

리턴 값으로 accessToken을 객체로 감싸서 반환

여기서 payload 에 간단한 정보를 담아서 서명할 수 있다

(중요한 정보는 절대 담지 않도록 주의)

post 요청 보내면 엑세스 토큰이 날라온다

✅ 토큰 인증 기능 구현

npm i @types/passport-jwt --save

타입스크립트에서 passport, jwt 를 위한 타입을 사용하기 위한 모듈

./src/auth/jwt.strategy.ts

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { InjectRepository } from '@nestjs/typeorm';
import { ExtractJwt, Strategy } from 'passport-jwt';
import { User } from './user.entity';
import { UserRepository } from './user.repository';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
    constructor(
        @InjectRepository(UserRepository)
        private userRepository: UserRepository,
    ) {
        super({
            secretOrKey: 'MySecretKey1234',
            jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
        });
    }

    async validate(payload) {
        const { username } = payload;
        const user: User = await this.userRepository.findOne({ username });

        if (!user) {
            throw new UnauthorizedException();
        }

        return user;
    }
}

JWT Strategy 는 PassportStrategy 를 상속받아서 구현한다

생성자에서는 DB와의 연동을 위해 userRepository 주입

또한 부모인 PassportStrategy 의 생성자를 통해 비밀 키와 토큰 타입을 지정해준다

아까 생성할때 사용한 비밀키와 똑같이 넣고

여기서는 BearerToken 을 사용하기 떄문에 그렇게 주입

./src/auth/auth.module.ts

import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { JwtStrategy } from './jwt.strategy';
import { UserRepository } from './user.repository';

@Module({
    imports: [
        PassportModule.register({ defaultStrategy: 'jwt' }),
        JwtModule.register({
            secret: 'MySecretKey1234',
            signOptions: {
                expiresIn: 3600,
            },
        }),
        TypeOrmModule.forFeature([UserRepository]),
    ],
    controllers: [AuthController],
    providers: [AuthService, JwtStrategy],
    exports: [JwtStrategy, PassportModule],
})
export class AuthModule {}

auth module 외부에서도 사용할 수 있게 하기 위해서

JwtStrategy 와 PassportModule 을 export 해줌

provider 에 JwtStrategy 도 등록해준다

./src/auth/auth.controller.ts

@Post('/test')
@UseGuards(AuthGuard())
test(@Req() req) {
    console.log('req', req);
}

@UseGuards 를 통해 인증 처리를 해줄 수 있다

Pipe 와 마찬가지 처럼 Guard 도 미들웨어로서 동작한다

인증과 관련된 것이기 때문에 AuthGuard() 를 주입해준다

Guard를 주입하지 않으면 인증 처리가 제대로 동작하지 않음

✅ req.user 바로 가져오기 - 커스텀 데코레이터 생성

./src/auth/get-user.decorator.ts

import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import { User } from './user.entity';

export const GetUser = createParamDecorator((data, ctx: ExecutionContext): User => {
        const req = ctx.switchToHttp().getRequest();
        return req.user;
    },
);

createParamDecorator를 통해 파라미터 레벨의 데코레이터를 만들 수 있다

인자로 함수를 넣는데 ctx 부분을 ExecutionContext 로 지정해주면 된다

request를 받아서 반환하면 req.user를 즉시 반환 가능

⚠ 단, request 에 user가 있다는 전제 하에만 사용해야 한다

./src/auth/auth.controller.ts

@Post('/test')
@UseGuards(AuthGuard())
test(@GetUser() user: User) {
    console.log('user', user);
}

확실히 req.user 를 가져오는 것 보다 깔끔해지긴 한다

[NestJs] 따라하면서 배우는 NestJs - 6 (auth 모듈 구현)

gengminy — Thu, 7 Jul 2022 13:38:23 +0900

✅ 인증을 위한 auth 모듈 생성

nest g module auth
nest g controller auth --no-spec
nest g service auth --no-spec

✅ User Entity & Repository 구현 및 등록

./src/auth/user.entity.ts

import { BaseEntity, Column, Entity, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class User extends BaseEntity {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    username: string;

    @Column()
    password: string;
}

./src/auth/user.repository.ts

import { EntityRepository, Repository } from 'typeorm';
import { User } from './user.entity';

@EntityRepository(User)
export class UserRepository extends Repository<User> {}

./src/auth/auth.module.ts

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { UserRepository } from './user.repository';

@Module({
    imports: [TypeOrmModule.forFeature([UserRepository])],
    controllers: [AuthController],
    providers: [AuthService],
})
export class AuthModule {}

./src/auth/auth.service.ts

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { UserRepository } from './user.repository';

@Injectable()
export class AuthService {
    constructor(
        @InjectRepository(UserRepository)
        private userRepository: UserRepository,
    ) {}
}

./src/auth/auth.controller.ts

import { Controller } from '@nestjs/common';
import { AuthService } from './auth.service';

@Controller('auth')
export class AuthController {
    constructor(private authService: AuthService) {}
}

의존성 주입까지 끝내면 기본 셋팅이 끝난다

✅ 회원가입 기능 추가

./src/auth/dto/auth-credential.dto.ts

export class AuthCredentialDto {
    username: string;
    password: string;
}

User 정보를 넘기기 위한 DTO(Data Transfer Object)도 추가해준다

./src/auth/user.repository.ts

async createUser(authCredentialDto: AuthCredentialDto) {
    const { username, password } = authCredentialDto;
    const user = this.create({ username, password });

    await this.save(user);
}

./src/auth/auth.service.ts

async signUp(authCredentialDto: AuthCredentialDto): Promise<void> {
    return this.userRepository.createUser(authCredentialDto);
}

./src/auth/auth.controller.ts

@Post('/signup')
signUp(@Body() authCredentialDto: AuthCredentialDto): Promise<void> {
    return this.authService.signUp(authCredentialDto);
}

간단하게 구현 끝

✅ 유저 유효성 체크

./src/auth/dto/auth-credential.dto.ts

import { IsString, Matches, MaxLength, MinLength } from 'class-validator';

export class AuthCredentialDto {
    @IsString()
    @MinLength(4)
    @MaxLength(20)
    username: string;

    @IsString()
    @MinLength(4)
    @MaxLength(20)
    //영어랑 숫자만 가능하도록 하는 정규식
    @Matches(/^[a-zA-Z0-9]*$/, {
        message: 'password only accepts English and number',
    })
    password: string;
}

class-validator 에서 데코레이터 끌어와서 사용한다

비밀번호에서는 정규식을 사용할 수도 있다

골뱅이 몇개 찍는 거 만으로도 유효성 체크를 자동으로 해주는게 진짜 편리하다

./src/auth/auth.controller.ts

@Post('/signup')
signUp(
    @Body(ValidationPipe) authCredentialDto: AuthCredentialDto,
): Promise<void> {
    return this.authService.signUp(authCredentialDto);
}

authController에서 @Body 부분에 ValidationPipe 집어넣어주면 동작한다

✅ 유저에 유니크한 이름 부여하기

./src/auth/user.entity.ts

@Entity()
@Unique(['username'])
export class User extends BaseEntity {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    username: string;

    @Column()
    password: string;
}

@Unique 데코레이터로 특정 값이 DB에서 처리될 때 unique 한지 검사할 수 있다

여기서는 username 에 유니크한 값을 주었다

대신 이렇게만 처리하면 오류 발생 시 500 에러(Internal Server Error)를 내보내는데

어디선가 듣기로 500 에러는 절대 나와서는 안되는 것이라고 했다

그러니까 try catch로 따로 잡아서 처리를 해주어야 한다

./src/auth/auth.controller.ts

async createUser(authCredentialDto: AuthCredentialDto) {
    const { username, password } = authCredentialDto;
    const user = this.create({ username, password });

    try {
        await this.save(user);
    } catch (error) {
        if (error.code === '23505') {
            throw new ConflictException('Existring username');
        } else {
            throw new InternalServerErrorException();
        }
    }
}

23505(500)에 해당하는 에러를 잡아서 따로 처리

역시 예외 처리는 백엔드 기본 소양이다

✅ 비밀번호 암호와 (bcryptjs)

npm i bcryptjs --save
import * as bcrypt from 'bcryptjs';

bcrypt 모듈 추가

./src/auth/auth.controller.ts

async createUser(authCredentialDto: AuthCredentialDto) {
    const { username, password } = authCredentialDto;

    const salt = await bcrypt.genSalt();
    const hashedPassword = await bcrypt.hash(password, salt);

    const user = this.create({ username, password: hashedPassword });

    try {
        await this.save(user);
    } catch (error) {
        if (error.code === '23505') {
            throw new ConflictException('Existring username');
        } else {
            throw new InternalServerErrorException();
        }
    }
}

비밀번호를 sha256 hash 를 사용하여 변환해 저장하는 것은 동일하지만

salt 를 덧붙이게 되면

서로 다른 유저가 동일한 비밀번호를 사용할 때 암호가 뚫리는 문제를 방지

salt 라는 유니크한 값을 추가하여 각기 다르게 해싱된다

✅ 로그인 기능 구현

./src/auth/auth.service.ts

async signIn(authCredentialDto: AuthCredentialDto): Promise<string> {
    const { username, password } = authCredentialDto;
    const user = await this.userRepository.findOne({ username });

    if (user && (await bcrypt.compare(password, user.password))) {
        return 'Login Success';
    } else {
        throw new UnauthorizedException('Login Failed');
    }
}

./src/auth/auth.controller.ts

@Post('/signin')
signIn(@Body(ValidationPipe) authCredentialDto: AuthCredentialDto) {
    return this.authService.signIn(authCredentialDto);
}

bcrypt.compare(pw1, pw2)로 두 비밀번호를 비교함

간단하다

[NestJs] 따라하면서 배우는 NestJs - 5 (레포지토리 구현 및 DB 이용 CRUD)

gengminy — Thu, 7 Jul 2022 00:29:00 +0900

✅ 레포지토리 의존성 주입

./src/boards/boards.service.ts

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { BoardRepository } from './board.repository';

@Injectable()
export class BoardsService {
    constructor(
        @InjectRepository(BoardRepository)
        private boardRepository: BoardRepository,
    ) {}
}

컨트롤러에 서비스를 주입한 것 처럼 서비스에 레포지토리를 주입해준다

여기서는 역시 생성자 주입 사용

데코레이터 @InjectRepository 를 사용하면서

인자로 우리가 만든 레포지토리 주입시켜주면 끝

✅ DB에서 하나의 id로 검색

./src/boards/boards.service.ts

import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Board } from './board.entity';
import { BoardRepository } from './board.repository';

@Injectable()
export class BoardsService {
    constructor(
        @InjectRepository(BoardRepository)
        private boardRepository: BoardRepository,
    ) {}

    async getBoardById(id: number): Promise<Board> {
        const found = await this.boardRepository.findOne(id);

        if (!found) {
            throw new NotFoundException(`Can't find Board with id ${id}`);
        }

        return found;
    }
}

DB에서 값을 불러오는 것을 기다려야 하기 때문에

async await 사용해서 반드시 비동기 작업으로 처리해주어야함

비동기 처리이기 때문에 리턴값은 Promise<T>

./src/boards/boards.controller.ts

import { Controller, Get, Param } from '@nestjs/common';
import { Board } from './board.entity';
import { BoardsService } from './boards.service';

@Controller('boards')
export class BoardsController {
    constructor(private boardsService: BoardsService) {}

    @Get('/:id')
    getBoardById(@Param('id') id: number): Promise<Board> {
        return this.boardsService.getBoardById(id);
    }
}

✅ 새 board 생성

./src/boards/boards.service.ts

async createBoard(createBoardDto: CreateBoardDto): Promise<Board> {
    const { title, description } = createBoardDto;

    const board = this.boardRepository.create({
        title: title,
        description: description,
        status: BoardStatus.PUBLIC,
    });

    await this.boardRepository.save(board);
    return board;
}

./src/boards/boards.controller.ts

@Post()
@UsePipes(ValidationPipe)
createBoard(@Body() createBoardDto: CreateBoardDto): Promise<Board> {
    return this.boardsService.createBoard(createBoardDto);
}

boardRepository.create 로 dto 생성

이후 boardRepository.save로 DB에 값을 전달해서 저장해주면 된다

❌ RepositoryNotFoundError

여기서 역시나 한가지 문제가 더 생겼는데.... 바로

자꾸 레포지토리와 엔티티를 찾을 수 없다고 뜨는 것이다

현재 최신 버전은 TypeORM 은 3.0, @nestjs/typeorm 은 8.4.5 이다

커스텀 레포지토리를 사용하기 위해 TypeORM 버전은 2.0으로 낮췄으나

아직 nestjs/typeorm 의 버전은 최신 버전과 연동되었기 때문에 발생하는 버그인 것 같다

@nestjs/typeorm 도 강제로 버전을 8.0.1로 낮춰주니까 잘 동작했다

2시간 동안 삽질의 결과 하

npm i @nestjs/typeorm@8.0.1 --save

강제로 다운그레이드

이제 잘 켜진다

postman 으로 post 보내기도 잘 됨

pgAdmin에서 Schemas -> Table 들어가서 빨간 아이콘 누르면 확인 가능

✅ DB 관련 로직 Repository로 옮겨주기

./src/boards/board.repository.ts

import { EntityRepository, Repository } from 'typeorm';
import { BoardStatus } from './board-status.enum';
import { Board } from './board.entity';
import { CreateBoardDto } from './dto/create-board.dto';

@EntityRepository(Board)
export class BoardRepository extends Repository<Board> {
    async createBoard(createBoardDto: CreateBoardDto): Promise<Board> {
        const { title, description } = createBoardDto;

        const board = this.create({
            title,
            description,
            status: BoardStatus.PUBLIC,
        });

        await this.save(board);
        return board;
    }
}

./src/boards/boards.service.ts

createBoard(createBoardDto: CreateBoardDto): Promise<Board> {
    return this.boardRepository.createBoard(createBoardDto);
}

서비스에 만들었던 create 로직을 repository 로 옮겨준다

서비스에 db 관련 로직까지 포함시키면 코드가 너무 복잡해질 수 있다

✅ 게시글 삭제

DELETE 메서드를 사용할 때 remove와 delete 를 사용할 수 있는데

remove는 해당 id 값이 무조건 존재해야 하며 (존재하지 않으면 404 error)

delete는 해당 id 값이 있으면 지우고 없으면 아무 영향을 끼치지 않음 (오류 발생 x)

그래서 remove는 DB에 2번 접근해야 해서 비효율적

여기서는 1번만 접근해도 되는 delete 사용

./src/boards/boards.service.ts

async deleteBoard(id: number): Promise<void> {
    const result = await this.boardRepository.delete(id);

    if (result.affected === 0) {
        throw new NotFoundException(`Can't find Board with id ${id}`);
    }
}

./src/boards/boards.controller.ts

@Delete('/:id')
deleteBoard(@Param('id', ParseIntPipe) id: number): Promise<void> {
    return this.boardsService.deleteBoard(id);
}

✅ 게시글 업데이트

./src/boards/boards.service.ts

async updateBoardStatus(id: number, status: BoardStatus): Promise<Board> {
    const board = await this.getBoardById(id);

    board.status = status;
    await this.boardRepository.save(board);

    return board;
}

./src/boards/boards.controller.ts

@Patch('/:id/status')
updateBoardStatus(
    @Param('id') id: number,
    @Body('status', BoardStatusValidationPipe) status: BoardStatus,
): Promise<Board> {
    return this.boardsService.updateBoardStatus(id, status);
}

request body에 status 정보를 같이 보내면 성공

✅ 모든 게시글 가져오기

./src/boards/boards.service.ts

async getAllBoards(): Promise<Board[]> {
    return this.boardRepository.find();
}

./src/boards/boards.controller.ts

@Get()
getAllBoard(): Promise<Board[]> {
    return this.boardsService.getAllBoards();
}

레포지토리의 find 를 사용하면 모든 데이터를 가져옴

간단하게 구현

[NestJs] TypeORM 사용 시 RepositoryNotFoundError 해결하기

gengminy — Wed, 6 Jul 2022 18:02:11 +0900

❌ 난관 봉착

nestjs의 TypeORM 은 3.0부터 EntityRepository 가 deprecated 되어서 사용할 수 없다

따라서 최신의 TypeORM 에서 이 커스텀 레포지토리를 사용하려면

커스텀 데코레이터를 만들어서 어찌저찌 하면 되긴 한다

하지만 일단은 예제를 따라 공부하는 중이기 때문에 TypeORM을 강제로 2.0으로 낮췄다

npm i --save typeorm@0.2

package.json

  "dependencies": {
    "@nestjs/common": "^8.0.0",
    "@nestjs/config": "^2.1.0",
    "@nestjs/core": "^8.0.0",
    "@nestjs/platform-express": "^8.0.0",
    "@nestjs/typeorm": "^8.0.1",
    "class-transformer": "^0.5.1",
    "class-validator": "^0.13.2",
    "dotenv": "^16.0.1",
    "pg": "^8.7.3",
    "reflect-metadata": "^0.1.13",
    "rimraf": "^3.0.2",
    "rxjs": "^7.2.0",
    "typeorm": "^0.2.45",
    "uuid": "^8.3.2"
  },

typeorm 버전이 0.2.45로 강제로 다운그레이드 되었다

이제 @EntityRepository 데코레이터 사용 가능하다

하지만 이렇게만 했을 경우 서버 실행이 안되는데...

바로 RepositoryNotFoundError 가 뜨는 것이다

ERROR [ExceptionHandler] No repository for "BoardRepository" was found. Looks like this entity is not registered in current "default" connection?
RepositoryNotFoundError: No repository for "BoardRepository" was found. Looks like this entity is not registered in current "default" connection?

바로 Entity가 등록이 안되었다고 하면서 연동이 안되는데...

이 문제로 스택 오버플로우 겁나 뒤져가면서 찾아도 엔티티 등록하는 것 밖에 안알려줬다

그러다가 인프런 검색하니까 바로 해결했다

바로바로 typeorm 과 같이 사용하는 @nestjs/typeorm 버전도 낮춰야 한다는 것이다...

이걸 몰라서 2시간 넘게 삽질했다 ㅠ

npm i @nestjs/typeorm@8.0.1 --save

강제로 8.0.1로 다운그레이드 시켜주었다

이제 잘켜진다

열어분들은 삽질하지 마시길

[NestJs] 따라하면서 배우는 NestJs - 4 (Postgres, TypeORM 적용)

gengminy — Tue, 5 Jul 2022 16:49:57 +0900

✅ ORM(Object Relational Mapping)

객체와 관계형 데이터베이스의 데이터를 자동으로 변형 및 연결해주는 것

객체 클래스 vs 관계형 db 테이블간 불일치를 해소

✅ Postgres, TypeORM 설치 및 적용

npm i pg typeorm @nestjs/typeorm --save

pg : postgres 모듈

typeorm : TypeORM 모듈

@nestjs/typeorm : nest와 TypeORM 간의 연동

예제에서는 postgresSQL과 pgAdmin4 사용

postgresSQL for MAC - https://postgresapp.com/downloads.html

pgAdmin4 for MAC - https://www.pgadmin.org/download/pgadmin-4-macos/

docs - https://docs.nestjs.com/techniques/database

./src/configs/typeorm.config.ts

import { TypeOrmModuleOptions } from '@nestjs/typeorm';

export const typeORMConfig: TypeOrmModuleOptions = {
    type: 'postgres',
    host: 'localhost',
    port: 5432,
    username: 'postgres',
    password: 'postgres',
    database: 'board-app',
    entities: [__dirname + '/../**/*.entity.{js,ts}'],
    synchronize: true,
};

entites 옵션에 저렇게 적으면

프로젝트의 엔티티 파일들을 모두 긁어와서 테이블을 자동 생성해준다

synchronize 옵션은 어플리케이션 재실행시 테이블을 drop 후 재생성 해준다

./src/app.module.ts

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { BoardsModule } from './boards/boards.module';
import { typeORMConfig } from './configs/typeorm.config';

@Module({
    imports: [TypeOrmModule.forRoot(typeORMConfig), BoardsModule],
})
export class AppModule {}

루트 모듈에도 추가해주면 연동 끝

✅ 엔티티 정의

./src/boards/board.entity.ts

import { BaseEntity, Column, PrimaryGeneratedColumn } from 'typeorm';
import { BoardStatus } from './board.model';

@Entity()
export class Board extends BaseEntity {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    title: string;

    @Column()
    description: string;

    @Column()
    status: BoardStatus;
}

BaseEntity 를 상속받아서 정의한다

@PrimaryGeneratedColumn() 데코레이터를 사용하면 unique id 를 자동으로 생성해준다

그 외에는 @Column() 데코레이터로 새 컬럼을 지정

✅ 레포지토리 정의

레포지토리는 엔티티에 대한 찾기, 삽입, 수정, 삭제등을 처리함

데이터베이스에 대한 연산을 서비스 대신 위임하게됨

Repository docs

http://typeorm.delightful.studio/classes/_repository_repository_.repository.html

하다가 보니까 EntityRepository 는 TypeORM@0.3 부터 사용하지 않는다(deprecated)해서 찾아보니까

커스텀 데코레이터 추가하고 뭐 하면 되긴 한다더라

TypeORM@0.3 CustomRepository docs

https://typeorm.io/custom-repository#how-to-create-custom-repository

EntityRepository 돌려줘! 데코레이터 뿌수기 + CustomRepository 커스텀

https://prod.velog.io/@pk3669/typeorm-0.3.x-EntityRepository-%EB%8F%8C%EB%A0%A4%EC%A4%98

근데 다이나믹 모듈이니 뭐니 너무너무 복잡해서 아직 더 공부해야겠지 싶고

일단은 예제 따라가는게 목적이니 TypeORM@0.2로 다운그레이드해서 해버림

npm i typeorm@0.2

./src/boards/board.repository.ts

import { EntityRepository, Repository } from 'typeorm';
import { Board } from './board.entity';

@EntityRepository(Board)
export class BoardRepository extends Repository<Board> {
    
}

TypeORM 다운그레이드 하니까 찍찍이 사라짐

Repository 를 상속받아서 구현한다

./src/boards/boards.module.ts

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { BoardRepository } from './board.repository';
import { BoardsController } from './boards.controller';
import { BoardsService } from './boards.service';

@Module({
    imports: [TypeOrmModule.forFeature([BoardRepository])],
    controllers: [BoardsController],
    providers: [BoardsService],
})
export class BoardsModule {}

레포지토리 import 해줌

일단 여기까지 하면 TypeORM 적용은 끝

[NestJs] 따라하면서 배우는 NestJs - 3 (pipe와 validation)

gengminy — Mon, 4 Jul 2022 18:17:51 +0900

✅ Pipe

데이터 변환과 데이터 유효성 검사를 위한 클래스

핸들러 레벨 / 파라미터 레벨 / 글로벌 레벨의 3가지 레벨에서 사용할 수 있음

✅ 모듈 설치

npm i class-validator class-transformer --save

class-validator docs

https://github.com/typestack/class-validator#manual-validation

✅ class-validator 적용

./boards/dto/create-board.dto.ts

import { IsNotEmpty } from 'class-validator';

export class CreateBoardDto {
    @IsNotEmpty()
    title: string;

    @IsNotEmpty()
    description: string;
}

./boards/boards.controller.ts

@Post()
@UsePipes(ValidationPipe)
createBoard(@Body() createBoardDto: CreateBoardDto): Board {
    return this.boardsService.createBoard(createBoardDto);
}

핸들러 레벨 파이프는 @UsePipes 를 적고

유효성 검사와 관련된 파이프를 사용하기 때문에 인자로 ValidationPipe를 넣어준다

기본 빌트인 파이프는 6가지로 NestJs가 기본적으로 제공한다

- ValidationPipe

- ParseIntPipe

- ParseBoolPipe

- ParseArrayPipe

- ParseUUIDPipe

- DefaultValuePipe

확실히 데코레이터를 사용하니까 구조적으로 눈에 잘 띄고

기본적인 파이프도 제공해서 편리하다

노드의 편리함과 스프링의 명확한 구조가 합쳐진 느낌

✅ READ - 없는 board를 가져오려 할 때 예외 처리

./boards/boards.service.ts

getBoardById(id: string): Board {
    const found = this.boards.find((board) => board.id === id);

    if (!found) {
        throw new NotFoundException(`Can't find Board with id ${id}`);
    }

    return found;
}

NotFoundException 또한 Nest가 기본적으로 제공하는 인스턴스

인자로 문자열을 주면 response에 해당 message가 실려 나간다

✅ DELETE - 없는 board를 지우려 할 때 예외 처리

./boards/boards.service.ts

deleteBoard(id: string): void {
    const found = this.getBoardById(id);
    this.boards = this.boards.filter((board) => board.id !== found.id);
}

getBoardById에 이미 예외처리 구문을 설정했으므로

일단 찾아서 일치하는지 확인해주는 라인만 추가

만약 해당 id에 해당하는 board가 없다면 getBoardById 메서드에서 예외 처리 진행

✅ 커스텀 파이프 구현

./boards/pipes/board-status-validation.pipe.ts

import {
    ArgumentMetadata,
    BadRequestException,
    PipeTransform,
} from '@nestjs/common';
import { BoardStatus } from '../board.model';

export class BoardStatusValidationPipe implements PipeTransform {
    readonly StatusOptions = [BoardStatus.PRIVATE, BoardStatus.PUBLIC];

    transform(value: any, metadata: ArgumentMetadata) {
        value = value.toUpperCase();

        if (!this.isStatusValid(value)) {
            throw new BadRequestException(
                `${value} isn't in the status options`,
            );
        }

        return value;
    }

    private isStatusValid(status: any) {
        const index = this.StatusOptions.indexOf(status);
        return index !== -1;
    }
}

커스텀 파이프를 구현하기 위해서는 반드시

1. PipeTransform 인터페이스를 가져와서

2. transform 메서드를 오버라이딩 해주어야 한다

PipeTransform 인터페이스 또한 Nest가 기본적으로 가지고 있다

여기서는 BoardStatus 의 두가지 상태를 가져와서

이 두 상태가 아닌 인자가 전달이 되면 400 에러를 응답하도록 했다

아직까지는 편리한 기능이 많은 거 같고 쉽다

아마도?