🌱 Node.js 기초: 백엔드 개발의 시작

Node.js가 뭔지 아직 잘 모른다고? 걱정 마! 아주 쉽게 설명해줄게. Node.js는 JavaScript를 서버 측에서 실행할 수 있게 해주는 런타임 환경이야. 원래 JavaScript는 웹 브라우저에서만 실행되는 언어였는데, Node.js 덕분에 서버에서도 JavaScript를 쓸 수 있게 된 거지!

Node.js의 특징 - 왜 이렇게 인기가 많을까? 🤔

1. 비동기 I/O 처리: Node.js는 이벤트 기반, 논블로킹 I/O 모델을 사용해서 가볍고 효율적이야. 쉽게 말하면, 여러 작업을 동시에 처리할 수 있다는 거지!
2. 단일 스레드 이벤트 루프: 복잡한 멀티스레드 프로그래밍 없이도 동시성을 처리할 수 있어.
3. npm(Node Package Manager): 세계 최대의 오픈 소스 라이브러리 생태계를 가지고 있어. 거의 모든 기능은 이미 누군가 패키지로 만들어놨다고 보면 돼!
4. JavaScript 기반: 프론트엔드와 백엔드 모두 JavaScript를 사용할 수 있어서 풀스택 개발이 편리해져.

Node.js 설치하기 🛠️

Node.js를 시작하려면 먼저 설치해야겠지? 아래 단계를 따라가 보자:

1. Node.js 공식 웹사이트에 접속해.
2. LTS(Long Term Support) 버전을 다운로드해. 안정적인 버전이라 초보자에게 추천해!
3. 설치 프로그램을 실행하고 지시에 따라 설치를 완료해.
4. 설치가 완료되면 터미널(맥/리눅스) 또는 명령 프롬프트(윈도우)를 열고 다음 명령어로 설치가 제대로 됐는지 확인해봐:

   node -v
   npm -v

위 명령어를 실행했을 때 버전 번호가 나온다면 성공적으로 설치된 거야! 🎉

첫 번째 Node.js 애플리케이션 만들기 🏗️

이제 정말 간단한 Node.js 애플리케이션을 만들어볼게. 터미널을 열고 다음 단계를 따라해봐:

1. 새 프로젝트 폴더를 만들고 그 폴더로 이동해:

   mkdir my-first-node-app
   cd my-first-node-app

2. package.json 파일을 생성해:

   npm init -y

3. 텍스트 에디터로 app.js 파일을 생성하고 다음 코드를 입력해:

   // 첫 번째 Node.js 애플리케이션
   console.log('안녕하세요! Node.js의 세계에 오신 것을 환영합니다!');
   
   // 간단한 HTTP 서버 만들기
   const http = require('http');
   
   const server = http.createServer((req, res) => {
     res.statusCode = 200;
     res.setHeader('Content-Type', 'text/plain');
     res.end('안녕! 내 첫 번째 Node.js 서버야!\n');
   });
   
   server.listen(3000, '127.0.0.1', () => {
     console.log('서버가 http://127.0.0.1:3000/ 에서 실행 중이야!');
   });

4. 터미널에서 다음 명령어로 애플리케이션을 실행해:

   node app.js

웹 브라우저를 열고 http://localhost:3000으로 접속해보면 "안녕! 내 첫 번째 Node.js 서버야!"라는 메시지를 볼 수 있을 거야. 축하해! 🎊 방금 너의 첫 번째 Node.js 서버를 만든 거야!

하지만 이렇게 HTTP 모듈만 사용해서 서버를 구축하면 복잡한 웹 애플리케이션을 만들기 어려워. 라우팅, 미들웨어, 요청 처리 등을 일일이 구현해야 하거든. 바로 이런 이유 때문에 Express.js 같은 프레임워크가 필요한 거지! 다음 섹션에서 Express.js에 대해 알아보자. 😉

🚂 Express.js 소개: 웹 애플리케이션 개발을 쉽게!

Express.js는 Node.js를 위한 빠르고 간결한 웹 프레임워크야. 쉽게 말하면, Node.js로 웹 애플리케이션과 API를 더 쉽게 만들 수 있게 도와주는 도구라고 생각하면 돼. 마치 레고 블록처럼 필요한 기능들을 쉽게 조립할 수 있게 해주지! 😊

Express.js가 해결해주는 문제들 🛠️

순수 Node.js만으로 웹 서버를 구축하면 다음과 같은 문제들을 직접 해결해야 해:

1. 라우팅 관리: 다양한 URL 경로와 HTTP 메서드(GET, POST 등)에 대한 처리
2. 요청 및 응답 처리: 요청 본문 파싱, 쿠키 처리, 세션 관리 등
3. 미들웨어 구현: 인증, 로깅, 오류 처리 등의 공통 기능
4. 정적 파일 제공: HTML, CSS, JavaScript, 이미지 등의 파일 서빙
5. 템플릿 엔진 통합: 동적 HTML 생성

Express.js는 이 모든 문제를 간결하고 우아한 API로 해결해줘. 그래서 개발자들이 비즈니스 로직에 집중할 수 있게 도와주는 거지!

Express.js 설치하기 📦

Express.js를 시작하려면 npm을 사용해서 설치해야 해. 아래 단계를 따라가 보자:

1. 새 프로젝트 폴더를 만들고 그 폴더로 이동해:

   mkdir my-express-app
   cd my-express-app

2. package.json 파일을 생성해:

   npm init -y

3. Express.js를 설치해:

   npm install express

이제 Express.js를 사용할 준비가 됐어! 🎉

첫 번째 Express.js 애플리케이션 만들기 🏗️

이제 정말 간단한 Express.js 애플리케이션을 만들어볼게. 텍스트 에디터로 app.js 파일을 생성하고 다음 코드를 입력해:

// Express.js 모듈 불러오기
const express = require('express');

// Express 애플리케이션 생성
const app = express();

// 루트 경로('/')에 대한 GET 요청 처리
app.get('/', (req, res) => {
  res.send('안녕! 내 첫 번째 Express.js 앱이야!');
});

// '/about' 경로에 대한 GET 요청 처리
app.get('/about', (req, res) => {
  res.send('이 앱은 Express.js를 배우기 위한 샘플 앱이야!');
});

// 서버 시작
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`서버가 http://localhost:${PORT} 에서 실행 중이야!`);
});

터미널에서 다음 명령어로 애플리케이션을 실행해:

node app.js

웹 브라우저를 열고 http://localhost:3000으로 접속해보면 "안녕! 내 첫 번째 Express.js 앱이야!"라는 메시지를 볼 수 있을 거야. http://localhost:3000/about으로 접속하면 다른 메시지도 볼 수 있고!

방금 만든 코드를 보면 순수 Node.js로 작성한 코드보다 훨씬 간결하고 이해하기 쉽다는 걸 알 수 있어. Express.js는 라우팅, 요청 처리, 응답 전송 등을 간단한 API로 제공하기 때문이지. 이게 바로 Express.js의 매력이야! 😍

다음 섹션에서는 Express.js의 핵심 개념인 라우팅에 대해 더 자세히 알아볼게. 계속 따라와! 🚶‍♂️

🛣️ Express.js 라우팅: 트래픽 관리의 기술

라우팅이 뭔지 모르겠다고? 간단히 말하면, 클라이언트의 요청(URL과 HTTP 메서드)을 어떤 핸들러 함수로 연결할지 결정하는 것이야. 마치 교통 경찰이 차들을 올바른 길로 안내하는 것처럼, 라우팅은 요청을 올바른 처리 함수로 안내하는 역할을 하지!

기본 라우팅 구조 🧩

Express.js에서 라우팅의 기본 구조는 다음과 같아:

app.METHOD(PATH, HANDLER)

여기서:

1. app은 Express 인스턴스야.
2. METHOD는 HTTP 요청 메서드(get, post, put, delete 등)야.
3. PATH는 서버에서의 경로야.
4. HANDLER는 라우트가 일치할 때 실행되는 함수야.

다양한 HTTP 메서드 활용하기 🔄

Express.js는 모든 HTTP 메서드를 지원해. 각 메서드의 일반적인 용도를 알아볼게:

// GET: 데이터 조회
app.get('/users', (req, res) => {
  // 사용자 목록 반환
  res.send('사용자 목록이야!');
});

// POST: 새 데이터 생성
app.post('/users', (req, res) => {
  // 새 사용자 생성
  res.send('새 사용자가 생성됐어!');
});

// PUT: 기존 데이터 전체 수정
app.put('/users/:id', (req, res) => {
  // 사용자 정보 전체 수정
  res.send(`사용자 ${req.params.id}의 정보가 수정됐어!`);
});

// PATCH: 기존 데이터 일부 수정
app.patch('/users/:id', (req, res) => {
  // 사용자 정보 일부 수정
  res.send(`사용자 ${req.params.id}의 정보가 일부 수정됐어!`);
});

// DELETE: 데이터 삭제
app.delete('/users/:id', (req, res) => {
  // 사용자 삭제
  res.send(`사용자 ${req.params.id}가 삭제됐어!`);
});

이렇게 HTTP 메서드에 따라 같은 URL에서도 다른 동작을 수행할 수 있어. 이게 바로 RESTful API의 기본 원칙이야! 🌟

라우트 매개변수 사용하기 📝

URL에서 동적인 값을 추출하고 싶을 때는 라우트 매개변수를 사용할 수 있어:

// 라우트 매개변수 사용 예제
app.get('/users/:userId/posts/:postId', (req, res) => {
  const userId = req.params.userId;
  const postId = req.params.postId;
  
  res.send(`사용자 ${userId}의 게시물 ${postId}를 조회했어!`);
});

이 예제에서 :userId와 :postId는 라우트 매개변수야. 클라이언트가 /users/123/posts/456과 같은 URL로 요청을 보내면, req.params.userId는 "123"이 되고, req.params.postId는 "456"이 돼. 이렇게 동적인 값을 쉽게 추출할 수 있지! 👍

쿼리 문자열 처리하기 🔍

URL의 쿼리 문자열(예: ?name=john&age=25)을 처리하려면 req.query 객체를 사용하면 돼:

// 쿼리 문자열 처리 예제
app.get('/search', (req, res) => {
  const query = req.query.q;
  const page = req.query.page || 1;  // 기본값 설정
  
  res.send(`"${query}"에 대한 검색 결과의 ${page} 페이지야!`);
});

클라이언트가 /search?q=express&page=2와 같은 URL로 요청을 보내면, req.query.q는 "express"가 되고, req.query.page는 "2"가 돼. 쿼리 문자열을 이렇게 쉽게 처리할 수 있어! 🔎

라우트 핸들러 체이닝 ⛓️

같은 경로에 여러 핸들러를 연결하고 싶을 때는 라우트 핸들러 체이닝을 사용할 수 있어:

// 라우트 핸들러 체이닝 예제
app.route('/books')
  .get((req, res) => {
    // 책 목록 조회
    res.send('책 목록을 가져왔어!');
  })
  .post((req, res) => {
    // 새 책 추가
    res.send('새 책을 추가했어!');
  })
  .put((req, res) => {
    // 책 정보 수정
    res.send('책 정보를 수정했어!');
  });

이렇게 하면 코드가 더 깔끔해지고, 같은 경로에 대한 여러 HTTP 메서드를 한 곳에서 관리할 수 있어! 👌

라우터 모듈화하기 📦

애플리케이션이 커지면 모든 라우트를 app.js 파일에 넣는 것은 관리하기 어려워져. 이럴 때는 라우터를 모듈화하는 것이 좋아:

먼저 routes 폴더를 만들고, 그 안에 users.js 파일을 생성해:

// routes/users.js
const express = require('express');
const router = express.Router();

// 사용자 목록 조회
router.get('/', (req, res) => {
  res.send('사용자 목록이야!');
});

// 특정 사용자 조회
router.get('/:id', (req, res) => {
  res.send(`사용자 ${req.params.id}의 정보야!`);
});

// 새 사용자 생성
router.post('/', (req, res) => {
  res.send('새 사용자가 생성됐어!');
});

// 라우터 모듈 내보내기
module.exports = router;

그리고 app.js 파일에서 이 라우터 모듈을 불러와서 사용해:

// app.js
const express = require('express');
const app = express();

// 사용자 라우터 불러오기
const usersRouter = require('./routes/users');

// '/users' 경로에 사용자 라우터 마운트
app.use('/users', usersRouter);

// 서버 시작
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`서버가 http://localhost:${PORT} 에서 실행 중이야!`);
});

이렇게 하면 /users로 시작하는 모든 요청은 usersRouter에서 처리하게 돼. 이런 방식으로 라우터를 모듈화하면 코드 구조가 깔끔해지고 유지보수가 쉬워져. 특히 큰 프로젝트에서는 필수적인 방법이지! 🏗️

라우팅에 대해 기본적인 내용을 배웠으니, 다음 섹션에서는 Express.js의 또 다른 핵심 개념인 미들웨어에 대해 알아볼게. 계속 따라와! 🚶‍♂️

🔄 Express.js 미들웨어: 요청과 응답 사이의 마법

미들웨어는 Express.js의 심장이라고 할 수 있어! 미들웨어는 요청(request)과 응답(response) 사이에서 동작하는 함수로, 요청 객체(req), 응답 객체(res), 그리고 다음 미들웨어 함수를 가리키는 next 함수를 매개변수로 받아. 🔄

미들웨어의 기본 구조 🧩

미들웨어 함수의 기본 구조는 다음과 같아:

function myMiddleware(req, res, next) {
  // 미들웨어 로직
  console.log('미들웨어가 실행됐어!');
  
  // 다음 미들웨어로 제어를 넘김
  next();
}

미들웨어는 다음과 같은 작업을 수행할 수 있어:

1. 요청 객체(req)나 응답 객체(res)를 수정할 수 있어.
2. 요청-응답 주기를 종료할 수 있어(예: res.send()를 호출).
3. 다음 미들웨어를 호출할 수 있어(next() 함수 호출).

중요한 점은 미들웨어에서 next()를 호출하지 않으면 요청 처리가 거기서 멈춘다는 거야! 그래서 항상 next()를 호출하거나, res.send()와 같은 메서드로 응답을 보내야 해. 그렇지 않으면 클라이언트는 응답을 받지 못하고 요청이 계속 대기 상태로 남게 돼. ⚠️

미들웨어 적용하기 🔧

Express.js에서 미들웨어를 적용하는 방법은 크게 세 가지야:

1. 애플리케이션 레벨 미들웨어: app.use() 또는 app.METHOD()를 사용해 애플리케이션의 모든 요청에 적용
2. 라우터 레벨 미들웨어: router.use() 또는 router.METHOD()를 사용해 특정 라우터에만 적용
3. 오류 처리 미들웨어: 오류를 처리하는 특별한 형태의 미들웨어

애플리케이션 레벨 미들웨어 예제:

// 모든 요청에 적용되는 미들웨어
app.use((req, res, next) => {
  console.log('요청 시간:', Date.now());
  next();
});

// 특정 경로에만 적용되는 미들웨어
app.use('/users', (req, res, next) => {
  console.log('사용자 관련 요청이 들어왔어!');
  next();
});

// 특정 HTTP 메서드와 경로에만 적용되는 미들웨어
app.get('/users', (req, res, next) => {
  console.log('사용자 목록 조회 요청이 들어왔어!');
  next();
});

라우터 레벨 미들웨어 예제:

const express = require('express');
const router = express.Router();

// 이 라우터의 모든 요청에 적용되는 미들웨어
router.use((req, res, next) => {
  console.log('라우터 레벨 미들웨어가 실행됐어!');
  next();
});

// 라우트 정의
router.get('/', (req, res) => {
  res.send('홈 페이지야!');
});

// 애플리케이션에 라우터 마운트
app.use('/', router);

오류 처리 미들웨어 예제:

// 오류 처리 미들웨어는 항상 4개의 인자를 가져야 해
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('서버에 문제가 생겼어! 😱');
});

오류 처리 미들웨어는 반드시 4개의 매개변수(err, req, res, next)를 가져야 해. Express.js는 이 패턴을 통해 오류 처리 미들웨어를 식별하거든! 🔍

자주 사용되는 미들웨어 패키지 📦

Express.js 생태계에는 다양한 미들웨어 패키지가 있어. 가장 많이 사용되는 몇 가지를 소개할게:

1. express.json(): JSON 요청 본문을 파싱해 req.body에 저장해.
2. express.urlencoded(): URL-encoded 요청 본문을 파싱해 req.body에 저장해.
3. express.static(): 정적 파일(HTML, CSS, JavaScript, 이미지 등)을 제공해.
4. cookie-parser: 쿠키를 파싱해 req.cookies에 저장해.
5. morgan: HTTP 요청 로깅을 위한 미들웨어야.
6. helmet: HTTP 헤더를 설정해 보안을 강화해.
7. cors: Cross-Origin Resource Sharing을 활성화해.

이런 미들웨어들을 사용하는 예제를 보여줄게:

const express = require('express');
const morgan = require('morgan');
const cookieParser = require('cookie-parser');
const helmet = require('helmet');
const cors = require('cors');

const app = express();

// 로깅 미들웨어
app.use(morgan('dev'));

// JSON 요청 본문 파싱
app.use(express.json());

// URL-encoded 요청 본문 파싱
app.use(express.urlencoded({ extended: false }));

// 쿠키 파싱
app.use(cookieParser());

// 정적 파일 제공
app.use(express.static('public'));

// 보안 헤더 설정
app.use(helmet());

// CORS 활성화
app.use(cors());

// 라우트 정의
app.get('/', (req, res) => {
  res.send('홈 페이지야!');
});

// 서버 시작
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`서버가 http://localhost:${PORT} 에서 실행 중이야!`);
});

이런 미들웨어들을 사용하면 반복적인 작업을 줄이고 애플리케이션의 기능을 쉽게 확장할 수 있어. 특히 재능넷과 같은 복잡한 웹 서비스를 개발할 때는 이런 미들웨어들이 정말 유용하지! 👍

커스텀 미들웨어 만들기 🛠️

필요한 기능이 기존 미들웨어에 없다면, 직접 커스텀 미들웨어를 만들 수도 있어. 예를 들어, 요청 시간을 측정하는 미들웨어를 만들어볼게:

// 요청 처리 시간을 측정하는 커스텀 미들웨어
function requestTime(req, res, next) {
  req.requestTime = Date.now();
  
  // 응답이 완료되면 실행되는 이벤트 리스너
  res.on('finish', () => {
    const duration = Date.now() - req.requestTime;
    console.log(`요청 처리 시간: ${duration}ms`);
  });
  
  next();
}

// 미들웨어 적용
app.use(requestTime);

이 미들웨어는 요청이 들어온 시간을 기록하고, 응답이 완료되면 처리 시간을 계산해서 로그로 출력해. 이런 식으로 필요한 기능을 직접 구현할 수 있어! 🔧

미들웨어에 대해 기본적인 내용을 배웠으니, 다음 섹션에서는 Express.js에서 요청 데이터를 처리하는 방법에 대해 알아볼게. 계속 따라와! 🚶‍♂️

📝 Express.js 요청 데이터 처리: 클라이언트의 목소리 듣기

클라이언트에서 서버로 데이터를 보내는 방법은 여러 가지가 있어. Express.js에서는 이런 다양한 형태의 요청 데이터를 쉽게 처리할 수 있는 방법을 제공해. 이번 섹션에서는 요청 본문(body), URL 매개변수, 쿼리 문자열, 헤더, 쿠키 등 다양한 형태의 요청 데이터를 처리하는 방법을 알아볼게! 📝

요청 본문(Request Body) 처리하기 📄

클라이언트가 POST, PUT, PATCH 요청을 통해 데이터를 보낼 때는 주로 요청 본문(body)을 사용해. Express.js에서 요청 본문을 처리하려면 미들웨어가 필요해:

// JSON 요청 본문 파싱
app.use(express.json());

// URL-encoded 요청 본문 파싱
app.use(express.urlencoded({ extended: false }));

// 요청 본문 처리 예제
app.post('/users', (req, res) => {
  const { name, email, age } = req.body;
  
  console.log(`이름: ${name}, 이메일: ${email}, 나이: ${age}`);
  
  // 데이터베이스에 사용자 추가하는 로직
  
  res.status(201).json({
    message: '사용자가 생성됐어!',
    user: { name, email, age }
  });
});

express.json()과 express.urlencoded() 미들웨어는 요청 본문을 파싱해서 req.body 객체로 만들어줘. 이렇게 하면 요청 본문의 데이터에 쉽게 접근할 수 있지! 👍

URL 매개변수(Route Parameters) 처리하기 🔍

URL의 일부를 동적으로 처리하고 싶을 때는 URL 매개변수(라우트 매개변수)를 사용할 수 있어:

// URL 매개변수 처리 예제
app.get('/users/:userId/posts/:postId', (req, res) => {
  const { userId, postId } = req.params;
  
  console.log(`사용자 ID: ${userId}, 게시물 ID: ${postId}`);
  
  // 데이터베이스에서 해당 사용자의 해당 게시물 조회하는 로직
  
  res.json({
    message: '게시물을 조회했어!',
    userId,
    postId
  });
});

URL 매개변수는 req.params 객체를 통해 접근할 수 있어. 이 방식은 RESTful API를 설계할 때 특히 유용하지! 🌟

쿼리 문자열(Query String) 처리하기 🔎

URL의 ? 뒤에 오는 쿼리 문자열(예: ?name=john&age=25)을 처리하려면 req.query 객체를 사용하면 돼:

// 쿼리 문자열 처리 예제
app.get('/search', (req, res) => {
  const { q, page = 1, limit = 10 } = req.query;
  
  console.log(`검색어: ${q}, 페이지: ${page}, 제한: ${limit}`);
  
  // 검색 로직
  
  res.json({
    message: '검색 결과야!',
    query: q,
    page: parseInt(page),
    limit: parseInt(limit)
  });
});

쿼리 문자열은 문자열로 전달되기 때문에, 숫자로 사용하려면 parseInt()나 parseFloat()를 사용해서 변환해야 해. 또한 기본값을 설정하는 것도 좋은 방법이야! 👌

헤더(Headers) 처리하기 📋

요청 헤더는 req.headers 객체를 통해 접근할 수 있어:

// 헤더 처리 예제
app.get('/api/data', (req, res) => {
  const authToken = req.headers.authorization;
  const userAgent = req.headers['user-agent'];
  
  console.log(`인증 토큰: ${authToken}`);
  console.log(`사용자 에이전트: ${userAgent}`);
  
  // 인증 로직
  
  res.json({
    message: '인증됐어!',
    data: { /* 데이터 */ }
  });
});

헤더 이름은 대소문자를 구분하지 않고, 하이픈(-)이 있는 헤더 이름은 대괄호 표기법을 사용해야 해. 예를 들어, req.headers['content-type']처럼 말이야! 📝

쿠키(Cookies) 처리하기 🍪

쿠키를 처리하려면 cookie-parser 미들웨어를 사용하는 것이 좋아:

const cookieParser = require('cookie-parser');

// 쿠키 파싱 미들웨어 적용
app.use(cookieParser());

// 쿠키 설정 예제
app.get('/login', (req, res) => {
  // 사용자 인증 로직
  
  // 쿠키 설정
  res.cookie('user_id', '123', {
    maxAge: 24 * 60 * 60 * 1000, // 24시간
    httpOnly: true,
    secure: process.env.NODE_ENV === 'production'
  });
  
  res.send('로그인 성공! 쿠키가 설정됐어!');
});

// 쿠키 읽기 예제
app.get('/profile', (req, res) => {
  const userId = req.cookies.user_id;
  
  if (!userId) {
    return res.status(401).send('로그인이 필요해!');
  }
  
  console.log(`사용자 ID: ${userId}`);
  
  // 사용자 프로필 조회 로직
  
  res.json({
    message: '프로필을 조회했어!',
    userId
  });
});

cookie-parser 미들웨어는 요청의 쿠키를 파싱해서 req.cookies 객체로 만들어줘. 쿠키를 설정할 때는 res.cookie() 메서드를 사용하면 돼! 🍪

파일 업로드 처리하기 📁

파일 업로드를 처리하려면 multer 미들웨어를 사용하는 것이 일반적이야:

const multer = require('multer');
const path = require('path');

// 파일 저장 설정
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, 'uploads/'); // 파일이 저장될 폴더
  },
  filename: (req, file, cb) => {
    cb(null, Date.now() + path.extname(file.originalname)); // 파일명 설정
  }
});

// 파일 필터링
const fileFilter = (req, file, cb) => {
  // 허용할 파일 형식
  const allowedTypes = /jpeg|jpg|png|gif/;
  
  // 파일 확장자 확인
  const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
  // MIME 타입 확인
  const mimetype = allowedTypes.test(file.mimetype);
  
  if (extname && mimetype) {
    return cb(null, true); // 파일 허용
  } else {
    cb(new Error('이미지 파일만 업로드할 수 있어! (jpeg, jpg, png, gif)'));
  }
};

// multer 설정
const upload = multer({
  storage,
  limits: { fileSize: 1024 * 1024 * 5 }, // 5MB 제한
  fileFilter
});

// 단일 파일 업로드 처리
app.post('/upload', upload.single('image'), (req, res) => {
  if (!req.file) {
    return res.status(400).send('파일이 없어!');
  }
  
  console.log('업로드된 파일:', req.file);
  
  res.json({
    message: '파일 업로드 성공!',
    file: req.file
  });
});

// 여러 파일 업로드 처리
app.post('/upload-multiple', upload.array('images', 5), (req, res) => {
  if (!req.files || req.files.length === 0) {
    return res.status(400).send('파일이 없어!');
  }
  
  console.log('업로드된 파일들:', req.files);
  
  res.json({
    message: '파일 업로드 성공!',
    files: req.files
  });
});

multer 미들웨어는 multipart/form-data 형식의 요청 본문을 처리해서 파일을 저장하고, 파일 정보를 req.file(단일 파일) 또는 req.files(여러 파일) 객체로 만들어줘. 파일 크기 제한, 저장 위치, 파일명 등을 설정할 수 있어! 📁

요청 데이터 처리에 대해 기본적인 내용을 배웠으니, 다음 섹션에서는 Express.js에서 응답을 보내는 방법에 대해 알아볼게. 계속 따라와! 🚶‍♂️

📤 Express.js 응답 처리: 클라이언트에게 말하기

서버가 클라이언트에게 응답을 보내는 방법은 여러 가지가 있어. Express.js에서는 다양한 형태의 응답을 쉽게 보낼 수 있는 방법을 제공해. 이번 섹션에서는 텍스트, JSON, HTML, 파일, 상태 코드 등 다양한 형태의 응답을 보내는 방법을 알아볼게! 📤

기본 응답 메서드 📋

Express.js에서 가장 많이 사용되는 응답 메서드는 다음과 같아:

1. res.send(): 다양한 유형의 응답을 보낼 수 있어.
2. res.json(): JSON 응답을 보낼 수 있어.
3. res.sendFile(): 파일을 응답으로 보낼 수 있어.
4. res.render(): 템플릿 엔진을 사용해 HTML을 생성하고 보낼 수 있어.
5. res.redirect(): 다른 URL로 리다이렉트할 수 있어.
6. res.status(): HTTP 상태 코드를 설정할 수 있어.

텍스트 응답 보내기 📝

가장 간단한 형태의 응답은 텍스트 응답이야:

// 텍스트 응답 예제
app.get('/hello', (req, res) => {
  res.send('안녕! Express.js 세계에 오신 것을 환영해!');
});

res.send() 메서드는 문자열을 보낼 때 자동으로 Content-Type을 text/html로 설정해. 다른 Content-Type을 원한다면 res.type() 메서드를 사용할 수 있어:

// Content-Type 설정 예제
app.get('/plain-text', (req, res) => {
  res.type('text/plain');
  res.send('이것은 일반 텍스트야!');
});

JSON 응답 보내기 📊

API를 개발할 때는 주로 JSON 형식으로 응답을 보내게 돼:

// JSON 응답 예제
app.get('/api/users', (req, res) => {
  const users = [
    { id: 1, name: '김철수', email: 'kim@example.com' },
    { id: 2, name: '이영희', email: 'lee@example.com' },
    { id: 3, name: '박지민', email: 'park@example.com' }
  ];
  
  res.json(users);
});

res.json() 메서드는 자동으로 객체를 JSON 문자열로 변환하고, Content-Type을 application/json으로 설정해. 이 메서드는 res.send()보다 JSON 응답을 보낼 때 더 명확하고 안전해! 👍

HTML 응답 보내기 🌐

정적인 HTML을 응답으로 보낼 수도 있어:

// HTML 응답 예제
app.get('/html', (req, res) => {
  const html = `
    <!DOCTYPE html>
    <html>
      <head>
        <title>Express.js 예제</title>
      </head>
      <body>
        <h1>안녕! Express.js 세계에 오신 것을 환영해!</h1>
        <p>이것은 HTML 응답이야!</p>
      </body>
    </html>
  `;
  
  res.send(html);
});

하지만 복잡한 HTML을 직접 문자열로 작성하는 것은 불편해. 이럴 때는 템플릿 엔진을 사용하는 것이 좋아! 🧩

템플릿 엔진으로 HTML 생성하기 🎨

Express.js는 다양한 템플릿 엔진(EJS, Pug, Handlebars 등)을 지원해. 여기서는 EJS를 예로 들어볼게:

먼저 EJS를 설치해:

npm install ejs

그리고 Express.js 애플리케이션에 템플릿 엔진을 설정해:

// 템플릿 엔진 설정
app.set('view engine', 'ejs');
app.set('views', './views'); // 템플릿 파일이 있는 디렉토리

이제 views 디렉토리에 index.ejs 파일을 만들어:

<!DOCTYPE html>
<html>
  <head>
    <title><%= title %></title>
  </head>
  <body>
    <h1><%= heading %></h1>
    <p>환영합니다, <%= username %>님!</p>
    
    <h2>사용자 목록</h2>
    <ul>
      <% users.forEach(user => { %>
        <li><%= user.name %> (<%= user.email %>)</li>
      <% }); %>
    </ul>
  </body>
</html>

마지막으로 라우트 핸들러에서 res.render() 메서드를 사용해 템플릿을 렌더링해:

// 템플릿 렌더링 예제
app.get('/template', (req, res) => {
  const data = {
    title: 'Express.js 템플릿 예제',
    heading: '안녕! Express.js 세계에 오신 것을 환영해!',
    username: '사용자',
    users: [
      { name: '김철수', email: 'kim@example.com' },
      { name: '이영희', email: 'lee@example.com' },
      { name: '박지민', email: 'park@example.com' }
    ]
  };
  
  res.render('index', data);
});

res.render() 메서드는 템플릿 파일과 데이터를 결합해 HTML을 생성하고, 그 결과를 클라이언트에게 보내. 이 방식은 동적인 웹 페이지를 만들 때 매우 유용해! 🎨

파일 응답 보내기 📁

파일을 응답으로 보내려면 res.sendFile() 메서드를 사용할 수 있어:

const path = require('path');

// 파일 응답 예제
app.get('/download', (req, res) => {
  const filePath = path.join(__dirname, 'files', 'example.pdf');
  res.sendFile(filePath);
});

파일을 다운로드 형태로 제공하려면 Content-Disposition 헤더를 설정하면 돼:

// 파일 다운로드 예제
app.get('/download-attachment', (req, res) => {
  const filePath = path.join(__dirname, 'files', 'example.pdf');
  
  res.setHeader('Content-Disposition', 'attachment; filename="downloaded-file.pdf"');
  res.sendFile(filePath);
});

상태 코드 설정하기 🚦

HTTP 상태 코드를 설정하려면 res.status() 메서드를 사용할 수 있어:

// 상태 코드 설정 예제
app.get('/not-found', (req, res) => {
  res.status(404).send('페이지를 찾을 수 없어! 😢');
});

app.get('/error', (req, res) => {
  res.status(500).json({
    error: '서버 오류가 발생했어! 😱',
    details: '나중에 다시 시도해줘!'
  });
});

res.status() 메서드는 체이닝이 가능해서 다른 응답 메서드와 함께 사용할 수 있어. 적절한 상태 코드를 설정하는 것은 RESTful API 설계의 중요한 부분이야! 🚦

리다이렉트 하기 🔄

클라이언트를 다른 URL로 리다이렉트하려면 res.redirect() 메서드를 사용할 수 있어:

// 리다이렉트 예제
app.get('/old-page', (req, res) => {
  res.redirect('/new-page'); // 상대 경로
});

app.get('/external', (req, res) => {
  res.redirect('https://www.jaenung.net'); // 절대 경로
});

app.get('/back', (req, res) => {
  res.redirect('back'); // 이전 페이지로
});

기본적으로 res.redirect()는 302(Found) 상태 코드를 사용해. 다른 상태 코드를 사용하고 싶다면 res.status()와 함께 사용하면 돼:

// 301 리다이렉트 예제 (영구 이동)
app.get('/permanent-redirect', (req, res) => {
  res.status(301).redirect('/new-location');
});

헤더 설정하기 📋

응답 헤더를 설정하려면 res.set() 또는 res.header() 메서드를 사용할 수 있어:

// 헤더 설정 예제
app.get('/custom-headers', (req, res) => {
  res.set({
    'Content-Type': 'text/plain',
    'X-Custom-Header': 'Hello from Express.js',
    'Cache-Control': 'no-cache'
  });
  
  res.send('커스텀 헤더가 설정됐어!');
});

쿠키 설정하기 🍪

쿠키를 설정하려면 res.cookie() 메서드를 사용할 수 있어:

// 쿠키 설정 예제
app.get('/set-cookie', (req, res) => {
  // 기본 쿠키
  res.cookie('name', '김철수');
  
  // 옵션이 있는 쿠키
  res.cookie('theme', 'dark', {
    maxAge: 24 * 60 * 60 * 1000, // 24시간
    httpOnly: true,
    secure: process.env.NODE_ENV === 'production',
    sameSite: 'strict'
  });
  
  res.send('쿠키가 설정됐어!');
});

// 쿠키 삭제 예제
app.get('/clear-cookie', (req, res) => {
  res.clearCookie('name');
  res.send('쿠키가 삭제됐어!');
});

res.cookie() 메서드는 다양한 옵션을 지원해. httpOnly 옵션은 JavaScript에서 쿠키에 접근하는 것을 방지하고, secure 옵션은 HTTPS 연결에서만 쿠키를 전송하도록 해. 이런 옵션들은 쿠키의 보안을 강화하는 데 중요해! 🔒

응답 처리에 대해 기본적인 내용을 배웠으니, 다음 섹션에서는 Express.js에서 데이터베이스와 연동하는 방법에 대해 알아볼게. 계속 따라와! 🚶‍♂️

💾 Express.js와 데이터베이스 연동: 데이터 영구 저장하기

웹 애플리케이션에서 데이터를 영구적으로 저장하려면 데이터베이스가 필요해. Express.js는 다양한 데이터베이스와 쉽게 연동할 수 있어. 이번 섹션에서는 MongoDB, MySQL, PostgreSQL 등 다양한 데이터베이스와 Express.js를 연동하는 방법을 알아볼게! 💾

MongoDB와 Mongoose 연동하기 🍃

MongoDB는 NoSQL 데이터베이스로, JSON과 유사한 형태로 데이터를 저장해. Mongoose는 MongoDB를 위한 ODM(Object Document Mapper)으로, 스키마 기반의 모델링과 유효성 검사 등을 제공해.

먼저 필요한 패키지를 설치해:

npm install mongoose

그리고 MongoDB와 연결해:

// MongoDB 연결 설정
const mongoose = require('mongoose');

// MongoDB 연결
mongoose.connect('mongodb://localhost:27017/myapp', {
  useNewUrlParser: true,
  useUnifiedTopology: true
})
  .then(() => console.log('MongoDB에 연결됐어! 🎉'))
  .catch(err => console.error('MongoDB 연결 오류:', err));

이제 Mongoose 스키마와 모델을 정의해:

// 사용자 스키마 및 모델 정의
const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: [true, '이름은 필수야!'],
    trim: true
  },
  email: {
    type: String,
    required: [true, '이메일은 필수야!'],
    unique: true,
    lowercase: true,
    trim: true,
    match: [/^\S+@\S+\.\S+$/, '유효한 이메일 주소를 입력해줘!']
  },
  age: {
    type: Number,
    min: [0, '나이는 0보다 작을 수 없어!'],
    max: [120, '나이는 120보다 클 수 없어!']
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});

// 사용자 모델 생성
const User = mongoose.model('User', userSchema);

이제 CRUD(Create, Read, Update, Delete) 작업을 위한 라우트를 만들어:

// 사용자 생성 (Create)
app.post('/api/users', async (req, res) => {
  try {
    const newUser = new User(req.body);
    const savedUser = await newUser.save();
    res.status(201).json(savedUser);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// 모든 사용자 조회 (Read)
app.get('/api/users', async (req, res) => {
  try {
    const users = await User.find();
    res.json(users);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 특정 사용자 조회 (Read)
app.get('/api/users/:id', async (req, res) => {
  try {
    const user = await User.findById(req.params.id);
    if (!user) {
      return res.status(404).json({ error: '사용자를 찾을 수 없어!' });
    }
    res.json(user);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 사용자 정보 수정 (Update)
app.put('/api/users/:id', async (req, res) => {
  try {
    const updatedUser = await User.findByIdAndUpdate(
      req.params.id,
      req.body,
      { new: true, runValidators: true }
    );
    if (!updatedUser) {
      return res.status(404).json({ error: '사용자를 찾을 수 없어!' });
    }
    res.json(updatedUser);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// 사용자 삭제 (Delete)
app.delete('/api/users/:id', async (req, res) => {
  try {
    const deletedUser = await User.findByIdAndDelete(req.params.id);
    if (!deletedUser) {
      return res.status(404).json({ error: '사용자를 찾을 수 없어!' });
    }
    res.json({ message: '사용자가 삭제됐어!' });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

이렇게 하면 MongoDB와 Mongoose를 사용해 완전한 CRUD 기능을 갖춘 API를 만들 수 있어! 🎉

MySQL과 Sequelize 연동하기 🐬

MySQL은 인기 있는 관계형 데이터베이스(RDBMS)야. Sequelize는 MySQL, PostgreSQL, SQLite 등 다양한 관계형 데이터베이스를 위한 ORM(Object-Relational Mapping)이야.

먼저 필요한 패키지를 설치해:

npm install sequelize mysql2

그리고 Sequelize를 설정해:

// Sequelize 설정
const { Sequelize, DataTypes } = require('sequelize');

// Sequelize 인스턴스 생성
const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'mysql'
});

// 연결 테스트
(async () => {
  try {
    await sequelize.authenticate();
    console.log('MySQL에 연결됐어! 🎉');
  } catch (err) {
    console.error('MySQL 연결 오류:', err);
  }
})();

이제 Sequelize 모델을 정의해:

// 사용자 모델 정의
const User = sequelize.define('User', {
  name: {
    type: DataTypes.STRING,
    allowNull: false,
    validate: {
      notEmpty: true
    }
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    validate: {
      isEmail: true
    }
  },
  age: {
    type: DataTypes.INTEGER,
    validate: {
      min: 0,
      max: 120
    }
  }
});

// 모델 동기화 (테이블 생성)
(async () => {
  await sequelize.sync({ force: false });
  console.log('모든 모델이 동기화됐어! 🎉');
})();

이제 CRUD 작업을 위한 라우트를 만들어:

// 사용자 생성 (Create)
app.post('/api/users', async (req, res) => {
  try {
    const newUser = await User.create(req.body);
    res.status(201).json(newUser);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// 모든 사용자 조회 (Read)
app.get('/api/users', async (req, res) => {
  try {
    const users = await User.findAll();
    res.json(users);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 특정 사용자 조회 (Read)
app.get('/api/users/:id', async (req, res) => {
  try {
    const user = await User.findByPk(req.params.id);
    if (!user) {
      return res.status(404).json({ error: '사용자를 찾을 수 없어!' });
    }
    res.json(user);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 사용자 정보 수정 (Update)
app.put('/api/users/:id', async (req, res) => {
  try {
    const [updated] = await User.update(req.body, {
      where: { id: req.params.id }
    });
    if (updated === 0) {
      return res.status(404).json({ error: '사용자를 찾을 수 없어!' });
    }
    const updatedUser = await User.findByPk(req.params.id);
    res.json(updatedUser);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// 사용자 삭제 (Delete)
app.delete('/api/users/:id', async (req, res) => {
  try {
    const deleted = await User.destroy({
      where: { id: req.params.id }
    });
    if (deleted === 0) {
      return res.status(404).json({ error: '사용자를 찾을 수 없어!' });
    }
    res.json({ message: '사용자가 삭제됐어!' });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

이렇게 하면 MySQL과 Sequelize를 사용해 완전한 CRUD 기능을 갖춘 API를 만들 수 있어! 🎉

데이터베이스 연결 관리하기 🔄

실제 애플리케이션에서는 데이터베이스 연결을 효율적으로 관리하는 것이 중요해. 다음은 몇 가지 모범 사례야:

1. 환경 변수 사용: 데이터베이스 연결 정보를 환경 변수로 관리해.
2. 연결 풀링: 데이터베이스 연결 풀을 사용해 성능을 향상시켜.
3. 에러 처리: 데이터베이스 연결 오류를 적절히 처리해.
4. 연결 재시도: 연결이 끊어졌을 때 자동으로 재연결을 시도해.

환경 변수를 사용하는 예제를 보여줄게:

// .env 파일
DB_HOST=localhost
DB_PORT=27017
DB_NAME=myapp
DB_USER=username
DB_PASS=password

// app.js
require('dotenv').config();

// MongoDB 연결 (환경 변수 사용)
mongoose.connect(`mongodb://${process.env.DB_HOST}:${process.env.DB_PORT}/${process.env.DB_NAME}`, {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

이렇게 하면 환경에 따라 다른 데이터베이스 설정을 사용할 수 있어. 개발 환경, 테스트 환경, 프로덕션 환경에서 각각 다른 데이터베이스를 사용하는 것이 일반적이야! 🔧

데이터베이스 모델 분리하기 📁

애플리케이션이 커지면 모델을 별도의 파일로 분리하는 것이 좋아. 다음은 모델을 분리하는 예제야:

먼저 models 디렉토리를 만들고, 그 안에 user.js 파일을 생성해:

// models/user.js (Mongoose 예제)
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: [true, '이름은 필수야!'],
    trim: true
  },
  email: {
    type: String,
    required: [true, '이메일은 필수야!'],
    unique: true,
    lowercase: true,
    trim: true,
    match: [/^\S+@\S+\.\S+$/, '유효한 이메일 주소를 입력해줘!']
  },
  age: {
    type: Number,
    min: [0, '나이는 0보다 작을 수 없어!'],
    max: [120, '나이는 120보다 클 수 없어!']
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});

const User = mongoose.model('User', userSchema);

module.exports = User;

그리고 app.js 파일에서 이 모델을 불러와서 사용해:

// app.js
const User = require('./models/user');

// 사용자 생성 (Create)
app.post('/api/users', async (req, res) => {
  try {
    const newUser = new User(req.body);
    const savedUser = await newUser.save();
    res.status(201).json(savedUser);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

이렇게 하면 코드 구조가 깔끔해지고 유지보수가 쉬워져. 특히 큰 프로젝트에서는 필수적인 방법이지! 🏗️

데이터베이스 트랜잭션 사용하기 🔄

여러 데이터베이스 작업을 원자적으로 처리해야 할 때는 트랜잭션을 사용하는 것이 좋아. 다음은 Sequelize에서 트랜잭션을 사용하는 예제야:

// Sequelize 트랜잭션 예제
app.post('/api/transfer', async (req, res) => {
  const { fromAccountId, toAccountId, amount } = req.body;
  
  // 트랜잭션 시작
  const transaction = await sequelize.transaction();
  
  try {
    // 출금 계좌에서 금액 차감
    const fromAccount = await Account.findByPk(fromAccountId, { transaction });
    if (!fromAccount || fromAccount.balance < amount) {
      await transaction.rollback();
      return res.status(400).json({ error: '잔액이 부족해!' });
    }
    
    await fromAccount.update(
      { balance: fromAccount.balance - amount },
      { transaction }
    );
    
    // 입금 계좌에 금액 추가
    const toAccount = await Account.findByPk(toAccountId, { transaction });
    if (!toAccount) {
      await transaction.rollback();
      return res.status(404).json({ error: '입금 계좌를 찾을 수 없어!' });
    }
    
    await toAccount.update(
      { balance: toAccount.balance + amount },
      { transaction }
    );
    
    // 거래 내역 기록
    await Transaction.create(
      {
        fromAccountId,
        toAccountId,
        amount,
        date: new Date()
      },
      { transaction }
    );
    
    // 트랜잭션 커밋
    await transaction.commit();
    
    res.json({ message: '송금이 완료됐어!' });
  } catch (err) {
    // 오류 발생 시 롤백
    await transaction.rollback();
    res.status(500).json({ error: err.message });
  }
});

트랜잭션을 사용하면 여러 데이터베이스 작업이 모두 성공하거나 모두 실패하도록 보장할 수 있어. 이는 데이터 일관성을 유지하는 데 매우 중요해! 🔒

데이터베이스 연동에 대해 기본적인 내용을 배웠으니, 다음 섹션에서는 Express.js에서 인증과 권한 부여를 구현하는 방법에 대해 알아볼게. 계속 따라와! 🚶‍♂️

🔐 Express.js 인증과 권한 부여: 보안의 기초

웹 애플리케이션에서 인증(Authentication)과 권한 부여(Authorization)는 보안의 핵심이야. 인증은 사용자의 신원을 확인하는 과정이고, 권한 부여는 인증된 사용자가 특정 리소스에 접근할 수 있는지 확인하는 과정이지. 이번 섹션에서는 Express.js에서 JWT, 세션, Passport.js 등을 사용한 인증 구현 방법을 알아볼게! 🔐

JWT(JSON Web Token) 인증 구현하기 🎟️

JWT는 클라이언트와 서버 간에 정보를 안전하게 주고받기 위한 토큰 기반 인증 방식이야. JWT는 세 부분(헤더, 페이로드, 서명)으로 구성되어 있어.

먼저 필요한 패키지를 설치해:

npm install jsonwebtoken bcrypt

그리고 사용자 등록(회원가입) 기능을 구현해:

// 사용자 등록 (회원가입)
app.post('/api/register', async (req, res) => {
  try {
    const { name, email, password } = req.body;
    
    // 이메일 중복 확인
    const existingUser = await User.findOne({ email });
    if (existingUser) {
      return res.status(400).json({ error: '이미 등록된 이메일이야!' });
    }
    
    // 비밀번호 해싱
    const salt = await bcrypt.genSalt(10);
    const hashedPassword = await bcrypt.hash(password, salt);
    
    // 새 사용자 생성
    const newUser = new User({
      name,
      email,
      password: hashedPassword
    });
    
    await newUser.save();
    
    res.status(201).json({ message: '회원가입이 완료됐어!' });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

이제 로그인 기능과 JWT 발급을 구현해:

// JWT 비밀 키 (환경 변수로 관리하는 것이 좋아)
const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';

// 로그인 및 JWT 발급
app.post('/api/login', async (req, res) => {
  try {
    const { email, password } = req.body;
    
    // 사용자 찾기
    const user = await User.findOne({ email });
    if (!user) {
      return res.status(401).json({ error: '이메일 또는 비밀번호가 올바르지 않아!' });
    }
    
    // 비밀번호 확인
    const isMatch = await bcrypt.compare(password, user.password);
    if (!isMatch) {
      return res.status(401).json({ error: '이메일 또는 비밀번호가 올바르지 않아!' });
    }
    
    // JWT 생성
    const token = jwt.sign(
      { id: user._id, email: user.email, name: user.name },
      JWT_SECRET,
      { expiresIn: '1h' } // 토큰 만료 시간
    );
    
    res.json({
      message: '로그인 성공!',
      token,
      user: {
        id: user._id,
        name: user.name,
        email: user.email
      }
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

이제 JWT를 검증하는 미들웨어를 만들어:

// JWT 검증 미들웨어
function authenticateToken(req, res, next) {
  // 헤더에서 토큰 가져오기
  const authHeader = req.headers.authorization;
  const token = authHeader && authHeader.split(' ')[1]; // "Bearer TOKEN" 형식에서 TOKEN 부분 추출
  
  if (!token) {
    return res.status(401).json({ error: '인증 토큰이 필요해!' });
  }
  
  // 토큰 검증
  jwt.verify(token, JWT_SECRET, (err, user) => {
    if (err) {
      return res.status(403).json({ error: '토큰이 유효하지 않아!' });
    }
    
    // 요청 객체에 사용자 정보 추가
    req.user = user;
    next();
  });
}

이제 이 미들웨어를 사용해 보호된 라우트를 만들어:

// 보호된 라우트 예제
app.get('/api/profile', authenticateToken, async (req, res) => {
  try {
    // req.user에는 토큰에서 추출한 사용자 정보가 있어
    const user = await User.findById(req.user.id).select('-password');
    if (!user) {
      return res.status(404).json({ error: '사용자를 찾을 수 없어!' });
    }
    
    res.json(user);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

이렇게 하면 JWT를 사용한 인증 시스템을 구현할 수 있어! 클라이언트는 로그인 후 받은 토큰을 저장하고, 이후 요청에서 Authorization 헤더에 포함시켜 보내면 돼. 🎟️

세션 기반 인증 구현하기 🍪

세션 기반 인증은 서버 측에서 사용자의 상태를 유지하는 방식이야. Express.js에서는 express-session 미들웨어를 사용해 세션을 관리할 수 있어.

먼저 필요한 패키지를 설치해:

npm install express-session connect-mongo bcrypt

그리고 세션 미들웨어를 설정해:

const session = require('express-session');
const MongoStore = require('connect-mongo');

// 세션 미들웨어 설정
app.use(session({
  secret: process.env.SESSION_SECRET || 'your-secret-key',
  resave: false,
  saveUninitialized: false,
  store: MongoStore.create({
    mongoUrl: 'mongodb://localhost:27017/myapp',
    ttl: 14 * 24 * 60 * 60 // 14일 (초 단위)
  }),
  cookie: {
    httpOnly: true,
    maxAge: 14 * 24 * 60 * 60 * 1000, // 14일 (밀리초 단위)
    secure: process.env.NODE_ENV === 'production'
  }
}));

이제 로그인 기능을 구현해:

// 로그인 (세션 기반)
app.post('/api/login', async (req, res) => {
  try {
    const { email, password } = req.body;
    
    // 사용자 찾기
    const user = await User.findOne({ email });
    if (!user) {
      return res.status(401).json({ error: '이메일 또는 비밀번호가 올바르지 않아!' });
    }
    
    // 비밀번호 확인
    const isMatch = await bcrypt.compare(password, user.password);
    if (!isMatch) {
      return res.status(401).json({ error: '이메일 또는 비밀번호가 올바르지 않아!' });
    }
    
    // 세션에 사용자 정보 저장
    req.session.user = {
      id: user._id,
      name: user.name,
      email: user.email
    };
    
    res.json({
      message: '로그인 성공!',
      user: {
        id: user._id,
        name: user.name,
        email: user.email
      }
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

로그아웃 기능도 구현해:

// 로그아웃 (세션 기반)
app.post('/api/logout', (req, res) => {
  req.session.destroy(err => {
    if (err) {
      return res.status(500).json({ error: '로그아웃 중 오류가 발생했어!' });
    }
    res.clearCookie('connect.sid'); // 세션 쿠키 삭제
    res.json({ message: '로그아웃 성공!' });
  });
});

이제 세션을 확인하는 미들웨어를 만들어:

// 세션 인증 미들웨어
function isAuthenticated(req, res, next) {
  if (req.session.user) {
    next();
  } else {
    res.status(401).json({ error: '로그인이 필요해!' });
  }
}

이 미들웨어를 사용해 보호된 라우트를 만들어:

// 보호된 라우트 예제 (세션 기반)
app.get('/api/profile', isAuthenticated, async (req, res) => {
  try {
    const user = await User.findById(req.session.user.id).select('-password');
    if (!user) {
      return res.status(404).json({ error: '사용자를 찾을 수 없어!' });
    }
    
    res.json(user);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

이렇게 하면 세션 기반 인증 시스템을 구현할 수 있어! 세션 정보는 서버에 저장되고, 클라이언트는 세션 ID를 쿠키로 받아 저장해. 이후 요청에서 이 쿠키가 자동으로 전송돼. 🍪

Passport.js를 사용한 인증 구현하기 🛂

Passport.js는 Node.js를 위한 인증 미들웨어로, 다양한 인증 전략(로컬, OAuth, JWT 등)을 지원해. 이를 통해 더 복잡한 인증 시스템을 쉽게 구현할 수 있어.

먼저 필요한 패키지를 설치해:

npm install passport passport-local passport-jwt express-session connect-mongo bcrypt

그리고 Passport.js를 설정해:

const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
const JwtStrategy = require('passport-jwt').Strategy;
const ExtractJwt = require('passport-jwt').ExtractJwt;

// 세션 미들웨어 설정 (위와 동일)
app.use(session({ /* ... */ }));

// Passport 초기화
app.use(passport.initialize());
app.use(passport.session());

// 로컬 전략 설정 (이메일과 비밀번호 사용)
passport.use(new LocalStrategy(
  { usernameField: 'email' },
  async (email, password, done) => {
    try {
      // 사용자 찾기
      const user = await User.findOne({ email });
      if (!user) {
        return done(null, false, { message: '이메일 또는 비밀번호가 올바르지 않아!' });
      }
      
      // 비밀번호 확인
      const isMatch = await bcrypt.compare(password, user.password);
      if (!isMatch) {
        return done(null, false, { message: '이메일 또는 비밀번호가 올바르지 않아!' });
      }
      
      return done(null, user);
    } catch (err) {
      return done(err);
    }
  }
));

// JWT 전략 설정
const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';

passport.use(new JwtStrategy(
  {
    jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
    secretOrKey: JWT_SECRET
  },
  async (payload, done) => {
    try {
      // 페이로드의 ID로 사용자 찾기
      const user = await User.findById(payload.id);
      if (!user) {
        return done(null, false);
      }
      
      return done(null, user);
    } catch (err) {
      return done(err, false);
    }
  }
));

// 세션을 위한 직렬화/역직렬화
passport.serializeUser((user, done) => {
  done(null, user.id);
});

passport.deserializeUser(async (id, done) => {
  try {
    const user = await User.findById(id);
    done(null, user);
  } catch (err) {
    done(err);
  }
});

이제 로컬 전략을 사용한 로그인 라우트를 구현해:

// 로컬 전략을 사용한 로그인
app.post('/api/login', (req, res, next) => {
  passport.authenticate('local', (err, user, info) => {
    if (err) {
      return next(err);
    }
    if (!user) {
      return res.status(401).json({ error: info.message });
    }
    
    // 로그인 (세션에 사용자 정보 저장)
    req.login(user, err => {
      if (err) {
        return next(err);
      }
      
      // JWT 생성 (선택 사항)
      const token = jwt.sign(
        { id: user._id, email: user.email, name: user.name },
        JWT_SECRET,
        { expiresIn: '1h' }
      );
      
      return res.json({
        message: '로그인 성공!',
        token, // 선택적으로 JWT도 제공
        user: {
          id: user._id,
          name: user.name,
          email: user.email
        }
      });
    });
  })(req, res, next);
});

JWT 전략을 사용한 보호된 라우트도 구현해:

// JWT 전략을 사용한 보호된 라우트
app.get('/api/protected', passport.authenticate('jwt', { session: false }), (req, res) => {
  res.json({
    message: '보호된 리소스에 접근했어!',
    user: {
      id: req.user._id,
      name: req.user.name,
      email: req.user.email
    }
  });
});

세션 기반 인증을 사용한 보호된 라우트도 구현해:

// 세션 기반 인증을 확인하는 미들웨어
function ensureAuthenticated(req, res, next) {
  if (req.isAuthenticated()) {
    return next();
  }
  res.status(401).json({ error: '로그인이 필요해!' });
}

// 세션 기반 인증을 사용한 보호된 라우트
app.get('/api/profile', ensureAuthenticated, (req, res) => {
  res.json({
    message: '프로필 정보야!',
    user: {
      id: req.user._id,
      name: req.user.name,
      email: req.user.email
    }
  });
});

로그아웃 기능도 구현해:

// 로그아웃
app.post('/api/logout', (req, res) => {
  req.logout(err => {
    if (err) {
      return res.status(500).json({ error: '로그아웃 중 오류가 발생했어!' });
    }
    res.json({ message: '로그아웃 성공!' });
  });
});

이렇게 하면 Passport.js를 사용한 다양한 인증 전략을 구현할 수 있어! Passport.js는 확장성이 뛰어나서 소셜 로그인(Google, Facebook, GitHub 등)도 쉽게 추가할 수 있어. 🛂

권한 부여(Authorization) 구현하기 👮

인증이 사용자의 신원을 확인하는 과정이라면, 권한 부여는 인증된 사용자가 특정 리소스에 접근할 수 있는지 확인하는 과정이야. 다음은 간단한 역할 기반 권한 부여 시스템을 구현하는 예제야:

// 사용자 모델에 역할 필드 추가
const userSchema = new mongoose.Schema({
  // 기존 필드들...
  role: {
    type: String,
    enum: ['user', 'admin', 'editor'],
    default: 'user'
  }
});

// 역할 기반 권한 부여 미들웨어
function authorize(roles = []) {
  // roles 매개변수는 문자열 또는 문자열 배열일 수 있어
  if (typeof roles === 'string') {
    roles = [roles];
  }
  
  return (req, res, next) => {
    // 먼저 인증 확인
    if (!req.user) {
      return res.status(401).json({ error: '로그인이 필요해!' });
    }
    
    // 역할 확인
    if (roles.length > 0 && !roles.includes(req.user.role)) {
      return res.status(403).json({ error: '이 작업을 수행할 권한이 없어!' });
    }
    
    // 권한이 있으면 다음 미들웨어로
    next();
  };
}

// 관리자만 접근 가능한 라우트
app.get('/api/admin', authenticateToken, authorize('admin'), (req, res) => {
  res.json({ message: '관리자 페이지에 접근했어!' });
});

// 관리자 또는 편집자만 접근 가능한 라우트
app.get('/api/content', authenticateToken, authorize(['admin', 'editor']), (req, res) => {
  res.json({ message: '콘텐츠 관리 페이지에 접근했어!' });
});

이렇게 하면 역할 기반 권한 부여 시스템을 구현할 수 있어! 더 복잡한 권한 부여 시스템이 필요하다면, 세분화된 권한(permission)을 정의하고 확인하는 로직을 추가할 수도 있어. 👮

인증과 권한 부여에 대해 기본적인 내용을 배웠으니, 다음 섹션에서는 Express.js 애플리케이션을 배포하는 방법에 대해 알아볼게. 계속 따라와! 🚶‍♂️

🚀 Express.js 애플리케이션 배포: 세상에 공개하기

Express.js 애플리케이션을 개발했다면, 이제 세상에 공개할 차례야! 이번 섹션에서는 Express.js 애플리케이션을 프로덕션 환경에 배포하는 방법에 대해 알아볼게. 배포 전 준비사항부터 다양한 호스팅 옵션까지 살펴볼 거야! 🚀

배포 전 준비사항 ✅

프로덕션 환경에 배포하기 전에 다음 사항들을 확인하고 준비해야 해:

1. 환경 변수 설정: 민감한 정보(API 키, 데이터베이스 비밀번호 등)는 환경 변수로 관리해.
2. 오류 처리 강화: 모든 예외를 적절히 처리하고, 오류 로깅 시스템을 구축해.
3. 보안 강화: Helmet 같은 보안 미들웨어를 사용하고, HTTPS를 설정해.
4. 성능 최적화: 압축, 캐싱 등을 적용해 성능을 향상시켜.
5. 로깅 설정: 요청, 오류 등을 로깅하는 시스템을 구축해.

다음은 배포 준비를 위한 코드 예제야:

// .env 파일
NODE_ENV=production
PORT=3000
MONGODB_URI=mongodb://username:password@host:port/database
JWT_SECRET=your-secret-key
SESSION_SECRET=another-secret-key

// app.js
require('dotenv').config();
const express = require('express');
const helmet = require('helmet');
const compression = require('compression');
const morgan = require('morgan');
const fs = require('fs');
const path = require('path');

const app = express();

// 보안 헤더 설정
app.use(helmet());

// 응답 압축
app.use(compression());

// 로깅 설정
if (process.env.NODE_ENV === 'production') {
  // 프로덕션 환경에서는 로그 파일에 기록
  const accessLogStream = fs.createWriteStream(
    path.join(__dirname, 'access.log'),
    { flags: 'a' }
  );
  app.use(morgan('combined', { stream: accessLogStream }));
} else {
  // 개발 환경에서는 콘솔에 출력
  app.use(morgan('dev'));
}

// 프로덕션 환경에 맞는 오류 처리
app.use((err, req, res, next) => {
  console.error(err.stack);
  
  // 클라이언트에게는 자세한 오류 정보를 노출하지 않음
  res.status(500).json({
    error: process.env.NODE_ENV === 'production'
      ? '서버 오류가 발생했어. 나중에 다시 시도해줘.'
      : err.message
  });
});

// 환경 변수에서 포트 가져오기
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`서버가 포트 ${PORT}에서 실행 중이야!`);
});

이렇게 하면 프로덕션 환경에 적합한 Express.js 애플리케이션을 준비할 수 있어! 🛠️

PM2를 사용한 프로세스 관리 ⚙️

Node.js 애플리케이션을 프로덕션 환경에서 실행할 때는 PM2 같은 프로세스 관리자를 사용하는 것이 좋아. PM2는 애플리케이션을 백그라운드에서 실행하고, 자동으로 재시작하며, 로드 밸런싱 기능도 제공해.

먼저 PM2를 전역으로 설치해:

npm install -g pm2

그리고 PM2로 애플리케이션을 실행해:

// 기본 실행
pm2 start app.js

// 이름 지정
pm2 start app.js --name "my-app"

// 클러스터 모드 (여러 인스턴스 실행)
pm2 start app.js -i max

// 환경 변수 설정
pm2 start app.js --env production

PM2 생태계 파일(ecosystem.config.js)을 사용하면 더 자세한 설정이 가능해:

// ecosystem.config.js
module.exports = {
  apps: [{
    name: 'my-express-app',
    script: 'app.js',
    instances: 'max',
    autorestart: true,
    watch: false,
    max_memory_restart: '1G',
    env: {
      NODE_ENV: 'development'
    },
    env_production: {
      NODE_ENV: 'production',
      PORT: 3000
    }
  }]
};

// 실행
pm2 start ecosystem.config.js --env production

PM2는 다음과 같은 유용한 명령어도 제공해:

// 상태 확인
pm2 status

// 로그 확인
pm2 logs

// 모니터링
pm2 monit

// 프로세스 재시작
pm2 restart my-express-app

// 프로세스 중지
pm2 stop my-express-app

// 프로세스 삭제
pm2 delete my-express-app

PM2를 사용하면 애플리케이션의 가용성과 안정성을 크게 향상시킬 수 있어! ⚙️

클라우드 플랫폼에 배포하기 ☁️

Express.js 애플리케이션을 다양한 클라우드 플랫폼에 배포할 수 있어. 가장 인기 있는 몇 가지 옵션을 살펴볼게:

Heroku에 배포하기

Heroku는 Node.js 애플리케이션을 쉽게 배포할 수 있는 PaaS(Platform as a Service)야.

1. Heroku CLI를 설치해.
2. Heroku 계정에 로그인해:

   heroku login

3. 프로젝트 루트에 Procfile을 생성해:

   web: node app.js

4. package.json에 Node.js 버전을 명시해:

   "engines": {
     "node": "14.x"
   }

5. Heroku 앱을 생성해:

   heroku create my-express-app

6. 환경 변수를 설정해:

   heroku config:set JWT_SECRET=your-secret-key

7. 코드를 배포해:

   git push heroku main

AWS Elastic Beanstalk에 배포하기

AWS Elastic Beanstalk는 애플리케이션을 배포하고 확장하기 쉬운 서비스야.

1. AWS CLI와 EB CLI를 설치해.
2. EB CLI를 초기화해:

   eb init

3. 환경을 생성하고 배포해:

   eb create my-express-env

4. 변경사항을 배포해:

   eb deploy

Google Cloud Run에 배포하기

Google Cloud Run은 컨테이너화된 애플리케이션을 서버리스로 실행할 수 있는 서비스야.

1. Google Cloud SDK를 설치해.
2. Dockerfile을 생성해:

   FROM node:14-alpine
   
   WORKDIR /app
   
   COPY package*.json ./
   RUN npm install --production
   
   COPY . .
   
   CMD ["node", "app.js"]

3. 이미지를 빌드하고 푸시해:

   gcloud builds submit --tag gcr.io/YOUR_PROJECT_ID/my-express-app

4. Cloud Run에 배포해:

   gcloud run deploy my-express-app --image gcr.io/YOUR_PROJECT_ID/my-express-app --platform managed

Docker를 사용한 컨테이너화 🐳

Docker를 사용하면 애플리케이션과 그 의존성을 컨테이너로 패키징할 수 있어. 이렇게 하면 어떤 환경에서든 동일하게 실행할 수 있지!

먼저 Dockerfile을 생성해:

FROM node:14-alpine

# 작업 디렉토리 설정
WORKDIR /app

# package.json과 package-lock.json 복사
COPY package*.json ./

# 의존성 설치
RUN npm install --production

# 소스 코드 복사
COPY . .

# 포트 노출
EXPOSE 3000

# 애플리케이션 실행
CMD ["node", "app.js"]

그리고 Docker 이미지를 빌드하고 실행해:

// 이미지 빌드
docker build -t my-express-app .

// 컨테이너 실행
docker run -p 3000:3000 -d my-express-app

여러 서비스(Node.js, MongoDB 등)를 함께 실행하려면 Docker Compose를 사용할 수 있어:

// docker-compose.yml
version: '3'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - MONGODB_URI=mongodb://mongo:27017/myapp
    depends_on:
      - mongo
  mongo:
    image: mongo
    ports:
      - "27017:27017"
    volumes:
      - mongo-data:/data/db
volumes:
  mongo-data:

Docker Compose로 서비스를 실행해:

docker-compose up -d

Docker를 사용하면 개발 환경과 프로덕션 환경의 일관성을 유지할 수 있어. 이는 "내 컴퓨터에서는 작동했는데..."라는 문제를 해결하는 데 큰 도움이 돼! 🐳

NGINX를 사용한 리버스 프록시 설정 🔄

프로덕션 환경에서는 NGINX 같은 웹 서버를 리버스 프록시로 사용하는 것이 일반적이야. 이렇게 하면 정적 파일 제공, SSL 종료, 로드 밸런싱 등의 기능을 활용할 수 있어.

다음은 NGINX 설정 예제야:

// /etc/nginx/sites-available/my-express-app
server {
    listen 80;
    server_name example.com www.example.com;

    # HTTP를 HTTPS로 리다이렉트
    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl;
    server_name example.com www.example.com;

    # SSL 인증서 설정
    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384;

    # 정적 파일 제공
    location /static/ {
        alias /var/www/my-express-app/public/;
        expires 30d;
        add_header Cache-Control "public, max-age=2592000";
    }

    # Express.js 애플리케이션으로 프록시
    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection '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;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
    }
}

이 설정을 활성화하려면 다음 명령어를 실행해:

sudo ln -s /etc/nginx/sites-available/my-express-app /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

NGINX를 리버스 프록시로 사용하면 보안과 성능을 향상시킬 수 있어. 특히 여러 Node.js 인스턴스를 실행하는 경우 로드 밸런싱에 유용해! 🔄

지속적 통합 및 배포(CI/CD) 설정 🔄

CI/CD 파이프라인을 설정하면 코드 변경사항을 자동으로 테스트하고 배포할 수 있어. GitHub Actions, GitLab CI/CD, Jenkins 등 다양한 도구를 사용할 수 있어.

다음은 GitHub Actions를 사용한 CI/CD 설정 예제야:

// .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Use Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14'
      - name: Install dependencies
        run: npm ci
      - name: Run tests
        run: npm test

  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Deploy to Heroku
        uses: akhileshns/heroku-deploy@v3.12.12
        with:
          heroku_api_key: ${{ secrets.HEROKU_API_KEY }}
          heroku_app_name: "my-express-app"
          heroku_email: ${{ secrets.HEROKU_EMAIL }}

CI/CD 파이프라인을 설정하면 개발 워크플로우를 자동화하고 배포 과정에서 발생할 수 있는 인적 오류를 줄일 수 있어! 🔄

배포에 대해 기본적인 내용을 배웠으니, 다음 섹션에서는 Express.js 애플리케이션의 성능을 최적화하는 방법에 대해 알아볼게. 계속 따라와! 🚶‍♂️

✨ Express.js 모범 사례: 더 나은 개발을 위한 팁

Express.js로 개발할 때 모범 사례를 따르면 코드 품질을 향상시키고 유지보수를 쉽게 만들 수 있어. 이번 섹션에서는 Express.js 개발의 모범 사례와 팁을 알아볼게! ✨

프로젝트 구조화 📂

잘 구조화된 프로젝트는 코드 탐색과 유지보수를 쉽게 만들어. 다음은 Express.js 프로젝트의 일반적인 구조야:

my-express-app/
├── config/             # 설정 파일
│   ├── database.js     # 데이터베이스 설정
│   └── passport.js     # 인증 설정
├── controllers/        # 라우트 핸들러
│   ├── authController.js
│   └── userController.js
├── middlewares/        # 커스텀 미들웨어
│   ├── auth.js
│   └── error.js
├── models/             # 데이터 모델
│   ├── User.js
│   └── Post.js
├── routes/             # 라우트 정의
│   ├── authRoutes.js
│   └── userRoutes.js
├── services/           # 비즈니스 로직
│   ├── authService.js
│   └── userService.js
├── utils/              # 유틸리티 함수
│   ├── logger.js
│   └── validator.js
├── public/             # 정적 파일
│   ├── css/
│   ├── js/
│   └── images/
├── views/              # 템플릿 파일
│   ├── layouts/
│   └── pages/
├── tests/              # 테스트 파일
│   ├── unit/
│   └── integration/
├── .env                # 환경 변수
├── .gitignore          # Git 무시 파일
├── app.js              # 애플리케이션 진입점
└── package.json        # 프로젝트 메타데이터

이런 구조를 사용하면 관심사 분리(Separation of Concerns) 원칙을 따를 수 있어. 각 파일과 디렉토리는 특정 역할을 담당하고, 코드의 재사용성과 테스트 용이성이 향상돼! 📂

비동기 코드 처리 ⏱️

Express.js에서 비동기 코드를 처리할 때는 Promise와 async/await를 사용하는 것이 좋아. 콜백 지옥을 피하고 코드를 더 읽기 쉽게 만들 수 있거든!

다음은 async/await를 사용한 라우트 핸들러 예제야:

// 콜백 방식 (권장하지 않음)
app.get('/users', (req, res) => {
  User.find({}, (err, users) => {
    if (err) {
      return res.status(500).json({ error: err.message });
    }
    res.json(users);
  });
});

// Promise 방식
app.get('/users', (req, res) => {
  User.find({})
    .then(users => res.json(users))
    .catch(err => res.status(500).json({ error: err.message }));
});

// async/await 방식 (가장 권장)
app.get('/users', async (req, res) => {
  try {
    const users = await User.find({});
    res.json(users);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

async/await를 사용하면 비동기 코드를 동기 코드처럼 작성할 수 있어. 이는 코드의 가독성과 유지보수성을 크게 향상시켜! ⏱️

오류 처리 통합 ⚠️

일관된 오류 처리는 사용자 경험과 디버깅에 중요해. 다음은 통합된 오류 처리 방법이야:

// 커스텀 오류 클래스
class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.status = `${statusCode}`.startsWith('4') ? 'fail' : 'error';
    this.isOperational = true;
    
    Error.captureStackTrace(this, this.constructor);
  }
}

// 오류 생성 함수
const createError = (message, statusCode) => {
  return new AppError(message, statusCode);
};

// 비동기 함수 래퍼 (try-catch 반복 방지)
const catchAsync = fn => {
  return (req, res, next) => {
    fn(req, res, next).catch(next);
  };
};

// 라우트 핸들러에서 사용
app.get('/users/:id', catchAsync(async (req, res, next) => {
  const user = await User.findById(req.params.id);
  
  if (!user) {
    return next(createError('사용자를 찾을 수 없어!', 404));
  }
  
  res.json(user);
}));

// 글로벌 오류 처리 미들웨어
app.use((err, req, res, next) => {
  err.statusCode = err.statusCode || 500;
  err.status = err.status || 'error';
  
  // 개발 환경에서는 자세한 오류 정보 제공
  if (process.env.NODE_ENV === 'development') {
    res.status(err.statusCode).json({
      status: err.status,
      error: err,
      message: err.message,
      stack: err.stack
    });
  } 
  // 프로덕션 환경에서는 간단한 오류 메시지만 제공
  else {
    // 운영상의 오류인 경우
    if (err.isOperational) {
      res.status(err.statusCode).json({
        status: err.status,
        message: err.message
      });
    } 
    // 프로그래밍 오류나 알 수 없는 오류인 경우
    else {
      console.error('ERROR 💥', err);
      res.status(500).json({
        status: 'error',
        message: '문제가 발생했어. 나중에 다시 시도해줘!'
      });
    }
  }
});

이런 방식으로 오류를 처리하면 코드 중복을 줄이고 일관된 오류 응답을 제공할 수 있어. 또한 개발 환경과 프로덕션 환경에서 다른 수준의 오류 정보를 제공할 수 있지! ⚠️

입력 유효성 검사 ✅

사용자 입력을 항상 검증하는 것은 보안과 데이터 무결성에 중요해. Express-validator 같은 라이브러리를 사용하면 쉽게 구현할 수 있어:

const { body, validationResult } = require('express-validator');

// 사용자 등록 유효성 검사
app.post('/api/register', [
  // 이름 검증
  body('name')
    .trim()
    .notEmpty().withMessage('이름은 필수야!')
    .isLength({ min: 2 }).withMessage('이름은 최소 2글자 이상이어야 해!'),
  
  // 이메일 검증
  body('email')
    .trim()
    .notEmpty().withMessage('이메일은 필수야!')
    .isEmail().withMessage('유효한 이메일 주소를 입력해줘!')
    .normalizeEmail(),
  
  // 비밀번호 검증
  body('password')
    .trim()
    .notEmpty().withMessage('비밀번호는 필수야!')
    .isLength({ min: 8 }).withMessage('비밀번호는 최소 8글자 이상이어야 해!')
    .matches(/\d/).withMessage('비밀번호는 최소 하나의 숫자를 포함해야 해!')
    .matches(/[a-z]/).withMessage('비밀번호는 최소 하나의 소문자를 포함해야 해!')
    .matches(/[A-Z]/).withMessage('비밀번호는 최소 하나의 대문자를 포함해야 해!')
    .matches(/[!@#$%^&*(),.?":{}|<>]/).withMessage('비밀번호는 최소 하나의 특수 문자를 포함해야 해!'),
  
  // 비밀번호 확인 검증
  body('passwordConfirm')
    .trim()
    .notEmpty().withMessage('비밀번호 확인은 필수야!')
    .custom((value, { req }) => {
      if (value !== req.body.password) {
        throw new Error('비밀번호가 일치하지 않아!');
      }
      return true;
    })
], (req, res) => {
  // 유효성 검사 오류 확인
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }
  
  // 유효성 검사 통과 시 사용자 등록 로직
  // ...
});

입력 유효성 검사를 통해 잘못된 데이터가 시스템에 들어오는 것을 방지하고, 사용자에게 명확한 오류 메시지를 제공할 수 있어! ✅

보안 강화 🔒

Express.js 애플리케이션의 보안을 강화하기 위한 몇 가지 팁이야:

1. Helmet 사용: HTTP 헤더를 설정해 알려진 웹 취약점으로부터 앱을 보호해.
2. 입력 유효성 검사: 모든 사용자 입력을 검증해.
3. CSRF 보호: CSRF 공격을 방지하기 위한 토큰을 사용해.
4. 속도 제한: 브루트 포스 공격을 방지하기 위해 요청 속도를 제한해.
5. HTTPS 사용: 모든 통신을 암호화해.
6. 안전한 쿠키 설정: httpOnly, secure, sameSite 옵션을 사용해.
7. 의존성 취약점 검사: npm audit을 정기적으로 실행해.

다음은 이런 보안 조치를 구현하는 예제야:

const express = require('express');
const helmet = require('helmet');
const csrf = require('csurf');
const rateLimit = require('express-rate-limit');
const cookieParser = require('cookie-parser');

const app = express();

// 기본 미들웨어
app.use(express.json({ limit: '10kb' })); // 요청 본문 크기 제한
app.use(cookieParser());

// 보안 헤더 설정
app.use(helmet());

// CSRF 보호
app.use(csrf({ cookie: true }));

// 속도 제한
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 100, // IP당 최대 요청 수
  message: '너무 많은 요청을 보냈어. 15분 후에 다시 시도해줘!'
});
app.use('/api', limiter);

// 안전한 쿠키 설정
app.use((req, res, next) => {
  res.cookie('cookieName', 'cookieValue', {
    httpOnly: true,
    secure: process.env.NODE_ENV === 'production',
    sameSite: 'strict',
    maxAge: 24 * 60 * 60 * 1000 // 24시간
  });
  next();
});

// CSRF 토큰 제공
app.get('/api/csrf-token', (req, res) => {
  res.json({ csrfToken: req.csrfToken() });
});

// 의존성 취약점 검사 명령어
// npm audit
// npm audit fix

이런 보안 조치를 구현하면 애플리케이션을 다양한 공격으로부터 보호할 수 있어! 🔒

성능 최적화 ⚡

Express.js 애플리케이션의 성능을 최적화하기 위한 몇 가지 팁이야:

1. 응답 압축: 응답 데이터를 압축해 전송 시간을 줄여.
2. 캐싱: 자주 변경되지 않는 데이터를 캐시해.
3. 데이터베이스 쿼리 최적화: 필요한 필드만 선택하고, 인덱스를 활용해.
4. 비동기 작업 병렬 처리: Promise.all을 사용해 독립적인 비동기 작업을 병렬로 처리해.
5. 정적 파일 제공 최적화: 정적 파일에 캐시 헤더를 설정하고, CDN을 활용해.

다음은 이런 성능 최적화를 구현하는 예제야:

const express = require('express');
const compression = require('compression');

const app = express();

// 응답 압축
app.use(compression());

// 정적 파일 제공 최적화
app.use(express.static('public', {
  maxAge: '1d', // 1일 동안 캐시
  etag: true,
  lastModified: true
}));

// 데이터베이스 쿼리 최적화 예제
app.get('/api/users', async (req, res) => {
  try {
    // 필요한 필드만 선택
    const users = await User.find({})
      .select('name email')
      .limit(10)
      .lean(); // POJO(Plain Old JavaScript Object)로 변환
    
    res.json(users);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// 비동기 작업 병렬 처리 예제
app.get('/api/dashboard', async (req, res) => {
  try {
    // 독립적인 비동기 작업을 병렬로 처리
    const [users, posts, comments] = await Promise.all([
      User.countDocuments(),
      Post.find().sort('-createdAt').limit(5),
      Comment.find().sort('-createdAt').limit(10)
    ]);
    
    res.json({
      userCount: users,
      recentPosts: posts,
      recentComments: comments
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

이런 성능 최적화를 구현하면 애플리케이션의 응답 시간을 줄이고 사용자 경험을 향상시킬 수 있어! ⚡

테스트 작성 🧪

테스트는 코드의 품질을 유지하고 버그를 조기에 발견하는 데 중요해. Express.js 애플리케이션에서는 Mocha, Chai, Supertest 같은 도구를 사용해 테스트를 작성할 수 있어.

먼저 필요한 패키지를 설치해:

npm install --save-dev mocha chai supertest

그리고 테스트 파일을 작성해:

// tests/integration/users.test.js
const request = require('supertest');
const { expect } = require('chai');
const app = require('../../app');
const User = require('../../models/User');

describe('User API', () => {
  // 각 테스트 전에 데이터베이스 초기화
  beforeEach(async () => {
    await User.deleteMany({});
  });
  
  describe('GET /api/users', () => {
    it('should return all users', async () => {
      // 테스트 데이터 생성
      await User.create([
        { name: '김철수', email: 'kim@example.com' },
        { name: '이영희', email: 'lee@example.com' }
      ]);
      
      // API 요청
      const res = await request(app).get('/api/users');
      
      // 응답 검증
      expect(res.status).to.equal(200);
      expect(res.body).to.be.an('array');
      expect(res.body.length).to.equal(2);
      expect(res.body[0]).to.have.property('name', '김철수');
    });
  });
  
  describe('POST /api/users', () => {
    it('should create a new user', async () => {
      const userData = {
        name: '박지민',
        email: 'park@example.com',
        password: 'Password123!'
      };
      
      // API 요청
      const res = await request(app)
        .post('/api/users')
        .send(userData);
      
      // 응답 검증
      expect(res.status).to.equal(201);
      expect(res.body).to.have.property('name', '박지민');
      expect(res.body).to.have.property('email', 'park@example.com');
      expect(res.body).to.not.have.property('password'); // 비밀번호는 응답에 포함되면 안 됨
      
      // 데이터베이스 검증
      const user = await User.findOne({ email: 'park@example.com' });
      expect(user).to.not.be.null;
      expect(user.name).to.equal('박지민');
    });
    
    it('should return 400 if email is already registered', async () => {
      // 기존 사용자 생성
      await User.create({
        name: '김철수',
        email: 'kim@example.com',
        password: 'Password123!'
      });
      
      // 같은 이메일로 새 사용자 생성 시도
      const userData = {
        name: '김철수2',
        email: 'kim@example.com',
        password: 'Password123!'
      };
      
      // API 요청
      const res = await request(app)
        .post('/api/users')
        .send(userData);
      
      // 응답 검증
      expect(res.status).to.equal(400);
      expect(res.body).to.have.property('error');
    });
  });
});

package.json에 테스트 스크립트를 추가해:

"scripts": {
  "test": "mocha tests/**/*.test.js --timeout 5000"
}

이제 다음 명령어로 테스트를 실행할 수 있어:

npm test

테스트를 작성하면 코드의 안정성을 보장하고, 리팩토링이나 새 기능 추가 시 기존 기능이 깨지지 않았는지 확인할 수 있어! 🧪

문서화 📚

API 문서화는 다른 개발자들이 API를 쉽게 이해하고 사용할 수 있게 도와줘. Swagger/OpenAPI, API Blueprint, Postman 등의 도구를 사용할 수 있어.

다음은 Swagger를 사용한 API 문서화 예제야:

// swagger.js
const swaggerJsdoc = require('swagger-jsdoc');
const swaggerUi = require('swagger-ui-express');

const options = {
  definition: {
    openapi: '3.0.0',
    info: {
      title: 'My Express API',
      version: '1.0.0',
      description: 'API 문서',
    },
    servers: [
      {
        url: 'http://localhost:3000',
        description: '개발 서버',
      },
    ],
  },
  apis: ['./routes/*.js'], // 라우트 파일 경로
};

const specs = swaggerJsdoc(options);

module.exports = (app) => {
  app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(specs));
};

라우트 파일에 Swagger 주석을 추가해:

/**
 * @swagger
 * /api/users:
 *   get:
 *     summary: 모든 사용자 조회
 *     description: 모든 사용자의 목록을 반환합니다.
 *     responses:
 *       200:
 *         description: 사용자 목록
 *         content:
 *           application/json:
 *             schema:
 *               type: array
 *               items:
 *                 type: object
 *                 properties:
 *                   id:
 *                     type: string
 *                     description: 사용자 ID
 *                   name:
 *                     type: string
 *                     description: 사용자 이름
 *                   email:
 *                     type: string
 *                     description: 사용자 이메일
 */
router.get('/users', userController.getAllUsers);

app.js에 Swagger 설정을 추가해:

const express = require('express');
const app = express();

// ... 다른 설정들 ...

// Swagger 설정
require('./swagger')(app);

// ... 라우트 설정 등 ...

이제 http://localhost:3000/api-docs에서 API 문서를 볼 수 있어! 문서화를 통해 API의 사용성을 향상시키고 개발자 간의 협업을 촉진할 수 있어! 📚

이런 모범 사례들을 따르면 더 나은 Express.js 애플리케이션을 개발할 수 있어. 코드 품질이 향상되고, 유지보수가 쉬워지며, 팀 협업이 원활해질 거야! ✨

🎉 마무리: Express.js로 백엔드 개발의 세계를 정복하자!

여기까지 Express.js를 활용한 백엔드 개발의 여정을 함께 했어! 정말 긴 여정이었지만, 이제 너는 Express.js의 기본부터 고급 기능까지 다양한 내용을 배웠어. 👏

우리가 함께 살펴본 내용을 요약해볼게:

1. Node.js와 Express.js 기초: JavaScript를 서버 측에서 실행하는 Node.js와 웹 애플리케이션 개발을 쉽게 만들어주는 Express.js의 기본 개념
2. 라우팅과 미들웨어: 클라이언트 요청을 처리하는 라우팅과 요청-응답 사이클을 관리하는 미들웨어
3. 요청과 응답 처리: 다양한 형태의 요청 데이터를 처리하고 응답을 보내는 방법
4. 데이터베이스 연동: MongoDB, MySQL 등 다양한 데이터베이스와 Express.js를 연동하는 방법
5. 인증과 권한 부여: JWT, 세션, Passport.js 등을 사용한 인증 구현 방법
6. 배포와 운영: Express.js 애플리케이션을 프로덕션 환경에 배포하고 운영하는 방법
7. 모범 사례: 더 나은 Express.js 애플리케이션을 개발하기 위한 팁과 모범 사례

이제 너는 Express.js를 활용해 다양한 백엔드 애플리케이션을 개발할 수 있는 지식을 갖추게 됐어! 🚀

다음 단계는? 🛣️

Express.js를 마스터하기 위한 여정은 여기서 끝나지 않아. 다음과 같은 주제들을 더 탐구해보면 좋을 거야:

1. GraphQL: REST API의 대안으로, 클라이언트가 필요한 데이터만 요청할 수 있는 쿼리 언어
2. WebSocket: 실시간 양방향 통신을 위한 프로토콜
3. 마이크로서비스 아키텍처: 큰 애플리케이션을 작은 서비스들로 분리하는 아키텍처 패턴
4. 서버리스 아키텍처: AWS Lambda, Google Cloud Functions 등을 활용한 서버리스 백엔드 개발
5. 컨테이너화와 오케스트레이션: Docker, Kubernetes 등을 활용한 애플리케이션 배포와 확장

또한, 실제 프로젝트를 만들어보는 것이 가장 좋은 학습 방법이야. 블로그, 소셜 미디어 플랫폼, 이커머스 사이트 등 다양한 프로젝트를 통해 배운 내용을 적용해보면 좋을 거야! 🏗️

재능넷에서 Express.js 개발자로 활동하기 💼

Express.js 기술을 익혔다면, 재능넷과 같은 재능 공유 플랫폼에서 백엔드 개발자로 활동할 수도 있어! 많은 기업과 개인이 Node.js와 Express.js 기술을 가진 개발자를 찾고 있거든. 너의 재능을 공유하고 수익도 창출할 수 있는 좋은 기회가 될 거야! 💰

Express.js는 계속해서 발전하고 있어. 공식 문서를 정기적으로 확인하고, 커뮤니티에 참여하며, 최신 트렌드를 따라가는 것이 중요해. 백엔드 개발은 끊임없이 배우고 성장하는 여정이니까! 🌱

마지막으로, 이 글이 너의 Express.js 학습 여정에 도움이 됐길 바라! 어떤 질문이나 피드백이 있다면 언제든지 공유해줘. 함께 성장하는 개발자 커뮤니티를 만들어가자! 👋

행운을 빌어! Express.js로 멋진 백엔드 애플리케이션을 만들어보자! 🎉