스프링 부트로 마이크로서비스 아키텍처 구현하기 🚀

안녕, 친구들! 오늘은 정말 흥미진진한 주제로 이야기를 나눠볼 거야. 바로 스프링 부트를 사용해서 마이크로서비스 아키텍처를 구현하는 방법에 대해 알아볼 거거든. 😎

혹시 재능넷(https://www.jaenung.net)이라는 사이트 들어봤어? 여기서는 다양한 재능을 거래할 수 있어. 그런데 말이야, 이런 플랫폼을 만들려면 어떻게 해야 할까? 바로 마이크로서비스 아키텍처가 답이 될 수 있어! 그럼 이제부터 본격적으로 파헤쳐 볼까?

마이크로서비스란 뭐야? 🤔

자, 먼저 마이크로서비스가 뭔지부터 알아보자. 쉽게 말해서 마이크로서비스는 큰 애플리케이션을 작은 서비스들로 쪼개는 거야. 각각의 서비스는 독립적으로 돌아가면서 서로 통신해. 마치 여러 명의 전문가가 팀을 이뤄 일하는 것처럼 말이야!

위의 그림을 보면 마이크로서비스 아키텍처가 어떻게 생겼는지 한눈에 알 수 있지? 각각의 동그라미가 하나의 서비스를 나타내고, 이들이 서로 연결되어 있어. 그리고 아래에 있는 API Gateway는 이 모든 서비스들을 관리하고 외부 요청을 적절한 서비스로 라우팅해주는 역할을 해.

마이크로서비스의 장점 👍

• 확장성이 좋아: 필요한 서비스만 독립적으로 확장할 수 있어.
• 유지보수가 쉬워: 각 서비스가 독립적이라 수정이 간편해.
• 기술 다양성: 각 서비스마다 다른 기술 스택을 사용할 수 있어.
• 장애 격리: 한 서비스에 문제가 생겨도 다른 서비스는 계속 작동해.

마이크로서비스의 단점 👎

• 복잡성 증가: 여러 서비스를 관리하는 게 쉽지 않아.
• 네트워크 오버헤드: 서비스 간 통신이 많아져 성능에 영향을 줄 수 있어.
• 데이터 일관성 유지: 여러 서비스에 걸친 트랜잭션 관리가 어려워.

자, 이제 마이크로서비스가 뭔지 대충 감이 왔지? 그럼 이제 스프링 부트로 어떻게 이걸 구현하는지 알아보자고!

스프링 부트로 시작하기 🌱

스프링 부트는 마이크로서비스를 구현하기에 정말 좋은 프레임워크야. 왜냐고? 설정이 간편하고, 내장 서버를 제공하며, 다양한 스프링 생태계의 기능을 쉽게 사용할 수 있거든!

스프링 부트 프로젝트 시작하기

먼저, 스프링 부트 프로젝트를 시작해보자. Spring Initializr(https://start.spring.io/)를 사용하면 정말 쉽게 프로젝트를 만들 수 있어.

1. Spring Initializr 사이트에 접속해.
2. Project: Maven Project
3. Language: Java
4. Spring Boot: 최신 안정 버전 선택
5. Group: com.example
6. Artifact: microservice-demo
7. Dependencies: Spring Web, Spring Data JPA, H2 Database 추가

이렇게 설정하고 'Generate' 버튼을 누르면 기본 프로젝트가 다운로드 돼. 이제 이걸 IDE에서 열어보자!

기본 구조 살펴보기

프로젝트를 열면 다음과 같은 구조가 보일 거야:

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── microservicedemo
│   │               └── MicroserviceDemoApplication.java
│   └── resources
│       ├── application.properties
│       ├── static
│       └── templates
└── test
    └── java
        └── com
            └── example
                └── microservicedemo
                    └── MicroserviceDemoApplicationTests.java
  

이 구조에서 우리가 주목해야 할 부분은 MicroserviceDemoApplication.java와 application.properties야. 전자는 애플리케이션의 진입점이고, 후자는 설정 파일이야.

Hello World 마이크로서비스 만들기

자, 이제 간단한 "Hello World" 마이크로서비스를 만들어볼까? MicroserviceDemoApplication.java 파일을 열고 다음과 같이 수정해봐:

package com.example.microservicedemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class MicroserviceDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(MicroserviceDemoApplication.class, args);
    }

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Microservice World!";
    }
}
  

이제 애플리케이션을 실행하고 브라우저에서 http://localhost:8080/hello에 접속하면 "Hello, Microservice World!"라는 메시지를 볼 수 있을 거야. 축하해, 네가 방금 첫 번째 마이크로서비스를 만든 거야! 🎉

마이크로서비스 아키텍처 설계하기 🏗️

좋아, 이제 기본적인 마이크로서비스를 만들어봤으니 좀 더 복잡한 시스템을 설계해볼까? 재능넷 같은 플랫폼을 예로 들어서 설명해볼게.

시스템 구성요소

재능넷 같은 플랫폼은 다음과 같은 주요 서비스들로 구성될 수 있어:

• 사용자 서비스: 회원가입, 로그인, 프로필 관리
• 재능 서비스: 재능 등록, 검색, 조회
• 주문 서비스: 재능 구매, 주문 관리
• 결제 서비스: 결제 처리, 환불
• 리뷰 서비스: 리뷰 작성, 조회
• 알림 서비스: 이메일, 푸시 알림

이렇게 나누면 각 서비스가 독립적으로 개발되고 운영될 수 있어. 예를 들어, 결제 시스템을 업그레이드하고 싶다면 다른 서비스에 영향을 주지 않고 결제 서비스만 수정하면 돼.

위 그림을 보면 각 서비스가 어떻게 연결되어 있는지 볼 수 있어. API Gateway를 통해 외부 요청이 들어오면, 적절한 서비스로 라우팅돼. 이렇게 하면 클라이언트는 하나의 엔드포인트만 알면 되고, 내부적으로 서비스들이 어떻게 구성되어 있는지 신경 쓰지 않아도 돼.

서비스 간 통신

마이크로서비스 아키텍처에서 서비스 간 통신은 정말 중요해. 주로 두 가지 방식을 사용하지:

1. 동기 통신 (Synchronous Communication): REST API를 이용한 HTTP 요청/응답
2. 비동기 통신 (Asynchronous Communication): 메시지 큐를 이용한 이벤트 기반 통신

예를 들어, 사용자가 재능을 구매할 때 다음과 같은 과정이 일어날 수 있어:

1. 주문 서비스가 사용자 서비스에 동기적으로 요청을 보내 사용자 정보를 확인해.
2. 주문이 생성되면, 주문 서비스가 결제 서비스에 동기적으로 요청을 보내 결제를 진행해.
3. 결제가 완료되면, 주문 서비스가 메시지 큐에 비동기적으로 이벤트를 발행해.
4. 알림 서비스가 이 이벤트를 구독하고 있다가, 이벤트를 받으면 사용자에게 알림을 보내.

데이터베이스 전략

마이크로서비스 아키텍처에서는 각 서비스가 자신만의 데이터베이스를 가지는 것이 일반적이야. 이를 Database per Service 패턴이라고 해. 이렇게 하면 각 서비스가 완전히 독립적으로 운영될 수 있어.

하지만 이 방식에는 도전과제도 있어:

• 데이터 일관성: 여러 서비스에 걸친 트랜잭션을 관리하기 어려워.
• 데이터 중복: 일부 데이터가 여러 서비스에 중복될 수 있어.
• 쿼리 복잡성: 여러 서비스의 데이터를 조합해야 하는 쿼리가 복잡해질 수 있어.

이런 문제를 해결하기 위해 다음과 같은 전략을 사용할 수 있어:

• SAGA 패턴: 분산 트랜잭션을 관리하기 위한 패턴
• CQRS (Command Query Responsibility Segregation): 읽기와 쓰기 작업을 분리하는 패턴
• 이벤트 소싱: 상태 변경을 이벤트로 저장하는 방식

재능넷의 경우, 예를 들어 사용자 서비스는 사용자 정보를, 재능 서비스는 재능 정보를, 주문 서비스는 주문 정보를 각각 독립적인 데이터베이스에 저장할 수 있어. 그리고 필요한 경우 서비스 간 API 호출이나 이벤트를 통해 데이터를 공유하는 거지.

스프링 부트로 마이크로서비스 구현하기 💻

자, 이제 실제로 스프링 부트를 사용해서 마이크로서비스를 구현해볼 거야. 재능넷의 일부 기능을 예로 들어 설명할게.

1. 사용자 서비스 구현

먼저 사용자 서비스를 만들어보자. 이 서비스는 사용자 등록, 조회, 수정 등의 기능을 담당할 거야.

@SpringBootApplication
@RestController
@RequestMapping("/users")
public class UserServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        // 사용자 생성 로직
        return ResponseEntity.ok(user);
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        // 사용자 조회 로직
        User user = new User(id, "John Doe", "john@example.com");
        return ResponseEntity.ok(user);
    }
}

class User {
    private Long id;
    private String name;
    private String email;

    // 생성자, getter, setter 생략
}
  

이 코드는 간단한 사용자 서비스를 구현한 거야. /users 엔드포인트로 POST 요청을 보내면 새 사용자를 생성하고, /users/{id}로 GET 요청을 보내면 해당 ID의 사용자 정보를 반환해.

2. 재능 서비스 구현

다음은 재능 서비스를 만들어볼까? 이 서비스는 재능 등록, 검색, 조회 등의 기능을 담당해.

@SpringBootApplication
@RestController
@RequestMapping("/talents")
public class TalentServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(TalentServiceApplication.class, args);
    }

    @PostMapping
    public ResponseEntity<Talent> createTalent(@RequestBody Talent talent) {
        // 재능 등록 로직
        return ResponseEntity.ok(talent);
    }

    @GetMapping
    public ResponseEntity<List<Talent>> searchTalents(@RequestParam String keyword) {
        // 재능 검색 로직
        List<Talent> talents = Arrays.asList(
            new Talent(1L, "웹 개발", "프론트엔드, 백엔드 개발 가능"),
            new Talent(2L, "디자인", "로고, 배너 디자인 전문")
        );
        return ResponseEntity.ok(talents);
    }
}

class Talent {
    private Long id;
    private String title;
    private String description;

    // 생성자, getter, setter 생략
}
  

이 코드는 재능 서비스의 기본 기능을 구현한 거야. /talents 엔드포인트로 POST 요청을 보내면 새 재능을 등록하고, GET 요청을 보내면 키워드로 재능을 검색할 수 있어.

3. 서비스 간 통신 구현

이제 서비스 간 통신을 구현해볼 거야. 예를 들어, 주문 서비스에서 사용자 정보와 재능 정보가 필요한 경우를 생각해보자.

@SpringBootApplication
@RestController
@RequestMapping("/orders")
public class OrderServiceApplication {

    @Autowired
    private RestTemplate restTemplate;  네, 계속해서 OrderServiceApplication 클래스의 구현을 이어가겠습니다.

    @PostMapping
    public ResponseEntity<order> createOrder(@RequestBody Order order) {
        // 사용자 정보 확인
        User user = restTemplate.getForObject("http://user-service/users/" + order.getUserId(), User.class);
        if (user == null) {
            return ResponseEntity.badRequest().build();
        }

        // 재능 정보 확인
        Talent talent = restTemplate.getForObject("http://talent-service/talents/" + order.getTalentId(), Talent.class);
        if (talent == null) {
            return ResponseEntity.badRequest().build();
        }

        // 주문 생성 로직
        order.setStatus("CREATED");
        
        // 결제 서비스 호출
        PaymentResult result = restTemplate.postForObject("http://payment-service/payments", new Payment(order.getId(), order.getAmount()), PaymentResult.class);
        if (result.isSuccess()) {
            order.setStatus("PAID");
        } else {
            order.setStatus("PAYMENT_FAILED");
        }

        // 주문 저장 로직 (생략)

        return ResponseEntity.ok(order);
    }

    @GetMapping("/{id}")
    public ResponseEntity<order> getOrder(@PathVariable Long id) {
        // 주문 조회 로직
        Order order = new Order(id, 1L, 1L, 50000, "PAID");
        return ResponseEntity.ok(order);
    }
}

class Order {
    private Long id;
    private Long userId;
    private Long talentId;
    private int amount;
    private String status;

    // 생성자, getter, setter 생략
}

class Payment {
    private Long orderId;
    private int amount;

    // 생성자, getter, setter 생략
}

class PaymentResult {
    private boolean success;

    // 생성자, getter, setter 생략
}
</order></order>

이 코드는 주문 서비스를 구현한 거야. 주문을 생성할 때 사용자 서비스와 재능 서비스를 호출해서 정보를 확인하고, 결제 서비스를 호출해서 결제를 진행해. 이렇게 하면 서비스 간 통신이 이루어지는 거지.

4. 서비스 디스커버리와 로드 밸런싱

마이크로서비스 아키텍처에서는 서비스 디스커버리와 로드 밸런싱이 중요해. 스프링 클라우드의 Eureka를 사용해서 이를 구현할 수 있어.

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

이렇게 Eureka 서버를 설정하고, 각 마이크로서비스에 Eureka 클라이언트를 추가하면 돼:

@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
    // ...
}

5. API Gateway 구현

마지막으로, API Gateway를 구현해볼게. 스프링 클라우드 게이트웨이를 사용할 거야.

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

    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("user_route", r -> r.path("/users/**")
                .uri("lb://user-service"))
            .route("talent_route", r -> r.path("/talents/**")
                .uri("lb://talent-service"))
            .route("order_route", r -> r.path("/orders/**")
                .uri("lb://order-service"))
            .build();
    }
}

이 코드는 API Gateway를 구현한 거야. 각 경로에 따라 적절한 서비스로 요청을 라우팅해주지.

마무리

자, 여기까지 스프링 부트로 마이크로서비스를 구현하는 방법에 대해 알아봤어. 물론 이게 전부는 아니야. 실제 프로덕션 환경에서는 더 많은 것들을 고려해야 해:

• 보안: OAuth2, JWT 등을 이용한 인증/인가
• 모니터링: 프로메테우스, 그라파나 등을 이용한 시스템 모니터링
• 로깅: ELK 스택 등을 이용한 중앙 집중식 로깅
• CI/CD: Jenkins, GitLab CI 등을 이용한 지속적 통합/배포
• 컨테이너화: Docker, Kubernetes 등을 이용한 컨테이너 관리

하지만 걱정하지 마. 이런 것들은 천천히 하나씩 배워나가면 돼. 지금까지 배운 내용만으로도 충분히 멋진 마이크로서비스 기반 애플리케이션을 만들 수 있을 거야!

자, 이제 너의 차례야. 이 지식을 바탕으로 멋진 프로젝트를 만들어봐. 화이팅! 🚀