Node.js 인터뷰 질문 50
질문: Node.js를 사용한 마이크로서비스 아키텍처의 구현 방법과 장단점에 대해 설명해주세요.
답변:
마이크로서비스 아키텍처는 하나의 큰 애플리케이션을 여러 개의 작은, 독립적인 서비스로 분할하는 소프트웨어 아키텍처 패턴입니다. Node.js는 가볍고, 비동기적이며, 이벤트 기반인 특성 덕분에 마이크로서비스 구현에 매우 적합한 기술입니다.
Node.js 마이크로서비스 구현 방법
1. 서비스 설계 및 분리
마이크로서비스 아키텍처에서는 각 서비스가 특정 비즈니스 기능을 담당하며, 독립적으로 개발, 배포, 확장이 가능해야 합니다.
// 사용자 서비스 예시 (user-service.js)
const express = require("express");
const app = express();
app.use(express.json());
// 사용자 관련 API 엔드포인트
app.get("/users/:id", async (req, res) => {
// 사용자 정보 조회 로직
const user = await getUserById(req.params.id);
res.json(user);
});
app.post("/users", async (req, res) => {
// 사용자 생성 로직
const newUser = await createUser(req.body);
res.status(201).json(newUser);
});
app.listen(3001, () => {
console.log("사용자 서비스가 포트 3001에서 실행 중입니다.");
});
// 상품 서비스 예시 (product-service.js)
const express = require("express");
const app = express();
app.use(express.json());
// 상품 관련 API 엔드포인트
app.get("/products/:id", async (req, res) => {
// 상품 정보 조회 로직
const product = await getProductById(req.params.id);
res.json(product);
});
app.post("/products", async (req, res) => {
// 상품 생성 로직
const newProduct = await createProduct(req.body);
res.status(201).json(newProduct);
});
app.listen(3002, () => {
console.log("상품 서비스가 포트 3002에서 실행 중입니다.");
});
2. 서비스 간 통신 구현
마이크로서비스 간 통신은 주로 HTTP/REST, gRPC, 또는 메시지 큐(RabbitMQ, Kafka 등)를 통해 이루어집니다.
HTTP/REST 통신 예시:
// 주문 서비스에서 사용자 서비스와 상품 서비스로 요청 보내기
const axios = require("axios");
async function createOrder(userId, productId, quantity) {
try {
// 사용자 서비스로 사용자 정보 요청
const userResponse = await axios.get(
`http://user-service:3001/users/${userId}`
);
const user = userResponse.data;
// 상품 서비스로 상품 정보 요청
const productResponse = await axios.get(
`http://product-service:3002/products/${productId}`
);
const product = productResponse.data;
// 재고 확인 및 주문 생성 로직
if (product.stock >= quantity) {
// 주문 생성 로직
return { orderId: generateOrderId(), user, product, quantity };
} else {
throw new Error("재고 부족");
}
} catch (error) {
console.error("주문 생성 실패:", error);
throw error;
}
}
메시지 큐를 사용한 통신 예시 (RabbitMQ):
// 메시지 생산자 (producer.js)
const amqp = require("amqplib");
async function publishOrderEvent(order) {
try {
const connection = await amqp.connect("amqp://localhost");
const channel = await connection.createChannel();
const queue = "order_events";
await channel.assertQueue(queue, { durable: true });
channel.sendToQueue(queue, Buffer.from(JSON.stringify(order)), {
persistent: true,
});
console.log(`주문 이벤트 발행: ${order.orderId}`);
setTimeout(() => {
connection.close();
}, 500);
} catch (error) {
console.error("메시지 발행 실패:", error);
}
}
// 새 주문이 생성되면 이벤트 발행
const order = { orderId: "12345", userId: "1", productId: "101", quantity: 2 };
publishOrderEvent(order);
// 메시지 소비자 (consumer.js)
const amqp = require("amqplib");
async function consumeOrderEvents() {
try {
const connection = await amqp.connect("amqp://localhost");
const channel = await connection.createChannel();
const queue = "order_events";
await channel.assertQueue(queue, { durable: true });
console.log("주문 이벤트 대기 중...");
channel.consume(queue, (msg) => {
if (msg !== null) {
const order = JSON.parse(msg.content.toString());
console.log(`주문 이벤트 수신: ${order.orderId}`);
// 주문 처리 로직
processOrder(order);
channel.ack(msg);
}
});
} catch (error) {
console.error("메시지 소비 실패:", error);
}
}
function processOrder(order) {
// 주문 처리 로직
console.log(`주문 ${order.orderId} 처리 중...`);
}
consumeOrderEvents();
3. API 게이트웨이 구현
API 게이트웨이는 클라이언트와 마이크로서비스 사이의 중간 계층으로, 요청 라우팅, 인증/인가, 로드 밸런싱 등을 담당합니다.
// api-gateway.js
const express = require("express");
const { createProxyMiddleware } = require("http-proxy-middleware");
const app = express();
// 인증 미들웨어
function authenticate(req, res, next) {
const token = req.headers.authorization;
if (!token) {
return res.status(401).json({ error: "인증 필요" });
}
// 토큰 검증 로직
// ...
next();
}
// 사용자 서비스로 요청 프록시
app.use(
"/api/users",
authenticate,
createProxyMiddleware({
target: "http://user-service:3001",
pathRewrite: {
"^/api/users": "/users",
},
changeOrigin: true,
})
);
// 상품 서비스로 요청 프록시
app.use(
"/api/products",
authenticate,
createProxyMiddleware({
target: "http://product-service:3002",
pathRewrite: {
"^/api/products": "/products",
},
changeOrigin: true,
})
);
// 주문 서비스로 요청 프록시
app.use(
"/api/orders",
authenticate,
createProxyMiddleware({
target: "http://order-service:3003",
pathRewrite: {
"^/api/orders": "/orders",
},
changeOrigin: true,
})
);
app.listen(3000, () => {
console.log("API 게이트웨이가 포트 3000에서 실행 중입니다.");
});
4. 데이터베이스 관리
마이크로서비스 아키텍처에서는 각 서비스가 자체 데이터베이스를 가지는 것이 일반적입니다(데이터베이스 per 서비스 패턴).
// 사용자 서비스의 데이터베이스 연결
const mongoose = require("mongoose");
mongoose
.connect("mongodb://user-db:27017/userdb", {
useNewUrlParser: true,
useUnifiedTopology: true,
})
.then(() => {
console.log("사용자 데이터베이스에 연결되었습니다.");
})
.catch((err) => {
console.error("데이터베이스 연결 실패:", err);
});
const userSchema = new mongoose.Schema({
name: String,
email: String,
password: String,
});
const User = mongoose.model("User", userSchema);
// 사용자 조회 및 생성 함수
async function getUserById(id) {
return await User.findById(id);
}
async function createUser(userData) {
const user = new User(userData);
return await user.save();
}
5. 서비스 검색 및 등록
서비스 검색 메커니즘을 통해 서비스의 위치(호스트, 포트)를 동적으로 찾을 수 있습니다. Consul, etcd, ZooKeeper 등이 사용됩니다.
// Consul을 사용한 서비스 등록 예시
const Consul = require("consul");
const consul = new Consul({
host: "consul",
port: 8500,
});
// 서비스 등록
consul.agent.service.register(
{
name: "user-service",
address: "user-service",
port: 3001,
check: {
http: "http://user-service:3001/health",
interval: "10s",
},
},
(err) => {
if (err) {
console.error("서비스 등록 실패:", err);
} else {
console.log("사용자 서비스가 Consul에 등록되었습니다.");
}
}
);
// 서비스 검색
function findService(serviceName) {
return new Promise((resolve, reject) => {
consul.catalog.service.nodes(serviceName, (err, result) => {
if (err) {
return reject(err);
}
if (result.length === 0) {
return reject(new Error(`서비스 ${serviceName}를 찾을 수 없습니다.`));
}
// 로드 밸런싱을 위해 랜덤 인스턴스 선택
const instance = result[Math.floor(Math.random() * result.length)];
resolve({
address: instance.ServiceAddress,
port: instance.ServicePort,
});
});
});
}
6. 배포 및 오케스트레이션
Docker 및 Kubernetes를 사용하여 마이크로서비스를 컨테이너화하고 오케스트레이션합니다.
# user-service.yaml (Kubernetes 배포 구성)
apiVersion: apps/v1
kind: Deployment
metadata:
name: user-service
spec:
replicas: 3
selector:
matchLabels:
app: user-service
template:
metadata:
labels:
app: user-service
spec:
containers:
- name: user-service
image: my-registry/user-service:latest
ports:
- containerPort: 3001
env:
- name: MONGODB_URI
value: mongodb://user-db:27017/userdb
resources:
limits:
cpu: "0.5"
memory: "512Mi"
requests:
cpu: "0.2"
memory: "256Mi"
---
apiVersion: v1
kind: Service
metadata:
name: user-service
spec:
selector:
app: user-service
ports:
- port: 3001
targetPort: 3001
type: ClusterIP
Node.js 마이크로서비스의 장점
확장성: 각 서비스를 독립적으로 확장할 수 있어 리소스를 효율적으로 활용할 수 있습니다.
기술 다양성: 각 서비스는 독립적이므로 서비스별로 최적의 기술 스택을 선택할 수 있습니다.
개발 및 배포 속도: 작은 코드베이스와 독립적인 배포는 개발 및 출시 속도를 향상시킵니다.
격리 및 복원력: 하나의 서비스가 실패해도 전체 시스템은 계속 작동할 수 있습니다.
팀 조직: 각 서비스를 담당하는 독립적인 팀 구성이 가능합니다.
Node.js의 비동기 특성: Node.js의 비동기, 이벤트 기반 모델은 I/O 바운드 마이크로서비스에 적합합니다.
Node.js 마이크로서비스의 단점
복잡성 증가: 분산 시스템 관리, 서비스 간 통신, 데이터 일관성 유지 등이 복잡해집니다.
네트워크 오버헤드: 서비스 간 통신이 네트워크를 통해 이루어져 지연이 발생할 수 있습니다.
분산 트랜잭션: 여러 서비스에 걸친 트랜잭션 관리가 어렵습니다.
테스트 및 디버깅 복잡성: 여러 서비스가 연결된 시스템의 테스트와 디버깅이 더 어려워집니다.
운영 오버헤드: 다수의 서비스를 배포하고 모니터링하는 데 추가적인 인프라와 도구가 필요합니다.
메모리 사용량: 각 Node.js 인스턴스가 별도의 메모리를 사용하므로 전체 메모리 사용량이 증가할 수 있습니다.
마이크로서비스 설계 원칙과 모범 사례
단일 책임 원칙: 각 서비스는 하나의 비즈니스 기능만 담당해야 합니다.
자율성: 서비스는 독립적으로 개발, 테스트, 배포, 확장이 가능해야 합니다.
탈중앙화된 데이터 관리: 각 서비스는 자체 데이터베이스를 관리해야 합니다.
장애 격리: 한 서비스의 장애가 전체 시스템에 영향을 미치지 않아야 합니다.
API 설계: 명확하고 잘 정의된 API를 통해 서비스 간 통신이 이루어져야 합니다.
모니터링 및 로깅: 분산 시스템의 모니터링을 위한 집중화된 로깅 및 모니터링 시스템이 필요합니다.
// 집중화된 로깅 예시 (Winston 및 ELK 스택 사용)
const winston = require("winston");
const { ElasticsearchTransport } = require("winston-elasticsearch");
// 로거 설정
const logger = winston.createLogger({
level: "info",
format: winston.format.combine(
winston.format.timestamp(),
winston.format.json()
),
defaultMeta: { service: "user-service" },
transports: [
new winston.transports.Console(),
new ElasticsearchTransport({
level: "info",
clientOpts: {
node: "http://elasticsearch:9200",
},
indexPrefix: "microservices-logs",
}),
],
});
// 로깅 사용 예시
function getUserById(id) {
logger.info(`사용자 조회 요청: ${id}`);
// 사용자 조회 로직
// ...
if (!user) {
logger.warn(`사용자를 찾을 수 없음: ${id}`);
return null;
}
logger.info(`사용자 조회 성공: ${id}`);
return user;
}
마이크로서비스 패턴 구현
1. Circuit Breaker 패턴
서비스 간 통신 실패 시 장애 전파를 방지하는 패턴입니다.
const circuitBreaker = require("opossum");
// Circuit Breaker 설정
const breaker = circuitBreaker(callUserService, {
timeout: 3000, // 타임아웃 시간 (ms)
errorThresholdPercentage: 50, // 장애 비율 임계값
resetTimeout: 10000, // 회로 재설정 시간 (ms)
});
// 폴백 함수 설정
breaker.fallback(() => {
return { id: "default", name: "기본 사용자" };
});
// 이벤트 리스너
breaker.on("open", () => {
console.log("회로가 열렸습니다 (실패 임계값 초과)");
});
breaker.on("close", () => {
console.log("회로가 닫혔습니다 (정상 작동)");
});
breaker.on("halfOpen", () => {
console.log("회로가 반쯤 열렸습니다 (테스트 단계)");
});
// 사용자 서비스 호출
async function callUserService(userId) {
const response = await axios.get(`http://user-service:3001/users/${userId}`);
return response.data;
}
// Circuit Breaker를 통한 서비스 호출
async function getUserWithCircuitBreaker(userId) {
try {
return await breaker.fire(userId);
} catch (error) {
console.error("사용자 서비스 호출 실패:", error);
throw error;
}
}
2. CQRS (Command Query Responsibility Segregation) 패턴
명령(쓰기)과 쿼리(읽기) 책임을 분리하는 패턴입니다.
// 명령 서비스 (Command Service)
app.post("/users", async (req, res) => {
try {
// 사용자 생성 로직
const newUser = await createUser(req.body);
// 이벤트 발행 (사용자 생성됨)
await publishEvent("USER_CREATED", newUser);
res.status(201).json({ id: newUser.id });
} catch (error) {
res.status(500).json({ error: error.message });
}
});
// 쿼리 서비스 (Query Service)
app.get("/users/:id", async (req, res) => {
try {
// 읽기 전용 데이터베이스/캐시에서 사용자 조회
const user = await getUserFromReadModel(req.params.id);
if (!user) {
return res.status(404).json({ error: "사용자를 찾을 수 없습니다." });
}
res.json(user);
} catch (error) {
res.status(500).json({ error: error.message });
}
});
// 이벤트 핸들러 (읽기 모델 업데이트)
async function handleUserCreatedEvent(userData) {
// 읽기 모델(캐시 또는 읽기 전용 DB)에 사용자 데이터 저장
await updateReadModel("users", userData.id, userData);
}
3. API 조합 패턴
여러 서비스의 데이터를 조합하여 클라이언트에 제공하는 패턴입니다.
// API 조합 서비스
app.get("/dashboard/:userId", async (req, res) => {
try {
const userId = req.params.userId;
// 병렬로 여러 서비스에 요청
const [user, orders, recommendations] = await Promise.all([
axios
.get(`http://user-service:3001/users/${userId}`)
.then((res) => res.data),
axios
.get(`http://order-service:3003/orders?userId=${userId}`)
.then((res) => res.data),
axios
.get(
`http://recommendation-service:3004/recommendations?userId=${userId}`
)
.then((res) => res.data),
]);
// 데이터 조합하여 응답
res.json({
user,
recentOrders: orders.slice(0, 5),
recommendations,
});
} catch (error) {
console.error("대시보드 데이터 조회 실패:", error);
res
.status(500)
.json({ error: "대시보드 데이터를 불러오는 데 실패했습니다." });
}
});
요약
Node.js는 가볍고 비동기적인 특성으로 인해 마이크로서비스 아키텍처 구현에 적합한 기술입니다. 마이크로서비스 아키텍처는 확장성, 기술 다양성, 개발 속도 등의 장점을 제공하지만, 복잡성 증가, 네트워크 오버헤드, 분산 트랜잭션 관리의 어려움 등의 단점도 있습니다.
성공적인 마이크로서비스 구현을 위해서는 서비스 분리, 통신 방식, API 게이트웨이, 서비스 검색, 데이터베이스 전략, 배포 및 모니터링 등을 신중하게 설계해야 합니다. 또한 Circuit Breaker, CQRS, API 조합 등의 패턴을 활용하여 마이크로서비스 아키텍처의 문제점을 완화할 수 있습니다.
마이크로서비스로의 전환은 모든 프로젝트에 적합한 것은 아니며, 프로젝트의 복잡성, 팀 규모, 확장 요구사항 등을 고려하여 결정해야 합니다.