5.14 AI 활용 DevOps & CI/CD

CI/CD 파이프라인 전체 흐름

GitHub Actions 기초

GitHub Actions는 GitHub 저장소에서 자동화 워크플로우를 실행하는 CI/CD 플랫폼입니다. YAML 파일로 정의하며, push/PR 이벤트에 반응합니다.

Node.js 프로젝트에 GitHub Actions CI/CD를 구성해줘.

요구사항:
1. main 브랜치 push 시 자동 실행
2. PR 생성 시 테스트만 실행
3. Node.js 20 버전, npm ci 사용
4. ESLint + Jest 테스트 실행
5. 테스트 통과 시 Docker 이미지 빌드 → GitHub Container Registry 푸시
6. 프로덕션은 수동 승인 후 배포

.github/workflows/ 디렉토리에 파일 생성해줘.

실전 GitHub Actions 워크플로우 (Node.js)

# .github/workflows/ci-cd.yml
name: CI/CD Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'npm'
      - run: npm ci
      - run: npm run lint
      - run: npm test -- --coverage
      - uses: actions/upload-artifact@v4
        with:
          name: coverage
          path: coverage/

  build:
    needs: test
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - uses: docker/build-push-action@v5
        with:
          push: true
          tags: ghcr.io/${{ github.repository }}:latest

Docker 기초 — AI로 Dockerfile 생성

이 Node.js Express 프로젝트에 Docker 설정을 만들어줘.
- 멀티스테이지 빌드로 이미지 최소화
- 보안: non-root 사용자 실행
- 헬스체크 포함
- docker-compose로 앱 + PostgreSQL + Redis 구성
- .dockerignore도 생성

# Dockerfile (멀티스테이지 빌드)
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:20-alpine
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY . .
USER appuser
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=3s \
  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
CMD ["node", "server.js"]

# docker-compose.yml
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
      - REDIS_URL=redis://cache:6379
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_started

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: myapp
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user"]
      interval: 5s
      retries: 5

  cache:
    image: redis:7-alpine

volumes:
  pgdata:

배포 전략 비교

5.15 AI 활용 테스팅 전략

테스트 종류별 비교

AI 기반 TDD 워크플로우

src/services/userService.js 파일의 모든 public 함수에 대해
Jest 단위 테스트를 작성해줘.

요구사항:
1. 정상 케이스 + 에러 케이스 모두 포함
2. 외부 의존성(DB, API)은 mock 처리
3. 경계값(빈 문자열, null, 0, 음수) 테스트 포함
4. describe/it 구조로 가독성 있게 작성
5. 각 테스트에 한국어 설명 주석 추가

Jest 단위 테스트 예시 (Node.js)

// __tests__/userService.test.js
const { createUser, findUserById } = require('../src/services/userService');
const userRepository = require('../src/repositories/userRepository');

// DB 의존성 mock
jest.mock('../src/repositories/userRepository');

describe('UserService', () => {
  afterEach(() => jest.clearAllMocks());

  describe('createUser', () => {
    it('정상적인 사용자를 생성한다', async () => {
      const input = { name: '홍길동', email: 'hong@test.com' };
      userRepository.save.mockResolvedValue({ id: 1, ...input });

      const result = await createUser(input);

      expect(result.id).toBe(1);
      expect(result.name).toBe('홍길동');
      expect(userRepository.save).toHaveBeenCalledWith(input);
    });

    it('이메일이 없으면 ValidationError를 던진다', async () => {
      await expect(createUser({ name: '홍길동' }))
        .rejects.toThrow('이메일은 필수입니다');
    });

    it('중복 이메일이면 DuplicateError를 던진다', async () => {
      userRepository.save.mockRejectedValue(
        new Error('UNIQUE_VIOLATION')
      );
      await expect(createUser({ name: '홍길동', email: 'dup@test.com' }))
        .rejects.toThrow('이미 등록된 이메일입니다');
    });
  });

  describe('findUserById', () => {
    it('존재하는 사용자를 반환한다', async () => {
      userRepository.findById.mockResolvedValue({ id: 1, name: '홍길동' });
      const user = await findUserById(1);
      expect(user.name).toBe('홍길동');
    });

    it('존재하지 않으면 null을 반환한다', async () => {
      userRepository.findById.mockResolvedValue(null);
      const user = await findUserById(999);
      expect(user).toBeNull();
    });
  });
});

Spring Boot JUnit 5 테스트 예시

// src/test/java/com/example/service/UserServiceTest.java
@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    @DisplayName("정상적인 사용자를 생성한다")
    void createUser_success() {
        // given
        UserCreateRequest request = new UserCreateRequest("홍길동", "hong@test.com");
        User savedUser = new User(1L, "홍길동", "hong@test.com");
        given(userRepository.save(any(User.class))).willReturn(savedUser);

        // when
        UserResponse result = userService.createUser(request);

        // then
        assertThat(result.getId()).isEqualTo(1L);
        assertThat(result.getName()).isEqualTo("홍길동");
        verify(userRepository).save(any(User.class));
    }

    @Test
    @DisplayName("중복 이메일이면 예외를 던진다")
    void createUser_duplicateEmail_throwsException() {
        // given
        UserCreateRequest request = new UserCreateRequest("홍길동", "dup@test.com");
        given(userRepository.existsByEmail("dup@test.com")).willReturn(true);

        // when & then
        assertThatThrownBy(() -> userService.createUser(request))
            .isInstanceOf(DuplicateEmailException.class)
            .hasMessage("이미 등록된 이메일입니다");
    }
}

Playwright E2E 테스트 — AI 활용

로그인 → 대시보드 → 프로필 수정 플로우의 Playwright E2E 테스트를 작성해줘.

시나리오:
1. /login 페이지에서 이메일/비밀번호로 로그인
2. 대시보드 페이지로 리다이렉트 확인
3. 프로필 편집 버튼 클릭 → 이름 변경 → 저장
4. 성공 토스트 메시지 확인
5. 새로고침 후 변경된 이름 유지 확인

Page Object 패턴으로 구조화해줘.

// e2e/tests/profile-update.spec.js
const { test, expect } = require('@playwright/test');

test.describe('프로필 수정 플로우', () => {
  test.beforeEach(async ({ page }) => {
    // 로그인
    await page.goto('/login');
    await page.fill('[name="email"]', 'test@example.com');
    await page.fill('[name="password"]', 'password123');
    await page.click('button[type="submit"]');
    await expect(page).toHaveURL('/dashboard');
  });

  test('프로필 이름을 변경하고 저장한다', async ({ page }) => {
    // 프로필 편집
    await page.click('[data-testid="edit-profile"]');
    await page.fill('[name="name"]', '김개발');
    await page.click('[data-testid="save-profile"]');

    // 성공 토스트 확인
    await expect(page.locator('.toast-success'))
      .toHaveText('프로필이 수정되었습니다');

    // 새로고침 후 유지 확인
    await page.reload();
    await expect(page.locator('[name="name"]'))
      .toHaveValue('김개발');
  });
});

테스트 커버리지 목표 가이드

5.16 AI 활용 API 설계

REST API 성숙도 모델 (Richardson Maturity Model)

HTTP 메서드 & 상태 코드 가이드

Claude Code로 API 설계하기

할 일 관리(Todo) 앱의 REST API를 설계해줘.

요구사항:
- 리소스: 사용자(User), 할 일(Todo), 카테고리(Category)
- 인증: JWT 기반
- 페이지네이션: cursor 기반
- 에러 응답 형식 통일 (code, message, details)
- API 버전: /api/v1 prefix

각 엔드포인트별로:
1. HTTP 메서드 + URL
2. 요청 Body (JSON)
3. 응답 Body (JSON) + 상태 코드
4. 인증 필요 여부

Express.js 라우터 코드도 함께 생성해줘.

Node.js Express API 예시

// routes/todos.js
const express = require('express');
const router = express.Router();
const { authenticate } = require('../middleware/auth');
const todoService = require('../services/todoService');

// 할 일 목록 조회 (페이지네이션)
router.get('/', authenticate, async (req, res, next) => {
  try {
    const { cursor, limit = 20 } = req.query;
    const todos = await todoService.findAll(req.user.id, { cursor, limit });
    res.json({
      data: todos.items,
      pagination: {
        nextCursor: todos.nextCursor,
        hasMore: todos.hasMore
      }
    });
  } catch (err) {
    next(err);
  }
});

// 할 일 생성
router.post('/', authenticate, async (req, res, next) => {
  try {
    const { title, categoryId, dueDate } = req.body;
    const todo = await todoService.create(req.user.id, {
      title, categoryId, dueDate
    });
    res.status(201).json({ data: todo });
  } catch (err) {
    next(err);
  }
});

// 할 일 수정
router.patch('/:id', authenticate, async (req, res, next) => {
  try {
    const todo = await todoService.update(req.params.id, req.user.id, req.body);
    res.json({ data: todo });
  } catch (err) {
    next(err);
  }
});

// 할 일 삭제
router.delete('/:id', authenticate, async (req, res, next) => {
  try {
    await todoService.remove(req.params.id, req.user.id);
    res.status(204).end();
  } catch (err) {
    next(err);
  }
});

// 통일된 에러 핸들러
router.use((err, req, res, next) => {
  const status = err.statusCode || 500;
  res.status(status).json({
    error: {
      code: err.code || 'INTERNAL_ERROR',
      message: err.message || '서버 오류가 발생했습니다',
      details: err.details || null
    }
  });
});

module.exports = router;

Spring Boot REST Controller 예시

// TodoController.java
@RestController
@RequestMapping("/api/v1/todos")
@RequiredArgsConstructor
public class TodoController {

    private final TodoService todoService;

    @GetMapping
    public ResponseEntity<PageResponse<TodoResponse>> findAll(
            @AuthenticationPrincipal UserPrincipal user,
            @RequestParam(required = false) String cursor,
            @RequestParam(defaultValue = "20") int limit) {
        return ResponseEntity.ok(
            todoService.findAll(user.getId(), cursor, limit)
        );
    }

    @PostMapping
    public ResponseEntity<DataResponse<TodoResponse>> create(
            @AuthenticationPrincipal UserPrincipal user,
            @Valid @RequestBody TodoCreateRequest request) {
        TodoResponse todo = todoService.create(user.getId(), request);
        return ResponseEntity.status(HttpStatus.CREATED)
            .body(DataResponse.of(todo));
    }

    @PatchMapping("/{id}")
    public ResponseEntity<DataResponse<TodoResponse>> update(
            @AuthenticationPrincipal UserPrincipal user,
            @PathVariable Long id,
            @Valid @RequestBody TodoUpdateRequest request) {
        TodoResponse todo = todoService.update(id, user.getId(), request);
        return ResponseEntity.ok(DataResponse.of(todo));
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> delete(
            @AuthenticationPrincipal UserPrincipal user,
            @PathVariable Long id) {
        todoService.delete(id, user.getId());
        return ResponseEntity.noContent().build();
    }
}

API 아키텍처 — 계층 구조

API 보안 체크리스트

OpenAPI (Swagger) 문서 자동화

현재 Express 라우터 파일들을 분석해서 OpenAPI 3.0 스펙(YAML)을 생성해줘.
각 엔드포인트별 request/response 스키마를 포함하고,
swagger-ui-express로 /api-docs에서 볼 수 있게 설정해줘.

# openapi.yaml (일부)
openapi: 3.0.3
info:
  title: Todo API
  version: 1.0.0
  description: 할 일 관리 REST API

paths:
  /api/v1/todos:
    get:
      summary: 할 일 목록 조회
      security:
        - bearerAuth: []
      parameters:
        - name: cursor
          in: query
          schema:
            type: string
        - name: limit
          in: query
          schema:
            type: integer
            default: 20
      responses:
        '200':
          description: 조회 성공
          content:
            application/json:
              schema:
                type: object
                properties:
                  data:
                    type: array
                    items:
                      $ref: '#/components/schemas/Todo'
                  pagination:
                    $ref: '#/components/schemas/Pagination'

    post:
      summary: 할 일 생성
      security:
        - bearerAuth: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/TodoCreate'
      responses:
        '201':
          description: 생성 성공

components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
  schemas:
    Todo:
      type: object
      properties:
        id:
          type: integer
        title:
          type: string
        completed:
          type: boolean
        dueDate:
          type: string
          format: date