AI 기반 시각화 전문지식 서비스

프로그램개발 · 분야 선택22개 분야

Ver3.0 전체 열람

Ver3.0 🚀 Deno와 Oak 프레임워크로 시작하는 서버리스 API 개발 완벽 가이드

2025.11.12

재능넷

댓글 0 전체 57 페이지

🚀 Deno와 Oak 프레임워크로 시작하는 서버리스 API 개발 완벽 가이드

친구처럼 쉽게 배우는 차세대 JavaScript 런타임 활용법

안녕! 👋 오늘은 요즘 개발자들 사이에서 핫한 화제인 Deno와 Oak 프레임워크를 활용한 서버리스 API 개발에 대해 이야기해볼게. Node.js의 창시자가 만든 차세대 런타임인 Deno, 들어는 봤는데 막상 어떻게 시작해야 할지 막막했다면? 이 글이 딱 너를 위한 거야! 😊

서버리스 아키텍처는 이제 선택이 아닌 필수가 되어가고 있어. 특히 스타트업이나 개인 프로젝트에서 빠르게 MVP를 만들어야 할 때, Deno와 Oak의 조합은 정말 강력한 무기가 되어줄 거야. 재능넷 같은 플랫폼에서도 이런 최신 기술 스택을 활용한 개발 재능을 공유하는 전문가들이 점점 늘어나고 있다는 사실! 🔥

🤔 Deno가 뭐길래 이렇게 난리야?

자, 먼저 Deno가 뭔지부터 알아보자. Deno는 Node.js를 만든 라이언 달(Ryan Dahl)이 2018년에 발표한 새로운 JavaScript/TypeScript 런타임이야. 그런데 왜 Node.js를 만든 사람이 또 다른 런타임을 만들었을까? 🤨

라이언 달은 2018년 JSConf에서 "Node.js에 대한 10가지 후회"라는 제목의 발표를 했어. 그는 Node.js를 만들면서 보안, 모듈 시스템, package.json 등 여러 부분에서 아쉬운 결정을 내렸다고 고백했지. 그리고 이런 문제들을 해결하기 위해 처음부터 다시 설계한 게 바로 Deno야!

🎯 Deno의 핵심 특징

1. 보안 우선 (Secure by Default) 🔒
Deno는 기본적으로 파일, 네트워크, 환경변수 접근이 모두 차단되어 있어. 명시적으로 권한을 부여해야만 접근할 수 있지. 이건 정말 혁신적인 변화야!

2. TypeScript 네이티브 지원 📘
별도의 설정 없이 TypeScript를 바로 실행할 수 있어. 타입 안정성을 원한다면 Deno가 최고의 선택이지.

3. ES 모듈 표준 사용 📦
CommonJS 대신 표준 ES 모듈을 사용해. URL로 직접 모듈을 import할 수 있어서 npm 같은 중앙 패키지 관리자가 필요 없어.

4. 내장 도구들 🛠️
포매터, 린터, 테스트 러너, 번들러가 모두 내장되어 있어. 별도의 패키지 설치가 필요 없다는 게 얼마나 편한지!

5. 웹 표준 API 🌐
fetch, WebSocket 등 브라우저 API를 그대로 사용할 수 있어. 프론트엔드 개발자라면 러닝 커브가 거의 없지!

🌳 Oak 프레임워크는 또 뭐야?

Oak는 Deno를 위한 미들웨어 프레임워크야. Node.js의 Express나 Koa를 사용해봤다면 금방 익숙해질 거야. 실제로 Oak는 Koa에서 영감을 받아 만들어졌거든! 🌲

Oak의 이름도 재미있어. "Deno"는 공룡을 의미하는데, 공룡이 살던 시대에는 참나무(Oak)가 많았다는 컨셉에서 따온 거래. 귀엽지? 😄

💡 Oak를 선택해야 하는 이유

• 간결한 API - Express보다 더 직관적이고 깔끔한 코드 작성이 가능해
• 강력한 라우팅 - RESTful API 구축에 최적화되어 있어
• 미들웨어 생태계 - 인증, 로깅, CORS 등 필요한 미들웨어가 잘 갖춰져 있어
• TypeScript 친화적 - 타입 정의가 완벽하게 되어 있어서 개발 경험이 정말 좋아
• 활발한 커뮤니티 - Deno 생태계에서 가장 인기 있는 웹 프레임워크야

🚀 Deno 설치부터 시작해보자!

자, 이제 본격적으로 시작해볼까? 먼저 Deno를 설치해야겠지? 설치는 정말 간단해! 😎

📥 설치 방법 (운영체제별)

macOS / Linux (Shell)

curl -fsSL https://deno.land/x/install/install.sh | sh

Windows (PowerShell)

irm https://deno.land/install.ps1 | iex

Homebrew (macOS)

brew install deno

Chocolatey (Windows)

choco install deno

설치가 끝났으면 터미널에서 확인해보자:

deno --version

버전 정보가 나오면 성공! 🎉 나는 현재 Deno 1.40.0을 사용하고 있어. (2024년 기준)

⚠️ 환경 변수 설정 주의사항

설치 후 PATH 환경 변수가 자동으로 설정되지 않을 수 있어. 그럴 땐 쉘 설정 파일(.bashrc, .zshrc 등)에 다음을 추가해줘:

export DENO_INSTALL="/home/username/.deno"
export PATH="$DENO_INSTALL/bin:$PATH"

그리고 source ~/.bashrc (또는 해당 쉘 설정 파일)로 적용하면 돼!

🎨 첫 번째 Deno 프로그램 만들기

설치가 끝났으니 간단한 프로그램부터 만들어보자. Deno의 매력을 느껴볼 시간이야! ✨

👶 Hello World 예제

hello.ts 파일을 만들고 다음 코드를 작성해봐:

// hello.ts
const greeting: string = "Hello, Deno! 🦕";
console.log(greeting);

// 현재 시간도 출력해보자
const now = new Date();
console.log(`현재 시간: ${now.toLocaleString('ko-KR')}`);

실행은 이렇게:

deno run hello.ts

보이지? TypeScript 파일을 별도의 컴파일 없이 바로 실행했어! 이게 Deno의 첫 번째 매력 포인트야. 😍

🌐 웹 서버 만들어보기

이제 간단한 웹 서버를 만들어볼까? server.ts 파일을 만들어:

// server.ts
const port = 8000;

const handler = (request: Request): Response => {
  const body = `Your user-agent is:\n\n${
    request.headers.get("user-agent") ?? "Unknown"
  }`;
  
  return new Response(body, { 
    status: 200,
    headers: {
      "content-type": "text/plain; charset=utf-8"
    }
  });
};

console.log(`HTTP 서버가 http://localhost:${port}/ 에서 실행 중입니다 🚀`);
Deno.serve({ port }, handler);

실행할 때는 네트워크 권한이 필요해:

deno run --allow-net server.ts

브라우저에서 http://localhost:8000에 접속하면 당신의 User-Agent 정보가 보일 거야! 🎯

여기서 주목할 점은 --allow-net 플래그야. 이게 바로 Deno의 보안 모델이지. 명시적으로 권한을 부여하지 않으면 네트워크 접근이 불가능해!

🌲 Oak 프레임워크로 본격 API 개발

자, 이제 Oak 프레임워크를 사용해서 제대로 된 API를 만들어보자! Oak는 별도 설치가 필요 없어. URL로 직접 import하면 돼. 이게 Deno의 두 번째 매력 포인트! 📦

🎬 기본 Oak 서버 구축

oak-basic.ts 파일을 만들어보자:

// oak-basic.ts
import { Application, Router } from "https://deno.land/x/oak@v12.6.1/mod.ts";

const router = new Router();

// 기본 라우트
router.get("/", (context) => {
  context.response.body = {
    message: "Welcome to Oak API! 🌲",
    timestamp: new Date().toISOString()
  };
});

// 사용자 정보 조회
router.get("/api/user/:id", (context) => {
  const userId = context.params.id;
  context.response.body = {
    id: userId,
    name: `User ${userId}`,
    email: `user${userId}@example.com`
  };
});

// POST 요청 처리
router.post("/api/users", async (context) => {
  const body = await context.request.body();
  const userData = await body.value;
  
  context.response.status = 201;
  context.response.body = {
    message: "사용자가 생성되었습니다",
    data: userData
  };
});

const app = new Application();

// 로거 미들웨어
app.use(async (context, next) => {
  const start = Date.now();
  await next();
  const ms = Date.now() - start;
  console.log(`${context.request.method} ${context.request.url} - ${ms}ms`);
});

app.use(router.routes());
app.use(router.allowedMethods());

console.log("🚀 Oak 서버가 http://localhost:8000 에서 실행 중입니다");
await app.listen({ port: 8000 });

실행:

deno run --allow-net oak-basic.ts

이제 API 테스트를 해보자! curl이나 Postman을 사용해도 되고, 브라우저에서 직접 접속해도 돼. 😊

🔍 코드 분석하기

위 코드에서 주목할 부분들을 살펴보자:

1. Import 방식
URL로 직접 모듈을 가져와. 버전도 URL에 명시되어 있어서 의존성 관리가 명확해.

2. Router 객체
Express의 Router와 비슷하지? HTTP 메서드별로 라우트를 정의할 수 있어.

3. Context 객체
request와 response가 하나의 context 객체로 통합되어 있어. Koa 스타일이지.

4. 미들웨어 체인
app.use()로 미들웨어를 등록하고, await next()로 다음 미들웨어를 호출해.

5. 비동기 처리
모든 핸들러가 async 함수로 작성되어 있어. Promise 기반의 깔끔한 비동기 처리가 가능해!

🎯 실전 RESTful API 구축하기

이제 실제 프로젝트에서 사용할 수 있는 수준의 API를 만들어보자. 간단한 블로그 API를 예제로 삼을게! 📝

📁 프로젝트 구조 설계

먼저 프로젝트 구조를 잡아보자:

blog-api/
├── src/
│   ├── controllers/
│   │   └── postController.ts
│   ├── models/
│   │   └── Post.ts
│   ├── routes/
│   │   └── postRoutes.ts
│   ├── middleware/
│   │   └── logger.ts
│   └── app.ts
├── deps.ts
└── mod.ts

Deno에서는 deps.ts 파일에 모든 외부 의존성을 모아두는 게 관례야. 이렇게 하면 의존성 관리가 훨씬 쉬워져!

📦 deps.ts - 의존성 관리

// deps.ts
export {
  Application,
  Router,
  Context,
  Status,
} from "https://deno.land/x/oak@v12.6.1/mod.ts";

export type {
  RouterContext,
  Middleware,
} from "https://deno.land/x/oak@v12.6.1/mod.ts";

이제 다른 파일에서는 deps.ts에서 import하면 돼. 버전 관리가 한 곳에서 이루어지니까 편하지? 🎯

📄 모델 정의 - Post.ts

// src/models/Post.ts
export interface Post {
  id: string;
  title: string;
  content: string;
  author: string;
  createdAt: Date;
  updatedAt: Date;
  tags: string[];
}

export class PostStore {
  private posts: Map<string, Post> = new Map();

  create(post: Omit<Post, 'id' | 'createdAt' | 'updatedAt'>): Post {
    const id = crypto.randomUUID();
    const now = new Date();
    
    const newPost: Post = {
      ...post,
      id,
      createdAt: now,
      updatedAt: now,
    };
    
    this.posts.set(id, newPost);
    return newPost;
  }

  findAll(): Post[] {
    return Array.from(this.posts.values());
  }

  findById(id: string): Post | undefined {
    return this.posts.get(id);
  }

  update(id: string, updates: Partial<Post>): Post | undefined {
    const post = this.posts.get(id);
    if (!post) return undefined;

    const updatedPost: Post = {
      ...post,
      ...updates,
      id: post.id,
      createdAt: post.createdAt,
      updatedAt: new Date(),
    };

    this.posts.set(id, updatedPost);
    return updatedPost;
  }

  delete(id: string): boolean {
    return this.posts.delete(id);
  }

  findByTag(tag: string): Post[] {
    return this.findAll().filter(post => 
      post.tags.includes(tag)
    );
  }
}

// 싱글톤 인스턴스
export const postStore = new PostStore();

여기서는 간단하게 메모리 저장소를 사용했어. 실제 프로덕션에서는 데이터베이스를 연결해야겠지? 나중에 MongoDB나 PostgreSQL 연결하는 방법도 알려줄게! 💾

🎮 컨트롤러 작성 - postController.ts

// src/controllers/postController.ts
import { RouterContext, Status } from "../../deps.ts";
import { postStore } from "../models/Post.ts";

export const getAllPosts = (context: RouterContext<"/posts">) => {
  const posts = postStore.findAll();
  context.response.body = {
    success: true,
    data: posts,
    count: posts.length,
  };
};

export const getPostById = (context: RouterContext<"/posts/:id">) => {
  const { id } = context.params;
  const post = postStore.findById(id);

  if (!post) {
    context.response.status = Status.NotFound;
    context.response.body = {
      success: false,
      message: "포스트를 찾을 수 없습니다",
    };
    return;
  }

  context.response.body = {
    success: true,
    data: post,
  };
};

export const createPost = async (context: RouterContext<"/posts">) => {
  try {
    const body = await context.request.body();
    const postData = await body.value;

    // 유효성 검사
    if (!postData.title || !postData.content || !postData.author) {
      context.response.status = Status.BadRequest;
      context.response.body = {
        success: false,
        message: "title, content, author는 필수 항목입니다",
      };
      return;
    }

    const newPost = postStore.create({
      title: postData.title,
      content: postData.content,
      author: postData.author,
      tags: postData.tags || [],
    });

    context.response.status = Status.Created;
    context.response.body = {
      success: true,
      data: newPost,
      message: "포스트가 생성되었습니다",
    };
  } catch (error) {
    context.response.status = Status.InternalServerError;
    context.response.body = {
      success: false,
      message: "서버 오류가 발생했습니다",
      error: error.message,
    };
  }
};

export const updatePost = async (context: RouterContext<"/posts/:id">) => {
  const { id } = context.params;
  
  try {
    const body = await context.request.body();
    const updates = await body.value;

    const updatedPost = postStore.update(id, updates);

    if (!updatedPost) {
      context.response.status = Status.NotFound;
      context.response.body = {
        success: false,
        message: "포스트를 찾을 수 없습니다",
      };
      return;
    }

    context.response.body = {
      success: true,
      data: updatedPost,
      message: "포스트가 수정되었습니다",
    };
  } catch (error) {
    context.response.status = Status.InternalServerError;
    context.response.body = {
      success: false,
      message: "서버 오류가 발생했습니다",
      error: error.message,
    };
  }
};

export const deletePost = (context: RouterContext<"/posts/:id">) => {
  const { id } = context.params;
  const deleted = postStore.delete(id);

  if (!deleted) {
    context.response.status = Status.NotFound;
    context.response.body = {
      success: false,
      message: "포스트를 찾을 수 없습니다",
    };
    return;
  }

  context.response.status = Status.NoContent;
};

export const getPostsByTag = (context: RouterContext<"/posts/tag/:tag">) => {
  const { tag } = context.params;
  const posts = postStore.findByTag(tag);

  context.response.body = {
    success: true,
    data: posts,
    count: posts.length,
    tag,
  };
};

컨트롤러에서는 비즈니스 로직을 처리해. 에러 핸들링도 꼼꼼하게 해줬어. 실제 프로젝트에서는 이런 패턴이 정말 중요하거든! 🎯

🛣️ 라우트 설정 - postRoutes.ts

// src/routes/postRoutes.ts
import { Router } from "../../deps.ts";
import {
  getAllPosts,
  getPostById,
  createPost,
  updatePost,
  deletePost,
  getPostsByTag,
} from "../controllers/postController.ts";

export const postRouter = new Router();

postRouter
  .get("/posts", getAllPosts)
  .get("/posts/tag/:tag", getPostsByTag)
  .get("/posts/:id", getPostById)
  .post("/posts", createPost)
  .put("/posts/:id", updatePost)
  .delete("/posts/:id", deletePost);

라우트는 깔끔하게 분리했어. 체이닝 방식으로 작성하면 가독성이 좋지? 😊

🔧 미들웨어 작성 - logger.ts

// src/middleware/logger.ts
import { Context, Middleware } from "../../deps.ts";

export const logger: Middleware = async (context: Context, next) => {
  const start = Date.now();
  const { method, url } = context.request;

  await next();

  const ms = Date.now() - start;
  const status = context.response.status;
  
  // 상태 코드에 따라 색상 변경 (터미널 출력용)
  const statusColor = status >= 500 ? "🔴"
    : status >= 400 ? "🟡"
    : status >= 300 ? "🔵"
    : "🟢";

  console.log(
    `${statusColor} ${method} ${url.pathname} - ${status} - ${ms}ms`
  );
};

export const errorHandler: Middleware = async (context: Context, next) => {
  try {
    await next();
  } catch (error) {
    console.error("❌ 에러 발생:", error);
    
    context.response.status = 500;
    context.response.body = {
      success: false,
      message: "서버 내부 오류가 발생했습니다",
      error: error.message,
    };
  }
};

export const corsMiddleware: Middleware = async (context: Context, next) => {
  context.response.headers.set("Access-Control-Allow-Origin", "*");
  context.response.headers.set(
    "Access-Control-Allow-Methods",
    "GET, POST, PUT, DELETE, OPTIONS"
  );
  context.response.headers.set(
    "Access-Control-Allow-Headers",
    "Content-Type, Authorization"
  );

  if (context.request.method === "OPTIONS") {
    context.response.status = 204;
    return;
  }

  await next();
};

미들웨어는 재사용 가능한 로직을 담는 곳이야. 로깅, 에러 처리, CORS 설정 등을 깔끔하게 분리했어! 🛠️

🚀 메인 애플리케이션 - app.ts

// src/app.ts
import { Application } from "../deps.ts";
import { postRouter } from "./routes/postRoutes.ts";
import { logger, errorHandler, corsMiddleware } from "./middleware/logger.ts";

const app = new Application();

// 전역 미들웨어 등록
app.use(errorHandler);
app.use(logger);
app.use(corsMiddleware);

// 라우터 등록
app.use(postRouter.routes());
app.use(postRouter.allowedMethods());

// 404 핸들러
app.use((context) => {
  context.response.status = 404;
  context.response.body = {
    success: false,
    message: "요청하신 리소스를 찾을 수 없습니다",
    path: context.request.url.pathname,
  };
});

export default app;

🎬 진입점 - mod.ts

// mod.ts
import app from "./src/app.ts";

const PORT = 8000;
const HOST = "localhost";

console.log(`
🦕 Deno Blog API Server
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🚀 서버가 시작되었습니다!
📍 URL: http://${HOST}:${PORT}
📝 API 엔드포인트:
   GET    /posts           - 모든 포스트 조회
   GET    /posts/:id       - 특정 포스트 조회
   GET    /posts/tag/:tag  - 태그별 포스트 조회
   POST   /posts           - 새 포스트 생성
   PUT    /posts/:id       - 포스트 수정
   DELETE /posts/:id       - 포스트 삭제
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
`);

await app.listen({ port: PORT, hostname: HOST });

실행:

deno run --allow-net mod.ts

짜잔! 🎉 완전한 RESTful API가 완성됐어! 이제 Postman이나 curl로 테스트해보자.

🧪 API 테스트하기

API를 만들었으면 당연히 테스트를 해봐야겠지? curl 명령어로 간단하게 테스트해볼게! 💻

📝 포스트 생성 (POST)

curl -X POST http://localhost:8000/posts \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Deno와 Oak로 API 만들기",
    "content": "정말 쉽고 재미있어요!",
    "author": "개발자 김코딩",
    "tags": ["deno", "oak", "typescript"]
  }'

응답:

{
  "success": true,
  "data": {
    "id": "550e8400-e29b-41d4-a716-446655440000",
    "title": "Deno와 Oak로 API 만들기",
    "content": "정말 쉽고 재미있어요!",
    "author": "개발자 김코딩",
    "tags": ["deno", "oak", "typescript"],
    "createdAt": "2024-01-15T10:30:00.000Z",
    "updatedAt": "2024-01-15T10:30:00.000Z"
  },
  "message": "포스트가 생성되었습니다"
}

📖 모든 포스트 조회 (GET)

curl http://localhost:8000/posts

응답:

{
  "success": true,
  "data": [
    {
      "id": "550e8400-e29b-41d4-a716-446655440000",
      "title": "Deno와 Oak로 API 만들기",
      "content": "정말 쉽고 재미있어요!",
      "author": "개발자 김코딩",
      "tags": ["deno", "oak", "typescript"],
      "createdAt": "2024-01-15T10:30:00.000Z",
      "updatedAt": "2024-01-15T10:30:00.000Z"
    }
  ],
  "count": 1
}

🔍 특정 포스트 조회 (GET)

curl http://localhost:8000/posts/550e8400-e29b-41d4-a716-446655440000

✏️ 포스트 수정 (PUT)

curl -X PUT http://localhost:8000/posts/550e8400-e29b-41d4-a716-446655440000 \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Deno와 Oak로 API 만들기 (수정됨)",
    "content": "업데이트된 내용입니다!"
  }'

🗑️ 포스트 삭제 (DELETE)

curl -X DELETE http://localhost:8000/posts/550e8400-e29b-41d4-a716-446655440000

🏷️ 태그로 검색 (GET)

curl http://localhost:8000/posts/tag/deno

☁️ 서버리스 배포하기

자, 이제 가장 중요한 부분! 서버리스 환경에 배포하는 방법을 알아보자. Deno는 여러 서버리스 플랫폼을 지원해. 대표적인 것들을 살펴볼게! 🚀

🌟 Deno Deploy - 공식 서버리스 플랫폼

Deno Deploy는 Deno 팀이 직접 만든 서버리스 플랫폼이야. 전 세계 35개 이상의 엣지 로케이션에서 실행되어 초저지연을 자랑하지! 🌍

특징:
• 무료 티어 제공 (월 100만 요청)
• GitHub 연동으로 자동 배포
• 전역 CDN 내장
• 커스텀 도메인 지원
• 환경 변수 관리
• 실시간 로그 확인

🚀 Deno Deploy 배포 과정

1단계: 계정 생성
deno.com/deploy에 접속해서 GitHub 계정으로 로그인해.

2단계: 프로젝트 생성
"New Project" 버튼을 클릭하고 GitHub 저장소를 연결해.

3단계: 진입점 설정
배포할 파일을 선택해. 우리의 경우 mod.ts를 선택하면 돼.

4단계: 환경 변수 설정 (필요시)
프로젝트 설정에서 환경 변수를 추가할 수 있어.

5단계: 배포!
"Deploy Project" 버튼을 클릭하면 끝! 몇 초 안에 전 세계에 배포돼. 😎

배포가 완료되면 https://your-project.deno.dev 같은 URL이 생성돼. 이제 전 세계 어디서든 당신의 API에 접근할 수 있어!

⚙️ 배포용 코드 수정

Deno Deploy에서는 포트를 자동으로 할당해줘. 코드를 약간 수정해야 해:

// mod.ts (배포용)
import app from "./src/app.ts";

const PORT = parseInt(Deno.env.get("PORT") || "8000");

console.log(`🚀 서버가 포트 ${PORT}에서 실행 중입니다`);

await app.listen({ port: PORT });

환경 변수에서 PORT를 가져오도록 수정했어. 이렇게 하면 로컬과 배포 환경 모두에서 잘 작동해! 👍

⚠️ 배포 시 주의사항

1. 파일 시스템 접근 제한
Deno Deploy는 파일 시스템 접근이 제한되어 있어. 파일 기반 데이터베이스는 사용할 수 없어.

2. 환경 변수 사용
API 키나 비밀번호는 절대 코드에 하드코딩하지 말고 환경 변수를 사용해.

3. 메모리 제한
무료 티어는 메모리 제한이 있어. 대용량 데이터 처리는 주의해야 해.

4. 실행 시간 제한
요청당 최대 실행 시간이 있어. 장시간 실행되는 작업은 적합하지 않아.

🗄️ 데이터베이스 연결하기

실제 프로덕션 환경에서는 데이터베이스가 필수겠지? Deno에서 사용할 수 있는 데이터베이스 옵션들을 알아보자! 💾

🍃 MongoDB 연결

MongoDB는 Deno와 궁합이 정말 좋아. mongo 드라이버를 사용하면 돼:

// deps.ts에 추가
export { MongoClient } from "https://deno.land/x/mongo@v0.32.0/mod.ts";

// src/db/mongodb.ts
import { MongoClient } from "../../deps.ts";

const client = new MongoClient();

// MongoDB 연결
await client.connect("mongodb://localhost:27017");

// 또는 MongoDB Atlas 사용
// await client.connect("mongodb+srv://username:password@cluster.mongodb.net");

const db = client.database("blog_api");
export const postsCollection = db.collection("posts");

console.log("✅ MongoDB 연결 성공!");

컨트롤러를 MongoDB용으로 수정:

// src/controllers/postController.ts (MongoDB 버전)
import { RouterContext, Status } from "../../deps.ts";
import { postsCollection } from "../db/mongodb.ts";
import { ObjectId } from "https://deno.land/x/mongo@v0.32.0/mod.ts";

export const getAllPosts = async (context: RouterContext<"/posts">) => {
  const posts = await postsCollection.find({}).toArray();
  
  context.response.body = {
    success: true,
    data: posts,
    count: posts.length,
  };
};

export const getPostById = async (context: RouterContext<"/posts/:id">) => {
  const { id } = context.params;
  
  try {
    const post = await postsCollection.findOne({ _id: new ObjectId(id) });
    
    if (!post) {
      context.response.status = Status.NotFound;
      context.response.body = {
        success: false,
        message: "포스트를 찾을 수 없습니다",
      };
      return;
    }
    
    context.response.body = {
      success: true,
      data: post,
    };
  } catch (error) {
    context.response.status = Status.BadRequest;
    context.response.body = {
      success: false,
      message: "잘못된 ID 형식입니다",
    };
  }
};

export const createPost = async (context: RouterContext<"/posts">) => {
  try {
    const body = await context.request.body();
    const postData = await body.value;
    
    const insertId = await postsCollection.insertOne({
      ...postData,
      createdAt: new Date(),
      updatedAt: new Date(),
    });
    
    context.response.status = Status.Created;
    context.response.body = {
      success: true,
      data: { id: insertId, ...postData },
      message: "포스트가 생성되었습니다",
    };
  } catch (error) {
    context.response.status = Status.InternalServerError;
    context.response.body = {
      success: false,
      message: "서버 오류가 발생했습니다",
      error: error.message,
    };
  }
};

🐘 PostgreSQL 연결

PostgreSQL을 선호한다면 postgres 드라이버를 사용해:

// deps.ts에 추가
export { Client } from "https://deno.land/x/postgres@v0.17.0/mod.ts";

// src/db/postgres.ts
import { Client } from "../../deps.ts";

const client = new Client({
  user: "your_username",
  database: "blog_api",
  hostname: "localhost",
  port: 5432,
  password: "your_password",
});

await client.connect();

// 테이블 생성
await client.queryArray(`
  CREATE TABLE IF NOT EXISTS posts (
    id SERIAL PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    content TEXT NOT NULL,
    author VARCHAR(100) NOT NULL,
    tags TEXT[],
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
  )
`);

console.log("✅ PostgreSQL 연결 성공!");

export default client;

// 사용 예시
import client from "../db/postgres.ts";

export const getAllPosts = async (context: RouterContext<"/posts">) => {
  const result = await client.queryObject(
    "SELECT * FROM posts ORDER BY created_at DESC"
  );
  
  context.response.body = {
    success: true,
    data: result.rows,
    count: result.rows.length,
  };
};

🔥 Supabase 연결 (추천!)

서버리스 환경에서는 Supabase가 정말 좋은 선택이야. PostgreSQL 기반이면서 실시간 기능도 제공하거든! 🚀

// deps.ts에 추가
export { createClient } from "https://esm.sh/@supabase/supabase-js@2.38.4";

// src/db/supabase.ts
import { createClient } from "../../deps.ts";

const supabaseUrl = Deno.env.get("SUPABASE_URL")!;
const supabaseKey = Deno.env.get("SUPABASE_KEY")!;

export const supabase = createClient(supabaseUrl, supabaseKey);

console.log("✅ Supabase 연결 성공!");

// 사용 예시
import { supabase } from "../db/supabase.ts";

export const getAllPosts = async (context: RouterContext<"/posts">) => {
  const { data, error } = await supabase
    .from("posts")
    .select("*")
    .order("created_at", { ascending: false });
  
  if (error) {
    context.response.status = Status.InternalServerError;
    context.response.body = {
      success: false,
      message: error.message,
    };
    return;
  }
  
  context.response.body = {
    success: true,
    data,
    count: data.length,
  };
};

export const createPost = async (context: RouterContext<"/posts">) => {
  const body = await context.request.body();
  const postData = await body.value;
  
  const { data, error } = await supabase
    .from("posts")
    .insert([postData])
    .select();
  
  if (error) {
    context.response.status = Status.BadRequest;
    context.response.body = {
      success: false,
      message: error.message,
    };
    return;
  }
  
  context.response.status = Status.Created;
  context.response.body = {
    success: true,
    data: data[0],
    message: "포스트가 생성되었습니다",
  };
};

Supabase는 무료 티어도 넉넉하고, Deno Deploy와 완벽하게 호환돼. 서버리스 API 개발에 최적이야! 👍

🔐 인증과 보안

API를 만들었으면 당연히 보안도 신경 써야겠지? JWT 기반 인증을 구현해보자! 🔒

🎫 JWT 인증 구현

// deps.ts에 추가
export { create, verify, getNumericDate } from "https://deno.land/x/djwt@v3.0.1/mod.ts";
export type { Payload } from "https://deno.land/x/djwt@v3.0.1/mod.ts";

// src/middleware/auth.ts
import { Context, Middleware, Status } from "../../deps.ts";
import { create, verify, getNumericDate } from "../../deps.ts";
import type { Payload } from "../../deps.ts";

const JWT_SECRET = Deno.env.get("JWT_SECRET") || "your-secret-key";
const key = await crypto.subtle.importKey(
  "raw",
  new TextEncoder().encode(JWT_SECRET),
  { name: "HMAC", hash: "SHA-256" },
  true,
  ["sign", "verify"]
);

export interface UserPayload extends Payload {
  userId: string;
  email: string;
  role: string;
}

// JWT 토큰 생성
export async function generateToken(userId: string, email: string, role: string = "user"): Promise<string> {
  const payload: UserPayload = {
    userId,
    email,
    role,
    exp: getNumericDate(60 * 60 * 24), // 24시간
  };
  
  return await create({ alg: "HS256", typ: "JWT" }, payload, key);
}

// JWT 검증 미들웨어
export const authMiddleware: Middleware = async (context: Context, next) => {
  const authHeader = context.request.headers.get("Authorization");
  
  if (!authHeader || !authHeader.startsWith("Bearer ")) {
    context.response.status = Status.Unauthorized;
    context.response.body = {
      success: false,
      message: "인증 토큰이 필요합니다",
    };
    return;
  }
  
  const token = authHeader.substring(7);
  
  try {
    const payload = await verify(token, key) as UserPayload;
    context.state.user = payload;
    await next();
  } catch (error) {
    context.response.status = Status.Unauthorized;
    context.response.body = {
      success: false,
      message: "유효하지 않은 토큰입니다",
      error: error.message,
    };
  }
};

// 역할 기반 접근 제어
export function requireRole(...roles: string[]): Middleware {
  return async (context: Context, next) => {
    const user = context.state.user as UserPayload;
    
    if (!user || !roles.includes(user.role)) {
      context.response.status = Status.Forbidden;
      context.response.body = {
        success: false,
        message: "접근 권한이 없습니다",
      };
      return;
    }
    
    await next();
  };
}

👤 사용자 인증 컨트롤러

// src/controllers/authController.ts
import { RouterContext, Status } from "../../deps.ts";
import { generateToken } from "../middleware/auth.ts";
import { supabase } from "../db/supabase.ts";

export const register = async (context: RouterContext<"/auth/register">) => {
  try {
    const body = await context.request.body();
    const { email, password, name } = await body.value;
    
    // Supabase Auth 사용
    const { data, error } = await supabase.auth.signUp({
      email,
      password,
      options: {
        data: { name }
      }
    });
    
    if (error) {
      context.response.status = Status.BadRequest;
      context.response.body = {
        success: false,
        message: error.message,
      };
      return;
    }
    
    const token = await generateToken(data.user!.id, email, "user");
    
    context.response.status = Status.Created;
    context.response.body = {
      success: true,
      data: {
        user: data.user,
        token,
      },
      message: "회원가입이 완료되었습니다",
    };
  } catch (error) {
    context.response.status = Status.InternalServerError;
    context.response.body = {
      success: false,
      message: "서버 오류가 발생했습니다",
      error: error.message,
    };
  }
};

export const login = async (context: RouterContext<"/auth/login">) => {
  try {
    const body = await context.request.body();
    const { email, password } = await body.value;
    
    const { data, error } = await supabase.auth.signInWithPassword({
      email,
      password,
    });
    
    if (error) {
      context.response.status = Status.Unauthorized;
      context.response.body = {
        success: false,
        message: "이메일 또는 비밀번호가 올바르지 않습니다",
      };
      return;
    }
    
    const token = await generateToken(data.user.id, email, "user");
    
    context.response.body = {
      success: true,
      data: {
        user: data.user,
        token,
      },
      message: "로그인 성공",
    };
  } catch (error) {
    context.response.status = Status.InternalServerError;
    context.response.body = {
      success: false,
      message: "서버 오류가 발생했습니다",
      error: error.message,
    };
  }
};

export const getProfile = async (context: RouterContext<"/auth/profile">) => {
  const user = context.state.user;
  
  context.response.body = {
    success: true,
    data: user,
  };
};

🛣️ 인증 라우트 추가

// src/routes/authRoutes.ts
import { Router } from "../../deps.ts";
import { register, login, getProfile } from "../controllers/authController.ts";
import { authMiddleware } from "../middleware/auth.ts";

export const authRouter = new Router();

authRouter
  .post("/auth/register", register)
  .post("/auth/login", login)
  .get("/auth/profile", authMiddleware, getProfile);

이제 보호된 라우트에 인증 미들웨어를 적용할 수 있어:

// src/routes/postRoutes.ts 수정
import { authMiddleware, requireRole } from "../middleware/auth.ts";

postRouter
  .get("/posts", getAllPosts)  // 공개
  .get("/posts/:id", getPostById)  // 공개
  .post("/posts", authMiddleware, createPost)  // 인증 필요
  .put("/posts/:id", authMiddleware, updatePost)  // 인증 필요
  .delete("/posts/:id", authMiddleware, requireRole("admin"), deletePost);  // 관리자만

💡 보안 팁

1. 환경 변수 사용
JWT_SECRET 같은 민감한 정보는 절대 코드에 하드코딩하지 말고 환경 변수로 관리해.

2. HTTPS 사용
프로덕션 환경에서는 반드시 HTTPS를 사용해. Deno Deploy는 자동으로 HTTPS를 제공해.

3. Rate Limiting
무차별 대입 공격을 방지하기 위해 요청 제한을 구현해.

4. 입력 검증
모든 사용자 입력은 철저히 검증하고 sanitize해야 해.

5. CORS 설정
필요한 도메인만 허용하도록 CORS를 제한적으로 설정해.

📊 성능 최적화와 모니터링

API를 만들었으면 성능도 신경 써야겠지? 몇 가지 최적화 기법을 알아보자! ⚡

🚀 캐싱 구현

// src/middleware/cache.ts
import { Context, Middleware } from "../../deps.ts";

interface CacheEntry {
  data: any;
  timestamp: number;
  ttl: number;
}

class SimpleCache {
  private cache: Map<string, CacheEntry> = new Map();

  set(key: string, data: any, ttl: number = 60000): void {
    this.cache.set(key, {
      data,
      timestamp: Date.now(),
      ttl,
    });
  }

  get(key: string): any | null {
    const entry = this.cache.get(key);
    
    if (!entry) return null;
    
    if (Date.now() - entry.timestamp > entry.ttl) {
      this.cache.delete(key);
      return null;
    }
    
    return entry.data;
  }

  clear(): void {
    this.cache.clear();
  }

  delete(key: string): void {
    this.cache.delete(key);
  }
}

export const cache = new SimpleCache();

export function cacheMiddleware(ttl: number = 60000): Middleware {
  return async (context: Context, next) => {
    const key = `${context.request.method}:${context.request.url.pathname}`;
    
    // GET 요청만 캐싱
    if (context.request.method === "GET") {
      const cached = cache.get(key);
      
      if (cached) {
        context.response.headers.set("X-Cache", "HIT");
        context.response.body = cached;
        return;
      }
    }
    
    await next();
    
    // 응답을 캐시에 저장
    if (context.request.method === "GET" && context.response.status === 200) {
      cache.set(key, context.response.body, ttl);
      context.response.headers.set("X-Cache", "MISS");
    }
  };
}

사용 예시:

// 특정 라우트에 캐싱 적용
postRouter.get(
  "/posts",
  cacheMiddleware(300000),  // 5분 캐싱
  getAllPosts
);

📈 Rate Limiting 구현

// src/middleware/rateLimit.ts
import { Context, Middleware, Status } from "../../deps.ts";

interface RateLimitEntry {
  count: number;
  resetTime: number;
}

class RateLimiter {
  private limits: Map<string, RateLimitEntry> = new Map();

  check(ip: string, maxRequests: number, windowMs: number): boolean {
    const now = Date.now();
    const entry = this.limits.get(ip);

    if (!entry || now > entry.resetTime) {
      this.limits.set(ip, {
        count: 1,
        resetTime: now + windowMs,
      });
      return true;
    }

    if (entry.count >= maxRequests) {
      return false;
    }

    entry.count++;
    return true;
  }

  getRemainingRequests(ip: string, maxRequests: number): number {
    const entry = this.limits.get(ip);
    if (!entry) return maxRequests;
    return Math.max(0, maxRequests - entry.count);
  }

  getResetTime(ip: string): number {
    const entry = this.limits.get(ip);
    return entry ? entry.resetTime : Date.now();
  }
}

const limiter = new RateLimiter();

export function rateLimitMiddleware(
  maxRequests: number = 100,
  windowMs: number = 60000
): Middleware {
  return async (context: Context, next) => {
    const ip = context.request.ip;
    
    if (!limiter.check(ip, maxRequests, windowMs)) {
      const resetTime = limiter.getResetTime(ip);
      const retryAfter = Math.ceil((resetTime - Date.now()) / 1000);
      
      context.response.status = Status.TooManyRequests;
      context.response.headers.set("Retry-After", retryAfter.toString());
      context.response.headers.set("X-RateLimit-Limit", maxRequests.toString());
      context.response.headers.set("X-RateLimit-Remaining", "0");
      context.response.headers.set("X-RateLimit-Reset", resetTime.toString());
      
      context.response.body = {
        success: false,
        message: "요청 한도를 초과했습니다",
        retryAfter,
      };
      return;
    }

    const remaining = limiter.getRemainingRequests(ip, maxRequests);
    context.response.headers.set("X-RateLimit-Limit", maxRequests.toString());
    context.response.headers.set("X-RateLimit-Remaining", remaining.toString());
    
    await next();
  };
}

전역 또는 특정 라우트에 적용:

// 전역 적용
app.use(rateLimitMiddleware(100, 60000));  // 분당 100 요청

// 특정 라우트에만 적용
authRouter.post(
  "/auth/login",
  rateLimitMiddleware(5, 60000),  // 로그인은 분당 5회로 제한
  login
);

📊 성능 모니터링

// src/middleware/metrics.ts
import { Context, Middleware } from "../../deps.ts";

interface Metrics {
  totalRequests: number;
  successfulRequests: number;
  failedRequests: number;
  averageResponseTime: number;
  requestsByEndpoint: Map<string, number>;
  responseTimesByEndpoint: Map<string, number[]>;
}

class MetricsCollector {
  private metrics: Metrics = {
    totalRequests: 0,
    successfulRequests: 0,
    failedRequests: 0,
    averageResponseTime: 0,
    requestsByEndpoint: new Map(),
    responseTimesByEndpoint: new Map(),
  };

  recordRequest(
    endpoint: string,
    responseTime: number,
    success: boolean
  ): void {
    this.metrics.totalRequests++;
    
    if (success) {
      this.metrics.successfulRequests++;
    } else {
      this.metrics.failedRequests++;
    }

    // 엔드포인트별 요청 수
    const count = this.metrics.requestsByEndpoint.get(endpoint) || 0;
    this.metrics.requestsByEndpoint.set(endpoint, count + 1);

    // 엔드포인트별 응답 시간
    const times = this.metrics.responseTimesByEndpoint.get(endpoint) || [];
    times.push(responseTime);
    this.metrics.responseTimesByEndpoint.set(endpoint, times);

    // 전체 평균 응답 시간 계산
    this.calculateAverageResponseTime();
  }

  private calculateAverageResponseTime(): void {
    let totalTime = 0;
    let totalCount = 0;

    for (const times of this.metrics.responseTimesByEndpoint.values()) {
      totalTime += times.reduce((a, b) => a + b, 0);
      totalCount += times.length;
    }

    this.metrics.averageResponseTime = totalCount > 0
      ? totalTime / totalCount
      : 0;
  }

  getMetrics(): Metrics {
    return { ...this.metrics };
  }

  getEndpointStats(endpoint: string) {
    const times = this.metrics.responseTimesByEndpoint.get(endpoint) || [];
    const count = this.metrics.requestsByEndpoint.get(endpoint) || 0;
    
    if (times.length === 0) {
      return null;
    }

    const avg = times.reduce((a, b) => a + b, 0) / times.length;
    const min = Math.min(...times);
    const max = Math.max(...times);

    return {
      endpoint,
      count,
      averageResponseTime: avg,
      minResponseTime: min,
      maxResponseTime: max,
    };
  }
}

export const metricsCollector = new MetricsCollector();

export const metricsMiddleware: Middleware = async (context: Context, next) => {
  const start = Date.now();
  const endpoint = context.request.url.pathname;

  try {
    await next();
    const responseTime = Date.now() - start;
    const success = context.response.status < 400;
    
    metricsCollector.recordRequest(endpoint, responseTime, success);
  } catch (error) {
    const responseTime = Date.now() - start;
    metricsCollector.recordRequest(endpoint, responseTime, false);
    throw error;
  }
};

// 메트릭 조회 엔드포인트
export const getMetrics = (context: Context) => {
  const metrics = metricsCollector.getMetrics();
  
  const endpointStats = Array.from(metrics.requestsByEndpoint.keys())
    .map(endpoint => metricsCollector.getEndpointStats(endpoint))
    .filter(stat => stat !== null);

  context.response.body = {
    success: true,
    data: {
      summary: {
        totalRequests: metrics.totalRequests,
        successfulRequests: metrics.successfulRequests,
        failedRequests: metrics.failedRequests,
        successRate: metrics.totalRequests > 0
          ? (metrics.successfulRequests / metrics.totalRequests * 100).toFixed(2) + "%"
          : "0%",
        averageResponseTime: metrics.averageResponseTime.toFixed(2) + "ms",
      },
      endpoints: endpointStats,
    },
  };
};

메트릭 라우트 추가:

// src/routes/metricsRoutes.ts
import { Router } from "../../deps.ts";
import { getMetrics } from "../middleware/metrics.ts";
import { authMiddleware, requireRole } from "../middleware/auth.ts";

export const metricsRouter = new Router();

metricsRouter.get(
  "/metrics",
  authMiddleware,
  requireRole("admin"),
  getMetrics
);

🎯 성능 최적화 체크리스트

✅ 데이터베이스 쿼리 최적화 - 인덱스 활용, N+1 문제 해결
✅ 캐싱 전략 - 자주 조회되는 데이터는 캐싱
✅ 페이지네이션 - 대량 데이터는 페이지 단위로 조회
✅ 압축 - gzip 압축으로 전송 데이터 크기 줄이기
✅ 연결 풀링 - 데이터베이스 연결 재사용
✅ 비동기 처리 - 무거운 작업은 백그라운드에서 처리
✅ CDN 활용 - 정적 파일은 CDN으로 서빙
✅ 모니터링 - 성능 지표를 지속적으로 모니터링

🧪 테스트 작성하기

좋은 코드는 테스트가 필수야! Deno는 테스트 러너가 내장되어 있어서 별도 설치가 필요 없어. 😊

✅ 기본 테스트 작성

// tests/post_test.ts
import { assertEquals, assertExists } from "https://deno.land/std@0.208.0/assert/mod.ts";
import { PostStore } from "../src/models/Post.ts";

Deno.test("PostStore - 포스트 생성", () => {
  const store = new PostStore();
  
  const post = store.create({
    title: "테스트 포스트",
    content: "테스트 내용",
    author: "테스터",
    tags: ["test"],
  });

  assertExists(post.id);
  assertEquals(post.title, "테스트 포스트");
  assertEquals(post.author, "테스터");
  assertExists(post.createdAt);
});

Deno.test("PostStore - 포스트 조회", () => {
  const store = new PostStore();
  
  const created = store.create({
    title: "조회 테스트",
    content: "내용",
    author: "작성자",
    tags: [],
  });

  const found = store.findById(created.id);
  
  assertExists(found);
  assertEquals(found?.id, created.id);
  assertEquals(found?.title, "조회 테스트");
});

Deno.test("PostStore - 포스트 수정", () => {
  const store = new PostStore();
  
  const created = store.create({
    title: "원본 제목",
    content: "원본 내용",
    author: "작성자",
    tags: [],
  });

  const updated = store.update(created.id, {
    title: "수정된 제목",
  });

  assertExists(updated);
  assertEquals(updated?.title, "수정된 제목");
  assertEquals(updated?.content, "원본 내용");
});

Deno.test("PostStore - 포스트 삭제", () => {
  const store = new PostStore();
  
  const created = store.create({
    title: "삭제할 포스트",
    content: "내용",
    author: "작성자",
    tags: [],
  });

  const deleted = store.delete(created.id);
  assertEquals(deleted, true);

  const found = store.findById(created.id);
  assertEquals(found, undefined);
});

Deno.test("PostStore - 태그로 검색", () => {
  const store = new PostStore();
  
  store.create({
    title: "Deno 포스트",
    content: "내용",
    author: "작성자",
    tags: ["deno", "typescript"],
  });

  store.create({
    title: "Oak 포스트",
    content: "내용",
    author: "작성자",
    tags: ["oak", "framework"],
  });

  const denoPosts = store.findByTag("deno");
  assertEquals(denoPosts.length, 1);
  assertEquals(denoPosts[0].title, "Deno 포스트");
});

테스트 실행:

deno test

특정 파일만 테스트:

deno test tests/post_test.ts

커버리지 확인:

deno test --coverage=coverage
deno coverage coverage

🌐 API 통합 테스트

// tests/api_test.ts
import { assertEquals } from "https://deno.land/std@0.208.0/assert/mod.ts";
import { superoak } from "https://deno.land/x/superoak@4.7.0/mod.ts";
import app from "../src/app.ts";

Deno.test("GET /posts - 모든 포스트 조회", async () => {
  const request = await superoak(app);
  
  await request
    .get("/posts")
    .expect(200)
    .expect("Content-Type", /json/)
    .expect((res) => {
      assertEquals(res.body.success, true);
      assertExists(res.body.data);
      assertExists(res.body.count);
    });
});

Deno.test("POST /posts - 새 포스트 생성", async () => {
  const request = await superoak(app);
  
  const newPost = {
    title: "API 테스트 포스트",
    content: "테스트 내용입니다",
    author: "테스터",
    tags: ["test", "api"],
  };

  await request
    .post("/posts")
    .send(newPost)
    .expect(201)
    .expect("Content-Type", /json/)
    .expect((res) => {
      assertEquals(res.body.success, true);
      assertEquals(res.body.data.title, newPost.title);
      assertExists(res.body.data.id);
    });
});

Deno.test("GET /posts/:id - 특정 포스트 조회", async () => {
  const request = await superoak(app);
  
  // 먼저 포스트 생성
  const createRes = await request
    .post("/posts")
    .send({
      title: "조회 테스트",
      content: "내용",
      author: "작성자",
      tags: [],
    });

  const postId = createRes.body.data.id;

  // 생성된 포스트 조회
  await request
    .get(`/posts/${postId}`)
    .expect(200)
    .expect((res) => {
      assertEquals(res.body.success, true);
      assertEquals(res.body.data.id, postId);
    });
});

Deno.test("GET /posts/invalid-id - 존재하지 않는 포스트", async () => {
  const request = await superoak(app);
  
  await request
    .get("/posts/invalid-id-12345")
    .expect(404)
    .expect((res) => {
      assertEquals(res.body.success, false);
    });
});

💡 테스트 작성 팁

1. 테스트는 독립적으로
각 테스트는 다른 테스트에 의존하지 않아야 해. 순서에 상관없이 실행될 수 있어야 해.

2. AAA 패턴 사용
Arrange(준비), Act(실행), Assert(검증) 패턴으로 테스트를 구조화해.

3. 의미 있는 테스트 이름
테스트 이름만 봐도 무엇을 테스트하는지 알 수 있어야 해.

4. 엣지 케이스 테스트
정상 케이스뿐만 아니라 에러 케이스도 꼭 테스트해.

5. 모킹 활용
외부 의존성은 모킹해서 테스트를 빠르고 안정적으로 만들어.

📚 실전 프로젝트 예제

지금까지 배운 내용을 종합해서 실전 프로젝트를 만들어보자! 간단한 TODO API를 만들어볼게. 📝

🎯 프로젝트 요구사항

기능 요구사항:
• 사용자 회원가입/로그인
• TODO 생성/조회/수정/삭제
• TODO 완료 상태 토글
• 사용자별 TODO 목록 조회
• 우선순위별 정렬
• 검색 기능

기술 스택:
• Deno + Oak
• Supabase (PostgreSQL)
• JWT 인증
• TypeScript

📋 데이터 모델

// src/models/Todo.ts
export interface Todo {
  id: string;
  user_id: string;
  title: string;
  description: string;
  completed: boolean;
  priority: "low" | "medium" | "high";
  due_date: Date | null;
  created_at: Date;
  updated_at: Date;
}

export interface CreateTodoDto {
  title: string;
  description?: string;
  priority?: "low" | "medium" | "high";
  due_date?: string;
}

export interface UpdateTodoDto {
  title?: string;
  description?: string;
  completed?: boolean;
  priority?: "low" | "medium" | "high";
  due_date?: string;
}

🎮 TODO 컨트롤러

// src/controllers/todoController.ts
import { RouterContext, Status } from "../../deps.ts";
import { supabase } from "../db/supabase.ts";
import type { CreateTodoDto, UpdateTodoDto } from "../models/Todo.ts";

export const getTodos = async (context: RouterContext<"/todos">) => {
  const userId = context.state.user.userId;
  const url = context.request.url;
  
  // 쿼리 파라미터 파싱
  const completed = url.searchParams.get("completed");
  const priority = url.searchParams.get("priority");
  const search = url.searchParams.get("search");
  const sortBy = url.searchParams.get("sortBy") || "created_at";
  const order = url.searchParams.get("order") || "desc";

  let query = supabase
    .from("todos")
    .select("*")
    .eq("user_id", userId);

  // 필터 적용
  if (completed !== null) {
    query = query.eq("completed", completed === "true");
  }

  if (priority) {
    query = query.eq("priority", priority);
  }

  if (search) {
    query = query.or(`title.ilike.%${search}%,description.ilike.%${search}%`);
  }

  // 정렬
  query = query.order(sortBy, { ascending: order === "asc" });

  const { data, error } = await query;

  if (error) {
    context.response.status = Status.InternalServerError;
    context.response.body = {
      success: false,
      message: error.message,
    };
    return;
  }

  context.response.body = {
    success: true,
    data,
    count: data.length,
  };
};

export const getTodoById = async (context: RouterContext<"/todos/:id">) => {
  const userId = context.state.user.userId;
  const { id } = context.params;

  const { data, error } = await supabase
    .from("todos")
    .select("*")
    .eq("id", id)
    .eq("user_id", userId)
    .single();

  if (error || !data) {
    context.response.status = Status.NotFound;
    context.response.body = {
      success: false,
      message: "TODO를 찾을 수 없습니다",
    };
    return;
  }

  context.response.body = {
    success: true,
    data,
  };
};

export const createTodo = async (context: RouterContext<"/todos">) => {
  const userId = context.state.user.userId;
  
  try {
    const body = await context.request.body();
    const todoData: CreateTodoDto = await body.value;

    // 유효성 검사
    if (!todoData.title || todoData.title.trim() === "") {
      context.response.status = Status.BadRequest;
      context.response.body = {
        success: false,
        message: "제목은 필수 항목입니다",
      };
      return;
    }

    const { data, error } = await supabase
      .from("todos")
      .insert([
        {
          user_id: userId,
          title: todoData.title,
          description: todoData.description || "",
          priority: todoData.priority || "medium",
          due_date: todoData.due_date || null,
          completed: false,
        },
      ])
      .select()
      .single();

    if (error) {
      context.response.status = Status.InternalServerError;
      context.response.body = {
        success: false,
        message: error.message,
      };
      return;
    }

    context.response.status = Status.Created;
    context.response.body = {
      success: true,
      data,
      message: "TODO가 생성되었습니다",
    };
  } catch (error) {
    context.response.status = Status.InternalServerError;
    context.response.body = {
      success: false,
      message: "서버 오류가 발생했습니다",
      error: error.message,
    };
  }
};

export const updateTodo = async (context: RouterContext<"/todos/:id">) => {
  const userId = context.state.user.userId;
  const { id } = context.params;

  try {
    const body = await context.request.body();
    const updates: UpdateTodoDto = await body.value;

    const { data, error } = await supabase
      .from("todos")
      .update({
        ...updates,
        updated_at: new Date().toISOString(),
      })
      .eq("id", id)
      .eq("user_id", userId)
      .select()
      .single();

    if (error || !data) {
      context.response.status = Status.NotFound;
      context.response.body = {
        success: false,
        message: "TODO를 찾을 수 없습니다",
      };
      return;
    }

    context.response.body = {
      success: true,
      data,
      message: "TODO가 수정되었습니다",
    };
  } catch (error) {
    context.response.status = Status.InternalServerError;
    context.response.body = {
      success: false,
      message: "서버 오류가 발생했습니다",
      error: error.message,
    };
  }
};

export const deleteTodo = async (context: RouterContext<"/todos/:id">) => {
  const userId = context.state.user.userId;
  const { id } = context.params;

  const { error } = await supabase
    .from("todos")
    .delete()
    .eq("id", id)
    .eq("user_id", userId);

  if (error) {
    context.response.status = Status.NotFound;
    context.response.body = {
      success: false,
      message: "TODO를 찾을 수 없습니다",
    };
    return;
  }

  context.response.status = Status.NoContent;
};

export const toggleTodo = async (context: RouterContext<"/todos/:id/toggle">) => {
  const userId = context.state.user.userId;
  const { id } = context.params;

  // 현재 상태 조회
  const { data: currentTodo, error: fetchError } = await supabase
    .from("todos")
    .select("completed")
    .eq("id", id)
    .eq("user_id", userId)
    .single();

  if (fetchError || !currentTodo) {
    context.response.status = Status.NotFound;
    context.response.body = {
      success: false,
      message: "TODO를 찾을 수 없습니다",
    };
    return;
  }

  // 상태 토글
  const { data, error } = await supabase
    .from("todos")
    .update({
      completed: !currentTodo.completed,
      updated_at: new Date().toISOString(),
    })
    .eq("id", id)
    .eq("user_id", userId)
    .select()
    .single();

  if (error) {
    context.response.status = Status.InternalServerError;
    context.response.body = {
      success: false,
      message: error.message,
    };
    return;
  }

  context.response.body = {
    success: true,
    data,
    message: `TODO가 ${data.completed ? "완료" : "미완료"} 상태로 변경되었습니다`,
  };
};

export const getStats = async (context: RouterContext<"/todos/stats">) => {
  const userId = context.state.user.userId;

  const { data: todos, error } = await supabase
    .from("todos")
    .select("*")
    .eq("user_id", userId);

  if (error) {
    context.response.status = Status.InternalServerError;
    context.response.body = {
      success: false,
      message: error.message,
    };
    return;
  }

  const total = todos.length;
  const completed = todos.filter(t => t.completed).length;
  const pending = total - completed;
  const byPriority = {
    high: todos.filter(t => t.priority === "high").length,
    medium: todos.filter(t => t.priority === "medium").length,
    low: todos.filter(t => t.priority === "low").length,
  };

  context.response.body = {
    success: true,
    data: {
      total,
      completed,
      pending,
      completionRate: total > 0 ? ((completed / total) * 100).toFixed(2) + "%" : "0%",
      byPriority,
    },
  };
};

🛣️ TODO 라우트

// src/routes/todoRoutes.ts
import { Router } from "../../deps.ts";
import {
  getTodos,
  getTodoById,
  createTodo,
  updateTodo,
  deleteTodo,
  toggleTodo,
  getStats,
} from "../controllers/todoController.ts";
import { authMiddleware } from "../middleware/auth.ts";

export const todoRouter = new Router();

// 모든 라우트에 인증 필요
todoRouter
  .get("/todos/stats", authMiddleware, getStats)
  .get("/todos", authMiddleware, getTodos)
  .get("/todos/:id", authMiddleware, getTodoById)
  .post("/todos", authMiddleware, createTodo)
  .put("/todos/:id", authMiddleware, updateTodo)
  .patch("/todos/:id/toggle", authMiddleware, toggleTodo)
  .delete("/todos/:id", authMiddleware, deleteTodo);

🚀 완성된 애플리케이션

// src/app.ts
import { Application } from "../deps.ts";
import { authRouter } from "./routes/authRoutes.ts";
import { todoRouter } from "./routes/todoRoutes.ts";
import { metricsRouter } from "./routes/metricsRoutes.ts";
import {
  logger,
  errorHandler,
  corsMiddleware,
} from "./middleware/logger.ts";
import { metricsMiddleware } from "./middleware/metrics.ts";
import { rateLimitMiddleware } from "./middleware/rateLimit.ts";

const app = new Application();

// 전역 미들웨어
app.use(errorHandler);
app.use(logger);
app.use(corsMiddleware);
app.use(metricsMiddleware);
app.use(rateLimitMiddleware(100, 60000));

// 라우터 등록
app.use(authRouter.routes());
app.use(authRouter.allowedMethods());
app.use(todoRouter.routes());
app.use(todoRouter.allowedMethods());
app.use(metricsRouter.routes());
app.use(metricsRouter.allowedMethods());

// 헬스 체크
app.use((context) => {
  if (context.request.url.pathname === "/health") {
    context.response.body = {
      status: "healthy",
      timestamp: new Date().toISOString(),
    };
    return;
  }

  // 404
  context.response.status = 404;
  context.response.body = {
    success: false,
    message: "요청하신 리소스를 찾을 수 없습니다",
    path: context.request.url.pathname,
  };
});

export default app;

🎓 학습 리소스와 커뮤니티

Deno를 더 깊이 공부하고 싶다면? 유용한 리소스들을 소개할게! 📚

📖 공식 문서 및 가이드

Deno 공식 문서
deno.land/manual - 가장 정확하고 최신 정보

Oak 문서
oakserver.github.io/oak - Oak 프레임워크 공식 문서

Deno by Example
examples.deno.land - 실용적인 예제 모음

Deno Deploy 문서
deno.com/deploy/docs - 배포 관련 상세 가이드

💬 커뮤니티

Discord
Deno 공식 Discord 서버 - 실시간으로 질문하고 답변받을 수 있어

GitHub
github.com/denoland/deno - 이슈 트래킹, 기여하기

Reddit
r/Deno - 다양한 토론과 정보 공유

Stack Overflow
#deno 태그 - 기술적인 질문과 답변

🎥 추천 학습 자료

YouTube 채널
• Traversy Media - Deno 크래시 코스
• Fireship - Deno in 100 Seconds
• The Net Ninja - Deno 튜토리얼 시리즈

온라인 강의
• Udemy - Deno: The Complete Guide
• Pluralsight - Getting Started with Deno
• Frontend Masters - Deno Fundamentals

블로그 및 아티클
• Dev.to #deno 태그
• Medium - Deno 관련 글들
• Hashnode - Deno 커뮤니티

🚀 다음 단계: 더 나아가기

기본을 마스터했다면 이제 더 고급 주제로 나아갈 시간이야! 🎯

🔥 고급 주제들

1. WebSocket 실시간 통신
채팅 앱이나 실시간 알림 시스템을 만들어봐. Oak는 WebSocket을 잘 지원해!

2. GraphQL API
REST 대신 GraphQL을 사용해보는 것도 좋아. gql 라이브러리를 활용해봐.

3. 마이크로서비스 아키텍처
여러 Deno 서비스를 조합해서 마이크로서비스를 구축해봐.

4. 서버사이드 렌더링 (SSR)
Fresh 프레임워크로 SSR을 경험해봐. Deno의 또 다른 강력한 기능이야!

5. CLI 도구 개발
Deno로 커맨드라인 도구를 만들어봐. 컴파일해서 실행 파일로 배포할 수도 있어!

6. 데이터 파이프라인
ETL 작업이나 데이터 처리 파이프라인을 Deno로 구축해봐.

7. 크론 작업 스케줄링
정기적인 작업을 자동화하는 스케줄러를 만들어봐.

🎯 프로젝트 아이디어

실력을 키우는 가장 좋은 방법은 직접 만들어보는 거야! 여기 몇 가지 프로젝트 아이디어를 제안할게:

초급
• URL 단축 서비스
• 간단한 블로그 API
• 날씨 정보 API
• 할 일 관리 앱

중급
• 소셜 미디어 API
• 전자상거래 백엔드
• 파일 업로드 서비스
• 실시간 채팅 앱

고급
• 비디오 스트리밍 플랫폼
• 협업 도구 (Notion 클론)
• 게임 서버
• IoT 데이터 수집 플랫폼

💡 실무 팁과 베스트 프랙티스

실제 프로젝트에서 유용한 팁들을 공유할게! 이건 경험에서 우러나온 조언들이야. 😊

⚠️ 흔한 실수들

1. 권한 플래그 남용
--allow-all은 편하지만 보안상 위험해. 필요한 권한만 명시적으로 부여해.

2. 에러 처리 소홀
try-catch를 빼먹지 말고, 의미 있는 에러 메시지를 반환해.

3. 타입 무시
TypeScript를 쓰면서 any를 남발하면 의미가 없어. 제대로 된 타입을 정의해.

4. 환경 변수 하드코딩
API 키나 비밀번호를 코드에 직접 넣지 마. 환경 변수를 사용해.

5. 테스트 생략
"나중에 테스트 작성하지 뭐"는 절대 오지 않아. 처음부터 테스트를 작성해.

✅ 베스트 프랙티스

1. 프로젝트 구조
일관된 폴더 구조를 유지해. controllers, models, routes, middleware 등으로 명확히 분리.

2. 의존성 관리
deps.ts 파일에 모든 외부 의존성을 모아두고, 버전을 명시해.

3. 환경 설정
.env 파일을 사용하고, .env.example을 제공해서 필요한 환경 변수를 문서화해.

4. 로깅
적절한 로그 레벨(debug, info, warn, error)을 사용해서 디버깅을 쉽게 만들어.

5. API 문서화
Swagger나 OpenAPI를 사용해서 API를 문서화해. 팀 협업에 필수야!

6. 버전 관리
API 버전을 URL에 포함시켜 (/api/v1/...) 하위 호환성을 유지해.

7. 성능 모니터링
응답 시간, 에러율 등을 지속적으로 모니터링해.

8. 보안
HTTPS 사용, CORS 설정, Rate Limiting, 입력 검증을 철저히 해.

📝 코드 스타일 가이드

// 좋은 예시 ✅
export interface User {
  id: string;
  email: string;
  name: string;
  createdAt: Date;
}

export async function createUser(
  email: string,
  password: string,
  name: string
): Promise<User | null> {
  try {
    // 유효성 검사
    if (!isValidEmail(email)) {
      throw new Error("Invalid email format");
    }

    // 비즈니스 로직
    const hashedPassword = await hashPassword(password);
    const user = await db.users.create({
      email,
      password: hashedPassword,
      name,
    });

    return user;
  } catch (error) {
    console.error("Failed to create user:", error);
    return null;
  }
}

// 나쁜 예시 ❌
export async function createUser(e: any, p: any, n: any): Promise<any> {
  const u = await db.users.create({ email: e, password: p, name: n });
  return u;
}

코드 스타일 포인트:
• 명확한 변수명 사용
• 타입을 명시적으로 정의
• 에러 처리 포함
• 주석으로 의도 설명
• 일관된 네이밍 컨벤션 (camelCase, PascalCase)

🎬 마무리하며

와! 여기까지 읽었다면 정말 대단해! 👏 우리는 Deno의 기초부터 Oak 프레임워크를 활용한 실전 API 개발, 그리고 서버리스 배포까지 모든 과정을 함께 살펴봤어.

Deno는 정말 매력적인 런타임이야. Node.js의 문제점들을 해결하면서도, 현대적인 개발 경험을 제공하지. TypeScript 네이티브 지원, 보안 우선 설계, 내장 도구들... 이 모든 게 개발자의 삶을 더 편하게 만들어줘. 🚀

Oak 프레임워크는 Deno 생태계에서 가장 성숙한 웹 프레임워크야. Express의 편리함과 Koa의 우아함을 모두 가지고 있어서, RESTful API를 만들기에 정말 좋아. 특히 서버리스 환경과의 궁합이 완벽하다는 게 큰 장점이지!

🎯 핵심 요약

Deno의 장점
✅ 보안 우선 설계
✅ TypeScript 네이티브 지원
✅ 표준 웹 API 사용
✅ 내장 도구들 (포매터, 린터, 테스트 러너)
✅ URL 기반 모듈 시스템

Oak의 장점
✅ 직관적인 API
✅ 강력한 미들웨어 시스템
✅ TypeScript 친화적
✅ 활발한 커뮤니티
✅ 서버리스 배포 최적화

서버리스의 장점
✅ 서버 관리 불필요
✅ 자동 스케일링
✅ 사용한 만큼만 과금
✅ 전역 CDN 활용
✅ 빠른 배포

이제 당신도 Deno와 Oak로 멋진 API를 만들 수 있어! 처음에는 낯설 수 있지만, 조금만 익숙해지면 Node.js보다 훨씬 편하다는 걸 느낄 거야. 😊

혹시 Deno나 Oak 관련해서 더 배우고 싶거나, 프로젝트에 도움이 필요하다면 재능넷에서 전문가들의 도움을 받을 수도 있어. 실전 경험이 풍부한 개발자들이 많이 활동하고 있거든!

마지막으로 한 가지 조언을 하자면, 이론만 공부하지 말고 직접 만들어봐! 작은 프로젝트라도 좋으니까 처음부터 끝까지 완성해보는 경험이 정말 중요해. 그 과정에서 만나는 에러들, 해결하는 과정들이 모두 당신의 실력이 되는 거야. 💪

🚀 다음 스텝 제안

1주차 - Deno 기초 다지기, 간단한 CLI 도구 만들기
2주차 - Oak로 기본 CRUD API 구현
3주차 - 데이터베이스 연결, 인증 구현
4주차 - 테스트 작성, 배포
5주차 이후 - 실전 프로젝트 진행, 포트폴리오 구축

이렇게 단계적으로 접근하면 한 달 안에 실전 투입 가능한 수준이 될 수 있어!

자, 이제 당신의 차례야! 🎉 오늘 배운 내용을 바탕으로 멋진 API를 만들어봐. 그리고 만든 프로젝트를 GitHub에 올리고, 커뮤니티와 공유해봐. 다른 개발자들의 피드백을 받으면서 성장하는 거야!

Deno와 Oak의 세계는 아직 탐험할 게 많아. 이 글이 그 여정의 좋은 출발점이 되었으면 좋겠어. 화이팅! 💪🦕

이 글이 도움이 되었나요? Deno와 Oak로 멋진 프로젝트를 만들어보세요! 🎉
질문이나 피드백은 언제든 환영입니다! 💬

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.

4.5K

JAVA(자바) /JSP/SPRING(스프링)/ SPRING BOOT/NextJS/React/PHP/전자정부

💻 전문 웹 개발 & 시스템 구축 서비스 2009년부터 개발을 시작하여 현재까지 다양한 언어와 기술을 활용해 왔습니다. 특히 2012년부터는 자바(JAVA)를 중심으로 JSP, 서블릿, 스프링(Spring), 스프링부트(Spring Boot), 전자정부프레임워크(eGovFrame) 등을 활용한 개발을 주로 진행하고 있습니다. 다양한 중개 거래 플랫폼에서 활

10,000원~

3.5K

[홈페이지 제작/수정] 반응형 · 모바일 · 크로스브라우징 홈페이지 문의주세요!

에이전시에 근무하여 여러 홈페이지를 제작한 경력으로 홈페이지 제작,수정을 도와드립니다. 어려워하지 마시고 문의 주세요. 제작준비부터 관리까지 도와드리겠습니다. - 쇼핑몰, 기업, 학회 등 신규 홈페이지 제작 - 기존 홈페이지 부분 수정및 페이지 수정, 홈페이지 관리 가능 - 반응형 웹, 모바일 웹 제작가능 - 그누보드, 제로보드 등 오픈소스 사용가능 - 단

10,000원~

재능인 5급 인증

9.2K

홈페이지 정가제 실시 15페이지 미만 홈페이지 25만원에 제작합니다.

250,000원~

웹사이트/홈페이지/seo최적화/그누보드/xe/wordpress/php/파싱/유지보수 해 드립니다

재능인 5급 인증

6.9K

웹사이트/홈페이지/seo최적화/그누보드/xe/wordpress/php/파싱/유지보수 해 드립니다

기본 작업은 사이트의 기능수정입니다.호스팅에 보드 설치 및 셋팅. (그누, 제로, 워드, 기타 cafe24,고도몰 등) 그리고 각 보드의 대표적인 테마나 빌더등도 가능합니다. 사이트에 생기는 오류확인 /수정 검색SEO 최적화 작업도 하구요 정규식,크롤링,파싱, 페이지 스킨 수정 이미지 교체, 메뉴 네비게이션 수정 소스 오류 수정 등 전반적으로 일어나는 의문

5,000원~

9.5K

홈페이지부터 앱·서버까지 이어서 만들어 드립니다, 반응형 소개 홈페이지 제작

홈페이지부터 앱, 서버까지 이어서 맡아 드립니다. 병원, 미용실, 식당 같은 소개 홈페이지를 만들었고, 같은 사람이 필요한 만큼 이어서 맡습니다. 홈페이지에서 시작해 앱, 서버까지 이어서 맡을 수 있습니다. 이런 일을 합니다 - 소개 홈페이지: 병원, 미용실, 식당처럼 우리 가게를 소개하는 홈페이지를 만듭니다. - 반응형 화면: PC, 태블릿, 휴대폰 화면

500,000원~

6.4K

[빠른 개발]쇼핑몰, 홈페이지, 어플등 저렴하게 제작해 드립니다.

안녕하세요. 경력 13년차 프리랜서입니다. 팀으로 프로젝트 작업하여 빠르고 퀄리티 있게 작업해드리겠습니다. 관계자 분이 ok 하실 때까지 제작 해드리겠습니다. 각 페이지별로 고도화하여 사용자들이 이용하는데 불편함 없이 만들어 드리며, 의뢰자와 함께 소통하여 더 나은 방향으로 만들어 드리고있습니다. - 팀 경력 - - 프로그램 개발 15년 풀스택 개발자,

50,000원~

웹개발 전문가가 최상의 결과물을 보여드립니다.

안녕하세요. 25년 웹개발 경력의 개발자입니다. 웹사이트 개발, 유지보수를 도와드립니다. ERP, 게임포털, 검색포털등에서 오랫동안 개발하고 서비스를 운영해 온 경험으로 최적의 결과물을 제공해드립니다. 웹사이트과 운영과 관련된 모든 부분(하드웨어 인프라, 클라우드 적용, 설계 및 구축)에 대해서 도움을 드릴 수 있습니다. 1. 작업이 가능한 내용 A.

5,000원~

홈페이지 제작 / 기존 페이지 수정 / PSD을 HTML로 퍼블리싱 가능! * 웹표준, 크로스브로우징, 웹접근성

재능인 5급 인증

10.6K

홈페이지 제작 / 기존 페이지 수정 / PSD을 HTML로 퍼블리싱 가능! * 웹표준, 크로스브로우징, 웹접근성

안녕하세요. 개발자 GP 입니다. 모든 사이트 개발은 웹사이트 제작시 웹표준을 준수하여 진행합니다. 웹표준이란 국제표준화 단체인 W3C(World Wide Web Consortium)에서 지정한 표준안입니다. 퍼블리싱인 경우 디자인을 분석하여 가능한 컴퍼넌트화 하여 개발하여 유지보수가 쉽고 시멘틱 마크업을 진행함으로 디자이너와 백엔드 개발자가 모두 의미를

30,000원~

프로그램개발 · 분야 선택22개 분야

🚀 Deno와 Oak 프레임워크로 시작하는 서버리스 API 개발 완벽 가이드

🤔 Deno가 뭐길래 이렇게 난리야?

🎯 Deno의 핵심 특징

🌳 Oak 프레임워크는 또 뭐야?

💡 Oak를 선택해야 하는 이유

🚀 Deno 설치부터 시작해보자!

📥 설치 방법 (운영체제별)

⚠️ 환경 변수 설정 주의사항

🎨 첫 번째 Deno 프로그램 만들기

👶 Hello World 예제

🌐 웹 서버 만들어보기

🌲 Oak 프레임워크로 본격 API 개발

🎬 기본 Oak 서버 구축

🔍 코드 분석하기

🎯 실전 RESTful API 구축하기

📁 프로젝트 구조 설계

📦 deps.ts - 의존성 관리

📄 모델 정의 - Post.ts

🎮 컨트롤러 작성 - postController.ts

🛣️ 라우트 설정 - postRoutes.ts

🔧 미들웨어 작성 - logger.ts

🚀 메인 애플리케이션 - app.ts

🎬 진입점 - mod.ts

🧪 API 테스트하기

📝 포스트 생성 (POST)

📖 모든 포스트 조회 (GET)

🔍 특정 포스트 조회 (GET)

✏️ 포스트 수정 (PUT)

🗑️ 포스트 삭제 (DELETE)

🏷️ 태그로 검색 (GET)

☁️ 서버리스 배포하기

🌟 Deno Deploy - 공식 서버리스 플랫폼

🚀 Deno Deploy 배포 과정

⚙️ 배포용 코드 수정

⚠️ 배포 시 주의사항

🗄️ 데이터베이스 연결하기

🍃 MongoDB 연결

🐘 PostgreSQL 연결

🔥 Supabase 연결 (추천!)

🔐 인증과 보안

🎫 JWT 인증 구현

👤 사용자 인증 컨트롤러

🛣️ 인증 라우트 추가

💡 보안 팁

📊 성능 최적화와 모니터링

🚀 캐싱 구현

📈 Rate Limiting 구현

📊 성능 모니터링

🎯 성능 최적화 체크리스트

🧪 테스트 작성하기

✅ 기본 테스트 작성

🌐 API 통합 테스트

💡 테스트 작성 팁

📚 실전 프로젝트 예제

🎯 프로젝트 요구사항

📋 데이터 모델

🎮 TODO 컨트롤러

🛣️ TODO 라우트

🚀 완성된 애플리케이션

🎓 학습 리소스와 커뮤니티

📖 공식 문서 및 가이드

💬 커뮤니티

🎥 추천 학습 자료

🚀 다음 단계: 더 나아가기

🔥 고급 주제들

🎯 프로젝트 아이디어

💡 실무 팁과 베스트 프랙티스

⚠️ 흔한 실수들

✅ 베스트 프랙티스

📝 코드 스타일 가이드

🎬 마무리하며

🎯 핵심 요약

🚀 다음 스텝 제안

관련 키워드

댓글 작성

로그인이 필요합니다

댓글 0

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지