MSA에서 서비스 통신 방법: 동기, 비동기, 그리고 그 너머

안녕하세요! 오늘은 마이크로서비스 아키텍처(MSA)에서 서비스 간 통신을 구현하는 다양한 방법을 살펴보고, 각각의 장단점을 정리해보려고 합니다. MSA에서는 서비스가 독립적으로 동작하기 때문에 통신 방식이 성능, 유연성, 유지보수성에 큰 영향을 미치죠. 이번 글에서는 동기 방식(HTTP/OpenFeign), 비동기 방식(메시지큐/Kafka), 그리고 제로 페이로드, GraphQL, gRPC까지 다뤄보겠습니다. 그럼 시작해볼까요?

1. 동기 통신: HTTP (OpenFeign)

설명:
HTTP는 MSA에서 가장 널리 사용되는 동기 통신 방식입니다. RESTful API를 통해 서비스 간 요청과 응답을 주고받죠. Spring Boot에서는 OpenFeign 같은 선언적 HTTP 클라이언트를 사용하면 코드가 간결해지고 외부 API 호출이 쉬워집니다. 예를 들어, 주문 서비스가 상품 서비스에 "재고 확인" 요청을 보내고 즉시 응답을 받는 식이에요.

장점:

• 직관적: 요청과 응답이 바로 이어져 로직이 단순하고 이해하기 쉬움.
• 즉시성: 결과를 실시간으로 받아야 하는 경우 적합 (예: 결제 처리).
• 생태계: REST API는 표준화되어 있어 도구와 라이브러리가 풍부함.

단점:

• 강한 결합: 호출하는 서비스가 응답을 기다려야 하므로 의존성이 강해질 수 있음.
• 지연: 응답이 느리거나 호출받는 서비스가 다운되면 전체 흐름이 멈춤.
• 확장성 한계: 트래픽이 많아지면 동기 호출이 병목현상을 일으킬 가능성 있음.

2. 비동기 통신: 메시지큐 (Kafka)

설명:
비동기 통신은 메시지큐를 통해 서비스 간 데이터를 전달합니다. Apache Kafka는 대표적인 메시지 브로커로, 프로듀서가 토픽에 메시지를 보내고 컨슈머가 이를 비동기적으로 처리하죠. 예를 들어, 주문 서비스가 "주문 생성" 이벤트를 Kafka에 보내고, 배송 서비스가 나중에 이를 받아 처리하는 방식입니다.

장점:

• 느슨한 결합: 서비스가 서로 직접 호출하지 않아 독립성이 높아짐.
• 확장성: 높은 처리량과 대규모 이벤트 처리가 가능 (Kafka의 강점!).
• 장애 내성: 한 서비스가 실패해도 메시지가 큐에 남아 있어 복구 후 처리 가능.

단점:

• 복잡성: 메시지 브로커 설정, 토픽 관리 등 추가 인프라가 필요.
• 지연 가능성: 실시간 응답이 필요한 경우 부적합.
• 추적 어려움: 메시지 흐름이 분산되어 디버깅이 까다로울 수 있음.

3. 제로 페이로드 (Zero Payload)

설명:
제로 페이로드는 데이터 자체를 주고받지 않고, 참조(예: ID나 URL)만 전달하는 방식입니다. 수신 서비스가 필요한 데이터를 직접 조회하죠. 예를 들어, 주문 서비스가 "상품 ID"만 보내고, 재고 서비스가 DB에서 해당 데이터를 가져오는 식이에요.

장점:

• 경량화: 네트워크 부하가 줄어 빠른 통신 가능.
• 유연성: 수신 측에서 필요한 데이터만 조회해 처리 가능.
• 단순성: 페이로드 구조를 신경 쓸 필요 없음.

단점:

• 추가 요청: 데이터를 조회하려면 별도 호출이 필요해 지연 발생 가능.
• 의존성: 수신 서비스가 데이터 소스에 접근할 수 있어야 함.
• 일관성 문제: 참조 데이터가 변경되면 불일치 위험이 있음.

4. GraphQL

설명:
GraphQL은 클라이언트가 필요한 데이터만 요청할 수 있는 쿼리 언어 기반 API입니다. MSA에서는 여러 서비스의 데이터를 하나의 GraphQL 엔드포인트로 통합해 제공하거나, 서비스 간 통신에 사용할 수 있어요. 예를 들어, 주문 서비스가 상품과 사용자 데이터를 한 번에 요청할 수 있죠.

장점:

• 효율성: 필요한 데이터만 받아 과다/과소 페칭 문제를 해결.
• 유연성: 클라이언트가 요청 형식을 자유롭게 정의 가능.
• 단일 엔드포인트: 여러 서비스 호출을 하나로 통합 가능.

단점:

• 복잡성: 서버 측에서 스키마 정의와 리졸버 구현이 필요.
• 캐싱 어려움: HTTP GET 기반 REST에 비해 캐싱이 까다로움.
• 오버헤드: 쿼리 파싱과 실행에 추가 리소스 소요.

5. gRPC

설명:
gRPC는 Google에서 개발한 고성능 RPC(Remote Procedure Call) 프레임워크로, HTTP/2와 Protocol Buffers(Protobuf)를 사용합니다. MSA에서 서비스 간 빠르고 효율적인 통신을 위해 사용되죠. 예를 들어, 주문 서비스가 재고 서비스의 함수를 직접 호출하듯 사용할 수 있습니다.

장점:

• 고성능: 이진 데이터(Protobuf)와 HTTP/2로 속도가 빠름.
• 타입 안정성: Protobuf로 인터페이스 정의 시 컴파일 타임에 오류 체크 가능.
• 스트리밍 지원: 양방향 스트리밍으로 실시간 통신 가능.

단점:

• 학습 곡선: Protobuf와 gRPC 설정이 처음에는 낯설 수 있음.
• 호환성: REST에 비해 브라우저 지원이 제한적.
• 복잡성: 설정과 디버깅이 HTTP보다 까다로울 수 있음.

어떤 방식을 선택할까?

• 실시간 응답 필요: HTTP(OpenFeign) 또는 gRPC.
• 대규모 이벤트 처리: Kafka.
• 최소 데이터 전송: 제로 페이로드.
• 클라이언트 유연성: GraphQL.
• 최고 성능: gRPC.

각 방법은 사용 사례와 요구사항에 따라 빛을 발합니다. 예를 들어, 결제처럼 즉시 응답이 필요한 경우는 OpenFeign, 주문 이벤트 전파처럼 비동기 처리가 적합한 경우는 Kafka를 선택하면 좋겠죠. 여러 방식을 조합해 사용하는 것도 좋은 전략이에요!

마무리

MSA에서 서비스 통신은 시스템의 성공을 좌우하는 핵심 요소입니다. 이번 글에서 다룬 다섯 가지 방법의 장단점을 이해하고, 프로젝트에 맞는 방식을 골라보세요.

Kafka와 Spring Boot로 메시지 보내고 받기

안녕하세요! 오늘은 분산 메시징 시스템인 Apache Kafka를 Spring Boot와 함께 사용해 메시지를 보내고 받는 방법을 알아보려고 합니다. Kafka는 대규모 데이터 처리나 실시간 스트리밍에 강력한 도구인데요, Spring Boot와 통합하면 설정도 간단하고 코드도 깔끔해집니다. 바로 시작해볼까요?

Kafka란?

Kafka는 LinkedIn에서 개발된 오픈소스 메시징 시스템으로, 높은 처리량과 확장성을 자랑합니다. **프로듀서(Producer)**가 메시지를 보내고, **컨슈머(Consumer)**가 이를 받아 처리하는 방식으로 동작하죠. 메시지는 **토픽(Topic)**이라는 카테고리에 저장되며, 필요에 따라 여러 컨슈머가 동일한 토픽을 구독할 수 있습니다.

이제 Spring Boot에서 Kafka를 활용하는 방법을 단계별로 살펴보겠습니다.

Spring Boot에서 Kafka 사용하기

Kafka를 사용하려면 먼저 Kafka 브로커가 실행 중이어야 합니다. 로컬에서 테스트하려면 Kafka 공식 사이트에서 다운로드해 실행하거나, Docker를 사용하는 것도 추천드려요. 여기서는 기본 설정을 기준으로 진행하겠습니다.

<카프카 실행 실습>

1. 의존성 추가

pom.xml에 Spring Kafka 의존성을 추가합니다.

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>

Spring Boot 버전에 따라 자동으로 적합한 Kafka 클라이언트가 포함되니, 별도로 버전을 명시하지 않아도 됩니다.

2. Kafka 설정 (application.yml)

Kafka 브로커와 연결 설정을 application.yml에 추가합니다.

spring:
  kafka:
    bootstrap-servers: localhost:9092  # Kafka 브로커 주소
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer:
      group-id: my-group  # 컨슈머 그룹 ID
      auto-offset-reset: earliest  # 처음부터 메시지 읽기
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

• bootstrap-servers: Kafka 브로커가 실행 중인 주소.
• serializers/deserializers: 메시지의 키와 값을 문자열로 직렬화/역직렬화.

3. 메시지 보내기 (Producer)

Spring Kafka는 KafkaTemplate을 제공해 메시지 전송을 쉽게 처리할 수 있습니다. 토픽에 메시지를 보내는 서비스를 만들어보죠.

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class KafkaProducerService {

    private static final String TOPIC = "my-topic";
    private final KafkaTemplate<String, String> kafkaTemplate;

    public KafkaProducerService(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public void sendMessage(String message) {
        kafkaTemplate.send(TOPIC, message);
        System.out.println("Message sent: " + message);
    }
}

• KafkaTemplate: Spring이 자동으로 주입해주는 템플릿.
• send: 토픽 이름과 메시지를 인자로 전달해 전송.

4. 컨트롤러에서 Producer 호출

간단한 REST 엔드포인트를 만들어 메시지를 보내보겠습니다.

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class KafkaController {

    private final KafkaProducerService producerService;

    public KafkaController(KafkaProducerService producerService) {
        this.producerService = producerService;
    }

    @PostMapping("/send")
    public String sendMessage(@RequestParam String message) {
        producerService.sendMessage(message);
        return "Message sent to Kafka: " + message;
    }
}

5. 메시지 받기 (Consumer)

이제 토픽에서 메시지를 받아오는 컨슈머를 작성합니다. @KafkaListener 어노테이션을 사용하면 매우 간단하죠.

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class KafkaConsumerService {

    @KafkaListener(topics = "my-topic", groupId = "my-group")
    public void listen(String message) {
        System.out.println("Received message: " + message);
    }
}

• @KafkaListener: 지정한 토픽의 메시지를 감지해 메서드를 실행.
• groupId: 컨슈머 그룹을 식별. 같은 그룹 내 컨슈머는 메시지를 나누어 처리.

6. 실행 및 테스트

1. Kafka 브로커를 실행합니다 (예: bin/kafka-server-start.sh config/server.properties).
2. Spring Boot 애플리케이션을 실행합니다.
3. Postman이나 curl로 POST http://localhost:8080/send?message=Hello Kafka! 요청을 보냅니다.

그러면 콘솔에서:

• Producer: "Message sent: Hello Kafka!"
• Consumer: "Received message: Hello Kafka!"

이렇게 출력되는 걸 확인할 수 있습니다!

추가 팁: JSON 메시지 처리

문자열 대신 JSON 객체를 주고받고 싶다면, JsonSerializer와 JsonDeserializer를 사용하세요. 의존성에 jackson-databind를 추가하고 설정을 변경하면 됩니다.

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

application.yml 수정:

spring:
  kafka:
    producer:
      value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
    consumer:
      value-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
      properties:
        spring.json.trusted.packages: "*"  # 역직렬화 시 신뢰할 패키지

그리고 DTO 클래스를 만들어 사용하면 됩니다 (예: Message 클래스).

마무리

Spring Boot와 Kafka를 함께 사용하면 메시지 기반 시스템을 정말 쉽게 구축할 수 있습니다. 이번 예제는 기본적인 Producer와 Consumer 설정을 다뤘는데요, 토픽 파티션 관리나 에러 처리 등 더 깊은 주제도 탐구해보시면 좋을 거예요. Kafka의 세계에 입문해보고 싶었다면, 지금이 시작할 완벽한 타이밍입니다!

OpenFeign이란? Spring Boot에서 활용하는 방법까지 알아보자

안녕하세요! 오늘은 마이크로서비스 개발에서 자주 활용되는 OpenFeign에 대해 알아보고, Spring Boot에서 이를 어떻게 사용할 수 있는지 예시와 함께 설명해보려고 합니다. REST API 호출을 단순화하고 코드 가독성을 높이고 싶은 분들에게 특히 유용한 도구인데요, 그럼 바로 시작해볼까요?

OpenFeign이란?

OpenFeign은 Netflix에서 개발한 오픈소스 프로젝트로, HTTP 클라이언트 라이브러리입니다. Spring Boot와 같은 프레임워크에서 외부 API를 호출할 때, 복잡한 HTTP 요청 코드를 작성하지 않고 간단한 인터페이스 정의만으로 호출을 처리할 수 있게 해줍니다. 특히 마이크로서비스 아키텍처에서 서비스 간 통신을 쉽게 만들어주는 도구로 사랑받고 있죠.

Feign의 특징을 간단히 정리하면:

• 선언적 방식: 인터페이스에 어노테이션을 붙여 API 호출을 정의.
• 통합 용이성: Spring Boot와 결합하면 @FeignClient로 쉽게 설정 가능.
• 확장성: 로드 밸런싱, 로깅, 에러 처리 등을 커스터마이징할 수 있음.

Spring Cloud에서 OpenFeign을 지원하면서 더욱 강력해졌는데, 이제 실제로 어떻게 사용하는지 예제를 통해 살펴보겠습니다.

Spring Boot에서 OpenFeign 사용하기

Spring Boot 프로젝트에서 OpenFeign을 설정하고 사용하는 과정을 단계별로 정리해볼게요.

1. 의존성 추가

먼저 pom.xml에 OpenFeign 의존성을 추가해야 합니다. Spring Cloud를 사용하므로 아래와 같이 설정합니다.

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

Spring Cloud 의존성 버전을 관리하려면 <dependencyManagement>에 Spring Cloud BOM(Bill of Materials)을 추가하는 것도 잊지 마세요.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2023.0.0</version> <!-- 최신 버전 확인 필요 -->
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

2. Feign 활성화

Spring Boot 애플리케이션 클래스에 @EnableFeignClients 어노테이션을 추가해 Feign 클라이언트를 활성화합니다.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

3. Feign 클라이언트 인터페이스 정의

이제 외부 API를 호출할 인터페이스를 작성합니다. 예를 들어, JSONPlaceholder라는 무료 API에서 게시글 데이터를 가져오는 클라이언트를 만들어볼게요.

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "jsonplaceholder", url = "https://jsonplaceholder.typicode.com")
public interface PostClient {

    @GetMapping("/posts/{id}")
    Post getPostById(@PathVariable("id") Long id);
}

• @FeignClient: 클라이언트의 이름과 호출할 기본 URL을 지정.
• @GetMapping: HTTP 메서드와 엔드포인트를 정의. Spring의 REST 어노테이션을 사용.
• Post: 응답 데이터를 매핑할 DTO 클래스 (아래에 정의).

4. DTO 클래스 작성

API 응답을 받을 데이터 객체를 정의합니다.

public class Post {
    private Long id;
    private Long userId;
    private String title;
    private String body;

    // 기본 생성자, getter, setter 생략 (Lombok 사용 가능)
}

5. 서비스에서 클라이언트 사용

이제 Feign 클라이언트를 서비스 계층에서 주입받아 사용해봅시다.

import org.springframework.stereotype.Service;

@Service
public class PostService {

    private final PostClient postClient;

    public PostService(PostClient postClient) {
        this.postClient = postClient;
    }

    public Post fetchPost(Long id) {
        return postClient.getPostById(id);
    }
}

6. 컨트롤러에서 호출

마지막으로 컨트롤러에서 서비스를 호출해 결과를 확인합니다.

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class PostController {

    private final PostService postService;

    public PostController(PostService postService) {
        this.postService = postService;
    }

    @GetMapping("/posts/{id}")
    public Post getPost(@PathVariable Long id) {
        return postService.fetchPost(id);
    }
}

7. 실행 및 테스트

애플리케이션을 실행한 뒤, 브라우저나 Postman으로 http://localhost:8080/posts/1에 접속하면 JSONPlaceholder에서 ID가 1인 게시글 데이터를 JSON 형태로 받아볼 수 있습니다!

추가 팁: 로깅과 에러 처리

• 로깅: application.yml에 feign.client.config.jsonplaceholder.logging-level: FULL을 추가하면 요청/응답을 자세히 로그로 확인할 수 있어요.
• 에러 처리: FeignException을 캐치하거나, @FeignClient에 fallback 속성을 추가해 예외 발생 시 대체 로직을 설정할 수도 있습니다.

마무리

OpenFeign은 복잡한 HTTP 호출 코드를 인터페이스 하나로 깔끔하게 정리할 수 있게 해주는 강력한 도구입니다. Spring Boot와 함께 사용하면 설정도 간단하고, 마이크로서비스 환경에서 특히 빛을 발하죠. 이번 예제를 참고해 직접 적용해보시며, OpenFeign을 사용해보세요!